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