3 * BlueZ - Bluetooth protocol stack for Linux
5 * Copyright (C) 2000-2001 Qualcomm Incorporated
6 * Copyright (C) 2002-2003 Maxim Krasnyansky <maxk@qualcomm.com>
7 * Copyright (C) 2002-2010 Marcel Holtmann <marcel@holtmann.org>
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.
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.
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
37 #include <sys/param.h>
40 #include <sys/types.h>
41 #include <sys/ioctl.h>
42 #include <sys/socket.h>
44 #include "bluetooth.h"
49 #define MIN(x, y) ((x) < (y) ? (x) : (y))
57 static char *hci_bit2str(hci_map *m, unsigned int val)
59 char *str = malloc(120);
67 if ((unsigned int) m->val & val)
68 ptr += sprintf(ptr, "%s ", m->str);
74 static int hci_str2bit(hci_map *map, char *str, unsigned int *val)
80 if (!str || !(str = ptr = strdup(str)))
85 while ((t = strsep(&ptr, ","))) {
86 for (m = map; m->str; m++) {
87 if (!strcasecmp(m->str, t)) {
88 *val |= (unsigned int) m->val;
98 static char *hci_uint2str(hci_map *m, unsigned int val)
100 char *str = malloc(50);
108 if ((unsigned int) m->val == val) {
109 ptr += sprintf(ptr, "%s", m->str);
117 static int hci_str2uint(hci_map *map, char *str, unsigned int *val)
126 str = ptr = strdup(str);
128 while ((t = strsep(&ptr, ","))) {
129 for (m = map; m->str; m++) {
130 if (!strcasecmp(m->str,t)) {
131 *val = (unsigned int) m->val;
142 char *hci_bustostr(int bus)
164 char *hci_dtypetostr(int type)
166 return hci_bustostr(type & 0x0f);
169 char *hci_typetostr(int type)
181 /* HCI dev flags mapping */
182 static hci_map dev_flags_map[] = {
184 { "INIT", HCI_INIT },
185 { "RUNNING", HCI_RUNNING },
187 { "PSCAN", HCI_PSCAN },
188 { "ISCAN", HCI_ISCAN },
189 { "INQUIRY", HCI_INQUIRY },
190 { "AUTH", HCI_AUTH },
191 { "ENCRYPT", HCI_ENCRYPT },
195 char *hci_dflagstostr(uint32_t flags)
197 char *str = bt_malloc(50);
199 hci_map *m = dev_flags_map;
206 if (!hci_test_bit(HCI_UP, &flags))
207 ptr += sprintf(ptr, "DOWN ");
210 if (hci_test_bit(m->val, &flags))
211 ptr += sprintf(ptr, "%s ", m->str);
217 /* HCI packet type mapping */
218 static hci_map pkt_type_map[] = {
228 { "2-DH1", HCI_2DH1 },
229 { "2-DH3", HCI_2DH3 },
230 { "2-DH5", HCI_2DH5 },
231 { "3-DH1", HCI_3DH1 },
232 { "3-DH3", HCI_3DH3 },
233 { "3-DH5", HCI_3DH5 },
237 static hci_map sco_ptype_map[] = {
244 { "2-EV3", HCI_2EV3 },
245 { "2-EV5", HCI_2EV5 },
246 { "3-EV3", HCI_3EV3 },
247 { "3-EV5", HCI_3EV5 },
251 char *hci_ptypetostr(unsigned int ptype)
253 return hci_bit2str(pkt_type_map, ptype);
256 int hci_strtoptype(char *str, unsigned int *val)
258 return hci_str2bit(pkt_type_map, str, val);
261 char *hci_scoptypetostr(unsigned int ptype)
263 return hci_bit2str(sco_ptype_map, ptype);
266 int hci_strtoscoptype(char *str, unsigned int *val)
268 return hci_str2bit(sco_ptype_map, str, val);
271 /* Link policy mapping */
272 static hci_map link_policy_map[] = {
274 { "RSWITCH", HCI_LP_RSWITCH },
275 { "HOLD", HCI_LP_HOLD },
276 { "SNIFF", HCI_LP_SNIFF },
277 { "PARK", HCI_LP_PARK },
281 char *hci_lptostr(unsigned int lp)
283 return hci_bit2str(link_policy_map, lp);
286 int hci_strtolp(char *str, unsigned int *val)
288 return hci_str2bit(link_policy_map, str, val);
291 /* Link mode mapping */
292 static hci_map link_mode_map[] = {
294 { "ACCEPT", HCI_LM_ACCEPT },
295 { "MASTER", HCI_LM_MASTER },
296 { "AUTH", HCI_LM_AUTH },
297 { "ENCRYPT", HCI_LM_ENCRYPT },
298 { "TRUSTED", HCI_LM_TRUSTED },
299 { "RELIABLE", HCI_LM_RELIABLE },
300 { "SECURE", HCI_LM_SECURE },
304 char *hci_lmtostr(unsigned int lm)
306 char *s, *str = bt_malloc(50);
311 if (!(lm & HCI_LM_MASTER))
312 strcpy(str, "SLAVE ");
314 s = hci_bit2str(link_mode_map, lm);
325 int hci_strtolm(char *str, unsigned int *val)
327 return hci_str2bit(link_mode_map, str, val);
330 /* Command mapping */
331 static hci_map commands_map[] = {
333 { "Inquiry Cancel", 1 },
334 { "Periodic Inquiry Mode", 2 },
335 { "Exit Periodic Inquiry Mode", 3 },
336 { "Create Connection", 4 },
338 { "Add SCO Connection", 6 },
339 { "Cancel Create Connection", 7 },
341 { "Accept Connection Request", 8 },
342 { "Reject Connection Request", 9 },
343 { "Link Key Request Reply", 10 },
344 { "Link Key Request Negative Reply", 11 },
345 { "PIN Code Request Reply", 12 },
346 { "PIN Code Request Negative Reply", 13 },
347 { "Change Connection Packet Type", 14 },
348 { "Authentication Requested", 15 },
350 { "Set Connection Encryption", 16 },
351 { "Change Connection Link Key", 17 },
352 { "Master Link Key", 18 },
353 { "Remote Name Request", 19 },
354 { "Cancel Remote Name Request", 20 },
355 { "Read Remote Supported Features", 21 },
356 { "Read Remote Extended Features", 22 },
357 { "Read Remote Version Information", 23 },
359 { "Read Clock Offset", 24 },
360 { "Read LMP Handle", 25 },
370 { "Sniff Mode", 34 },
371 { "Exit Sniff Mode", 35 },
372 { "Park State", 36 },
373 { "Exit Park State", 37 },
375 { "Role Discovery", 39 },
377 { "Switch Role", 40 },
378 { "Read Link Policy Settings", 41 },
379 { "Write Link Policy Settings", 42 },
380 { "Read Default Link Policy Settings", 43 },
381 { "Write Default Link Policy Settings", 44 },
382 { "Flow Specification", 45 },
383 { "Set Event Mask", 46 },
386 { "Set Event Filter", 48 },
388 { "Read PIN Type", 50 },
389 { "Write PIN Type", 51 },
390 { "Create New Unit Key", 52 },
391 { "Read Stored Link Key", 53 },
392 { "Write Stored Link Key", 54 },
393 { "Delete Stored Link Key", 55 },
395 { "Write Local Name", 56 },
396 { "Read Local Name", 57 },
397 { "Read Connection Accept Timeout", 58 },
398 { "Write Connection Accept Timeout", 59 },
399 { "Read Page Timeout", 60 },
400 { "Write Page Timeout", 61 },
401 { "Read Scan Enable", 62 },
402 { "Write Scan Enable", 63 },
404 { "Read Page Scan Activity", 64 },
405 { "Write Page Scan Activity", 65 },
406 { "Read Inquiry Scan Activity", 66 },
407 { "Write Inquiry Scan Activity", 67 },
408 { "Read Authentication Enable", 68 },
409 { "Write Authentication Enable", 69 },
410 { "Read Encryption Mode", 70 },
411 { "Write Encryption Mode", 71 },
413 { "Read Class Of Device", 72 },
414 { "Write Class Of Device", 73 },
415 { "Read Voice Setting", 74 },
416 { "Write Voice Setting", 75 },
417 { "Read Automatic Flush Timeout", 76 },
418 { "Write Automatic Flush Timeout", 77 },
419 { "Read Num Broadcast Retransmissions", 78 },
420 { "Write Num Broadcast Retransmissions", 79 },
422 { "Read Hold Mode Activity", 80 },
423 { "Write Hold Mode Activity", 81 },
424 { "Read Transmit Power Level", 82 },
425 { "Read Synchronous Flow Control Enable", 83 },
426 { "Write Synchronous Flow Control Enable", 84 },
427 { "Set Host Controller To Host Flow Control", 85 },
428 { "Host Buffer Size", 86 },
429 { "Host Number Of Completed Packets", 87 },
431 { "Read Link Supervision Timeout", 88 },
432 { "Write Link Supervision Timeout", 89 },
433 { "Read Number of Supported IAC", 90 },
434 { "Read Current IAC LAP", 91 },
435 { "Write Current IAC LAP", 92 },
436 { "Read Page Scan Period Mode", 93 },
437 { "Write Page Scan Period Mode", 94 },
438 { "Read Page Scan Mode", 95 },
440 { "Write Page Scan Mode", 96 },
441 { "Set AFH Channel Classification", 97 },
444 { "Read Inquiry Scan Type", 100 },
445 { "Write Inquiry Scan Type", 101 },
446 { "Read Inquiry Mode", 102 },
447 { "Write Inquiry Mode", 103 },
449 { "Read Page Scan Type", 104 },
450 { "Write Page Scan Type", 105 },
451 { "Read AFH Channel Assessment Mode", 106 },
452 { "Write AFH Channel Assessment Mode", 107 },
461 { "Read Local Version Information", 115 },
462 { "Read Local Supported Commands", 116 },
463 { "Read Local Supported Features", 117 },
464 { "Read Local Extended Features", 118 },
465 { "Read Buffer Size", 119 },
467 { "Read Country Code", 120 },
468 { "Read BD ADDR", 121 },
469 { "Read Failed Contact Counter", 122 },
470 { "Reset Failed Contact Counter", 123 },
471 { "Get Link Quality", 124 },
472 { "Read RSSI", 125 },
473 { "Read AFH Channel Map", 126 },
474 { "Read BD Clock", 127 },
476 { "Read Loopback Mode", 128 },
477 { "Write Loopback Mode", 129 },
478 { "Enable Device Under Test Mode", 130 },
479 { "Setup Synchronous Connection", 131 },
480 { "Accept Synchronous Connection", 132 },
481 { "Reject Synchronous Connection", 133 },
485 { "Read Extended Inquiry Response", 136 },
486 { "Write Extended Inquiry Response", 137 },
487 { "Refresh Encryption Key", 138 },
489 { "Sniff Subrating", 140 },
490 { "Read Simple Pairing Mode", 141 },
491 { "Write Simple Pairing Mode", 142 },
492 { "Read Local OOB Data", 143 },
494 { "Read Inquiry Response Transmit Power Level", 144 },
495 { "Write Inquiry Transmit Power Level", 145 },
496 { "Read Default Erroneous Data Reporting", 146 },
497 { "Write Default Erroneous Data Reporting", 147 },
501 { "IO Capability Request Reply", 151 },
503 { "User Confirmation Request Reply", 152 },
504 { "User Confirmation Request Negative Reply", 153 },
505 { "User Passkey Request Reply", 154 },
506 { "User Passkey Request Negative Reply", 155 },
507 { "Remote OOB Data Request Reply", 156 },
508 { "Write Simple Pairing Debug Mode", 157 },
509 { "Enhanced Flush", 158 },
510 { "Remote OOB Data Request Negative Reply", 159 },
514 { "Send Keypress Notification", 162 },
515 { "IO Capability Request Negative Reply", 163 },
516 { "Read Encryption Key Size", 164 },
521 { "Create Physical Link", 168 },
522 { "Accept Physical Link", 169 },
523 { "Disconnect Physical Link", 170 },
524 { "Create Logical Link", 171 },
525 { "Accept Logical Link", 172 },
526 { "Disconnect Logical Link", 173 },
527 { "Logical Link Cancel", 174 },
528 { "Flow Specification Modify", 175 },
530 { "Read Logical Link Accept Timeout", 176 },
531 { "Write Logical Link Accept Timeout", 177 },
532 { "Set Event Mask Page 2", 178 },
533 { "Read Location Data", 179 },
534 { "Write Location Data", 180 },
535 { "Read Local AMP Info", 181 },
536 { "Read Local AMP_ASSOC", 182 },
537 { "Write Remote AMP_ASSOC", 183 },
539 { "Read Flow Control Mode", 184 },
540 { "Write Flow Control Mode", 185 },
541 { "Read Data Block Size", 186 },
544 { "Enable AMP Receiver Reports", 189 },
545 { "AMP Test End", 190 },
546 { "AMP Test Command", 191 },
548 { "Read Enhanced Transmit Power Level", 192 },
550 { "Read Best Effort Flush Timeout", 194 },
551 { "Write Best Effort Flush Timeout", 195 },
552 { "Short Range Mode", 196 },
553 { "Read LE Host Support", 197 },
554 { "Write LE Host Support", 198 },
557 { "LE Set Event Mask", 200 },
558 { "LE Read Buffer Size", 201 },
559 { "LE Read Local Supported Features", 202 },
561 { "LE Set Random Address", 204 },
562 { "LE Set Advertising Parameters", 205 },
563 { "LE Read Advertising Channel TX Power", 206 },
564 { "LE Set Advertising Data", 207 },
566 { "LE Set Scan Response Data", 208 },
567 { "LE Set Advertise Enable", 209 },
568 { "LE Set Scan Parameters", 210 },
569 { "LE Set Scan Enable", 211 },
570 { "LE Create Connection", 212 },
571 { "LE Create Connection Cancel", 213 },
572 { "LE Read White List Size", 214 },
573 { "LE Clear White List", 215 },
575 { "LE Add Device To White List", 216 },
576 { "LE Remove Device From White List", 217 },
577 { "LE Connection Update", 218 },
578 { "LE Set Host Channel Classification", 219 },
579 { "LE Read Channel Map", 220 },
580 { "LE Read Remote Used Features", 221 },
581 { "LE Encrypt", 222 },
584 { "LE Start Encryption", 224 },
585 { "LE Long Term Key Request Reply", 225 },
586 { "LE Long Term Key Request Negative Reply", 226 },
587 { "LE Read Supported States", 227 },
588 { "LE Receiver Test", 228 },
589 { "LE Transmitter Test", 229 },
590 { "LE Test End", 230 },
596 char *hci_cmdtostr(unsigned int cmd)
598 return hci_uint2str(commands_map, cmd);
601 char *hci_commandstostr(uint8_t *commands, char *pref, int width)
603 unsigned int maxwidth = width - 3;
605 char *off, *ptr, *str;
611 if (commands[m->val / 8] & (1 << (m->val % 8)))
612 size += strlen(m->str) + (pref ? strlen(pref) : 0) + 3;
616 str = bt_malloc(size);
620 ptr = str; *ptr = '\0';
623 ptr += sprintf(ptr, "%s", pref);
630 if (commands[m->val / 8] & (1 << (m->val % 8))) {
631 if (strlen(off) + strlen(m->str) > maxwidth) {
632 ptr += sprintf(ptr, "\n%s", pref ? pref : "");
635 ptr += sprintf(ptr, "'%s' ", m->str);
643 /* Version mapping */
644 static hci_map ver_map[] = {
655 char *hci_vertostr(unsigned int ver)
657 return hci_uint2str(ver_map, ver);
660 int hci_strtover(char *str, unsigned int *ver)
662 return hci_str2uint(ver_map, str, ver);
665 char *lmp_vertostr(unsigned int ver)
667 return hci_uint2str(ver_map, ver);
670 int lmp_strtover(char *str, unsigned int *ver)
672 return hci_str2uint(ver_map, str, ver);
675 /* LMP features mapping */
676 static hci_map lmp_features_map[8][9] = {
678 { "<3-slot packets>", LMP_3SLOT }, /* Bit 0 */
679 { "<5-slot packets>", LMP_5SLOT }, /* Bit 1 */
680 { "<encryption>", LMP_ENCRYPT }, /* Bit 2 */
681 { "<slot offset>", LMP_SOFFSET }, /* Bit 3 */
682 { "<timing accuracy>", LMP_TACCURACY }, /* Bit 4 */
683 { "<role switch>", LMP_RSWITCH }, /* Bit 5 */
684 { "<hold mode>", LMP_HOLD }, /* Bit 6 */
685 { "<sniff mode>", LMP_SNIFF }, /* Bit 7 */
689 { "<park state>", LMP_PARK }, /* Bit 0 */
690 { "<RSSI>", LMP_RSSI }, /* Bit 1 */
691 { "<channel quality>", LMP_QUALITY }, /* Bit 2 */
692 { "<SCO link>", LMP_SCO }, /* Bit 3 */
693 { "<HV2 packets>", LMP_HV2 }, /* Bit 4 */
694 { "<HV3 packets>", LMP_HV3 }, /* Bit 5 */
695 { "<u-law log>", LMP_ULAW }, /* Bit 6 */
696 { "<A-law log>", LMP_ALAW }, /* Bit 7 */
700 { "<CVSD>", LMP_CVSD }, /* Bit 0 */
701 { "<paging scheme>", LMP_PSCHEME }, /* Bit 1 */
702 { "<power control>", LMP_PCONTROL }, /* Bit 2 */
703 { "<transparent SCO>", LMP_TRSP_SCO }, /* Bit 3 */
704 { "<broadcast encrypt>",LMP_BCAST_ENC }, /* Bit 7 */
708 { "<no. 24>", 0x01 }, /* Bit 0 */
709 { "<EDR ACL 2 Mbps>", LMP_EDR_ACL_2M }, /* Bit 1 */
710 { "<EDR ACL 3 Mbps>", LMP_EDR_ACL_3M }, /* Bit 2 */
711 { "<enhanced iscan>", LMP_ENH_ISCAN }, /* Bit 3 */
712 { "<interlaced iscan>", LMP_ILACE_ISCAN }, /* Bit 4 */
713 { "<interlaced pscan>", LMP_ILACE_PSCAN }, /* Bit 5 */
714 { "<inquiry with RSSI>",LMP_RSSI_INQ }, /* Bit 6 */
715 { "<extended SCO>", LMP_ESCO }, /* Bit 7 */
719 { "<EV4 packets>", LMP_EV4 }, /* Bit 0 */
720 { "<EV5 packets>", LMP_EV5 }, /* Bit 1 */
721 { "<no. 34>", 0x04 }, /* Bit 2 */
722 { "<AFH cap. slave>", LMP_AFH_CAP_SLV }, /* Bit 3 */
723 { "<AFH class. slave>", LMP_AFH_CLS_SLV }, /* Bit 4 */
724 { "<BR/EDR not supp.>", LMP_NO_BREDR }, /* Bit 5 */
725 { "<LE support>", LMP_LE }, /* Bit 6 */
726 { "<3-slot EDR ACL>", LMP_EDR_3SLOT }, /* Bit 7 */
730 { "<5-slot EDR ACL>", LMP_EDR_5SLOT }, /* Bit 0 */
731 { "<sniff subrating>", LMP_SNIFF_SUBR }, /* Bit 1 */
732 { "<pause encryption>", LMP_PAUSE_ENC }, /* Bit 2 */
733 { "<AFH cap. master>", LMP_AFH_CAP_MST }, /* Bit 3 */
734 { "<AFH class. master>",LMP_AFH_CLS_MST }, /* Bit 4 */
735 { "<EDR eSCO 2 Mbps>", LMP_EDR_ESCO_2M }, /* Bit 5 */
736 { "<EDR eSCO 3 Mbps>", LMP_EDR_ESCO_3M }, /* Bit 6 */
737 { "<3-slot EDR eSCO>", LMP_EDR_3S_ESCO }, /* Bit 7 */
741 { "<extended inquiry>", LMP_EXT_INQ }, /* Bit 0 */
742 { "<LE and BR/EDR>", LMP_LE_BREDR }, /* Bit 1 */
743 { "<no. 50>", 0x04 }, /* Bit 2 */
744 { "<simple pairing>", LMP_SIMPLE_PAIR }, /* Bit 3 */
745 { "<encapsulated PDU>", LMP_ENCAPS_PDU }, /* Bit 4 */
746 { "<err. data report>", LMP_ERR_DAT_REP }, /* Bit 5 */
747 { "<non-flush flag>", LMP_NFLUSH_PKTS }, /* Bit 6 */
748 { "<no. 55>", 0x80 }, /* Bit 7 */
752 { "<LSTO>", LMP_LSTO }, /* Bit 1 */
753 { "<inquiry TX power>", LMP_INQ_TX_PWR }, /* Bit 1 */
754 { "<EPC>", LMP_EPC }, /* Bit 2 */
755 { "<no. 59>", 0x08 }, /* Bit 3 */
756 { "<no. 60>", 0x10 }, /* Bit 4 */
757 { "<no. 61>", 0x20 }, /* Bit 5 */
758 { "<no. 62>", 0x40 }, /* Bit 6 */
759 { "<extended features>",LMP_EXT_FEAT }, /* Bit 7 */
764 char *lmp_featurestostr(uint8_t *features, char *pref, int width)
766 unsigned int maxwidth = width - 1;
767 char *off, *ptr, *str;
770 for (i = 0; i < 8; i++) {
771 hci_map *m = lmp_features_map[i];
774 if (m->val & features[i])
775 size += strlen(m->str) +
776 (pref ? strlen(pref) : 0) + 1;
781 str = bt_malloc(size);
785 ptr = str; *ptr = '\0';
788 ptr += sprintf(ptr, "%s", pref);
792 for (i = 0; i < 8; i++) {
793 hci_map *m = lmp_features_map[i];
796 if (m->val & features[i]) {
797 if (strlen(off) + strlen(m->str) > maxwidth) {
798 ptr += sprintf(ptr, "\n%s",
802 ptr += sprintf(ptr, "%s ", m->str);
811 /* HCI functions that do not require open device */
812 int hci_for_each_dev(int flag, int (*func)(int dd, int dev_id, long arg),
815 struct hci_dev_list_req *dl;
816 struct hci_dev_req *dr;
820 sk = socket(AF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI);
824 dl = malloc(HCI_MAX_DEV * sizeof(*dr) + sizeof(*dl));
830 memset(dl, 0, HCI_MAX_DEV * sizeof(*dr) + sizeof(*dl));
832 dl->dev_num = HCI_MAX_DEV;
835 if (ioctl(sk, HCIGETDEVLIST, (void *) dl) < 0) {
840 for (i = 0; i < dl->dev_num; i++, dr++) {
841 if (hci_test_bit(flag, &dr->dev_opt))
842 if (!func || func(sk, dr->dev_id, arg)) {
861 static int __other_bdaddr(int dd, int dev_id, long arg)
863 struct hci_dev_info di = { .dev_id = dev_id };
865 if (ioctl(dd, HCIGETDEVINFO, (void *) &di))
868 if (hci_test_bit(HCI_RAW, &di.flags))
871 return bacmp((bdaddr_t *) arg, &di.bdaddr);
874 static int __same_bdaddr(int dd, int dev_id, long arg)
876 struct hci_dev_info di = { .dev_id = dev_id };
878 if (ioctl(dd, HCIGETDEVINFO, (void *) &di))
881 return !bacmp((bdaddr_t *) arg, &di.bdaddr);
884 int hci_get_route(bdaddr_t *bdaddr)
886 return hci_for_each_dev(HCI_UP, __other_bdaddr,
887 (long) (bdaddr ? bdaddr : BDADDR_ANY));
890 int hci_devid(const char *str)
895 if (!strncmp(str, "hci", 3) && strlen(str) >= 4) {
897 if (hci_devba(id, &ba) < 0)
902 id = hci_for_each_dev(HCI_UP, __same_bdaddr, (long) &ba);
908 int hci_devinfo(int dev_id, struct hci_dev_info *di)
912 dd = socket(AF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI);
916 memset(di, 0, sizeof(struct hci_dev_info));
919 ret = ioctl(dd, HCIGETDEVINFO, (void *) di);
928 int hci_devba(int dev_id, bdaddr_t *bdaddr)
930 struct hci_dev_info di;
932 memset(&di, 0, sizeof(di));
934 if (hci_devinfo(dev_id, &di))
937 if (!hci_test_bit(HCI_UP, &di.flags)) {
942 bacpy(bdaddr, &di.bdaddr);
947 int hci_inquiry(int dev_id, int len, int nrsp, const uint8_t *lap,
948 inquiry_info **ii, long flags)
950 struct hci_inquiry_req *ir;
951 uint8_t num_rsp = nrsp;
953 int dd, size, err, ret = -1;
961 dev_id = hci_get_route(NULL);
968 dd = socket(AF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI);
972 buf = malloc(sizeof(*ir) + (sizeof(inquiry_info) * (nrsp)));
978 ir->num_rsp = num_rsp;
983 memcpy(ir->lap, lap, 3);
990 ret = ioctl(dd, HCIINQUIRY, (unsigned long) buf);
994 size = sizeof(inquiry_info) * ir->num_rsp;
1000 memcpy((void *) *ii, buf + sizeof(*ir), size);
1017 * Returns device descriptor (dd). */
1018 int hci_open_dev(int dev_id)
1020 struct sockaddr_hci a;
1023 /* Create HCI socket */
1024 dd = socket(AF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI);
1028 /* Bind socket to the HCI device */
1029 memset(&a, 0, sizeof(a));
1030 a.hci_family = AF_BLUETOOTH;
1032 if (bind(dd, (struct sockaddr *) &a, sizeof(a)) < 0)
1045 int hci_close_dev(int dd)
1050 /* HCI functions that require open device
1051 * dd - Device descriptor returned by hci_open_dev. */
1053 int hci_send_cmd(int dd, uint16_t ogf, uint16_t ocf, uint8_t plen, void *param)
1055 uint8_t type = HCI_COMMAND_PKT;
1060 hc.opcode = htobs(cmd_opcode_pack(ogf, ocf));
1063 iv[0].iov_base = &type;
1065 iv[1].iov_base = &hc;
1066 iv[1].iov_len = HCI_COMMAND_HDR_SIZE;
1070 iv[2].iov_base = param;
1071 iv[2].iov_len = plen;
1075 while (writev(dd, iv, ivn) < 0) {
1076 if (errno == EAGAIN || errno == EINTR)
1083 int hci_send_req(int dd, struct hci_request *r, int to)
1085 unsigned char buf[HCI_MAX_EVENT_SIZE], *ptr;
1086 uint16_t opcode = htobs(cmd_opcode_pack(r->ogf, r->ocf));
1087 struct hci_filter nf, of;
1093 if (getsockopt(dd, SOL_HCI, HCI_FILTER, &of, &olen) < 0)
1096 hci_filter_clear(&nf);
1097 hci_filter_set_ptype(HCI_EVENT_PKT, &nf);
1098 hci_filter_set_event(EVT_CMD_STATUS, &nf);
1099 hci_filter_set_event(EVT_CMD_COMPLETE, &nf);
1100 hci_filter_set_event(EVT_LE_META_EVENT, &nf);
1101 hci_filter_set_event(r->event, &nf);
1102 hci_filter_set_opcode(opcode, &nf);
1103 if (setsockopt(dd, SOL_HCI, HCI_FILTER, &nf, sizeof(nf)) < 0)
1106 if (hci_send_cmd(dd, r->ogf, r->ocf, r->clen, r->cparam) < 0)
1111 evt_cmd_complete *cc;
1113 evt_remote_name_req_complete *rn;
1114 evt_le_meta_event *me;
1115 remote_name_req_cp *cp;
1122 p.fd = dd; p.events = POLLIN;
1123 while ((n = poll(&p, 1, to)) < 0) {
1124 if (errno == EAGAIN || errno == EINTR)
1140 while ((len = read(dd, buf, sizeof(buf))) < 0) {
1141 if (errno == EAGAIN || errno == EINTR)
1146 hdr = (void *) (buf + 1);
1147 ptr = buf + (1 + HCI_EVENT_HDR_SIZE);
1148 len -= (1 + HCI_EVENT_HDR_SIZE);
1151 case EVT_CMD_STATUS:
1154 if (cs->opcode != opcode)
1157 if (r->event != EVT_CMD_STATUS) {
1165 r->rlen = MIN(len, r->rlen);
1166 memcpy(r->rparam, ptr, r->rlen);
1169 case EVT_CMD_COMPLETE:
1172 if (cc->opcode != opcode)
1175 ptr += EVT_CMD_COMPLETE_SIZE;
1176 len -= EVT_CMD_COMPLETE_SIZE;
1178 r->rlen = MIN(len, r->rlen);
1179 memcpy(r->rparam, ptr, r->rlen);
1182 case EVT_REMOTE_NAME_REQ_COMPLETE:
1183 if (hdr->evt != r->event)
1189 if (bacmp(&rn->bdaddr, &cp->bdaddr))
1192 r->rlen = MIN(len, r->rlen);
1193 memcpy(r->rparam, ptr, r->rlen);
1196 case EVT_LE_META_EVENT:
1199 if (me->subevent != r->event)
1203 r->rlen = MIN(len, r->rlen);
1204 memcpy(r->rparam, me->data, r->rlen);
1208 if (hdr->evt != r->event)
1211 r->rlen = MIN(len, r->rlen);
1212 memcpy(r->rparam, ptr, r->rlen);
1220 setsockopt(dd, SOL_HCI, HCI_FILTER, &of, sizeof(of));
1225 setsockopt(dd, SOL_HCI, HCI_FILTER, &of, sizeof(of));
1229 int hci_create_connection(int dd, const bdaddr_t *bdaddr, uint16_t ptype,
1230 uint16_t clkoffset, uint8_t rswitch,
1231 uint16_t *handle, int to)
1233 evt_conn_complete rp;
1235 struct hci_request rq;
1237 memset(&cp, 0, sizeof(cp));
1238 bacpy(&cp.bdaddr, bdaddr);
1239 cp.pkt_type = ptype;
1240 cp.pscan_rep_mode = 0x02;
1241 cp.clock_offset = clkoffset;
1242 cp.role_switch = rswitch;
1244 memset(&rq, 0, sizeof(rq));
1245 rq.ogf = OGF_LINK_CTL;
1246 rq.ocf = OCF_CREATE_CONN;
1247 rq.event = EVT_CONN_COMPLETE;
1249 rq.clen = CREATE_CONN_CP_SIZE;
1251 rq.rlen = EVT_CONN_COMPLETE_SIZE;
1253 if (hci_send_req(dd, &rq, to) < 0)
1261 *handle = rp.handle;
1265 int hci_disconnect(int dd, uint16_t handle, uint8_t reason, int to)
1267 evt_disconn_complete rp;
1269 struct hci_request rq;
1271 memset(&cp, 0, sizeof(cp));
1275 memset(&rq, 0, sizeof(rq));
1276 rq.ogf = OGF_LINK_CTL;
1277 rq.ocf = OCF_DISCONNECT;
1278 rq.event = EVT_DISCONN_COMPLETE;
1280 rq.clen = DISCONNECT_CP_SIZE;
1282 rq.rlen = EVT_DISCONN_COMPLETE_SIZE;
1284 if (hci_send_req(dd, &rq, to) < 0)
1294 int hci_le_add_white_list(int dd, const bdaddr_t *bdaddr, uint8_t type, int to)
1296 struct hci_request rq;
1297 le_add_device_to_white_list_cp cp;
1300 memset(&cp, 0, sizeof(cp));
1301 cp.bdaddr_type = type;
1302 bacpy(&cp.bdaddr, bdaddr);
1304 memset(&rq, 0, sizeof(rq));
1305 rq.ogf = OGF_LE_CTL;
1306 rq.ocf = OCF_LE_ADD_DEVICE_TO_WHITE_LIST;
1308 rq.clen = LE_ADD_DEVICE_TO_WHITE_LIST_CP_SIZE;
1309 rq.rparam = &status;
1312 if (hci_send_req(dd, &rq, to) < 0)
1323 int hci_le_rm_white_list(int dd, const bdaddr_t *bdaddr, uint8_t type, int to)
1325 struct hci_request rq;
1326 le_remove_device_from_white_list_cp cp;
1329 memset(&cp, 0, sizeof(cp));
1330 cp.bdaddr_type = type;
1331 bacpy(&cp.bdaddr, bdaddr);
1333 memset(&rq, 0, sizeof(rq));
1334 rq.ogf = OGF_LE_CTL;
1335 rq.ocf = OCF_LE_REMOVE_DEVICE_FROM_WHITE_LIST;
1337 rq.clen = LE_REMOVE_DEVICE_FROM_WHITE_LIST_CP_SIZE;
1338 rq.rparam = &status;
1341 if (hci_send_req(dd, &rq, to) < 0)
1352 int hci_le_read_white_list_size(int dd, uint8_t *size, int to)
1354 struct hci_request rq;
1355 le_read_white_list_size_rp rp;
1357 memset(&rp, 0, sizeof(rp));
1358 memset(&rq, 0, sizeof(rq));
1360 rq.ogf = OGF_LE_CTL;
1361 rq.ocf = OCF_LE_READ_WHITE_LIST_SIZE;
1363 rq.rlen = LE_READ_WHITE_LIST_SIZE_RP_SIZE;
1365 if (hci_send_req(dd, &rq, to) < 0)
1379 int hci_le_clear_white_list(int dd, int to)
1381 struct hci_request rq;
1384 memset(&rq, 0, sizeof(rq));
1385 rq.ogf = OGF_LE_CTL;
1386 rq.ocf = OCF_LE_CLEAR_WHITE_LIST;
1387 rq.rparam = &status;
1390 if (hci_send_req(dd, &rq, to) < 0)
1401 int hci_read_local_name(int dd, int len, char *name, int to)
1403 read_local_name_rp rp;
1404 struct hci_request rq;
1406 memset(&rq, 0, sizeof(rq));
1407 rq.ogf = OGF_HOST_CTL;
1408 rq.ocf = OCF_READ_LOCAL_NAME;
1410 rq.rlen = READ_LOCAL_NAME_RP_SIZE;
1412 if (hci_send_req(dd, &rq, to) < 0)
1420 #ifdef __TIZEN_PATCH__
1421 strncpy(name, (char *) rp.name, len - 1);
1422 name[len - 1] = '\0';
1424 rp.name[247] = '\0';
1425 strncpy(name, (char *) rp.name, len);
1430 int hci_write_local_name(int dd, const char *name, int to)
1432 change_local_name_cp cp;
1433 struct hci_request rq;
1435 memset(&cp, 0, sizeof(cp));
1436 strncpy((char *) cp.name, name, sizeof(cp.name));
1438 memset(&rq, 0, sizeof(rq));
1439 rq.ogf = OGF_HOST_CTL;
1440 rq.ocf = OCF_CHANGE_LOCAL_NAME;
1442 rq.clen = CHANGE_LOCAL_NAME_CP_SIZE;
1444 if (hci_send_req(dd, &rq, to) < 0)
1450 int hci_read_remote_name_with_clock_offset(int dd, const bdaddr_t *bdaddr,
1451 uint8_t pscan_rep_mode,
1453 int len, char *name, int to)
1455 evt_remote_name_req_complete rn;
1456 remote_name_req_cp cp;
1457 struct hci_request rq;
1459 memset(&cp, 0, sizeof(cp));
1460 bacpy(&cp.bdaddr, bdaddr);
1461 cp.pscan_rep_mode = pscan_rep_mode;
1462 cp.clock_offset = clkoffset;
1464 memset(&rq, 0, sizeof(rq));
1465 rq.ogf = OGF_LINK_CTL;
1466 rq.ocf = OCF_REMOTE_NAME_REQ;
1468 rq.clen = REMOTE_NAME_REQ_CP_SIZE;
1469 rq.event = EVT_REMOTE_NAME_REQ_COMPLETE;
1471 rq.rlen = EVT_REMOTE_NAME_REQ_COMPLETE_SIZE;
1473 if (hci_send_req(dd, &rq, to) < 0)
1481 rn.name[247] = '\0';
1482 strncpy(name, (char *) rn.name, len);
1486 int hci_read_remote_name(int dd, const bdaddr_t *bdaddr, int len, char *name,
1489 return hci_read_remote_name_with_clock_offset(dd, bdaddr, 0x02, 0x0000,
1493 int hci_read_remote_name_cancel(int dd, const bdaddr_t *bdaddr, int to)
1495 remote_name_req_cancel_cp cp;
1496 struct hci_request rq;
1498 memset(&cp, 0, sizeof(cp));
1499 bacpy(&cp.bdaddr, bdaddr);
1501 memset(&rq, 0, sizeof(rq));
1502 rq.ogf = OGF_LINK_CTL;
1503 rq.ocf = OCF_REMOTE_NAME_REQ_CANCEL;
1505 rq.clen = REMOTE_NAME_REQ_CANCEL_CP_SIZE;
1507 if (hci_send_req(dd, &rq, to) < 0)
1513 int hci_read_remote_version(int dd, uint16_t handle, struct hci_version *ver,
1516 evt_read_remote_version_complete rp;
1517 read_remote_version_cp cp;
1518 struct hci_request rq;
1520 memset(&cp, 0, sizeof(cp));
1523 memset(&rq, 0, sizeof(rq));
1524 rq.ogf = OGF_LINK_CTL;
1525 rq.ocf = OCF_READ_REMOTE_VERSION;
1526 rq.event = EVT_READ_REMOTE_VERSION_COMPLETE;
1528 rq.clen = READ_REMOTE_VERSION_CP_SIZE;
1530 rq.rlen = EVT_READ_REMOTE_VERSION_COMPLETE_SIZE;
1532 if (hci_send_req(dd, &rq, to) < 0)
1540 ver->manufacturer = btohs(rp.manufacturer);
1541 ver->lmp_ver = rp.lmp_ver;
1542 ver->lmp_subver = btohs(rp.lmp_subver);
1546 int hci_read_remote_features(int dd, uint16_t handle, uint8_t *features, int to)
1548 evt_read_remote_features_complete rp;
1549 read_remote_features_cp cp;
1550 struct hci_request rq;
1552 memset(&cp, 0, sizeof(cp));
1555 memset(&rq, 0, sizeof(rq));
1556 rq.ogf = OGF_LINK_CTL;
1557 rq.ocf = OCF_READ_REMOTE_FEATURES;
1558 rq.event = EVT_READ_REMOTE_FEATURES_COMPLETE;
1560 rq.clen = READ_REMOTE_FEATURES_CP_SIZE;
1562 rq.rlen = EVT_READ_REMOTE_FEATURES_COMPLETE_SIZE;
1564 if (hci_send_req(dd, &rq, to) < 0)
1573 memcpy(features, rp.features, 8);
1578 int hci_read_remote_ext_features(int dd, uint16_t handle, uint8_t page,
1579 uint8_t *max_page, uint8_t *features,
1582 evt_read_remote_ext_features_complete rp;
1583 read_remote_ext_features_cp cp;
1584 struct hci_request rq;
1586 memset(&cp, 0, sizeof(cp));
1590 memset(&rq, 0, sizeof(rq));
1591 rq.ogf = OGF_LINK_CTL;
1592 rq.ocf = OCF_READ_REMOTE_EXT_FEATURES;
1593 rq.event = EVT_READ_REMOTE_EXT_FEATURES_COMPLETE;
1595 rq.clen = READ_REMOTE_EXT_FEATURES_CP_SIZE;
1597 rq.rlen = EVT_READ_REMOTE_EXT_FEATURES_COMPLETE_SIZE;
1599 if (hci_send_req(dd, &rq, to) < 0)
1608 *max_page = rp.max_page_num;
1611 memcpy(features, rp.features, 8);
1616 int hci_read_clock_offset(int dd, uint16_t handle, uint16_t *clkoffset, int to)
1618 evt_read_clock_offset_complete rp;
1619 read_clock_offset_cp cp;
1620 struct hci_request rq;
1622 memset(&cp, 0, sizeof(cp));
1625 memset(&rq, 0, sizeof(rq));
1626 rq.ogf = OGF_LINK_CTL;
1627 rq.ocf = OCF_READ_CLOCK_OFFSET;
1628 rq.event = EVT_READ_CLOCK_OFFSET_COMPLETE;
1630 rq.clen = READ_CLOCK_OFFSET_CP_SIZE;
1632 rq.rlen = EVT_READ_CLOCK_OFFSET_COMPLETE_SIZE;
1634 if (hci_send_req(dd, &rq, to) < 0)
1642 *clkoffset = rp.clock_offset;
1646 int hci_read_local_version(int dd, struct hci_version *ver, int to)
1648 read_local_version_rp rp;
1649 struct hci_request rq;
1651 memset(&rq, 0, sizeof(rq));
1652 rq.ogf = OGF_INFO_PARAM;
1653 rq.ocf = OCF_READ_LOCAL_VERSION;
1655 rq.rlen = READ_LOCAL_VERSION_RP_SIZE;
1657 if (hci_send_req(dd, &rq, to) < 0)
1665 ver->manufacturer = btohs(rp.manufacturer);
1666 ver->hci_ver = rp.hci_ver;
1667 ver->hci_rev = btohs(rp.hci_rev);
1668 ver->lmp_ver = rp.lmp_ver;
1669 ver->lmp_subver = btohs(rp.lmp_subver);
1673 int hci_read_local_commands(int dd, uint8_t *commands, int to)
1675 read_local_commands_rp rp;
1676 struct hci_request rq;
1678 memset(&rq, 0, sizeof(rq));
1679 rq.ogf = OGF_INFO_PARAM;
1680 rq.ocf = OCF_READ_LOCAL_COMMANDS;
1682 rq.rlen = READ_LOCAL_COMMANDS_RP_SIZE;
1684 if (hci_send_req(dd, &rq, to) < 0)
1693 memcpy(commands, rp.commands, 64);
1698 int hci_read_local_features(int dd, uint8_t *features, int to)
1700 read_local_features_rp rp;
1701 struct hci_request rq;
1703 memset(&rq, 0, sizeof(rq));
1704 rq.ogf = OGF_INFO_PARAM;
1705 rq.ocf = OCF_READ_LOCAL_FEATURES;
1707 rq.rlen = READ_LOCAL_FEATURES_RP_SIZE;
1709 if (hci_send_req(dd, &rq, to) < 0)
1718 memcpy(features, rp.features, 8);
1723 int hci_read_local_ext_features(int dd, uint8_t page, uint8_t *max_page,
1724 uint8_t *features, int to)
1726 read_local_ext_features_cp cp;
1727 read_local_ext_features_rp rp;
1728 struct hci_request rq;
1732 memset(&rq, 0, sizeof(rq));
1733 rq.ogf = OGF_INFO_PARAM;
1734 rq.ocf = OCF_READ_LOCAL_EXT_FEATURES;
1736 rq.clen = READ_LOCAL_EXT_FEATURES_CP_SIZE;
1738 rq.rlen = READ_LOCAL_EXT_FEATURES_RP_SIZE;
1740 if (hci_send_req(dd, &rq, to) < 0)
1749 *max_page = rp.max_page_num;
1752 memcpy(features, rp.features, 8);
1757 int hci_read_bd_addr(int dd, bdaddr_t *bdaddr, int to)
1760 struct hci_request rq;
1762 memset(&rq, 0, sizeof(rq));
1763 rq.ogf = OGF_INFO_PARAM;
1764 rq.ocf = OCF_READ_BD_ADDR;
1766 rq.rlen = READ_BD_ADDR_RP_SIZE;
1768 if (hci_send_req(dd, &rq, to) < 0)
1777 bacpy(bdaddr, &rp.bdaddr);
1782 int hci_read_class_of_dev(int dd, uint8_t *cls, int to)
1784 read_class_of_dev_rp rp;
1785 struct hci_request rq;
1787 memset(&rq, 0, sizeof(rq));
1788 rq.ogf = OGF_HOST_CTL;
1789 rq.ocf = OCF_READ_CLASS_OF_DEV;
1791 rq.rlen = READ_CLASS_OF_DEV_RP_SIZE;
1793 if (hci_send_req(dd, &rq, to) < 0)
1801 memcpy(cls, rp.dev_class, 3);
1805 int hci_write_class_of_dev(int dd, uint32_t cls, int to)
1807 write_class_of_dev_cp cp;
1808 struct hci_request rq;
1810 memset(&rq, 0, sizeof(rq));
1811 cp.dev_class[0] = cls & 0xff;
1812 cp.dev_class[1] = (cls >> 8) & 0xff;
1813 cp.dev_class[2] = (cls >> 16) & 0xff;
1814 rq.ogf = OGF_HOST_CTL;
1815 rq.ocf = OCF_WRITE_CLASS_OF_DEV;
1817 rq.clen = WRITE_CLASS_OF_DEV_CP_SIZE;
1818 return hci_send_req(dd, &rq, to);
1821 int hci_read_voice_setting(int dd, uint16_t *vs, int to)
1823 read_voice_setting_rp rp;
1824 struct hci_request rq;
1826 memset(&rq, 0, sizeof(rq));
1827 rq.ogf = OGF_HOST_CTL;
1828 rq.ocf = OCF_READ_VOICE_SETTING;
1830 rq.rlen = READ_VOICE_SETTING_RP_SIZE;
1832 if (hci_send_req(dd, &rq, to) < 0)
1840 *vs = rp.voice_setting;
1844 int hci_write_voice_setting(int dd, uint16_t vs, int to)
1846 write_voice_setting_cp cp;
1847 struct hci_request rq;
1849 memset(&rq, 0, sizeof(rq));
1850 cp.voice_setting = vs;
1851 rq.ogf = OGF_HOST_CTL;
1852 rq.ocf = OCF_WRITE_VOICE_SETTING;
1854 rq.clen = WRITE_VOICE_SETTING_CP_SIZE;
1856 return hci_send_req(dd, &rq, to);
1859 int hci_read_current_iac_lap(int dd, uint8_t *num_iac, uint8_t *lap, int to)
1861 read_current_iac_lap_rp rp;
1862 struct hci_request rq;
1864 memset(&rq, 0, sizeof(rq));
1865 rq.ogf = OGF_HOST_CTL;
1866 rq.ocf = OCF_READ_CURRENT_IAC_LAP;
1868 rq.rlen = READ_CURRENT_IAC_LAP_RP_SIZE;
1870 if (hci_send_req(dd, &rq, to) < 0)
1878 *num_iac = rp.num_current_iac;
1879 memcpy(lap, rp.lap, rp.num_current_iac * 3);
1883 int hci_write_current_iac_lap(int dd, uint8_t num_iac, uint8_t *lap, int to)
1885 write_current_iac_lap_cp cp;
1886 struct hci_request rq;
1888 memset(&cp, 0, sizeof(cp));
1889 cp.num_current_iac = num_iac;
1890 memcpy(&cp.lap, lap, num_iac * 3);
1892 memset(&rq, 0, sizeof(rq));
1893 rq.ogf = OGF_HOST_CTL;
1894 rq.ocf = OCF_WRITE_CURRENT_IAC_LAP;
1896 rq.clen = num_iac * 3 + 1;
1898 return hci_send_req(dd, &rq, to);
1901 int hci_read_stored_link_key(int dd, bdaddr_t *bdaddr, uint8_t all, int to)
1903 read_stored_link_key_cp cp;
1904 struct hci_request rq;
1906 memset(&cp, 0, sizeof(cp));
1907 bacpy(&cp.bdaddr, bdaddr);
1910 memset(&rq, 0, sizeof(rq));
1911 rq.ogf = OGF_HOST_CTL;
1912 rq.ocf = OCF_READ_STORED_LINK_KEY;
1914 rq.clen = READ_STORED_LINK_KEY_CP_SIZE;
1916 return hci_send_req(dd, &rq, to);
1919 int hci_write_stored_link_key(int dd, bdaddr_t *bdaddr, uint8_t *key, int to)
1921 unsigned char cp[WRITE_STORED_LINK_KEY_CP_SIZE + 6 + 16];
1922 struct hci_request rq;
1924 memset(&cp, 0, sizeof(cp));
1926 bacpy((bdaddr_t *) (cp + 1), bdaddr);
1927 memcpy(cp + 7, key, 16);
1929 memset(&rq, 0, sizeof(rq));
1930 rq.ogf = OGF_HOST_CTL;
1931 rq.ocf = OCF_WRITE_STORED_LINK_KEY;
1933 rq.clen = WRITE_STORED_LINK_KEY_CP_SIZE + 6 + 16;
1935 return hci_send_req(dd, &rq, to);
1938 int hci_delete_stored_link_key(int dd, bdaddr_t *bdaddr, uint8_t all, int to)
1940 delete_stored_link_key_cp cp;
1941 struct hci_request rq;
1943 memset(&cp, 0, sizeof(cp));
1944 bacpy(&cp.bdaddr, bdaddr);
1945 cp.delete_all = all;
1947 memset(&rq, 0, sizeof(rq));
1948 rq.ogf = OGF_HOST_CTL;
1949 rq.ocf = OCF_DELETE_STORED_LINK_KEY;
1951 rq.clen = DELETE_STORED_LINK_KEY_CP_SIZE;
1953 return hci_send_req(dd, &rq, to);
1956 int hci_authenticate_link(int dd, uint16_t handle, int to)
1958 auth_requested_cp cp;
1959 evt_auth_complete rp;
1960 struct hci_request rq;
1964 rq.ogf = OGF_LINK_CTL;
1965 rq.ocf = OCF_AUTH_REQUESTED;
1966 rq.event = EVT_AUTH_COMPLETE;
1968 rq.clen = AUTH_REQUESTED_CP_SIZE;
1970 rq.rlen = EVT_AUTH_COMPLETE_SIZE;
1972 if (hci_send_req(dd, &rq, to) < 0)
1983 int hci_encrypt_link(int dd, uint16_t handle, uint8_t encrypt, int to)
1985 set_conn_encrypt_cp cp;
1986 evt_encrypt_change rp;
1987 struct hci_request rq;
1990 cp.encrypt = encrypt;
1992 rq.ogf = OGF_LINK_CTL;
1993 rq.ocf = OCF_SET_CONN_ENCRYPT;
1994 rq.event = EVT_ENCRYPT_CHANGE;
1996 rq.clen = SET_CONN_ENCRYPT_CP_SIZE;
1998 rq.rlen = EVT_ENCRYPT_CHANGE_SIZE;
2000 if (hci_send_req(dd, &rq, to) < 0)
2011 int hci_change_link_key(int dd, uint16_t handle, int to)
2013 change_conn_link_key_cp cp;
2014 evt_change_conn_link_key_complete rp;
2015 struct hci_request rq;
2019 rq.ogf = OGF_LINK_CTL;
2020 rq.ocf = OCF_CHANGE_CONN_LINK_KEY;
2021 rq.event = EVT_CHANGE_CONN_LINK_KEY_COMPLETE;
2023 rq.clen = CHANGE_CONN_LINK_KEY_CP_SIZE;
2025 rq.rlen = EVT_CHANGE_CONN_LINK_KEY_COMPLETE_SIZE;
2027 if (hci_send_req(dd, &rq, to) < 0)
2038 int hci_switch_role(int dd, bdaddr_t *bdaddr, uint8_t role, int to)
2042 struct hci_request rq;
2044 bacpy(&cp.bdaddr, bdaddr);
2046 rq.ogf = OGF_LINK_POLICY;
2047 rq.ocf = OCF_SWITCH_ROLE;
2049 rq.clen = SWITCH_ROLE_CP_SIZE;
2051 rq.rlen = EVT_ROLE_CHANGE_SIZE;
2052 rq.event = EVT_ROLE_CHANGE;
2054 if (hci_send_req(dd, &rq, to) < 0)
2065 int hci_park_mode(int dd, uint16_t handle, uint16_t max_interval,
2066 uint16_t min_interval, int to)
2070 struct hci_request rq;
2072 memset(&cp, 0, sizeof (cp));
2074 cp.max_interval = max_interval;
2075 cp.min_interval = min_interval;
2077 memset(&rq, 0, sizeof (rq));
2078 rq.ogf = OGF_LINK_POLICY;
2079 rq.ocf = OCF_PARK_MODE;
2080 rq.event = EVT_MODE_CHANGE;
2082 rq.clen = PARK_MODE_CP_SIZE;
2084 rq.rlen = EVT_MODE_CHANGE_SIZE;
2086 if (hci_send_req(dd, &rq, to) < 0)
2097 int hci_exit_park_mode(int dd, uint16_t handle, int to)
2099 exit_park_mode_cp cp;
2101 struct hci_request rq;
2103 memset(&cp, 0, sizeof (cp));
2106 memset (&rq, 0, sizeof (rq));
2107 rq.ogf = OGF_LINK_POLICY;
2108 rq.ocf = OCF_EXIT_PARK_MODE;
2109 rq.event = EVT_MODE_CHANGE;
2111 rq.clen = EXIT_PARK_MODE_CP_SIZE;
2113 rq.rlen = EVT_MODE_CHANGE_SIZE;
2115 if (hci_send_req(dd, &rq, to) < 0)
2126 int hci_read_inquiry_scan_type(int dd, uint8_t *type, int to)
2128 read_inquiry_scan_type_rp rp;
2129 struct hci_request rq;
2131 memset(&rq, 0, sizeof(rq));
2132 rq.ogf = OGF_HOST_CTL;
2133 rq.ocf = OCF_READ_INQUIRY_SCAN_TYPE;
2135 rq.rlen = READ_INQUIRY_SCAN_TYPE_RP_SIZE;
2137 if (hci_send_req(dd, &rq, to) < 0)
2149 int hci_write_inquiry_scan_type(int dd, uint8_t type, int to)
2151 write_inquiry_scan_type_cp cp;
2152 write_inquiry_scan_type_rp rp;
2153 struct hci_request rq;
2155 memset(&cp, 0, sizeof(cp));
2158 memset(&rq, 0, sizeof(rq));
2159 rq.ogf = OGF_HOST_CTL;
2160 rq.ocf = OCF_WRITE_INQUIRY_SCAN_TYPE;
2162 rq.clen = WRITE_INQUIRY_SCAN_TYPE_CP_SIZE;
2164 rq.rlen = WRITE_INQUIRY_SCAN_TYPE_RP_SIZE;
2166 if (hci_send_req(dd, &rq, to) < 0)
2177 int hci_read_inquiry_mode(int dd, uint8_t *mode, int to)
2179 read_inquiry_mode_rp rp;
2180 struct hci_request rq;
2182 memset(&rq, 0, sizeof(rq));
2183 rq.ogf = OGF_HOST_CTL;
2184 rq.ocf = OCF_READ_INQUIRY_MODE;
2186 rq.rlen = READ_INQUIRY_MODE_RP_SIZE;
2188 if (hci_send_req(dd, &rq, to) < 0)
2200 int hci_write_inquiry_mode(int dd, uint8_t mode, int to)
2202 write_inquiry_mode_cp cp;
2203 write_inquiry_mode_rp rp;
2204 struct hci_request rq;
2206 memset(&cp, 0, sizeof(cp));
2209 memset(&rq, 0, sizeof(rq));
2210 rq.ogf = OGF_HOST_CTL;
2211 rq.ocf = OCF_WRITE_INQUIRY_MODE;
2213 rq.clen = WRITE_INQUIRY_MODE_CP_SIZE;
2215 rq.rlen = WRITE_INQUIRY_MODE_RP_SIZE;
2217 if (hci_send_req(dd, &rq, to) < 0)
2228 int hci_read_afh_mode(int dd, uint8_t *mode, int to)
2230 read_afh_mode_rp rp;
2231 struct hci_request rq;
2233 memset(&rq, 0, sizeof(rq));
2234 rq.ogf = OGF_HOST_CTL;
2235 rq.ocf = OCF_READ_AFH_MODE;
2237 rq.rlen = READ_AFH_MODE_RP_SIZE;
2239 if (hci_send_req(dd, &rq, to) < 0)
2251 int hci_write_afh_mode(int dd, uint8_t mode, int to)
2253 write_afh_mode_cp cp;
2254 write_afh_mode_rp rp;
2255 struct hci_request rq;
2257 memset(&cp, 0, sizeof(cp));
2260 memset(&rq, 0, sizeof(rq));
2261 rq.ogf = OGF_HOST_CTL;
2262 rq.ocf = OCF_WRITE_AFH_MODE;
2264 rq.clen = WRITE_AFH_MODE_CP_SIZE;
2266 rq.rlen = WRITE_AFH_MODE_RP_SIZE;
2268 if (hci_send_req(dd, &rq, to) < 0)
2279 int hci_read_ext_inquiry_response(int dd, uint8_t *fec, uint8_t *data, int to)
2281 read_ext_inquiry_response_rp rp;
2282 struct hci_request rq;
2284 memset(&rq, 0, sizeof(rq));
2285 rq.ogf = OGF_HOST_CTL;
2286 rq.ocf = OCF_READ_EXT_INQUIRY_RESPONSE;
2288 rq.rlen = READ_EXT_INQUIRY_RESPONSE_RP_SIZE;
2290 if (hci_send_req(dd, &rq, to) < 0)
2299 memcpy(data, rp.data, HCI_MAX_EIR_LENGTH);
2304 int hci_write_ext_inquiry_response(int dd, uint8_t fec, uint8_t *data, int to)
2306 write_ext_inquiry_response_cp cp;
2307 write_ext_inquiry_response_rp rp;
2308 struct hci_request rq;
2310 memset(&cp, 0, sizeof(cp));
2312 memcpy(cp.data, data, HCI_MAX_EIR_LENGTH);
2314 memset(&rq, 0, sizeof(rq));
2315 rq.ogf = OGF_HOST_CTL;
2316 rq.ocf = OCF_WRITE_EXT_INQUIRY_RESPONSE;
2318 rq.clen = WRITE_EXT_INQUIRY_RESPONSE_CP_SIZE;
2320 rq.rlen = WRITE_EXT_INQUIRY_RESPONSE_RP_SIZE;
2322 if (hci_send_req(dd, &rq, to) < 0)
2333 int hci_read_simple_pairing_mode(int dd, uint8_t *mode, int to)
2335 read_simple_pairing_mode_rp rp;
2336 struct hci_request rq;
2338 memset(&rq, 0, sizeof(rq));
2339 rq.ogf = OGF_HOST_CTL;
2340 rq.ocf = OCF_READ_SIMPLE_PAIRING_MODE;
2342 rq.rlen = READ_SIMPLE_PAIRING_MODE_RP_SIZE;
2344 if (hci_send_req(dd, &rq, to) < 0)
2356 int hci_write_simple_pairing_mode(int dd, uint8_t mode, int to)
2358 write_simple_pairing_mode_cp cp;
2359 write_simple_pairing_mode_rp rp;
2360 struct hci_request rq;
2362 memset(&cp, 0, sizeof(cp));
2365 memset(&rq, 0, sizeof(rq));
2366 rq.ogf = OGF_HOST_CTL;
2367 rq.ocf = OCF_WRITE_SIMPLE_PAIRING_MODE;
2369 rq.clen = WRITE_SIMPLE_PAIRING_MODE_CP_SIZE;
2371 rq.rlen = WRITE_SIMPLE_PAIRING_MODE_RP_SIZE;
2373 if (hci_send_req(dd, &rq, to) < 0)
2384 int hci_read_local_oob_data(int dd, uint8_t *hash, uint8_t *randomizer, int to)
2386 read_local_oob_data_rp rp;
2387 struct hci_request rq;
2389 memset(&rq, 0, sizeof(rq));
2390 rq.ogf = OGF_HOST_CTL;
2391 rq.ocf = OCF_READ_LOCAL_OOB_DATA;
2393 rq.rlen = READ_LOCAL_OOB_DATA_RP_SIZE;
2395 if (hci_send_req(dd, &rq, to) < 0)
2403 memcpy(hash, rp.hash, 16);
2404 memcpy(randomizer, rp.randomizer, 16);
2408 int hci_read_inq_response_tx_power_level(int dd, int8_t *level, int to)
2410 read_inq_response_tx_power_level_rp rp;
2411 struct hci_request rq;
2413 memset(&rq, 0, sizeof(rq));
2414 rq.ogf = OGF_HOST_CTL;
2415 rq.ocf = OCF_READ_INQ_RESPONSE_TX_POWER_LEVEL;
2417 rq.rlen = READ_INQ_RESPONSE_TX_POWER_LEVEL_RP_SIZE;
2419 if (hci_send_req(dd, &rq, to) < 0)
2431 int hci_read_inquiry_transmit_power_level(int dd, int8_t *level, int to)
2433 return hci_read_inq_response_tx_power_level(dd, level, to);
2436 int hci_write_inquiry_transmit_power_level(int dd, int8_t level, int to)
2438 write_inquiry_transmit_power_level_cp cp;
2439 write_inquiry_transmit_power_level_rp rp;
2440 struct hci_request rq;
2442 memset(&cp, 0, sizeof(cp));
2445 memset(&rq, 0, sizeof(rq));
2446 rq.ogf = OGF_HOST_CTL;
2447 rq.ocf = OCF_WRITE_INQUIRY_TRANSMIT_POWER_LEVEL;
2449 rq.clen = WRITE_INQUIRY_TRANSMIT_POWER_LEVEL_CP_SIZE;
2451 rq.rlen = WRITE_INQUIRY_TRANSMIT_POWER_LEVEL_RP_SIZE;
2453 if (hci_send_req(dd, &rq, to) < 0)
2464 int hci_read_transmit_power_level(int dd, uint16_t handle, uint8_t type,
2465 int8_t *level, int to)
2467 read_transmit_power_level_cp cp;
2468 read_transmit_power_level_rp rp;
2469 struct hci_request rq;
2471 memset(&cp, 0, sizeof(cp));
2475 memset(&rq, 0, sizeof(rq));
2476 rq.ogf = OGF_HOST_CTL;
2477 rq.ocf = OCF_READ_TRANSMIT_POWER_LEVEL;
2479 rq.clen = READ_TRANSMIT_POWER_LEVEL_CP_SIZE;
2481 rq.rlen = READ_TRANSMIT_POWER_LEVEL_RP_SIZE;
2483 if (hci_send_req(dd, &rq, to) < 0)
2495 int hci_read_link_policy(int dd, uint16_t handle, uint16_t *policy, int to)
2497 read_link_policy_rp rp;
2498 struct hci_request rq;
2500 memset(&rq, 0, sizeof(rq));
2501 rq.ogf = OGF_LINK_POLICY;
2502 rq.ocf = OCF_READ_LINK_POLICY;
2503 rq.cparam = &handle;
2506 rq.rlen = READ_LINK_POLICY_RP_SIZE;
2508 if (hci_send_req(dd, &rq, to) < 0)
2516 *policy = rp.policy;
2520 int hci_write_link_policy(int dd, uint16_t handle, uint16_t policy, int to)
2522 write_link_policy_cp cp;
2523 write_link_policy_rp rp;
2524 struct hci_request rq;
2526 memset(&cp, 0, sizeof(cp));
2530 memset(&rq, 0, sizeof(rq));
2531 rq.ogf = OGF_LINK_POLICY;
2532 rq.ocf = OCF_WRITE_LINK_POLICY;
2534 rq.clen = WRITE_LINK_POLICY_CP_SIZE;
2536 rq.rlen = WRITE_LINK_POLICY_RP_SIZE;
2538 if (hci_send_req(dd, &rq, to) < 0)
2549 int hci_read_link_supervision_timeout(int dd, uint16_t handle,
2550 uint16_t *timeout, int to)
2552 read_link_supervision_timeout_rp rp;
2553 struct hci_request rq;
2555 memset(&rq, 0, sizeof(rq));
2556 rq.ogf = OGF_HOST_CTL;
2557 rq.ocf = OCF_READ_LINK_SUPERVISION_TIMEOUT;
2558 rq.cparam = &handle;
2561 rq.rlen = READ_LINK_SUPERVISION_TIMEOUT_RP_SIZE;
2563 if (hci_send_req(dd, &rq, to) < 0)
2571 *timeout = rp.timeout;
2575 int hci_write_link_supervision_timeout(int dd, uint16_t handle,
2576 uint16_t timeout, int to)
2578 write_link_supervision_timeout_cp cp;
2579 write_link_supervision_timeout_rp rp;
2580 struct hci_request rq;
2582 memset(&cp, 0, sizeof(cp));
2584 cp.timeout = timeout;
2586 memset(&rq, 0, sizeof(rq));
2587 rq.ogf = OGF_HOST_CTL;
2588 rq.ocf = OCF_WRITE_LINK_SUPERVISION_TIMEOUT;
2590 rq.clen = WRITE_LINK_SUPERVISION_TIMEOUT_CP_SIZE;
2592 rq.rlen = WRITE_LINK_SUPERVISION_TIMEOUT_RP_SIZE;
2594 if (hci_send_req(dd, &rq, to) < 0)
2605 int hci_set_afh_classification(int dd, uint8_t *map, int to)
2607 set_afh_classification_cp cp;
2608 set_afh_classification_rp rp;
2609 struct hci_request rq;
2611 memset(&cp, 0, sizeof(cp));
2612 memcpy(cp.map, map, 10);
2614 memset(&rq, 0, sizeof(rq));
2615 rq.ogf = OGF_HOST_CTL;
2616 rq.ocf = OCF_SET_AFH_CLASSIFICATION;
2618 rq.clen = SET_AFH_CLASSIFICATION_CP_SIZE;
2620 rq.rlen = SET_AFH_CLASSIFICATION_RP_SIZE;
2622 if (hci_send_req(dd, &rq, to) < 0)
2633 int hci_read_link_quality(int dd, uint16_t handle, uint8_t *link_quality,
2636 read_link_quality_rp rp;
2637 struct hci_request rq;
2639 memset(&rq, 0, sizeof(rq));
2640 rq.ogf = OGF_STATUS_PARAM;
2641 rq.ocf = OCF_READ_LINK_QUALITY;
2642 rq.cparam = &handle;
2645 rq.rlen = READ_LINK_QUALITY_RP_SIZE;
2647 if (hci_send_req(dd, &rq, to) < 0)
2655 *link_quality = rp.link_quality;
2659 int hci_read_rssi(int dd, uint16_t handle, int8_t *rssi, int to)
2662 struct hci_request rq;
2664 memset(&rq, 0, sizeof(rq));
2665 rq.ogf = OGF_STATUS_PARAM;
2666 rq.ocf = OCF_READ_RSSI;
2667 rq.cparam = &handle;
2670 rq.rlen = READ_RSSI_RP_SIZE;
2672 if (hci_send_req(dd, &rq, to) < 0)
2684 int hci_read_afh_map(int dd, uint16_t handle, uint8_t *mode, uint8_t *map,
2688 struct hci_request rq;
2690 memset(&rq, 0, sizeof(rq));
2691 rq.ogf = OGF_STATUS_PARAM;
2692 rq.ocf = OCF_READ_AFH_MAP;
2693 rq.cparam = &handle;
2696 rq.rlen = READ_AFH_MAP_RP_SIZE;
2698 if (hci_send_req(dd, &rq, to) < 0)
2707 memcpy(map, rp.map, 10);
2711 int hci_read_clock(int dd, uint16_t handle, uint8_t which, uint32_t *clock,
2712 uint16_t *accuracy, int to)
2716 struct hci_request rq;
2718 memset(&cp, 0, sizeof(cp));
2720 cp.which_clock = which;
2722 memset(&rq, 0, sizeof(rq));
2723 rq.ogf = OGF_STATUS_PARAM;
2724 rq.ocf = OCF_READ_CLOCK;
2726 rq.clen = READ_CLOCK_CP_SIZE;
2728 rq.rlen = READ_CLOCK_RP_SIZE;
2730 if (hci_send_req(dd, &rq, to) < 0)
2739 *accuracy = rp.accuracy;
2743 int hci_le_set_scan_enable(int dd, uint8_t enable, uint8_t filter_dup, int to)
2745 struct hci_request rq;
2746 le_set_scan_enable_cp scan_cp;
2749 memset(&scan_cp, 0, sizeof(scan_cp));
2750 scan_cp.enable = enable;
2751 scan_cp.filter_dup = filter_dup;
2753 memset(&rq, 0, sizeof(rq));
2754 rq.ogf = OGF_LE_CTL;
2755 rq.ocf = OCF_LE_SET_SCAN_ENABLE;
2756 rq.cparam = &scan_cp;
2757 rq.clen = LE_SET_SCAN_ENABLE_CP_SIZE;
2758 rq.rparam = &status;
2761 if (hci_send_req(dd, &rq, to) < 0)
2772 int hci_le_set_scan_parameters(int dd, uint8_t type,
2773 uint16_t interval, uint16_t window,
2774 uint8_t own_type, uint8_t filter, int to)
2776 struct hci_request rq;
2777 le_set_scan_parameters_cp param_cp;
2780 memset(¶m_cp, 0, sizeof(param_cp));
2781 param_cp.type = type;
2782 param_cp.interval = interval;
2783 param_cp.window = window;
2784 param_cp.own_bdaddr_type = own_type;
2785 param_cp.filter = filter;
2787 memset(&rq, 0, sizeof(rq));
2788 rq.ogf = OGF_LE_CTL;
2789 rq.ocf = OCF_LE_SET_SCAN_PARAMETERS;
2790 rq.cparam = ¶m_cp;
2791 rq.clen = LE_SET_SCAN_PARAMETERS_CP_SIZE;
2792 rq.rparam = &status;
2795 if (hci_send_req(dd, &rq, to) < 0)
2806 int hci_le_set_advertise_enable(int dd, uint8_t enable, int to)
2808 struct hci_request rq;
2809 le_set_advertise_enable_cp adv_cp;
2812 memset(&adv_cp, 0, sizeof(adv_cp));
2813 adv_cp.enable = enable;
2815 memset(&rq, 0, sizeof(rq));
2816 rq.ogf = OGF_LE_CTL;
2817 rq.ocf = OCF_LE_SET_ADVERTISE_ENABLE;
2818 rq.cparam = &adv_cp;
2819 rq.clen = LE_SET_ADVERTISE_ENABLE_CP_SIZE;
2820 rq.rparam = &status;
2823 if (hci_send_req(dd, &rq, to) < 0)
2834 int hci_le_create_conn(int dd, uint16_t interval, uint16_t window,
2835 uint8_t initiator_filter, uint8_t peer_bdaddr_type,
2836 bdaddr_t peer_bdaddr, uint8_t own_bdaddr_type,
2837 uint16_t min_interval, uint16_t max_interval,
2838 uint16_t latency, uint16_t supervision_timeout,
2839 uint16_t min_ce_length, uint16_t max_ce_length,
2840 uint16_t *handle, int to)
2842 struct hci_request rq;
2843 le_create_connection_cp create_conn_cp;
2844 evt_le_connection_complete conn_complete_rp;
2846 memset(&create_conn_cp, 0, sizeof(create_conn_cp));
2847 create_conn_cp.interval = interval;
2848 create_conn_cp.window = window;
2849 create_conn_cp.initiator_filter = initiator_filter;
2850 create_conn_cp.peer_bdaddr_type = peer_bdaddr_type;
2851 create_conn_cp.peer_bdaddr = peer_bdaddr;
2852 create_conn_cp.own_bdaddr_type = own_bdaddr_type;
2853 create_conn_cp.min_interval = min_interval;
2854 create_conn_cp.max_interval = max_interval;
2855 create_conn_cp.latency = latency;
2856 create_conn_cp.supervision_timeout = supervision_timeout;
2857 create_conn_cp.min_ce_length = min_ce_length;
2858 create_conn_cp.max_ce_length = max_ce_length;
2860 memset(&rq, 0, sizeof(rq));
2861 rq.ogf = OGF_LE_CTL;
2862 rq.ocf = OCF_LE_CREATE_CONN;
2863 rq.event = EVT_LE_CONN_COMPLETE;
2864 rq.cparam = &create_conn_cp;
2865 rq.clen = LE_CREATE_CONN_CP_SIZE;
2866 rq.rparam = &conn_complete_rp;
2867 rq.rlen = EVT_CONN_COMPLETE_SIZE;
2869 if (hci_send_req(dd, &rq, to) < 0)
2872 if (conn_complete_rp.status) {
2878 *handle = conn_complete_rp.handle;
2883 int hci_le_conn_update(int dd, uint16_t handle, uint16_t min_interval,
2884 uint16_t max_interval, uint16_t latency,
2885 uint16_t supervision_timeout, int to)
2887 evt_le_connection_update_complete evt;
2888 le_connection_update_cp cp;
2889 struct hci_request rq;
2891 memset(&cp, 0, sizeof(cp));
2893 cp.min_interval = min_interval;
2894 cp.max_interval = max_interval;
2895 cp.latency = latency;
2896 cp.supervision_timeout = supervision_timeout;
2897 cp.min_ce_length = htobs(0x0001);
2898 cp.max_ce_length = htobs(0x0001);
2900 memset(&rq, 0, sizeof(rq));
2901 rq.ogf = OGF_LE_CTL;
2902 rq.ocf = OCF_LE_CONN_UPDATE;
2904 rq.clen = LE_CONN_UPDATE_CP_SIZE;
2905 rq.event = EVT_LE_CONN_UPDATE_COMPLETE;
2907 rq.rlen = sizeof(evt);
2909 if (hci_send_req(dd, &rq, to) < 0)