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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 ****/ 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 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 ****/ 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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
