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 BLE_INCLUDED) && (BLE_INCLUDED == TRUE) 37 38 BOOLEAN btsnd_hcic_ble_set_local_used_feat (UINT8 feat_set[8]) 39 { 40 BT_HDR *p; 41 UINT8 *pp; 42 43 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_SET_USED_FEAT_CMD)) == NULL) 44 return (FALSE); 45 46 pp = (UINT8 *)(p + 1); 47 48 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_SET_USED_FEAT_CMD; 49 p->offset = 0; 50 51 UINT16_TO_STREAM (pp, HCI_BLE_WRITE_LOCAL_SPT_FEAT); 52 ARRAY_TO_STREAM (pp, feat_set, HCIC_PARAM_SIZE_SET_USED_FEAT_CMD); 53 54 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p); 55 return (TRUE); 56 } 57 58 BOOLEAN btsnd_hcic_ble_set_random_addr (BD_ADDR random_bda) 59 { 60 BT_HDR *p; 61 UINT8 *pp; 62 63 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_WRITE_RANDOM_ADDR_CMD)) == NULL) 64 return (FALSE); 65 66 pp = (UINT8 *)(p + 1); 67 68 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_WRITE_RANDOM_ADDR_CMD; 69 p->offset = 0; 70 71 UINT16_TO_STREAM (pp, HCI_BLE_WRITE_RANDOM_ADDR); 72 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_WRITE_RANDOM_ADDR_CMD); 73 74 BDADDR_TO_STREAM (pp, random_bda); 75 76 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p); 77 return (TRUE); 78 } 79 80 BOOLEAN btsnd_hcic_ble_write_adv_params (UINT16 adv_int_min, UINT16 adv_int_max, 81 UINT8 adv_type, UINT8 addr_type_own, 82 UINT8 addr_type_dir, BD_ADDR direct_bda, 83 UINT8 channel_map, UINT8 adv_filter_policy) 84 { 85 BT_HDR *p; 86 UINT8 *pp; 87 88 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_BLE_WRITE_ADV_PARAMS)) == NULL) 89 return (FALSE); 90 91 pp = (UINT8 *)(p + 1); 92 93 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_BLE_WRITE_ADV_PARAMS ; 94 p->offset = 0; 95 96 UINT16_TO_STREAM (pp, HCI_BLE_WRITE_ADV_PARAMS); 97 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_BLE_WRITE_ADV_PARAMS ); 98 99 UINT16_TO_STREAM (pp, adv_int_min); 100 UINT16_TO_STREAM (pp, adv_int_max); 101 UINT8_TO_STREAM (pp, adv_type); 102 UINT8_TO_STREAM (pp, addr_type_own); 103 UINT8_TO_STREAM (pp, addr_type_dir); 104 BDADDR_TO_STREAM (pp, direct_bda); 105 UINT8_TO_STREAM (pp, channel_map); 106 UINT8_TO_STREAM (pp, adv_filter_policy); 107 108 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p); 109 return (TRUE); 110 } 111 BOOLEAN btsnd_hcic_ble_read_adv_chnl_tx_power (void) 112 { 113 BT_HDR *p; 114 UINT8 *pp; 115 116 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_READ_CMD)) == NULL) 117 return (FALSE); 118 119 pp = (UINT8 *)(p + 1); 120 121 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_READ_CMD; 122 p->offset = 0; 123 124 UINT16_TO_STREAM (pp, HCI_BLE_READ_ADV_CHNL_TX_POWER); 125 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_READ_CMD); 126 127 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p); 128 return (TRUE); 129 130 } 131 132 BOOLEAN btsnd_hcic_ble_set_adv_data (UINT8 data_len, UINT8 *p_data) 133 { 134 BT_HDR *p; 135 UINT8 *pp; 136 137 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_BLE_WRITE_ADV_DATA + 1)) == NULL) 138 return (FALSE); 139 140 pp = (UINT8 *)(p + 1); 141 142 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_BLE_WRITE_ADV_DATA + 1; 143 p->offset = 0; 144 145 UINT16_TO_STREAM (pp, HCI_BLE_WRITE_ADV_DATA); 146 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_BLE_WRITE_ADV_DATA + 1); 147 148 memset(pp, 0, HCIC_PARAM_SIZE_BLE_WRITE_ADV_DATA); 149 150 if (p_data != NULL && data_len > 0) 151 { 152 if (data_len > HCIC_PARAM_SIZE_BLE_WRITE_ADV_DATA) 153 data_len = HCIC_PARAM_SIZE_BLE_WRITE_ADV_DATA; 154 155 UINT8_TO_STREAM (pp, data_len); 156 157 ARRAY_TO_STREAM (pp, p_data, data_len); 158 } 159 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p); 160 161 return (TRUE); 162 } 163 BOOLEAN btsnd_hcic_ble_set_scan_rsp_data (UINT8 data_len, UINT8 *p_scan_rsp) 164 { 165 BT_HDR *p; 166 UINT8 *pp; 167 168 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_BLE_WRITE_SCAN_RSP + 1)) == NULL) 169 return (FALSE); 170 171 pp = (UINT8 *)(p + 1); 172 173 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_BLE_WRITE_SCAN_RSP + 1; 174 p->offset = 0; 175 176 UINT16_TO_STREAM (pp, HCI_BLE_WRITE_SCAN_RSP_DATA); 177 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_BLE_WRITE_SCAN_RSP + 1); 178 179 memset(pp, 0, HCIC_PARAM_SIZE_BLE_WRITE_SCAN_RSP); 180 181 if (p_scan_rsp != NULL && data_len > 0) 182 { 183 184 if (data_len > HCIC_PARAM_SIZE_BLE_WRITE_SCAN_RSP ) 185 data_len = HCIC_PARAM_SIZE_BLE_WRITE_SCAN_RSP; 186 187 UINT8_TO_STREAM (pp, data_len); 188 189 ARRAY_TO_STREAM (pp, p_scan_rsp, data_len); 190 } 191 192 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p); 193 194 return (TRUE); 195 } 196 197 BOOLEAN btsnd_hcic_ble_set_adv_enable (UINT8 adv_enable) 198 { 199 BT_HDR *p; 200 UINT8 *pp; 201 202 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_WRITE_ADV_ENABLE)) == NULL) 203 return (FALSE); 204 205 pp = (UINT8 *)(p + 1); 206 207 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_WRITE_ADV_ENABLE; 208 p->offset = 0; 209 210 UINT16_TO_STREAM (pp, HCI_BLE_WRITE_ADV_ENABLE); 211 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_WRITE_ADV_ENABLE); 212 213 UINT8_TO_STREAM (pp, adv_enable); 214 215 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p); 216 return (TRUE); 217 } 218 BOOLEAN btsnd_hcic_ble_set_scan_params (UINT8 scan_type, 219 UINT16 scan_int, UINT16 scan_win, 220 UINT8 addr_type_own, UINT8 scan_filter_policy) 221 { 222 BT_HDR *p; 223 UINT8 *pp; 224 225 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_BLE_WRITE_SCAN_PARAM)) == NULL) 226 return (FALSE); 227 228 pp = (UINT8 *)(p + 1); 229 230 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_BLE_WRITE_SCAN_PARAM; 231 p->offset = 0; 232 233 UINT16_TO_STREAM (pp, HCI_BLE_WRITE_SCAN_PARAMS); 234 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_BLE_WRITE_SCAN_PARAM); 235 236 UINT8_TO_STREAM (pp, scan_type); 237 UINT16_TO_STREAM (pp, scan_int); 238 UINT16_TO_STREAM (pp, scan_win); 239 UINT8_TO_STREAM (pp, addr_type_own); 240 UINT8_TO_STREAM (pp, scan_filter_policy); 241 242 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p); 243 return (TRUE); 244 } 245 246 BOOLEAN btsnd_hcic_ble_set_scan_enable (UINT8 scan_enable, UINT8 duplicate) 247 { 248 BT_HDR *p; 249 UINT8 *pp; 250 251 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_BLE_WRITE_SCAN_ENABLE)) == NULL) 252 return (FALSE); 253 254 pp = (UINT8 *)(p + 1); 255 256 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_BLE_WRITE_SCAN_ENABLE; 257 p->offset = 0; 258 259 UINT16_TO_STREAM (pp, HCI_BLE_WRITE_SCAN_ENABLE); 260 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_BLE_WRITE_SCAN_ENABLE); 261 262 UINT8_TO_STREAM (pp, scan_enable); 263 UINT8_TO_STREAM (pp, duplicate); 264 265 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p); 266 return (TRUE); 267 } 268 269 /* link layer connection management commands */ 270 BOOLEAN btsnd_hcic_ble_create_ll_conn (UINT16 scan_int, UINT16 scan_win, 271 UINT8 init_filter_policy, 272 UINT8 addr_type_peer, BD_ADDR bda_peer, 273 UINT8 addr_type_own, 274 UINT16 conn_int_min, UINT16 conn_int_max, 275 UINT16 conn_latency, UINT16 conn_timeout, 276 UINT16 min_ce_len, UINT16 max_ce_len) 277 { 278 BT_HDR *p; 279 UINT8 *pp; 280 281 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_BLE_CREATE_LL_CONN)) == NULL) 282 return (FALSE); 283 284 pp = (UINT8 *)(p + 1); 285 286 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_BLE_CREATE_LL_CONN; 287 p->offset = 0; 288 289 UINT16_TO_STREAM (pp, HCI_BLE_CREATE_LL_CONN); 290 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_BLE_CREATE_LL_CONN); 291 292 UINT16_TO_STREAM (pp, scan_int); 293 UINT16_TO_STREAM (pp, scan_win); 294 UINT8_TO_STREAM (pp, init_filter_policy); 295 296 UINT8_TO_STREAM (pp, addr_type_peer); 297 BDADDR_TO_STREAM (pp, bda_peer); 298 UINT8_TO_STREAM (pp, addr_type_own); 299 300 UINT16_TO_STREAM (pp, conn_int_min); 301 UINT16_TO_STREAM (pp, conn_int_max); 302 UINT16_TO_STREAM (pp, conn_latency); 303 UINT16_TO_STREAM (pp, conn_timeout); 304 305 UINT16_TO_STREAM (pp, min_ce_len); 306 UINT16_TO_STREAM (pp, max_ce_len); 307 308 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p); 309 return (TRUE); 310 } 311 312 BOOLEAN btsnd_hcic_ble_create_conn_cancel (void) 313 { 314 BT_HDR *p; 315 UINT8 *pp; 316 317 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_BLE_CREATE_CONN_CANCEL)) == NULL) 318 return (FALSE); 319 320 pp = (UINT8 *)(p + 1); 321 322 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_BLE_CREATE_CONN_CANCEL; 323 p->offset = 0; 324 325 UINT16_TO_STREAM (pp, HCI_BLE_CREATE_CONN_CANCEL); 326 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_BLE_CREATE_CONN_CANCEL); 327 328 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p); 329 return (TRUE); 330 } 331 332 BOOLEAN btsnd_hcic_ble_clear_white_list (void) 333 { 334 BT_HDR *p; 335 UINT8 *pp; 336 337 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_CLEAR_WHITE_LIST)) == NULL) 338 return (FALSE); 339 340 pp = (UINT8 *)(p + 1); 341 342 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_CLEAR_WHITE_LIST; 343 p->offset = 0; 344 345 UINT16_TO_STREAM (pp, HCI_BLE_CLEAR_WHITE_LIST); 346 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_CLEAR_WHITE_LIST); 347 348 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p); 349 return (TRUE); 350 } 351 352 BOOLEAN btsnd_hcic_ble_add_white_list (UINT8 addr_type, BD_ADDR bda) 353 { 354 BT_HDR *p; 355 UINT8 *pp; 356 357 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_ADD_WHITE_LIST)) == NULL) 358 return (FALSE); 359 360 pp = (UINT8 *)(p + 1); 361 362 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_ADD_WHITE_LIST; 363 p->offset = 0; 364 365 UINT16_TO_STREAM (pp, HCI_BLE_ADD_WHITE_LIST); 366 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_ADD_WHITE_LIST); 367 368 UINT8_TO_STREAM (pp, addr_type); 369 BDADDR_TO_STREAM (pp, bda); 370 371 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p); 372 return (TRUE); 373 } 374 375 BOOLEAN btsnd_hcic_ble_remove_from_white_list (UINT8 addr_type, BD_ADDR bda) 376 { 377 BT_HDR *p; 378 UINT8 *pp; 379 380 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_REMOVE_WHITE_LIST)) == NULL) 381 return (FALSE); 382 383 pp = (UINT8 *)(p + 1); 384 385 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_REMOVE_WHITE_LIST; 386 p->offset = 0; 387 388 UINT16_TO_STREAM (pp, HCI_BLE_REMOVE_WHITE_LIST); 389 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_REMOVE_WHITE_LIST); 390 391 UINT8_TO_STREAM (pp, addr_type); 392 BDADDR_TO_STREAM (pp, bda); 393 394 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p); 395 return (TRUE); 396 } 397 398 BOOLEAN btsnd_hcic_ble_upd_ll_conn_params (UINT16 handle, 399 UINT16 conn_int_min, UINT16 conn_int_max, 400 UINT16 conn_latency, UINT16 conn_timeout, 401 UINT16 min_ce_len, UINT16 max_ce_len) 402 { 403 BT_HDR *p; 404 UINT8 *pp; 405 406 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_BLE_UPD_LL_CONN_PARAMS)) == NULL) 407 return (FALSE); 408 409 pp = (UINT8 *)(p + 1); 410 411 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_BLE_UPD_LL_CONN_PARAMS; 412 p->offset = 0; 413 414 UINT16_TO_STREAM (pp, HCI_BLE_UPD_LL_CONN_PARAMS); 415 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_BLE_UPD_LL_CONN_PARAMS); 416 417 UINT16_TO_STREAM (pp, handle); 418 419 UINT16_TO_STREAM (pp, conn_int_min); 420 UINT16_TO_STREAM (pp, conn_int_max); 421 UINT16_TO_STREAM (pp, conn_latency); 422 UINT16_TO_STREAM (pp, conn_timeout); 423 UINT16_TO_STREAM (pp, min_ce_len); 424 UINT16_TO_STREAM (pp, max_ce_len); 425 426 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p); 427 return (TRUE); 428 } 429 430 BOOLEAN btsnd_hcic_ble_set_host_chnl_class (UINT8 chnl_map[HCIC_BLE_CHNL_MAP_SIZE]) 431 { 432 BT_HDR *p; 433 UINT8 *pp; 434 435 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_SET_HOST_CHNL_CLASS)) == NULL) 436 return (FALSE); 437 438 pp = (UINT8 *)(p + 1); 439 440 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_SET_HOST_CHNL_CLASS; 441 p->offset = 0; 442 443 UINT16_TO_STREAM (pp, HCI_BLE_SET_HOST_CHNL_CLASS); 444 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_SET_HOST_CHNL_CLASS); 445 446 ARRAY_TO_STREAM (pp, chnl_map, HCIC_BLE_CHNL_MAP_SIZE); 447 448 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p); 449 return (TRUE); 450 } 451 452 BOOLEAN btsnd_hcic_ble_read_chnl_map (UINT16 handle) 453 { 454 BT_HDR *p; 455 UINT8 *pp; 456 457 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_READ_CHNL_MAP)) == NULL) 458 return (FALSE); 459 460 pp = (UINT8 *)(p + 1); 461 462 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_READ_CHNL_MAP; 463 p->offset = 0; 464 465 UINT16_TO_STREAM (pp, HCI_BLE_READ_CHNL_MAP); 466 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_READ_CHNL_MAP); 467 468 UINT16_TO_STREAM (pp, handle); 469 470 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p); 471 return (TRUE); 472 } 473 474 BOOLEAN btsnd_hcic_ble_read_remote_feat (UINT16 handle) 475 { 476 BT_HDR *p; 477 UINT8 *pp; 478 479 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_BLE_READ_REMOTE_FEAT)) == NULL) 480 return (FALSE); 481 482 pp = (UINT8 *)(p + 1); 483 484 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_BLE_READ_REMOTE_FEAT; 485 p->offset = 0; 486 487 UINT16_TO_STREAM (pp, HCI_BLE_READ_REMOTE_FEAT); 488 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_BLE_READ_REMOTE_FEAT); 489 490 UINT16_TO_STREAM (pp, handle); 491 492 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p); 493 return (TRUE); 494 } 495 496 /* security management commands */ 497 BOOLEAN btsnd_hcic_ble_encrypt (UINT8 *key, UINT8 key_len, 498 UINT8 *plain_text, UINT8 pt_len, 499 void *p_cmd_cplt_cback) 500 { 501 BT_HDR *p; 502 UINT8 *pp; 503 504 if ((p = HCI_GET_CMD_BUF(sizeof(BT_HDR) + sizeof (void *) + 505 HCIC_PARAM_SIZE_BLE_ENCRYPT)) == NULL) 506 return (FALSE); 507 508 pp = (UINT8 *)(p + 1); 509 510 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_BLE_ENCRYPT; 511 p->offset = sizeof(void *); 512 513 *((void **)pp) = p_cmd_cplt_cback; /* Store command complete callback in buffer */ 514 pp += sizeof(void *); /* Skip over callback pointer */ 515 516 517 UINT16_TO_STREAM (pp, HCI_BLE_ENCRYPT); 518 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_BLE_ENCRYPT); 519 520 memset(pp, 0, HCIC_PARAM_SIZE_BLE_ENCRYPT); 521 522 if (key_len > HCIC_BLE_ENCRYT_KEY_SIZE) key_len = HCIC_BLE_ENCRYT_KEY_SIZE; 523 if (pt_len > HCIC_BLE_ENCRYT_KEY_SIZE) pt_len = HCIC_BLE_ENCRYT_KEY_SIZE; 524 525 ARRAY_TO_STREAM (pp, key, key_len); 526 pp += (HCIC_BLE_ENCRYT_KEY_SIZE - key_len); 527 ARRAY_TO_STREAM (pp, plain_text, pt_len); 528 529 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p); 530 return (TRUE); 531 } 532 533 BOOLEAN btsnd_hcic_ble_rand (void *p_cmd_cplt_cback) 534 { 535 BT_HDR *p; 536 UINT8 *pp; 537 538 if ((p = HCI_GET_CMD_BUF(sizeof(BT_HDR) + sizeof (void *) + 539 HCIC_PARAM_SIZE_BLE_RAND)) == NULL) 540 return (FALSE); 541 542 pp = (UINT8 *)(p + 1); 543 544 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_BLE_RAND; 545 p->offset = sizeof(void *); 546 547 *((void **)pp) = p_cmd_cplt_cback; /* Store command complete callback in buffer */ 548 pp += sizeof(void *); /* Skip over callback pointer */ 549 550 UINT16_TO_STREAM (pp, HCI_BLE_RAND); 551 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_BLE_RAND); 552 553 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p); 554 return (TRUE); 555 } 556 557 BOOLEAN btsnd_hcic_ble_start_enc (UINT16 handle, UINT8 rand[HCIC_BLE_RAND_DI_SIZE], 558 UINT16 ediv, UINT8 ltk[HCIC_BLE_ENCRYT_KEY_SIZE]) 559 { 560 BT_HDR *p; 561 UINT8 *pp; 562 563 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_BLE_START_ENC)) == NULL) 564 return (FALSE); 565 566 pp = (UINT8 *)(p + 1); 567 568 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_BLE_START_ENC; 569 p->offset = 0; 570 571 UINT16_TO_STREAM (pp, HCI_BLE_START_ENC); 572 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_BLE_START_ENC); 573 574 UINT16_TO_STREAM (pp, handle); 575 ARRAY_TO_STREAM (pp, rand, HCIC_BLE_RAND_DI_SIZE); 576 UINT16_TO_STREAM (pp, ediv); 577 ARRAY_TO_STREAM (pp, ltk, HCIC_BLE_ENCRYT_KEY_SIZE); 578 579 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p); 580 return (TRUE); 581 } 582 583 BOOLEAN btsnd_hcic_ble_ltk_req_reply (UINT16 handle, UINT8 ltk[HCIC_BLE_ENCRYT_KEY_SIZE]) 584 { 585 BT_HDR *p; 586 UINT8 *pp; 587 588 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_LTK_REQ_REPLY)) == NULL) 589 return (FALSE); 590 591 pp = (UINT8 *)(p + 1); 592 593 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_LTK_REQ_REPLY; 594 p->offset = 0; 595 596 UINT16_TO_STREAM (pp, HCI_BLE_LTK_REQ_REPLY); 597 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_LTK_REQ_REPLY); 598 599 UINT16_TO_STREAM (pp, handle); 600 ARRAY_TO_STREAM (pp, ltk, HCIC_BLE_ENCRYT_KEY_SIZE); 601 602 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p); 603 return (TRUE); 604 } 605 606 BOOLEAN btsnd_hcic_ble_ltk_req_neg_reply (UINT16 handle) 607 { 608 BT_HDR *p; 609 UINT8 *pp; 610 611 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_LTK_REQ_NEG_REPLY)) == NULL) 612 return (FALSE); 613 614 pp = (UINT8 *)(p + 1); 615 616 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_LTK_REQ_NEG_REPLY; 617 p->offset = 0; 618 619 UINT16_TO_STREAM (pp, HCI_BLE_LTK_REQ_NEG_REPLY); 620 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_LTK_REQ_NEG_REPLY); 621 622 UINT16_TO_STREAM (pp, handle); 623 624 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p); 625 return (TRUE); 626 } 627 628 BOOLEAN btsnd_hcic_ble_receiver_test(UINT8 rx_freq) 629 { 630 BT_HDR *p; 631 UINT8 *pp; 632 633 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_WRITE_PARAM1)) == NULL) 634 return (FALSE); 635 636 pp = (UINT8 *)(p + 1); 637 638 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_WRITE_PARAM1; 639 p->offset = 0; 640 641 UINT16_TO_STREAM (pp, HCI_BLE_RECEIVER_TEST); 642 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_WRITE_PARAM1); 643 644 UINT8_TO_STREAM (pp, rx_freq); 645 646 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p); 647 return (TRUE); 648 } 649 650 BOOLEAN btsnd_hcic_ble_transmitter_test(UINT8 tx_freq, UINT8 test_data_len, UINT8 payload) 651 { 652 BT_HDR *p; 653 UINT8 *pp; 654 655 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_WRITE_PARAM3)) == NULL) 656 return (FALSE); 657 658 pp = (UINT8 *)(p + 1); 659 660 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_WRITE_PARAM3; 661 p->offset = 0; 662 663 UINT16_TO_STREAM (pp, HCI_BLE_TRANSMITTER_TEST); 664 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_WRITE_PARAM3); 665 666 UINT8_TO_STREAM (pp, tx_freq); 667 UINT8_TO_STREAM (pp, test_data_len); 668 UINT8_TO_STREAM (pp, payload); 669 670 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p); 671 return (TRUE); 672 } 673 674 BOOLEAN btsnd_hcic_ble_test_end(void) 675 { 676 BT_HDR *p; 677 UINT8 *pp; 678 679 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_READ_CMD)) == NULL) 680 return (FALSE); 681 682 pp = (UINT8 *)(p + 1); 683 684 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_READ_CMD; 685 p->offset = 0; 686 687 UINT16_TO_STREAM (pp, HCI_BLE_TEST_END); 688 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_READ_CMD); 689 690 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p); 691 return (TRUE); 692 } 693 694 BOOLEAN btsnd_hcic_ble_read_host_supported (void) 695 { 696 BT_HDR *p; 697 UINT8 *pp; 698 699 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_READ_CMD)) == NULL) 700 return (FALSE); 701 702 pp = (UINT8 *)(p + 1); 703 704 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_READ_CMD; 705 p->offset = 0; 706 707 UINT16_TO_STREAM (pp, HCI_READ_LE_HOST_SUPPORT); 708 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_READ_CMD); 709 710 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p); 711 return (TRUE); 712 } 713 714 #if (defined BLE_LLT_INCLUDED) && (BLE_LLT_INCLUDED == TRUE) 715 716 BOOLEAN btsnd_hcic_ble_rc_param_req_reply( UINT16 handle, 717 UINT16 conn_int_min, UINT16 conn_int_max, 718 UINT16 conn_latency, UINT16 conn_timeout, 719 UINT16 min_ce_len, UINT16 max_ce_len ) 720 { 721 BT_HDR *p; 722 UINT8 *pp; 723 724 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_BLE_RC_PARAM_REQ_REPLY)) == NULL) 725 return (FALSE); 726 727 pp = (UINT8 *)(p + 1); 728 729 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_BLE_RC_PARAM_REQ_REPLY; 730 p->offset = 0; 731 732 UINT16_TO_STREAM (pp, HCI_BLE_RC_PARAM_REQ_REPLY); 733 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_BLE_RC_PARAM_REQ_REPLY); 734 735 UINT16_TO_STREAM (pp, handle); 736 UINT16_TO_STREAM (pp, conn_int_min); 737 UINT16_TO_STREAM (pp, conn_int_max); 738 UINT16_TO_STREAM (pp, conn_latency); 739 UINT16_TO_STREAM (pp, conn_timeout); 740 UINT16_TO_STREAM (pp, min_ce_len); 741 UINT16_TO_STREAM (pp, max_ce_len); 742 743 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p); 744 return (TRUE); 745 } 746 747 BOOLEAN btsnd_hcic_ble_rc_param_req_neg_reply(UINT16 handle, UINT8 reason) 748 { 749 BT_HDR *p; 750 UINT8 *pp; 751 752 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_BLE_RC_PARAM_REQ_NEG_REPLY)) == NULL) 753 return (FALSE); 754 755 pp = (UINT8 *)(p + 1); 756 757 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_BLE_RC_PARAM_REQ_NEG_REPLY; 758 p->offset = 0; 759 760 UINT16_TO_STREAM (pp, HCI_BLE_RC_PARAM_REQ_NEG_REPLY); 761 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_BLE_RC_PARAM_REQ_NEG_REPLY); 762 763 UINT16_TO_STREAM (pp, handle); 764 UINT8_TO_STREAM (pp, reason); 765 766 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p); 767 return (TRUE); 768 } 769 #endif 770 771 BOOLEAN btsnd_hcic_ble_add_device_resolving_list (UINT8 addr_type_peer, BD_ADDR bda_peer, 772 UINT8 irk_peer[HCIC_BLE_IRK_SIZE], 773 UINT8 irk_local[HCIC_BLE_IRK_SIZE]) 774 { 775 BT_HDR *p; 776 UINT8 *pp; 777 778 if ((p = HCI_GET_CMD_BUF (HCIC_PARAM_SIZE_BLE_ADD_DEV_RESOLVING_LIST)) == NULL) 779 return (FALSE); 780 781 pp = (UINT8 *)(p + 1); 782 783 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_BLE_ADD_DEV_RESOLVING_LIST; 784 p->offset = 0; 785 786 UINT16_TO_STREAM (pp, HCI_BLE_ADD_DEV_RESOLVING_LIST); 787 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_BLE_ADD_DEV_RESOLVING_LIST); 788 UINT8_TO_STREAM (pp, addr_type_peer); 789 BDADDR_TO_STREAM (pp, bda_peer); 790 ARRAY_TO_STREAM (pp, irk_peer, HCIC_BLE_ENCRYT_KEY_SIZE); 791 ARRAY_TO_STREAM (pp, irk_local, HCIC_BLE_ENCRYT_KEY_SIZE); 792 793 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p); 794 795 return (TRUE); 796 } 797 798 BOOLEAN btsnd_hcic_ble_rm_device_resolving_list (UINT8 addr_type_peer, BD_ADDR bda_peer) 799 { 800 BT_HDR *p; 801 UINT8 *pp; 802 803 if ((p = HCI_GET_CMD_BUF (HCIC_PARAM_SIZE_BLE_RM_DEV_RESOLVING_LIST)) == NULL) 804 return (FALSE); 805 806 pp = (UINT8 *)(p + 1); 807 808 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_BLE_RM_DEV_RESOLVING_LIST; 809 p->offset = 0; 810 811 UINT16_TO_STREAM (pp, HCI_BLE_RM_DEV_RESOLVING_LIST); 812 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_BLE_RM_DEV_RESOLVING_LIST); 813 UINT8_TO_STREAM (pp, addr_type_peer); 814 BDADDR_TO_STREAM (pp, bda_peer); 815 816 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p); 817 818 return (TRUE); 819 } 820 821 BOOLEAN btsnd_hcic_ble_clear_resolving_list (void) 822 { 823 BT_HDR *p; 824 UINT8 *pp; 825 826 if ((p = HCI_GET_CMD_BUF (HCIC_PARAM_SIZE_BLE_CLEAR_RESOLVING_LIST)) == NULL) 827 return (FALSE); 828 829 pp = (UINT8 *)(p + 1); 830 831 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_BLE_CLEAR_RESOLVING_LIST; 832 p->offset = 0; 833 834 UINT16_TO_STREAM (pp, HCI_BLE_CLEAR_RESOLVING_LIST); 835 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_BLE_CLEAR_RESOLVING_LIST); 836 837 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p); 838 839 return (TRUE); 840 } 841 842 BOOLEAN btsnd_hcic_ble_read_resolvable_addr_peer (UINT8 addr_type_peer, BD_ADDR bda_peer) 843 { 844 BT_HDR *p; 845 UINT8 *pp; 846 847 if ((p = HCI_GET_CMD_BUF (HCIC_PARAM_SIZE_BLE_READ_RESOLVABLE_ADDR_PEER)) == NULL) 848 return (FALSE); 849 850 pp = (UINT8 *)(p + 1); 851 852 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_BLE_READ_RESOLVABLE_ADDR_PEER; 853 p->offset = 0; 854 855 UINT16_TO_STREAM (pp, HCI_BLE_READ_RESOLVABLE_ADDR_PEER); 856 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_BLE_READ_RESOLVABLE_ADDR_PEER); 857 UINT8_TO_STREAM (pp, addr_type_peer); 858 BDADDR_TO_STREAM (pp, bda_peer); 859 860 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p); 861 862 return (TRUE); 863 } 864 865 BOOLEAN btsnd_hcic_ble_read_resolvable_addr_local (UINT8 addr_type_peer, BD_ADDR bda_peer) 866 { 867 BT_HDR *p; 868 UINT8 *pp; 869 870 if ((p = HCI_GET_CMD_BUF (HCIC_PARAM_SIZE_BLE_READ_RESOLVABLE_ADDR_LOCAL)) == NULL) 871 return (FALSE); 872 873 pp = (UINT8 *)(p + 1); 874 875 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_BLE_READ_RESOLVABLE_ADDR_LOCAL; 876 p->offset = 0; 877 878 UINT16_TO_STREAM (pp, HCI_BLE_READ_RESOLVABLE_ADDR_LOCAL); 879 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_BLE_READ_RESOLVABLE_ADDR_LOCAL); 880 UINT8_TO_STREAM (pp, addr_type_peer); 881 BDADDR_TO_STREAM (pp, bda_peer); 882 883 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p); 884 885 return (TRUE); 886 } 887 888 BOOLEAN btsnd_hcic_ble_set_addr_resolution_enable (UINT8 addr_resolution_enable) 889 { 890 BT_HDR *p; 891 UINT8 *pp; 892 893 if ((p = HCI_GET_CMD_BUF (HCIC_PARAM_SIZE_BLE_SET_ADDR_RESOLUTION_ENABLE)) == NULL) 894 return (FALSE); 895 896 pp = (UINT8 *)(p + 1); 897 898 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_BLE_SET_ADDR_RESOLUTION_ENABLE; 899 p->offset = 0; 900 901 UINT16_TO_STREAM (pp, HCI_BLE_SET_ADDR_RESOLUTION_ENABLE); 902 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_BLE_SET_ADDR_RESOLUTION_ENABLE); 903 UINT8_TO_STREAM (pp, addr_resolution_enable); 904 905 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p); 906 907 return (TRUE); 908 } 909 910 BOOLEAN btsnd_hcic_ble_set_rand_priv_addr_timeout (UINT16 rpa_timout) 911 { 912 BT_HDR *p; 913 UINT8 *pp; 914 915 if ((p = HCI_GET_CMD_BUF (HCIC_PARAM_SIZE_BLE_SET_RAND_PRIV_ADDR_TIMOUT)) == NULL) 916 return (FALSE); 917 918 pp = (UINT8 *)(p + 1); 919 920 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_BLE_SET_RAND_PRIV_ADDR_TIMOUT; 921 p->offset = 0; 922 923 UINT16_TO_STREAM (pp, HCI_BLE_SET_RAND_PRIV_ADDR_TIMOUT); 924 UINT8_TO_STREAM (pp, HCIC_PARAM_SIZE_BLE_SET_RAND_PRIV_ADDR_TIMOUT); 925 UINT16_TO_STREAM (pp, rpa_timout); 926 927 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p); 928 929 return (TRUE); 930 } 931 932 BOOLEAN btsnd_hcic_ble_set_data_length(UINT16 conn_handle, UINT16 tx_octets, UINT16 tx_time) 933 { 934 BT_HDR *p; 935 UINT8 *pp; 936 937 if ((p = HCI_GET_CMD_BUF(HCIC_PARAM_SIZE_BLE_SET_DATA_LENGTH)) == NULL) 938 return FALSE; 939 940 pp = p->data; 941 942 p->len = HCIC_PREAMBLE_SIZE + HCIC_PARAM_SIZE_BLE_SET_DATA_LENGTH; 943 p->offset = 0; 944 945 UINT16_TO_STREAM(pp, HCI_BLE_SET_DATA_LENGTH); 946 UINT8_TO_STREAM(pp, HCIC_PARAM_SIZE_BLE_SET_DATA_LENGTH); 947 948 UINT16_TO_STREAM(pp, conn_handle); 949 UINT16_TO_STREAM(pp, tx_octets); 950 UINT16_TO_STREAM(pp, tx_time); 951 952 btu_hcif_send_cmd (LOCAL_BR_EDR_CONTROLLER_ID, p); 953 return TRUE; 954 } 955 956 #endif 957 958
