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 "bt_target.h"
27 #include "gki.h"
28 #include "hcidefs.h"
29 #include "hcimsgs.h"
30 #include "hcidefs.h"
31 #include "btu.h"
32
33 #include <stddef.h>
34 #include <string.h>
35
36 #if defined (LMP_TEST)
37 #include <script.h>
38 #define btu_hcif_send_cmd(p1, p2) HCI_CMD_TO_LOWER((p2))
39 #else
40 #include "btm_int.h" /* Included for UIPC_* macro definitions */
41 #endif
42
btsnd_hcic_inquiry(const LAP inq_lap,UINT8 duration,UINT8 response_cnt)43 BOOLEAN btsnd_hcic_inquiry(const LAP inq_lap, UINT8 duration, UINT8 response_cnt)
44 {
45 BT_HDR *p;
46 UINT8 *pp;
47
48 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_INQUIRY)) == NULL)
49 return (FALSE);
50
51 pp = (UINT8 *)(p + 1);
52
53 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_INQUIRY;
54 p->offset = 0;
55
56 UINT16_TO_STREAM (pp, HCI_INQUIRY);
57 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_INQUIRY);
58
59 LAP_TO_STREAM (pp, inq_lap);
60 UINT8_TO_STREAM (pp, duration);
61 UINT8_TO_STREAM (pp, response_cnt);
62
63 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
64 return (TRUE);
65 }
66
btsnd_hcic_inq_cancel(void)67 BOOLEAN btsnd_hcic_inq_cancel(void)
68 {
69 BT_HDR *p;
70 UINT8 *pp;
71
72 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_INQ_CANCEL)) == NULL)
73 return (FALSE);
74
75 pp = (UINT8 *)(p + 1);
76
77 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_INQ_CANCEL;
78 p->offset = 0;
79 UINT16_TO_STREAM (pp, HCI_INQUIRY_CANCEL);
80 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_INQ_CANCEL);
81
82 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
83 return (TRUE);
84 }
85
btsnd_hcic_per_inq_mode(UINT16 max_period,UINT16 min_period,const LAP inq_lap,UINT8 duration,UINT8 response_cnt)86 BOOLEAN btsnd_hcic_per_inq_mode (UINT16 max_period, UINT16 min_period,
87 const LAP inq_lap, UINT8 duration, UINT8 response_cnt)
88 {
89 BT_HDR *p;
90 UINT8 *pp;
91
92 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_PER_INQ_MODE)) == NULL)
93 return (FALSE);
94
95 pp = (UINT8 *)(p + 1);
96
97 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_PER_INQ_MODE;
98 p->offset = 0;
99
100 UINT16_TO_STREAM (pp, HCI_PERIODIC_INQUIRY_MODE);
101 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_PER_INQ_MODE);
102
103 UINT16_TO_STREAM (pp, max_period);
104 UINT16_TO_STREAM (pp, min_period);
105 LAP_TO_STREAM (pp, inq_lap);
106 UINT8_TO_STREAM (pp, duration);
107 UINT8_TO_STREAM (pp, response_cnt);
108
109 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
110 return (TRUE);
111 }
112
btsnd_hcic_exit_per_inq(void)113 BOOLEAN btsnd_hcic_exit_per_inq (void)
114 {
115 BT_HDR *p;
116 UINT8 *pp;
117
118 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_EXIT_PER_INQ)) == NULL)
119 return (FALSE);
120
121 pp = (UINT8 *)(p + 1);
122
123 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_EXIT_PER_INQ;
124 p->offset = 0;
125 UINT16_TO_STREAM (pp, HCI_EXIT_PERIODIC_INQUIRY_MODE);
126 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_EXIT_PER_INQ);
127
128 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
129 return (TRUE);
130 }
131
132
btsnd_hcic_create_conn(BD_ADDR dest,UINT16 packet_types,UINT8 page_scan_rep_mode,UINT8 page_scan_mode,UINT16 clock_offset,UINT8 allow_switch)133 BOOLEAN btsnd_hcic_create_conn(BD_ADDR dest, UINT16 packet_types,
134 UINT8 page_scan_rep_mode, UINT8 page_scan_mode,
135 UINT16 clock_offset, UINT8 allow_switch)
136 {
137 BT_HDR *p;
138 UINT8 *pp;
139
140 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_CREATE_CONN)) == NULL)
141 return (FALSE);
142
143 pp = (UINT8 *)(p + 1);
144
145 #ifndef BT_10A
146 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_CREATE_CONN;
147 #else
148 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_CREATE_CONN - 1;
149 #endif
150 p->offset = 0;
151
152 UINT16_TO_STREAM (pp, HCI_CREATE_CONNECTION);
153 #ifndef BT_10A
154 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_CREATE_CONN);
155 #else
156 UINT8_TO_STREAM (pp, (HCIC_PARAM_SIZE_CREATE_CONN - 1));
157 #endif
158 BDADDR_TO_STREAM (pp, dest);
159 UINT16_TO_STREAM (pp, packet_types);
160 UINT8_TO_STREAM (pp, page_scan_rep_mode);
161 UINT8_TO_STREAM (pp, page_scan_mode);
162 UINT16_TO_STREAM (pp, clock_offset);
163 #if !defined (BT_10A)
164 UINT8_TO_STREAM (pp, allow_switch);
165 #endif
166 /* If calling from LMP_TEST or ScriptEngine, then send HCI command immediately */
167 #if (!defined (LMP_TEST) && !defined(BTISE))
168 btm_acl_paging (p, dest);
169 #else
170 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
171 #endif
172 return (TRUE);
173 }
174
btsnd_hcic_disconnect(UINT16 handle,UINT8 reason)175 BOOLEAN btsnd_hcic_disconnect (UINT16 handle, UINT8 reason)
176 {
177 BT_HDR *p;
178 UINT8 *pp;
179
180 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_DISCONNECT)) == NULL)
181 return (FALSE);
182
183 pp = (UINT8 *)(p + 1);
184
185 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_DISCONNECT;
186 p->offset = 0;
187
188 UINT16_TO_STREAM (pp, HCI_DISCONNECT);
189 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_DISCONNECT);
190 UINT16_TO_STREAM (pp, handle);
191 UINT8_TO_STREAM (pp, reason);
192
193 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
194 /* If calling from LMP_TEST or ScriptEngine, then send HCI command immediately */
195 #if (!defined (LMP_TEST) && !defined(BTISE))
196 // btla-specific ++
197 // btm_acl_set_discing(TRUE);
198 // btla-specific --
199 #endif
200 return (TRUE);
201 }
202
203 #if BTM_SCO_INCLUDED == TRUE
btsnd_hcic_add_SCO_conn(UINT16 handle,UINT16 packet_types)204 BOOLEAN btsnd_hcic_add_SCO_conn (UINT16 handle, UINT16 packet_types)
205 {
206 BT_HDR *p;
207 UINT8 *pp;
208
209 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_ADD_SCO_CONN)) == NULL)
210 return (FALSE);
211
212 pp = (UINT8 *)(p + 1);
213
214 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_ADD_SCO_CONN;
215 p->offset = 0;
216
217 UINT16_TO_STREAM (pp, HCI_ADD_SCO_CONNECTION);
218 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_ADD_SCO_CONN);
219
220 UINT16_TO_STREAM (pp, handle);
221 UINT16_TO_STREAM (pp, packet_types);
222
223 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
224 return (TRUE);
225 }
226 #endif /* BTM_SCO_INCLUDED */
227
btsnd_hcic_create_conn_cancel(BD_ADDR dest)228 BOOLEAN btsnd_hcic_create_conn_cancel(BD_ADDR dest)
229 {
230 BT_HDR *p;
231 UINT8 *pp;
232
233 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_CREATE_CONN_CANCEL)) == NULL)
234 return (FALSE);
235
236 pp = (UINT8 *)(p + 1);
237
238 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_CREATE_CONN_CANCEL;
239 p->offset = 0;
240
241 UINT16_TO_STREAM (pp, HCI_CREATE_CONNECTION_CANCEL);
242 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_CREATE_CONN_CANCEL);
243
244 BDADDR_TO_STREAM (pp, dest);
245
246 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
247 return (TRUE);
248 }
249
btsnd_hcic_accept_conn(BD_ADDR dest,UINT8 role)250 BOOLEAN btsnd_hcic_accept_conn (BD_ADDR dest, UINT8 role)
251 {
252 BT_HDR *p;
253 UINT8 *pp;
254
255 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_ACCEPT_CONN)) == NULL)
256 return (FALSE);
257
258 pp = (UINT8 *)(p + 1);
259
260 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_ACCEPT_CONN;
261 p->offset = 0;
262
263 UINT16_TO_STREAM (pp, HCI_ACCEPT_CONNECTION_REQUEST);
264 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_ACCEPT_CONN);
265 BDADDR_TO_STREAM (pp, dest);
266 UINT8_TO_STREAM (pp, role);
267
268 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
269 return (TRUE);
270 }
271
btsnd_hcic_reject_conn(BD_ADDR dest,UINT8 reason)272 BOOLEAN btsnd_hcic_reject_conn (BD_ADDR dest, UINT8 reason)
273 {
274 BT_HDR *p;
275 UINT8 *pp;
276
277 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_REJECT_CONN)) == NULL)
278 return (FALSE);
279
280 pp = (UINT8 *)(p + 1);
281
282 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_REJECT_CONN;
283 p->offset = 0;
284
285 UINT16_TO_STREAM (pp, HCI_REJECT_CONNECTION_REQUEST);
286 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_REJECT_CONN);
287
288 BDADDR_TO_STREAM (pp, dest);
289 UINT8_TO_STREAM (pp, reason);
290
291 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
292 return (TRUE);
293 }
294
btsnd_hcic_link_key_req_reply(BD_ADDR bd_addr,LINK_KEY link_key)295 BOOLEAN btsnd_hcic_link_key_req_reply (BD_ADDR bd_addr, LINK_KEY link_key)
296 {
297 BT_HDR *p;
298 UINT8 *pp;
299
300 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_LINK_KEY_REQ_REPLY)) == NULL)
301 return (FALSE);
302
303 pp = (UINT8 *)(p + 1);
304
305 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_LINK_KEY_REQ_REPLY;
306 p->offset = 0;
307
308 UINT16_TO_STREAM (pp, HCI_LINK_KEY_REQUEST_REPLY);
309 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_LINK_KEY_REQ_REPLY);
310
311 BDADDR_TO_STREAM (pp, bd_addr);
312 ARRAY16_TO_STREAM (pp, link_key);
313
314 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
315 return (TRUE);
316 }
317
btsnd_hcic_link_key_neg_reply(BD_ADDR bd_addr)318 BOOLEAN btsnd_hcic_link_key_neg_reply (BD_ADDR bd_addr)
319 {
320 BT_HDR *p;
321 UINT8 *pp;
322
323 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_LINK_KEY_NEG_REPLY)) == NULL)
324 return (FALSE);
325
326 pp = (UINT8 *)(p + 1);
327
328 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_LINK_KEY_NEG_REPLY;
329 p->offset = 0;
330
331 UINT16_TO_STREAM (pp, HCI_LINK_KEY_REQUEST_NEG_REPLY);
332 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_LINK_KEY_NEG_REPLY);
333
334 BDADDR_TO_STREAM (pp, bd_addr);
335
336 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
337 return (TRUE);
338 }
339
btsnd_hcic_pin_code_req_reply(BD_ADDR bd_addr,UINT8 pin_code_len,PIN_CODE pin_code)340 BOOLEAN btsnd_hcic_pin_code_req_reply (BD_ADDR bd_addr, UINT8 pin_code_len,
341 PIN_CODE pin_code)
342 {
343 BT_HDR *p;
344 UINT8 *pp;
345 int i;
346
347 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_PIN_CODE_REQ_REPLY)) == NULL)
348 return (FALSE);
349
350 pp = (UINT8 *)(p + 1);
351
352 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_PIN_CODE_REQ_REPLY;
353 p->offset = 0;
354
355 UINT16_TO_STREAM (pp, HCI_PIN_CODE_REQUEST_REPLY);
356 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_PIN_CODE_REQ_REPLY);
357
358 BDADDR_TO_STREAM (pp, bd_addr);
359 UINT8_TO_STREAM (pp, pin_code_len);
360
361 for (i = 0; i < pin_code_len; i++)
362 *pp++ = *pin_code++;
363
364 for (; i < PIN_CODE_LEN; i++)
365 *pp++ = 0;
366
367
368 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
369 return (TRUE);
370 }
371
btsnd_hcic_pin_code_neg_reply(BD_ADDR bd_addr)372 BOOLEAN btsnd_hcic_pin_code_neg_reply (BD_ADDR bd_addr)
373 {
374 BT_HDR *p;
375 UINT8 *pp;
376
377 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_PIN_CODE_NEG_REPLY)) == NULL)
378 return (FALSE);
379
380 pp = (UINT8 *)(p + 1);
381
382 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_PIN_CODE_NEG_REPLY;
383 p->offset = 0;
384
385 UINT16_TO_STREAM (pp, HCI_PIN_CODE_REQUEST_NEG_REPLY);
386 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_PIN_CODE_NEG_REPLY);
387
388 BDADDR_TO_STREAM (pp, bd_addr);
389
390 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
391 return (TRUE);
392 }
393
btsnd_hcic_change_conn_type(UINT16 handle,UINT16 packet_types)394 BOOLEAN btsnd_hcic_change_conn_type (UINT16 handle, UINT16 packet_types)
395 {
396 BT_HDR *p;
397 UINT8 *pp;
398
399 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_CHANGE_CONN_TYPE)) == NULL)
400 return (FALSE);
401
402 pp = (UINT8 *)(p + 1);
403
404 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_CHANGE_CONN_TYPE;
405 p->offset = 0;
406
407 UINT16_TO_STREAM (pp, HCI_CHANGE_CONN_PACKET_TYPE);
408 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_CHANGE_CONN_TYPE);
409
410 UINT16_TO_STREAM (pp, handle);
411 UINT16_TO_STREAM (pp, packet_types);
412
413 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
414 return (TRUE);
415 }
416
btsnd_hcic_auth_request(UINT16 handle)417 BOOLEAN btsnd_hcic_auth_request (UINT16 handle)
418 {
419 BT_HDR *p;
420 UINT8 *pp;
421
422 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_CMD_HANDLE)) == NULL)
423 return (FALSE);
424
425 pp = (UINT8 *)(p + 1);
426
427 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_CMD_HANDLE;
428 p->offset = 0;
429
430 UINT16_TO_STREAM (pp, HCI_AUTHENTICATION_REQUESTED);
431 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_CMD_HANDLE);
432
433 UINT16_TO_STREAM (pp, handle);
434
435 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
436 return (TRUE);
437 }
438
btsnd_hcic_set_conn_encrypt(UINT16 handle,BOOLEAN enable)439 BOOLEAN btsnd_hcic_set_conn_encrypt (UINT16 handle, BOOLEAN enable)
440 {
441 BT_HDR *p;
442 UINT8 *pp;
443
444 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_SET_CONN_ENCRYPT)) == NULL)
445 return (FALSE);
446
447 pp = (UINT8 *)(p + 1);
448
449 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_SET_CONN_ENCRYPT;
450 p->offset = 0;
451
452 UINT16_TO_STREAM (pp, HCI_SET_CONN_ENCRYPTION);
453 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_SET_CONN_ENCRYPT);
454
455 UINT16_TO_STREAM (pp, handle);
456 UINT8_TO_STREAM (pp, enable);
457
458 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
459 return (TRUE);
460 }
461
btsnd_hcic_change_link_key(UINT16 handle)462 BOOLEAN btsnd_hcic_change_link_key (UINT16 handle)
463 {
464 BT_HDR *p;
465 UINT8 *pp;
466
467 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_CMD_HANDLE)) == NULL)
468 return (FALSE);
469
470 pp = (UINT8 *)(p + 1);
471
472 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_CMD_HANDLE;
473 p->offset = 0;
474
475 UINT16_TO_STREAM (pp, HCI_CHANGE_CONN_LINK_KEY);
476 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_CMD_HANDLE);
477
478 UINT16_TO_STREAM (pp, handle);
479
480 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
481 return (TRUE);
482 }
483
btsnd_hcic_master_link_key(BOOLEAN key_flag)484 BOOLEAN btsnd_hcic_master_link_key (BOOLEAN key_flag)
485 {
486 BT_HDR *p;
487 UINT8 *pp;
488
489 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_MASTER_LINK_KEY)) == NULL)
490 return (FALSE);
491
492 pp = (UINT8 *)(p + 1);
493
494 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_MASTER_LINK_KEY;
495 p->offset = 0;
496
497 UINT16_TO_STREAM (pp, HCI_MASTER_LINK_KEY);
498 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_MASTER_LINK_KEY);
499
500 UINT8_TO_STREAM (pp, key_flag);
501
502 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
503 return (TRUE);
504 }
505
btsnd_hcic_rmt_name_req(BD_ADDR bd_addr,UINT8 page_scan_rep_mode,UINT8 page_scan_mode,UINT16 clock_offset)506 BOOLEAN btsnd_hcic_rmt_name_req (BD_ADDR bd_addr, UINT8 page_scan_rep_mode,
507 UINT8 page_scan_mode, UINT16 clock_offset)
508 {
509 BT_HDR *p;
510 UINT8 *pp;
511
512 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_RMT_NAME_REQ)) == NULL)
513 return (FALSE);
514
515 pp = (UINT8 *)(p + 1);
516
517 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_RMT_NAME_REQ;
518 p->offset = 0;
519
520 UINT16_TO_STREAM (pp, HCI_RMT_NAME_REQUEST);
521 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_RMT_NAME_REQ);
522
523 BDADDR_TO_STREAM (pp, bd_addr);
524 UINT8_TO_STREAM (pp, page_scan_rep_mode);
525 UINT8_TO_STREAM (pp, page_scan_mode);
526 UINT16_TO_STREAM (pp, clock_offset);
527
528 /* If calling from LMP_TEST or ScriptEngine, then send HCI command immediately */
529 #if (!defined (LMP_TEST) && !defined(BTISE))
530 btm_acl_paging (p, bd_addr);
531 #else
532 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
533 #endif
534 return (TRUE);
535 }
536
btsnd_hcic_rmt_name_req_cancel(BD_ADDR bd_addr)537 BOOLEAN btsnd_hcic_rmt_name_req_cancel (BD_ADDR bd_addr)
538 {
539 BT_HDR *p;
540 UINT8 *pp;
541
542 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_RMT_NAME_REQ_CANCEL)) == NULL)
543 return (FALSE);
544
545 pp = (UINT8 *)(p + 1);
546
547 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_RMT_NAME_REQ_CANCEL;
548 p->offset = 0;
549
550 UINT16_TO_STREAM (pp, HCI_RMT_NAME_REQUEST_CANCEL);
551 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_RMT_NAME_REQ_CANCEL);
552
553 BDADDR_TO_STREAM (pp, bd_addr);
554
555 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
556 return (TRUE);
557 }
558
btsnd_hcic_rmt_features_req(UINT16 handle)559 BOOLEAN btsnd_hcic_rmt_features_req (UINT16 handle)
560 {
561 BT_HDR *p;
562 UINT8 *pp;
563
564 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_CMD_HANDLE)) == NULL)
565 return (FALSE);
566
567 pp = (UINT8 *)(p + 1);
568
569 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_CMD_HANDLE;
570 p->offset = 0;
571
572 UINT16_TO_STREAM (pp, HCI_READ_RMT_FEATURES);
573 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_CMD_HANDLE);
574
575 UINT16_TO_STREAM (pp, handle);
576
577 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
578 return (TRUE);
579 }
580
btsnd_hcic_rmt_ext_features(UINT16 handle,UINT8 page_num)581 BOOLEAN btsnd_hcic_rmt_ext_features (UINT16 handle, UINT8 page_num)
582 {
583 BT_HDR *p;
584 UINT8 *pp;
585
586 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_RMT_EXT_FEATURES)) == NULL)
587 return (FALSE);
588
589 pp = (UINT8 *)(p + 1);
590
591 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_RMT_EXT_FEATURES;
592 p->offset = 0;
593
594 UINT16_TO_STREAM (pp, HCI_READ_RMT_EXT_FEATURES);
595 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_RMT_EXT_FEATURES);
596
597 UINT16_TO_STREAM (pp, handle);
598 UINT8_TO_STREAM (pp, page_num);
599
600 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
601 return (TRUE);
602 }
603
btsnd_hcic_rmt_ver_req(UINT16 handle)604 BOOLEAN btsnd_hcic_rmt_ver_req (UINT16 handle)
605 {
606 BT_HDR *p;
607 UINT8 *pp;
608
609 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_CMD_HANDLE)) == NULL)
610 return (FALSE);
611
612 pp = (UINT8 *)(p + 1);
613
614 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_CMD_HANDLE;
615 p->offset = 0;
616
617 UINT16_TO_STREAM (pp, HCI_READ_RMT_VERSION_INFO);
618 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_CMD_HANDLE);
619
620 UINT16_TO_STREAM (pp, handle);
621
622 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
623 return (TRUE);
624 }
625
btsnd_hcic_read_rmt_clk_offset(UINT16 handle)626 BOOLEAN btsnd_hcic_read_rmt_clk_offset (UINT16 handle)
627 {
628 BT_HDR *p;
629 UINT8 *pp;
630
631 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_CMD_HANDLE)) == NULL)
632 return (FALSE);
633
634 pp = (UINT8 *)(p + 1);
635
636 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_CMD_HANDLE;
637 p->offset = 0;
638
639 UINT16_TO_STREAM (pp, HCI_READ_RMT_CLOCK_OFFSET);
640 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_CMD_HANDLE);
641
642 UINT16_TO_STREAM (pp, handle);
643
644 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
645 return (TRUE);
646 }
647
btsnd_hcic_read_lmp_handle(UINT16 handle)648 BOOLEAN btsnd_hcic_read_lmp_handle (UINT16 handle)
649 {
650 BT_HDR *p;
651 UINT8 *pp;
652
653 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_CMD_HANDLE)) == NULL)
654 return (FALSE);
655
656 pp = (UINT8 *)(p + 1);
657
658 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_CMD_HANDLE;
659 p->offset = 0;
660
661 UINT16_TO_STREAM (pp, HCI_READ_LMP_HANDLE);
662 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_CMD_HANDLE);
663
664 UINT16_TO_STREAM (pp, handle);
665
666 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
667 return (TRUE);
668 }
669
btsnd_hcic_setup_esco_conn(UINT16 handle,UINT32 tx_bw,UINT32 rx_bw,UINT16 max_latency,UINT16 voice,UINT8 retrans_effort,UINT16 packet_types)670 BOOLEAN btsnd_hcic_setup_esco_conn (UINT16 handle, UINT32 tx_bw,
671 UINT32 rx_bw, UINT16 max_latency, UINT16 voice,
672 UINT8 retrans_effort, UINT16 packet_types)
673 {
674 BT_HDR *p;
675 UINT8 *pp;
676
677 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_SETUP_ESCO)) == NULL)
678 return (FALSE);
679
680 pp = (UINT8 *)(p + 1);
681
682 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_SETUP_ESCO;
683 p->offset = 0;
684
685 UINT16_TO_STREAM (pp, HCI_SETUP_ESCO_CONNECTION);
686 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_SETUP_ESCO);
687
688 UINT16_TO_STREAM (pp, handle);
689 UINT32_TO_STREAM (pp, tx_bw);
690 UINT32_TO_STREAM (pp, rx_bw);
691 UINT16_TO_STREAM (pp, max_latency);
692 UINT16_TO_STREAM (pp, voice);
693 UINT8_TO_STREAM (pp, retrans_effort);
694 UINT16_TO_STREAM (pp, packet_types);
695
696 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
697 return (TRUE);
698 }
699
btsnd_hcic_accept_esco_conn(BD_ADDR bd_addr,UINT32 tx_bw,UINT32 rx_bw,UINT16 max_latency,UINT16 content_fmt,UINT8 retrans_effort,UINT16 packet_types)700 BOOLEAN btsnd_hcic_accept_esco_conn (BD_ADDR bd_addr, UINT32 tx_bw,
701 UINT32 rx_bw, UINT16 max_latency,
702 UINT16 content_fmt, UINT8 retrans_effort,
703 UINT16 packet_types)
704 {
705 BT_HDR *p;
706 UINT8 *pp;
707
708 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_ACCEPT_ESCO)) == NULL)
709 return (FALSE);
710
711 pp = (UINT8 *)(p + 1);
712
713 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_ACCEPT_ESCO;
714 p->offset = 0;
715
716 UINT16_TO_STREAM (pp, HCI_ACCEPT_ESCO_CONNECTION);
717 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_ACCEPT_ESCO);
718
719 BDADDR_TO_STREAM (pp, bd_addr);
720 UINT32_TO_STREAM (pp, tx_bw);
721 UINT32_TO_STREAM (pp, rx_bw);
722 UINT16_TO_STREAM (pp, max_latency);
723 UINT16_TO_STREAM (pp, content_fmt);
724 UINT8_TO_STREAM (pp, retrans_effort);
725 UINT16_TO_STREAM (pp, packet_types);
726
727 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
728 return (TRUE);
729 }
730
btsnd_hcic_reject_esco_conn(BD_ADDR bd_addr,UINT8 reason)731 BOOLEAN btsnd_hcic_reject_esco_conn (BD_ADDR bd_addr, UINT8 reason)
732 {
733 BT_HDR *p;
734 UINT8 *pp;
735
736 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_REJECT_ESCO)) == NULL)
737 return (FALSE);
738
739 pp = (UINT8 *)(p + 1);
740
741 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_REJECT_ESCO;
742 p->offset = 0;
743
744 UINT16_TO_STREAM (pp, HCI_REJECT_ESCO_CONNECTION);
745 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_REJECT_ESCO);
746
747 BDADDR_TO_STREAM (pp, bd_addr);
748 UINT8_TO_STREAM (pp, reason);
749
750 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
751 return (TRUE);
752 }
753
btsnd_hcic_hold_mode(UINT16 handle,UINT16 max_hold_period,UINT16 min_hold_period)754 BOOLEAN btsnd_hcic_hold_mode (UINT16 handle, UINT16 max_hold_period,
755 UINT16 min_hold_period)
756 {
757 BT_HDR *p;
758 UINT8 *pp;
759
760 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_HOLD_MODE)) == NULL)
761 return (FALSE);
762
763 pp = (UINT8 *)(p + 1);
764
765 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_HOLD_MODE;
766 p->offset = 0;
767
768 UINT16_TO_STREAM (pp, HCI_HOLD_MODE);
769 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_HOLD_MODE);
770
771 UINT16_TO_STREAM (pp, handle);
772 UINT16_TO_STREAM (pp, max_hold_period);
773 UINT16_TO_STREAM (pp, min_hold_period);
774
775 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
776 return (TRUE);
777 }
778
btsnd_hcic_sniff_mode(UINT16 handle,UINT16 max_sniff_period,UINT16 min_sniff_period,UINT16 sniff_attempt,UINT16 sniff_timeout)779 BOOLEAN btsnd_hcic_sniff_mode (UINT16 handle, UINT16 max_sniff_period,
780 UINT16 min_sniff_period, UINT16 sniff_attempt,
781 UINT16 sniff_timeout)
782 {
783 BT_HDR *p;
784 UINT8 *pp;
785
786 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_SNIFF_MODE)) == NULL)
787 return (FALSE);
788
789 pp = (UINT8 *)(p + 1);
790
791 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_SNIFF_MODE;
792 p->offset = 0;
793
794 UINT16_TO_STREAM (pp, HCI_SNIFF_MODE);
795 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_SNIFF_MODE);
796
797 UINT16_TO_STREAM (pp, handle);
798 UINT16_TO_STREAM (pp, max_sniff_period);
799 UINT16_TO_STREAM (pp, min_sniff_period);
800 UINT16_TO_STREAM (pp, sniff_attempt);
801 UINT16_TO_STREAM (pp, sniff_timeout);
802
803 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
804 return (TRUE);
805 }
806
btsnd_hcic_exit_sniff_mode(UINT16 handle)807 BOOLEAN btsnd_hcic_exit_sniff_mode (UINT16 handle)
808 {
809 BT_HDR *p;
810 UINT8 *pp;
811
812 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_CMD_HANDLE)) == NULL)
813 return (FALSE);
814
815 pp = (UINT8 *)(p + 1);
816
817 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_CMD_HANDLE;
818 p->offset = 0;
819
820 UINT16_TO_STREAM (pp, HCI_EXIT_SNIFF_MODE);
821 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_CMD_HANDLE);
822
823 UINT16_TO_STREAM (pp, handle);
824
825 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
826 return TRUE;
827 }
828
btsnd_hcic_park_mode(UINT16 handle,UINT16 beacon_max_interval,UINT16 beacon_min_interval)829 BOOLEAN btsnd_hcic_park_mode (UINT16 handle, UINT16 beacon_max_interval,
830 UINT16 beacon_min_interval)
831 {
832 BT_HDR *p;
833 UINT8 *pp;
834
835 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_PARK_MODE)) == NULL)
836 return (FALSE);
837
838 pp = (UINT8 *)(p + 1);
839
840 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_PARK_MODE;
841 p->offset = 0;
842
843 UINT16_TO_STREAM (pp, HCI_PARK_MODE);
844 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_PARK_MODE);
845
846 UINT16_TO_STREAM (pp, handle);
847 UINT16_TO_STREAM (pp, beacon_max_interval);
848 UINT16_TO_STREAM (pp, beacon_min_interval);
849
850 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
851 return (TRUE);
852 }
853
btsnd_hcic_exit_park_mode(UINT16 handle)854 BOOLEAN btsnd_hcic_exit_park_mode (UINT16 handle)
855 {
856 BT_HDR *p;
857 UINT8 *pp;
858
859 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_CMD_HANDLE)) == NULL)
860 return (FALSE);
861
862 pp = (UINT8 *)(p + 1);
863
864 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_CMD_HANDLE;
865 p->offset = 0;
866
867 UINT16_TO_STREAM (pp, HCI_EXIT_PARK_MODE);
868 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_CMD_HANDLE);
869
870 UINT16_TO_STREAM (pp, handle);
871
872 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
873 return TRUE;
874 }
875
btsnd_hcic_qos_setup(UINT16 handle,UINT8 flags,UINT8 service_type,UINT32 token_rate,UINT32 peak,UINT32 latency,UINT32 delay_var)876 BOOLEAN btsnd_hcic_qos_setup (UINT16 handle, UINT8 flags, UINT8 service_type,
877 UINT32 token_rate, UINT32 peak, UINT32 latency,
878 UINT32 delay_var)
879 {
880 BT_HDR *p;
881 UINT8 *pp;
882
883 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_QOS_SETUP)) == NULL)
884 return (FALSE);
885
886 pp = (UINT8 *)(p + 1);
887
888 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_QOS_SETUP;
889 p->offset = 0;
890
891 UINT16_TO_STREAM (pp, HCI_QOS_SETUP);
892 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_QOS_SETUP);
893
894 UINT16_TO_STREAM (pp, handle);
895 UINT8_TO_STREAM (pp, flags);
896 UINT8_TO_STREAM (pp, service_type);
897 UINT32_TO_STREAM (pp, token_rate);
898 UINT32_TO_STREAM (pp, peak);
899 UINT32_TO_STREAM (pp, latency);
900 UINT32_TO_STREAM (pp, delay_var);
901
902 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
903 return (TRUE);
904 }
905
btsnd_hcic_role_discovery(UINT16 handle)906 BOOLEAN btsnd_hcic_role_discovery (UINT16 handle)
907 {
908 BT_HDR *p;
909 UINT8 *pp;
910
911 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_CMD_HANDLE)) == NULL)
912 return (FALSE);
913
914 pp = (UINT8 *)(p + 1);
915
916 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_CMD_HANDLE;
917 p->offset = 0;
918
919 UINT16_TO_STREAM (pp, HCI_ROLE_DISCOVERY);
920 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_CMD_HANDLE);
921
922 UINT16_TO_STREAM (pp, handle);
923
924 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
925 return (TRUE);
926 }
927
btsnd_hcic_switch_role(BD_ADDR bd_addr,UINT8 role)928 BOOLEAN btsnd_hcic_switch_role (BD_ADDR bd_addr, UINT8 role)
929 {
930 BT_HDR *p;
931 UINT8 *pp;
932
933 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_SWITCH_ROLE)) == NULL)
934 return (FALSE);
935
936 pp = (UINT8 *)(p + 1);
937
938 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_SWITCH_ROLE;
939 p->offset = 0;
940
941 UINT16_TO_STREAM (pp, HCI_SWITCH_ROLE);
942 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_SWITCH_ROLE);
943
944 BDADDR_TO_STREAM (pp, bd_addr);
945 UINT8_TO_STREAM (pp, role);
946
947 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
948 return (TRUE);
949 }
950
btsnd_hcic_read_policy_set(UINT16 handle)951 BOOLEAN btsnd_hcic_read_policy_set (UINT16 handle)
952 {
953 BT_HDR *p;
954 UINT8 *pp;
955
956 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_CMD_HANDLE)) == NULL)
957 return (FALSE);
958
959 pp = (UINT8 *)(p + 1);
960
961 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_CMD_HANDLE;
962 p->offset = 0;
963
964 UINT16_TO_STREAM (pp, HCI_READ_POLICY_SETTINGS);
965 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_CMD_HANDLE);
966
967 UINT16_TO_STREAM (pp, handle);
968
969 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
970 return (TRUE);
971 }
972
btsnd_hcic_write_policy_set(UINT16 handle,UINT16 settings)973 BOOLEAN btsnd_hcic_write_policy_set (UINT16 handle, UINT16 settings)
974 {
975 BT_HDR *p;
976 UINT8 *pp;
977
978 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_WRITE_POLICY_SET)) == NULL)
979 return (FALSE);
980
981 pp = (UINT8 *)(p + 1);
982
983 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_WRITE_POLICY_SET;
984 p->offset = 0;
985 UINT16_TO_STREAM (pp, HCI_WRITE_POLICY_SETTINGS);
986 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_WRITE_POLICY_SET);
987
988 UINT16_TO_STREAM (pp, handle);
989 UINT16_TO_STREAM (pp, settings);
990
991 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
992 return (TRUE);
993 }
994
btsnd_hcic_read_def_policy_set(void)995 BOOLEAN btsnd_hcic_read_def_policy_set (void)
996 {
997 BT_HDR *p;
998 UINT8 *pp;
999
1000 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_READ_DEF_POLICY_SET)) == NULL)
1001 return (FALSE);
1002
1003 pp = (UINT8 *)(p + 1);
1004
1005 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_READ_DEF_POLICY_SET;
1006 p->offset = 0;
1007
1008 UINT16_TO_STREAM (pp, HCI_READ_DEF_POLICY_SETTINGS);
1009 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_READ_DEF_POLICY_SET);
1010
1011 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1012 return (TRUE);
1013 }
1014
btsnd_hcic_write_def_policy_set(UINT16 settings)1015 BOOLEAN btsnd_hcic_write_def_policy_set (UINT16 settings)
1016 {
1017 BT_HDR *p;
1018 UINT8 *pp;
1019
1020 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_WRITE_DEF_POLICY_SET)) == NULL)
1021 return (FALSE);
1022
1023 pp = (UINT8 *)(p + 1);
1024
1025 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_WRITE_DEF_POLICY_SET;
1026 p->offset = 0;
1027 UINT16_TO_STREAM (pp, HCI_WRITE_DEF_POLICY_SETTINGS);
1028 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_WRITE_DEF_POLICY_SET);
1029
1030 UINT16_TO_STREAM (pp, settings);
1031
1032 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1033 return (TRUE);
1034 }
1035
btsnd_hcic_flow_specification(UINT16 handle,UINT8 flags,UINT8 flow_direct,UINT8 service_type,UINT32 token_rate,UINT32 token_bucket_size,UINT32 peak,UINT32 latency)1036 BOOLEAN btsnd_hcic_flow_specification(UINT16 handle, UINT8 flags, UINT8 flow_direct,
1037 UINT8 service_type, UINT32 token_rate,
1038 UINT32 token_bucket_size, UINT32 peak,
1039 UINT32 latency)
1040 {
1041 BT_HDR *p;
1042 UINT8 *pp;
1043
1044 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_FLOW_SPEC)) == NULL)
1045 return (FALSE);
1046
1047 pp = (UINT8 *)(p + 1);
1048
1049 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_FLOW_SPEC;
1050 p->offset = 0;
1051
1052 UINT16_TO_STREAM (pp, HCI_FLOW_SPECIFICATION);
1053 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_FLOW_SPEC);
1054
1055 UINT16_TO_STREAM (pp, handle);
1056 UINT8_TO_STREAM (pp, flags);
1057 UINT8_TO_STREAM (pp, flow_direct);
1058 UINT8_TO_STREAM (pp, service_type);
1059 UINT32_TO_STREAM (pp, token_rate);
1060 UINT32_TO_STREAM (pp, token_bucket_size);
1061 UINT32_TO_STREAM (pp, peak);
1062 UINT32_TO_STREAM (pp, latency);
1063
1064 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1065 return (TRUE);
1066 }
1067
btsnd_hcic_set_event_mask(UINT8 local_controller_id,BT_EVENT_MASK event_mask)1068 BOOLEAN btsnd_hcic_set_event_mask(UINT8 local_controller_id, BT_EVENT_MASK event_mask)
1069 {
1070 BT_HDR *p;
1071 UINT8 *pp;
1072
1073 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_SET_EVENT_MASK)) == NULL)
1074 return (FALSE);
1075
1076 pp = (UINT8 *)(p + 1);
1077
1078 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_SET_EVENT_MASK;
1079 p->offset = 0;
1080
1081 UINT16_TO_STREAM (pp, HCI_SET_EVENT_MASK);
1082 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_SET_EVENT_MASK);
1083 ARRAY8_TO_STREAM (pp, event_mask);
1084
1085 btu_hcif_send_cmd (local_controller_id, p);
1086 return (TRUE);
1087 }
1088
btsnd_hcic_set_event_mask_page_2(UINT8 local_controller_id,BT_EVENT_MASK event_mask)1089 BOOLEAN btsnd_hcic_set_event_mask_page_2 (UINT8 local_controller_id, BT_EVENT_MASK event_mask)
1090 {
1091 BT_HDR *p;
1092 UINT8 *pp;
1093
1094 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_SET_EVENT_MASK_PAGE_2)) == NULL)
1095 return (FALSE);
1096
1097 pp = (UINT8 *)(p + 1);
1098
1099 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_SET_EVENT_MASK_PAGE_2;
1100 p->offset = 0;
1101
1102 UINT16_TO_STREAM (pp, HCI_SET_EVENT_MASK_PAGE_2);
1103 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_SET_EVENT_MASK_PAGE_2);
1104 ARRAY8_TO_STREAM (pp, event_mask);
1105
1106 btu_hcif_send_cmd (local_controller_id, p);
1107 return (TRUE);
1108 }
1109
btsnd_hcic_reset(UINT8 local_controller_id)1110 BOOLEAN btsnd_hcic_reset (UINT8 local_controller_id)
1111 {
1112 BT_HDR *p;
1113 UINT8 *pp;
1114
1115 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_RESET)) == NULL)
1116 return (FALSE);
1117
1118 pp = (UINT8 *)(p + 1);
1119
1120 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_RESET;
1121 p->offset = 0;
1122
1123 UINT16_TO_STREAM (pp, HCI_RESET);
1124 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_RESET);
1125
1126 btu_hcif_send_cmd (local_controller_id, p);
1127 /* If calling from LMP_TEST or ScriptEngine, then send HCI command immediately */
1128 #if (!defined (LMP_TEST) && !defined(BTISE))
1129 if (local_controller_id == LOCAL_BR_EDR_CONTROLLER_ID)
1130 {
1131 btm_acl_reset_paging ();
1132 btm_acl_set_discing (FALSE);
1133 }
1134 #endif
1135 return (TRUE);
1136 }
1137
btsnd_hcic_set_event_filter(UINT8 filt_type,UINT8 filt_cond_type,UINT8 * filt_cond,UINT8 filt_cond_len)1138 BOOLEAN btsnd_hcic_set_event_filter (UINT8 filt_type, UINT8 filt_cond_type,
1139 UINT8 *filt_cond, UINT8 filt_cond_len)
1140 {
1141 BT_HDR *p;
1142 UINT8 *pp;
1143
1144 /* Use buffer large enough to hold all sizes in this command */
1145 if ((p = HCI_GET_CMD_BUF(2 + filt_cond_len)) == NULL)
1146 return (FALSE);
1147
1148 pp = (UINT8 *)(p + 1);
1149
1150 p->offset = 0;
1151
1152 UINT16_TO_STREAM (pp, HCI_SET_EVENT_FILTER);
1153
1154 if (filt_type)
1155 {
1156 p->len = (UINT16)(HCIC_PREAMBLE_SIZE + 2 + filt_cond_len);
1157 UINT8_TO_STREAM (pp, (UINT8)(2 + filt_cond_len));
1158
1159 UINT8_TO_STREAM (pp, filt_type);
1160 UINT8_TO_STREAM (pp, filt_cond_type);
1161
1162 if (filt_cond_type == HCI_FILTER_COND_DEVICE_CLASS)
1163 {
1164 DEVCLASS_TO_STREAM (pp, filt_cond);
1165 filt_cond += DEV_CLASS_LEN;
1166 DEVCLASS_TO_STREAM (pp, filt_cond);
1167 filt_cond += DEV_CLASS_LEN;
1168
1169 filt_cond_len -= (2 * DEV_CLASS_LEN);
1170 }
1171 else if (filt_cond_type == HCI_FILTER_COND_BD_ADDR)
1172 {
1173 BDADDR_TO_STREAM (pp, filt_cond);
1174 filt_cond += BD_ADDR_LEN;
1175
1176 filt_cond_len -= BD_ADDR_LEN;
1177 }
1178
1179 if (filt_cond_len)
1180 ARRAY_TO_STREAM (pp, filt_cond, filt_cond_len);
1181 }
1182 else
1183 {
1184 p->len = (UINT16)(HCIC_PREAMBLE_SIZE + 1);
1185 UINT8_TO_STREAM (pp, 1);
1186
1187 UINT8_TO_STREAM (pp, filt_type);
1188 }
1189
1190 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1191 return (TRUE);
1192 }
1193
btsnd_hcic_flush(UINT8 local_controller_id,UINT16 handle)1194 BOOLEAN btsnd_hcic_flush (UINT8 local_controller_id, UINT16 handle)
1195 {
1196 BT_HDR *p;
1197 UINT8 *pp;
1198
1199 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_CMD_HANDLE)) == NULL)
1200 return (FALSE);
1201
1202 pp = (UINT8 *)(p + 1);
1203
1204 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_CMD_HANDLE;
1205 p->offset = 0;
1206 UINT16_TO_STREAM (pp, HCI_FLUSH);
1207 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_CMD_HANDLE);
1208
1209 UINT16_TO_STREAM (pp, handle);
1210
1211 btu_hcif_send_cmd (local_controller_id, p);
1212 return (TRUE);
1213 }
1214
btsnd_hcic_read_pin_type(void)1215 BOOLEAN btsnd_hcic_read_pin_type (void)
1216 {
1217 BT_HDR *p;
1218 UINT8 *pp;
1219
1220 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_READ_CMD)) == NULL)
1221 return (FALSE);
1222
1223 pp = (UINT8 *)(p + 1);
1224
1225 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_READ_CMD;
1226 p->offset = 0;
1227
1228 UINT16_TO_STREAM (pp, HCI_READ_PIN_TYPE);
1229 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_READ_CMD);
1230
1231 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1232 return (TRUE);
1233 }
1234
btsnd_hcic_write_pin_type(UINT8 type)1235 BOOLEAN btsnd_hcic_write_pin_type (UINT8 type)
1236 {
1237 BT_HDR *p;
1238 UINT8 *pp;
1239
1240 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_WRITE_PARAM1)) == NULL)
1241 return (FALSE);
1242
1243 pp = (UINT8 *)(p + 1);
1244
1245 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_WRITE_PARAM1;
1246 p->offset = 0;
1247
1248 UINT16_TO_STREAM (pp, HCI_WRITE_PIN_TYPE);
1249 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_WRITE_PARAM1);
1250
1251 UINT8_TO_STREAM (pp, type);
1252
1253 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1254 return (TRUE);
1255 }
1256
btsnd_hcic_new_unit_key(void)1257 BOOLEAN btsnd_hcic_new_unit_key (void)
1258 {
1259 BT_HDR *p;
1260 UINT8 *pp;
1261
1262 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_NEW_UNIT_KEY)) == NULL)
1263 return (FALSE);
1264
1265 pp = (UINT8 *)(p + 1);
1266
1267 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_NEW_UNIT_KEY;
1268 p->offset = 0;
1269
1270 UINT16_TO_STREAM (pp, HCI_CREATE_NEW_UNIT_KEY);
1271 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_NEW_UNIT_KEY);
1272
1273 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1274 return (TRUE);
1275 }
1276
btsnd_hcic_read_stored_key(BD_ADDR bd_addr,BOOLEAN read_all_flag)1277 BOOLEAN btsnd_hcic_read_stored_key (BD_ADDR bd_addr, BOOLEAN read_all_flag)
1278 {
1279 BT_HDR *p;
1280 UINT8 *pp;
1281
1282 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_READ_STORED_KEY)) == NULL)
1283 return (FALSE);
1284
1285 pp = (UINT8 *)(p + 1);
1286
1287 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_READ_STORED_KEY;
1288 p->offset = 0;
1289
1290 UINT16_TO_STREAM (pp, HCI_READ_STORED_LINK_KEY);
1291 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_READ_STORED_KEY);
1292
1293 BDADDR_TO_STREAM (pp, bd_addr);
1294 UINT8_TO_STREAM (pp, read_all_flag);
1295
1296 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1297 return (TRUE);
1298 }
1299
btsnd_hcic_write_stored_key(UINT8 num_keys,BD_ADDR * bd_addr,LINK_KEY * link_key)1300 BOOLEAN btsnd_hcic_write_stored_key (UINT8 num_keys, BD_ADDR *bd_addr,
1301 LINK_KEY *link_key)
1302 {
1303 BT_HDR *p;
1304 UINT8 *pp;
1305 int j;
1306
1307 if ((p = HCI_GET_CMD_BUF(1 + (num_keys * (BD_ADDR_LEN + LINK_KEY_LEN)))) == NULL)
1308 return (FALSE);
1309
1310 pp = (UINT8 *)(p + 1);
1311
1312
1313 p->len = HCIC_PREAMBLE_SIZE + 1 + (num_keys * (BD_ADDR_LEN + LINK_KEY_LEN));
1314 p->offset = 0;
1315
1316 UINT16_TO_STREAM (pp, HCI_WRITE_STORED_LINK_KEY);
1317 UINT8_TO_STREAM (pp, p->len - HCIC_PREAMBLE_SIZE);
1318
1319 if(num_keys > HCI_MAX_NUM_OF_LINK_KEYS_PER_CMMD)
1320 num_keys = HCI_MAX_NUM_OF_LINK_KEYS_PER_CMMD;
1321
1322 UINT8_TO_STREAM (pp, num_keys);
1323
1324 for (j = 0; j < num_keys; j++)
1325 {
1326 BDADDR_TO_STREAM (pp, bd_addr[j]);
1327 ARRAY16_TO_STREAM (pp, link_key[j]);
1328 }
1329
1330 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1331 return (TRUE);
1332 }
1333
btsnd_hcic_delete_stored_key(BD_ADDR bd_addr,BOOLEAN delete_all_flag)1334 BOOLEAN btsnd_hcic_delete_stored_key (BD_ADDR bd_addr, BOOLEAN delete_all_flag)
1335 {
1336 BT_HDR *p;
1337 UINT8 *pp;
1338
1339 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_DELETE_STORED_KEY)) == NULL)
1340 return (FALSE);
1341
1342 pp = (UINT8 *)(p + 1);
1343
1344 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_DELETE_STORED_KEY;
1345 p->offset = 0;
1346
1347 UINT16_TO_STREAM (pp, HCI_DELETE_STORED_LINK_KEY);
1348 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_DELETE_STORED_KEY);
1349
1350 BDADDR_TO_STREAM (pp, bd_addr);
1351 UINT8_TO_STREAM (pp, delete_all_flag);
1352
1353 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1354 return (TRUE);
1355 }
1356
btsnd_hcic_change_name(BD_NAME name)1357 BOOLEAN btsnd_hcic_change_name (BD_NAME name)
1358 {
1359 BT_HDR *p;
1360 UINT8 *pp;
1361 UINT16 len = strlen ((char *)name) + 1;
1362
1363 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_CHANGE_NAME)) == NULL)
1364 return (FALSE);
1365
1366 pp = (UINT8 *)(p + 1);
1367 memset(pp, 0, HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_CHANGE_NAME);
1368
1369 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_CHANGE_NAME;
1370 p->offset = 0;
1371
1372 UINT16_TO_STREAM (pp, HCI_CHANGE_LOCAL_NAME);
1373 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_CHANGE_NAME);
1374
1375 if (len > HCIC_PARAM_SIZE_CHANGE_NAME)
1376 len = HCIC_PARAM_SIZE_CHANGE_NAME;
1377
1378 ARRAY_TO_STREAM (pp, name, len);
1379
1380 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1381 return (TRUE);
1382 }
1383
btsnd_hcic_read_name(void)1384 BOOLEAN btsnd_hcic_read_name (void)
1385 {
1386 BT_HDR *p;
1387 UINT8 *pp;
1388
1389 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_READ_CMD)) == NULL)
1390 return (FALSE);
1391
1392 pp = (UINT8 *)(p + 1);
1393
1394 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_READ_CMD;
1395 p->offset = 0;
1396
1397 UINT16_TO_STREAM (pp, HCI_READ_LOCAL_NAME);
1398 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_READ_CMD);
1399
1400 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1401 return (TRUE);
1402 }
1403
btsnd_hcic_read_conn_acc_tout(UINT8 local_controller_id)1404 BOOLEAN btsnd_hcic_read_conn_acc_tout (UINT8 local_controller_id)
1405 {
1406 BT_HDR *p;
1407 UINT8 *pp;
1408
1409 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_READ_CMD)) == NULL)
1410 return (FALSE);
1411
1412 pp = (UINT8 *)(p + 1);
1413
1414 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_READ_CMD;
1415 p->offset = 0;
1416
1417 UINT16_TO_STREAM (pp, HCI_READ_CONN_ACCEPT_TOUT);
1418 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_READ_CMD);
1419
1420 btu_hcif_send_cmd (local_controller_id, p);
1421 return (TRUE);
1422 }
1423
btsnd_hcic_write_conn_acc_tout(UINT8 local_controller_id,UINT16 timeout)1424 BOOLEAN btsnd_hcic_write_conn_acc_tout (UINT8 local_controller_id, UINT16 timeout)
1425 {
1426 BT_HDR *p;
1427 UINT8 *pp;
1428
1429 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_WRITE_PARAM2)) == NULL)
1430 return (FALSE);
1431
1432 pp = (UINT8 *)(p + 1);
1433
1434 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_WRITE_PARAM2;
1435 p->offset = 0;
1436
1437 UINT16_TO_STREAM (pp, HCI_WRITE_CONN_ACCEPT_TOUT);
1438 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_WRITE_PARAM2);
1439
1440 UINT16_TO_STREAM (pp, timeout);
1441
1442 btu_hcif_send_cmd (local_controller_id, p);
1443 return (TRUE);
1444 }
1445
btsnd_hcic_read_page_tout(void)1446 BOOLEAN btsnd_hcic_read_page_tout (void)
1447 {
1448 BT_HDR *p;
1449 UINT8 *pp;
1450
1451 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_READ_CMD)) == NULL)
1452 return (FALSE);
1453
1454 pp = (UINT8 *)(p + 1);
1455
1456 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_READ_CMD;
1457 p->offset = 0;
1458
1459 UINT16_TO_STREAM (pp, HCI_READ_PAGE_TOUT);
1460 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_READ_CMD);
1461
1462 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1463 return (TRUE);
1464 }
1465
btsnd_hcic_write_page_tout(UINT16 timeout)1466 BOOLEAN btsnd_hcic_write_page_tout (UINT16 timeout)
1467 {
1468 BT_HDR *p;
1469 UINT8 *pp;
1470
1471 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_WRITE_PARAM2)) == NULL)
1472 return (FALSE);
1473
1474 pp = (UINT8 *)(p + 1);
1475
1476 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_WRITE_PARAM2;
1477 p->offset = 0;
1478
1479 UINT16_TO_STREAM (pp, HCI_WRITE_PAGE_TOUT);
1480 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_WRITE_PARAM2);
1481
1482 UINT16_TO_STREAM (pp, timeout);
1483
1484 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1485 return (TRUE);
1486 }
1487
btsnd_hcic_read_scan_enable(void)1488 BOOLEAN btsnd_hcic_read_scan_enable (void)
1489 {
1490 BT_HDR *p;
1491 UINT8 *pp;
1492
1493 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_READ_CMD)) == NULL)
1494 return (FALSE);
1495
1496 pp = (UINT8 *)(p + 1);
1497
1498 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_READ_CMD;
1499 p->offset = 0;
1500
1501 UINT16_TO_STREAM (pp, HCI_READ_SCAN_ENABLE);
1502 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_READ_CMD);
1503
1504 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1505 return (TRUE);
1506 }
1507
btsnd_hcic_write_scan_enable(UINT8 flag)1508 BOOLEAN btsnd_hcic_write_scan_enable (UINT8 flag)
1509 {
1510 BT_HDR *p;
1511 UINT8 *pp;
1512
1513 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_WRITE_PARAM1)) == NULL)
1514 return (FALSE);
1515
1516 pp = (UINT8 *)(p + 1);
1517
1518 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_WRITE_PARAM1;
1519 p->offset = 0;
1520
1521 UINT16_TO_STREAM (pp, HCI_WRITE_SCAN_ENABLE);
1522 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_WRITE_PARAM1);
1523
1524 UINT8_TO_STREAM (pp, flag);
1525
1526 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1527 return (TRUE);
1528 }
1529
btsnd_hcic_read_pagescan_cfg(void)1530 BOOLEAN btsnd_hcic_read_pagescan_cfg(void)
1531 {
1532 BT_HDR *p;
1533 UINT8 *pp;
1534
1535 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_READ_CMD)) == NULL)
1536 return (FALSE);
1537
1538 pp = (UINT8 *)(p + 1);
1539
1540 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_READ_CMD;
1541 p->offset = 0;
1542
1543 UINT16_TO_STREAM (pp, HCI_READ_PAGESCAN_CFG);
1544 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_READ_CMD);
1545
1546 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1547 return (TRUE);
1548 }
1549
btsnd_hcic_write_pagescan_cfg(UINT16 interval,UINT16 window)1550 BOOLEAN btsnd_hcic_write_pagescan_cfg(UINT16 interval, UINT16 window)
1551 {
1552 BT_HDR *p;
1553 UINT8 *pp;
1554
1555 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_WRITE_PAGESCAN_CFG)) == NULL)
1556 return (FALSE);
1557
1558 pp = (UINT8 *)(p + 1);
1559
1560 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_WRITE_PAGESCAN_CFG;
1561 p->offset = 0;
1562
1563 UINT16_TO_STREAM (pp, HCI_WRITE_PAGESCAN_CFG);
1564 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_WRITE_PAGESCAN_CFG);
1565
1566 UINT16_TO_STREAM (pp, interval);
1567 UINT16_TO_STREAM (pp, window);
1568
1569 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1570 return (TRUE);
1571 }
1572
btsnd_hcic_read_inqscan_cfg(void)1573 BOOLEAN btsnd_hcic_read_inqscan_cfg(void)
1574 {
1575 BT_HDR *p;
1576 UINT8 *pp;
1577
1578 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_READ_CMD)) == NULL)
1579 return (FALSE);
1580
1581 pp = (UINT8 *)(p + 1);
1582
1583 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_READ_CMD;
1584 p->offset = 0;
1585
1586 UINT16_TO_STREAM (pp, HCI_READ_INQUIRYSCAN_CFG);
1587 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_READ_CMD);
1588
1589 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1590 return (TRUE);
1591 }
1592
btsnd_hcic_write_inqscan_cfg(UINT16 interval,UINT16 window)1593 BOOLEAN btsnd_hcic_write_inqscan_cfg(UINT16 interval, UINT16 window)
1594 {
1595 BT_HDR *p;
1596 UINT8 *pp;
1597
1598 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_WRITE_INQSCAN_CFG)) == NULL)
1599 return (FALSE);
1600
1601 pp = (UINT8 *)(p + 1);
1602
1603 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_WRITE_INQSCAN_CFG;
1604 p->offset = 0;
1605
1606 UINT16_TO_STREAM (pp, HCI_WRITE_INQUIRYSCAN_CFG);
1607 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_WRITE_INQSCAN_CFG);
1608
1609 UINT16_TO_STREAM (pp, interval);
1610 UINT16_TO_STREAM (pp, window);
1611
1612 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1613 return (TRUE);
1614 }
1615
btsnd_hcic_read_auth_enable(void)1616 BOOLEAN btsnd_hcic_read_auth_enable (void)
1617 {
1618 BT_HDR *p;
1619 UINT8 *pp;
1620
1621 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_READ_CMD)) == NULL)
1622 return (FALSE);
1623
1624 pp = (UINT8 *)(p + 1);
1625
1626 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_READ_CMD;
1627 p->offset = 0;
1628
1629 UINT16_TO_STREAM (pp, HCI_READ_AUTHENTICATION_ENABLE);
1630 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_READ_CMD);
1631
1632 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1633 return (TRUE);
1634 }
1635
btsnd_hcic_write_auth_enable(UINT8 flag)1636 BOOLEAN btsnd_hcic_write_auth_enable (UINT8 flag)
1637 {
1638 BT_HDR *p;
1639 UINT8 *pp;
1640
1641 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_WRITE_PARAM1)) == NULL)
1642 return (FALSE);
1643
1644 pp = (UINT8 *)(p + 1);
1645
1646 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_WRITE_PARAM1;
1647 p->offset = 0;
1648
1649 UINT16_TO_STREAM (pp, HCI_WRITE_AUTHENTICATION_ENABLE);
1650 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_WRITE_PARAM1);
1651
1652 UINT8_TO_STREAM (pp, flag);
1653
1654 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1655 return (TRUE);
1656 }
1657
btsnd_hcic_read_encr_mode(void)1658 BOOLEAN btsnd_hcic_read_encr_mode (void)
1659 {
1660 BT_HDR *p;
1661 UINT8 *pp;
1662
1663 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_READ_CMD)) == NULL)
1664 return (FALSE);
1665
1666 pp = (UINT8 *)(p + 1);
1667
1668 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_READ_CMD;
1669 p->offset = 0;
1670
1671 UINT16_TO_STREAM (pp, HCI_READ_ENCRYPTION_MODE);
1672 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_READ_CMD);
1673
1674 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1675 return (TRUE);
1676 }
1677
btsnd_hcic_write_encr_mode(UINT8 mode)1678 BOOLEAN btsnd_hcic_write_encr_mode (UINT8 mode)
1679 {
1680 BT_HDR *p;
1681 UINT8 *pp;
1682
1683 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_WRITE_PARAM1)) == NULL)
1684 return (FALSE);
1685
1686 pp = (UINT8 *)(p + 1);
1687
1688 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_WRITE_PARAM1;
1689 p->offset = 0;
1690
1691 UINT16_TO_STREAM (pp, HCI_WRITE_ENCRYPTION_MODE);
1692 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_WRITE_PARAM1);
1693
1694 UINT8_TO_STREAM (pp, mode);
1695
1696 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1697 return (TRUE);
1698 }
1699
btsnd_hcic_read_dev_class(void)1700 BOOLEAN btsnd_hcic_read_dev_class(void)
1701 {
1702 BT_HDR *p;
1703 UINT8 *pp;
1704
1705 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_READ_CMD)) == NULL)
1706 return (FALSE);
1707
1708 pp = (UINT8 *)(p + 1);
1709
1710 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_READ_CMD;
1711 p->offset = 0;
1712
1713 UINT16_TO_STREAM (pp, HCI_READ_CLASS_OF_DEVICE);
1714 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_READ_CMD);
1715
1716 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1717 return (TRUE);
1718 }
1719
btsnd_hcic_write_dev_class(DEV_CLASS dev_class)1720 BOOLEAN btsnd_hcic_write_dev_class(DEV_CLASS dev_class)
1721 {
1722 BT_HDR *p;
1723 UINT8 *pp;
1724
1725 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_WRITE_PARAM3)) == NULL)
1726 return (FALSE);
1727
1728 pp = (UINT8 *)(p + 1);
1729
1730 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_WRITE_PARAM3;
1731 p->offset = 0;
1732
1733 UINT16_TO_STREAM (pp, HCI_WRITE_CLASS_OF_DEVICE);
1734 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_WRITE_PARAM3);
1735
1736 DEVCLASS_TO_STREAM (pp, dev_class);
1737
1738 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1739 return (TRUE);
1740 }
1741
btsnd_hcic_read_voice_settings(void)1742 BOOLEAN btsnd_hcic_read_voice_settings(void)
1743 {
1744 BT_HDR *p;
1745 UINT8 *pp;
1746
1747 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_READ_CMD)) == NULL)
1748 return (FALSE);
1749
1750 pp = (UINT8 *)(p + 1);
1751
1752 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_READ_CMD;
1753 p->offset = 0;
1754
1755 UINT16_TO_STREAM (pp, HCI_READ_VOICE_SETTINGS);
1756 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_READ_CMD);
1757
1758 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1759 return (TRUE);
1760 }
1761
btsnd_hcic_write_voice_settings(UINT16 flags)1762 BOOLEAN btsnd_hcic_write_voice_settings(UINT16 flags)
1763 {
1764 BT_HDR *p;
1765 UINT8 *pp;
1766
1767 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_WRITE_PARAM2)) == NULL)
1768 return (FALSE);
1769
1770 pp = (UINT8 *)(p + 1);
1771
1772 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_WRITE_PARAM2;
1773 p->offset = 0;
1774
1775 UINT16_TO_STREAM (pp, HCI_WRITE_VOICE_SETTINGS);
1776 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_WRITE_PARAM2);
1777
1778 UINT16_TO_STREAM (pp, flags);
1779
1780 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1781 return (TRUE);
1782 }
1783
btsnd_hcic_read_auto_flush_tout(UINT16 handle)1784 BOOLEAN btsnd_hcic_read_auto_flush_tout (UINT16 handle)
1785 {
1786 BT_HDR *p;
1787 UINT8 *pp;
1788
1789 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_CMD_HANDLE)) == NULL)
1790 return (FALSE);
1791
1792 pp = (UINT8 *)(p + 1);
1793
1794 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_CMD_HANDLE;
1795 p->offset = 0;
1796
1797 UINT16_TO_STREAM (pp, HCI_READ_AUTO_FLUSH_TOUT);
1798 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_CMD_HANDLE);
1799
1800 UINT16_TO_STREAM (pp, handle);
1801
1802 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1803 return (TRUE);
1804 }
1805
btsnd_hcic_write_auto_flush_tout(UINT16 handle,UINT16 tout)1806 BOOLEAN btsnd_hcic_write_auto_flush_tout (UINT16 handle, UINT16 tout)
1807 {
1808 BT_HDR *p;
1809 UINT8 *pp;
1810
1811 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_WRITE_AUTO_FLUSH_TOUT)) == NULL)
1812 return (FALSE);
1813
1814 pp = (UINT8 *)(p + 1);
1815
1816 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_WRITE_AUTO_FLUSH_TOUT;
1817 p->offset = 0;
1818
1819 UINT16_TO_STREAM (pp, HCI_WRITE_AUTO_FLUSH_TOUT);
1820 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_WRITE_AUTO_FLUSH_TOUT);
1821
1822 UINT16_TO_STREAM (pp, handle);
1823 UINT16_TO_STREAM (pp, tout);
1824
1825 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1826 return (TRUE);
1827 }
1828
btsnd_hcic_read_num_bcast_xmit(void)1829 BOOLEAN btsnd_hcic_read_num_bcast_xmit (void)
1830 {
1831 BT_HDR *p;
1832 UINT8 *pp;
1833
1834 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_READ_CMD)) == NULL)
1835 return (FALSE);
1836
1837 pp = (UINT8 *)(p + 1);
1838
1839 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_READ_CMD;
1840 p->offset = 0;
1841
1842 UINT16_TO_STREAM (pp, HCI_READ_NUM_BCAST_REXMITS);
1843 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_READ_CMD);
1844
1845 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1846 return (TRUE);
1847 }
1848
btsnd_hcic_write_num_bcast_xmit(UINT8 num)1849 BOOLEAN btsnd_hcic_write_num_bcast_xmit (UINT8 num)
1850 {
1851 BT_HDR *p;
1852 UINT8 *pp;
1853
1854 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_WRITE_PARAM1)) == NULL)
1855 return (FALSE);
1856
1857 pp = (UINT8 *)(p + 1);
1858
1859 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_WRITE_PARAM1;
1860 p->offset = 0;
1861
1862 UINT16_TO_STREAM (pp, HCI_WRITE_NUM_BCAST_REXMITS);
1863 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_WRITE_PARAM1);
1864
1865 UINT8_TO_STREAM (pp, num);
1866
1867 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1868 return (TRUE);
1869 }
1870
btsnd_hcic_read_hold_mode_act(void)1871 BOOLEAN btsnd_hcic_read_hold_mode_act (void)
1872 {
1873 BT_HDR *p;
1874 UINT8 *pp;
1875
1876 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_READ_CMD)) == NULL)
1877 return (FALSE);
1878
1879 pp = (UINT8 *)(p + 1);
1880
1881 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_READ_CMD;
1882 p->offset = 0;
1883
1884 UINT16_TO_STREAM (pp, HCI_READ_HOLD_MODE_ACTIVITY);
1885 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_READ_CMD);
1886
1887 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1888 return (TRUE);
1889 }
1890
btsnd_hcic_write_hold_mode_act(UINT8 flags)1891 BOOLEAN btsnd_hcic_write_hold_mode_act (UINT8 flags)
1892 {
1893 BT_HDR *p;
1894 UINT8 *pp;
1895
1896 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_WRITE_PARAM1)) == NULL)
1897 return (FALSE);
1898
1899 pp = (UINT8 *)(p + 1);
1900
1901 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_WRITE_PARAM1;
1902 p->offset = 0;
1903
1904 UINT16_TO_STREAM (pp, HCI_WRITE_HOLD_MODE_ACTIVITY);
1905 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_WRITE_PARAM1);
1906
1907 UINT8_TO_STREAM (pp, flags);
1908
1909 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1910 return (TRUE);
1911 }
1912
btsnd_hcic_read_tx_power(UINT16 handle,UINT8 type)1913 BOOLEAN btsnd_hcic_read_tx_power (UINT16 handle, UINT8 type)
1914 {
1915 BT_HDR *p;
1916 UINT8 *pp;
1917
1918 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_READ_TX_POWER)) == NULL)
1919 return (FALSE);
1920
1921 pp = (UINT8 *)(p + 1);
1922
1923 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_READ_TX_POWER;
1924 p->offset = 0;
1925
1926 UINT16_TO_STREAM (pp, HCI_READ_TRANSMIT_POWER_LEVEL);
1927 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_READ_TX_POWER);
1928
1929 UINT16_TO_STREAM (pp, handle);
1930 UINT8_TO_STREAM (pp, type);
1931
1932 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1933 return (TRUE);
1934 }
1935
btsnd_hcic_read_sco_flow_enable(void)1936 BOOLEAN btsnd_hcic_read_sco_flow_enable (void)
1937 {
1938 BT_HDR *p;
1939 UINT8 *pp;
1940
1941 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_READ_CMD)) == NULL)
1942 return (FALSE);
1943
1944 pp = (UINT8 *)(p + 1);
1945
1946 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_READ_CMD;
1947 p->offset = 0;
1948
1949 UINT16_TO_STREAM (pp, HCI_READ_SCO_FLOW_CTRL_ENABLE);
1950 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_READ_CMD);
1951
1952 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1953 return (TRUE);
1954 }
1955
btsnd_hcic_write_sco_flow_enable(UINT8 flag)1956 BOOLEAN btsnd_hcic_write_sco_flow_enable (UINT8 flag)
1957 {
1958 BT_HDR *p;
1959 UINT8 *pp;
1960
1961 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_WRITE_PARAM1)) == NULL)
1962 return (FALSE);
1963
1964 pp = (UINT8 *)(p + 1);
1965
1966 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_WRITE_PARAM1;
1967 p->offset = 0;
1968
1969 UINT16_TO_STREAM (pp, HCI_WRITE_SCO_FLOW_CTRL_ENABLE);
1970 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_WRITE_PARAM1);
1971
1972 UINT8_TO_STREAM (pp, flag);
1973
1974 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1975 return (TRUE);
1976 }
1977
btsnd_hcic_set_host_flow_ctrl(UINT8 value)1978 BOOLEAN btsnd_hcic_set_host_flow_ctrl (UINT8 value)
1979 {
1980 BT_HDR *p;
1981 UINT8 *pp;
1982
1983 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_WRITE_PARAM1)) == NULL)
1984 return (FALSE);
1985
1986 pp = (UINT8 *)(p + 1);
1987
1988 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_WRITE_PARAM1;
1989 p->offset = 0;
1990
1991 UINT16_TO_STREAM (pp, HCI_SET_HC_TO_HOST_FLOW_CTRL);
1992 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_WRITE_PARAM1);
1993
1994 UINT8_TO_STREAM (pp, value);
1995
1996 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1997 return (TRUE);
1998 }
1999
btsnd_hcic_set_host_buf_size(UINT16 acl_len,UINT8 sco_len,UINT16 acl_num,UINT16 sco_num)2000 BOOLEAN btsnd_hcic_set_host_buf_size (UINT16 acl_len, UINT8 sco_len,
2001 UINT16 acl_num, UINT16 sco_num)
2002 {
2003 BT_HDR *p;
2004 UINT8 *pp;
2005
2006 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_SET_HOST_BUF_SIZE)) == NULL)
2007 return (FALSE);
2008
2009 pp = (UINT8 *)(p + 1);
2010
2011 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_SET_HOST_BUF_SIZE;
2012 p->offset = 0;
2013
2014 UINT16_TO_STREAM (pp, HCI_HOST_BUFFER_SIZE);
2015 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_SET_HOST_BUF_SIZE);
2016
2017 UINT16_TO_STREAM (pp, acl_len);
2018 UINT8_TO_STREAM (pp, sco_len);
2019 UINT16_TO_STREAM (pp, acl_num);
2020 UINT16_TO_STREAM (pp, sco_num);
2021
2022 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
2023 return (TRUE);
2024 }
2025
btsnd_hcic_host_num_xmitted_pkts(UINT8 num_handles,UINT16 * handle,UINT16 * num_pkts)2026 BOOLEAN btsnd_hcic_host_num_xmitted_pkts (UINT8 num_handles, UINT16 *handle,
2027 UINT16 *num_pkts)
2028 {
2029 BT_HDR *p;
2030 UINT8 *pp;
2031 int j;
2032
2033 if ((p = HCI_GET_CMD_BUF(1 + (num_handles * 4))) == NULL)
2034 return (FALSE);
2035
2036 pp = (UINT8 *)(p + 1);
2037
2038 p->len = HCIC_PREAMBLE_SIZE + 1 + (num_handles * 4);
2039 p->offset = 0;
2040
2041 UINT16_TO_STREAM (pp, HCI_HOST_NUM_PACKETS_DONE);
2042 UINT8_TO_STREAM (pp, p->len - HCIC_PREAMBLE_SIZE);
2043
2044 UINT8_TO_STREAM (pp, num_handles);
2045
2046 for (j = 0; j < num_handles; j++)
2047 {
2048 UINT16_TO_STREAM (pp, handle[j]);
2049 UINT16_TO_STREAM (pp, num_pkts[j]);
2050 }
2051
2052 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
2053 return (TRUE);
2054 }
2055
btsnd_hcic_read_link_super_tout(UINT8 local_controller_id,UINT16 handle)2056 BOOLEAN btsnd_hcic_read_link_super_tout (UINT8 local_controller_id, UINT16 handle)
2057 {
2058 BT_HDR *p;
2059 UINT8 *pp;
2060
2061 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_CMD_HANDLE)) == NULL)
2062 return (FALSE);
2063
2064 pp = (UINT8 *)(p + 1);
2065
2066 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_CMD_HANDLE;
2067 p->offset = 0;
2068
2069 UINT16_TO_STREAM (pp, HCI_READ_LINK_SUPER_TOUT);
2070 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_CMD_HANDLE);
2071
2072 UINT16_TO_STREAM (pp, handle);
2073
2074 btu_hcif_send_cmd (local_controller_id, p);
2075 return (TRUE);
2076 }
2077
btsnd_hcic_write_link_super_tout(UINT8 local_controller_id,UINT16 handle,UINT16 timeout)2078 BOOLEAN btsnd_hcic_write_link_super_tout (UINT8 local_controller_id, UINT16 handle, UINT16 timeout)
2079 {
2080 BT_HDR *p;
2081 UINT8 *pp;
2082
2083 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_WRITE_LINK_SUPER_TOUT)) == NULL)
2084 return (FALSE);
2085
2086 pp = (UINT8 *)(p + 1);
2087
2088 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_WRITE_LINK_SUPER_TOUT;
2089 p->offset = 0;
2090
2091 UINT16_TO_STREAM (pp, HCI_WRITE_LINK_SUPER_TOUT);
2092 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_WRITE_LINK_SUPER_TOUT);
2093
2094 UINT16_TO_STREAM (pp, handle);
2095 UINT16_TO_STREAM (pp, timeout);
2096
2097 btu_hcif_send_cmd (local_controller_id, p);
2098 return (TRUE);
2099 }
2100
btsnd_hcic_read_max_iac(void)2101 BOOLEAN btsnd_hcic_read_max_iac (void)
2102 {
2103 BT_HDR *p;
2104 UINT8 *pp;
2105
2106 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_READ_CMD)) == NULL)
2107 return (FALSE);
2108
2109 pp = (UINT8 *)(p + 1);
2110
2111 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_READ_CMD;
2112 p->offset = 0;
2113
2114 UINT16_TO_STREAM (pp, HCI_READ_NUM_SUPPORTED_IAC);
2115 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_READ_CMD);
2116
2117 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
2118 return (TRUE);
2119 }
2120
btsnd_hcic_read_cur_iac_lap(void)2121 BOOLEAN btsnd_hcic_read_cur_iac_lap (void)
2122 {
2123 BT_HDR *p;
2124 UINT8 *pp;
2125
2126 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_READ_CMD)) == NULL)
2127 return (FALSE);
2128
2129 pp = (UINT8 *)(p + 1);
2130
2131 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_READ_CMD;
2132 p->offset = 0;
2133
2134 UINT16_TO_STREAM (pp, HCI_READ_CURRENT_IAC_LAP);
2135 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_READ_CMD);
2136
2137 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
2138 return (TRUE);
2139 }
2140
btsnd_hcic_write_cur_iac_lap(UINT8 num_cur_iac,LAP * const iac_lap)2141 BOOLEAN btsnd_hcic_write_cur_iac_lap (UINT8 num_cur_iac, LAP * const iac_lap)
2142 {
2143 BT_HDR *p;
2144 UINT8 *pp;
2145 int i;
2146
2147 if ((p = HCI_GET_CMD_BUF(1 + (LAP_LEN * num_cur_iac))) == NULL)
2148 return (FALSE);
2149
2150 pp = (UINT8 *)(p + 1);
2151
2152 p->len = HCIC_PREAMBLE_SIZE + 1 + (LAP_LEN * num_cur_iac);
2153 p->offset = 0;
2154
2155 UINT16_TO_STREAM (pp, HCI_WRITE_CURRENT_IAC_LAP);
2156 UINT8_TO_STREAM (pp, p->len - HCIC_PREAMBLE_SIZE);
2157
2158 UINT8_TO_STREAM (pp, num_cur_iac);
2159
2160 for (i = 0; i < num_cur_iac; i++)
2161 LAP_TO_STREAM (pp, iac_lap[i]);
2162
2163 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
2164 return (TRUE);
2165 }
2166
btsnd_hcic_read_page_scan_per(void)2167 BOOLEAN btsnd_hcic_read_page_scan_per (void)
2168 {
2169 BT_HDR *p;
2170 UINT8 *pp;
2171
2172 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_READ_CMD)) == NULL)
2173 return (FALSE);
2174
2175 pp = (UINT8 *)(p + 1);
2176
2177 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_READ_CMD;
2178 p->offset = 0;
2179
2180 UINT16_TO_STREAM (pp, HCI_READ_PAGESCAN_PERIOD_MODE);
2181 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_READ_CMD);
2182
2183 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
2184 return (TRUE);
2185 }
2186
btsnd_hcic_write_page_scan_per(UINT8 mode)2187 BOOLEAN btsnd_hcic_write_page_scan_per (UINT8 mode)
2188 {
2189 BT_HDR *p;
2190 UINT8 *pp;
2191
2192 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_WRITE_PARAM1)) == NULL)
2193 return (FALSE);
2194
2195 pp = (UINT8 *)(p + 1);
2196
2197 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_WRITE_PARAM1;
2198 p->offset = 0;
2199
2200 UINT16_TO_STREAM (pp, HCI_WRITE_PAGESCAN_PERIOD_MODE);
2201 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_WRITE_PARAM1);
2202
2203 UINT8_TO_STREAM (pp, mode);
2204
2205 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
2206 return (TRUE);
2207 }
2208
btsnd_hcic_read_page_scan_mode(void)2209 BOOLEAN btsnd_hcic_read_page_scan_mode (void)
2210 {
2211 BT_HDR *p;
2212 UINT8 *pp;
2213
2214 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_READ_CMD)) == NULL)
2215 return (FALSE);
2216
2217 pp = (UINT8 *)(p + 1);
2218
2219 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_READ_CMD;
2220 p->offset = 0;
2221
2222 UINT16_TO_STREAM (pp, HCI_READ_PAGESCAN_MODE);
2223 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_READ_CMD);
2224
2225 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
2226 return (TRUE);
2227 }
2228
btsnd_hcic_write_page_scan_mode(UINT8 mode)2229 BOOLEAN btsnd_hcic_write_page_scan_mode (UINT8 mode)
2230 {
2231 BT_HDR *p;
2232 UINT8 *pp;
2233
2234 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_WRITE_PARAM1)) == NULL)
2235 return (FALSE);
2236
2237 pp = (UINT8 *)(p + 1);
2238
2239 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_WRITE_PARAM1;
2240 p->offset = 0;
2241
2242 UINT16_TO_STREAM (pp, HCI_WRITE_PAGESCAN_MODE);
2243 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_WRITE_PARAM1);
2244
2245 UINT8_TO_STREAM (pp, mode);
2246
2247 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
2248 return (TRUE);
2249 }
2250
2251 /******************************************
2252 ** Lisbon Features
2253 *******************************************/
2254 #if BTM_SSR_INCLUDED == TRUE
2255
btsnd_hcic_sniff_sub_rate(UINT16 handle,UINT16 max_lat,UINT16 min_remote_lat,UINT16 min_local_lat)2256 BOOLEAN btsnd_hcic_sniff_sub_rate(UINT16 handle, UINT16 max_lat,
2257 UINT16 min_remote_lat, UINT16 min_local_lat)
2258 {
2259 BT_HDR *p;
2260 UINT8 *pp;
2261
2262 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_SNIFF_SUB_RATE)) == NULL)
2263 return (FALSE);
2264
2265 pp = (UINT8 *)(p + 1);
2266
2267 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_SNIFF_SUB_RATE;
2268 p->offset = 0;
2269
2270 UINT16_TO_STREAM (pp, HCI_SNIFF_SUB_RATE);
2271 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_SNIFF_SUB_RATE);
2272
2273 UINT16_TO_STREAM (pp, handle);
2274 UINT16_TO_STREAM (pp, max_lat);
2275 UINT16_TO_STREAM (pp, min_remote_lat);
2276 UINT16_TO_STREAM (pp, min_local_lat);
2277
2278 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
2279 return (TRUE);
2280 }
2281 #endif /* BTM_SSR_INCLUDED */
2282
2283 #if (BTM_EIR_SERVER_INCLUDED == TRUE)
2284 /**** Extended Inquiry Response Commands ****/
btsnd_hcic_read_ext_inquiry_response(void)2285 BOOLEAN btsnd_hcic_read_ext_inquiry_response (void)
2286 {
2287 BT_HDR *p;
2288 UINT8 *pp;
2289
2290 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_READ_CMD)) == NULL)
2291 return (FALSE);
2292
2293 pp = (UINT8 *)(p + 1);
2294
2295 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_READ_CMD;
2296 p->offset = 0;
2297
2298 UINT16_TO_STREAM (pp, HCI_READ_EXT_INQ_RESPONSE);
2299 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_READ_CMD);
2300
2301 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
2302 return (TRUE);
2303 }
2304
btsnd_hcic_write_ext_inquiry_response(void * buffer,UINT8 fec_req)2305 void btsnd_hcic_write_ext_inquiry_response (void *buffer, UINT8 fec_req)
2306 {
2307 BT_HDR *p = (BT_HDR *)buffer;
2308 UINT8 *pp = (UINT8 *)(p + 1);
2309
2310 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_EXT_INQ_RESP;
2311 p->offset = 0;
2312
2313 UINT16_TO_STREAM (pp, HCI_WRITE_EXT_INQ_RESPONSE);
2314 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_EXT_INQ_RESP);
2315
2316 UINT8_TO_STREAM (pp, fec_req);
2317
2318 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
2319 }
2320 #endif /* BTM_EIR_SERVER_INCLUDED == TRUE */
2321
2322 /**** Simple Pairing Commands ****/
btsnd_hcic_write_simple_pairing_mode(UINT8 mode)2323 BOOLEAN btsnd_hcic_write_simple_pairing_mode (UINT8 mode)
2324 {
2325 BT_HDR *p;
2326 UINT8 *pp;
2327
2328 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_W_SIMP_PAIR)) == NULL)
2329 return (FALSE);
2330
2331 pp = (UINT8 *)(p + 1);
2332
2333 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_W_SIMP_PAIR;
2334 p->offset = 0;
2335
2336 UINT16_TO_STREAM (pp, HCI_WRITE_SIMPLE_PAIRING_MODE);
2337 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_W_SIMP_PAIR);
2338
2339 UINT8_TO_STREAM (pp, mode);
2340
2341 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
2342 return (TRUE);
2343 }
2344
btsnd_hcic_read_simple_pairing_mode(void)2345 BOOLEAN btsnd_hcic_read_simple_pairing_mode (void)
2346 {
2347 BT_HDR *p;
2348 UINT8 *pp;
2349
2350 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_R_SIMP_PAIR)) == NULL)
2351 return (FALSE);
2352
2353 pp = (UINT8 *)(p + 1);
2354
2355 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_R_SIMP_PAIR;
2356 p->offset = 0;
2357
2358 UINT16_TO_STREAM (pp, HCI_READ_SIMPLE_PAIRING_MODE);
2359 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_R_SIMP_PAIR);
2360
2361 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
2362 return (TRUE);
2363 }
2364
btsnd_hcic_write_simp_pair_debug_mode(UINT8 debug_mode)2365 BOOLEAN btsnd_hcic_write_simp_pair_debug_mode(UINT8 debug_mode)
2366 {
2367 BT_HDR *p;
2368 UINT8 *pp;
2369
2370 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_SIMP_PAIR_DBUG)) == NULL)
2371 return (FALSE);
2372
2373 pp = (UINT8 *)(p + 1);
2374
2375 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_SIMP_PAIR_DBUG;
2376 p->offset = 0;
2377
2378 UINT16_TO_STREAM (pp, HCI_WRITE_SIMP_PAIR_DEBUG_MODE);
2379 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_SIMP_PAIR_DBUG);
2380
2381 UINT8_TO_STREAM (pp, debug_mode);
2382
2383 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
2384 return (TRUE);
2385 }
2386
btsnd_hcic_io_cap_req_reply(BD_ADDR bd_addr,UINT8 capability,UINT8 oob_present,UINT8 auth_req)2387 BOOLEAN btsnd_hcic_io_cap_req_reply (BD_ADDR bd_addr, UINT8 capability,
2388 UINT8 oob_present, UINT8 auth_req)
2389 {
2390 BT_HDR *p;
2391 UINT8 *pp;
2392
2393 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_IO_CAP_RESP)) == NULL)
2394 return (FALSE);
2395
2396 pp = (UINT8 *)(p + 1);
2397
2398 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_IO_CAP_RESP;
2399 p->offset = 0;
2400
2401 UINT16_TO_STREAM (pp, HCI_IO_CAPABILITY_RESPONSE);
2402 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_IO_CAP_RESP);
2403
2404 BDADDR_TO_STREAM (pp, bd_addr);
2405 UINT8_TO_STREAM (pp, capability);
2406 UINT8_TO_STREAM (pp, oob_present);
2407 UINT8_TO_STREAM (pp, auth_req);
2408
2409 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
2410 return (TRUE);
2411 }
2412
btsnd_hcic_io_cap_req_neg_reply(BD_ADDR bd_addr,UINT8 err_code)2413 BOOLEAN btsnd_hcic_io_cap_req_neg_reply (BD_ADDR bd_addr, UINT8 err_code)
2414 {
2415 BT_HDR *p;
2416 UINT8 *pp;
2417
2418 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_IO_CAP_NEG_REPLY)) == NULL)
2419 return (FALSE);
2420
2421 pp = (UINT8 *)(p + 1);
2422
2423 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_IO_CAP_NEG_REPLY;
2424 p->offset = 0;
2425
2426 UINT16_TO_STREAM (pp, HCI_IO_CAP_REQ_NEG_REPLY);
2427 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_IO_CAP_NEG_REPLY);
2428
2429 BDADDR_TO_STREAM (pp, bd_addr);
2430 UINT8_TO_STREAM (pp, err_code);
2431
2432 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
2433 return (TRUE);
2434 }
2435
btsnd_hcic_read_local_oob_data(void)2436 BOOLEAN btsnd_hcic_read_local_oob_data (void)
2437 {
2438 BT_HDR *p;
2439 UINT8 *pp;
2440
2441 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_R_LOCAL_OOB)) == NULL)
2442 return (FALSE);
2443
2444 pp = (UINT8 *)(p + 1);
2445
2446 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_R_LOCAL_OOB;
2447 p->offset = 0;
2448
2449 UINT16_TO_STREAM (pp, HCI_READ_LOCAL_OOB_DATA);
2450 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_R_LOCAL_OOB);
2451
2452 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
2453 return (TRUE);
2454 }
2455
btsnd_hcic_user_conf_reply(BD_ADDR bd_addr,BOOLEAN is_yes)2456 BOOLEAN btsnd_hcic_user_conf_reply (BD_ADDR bd_addr, BOOLEAN is_yes)
2457 {
2458 BT_HDR *p;
2459 UINT8 *pp;
2460
2461 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_UCONF_REPLY)) == NULL)
2462 return (FALSE);
2463
2464 pp = (UINT8 *)(p + 1);
2465
2466 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_UCONF_REPLY;
2467 p->offset = 0;
2468
2469 if (!is_yes)
2470 {
2471 /* Negative reply */
2472 UINT16_TO_STREAM (pp, HCI_USER_CONF_VALUE_NEG_REPLY);
2473 }
2474 else
2475 {
2476 /* Confirmation */
2477 UINT16_TO_STREAM (pp, HCI_USER_CONF_REQUEST_REPLY);
2478 }
2479
2480 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_UCONF_REPLY);
2481
2482 BDADDR_TO_STREAM (pp, bd_addr);
2483
2484 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
2485 return (TRUE);
2486 }
2487
btsnd_hcic_user_passkey_reply(BD_ADDR bd_addr,UINT32 value)2488 BOOLEAN btsnd_hcic_user_passkey_reply (BD_ADDR bd_addr, UINT32 value)
2489 {
2490 BT_HDR *p;
2491 UINT8 *pp;
2492
2493 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_U_PKEY_REPLY)) == NULL)
2494 return (FALSE);
2495
2496 pp = (UINT8 *)(p + 1);
2497
2498 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_U_PKEY_REPLY;
2499 p->offset = 0;
2500
2501 UINT16_TO_STREAM (pp, HCI_USER_PASSKEY_REQ_REPLY);
2502 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_U_PKEY_REPLY);
2503
2504 BDADDR_TO_STREAM (pp, bd_addr);
2505 UINT32_TO_STREAM (pp, value);
2506
2507 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
2508 return (TRUE);
2509 }
2510
btsnd_hcic_user_passkey_neg_reply(BD_ADDR bd_addr)2511 BOOLEAN btsnd_hcic_user_passkey_neg_reply (BD_ADDR bd_addr)
2512 {
2513 BT_HDR *p;
2514 UINT8 *pp;
2515
2516 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_U_PKEY_NEG_REPLY)) == NULL)
2517 return (FALSE);
2518
2519 pp = (UINT8 *)(p + 1);
2520
2521 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_U_PKEY_NEG_REPLY;
2522 p->offset = 0;
2523
2524 UINT16_TO_STREAM (pp, HCI_USER_PASSKEY_REQ_NEG_REPLY);
2525 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_U_PKEY_NEG_REPLY);
2526
2527 BDADDR_TO_STREAM (pp, bd_addr);
2528
2529 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
2530 return (TRUE);
2531 }
2532
btsnd_hcic_rem_oob_reply(BD_ADDR bd_addr,UINT8 * p_c,UINT8 * p_r)2533 BOOLEAN btsnd_hcic_rem_oob_reply (BD_ADDR bd_addr, UINT8 *p_c, UINT8 *p_r)
2534 {
2535 BT_HDR *p;
2536 UINT8 *pp;
2537
2538 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_REM_OOB_REPLY)) == NULL)
2539 return (FALSE);
2540
2541 pp = (UINT8 *)(p + 1);
2542
2543 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_REM_OOB_REPLY;
2544 p->offset = 0;
2545
2546 UINT16_TO_STREAM (pp, HCI_REM_OOB_DATA_REQ_REPLY);
2547 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_REM_OOB_REPLY);
2548
2549 BDADDR_TO_STREAM (pp, bd_addr);
2550 ARRAY16_TO_STREAM (pp, p_c);
2551 ARRAY16_TO_STREAM (pp, p_r);
2552
2553 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
2554 return (TRUE);
2555 }
2556
btsnd_hcic_rem_oob_neg_reply(BD_ADDR bd_addr)2557 BOOLEAN btsnd_hcic_rem_oob_neg_reply (BD_ADDR bd_addr)
2558 {
2559 BT_HDR *p;
2560 UINT8 *pp;
2561
2562 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_REM_OOB_NEG_REPLY)) == NULL)
2563 return (FALSE);
2564
2565 pp = (UINT8 *)(p + 1);
2566
2567 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_REM_OOB_NEG_REPLY;
2568 p->offset = 0;
2569
2570 UINT16_TO_STREAM (pp, HCI_REM_OOB_DATA_REQ_NEG_REPLY);
2571 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_REM_OOB_NEG_REPLY);
2572
2573 BDADDR_TO_STREAM (pp, bd_addr);
2574
2575 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
2576 return (TRUE);
2577 }
2578
2579
btsnd_hcic_read_inq_tx_power(void)2580 BOOLEAN btsnd_hcic_read_inq_tx_power (void)
2581 {
2582 BT_HDR *p;
2583 UINT8 *pp;
2584
2585 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_R_TX_POWER)) == NULL)
2586 return (FALSE);
2587
2588 pp = (UINT8 *)(p + 1);
2589
2590 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_R_TX_POWER;
2591 p->offset = 0;
2592
2593 UINT16_TO_STREAM (pp, HCI_READ_INQ_TX_POWER_LEVEL);
2594 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_R_TX_POWER);
2595
2596 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
2597 return (TRUE);
2598 }
2599
btsnd_hcic_write_inq_tx_power(INT8 level)2600 BOOLEAN btsnd_hcic_write_inq_tx_power (INT8 level)
2601 {
2602 BT_HDR *p;
2603 UINT8 *pp;
2604
2605 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_W_TX_POWER)) == NULL)
2606 return (FALSE);
2607
2608 pp = (UINT8 *)(p + 1);
2609
2610 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_W_TX_POWER;
2611 p->offset = 0;
2612
2613 UINT16_TO_STREAM (pp, HCI_WRITE_INQ_TX_POWER_LEVEL);
2614 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_W_TX_POWER);
2615
2616 INT8_TO_STREAM (pp, level);
2617
2618 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
2619 return (TRUE);
2620 }
2621
2622 #if 0 /* currently not been used */
2623 BOOLEAN btsnd_hcic_read_default_erroneous_data_rpt (void)
2624 {
2625 BT_HDR *p;
2626 UINT8 *pp;
2627
2628 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_R_ERR_DATA_RPT)) == NULL)
2629 return (FALSE);
2630
2631 pp = (UINT8 *)(p + 1);
2632
2633 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_R_ERR_DATA_RPT;
2634 p->offset = 0;
2635
2636 UINT16_TO_STREAM (pp, HCI_READ_ERRONEOUS_DATA_RPT);
2637 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_R_ERR_DATA_RPT);
2638
2639 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
2640 return (TRUE);
2641 }
2642 #endif
2643
btsnd_hcic_write_default_erroneous_data_rpt(UINT8 flag)2644 BOOLEAN btsnd_hcic_write_default_erroneous_data_rpt (UINT8 flag)
2645 {
2646 BT_HDR *p;
2647 UINT8 *pp;
2648
2649 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_W_ERR_DATA_RPT)) == NULL)
2650 return (FALSE);
2651
2652 pp = (UINT8 *)(p + 1);
2653
2654 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_W_ERR_DATA_RPT;
2655 p->offset = 0;
2656
2657 UINT16_TO_STREAM (pp, HCI_WRITE_ERRONEOUS_DATA_RPT);
2658 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_W_ERR_DATA_RPT);
2659
2660 UINT8_TO_STREAM (pp, flag);
2661
2662 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
2663 return (TRUE);
2664 }
2665
btsnd_hcic_send_keypress_notif(BD_ADDR bd_addr,UINT8 notif)2666 BOOLEAN btsnd_hcic_send_keypress_notif (BD_ADDR bd_addr, UINT8 notif)
2667 {
2668 BT_HDR *p;
2669 UINT8 *pp;
2670
2671 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_SEND_KEYPRESS_NOTIF)) == NULL)
2672 return (FALSE);
2673
2674 pp = (UINT8 *)(p + 1);
2675
2676 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_SEND_KEYPRESS_NOTIF;
2677 p->offset = 0;
2678
2679 UINT16_TO_STREAM (pp, HCI_SEND_KEYPRESS_NOTIF);
2680 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_SEND_KEYPRESS_NOTIF);
2681
2682 BDADDR_TO_STREAM (pp, bd_addr);
2683 UINT8_TO_STREAM (pp, notif);
2684
2685 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
2686 return (TRUE);
2687 }
2688
2689 /**** end of Simple Pairing Commands ****/
2690
2691 #if L2CAP_NON_FLUSHABLE_PB_INCLUDED == TRUE
btsnd_hcic_enhanced_flush(UINT16 handle,UINT8 packet_type)2692 BOOLEAN btsnd_hcic_enhanced_flush (UINT16 handle, UINT8 packet_type)
2693 {
2694 BT_HDR *p;
2695 UINT8 *pp;
2696
2697 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_ENHANCED_FLUSH)) == NULL)
2698 return (FALSE);
2699
2700 pp = (UINT8 *)(p + 1);
2701
2702 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_ENHANCED_FLUSH;
2703 p->offset = 0;
2704 UINT16_TO_STREAM (pp, HCI_ENHANCED_FLUSH);
2705 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_ENHANCED_FLUSH);
2706
2707 UINT16_TO_STREAM (pp, handle);
2708 UINT8_TO_STREAM (pp, packet_type);
2709
2710 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
2711 return (TRUE);
2712 }
2713 #endif
2714
2715
btsnd_hcic_refresh_encryption_key(UINT16 handle)2716 BOOLEAN btsnd_hcic_refresh_encryption_key (UINT16 handle)
2717 {
2718 BT_HDR *p;
2719 UINT8 *pp;
2720
2721 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_CMD_HANDLE)) == NULL)
2722 return (FALSE);
2723
2724 pp = (UINT8 *)(p + 1);
2725
2726 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_CMD_HANDLE;
2727 p->offset = 0;
2728 UINT16_TO_STREAM (pp, HCI_REFRESH_ENCRYPTION_KEY);
2729 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_CMD_HANDLE);
2730
2731 UINT16_TO_STREAM (pp, handle);
2732
2733 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
2734 return (TRUE);
2735 }
2736 /*************************
2737 ** End of Lisbon Commands
2738 **************************/
2739
btsnd_hcic_read_local_ver(UINT8 local_controller_id)2740 BOOLEAN btsnd_hcic_read_local_ver (UINT8 local_controller_id)
2741 {
2742 BT_HDR *p;
2743 UINT8 *pp;
2744
2745 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_READ_CMD)) == NULL)
2746 return (FALSE);
2747
2748 pp = (UINT8 *)(p + 1);
2749
2750 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_READ_CMD;
2751 p->offset = 0;
2752
2753 UINT16_TO_STREAM (pp, HCI_READ_LOCAL_VERSION_INFO);
2754 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_READ_CMD);
2755
2756 btu_hcif_send_cmd (local_controller_id, p);
2757 return (TRUE);
2758 }
2759
btsnd_hcic_read_local_supported_cmds(UINT8 local_controller_id)2760 BOOLEAN btsnd_hcic_read_local_supported_cmds (UINT8 local_controller_id)
2761 {
2762 BT_HDR *p;
2763 UINT8 *pp;
2764
2765 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_READ_CMD)) == NULL)
2766 return (FALSE);
2767
2768 pp = (UINT8 *)(p + 1);
2769
2770 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_READ_CMD;
2771 p->offset = 0;
2772
2773 UINT16_TO_STREAM (pp, HCI_READ_LOCAL_SUPPORTED_CMDS);
2774 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_READ_CMD);
2775
2776 btu_hcif_send_cmd (local_controller_id, p);
2777 return (TRUE);
2778 }
2779
btsnd_hcic_read_local_features(void)2780 BOOLEAN btsnd_hcic_read_local_features (void)
2781 {
2782 BT_HDR *p;
2783 UINT8 *pp;
2784
2785 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_READ_CMD)) == NULL)
2786 return (FALSE);
2787
2788 pp = (UINT8 *)(p + 1);
2789
2790 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_READ_CMD;
2791 p->offset = 0;
2792
2793 UINT16_TO_STREAM (pp, HCI_READ_LOCAL_FEATURES);
2794 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_READ_CMD);
2795
2796 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
2797 return (TRUE);
2798 }
2799
btsnd_hcic_read_local_ext_features(UINT8 page_num)2800 BOOLEAN btsnd_hcic_read_local_ext_features (UINT8 page_num)
2801 {
2802 BT_HDR *p;
2803 UINT8 *pp;
2804
2805 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_LOCAL_EXT_FEATURES)) == NULL)
2806 return (FALSE);
2807
2808 pp = (UINT8 *)(p + 1);
2809
2810 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_LOCAL_EXT_FEATURES;
2811 p->offset = 0;
2812
2813 UINT16_TO_STREAM (pp, HCI_READ_LOCAL_EXT_FEATURES);
2814 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_LOCAL_EXT_FEATURES);
2815
2816 UINT8_TO_STREAM (pp, page_num);
2817
2818 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
2819 return (TRUE);
2820 }
2821
btsnd_hcic_read_buffer_size(void)2822 BOOLEAN btsnd_hcic_read_buffer_size (void)
2823 {
2824 BT_HDR *p;
2825 UINT8 *pp;
2826
2827 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_READ_CMD)) == NULL)
2828 return (FALSE);
2829
2830 pp = (UINT8 *)(p + 1);
2831
2832 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_READ_CMD;
2833 p->offset = 0;
2834
2835 UINT16_TO_STREAM (pp, HCI_READ_BUFFER_SIZE);
2836 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_READ_CMD);
2837
2838 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
2839 return (TRUE);
2840 }
2841
btsnd_hcic_read_country_code(void)2842 BOOLEAN btsnd_hcic_read_country_code (void)
2843 {
2844 BT_HDR *p;
2845 UINT8 *pp;
2846
2847 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_READ_CMD)) == NULL)
2848 return (FALSE);
2849
2850 pp = (UINT8 *)(p + 1);
2851
2852 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_READ_CMD;
2853 p->offset = 0;
2854
2855 UINT16_TO_STREAM (pp, HCI_READ_COUNTRY_CODE);
2856 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_READ_CMD);
2857
2858 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
2859 return (TRUE);
2860 }
2861
btsnd_hcic_read_bd_addr(void)2862 BOOLEAN btsnd_hcic_read_bd_addr (void)
2863 {
2864 BT_HDR *p;
2865 UINT8 *pp;
2866
2867 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_READ_CMD)) == NULL)
2868 return (FALSE);
2869
2870 pp = (UINT8 *)(p + 1);
2871
2872 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_READ_CMD;
2873 p->offset = 0;
2874
2875 UINT16_TO_STREAM (pp, HCI_READ_BD_ADDR);
2876 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_READ_CMD);
2877
2878 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
2879 return (TRUE);
2880 }
2881
btsnd_hcic_read_fail_contact_count(UINT8 local_controller_id,UINT16 handle)2882 BOOLEAN btsnd_hcic_read_fail_contact_count (UINT8 local_controller_id, UINT16 handle)
2883 {
2884 BT_HDR *p;
2885 UINT8 *pp;
2886
2887 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_CMD_HANDLE)) == NULL)
2888 return (FALSE);
2889
2890 pp = (UINT8 *)(p + 1);
2891
2892 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_CMD_HANDLE;
2893 p->offset = 0;
2894
2895 UINT16_TO_STREAM (pp, HCI_READ_FAILED_CONTACT_COUNT);
2896 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_CMD_HANDLE);
2897
2898 UINT16_TO_STREAM (pp, handle);
2899
2900 btu_hcif_send_cmd (local_controller_id, p);
2901 return (TRUE);
2902 }
2903
btsnd_hcic_reset_fail_contact_count(UINT8 local_controller_id,UINT16 handle)2904 BOOLEAN btsnd_hcic_reset_fail_contact_count (UINT8 local_controller_id, UINT16 handle)
2905 {
2906 BT_HDR *p;
2907 UINT8 *pp;
2908
2909 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_CMD_HANDLE)) == NULL)
2910 return (FALSE);
2911
2912 pp = (UINT8 *)(p + 1);
2913
2914 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_CMD_HANDLE;
2915 p->offset = 0;
2916
2917 UINT16_TO_STREAM (pp, HCI_RESET_FAILED_CONTACT_COUNT);
2918 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_CMD_HANDLE);
2919
2920 UINT16_TO_STREAM (pp, handle);
2921
2922 btu_hcif_send_cmd (local_controller_id, p);
2923 return (TRUE);
2924 }
2925
btsnd_hcic_get_link_quality(UINT16 handle)2926 BOOLEAN btsnd_hcic_get_link_quality (UINT16 handle)
2927 {
2928 BT_HDR *p;
2929 UINT8 *pp;
2930
2931 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_CMD_HANDLE)) == NULL)
2932 return (FALSE);
2933
2934 pp = (UINT8 *)(p + 1);
2935
2936 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_CMD_HANDLE;
2937 p->offset = 0;
2938
2939 UINT16_TO_STREAM (pp, HCI_GET_LINK_QUALITY);
2940 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_CMD_HANDLE);
2941
2942 UINT16_TO_STREAM (pp, handle);
2943
2944 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
2945 return (TRUE);
2946 }
2947
btsnd_hcic_read_rssi(UINT16 handle)2948 BOOLEAN btsnd_hcic_read_rssi (UINT16 handle)
2949 {
2950 BT_HDR *p;
2951 UINT8 *pp;
2952
2953 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_CMD_HANDLE)) == NULL)
2954 return (FALSE);
2955
2956 pp = (UINT8 *)(p + 1);
2957
2958 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_CMD_HANDLE;
2959 p->offset = 0;
2960
2961 UINT16_TO_STREAM (pp, HCI_READ_RSSI);
2962 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_CMD_HANDLE);
2963
2964 UINT16_TO_STREAM (pp, handle);
2965
2966 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
2967 return (TRUE);
2968 }
2969
btsnd_hcic_read_loopback_mode(void)2970 BOOLEAN btsnd_hcic_read_loopback_mode (void)
2971 {
2972 BT_HDR *p;
2973 UINT8 *pp;
2974
2975 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_READ_CMD)) == NULL)
2976 return (FALSE);
2977
2978 pp = (UINT8 *)(p + 1);
2979
2980 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_READ_CMD;
2981 p->offset = 0;
2982
2983 UINT16_TO_STREAM (pp, HCI_READ_LOOPBACK_MODE);
2984 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_READ_CMD);
2985
2986 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
2987 return (TRUE);
2988 }
2989
btsnd_hcic_write_loopback_mode(UINT8 mode)2990 BOOLEAN btsnd_hcic_write_loopback_mode (UINT8 mode)
2991 {
2992 BT_HDR *p;
2993 UINT8 *pp;
2994
2995 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_WRITE_PARAM1)) == NULL)
2996 return (FALSE);
2997
2998 pp = (UINT8 *)(p + 1);
2999
3000 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_WRITE_PARAM1;
3001 p->offset = 0;
3002
3003 UINT16_TO_STREAM (pp, HCI_WRITE_LOOPBACK_MODE);
3004 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_WRITE_PARAM1);
3005
3006 UINT8_TO_STREAM (pp, mode);
3007
3008 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
3009 return (TRUE);
3010 }
3011
btsnd_hcic_enable_test_mode(void)3012 BOOLEAN btsnd_hcic_enable_test_mode (void)
3013 {
3014 BT_HDR *p;
3015 UINT8 *pp;
3016
3017 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_READ_CMD)) == NULL)
3018 return (FALSE);
3019
3020 pp = (UINT8 *)(p + 1);
3021
3022 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_READ_CMD;
3023 p->offset = 0;
3024
3025 UINT16_TO_STREAM (pp, HCI_ENABLE_DEV_UNDER_TEST_MODE);
3026 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_READ_CMD);
3027
3028 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
3029 return (TRUE);
3030 }
3031
btsnd_hcic_write_afh_channel_assessment_mode(UINT8 mode)3032 BOOLEAN btsnd_hcic_write_afh_channel_assessment_mode (UINT8 mode)
3033 {
3034 BT_HDR *p;
3035 UINT8 *pp;
3036
3037 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_WRITE_PARAM1)) == NULL)
3038 return (FALSE);
3039
3040 pp = (UINT8 *)(p + 1);
3041
3042 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_WRITE_PARAM1;
3043 p->offset = 0;
3044
3045 UINT16_TO_STREAM (pp, HCI_WRITE_AFH_ASSESSMENT_MODE);
3046 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_WRITE_PARAM1);
3047
3048 UINT8_TO_STREAM (pp, mode);
3049
3050 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
3051 return (TRUE);
3052 }
3053
btsnd_hcic_read_afh_channel_assessment_mode(void)3054 BOOLEAN btsnd_hcic_read_afh_channel_assessment_mode(void)
3055 {
3056 BT_HDR *p;
3057 UINT8 *pp;
3058
3059 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_READ_CMD)) == NULL)
3060 return (FALSE);
3061
3062 pp = (UINT8 *)(p + 1);
3063
3064 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_READ_CMD;
3065 p->offset = 0;
3066
3067 UINT16_TO_STREAM (pp, HCI_READ_AFH_ASSESSMENT_MODE);
3068 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_READ_CMD);
3069
3070 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
3071 return (TRUE);
3072 }
3073
btsnd_hcic_set_afh_channels(UINT8 first,UINT8 last)3074 BOOLEAN btsnd_hcic_set_afh_channels (UINT8 first, UINT8 last)
3075 {
3076 BT_HDR *p;
3077 UINT8 *pp;
3078 UINT8 channels[10] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F};
3079 int i;
3080
3081 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_SET_AFH_CHANNELS)) == NULL)
3082 return (FALSE);
3083
3084 pp = (UINT8 *)(p + 1);
3085
3086 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_SET_AFH_CHANNELS;
3087 p->offset = 0;
3088
3089 UINT16_TO_STREAM (pp, HCI_SET_AFH_CHANNELS);
3090 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_SET_AFH_CHANNELS);
3091
3092 /* Just make sure that caller did not exceed 79 Bluetooth channels */
3093 if ((first <= last) && (last <= 78))
3094 {
3095 for (i = first; i <= last; i++)
3096 {
3097 int byte_offset = i / 8;
3098 int bit_offset = i % 8;
3099 channels[byte_offset] &= ~(1 << bit_offset);
3100 }
3101 }
3102 for (i = 0; i < 10; i++)
3103 *pp++ = channels[i];
3104
3105 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
3106 return (TRUE);
3107 }
3108
btsnd_hcic_set_afh_host_channel_class(UINT8 * p_afhchannelmap)3109 BOOLEAN btsnd_hcic_set_afh_host_channel_class (UINT8 *p_afhchannelmap)
3110 {
3111 BT_HDR *p;
3112 UINT8 *pp;
3113 int i;
3114
3115 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_SET_AFH_CHANNELS)) == NULL)
3116 return (FALSE);
3117
3118 pp = (UINT8 *)(p + 1);
3119
3120 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_SET_AFH_CHANNELS;
3121 p->offset = 0;
3122
3123 UINT16_TO_STREAM (pp, HCI_SET_AFH_CHANNELS);
3124 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_SET_AFH_CHANNELS);
3125
3126 /* Copy and convert */
3127 for (i = 0; i < 10; i++)
3128 *pp++ = p_afhchannelmap[9-i];
3129
3130 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
3131 return (TRUE);
3132 }
3133
btsnd_hcic_read_afh_channel_map(UINT16 handle)3134 BOOLEAN btsnd_hcic_read_afh_channel_map (UINT16 handle)
3135 {
3136 BT_HDR *p;
3137 UINT8 *pp;
3138
3139 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_CMD_HANDLE)) == NULL)
3140 return (FALSE);
3141
3142 pp = (UINT8 *)(p + 1);
3143
3144 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_CMD_HANDLE;
3145 p->offset = 0;
3146
3147 UINT16_TO_STREAM (pp, HCI_READ_AFH_CH_MAP);
3148 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_CMD_HANDLE);
3149
3150 UINT16_TO_STREAM (pp, handle);
3151
3152 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
3153 return (TRUE);
3154 }
3155
btsnd_hcic_read_clock(UINT16 handle,UINT8 which_clock)3156 BOOLEAN btsnd_hcic_read_clock (UINT16 handle, UINT8 which_clock)
3157 {
3158 BT_HDR *p;
3159 UINT8 *pp;
3160
3161 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_READ_CLOCK)) == NULL)
3162 return (FALSE);
3163
3164 pp = (UINT8 *)(p + 1);
3165
3166 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_READ_CLOCK;
3167 p->offset = 0;
3168
3169 UINT16_TO_STREAM (pp, HCI_READ_CLOCK);
3170 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_READ_CLOCK);
3171
3172 UINT16_TO_STREAM (pp, handle);
3173 UINT8_TO_STREAM (pp, which_clock);
3174
3175 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
3176 return (TRUE);
3177 }
3178
btsnd_hcic_read_inqscan_type(void)3179 BOOLEAN btsnd_hcic_read_inqscan_type(void)
3180 {
3181 BT_HDR *p;
3182 UINT8 *pp;
3183
3184 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_READ_CMD)) == NULL)
3185 return (FALSE);
3186
3187 pp = (UINT8 *)(p + 1);
3188
3189 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_READ_CMD;
3190 p->offset = 0;
3191
3192 UINT16_TO_STREAM (pp, HCI_READ_INQSCAN_TYPE);
3193 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_READ_CMD);
3194
3195 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
3196 return (TRUE);
3197 }
3198
btsnd_hcic_write_inqscan_type(UINT8 type)3199 BOOLEAN btsnd_hcic_write_inqscan_type (UINT8 type)
3200 {
3201 BT_HDR *p;
3202 UINT8 *pp;
3203
3204 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_WRITE_PARAM1)) == NULL)
3205 return (FALSE);
3206
3207 pp = (UINT8 *)(p + 1);
3208
3209 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_WRITE_PARAM1;
3210 p->offset = 0;
3211
3212 UINT16_TO_STREAM (pp, HCI_WRITE_INQSCAN_TYPE);
3213 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_WRITE_PARAM1);
3214
3215 UINT8_TO_STREAM (pp, type);
3216
3217 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
3218 return (TRUE);
3219 }
3220
btsnd_hcic_read_inquiry_mode(void)3221 BOOLEAN btsnd_hcic_read_inquiry_mode (void)
3222 {
3223 BT_HDR *p;
3224 UINT8 *pp;
3225
3226 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_READ_CMD)) == NULL)
3227 return (FALSE);
3228
3229 pp = (UINT8 *)(p + 1);
3230
3231 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_READ_CMD;
3232 p->offset = 0;
3233
3234 UINT16_TO_STREAM (pp, HCI_READ_INQUIRY_MODE);
3235 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_READ_CMD);
3236
3237 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
3238 return (TRUE);
3239 }
3240
btsnd_hcic_write_inquiry_mode(UINT8 mode)3241 BOOLEAN btsnd_hcic_write_inquiry_mode (UINT8 mode)
3242 {
3243 BT_HDR *p;
3244 UINT8 *pp;
3245
3246 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_WRITE_PARAM1)) == NULL)
3247 return (FALSE);
3248
3249 pp = (UINT8 *)(p + 1);
3250
3251 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_WRITE_PARAM1;
3252 p->offset = 0;
3253
3254 UINT16_TO_STREAM (pp, HCI_WRITE_INQUIRY_MODE);
3255 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_WRITE_PARAM1);
3256
3257 UINT8_TO_STREAM (pp, mode);
3258
3259 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
3260 return (TRUE);
3261 }
3262
btsnd_hcic_read_pagescan_type(void)3263 BOOLEAN btsnd_hcic_read_pagescan_type (void)
3264 {
3265 BT_HDR *p;
3266 UINT8 *pp;
3267
3268 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_READ_CMD)) == NULL)
3269 return (FALSE);
3270
3271 pp = (UINT8 *)(p + 1);
3272
3273 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_READ_CMD;
3274 p->offset = 0;
3275
3276 UINT16_TO_STREAM (pp, HCI_READ_PAGESCAN_TYPE);
3277 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_READ_CMD);
3278
3279 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
3280 return (TRUE);
3281 }
3282
btsnd_hcic_write_pagescan_type(UINT8 type)3283 BOOLEAN btsnd_hcic_write_pagescan_type (UINT8 type)
3284 {
3285 BT_HDR *p;
3286 UINT8 *pp;
3287
3288 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_WRITE_PARAM1)) == NULL)
3289 return (FALSE);
3290
3291 pp = (UINT8 *)(p + 1);
3292
3293 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_WRITE_PARAM1;
3294 p->offset = 0;
3295
3296 UINT16_TO_STREAM (pp, HCI_WRITE_PAGESCAN_TYPE);
3297 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_WRITE_PARAM1);
3298
3299 UINT8_TO_STREAM (pp, type);
3300
3301 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
3302 return (TRUE);
3303 }
3304
3305 /* Must have room to store BT_HDR + max VSC length + callback pointer */
3306 #if !defined (LMP_TEST) && (HCI_CMD_POOL_BUF_SIZE < 268)
3307 #error "HCI_CMD_POOL_BUF_SIZE must be larger than 268"
3308 #endif
3309
btsnd_hcic_vendor_spec_cmd(void * buffer,UINT16 opcode,UINT8 len,UINT8 * p_data,void * p_cmd_cplt_cback)3310 void btsnd_hcic_vendor_spec_cmd (void *buffer, UINT16 opcode, UINT8 len,
3311 UINT8 *p_data, void *p_cmd_cplt_cback)
3312 {
3313 BT_HDR *p = (BT_HDR *)buffer;
3314 UINT8 *pp = (UINT8 *)(p + 1);
3315
3316 p->len = HCIC_PREAMBLE_SIZE + len;
3317 p->offset = sizeof(void *);
3318
3319 *((void **)pp) = p_cmd_cplt_cback; /* Store command complete callback in buffer */
3320 pp += sizeof(void *); /* Skip over callback pointer */
3321
3322 UINT16_TO_STREAM (pp, HCI_GRP_VENDOR_SPECIFIC | opcode);
3323 UINT8_TO_STREAM (pp, len);
3324 ARRAY_TO_STREAM (pp, p_data, len);
3325
3326 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
3327 }
3328
btsnd_hcic_data(BT_HDR * p_buf,UINT16 len,UINT16 handle,UINT8 boundary,UINT8 broadcast)3329 void btsnd_hcic_data (BT_HDR *p_buf, UINT16 len, UINT16 handle, UINT8 boundary, UINT8 broadcast)
3330 {
3331 UINT8 *p;
3332
3333 /* Higher layer should have left 4 bytes for us to fill the header */
3334 p_buf->offset -= 4;
3335 p_buf->len += 4;
3336
3337 /* Find the pointer to the beginning of the data */
3338 p = (UINT8 *)(p_buf + 1) + p_buf->offset;
3339
3340 UINT16_TO_STREAM (p, handle | ((boundary & 3) << 12) | ((broadcast & 3) << 14));
3341 UINT16_TO_STREAM (p, len);
3342
3343 HCI_ACL_DATA_TO_LOWER (p_buf);
3344 }
3345
btsnd_hcic_nop(void)3346 BOOLEAN btsnd_hcic_nop (void)
3347 {
3348 BT_HDR *p;
3349 UINT8 *pp;
3350
3351 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_READ_CMD)) == NULL)
3352 return (FALSE);
3353
3354 pp = (UINT8 *)(p + 1);
3355
3356 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_READ_CMD;
3357 p->offset = 0;
3358
3359 UINT16_TO_STREAM (pp, HCI_COMMAND_NONE);
3360 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_READ_CMD);
3361
3362 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
3363 return (TRUE);
3364 }
3365
3366