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