1 /* 2 * 3 * BlueZ - Bluetooth protocol stack for Linux 4 * 5 * Copyright (C) 2000-2001 Qualcomm Incorporated 6 * Copyright (C) 2002-2003 Maxim Krasnyansky <maxk (at) qualcomm.com> 7 * Copyright (C) 2002-2010 Marcel Holtmann <marcel (at) holtmann.org> 8 * 9 * 10 * This program is free software; you can redistribute it and/or modify 11 * it under the terms of the GNU General Public License as published by 12 * the Free Software Foundation; either version 2 of the License, or 13 * (at your option) any later version. 14 * 15 * This program is distributed in the hope that it will be useful, 16 * but WITHOUT ANY WARRANTY; without even the implied warranty of 17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 * GNU General Public License for more details. 19 * 20 * You should have received a copy of the GNU General Public License 21 * along with this program; if not, write to the Free Software 22 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 23 * 24 */ 25 26 #ifdef HAVE_CONFIG_H 27 #include <config.h> 28 #endif 29 30 #include <stdio.h> 31 #include <errno.h> 32 #include <fcntl.h> 33 #include <unistd.h> 34 #include <stdlib.h> 35 #include <string.h> 36 37 #include <sys/param.h> 38 #include <sys/uio.h> 39 #include <sys/poll.h> 40 #include <sys/types.h> 41 #include <sys/ioctl.h> 42 #include <sys/socket.h> 43 44 #include "bluetooth.h" 45 #include "hci.h" 46 #include "hci_lib.h" 47 48 #ifndef MIN 49 #define MIN(x, y) ((x) < (y) ? (x) : (y)) 50 #endif 51 52 typedef struct { 53 char *str; 54 unsigned int val; 55 } hci_map; 56 57 static char *hci_bit2str(hci_map *m, unsigned int val) 58 { 59 char *str = malloc(120); 60 char *ptr = str; 61 62 if (!str) 63 return NULL; 64 65 *ptr = 0; 66 while (m->str) { 67 if ((unsigned int) m->val & val) 68 ptr += sprintf(ptr, "%s ", m->str); 69 m++; 70 } 71 return str; 72 } 73 74 static int hci_str2bit(hci_map *map, char *str, unsigned int *val) 75 { 76 char *t, *ptr; 77 hci_map *m; 78 int set; 79 80 if (!str || !(str = ptr = strdup(str))) 81 return 0; 82 83 *val = set = 0; 84 85 while ((t = strsep(&ptr, ","))) { 86 for (m = map; m->str; m++) { 87 if (!strcasecmp(m->str, t)) { 88 *val |= (unsigned int) m->val; 89 set = 1; 90 } 91 } 92 } 93 free(str); 94 95 return set; 96 } 97 98 static char *hci_uint2str(hci_map *m, unsigned int val) 99 { 100 char *str = malloc(50); 101 char *ptr = str; 102 103 if (!str) 104 return NULL; 105 106 *ptr = 0; 107 while (m->str) { 108 if ((unsigned int) m->val == val) { 109 ptr += sprintf(ptr, "%s", m->str); 110 break; 111 } 112 m++; 113 } 114 return str; 115 } 116 117 static int hci_str2uint(hci_map *map, char *str, unsigned int *val) 118 { 119 char *t, *ptr; 120 hci_map *m; 121 int set = 0; 122 123 if (!str) 124 return 0; 125 126 str = ptr = strdup(str); 127 128 while ((t = strsep(&ptr, ","))) { 129 for (m = map; m->str; m++) { 130 if (!strcasecmp(m->str,t)) { 131 *val = (unsigned int) m->val; set = 1; 132 break; 133 } 134 } 135 } 136 free(str); 137 138 return set; 139 } 140 141 char *hci_bustostr(int bus) 142 { 143 switch (bus) { 144 case HCI_VIRTUAL: 145 return "VIRTUAL"; 146 case HCI_USB: 147 return "USB"; 148 case HCI_PCCARD: 149 return "PCCARD"; 150 case HCI_UART: 151 return "UART"; 152 case HCI_RS232: 153 return "RS232"; 154 case HCI_PCI: 155 return "PCI"; 156 case HCI_SDIO: 157 return "SDIO"; 158 default: 159 return "UNKNOWN"; 160 } 161 } 162 163 char *hci_dtypetostr(int type) 164 { 165 return hci_bustostr(type & 0x0f); 166 } 167 168 char *hci_typetostr(int type) 169 { 170 switch (type) { 171 case HCI_BREDR: 172 return "BR/EDR"; 173 case HCI_80211: 174 return "802.11"; 175 default: 176 return "UNKNOWN"; 177 } 178 } 179 180 /* HCI dev flags mapping */ 181 static hci_map dev_flags_map[] = { 182 { "UP", HCI_UP }, 183 { "INIT", HCI_INIT }, 184 { "RUNNING", HCI_RUNNING }, 185 { "RAW", HCI_RAW }, 186 { "PSCAN", HCI_PSCAN }, 187 { "ISCAN", HCI_ISCAN }, 188 { "INQUIRY", HCI_INQUIRY }, 189 { "AUTH", HCI_AUTH }, 190 { "ENCRYPT", HCI_ENCRYPT }, 191 { NULL } 192 }; 193 194 char *hci_dflagstostr(uint32_t flags) 195 { 196 char *str = bt_malloc(50); 197 char *ptr = str; 198 hci_map *m = dev_flags_map; 199 200 if (!str) 201 return NULL; 202 203 *ptr = 0; 204 205 if (!hci_test_bit(HCI_UP, &flags)) 206 ptr += sprintf(ptr, "DOWN "); 207 208 while (m->str) { 209 if (hci_test_bit(m->val, &flags)) 210 ptr += sprintf(ptr, "%s ", m->str); 211 m++; 212 } 213 return str; 214 } 215 216 /* HCI packet type mapping */ 217 static hci_map pkt_type_map[] = { 218 { "DM1", HCI_DM1 }, 219 { "DM3", HCI_DM3 }, 220 { "DM5", HCI_DM5 }, 221 { "DH1", HCI_DH1 }, 222 { "DH3", HCI_DH3 }, 223 { "DH5", HCI_DH5 }, 224 { "HV1", HCI_HV1 }, 225 { "HV2", HCI_HV2 }, 226 { "HV3", HCI_HV3 }, 227 { "2-DH1", HCI_2DH1 }, 228 { "2-DH3", HCI_2DH3 }, 229 { "2-DH5", HCI_2DH5 }, 230 { "3-DH1", HCI_3DH1 }, 231 { "3-DH3", HCI_3DH3 }, 232 { "3-DH5", HCI_3DH5 }, 233 { NULL } 234 }; 235 236 static hci_map sco_ptype_map[] = { 237 { "HV1", 0x0001 }, 238 { "HV2", 0x0002 }, 239 { "HV3", 0x0004 }, 240 { "EV3", HCI_EV3 }, 241 { "EV4", HCI_EV4 }, 242 { "EV5", HCI_EV5 }, 243 { "2-EV3", HCI_2EV3 }, 244 { "2-EV5", HCI_2EV5 }, 245 { "3-EV3", HCI_3EV3 }, 246 { "3-EV5", HCI_3EV5 }, 247 { NULL } 248 }; 249 250 char *hci_ptypetostr(unsigned int ptype) 251 { 252 return hci_bit2str(pkt_type_map, ptype); 253 } 254 255 int hci_strtoptype(char *str, unsigned int *val) 256 { 257 return hci_str2bit(pkt_type_map, str, val); 258 } 259 260 char *hci_scoptypetostr(unsigned int ptype) 261 { 262 return hci_bit2str(sco_ptype_map, ptype); 263 } 264 265 int hci_strtoscoptype(char *str, unsigned int *val) 266 { 267 return hci_str2bit(sco_ptype_map, str, val); 268 } 269 270 /* Link policy mapping */ 271 static hci_map link_policy_map[] = { 272 { "NONE", 0 }, 273 { "RSWITCH", HCI_LP_RSWITCH }, 274 { "HOLD", HCI_LP_HOLD }, 275 { "SNIFF", HCI_LP_SNIFF }, 276 { "PARK", HCI_LP_PARK }, 277 { NULL } 278 }; 279 280 char *hci_lptostr(unsigned int lp) 281 { 282 return hci_bit2str(link_policy_map, lp); 283 } 284 285 int hci_strtolp(char *str, unsigned int *val) 286 { 287 return hci_str2bit(link_policy_map, str, val); 288 } 289 290 /* Link mode mapping */ 291 static hci_map link_mode_map[] = { 292 { "NONE", 0 }, 293 { "ACCEPT", HCI_LM_ACCEPT }, 294 { "MASTER", HCI_LM_MASTER }, 295 { "AUTH", HCI_LM_AUTH }, 296 { "ENCRYPT", HCI_LM_ENCRYPT }, 297 { "TRUSTED", HCI_LM_TRUSTED }, 298 { "RELIABLE", HCI_LM_RELIABLE }, 299 { "SECURE", HCI_LM_SECURE }, 300 { NULL } 301 }; 302 303 char *hci_lmtostr(unsigned int lm) 304 { 305 char *s, *str = bt_malloc(50); 306 if (!str) 307 return NULL; 308 309 *str = 0; 310 if (!(lm & HCI_LM_MASTER)) 311 strcpy(str, "SLAVE "); 312 313 s = hci_bit2str(link_mode_map, lm); 314 if (!s) { 315 bt_free(str); 316 return NULL; 317 } 318 319 strcat(str, s); 320 free(s); 321 return str; 322 } 323 324 int hci_strtolm(char *str, unsigned int *val) 325 { 326 return hci_str2bit(link_mode_map, str, val); 327 } 328 329 /* Command mapping */ 330 static hci_map commands_map[] = { 331 { "Inquiry", 0 }, 332 { "Inquiry Cancel", 1 }, 333 { "Periodic Inquiry Mode", 2 }, 334 { "Exit Periodic Inquiry Mode", 3 }, 335 { "Create Connection", 4 }, 336 { "Disconnect", 5 }, 337 { "Add SCO Connection", 6 }, 338 { "Cancel Create Connection", 7 }, 339 340 { "Accept Connection Request", 8 }, 341 { "Reject Connection Request", 9 }, 342 { "Link Key Request Reply", 10 }, 343 { "Link Key Request Negative Reply", 11 }, 344 { "PIN Code Request Reply", 12 }, 345 { "PIN Code Request Negative Reply", 13 }, 346 { "Change Connection Packet Type", 14 }, 347 { "Authentication Requested", 15 }, 348 349 { "Set Connection Encryption", 16 }, 350 { "Change Connection Link Key", 17 }, 351 { "Master Link Key", 18 }, 352 { "Remote Name Request", 19 }, 353 { "Cancel Remote Name Request", 20 }, 354 { "Read Remote Supported Features", 21 }, 355 { "Read Remote Extended Features", 22 }, 356 { "Read Remote Version Information", 23 }, 357 358 { "Read Clock Offset", 24 }, 359 { "Read LMP Handle", 25 }, 360 { "Reserved", 26 }, 361 { "Reserved", 27 }, 362 { "Reserved", 28 }, 363 { "Reserved", 29 }, 364 { "Reserved", 30 }, 365 { "Reserved", 31 }, 366 367 { "Reserved", 32 }, 368 { "Hold Mode", 33 }, 369 { "Sniff Mode", 34 }, 370 { "Exit Sniff Mode", 35 }, 371 { "Park State", 36 }, 372 { "Exit Park State", 37 }, 373 { "QoS Setup", 38 }, 374 { "Role Discovery", 39 }, 375 376 { "Switch Role", 40 }, 377 { "Read Link Policy Settings", 41 }, 378 { "Write Link Policy Settings", 42 }, 379 { "Read Default Link Policy Settings", 43 }, 380 { "Write Default Link Policy Settings", 44 }, 381 { "Flow Specification", 45 }, 382 { "Set Event Mask", 46 }, 383 { "Reset", 47 }, 384 385 { "Set Event Filter", 48 }, 386 { "Flush", 49 }, 387 { "Read PIN Type", 50 }, 388 { "Write PIN Type", 51 }, 389 { "Create New Unit Key", 52 }, 390 { "Read Stored Link Key", 53 }, 391 { "Write Stored Link Key", 54 }, 392 { "Delete Stored Link Key", 55 }, 393 394 { "Write Local Name", 56 }, 395 { "Read Local Name", 57 }, 396 { "Read Connection Accept Timeout", 58 }, 397 { "Write Connection Accept Timeout", 59 }, 398 { "Read Page Timeout", 60 }, 399 { "Write Page Timeout", 61 }, 400 { "Read Scan Enable", 62 }, 401 { "Write Scan Enable", 63 }, 402 403 { "Read Page Scan Activity", 64 }, 404 { "Write Page Scan Activity", 65 }, 405 { "Read Inquiry Scan Activity", 66 }, 406 { "Write Inquiry Scan Activity", 67 }, 407 { "Read Authentication Enable", 68 }, 408 { "Write Authentication Enable", 69 }, 409 { "Read Encryption Mode", 70 }, 410 { "Write Encryption Mode", 71 }, 411 412 { "Read Class Of Device", 72 }, 413 { "Write Class Of Device", 73 }, 414 { "Read Voice Setting", 74 }, 415 { "Write Voice Setting", 75 }, 416 { "Read Automatic Flush Timeout", 76 }, 417 { "Write Automatic Flush Timeout", 77 }, 418 { "Read Num Broadcast Retransmissions", 78 }, 419 { "Write Num Broadcast Retransmissions", 79 }, 420 421 { "Read Hold Mode Activity", 80 }, 422 { "Write Hold Mode Activity", 81 }, 423 { "Read Transmit Power Level", 82 }, 424 { "Read Synchronous Flow Control Enable", 83 }, 425 { "Write Synchronous Flow Control Enable", 84 }, 426 { "Set Host Controller To Host Flow Control", 85 }, 427 { "Host Buffer Size", 86 }, 428 { "Host Number Of Completed Packets", 87 }, 429 430 { "Read Link Supervision Timeout", 88 }, 431 { "Write Link Supervision Timeout", 89 }, 432 { "Read Number of Supported IAC", 90 }, 433 { "Read Current IAC LAP", 91 }, 434 { "Write Current IAC LAP", 92 }, 435 { "Read Page Scan Period Mode", 93 }, 436 { "Write Page Scan Period Mode", 94 }, 437 { "Read Page Scan Mode", 95 }, 438 439 { "Write Page Scan Mode", 96 }, 440 { "Set AFH Channel Classification", 97 }, 441 { "Reserved", 98 }, 442 { "Reserved", 99 }, 443 { "Read Inquiry Scan Type", 100 }, 444 { "Write Inquiry Scan Type", 101 }, 445 { "Read Inquiry Mode", 102 }, 446 { "Write Inquiry Mode", 103 }, 447 448 { "Read Page Scan Type", 104 }, 449 { "Write Page Scan Type", 105 }, 450 { "Read AFH Channel Assessment Mode", 106 }, 451 { "Write AFH Channel Assessment Mode", 107 }, 452 { "Reserved", 108 }, 453 { "Reserved", 109 }, 454 { "Reserved", 110 }, 455 { "Reserved", 111 }, 456 457 { "Reserved", 112 }, 458 { "Reserved", 113 }, 459 { "Reserved", 114 }, 460 { "Read Local Version Information", 115 }, 461 { "Read Local Supported Commands", 116 }, 462 { "Read Local Supported Features", 117 }, 463 { "Read Local Extended Features", 118 }, 464 { "Read Buffer Size", 119 }, 465 466 { "Read Country Code", 120 }, 467 { "Read BD ADDR", 121 }, 468 { "Read Failed Contact Counter", 122 }, 469 { "Reset Failed Contact Counter", 123 }, 470 { "Get Link Quality", 124 }, 471 { "Read RSSI", 125 }, 472 { "Read AFH Channel Map", 126 }, 473 { "Read BD Clock", 127 }, 474 475 { "Read Loopback Mode", 128 }, 476 { "Write Loopback Mode", 129 }, 477 { "Enable Device Under Test Mode", 130 }, 478 { "Setup Synchronous Connection", 131 }, 479 { "Accept Synchronous Connection", 132 }, 480 { "Reject Synchronous Connection", 133 }, 481 { "Reserved", 134 }, 482 { "Reserved", 135 }, 483 484 { "Read Extended Inquiry Response", 136 }, 485 { "Write Extended Inquiry Response", 137 }, 486 { "Refresh Encryption Key", 138 }, 487 { "Reserved", 139 }, 488 { "Sniff Subrating", 140 }, 489 { "Read Simple Pairing Mode", 141 }, 490 { "Write Simple Pairing Mode", 142 }, 491 { "Read Local OOB Data", 143 }, 492 493 { "Read Inquiry Response Transmit Power Level", 144 }, 494 { "Write Inquiry Transmit Power Level", 145 }, 495 { "Read Default Erroneous Data Reporting", 146 }, 496 { "Write Default Erroneous Data Reporting", 147 }, 497 { "Reserved", 148 }, 498 { "Reserved", 149 }, 499 { "Reserved", 150 }, 500 { "IO Capability Request Reply", 151 }, 501 502 { "User Confirmation Request Reply", 152 }, 503 { "User Confirmation Request Negative Reply", 153 }, 504 { "User Passkey Request Reply", 154 }, 505 { "User Passkey Request Negative Reply", 155 }, 506 { "Remote OOB Data Request Reply", 156 }, 507 { "Write Simple Pairing Debug Mode", 157 }, 508 { "Enhanced Flush", 158 }, 509 { "Remote OOB Data Request Negative Reply", 159 }, 510 511 { "Reserved", 160 }, 512 { "Reserved", 161 }, 513 { "Send Keypress Notification", 162 }, 514 { "IO Capability Request Negative Reply", 163 }, 515 { "Read Encryption Key Size", 164 }, 516 { "Reserved", 165 }, 517 { "Reserved", 166 }, 518 { "Reserved", 167 }, 519 520 { "Create Physical Link", 168 }, 521 { "Accept Physical Link", 169 }, 522 { "Disconnect Physical Link", 170 }, 523 { "Create Logical Link", 171 }, 524 { "Accept Logical Link", 172 }, 525 { "Disconnect Logical Link", 173 }, 526 { "Logical Link Cancel", 174 }, 527 { "Flow Specification Modify", 175 }, 528 529 { "Read Logical Link Accept Timeout", 176 }, 530 { "Write Logical Link Accept Timeout", 177 }, 531 { "Set Event Mask Page 2", 178 }, 532 { "Read Location Data", 179 }, 533 { "Write Location Data", 180 }, 534 { "Read Local AMP Info", 181 }, 535 { "Read Local AMP_ASSOC", 182 }, 536 { "Write Remote AMP_ASSOC", 183 }, 537 538 { "Read Flow Control Mode", 184 }, 539 { "Write Flow Control Mode", 185 }, 540 { "Read Data Block Size", 186 }, 541 { "Reserved", 187 }, 542 { "Reserved", 188 }, 543 { "Enable AMP Receiver Reports", 189 }, 544 { "AMP Test End", 190 }, 545 { "AMP Test Command", 191 }, 546 547 { "Read Enhanced Transmit Power Level", 192 }, 548 { "Reserved", 193 }, 549 { "Read Best Effort Flush Timeout", 194 }, 550 { "Write Best Effort Flush Timeout", 195 }, 551 { "Short Range Mode", 196 }, 552 { "Read LE Host Support", 197 }, 553 { "Write LE Host Support", 198 }, 554 { "Reserved", 199 }, 555 556 { "LE Set Event Mask", 200 }, 557 { "LE Read Buffer Size", 201 }, 558 { "LE Read Local Supported Features", 202 }, 559 { "Reserved", 203 }, 560 { "LE Set Random Address", 204 }, 561 { "LE Set Advertising Parameters", 205 }, 562 { "LE Read Advertising Channel TX Power", 206 }, 563 { "LE Set Advertising Data", 207 }, 564 565 { "LE Set Scan Response Data", 208 }, 566 { "LE Set Advertise Enable", 209 }, 567 { "LE Set Scan Parameters", 210 }, 568 { "LE Set Scan Enable", 211 }, 569 { "LE Create Connection", 212 }, 570 { "LE Create Connection Cancel", 213 }, 571 { "LE Read White List Size", 214 }, 572 { "LE Clear White List", 215 }, 573 574 { "LE Add Device To White List", 216 }, 575 { "LE Remove Device From White List", 217 }, 576 { "LE Connection Update", 218 }, 577 { "LE Set Host Channel Classification", 219 }, 578 { "LE Read Channel Map", 220 }, 579 { "LE Read Remote Used Features", 221 }, 580 { "LE Encrypt", 222 }, 581 { "LE Rand", 223 }, 582 583 { "LE Start Encryption", 224 }, 584 { "LE Long Term Key Request Reply", 225 }, 585 { "LE Long Term Key Request Negative Reply", 226 }, 586 { "LE Read Supported States", 227 }, 587 { "LE Receiver Test", 228 }, 588 { "LE Transmitter Test", 229 }, 589 { "LE Test End", 230 }, 590 { "Reserved", 231 }, 591 592 { NULL } 593 }; 594 595 char *hci_cmdtostr(unsigned int cmd) 596 { 597 return hci_uint2str(commands_map, cmd); 598 } 599 600 char *hci_commandstostr(uint8_t *commands, char *pref, int width) 601 { 602 unsigned int maxwidth = width - 3; 603 hci_map *m; 604 char *off, *ptr, *str; 605 int size = 10; 606 607 m = commands_map; 608 609 while (m->str) { 610 if (commands[m->val / 8] & (1 << (m->val % 8))) 611 size += strlen(m->str) + (pref ? strlen(pref) : 0) + 3; 612 m++; 613 } 614 615 str = bt_malloc(size); 616 if (!str) 617 return NULL; 618 619 ptr = str; *ptr = '\0'; 620 621 if (pref) 622 ptr += sprintf(ptr, "%s", pref); 623 624 off = ptr; 625 626 m = commands_map; 627 628 while (m->str) { 629 if (commands[m->val / 8] & (1 << (m->val % 8))) { 630 if (strlen(off) + strlen(m->str) > maxwidth) { 631 ptr += sprintf(ptr, "\n%s", pref ? pref : ""); 632 off = ptr; 633 } 634 ptr += sprintf(ptr, "'%s' ", m->str); 635 } 636 m++; 637 } 638 639 return str; 640 } 641 642 /* Version mapping */ 643 static hci_map ver_map[] = { 644 { "1.0b", 0x00 }, 645 { "1.1", 0x01 }, 646 { "1.2", 0x02 }, 647 { "2.0", 0x03 }, 648 { "2.1", 0x04 }, 649 { "3.0", 0x05 }, 650 { "4.0", 0x06 }, 651 { NULL } 652 }; 653 654 char *hci_vertostr(unsigned int ver) 655 { 656 return hci_uint2str(ver_map, ver); 657 } 658 659 int hci_strtover(char *str, unsigned int *ver) 660 { 661 return hci_str2uint(ver_map, str, ver); 662 } 663 664 char *lmp_vertostr(unsigned int ver) 665 { 666 return hci_uint2str(ver_map, ver); 667 } 668 669 int lmp_strtover(char *str, unsigned int *ver) 670 { 671 return hci_str2uint(ver_map, str, ver); 672 } 673 674 /* LMP features mapping */ 675 static hci_map lmp_features_map[8][9] = { 676 { /* Byte 0 */ 677 { "<3-slot packets>", LMP_3SLOT }, /* Bit 0 */ 678 { "<5-slot packets>", LMP_5SLOT }, /* Bit 1 */ 679 { "<encryption>", LMP_ENCRYPT }, /* Bit 2 */ 680 { "<slot offset>", LMP_SOFFSET }, /* Bit 3 */ 681 { "<timing accuracy>", LMP_TACCURACY }, /* Bit 4 */ 682 { "<role switch>", LMP_RSWITCH }, /* Bit 5 */ 683 { "<hold mode>", LMP_HOLD }, /* Bit 6 */ 684 { "<sniff mode>", LMP_SNIFF }, /* Bit 7 */ 685 { NULL } 686 }, 687 { /* Byte 1 */ 688 { "<park state>", LMP_PARK }, /* Bit 0 */ 689 { "<RSSI>", LMP_RSSI }, /* Bit 1 */ 690 { "<channel quality>", LMP_QUALITY }, /* Bit 2 */ 691 { "<SCO link>", LMP_SCO }, /* Bit 3 */ 692 { "<HV2 packets>", LMP_HV2 }, /* Bit 4 */ 693 { "<HV3 packets>", LMP_HV3 }, /* Bit 5 */ 694 { "<u-law log>", LMP_ULAW }, /* Bit 6 */ 695 { "<A-law log>", LMP_ALAW }, /* Bit 7 */ 696 { NULL } 697 }, 698 { /* Byte 2 */ 699 { "<CVSD>", LMP_CVSD }, /* Bit 0 */ 700 { "<paging scheme>", LMP_PSCHEME }, /* Bit 1 */ 701 { "<power control>", LMP_PCONTROL }, /* Bit 2 */ 702 { "<transparent SCO>", LMP_TRSP_SCO }, /* Bit 3 */ 703 { "<broadcast encrypt>",LMP_BCAST_ENC }, /* Bit 7 */ 704 { NULL } 705 }, 706 { /* Byte 3 */ 707 { "<no. 24>", 0x01 }, /* Bit 0 */ 708 { "<EDR ACL 2 Mbps>", LMP_EDR_ACL_2M }, /* Bit 1 */ 709 { "<EDR ACL 3 Mbps>", LMP_EDR_ACL_3M }, /* Bit 2 */ 710 { "<enhanced iscan>", LMP_ENH_ISCAN }, /* Bit 3 */ 711 { "<interlaced iscan>", LMP_ILACE_ISCAN }, /* Bit 4 */ 712 { "<interlaced pscan>", LMP_ILACE_PSCAN }, /* Bit 5 */ 713 { "<inquiry with RSSI>",LMP_RSSI_INQ }, /* Bit 6 */ 714 { "<extended SCO>", LMP_ESCO }, /* Bit 7 */ 715 { NULL } 716 }, 717 { /* Byte 4 */ 718 { "<EV4 packets>", LMP_EV4 }, /* Bit 0 */ 719 { "<EV5 packets>", LMP_EV5 }, /* Bit 1 */ 720 { "<no. 34>", 0x04 }, /* Bit 2 */ 721 { "<AFH cap. slave>", LMP_AFH_CAP_SLV }, /* Bit 3 */ 722 { "<AFH class. slave>", LMP_AFH_CLS_SLV }, /* Bit 4 */ 723 { "<BR/EDR not supp.>", LMP_NO_BREDR }, /* Bit 5 */ 724 { "<LE support>", LMP_LE }, /* Bit 6 */ 725 { "<3-slot EDR ACL>", LMP_EDR_3SLOT }, /* Bit 7 */ 726 { NULL } 727 }, 728 { /* Byte 5 */ 729 { "<5-slot EDR ACL>", LMP_EDR_5SLOT }, /* Bit 0 */ 730 { "<sniff subrating>", LMP_SNIFF_SUBR }, /* Bit 1 */ 731 { "<pause encryption>", LMP_PAUSE_ENC }, /* Bit 2 */ 732 { "<AFH cap. master>", LMP_AFH_CAP_MST }, /* Bit 3 */ 733 { "<AFH class. master>",LMP_AFH_CLS_MST }, /* Bit 4 */ 734 { "<EDR eSCO 2 Mbps>", LMP_EDR_ESCO_2M }, /* Bit 5 */ 735 { "<EDR eSCO 3 Mbps>", LMP_EDR_ESCO_3M }, /* Bit 6 */ 736 { "<3-slot EDR eSCO>", LMP_EDR_3S_ESCO }, /* Bit 7 */ 737 { NULL } 738 }, 739 { /* Byte 6 */ 740 { "<extended inquiry>", LMP_EXT_INQ }, /* Bit 0 */ 741 { "<LE and BR/EDR>", LMP_LE_BREDR }, /* Bit 1 */ 742 { "<no. 50>", 0x04 }, /* Bit 2 */ 743 { "<simple pairing>", LMP_SIMPLE_PAIR }, /* Bit 3 */ 744 { "<encapsulated PDU>", LMP_ENCAPS_PDU }, /* Bit 4 */ 745 { "<err. data report>", LMP_ERR_DAT_REP }, /* Bit 5 */ 746 { "<non-flush flag>", LMP_NFLUSH_PKTS }, /* Bit 6 */ 747 { "<no. 55>", 0x80 }, /* Bit 7 */ 748 { NULL } 749 }, 750 { /* Byte 7 */ 751 { "<LSTO>", LMP_LSTO }, /* Bit 1 */ 752 { "<inquiry TX power>", LMP_INQ_TX_PWR }, /* Bit 1 */ 753 { "<EPC>", LMP_EPC }, /* Bit 2 */ 754 { "<no. 59>", 0x08 }, /* Bit 3 */ 755 { "<no. 60>", 0x10 }, /* Bit 4 */ 756 { "<no. 61>", 0x20 }, /* Bit 5 */ 757 { "<no. 62>", 0x40 }, /* Bit 6 */ 758 { "<extended features>",LMP_EXT_FEAT }, /* Bit 7 */ 759 { NULL } 760 }, 761 }; 762 763 char *lmp_featurestostr(uint8_t *features, char *pref, int width) 764 { 765 unsigned int maxwidth = width - 1; 766 char *off, *ptr, *str; 767 int i, size = 10; 768 769 for (i = 0; i < 8; i++) { 770 hci_map *m = lmp_features_map[i]; 771 772 while (m->str) { 773 if (m->val & features[i]) 774 size += strlen(m->str) + (pref ? strlen(pref) : 0) + 1; 775 m++; 776 } 777 } 778 779 str = bt_malloc(size); 780 if (!str) 781 return NULL; 782 783 ptr = str; *ptr = '\0'; 784 785 if (pref) 786 ptr += sprintf(ptr, "%s", pref); 787 788 off = ptr; 789 790 for (i = 0; i < 8; i++) { 791 hci_map *m = lmp_features_map[i]; 792 793 while (m->str) { 794 if (m->val & features[i]) { 795 if (strlen(off) + strlen(m->str) > maxwidth) { 796 ptr += sprintf(ptr, "\n%s", pref ? pref : ""); 797 off = ptr; 798 } 799 ptr += sprintf(ptr, "%s ", m->str); 800 } 801 m++; 802 } 803 } 804 805 return str; 806 } 807 808 /* HCI functions that do not require open device */ 809 810 int hci_for_each_dev(int flag, int (*func)(int dd, int dev_id, long arg), long arg) 811 { 812 struct hci_dev_list_req *dl; 813 struct hci_dev_req *dr; 814 int dev_id = -1; 815 int i, sk, err = 0; 816 817 sk = socket(AF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI); 818 if (sk < 0) 819 return -1; 820 821 dl = malloc(HCI_MAX_DEV * sizeof(*dr) + sizeof(*dl)); 822 if (!dl) { 823 err = errno; 824 goto done; 825 } 826 827 memset(dl, 0, HCI_MAX_DEV * sizeof(*dr) + sizeof(*dl)); 828 829 dl->dev_num = HCI_MAX_DEV; 830 dr = dl->dev_req; 831 832 if (ioctl(sk, HCIGETDEVLIST, (void *) dl) < 0) { 833 err = errno; 834 goto free; 835 } 836 837 for (i = 0; i < dl->dev_num; i++, dr++) { 838 if (hci_test_bit(flag, &dr->dev_opt)) 839 if (!func || func(sk, dr->dev_id, arg)) { 840 dev_id = dr->dev_id; 841 break; 842 } 843 } 844 845 if (dev_id < 0) 846 err = ENODEV; 847 848 free: 849 free(dl); 850 851 done: 852 close(sk); 853 errno = err; 854 855 return dev_id; 856 } 857 858 static int __other_bdaddr(int dd, int dev_id, long arg) 859 { 860 struct hci_dev_info di = { dev_id: dev_id }; 861 862 if (ioctl(dd, HCIGETDEVINFO, (void *) &di)) 863 return 0; 864 865 if (hci_test_bit(HCI_RAW, &di.flags)) 866 return 0; 867 868 return bacmp((bdaddr_t *) arg, &di.bdaddr); 869 } 870 871 static int __same_bdaddr(int dd, int dev_id, long arg) 872 { 873 struct hci_dev_info di = { dev_id: dev_id }; 874 875 if (ioctl(dd, HCIGETDEVINFO, (void *) &di)) 876 return 0; 877 878 return !bacmp((bdaddr_t *) arg, &di.bdaddr); 879 } 880 881 int hci_get_route(bdaddr_t *bdaddr) 882 { 883 return hci_for_each_dev(HCI_UP, __other_bdaddr, 884 (long) (bdaddr ? bdaddr : BDADDR_ANY)); 885 } 886 887 int hci_devid(const char *str) 888 { 889 bdaddr_t ba; 890 int id = -1; 891 892 if (!strncmp(str, "hci", 3) && strlen(str) >= 4) { 893 id = atoi(str + 3); 894 if (hci_devba(id, &ba) < 0) 895 return -1; 896 } else { 897 errno = ENODEV; 898 str2ba(str, &ba); 899 id = hci_for_each_dev(HCI_UP, __same_bdaddr, (long) &ba); 900 } 901 902 return id; 903 } 904 905 int hci_devinfo(int dev_id, struct hci_dev_info *di) 906 { 907 int dd, err, ret; 908 909 dd = socket(AF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI); 910 if (dd < 0) 911 return dd; 912 913 memset(di, 0, sizeof(struct hci_dev_info)); 914 915 di->dev_id = dev_id; 916 ret = ioctl(dd, HCIGETDEVINFO, (void *) di); 917 918 err = errno; 919 close(dd); 920 errno = err; 921 922 return ret; 923 } 924 925 int hci_devba(int dev_id, bdaddr_t *bdaddr) 926 { 927 struct hci_dev_info di; 928 929 memset(&di, 0, sizeof(di)); 930 931 if (hci_devinfo(dev_id, &di)) 932 return -1; 933 934 if (!hci_test_bit(HCI_UP, &di.flags)) { 935 errno = ENETDOWN; 936 return -1; 937 } 938 939 bacpy(bdaddr, &di.bdaddr); 940 941 return 0; 942 } 943 944 int hci_inquiry(int dev_id, int len, int nrsp, const uint8_t *lap, inquiry_info **ii, long flags) 945 { 946 struct hci_inquiry_req *ir; 947 uint8_t num_rsp = nrsp; 948 void *buf; 949 int dd, size, err, ret = -1; 950 951 if (nrsp <= 0) { 952 num_rsp = 0; 953 nrsp = 255; 954 } 955 956 if (dev_id < 0) { 957 dev_id = hci_get_route(NULL); 958 if (dev_id < 0) { 959 errno = ENODEV; 960 return -1; 961 } 962 } 963 964 dd = socket(AF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI); 965 if (dd < 0) 966 return dd; 967 968 buf = malloc(sizeof(*ir) + (sizeof(inquiry_info) * (nrsp))); 969 if (!buf) 970 goto done; 971 972 ir = buf; 973 ir->dev_id = dev_id; 974 ir->num_rsp = num_rsp; 975 ir->length = len; 976 ir->flags = flags; 977 978 if (lap) { 979 memcpy(ir->lap, lap, 3); 980 } else { 981 ir->lap[0] = 0x33; 982 ir->lap[1] = 0x8b; 983 ir->lap[2] = 0x9e; 984 } 985 986 ret = ioctl(dd, HCIINQUIRY, (unsigned long) buf); 987 if (ret < 0) 988 goto free; 989 990 size = sizeof(inquiry_info) * ir->num_rsp; 991 992 if (!*ii) 993 *ii = malloc(size); 994 995 if (*ii) { 996 memcpy((void *) *ii, buf + sizeof(*ir), size); 997 ret = ir->num_rsp; 998 } else 999 ret = -1; 1000 1001 free: 1002 free(buf); 1003 1004 done: 1005 err = errno; 1006 close(dd); 1007 errno = err; 1008 1009 return ret; 1010 } 1011 1012 /* Open HCI device. 1013 * Returns device descriptor (dd). */ 1014 int hci_open_dev(int dev_id) 1015 { 1016 struct sockaddr_hci a; 1017 int dd, err; 1018 1019 /* Create HCI socket */ 1020 dd = socket(AF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI); 1021 if (dd < 0) 1022 return dd; 1023 1024 /* Bind socket to the HCI device */ 1025 memset(&a, 0, sizeof(a)); 1026 a.hci_family = AF_BLUETOOTH; 1027 a.hci_dev = dev_id; 1028 if (bind(dd, (struct sockaddr *) &a, sizeof(a)) < 0) 1029 goto failed; 1030 1031 return dd; 1032 1033 failed: 1034 err = errno; 1035 close(dd); 1036 errno = err; 1037 1038 return -1; 1039 } 1040 1041 int hci_close_dev(int dd) 1042 { 1043 return close(dd); 1044 } 1045 1046 /* HCI functions that require open device 1047 * dd - Device descriptor returned by hci_open_dev. */ 1048 1049 int hci_send_cmd(int dd, uint16_t ogf, uint16_t ocf, uint8_t plen, void *param) 1050 { 1051 uint8_t type = HCI_COMMAND_PKT; 1052 hci_command_hdr hc; 1053 struct iovec iv[3]; 1054 int ivn; 1055 1056 hc.opcode = htobs(cmd_opcode_pack(ogf, ocf)); 1057 hc.plen= plen; 1058 1059 iv[0].iov_base = &type; 1060 iv[0].iov_len = 1; 1061 iv[1].iov_base = &hc; 1062 iv[1].iov_len = HCI_COMMAND_HDR_SIZE; 1063 ivn = 2; 1064 1065 if (plen) { 1066 iv[2].iov_base = param; 1067 iv[2].iov_len = plen; 1068 ivn = 3; 1069 } 1070 1071 while (writev(dd, iv, ivn) < 0) { 1072 if (errno == EAGAIN || errno == EINTR) 1073 continue; 1074 return -1; 1075 } 1076 return 0; 1077 } 1078 1079 int hci_send_req(int dd, struct hci_request *r, int to) 1080 { 1081 unsigned char buf[HCI_MAX_EVENT_SIZE], *ptr; 1082 uint16_t opcode = htobs(cmd_opcode_pack(r->ogf, r->ocf)); 1083 struct hci_filter nf, of; 1084 socklen_t olen; 1085 hci_event_hdr *hdr; 1086 int err, try; 1087 1088 olen = sizeof(of); 1089 if (getsockopt(dd, SOL_HCI, HCI_FILTER, &of, &olen) < 0) 1090 return -1; 1091 1092 hci_filter_clear(&nf); 1093 hci_filter_set_ptype(HCI_EVENT_PKT, &nf); 1094 hci_filter_set_event(EVT_CMD_STATUS, &nf); 1095 hci_filter_set_event(EVT_CMD_COMPLETE, &nf); 1096 hci_filter_set_event(EVT_LE_META_EVENT, &nf); 1097 hci_filter_set_event(r->event, &nf); 1098 hci_filter_set_opcode(opcode, &nf); 1099 if (setsockopt(dd, SOL_HCI, HCI_FILTER, &nf, sizeof(nf)) < 0) 1100 return -1; 1101 1102 if (hci_send_cmd(dd, r->ogf, r->ocf, r->clen, r->cparam) < 0) 1103 goto failed; 1104 1105 try = 10; 1106 while (try--) { 1107 evt_cmd_complete *cc; 1108 evt_cmd_status *cs; 1109 evt_remote_name_req_complete *rn; 1110 evt_le_meta_event *me; 1111 remote_name_req_cp *cp; 1112 int len; 1113 1114 if (to) { 1115 struct pollfd p; 1116 int n; 1117 1118 p.fd = dd; p.events = POLLIN; 1119 while ((n = poll(&p, 1, to)) < 0) { 1120 if (errno == EAGAIN || errno == EINTR) 1121 continue; 1122 goto failed; 1123 } 1124 1125 if (!n) { 1126 errno = ETIMEDOUT; 1127 goto failed; 1128 } 1129 1130 to -= 10; 1131 if (to < 0) to = 0; 1132 1133 } 1134 1135 while ((len = read(dd, buf, sizeof(buf))) < 0) { 1136 if (errno == EAGAIN || errno == EINTR) 1137 continue; 1138 goto failed; 1139 } 1140 1141 hdr = (void *) (buf + 1); 1142 ptr = buf + (1 + HCI_EVENT_HDR_SIZE); 1143 len -= (1 + HCI_EVENT_HDR_SIZE); 1144 1145 switch (hdr->evt) { 1146 case EVT_CMD_STATUS: 1147 cs = (void *) ptr; 1148 1149 if (cs->opcode != opcode) 1150 continue; 1151 1152 if (r->event != EVT_CMD_STATUS) { 1153 if (cs->status) { 1154 errno = EIO; 1155 goto failed; 1156 } 1157 break; 1158 } 1159 1160 r->rlen = MIN(len, r->rlen); 1161 memcpy(r->rparam, ptr, r->rlen); 1162 goto done; 1163 1164 case EVT_CMD_COMPLETE: 1165 cc = (void *) ptr; 1166 1167 if (cc->opcode != opcode) 1168 continue; 1169 1170 ptr += EVT_CMD_COMPLETE_SIZE; 1171 len -= EVT_CMD_COMPLETE_SIZE; 1172 1173 r->rlen = MIN(len, r->rlen); 1174 memcpy(r->rparam, ptr, r->rlen); 1175 goto done; 1176 1177 case EVT_REMOTE_NAME_REQ_COMPLETE: 1178 if (hdr->evt != r->event) 1179 break; 1180 1181 rn = (void *) ptr; 1182 cp = r->cparam; 1183 1184 if (bacmp(&rn->bdaddr, &cp->bdaddr)) 1185 continue; 1186 1187 r->rlen = MIN(len, r->rlen); 1188 memcpy(r->rparam, ptr, r->rlen); 1189 goto done; 1190 1191 case EVT_LE_META_EVENT: 1192 me = (void *) ptr; 1193 1194 if (me->subevent != r->event) 1195 continue; 1196 1197 len -= 1; 1198 r->rlen = MIN(len, r->rlen); 1199 memcpy(r->rparam, me->data, r->rlen); 1200 goto done; 1201 1202 default: 1203 if (hdr->evt != r->event) 1204 break; 1205 1206 r->rlen = MIN(len, r->rlen); 1207 memcpy(r->rparam, ptr, r->rlen); 1208 goto done; 1209 } 1210 } 1211 errno = ETIMEDOUT; 1212 1213 failed: 1214 err = errno; 1215 setsockopt(dd, SOL_HCI, HCI_FILTER, &of, sizeof(of)); 1216 errno = err; 1217 return -1; 1218 1219 done: 1220 setsockopt(dd, SOL_HCI, HCI_FILTER, &of, sizeof(of)); 1221 return 0; 1222 } 1223 1224 int hci_create_connection(int dd, const bdaddr_t *bdaddr, uint16_t ptype, uint16_t clkoffset, uint8_t rswitch, uint16_t *handle, int to) 1225 { 1226 evt_conn_complete rp; 1227 create_conn_cp cp; 1228 struct hci_request rq; 1229 1230 memset(&cp, 0, sizeof(cp)); 1231 bacpy(&cp.bdaddr, bdaddr); 1232 cp.pkt_type = ptype; 1233 cp.pscan_rep_mode = 0x02; 1234 cp.clock_offset = clkoffset; 1235 cp.role_switch = rswitch; 1236 1237 memset(&rq, 0, sizeof(rq)); 1238 rq.ogf = OGF_LINK_CTL; 1239 rq.ocf = OCF_CREATE_CONN; 1240 rq.event = EVT_CONN_COMPLETE; 1241 rq.cparam = &cp; 1242 rq.clen = CREATE_CONN_CP_SIZE; 1243 rq.rparam = &rp; 1244 rq.rlen = EVT_CONN_COMPLETE_SIZE; 1245 1246 if (hci_send_req(dd, &rq, to) < 0) 1247 return -1; 1248 1249 if (rp.status) { 1250 errno = EIO; 1251 return -1; 1252 } 1253 1254 *handle = rp.handle; 1255 return 0; 1256 } 1257 1258 int hci_disconnect(int dd, uint16_t handle, uint8_t reason, int to) 1259 { 1260 evt_disconn_complete rp; 1261 disconnect_cp cp; 1262 struct hci_request rq; 1263 1264 memset(&cp, 0, sizeof(cp)); 1265 cp.handle = handle; 1266 cp.reason = reason; 1267 1268 memset(&rq, 0, sizeof(rq)); 1269 rq.ogf = OGF_LINK_CTL; 1270 rq.ocf = OCF_DISCONNECT; 1271 rq.event = EVT_DISCONN_COMPLETE; 1272 rq.cparam = &cp; 1273 rq.clen = DISCONNECT_CP_SIZE; 1274 rq.rparam = &rp; 1275 rq.rlen = EVT_DISCONN_COMPLETE_SIZE; 1276 1277 if (hci_send_req(dd, &rq, to) < 0) 1278 return -1; 1279 1280 if (rp.status) { 1281 errno = EIO; 1282 return -1; 1283 } 1284 return 0; 1285 } 1286 1287 int hci_read_local_name(int dd, int len, char *name, int to) 1288 { 1289 read_local_name_rp rp; 1290 struct hci_request rq; 1291 1292 memset(&rq, 0, sizeof(rq)); 1293 rq.ogf = OGF_HOST_CTL; 1294 rq.ocf = OCF_READ_LOCAL_NAME; 1295 rq.rparam = &rp; 1296 rq.rlen = READ_LOCAL_NAME_RP_SIZE; 1297 1298 if (hci_send_req(dd, &rq, to) < 0) 1299 return -1; 1300 1301 if (rp.status) { 1302 errno = EIO; 1303 return -1; 1304 } 1305 1306 rp.name[247] = '\0'; 1307 strncpy(name, (char *) rp.name, len); 1308 return 0; 1309 } 1310 1311 int hci_write_local_name(int dd, const char *name, int to) 1312 { 1313 change_local_name_cp cp; 1314 struct hci_request rq; 1315 1316 memset(&cp, 0, sizeof(cp)); 1317 strncpy((char *) cp.name, name, sizeof(cp.name)); 1318 1319 memset(&rq, 0, sizeof(rq)); 1320 rq.ogf = OGF_HOST_CTL; 1321 rq.ocf = OCF_CHANGE_LOCAL_NAME; 1322 rq.cparam = &cp; 1323 rq.clen = CHANGE_LOCAL_NAME_CP_SIZE; 1324 1325 if (hci_send_req(dd, &rq, to) < 0) 1326 return -1; 1327 1328 return 0; 1329 } 1330 1331 int hci_read_remote_name_with_clock_offset(int dd, const bdaddr_t *bdaddr, uint8_t pscan_rep_mode, uint16_t clkoffset, int len, char *name, int to) 1332 { 1333 evt_remote_name_req_complete rn; 1334 remote_name_req_cp cp; 1335 struct hci_request rq; 1336 1337 memset(&cp, 0, sizeof(cp)); 1338 bacpy(&cp.bdaddr, bdaddr); 1339 cp.pscan_rep_mode = pscan_rep_mode; 1340 cp.clock_offset = clkoffset; 1341 1342 memset(&rq, 0, sizeof(rq)); 1343 rq.ogf = OGF_LINK_CTL; 1344 rq.ocf = OCF_REMOTE_NAME_REQ; 1345 rq.cparam = &cp; 1346 rq.clen = REMOTE_NAME_REQ_CP_SIZE; 1347 rq.event = EVT_REMOTE_NAME_REQ_COMPLETE; 1348 rq.rparam = &rn; 1349 rq.rlen = EVT_REMOTE_NAME_REQ_COMPLETE_SIZE; 1350 1351 if (hci_send_req(dd, &rq, to) < 0) 1352 return -1; 1353 1354 if (rn.status) { 1355 errno = EIO; 1356 return -1; 1357 } 1358 1359 rn.name[247] = '\0'; 1360 strncpy(name, (char *) rn.name, len); 1361 return 0; 1362 } 1363 1364 int hci_read_remote_name(int dd, const bdaddr_t *bdaddr, int len, char *name, int to) 1365 { 1366 return hci_read_remote_name_with_clock_offset(dd, bdaddr, 0x02, 0x0000, len, name, to); 1367 } 1368 1369 int hci_read_remote_name_cancel(int dd, const bdaddr_t *bdaddr, int to) 1370 { 1371 remote_name_req_cancel_cp cp; 1372 struct hci_request rq; 1373 1374 memset(&cp, 0, sizeof(cp)); 1375 bacpy(&cp.bdaddr, bdaddr); 1376 1377 memset(&rq, 0, sizeof(rq)); 1378 rq.ogf = OGF_LINK_CTL; 1379 rq.ocf = OCF_REMOTE_NAME_REQ_CANCEL; 1380 rq.cparam = &cp; 1381 rq.clen = REMOTE_NAME_REQ_CANCEL_CP_SIZE; 1382 1383 if (hci_send_req(dd, &rq, to) < 0) 1384 return -1; 1385 1386 return 0; 1387 } 1388 1389 int hci_read_remote_version(int dd, uint16_t handle, struct hci_version *ver, int to) 1390 { 1391 evt_read_remote_version_complete rp; 1392 read_remote_version_cp cp; 1393 struct hci_request rq; 1394 1395 memset(&cp, 0, sizeof(cp)); 1396 cp.handle = handle; 1397 1398 memset(&rq, 0, sizeof(rq)); 1399 rq.ogf = OGF_LINK_CTL; 1400 rq.ocf = OCF_READ_REMOTE_VERSION; 1401 rq.event = EVT_READ_REMOTE_VERSION_COMPLETE; 1402 rq.cparam = &cp; 1403 rq.clen = READ_REMOTE_VERSION_CP_SIZE; 1404 rq.rparam = &rp; 1405 rq.rlen = EVT_READ_REMOTE_VERSION_COMPLETE_SIZE; 1406 1407 if (hci_send_req(dd, &rq, to) < 0) 1408 return -1; 1409 1410 if (rp.status) { 1411 errno = EIO; 1412 return -1; 1413 } 1414 1415 ver->manufacturer = btohs(rp.manufacturer); 1416 ver->lmp_ver = rp.lmp_ver; 1417 ver->lmp_subver = btohs(rp.lmp_subver); 1418 return 0; 1419 } 1420 1421 int hci_read_remote_features(int dd, uint16_t handle, uint8_t *features, int to) 1422 { 1423 evt_read_remote_features_complete rp; 1424 read_remote_features_cp cp; 1425 struct hci_request rq; 1426 1427 memset(&cp, 0, sizeof(cp)); 1428 cp.handle = handle; 1429 1430 memset(&rq, 0, sizeof(rq)); 1431 rq.ogf = OGF_LINK_CTL; 1432 rq.ocf = OCF_READ_REMOTE_FEATURES; 1433 rq.event = EVT_READ_REMOTE_FEATURES_COMPLETE; 1434 rq.cparam = &cp; 1435 rq.clen = READ_REMOTE_FEATURES_CP_SIZE; 1436 rq.rparam = &rp; 1437 rq.rlen = EVT_READ_REMOTE_FEATURES_COMPLETE_SIZE; 1438 1439 if (hci_send_req(dd, &rq, to) < 0) 1440 return -1; 1441 1442 if (rp.status) { 1443 errno = EIO; 1444 return -1; 1445 } 1446 1447 if (features) 1448 memcpy(features, rp.features, 8); 1449 1450 return 0; 1451 } 1452 1453 int hci_read_remote_ext_features(int dd, uint16_t handle, uint8_t page, uint8_t *max_page, uint8_t *features, int to) 1454 { 1455 evt_read_remote_ext_features_complete rp; 1456 read_remote_ext_features_cp cp; 1457 struct hci_request rq; 1458 1459 memset(&cp, 0, sizeof(cp)); 1460 cp.handle = handle; 1461 cp.page_num = page; 1462 1463 memset(&rq, 0, sizeof(rq)); 1464 rq.ogf = OGF_LINK_CTL; 1465 rq.ocf = OCF_READ_REMOTE_EXT_FEATURES; 1466 rq.event = EVT_READ_REMOTE_EXT_FEATURES_COMPLETE; 1467 rq.cparam = &cp; 1468 rq.clen = READ_REMOTE_EXT_FEATURES_CP_SIZE; 1469 rq.rparam = &rp; 1470 rq.rlen = EVT_READ_REMOTE_EXT_FEATURES_COMPLETE_SIZE; 1471 1472 if (hci_send_req(dd, &rq, to) < 0) 1473 return -1; 1474 1475 if (rp.status) { 1476 errno = EIO; 1477 return -1; 1478 } 1479 1480 if (max_page) 1481 *max_page = rp.max_page_num; 1482 1483 if (features) 1484 memcpy(features, rp.features, 8); 1485 1486 return 0; 1487 } 1488 1489 int hci_read_clock_offset(int dd, uint16_t handle, uint16_t *clkoffset, int to) 1490 { 1491 evt_read_clock_offset_complete rp; 1492 read_clock_offset_cp cp; 1493 struct hci_request rq; 1494 1495 memset(&cp, 0, sizeof(cp)); 1496 cp.handle = handle; 1497 1498 memset(&rq, 0, sizeof(rq)); 1499 rq.ogf = OGF_LINK_CTL; 1500 rq.ocf = OCF_READ_CLOCK_OFFSET; 1501 rq.event = EVT_READ_CLOCK_OFFSET_COMPLETE; 1502 rq.cparam = &cp; 1503 rq.clen = READ_CLOCK_OFFSET_CP_SIZE; 1504 rq.rparam = &rp; 1505 rq.rlen = EVT_READ_CLOCK_OFFSET_COMPLETE_SIZE; 1506 1507 if (hci_send_req(dd, &rq, to) < 0) 1508 return -1; 1509 1510 if (rp.status) { 1511 errno = EIO; 1512 return -1; 1513 } 1514 1515 *clkoffset = rp.clock_offset; 1516 return 0; 1517 } 1518 1519 int hci_read_local_version(int dd, struct hci_version *ver, int to) 1520 { 1521 read_local_version_rp rp; 1522 struct hci_request rq; 1523 1524 memset(&rq, 0, sizeof(rq)); 1525 rq.ogf = OGF_INFO_PARAM; 1526 rq.ocf = OCF_READ_LOCAL_VERSION; 1527 rq.rparam = &rp; 1528 rq.rlen = READ_LOCAL_VERSION_RP_SIZE; 1529 1530 if (hci_send_req(dd, &rq, to) < 0) 1531 return -1; 1532 1533 if (rp.status) { 1534 errno = EIO; 1535 return -1; 1536 } 1537 1538 ver->manufacturer = btohs(rp.manufacturer); 1539 ver->hci_ver = rp.hci_ver; 1540 ver->hci_rev = btohs(rp.hci_rev); 1541 ver->lmp_ver = rp.lmp_ver; 1542 ver->lmp_subver = btohs(rp.lmp_subver); 1543 return 0; 1544 } 1545 1546 int hci_read_local_commands(int dd, uint8_t *commands, int to) 1547 { 1548 read_local_commands_rp rp; 1549 struct hci_request rq; 1550 1551 memset(&rq, 0, sizeof(rq)); 1552 rq.ogf = OGF_INFO_PARAM; 1553 rq.ocf = OCF_READ_LOCAL_COMMANDS; 1554 rq.rparam = &rp; 1555 rq.rlen = READ_LOCAL_COMMANDS_RP_SIZE; 1556 1557 if (hci_send_req(dd, &rq, to) < 0) 1558 return -1; 1559 1560 if (rp.status) { 1561 errno = EIO; 1562 return -1; 1563 } 1564 1565 if (commands) 1566 memcpy(commands, rp.commands, 64); 1567 1568 return 0; 1569 } 1570 1571 int hci_read_local_features(int dd, uint8_t *features, int to) 1572 { 1573 read_local_features_rp rp; 1574 struct hci_request rq; 1575 1576 memset(&rq, 0, sizeof(rq)); 1577 rq.ogf = OGF_INFO_PARAM; 1578 rq.ocf = OCF_READ_LOCAL_FEATURES; 1579 rq.rparam = &rp; 1580 rq.rlen = READ_LOCAL_FEATURES_RP_SIZE; 1581 1582 if (hci_send_req(dd, &rq, to) < 0) 1583 return -1; 1584 1585 if (rp.status) { 1586 errno = EIO; 1587 return -1; 1588 } 1589 1590 if (features) 1591 memcpy(features, rp.features, 8); 1592 1593 return 0; 1594 } 1595 1596 int hci_read_local_ext_features(int dd, uint8_t page, uint8_t *max_page, uint8_t *features, int to) 1597 { 1598 read_local_ext_features_cp cp; 1599 read_local_ext_features_rp rp; 1600 struct hci_request rq; 1601 1602 cp.page_num = page; 1603 1604 memset(&rq, 0, sizeof(rq)); 1605 rq.ogf = OGF_INFO_PARAM; 1606 rq.ocf = OCF_READ_LOCAL_EXT_FEATURES; 1607 rq.cparam = &cp; 1608 rq.clen = READ_LOCAL_EXT_FEATURES_CP_SIZE; 1609 rq.rparam = &rp; 1610 rq.rlen = READ_LOCAL_EXT_FEATURES_RP_SIZE; 1611 1612 if (hci_send_req(dd, &rq, to) < 0) 1613 return -1; 1614 1615 if (rp.status) { 1616 errno = EIO; 1617 return -1; 1618 } 1619 1620 if (max_page) 1621 *max_page = rp.max_page_num; 1622 1623 if (features) 1624 memcpy(features, rp.features, 8); 1625 1626 return 0; 1627 } 1628 1629 int hci_read_bd_addr(int dd, bdaddr_t *bdaddr, int to) 1630 { 1631 read_bd_addr_rp rp; 1632 struct hci_request rq; 1633 1634 memset(&rq, 0, sizeof(rq)); 1635 rq.ogf = OGF_INFO_PARAM; 1636 rq.ocf = OCF_READ_BD_ADDR; 1637 rq.rparam = &rp; 1638 rq.rlen = READ_BD_ADDR_RP_SIZE; 1639 1640 if (hci_send_req(dd, &rq, to) < 0) 1641 return -1; 1642 1643 if (rp.status) { 1644 errno = EIO; 1645 return -1; 1646 } 1647 1648 if (bdaddr) 1649 bacpy(bdaddr, &rp.bdaddr); 1650 1651 return 0; 1652 } 1653 1654 int hci_read_class_of_dev(int dd, uint8_t *cls, int to) 1655 { 1656 read_class_of_dev_rp rp; 1657 struct hci_request rq; 1658 1659 memset(&rq, 0, sizeof(rq)); 1660 rq.ogf = OGF_HOST_CTL; 1661 rq.ocf = OCF_READ_CLASS_OF_DEV; 1662 rq.rparam = &rp; 1663 rq.rlen = READ_CLASS_OF_DEV_RP_SIZE; 1664 1665 if (hci_send_req(dd, &rq, to) < 0) 1666 return -1; 1667 1668 if (rp.status) { 1669 errno = EIO; 1670 return -1; 1671 } 1672 1673 memcpy(cls, rp.dev_class, 3); 1674 return 0; 1675 } 1676 1677 int hci_write_class_of_dev(int dd, uint32_t cls, int to) 1678 { 1679 write_class_of_dev_cp cp; 1680 struct hci_request rq; 1681 1682 memset(&rq, 0, sizeof(rq)); 1683 cp.dev_class[0] = cls & 0xff; 1684 cp.dev_class[1] = (cls >> 8) & 0xff; 1685 cp.dev_class[2] = (cls >> 16) & 0xff; 1686 rq.ogf = OGF_HOST_CTL; 1687 rq.ocf = OCF_WRITE_CLASS_OF_DEV; 1688 rq.cparam = &cp; 1689 rq.clen = WRITE_CLASS_OF_DEV_CP_SIZE; 1690 return hci_send_req(dd, &rq, to); 1691 } 1692 1693 int hci_read_voice_setting(int dd, uint16_t *vs, int to) 1694 { 1695 read_voice_setting_rp rp; 1696 struct hci_request rq; 1697 1698 memset(&rq, 0, sizeof(rq)); 1699 rq.ogf = OGF_HOST_CTL; 1700 rq.ocf = OCF_READ_VOICE_SETTING; 1701 rq.rparam = &rp; 1702 rq.rlen = READ_VOICE_SETTING_RP_SIZE; 1703 1704 if (hci_send_req(dd, &rq, to) < 0) 1705 return -1; 1706 1707 if (rp.status) { 1708 errno = EIO; 1709 return -1; 1710 } 1711 1712 *vs = rp.voice_setting; 1713 return 0; 1714 } 1715 1716 int hci_write_voice_setting(int dd, uint16_t vs, int to) 1717 { 1718 write_voice_setting_cp cp; 1719 struct hci_request rq; 1720 1721 memset(&rq, 0, sizeof(rq)); 1722 cp.voice_setting = vs; 1723 rq.ogf = OGF_HOST_CTL; 1724 rq.ocf = OCF_WRITE_VOICE_SETTING; 1725 rq.cparam = &cp; 1726 rq.clen = WRITE_VOICE_SETTING_CP_SIZE; 1727 1728 return hci_send_req(dd, &rq, to); 1729 } 1730 1731 int hci_read_current_iac_lap(int dd, uint8_t *num_iac, uint8_t *lap, int to) 1732 { 1733 read_current_iac_lap_rp rp; 1734 struct hci_request rq; 1735 1736 memset(&rq, 0, sizeof(rq)); 1737 rq.ogf = OGF_HOST_CTL; 1738 rq.ocf = OCF_READ_CURRENT_IAC_LAP; 1739 rq.rparam = &rp; 1740 rq.rlen = READ_CURRENT_IAC_LAP_RP_SIZE; 1741 1742 if (hci_send_req(dd, &rq, to) < 0) 1743 return -1; 1744 1745 if (rp.status) { 1746 errno = EIO; 1747 return -1; 1748 } 1749 1750 *num_iac = rp.num_current_iac; 1751 memcpy(lap, rp.lap, rp.num_current_iac * 3); 1752 return 0; 1753 } 1754 1755 int hci_write_current_iac_lap(int dd, uint8_t num_iac, uint8_t *lap, int to) 1756 { 1757 write_current_iac_lap_cp cp; 1758 struct hci_request rq; 1759 1760 memset(&cp, 0, sizeof(cp)); 1761 cp.num_current_iac = num_iac; 1762 memcpy(&cp.lap, lap, num_iac * 3); 1763 1764 memset(&rq, 0, sizeof(rq)); 1765 rq.ogf = OGF_HOST_CTL; 1766 rq.ocf = OCF_WRITE_CURRENT_IAC_LAP; 1767 rq.cparam = &cp; 1768 rq.clen = num_iac * 3 + 1; 1769 1770 return hci_send_req(dd, &rq, to); 1771 } 1772 1773 int hci_read_stored_link_key(int dd, bdaddr_t *bdaddr, uint8_t all, int to) 1774 { 1775 read_stored_link_key_cp cp; 1776 struct hci_request rq; 1777 1778 memset(&cp, 0, sizeof(cp)); 1779 bacpy(&cp.bdaddr, bdaddr); 1780 cp.read_all = all; 1781 1782 memset(&rq, 0, sizeof(rq)); 1783 rq.ogf = OGF_HOST_CTL; 1784 rq.ocf = OCF_READ_STORED_LINK_KEY; 1785 rq.cparam = &cp; 1786 rq.clen = READ_STORED_LINK_KEY_CP_SIZE; 1787 1788 return hci_send_req(dd, &rq, to); 1789 } 1790 1791 int hci_write_stored_link_key(int dd, bdaddr_t *bdaddr, uint8_t *key, int to) 1792 { 1793 unsigned char cp[WRITE_STORED_LINK_KEY_CP_SIZE + 6 + 16]; 1794 struct hci_request rq; 1795 1796 memset(&cp, 0, sizeof(cp)); 1797 cp[0] = 1; 1798 bacpy((bdaddr_t *) (cp + 1), bdaddr); 1799 memcpy(cp + 7, key, 16); 1800 1801 memset(&rq, 0, sizeof(rq)); 1802 rq.ogf = OGF_HOST_CTL; 1803 rq.ocf = OCF_WRITE_STORED_LINK_KEY; 1804 rq.cparam = &cp; 1805 rq.clen = WRITE_STORED_LINK_KEY_CP_SIZE + 6 + 16; 1806 1807 return hci_send_req(dd, &rq, to); 1808 } 1809 1810 int hci_delete_stored_link_key(int dd, bdaddr_t *bdaddr, uint8_t all, int to) 1811 { 1812 delete_stored_link_key_cp cp; 1813 struct hci_request rq; 1814 1815 memset(&cp, 0, sizeof(cp)); 1816 bacpy(&cp.bdaddr, bdaddr); 1817 cp.delete_all = all; 1818 1819 memset(&rq, 0, sizeof(rq)); 1820 rq.ogf = OGF_HOST_CTL; 1821 rq.ocf = OCF_DELETE_STORED_LINK_KEY; 1822 rq.cparam = &cp; 1823 rq.clen = DELETE_STORED_LINK_KEY_CP_SIZE; 1824 1825 return hci_send_req(dd, &rq, to); 1826 } 1827 1828 int hci_authenticate_link(int dd, uint16_t handle, int to) 1829 { 1830 auth_requested_cp cp; 1831 evt_auth_complete rp; 1832 struct hci_request rq; 1833 1834 cp.handle = handle; 1835 1836 rq.ogf = OGF_LINK_CTL; 1837 rq.ocf = OCF_AUTH_REQUESTED; 1838 rq.event = EVT_AUTH_COMPLETE; 1839 rq.cparam = &cp; 1840 rq.clen = AUTH_REQUESTED_CP_SIZE; 1841 rq.rparam = &rp; 1842 rq.rlen = EVT_AUTH_COMPLETE_SIZE; 1843 1844 if (hci_send_req(dd, &rq, to) < 0) 1845 return -1; 1846 1847 if (rp.status) { 1848 errno = EIO; 1849 return -1; 1850 } 1851 1852 return 0; 1853 } 1854 1855 int hci_encrypt_link(int dd, uint16_t handle, uint8_t encrypt, int to) 1856 { 1857 set_conn_encrypt_cp cp; 1858 evt_encrypt_change rp; 1859 struct hci_request rq; 1860 1861 cp.handle = handle; 1862 cp.encrypt = encrypt; 1863 1864 rq.ogf = OGF_LINK_CTL; 1865 rq.ocf = OCF_SET_CONN_ENCRYPT; 1866 rq.event = EVT_ENCRYPT_CHANGE; 1867 rq.cparam = &cp; 1868 rq.clen = SET_CONN_ENCRYPT_CP_SIZE; 1869 rq.rparam = &rp; 1870 rq.rlen = EVT_ENCRYPT_CHANGE_SIZE; 1871 1872 if (hci_send_req(dd, &rq, to) < 0) 1873 return -1; 1874 1875 if (rp.status) { 1876 errno = EIO; 1877 return -1; 1878 } 1879 1880 return 0; 1881 } 1882 1883 int hci_change_link_key(int dd, uint16_t handle, int to) 1884 { 1885 change_conn_link_key_cp cp; 1886 evt_change_conn_link_key_complete rp; 1887 struct hci_request rq; 1888 1889 cp.handle = handle; 1890 1891 rq.ogf = OGF_LINK_CTL; 1892 rq.ocf = OCF_CHANGE_CONN_LINK_KEY; 1893 rq.event = EVT_CHANGE_CONN_LINK_KEY_COMPLETE; 1894 rq.cparam = &cp; 1895 rq.clen = CHANGE_CONN_LINK_KEY_CP_SIZE; 1896 rq.rparam = &rp; 1897 rq.rlen = EVT_CHANGE_CONN_LINK_KEY_COMPLETE_SIZE; 1898 1899 if (hci_send_req(dd, &rq, to) < 0) 1900 return -1; 1901 1902 if (rp.status) { 1903 errno = EIO; 1904 return -1; 1905 } 1906 1907 return 0; 1908 } 1909 1910 int hci_switch_role(int dd, bdaddr_t *bdaddr, uint8_t role, int to) 1911 { 1912 switch_role_cp cp; 1913 evt_role_change rp; 1914 struct hci_request rq; 1915 1916 bacpy(&cp.bdaddr, bdaddr); 1917 cp.role = role; 1918 rq.ogf = OGF_LINK_POLICY; 1919 rq.ocf = OCF_SWITCH_ROLE; 1920 rq.cparam = &cp; 1921 rq.clen = SWITCH_ROLE_CP_SIZE; 1922 rq.rparam = &rp; 1923 rq.rlen = EVT_ROLE_CHANGE_SIZE; 1924 rq.event = EVT_ROLE_CHANGE; 1925 1926 if (hci_send_req(dd, &rq, to) < 0) 1927 return -1; 1928 1929 if (rp.status) { 1930 errno = EIO; 1931 return -1; 1932 } 1933 1934 return 0; 1935 } 1936 1937 int hci_park_mode(int dd, uint16_t handle, uint16_t max_interval, uint16_t min_interval, int to) 1938 { 1939 park_mode_cp cp; 1940 evt_mode_change rp; 1941 struct hci_request rq; 1942 1943 memset(&cp, 0, sizeof (cp)); 1944 cp.handle = handle; 1945 cp.max_interval = max_interval; 1946 cp.min_interval = min_interval; 1947 1948 memset(&rq, 0, sizeof (rq)); 1949 rq.ogf = OGF_LINK_POLICY; 1950 rq.ocf = OCF_PARK_MODE; 1951 rq.event = EVT_MODE_CHANGE; 1952 rq.cparam = &cp; 1953 rq.clen = PARK_MODE_CP_SIZE; 1954 rq.rparam = &rp; 1955 rq.rlen = EVT_MODE_CHANGE_SIZE; 1956 1957 if (hci_send_req(dd, &rq, to) < 0) 1958 return -1; 1959 1960 if (rp.status) { 1961 errno = EIO; 1962 return -1; 1963 } 1964 1965 return 0; 1966 } 1967 1968 int hci_exit_park_mode(int dd, uint16_t handle, int to) 1969 { 1970 exit_park_mode_cp cp; 1971 evt_mode_change rp; 1972 struct hci_request rq; 1973 1974 memset(&cp, 0, sizeof (cp)); 1975 cp.handle = handle; 1976 1977 memset (&rq, 0, sizeof (rq)); 1978 rq.ogf = OGF_LINK_POLICY; 1979 rq.ocf = OCF_EXIT_PARK_MODE; 1980 rq.event = EVT_MODE_CHANGE; 1981 rq.cparam = &cp; 1982 rq.clen = EXIT_PARK_MODE_CP_SIZE; 1983 rq.rparam = &rp; 1984 rq.rlen = EVT_MODE_CHANGE_SIZE; 1985 1986 if (hci_send_req(dd, &rq, to) < 0) 1987 return -1; 1988 1989 if (rp.status) { 1990 errno = EIO; 1991 return -1; 1992 } 1993 1994 return 0; 1995 } 1996 1997 int hci_read_inquiry_scan_type(int dd, uint8_t *type, int to) 1998 { 1999 read_inquiry_scan_type_rp rp; 2000 struct hci_request rq; 2001 2002 memset(&rq, 0, sizeof(rq)); 2003 rq.ogf = OGF_HOST_CTL; 2004 rq.ocf = OCF_READ_INQUIRY_SCAN_TYPE; 2005 rq.rparam = &rp; 2006 rq.rlen = READ_INQUIRY_SCAN_TYPE_RP_SIZE; 2007 2008 if (hci_send_req(dd, &rq, to) < 0) 2009 return -1; 2010 2011 if (rp.status) { 2012 errno = EIO; 2013 return -1; 2014 } 2015 2016 *type = rp.type; 2017 return 0; 2018 } 2019 2020 int hci_write_inquiry_scan_type(int dd, uint8_t type, int to) 2021 { 2022 write_inquiry_scan_type_cp cp; 2023 write_inquiry_scan_type_rp rp; 2024 struct hci_request rq; 2025 2026 memset(&cp, 0, sizeof(cp)); 2027 cp.type = type; 2028 2029 memset(&rq, 0, sizeof(rq)); 2030 rq.ogf = OGF_HOST_CTL; 2031 rq.ocf = OCF_WRITE_INQUIRY_SCAN_TYPE; 2032 rq.cparam = &cp; 2033 rq.clen = WRITE_INQUIRY_SCAN_TYPE_CP_SIZE; 2034 rq.rparam = &rp; 2035 rq.rlen = WRITE_INQUIRY_SCAN_TYPE_RP_SIZE; 2036 2037 if (hci_send_req(dd, &rq, to) < 0) 2038 return -1; 2039 2040 if (rp.status) { 2041 errno = EIO; 2042 return -1; 2043 } 2044 2045 return 0; 2046 } 2047 2048 int hci_read_inquiry_mode(int dd, uint8_t *mode, int to) 2049 { 2050 read_inquiry_mode_rp rp; 2051 struct hci_request rq; 2052 2053 memset(&rq, 0, sizeof(rq)); 2054 rq.ogf = OGF_HOST_CTL; 2055 rq.ocf = OCF_READ_INQUIRY_MODE; 2056 rq.rparam = &rp; 2057 rq.rlen = READ_INQUIRY_MODE_RP_SIZE; 2058 2059 if (hci_send_req(dd, &rq, to) < 0) 2060 return -1; 2061 2062 if (rp.status) { 2063 errno = EIO; 2064 return -1; 2065 } 2066 2067 *mode = rp.mode; 2068 return 0; 2069 } 2070 2071 int hci_write_inquiry_mode(int dd, uint8_t mode, int to) 2072 { 2073 write_inquiry_mode_cp cp; 2074 write_inquiry_mode_rp rp; 2075 struct hci_request rq; 2076 2077 memset(&cp, 0, sizeof(cp)); 2078 cp.mode = mode; 2079 2080 memset(&rq, 0, sizeof(rq)); 2081 rq.ogf = OGF_HOST_CTL; 2082 rq.ocf = OCF_WRITE_INQUIRY_MODE; 2083 rq.cparam = &cp; 2084 rq.clen = WRITE_INQUIRY_MODE_CP_SIZE; 2085 rq.rparam = &rp; 2086 rq.rlen = WRITE_INQUIRY_MODE_RP_SIZE; 2087 2088 if (hci_send_req(dd, &rq, to) < 0) 2089 return -1; 2090 2091 if (rp.status) { 2092 errno = EIO; 2093 return -1; 2094 } 2095 2096 return 0; 2097 } 2098 2099 int hci_read_afh_mode(int dd, uint8_t *mode, int to) 2100 { 2101 read_afh_mode_rp rp; 2102 struct hci_request rq; 2103 2104 memset(&rq, 0, sizeof(rq)); 2105 rq.ogf = OGF_HOST_CTL; 2106 rq.ocf = OCF_READ_AFH_MODE; 2107 rq.rparam = &rp; 2108 rq.rlen = READ_AFH_MODE_RP_SIZE; 2109 2110 if (hci_send_req(dd, &rq, to) < 0) 2111 return -1; 2112 2113 if (rp.status) { 2114 errno = EIO; 2115 return -1; 2116 } 2117 2118 *mode = rp.mode; 2119 return 0; 2120 } 2121 2122 int hci_write_afh_mode(int dd, uint8_t mode, int to) 2123 { 2124 write_afh_mode_cp cp; 2125 write_afh_mode_rp rp; 2126 struct hci_request rq; 2127 2128 memset(&cp, 0, sizeof(cp)); 2129 cp.mode = mode; 2130 2131 memset(&rq, 0, sizeof(rq)); 2132 rq.ogf = OGF_HOST_CTL; 2133 rq.ocf = OCF_WRITE_AFH_MODE; 2134 rq.cparam = &cp; 2135 rq.clen = WRITE_AFH_MODE_CP_SIZE; 2136 rq.rparam = &rp; 2137 rq.rlen = WRITE_AFH_MODE_RP_SIZE; 2138 2139 if (hci_send_req(dd, &rq, to) < 0) 2140 return -1; 2141 2142 if (rp.status) { 2143 errno = EIO; 2144 return -1; 2145 } 2146 2147 return 0; 2148 } 2149 2150 int hci_read_ext_inquiry_response(int dd, uint8_t *fec, uint8_t *data, int to) 2151 { 2152 read_ext_inquiry_response_rp rp; 2153 struct hci_request rq; 2154 2155 memset(&rq, 0, sizeof(rq)); 2156 rq.ogf = OGF_HOST_CTL; 2157 rq.ocf = OCF_READ_EXT_INQUIRY_RESPONSE; 2158 rq.rparam = &rp; 2159 rq.rlen = READ_EXT_INQUIRY_RESPONSE_RP_SIZE; 2160 2161 if (hci_send_req(dd, &rq, to) < 0) 2162 return -1; 2163 2164 if (rp.status) { 2165 errno = EIO; 2166 return -1; 2167 } 2168 2169 *fec = rp.fec; 2170 memcpy(data, rp.data, 240); 2171 2172 return 0; 2173 } 2174 2175 int hci_write_ext_inquiry_response(int dd, uint8_t fec, uint8_t *data, int to) 2176 { 2177 write_ext_inquiry_response_cp cp; 2178 write_ext_inquiry_response_rp rp; 2179 struct hci_request rq; 2180 2181 memset(&cp, 0, sizeof(cp)); 2182 cp.fec = fec; 2183 memcpy(cp.data, data, 240); 2184 2185 memset(&rq, 0, sizeof(rq)); 2186 rq.ogf = OGF_HOST_CTL; 2187 rq.ocf = OCF_WRITE_EXT_INQUIRY_RESPONSE; 2188 rq.cparam = &cp; 2189 rq.clen = WRITE_EXT_INQUIRY_RESPONSE_CP_SIZE; 2190 rq.rparam = &rp; 2191 rq.rlen = WRITE_EXT_INQUIRY_RESPONSE_RP_SIZE; 2192 2193 if (hci_send_req(dd, &rq, to) < 0) 2194 return -1; 2195 2196 if (rp.status) { 2197 errno = EIO; 2198 return -1; 2199 } 2200 2201 return 0; 2202 } 2203 2204 int hci_read_simple_pairing_mode(int dd, uint8_t *mode, int to) 2205 { 2206 read_simple_pairing_mode_rp rp; 2207 struct hci_request rq; 2208 2209 memset(&rq, 0, sizeof(rq)); 2210 rq.ogf = OGF_HOST_CTL; 2211 rq.ocf = OCF_READ_SIMPLE_PAIRING_MODE; 2212 rq.rparam = &rp; 2213 rq.rlen = READ_SIMPLE_PAIRING_MODE_RP_SIZE; 2214 2215 if (hci_send_req(dd, &rq, to) < 0) 2216 return -1; 2217 2218 if (rp.status) { 2219 errno = EIO; 2220 return -1; 2221 } 2222 2223 *mode = rp.mode; 2224 return 0; 2225 } 2226 2227 int hci_write_simple_pairing_mode(int dd, uint8_t mode, int to) 2228 { 2229 write_simple_pairing_mode_cp cp; 2230 write_simple_pairing_mode_rp rp; 2231 struct hci_request rq; 2232 2233 memset(&cp, 0, sizeof(cp)); 2234 cp.mode = mode; 2235 2236 memset(&rq, 0, sizeof(rq)); 2237 rq.ogf = OGF_HOST_CTL; 2238 rq.ocf = OCF_WRITE_SIMPLE_PAIRING_MODE; 2239 rq.cparam = &cp; 2240 rq.clen = WRITE_SIMPLE_PAIRING_MODE_CP_SIZE; 2241 rq.rparam = &rp; 2242 rq.rlen = WRITE_SIMPLE_PAIRING_MODE_RP_SIZE; 2243 2244 if (hci_send_req(dd, &rq, to) < 0) 2245 return -1; 2246 2247 if (rp.status) { 2248 errno = EIO; 2249 return -1; 2250 } 2251 2252 return 0; 2253 } 2254 2255 int hci_read_local_oob_data(int dd, uint8_t *hash, uint8_t *randomizer, int to) 2256 { 2257 read_local_oob_data_rp rp; 2258 struct hci_request rq; 2259 2260 memset(&rq, 0, sizeof(rq)); 2261 rq.ogf = OGF_HOST_CTL; 2262 rq.ocf = OCF_READ_LOCAL_OOB_DATA; 2263 rq.rparam = &rp; 2264 rq.rlen = READ_LOCAL_OOB_DATA_RP_SIZE; 2265 2266 if (hci_send_req(dd, &rq, to) < 0) 2267 return -1; 2268 2269 if (rp.status) { 2270 errno = EIO; 2271 return -1; 2272 } 2273 2274 memcpy(hash, rp.hash, 16); 2275 memcpy(randomizer, rp.randomizer, 16); 2276 return 0; 2277 } 2278 2279 int hci_read_inq_response_tx_power_level(int dd, int8_t *level, int to) 2280 { 2281 read_inq_response_tx_power_level_rp rp; 2282 struct hci_request rq; 2283 2284 memset(&rq, 0, sizeof(rq)); 2285 rq.ogf = OGF_HOST_CTL; 2286 rq.ocf = OCF_READ_INQ_RESPONSE_TX_POWER_LEVEL; 2287 rq.rparam = &rp; 2288 rq.rlen = READ_INQ_RESPONSE_TX_POWER_LEVEL_RP_SIZE; 2289 2290 if (hci_send_req(dd, &rq, to) < 0) 2291 return -1; 2292 2293 if (rp.status) { 2294 errno = EIO; 2295 return -1; 2296 } 2297 2298 *level = rp.level; 2299 return 0; 2300 } 2301 2302 int hci_read_inquiry_transmit_power_level(int dd, int8_t *level, int to) 2303 { 2304 return hci_read_inq_response_tx_power_level(dd, level, to); 2305 } 2306 2307 int hci_write_inquiry_transmit_power_level(int dd, int8_t level, int to) 2308 { 2309 write_inquiry_transmit_power_level_cp cp; 2310 write_inquiry_transmit_power_level_rp rp; 2311 struct hci_request rq; 2312 2313 memset(&cp, 0, sizeof(cp)); 2314 cp.level = level; 2315 2316 memset(&rq, 0, sizeof(rq)); 2317 rq.ogf = OGF_HOST_CTL; 2318 rq.ocf = OCF_WRITE_INQUIRY_TRANSMIT_POWER_LEVEL; 2319 rq.cparam = &cp; 2320 rq.clen = WRITE_INQUIRY_TRANSMIT_POWER_LEVEL_CP_SIZE; 2321 rq.rparam = &rp; 2322 rq.rlen = WRITE_INQUIRY_TRANSMIT_POWER_LEVEL_RP_SIZE; 2323 2324 if (hci_send_req(dd, &rq, to) < 0) 2325 return -1; 2326 2327 if (rp.status) { 2328 errno = EIO; 2329 return -1; 2330 } 2331 2332 return 0; 2333 } 2334 2335 int hci_read_transmit_power_level(int dd, uint16_t handle, uint8_t type, int8_t *level, int to) 2336 { 2337 read_transmit_power_level_cp cp; 2338 read_transmit_power_level_rp rp; 2339 struct hci_request rq; 2340 2341 memset(&cp, 0, sizeof(cp)); 2342 cp.handle = handle; 2343 cp.type = type; 2344 2345 memset(&rq, 0, sizeof(rq)); 2346 rq.ogf = OGF_HOST_CTL; 2347 rq.ocf = OCF_READ_TRANSMIT_POWER_LEVEL; 2348 rq.cparam = &cp; 2349 rq.clen = READ_TRANSMIT_POWER_LEVEL_CP_SIZE; 2350 rq.rparam = &rp; 2351 rq.rlen = READ_TRANSMIT_POWER_LEVEL_RP_SIZE; 2352 2353 if (hci_send_req(dd, &rq, to) < 0) 2354 return -1; 2355 2356 if (rp.status) { 2357 errno = EIO; 2358 return -1; 2359 } 2360 2361 *level = rp.level; 2362 return 0; 2363 } 2364 2365 int hci_read_link_policy(int dd, uint16_t handle, uint16_t *policy, int to) 2366 { 2367 read_link_policy_rp rp; 2368 struct hci_request rq; 2369 2370 memset(&rq, 0, sizeof(rq)); 2371 rq.ogf = OGF_LINK_POLICY; 2372 rq.ocf = OCF_READ_LINK_POLICY; 2373 rq.cparam = &handle; 2374 rq.clen = 2; 2375 rq.rparam = &rp; 2376 rq.rlen = READ_LINK_POLICY_RP_SIZE; 2377 2378 if (hci_send_req(dd, &rq, to) < 0) 2379 return -1; 2380 2381 if (rp.status) { 2382 errno = EIO; 2383 return -1; 2384 } 2385 2386 *policy = rp.policy; 2387 return 0; 2388 } 2389 2390 int hci_write_link_policy(int dd, uint16_t handle, uint16_t policy, int to) 2391 { 2392 write_link_policy_cp cp; 2393 write_link_policy_rp rp; 2394 struct hci_request rq; 2395 2396 memset(&cp, 0, sizeof(cp)); 2397 cp.handle = handle; 2398 cp.policy = policy; 2399 2400 memset(&rq, 0, sizeof(rq)); 2401 rq.ogf = OGF_LINK_POLICY; 2402 rq.ocf = OCF_WRITE_LINK_POLICY; 2403 rq.cparam = &cp; 2404 rq.clen = WRITE_LINK_POLICY_CP_SIZE; 2405 rq.rparam = &rp; 2406 rq.rlen = WRITE_LINK_POLICY_RP_SIZE; 2407 2408 if (hci_send_req(dd, &rq, to) < 0) 2409 return -1; 2410 2411 if (rp.status) { 2412 errno = EIO; 2413 return -1; 2414 } 2415 2416 return 0; 2417 } 2418 2419 int hci_read_link_supervision_timeout(int dd, uint16_t handle, uint16_t *timeout, int to) 2420 { 2421 read_link_supervision_timeout_rp rp; 2422 struct hci_request rq; 2423 2424 memset(&rq, 0, sizeof(rq)); 2425 rq.ogf = OGF_HOST_CTL; 2426 rq.ocf = OCF_READ_LINK_SUPERVISION_TIMEOUT; 2427 rq.cparam = &handle; 2428 rq.clen = 2; 2429 rq.rparam = &rp; 2430 rq.rlen = READ_LINK_SUPERVISION_TIMEOUT_RP_SIZE; 2431 2432 if (hci_send_req(dd, &rq, to) < 0) 2433 return -1; 2434 2435 if (rp.status) { 2436 errno = EIO; 2437 return -1; 2438 } 2439 2440 *timeout = rp.timeout; 2441 return 0; 2442 } 2443 2444 int hci_write_link_supervision_timeout(int dd, uint16_t handle, uint16_t timeout, int to) 2445 { 2446 write_link_supervision_timeout_cp cp; 2447 write_link_supervision_timeout_rp rp; 2448 struct hci_request rq; 2449 2450 memset(&cp, 0, sizeof(cp)); 2451 cp.handle = handle; 2452 cp.timeout = timeout; 2453 2454 memset(&rq, 0, sizeof(rq)); 2455 rq.ogf = OGF_HOST_CTL; 2456 rq.ocf = OCF_WRITE_LINK_SUPERVISION_TIMEOUT; 2457 rq.cparam = &cp; 2458 rq.clen = WRITE_LINK_SUPERVISION_TIMEOUT_CP_SIZE; 2459 rq.rparam = &rp; 2460 rq.rlen = WRITE_LINK_SUPERVISION_TIMEOUT_RP_SIZE; 2461 2462 if (hci_send_req(dd, &rq, to) < 0) 2463 return -1; 2464 2465 if (rp.status) { 2466 errno = EIO; 2467 return -1; 2468 } 2469 2470 return 0; 2471 } 2472 2473 int hci_set_afh_classification(int dd, uint8_t *map, int to) 2474 { 2475 set_afh_classification_cp cp; 2476 set_afh_classification_rp rp; 2477 struct hci_request rq; 2478 2479 memset(&cp, 0, sizeof(cp)); 2480 memcpy(cp.map, map, 10); 2481 2482 memset(&rq, 0, sizeof(rq)); 2483 rq.ogf = OGF_HOST_CTL; 2484 rq.ocf = OCF_SET_AFH_CLASSIFICATION; 2485 rq.cparam = &cp; 2486 rq.clen = SET_AFH_CLASSIFICATION_CP_SIZE; 2487 rq.rparam = &rp; 2488 rq.rlen = SET_AFH_CLASSIFICATION_RP_SIZE; 2489 2490 if (hci_send_req(dd, &rq, to) < 0) 2491 return -1; 2492 2493 if (rp.status) { 2494 errno = EIO; 2495 return -1; 2496 } 2497 2498 return 0; 2499 } 2500 2501 int hci_read_link_quality(int dd, uint16_t handle, uint8_t *link_quality, int to) 2502 { 2503 read_link_quality_rp rp; 2504 struct hci_request rq; 2505 2506 memset(&rq, 0, sizeof(rq)); 2507 rq.ogf = OGF_STATUS_PARAM; 2508 rq.ocf = OCF_READ_LINK_QUALITY; 2509 rq.cparam = &handle; 2510 rq.clen = 2; 2511 rq.rparam = &rp; 2512 rq.rlen = READ_LINK_QUALITY_RP_SIZE; 2513 2514 if (hci_send_req(dd, &rq, to) < 0) 2515 return -1; 2516 2517 if (rp.status) { 2518 errno = EIO; 2519 return -1; 2520 } 2521 2522 *link_quality = rp.link_quality; 2523 return 0; 2524 } 2525 2526 int hci_read_rssi(int dd, uint16_t handle, int8_t *rssi, int to) 2527 { 2528 read_rssi_rp rp; 2529 struct hci_request rq; 2530 2531 memset(&rq, 0, sizeof(rq)); 2532 rq.ogf = OGF_STATUS_PARAM; 2533 rq.ocf = OCF_READ_RSSI; 2534 rq.cparam = &handle; 2535 rq.clen = 2; 2536 rq.rparam = &rp; 2537 rq.rlen = READ_RSSI_RP_SIZE; 2538 2539 if (hci_send_req(dd, &rq, to) < 0) 2540 return -1; 2541 2542 if (rp.status) { 2543 errno = EIO; 2544 return -1; 2545 } 2546 2547 *rssi = rp.rssi; 2548 return 0; 2549 } 2550 2551 int hci_read_afh_map(int dd, uint16_t handle, uint8_t *mode, uint8_t *map, int to) 2552 { 2553 read_afh_map_rp rp; 2554 struct hci_request rq; 2555 2556 memset(&rq, 0, sizeof(rq)); 2557 rq.ogf = OGF_STATUS_PARAM; 2558 rq.ocf = OCF_READ_AFH_MAP; 2559 rq.cparam = &handle; 2560 rq.clen = 2; 2561 rq.rparam = &rp; 2562 rq.rlen = READ_AFH_MAP_RP_SIZE; 2563 2564 if (hci_send_req(dd, &rq, to) < 0) 2565 return -1; 2566 2567 if (rp.status) { 2568 errno = EIO; 2569 return -1; 2570 } 2571 2572 *mode = rp.mode; 2573 memcpy(map, rp.map, 10); 2574 return 0; 2575 } 2576 2577 int hci_read_clock(int dd, uint16_t handle, uint8_t which, uint32_t *clock, uint16_t *accuracy, int to) 2578 { 2579 read_clock_cp cp; 2580 read_clock_rp rp; 2581 struct hci_request rq; 2582 2583 memset(&cp, 0, sizeof(cp)); 2584 cp.handle = handle; 2585 cp.which_clock = which; 2586 2587 memset(&rq, 0, sizeof(rq)); 2588 rq.ogf = OGF_STATUS_PARAM; 2589 rq.ocf = OCF_READ_CLOCK; 2590 rq.cparam = &cp; 2591 rq.clen = READ_CLOCK_CP_SIZE; 2592 rq.rparam = &rp; 2593 rq.rlen = READ_CLOCK_RP_SIZE; 2594 2595 if (hci_send_req(dd, &rq, to) < 0) 2596 return -1; 2597 2598 if (rp.status) { 2599 errno = EIO; 2600 return -1; 2601 } 2602 2603 *clock = rp.clock; 2604 *accuracy = rp.accuracy; 2605 return 0; 2606 } 2607 2608 int hci_le_set_scan_enable(int dd, uint8_t enable, uint8_t filter_dup) 2609 { 2610 struct hci_request rq; 2611 le_set_scan_enable_cp scan_cp; 2612 uint8_t status; 2613 2614 memset(&scan_cp, 0, sizeof(scan_cp)); 2615 scan_cp.enable = enable; 2616 scan_cp.filter_dup = filter_dup; 2617 2618 memset(&rq, 0, sizeof(rq)); 2619 rq.ogf = OGF_LE_CTL; 2620 rq.ocf = OCF_LE_SET_SCAN_ENABLE; 2621 rq.cparam = &scan_cp; 2622 rq.clen = LE_SET_SCAN_ENABLE_CP_SIZE; 2623 rq.rparam = &status; 2624 rq.rlen = 1; 2625 2626 if (hci_send_req(dd, &rq, 100) < 0) 2627 return -1; 2628 2629 if (status) { 2630 errno = EIO; 2631 return -1; 2632 } 2633 2634 return 0; 2635 } 2636 2637 int hci_le_set_scan_parameters(int dd, uint8_t type, 2638 uint16_t interval, uint16_t window, 2639 uint8_t own_type, uint8_t filter) 2640 { 2641 struct hci_request rq; 2642 le_set_scan_parameters_cp param_cp; 2643 uint8_t status; 2644 2645 memset(¶m_cp, 0, sizeof(param_cp)); 2646 param_cp.type = type; 2647 param_cp.interval = interval; 2648 param_cp.window = window; 2649 param_cp.own_bdaddr_type = own_type; 2650 param_cp.filter = filter; 2651 2652 memset(&rq, 0, sizeof(rq)); 2653 rq.ogf = OGF_LE_CTL; 2654 rq.ocf = OCF_LE_SET_SCAN_PARAMETERS; 2655 rq.cparam = ¶m_cp; 2656 rq.clen = LE_SET_SCAN_PARAMETERS_CP_SIZE; 2657 rq.rparam = &status; 2658 rq.rlen = 1; 2659 2660 if (hci_send_req(dd, &rq, 100) < 0) 2661 return -1; 2662 2663 if (status) { 2664 errno = EIO; 2665 return -1; 2666 } 2667 2668 return 0; 2669 } 2670 2671 int hci_le_set_advertise_enable(int dd, uint8_t enable) 2672 { 2673 struct hci_request rq; 2674 le_set_advertise_enable_cp adv_cp; 2675 uint8_t status; 2676 2677 memset(&adv_cp, 0, sizeof(adv_cp)); 2678 adv_cp.enable = enable; 2679 2680 memset(&rq, 0, sizeof(rq)); 2681 rq.ogf = OGF_LE_CTL; 2682 rq.ocf = OCF_LE_SET_ADVERTISE_ENABLE; 2683 rq.cparam = &adv_cp; 2684 rq.clen = LE_SET_ADVERTISE_ENABLE_CP_SIZE; 2685 rq.rparam = &status; 2686 rq.rlen = 1; 2687 2688 if (hci_send_req(dd, &rq, 100) < 0) 2689 return -1; 2690 2691 if (status) { 2692 errno = EIO; 2693 return -1; 2694 } 2695 2696 return 0; 2697 } 2698 2699 int hci_le_create_conn(int dd, uint16_t interval, uint16_t window, 2700 uint8_t initiator_filter, uint8_t peer_bdaddr_type, 2701 bdaddr_t peer_bdaddr, uint8_t own_bdaddr_type, 2702 uint16_t min_interval, uint16_t max_interval, 2703 uint16_t latency, uint16_t supervision_timeout, 2704 uint16_t min_ce_length, uint16_t max_ce_length, 2705 uint16_t *handle, int to) 2706 { 2707 struct hci_request rq; 2708 le_create_connection_cp create_conn_cp; 2709 evt_le_connection_complete conn_complete_rp; 2710 2711 memset(&create_conn_cp, 0, sizeof(create_conn_cp)); 2712 create_conn_cp.interval = interval; 2713 create_conn_cp.window = window; 2714 create_conn_cp.initiator_filter = initiator_filter; 2715 create_conn_cp.peer_bdaddr_type = peer_bdaddr_type; 2716 create_conn_cp.peer_bdaddr = peer_bdaddr; 2717 create_conn_cp.own_bdaddr_type = own_bdaddr_type; 2718 create_conn_cp.min_interval = min_interval; 2719 create_conn_cp.max_interval = max_interval; 2720 create_conn_cp.latency = latency; 2721 create_conn_cp.supervision_timeout = supervision_timeout; 2722 create_conn_cp.min_ce_length = min_ce_length; 2723 create_conn_cp.max_ce_length = max_ce_length; 2724 2725 memset(&rq, 0, sizeof(rq)); 2726 rq.ogf = OGF_LE_CTL; 2727 rq.ocf = OCF_LE_CREATE_CONN; 2728 rq.event = EVT_LE_CONN_COMPLETE; 2729 rq.cparam = &create_conn_cp; 2730 rq.clen = LE_CREATE_CONN_CP_SIZE; 2731 rq.rparam = &conn_complete_rp; 2732 rq.rlen = EVT_CONN_COMPLETE_SIZE; 2733 2734 if (hci_send_req(dd, &rq, to) < 0) 2735 return -1; 2736 2737 if (conn_complete_rp.status) { 2738 errno = EIO; 2739 return -1; 2740 } 2741 2742 if (handle) 2743 *handle = conn_complete_rp.handle; 2744 2745 return 0; 2746 } 2747
