Tizen 2.0 Release
[profile/ivi/bluez.git] / 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 }