1 /******************************************************************************
2 *
3 * Copyright (C) 1999-2012 Broadcom Corporation
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at:
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 *
17 ******************************************************************************/
18
19 /******************************************************************************
20 *
21 * This file contains function of the HCIC unit to format and send HCI
22 * commands.
23 *
24 ******************************************************************************/
25
26 #include "common/bt_target.h"
27 #include "osi/allocator.h"
28 #include "stack/hcidefs.h"
29 #include "stack/hcimsgs.h"
30 #include "stack/hcidefs.h"
31 #include "stack/btu.h"
32
33 #include <stddef.h>
34 #include <string.h>
35
36 #if (BLE_50_FEATURE_SUPPORT == TRUE)
37 static BlE_SYNC ble_sync_info;
38
btsnd_hcic_ble_sync_sem_init(void)39 void btsnd_hcic_ble_sync_sem_init(void)
40 {
41 ble_sync_info.opcode = 0;
42 osi_sem_new(&ble_sync_info.sync_sem, 1, 0);
43 }
44
btsnd_hcic_ble_sync_sem_deinit(void)45 void btsnd_hcic_ble_sync_sem_deinit(void)
46 {
47 ble_sync_info.opcode = 0;
48 osi_sem_free(&ble_sync_info.sync_sem);
49 }
50
btsnd_hcic_ble_get_sync_info(void)51 BlE_SYNC *btsnd_hcic_ble_get_sync_info(void)
52 {
53 return &ble_sync_info;
54 }
55
btsnd_hcic_ble_get_status(void)56 uint8_t btsnd_hcic_ble_get_status(void)
57 {
58 return ble_sync_info.status;
59 }
60
btsnd_hci_ble_set_status(UINT8 hci_status)61 void btsnd_hci_ble_set_status(UINT8 hci_status)
62 {
63 ble_sync_info.status = hci_status;
64 return;
65 }
66 #endif // #if (BLE_50_FEATURE_SUPPORT == TRUE)
67
68 #if (defined BLE_INCLUDED) && (BLE_INCLUDED == TRUE)
69
btsnd_hcic_ble_set_local_used_feat(UINT8 feat_set[8])70 BOOLEAN btsnd_hcic_ble_set_local_used_feat (UINT8 feat_set[8])
71 {
72 BT_HDR *p;
73 UINT8 *pp;
74
75 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_SET_USED_FEAT_CMD)) == NULL) {
76 return (FALSE);
77 }
78
79 pp = (UINT8 *)(p + 1);
80
81 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_SET_USED_FEAT_CMD;
82 p->offset = 0;
83
84 UINT16_TO_STREAM (pp, HCI_BLE_WRITE_LOCAL_SPT_FEAT);
85 ARRAY_TO_STREAM (pp, feat_set, HCIC_PARAM_SIZE_SET_USED_FEAT_CMD);
86
87 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
88 return (TRUE);
89 }
90
btsnd_hcic_ble_set_random_addr(BD_ADDR random_bda)91 BOOLEAN btsnd_hcic_ble_set_random_addr (BD_ADDR random_bda)
92 {
93 BT_HDR *p;
94 UINT8 *pp;
95
96 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_WRITE_RANDOM_ADDR_CMD)) == NULL) {
97 return (FALSE);
98 }
99
100 pp = (UINT8 *)(p + 1);
101
102 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_WRITE_RANDOM_ADDR_CMD;
103 p->offset = 0;
104
105 UINT16_TO_STREAM (pp, HCI_BLE_WRITE_RANDOM_ADDR);
106 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_WRITE_RANDOM_ADDR_CMD);
107
108 BDADDR_TO_STREAM (pp, random_bda);
109
110 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
111 return (TRUE);
112 }
113
btsnd_hcic_ble_write_adv_params(UINT16 adv_int_min,UINT16 adv_int_max,UINT8 adv_type,UINT8 addr_type_own,UINT8 addr_type_dir,BD_ADDR direct_bda,UINT8 channel_map,UINT8 adv_filter_policy)114 BOOLEAN btsnd_hcic_ble_write_adv_params (UINT16 adv_int_min, UINT16 adv_int_max,
115 UINT8 adv_type, UINT8 addr_type_own,
116 UINT8 addr_type_dir, BD_ADDR direct_bda,
117 UINT8 channel_map, UINT8 adv_filter_policy)
118 {
119 BT_HDR *p;
120 UINT8 *pp;
121 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_BLE_WRITE_ADV_PARAMS)) == NULL) {
122 return (FALSE);
123 }
124
125 pp = (UINT8 *)(p + 1);
126
127 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_BLE_WRITE_ADV_PARAMS ;
128 p->offset = 0;
129
130 UINT16_TO_STREAM (pp, HCI_BLE_WRITE_ADV_PARAMS);
131 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_BLE_WRITE_ADV_PARAMS );
132
133 UINT16_TO_STREAM (pp, adv_int_min);
134 UINT16_TO_STREAM (pp, adv_int_max);
135 UINT8_TO_STREAM (pp, adv_type);
136 UINT8_TO_STREAM (pp, addr_type_own);
137 UINT8_TO_STREAM (pp, addr_type_dir);
138 BDADDR_TO_STREAM (pp, direct_bda);
139 UINT8_TO_STREAM (pp, channel_map);
140 UINT8_TO_STREAM (pp, adv_filter_policy);
141
142 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
143 return (TRUE);
144 }
btsnd_hcic_ble_read_adv_chnl_tx_power(void)145 BOOLEAN btsnd_hcic_ble_read_adv_chnl_tx_power (void)
146 {
147 BT_HDR *p;
148 UINT8 *pp;
149
150 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_READ_CMD)) == NULL) {
151 return (FALSE);
152 }
153
154 pp = (UINT8 *)(p + 1);
155
156 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_READ_CMD;
157 p->offset = 0;
158
159 UINT16_TO_STREAM (pp, HCI_BLE_READ_ADV_CHNL_TX_POWER);
160 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_READ_CMD);
161
162 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
163 return (TRUE);
164
165 }
166
btsnd_hcic_ble_set_adv_data(UINT8 data_len,UINT8 * p_data)167 BOOLEAN btsnd_hcic_ble_set_adv_data (UINT8 data_len, UINT8 *p_data)
168 {
169 BT_HDR *p;
170 UINT8 *pp;
171
172 for (int i = 0; i < data_len; i++) {
173 HCI_TRACE_DEBUG("p_data[%d] = %x\n", i, p_data[i]);
174 }
175
176 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_BLE_WRITE_ADV_DATA + 1)) == NULL) {
177 return (FALSE);
178 }
179
180 pp = (UINT8 *)(p + 1);
181
182 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_BLE_WRITE_ADV_DATA + 1;
183 p->offset = 0;
184
185 UINT16_TO_STREAM (pp, HCI_BLE_WRITE_ADV_DATA);
186 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_BLE_WRITE_ADV_DATA + 1);
187
188 memset(pp, 0, HCIC_PARAM_SIZE_BLE_WRITE_ADV_DATA);
189
190 if (p_data != NULL && data_len > 0) {
191 if (data_len > HCIC_PARAM_SIZE_BLE_WRITE_ADV_DATA) {
192 data_len = HCIC_PARAM_SIZE_BLE_WRITE_ADV_DATA;
193 HCI_TRACE_WARNING("Data length exceeds 31 bytes, only the first 31 bytes are used.\n");
194 }
195
196 UINT8_TO_STREAM (pp, data_len);
197
198 ARRAY_TO_STREAM (pp, p_data, data_len);
199 }
200 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
201
202 return (TRUE);
203 }
btsnd_hcic_ble_set_scan_rsp_data(UINT8 data_len,UINT8 * p_scan_rsp)204 BOOLEAN btsnd_hcic_ble_set_scan_rsp_data (UINT8 data_len, UINT8 *p_scan_rsp)
205 {
206 BT_HDR *p;
207 UINT8 *pp;
208
209 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_BLE_WRITE_SCAN_RSP + 1)) == NULL) {
210 return (FALSE);
211 }
212
213 pp = (UINT8 *)(p + 1);
214
215 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_BLE_WRITE_SCAN_RSP + 1;
216 p->offset = 0;
217
218 UINT16_TO_STREAM (pp, HCI_BLE_WRITE_SCAN_RSP_DATA);
219 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_BLE_WRITE_SCAN_RSP + 1);
220
221 memset(pp, 0, HCIC_PARAM_SIZE_BLE_WRITE_SCAN_RSP);
222
223 if (p_scan_rsp != NULL && data_len > 0) {
224
225 if (data_len > HCIC_PARAM_SIZE_BLE_WRITE_SCAN_RSP ) {
226 data_len = HCIC_PARAM_SIZE_BLE_WRITE_SCAN_RSP;
227 HCI_TRACE_WARNING("Data length exceeds 31 bytes, only the first 31 bytes are used.\n");
228 }
229
230 UINT8_TO_STREAM (pp, data_len);
231
232 ARRAY_TO_STREAM (pp, p_scan_rsp, data_len);
233 }
234
235 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
236
237 return (TRUE);
238 }
239
btsnd_hcic_ble_set_adv_enable(UINT8 adv_enable)240 BOOLEAN btsnd_hcic_ble_set_adv_enable (UINT8 adv_enable)
241 {
242 BT_HDR *p;
243 UINT8 *pp;
244
245 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_WRITE_ADV_ENABLE)) == NULL) {
246 return (FALSE);
247 }
248
249 pp = (UINT8 *)(p + 1);
250
251 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_WRITE_ADV_ENABLE;
252 p->offset = 0;
253
254 UINT16_TO_STREAM (pp, HCI_BLE_WRITE_ADV_ENABLE);
255 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_WRITE_ADV_ENABLE);
256
257 UINT8_TO_STREAM (pp, adv_enable);
258
259 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
260 return (TRUE);
261 }
btsnd_hcic_ble_set_scan_params(UINT8 scan_type,UINT16 scan_int,UINT16 scan_win,UINT8 addr_type_own,UINT8 scan_filter_policy)262 BOOLEAN btsnd_hcic_ble_set_scan_params (UINT8 scan_type,
263 UINT16 scan_int, UINT16 scan_win,
264 UINT8 addr_type_own, UINT8 scan_filter_policy)
265 {
266 BT_HDR *p;
267 UINT8 *pp;
268
269 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_BLE_WRITE_SCAN_PARAM)) == NULL) {
270 return (FALSE);
271 }
272
273 pp = (UINT8 *)(p + 1);
274
275 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_BLE_WRITE_SCAN_PARAM;
276 p->offset = 0;
277
278 UINT16_TO_STREAM (pp, HCI_BLE_WRITE_SCAN_PARAMS);
279 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_BLE_WRITE_SCAN_PARAM);
280
281 UINT8_TO_STREAM (pp, scan_type);
282 UINT16_TO_STREAM (pp, scan_int);
283 UINT16_TO_STREAM (pp, scan_win);
284 UINT8_TO_STREAM (pp, addr_type_own);
285 UINT8_TO_STREAM (pp, scan_filter_policy);
286
287 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
288 return (TRUE);
289 }
290
btsnd_hcic_ble_set_scan_enable(UINT8 scan_enable,UINT8 duplicate)291 BOOLEAN btsnd_hcic_ble_set_scan_enable (UINT8 scan_enable, UINT8 duplicate)
292 {
293 BT_HDR *p;
294 UINT8 *pp;
295
296 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_BLE_WRITE_SCAN_ENABLE)) == NULL) {
297 return (FALSE);
298 }
299
300 pp = (UINT8 *)(p + 1);
301
302 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_BLE_WRITE_SCAN_ENABLE;
303 p->offset = 0;
304
305 UINT16_TO_STREAM (pp, HCI_BLE_WRITE_SCAN_ENABLE);
306 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_BLE_WRITE_SCAN_ENABLE);
307
308 UINT8_TO_STREAM (pp, scan_enable);
309 UINT8_TO_STREAM (pp, duplicate);
310
311 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
312 return (TRUE);
313 }
314
315 /* link layer connection management commands */
btsnd_hcic_ble_create_ll_conn(UINT16 scan_int,UINT16 scan_win,UINT8 init_filter_policy,UINT8 addr_type_peer,BD_ADDR bda_peer,UINT8 addr_type_own,UINT16 conn_int_min,UINT16 conn_int_max,UINT16 conn_latency,UINT16 conn_timeout,UINT16 min_ce_len,UINT16 max_ce_len)316 BOOLEAN btsnd_hcic_ble_create_ll_conn (UINT16 scan_int, UINT16 scan_win,
317 UINT8 init_filter_policy,
318 UINT8 addr_type_peer, BD_ADDR bda_peer,
319 UINT8 addr_type_own,
320 UINT16 conn_int_min, UINT16 conn_int_max,
321 UINT16 conn_latency, UINT16 conn_timeout,
322 UINT16 min_ce_len, UINT16 max_ce_len)
323 {
324 BT_HDR *p;
325 UINT8 *pp;
326
327 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_BLE_CREATE_LL_CONN)) == NULL) {
328 return (FALSE);
329 }
330
331 pp = (UINT8 *)(p + 1);
332
333 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_BLE_CREATE_LL_CONN;
334 p->offset = 0;
335
336 UINT16_TO_STREAM (pp, HCI_BLE_CREATE_LL_CONN);
337 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_BLE_CREATE_LL_CONN);
338
339 UINT16_TO_STREAM (pp, scan_int);
340 UINT16_TO_STREAM (pp, scan_win);
341 UINT8_TO_STREAM (pp, init_filter_policy);
342
343 UINT8_TO_STREAM (pp, addr_type_peer);
344 BDADDR_TO_STREAM (pp, bda_peer);
345 UINT8_TO_STREAM (pp, addr_type_own);
346
347 UINT16_TO_STREAM (pp, conn_int_min);
348 UINT16_TO_STREAM (pp, conn_int_max);
349 UINT16_TO_STREAM (pp, conn_latency);
350 UINT16_TO_STREAM (pp, conn_timeout);
351
352 UINT16_TO_STREAM (pp, min_ce_len ? min_ce_len : BLE_CE_LEN_MIN);
353 UINT16_TO_STREAM (pp, max_ce_len ? max_ce_len : BLE_CE_LEN_MIN);
354
355 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
356 return (TRUE);
357 }
358
btsnd_hcic_ble_create_conn_cancel(void)359 BOOLEAN btsnd_hcic_ble_create_conn_cancel (void)
360 {
361 BT_HDR *p;
362 UINT8 *pp;
363
364 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_BLE_CREATE_CONN_CANCEL)) == NULL) {
365 return (FALSE);
366 }
367
368 pp = (UINT8 *)(p + 1);
369
370 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_BLE_CREATE_CONN_CANCEL;
371 p->offset = 0;
372
373 UINT16_TO_STREAM (pp, HCI_BLE_CREATE_CONN_CANCEL);
374 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_BLE_CREATE_CONN_CANCEL);
375
376 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
377 return (TRUE);
378 }
379
btsnd_hcic_ble_clear_white_list(void)380 BOOLEAN btsnd_hcic_ble_clear_white_list (void)
381 {
382 BT_HDR *p;
383 UINT8 *pp;
384
385 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_CLEAR_WHITE_LIST)) == NULL) {
386 return (FALSE);
387 }
388
389 pp = (UINT8 *)(p + 1);
390
391 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_CLEAR_WHITE_LIST;
392 p->offset = 0;
393
394 UINT16_TO_STREAM (pp, HCI_BLE_CLEAR_WHITE_LIST);
395 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_CLEAR_WHITE_LIST);
396
397 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
398 return (TRUE);
399 }
400
btsnd_hcic_ble_add_white_list(UINT8 addr_type,BD_ADDR bda)401 BOOLEAN btsnd_hcic_ble_add_white_list (UINT8 addr_type, BD_ADDR bda)
402 {
403 BT_HDR *p;
404 UINT8 *pp;
405
406 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_ADD_WHITE_LIST)) == NULL) {
407 return (FALSE);
408 }
409
410 pp = (UINT8 *)(p + 1);
411
412 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_ADD_WHITE_LIST;
413 p->offset = 0;
414
415 UINT16_TO_STREAM (pp, HCI_BLE_ADD_WHITE_LIST);
416 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_ADD_WHITE_LIST);
417
418 UINT8_TO_STREAM (pp, addr_type);
419 BDADDR_TO_STREAM (pp, bda);
420
421 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
422 return (TRUE);
423 }
424
btsnd_hcic_ble_remove_from_white_list(UINT8 addr_type,BD_ADDR bda)425 BOOLEAN btsnd_hcic_ble_remove_from_white_list (UINT8 addr_type, BD_ADDR bda)
426 {
427 BT_HDR *p;
428 UINT8 *pp;
429
430 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_REMOVE_WHITE_LIST)) == NULL) {
431 return (FALSE);
432 }
433
434 pp = (UINT8 *)(p + 1);
435
436 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_REMOVE_WHITE_LIST;
437 p->offset = 0;
438
439 UINT16_TO_STREAM (pp, HCI_BLE_REMOVE_WHITE_LIST);
440 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_REMOVE_WHITE_LIST);
441
442 UINT8_TO_STREAM (pp, addr_type);
443 BDADDR_TO_STREAM (pp, bda);
444
445 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
446 return (TRUE);
447 }
448
btsnd_hcic_ble_upd_ll_conn_params(UINT16 handle,UINT16 conn_int_min,UINT16 conn_int_max,UINT16 conn_latency,UINT16 conn_timeout,UINT16 min_ce_len,UINT16 max_ce_len)449 BOOLEAN btsnd_hcic_ble_upd_ll_conn_params (UINT16 handle,
450 UINT16 conn_int_min, UINT16 conn_int_max,
451 UINT16 conn_latency, UINT16 conn_timeout,
452 UINT16 min_ce_len, UINT16 max_ce_len)
453 {
454 BT_HDR *p;
455 UINT8 *pp;
456
457 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_BLE_UPD_LL_CONN_PARAMS)) == NULL) {
458 return (FALSE);
459 }
460
461 pp = (UINT8 *)(p + 1);
462
463 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_BLE_UPD_LL_CONN_PARAMS;
464 p->offset = 0;
465
466 UINT16_TO_STREAM (pp, HCI_BLE_UPD_LL_CONN_PARAMS);
467 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_BLE_UPD_LL_CONN_PARAMS);
468
469 UINT16_TO_STREAM (pp, handle);
470
471 UINT16_TO_STREAM (pp, conn_int_min);
472 UINT16_TO_STREAM (pp, conn_int_max);
473 UINT16_TO_STREAM (pp, conn_latency);
474 UINT16_TO_STREAM (pp, conn_timeout);
475 UINT16_TO_STREAM (pp, min_ce_len);
476 UINT16_TO_STREAM (pp, max_ce_len);
477
478 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
479 return (TRUE);
480 }
481
btsnd_hcic_ble_set_host_chnl_class(UINT8 chnl_map[HCIC_BLE_CHNL_MAP_SIZE])482 BOOLEAN btsnd_hcic_ble_set_host_chnl_class (UINT8 chnl_map[HCIC_BLE_CHNL_MAP_SIZE])
483 {
484 BT_HDR *p;
485 UINT8 *pp;
486
487 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_SET_HOST_CHNL_CLASS)) == NULL) {
488 return (FALSE);
489 }
490
491 pp = (UINT8 *)(p + 1);
492
493 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_SET_HOST_CHNL_CLASS;
494 p->offset = 0;
495
496 UINT16_TO_STREAM (pp, HCI_BLE_SET_HOST_CHNL_CLASS);
497 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_SET_HOST_CHNL_CLASS);
498
499 ARRAY_TO_STREAM (pp, chnl_map, HCIC_BLE_CHNL_MAP_SIZE);
500
501 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
502 return (TRUE);
503 }
504
btsnd_hcic_ble_read_chnl_map(UINT16 handle)505 BOOLEAN btsnd_hcic_ble_read_chnl_map (UINT16 handle)
506 {
507 BT_HDR *p;
508 UINT8 *pp;
509
510 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_READ_CHNL_MAP)) == NULL) {
511 return (FALSE);
512 }
513
514 pp = (UINT8 *)(p + 1);
515
516 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_READ_CHNL_MAP;
517 p->offset = 0;
518
519 UINT16_TO_STREAM (pp, HCI_BLE_READ_CHNL_MAP);
520 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_READ_CHNL_MAP);
521
522 UINT16_TO_STREAM (pp, handle);
523
524 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
525 return (TRUE);
526 }
527
btsnd_hcic_ble_read_remote_feat(UINT16 handle)528 BOOLEAN btsnd_hcic_ble_read_remote_feat (UINT16 handle)
529 {
530 BT_HDR *p;
531 UINT8 *pp;
532
533 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_BLE_READ_REMOTE_FEAT)) == NULL) {
534 return (FALSE);
535 }
536
537 pp = (UINT8 *)(p + 1);
538
539 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_BLE_READ_REMOTE_FEAT;
540 p->offset = 0;
541
542 UINT16_TO_STREAM (pp, HCI_BLE_READ_REMOTE_FEAT);
543 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_BLE_READ_REMOTE_FEAT);
544
545 UINT16_TO_STREAM (pp, handle);
546
547 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
548 return (TRUE);
549 }
550
551 /* security management commands */
btsnd_hcic_ble_encrypt(UINT8 * key,UINT8 key_len,UINT8 * plain_text,UINT8 pt_len,void * p_cmd_cplt_cback)552 BOOLEAN btsnd_hcic_ble_encrypt (UINT8 *key, UINT8 key_len,
553 UINT8 *plain_text, UINT8 pt_len,
554 void *p_cmd_cplt_cback)
555 {
556 BT_HDR *p;
557 UINT8 *pp;
558
559 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_BLE_ENCRYPT)) == NULL) {
560 return (FALSE);
561 }
562
563 pp = (UINT8 *)(p + 1);
564
565 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_BLE_ENCRYPT;
566 p->offset = 0;
567
568 hci_cmd_metadata_t *metadata = HCI_GET_CMD_METAMSG(p);
569 metadata->context = p_cmd_cplt_cback;
570
571 UINT16_TO_STREAM (pp, HCI_BLE_ENCRYPT);
572 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_BLE_ENCRYPT);
573
574 memset(pp, 0, HCIC_PARAM_SIZE_BLE_ENCRYPT);
575
576 if (key_len > HCIC_BLE_ENCRYT_KEY_SIZE) {
577 key_len = HCIC_BLE_ENCRYT_KEY_SIZE;
578 }
579 if (pt_len > HCIC_BLE_ENCRYT_KEY_SIZE) {
580 pt_len = HCIC_BLE_ENCRYT_KEY_SIZE;
581 }
582
583 ARRAY_TO_STREAM (pp, key, key_len);
584 pp += (HCIC_BLE_ENCRYT_KEY_SIZE - key_len);
585 ARRAY_TO_STREAM (pp, plain_text, pt_len);
586
587 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
588 return (TRUE);
589 }
590
btsnd_hcic_ble_rand(void * p_cmd_cplt_cback)591 BOOLEAN btsnd_hcic_ble_rand (void *p_cmd_cplt_cback)
592 {
593 BT_HDR *p;
594 UINT8 *pp;
595
596 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_BLE_RAND)) == NULL) {
597 return (FALSE);
598 }
599
600 pp = (UINT8 *)(p + 1);
601
602 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_BLE_RAND;
603 p->offset = 0;
604
605 hci_cmd_metadata_t *metadata = HCI_GET_CMD_METAMSG(p);
606 metadata->context = p_cmd_cplt_cback;
607
608 UINT16_TO_STREAM (pp, HCI_BLE_RAND);
609 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_BLE_RAND);
610
611 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
612 return (TRUE);
613 }
614
btsnd_hcic_ble_start_enc(UINT16 handle,UINT8 rand[HCIC_BLE_RAND_DI_SIZE],UINT16 ediv,UINT8 ltk[HCIC_BLE_ENCRYT_KEY_SIZE])615 BOOLEAN btsnd_hcic_ble_start_enc (UINT16 handle, UINT8 rand[HCIC_BLE_RAND_DI_SIZE],
616 UINT16 ediv, UINT8 ltk[HCIC_BLE_ENCRYT_KEY_SIZE])
617 {
618 BT_HDR *p;
619 UINT8 *pp;
620
621 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_BLE_START_ENC)) == NULL) {
622 return (FALSE);
623 }
624
625 pp = (UINT8 *)(p + 1);
626
627 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_BLE_START_ENC;
628 p->offset = 0;
629
630 UINT16_TO_STREAM (pp, HCI_BLE_START_ENC);
631 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_BLE_START_ENC);
632
633 UINT16_TO_STREAM (pp, handle);
634 ARRAY_TO_STREAM (pp, rand, HCIC_BLE_RAND_DI_SIZE);
635 UINT16_TO_STREAM (pp, ediv);
636 ARRAY_TO_STREAM (pp, ltk, HCIC_BLE_ENCRYT_KEY_SIZE);
637
638 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
639 return (TRUE);
640 }
641
btsnd_hcic_ble_ltk_req_reply(UINT16 handle,UINT8 ltk[HCIC_BLE_ENCRYT_KEY_SIZE])642 BOOLEAN btsnd_hcic_ble_ltk_req_reply (UINT16 handle, UINT8 ltk[HCIC_BLE_ENCRYT_KEY_SIZE])
643 {
644 BT_HDR *p;
645 UINT8 *pp;
646
647 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_LTK_REQ_REPLY)) == NULL) {
648 return (FALSE);
649 }
650
651 pp = (UINT8 *)(p + 1);
652
653 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_LTK_REQ_REPLY;
654 p->offset = 0;
655
656 UINT16_TO_STREAM (pp, HCI_BLE_LTK_REQ_REPLY);
657 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_LTK_REQ_REPLY);
658
659 UINT16_TO_STREAM (pp, handle);
660 ARRAY_TO_STREAM (pp, ltk, HCIC_BLE_ENCRYT_KEY_SIZE);
661
662 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
663 return (TRUE);
664 }
665
btsnd_hcic_ble_ltk_req_neg_reply(UINT16 handle)666 BOOLEAN btsnd_hcic_ble_ltk_req_neg_reply (UINT16 handle)
667 {
668 BT_HDR *p;
669 UINT8 *pp;
670
671 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_LTK_REQ_NEG_REPLY)) == NULL) {
672 return (FALSE);
673 }
674
675 pp = (UINT8 *)(p + 1);
676
677 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_LTK_REQ_NEG_REPLY;
678 p->offset = 0;
679
680 UINT16_TO_STREAM (pp, HCI_BLE_LTK_REQ_NEG_REPLY);
681 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_LTK_REQ_NEG_REPLY);
682
683 UINT16_TO_STREAM (pp, handle);
684
685 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
686 return (TRUE);
687 }
688
btsnd_hcic_ble_receiver_test(UINT8 rx_freq)689 BOOLEAN btsnd_hcic_ble_receiver_test(UINT8 rx_freq)
690 {
691 BT_HDR *p;
692 UINT8 *pp;
693
694 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_WRITE_PARAM1)) == NULL) {
695 return (FALSE);
696 }
697
698 pp = (UINT8 *)(p + 1);
699
700 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_WRITE_PARAM1;
701 p->offset = 0;
702
703 UINT16_TO_STREAM (pp, HCI_BLE_RECEIVER_TEST);
704 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_WRITE_PARAM1);
705
706 UINT8_TO_STREAM (pp, rx_freq);
707
708 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
709 return (TRUE);
710 }
711
btsnd_hcic_ble_transmitter_test(UINT8 tx_freq,UINT8 test_data_len,UINT8 payload)712 BOOLEAN btsnd_hcic_ble_transmitter_test(UINT8 tx_freq, UINT8 test_data_len, UINT8 payload)
713 {
714 BT_HDR *p;
715 UINT8 *pp;
716
717 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_WRITE_PARAM3)) == NULL) {
718 return (FALSE);
719 }
720
721 pp = (UINT8 *)(p + 1);
722
723 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_WRITE_PARAM3;
724 p->offset = 0;
725
726 UINT16_TO_STREAM (pp, HCI_BLE_TRANSMITTER_TEST);
727 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_WRITE_PARAM3);
728
729 UINT8_TO_STREAM (pp, tx_freq);
730 UINT8_TO_STREAM (pp, test_data_len);
731 UINT8_TO_STREAM (pp, payload);
732
733 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
734 return (TRUE);
735 }
736
btsnd_hcic_ble_test_end(void)737 BOOLEAN btsnd_hcic_ble_test_end(void)
738 {
739 BT_HDR *p;
740 UINT8 *pp;
741
742 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_READ_CMD)) == NULL) {
743 return (FALSE);
744 }
745
746 pp = (UINT8 *)(p + 1);
747
748 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_READ_CMD;
749 p->offset = 0;
750
751 UINT16_TO_STREAM (pp, HCI_BLE_TEST_END);
752 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_READ_CMD);
753
754 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
755 return (TRUE);
756 }
757
btsnd_hcic_ble_read_host_supported(void)758 BOOLEAN btsnd_hcic_ble_read_host_supported (void)
759 {
760 BT_HDR *p;
761 UINT8 *pp;
762
763 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_READ_CMD)) == NULL) {
764 return (FALSE);
765 }
766
767 pp = (UINT8 *)(p + 1);
768
769 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_READ_CMD;
770 p->offset = 0;
771
772 UINT16_TO_STREAM (pp, HCI_READ_LE_HOST_SUPPORT);
773 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_READ_CMD);
774
775 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
776 return (TRUE);
777 }
778
779 #if (defined BLE_LLT_INCLUDED) && (BLE_LLT_INCLUDED == TRUE)
780
btsnd_hcic_ble_rc_param_req_reply(UINT16 handle,UINT16 conn_int_min,UINT16 conn_int_max,UINT16 conn_latency,UINT16 conn_timeout,UINT16 min_ce_len,UINT16 max_ce_len)781 BOOLEAN btsnd_hcic_ble_rc_param_req_reply( UINT16 handle,
782 UINT16 conn_int_min, UINT16 conn_int_max,
783 UINT16 conn_latency, UINT16 conn_timeout,
784 UINT16 min_ce_len, UINT16 max_ce_len )
785 {
786 BT_HDR *p;
787 UINT8 *pp;
788
789 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_BLE_RC_PARAM_REQ_REPLY)) == NULL) {
790 return (FALSE);
791 }
792
793 pp = (UINT8 *)(p + 1);
794
795 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_BLE_RC_PARAM_REQ_REPLY;
796 p->offset = 0;
797
798 UINT16_TO_STREAM (pp, HCI_BLE_RC_PARAM_REQ_REPLY);
799 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_BLE_RC_PARAM_REQ_REPLY);
800
801 UINT16_TO_STREAM (pp, handle);
802 UINT16_TO_STREAM (pp, conn_int_min);
803 UINT16_TO_STREAM (pp, conn_int_max);
804 UINT16_TO_STREAM (pp, conn_latency);
805 UINT16_TO_STREAM (pp, conn_timeout);
806 UINT16_TO_STREAM (pp, min_ce_len);
807 UINT16_TO_STREAM (pp, max_ce_len);
808
809 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
810 return (TRUE);
811 }
812
btsnd_hcic_ble_rc_param_req_neg_reply(UINT16 handle,UINT8 reason)813 BOOLEAN btsnd_hcic_ble_rc_param_req_neg_reply(UINT16 handle, UINT8 reason)
814 {
815 BT_HDR *p;
816 UINT8 *pp;
817
818 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_BLE_RC_PARAM_REQ_NEG_REPLY)) == NULL) {
819 return (FALSE);
820 }
821
822 pp = (UINT8 *)(p + 1);
823
824 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_BLE_RC_PARAM_REQ_NEG_REPLY;
825 p->offset = 0;
826
827 UINT16_TO_STREAM (pp, HCI_BLE_RC_PARAM_REQ_NEG_REPLY);
828 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_BLE_RC_PARAM_REQ_NEG_REPLY);
829
830 UINT16_TO_STREAM (pp, handle);
831 UINT8_TO_STREAM (pp, reason);
832
833 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
834 return (TRUE);
835 }
836 #endif
837
btsnd_hcic_ble_add_device_resolving_list(UINT8 addr_type_peer,BD_ADDR bda_peer,UINT8 irk_peer[HCIC_BLE_IRK_SIZE],UINT8 irk_local[HCIC_BLE_IRK_SIZE])838 BOOLEAN btsnd_hcic_ble_add_device_resolving_list (UINT8 addr_type_peer, BD_ADDR bda_peer,
839 UINT8 irk_peer[HCIC_BLE_IRK_SIZE],
840 UINT8 irk_local[HCIC_BLE_IRK_SIZE])
841 {
842 BT_HDR *p;
843 UINT8 *pp;
844
845 if ((p = HCI_GET_CMD_BUF (HCIC_PARAM_SIZE_BLE_ADD_DEV_RESOLVING_LIST)) == NULL) {
846 return (FALSE);
847 }
848
849 pp = (UINT8 *)(p + 1);
850
851 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_BLE_ADD_DEV_RESOLVING_LIST;
852 p->offset = 0;
853
854 UINT16_TO_STREAM (pp, HCI_BLE_ADD_DEV_RESOLVING_LIST);
855 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_BLE_ADD_DEV_RESOLVING_LIST);
856 UINT8_TO_STREAM (pp, addr_type_peer);
857 BDADDR_TO_STREAM (pp, bda_peer);
858 ARRAY_TO_STREAM (pp, irk_peer, HCIC_BLE_ENCRYT_KEY_SIZE);
859 ARRAY_TO_STREAM (pp, irk_local, HCIC_BLE_ENCRYT_KEY_SIZE);
860
861 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
862
863 return (TRUE);
864 }
865
btsnd_hcic_ble_rm_device_resolving_list(UINT8 addr_type_peer,BD_ADDR bda_peer)866 BOOLEAN btsnd_hcic_ble_rm_device_resolving_list (UINT8 addr_type_peer, BD_ADDR bda_peer)
867 {
868 BT_HDR *p;
869 UINT8 *pp;
870
871 if ((p = HCI_GET_CMD_BUF (HCIC_PARAM_SIZE_BLE_RM_DEV_RESOLVING_LIST)) == NULL) {
872 return (FALSE);
873 }
874
875 pp = (UINT8 *)(p + 1);
876
877 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_BLE_RM_DEV_RESOLVING_LIST;
878 p->offset = 0;
879
880 UINT16_TO_STREAM (pp, HCI_BLE_RM_DEV_RESOLVING_LIST);
881 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_BLE_RM_DEV_RESOLVING_LIST);
882 UINT8_TO_STREAM (pp, addr_type_peer);
883 BDADDR_TO_STREAM (pp, bda_peer);
884
885 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
886
887 return (TRUE);
888 }
889
btsnd_hcic_ble_clear_resolving_list(void)890 BOOLEAN btsnd_hcic_ble_clear_resolving_list (void)
891 {
892 BT_HDR *p;
893 UINT8 *pp;
894
895 if ((p = HCI_GET_CMD_BUF (HCIC_PARAM_SIZE_BLE_CLEAR_RESOLVING_LIST)) == NULL) {
896 return (FALSE);
897 }
898
899 pp = (UINT8 *)(p + 1);
900
901 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_BLE_CLEAR_RESOLVING_LIST;
902 p->offset = 0;
903
904 UINT16_TO_STREAM (pp, HCI_BLE_CLEAR_RESOLVING_LIST);
905 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_BLE_CLEAR_RESOLVING_LIST);
906
907 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
908
909 return (TRUE);
910 }
911
btsnd_hcic_ble_read_resolvable_addr_peer(UINT8 addr_type_peer,BD_ADDR bda_peer)912 BOOLEAN btsnd_hcic_ble_read_resolvable_addr_peer (UINT8 addr_type_peer, BD_ADDR bda_peer)
913 {
914 BT_HDR *p;
915 UINT8 *pp;
916
917 if ((p = HCI_GET_CMD_BUF (HCIC_PARAM_SIZE_BLE_READ_RESOLVABLE_ADDR_PEER)) == NULL) {
918 return (FALSE);
919 }
920
921 pp = (UINT8 *)(p + 1);
922
923 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_BLE_READ_RESOLVABLE_ADDR_PEER;
924 p->offset = 0;
925
926 UINT16_TO_STREAM (pp, HCI_BLE_READ_RESOLVABLE_ADDR_PEER);
927 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_BLE_READ_RESOLVABLE_ADDR_PEER);
928 UINT8_TO_STREAM (pp, addr_type_peer);
929 BDADDR_TO_STREAM (pp, bda_peer);
930
931 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
932
933 return (TRUE);
934 }
935
btsnd_hcic_ble_read_resolvable_addr_local(UINT8 addr_type_peer,BD_ADDR bda_peer)936 BOOLEAN btsnd_hcic_ble_read_resolvable_addr_local (UINT8 addr_type_peer, BD_ADDR bda_peer)
937 {
938 BT_HDR *p;
939 UINT8 *pp;
940
941 if ((p = HCI_GET_CMD_BUF (HCIC_PARAM_SIZE_BLE_READ_RESOLVABLE_ADDR_LOCAL)) == NULL) {
942 return (FALSE);
943 }
944
945 pp = (UINT8 *)(p + 1);
946
947 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_BLE_READ_RESOLVABLE_ADDR_LOCAL;
948 p->offset = 0;
949
950 UINT16_TO_STREAM (pp, HCI_BLE_READ_RESOLVABLE_ADDR_LOCAL);
951 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_BLE_READ_RESOLVABLE_ADDR_LOCAL);
952 UINT8_TO_STREAM (pp, addr_type_peer);
953 BDADDR_TO_STREAM (pp, bda_peer);
954
955 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
956
957 return (TRUE);
958 }
959
btsnd_hcic_ble_set_addr_resolution_enable(UINT8 addr_resolution_enable)960 BOOLEAN btsnd_hcic_ble_set_addr_resolution_enable (UINT8 addr_resolution_enable)
961 {
962 BT_HDR *p;
963 UINT8 *pp;
964
965 if ((p = HCI_GET_CMD_BUF (HCIC_PARAM_SIZE_BLE_SET_ADDR_RESOLUTION_ENABLE)) == NULL) {
966 return (FALSE);
967 }
968
969 pp = (UINT8 *)(p + 1);
970
971 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_BLE_SET_ADDR_RESOLUTION_ENABLE;
972 p->offset = 0;
973
974 UINT16_TO_STREAM (pp, HCI_BLE_SET_ADDR_RESOLUTION_ENABLE);
975 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_BLE_SET_ADDR_RESOLUTION_ENABLE);
976 UINT8_TO_STREAM (pp, addr_resolution_enable);
977
978 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
979
980 return (TRUE);
981 }
982
btsnd_hcic_ble_set_rand_priv_addr_timeout(UINT16 rpa_timout)983 BOOLEAN btsnd_hcic_ble_set_rand_priv_addr_timeout (UINT16 rpa_timout)
984 {
985 BT_HDR *p;
986 UINT8 *pp;
987
988 if ((p = HCI_GET_CMD_BUF (HCIC_PARAM_SIZE_BLE_SET_RAND_PRIV_ADDR_TIMOUT)) == NULL) {
989 return (FALSE);
990 }
991
992 pp = (UINT8 *)(p + 1);
993
994 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_BLE_SET_RAND_PRIV_ADDR_TIMOUT;
995 p->offset = 0;
996
997 UINT16_TO_STREAM (pp, HCI_BLE_SET_RAND_PRIV_ADDR_TIMOUT);
998 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_BLE_SET_RAND_PRIV_ADDR_TIMOUT);
999 UINT16_TO_STREAM (pp, rpa_timout);
1000
1001 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1002
1003 return (TRUE);
1004 }
1005
btsnd_hcic_ble_set_data_length(UINT16 conn_handle,UINT16 tx_octets,UINT16 tx_time)1006 BOOLEAN btsnd_hcic_ble_set_data_length(UINT16 conn_handle, UINT16 tx_octets, UINT16 tx_time)
1007 {
1008 BT_HDR *p;
1009 UINT8 *pp;
1010
1011 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_BLE_SET_DATA_LENGTH)) == NULL) {
1012 return FALSE;
1013 }
1014
1015 pp = p->data;
1016
1017 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_BLE_SET_DATA_LENGTH;
1018 p->offset = 0;
1019
1020 UINT16_TO_STREAM(pp, HCI_BLE_SET_DATA_LENGTH);
1021 UINT8_TO_STREAM(pp, HCIC_PARAM_SIZE_BLE_SET_DATA_LENGTH);
1022
1023 UINT16_TO_STREAM(pp, conn_handle);
1024 UINT16_TO_STREAM(pp, tx_octets);
1025 UINT16_TO_STREAM(pp, tx_time);
1026
1027 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1028 return TRUE;
1029 }
1030
btsnd_hcic_ble_update_adv_report_flow_control(UINT16 num,BT_HDR * static_buf)1031 BOOLEAN btsnd_hcic_ble_update_adv_report_flow_control (UINT16 num, BT_HDR *static_buf)
1032 {
1033 BT_HDR *p;
1034 UINT8 *pp;
1035
1036 if (static_buf != NULL) {
1037 p = static_buf;
1038 } else {
1039 if ((p = HCI_GET_CMD_BUF (HCIC_PARAM_SIZE_BLE_UPDATE_ADV_FLOW_CONTROL)) == NULL) {
1040 return (FALSE);
1041 }
1042 }
1043
1044 hci_cmd_metadata_t *metadata = HCI_GET_CMD_METAMSG(p);
1045 metadata->flags_src = HCI_CMD_MSG_F_SRC_NOACK;
1046 if (static_buf == p) {
1047 assert(metadata->command_free_cb != NULL);
1048 }
1049 p->layer_specific = HCI_CMD_BUF_TYPE_METADATA;
1050
1051 pp = (UINT8 *)(p + 1);
1052
1053 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_BLE_UPDATE_ADV_FLOW_CONTROL;
1054 p->offset = 0;
1055
1056 UINT16_TO_STREAM (pp, HCI_VENDOR_BLE_ADV_REPORT_FLOW_CONTROL);
1057 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_BLE_UPDATE_ADV_FLOW_CONTROL);
1058 UINT16_TO_STREAM (pp, num);
1059
1060 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1061 return TRUE;
1062 }
1063
btsnd_hcic_ble_set_channels(BLE_CHANNELS channels)1064 BOOLEAN btsnd_hcic_ble_set_channels (BLE_CHANNELS channels)
1065 {
1066 BT_HDR *p;
1067 UINT8 *pp;
1068
1069 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_BLE_SET_CHANNELS)) == NULL) {
1070 return (FALSE);
1071 }
1072
1073 pp = (UINT8 *)(p + 1);
1074
1075 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_BLE_SET_CHANNELS;
1076 p->offset = 0;
1077
1078 UINT16_TO_STREAM (pp, HCI_BLE_SET_HOST_CHNL_CLASS);
1079 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_BLE_SET_CHANNELS);
1080
1081 ARRAY_TO_STREAM (pp, channels, HCIC_PARAM_SIZE_BLE_SET_CHANNELS);
1082
1083 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1084 return (TRUE);
1085 }
1086
btsnd_hcic_ble_clear_adv(void)1087 BOOLEAN btsnd_hcic_ble_clear_adv (void)
1088 {
1089 BT_HDR *p;
1090 UINT8 *pp;
1091
1092 if ((p = HCI_GET_CMD_BUF (HCIC_PARAM_SIZE_BLE_CLEAR_ADV)) == NULL) {
1093 return (FALSE);
1094 }
1095
1096 pp = (UINT8 *)(p + 1);
1097
1098 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_BLE_CLEAR_ADV;
1099 p->offset = 0;
1100
1101 UINT16_TO_STREAM (pp, HCI_VENDOR_BLE_CLEAR_ADV);
1102 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_BLE_CLEAR_ADV);
1103
1104 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1105 return TRUE;
1106 }
1107
1108 #define HCIC_BLE_CMD_CREATED(p, pp, size) do{\
1109 if ((p = HCI_GET_CMD_BUF(size)) == NULL) { \
1110 return FALSE; \
1111 } \
1112 pp = p->data; \
1113 p->len = HCIC_PREAMBLE_SIZE + size;\
1114 p->offset = 0; \
1115 } while(0)
1116
1117 #if (BLE_50_FEATURE_SUPPORT == TRUE)
1118
btsnd_hcic_ble_read_phy(UINT16 conn_handle)1119 BOOLEAN btsnd_hcic_ble_read_phy(UINT16 conn_handle)
1120 {
1121 BT_HDR *p;
1122 UINT8 *pp;
1123
1124 HCI_TRACE_EVENT("%s, conn_handle = %d", __func__, conn_handle);
1125 HCIC_BLE_CMD_CREATED(p, pp, HCIC_PARAM_SIZE_BLE_READ_PHY);
1126
1127 UINT16_TO_STREAM(pp, HCI_BLE_READ_PHY);
1128 UINT8_TO_STREAM(pp, HCIC_PARAM_SIZE_BLE_READ_PHY);
1129 UINT16_TO_STREAM(pp, conn_handle);
1130
1131 btu_hcif_send_cmd(LOCAL_BR_EDR_CONTROLLER_ID, p);
1132 return TRUE;
1133 }
1134
btsnd_hcic_ble_set_prefered_default_phy(UINT8 all_phys,UINT8 tx_phys,UINT8 rx_phys)1135 UINT8 btsnd_hcic_ble_set_prefered_default_phy(UINT8 all_phys,
1136 UINT8 tx_phys,
1137 UINT8 rx_phys)
1138 {
1139 BT_HDR *p;
1140 UINT8 *pp;
1141
1142 HCI_TRACE_EVENT("%s, all_phys = %d, tx_phys = %d, rx_phys = %d", __func__, all_phys, tx_phys, rx_phys);
1143 HCIC_BLE_CMD_CREATED(p, pp, HCIC_PARAM_SIZE_BLE_SET_DEF_PHY);
1144
1145 UINT16_TO_STREAM(pp, HCI_BLE_SET_DEFAULT_PHY);
1146 UINT8_TO_STREAM(pp, HCIC_PARAM_SIZE_BLE_SET_DEF_PHY);
1147
1148 UINT8_TO_STREAM(pp, all_phys);
1149 UINT8_TO_STREAM(pp, tx_phys);
1150 UINT8_TO_STREAM(pp, rx_phys);
1151
1152 return btu_hcif_send_cmd_sync(LOCAL_BR_EDR_CONTROLLER_ID, p);
1153 }
1154
btsnd_hcic_ble_set_phy(UINT16 conn_handle,UINT8 all_phys,UINT8 tx_phys,UINT8 rx_phys,UINT16 phy_options)1155 BOOLEAN btsnd_hcic_ble_set_phy(UINT16 conn_handle,
1156 UINT8 all_phys, UINT8 tx_phys,
1157 UINT8 rx_phys, UINT16 phy_options)
1158 {
1159 BT_HDR *p;
1160 UINT8 *pp;
1161 HCI_TRACE_EVENT("%s, conn_handle = %d, all_phys = %d, tx_phys = %d, rx_phys = %d, phy_options = %d", __func__,
1162 conn_handle, all_phys, tx_phys, rx_phys, phy_options);
1163 HCIC_BLE_CMD_CREATED(p, pp, HCIC_PARAM_SIZE_BLE_SET_PHY);
1164
1165 UINT16_TO_STREAM(pp, HCI_BLE_SET_PHY);
1166 UINT8_TO_STREAM(pp, HCIC_PARAM_SIZE_BLE_SET_PHY);
1167 UINT16_TO_STREAM(pp, conn_handle);
1168 UINT8_TO_STREAM(pp, all_phys);
1169 UINT8_TO_STREAM(pp, tx_phys);
1170 UINT8_TO_STREAM(pp, rx_phys);
1171 UINT16_TO_STREAM(pp, phy_options);
1172
1173 btu_hcif_send_cmd(LOCAL_BR_EDR_CONTROLLER_ID, p);
1174 return TRUE;
1175 }
1176
btsnd_hcic_ble_enhand_rx_test(UINT8 rx_channel,UINT8 phy,UINT8 modulation_idx)1177 UINT8 btsnd_hcic_ble_enhand_rx_test(UINT8 rx_channel, UINT8 phy,
1178 UINT8 modulation_idx)
1179 {
1180 BT_HDR *p;
1181 UINT8 *pp;
1182
1183 HCI_TRACE_EVENT("%s, rx_channel = %d, phy = %d, modulation_idx = %d", __func__,
1184 rx_channel, phy, modulation_idx);
1185 HCIC_BLE_CMD_CREATED(p, pp, HCIC_PARAM_SIZE_ENH_RX_TEST);
1186
1187 UINT16_TO_STREAM(pp, HCI_BLE_ENH_RX_TEST);
1188 UINT8_TO_STREAM(pp, HCIC_PARAM_SIZE_ENH_RX_TEST);
1189 UINT8_TO_STREAM(pp, rx_channel);
1190 UINT8_TO_STREAM(pp, phy);
1191 UINT8_TO_STREAM(pp, modulation_idx);
1192
1193 btu_hcif_send_cmd(LOCAL_BR_EDR_CONTROLLER_ID, p);
1194
1195 return TRUE;
1196 }
1197
btsnd_hcic_ble_enhand_tx_test(UINT8 tx_channel,UINT8 len,UINT8 packect,UINT8 phy)1198 UINT8 btsnd_hcic_ble_enhand_tx_test(UINT8 tx_channel, UINT8 len,
1199 UINT8 packect,
1200 UINT8 phy)
1201 {
1202 BT_HDR *p;
1203 UINT8 *pp;
1204
1205 HCI_TRACE_EVENT("%s, tx_channel = %d, len = %d, packect = %d, phy = %d", __func__,
1206 tx_channel, len, packect, phy);
1207
1208 HCIC_BLE_CMD_CREATED(p, pp, HCIC_PARAM_SIZE_ENH_TX_TEST);
1209
1210 UINT16_TO_STREAM(pp, HCI_BLE_ENH_TX_TEST);
1211 UINT8_TO_STREAM(pp, HCIC_PARAM_SIZE_ENH_TX_TEST);
1212 UINT8_TO_STREAM(pp, tx_channel);
1213 UINT8_TO_STREAM(pp, len);
1214 UINT8_TO_STREAM(pp, packect);
1215 UINT8_TO_STREAM(pp, phy);
1216
1217 btu_hcif_send_cmd(LOCAL_BR_EDR_CONTROLLER_ID, p);
1218
1219 return TRUE;
1220 }
1221
btsnd_hcic_ble_set_extend_rand_address(UINT8 adv_handle,BD_ADDR rand_addr)1222 UINT8 btsnd_hcic_ble_set_extend_rand_address(UINT8 adv_handle, BD_ADDR rand_addr)
1223 {
1224 BT_HDR *p;
1225 UINT8 *pp;
1226 HCI_TRACE_EVENT("%s, adv_handle = %d", __func__, adv_handle);
1227
1228 HCIC_BLE_CMD_CREATED(p, pp, HCIC_PARAM_SIZE_EXT_RAND_ADDR);
1229
1230 UINT16_TO_STREAM (pp, HCI_BLE_SET_ADV_RAND_ADDR);
1231 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_EXT_RAND_ADDR);
1232 UINT8_TO_STREAM(pp, adv_handle);
1233 BDADDR_TO_STREAM (pp, rand_addr);
1234
1235 return btu_hcif_send_cmd_sync (LOCAL_BR_EDR_CONTROLLER_ID, p);
1236
1237 }
1238
btsnd_hcic_ble_set_ext_adv_params(UINT8 adv_handle,UINT16 properties,UINT32 interval_min,UINT32 interval_max,UINT8 channel_map,UINT8 own_addr_type,UINT8 peer_addr_type,BD_ADDR peer_addr,UINT8 adv_filter_policy,INT8 adv_tx_power,UINT8 primary_adv_phy,UINT8 secondary_adv_max_skip,UINT8 secondary_adv_phy,UINT8 adv_sid,UINT8 scan_req_ntf_enable)1239 UINT8 btsnd_hcic_ble_set_ext_adv_params(UINT8 adv_handle, UINT16 properties, UINT32 interval_min,
1240 UINT32 interval_max, UINT8 channel_map, UINT8 own_addr_type,
1241 UINT8 peer_addr_type, BD_ADDR peer_addr,
1242 UINT8 adv_filter_policy, INT8 adv_tx_power,
1243 UINT8 primary_adv_phy, UINT8 secondary_adv_max_skip,
1244 UINT8 secondary_adv_phy,
1245 UINT8 adv_sid, UINT8 scan_req_ntf_enable)
1246 {
1247 BT_HDR *p;
1248 UINT8 *pp;
1249
1250
1251 HCI_TRACE_EVENT("%s, adv_handle = %d, properties = %d, interval_min = %d, interval_max = %d, channel_map = %d,\n\
1252 own_addr_type = %d, peer_addr_type = %d, adv_filter_policy = %d,\n\
1253 adv_tx_power = %d, primary_adv_phy = %d, secondary_adv_max_skip = %d, secondary_adv_phy = %d,\n\
1254 adv_sid = %d, scan_req_ntf_enable = %d", __func__, adv_handle, properties, interval_min, interval_max,
1255 channel_map, own_addr_type, peer_addr_type, adv_filter_policy, adv_tx_power,
1256 primary_adv_phy, secondary_adv_max_skip, secondary_adv_phy, adv_sid, scan_req_ntf_enable);
1257
1258 HCIC_BLE_CMD_CREATED(p, pp, HCIC_PARAM_SIZE_EXT_ADV_SET_PARAMS);
1259
1260 UINT16_TO_STREAM(pp, HCI_BLE_SET_EXT_ADV_PARAM);
1261 UINT8_TO_STREAM(pp, HCIC_PARAM_SIZE_EXT_ADV_SET_PARAMS);
1262
1263 UINT8_TO_STREAM(pp, adv_handle);
1264 UINT16_TO_STREAM(pp, properties);
1265 UINT24_TO_STREAM(pp, interval_min);
1266 UINT24_TO_STREAM(pp, interval_max);
1267 UINT8_TO_STREAM(pp, channel_map);
1268 UINT8_TO_STREAM(pp, own_addr_type);
1269 UINT8_TO_STREAM(pp, peer_addr_type);
1270 BDADDR_TO_STREAM (pp, peer_addr);
1271 UINT8_TO_STREAM(pp, adv_filter_policy);
1272 INT8_TO_STREAM(pp, adv_tx_power);
1273 UINT8_TO_STREAM(pp, primary_adv_phy);
1274 UINT8_TO_STREAM(pp, secondary_adv_max_skip);
1275 UINT8_TO_STREAM(pp, secondary_adv_phy);
1276 UINT8_TO_STREAM(pp, adv_sid);
1277 UINT8_TO_STREAM(pp, scan_req_ntf_enable);
1278
1279 return btu_hcif_send_cmd_sync (LOCAL_BR_EDR_CONTROLLER_ID, p);
1280 }
1281
1282 bool ext_adv_flag = false;
1283
btsnd_hcic_ble_set_ext_adv_data(UINT8 adv_handle,UINT8 operation,UINT8 fragment_prefrence,UINT8 data_len,UINT8 * p_data)1284 UINT8 btsnd_hcic_ble_set_ext_adv_data(UINT8 adv_handle,
1285 UINT8 operation, UINT8 fragment_prefrence,
1286 UINT8 data_len, UINT8 *p_data)
1287 {
1288 BT_HDR *p;
1289 UINT8 *pp;
1290 HCI_TRACE_EVENT("%s, adv_handle = %d, operation = %d, fragment_prefrence = %d,\
1291 data_len = %d", __func__, adv_handle, operation, fragment_prefrence, data_len);
1292 ext_adv_flag = true;
1293
1294 HCIC_BLE_CMD_CREATED(p, pp, data_len + 4);
1295 UINT16_TO_STREAM(pp, HCI_BLE_SET_EXT_ADV_DATA);
1296 UINT8_TO_STREAM(pp, data_len + 4);
1297 UINT8_TO_STREAM(pp, adv_handle);
1298 UINT8_TO_STREAM(pp, operation);
1299 UINT8_TO_STREAM(pp, fragment_prefrence);
1300
1301 if (data_len > HCIC_PARAM_SIZE_EXT_ADV_WRITE_DATA) {
1302 data_len = HCIC_PARAM_SIZE_EXT_ADV_WRITE_DATA;
1303 }
1304
1305 UINT8_TO_STREAM (pp, data_len);
1306
1307 if (p_data != NULL && data_len > 0){
1308 ARRAY_TO_STREAM (pp, p_data, data_len);
1309 }
1310
1311 uint8_t status = btu_hcif_send_cmd_sync (LOCAL_BR_EDR_CONTROLLER_ID, p);
1312 return status;
1313
1314 }
1315
btsnd_hcic_ble_set_ext_adv_scan_rsp_data(UINT8 adv_handle,UINT8 operation,UINT8 fragment_prefrence,UINT8 data_len,UINT8 * p_data)1316 UINT8 btsnd_hcic_ble_set_ext_adv_scan_rsp_data(UINT8 adv_handle,
1317 UINT8 operation, UINT8 fragment_prefrence,
1318 UINT8 data_len, UINT8 *p_data)
1319 {
1320 BT_HDR *p;
1321 UINT8 *pp;
1322
1323 HCI_TRACE_EVENT("%s, adv_handle = %d, operation = %d, fragment_prefrence = %d,\n\
1324 data_len = %d", __func__, adv_handle, operation, fragment_prefrence, data_len);
1325
1326 HCIC_BLE_CMD_CREATED(p, pp, data_len + 4);
1327
1328 UINT16_TO_STREAM(pp, HCI_BLE_SET_EXT_SCAN_RSP_DATA);
1329 UINT8_TO_STREAM(pp, data_len + 4);
1330 UINT8_TO_STREAM(pp, adv_handle);
1331 UINT8_TO_STREAM(pp, operation);
1332 UINT8_TO_STREAM(pp, fragment_prefrence);
1333
1334 memset(pp, 0, data_len);
1335
1336 if (data_len > HCIC_PARAM_SIZE_EXT_ADV_WRITE_DATA) {
1337 data_len = HCIC_PARAM_SIZE_EXT_ADV_WRITE_DATA;
1338 }
1339
1340 UINT8_TO_STREAM (pp, data_len);
1341 if (p_data != NULL && data_len > 0) {
1342 ARRAY_TO_STREAM (pp, p_data, data_len);
1343 }
1344
1345 return btu_hcif_send_cmd_sync (LOCAL_BR_EDR_CONTROLLER_ID, p);
1346
1347 }
1348
btsnd_hcic_ble_ext_adv_enable(UINT8 enable,UINT8 num_of_sets,UINT8 * adv_handle,UINT16 * duration,UINT8 * max_adv_evt)1349 UINT8 btsnd_hcic_ble_ext_adv_enable(UINT8 enable, UINT8 num_of_sets, UINT8 *adv_handle,
1350 UINT16 *duration, UINT8 *max_adv_evt)
1351 {
1352 BT_HDR *p;
1353 UINT8 *pp;
1354 UINT8 ext_adv_size = num_of_sets*4 + 2;
1355 HCIC_BLE_CMD_CREATED(p, pp, ext_adv_size);
1356
1357 HCI_TRACE_EVENT("%s, enable = %d, num_of_sets = %d", __func__, enable, num_of_sets);
1358
1359 for (int k = 0; k < num_of_sets; k++) {
1360 HCI_TRACE_EVENT("adv_handle[%d] = %d, duration[%d] = %d, max_adv_evt[%d] = %d", k, adv_handle[k],
1361 k, duration[k], k, max_adv_evt[k]);
1362 }
1363
1364 UINT16_TO_STREAM(pp, HCI_BLE_SET_EXT_ADV_ENABLE);
1365 UINT8_TO_STREAM(pp, ext_adv_size);
1366 UINT8_TO_STREAM(pp, enable);
1367 UINT8_TO_STREAM(pp, num_of_sets);
1368
1369 for (int i = 0; i < num_of_sets; i++) {
1370 UINT8_TO_STREAM(pp, adv_handle[i]);
1371 UINT16_TO_STREAM(pp, duration[i]);
1372 UINT8_TO_STREAM(pp, max_adv_evt[i]);
1373 }
1374
1375 return btu_hcif_send_cmd_sync (LOCAL_BR_EDR_CONTROLLER_ID, p);
1376 }
1377
btsnd_hcic_ble_read_max_adv_len(void)1378 UINT8 btsnd_hcic_ble_read_max_adv_len(void)
1379 {
1380 BT_HDR *p;
1381 UINT8 *pp;
1382 HCI_TRACE_EVENT("%s", __func__);
1383
1384 HCIC_BLE_CMD_CREATED(p, pp, HCIC_PARAM_SIZE_READ_MAX_ADV_SIZE + 1);
1385
1386 UINT16_TO_STREAM(pp, HCI_BLE_RD_MAX_ADV_DATA_LEN);
1387 UINT8_TO_STREAM(pp, HCIC_PARAM_SIZE_READ_MAX_ADV_SIZE);
1388
1389 return btu_hcif_send_cmd_sync (LOCAL_BR_EDR_CONTROLLER_ID, p);
1390 }
1391
btsnd_hcic_ble_read_num_support_adv_set(void)1392 UINT8 btsnd_hcic_ble_read_num_support_adv_set(void)
1393 {
1394 BT_HDR *p;
1395 UINT8 *pp;
1396 HCI_TRACE_EVENT("%s", __func__);
1397
1398 HCIC_BLE_CMD_CREATED(p, pp, HCIC_PARAM_SIZE_NUM_SUPPORT_ADV_SET + 1);
1399
1400 UINT16_TO_STREAM(pp, HCI_BLE_RD_NUM_OF_ADV_SETS);
1401 UINT8_TO_STREAM(pp, HCIC_PARAM_SIZE_NUM_SUPPORT_ADV_SET);
1402
1403 return btu_hcif_send_cmd_sync (LOCAL_BR_EDR_CONTROLLER_ID, p);
1404 }
1405
btsnd_hcic_ble_remove_adv_set(UINT8 adv_handle)1406 UINT8 btsnd_hcic_ble_remove_adv_set(UINT8 adv_handle)
1407 {
1408 BT_HDR *p;
1409 UINT8 *pp;
1410 HCI_TRACE_EVENT("%s, adv_handle = %d", __func__, adv_handle);
1411
1412 HCIC_BLE_CMD_CREATED(p, pp, HCIC_PARAM_SIZE_REMOVE_ADV_SET + 1);
1413
1414 UINT16_TO_STREAM(pp, HCI_BLE_REMOVE_ADV_SET);
1415 UINT8_TO_STREAM(pp, HCIC_PARAM_SIZE_REMOVE_ADV_SET);
1416 UINT8_TO_STREAM(pp, adv_handle);
1417
1418 return btu_hcif_send_cmd_sync(LOCAL_BR_EDR_CONTROLLER_ID, p);
1419 }
1420
btsnd_hcic_ble_clear_adv_set(void)1421 UINT8 btsnd_hcic_ble_clear_adv_set(void)
1422 {
1423 BT_HDR *p;
1424 UINT8 *pp;
1425 HCI_TRACE_EVENT("%s", __func__);
1426
1427 HCIC_BLE_CMD_CREATED(p, pp, HCIC_PARAM_SIZE_CLEAR_ADV_SET + 1);
1428
1429 UINT16_TO_STREAM(pp, HCI_BLE_CLEAR_ADV_SETS);
1430 UINT8_TO_STREAM(pp, HCIC_PARAM_SIZE_CLEAR_ADV_SET);
1431
1432 return btu_hcif_send_cmd_sync(LOCAL_BR_EDR_CONTROLLER_ID, p);
1433
1434 }
1435
btsnd_hcic_ble_set_periodic_adv_params(UINT8 adv_handle,UINT16 interval_min,UINT16 interval_max,UINT8 propertics)1436 UINT8 btsnd_hcic_ble_set_periodic_adv_params(UINT8 adv_handle,
1437 UINT16 interval_min,
1438 UINT16 interval_max,
1439 UINT8 propertics)
1440 {
1441 BT_HDR *p;
1442 UINT8 *pp;
1443 HCI_TRACE_EVENT("%s, adv_handle = %d, interval_min = %d, interval_max = %d, propertics = %d",
1444 __func__, adv_handle, interval_min, interval_max, propertics);
1445
1446 HCIC_BLE_CMD_CREATED(p, pp, HCIC_PARAM_SIZE_SET_PERIODIC_ADV_PARAMS);
1447
1448 UINT16_TO_STREAM(pp, HCI_BLE_SET_PERIOD_ADV_PARAMS);
1449 UINT8_TO_STREAM(pp, HCIC_PARAM_SIZE_SET_PERIODIC_ADV_PARAMS);
1450
1451 UINT8_TO_STREAM(pp, adv_handle);
1452 UINT16_TO_STREAM(pp, interval_min);
1453 UINT16_TO_STREAM(pp, interval_max);
1454 UINT16_TO_STREAM(pp, propertics);
1455
1456 return btu_hcif_send_cmd_sync(LOCAL_BR_EDR_CONTROLLER_ID, p);
1457
1458 }
1459
btsnd_hcic_ble_set_periodic_adv_data(UINT8 adv_handle,UINT8 operation,UINT8 len,UINT8 * p_data)1460 UINT8 btsnd_hcic_ble_set_periodic_adv_data(UINT8 adv_handle,
1461 UINT8 operation,
1462 UINT8 len,
1463 UINT8 *p_data)
1464 {
1465 BT_HDR *p;
1466 UINT8 *pp;
1467 HCI_TRACE_EVENT("%s, adv_handle = %d, operation = %d, len = %d",
1468 __func__, adv_handle, operation, len);
1469
1470 HCIC_BLE_CMD_CREATED(p, pp, len + 3);
1471
1472 UINT16_TO_STREAM(pp, HCI_BLE_SET_PERIOD_ADV_DATA);
1473 UINT8_TO_STREAM(pp, len + 3);
1474 UINT8_TO_STREAM(pp, adv_handle);
1475 UINT8_TO_STREAM(pp, operation);
1476
1477 //memset(pp, 0, len);
1478
1479 if (len > HCIC_PARAM_SIZE_WRITE_PERIODIC_ADV_DATA) {
1480 len = HCIC_PARAM_SIZE_WRITE_PERIODIC_ADV_DATA;
1481 }
1482
1483 UINT8_TO_STREAM (pp, len);
1484
1485 if (p_data != NULL && len > 0) {
1486 ARRAY_TO_STREAM (pp, p_data, len);
1487 }
1488
1489 return btu_hcif_send_cmd_sync(LOCAL_BR_EDR_CONTROLLER_ID, p);
1490
1491 }
1492
btsnd_hcic_ble_periodic_adv_enable(UINT8 enable,UINT8 adv_handle)1493 UINT8 btsnd_hcic_ble_periodic_adv_enable(UINT8 enable, UINT8 adv_handle)
1494 {
1495 BT_HDR *p;
1496 UINT8 *pp;
1497 HCI_TRACE_EVENT("%s, enable = %d, adv_handle = %d",
1498 __func__, enable, adv_handle);
1499
1500 HCIC_BLE_CMD_CREATED(p, pp, HCIC_PARAM_SIZE_PERIODIC_ADV_ENABLE);
1501
1502 UINT16_TO_STREAM(pp, HCI_BLE_SET_PERIOD_ADV_ENABLE);
1503 UINT8_TO_STREAM(pp, HCIC_PARAM_SIZE_PERIODIC_ADV_ENABLE);
1504 UINT8_TO_STREAM(pp, enable);
1505 UINT8_TO_STREAM(pp, adv_handle);
1506
1507 return btu_hcif_send_cmd_sync(LOCAL_BR_EDR_CONTROLLER_ID, p);
1508
1509 }
1510
btsnd_hcic_ble_set_ext_scan_params(UINT8 own_addr_type,UINT8 filter_policy,UINT8 phy_mask,UINT8 phy_count,tHCI_EXT_SCAN_PARAMS * params)1511 UINT8 btsnd_hcic_ble_set_ext_scan_params(UINT8 own_addr_type, UINT8 filter_policy,
1512 UINT8 phy_mask, UINT8 phy_count,
1513 tHCI_EXT_SCAN_PARAMS *params)
1514 {
1515 BT_HDR *p;
1516 UINT8 *pp;
1517 HCI_TRACE_EVENT("%s, own_addr_type = %d, filter_policy = %d, phy_mask = %d, phy_count = %d",
1518 __func__, own_addr_type, filter_policy, phy_mask, phy_count);
1519 UINT8 params_size = HCIC_PARAM_SIZE_SET_EXT_SCAN_PARAMS + phy_count*5;
1520
1521 HCIC_BLE_CMD_CREATED(p, pp, params_size);
1522
1523 UINT16_TO_STREAM(pp, HCI_BLE_SET_EXT_SCAN_PARAMS);
1524 UINT8_TO_STREAM(pp, params_size);
1525 UINT8_TO_STREAM(pp, own_addr_type);
1526 UINT8_TO_STREAM(pp, filter_policy);
1527 UINT8_TO_STREAM(pp, phy_mask);
1528
1529 for (int i = 0; i < phy_count; i++) {
1530 UINT8_TO_STREAM(pp, params[i].scan_type);
1531 UINT16_TO_STREAM(pp, params[i].scan_interval);
1532 UINT16_TO_STREAM(pp, params[i].scan_window);
1533 }
1534
1535 return btu_hcif_send_cmd_sync(LOCAL_BR_EDR_CONTROLLER_ID, p);
1536
1537 }
1538
btsnd_hcic_ble_ext_scan_enable(UINT8 enable,UINT8 filter_dups,UINT16 duration,UINT16 period)1539 UINT8 btsnd_hcic_ble_ext_scan_enable(UINT8 enable, UINT8 filter_dups,
1540 UINT16 duration, UINT16 period)
1541 {
1542 BT_HDR *p;
1543 UINT8 *pp;
1544 HCI_TRACE_EVENT("%s, enable = %d, filter_dups = %d, duration = %d, period = %d",
1545 __func__, enable, filter_dups, duration, period);
1546
1547 HCIC_BLE_CMD_CREATED(p, pp, HCIC_PARAM_SIZE_EXT_SCAN_ENABLE);
1548
1549 UINT16_TO_STREAM(pp, HCI_BLE_SET_EXT_SCAN_ENABLE);
1550 UINT8_TO_STREAM(pp, HCIC_PARAM_SIZE_EXT_SCAN_ENABLE);
1551 UINT8_TO_STREAM(pp, enable);
1552 UINT8_TO_STREAM(pp, filter_dups);
1553 UINT16_TO_STREAM(pp, duration);
1554 UINT16_TO_STREAM(pp, period);
1555
1556 return btu_hcif_send_cmd_sync(LOCAL_BR_EDR_CONTROLLER_ID, p);
1557 }
1558
btsnd_hcic_ble_create_ext_conn(tHCI_CreatExtConn * p_conn)1559 BOOLEAN btsnd_hcic_ble_create_ext_conn(tHCI_CreatExtConn *p_conn)
1560 {
1561 BT_HDR *p;
1562 UINT8 *pp;
1563 tHCI_ExtConnParams *params;
1564 HCI_TRACE_EVENT("%s", __func__);
1565 uint8_t size = HCIC_PARAM_SIZE_EXT_CONN_CREATE_BASE;
1566
1567 if (p_conn->init_phy_mask & 0x01) {
1568 size += sizeof(tHCI_ExtConnParams);
1569 }
1570
1571 if (p_conn->init_phy_mask & 0x02) {
1572 size += sizeof(tHCI_ExtConnParams);
1573 }
1574
1575 if (p_conn->init_phy_mask & 0x04) {
1576 size += sizeof(tHCI_ExtConnParams);
1577 }
1578
1579 HCIC_BLE_CMD_CREATED(p, pp, size);
1580
1581 UINT16_TO_STREAM(pp, HCI_BLE_EXT_CREATE_CONN);
1582 UINT8_TO_STREAM(pp, size);
1583 UINT8_TO_STREAM(pp, p_conn->filter_policy);
1584 UINT8_TO_STREAM(pp, p_conn->own_addr_type);
1585 UINT8_TO_STREAM(pp, p_conn->peer_addr_type);
1586 BDADDR_TO_STREAM(pp, p_conn->peer_addr);
1587 UINT8_TO_STREAM(pp, p_conn->init_phy_mask);
1588
1589 if (p_conn->init_phy_mask & 0x01) {
1590 params = &p_conn->params[0];
1591 UINT16_TO_STREAM(pp, params->scan_interval);
1592 UINT16_TO_STREAM(pp, params->scan_window);
1593 UINT16_TO_STREAM(pp, params->conn_interval_min);
1594 UINT16_TO_STREAM(pp, params->conn_interval_max);
1595 UINT16_TO_STREAM(pp, params->conn_latency);
1596 UINT16_TO_STREAM(pp, params->sup_timeout);
1597 UINT16_TO_STREAM(pp, params->min_ce_len ? params->min_ce_len : BLE_CE_LEN_MIN);
1598 UINT16_TO_STREAM(pp, params->max_ce_len ? params->max_ce_len : BLE_CE_LEN_MIN);
1599 }
1600
1601 if (p_conn->init_phy_mask & 0x02) {
1602 params = &p_conn->params[1];
1603 UINT16_TO_STREAM(pp, params->scan_interval);
1604 UINT16_TO_STREAM(pp, params->scan_window);
1605 UINT16_TO_STREAM(pp, params->conn_interval_min);
1606 UINT16_TO_STREAM(pp, params->conn_interval_max);
1607 UINT16_TO_STREAM(pp, params->conn_latency);
1608 UINT16_TO_STREAM(pp, params->sup_timeout);
1609 UINT16_TO_STREAM(pp, params->min_ce_len ? params->min_ce_len : BLE_CE_LEN_MIN);
1610 UINT16_TO_STREAM(pp, params->max_ce_len ? params->max_ce_len : BLE_CE_LEN_MIN);
1611 }
1612
1613 if (p_conn->init_phy_mask & 0x04) {
1614 params = &p_conn->params[2];
1615 UINT16_TO_STREAM(pp, params->scan_interval);
1616 UINT16_TO_STREAM(pp, params->scan_window);
1617 UINT16_TO_STREAM(pp, params->conn_interval_min);
1618 UINT16_TO_STREAM(pp, params->conn_interval_max);
1619 UINT16_TO_STREAM(pp, params->conn_latency);
1620 UINT16_TO_STREAM(pp, params->sup_timeout);
1621 UINT16_TO_STREAM(pp, params->min_ce_len ? params->min_ce_len : BLE_CE_LEN_MIN);
1622 UINT16_TO_STREAM(pp, params->max_ce_len ? params->max_ce_len : BLE_CE_LEN_MIN);
1623 }
1624
1625 btu_hcif_send_cmd(LOCAL_BR_EDR_CONTROLLER_ID, p);
1626 return TRUE;
1627
1628 }
1629
btsnd_hcic_ble_periodic_adv_create_sync(UINT8 option,UINT8 adv_sid,UINT8 adv_addr_type,BD_ADDR adv_addr,UINT16 sync_timeout,UINT8 unused)1630 BOOLEAN btsnd_hcic_ble_periodic_adv_create_sync(UINT8 option, UINT8 adv_sid,
1631 UINT8 adv_addr_type, BD_ADDR adv_addr,
1632 UINT16 sync_timeout, UINT8 unused)
1633 {
1634 BT_HDR *p;
1635 UINT8 *pp;
1636 HCI_TRACE_EVENT("%s, option = %d, adv_sid = %d, adv_addr_type = %d, sync_timeout = %d, unused = %d",
1637 __func__, option, adv_sid, adv_addr_type, sync_timeout, unused);
1638
1639 HCI_TRACE_EVENT("addr %02x %02x %02x %02x %02x %02x", adv_addr[0], adv_addr[1], adv_addr[2], adv_addr[3], adv_addr[4], adv_addr[5]);
1640 uint16_t skip = 0;
1641 HCIC_BLE_CMD_CREATED(p, pp, HCIC_PARAM_SIZE_PERIODIC_ADV_CREATE_SYNC + 2);
1642
1643 UINT16_TO_STREAM(pp, HCI_BLE_PERIOD_ADV_CREATE_SYNC);
1644 UINT8_TO_STREAM(pp, HCIC_PARAM_SIZE_PERIODIC_ADV_CREATE_SYNC + 2);
1645 UINT8_TO_STREAM(pp, option);
1646 UINT8_TO_STREAM(pp, adv_sid);
1647 UINT8_TO_STREAM(pp, adv_addr_type);
1648 BDADDR_TO_STREAM(pp, adv_addr);
1649 UINT16_TO_STREAM(pp, skip);
1650 UINT16_TO_STREAM(pp, sync_timeout);
1651 UINT8_TO_STREAM(pp, unused);
1652
1653 btu_hcif_send_cmd(LOCAL_BR_EDR_CONTROLLER_ID, p);
1654 return TRUE;
1655 }
1656
btsnd_hcic_ble_periodic_adv_create_sync_cancel(void)1657 UINT8 btsnd_hcic_ble_periodic_adv_create_sync_cancel(void)
1658 {
1659 BT_HDR *p;
1660 UINT8 *pp;
1661 HCI_TRACE_EVENT("%s", __func__);
1662
1663 HCIC_BLE_CMD_CREATED(p, pp, HCIC_PARAM_SIZE_PERIODIC_ADV_CREATE_SYNC_CANCEL);
1664
1665 UINT16_TO_STREAM(pp, HCI_BLE_PERIOD_ADV_CREATE_SYNC_CANCEL);
1666 UINT8_TO_STREAM(pp, HCIC_PARAM_SIZE_PERIODIC_ADV_CREATE_SYNC_CANCEL);
1667
1668 return btu_hcif_send_cmd_sync(LOCAL_BR_EDR_CONTROLLER_ID, p);
1669 }
1670
btsnd_hcic_ble_periodic_adv_term_sync(UINT16 sync_handle)1671 UINT8 btsnd_hcic_ble_periodic_adv_term_sync(UINT16 sync_handle)
1672 {
1673 BT_HDR *p;
1674 UINT8 *pp;
1675 HCI_TRACE_EVENT("%s, sync_handle = %d", __func__, sync_handle);
1676
1677 HCIC_BLE_CMD_CREATED(p, pp, HCIC_PARAM_SIZE_PERIODIC_ADV_TERM_SYNC);
1678
1679 UINT16_TO_STREAM(pp, HCI_BLE_PERIOD_ADV_TERM_SYNC);
1680 UINT8_TO_STREAM(pp, HCIC_PARAM_SIZE_PERIODIC_ADV_TERM_SYNC);
1681
1682 UINT16_TO_STREAM(pp, sync_handle);
1683
1684 return btu_hcif_send_cmd_sync(LOCAL_BR_EDR_CONTROLLER_ID, p);
1685 }
1686
btsnd_hcic_ble_add_dev_to_periodic_adv_list(UINT8 adv_addr_type,BD_ADDR adv_addr,UINT8 adv_sid)1687 UINT8 btsnd_hcic_ble_add_dev_to_periodic_adv_list(UINT8 adv_addr_type, BD_ADDR adv_addr,
1688 UINT8 adv_sid)
1689 {
1690 BT_HDR *p;
1691 UINT8 *pp;
1692 HCI_TRACE_EVENT("%s, adv_addr_type = %d, adv_sid = %d", __func__, adv_addr_type, adv_sid);
1693 esp_log_buffer_hex_internal("addr", adv_addr, sizeof(BD_ADDR), ESP_LOG_WARN);
1694
1695 HCIC_BLE_CMD_CREATED(p, pp, HCIC_PARAM_SIZE_ADD_DEV_TO_PERIODIC_ADV_LIST);
1696
1697 UINT16_TO_STREAM(pp, HCI_BLE_ADV_DEV_TO_PERIOD_ADV_LIST);
1698 UINT8_TO_STREAM(pp, HCIC_PARAM_SIZE_ADD_DEV_TO_PERIODIC_ADV_LIST);
1699 UINT8_TO_STREAM(pp, adv_addr_type);
1700 BDADDR_TO_STREAM(pp, adv_addr);
1701 UINT8_TO_STREAM(pp, adv_sid);
1702
1703 return btu_hcif_send_cmd_sync(LOCAL_BR_EDR_CONTROLLER_ID, p);
1704 }
1705
btsnd_hcic_ble_rm_dev_from_periodic_adv_list(UINT8 adv_addr_type,BD_ADDR adv_addr,UINT8 adv_sid)1706 UINT8 btsnd_hcic_ble_rm_dev_from_periodic_adv_list(UINT8 adv_addr_type, BD_ADDR adv_addr,
1707 UINT8 adv_sid)
1708 {
1709 BT_HDR *p;
1710 UINT8 *pp;
1711 HCI_TRACE_EVENT("%s, adv_addr_type = %d, adv_sid = %d", __func__, adv_addr_type, adv_sid);
1712 esp_log_buffer_hex_internal("addr", adv_addr, sizeof(BD_ADDR), ESP_LOG_WARN);
1713
1714 HCIC_BLE_CMD_CREATED(p, pp, HCIC_PARAM_SIZE_RM_DEV_FROM_PERIODIC_ADV_LIST);
1715
1716 UINT16_TO_STREAM(pp, HCI_BLE_REMOVE_DEV_FROM_PERIOD_ADV_LIST);
1717 UINT8_TO_STREAM(pp, HCIC_PARAM_SIZE_RM_DEV_FROM_PERIODIC_ADV_LIST);
1718 UINT8_TO_STREAM(pp, adv_addr_type);
1719 BDADDR_TO_STREAM(pp, adv_addr);
1720 UINT8_TO_STREAM(pp, adv_sid);
1721
1722 return btu_hcif_send_cmd_sync(LOCAL_BR_EDR_CONTROLLER_ID, p);
1723
1724 }
1725
btsnd_hcic_ble_clear_periodic_adv_list(void)1726 UINT8 btsnd_hcic_ble_clear_periodic_adv_list(void)
1727 {
1728 BT_HDR *p;
1729 UINT8 *pp;
1730 HCI_TRACE_EVENT("%s", __func__);
1731
1732 HCIC_BLE_CMD_CREATED(p, pp, HCIC_PARAM_SIZE_CLEAR_PERIODIC_ADV_LIST);
1733
1734 UINT16_TO_STREAM(pp, HCI_BLE_CLEAR_PERIOD_ADV_LIST);
1735 UINT8_TO_STREAM(pp, HCIC_PARAM_SIZE_CLEAR_PERIODIC_ADV_LIST);
1736
1737 return btu_hcif_send_cmd_sync(LOCAL_BR_EDR_CONTROLLER_ID, p);
1738 }
1739
btsnd_hcic_ble_read_periodic_adv_list_size(void)1740 UINT8 btsnd_hcic_ble_read_periodic_adv_list_size(void)
1741 {
1742 BT_HDR *p;
1743 UINT8 *pp;
1744 HCI_TRACE_EVENT("%s", __func__);
1745
1746 HCIC_BLE_CMD_CREATED(p, pp, HCIC_PARAM_SIZE_READ_PERIODIC_ADV_LIST);
1747
1748 UINT16_TO_STREAM(pp, HCI_BLE_RD_PERIOD_ADV_LIST_SIZE);
1749 UINT8_TO_STREAM(pp, HCIC_PARAM_SIZE_READ_PERIODIC_ADV_LIST);
1750
1751 return btu_hcif_send_cmd_sync(LOCAL_BR_EDR_CONTROLLER_ID, p);
1752 }
1753
btsnd_hcic_ble_read_trans_power(void)1754 UINT8 btsnd_hcic_ble_read_trans_power(void)
1755 {
1756 BT_HDR *p;
1757 UINT8 *pp;
1758 HCI_TRACE_EVENT("%s", __func__);
1759
1760 HCIC_BLE_CMD_CREATED(p, pp, HCIC_PARAM_SIZE_READ_TRANS_POWER);
1761
1762 UINT16_TO_STREAM(pp, HCI_BLE_RD_TRANSMIT_POWER);
1763 UINT8_TO_STREAM(pp, HCIC_PARAM_SIZE_READ_TRANS_POWER);
1764
1765 return btu_hcif_send_cmd_sync(LOCAL_BR_EDR_CONTROLLER_ID, p);
1766 }
1767
btsnd_hcic_ble_read_rf_path_compensation(void)1768 UINT8 btsnd_hcic_ble_read_rf_path_compensation(void)
1769 {
1770 BT_HDR *p;
1771 UINT8 *pp;
1772 HCI_TRACE_EVENT("%s", __func__);
1773
1774 HCIC_BLE_CMD_CREATED(p, pp, HCIC_PARAM_SIZE_READ_RF_PATH_COMPENSATION);
1775
1776 UINT16_TO_STREAM(pp, HCI_BLE_RD_RF_PATH_COMPENSATION);
1777 UINT8_TO_STREAM(pp, HCIC_PARAM_SIZE_READ_RF_PATH_COMPENSATION);
1778
1779 return btu_hcif_send_cmd_sync(LOCAL_BR_EDR_CONTROLLER_ID, p);
1780 }
1781
btsnd_hcic_ble_write_rf_path_compensation(UINT16 rf_tx_path,UINT16 rf_rx_path)1782 UINT8 btsnd_hcic_ble_write_rf_path_compensation(UINT16 rf_tx_path, UINT16 rf_rx_path)
1783 {
1784 BT_HDR *p;
1785 UINT8 *pp;
1786 HCI_TRACE_EVENT("%s, rf_tx_path = %d, rf_rx_path = %d", __func__, rf_tx_path, rf_rx_path);
1787
1788 HCIC_BLE_CMD_CREATED(p, pp, HCIC_PARAM_SIZE_WRITE_RF_PATH_COMPENSATION);
1789
1790 pp = (UINT8 *)(p + 1);
1791
1792 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_WRITE_RF_PATH_COMPENSATION;
1793 p->offset = 0;
1794
1795 UINT16_TO_STREAM(pp, HCI_BLE_WR_RF_PATH_COMPENSATION);
1796 UINT8_TO_STREAM(pp, HCIC_PARAM_SIZE_WRITE_RF_PATH_COMPENSATION);
1797
1798 UINT16_TO_STREAM(pp, rf_tx_path);
1799 UINT16_TO_STREAM(pp, rf_tx_path);
1800
1801 return btu_hcif_send_cmd_sync(LOCAL_BR_EDR_CONTROLLER_ID, p);
1802 }
1803 #endif // #if (BLE_50_FEATURE_SUPPORT == TRUE)
1804
1805 #if (BLE_FEAT_PERIODIC_ADV_SYNC_TRANSFER == TRUE)
btsnd_hcic_ble_set_periodic_adv_recv_enable(UINT16 sync_handle,UINT8 enable)1806 UINT8 btsnd_hcic_ble_set_periodic_adv_recv_enable(UINT16 sync_handle, UINT8 enable)
1807 {
1808 BT_HDR *p;
1809 UINT8 *pp;
1810
1811 HCIC_BLE_CMD_CREATED(p, pp, HCIC_PARAM_SIZE_PERIODIC_ADV_RECV_ENABLE);
1812
1813 pp = (UINT8 *)(p + 1);
1814
1815 UINT16_TO_STREAM(pp, HCI_BLE_SET_PERIOD_ADV_RECV_ENABLE);
1816 UINT8_TO_STREAM(pp, HCIC_PARAM_SIZE_PERIODIC_ADV_RECV_ENABLE);
1817
1818 UINT16_TO_STREAM(pp, sync_handle);
1819 UINT8_TO_STREAM(pp, enable);
1820
1821 return btu_hcif_send_cmd_sync(LOCAL_BR_EDR_CONTROLLER_ID, p);
1822 }
1823
btsnd_hcic_ble_periodic_adv_sync_trans(UINT16 conn_handle,UINT16 service_data,UINT16 sync_handle)1824 BOOLEAN btsnd_hcic_ble_periodic_adv_sync_trans(UINT16 conn_handle, UINT16 service_data, UINT16 sync_handle)
1825 {
1826 BT_HDR *p;
1827 UINT8 *pp;
1828
1829 HCIC_BLE_CMD_CREATED(p, pp, HCIC_PARAM_SIZE_PERIODIC_ADV_SYNC_TRANS);
1830
1831 pp = (UINT8 *)(p + 1);
1832
1833 UINT16_TO_STREAM(pp, HCI_BLE_PERIOD_ADV_SYNC_TRANS);
1834 UINT8_TO_STREAM(pp, HCIC_PARAM_SIZE_PERIODIC_ADV_SYNC_TRANS);
1835
1836 UINT16_TO_STREAM(pp, conn_handle);
1837 UINT16_TO_STREAM(pp, service_data);
1838 UINT16_TO_STREAM(pp, sync_handle);
1839
1840 btu_hcif_send_cmd(LOCAL_BR_EDR_CONTROLLER_ID, p);
1841 return TRUE;
1842 }
1843
btsnd_hcic_ble_periodic_adv_set_info_trans(UINT16 conn_handle,UINT16 service_data,UINT8 adv_handle)1844 BOOLEAN btsnd_hcic_ble_periodic_adv_set_info_trans(UINT16 conn_handle, UINT16 service_data, UINT8 adv_handle)
1845 {
1846 BT_HDR *p;
1847 UINT8 *pp;
1848
1849 HCI_TRACE_DEBUG("%s conn handle %x, adv handle %x", __func__, conn_handle, adv_handle);
1850
1851 HCIC_BLE_CMD_CREATED(p, pp, HCIC_PARAM_SIZE_PERIODIC_ADV_SET_INFO_TRANS);
1852
1853 pp = (UINT8 *)(p + 1);
1854
1855 UINT16_TO_STREAM(pp, HCI_BLE_PERIOD_ADV_SET_INFO_TRANS);
1856 UINT8_TO_STREAM(pp, HCIC_PARAM_SIZE_PERIODIC_ADV_SET_INFO_TRANS);
1857
1858 UINT16_TO_STREAM(pp, conn_handle);
1859 UINT16_TO_STREAM(pp, service_data);
1860 UINT8_TO_STREAM(pp, adv_handle);
1861
1862 btu_hcif_send_cmd(LOCAL_BR_EDR_CONTROLLER_ID, p);
1863 return TRUE;
1864 }
1865
btsnd_hcic_ble_set_periodic_adv_sync_trans_params(UINT16 conn_handle,UINT8 mode,UINT16 skip,UINT16 sync_timeout,UINT8 cte_type)1866 BOOLEAN btsnd_hcic_ble_set_periodic_adv_sync_trans_params(UINT16 conn_handle, UINT8 mode, UINT16 skip, UINT16 sync_timeout, UINT8 cte_type)
1867 {
1868 BT_HDR *p;
1869 UINT8 *pp;
1870
1871 HCI_TRACE_DEBUG("%s conn handle %x, mode %x, sync timeout %x", __func__, conn_handle, mode, sync_timeout);
1872
1873 HCIC_BLE_CMD_CREATED(p, pp, HCIC_PARAM_SIZE_SET_PAST_PARAMS);
1874
1875 pp = (UINT8 *)(p + 1);
1876
1877 UINT16_TO_STREAM(pp, HCI_BLE_SET_PAST_PARAMS);
1878 UINT8_TO_STREAM(pp, HCIC_PARAM_SIZE_SET_PAST_PARAMS);
1879
1880 UINT16_TO_STREAM(pp, conn_handle);
1881 UINT8_TO_STREAM(pp, mode);
1882 UINT16_TO_STREAM(pp, skip);
1883 UINT16_TO_STREAM(pp, sync_timeout);
1884 UINT8_TO_STREAM(pp, cte_type);
1885
1886 btu_hcif_send_cmd(LOCAL_BR_EDR_CONTROLLER_ID, p);
1887 return TRUE;
1888 }
1889
btsnd_hcic_ble_set_default_periodic_adv_sync_trans_params(UINT8 mode,UINT16 skip,UINT16 sync_timeout,UINT8 cte_type)1890 UINT8 btsnd_hcic_ble_set_default_periodic_adv_sync_trans_params(UINT8 mode, UINT16 skip, UINT16 sync_timeout, UINT8 cte_type)
1891 {
1892 BT_HDR *p;
1893 UINT8 *pp;
1894
1895 HCI_TRACE_DEBUG("%s mode %x, skip %x, sync timeout %x", __func__, mode, skip, sync_timeout);
1896
1897 HCIC_BLE_CMD_CREATED(p, pp, HCIC_PARAM_SIZE_SET_DEFAULT_PAST_PARAMS);
1898
1899 pp = (UINT8 *)(p + 1);
1900
1901 UINT16_TO_STREAM(pp, HCI_BLE_SET_DEFAULT_PAST_PARAMS);
1902 UINT8_TO_STREAM(pp, HCIC_PARAM_SIZE_SET_DEFAULT_PAST_PARAMS);
1903
1904 UINT8_TO_STREAM(pp, mode);
1905 UINT16_TO_STREAM(pp, skip);
1906 UINT16_TO_STREAM(pp, sync_timeout);
1907 UINT8_TO_STREAM(pp, cte_type);
1908
1909 return btu_hcif_send_cmd_sync(LOCAL_BR_EDR_CONTROLLER_ID, p);
1910 }
1911 #endif // #if (BLE_FEAT_PERIODIC_ADV_SYNC_TRANSFER == TRUE)
1912
btsnd_hcic_ble_set_privacy_mode(UINT8 addr_type,BD_ADDR addr,UINT8 privacy_mode)1913 BOOLEAN btsnd_hcic_ble_set_privacy_mode(UINT8 addr_type, BD_ADDR addr, UINT8 privacy_mode)
1914 {
1915 BT_HDR *p;
1916 UINT8 *pp;
1917
1918 if ((p = HCI_GET_CMD_BUF (HCIC_PARAM_SIZE_SET_PRIVACY_MODE)) == NULL) {
1919 return (FALSE);
1920 }
1921
1922 pp = (UINT8 *)(p + 1);
1923 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_SET_PRIVACY_MODE;
1924 p->offset = 0;
1925
1926 UINT16_TO_STREAM(pp, HCI_BLE_SET_PRIVACY_MODE);
1927 UINT8_TO_STREAM(pp, HCIC_PARAM_SIZE_SET_PRIVACY_MODE);
1928
1929 UINT8_TO_STREAM(pp, addr_type);
1930 BDADDR_TO_STREAM(pp, addr);
1931 UINT8_TO_STREAM(pp, privacy_mode);
1932
1933 btu_hcif_send_cmd(LOCAL_BR_EDR_CONTROLLER_ID, p);
1934 return (TRUE);
1935 }
1936
btsnd_hcic_ble_set_csa_support(UINT8 csa_select)1937 BOOLEAN btsnd_hcic_ble_set_csa_support (UINT8 csa_select)
1938 {
1939 BT_HDR *p;
1940 UINT8 *pp;
1941
1942 if ((p = HCI_GET_CMD_BUF (HCIC_PARAM_SIZE_BLE_SET_CSA_SUPPORT)) == NULL) {
1943 return (FALSE);
1944 }
1945
1946 pp = (UINT8 *)(p + 1);
1947
1948 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_BLE_SET_CSA_SUPPORT;
1949 p->offset = 0;
1950
1951 UINT16_TO_STREAM (pp, HCI_VENDOR_BLE_SET_CSA_SUPPORT);
1952 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_BLE_SET_CSA_SUPPORT);
1953 UINT8_TO_STREAM (pp, csa_select);
1954
1955 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1956 return TRUE;
1957 }
1958 #endif
1959
