lib/hci.c

   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@qualcomm.com>
   7  *  Copyright (C) 2002-2010  Marcel Holtmann <marcel@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;
 132                                 set = 1;
 133                                 break;
 134                         }
 135                 }
 136         }
 137         free(str);
 138
 139         return set;
 140 }
 141
 142 char *hci_bustostr(int bus)
 143 {
 144         switch (bus) {
 145         case HCI_VIRTUAL:
 146                 return "VIRTUAL";
 147         case HCI_USB:
 148                 return "USB";
 149         case HCI_PCCARD:
 150                 return "PCCARD";
 151         case HCI_UART:
 152                 return "UART";
 153         case HCI_RS232:
 154                 return "RS232";
 155         case HCI_PCI:
 156                 return "PCI";
 157         case HCI_SDIO:
 158                 return "SDIO";
 159         default:
 160                 return "UNKNOWN";
 161         }
 162 }
 163
 164 char *hci_dtypetostr(int type)
 165 {
 166         return hci_bustostr(type & 0x0f);
 167 }
 168
 169 char *hci_typetostr(int type)
 170 {
 171         switch (type) {
 172         case HCI_BREDR:
 173                 return "BR/EDR";
 174         case HCI_AMP:
 175                 return "AMP";
 176         default:
 177                 return "UNKNOWN";
 178         }
 179 }
 180
 181 /* HCI dev flags mapping */
 182 static hci_map dev_flags_map[] = {
 183         { "UP",      HCI_UP      },
 184         { "INIT",    HCI_INIT    },
 185         { "RUNNING", HCI_RUNNING },
 186         { "RAW",     HCI_RAW     },
 187         { "PSCAN",   HCI_PSCAN   },
 188         { "ISCAN",   HCI_ISCAN   },
 189         { "INQUIRY", HCI_INQUIRY },
 190         { "AUTH",    HCI_AUTH    },
 191         { "ENCRYPT", HCI_ENCRYPT },
 192         { NULL }
 193 };
 194
 195 char *hci_dflagstostr(uint32_t flags)
 196 {
 197         char *str = bt_malloc(50);
 198         char *ptr = str;
 199         hci_map *m = dev_flags_map;
 200
 201         if (!str)
 202                 return NULL;
 203
 204         *ptr = 0;
 205
 206         if (!hci_test_bit(HCI_UP, &flags))
 207                 ptr += sprintf(ptr, "DOWN ");
 208
 209         while (m->str) {
 210                 if (hci_test_bit(m->val, &flags))
 211                         ptr += sprintf(ptr, "%s ", m->str);
 212                 m++;
 213         }
 214         return str;
 215 }
 216
 217 /* HCI packet type mapping */
 218 static hci_map pkt_type_map[] = {
 219         { "DM1",   HCI_DM1  },
 220         { "DM3",   HCI_DM3  },
 221         { "DM5",   HCI_DM5  },
 222         { "DH1",   HCI_DH1  },
 223         { "DH3",   HCI_DH3  },
 224         { "DH5",   HCI_DH5  },
 225         { "HV1",   HCI_HV1  },
 226         { "HV2",   HCI_HV2  },
 227         { "HV3",   HCI_HV3  },
 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 },
 234         { NULL }
 235 };
 236
 237 static hci_map sco_ptype_map[] = {
 238         { "HV1",   0x0001   },
 239         { "HV2",   0x0002   },
 240         { "HV3",   0x0004   },
 241         { "EV3",   HCI_EV3  },
 242         { "EV4",   HCI_EV4  },
 243         { "EV5",   HCI_EV5  },
 244         { "2-EV3", HCI_2EV3 },
 245         { "2-EV5", HCI_2EV5 },
 246         { "3-EV3", HCI_3EV3 },
 247         { "3-EV5", HCI_3EV5 },
 248         { NULL }
 249 };
 250
 251 char *hci_ptypetostr(unsigned int ptype)
 252 {
 253         return hci_bit2str(pkt_type_map, ptype);
 254 }
 255
 256 int hci_strtoptype(char *str, unsigned int *val)
 257 {
 258         return hci_str2bit(pkt_type_map, str, val);
 259 }
 260
 261 char *hci_scoptypetostr(unsigned int ptype)
 262 {
 263         return hci_bit2str(sco_ptype_map, ptype);
 264 }
 265
 266 int hci_strtoscoptype(char *str, unsigned int *val)
 267 {
 268         return hci_str2bit(sco_ptype_map, str, val);
 269 }
 270
 271 /* Link policy mapping */
 272 static hci_map link_policy_map[] = {
 273         { "NONE",       0               },
 274         { "RSWITCH",    HCI_LP_RSWITCH  },
 275         { "HOLD",       HCI_LP_HOLD     },
 276         { "SNIFF",      HCI_LP_SNIFF    },
 277         { "PARK",       HCI_LP_PARK     },
 278         { NULL }
 279 };
 280
 281 char *hci_lptostr(unsigned int lp)
 282 {
 283         return hci_bit2str(link_policy_map, lp);
 284 }
 285
 286 int hci_strtolp(char *str, unsigned int *val)
 287 {
 288         return hci_str2bit(link_policy_map, str, val);
 289 }
 290
 291 /* Link mode mapping */
 292 static hci_map link_mode_map[] = {
 293         { "NONE",       0               },
 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   },
 301         { NULL }
 302 };
 303
 304 char *hci_lmtostr(unsigned int lm)
 305 {
 306         char *s, *str = bt_malloc(50);
 307         if (!str)
 308                 return NULL;
 309
 310         *str = 0;
 311         if (!(lm & HCI_LM_MASTER))
 312                 strcpy(str, "SLAVE ");
 313
 314         s = hci_bit2str(link_mode_map, lm);
 315         if (!s) {
 316                 bt_free(str);
 317                 return NULL;
 318         }
 319
 320         strcat(str, s);
 321         free(s);
 322         return str;
 323 }
 324
 325 int hci_strtolm(char *str, unsigned int *val)
 326 {
 327         return hci_str2bit(link_mode_map, str, val);
 328 }
 329
 330 /* Command mapping */
 331 static hci_map commands_map[] = {
 332         { "Inquiry",                                    0   },
 333         { "Inquiry Cancel",                             1   },
 334         { "Periodic Inquiry Mode",                      2   },
 335         { "Exit Periodic Inquiry Mode",                 3   },
 336         { "Create Connection",                          4   },
 337         { "Disconnect",                                 5   },
 338         { "Add SCO Connection",                         6   },
 339         { "Cancel Create Connection",                   7   },
 340
 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  },
 349
 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  },
 358
 359         { "Read Clock Offset",                          24  },
 360         { "Read LMP Handle",                            25  },
 361         { "Reserved",                                   26  },
 362         { "Reserved",                                   27  },
 363         { "Reserved",                                   28  },
 364         { "Reserved",                                   29  },
 365         { "Reserved",                                   30  },
 366         { "Reserved",                                   31  },
 367
 368         { "Reserved",                                   32  },
 369         { "Hold Mode",                                  33  },
 370         { "Sniff Mode",                                 34  },
 371         { "Exit Sniff Mode",                            35  },
 372         { "Park State",                                 36  },
 373         { "Exit Park State",                            37  },
 374         { "QoS Setup",                                  38  },
 375         { "Role Discovery",                             39  },
 376
 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  },
 384         { "Reset",                                      47  },
 385
 386         { "Set Event Filter",                           48  },
 387         { "Flush",                                      49  },
 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  },
 394
 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  },
 403
 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  },
 412
 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  },
 421
 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  },
 430
 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  },
 439
 440         { "Write Page Scan Mode",                       96  },
 441         { "Set AFH Channel Classification",             97  },
 442         { "Reserved",                                   98  },
 443         { "Reserved",                                   99  },
 444         { "Read Inquiry Scan Type",                     100 },
 445         { "Write Inquiry Scan Type",                    101 },
 446         { "Read Inquiry Mode",                          102 },
 447         { "Write Inquiry Mode",                         103 },
 448
 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 },
 453         { "Reserved",                                   108 },
 454         { "Reserved",                                   109 },
 455         { "Reserved",                                   110 },
 456         { "Reserved",                                   111 },
 457
 458         { "Reserved",                                   112 },
 459         { "Reserved",                                   113 },
 460         { "Reserved",                                   114 },
 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 },
 466
 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 },
 475
 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 },
 482         { "Reserved",                                   134 },
 483         { "Reserved",                                   135 },
 484
 485         { "Read Extended Inquiry Response",             136 },
 486         { "Write Extended Inquiry Response",            137 },
 487         { "Refresh Encryption Key",                     138 },
 488         { "Reserved",                                   139 },
 489         { "Sniff Subrating",                            140 },
 490         { "Read Simple Pairing Mode",                   141 },
 491         { "Write Simple Pairing Mode",                  142 },
 492         { "Read Local OOB Data",                        143 },
 493
 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 },
 498         { "Reserved",                                   148 },
 499         { "Reserved",                                   149 },
 500         { "Reserved",                                   150 },
 501         { "IO Capability Request Reply",                151 },
 502
 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 },
 511
 512         { "Reserved",                                   160 },
 513         { "Reserved",                                   161 },
 514         { "Send Keypress Notification",                 162 },
 515         { "IO Capability Request Negative Reply",       163 },
 516         { "Read Encryption Key Size",                   164 },
 517         { "Reserved",                                   165 },
 518         { "Reserved",                                   166 },
 519         { "Reserved",                                   167 },
 520
 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 },
 529
 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 },
 538
 539         { "Read Flow Control Mode",                     184 },
 540         { "Write Flow Control Mode",                    185 },
 541         { "Read Data Block Size",                       186 },
 542         { "Reserved",                                   187 },
 543         { "Reserved",                                   188 },
 544         { "Enable AMP Receiver Reports",                189 },
 545         { "AMP Test End",                               190 },
 546         { "AMP Test Command",                           191 },
 547
 548         { "Read Enhanced Transmit Power Level",         192 },
 549         { "Reserved",                                   193 },
 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 },
 555         { "Reserved",                                   199 },
 556
 557         { "LE Set Event Mask",                          200 },
 558         { "LE Read Buffer Size",                        201 },
 559         { "LE Read Local Supported Features",           202 },
 560         { "Reserved",                                   203 },
 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 },
 565
 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 },
 574
 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 },
 582         { "LE Rand",                                    223 },
 583
 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 },
 591         { "Reserved",                                   231 },
 592
 593         { NULL }
 594 };
 595
 596 char *hci_cmdtostr(unsigned int cmd)
 597 {
 598         return hci_uint2str(commands_map, cmd);
 599 }
 600
 601 char *hci_commandstostr(uint8_t *commands, char *pref, int width)
 602 {
 603         unsigned int maxwidth = width - 3;
 604         hci_map *m;
 605         char *off, *ptr, *str;
 606         int size = 10;
 607
 608         m = commands_map;
 609
 610         while (m->str) {
 611                 if (commands[m->val / 8] & (1 << (m->val % 8)))
 612                         size += strlen(m->str) + (pref ? strlen(pref) : 0) + 3;
 613                 m++;
 614         }
 615
 616         str = bt_malloc(size);
 617         if (!str)
 618                 return NULL;
 619
 620         ptr = str; *ptr = '\0';
 621
 622         if (pref)
 623                 ptr += sprintf(ptr, "%s", pref);
 624
 625         off = ptr;
 626
 627         m = commands_map;
 628
 629         while (m->str) {
 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 : "");
 633                                 off = ptr;
 634                         }
 635                         ptr += sprintf(ptr, "'%s' ", m->str);
 636                 }
 637                 m++;
 638         }
 639
 640         return str;
 641 }
 642
 643 /* Version mapping */
 644 static hci_map ver_map[] = {
 645         { "1.0b",       0x00 },
 646         { "1.1",        0x01 },
 647         { "1.2",        0x02 },
 648         { "2.0",        0x03 },
 649         { "2.1",        0x04 },
 650         { "3.0",        0x05 },
 651         { "4.0",        0x06 },
 652         { NULL }
 653 };
 654
 655 char *hci_vertostr(unsigned int ver)
 656 {
 657         return hci_uint2str(ver_map, ver);
 658 }
 659
 660 int hci_strtover(char *str, unsigned int *ver)
 661 {
 662         return hci_str2uint(ver_map, str, ver);
 663 }
 664
 665 char *lmp_vertostr(unsigned int ver)
 666 {
 667         return hci_uint2str(ver_map, ver);
 668 }
 669
 670 int lmp_strtover(char *str, unsigned int *ver)
 671 {
 672         return hci_str2uint(ver_map, str, ver);
 673 }
 674
 675 /* LMP features mapping */
 676 static hci_map lmp_features_map[8][9] = {
 677         {       /* Byte 0 */
 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 */
 686                 { NULL }
 687         },
 688         {       /* Byte 1 */
 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 */
 697                 { NULL }
 698         },
 699         {       /* Byte 2 */
 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 */
 705                 { NULL }
 706         },
 707         {       /* Byte 3 */
 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 */
 716                 { NULL }
 717         },
 718         {       /* Byte 4 */
 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 */
 727                 { NULL }
 728         },
 729         {       /* Byte 5 */
 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 */
 738                 { NULL }
 739         },
 740         {       /* Byte 6 */
 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 */
 749                 { NULL }
 750         },
 751         {       /* Byte 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 */
 760                 { NULL }
 761         },
 762 };
 763
 764 char *lmp_featurestostr(uint8_t *features, char *pref, int width)
 765 {
 766         unsigned int maxwidth = width - 1;
 767         char *off, *ptr, *str;
 768         int i, size = 10;
 769
 770         for (i = 0; i < 8; i++) {
 771                 hci_map *m = lmp_features_map[i];
 772
 773                 while (m->str) {
 774                         if (m->val & features[i])
 775                                 size += strlen(m->str) +
 776                                                 (pref ? strlen(pref) : 0) + 1;
 777                         m++;
 778                 }
 779         }
 780
 781         str = bt_malloc(size);
 782         if (!str)
 783                 return NULL;
 784
 785         ptr = str; *ptr = '\0';
 786
 787         if (pref)
 788                 ptr += sprintf(ptr, "%s", pref);
 789
 790         off = ptr;
 791
 792         for (i = 0; i < 8; i++) {
 793                 hci_map *m = lmp_features_map[i];
 794
 795                 while (m->str) {
 796                         if (m->val & features[i]) {
 797                                 if (strlen(off) + strlen(m->str) > maxwidth) {
 798                                         ptr += sprintf(ptr, "\n%s",
 799                                                         pref ? pref : "");
 800                                         off = ptr;
 801                                 }
 802                                 ptr += sprintf(ptr, "%s ", m->str);
 803                         }
 804                         m++;
 805                 }
 806         }
 807
 808         return str;
 809 }
 810
 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),
 813                         long arg)
 814 {
 815         struct hci_dev_list_req *dl;
 816         struct hci_dev_req *dr;
 817         int dev_id = -1;
 818         int i, sk, err = 0;
 819
 820         sk = socket(AF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI);
 821         if (sk < 0)
 822                 return -1;
 823
 824         dl = malloc(HCI_MAX_DEV * sizeof(*dr) + sizeof(*dl));
 825         if (!dl) {
 826                 err = errno;
 827                 goto done;
 828         }
 829
 830         memset(dl, 0, HCI_MAX_DEV * sizeof(*dr) + sizeof(*dl));
 831
 832         dl->dev_num = HCI_MAX_DEV;
 833         dr = dl->dev_req;
 834
 835         if (ioctl(sk, HCIGETDEVLIST, (void *) dl) < 0) {
 836                 err = errno;
 837                 goto free;
 838         }
 839
 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)) {
 843                                 dev_id = dr->dev_id;
 844                                 break;
 845                         }
 846         }
 847
 848         if (dev_id < 0)
 849                 err = ENODEV;
 850
 851 free:
 852         free(dl);
 853
 854 done:
 855         close(sk);
 856         errno = err;
 857
 858         return dev_id;
 859 }
 860
 861 static int __other_bdaddr(int dd, int dev_id, long arg)
 862 {
 863         struct hci_dev_info di = { .dev_id = dev_id };
 864
 865         if (ioctl(dd, HCIGETDEVINFO, (void *) &di))
 866                 return 0;
 867
 868         if (hci_test_bit(HCI_RAW, &di.flags))
 869                 return 0;
 870
 871         return bacmp((bdaddr_t *) arg, &di.bdaddr);
 872 }
 873
 874 static int __same_bdaddr(int dd, int dev_id, long arg)
 875 {
 876         struct hci_dev_info di = { .dev_id = dev_id };
 877
 878         if (ioctl(dd, HCIGETDEVINFO, (void *) &di))
 879                 return 0;
 880
 881         return !bacmp((bdaddr_t *) arg, &di.bdaddr);
 882 }
 883
 884 int hci_get_route(bdaddr_t *bdaddr)
 885 {
 886         return hci_for_each_dev(HCI_UP, __other_bdaddr,
 887                                 (long) (bdaddr ? bdaddr : BDADDR_ANY));
 888 }
 889
 890 int hci_devid(const char *str)
 891 {
 892         bdaddr_t ba;
 893         int id = -1;
 894
 895         if (!strncmp(str, "hci", 3) && strlen(str) >= 4) {
 896                 id = atoi(str + 3);
 897                 if (hci_devba(id, &ba) < 0)
 898                         return -1;
 899         } else {
 900                 errno = ENODEV;
 901                 str2ba(str, &ba);
 902                 id = hci_for_each_dev(HCI_UP, __same_bdaddr, (long) &ba);
 903         }
 904
 905         return id;
 906 }
 907
 908 int hci_devinfo(int dev_id, struct hci_dev_info *di)
 909 {
 910         int dd, err, ret;
 911
 912         dd = socket(AF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI);
 913         if (dd < 0)
 914                 return dd;
 915
 916         memset(di, 0, sizeof(struct hci_dev_info));
 917
 918         di->dev_id = dev_id;
 919         ret = ioctl(dd, HCIGETDEVINFO, (void *) di);
 920
 921         err = errno;
 922         close(dd);
 923         errno = err;
 924
 925         return ret;
 926 }
 927
 928 int hci_devba(int dev_id, bdaddr_t *bdaddr)
 929 {
 930         struct hci_dev_info di;
 931
 932         memset(&di, 0, sizeof(di));
 933
 934         if (hci_devinfo(dev_id, &di))
 935                 return -1;
 936
 937         if (!hci_test_bit(HCI_UP, &di.flags)) {
 938                 errno = ENETDOWN;
 939                 return -1;
 940         }
 941
 942         bacpy(bdaddr, &di.bdaddr);
 943
 944         return 0;
 945 }
 946
 947 int hci_inquiry(int dev_id, int len, int nrsp, const uint8_t *lap,
 948                 inquiry_info **ii, long flags)
 949 {
 950         struct hci_inquiry_req *ir;
 951         uint8_t num_rsp = nrsp;
 952         void *buf;
 953         int dd, size, err, ret = -1;
 954
 955         if (nrsp <= 0) {
 956                 num_rsp = 0;
 957                 nrsp = 255;
 958         }
 959
 960         if (dev_id < 0) {
 961                 dev_id = hci_get_route(NULL);
 962                 if (dev_id < 0) {
 963                         errno = ENODEV;
 964                         return -1;
 965                 }
 966         }
 967
 968         dd = socket(AF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI);
 969         if (dd < 0)
 970                 return dd;
 971
 972         buf = malloc(sizeof(*ir) + (sizeof(inquiry_info) * (nrsp)));
 973         if (!buf)
 974                 goto done;
 975
 976         ir = buf;
 977         ir->dev_id  = dev_id;
 978         ir->num_rsp = num_rsp;
 979         ir->length  = len;
 980         ir->flags   = flags;
 981
 982         if (lap) {
 983                 memcpy(ir->lap, lap, 3);
 984         } else {
 985                 ir->lap[0] = 0x33;
 986                 ir->lap[1] = 0x8b;
 987                 ir->lap[2] = 0x9e;
 988         }
 989
 990         ret = ioctl(dd, HCIINQUIRY, (unsigned long) buf);
 991         if (ret < 0)
 992                 goto free;
 993
 994         size = sizeof(inquiry_info) * ir->num_rsp;
 995
 996         if (!*ii)
 997                 *ii = malloc(size);
 998
 999         if (*ii) {
1000                 memcpy((void *) *ii, buf + sizeof(*ir), size);
1001                 ret = ir->num_rsp;
1002         } else
1003                 ret = -1;
1004
1005 free:
1006         free(buf);
1007
1008 done:
1009         err = errno;
1010         close(dd);
1011         errno = err;
1012
1013         return ret;
1014 }
1015
1016 /* Open HCI device.
1017  * Returns device descriptor (dd). */
1018 int hci_open_dev(int dev_id)
1019 {
1020         struct sockaddr_hci a;
1021         int dd, err;
1022
1023         /* Create HCI socket */
1024         dd = socket(AF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI);
1025         if (dd < 0)
1026                 return dd;
1027
1028         /* Bind socket to the HCI device */
1029         memset(&a, 0, sizeof(a));
1030         a.hci_family = AF_BLUETOOTH;
1031         a.hci_dev = dev_id;
1032         if (bind(dd, (struct sockaddr *) &a, sizeof(a)) < 0)
1033                 goto failed;
1034
1035         return dd;
1036
1037 failed:
1038         err = errno;
1039         close(dd);
1040         errno = err;
1041
1042         return -1;
1043 }
1044
1045 int hci_close_dev(int dd)
1046 {
1047         return close(dd);
1048 }
1049
1050 /* HCI functions that require open device
1051  * dd - Device descriptor returned by hci_open_dev. */
1052
1053 int hci_send_cmd(int dd, uint16_t ogf, uint16_t ocf, uint8_t plen, void *param)
1054 {
1055         uint8_t type = HCI_COMMAND_PKT;
1056         hci_command_hdr hc;
1057         struct iovec iv[3];
1058         int ivn;
1059
1060         hc.opcode = htobs(cmd_opcode_pack(ogf, ocf));
1061         hc.plen= plen;
1062
1063         iv[0].iov_base = &type;
1064         iv[0].iov_len  = 1;
1065         iv[1].iov_base = &hc;
1066         iv[1].iov_len  = HCI_COMMAND_HDR_SIZE;
1067         ivn = 2;
1068
1069         if (plen) {
1070                 iv[2].iov_base = param;
1071                 iv[2].iov_len  = plen;
1072                 ivn = 3;
1073         }
1074
1075         while (writev(dd, iv, ivn) < 0) {
1076                 if (errno == EAGAIN || errno == EINTR)
1077                         continue;
1078                 return -1;
1079         }
1080         return 0;
1081 }
1082
1083 int hci_send_req(int dd, struct hci_request *r, int to)
1084 {
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;
1088         socklen_t olen;
1089         hci_event_hdr *hdr;
1090         int err, try;
1091
1092         olen = sizeof(of);
1093         if (getsockopt(dd, SOL_HCI, HCI_FILTER, &of, &olen) < 0)
1094                 return -1;
1095
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)
1104                 return -1;
1105
1106         if (hci_send_cmd(dd, r->ogf, r->ocf, r->clen, r->cparam) < 0)
1107                 goto failed;
1108
1109         try = 10;
1110         while (try--) {
1111                 evt_cmd_complete *cc;
1112                 evt_cmd_status *cs;
1113                 evt_remote_name_req_complete *rn;
1114                 evt_le_meta_event *me;
1115                 remote_name_req_cp *cp;
1116                 int len;
1117
1118                 if (to) {
1119                         struct pollfd p;
1120                         int n;
1121
1122                         p.fd = dd; p.events = POLLIN;
1123                         while ((n = poll(&p, 1, to)) < 0) {
1124                                 if (errno == EAGAIN || errno == EINTR)
1125                                         continue;
1126                                 goto failed;
1127                         }
1128
1129                         if (!n) {
1130                                 errno = ETIMEDOUT;
1131                                 goto failed;
1132                         }
1133
1134                         to -= 10;
1135                         if (to < 0)
1136                                 to = 0;
1137
1138                 }
1139
1140                 while ((len = read(dd, buf, sizeof(buf))) < 0) {
1141                         if (errno == EAGAIN || errno == EINTR)
1142                                 continue;
1143                         goto failed;
1144                 }
1145
1146                 hdr = (void *) (buf + 1);
1147                 ptr = buf + (1 + HCI_EVENT_HDR_SIZE);
1148                 len -= (1 + HCI_EVENT_HDR_SIZE);
1149
1150                 switch (hdr->evt) {
1151                 case EVT_CMD_STATUS:
1152                         cs = (void *) ptr;
1153
1154                         if (cs->opcode != opcode)
1155                                 continue;
1156
1157                         if (r->event != EVT_CMD_STATUS) {
1158                                 if (cs->status) {
1159                                         errno = EIO;
1160                                         goto failed;
1161                                 }
1162                                 break;
1163                         }
1164
1165                         r->rlen = MIN(len, r->rlen);
1166                         memcpy(r->rparam, ptr, r->rlen);
1167                         goto done;
1168
1169                 case EVT_CMD_COMPLETE:
1170                         cc = (void *) ptr;
1171
1172                         if (cc->opcode != opcode)
1173                                 continue;
1174
1175                         ptr += EVT_CMD_COMPLETE_SIZE;
1176                         len -= EVT_CMD_COMPLETE_SIZE;
1177
1178                         r->rlen = MIN(len, r->rlen);
1179                         memcpy(r->rparam, ptr, r->rlen);
1180                         goto done;
1181
1182                 case EVT_REMOTE_NAME_REQ_COMPLETE:
1183                         if (hdr->evt != r->event)
1184                                 break;
1185
1186                         rn = (void *) ptr;
1187                         cp = r->cparam;
1188
1189                         if (bacmp(&rn->bdaddr, &cp->bdaddr))
1190                                 continue;
1191
1192                         r->rlen = MIN(len, r->rlen);
1193                         memcpy(r->rparam, ptr, r->rlen);
1194                         goto done;
1195
1196                 case EVT_LE_META_EVENT:
1197                         me = (void *) ptr;
1198
1199                         if (me->subevent != r->event)
1200                                 continue;
1201
1202                         len -= 1;
1203                         r->rlen = MIN(len, r->rlen);
1204                         memcpy(r->rparam, me->data, r->rlen);
1205                         goto done;
1206
1207                 default:
1208                         if (hdr->evt != r->event)
1209                                 break;
1210
1211                         r->rlen = MIN(len, r->rlen);
1212                         memcpy(r->rparam, ptr, r->rlen);
1213                         goto done;
1214                 }
1215         }
1216         errno = ETIMEDOUT;
1217
1218 failed:
1219         err = errno;
1220         setsockopt(dd, SOL_HCI, HCI_FILTER, &of, sizeof(of));
1221         errno = err;
1222         return -1;
1223
1224 done:
1225         setsockopt(dd, SOL_HCI, HCI_FILTER, &of, sizeof(of));
1226         return 0;
1227 }
1228
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)
1232 {
1233         evt_conn_complete rp;
1234         create_conn_cp cp;
1235         struct hci_request rq;
1236
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;
1243
1244         memset(&rq, 0, sizeof(rq));
1245         rq.ogf    = OGF_LINK_CTL;
1246         rq.ocf    = OCF_CREATE_CONN;
1247         rq.event  = EVT_CONN_COMPLETE;
1248         rq.cparam = &cp;
1249         rq.clen   = CREATE_CONN_CP_SIZE;
1250         rq.rparam = &rp;
1251         rq.rlen   = EVT_CONN_COMPLETE_SIZE;
1252
1253         if (hci_send_req(dd, &rq, to) < 0)
1254                 return -1;
1255
1256         if (rp.status) {
1257                 errno = EIO;
1258                 return -1;
1259         }
1260
1261         *handle = rp.handle;
1262         return 0;
1263 }
1264
1265 int hci_disconnect(int dd, uint16_t handle, uint8_t reason, int to)
1266 {
1267         evt_disconn_complete rp;
1268         disconnect_cp cp;
1269         struct hci_request rq;
1270
1271         memset(&cp, 0, sizeof(cp));
1272         cp.handle = handle;
1273         cp.reason = reason;
1274
1275         memset(&rq, 0, sizeof(rq));
1276         rq.ogf    = OGF_LINK_CTL;
1277         rq.ocf    = OCF_DISCONNECT;
1278         rq.event  = EVT_DISCONN_COMPLETE;
1279         rq.cparam = &cp;
1280         rq.clen   = DISCONNECT_CP_SIZE;
1281         rq.rparam = &rp;
1282         rq.rlen   = EVT_DISCONN_COMPLETE_SIZE;
1283
1284         if (hci_send_req(dd, &rq, to) < 0)
1285                 return -1;
1286
1287         if (rp.status) {
1288                 errno = EIO;
1289                 return -1;
1290         }
1291         return 0;
1292 }
1293
1294 int hci_le_add_white_list(int dd, const bdaddr_t *bdaddr, uint8_t type, int to)
1295 {
1296         struct hci_request rq;
1297         le_add_device_to_white_list_cp cp;
1298         uint8_t status;
1299
1300         memset(&cp, 0, sizeof(cp));
1301         cp.bdaddr_type = type;
1302         bacpy(&cp.bdaddr, bdaddr);
1303
1304         memset(&rq, 0, sizeof(rq));
1305         rq.ogf = OGF_LE_CTL;
1306         rq.ocf = OCF_LE_ADD_DEVICE_TO_WHITE_LIST;
1307         rq.cparam = &cp;
1308         rq.clen = LE_ADD_DEVICE_TO_WHITE_LIST_CP_SIZE;
1309         rq.rparam = &status;
1310         rq.rlen = 1;
1311
1312         if (hci_send_req(dd, &rq, to) < 0)
1313                 return -1;
1314
1315         if (status) {
1316                 errno = EIO;
1317                 return -1;
1318         }
1319
1320         return 0;
1321 }
1322
1323 int hci_le_rm_white_list(int dd, const bdaddr_t *bdaddr, uint8_t type, int to)
1324 {
1325         struct hci_request rq;
1326         le_remove_device_from_white_list_cp cp;
1327         uint8_t status;
1328
1329         memset(&cp, 0, sizeof(cp));
1330         cp.bdaddr_type = type;
1331         bacpy(&cp.bdaddr, bdaddr);
1332
1333         memset(&rq, 0, sizeof(rq));
1334         rq.ogf = OGF_LE_CTL;
1335         rq.ocf = OCF_LE_REMOVE_DEVICE_FROM_WHITE_LIST;
1336         rq.cparam = &cp;
1337         rq.clen = LE_REMOVE_DEVICE_FROM_WHITE_LIST_CP_SIZE;
1338         rq.rparam = &status;
1339         rq.rlen = 1;
1340
1341         if (hci_send_req(dd, &rq, to) < 0)
1342                 return -1;
1343
1344         if (status) {
1345                 errno = EIO;
1346                 return -1;
1347         }
1348
1349         return 0;
1350 }
1351
1352 int hci_le_read_white_list_size(int dd, uint8_t *size, int to)
1353 {
1354         struct hci_request rq;
1355         le_read_white_list_size_rp rp;
1356
1357         memset(&rp, 0, sizeof(rp));
1358         memset(&rq, 0, sizeof(rq));
1359
1360         rq.ogf = OGF_LE_CTL;
1361         rq.ocf = OCF_LE_READ_WHITE_LIST_SIZE;
1362         rq.rparam = &rp;
1363         rq.rlen = LE_READ_WHITE_LIST_SIZE_RP_SIZE;
1364
1365         if (hci_send_req(dd, &rq, to) < 0)
1366                 return -1;
1367
1368         if (rp.status) {
1369                 errno = EIO;
1370                 return -1;
1371         }
1372
1373         if (size)
1374                 *size = rp.size;
1375
1376         return 0;
1377 }
1378
1379 int hci_le_clear_white_list(int dd, int to)
1380 {
1381         struct hci_request rq;
1382         uint8_t status;
1383
1384         memset(&rq, 0, sizeof(rq));
1385         rq.ogf = OGF_LE_CTL;
1386         rq.ocf = OCF_LE_CLEAR_WHITE_LIST;
1387         rq.rparam = &status;
1388         rq.rlen = 1;
1389
1390         if (hci_send_req(dd, &rq, to) < 0)
1391                 return -1;
1392
1393         if (status) {
1394                 errno = EIO;
1395                 return -1;
1396         }
1397
1398         return 0;
1399 }
1400
1401 int hci_read_local_name(int dd, int len, char *name, int to)
1402 {
1403         read_local_name_rp rp;
1404         struct hci_request rq;
1405
1406         memset(&rq, 0, sizeof(rq));
1407         rq.ogf    = OGF_HOST_CTL;
1408         rq.ocf    = OCF_READ_LOCAL_NAME;
1409         rq.rparam = &rp;
1410         rq.rlen   = READ_LOCAL_NAME_RP_SIZE;
1411
1412         if (hci_send_req(dd, &rq, to) < 0)
1413                 return -1;
1414
1415         if (rp.status) {
1416                 errno = EIO;
1417                 return -1;
1418         }
1419
1420 #ifdef __TIZEN_PATCH__
1421         strncpy(name, (char *) rp.name, len - 1);
1422         name[len - 1] = '\0';
1423 #else
1424         rp.name[247] = '\0';
1425         strncpy(name, (char *) rp.name, len);
1426 #endif
1427         return 0;
1428 }
1429
1430 int hci_write_local_name(int dd, const char *name, int to)
1431 {
1432         change_local_name_cp cp;
1433         struct hci_request rq;
1434
1435         memset(&cp, 0, sizeof(cp));
1436         strncpy((char *) cp.name, name, sizeof(cp.name));
1437
1438         memset(&rq, 0, sizeof(rq));
1439         rq.ogf    = OGF_HOST_CTL;
1440         rq.ocf    = OCF_CHANGE_LOCAL_NAME;
1441         rq.cparam = &cp;
1442         rq.clen   = CHANGE_LOCAL_NAME_CP_SIZE;
1443
1444         if (hci_send_req(dd, &rq, to) < 0)
1445                 return -1;
1446
1447         return 0;
1448 }
1449
1450 int hci_read_remote_name_with_clock_offset(int dd, const bdaddr_t *bdaddr,
1451                                                 uint8_t pscan_rep_mode,
1452                                                 uint16_t clkoffset,
1453                                                 int len, char *name, int to)
1454 {
1455         evt_remote_name_req_complete rn;
1456         remote_name_req_cp cp;
1457         struct hci_request rq;
1458
1459         memset(&cp, 0, sizeof(cp));
1460         bacpy(&cp.bdaddr, bdaddr);
1461         cp.pscan_rep_mode = pscan_rep_mode;
1462         cp.clock_offset   = clkoffset;
1463
1464         memset(&rq, 0, sizeof(rq));
1465         rq.ogf    = OGF_LINK_CTL;
1466         rq.ocf    = OCF_REMOTE_NAME_REQ;
1467         rq.cparam = &cp;
1468         rq.clen   = REMOTE_NAME_REQ_CP_SIZE;
1469         rq.event  = EVT_REMOTE_NAME_REQ_COMPLETE;
1470         rq.rparam = &rn;
1471         rq.rlen   = EVT_REMOTE_NAME_REQ_COMPLETE_SIZE;
1472
1473         if (hci_send_req(dd, &rq, to) < 0)
1474                 return -1;
1475
1476         if (rn.status) {
1477                 errno = EIO;
1478                 return -1;
1479         }
1480
1481         rn.name[247] = '\0';
1482         strncpy(name, (char *) rn.name, len);
1483         return 0;
1484 }
1485
1486 int hci_read_remote_name(int dd, const bdaddr_t *bdaddr, int len, char *name,
1487                                 int to)
1488 {
1489         return hci_read_remote_name_with_clock_offset(dd, bdaddr, 0x02, 0x0000,
1490                                                         len, name, to);
1491 }
1492
1493 int hci_read_remote_name_cancel(int dd, const bdaddr_t *bdaddr, int to)
1494 {
1495         remote_name_req_cancel_cp cp;
1496         struct hci_request rq;
1497
1498         memset(&cp, 0, sizeof(cp));
1499         bacpy(&cp.bdaddr, bdaddr);
1500
1501         memset(&rq, 0, sizeof(rq));
1502         rq.ogf    = OGF_LINK_CTL;
1503         rq.ocf    = OCF_REMOTE_NAME_REQ_CANCEL;
1504         rq.cparam = &cp;
1505         rq.clen   = REMOTE_NAME_REQ_CANCEL_CP_SIZE;
1506
1507         if (hci_send_req(dd, &rq, to) < 0)
1508                 return -1;
1509
1510         return 0;
1511 }
1512
1513 int hci_read_remote_version(int dd, uint16_t handle, struct hci_version *ver,
1514                                 int to)
1515 {
1516         evt_read_remote_version_complete rp;
1517         read_remote_version_cp cp;
1518         struct hci_request rq;
1519
1520         memset(&cp, 0, sizeof(cp));
1521         cp.handle = handle;
1522
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;
1527         rq.cparam = &cp;
1528         rq.clen   = READ_REMOTE_VERSION_CP_SIZE;
1529         rq.rparam = &rp;
1530         rq.rlen   = EVT_READ_REMOTE_VERSION_COMPLETE_SIZE;
1531
1532         if (hci_send_req(dd, &rq, to) < 0)
1533                 return -1;
1534
1535         if (rp.status) {
1536                 errno = EIO;
1537                 return -1;
1538         }
1539
1540         ver->manufacturer = btohs(rp.manufacturer);
1541         ver->lmp_ver      = rp.lmp_ver;
1542         ver->lmp_subver   = btohs(rp.lmp_subver);
1543         return 0;
1544 }
1545
1546 int hci_read_remote_features(int dd, uint16_t handle, uint8_t *features, int to)
1547 {
1548         evt_read_remote_features_complete rp;
1549         read_remote_features_cp cp;
1550         struct hci_request rq;
1551
1552         memset(&cp, 0, sizeof(cp));
1553         cp.handle = handle;
1554
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;
1559         rq.cparam = &cp;
1560         rq.clen   = READ_REMOTE_FEATURES_CP_SIZE;
1561         rq.rparam = &rp;
1562         rq.rlen   = EVT_READ_REMOTE_FEATURES_COMPLETE_SIZE;
1563
1564         if (hci_send_req(dd, &rq, to) < 0)
1565                 return -1;
1566
1567         if (rp.status) {
1568                 errno = EIO;
1569                 return -1;
1570         }
1571
1572         if (features)
1573                 memcpy(features, rp.features, 8);
1574
1575         return 0;
1576 }
1577
1578 int hci_read_remote_ext_features(int dd, uint16_t handle, uint8_t page,
1579                                         uint8_t *max_page, uint8_t *features,
1580                                         int to)
1581 {
1582         evt_read_remote_ext_features_complete rp;
1583         read_remote_ext_features_cp cp;
1584         struct hci_request rq;
1585
1586         memset(&cp, 0, sizeof(cp));
1587         cp.handle   = handle;
1588         cp.page_num = page;
1589
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;
1594         rq.cparam = &cp;
1595         rq.clen   = READ_REMOTE_EXT_FEATURES_CP_SIZE;
1596         rq.rparam = &rp;
1597         rq.rlen   = EVT_READ_REMOTE_EXT_FEATURES_COMPLETE_SIZE;
1598
1599         if (hci_send_req(dd, &rq, to) < 0)
1600                 return -1;
1601
1602         if (rp.status) {
1603                 errno = EIO;
1604                 return -1;
1605         }
1606
1607         if (max_page)
1608                 *max_page = rp.max_page_num;
1609
1610         if (features)
1611                 memcpy(features, rp.features, 8);
1612
1613         return 0;
1614 }
1615
1616 int hci_read_clock_offset(int dd, uint16_t handle, uint16_t *clkoffset, int to)
1617 {
1618         evt_read_clock_offset_complete rp;
1619         read_clock_offset_cp cp;
1620         struct hci_request rq;
1621
1622         memset(&cp, 0, sizeof(cp));
1623         cp.handle = handle;
1624
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;
1629         rq.cparam = &cp;
1630         rq.clen   = READ_CLOCK_OFFSET_CP_SIZE;
1631         rq.rparam = &rp;
1632         rq.rlen   = EVT_READ_CLOCK_OFFSET_COMPLETE_SIZE;
1633
1634         if (hci_send_req(dd, &rq, to) < 0)
1635                 return -1;
1636
1637         if (rp.status) {
1638                 errno = EIO;
1639                 return -1;
1640         }
1641
1642         *clkoffset = rp.clock_offset;
1643         return 0;
1644 }
1645
1646 int hci_read_local_version(int dd, struct hci_version *ver, int to)
1647 {
1648         read_local_version_rp rp;
1649         struct hci_request rq;
1650
1651         memset(&rq, 0, sizeof(rq));
1652         rq.ogf    = OGF_INFO_PARAM;
1653         rq.ocf    = OCF_READ_LOCAL_VERSION;
1654         rq.rparam = &rp;
1655         rq.rlen   = READ_LOCAL_VERSION_RP_SIZE;
1656
1657         if (hci_send_req(dd, &rq, to) < 0)
1658                 return -1;
1659
1660         if (rp.status) {
1661                 errno = EIO;
1662                 return -1;
1663         }
1664
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);
1670         return 0;
1671 }
1672
1673 int hci_read_local_commands(int dd, uint8_t *commands, int to)
1674 {
1675         read_local_commands_rp rp;
1676         struct hci_request rq;
1677
1678         memset(&rq, 0, sizeof(rq));
1679         rq.ogf    = OGF_INFO_PARAM;
1680         rq.ocf    = OCF_READ_LOCAL_COMMANDS;
1681         rq.rparam = &rp;
1682         rq.rlen   = READ_LOCAL_COMMANDS_RP_SIZE;
1683
1684         if (hci_send_req(dd, &rq, to) < 0)
1685                 return -1;
1686
1687         if (rp.status) {
1688                 errno = EIO;
1689                 return -1;
1690         }
1691
1692         if (commands)
1693                 memcpy(commands, rp.commands, 64);
1694
1695         return 0;
1696 }
1697
1698 int hci_read_local_features(int dd, uint8_t *features, int to)
1699 {
1700         read_local_features_rp rp;
1701         struct hci_request rq;
1702
1703         memset(&rq, 0, sizeof(rq));
1704         rq.ogf    = OGF_INFO_PARAM;
1705         rq.ocf    = OCF_READ_LOCAL_FEATURES;
1706         rq.rparam = &rp;
1707         rq.rlen   = READ_LOCAL_FEATURES_RP_SIZE;
1708
1709         if (hci_send_req(dd, &rq, to) < 0)
1710                 return -1;
1711
1712         if (rp.status) {
1713                 errno = EIO;
1714                 return -1;
1715         }
1716
1717         if (features)
1718                 memcpy(features, rp.features, 8);
1719
1720         return 0;
1721 }
1722
1723 int hci_read_local_ext_features(int dd, uint8_t page, uint8_t *max_page,
1724                                 uint8_t *features, int to)
1725 {
1726         read_local_ext_features_cp cp;
1727         read_local_ext_features_rp rp;
1728         struct hci_request rq;
1729
1730         cp.page_num = page;
1731
1732         memset(&rq, 0, sizeof(rq));
1733         rq.ogf    = OGF_INFO_PARAM;
1734         rq.ocf    = OCF_READ_LOCAL_EXT_FEATURES;
1735         rq.cparam = &cp;
1736         rq.clen   = READ_LOCAL_EXT_FEATURES_CP_SIZE;
1737         rq.rparam = &rp;
1738         rq.rlen   = READ_LOCAL_EXT_FEATURES_RP_SIZE;
1739
1740         if (hci_send_req(dd, &rq, to) < 0)
1741                 return -1;
1742
1743         if (rp.status) {
1744                 errno = EIO;
1745                 return -1;
1746         }
1747
1748         if (max_page)
1749                 *max_page = rp.max_page_num;
1750
1751         if (features)
1752                 memcpy(features, rp.features, 8);
1753
1754         return 0;
1755 }
1756
1757 int hci_read_bd_addr(int dd, bdaddr_t *bdaddr, int to)
1758 {
1759         read_bd_addr_rp rp;
1760         struct hci_request rq;
1761
1762         memset(&rq, 0, sizeof(rq));
1763         rq.ogf    = OGF_INFO_PARAM;
1764         rq.ocf    = OCF_READ_BD_ADDR;
1765         rq.rparam = &rp;
1766         rq.rlen   = READ_BD_ADDR_RP_SIZE;
1767
1768         if (hci_send_req(dd, &rq, to) < 0)
1769                 return -1;
1770
1771         if (rp.status) {
1772                 errno = EIO;
1773                 return -1;
1774         }
1775
1776         if (bdaddr)
1777                 bacpy(bdaddr, &rp.bdaddr);
1778
1779         return 0;
1780 }
1781
1782 int hci_read_class_of_dev(int dd, uint8_t *cls, int to)
1783 {
1784         read_class_of_dev_rp rp;
1785         struct hci_request rq;
1786
1787         memset(&rq, 0, sizeof(rq));
1788         rq.ogf    = OGF_HOST_CTL;
1789         rq.ocf    = OCF_READ_CLASS_OF_DEV;
1790         rq.rparam = &rp;
1791         rq.rlen   = READ_CLASS_OF_DEV_RP_SIZE;
1792
1793         if (hci_send_req(dd, &rq, to) < 0)
1794                 return -1;
1795
1796         if (rp.status) {
1797                 errno = EIO;
1798                 return -1;
1799         }
1800
1801         memcpy(cls, rp.dev_class, 3);
1802         return 0;
1803 }
1804
1805 int hci_write_class_of_dev(int dd, uint32_t cls, int to)
1806 {
1807         write_class_of_dev_cp cp;
1808         struct hci_request rq;
1809
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;
1816         rq.cparam = &cp;
1817         rq.clen   = WRITE_CLASS_OF_DEV_CP_SIZE;
1818         return hci_send_req(dd, &rq, to);
1819 }
1820
1821 int hci_read_voice_setting(int dd, uint16_t *vs, int to)
1822 {
1823         read_voice_setting_rp rp;
1824         struct hci_request rq;
1825
1826         memset(&rq, 0, sizeof(rq));
1827         rq.ogf    = OGF_HOST_CTL;
1828         rq.ocf    = OCF_READ_VOICE_SETTING;
1829         rq.rparam = &rp;
1830         rq.rlen   = READ_VOICE_SETTING_RP_SIZE;
1831
1832         if (hci_send_req(dd, &rq, to) < 0)
1833                 return -1;
1834
1835         if (rp.status) {
1836                 errno = EIO;
1837                 return -1;
1838         }
1839
1840         *vs = rp.voice_setting;
1841         return 0;
1842 }
1843
1844 int hci_write_voice_setting(int dd, uint16_t vs, int to)
1845 {
1846         write_voice_setting_cp cp;
1847         struct hci_request rq;
1848
1849         memset(&rq, 0, sizeof(rq));
1850         cp.voice_setting = vs;
1851         rq.ogf    = OGF_HOST_CTL;
1852         rq.ocf    = OCF_WRITE_VOICE_SETTING;
1853         rq.cparam = &cp;
1854         rq.clen   = WRITE_VOICE_SETTING_CP_SIZE;
1855
1856         return hci_send_req(dd, &rq, to);
1857 }
1858
1859 int hci_read_current_iac_lap(int dd, uint8_t *num_iac, uint8_t *lap, int to)
1860 {
1861         read_current_iac_lap_rp rp;
1862         struct hci_request rq;
1863
1864         memset(&rq, 0, sizeof(rq));
1865         rq.ogf    = OGF_HOST_CTL;
1866         rq.ocf    = OCF_READ_CURRENT_IAC_LAP;
1867         rq.rparam = &rp;
1868         rq.rlen   = READ_CURRENT_IAC_LAP_RP_SIZE;
1869
1870         if (hci_send_req(dd, &rq, to) < 0)
1871                 return -1;
1872
1873         if (rp.status) {
1874                 errno = EIO;
1875                 return -1;
1876         }
1877
1878         *num_iac = rp.num_current_iac;
1879         memcpy(lap, rp.lap, rp.num_current_iac * 3);
1880         return 0;
1881 }
1882
1883 int hci_write_current_iac_lap(int dd, uint8_t num_iac, uint8_t *lap, int to)
1884 {
1885         write_current_iac_lap_cp cp;
1886         struct hci_request rq;
1887
1888         memset(&cp, 0, sizeof(cp));
1889         cp.num_current_iac = num_iac;
1890         memcpy(&cp.lap, lap, num_iac * 3);
1891
1892         memset(&rq, 0, sizeof(rq));
1893         rq.ogf    = OGF_HOST_CTL;
1894         rq.ocf    = OCF_WRITE_CURRENT_IAC_LAP;
1895         rq.cparam = &cp;
1896         rq.clen   = num_iac * 3 + 1;
1897
1898         return hci_send_req(dd, &rq, to);
1899 }
1900
1901 int hci_read_stored_link_key(int dd, bdaddr_t *bdaddr, uint8_t all, int to)
1902 {
1903         read_stored_link_key_cp cp;
1904         struct hci_request rq;
1905
1906         memset(&cp, 0, sizeof(cp));
1907         bacpy(&cp.bdaddr, bdaddr);
1908         cp.read_all = all;
1909
1910         memset(&rq, 0, sizeof(rq));
1911         rq.ogf    = OGF_HOST_CTL;
1912         rq.ocf    = OCF_READ_STORED_LINK_KEY;
1913         rq.cparam = &cp;
1914         rq.clen   = READ_STORED_LINK_KEY_CP_SIZE;
1915
1916         return hci_send_req(dd, &rq, to);
1917 }
1918
1919 int hci_write_stored_link_key(int dd, bdaddr_t *bdaddr, uint8_t *key, int to)
1920 {
1921         unsigned char cp[WRITE_STORED_LINK_KEY_CP_SIZE + 6 + 16];
1922         struct hci_request rq;
1923
1924         memset(&cp, 0, sizeof(cp));
1925         cp[0] = 1;
1926         bacpy((bdaddr_t *) (cp + 1), bdaddr);
1927         memcpy(cp + 7, key, 16);
1928
1929         memset(&rq, 0, sizeof(rq));
1930         rq.ogf    = OGF_HOST_CTL;
1931         rq.ocf    = OCF_WRITE_STORED_LINK_KEY;
1932         rq.cparam = &cp;
1933         rq.clen   = WRITE_STORED_LINK_KEY_CP_SIZE + 6 + 16;
1934
1935         return hci_send_req(dd, &rq, to);
1936 }
1937
1938 int hci_delete_stored_link_key(int dd, bdaddr_t *bdaddr, uint8_t all, int to)
1939 {
1940         delete_stored_link_key_cp cp;
1941         struct hci_request rq;
1942
1943         memset(&cp, 0, sizeof(cp));
1944         bacpy(&cp.bdaddr, bdaddr);
1945         cp.delete_all = all;
1946
1947         memset(&rq, 0, sizeof(rq));
1948         rq.ogf    = OGF_HOST_CTL;
1949         rq.ocf    = OCF_DELETE_STORED_LINK_KEY;
1950         rq.cparam = &cp;
1951         rq.clen   = DELETE_STORED_LINK_KEY_CP_SIZE;
1952
1953         return hci_send_req(dd, &rq, to);
1954 }
1955
1956 int hci_authenticate_link(int dd, uint16_t handle, int to)
1957 {
1958         auth_requested_cp cp;
1959         evt_auth_complete rp;
1960         struct hci_request rq;
1961
1962         cp.handle = handle;
1963
1964         rq.ogf    = OGF_LINK_CTL;
1965         rq.ocf    = OCF_AUTH_REQUESTED;
1966         rq.event  = EVT_AUTH_COMPLETE;
1967         rq.cparam = &cp;
1968         rq.clen   = AUTH_REQUESTED_CP_SIZE;
1969         rq.rparam = &rp;
1970         rq.rlen   = EVT_AUTH_COMPLETE_SIZE;
1971
1972         if (hci_send_req(dd, &rq, to) < 0)
1973                 return -1;
1974
1975         if (rp.status) {
1976                 errno = EIO;
1977                 return -1;
1978         }
1979
1980         return 0;
1981 }
1982
1983 int hci_encrypt_link(int dd, uint16_t handle, uint8_t encrypt, int to)
1984 {
1985         set_conn_encrypt_cp cp;
1986         evt_encrypt_change rp;
1987         struct hci_request rq;
1988
1989         cp.handle  = handle;
1990         cp.encrypt = encrypt;
1991
1992         rq.ogf     = OGF_LINK_CTL;
1993         rq.ocf     = OCF_SET_CONN_ENCRYPT;
1994         rq.event   = EVT_ENCRYPT_CHANGE;
1995         rq.cparam  = &cp;
1996         rq.clen    = SET_CONN_ENCRYPT_CP_SIZE;
1997         rq.rparam  = &rp;
1998         rq.rlen    = EVT_ENCRYPT_CHANGE_SIZE;
1999
2000         if (hci_send_req(dd, &rq, to) < 0)
2001                 return -1;
2002
2003         if (rp.status) {
2004                 errno = EIO;
2005                 return -1;
2006         }
2007
2008         return 0;
2009 }
2010
2011 int hci_change_link_key(int dd, uint16_t handle, int to)
2012 {
2013         change_conn_link_key_cp cp;
2014         evt_change_conn_link_key_complete rp;
2015         struct hci_request rq;
2016
2017         cp.handle = handle;
2018
2019         rq.ogf    = OGF_LINK_CTL;
2020         rq.ocf    = OCF_CHANGE_CONN_LINK_KEY;
2021         rq.event  = EVT_CHANGE_CONN_LINK_KEY_COMPLETE;
2022         rq.cparam = &cp;
2023         rq.clen   = CHANGE_CONN_LINK_KEY_CP_SIZE;
2024         rq.rparam = &rp;
2025         rq.rlen   = EVT_CHANGE_CONN_LINK_KEY_COMPLETE_SIZE;
2026
2027         if (hci_send_req(dd, &rq, to) < 0)
2028                 return -1;
2029
2030         if (rp.status) {
2031                 errno = EIO;
2032                 return -1;
2033         }
2034
2035         return 0;
2036 }
2037
2038 int hci_switch_role(int dd, bdaddr_t *bdaddr, uint8_t role, int to)
2039 {
2040         switch_role_cp cp;
2041         evt_role_change rp;
2042         struct hci_request rq;
2043
2044         bacpy(&cp.bdaddr, bdaddr);
2045         cp.role   = role;
2046         rq.ogf    = OGF_LINK_POLICY;
2047         rq.ocf    = OCF_SWITCH_ROLE;
2048         rq.cparam = &cp;
2049         rq.clen   = SWITCH_ROLE_CP_SIZE;
2050         rq.rparam = &rp;
2051         rq.rlen   = EVT_ROLE_CHANGE_SIZE;
2052         rq.event  = EVT_ROLE_CHANGE;
2053
2054         if (hci_send_req(dd, &rq, to) < 0)
2055                 return -1;
2056
2057         if (rp.status) {
2058                 errno = EIO;
2059                 return -1;
2060         }
2061
2062         return 0;
2063 }
2064
2065 int hci_park_mode(int dd, uint16_t handle, uint16_t max_interval,
2066                         uint16_t min_interval, int to)
2067 {
2068         park_mode_cp cp;
2069         evt_mode_change rp;
2070         struct hci_request rq;
2071
2072         memset(&cp, 0, sizeof (cp));
2073         cp.handle       = handle;
2074         cp.max_interval = max_interval;
2075         cp.min_interval = min_interval;
2076
2077         memset(&rq, 0, sizeof (rq));
2078         rq.ogf    = OGF_LINK_POLICY;
2079         rq.ocf    = OCF_PARK_MODE;
2080         rq.event  = EVT_MODE_CHANGE;
2081         rq.cparam = &cp;
2082         rq.clen   = PARK_MODE_CP_SIZE;
2083         rq.rparam = &rp;
2084         rq.rlen   = EVT_MODE_CHANGE_SIZE;
2085
2086         if (hci_send_req(dd, &rq, to) < 0)
2087                 return -1;
2088
2089         if (rp.status) {
2090                 errno = EIO;
2091                 return -1;
2092         }
2093
2094         return 0;
2095 }
2096
2097 int hci_exit_park_mode(int dd, uint16_t handle, int to)
2098 {
2099         exit_park_mode_cp cp;
2100         evt_mode_change rp;
2101         struct hci_request rq;
2102
2103         memset(&cp, 0, sizeof (cp));
2104         cp.handle = handle;
2105
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;
2110         rq.cparam = &cp;
2111         rq.clen   = EXIT_PARK_MODE_CP_SIZE;
2112         rq.rparam = &rp;
2113         rq.rlen   = EVT_MODE_CHANGE_SIZE;
2114
2115         if (hci_send_req(dd, &rq, to) < 0)
2116                 return -1;
2117
2118         if (rp.status) {
2119                 errno = EIO;
2120                 return -1;
2121         }
2122
2123         return 0;
2124 }
2125
2126 int hci_read_inquiry_scan_type(int dd, uint8_t *type, int to)
2127 {
2128         read_inquiry_scan_type_rp rp;
2129         struct hci_request rq;
2130
2131         memset(&rq, 0, sizeof(rq));
2132         rq.ogf    = OGF_HOST_CTL;
2133         rq.ocf    = OCF_READ_INQUIRY_SCAN_TYPE;
2134         rq.rparam = &rp;
2135         rq.rlen   = READ_INQUIRY_SCAN_TYPE_RP_SIZE;
2136
2137         if (hci_send_req(dd, &rq, to) < 0)
2138                 return -1;
2139
2140         if (rp.status) {
2141                 errno = EIO;
2142                 return -1;
2143         }
2144
2145         *type = rp.type;
2146         return 0;
2147 }
2148
2149 int hci_write_inquiry_scan_type(int dd, uint8_t type, int to)
2150 {
2151         write_inquiry_scan_type_cp cp;
2152         write_inquiry_scan_type_rp rp;
2153         struct hci_request rq;
2154
2155         memset(&cp, 0, sizeof(cp));
2156         cp.type = type;
2157
2158         memset(&rq, 0, sizeof(rq));
2159         rq.ogf    = OGF_HOST_CTL;
2160         rq.ocf    = OCF_WRITE_INQUIRY_SCAN_TYPE;
2161         rq.cparam = &cp;
2162         rq.clen   = WRITE_INQUIRY_SCAN_TYPE_CP_SIZE;
2163         rq.rparam = &rp;
2164         rq.rlen   = WRITE_INQUIRY_SCAN_TYPE_RP_SIZE;
2165
2166         if (hci_send_req(dd, &rq, to) < 0)
2167                 return -1;
2168
2169         if (rp.status) {
2170                 errno = EIO;
2171                 return -1;
2172         }
2173
2174         return 0;
2175 }
2176
2177 int hci_read_inquiry_mode(int dd, uint8_t *mode, int to)
2178 {
2179         read_inquiry_mode_rp rp;
2180         struct hci_request rq;
2181
2182         memset(&rq, 0, sizeof(rq));
2183         rq.ogf    = OGF_HOST_CTL;
2184         rq.ocf    = OCF_READ_INQUIRY_MODE;
2185         rq.rparam = &rp;
2186         rq.rlen   = READ_INQUIRY_MODE_RP_SIZE;
2187
2188         if (hci_send_req(dd, &rq, to) < 0)
2189                 return -1;
2190
2191         if (rp.status) {
2192                 errno = EIO;
2193                 return -1;
2194         }
2195
2196         *mode = rp.mode;
2197         return 0;
2198 }
2199
2200 int hci_write_inquiry_mode(int dd, uint8_t mode, int to)
2201 {
2202         write_inquiry_mode_cp cp;
2203         write_inquiry_mode_rp rp;
2204         struct hci_request rq;
2205
2206         memset(&cp, 0, sizeof(cp));
2207         cp.mode = mode;
2208
2209         memset(&rq, 0, sizeof(rq));
2210         rq.ogf    = OGF_HOST_CTL;
2211         rq.ocf    = OCF_WRITE_INQUIRY_MODE;
2212         rq.cparam = &cp;
2213         rq.clen   = WRITE_INQUIRY_MODE_CP_SIZE;
2214         rq.rparam = &rp;
2215         rq.rlen   = WRITE_INQUIRY_MODE_RP_SIZE;
2216
2217         if (hci_send_req(dd, &rq, to) < 0)
2218                 return -1;
2219
2220         if (rp.status) {
2221                 errno = EIO;
2222                 return -1;
2223         }
2224
2225         return 0;
2226 }
2227
2228 int hci_read_afh_mode(int dd, uint8_t *mode, int to)
2229 {
2230         read_afh_mode_rp rp;
2231         struct hci_request rq;
2232
2233         memset(&rq, 0, sizeof(rq));
2234         rq.ogf    = OGF_HOST_CTL;
2235         rq.ocf    = OCF_READ_AFH_MODE;
2236         rq.rparam = &rp;
2237         rq.rlen   = READ_AFH_MODE_RP_SIZE;
2238
2239         if (hci_send_req(dd, &rq, to) < 0)
2240                 return -1;
2241
2242         if (rp.status) {
2243                 errno = EIO;
2244                 return -1;
2245         }
2246
2247         *mode = rp.mode;
2248         return 0;
2249 }
2250
2251 int hci_write_afh_mode(int dd, uint8_t mode, int to)
2252 {
2253         write_afh_mode_cp cp;
2254         write_afh_mode_rp rp;
2255         struct hci_request rq;
2256
2257         memset(&cp, 0, sizeof(cp));
2258         cp.mode = mode;
2259
2260         memset(&rq, 0, sizeof(rq));
2261         rq.ogf    = OGF_HOST_CTL;
2262         rq.ocf    = OCF_WRITE_AFH_MODE;
2263         rq.cparam = &cp;
2264         rq.clen   = WRITE_AFH_MODE_CP_SIZE;
2265         rq.rparam = &rp;
2266         rq.rlen   = WRITE_AFH_MODE_RP_SIZE;
2267
2268         if (hci_send_req(dd, &rq, to) < 0)
2269                 return -1;
2270
2271         if (rp.status) {
2272                 errno = EIO;
2273                 return -1;
2274         }
2275
2276         return 0;
2277 }
2278
2279 int hci_read_ext_inquiry_response(int dd, uint8_t *fec, uint8_t *data, int to)
2280 {
2281         read_ext_inquiry_response_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_EXT_INQUIRY_RESPONSE;
2287         rq.rparam = &rp;
2288         rq.rlen   = READ_EXT_INQUIRY_RESPONSE_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         *fec = rp.fec;
2299         memcpy(data, rp.data, HCI_MAX_EIR_LENGTH);
2300
2301         return 0;
2302 }
2303
2304 int hci_write_ext_inquiry_response(int dd, uint8_t fec, uint8_t *data, int to)
2305 {
2306         write_ext_inquiry_response_cp cp;
2307         write_ext_inquiry_response_rp rp;
2308         struct hci_request rq;
2309
2310         memset(&cp, 0, sizeof(cp));
2311         cp.fec = fec;
2312         memcpy(cp.data, data, HCI_MAX_EIR_LENGTH);
2313
2314         memset(&rq, 0, sizeof(rq));
2315         rq.ogf    = OGF_HOST_CTL;
2316         rq.ocf    = OCF_WRITE_EXT_INQUIRY_RESPONSE;
2317         rq.cparam = &cp;
2318         rq.clen   = WRITE_EXT_INQUIRY_RESPONSE_CP_SIZE;
2319         rq.rparam = &rp;
2320         rq.rlen   = WRITE_EXT_INQUIRY_RESPONSE_RP_SIZE;
2321
2322         if (hci_send_req(dd, &rq, to) < 0)
2323                 return -1;
2324
2325         if (rp.status) {
2326                 errno = EIO;
2327                 return -1;
2328         }
2329
2330         return 0;
2331 }
2332
2333 int hci_read_simple_pairing_mode(int dd, uint8_t *mode, int to)
2334 {
2335         read_simple_pairing_mode_rp rp;
2336         struct hci_request rq;
2337
2338         memset(&rq, 0, sizeof(rq));
2339         rq.ogf    = OGF_HOST_CTL;
2340         rq.ocf    = OCF_READ_SIMPLE_PAIRING_MODE;
2341         rq.rparam = &rp;
2342         rq.rlen   = READ_SIMPLE_PAIRING_MODE_RP_SIZE;
2343
2344         if (hci_send_req(dd, &rq, to) < 0)
2345                 return -1;
2346
2347         if (rp.status) {
2348                 errno = EIO;
2349                 return -1;
2350         }
2351
2352         *mode = rp.mode;
2353         return 0;
2354 }
2355
2356 int hci_write_simple_pairing_mode(int dd, uint8_t mode, int to)
2357 {
2358         write_simple_pairing_mode_cp cp;
2359         write_simple_pairing_mode_rp rp;
2360         struct hci_request rq;
2361
2362         memset(&cp, 0, sizeof(cp));
2363         cp.mode = mode;
2364
2365         memset(&rq, 0, sizeof(rq));
2366         rq.ogf    = OGF_HOST_CTL;
2367         rq.ocf    = OCF_WRITE_SIMPLE_PAIRING_MODE;
2368         rq.cparam = &cp;
2369         rq.clen   = WRITE_SIMPLE_PAIRING_MODE_CP_SIZE;
2370         rq.rparam = &rp;
2371         rq.rlen   = WRITE_SIMPLE_PAIRING_MODE_RP_SIZE;
2372
2373         if (hci_send_req(dd, &rq, to) < 0)
2374                 return -1;
2375
2376         if (rp.status) {
2377                 errno = EIO;
2378                 return -1;
2379         }
2380
2381         return 0;
2382 }
2383
2384 int hci_read_local_oob_data(int dd, uint8_t *hash, uint8_t *randomizer, int to)
2385 {
2386         read_local_oob_data_rp rp;
2387         struct hci_request rq;
2388
2389         memset(&rq, 0, sizeof(rq));
2390         rq.ogf    = OGF_HOST_CTL;
2391         rq.ocf    = OCF_READ_LOCAL_OOB_DATA;
2392         rq.rparam = &rp;
2393         rq.rlen   = READ_LOCAL_OOB_DATA_RP_SIZE;
2394
2395         if (hci_send_req(dd, &rq, to) < 0)
2396                 return -1;
2397
2398         if (rp.status) {
2399                 errno = EIO;
2400                 return -1;
2401         }
2402
2403         memcpy(hash, rp.hash, 16);
2404         memcpy(randomizer, rp.randomizer, 16);
2405         return 0;
2406 }
2407
2408 int hci_read_inq_response_tx_power_level(int dd, int8_t *level, int to)
2409 {
2410         read_inq_response_tx_power_level_rp rp;
2411         struct hci_request rq;
2412
2413         memset(&rq, 0, sizeof(rq));
2414         rq.ogf    = OGF_HOST_CTL;
2415         rq.ocf    = OCF_READ_INQ_RESPONSE_TX_POWER_LEVEL;
2416         rq.rparam = &rp;
2417         rq.rlen   = READ_INQ_RESPONSE_TX_POWER_LEVEL_RP_SIZE;
2418
2419         if (hci_send_req(dd, &rq, to) < 0)
2420                 return -1;
2421
2422         if (rp.status) {
2423                 errno = EIO;
2424                 return -1;
2425         }
2426
2427         *level = rp.level;
2428         return 0;
2429 }
2430
2431 int hci_read_inquiry_transmit_power_level(int dd, int8_t *level, int to)
2432 {
2433         return hci_read_inq_response_tx_power_level(dd, level, to);
2434 }
2435
2436 int hci_write_inquiry_transmit_power_level(int dd, int8_t level, int to)
2437 {
2438         write_inquiry_transmit_power_level_cp cp;
2439         write_inquiry_transmit_power_level_rp rp;
2440         struct hci_request rq;
2441
2442         memset(&cp, 0, sizeof(cp));
2443         cp.level = level;
2444
2445         memset(&rq, 0, sizeof(rq));
2446         rq.ogf    = OGF_HOST_CTL;
2447         rq.ocf    = OCF_WRITE_INQUIRY_TRANSMIT_POWER_LEVEL;
2448         rq.cparam = &cp;
2449         rq.clen   = WRITE_INQUIRY_TRANSMIT_POWER_LEVEL_CP_SIZE;
2450         rq.rparam = &rp;
2451         rq.rlen   = WRITE_INQUIRY_TRANSMIT_POWER_LEVEL_RP_SIZE;
2452
2453         if (hci_send_req(dd, &rq, to) < 0)
2454                 return -1;
2455
2456         if (rp.status) {
2457                 errno = EIO;
2458                 return -1;
2459         }
2460
2461         return 0;
2462 }
2463
2464 int hci_read_transmit_power_level(int dd, uint16_t handle, uint8_t type,
2465                                         int8_t *level, int to)
2466 {
2467         read_transmit_power_level_cp cp;
2468         read_transmit_power_level_rp rp;
2469         struct hci_request rq;
2470
2471         memset(&cp, 0, sizeof(cp));
2472         cp.handle = handle;
2473         cp.type   = type;
2474
2475         memset(&rq, 0, sizeof(rq));
2476         rq.ogf    = OGF_HOST_CTL;
2477         rq.ocf    = OCF_READ_TRANSMIT_POWER_LEVEL;
2478         rq.cparam = &cp;
2479         rq.clen   = READ_TRANSMIT_POWER_LEVEL_CP_SIZE;
2480         rq.rparam = &rp;
2481         rq.rlen   = READ_TRANSMIT_POWER_LEVEL_RP_SIZE;
2482
2483         if (hci_send_req(dd, &rq, to) < 0)
2484                 return -1;
2485
2486         if (rp.status) {
2487                 errno = EIO;
2488                 return -1;
2489         }
2490
2491         *level = rp.level;
2492         return 0;
2493 }
2494
2495 int hci_read_link_policy(int dd, uint16_t handle, uint16_t *policy, int to)
2496 {
2497         read_link_policy_rp rp;
2498         struct hci_request rq;
2499
2500         memset(&rq, 0, sizeof(rq));
2501         rq.ogf    = OGF_LINK_POLICY;
2502         rq.ocf    = OCF_READ_LINK_POLICY;
2503         rq.cparam = &handle;
2504         rq.clen   = 2;
2505         rq.rparam = &rp;
2506         rq.rlen   = READ_LINK_POLICY_RP_SIZE;
2507
2508         if (hci_send_req(dd, &rq, to) < 0)
2509                 return -1;
2510
2511         if (rp.status) {
2512                 errno = EIO;
2513                 return -1;
2514         }
2515
2516         *policy = rp.policy;
2517         return 0;
2518 }
2519
2520 int hci_write_link_policy(int dd, uint16_t handle, uint16_t policy, int to)
2521 {
2522         write_link_policy_cp cp;
2523         write_link_policy_rp rp;
2524         struct hci_request rq;
2525
2526         memset(&cp, 0, sizeof(cp));
2527         cp.handle = handle;
2528         cp.policy = policy;
2529
2530         memset(&rq, 0, sizeof(rq));
2531         rq.ogf    = OGF_LINK_POLICY;
2532         rq.ocf    = OCF_WRITE_LINK_POLICY;
2533         rq.cparam = &cp;
2534         rq.clen   = WRITE_LINK_POLICY_CP_SIZE;
2535         rq.rparam = &rp;
2536         rq.rlen   = WRITE_LINK_POLICY_RP_SIZE;
2537
2538         if (hci_send_req(dd, &rq, to) < 0)
2539                 return -1;
2540
2541         if (rp.status) {
2542                 errno = EIO;
2543                 return -1;
2544         }
2545
2546         return 0;
2547 }
2548
2549 int hci_read_link_supervision_timeout(int dd, uint16_t handle,
2550                                         uint16_t *timeout, int to)
2551 {
2552         read_link_supervision_timeout_rp rp;
2553         struct hci_request rq;
2554
2555         memset(&rq, 0, sizeof(rq));
2556         rq.ogf    = OGF_HOST_CTL;
2557         rq.ocf    = OCF_READ_LINK_SUPERVISION_TIMEOUT;
2558         rq.cparam = &handle;
2559         rq.clen   = 2;
2560         rq.rparam = &rp;
2561         rq.rlen   = READ_LINK_SUPERVISION_TIMEOUT_RP_SIZE;
2562
2563         if (hci_send_req(dd, &rq, to) < 0)
2564                 return -1;
2565
2566         if (rp.status) {
2567                 errno = EIO;
2568                 return -1;
2569         }
2570
2571         *timeout = rp.timeout;
2572         return 0;
2573 }
2574
2575 int hci_write_link_supervision_timeout(int dd, uint16_t handle,
2576                                         uint16_t timeout, int to)
2577 {
2578         write_link_supervision_timeout_cp cp;
2579         write_link_supervision_timeout_rp rp;
2580         struct hci_request rq;
2581
2582         memset(&cp, 0, sizeof(cp));
2583         cp.handle  = handle;
2584         cp.timeout = timeout;
2585
2586         memset(&rq, 0, sizeof(rq));
2587         rq.ogf    = OGF_HOST_CTL;
2588         rq.ocf    = OCF_WRITE_LINK_SUPERVISION_TIMEOUT;
2589         rq.cparam = &cp;
2590         rq.clen   = WRITE_LINK_SUPERVISION_TIMEOUT_CP_SIZE;
2591         rq.rparam = &rp;
2592         rq.rlen   = WRITE_LINK_SUPERVISION_TIMEOUT_RP_SIZE;
2593
2594         if (hci_send_req(dd, &rq, to) < 0)
2595                 return -1;
2596
2597         if (rp.status) {
2598                 errno = EIO;
2599                 return -1;
2600         }
2601
2602         return 0;
2603 }
2604
2605 int hci_set_afh_classification(int dd, uint8_t *map, int to)
2606 {
2607         set_afh_classification_cp cp;
2608         set_afh_classification_rp rp;
2609         struct hci_request rq;
2610
2611         memset(&cp, 0, sizeof(cp));
2612         memcpy(cp.map, map, 10);
2613
2614         memset(&rq, 0, sizeof(rq));
2615         rq.ogf    = OGF_HOST_CTL;
2616         rq.ocf    = OCF_SET_AFH_CLASSIFICATION;
2617         rq.cparam = &cp;
2618         rq.clen   = SET_AFH_CLASSIFICATION_CP_SIZE;
2619         rq.rparam = &rp;
2620         rq.rlen   = SET_AFH_CLASSIFICATION_RP_SIZE;
2621
2622         if (hci_send_req(dd, &rq, to) < 0)
2623                 return -1;
2624
2625         if (rp.status) {
2626                 errno = EIO;
2627                 return -1;
2628         }
2629
2630         return 0;
2631 }
2632
2633 int hci_read_link_quality(int dd, uint16_t handle, uint8_t *link_quality,
2634                                 int to)
2635 {
2636         read_link_quality_rp rp;
2637         struct hci_request rq;
2638
2639         memset(&rq, 0, sizeof(rq));
2640         rq.ogf    = OGF_STATUS_PARAM;
2641         rq.ocf    = OCF_READ_LINK_QUALITY;
2642         rq.cparam = &handle;
2643         rq.clen   = 2;
2644         rq.rparam = &rp;
2645         rq.rlen   = READ_LINK_QUALITY_RP_SIZE;
2646
2647         if (hci_send_req(dd, &rq, to) < 0)
2648                 return -1;
2649
2650         if (rp.status) {
2651                 errno = EIO;
2652                 return -1;
2653         }
2654
2655         *link_quality = rp.link_quality;
2656         return 0;
2657 }
2658
2659 int hci_read_rssi(int dd, uint16_t handle, int8_t *rssi, int to)
2660 {
2661         read_rssi_rp rp;
2662         struct hci_request rq;
2663
2664         memset(&rq, 0, sizeof(rq));
2665         rq.ogf    = OGF_STATUS_PARAM;
2666         rq.ocf    = OCF_READ_RSSI;
2667         rq.cparam = &handle;
2668         rq.clen   = 2;
2669         rq.rparam = &rp;
2670         rq.rlen   = READ_RSSI_RP_SIZE;
2671
2672         if (hci_send_req(dd, &rq, to) < 0)
2673                 return -1;
2674
2675         if (rp.status) {
2676                 errno = EIO;
2677                 return -1;
2678         }
2679
2680         *rssi = rp.rssi;
2681         return 0;
2682 }
2683
2684 int hci_read_afh_map(int dd, uint16_t handle, uint8_t *mode, uint8_t *map,
2685                         int to)
2686 {
2687         read_afh_map_rp rp;
2688         struct hci_request rq;
2689
2690         memset(&rq, 0, sizeof(rq));
2691         rq.ogf    = OGF_STATUS_PARAM;
2692         rq.ocf    = OCF_READ_AFH_MAP;
2693         rq.cparam = &handle;
2694         rq.clen   = 2;
2695         rq.rparam = &rp;
2696         rq.rlen   = READ_AFH_MAP_RP_SIZE;
2697
2698         if (hci_send_req(dd, &rq, to) < 0)
2699                 return -1;
2700
2701         if (rp.status) {
2702                 errno = EIO;
2703                 return -1;
2704         }
2705
2706         *mode = rp.mode;
2707         memcpy(map, rp.map, 10);
2708         return 0;
2709 }
2710
2711 int hci_read_clock(int dd, uint16_t handle, uint8_t which, uint32_t *clock,
2712                         uint16_t *accuracy, int to)
2713 {
2714         read_clock_cp cp;
2715         read_clock_rp rp;
2716         struct hci_request rq;
2717
2718         memset(&cp, 0, sizeof(cp));
2719         cp.handle      = handle;
2720         cp.which_clock = which;
2721
2722         memset(&rq, 0, sizeof(rq));
2723         rq.ogf    = OGF_STATUS_PARAM;
2724         rq.ocf    = OCF_READ_CLOCK;
2725         rq.cparam = &cp;
2726         rq.clen   = READ_CLOCK_CP_SIZE;
2727         rq.rparam = &rp;
2728         rq.rlen   = READ_CLOCK_RP_SIZE;
2729
2730         if (hci_send_req(dd, &rq, to) < 0)
2731                 return -1;
2732
2733         if (rp.status) {
2734                 errno = EIO;
2735                 return -1;
2736         }
2737
2738         *clock    = rp.clock;
2739         *accuracy = rp.accuracy;
2740         return 0;
2741 }
2742
2743 int hci_le_set_scan_enable(int dd, uint8_t enable, uint8_t filter_dup, int to)
2744 {
2745         struct hci_request rq;
2746         le_set_scan_enable_cp scan_cp;
2747         uint8_t status;
2748
2749         memset(&scan_cp, 0, sizeof(scan_cp));
2750         scan_cp.enable = enable;
2751         scan_cp.filter_dup = filter_dup;
2752
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;
2759         rq.rlen = 1;
2760
2761         if (hci_send_req(dd, &rq, to) < 0)
2762                 return -1;
2763
2764         if (status) {
2765                 errno = EIO;
2766                 return -1;
2767         }
2768
2769         return 0;
2770 }
2771
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)
2775 {
2776         struct hci_request rq;
2777         le_set_scan_parameters_cp param_cp;
2778         uint8_t status;
2779
2780         memset(&param_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;
2786
2787         memset(&rq, 0, sizeof(rq));
2788         rq.ogf = OGF_LE_CTL;
2789         rq.ocf = OCF_LE_SET_SCAN_PARAMETERS;
2790         rq.cparam = &param_cp;
2791         rq.clen = LE_SET_SCAN_PARAMETERS_CP_SIZE;
2792         rq.rparam = &status;
2793         rq.rlen = 1;
2794
2795         if (hci_send_req(dd, &rq, to) < 0)
2796                 return -1;
2797
2798         if (status) {
2799                 errno = EIO;
2800                 return -1;
2801         }
2802
2803         return 0;
2804 }
2805
2806 int hci_le_set_advertise_enable(int dd, uint8_t enable, int to)
2807 {
2808         struct hci_request rq;
2809         le_set_advertise_enable_cp adv_cp;
2810         uint8_t status;
2811
2812         memset(&adv_cp, 0, sizeof(adv_cp));
2813         adv_cp.enable = enable;
2814
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;
2821         rq.rlen = 1;
2822
2823         if (hci_send_req(dd, &rq, to) < 0)
2824                 return -1;
2825
2826         if (status) {
2827                 errno = EIO;
2828                 return -1;
2829         }
2830
2831         return 0;
2832 }
2833
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)
2841 {
2842         struct hci_request rq;
2843         le_create_connection_cp create_conn_cp;
2844         evt_le_connection_complete conn_complete_rp;
2845
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;
2859
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;
2868
2869         if (hci_send_req(dd, &rq, to) < 0)
2870                 return -1;
2871
2872         if (conn_complete_rp.status) {
2873                 errno = EIO;
2874                 return -1;
2875         }
2876
2877         if (handle)
2878                 *handle = conn_complete_rp.handle;
2879
2880         return 0;
2881 }
2882
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)
2886 {
2887         evt_le_connection_update_complete evt;
2888         le_connection_update_cp cp;
2889         struct hci_request rq;
2890
2891         memset(&cp, 0, sizeof(cp));
2892         cp.handle = handle;
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);
2899
2900         memset(&rq, 0, sizeof(rq));
2901         rq.ogf = OGF_LE_CTL;
2902         rq.ocf = OCF_LE_CONN_UPDATE;
2903         rq.cparam = &cp;
2904         rq.clen = LE_CONN_UPDATE_CP_SIZE;
2905         rq.event = EVT_LE_CONN_UPDATE_COMPLETE;
2906         rq.rparam = &evt;
2907         rq.rlen = sizeof(evt);
2908
2909         if (hci_send_req(dd, &rq, to) < 0)
2910                 return -1;
2911
2912         if (evt.status) {
2913                 errno = EIO;
2914                 return -1;
2915         }
2916
2917         return 0;
2918 }