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 "btcore/include/counter.h"
28 #include "gki.h"
29 #include "hcidefs.h"
30 #include "hcimsgs.h"
31 #include "hcidefs.h"
32 #include "btu.h"
33
34 #include <stddef.h>
35 #include <string.h>
36
37 #include "btm_int.h" /* Included for UIPC_* macro definitions */
38
btsnd_hcic_inquiry(const LAP inq_lap,UINT8 duration,UINT8 response_cnt)39 BOOLEAN btsnd_hcic_inquiry(const LAP inq_lap, UINT8 duration, UINT8 response_cnt)
40 {
41 BT_HDR *p;
42 UINT8 *pp;
43
44 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_INQUIRY)) == NULL)
45 return (FALSE);
46
47 pp = (UINT8 *)(p + 1);
48
49 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_INQUIRY;
50 p->offset = 0;
51
52 UINT16_TO_STREAM (pp, HCI_INQUIRY);
53 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_INQUIRY);
54
55 LAP_TO_STREAM (pp, inq_lap);
56 UINT8_TO_STREAM (pp, duration);
57 UINT8_TO_STREAM (pp, response_cnt);
58
59 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
60 return (TRUE);
61 }
62
btsnd_hcic_inq_cancel(void)63 BOOLEAN btsnd_hcic_inq_cancel(void)
64 {
65 BT_HDR *p;
66 UINT8 *pp;
67
68 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_INQ_CANCEL)) == NULL)
69 return (FALSE);
70
71 pp = (UINT8 *)(p + 1);
72
73 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_INQ_CANCEL;
74 p->offset = 0;
75 UINT16_TO_STREAM (pp, HCI_INQUIRY_CANCEL);
76 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_INQ_CANCEL);
77
78 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
79 return (TRUE);
80 }
81
btsnd_hcic_per_inq_mode(UINT16 max_period,UINT16 min_period,const LAP inq_lap,UINT8 duration,UINT8 response_cnt)82 BOOLEAN btsnd_hcic_per_inq_mode (UINT16 max_period, UINT16 min_period,
83 const LAP inq_lap, UINT8 duration, UINT8 response_cnt)
84 {
85 BT_HDR *p;
86 UINT8 *pp;
87
88 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_PER_INQ_MODE)) == NULL)
89 return (FALSE);
90
91 pp = (UINT8 *)(p + 1);
92
93 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_PER_INQ_MODE;
94 p->offset = 0;
95
96 UINT16_TO_STREAM (pp, HCI_PERIODIC_INQUIRY_MODE);
97 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_PER_INQ_MODE);
98
99 UINT16_TO_STREAM (pp, max_period);
100 UINT16_TO_STREAM (pp, min_period);
101 LAP_TO_STREAM (pp, inq_lap);
102 UINT8_TO_STREAM (pp, duration);
103 UINT8_TO_STREAM (pp, response_cnt);
104
105 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
106 return (TRUE);
107 }
108
btsnd_hcic_exit_per_inq(void)109 BOOLEAN btsnd_hcic_exit_per_inq (void)
110 {
111 BT_HDR *p;
112 UINT8 *pp;
113
114 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_EXIT_PER_INQ)) == NULL)
115 return (FALSE);
116
117 pp = (UINT8 *)(p + 1);
118
119 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_EXIT_PER_INQ;
120 p->offset = 0;
121 UINT16_TO_STREAM (pp, HCI_EXIT_PERIODIC_INQUIRY_MODE);
122 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_EXIT_PER_INQ);
123
124 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
125 return (TRUE);
126 }
127
128
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)129 BOOLEAN btsnd_hcic_create_conn(BD_ADDR dest, UINT16 packet_types,
130 UINT8 page_scan_rep_mode, UINT8 page_scan_mode,
131 UINT16 clock_offset, UINT8 allow_switch)
132 {
133 BT_HDR *p;
134 UINT8 *pp;
135
136 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_CREATE_CONN)) == NULL)
137 return (FALSE);
138
139 pp = (UINT8 *)(p + 1);
140
141 #ifndef BT_10A
142 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_CREATE_CONN;
143 #else
144 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_CREATE_CONN - 1;
145 #endif
146 p->offset = 0;
147
148 UINT16_TO_STREAM (pp, HCI_CREATE_CONNECTION);
149 #ifndef BT_10A
150 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_CREATE_CONN);
151 #else
152 UINT8_TO_STREAM (pp, (HCIC_PARAM_SIZE_CREATE_CONN - 1));
153 #endif
154 BDADDR_TO_STREAM (pp, dest);
155 UINT16_TO_STREAM (pp, packet_types);
156 UINT8_TO_STREAM (pp, page_scan_rep_mode);
157 UINT8_TO_STREAM (pp, page_scan_mode);
158 UINT16_TO_STREAM (pp, clock_offset);
159 #if !defined (BT_10A)
160 UINT8_TO_STREAM (pp, allow_switch);
161 #endif
162 btm_acl_paging (p, dest);
163 return (TRUE);
164 }
165
btsnd_hcic_disconnect(UINT16 handle,UINT8 reason)166 BOOLEAN btsnd_hcic_disconnect (UINT16 handle, UINT8 reason)
167 {
168 BT_HDR *p;
169 UINT8 *pp;
170
171 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_DISCONNECT)) == NULL)
172 return (FALSE);
173
174 pp = (UINT8 *)(p + 1);
175
176 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_DISCONNECT;
177 p->offset = 0;
178
179 UINT16_TO_STREAM (pp, HCI_DISCONNECT);
180 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_DISCONNECT);
181 UINT16_TO_STREAM (pp, handle);
182 UINT8_TO_STREAM (pp, reason);
183
184 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
185 return (TRUE);
186 }
187
188 #if BTM_SCO_INCLUDED == TRUE
btsnd_hcic_add_SCO_conn(UINT16 handle,UINT16 packet_types)189 BOOLEAN btsnd_hcic_add_SCO_conn (UINT16 handle, UINT16 packet_types)
190 {
191 BT_HDR *p;
192 UINT8 *pp;
193
194 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_ADD_SCO_CONN)) == NULL)
195 return (FALSE);
196
197 pp = (UINT8 *)(p + 1);
198
199 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_ADD_SCO_CONN;
200 p->offset = 0;
201
202 UINT16_TO_STREAM (pp, HCI_ADD_SCO_CONNECTION);
203 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_ADD_SCO_CONN);
204
205 UINT16_TO_STREAM (pp, handle);
206 UINT16_TO_STREAM (pp, packet_types);
207
208 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
209 return (TRUE);
210 }
211 #endif /* BTM_SCO_INCLUDED */
212
btsnd_hcic_create_conn_cancel(BD_ADDR dest)213 BOOLEAN btsnd_hcic_create_conn_cancel(BD_ADDR dest)
214 {
215 BT_HDR *p;
216 UINT8 *pp;
217
218 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_CREATE_CONN_CANCEL)) == NULL)
219 return (FALSE);
220
221 pp = (UINT8 *)(p + 1);
222
223 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_CREATE_CONN_CANCEL;
224 p->offset = 0;
225
226 UINT16_TO_STREAM (pp, HCI_CREATE_CONNECTION_CANCEL);
227 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_CREATE_CONN_CANCEL);
228
229 BDADDR_TO_STREAM (pp, dest);
230
231 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
232 return (TRUE);
233 }
234
btsnd_hcic_accept_conn(BD_ADDR dest,UINT8 role)235 BOOLEAN btsnd_hcic_accept_conn (BD_ADDR dest, UINT8 role)
236 {
237 BT_HDR *p;
238 UINT8 *pp;
239
240 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_ACCEPT_CONN)) == NULL)
241 return (FALSE);
242
243 pp = (UINT8 *)(p + 1);
244
245 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_ACCEPT_CONN;
246 p->offset = 0;
247
248 UINT16_TO_STREAM (pp, HCI_ACCEPT_CONNECTION_REQUEST);
249 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_ACCEPT_CONN);
250 BDADDR_TO_STREAM (pp, dest);
251 UINT8_TO_STREAM (pp, role);
252
253 counter_add("hci.conn.accept", 1);
254
255 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
256 return (TRUE);
257 }
258
btsnd_hcic_reject_conn(BD_ADDR dest,UINT8 reason)259 BOOLEAN btsnd_hcic_reject_conn (BD_ADDR dest, UINT8 reason)
260 {
261 BT_HDR *p;
262 UINT8 *pp;
263
264 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_REJECT_CONN)) == NULL)
265 return (FALSE);
266
267 pp = (UINT8 *)(p + 1);
268
269 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_REJECT_CONN;
270 p->offset = 0;
271
272 UINT16_TO_STREAM (pp, HCI_REJECT_CONNECTION_REQUEST);
273 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_REJECT_CONN);
274
275 BDADDR_TO_STREAM (pp, dest);
276 UINT8_TO_STREAM (pp, reason);
277
278 counter_add("hci.conn.reject", 1);
279
280 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
281 return (TRUE);
282 }
283
btsnd_hcic_link_key_req_reply(BD_ADDR bd_addr,LINK_KEY link_key)284 BOOLEAN btsnd_hcic_link_key_req_reply (BD_ADDR bd_addr, LINK_KEY link_key)
285 {
286 BT_HDR *p;
287 UINT8 *pp;
288
289 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_LINK_KEY_REQ_REPLY)) == NULL)
290 return (FALSE);
291
292 pp = (UINT8 *)(p + 1);
293
294 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_LINK_KEY_REQ_REPLY;
295 p->offset = 0;
296
297 UINT16_TO_STREAM (pp, HCI_LINK_KEY_REQUEST_REPLY);
298 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_LINK_KEY_REQ_REPLY);
299
300 BDADDR_TO_STREAM (pp, bd_addr);
301 ARRAY16_TO_STREAM (pp, link_key);
302
303 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
304 return (TRUE);
305 }
306
btsnd_hcic_link_key_neg_reply(BD_ADDR bd_addr)307 BOOLEAN btsnd_hcic_link_key_neg_reply (BD_ADDR bd_addr)
308 {
309 BT_HDR *p;
310 UINT8 *pp;
311
312 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_LINK_KEY_NEG_REPLY)) == NULL)
313 return (FALSE);
314
315 pp = (UINT8 *)(p + 1);
316
317 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_LINK_KEY_NEG_REPLY;
318 p->offset = 0;
319
320 UINT16_TO_STREAM (pp, HCI_LINK_KEY_REQUEST_NEG_REPLY);
321 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_LINK_KEY_NEG_REPLY);
322
323 BDADDR_TO_STREAM (pp, bd_addr);
324
325 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
326 return (TRUE);
327 }
328
btsnd_hcic_pin_code_req_reply(BD_ADDR bd_addr,UINT8 pin_code_len,PIN_CODE pin_code)329 BOOLEAN btsnd_hcic_pin_code_req_reply (BD_ADDR bd_addr, UINT8 pin_code_len,
330 PIN_CODE pin_code)
331 {
332 BT_HDR *p;
333 UINT8 *pp;
334 int i;
335
336 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_PIN_CODE_REQ_REPLY)) == NULL)
337 return (FALSE);
338
339 pp = (UINT8 *)(p + 1);
340
341 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_PIN_CODE_REQ_REPLY;
342 p->offset = 0;
343
344 UINT16_TO_STREAM (pp, HCI_PIN_CODE_REQUEST_REPLY);
345 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_PIN_CODE_REQ_REPLY);
346
347 BDADDR_TO_STREAM (pp, bd_addr);
348 UINT8_TO_STREAM (pp, pin_code_len);
349
350 for (i = 0; i < pin_code_len; i++)
351 *pp++ = *pin_code++;
352
353 for (; i < PIN_CODE_LEN; i++)
354 *pp++ = 0;
355
356
357 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
358 return (TRUE);
359 }
360
btsnd_hcic_pin_code_neg_reply(BD_ADDR bd_addr)361 BOOLEAN btsnd_hcic_pin_code_neg_reply (BD_ADDR bd_addr)
362 {
363 BT_HDR *p;
364 UINT8 *pp;
365
366 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_PIN_CODE_NEG_REPLY)) == NULL)
367 return (FALSE);
368
369 pp = (UINT8 *)(p + 1);
370
371 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_PIN_CODE_NEG_REPLY;
372 p->offset = 0;
373
374 UINT16_TO_STREAM (pp, HCI_PIN_CODE_REQUEST_NEG_REPLY);
375 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_PIN_CODE_NEG_REPLY);
376
377 BDADDR_TO_STREAM (pp, bd_addr);
378
379 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
380 return (TRUE);
381 }
382
btsnd_hcic_change_conn_type(UINT16 handle,UINT16 packet_types)383 BOOLEAN btsnd_hcic_change_conn_type (UINT16 handle, UINT16 packet_types)
384 {
385 BT_HDR *p;
386 UINT8 *pp;
387
388 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_CHANGE_CONN_TYPE)) == NULL)
389 return (FALSE);
390
391 pp = (UINT8 *)(p + 1);
392
393 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_CHANGE_CONN_TYPE;
394 p->offset = 0;
395
396 UINT16_TO_STREAM (pp, HCI_CHANGE_CONN_PACKET_TYPE);
397 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_CHANGE_CONN_TYPE);
398
399 UINT16_TO_STREAM (pp, handle);
400 UINT16_TO_STREAM (pp, packet_types);
401
402 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
403 return (TRUE);
404 }
405
btsnd_hcic_auth_request(UINT16 handle)406 BOOLEAN btsnd_hcic_auth_request (UINT16 handle)
407 {
408 BT_HDR *p;
409 UINT8 *pp;
410
411 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_CMD_HANDLE)) == NULL)
412 return (FALSE);
413
414 pp = (UINT8 *)(p + 1);
415
416 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_CMD_HANDLE;
417 p->offset = 0;
418
419 UINT16_TO_STREAM (pp, HCI_AUTHENTICATION_REQUESTED);
420 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_CMD_HANDLE);
421
422 UINT16_TO_STREAM (pp, handle);
423
424 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
425 return (TRUE);
426 }
427
btsnd_hcic_set_conn_encrypt(UINT16 handle,BOOLEAN enable)428 BOOLEAN btsnd_hcic_set_conn_encrypt (UINT16 handle, BOOLEAN enable)
429 {
430 BT_HDR *p;
431 UINT8 *pp;
432
433 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_SET_CONN_ENCRYPT)) == NULL)
434 return (FALSE);
435
436 pp = (UINT8 *)(p + 1);
437
438 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_SET_CONN_ENCRYPT;
439 p->offset = 0;
440
441 UINT16_TO_STREAM (pp, HCI_SET_CONN_ENCRYPTION);
442 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_SET_CONN_ENCRYPT);
443
444 UINT16_TO_STREAM (pp, handle);
445 UINT8_TO_STREAM (pp, enable);
446
447 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
448 return (TRUE);
449 }
450
btsnd_hcic_rmt_name_req(BD_ADDR bd_addr,UINT8 page_scan_rep_mode,UINT8 page_scan_mode,UINT16 clock_offset)451 BOOLEAN btsnd_hcic_rmt_name_req (BD_ADDR bd_addr, UINT8 page_scan_rep_mode,
452 UINT8 page_scan_mode, UINT16 clock_offset)
453 {
454 BT_HDR *p;
455 UINT8 *pp;
456
457 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_RMT_NAME_REQ)) == NULL)
458 return (FALSE);
459
460 pp = (UINT8 *)(p + 1);
461
462 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_RMT_NAME_REQ;
463 p->offset = 0;
464
465 UINT16_TO_STREAM (pp, HCI_RMT_NAME_REQUEST);
466 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_RMT_NAME_REQ);
467
468 BDADDR_TO_STREAM (pp, bd_addr);
469 UINT8_TO_STREAM (pp, page_scan_rep_mode);
470 UINT8_TO_STREAM (pp, page_scan_mode);
471 UINT16_TO_STREAM (pp, clock_offset);
472
473 btm_acl_paging (p, bd_addr);
474 return (TRUE);
475 }
476
btsnd_hcic_rmt_name_req_cancel(BD_ADDR bd_addr)477 BOOLEAN btsnd_hcic_rmt_name_req_cancel (BD_ADDR bd_addr)
478 {
479 BT_HDR *p;
480 UINT8 *pp;
481
482 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_RMT_NAME_REQ_CANCEL)) == NULL)
483 return (FALSE);
484
485 pp = (UINT8 *)(p + 1);
486
487 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_RMT_NAME_REQ_CANCEL;
488 p->offset = 0;
489
490 UINT16_TO_STREAM (pp, HCI_RMT_NAME_REQUEST_CANCEL);
491 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_RMT_NAME_REQ_CANCEL);
492
493 BDADDR_TO_STREAM (pp, bd_addr);
494
495 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
496 return (TRUE);
497 }
498
btsnd_hcic_rmt_features_req(UINT16 handle)499 BOOLEAN btsnd_hcic_rmt_features_req (UINT16 handle)
500 {
501 BT_HDR *p;
502 UINT8 *pp;
503
504 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_CMD_HANDLE)) == NULL)
505 return (FALSE);
506
507 pp = (UINT8 *)(p + 1);
508
509 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_CMD_HANDLE;
510 p->offset = 0;
511
512 UINT16_TO_STREAM (pp, HCI_READ_RMT_FEATURES);
513 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_CMD_HANDLE);
514
515 UINT16_TO_STREAM (pp, handle);
516
517 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
518 return (TRUE);
519 }
520
btsnd_hcic_rmt_ext_features(UINT16 handle,UINT8 page_num)521 BOOLEAN btsnd_hcic_rmt_ext_features (UINT16 handle, UINT8 page_num)
522 {
523 BT_HDR *p;
524 UINT8 *pp;
525
526 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_RMT_EXT_FEATURES)) == NULL)
527 return (FALSE);
528
529 pp = (UINT8 *)(p + 1);
530
531 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_RMT_EXT_FEATURES;
532 p->offset = 0;
533
534 UINT16_TO_STREAM (pp, HCI_READ_RMT_EXT_FEATURES);
535 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_RMT_EXT_FEATURES);
536
537 UINT16_TO_STREAM (pp, handle);
538 UINT8_TO_STREAM (pp, page_num);
539
540 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
541 return (TRUE);
542 }
543
btsnd_hcic_rmt_ver_req(UINT16 handle)544 BOOLEAN btsnd_hcic_rmt_ver_req (UINT16 handle)
545 {
546 BT_HDR *p;
547 UINT8 *pp;
548
549 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_CMD_HANDLE)) == NULL)
550 return (FALSE);
551
552 pp = (UINT8 *)(p + 1);
553
554 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_CMD_HANDLE;
555 p->offset = 0;
556
557 UINT16_TO_STREAM (pp, HCI_READ_RMT_VERSION_INFO);
558 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_CMD_HANDLE);
559
560 UINT16_TO_STREAM (pp, handle);
561
562 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
563 return (TRUE);
564 }
565
btsnd_hcic_read_rmt_clk_offset(UINT16 handle)566 BOOLEAN btsnd_hcic_read_rmt_clk_offset (UINT16 handle)
567 {
568 BT_HDR *p;
569 UINT8 *pp;
570
571 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_CMD_HANDLE)) == NULL)
572 return (FALSE);
573
574 pp = (UINT8 *)(p + 1);
575
576 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_CMD_HANDLE;
577 p->offset = 0;
578
579 UINT16_TO_STREAM (pp, HCI_READ_RMT_CLOCK_OFFSET);
580 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_CMD_HANDLE);
581
582 UINT16_TO_STREAM (pp, handle);
583
584 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
585 return (TRUE);
586 }
587
btsnd_hcic_read_lmp_handle(UINT16 handle)588 BOOLEAN btsnd_hcic_read_lmp_handle (UINT16 handle)
589 {
590 BT_HDR *p;
591 UINT8 *pp;
592
593 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_CMD_HANDLE)) == NULL)
594 return (FALSE);
595
596 pp = (UINT8 *)(p + 1);
597
598 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_CMD_HANDLE;
599 p->offset = 0;
600
601 UINT16_TO_STREAM (pp, HCI_READ_LMP_HANDLE);
602 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_CMD_HANDLE);
603
604 UINT16_TO_STREAM (pp, handle);
605
606 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
607 return (TRUE);
608 }
609
btsnd_hcic_setup_esco_conn(UINT16 handle,UINT32 tx_bw,UINT32 rx_bw,UINT16 max_latency,UINT16 voice,UINT8 retrans_effort,UINT16 packet_types)610 BOOLEAN btsnd_hcic_setup_esco_conn (UINT16 handle, UINT32 tx_bw,
611 UINT32 rx_bw, UINT16 max_latency, UINT16 voice,
612 UINT8 retrans_effort, UINT16 packet_types)
613 {
614 BT_HDR *p;
615 UINT8 *pp;
616
617 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_SETUP_ESCO)) == NULL)
618 return (FALSE);
619
620 pp = (UINT8 *)(p + 1);
621
622 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_SETUP_ESCO;
623 p->offset = 0;
624
625 UINT16_TO_STREAM (pp, HCI_SETUP_ESCO_CONNECTION);
626 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_SETUP_ESCO);
627
628 UINT16_TO_STREAM (pp, handle);
629 UINT32_TO_STREAM (pp, tx_bw);
630 UINT32_TO_STREAM (pp, rx_bw);
631 UINT16_TO_STREAM (pp, max_latency);
632 UINT16_TO_STREAM (pp, voice);
633 UINT8_TO_STREAM (pp, retrans_effort);
634 UINT16_TO_STREAM (pp, packet_types);
635
636 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
637 return (TRUE);
638 }
639
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)640 BOOLEAN btsnd_hcic_accept_esco_conn (BD_ADDR bd_addr, UINT32 tx_bw,
641 UINT32 rx_bw, UINT16 max_latency,
642 UINT16 content_fmt, UINT8 retrans_effort,
643 UINT16 packet_types)
644 {
645 BT_HDR *p;
646 UINT8 *pp;
647
648 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_ACCEPT_ESCO)) == NULL)
649 return (FALSE);
650
651 pp = (UINT8 *)(p + 1);
652
653 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_ACCEPT_ESCO;
654 p->offset = 0;
655
656 UINT16_TO_STREAM (pp, HCI_ACCEPT_ESCO_CONNECTION);
657 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_ACCEPT_ESCO);
658
659 BDADDR_TO_STREAM (pp, bd_addr);
660 UINT32_TO_STREAM (pp, tx_bw);
661 UINT32_TO_STREAM (pp, rx_bw);
662 UINT16_TO_STREAM (pp, max_latency);
663 UINT16_TO_STREAM (pp, content_fmt);
664 UINT8_TO_STREAM (pp, retrans_effort);
665 UINT16_TO_STREAM (pp, packet_types);
666
667 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
668 return (TRUE);
669 }
670
btsnd_hcic_reject_esco_conn(BD_ADDR bd_addr,UINT8 reason)671 BOOLEAN btsnd_hcic_reject_esco_conn (BD_ADDR bd_addr, UINT8 reason)
672 {
673 BT_HDR *p;
674 UINT8 *pp;
675
676 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_REJECT_ESCO)) == NULL)
677 return (FALSE);
678
679 pp = (UINT8 *)(p + 1);
680
681 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_REJECT_ESCO;
682 p->offset = 0;
683
684 UINT16_TO_STREAM (pp, HCI_REJECT_ESCO_CONNECTION);
685 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_REJECT_ESCO);
686
687 BDADDR_TO_STREAM (pp, bd_addr);
688 UINT8_TO_STREAM (pp, reason);
689
690 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
691 return (TRUE);
692 }
693
btsnd_hcic_hold_mode(UINT16 handle,UINT16 max_hold_period,UINT16 min_hold_period)694 BOOLEAN btsnd_hcic_hold_mode (UINT16 handle, UINT16 max_hold_period,
695 UINT16 min_hold_period)
696 {
697 BT_HDR *p;
698 UINT8 *pp;
699
700 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_HOLD_MODE)) == NULL)
701 return (FALSE);
702
703 pp = (UINT8 *)(p + 1);
704
705 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_HOLD_MODE;
706 p->offset = 0;
707
708 UINT16_TO_STREAM (pp, HCI_HOLD_MODE);
709 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_HOLD_MODE);
710
711 UINT16_TO_STREAM (pp, handle);
712 UINT16_TO_STREAM (pp, max_hold_period);
713 UINT16_TO_STREAM (pp, min_hold_period);
714
715 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
716 return (TRUE);
717 }
718
btsnd_hcic_sniff_mode(UINT16 handle,UINT16 max_sniff_period,UINT16 min_sniff_period,UINT16 sniff_attempt,UINT16 sniff_timeout)719 BOOLEAN btsnd_hcic_sniff_mode (UINT16 handle, UINT16 max_sniff_period,
720 UINT16 min_sniff_period, UINT16 sniff_attempt,
721 UINT16 sniff_timeout)
722 {
723 BT_HDR *p;
724 UINT8 *pp;
725
726 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_SNIFF_MODE)) == NULL)
727 return (FALSE);
728
729 pp = (UINT8 *)(p + 1);
730
731 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_SNIFF_MODE;
732 p->offset = 0;
733
734 UINT16_TO_STREAM (pp, HCI_SNIFF_MODE);
735 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_SNIFF_MODE);
736
737 UINT16_TO_STREAM (pp, handle);
738 UINT16_TO_STREAM (pp, max_sniff_period);
739 UINT16_TO_STREAM (pp, min_sniff_period);
740 UINT16_TO_STREAM (pp, sniff_attempt);
741 UINT16_TO_STREAM (pp, sniff_timeout);
742
743 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
744 return (TRUE);
745 }
746
btsnd_hcic_exit_sniff_mode(UINT16 handle)747 BOOLEAN btsnd_hcic_exit_sniff_mode (UINT16 handle)
748 {
749 BT_HDR *p;
750 UINT8 *pp;
751
752 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_CMD_HANDLE)) == NULL)
753 return (FALSE);
754
755 pp = (UINT8 *)(p + 1);
756
757 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_CMD_HANDLE;
758 p->offset = 0;
759
760 UINT16_TO_STREAM (pp, HCI_EXIT_SNIFF_MODE);
761 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_CMD_HANDLE);
762
763 UINT16_TO_STREAM (pp, handle);
764
765 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
766 return TRUE;
767 }
768
btsnd_hcic_park_mode(UINT16 handle,UINT16 beacon_max_interval,UINT16 beacon_min_interval)769 BOOLEAN btsnd_hcic_park_mode (UINT16 handle, UINT16 beacon_max_interval,
770 UINT16 beacon_min_interval)
771 {
772 BT_HDR *p;
773 UINT8 *pp;
774
775 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_PARK_MODE)) == NULL)
776 return (FALSE);
777
778 pp = (UINT8 *)(p + 1);
779
780 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_PARK_MODE;
781 p->offset = 0;
782
783 UINT16_TO_STREAM (pp, HCI_PARK_MODE);
784 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_PARK_MODE);
785
786 UINT16_TO_STREAM (pp, handle);
787 UINT16_TO_STREAM (pp, beacon_max_interval);
788 UINT16_TO_STREAM (pp, beacon_min_interval);
789
790 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
791 return (TRUE);
792 }
793
btsnd_hcic_exit_park_mode(UINT16 handle)794 BOOLEAN btsnd_hcic_exit_park_mode (UINT16 handle)
795 {
796 BT_HDR *p;
797 UINT8 *pp;
798
799 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_CMD_HANDLE)) == NULL)
800 return (FALSE);
801
802 pp = (UINT8 *)(p + 1);
803
804 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_CMD_HANDLE;
805 p->offset = 0;
806
807 UINT16_TO_STREAM (pp, HCI_EXIT_PARK_MODE);
808 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_CMD_HANDLE);
809
810 UINT16_TO_STREAM (pp, handle);
811
812 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
813 return TRUE;
814 }
815
btsnd_hcic_qos_setup(UINT16 handle,UINT8 flags,UINT8 service_type,UINT32 token_rate,UINT32 peak,UINT32 latency,UINT32 delay_var)816 BOOLEAN btsnd_hcic_qos_setup (UINT16 handle, UINT8 flags, UINT8 service_type,
817 UINT32 token_rate, UINT32 peak, UINT32 latency,
818 UINT32 delay_var)
819 {
820 BT_HDR *p;
821 UINT8 *pp;
822
823 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_QOS_SETUP)) == NULL)
824 return (FALSE);
825
826 pp = (UINT8 *)(p + 1);
827
828 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_QOS_SETUP;
829 p->offset = 0;
830
831 UINT16_TO_STREAM (pp, HCI_QOS_SETUP);
832 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_QOS_SETUP);
833
834 UINT16_TO_STREAM (pp, handle);
835 UINT8_TO_STREAM (pp, flags);
836 UINT8_TO_STREAM (pp, service_type);
837 UINT32_TO_STREAM (pp, token_rate);
838 UINT32_TO_STREAM (pp, peak);
839 UINT32_TO_STREAM (pp, latency);
840 UINT32_TO_STREAM (pp, delay_var);
841
842 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
843 return (TRUE);
844 }
845
btsnd_hcic_switch_role(BD_ADDR bd_addr,UINT8 role)846 BOOLEAN btsnd_hcic_switch_role (BD_ADDR bd_addr, UINT8 role)
847 {
848 BT_HDR *p;
849 UINT8 *pp;
850
851 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_SWITCH_ROLE)) == NULL)
852 return (FALSE);
853
854 pp = (UINT8 *)(p + 1);
855
856 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_SWITCH_ROLE;
857 p->offset = 0;
858
859 UINT16_TO_STREAM (pp, HCI_SWITCH_ROLE);
860 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_SWITCH_ROLE);
861
862 BDADDR_TO_STREAM (pp, bd_addr);
863 UINT8_TO_STREAM (pp, role);
864
865 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
866 return (TRUE);
867 }
868
btsnd_hcic_write_policy_set(UINT16 handle,UINT16 settings)869 BOOLEAN btsnd_hcic_write_policy_set (UINT16 handle, UINT16 settings)
870 {
871 BT_HDR *p;
872 UINT8 *pp;
873
874 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_WRITE_POLICY_SET)) == NULL)
875 return (FALSE);
876
877 pp = (UINT8 *)(p + 1);
878
879 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_WRITE_POLICY_SET;
880 p->offset = 0;
881 UINT16_TO_STREAM (pp, HCI_WRITE_POLICY_SETTINGS);
882 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_WRITE_POLICY_SET);
883
884 UINT16_TO_STREAM (pp, handle);
885 UINT16_TO_STREAM (pp, settings);
886
887 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
888 return (TRUE);
889 }
890
btsnd_hcic_write_def_policy_set(UINT16 settings)891 BOOLEAN btsnd_hcic_write_def_policy_set (UINT16 settings)
892 {
893 BT_HDR *p;
894 UINT8 *pp;
895
896 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_WRITE_DEF_POLICY_SET)) == NULL)
897 return (FALSE);
898
899 pp = (UINT8 *)(p + 1);
900
901 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_WRITE_DEF_POLICY_SET;
902 p->offset = 0;
903 UINT16_TO_STREAM (pp, HCI_WRITE_DEF_POLICY_SETTINGS);
904 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_WRITE_DEF_POLICY_SET);
905
906 UINT16_TO_STREAM (pp, settings);
907
908 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
909 return (TRUE);
910 }
911
btsnd_hcic_set_event_filter(UINT8 filt_type,UINT8 filt_cond_type,UINT8 * filt_cond,UINT8 filt_cond_len)912 BOOLEAN btsnd_hcic_set_event_filter (UINT8 filt_type, UINT8 filt_cond_type,
913 UINT8 *filt_cond, UINT8 filt_cond_len)
914 {
915 BT_HDR *p;
916 UINT8 *pp;
917
918 /* Use buffer large enough to hold all sizes in this command */
919 if ((p = HCI_GET_CMD_BUF(2 + filt_cond_len)) == NULL)
920 return (FALSE);
921
922 pp = (UINT8 *)(p + 1);
923
924 p->offset = 0;
925
926 UINT16_TO_STREAM (pp, HCI_SET_EVENT_FILTER);
927
928 if (filt_type)
929 {
930 p->len = (UINT16)(HCIC_PREAMBLE_SIZE + 2 + filt_cond_len);
931 UINT8_TO_STREAM (pp, (UINT8)(2 + filt_cond_len));
932
933 UINT8_TO_STREAM (pp, filt_type);
934 UINT8_TO_STREAM (pp, filt_cond_type);
935
936 if (filt_cond_type == HCI_FILTER_COND_DEVICE_CLASS)
937 {
938 DEVCLASS_TO_STREAM (pp, filt_cond);
939 filt_cond += DEV_CLASS_LEN;
940 DEVCLASS_TO_STREAM (pp, filt_cond);
941 filt_cond += DEV_CLASS_LEN;
942
943 filt_cond_len -= (2 * DEV_CLASS_LEN);
944 }
945 else if (filt_cond_type == HCI_FILTER_COND_BD_ADDR)
946 {
947 BDADDR_TO_STREAM (pp, filt_cond);
948 filt_cond += BD_ADDR_LEN;
949
950 filt_cond_len -= BD_ADDR_LEN;
951 }
952
953 if (filt_cond_len)
954 ARRAY_TO_STREAM (pp, filt_cond, filt_cond_len);
955 }
956 else
957 {
958 p->len = (UINT16)(HCIC_PREAMBLE_SIZE + 1);
959 UINT8_TO_STREAM (pp, 1);
960
961 UINT8_TO_STREAM (pp, filt_type);
962 }
963
964 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
965 return (TRUE);
966 }
967
btsnd_hcic_write_pin_type(UINT8 type)968 BOOLEAN btsnd_hcic_write_pin_type (UINT8 type)
969 {
970 BT_HDR *p;
971 UINT8 *pp;
972
973 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_WRITE_PARAM1)) == NULL)
974 return (FALSE);
975
976 pp = (UINT8 *)(p + 1);
977
978 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_WRITE_PARAM1;
979 p->offset = 0;
980
981 UINT16_TO_STREAM (pp, HCI_WRITE_PIN_TYPE);
982 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_WRITE_PARAM1);
983
984 UINT8_TO_STREAM (pp, type);
985
986 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
987 return (TRUE);
988 }
989
btsnd_hcic_delete_stored_key(BD_ADDR bd_addr,BOOLEAN delete_all_flag)990 BOOLEAN btsnd_hcic_delete_stored_key (BD_ADDR bd_addr, BOOLEAN delete_all_flag)
991 {
992 BT_HDR *p;
993 UINT8 *pp;
994
995 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_DELETE_STORED_KEY)) == NULL)
996 return (FALSE);
997
998 pp = (UINT8 *)(p + 1);
999
1000 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_DELETE_STORED_KEY;
1001 p->offset = 0;
1002
1003 UINT16_TO_STREAM (pp, HCI_DELETE_STORED_LINK_KEY);
1004 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_DELETE_STORED_KEY);
1005
1006 BDADDR_TO_STREAM (pp, bd_addr);
1007 UINT8_TO_STREAM (pp, delete_all_flag);
1008
1009 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1010 return (TRUE);
1011 }
1012
btsnd_hcic_change_name(BD_NAME name)1013 BOOLEAN btsnd_hcic_change_name (BD_NAME name)
1014 {
1015 BT_HDR *p;
1016 UINT8 *pp;
1017 UINT16 len = strlen ((char *)name) + 1;
1018
1019 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_CHANGE_NAME)) == NULL)
1020 return (FALSE);
1021
1022 pp = (UINT8 *)(p + 1);
1023 memset(pp, 0, HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_CHANGE_NAME);
1024
1025 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_CHANGE_NAME;
1026 p->offset = 0;
1027
1028 UINT16_TO_STREAM (pp, HCI_CHANGE_LOCAL_NAME);
1029 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_CHANGE_NAME);
1030
1031 if (len > HCIC_PARAM_SIZE_CHANGE_NAME)
1032 len = HCIC_PARAM_SIZE_CHANGE_NAME;
1033
1034 ARRAY_TO_STREAM (pp, name, len);
1035
1036 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1037 return (TRUE);
1038 }
1039
btsnd_hcic_read_name(void)1040 BOOLEAN btsnd_hcic_read_name (void)
1041 {
1042 BT_HDR *p;
1043 UINT8 *pp;
1044
1045 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_READ_CMD)) == NULL)
1046 return (FALSE);
1047
1048 pp = (UINT8 *)(p + 1);
1049
1050 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_READ_CMD;
1051 p->offset = 0;
1052
1053 UINT16_TO_STREAM (pp, HCI_READ_LOCAL_NAME);
1054 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_READ_CMD);
1055
1056 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1057 return (TRUE);
1058 }
1059
btsnd_hcic_write_page_tout(UINT16 timeout)1060 BOOLEAN btsnd_hcic_write_page_tout (UINT16 timeout)
1061 {
1062 BT_HDR *p;
1063 UINT8 *pp;
1064
1065 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_WRITE_PARAM2)) == NULL)
1066 return (FALSE);
1067
1068 pp = (UINT8 *)(p + 1);
1069
1070 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_WRITE_PARAM2;
1071 p->offset = 0;
1072
1073 UINT16_TO_STREAM (pp, HCI_WRITE_PAGE_TOUT);
1074 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_WRITE_PARAM2);
1075
1076 UINT16_TO_STREAM (pp, timeout);
1077
1078 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1079 return (TRUE);
1080 }
1081
btsnd_hcic_write_scan_enable(UINT8 flag)1082 BOOLEAN btsnd_hcic_write_scan_enable (UINT8 flag)
1083 {
1084 BT_HDR *p;
1085 UINT8 *pp;
1086
1087 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_WRITE_PARAM1)) == NULL)
1088 return (FALSE);
1089
1090 pp = (UINT8 *)(p + 1);
1091
1092 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_WRITE_PARAM1;
1093 p->offset = 0;
1094
1095 UINT16_TO_STREAM (pp, HCI_WRITE_SCAN_ENABLE);
1096 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_WRITE_PARAM1);
1097
1098 UINT8_TO_STREAM (pp, flag);
1099
1100 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1101 return (TRUE);
1102 }
1103
btsnd_hcic_write_pagescan_cfg(UINT16 interval,UINT16 window)1104 BOOLEAN btsnd_hcic_write_pagescan_cfg(UINT16 interval, UINT16 window)
1105 {
1106 BT_HDR *p;
1107 UINT8 *pp;
1108
1109 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_WRITE_PAGESCAN_CFG)) == NULL)
1110 return (FALSE);
1111
1112 pp = (UINT8 *)(p + 1);
1113
1114 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_WRITE_PAGESCAN_CFG;
1115 p->offset = 0;
1116
1117 UINT16_TO_STREAM (pp, HCI_WRITE_PAGESCAN_CFG);
1118 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_WRITE_PAGESCAN_CFG);
1119
1120 UINT16_TO_STREAM (pp, interval);
1121 UINT16_TO_STREAM (pp, window);
1122
1123 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1124 return (TRUE);
1125 }
1126
btsnd_hcic_write_inqscan_cfg(UINT16 interval,UINT16 window)1127 BOOLEAN btsnd_hcic_write_inqscan_cfg(UINT16 interval, UINT16 window)
1128 {
1129 BT_HDR *p;
1130 UINT8 *pp;
1131
1132 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_WRITE_INQSCAN_CFG)) == NULL)
1133 return (FALSE);
1134
1135 pp = (UINT8 *)(p + 1);
1136
1137 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_WRITE_INQSCAN_CFG;
1138 p->offset = 0;
1139
1140 UINT16_TO_STREAM (pp, HCI_WRITE_INQUIRYSCAN_CFG);
1141 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_WRITE_INQSCAN_CFG);
1142
1143 UINT16_TO_STREAM (pp, interval);
1144 UINT16_TO_STREAM (pp, window);
1145
1146 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1147 return (TRUE);
1148 }
1149
btsnd_hcic_write_auth_enable(UINT8 flag)1150 BOOLEAN btsnd_hcic_write_auth_enable (UINT8 flag)
1151 {
1152 BT_HDR *p;
1153 UINT8 *pp;
1154
1155 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_WRITE_PARAM1)) == NULL)
1156 return (FALSE);
1157
1158 pp = (UINT8 *)(p + 1);
1159
1160 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_WRITE_PARAM1;
1161 p->offset = 0;
1162
1163 UINT16_TO_STREAM (pp, HCI_WRITE_AUTHENTICATION_ENABLE);
1164 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_WRITE_PARAM1);
1165
1166 UINT8_TO_STREAM (pp, flag);
1167
1168 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1169 return (TRUE);
1170 }
1171
btsnd_hcic_write_dev_class(DEV_CLASS dev_class)1172 BOOLEAN btsnd_hcic_write_dev_class(DEV_CLASS dev_class)
1173 {
1174 BT_HDR *p;
1175 UINT8 *pp;
1176
1177 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_WRITE_PARAM3)) == NULL)
1178 return (FALSE);
1179
1180 pp = (UINT8 *)(p + 1);
1181
1182 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_WRITE_PARAM3;
1183 p->offset = 0;
1184
1185 UINT16_TO_STREAM (pp, HCI_WRITE_CLASS_OF_DEVICE);
1186 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_WRITE_PARAM3);
1187
1188 DEVCLASS_TO_STREAM (pp, dev_class);
1189
1190 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1191 return (TRUE);
1192 }
1193
btsnd_hcic_write_voice_settings(UINT16 flags)1194 BOOLEAN btsnd_hcic_write_voice_settings(UINT16 flags)
1195 {
1196 BT_HDR *p;
1197 UINT8 *pp;
1198
1199 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_WRITE_PARAM2)) == NULL)
1200 return (FALSE);
1201
1202 pp = (UINT8 *)(p + 1);
1203
1204 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_WRITE_PARAM2;
1205 p->offset = 0;
1206
1207 UINT16_TO_STREAM (pp, HCI_WRITE_VOICE_SETTINGS);
1208 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_WRITE_PARAM2);
1209
1210 UINT16_TO_STREAM (pp, flags);
1211
1212 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1213 return (TRUE);
1214 }
1215
btsnd_hcic_write_auto_flush_tout(UINT16 handle,UINT16 tout)1216 BOOLEAN btsnd_hcic_write_auto_flush_tout (UINT16 handle, UINT16 tout)
1217 {
1218 BT_HDR *p;
1219 UINT8 *pp;
1220
1221 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_WRITE_AUTO_FLUSH_TOUT)) == NULL)
1222 return (FALSE);
1223
1224 pp = (UINT8 *)(p + 1);
1225
1226 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_WRITE_AUTO_FLUSH_TOUT;
1227 p->offset = 0;
1228
1229 UINT16_TO_STREAM (pp, HCI_WRITE_AUTO_FLUSH_TOUT);
1230 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_WRITE_AUTO_FLUSH_TOUT);
1231
1232 UINT16_TO_STREAM (pp, handle);
1233 UINT16_TO_STREAM (pp, tout);
1234
1235 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1236 return (TRUE);
1237 }
1238
btsnd_hcic_read_tx_power(UINT16 handle,UINT8 type)1239 BOOLEAN btsnd_hcic_read_tx_power (UINT16 handle, UINT8 type)
1240 {
1241 BT_HDR *p;
1242 UINT8 *pp;
1243
1244 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_READ_TX_POWER)) == NULL)
1245 return (FALSE);
1246
1247 pp = (UINT8 *)(p + 1);
1248
1249 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_READ_TX_POWER;
1250 p->offset = 0;
1251
1252 UINT16_TO_STREAM (pp, HCI_READ_TRANSMIT_POWER_LEVEL);
1253 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_READ_TX_POWER);
1254
1255 UINT16_TO_STREAM (pp, handle);
1256 UINT8_TO_STREAM (pp, type);
1257
1258 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1259 return (TRUE);
1260 }
1261
btsnd_hcic_host_num_xmitted_pkts(UINT8 num_handles,UINT16 * handle,UINT16 * num_pkts)1262 BOOLEAN btsnd_hcic_host_num_xmitted_pkts (UINT8 num_handles, UINT16 *handle,
1263 UINT16 *num_pkts)
1264 {
1265 BT_HDR *p;
1266 UINT8 *pp;
1267 int j;
1268
1269 if ((p = HCI_GET_CMD_BUF(1 + (num_handles * 4))) == NULL)
1270 return (FALSE);
1271
1272 pp = (UINT8 *)(p + 1);
1273
1274 p->len = HCIC_PREAMBLE_SIZE + 1 + (num_handles * 4);
1275 p->offset = 0;
1276
1277 UINT16_TO_STREAM (pp, HCI_HOST_NUM_PACKETS_DONE);
1278 UINT8_TO_STREAM (pp, p->len - HCIC_PREAMBLE_SIZE);
1279
1280 UINT8_TO_STREAM (pp, num_handles);
1281
1282 for (j = 0; j < num_handles; j++)
1283 {
1284 UINT16_TO_STREAM (pp, handle[j]);
1285 UINT16_TO_STREAM (pp, num_pkts[j]);
1286 }
1287
1288 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1289 return (TRUE);
1290 }
1291
btsnd_hcic_write_link_super_tout(UINT8 local_controller_id,UINT16 handle,UINT16 timeout)1292 BOOLEAN btsnd_hcic_write_link_super_tout (UINT8 local_controller_id, UINT16 handle, UINT16 timeout)
1293 {
1294 BT_HDR *p;
1295 UINT8 *pp;
1296
1297 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_WRITE_LINK_SUPER_TOUT)) == NULL)
1298 return (FALSE);
1299
1300 pp = (UINT8 *)(p + 1);
1301
1302 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_WRITE_LINK_SUPER_TOUT;
1303 p->offset = 0;
1304
1305 UINT16_TO_STREAM (pp, HCI_WRITE_LINK_SUPER_TOUT);
1306 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_WRITE_LINK_SUPER_TOUT);
1307
1308 UINT16_TO_STREAM (pp, handle);
1309 UINT16_TO_STREAM (pp, timeout);
1310
1311 btu_hcif_send_cmd (local_controller_id, p);
1312 return (TRUE);
1313 }
1314
btsnd_hcic_write_cur_iac_lap(UINT8 num_cur_iac,LAP * const iac_lap)1315 BOOLEAN btsnd_hcic_write_cur_iac_lap (UINT8 num_cur_iac, LAP * const iac_lap)
1316 {
1317 BT_HDR *p;
1318 UINT8 *pp;
1319 int i;
1320
1321 if ((p = HCI_GET_CMD_BUF(1 + (LAP_LEN * num_cur_iac))) == NULL)
1322 return (FALSE);
1323
1324 pp = (UINT8 *)(p + 1);
1325
1326 p->len = HCIC_PREAMBLE_SIZE + 1 + (LAP_LEN * num_cur_iac);
1327 p->offset = 0;
1328
1329 UINT16_TO_STREAM (pp, HCI_WRITE_CURRENT_IAC_LAP);
1330 UINT8_TO_STREAM (pp, p->len - HCIC_PREAMBLE_SIZE);
1331
1332 UINT8_TO_STREAM (pp, num_cur_iac);
1333
1334 for (i = 0; i < num_cur_iac; i++)
1335 LAP_TO_STREAM (pp, iac_lap[i]);
1336
1337 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1338 return (TRUE);
1339 }
1340
1341 /******************************************
1342 ** Lisbon Features
1343 *******************************************/
1344 #if BTM_SSR_INCLUDED == TRUE
1345
btsnd_hcic_sniff_sub_rate(UINT16 handle,UINT16 max_lat,UINT16 min_remote_lat,UINT16 min_local_lat)1346 BOOLEAN btsnd_hcic_sniff_sub_rate(UINT16 handle, UINT16 max_lat,
1347 UINT16 min_remote_lat, UINT16 min_local_lat)
1348 {
1349 BT_HDR *p;
1350 UINT8 *pp;
1351
1352 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_SNIFF_SUB_RATE)) == NULL)
1353 return (FALSE);
1354
1355 pp = (UINT8 *)(p + 1);
1356
1357 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_SNIFF_SUB_RATE;
1358 p->offset = 0;
1359
1360 UINT16_TO_STREAM (pp, HCI_SNIFF_SUB_RATE);
1361 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_SNIFF_SUB_RATE);
1362
1363 UINT16_TO_STREAM (pp, handle);
1364 UINT16_TO_STREAM (pp, max_lat);
1365 UINT16_TO_STREAM (pp, min_remote_lat);
1366 UINT16_TO_STREAM (pp, min_local_lat);
1367
1368 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1369 return (TRUE);
1370 }
1371 #endif /* BTM_SSR_INCLUDED */
1372
1373 /**** Extended Inquiry Response Commands ****/
btsnd_hcic_write_ext_inquiry_response(void * buffer,UINT8 fec_req)1374 void btsnd_hcic_write_ext_inquiry_response (void *buffer, UINT8 fec_req)
1375 {
1376 BT_HDR *p = (BT_HDR *)buffer;
1377 UINT8 *pp = (UINT8 *)(p + 1);
1378
1379 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_EXT_INQ_RESP;
1380 p->offset = 0;
1381
1382 UINT16_TO_STREAM (pp, HCI_WRITE_EXT_INQ_RESPONSE);
1383 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_EXT_INQ_RESP);
1384
1385 UINT8_TO_STREAM (pp, fec_req);
1386
1387 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1388 }
1389
btsnd_hcic_io_cap_req_reply(BD_ADDR bd_addr,UINT8 capability,UINT8 oob_present,UINT8 auth_req)1390 BOOLEAN btsnd_hcic_io_cap_req_reply (BD_ADDR bd_addr, UINT8 capability,
1391 UINT8 oob_present, UINT8 auth_req)
1392 {
1393 BT_HDR *p;
1394 UINT8 *pp;
1395
1396 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_IO_CAP_RESP)) == NULL)
1397 return (FALSE);
1398
1399 pp = (UINT8 *)(p + 1);
1400
1401 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_IO_CAP_RESP;
1402 p->offset = 0;
1403
1404 UINT16_TO_STREAM (pp, HCI_IO_CAPABILITY_REQUEST_REPLY);
1405 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_IO_CAP_RESP);
1406
1407 BDADDR_TO_STREAM (pp, bd_addr);
1408 UINT8_TO_STREAM (pp, capability);
1409 UINT8_TO_STREAM (pp, oob_present);
1410 UINT8_TO_STREAM (pp, auth_req);
1411
1412 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1413 return (TRUE);
1414 }
1415
btsnd_hcic_io_cap_req_neg_reply(BD_ADDR bd_addr,UINT8 err_code)1416 BOOLEAN btsnd_hcic_io_cap_req_neg_reply (BD_ADDR bd_addr, UINT8 err_code)
1417 {
1418 BT_HDR *p;
1419 UINT8 *pp;
1420
1421 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_IO_CAP_NEG_REPLY)) == NULL)
1422 return (FALSE);
1423
1424 pp = (UINT8 *)(p + 1);
1425
1426 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_IO_CAP_NEG_REPLY;
1427 p->offset = 0;
1428
1429 UINT16_TO_STREAM (pp, HCI_IO_CAP_REQ_NEG_REPLY);
1430 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_IO_CAP_NEG_REPLY);
1431
1432 BDADDR_TO_STREAM (pp, bd_addr);
1433 UINT8_TO_STREAM (pp, err_code);
1434
1435 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1436 return (TRUE);
1437 }
1438
btsnd_hcic_read_local_oob_data(void)1439 BOOLEAN btsnd_hcic_read_local_oob_data (void)
1440 {
1441 BT_HDR *p;
1442 UINT8 *pp;
1443
1444 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_R_LOCAL_OOB)) == NULL)
1445 return (FALSE);
1446
1447 pp = (UINT8 *)(p + 1);
1448
1449 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_R_LOCAL_OOB;
1450 p->offset = 0;
1451
1452 UINT16_TO_STREAM (pp, HCI_READ_LOCAL_OOB_DATA);
1453 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_R_LOCAL_OOB);
1454
1455 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1456 return (TRUE);
1457 }
1458
btsnd_hcic_user_conf_reply(BD_ADDR bd_addr,BOOLEAN is_yes)1459 BOOLEAN btsnd_hcic_user_conf_reply (BD_ADDR bd_addr, BOOLEAN is_yes)
1460 {
1461 BT_HDR *p;
1462 UINT8 *pp;
1463
1464 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_UCONF_REPLY)) == NULL)
1465 return (FALSE);
1466
1467 pp = (UINT8 *)(p + 1);
1468
1469 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_UCONF_REPLY;
1470 p->offset = 0;
1471
1472 if (!is_yes)
1473 {
1474 /* Negative reply */
1475 UINT16_TO_STREAM (pp, HCI_USER_CONF_VALUE_NEG_REPLY);
1476 }
1477 else
1478 {
1479 /* Confirmation */
1480 UINT16_TO_STREAM (pp, HCI_USER_CONF_REQUEST_REPLY);
1481 }
1482
1483 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_UCONF_REPLY);
1484
1485 BDADDR_TO_STREAM (pp, bd_addr);
1486
1487 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1488 return (TRUE);
1489 }
1490
btsnd_hcic_user_passkey_reply(BD_ADDR bd_addr,UINT32 value)1491 BOOLEAN btsnd_hcic_user_passkey_reply (BD_ADDR bd_addr, UINT32 value)
1492 {
1493 BT_HDR *p;
1494 UINT8 *pp;
1495
1496 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_U_PKEY_REPLY)) == NULL)
1497 return (FALSE);
1498
1499 pp = (UINT8 *)(p + 1);
1500
1501 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_U_PKEY_REPLY;
1502 p->offset = 0;
1503
1504 UINT16_TO_STREAM (pp, HCI_USER_PASSKEY_REQ_REPLY);
1505 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_U_PKEY_REPLY);
1506
1507 BDADDR_TO_STREAM (pp, bd_addr);
1508 UINT32_TO_STREAM (pp, value);
1509
1510 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1511 return (TRUE);
1512 }
1513
btsnd_hcic_user_passkey_neg_reply(BD_ADDR bd_addr)1514 BOOLEAN btsnd_hcic_user_passkey_neg_reply (BD_ADDR bd_addr)
1515 {
1516 BT_HDR *p;
1517 UINT8 *pp;
1518
1519 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_U_PKEY_NEG_REPLY)) == NULL)
1520 return (FALSE);
1521
1522 pp = (UINT8 *)(p + 1);
1523
1524 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_U_PKEY_NEG_REPLY;
1525 p->offset = 0;
1526
1527 UINT16_TO_STREAM (pp, HCI_USER_PASSKEY_REQ_NEG_REPLY);
1528 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_U_PKEY_NEG_REPLY);
1529
1530 BDADDR_TO_STREAM (pp, bd_addr);
1531
1532 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1533 return (TRUE);
1534 }
1535
btsnd_hcic_rem_oob_reply(BD_ADDR bd_addr,UINT8 * p_c,UINT8 * p_r)1536 BOOLEAN btsnd_hcic_rem_oob_reply (BD_ADDR bd_addr, UINT8 *p_c, UINT8 *p_r)
1537 {
1538 BT_HDR *p;
1539 UINT8 *pp;
1540
1541 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_REM_OOB_REPLY)) == NULL)
1542 return (FALSE);
1543
1544 pp = (UINT8 *)(p + 1);
1545
1546 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_REM_OOB_REPLY;
1547 p->offset = 0;
1548
1549 UINT16_TO_STREAM (pp, HCI_REM_OOB_DATA_REQ_REPLY);
1550 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_REM_OOB_REPLY);
1551
1552 BDADDR_TO_STREAM (pp, bd_addr);
1553 ARRAY16_TO_STREAM (pp, p_c);
1554 ARRAY16_TO_STREAM (pp, p_r);
1555
1556 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1557 return (TRUE);
1558 }
1559
btsnd_hcic_rem_oob_neg_reply(BD_ADDR bd_addr)1560 BOOLEAN btsnd_hcic_rem_oob_neg_reply (BD_ADDR bd_addr)
1561 {
1562 BT_HDR *p;
1563 UINT8 *pp;
1564
1565 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_REM_OOB_NEG_REPLY)) == NULL)
1566 return (FALSE);
1567
1568 pp = (UINT8 *)(p + 1);
1569
1570 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_REM_OOB_NEG_REPLY;
1571 p->offset = 0;
1572
1573 UINT16_TO_STREAM (pp, HCI_REM_OOB_DATA_REQ_NEG_REPLY);
1574 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_REM_OOB_NEG_REPLY);
1575
1576 BDADDR_TO_STREAM (pp, bd_addr);
1577
1578 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1579 return (TRUE);
1580 }
1581
1582
btsnd_hcic_read_inq_tx_power(void)1583 BOOLEAN btsnd_hcic_read_inq_tx_power (void)
1584 {
1585 BT_HDR *p;
1586 UINT8 *pp;
1587
1588 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_R_TX_POWER)) == NULL)
1589 return (FALSE);
1590
1591 pp = (UINT8 *)(p + 1);
1592
1593 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_R_TX_POWER;
1594 p->offset = 0;
1595
1596 UINT16_TO_STREAM (pp, HCI_READ_INQ_TX_POWER_LEVEL);
1597 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_R_TX_POWER);
1598
1599 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1600 return (TRUE);
1601 }
1602
btsnd_hcic_send_keypress_notif(BD_ADDR bd_addr,UINT8 notif)1603 BOOLEAN btsnd_hcic_send_keypress_notif (BD_ADDR bd_addr, UINT8 notif)
1604 {
1605 BT_HDR *p;
1606 UINT8 *pp;
1607
1608 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_SEND_KEYPRESS_NOTIF)) == NULL)
1609 return (FALSE);
1610
1611 pp = (UINT8 *)(p + 1);
1612
1613 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_SEND_KEYPRESS_NOTIF;
1614 p->offset = 0;
1615
1616 UINT16_TO_STREAM (pp, HCI_SEND_KEYPRESS_NOTIF);
1617 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_SEND_KEYPRESS_NOTIF);
1618
1619 BDADDR_TO_STREAM (pp, bd_addr);
1620 UINT8_TO_STREAM (pp, notif);
1621
1622 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1623 return (TRUE);
1624 }
1625
1626 /**** end of Simple Pairing Commands ****/
1627
1628 #if L2CAP_NON_FLUSHABLE_PB_INCLUDED == TRUE
btsnd_hcic_enhanced_flush(UINT16 handle,UINT8 packet_type)1629 BOOLEAN btsnd_hcic_enhanced_flush (UINT16 handle, UINT8 packet_type)
1630 {
1631 BT_HDR *p;
1632 UINT8 *pp;
1633
1634 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_ENHANCED_FLUSH)) == NULL)
1635 return (FALSE);
1636
1637 pp = (UINT8 *)(p + 1);
1638
1639 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_ENHANCED_FLUSH;
1640 p->offset = 0;
1641 UINT16_TO_STREAM (pp, HCI_ENHANCED_FLUSH);
1642 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_ENHANCED_FLUSH);
1643
1644 UINT16_TO_STREAM (pp, handle);
1645 UINT8_TO_STREAM (pp, packet_type);
1646
1647 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1648 return (TRUE);
1649 }
1650 #endif
1651
1652 /*************************
1653 ** End of Lisbon Commands
1654 **************************/
1655
btsnd_hcic_get_link_quality(UINT16 handle)1656 BOOLEAN btsnd_hcic_get_link_quality (UINT16 handle)
1657 {
1658 BT_HDR *p;
1659 UINT8 *pp;
1660
1661 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_CMD_HANDLE)) == NULL)
1662 return (FALSE);
1663
1664 pp = (UINT8 *)(p + 1);
1665
1666 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_CMD_HANDLE;
1667 p->offset = 0;
1668
1669 UINT16_TO_STREAM (pp, HCI_GET_LINK_QUALITY);
1670 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_CMD_HANDLE);
1671
1672 UINT16_TO_STREAM (pp, handle);
1673
1674 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1675 return (TRUE);
1676 }
1677
btsnd_hcic_read_rssi(UINT16 handle)1678 BOOLEAN btsnd_hcic_read_rssi (UINT16 handle)
1679 {
1680 BT_HDR *p;
1681 UINT8 *pp;
1682
1683 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_CMD_HANDLE)) == NULL)
1684 return (FALSE);
1685
1686 pp = (UINT8 *)(p + 1);
1687
1688 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_CMD_HANDLE;
1689 p->offset = 0;
1690
1691 UINT16_TO_STREAM (pp, HCI_READ_RSSI);
1692 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_CMD_HANDLE);
1693
1694 UINT16_TO_STREAM (pp, handle);
1695
1696 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1697 return (TRUE);
1698 }
1699
btsnd_hcic_enable_test_mode(void)1700 BOOLEAN btsnd_hcic_enable_test_mode (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_ENABLE_DEV_UNDER_TEST_MODE);
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_inqscan_type(UINT8 type)1720 BOOLEAN btsnd_hcic_write_inqscan_type (UINT8 type)
1721 {
1722 BT_HDR *p;
1723 UINT8 *pp;
1724
1725 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_WRITE_PARAM1)) == NULL)
1726 return (FALSE);
1727
1728 pp = (UINT8 *)(p + 1);
1729
1730 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_WRITE_PARAM1;
1731 p->offset = 0;
1732
1733 UINT16_TO_STREAM (pp, HCI_WRITE_INQSCAN_TYPE);
1734 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_WRITE_PARAM1);
1735
1736 UINT8_TO_STREAM (pp, type);
1737
1738 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1739 return (TRUE);
1740 }
1741
btsnd_hcic_write_inquiry_mode(UINT8 mode)1742 BOOLEAN btsnd_hcic_write_inquiry_mode (UINT8 mode)
1743 {
1744 BT_HDR *p;
1745 UINT8 *pp;
1746
1747 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_WRITE_PARAM1)) == NULL)
1748 return (FALSE);
1749
1750 pp = (UINT8 *)(p + 1);
1751
1752 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_WRITE_PARAM1;
1753 p->offset = 0;
1754
1755 UINT16_TO_STREAM (pp, HCI_WRITE_INQUIRY_MODE);
1756 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_WRITE_PARAM1);
1757
1758 UINT8_TO_STREAM (pp, mode);
1759
1760 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1761 return (TRUE);
1762 }
1763
btsnd_hcic_write_pagescan_type(UINT8 type)1764 BOOLEAN btsnd_hcic_write_pagescan_type (UINT8 type)
1765 {
1766 BT_HDR *p;
1767 UINT8 *pp;
1768
1769 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_WRITE_PARAM1)) == NULL)
1770 return (FALSE);
1771
1772 pp = (UINT8 *)(p + 1);
1773
1774 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_WRITE_PARAM1;
1775 p->offset = 0;
1776
1777 UINT16_TO_STREAM (pp, HCI_WRITE_PAGESCAN_TYPE);
1778 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_WRITE_PARAM1);
1779
1780 UINT8_TO_STREAM (pp, type);
1781
1782 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1783 return (TRUE);
1784 }
1785
1786 /* Must have room to store BT_HDR + max VSC length + callback pointer */
1787 #if (HCI_CMD_POOL_BUF_SIZE < 268)
1788 #error "HCI_CMD_POOL_BUF_SIZE must be larger than 268"
1789 #endif
1790
btsnd_hcic_vendor_spec_cmd(void * buffer,UINT16 opcode,UINT8 len,UINT8 * p_data,void * p_cmd_cplt_cback)1791 void btsnd_hcic_vendor_spec_cmd (void *buffer, UINT16 opcode, UINT8 len,
1792 UINT8 *p_data, void *p_cmd_cplt_cback)
1793 {
1794 BT_HDR *p = (BT_HDR *)buffer;
1795 UINT8 *pp = (UINT8 *)(p + 1);
1796
1797 p->len = HCIC_PREAMBLE_SIZE + len;
1798 p->offset = sizeof(void *);
1799
1800 *((void **)pp) = p_cmd_cplt_cback; /* Store command complete callback in buffer */
1801 pp += sizeof(void *); /* Skip over callback pointer */
1802
1803 UINT16_TO_STREAM (pp, HCI_GRP_VENDOR_SPECIFIC | opcode);
1804 UINT8_TO_STREAM (pp, len);
1805 ARRAY_TO_STREAM (pp, p_data, len);
1806
1807 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p);
1808 }
1809