hci.c

Go to the documentation of this file.

/*
 *
 *  BlueZ - Bluetooth protocol stack for Linux
 *
 *  Copyright (C) 2000-2001  Qualcomm Incorporated
 *  Copyright (C) 2002-2003  Maxim Krasnyansky <maxk@qualcomm.com>
 *  Copyright (C) 2002-2010  Marcel Holtmann <marcel@holtmann.org>
 *
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include <stdio.h>
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <poll.h>

#include <sys/param.h>
#include <sys/uio.h>
#include <sys/types.h>
#include <sys/ioctl.h>
#include <sys/socket.h>

#include "bluetooth.h"
#include "hci.h"
#include "hci_lib.h"

#ifndef MIN
#define MIN(x, y) ((x) < (y) ? (x) : (y))
#endif

typedef struct {
    char *str;
    unsigned int val;
} hci_map;

static char *hci_bit2str(hci_map *m, unsigned int val)
{
    char *str = malloc(120);
    char *ptr = str;

    if (!str)
        return NULL;

    *ptr = 0;
    while (m->str) {
        if ((unsigned int) m->val & val)
            ptr += sprintf(ptr, "%s ", m->str);
        m++;
    }
    return str;
}
static int hci_str2bit(hci_map *map, char *str, unsigned int *val)
{
    char *t, *ptr;
    hci_map *m;
    int set;

    if (!str || !(str = ptr = strdup(str)))
        return 0;

    *val = set = 0;

    while ((t = strsep(&ptr, ","))) {
        for (m = map; m->str; m++) {
            if (!strcasecmp(m->str, t)) {
                *val |= (unsigned int) m->val;
                set = 1;
            }
        }
    }
    free(str);

    return set;
}

static char *hci_uint2str(hci_map *m, unsigned int val)
{
    char *str = malloc(50);
    char *ptr = str;

    if (!str)
        return NULL;

    *ptr = 0;
    while (m->str) {
        if ((unsigned int) m->val == val) {
            ptr += sprintf(ptr, "%s", m->str);
            break;
        }
        m++;
    }
    return str;
}

static int hci_str2uint(hci_map *map, char *str, unsigned int *val)
{
    char *t, *ptr;
    hci_map *m;
    int set = 0;

    if (!str)
        return 0;

    str = ptr = strdup(str);

    while ((t = strsep(&ptr, ","))) {
        for (m = map; m->str; m++) {
            if (!strcasecmp(m->str,t)) {
                *val = (unsigned int) m->val;
                set = 1;
                break;
            }
        }
    }
    free(str);

    return set;
}

char *hci_bustostr(int bus)
{
    switch (bus) {
    case HCI_VIRTUAL:
        return "VIRTUAL";
    case HCI_USB:
        return "USB";
    case HCI_PCCARD:
        return "PCCARD";
    case HCI_UART:
        return "UART";
    case HCI_RS232:
        return "RS232";
    case HCI_PCI:
        return "PCI";
    case HCI_SDIO:
        return "SDIO";
    default:
        return "UNKNOWN";
    }
}

char *hci_dtypetostr(int type)
{
    return hci_bustostr(type & 0x0f);
}

char *hci_typetostr(int type)
{
    switch (type) {
    case HCI_BREDR:
        return "BR/EDR";
    case HCI_AMP:
        return "AMP";
    default:
        return "UNKNOWN";
    }
}

/* HCI dev flags mapping */
static hci_map dev_flags_map[] = {
    { "UP",      HCI_UP      },
    { "INIT",    HCI_INIT    },
    { "RUNNING", HCI_RUNNING },
    { "RAW",     HCI_RAW     },
    { "PSCAN",   HCI_PSCAN   },
    { "ISCAN",   HCI_ISCAN   },
    { "INQUIRY", HCI_INQUIRY },
    { "AUTH",    HCI_AUTH    },
    { "ENCRYPT", HCI_ENCRYPT },
    { NULL }
};

char *hci_dflagstostr(uint32_t flags)
{
    char *str = bt_malloc(50);
    char *ptr = str;
    hci_map *m = dev_flags_map;

    if (!str)
        return NULL;

    *ptr = 0;

    if (!hci_test_bit(HCI_UP, &flags))
        ptr += sprintf(ptr, "DOWN ");

    while (m->str) {
        if (hci_test_bit(m->val, &flags))
            ptr += sprintf(ptr, "%s ", m->str);
        m++;
    }
    return str;
}

/* HCI packet type mapping */
static hci_map pkt_type_map[] = {
    { "DM1",   HCI_DM1  },
    { "DM3",   HCI_DM3  },
    { "DM5",   HCI_DM5  },
    { "DH1",   HCI_DH1  },
    { "DH3",   HCI_DH3  },
    { "DH5",   HCI_DH5  },
    { "HV1",   HCI_HV1  },
    { "HV2",   HCI_HV2  },
    { "HV3",   HCI_HV3  },
    { "2-DH1", HCI_2DH1 },
    { "2-DH3", HCI_2DH3 },
    { "2-DH5", HCI_2DH5 },
    { "3-DH1", HCI_3DH1 },
    { "3-DH3", HCI_3DH3 },
    { "3-DH5", HCI_3DH5 },
    { NULL }
};

/* SCO (synchronous connection orientated) links */
static hci_map sco_ptype_map[] = {
    { "HV1",   0x0001   },
    { "HV2",   0x0002   },
    { "HV3",   0x0004   },
    { "EV3",   HCI_EV3  },
    { "EV4",   HCI_EV4  },
    { "EV5",   HCI_EV5  },
    { "2-EV3", HCI_2EV3 },
    { "2-EV5", HCI_2EV5 },
    { "3-EV3", HCI_3EV3 },
    { "3-EV5", HCI_3EV5 },
    { NULL }
};

char *hci_ptypetostr(unsigned int ptype)
{
    return hci_bit2str(pkt_type_map, ptype);
}

int hci_strtoptype(char *str, unsigned int *val)
{
    return hci_str2bit(pkt_type_map, str, val);
}

char *hci_scoptypetostr(unsigned int ptype)
{
    return hci_bit2str(sco_ptype_map, ptype);
}

int hci_strtoscoptype(char *str, unsigned int *val)
{
    return hci_str2bit(sco_ptype_map, str, val);
}

/* Link policy mapping */
static hci_map link_policy_map[] = {
    { "NONE",   0       },
    { "RSWITCH",    HCI_LP_RSWITCH  },
    { "HOLD",   HCI_LP_HOLD },
    { "SNIFF",  HCI_LP_SNIFF    },
    { "PARK",   HCI_LP_PARK },
    { NULL }
};

char *hci_lptostr(unsigned int lp)
{
    return hci_bit2str(link_policy_map, lp);
}

int hci_strtolp(char *str, unsigned int *val)
{
    return hci_str2bit(link_policy_map, str, val);
}

/* Link mode mapping */
static hci_map link_mode_map[] = {
    { "NONE",   0       },
    { "ACCEPT", HCI_LM_ACCEPT   },
    { "MASTER", HCI_LM_MASTER   },
    { "AUTH",   HCI_LM_AUTH },
    { "ENCRYPT",    HCI_LM_ENCRYPT  },
    { "TRUSTED",    HCI_LM_TRUSTED  },
    { "RELIABLE",   HCI_LM_RELIABLE },
    { "SECURE", HCI_LM_SECURE   },
    { NULL }
};

char *hci_lmtostr(unsigned int lm)
{
    char *s, *str = bt_malloc(50);
    if (!str)
        return NULL;

    *str = 0;
    if (!(lm & HCI_LM_MASTER))
        strcpy(str, "SLAVE ");

    s = hci_bit2str(link_mode_map, lm);
    if (!s) {
        bt_free(str);
        return NULL;
    }

    strcat(str, s);
    free(s);
    return str;
}

int hci_strtolm(char *str, unsigned int *val)
{
    return hci_str2bit(link_mode_map, str, val);
}

/* Command mapping */
static hci_map commands_map[] = {
    { "Inquiry",                    0   },
    { "Inquiry Cancel",             1   },
    { "Periodic Inquiry Mode",          2   },
    { "Exit Periodic Inquiry Mode",         3   },
    { "Create Connection",              4   },
    { "Disconnect",                 5   },
    { "Add SCO Connection",             6   },
    { "Cancel Create Connection",           7   },

    { "Accept Connection Request",          8   },
    { "Reject Connection Request",          9   },
    { "Link Key Request Reply",         10  },
    { "Link Key Request Negative Reply",        11  },
    { "PIN Code Request Reply",         12  },
    { "PIN Code Request Negative Reply",        13  },
    { "Change Connection Packet Type",      14  },
    { "Authentication Requested",           15  },

    { "Set Connection Encryption",          16  },
    { "Change Connection Link Key",         17  },
    { "Master Link Key",                18  },
    { "Remote Name Request",            19  },
    { "Cancel Remote Name Request",         20  },
    { "Read Remote Supported Features",     21  },
    { "Read Remote Extended Features",      22  },
    { "Read Remote Version Information",        23  },

    { "Read Clock Offset",              24  },
    { "Read LMP Handle",                25  },
    { "Reserved",                   26  },
    { "Reserved",                   27  },
    { "Reserved",                   28  },
    { "Reserved",                   29  },
    { "Reserved",                   30  },
    { "Reserved",                   31  },

    { "Reserved",                   32  },
    { "Hold Mode",                  33  },
    { "Sniff Mode",                 34  },
    { "Exit Sniff Mode",                35  },
    { "Park State",                 36  },
    { "Exit Park State",                37  },
    { "QoS Setup",                  38  },
    { "Role Discovery",             39  },

    { "Switch Role",                40  },
    { "Read Link Policy Settings",          41  },
    { "Write Link Policy Settings",         42  },
    { "Read Default Link Policy Settings",      43  },
    { "Write Default Link Policy Settings",     44  },
    { "Flow Specification",             45  },
    { "Set Event Mask",             46  },
    { "Reset",                  47  },

    { "Set Event Filter",               48  },
    { "Flush",                  49  },
    { "Read PIN Type",              50  },
    { "Write PIN Type",             51  },
    { "Create New Unit Key",            52  },
    { "Read Stored Link Key",           53  },
    { "Write Stored Link Key",          54  },
    { "Delete Stored Link Key",         55  },

    { "Write Local Name",               56  },
    { "Read Local Name",                57  },
    { "Read Connection Accept Timeout",     58  },
    { "Write Connection Accept Timeout",        59  },
    { "Read Page Timeout",              60  },
    { "Write Page Timeout",             61  },
    { "Read Scan Enable",               62  },
    { "Write Scan Enable",              63  },

    { "Read Page Scan Activity",            64  },
    { "Write Page Scan Activity",           65  },
    { "Read Inquiry Scan Activity",         66  },
    { "Write Inquiry Scan Activity",        67  },
    { "Read Authentication Enable",         68  },
    { "Write Authentication Enable",        69  },
    { "Read Encryption Mode",           70  },
    { "Write Encryption Mode",          71  },

    { "Read Class Of Device",           72  },
    { "Write Class Of Device",          73  },
    { "Read Voice Setting",             74  },
    { "Write Voice Setting",            75  },
    { "Read Automatic Flush Timeout",       76  },
    { "Write Automatic Flush Timeout",      77  },
    { "Read Num Broadcast Retransmissions",     78  },
    { "Write Num Broadcast Retransmissions",    79  },

    { "Read Hold Mode Activity",            80  },
    { "Write Hold Mode Activity",           81  },
    { "Read Transmit Power Level",          82  },
    { "Read Synchronous Flow Control Enable",   83  },
    { "Write Synchronous Flow Control Enable",  84  },
    { "Set Host Controller To Host Flow Control",   85  },
    { "Host Buffer Size",               86  },
    { "Host Number Of Completed Packets",       87  },

    { "Read Link Supervision Timeout",      88  },
    { "Write Link Supervision Timeout",     89  },
    { "Read Number of Supported IAC",       90  },
    { "Read Current IAC LAP",           91  },
    { "Write Current IAC LAP",          92  },
    { "Read Page Scan Period Mode",         93  },
    { "Write Page Scan Period Mode",        94  },
    { "Read Page Scan Mode",            95  },

    { "Write Page Scan Mode",           96  },
    { "Set AFH Channel Classification",     97  },
    { "Reserved",                   98  },
    { "Reserved",                   99  },
    { "Read Inquiry Scan Type",         100 },
    { "Write Inquiry Scan Type",            101 },
    { "Read Inquiry Mode",              102 },
    { "Write Inquiry Mode",             103 },

    { "Read Page Scan Type",            104 },
    { "Write Page Scan Type",           105 },
    { "Read AFH Channel Assessment Mode",       106 },
    { "Write AFH Channel Assessment Mode",      107 },
    { "Reserved",                   108 },
    { "Reserved",                   109 },
    { "Reserved",                   110 },
    { "Reserved",                   111 },

    { "Reserved",                   112 },
    { "Reserved",                   113 },
    { "Reserved",                   114 },
    { "Read Local Version Information",     115 },
    { "Read Local Supported Commands",      116 },
    { "Read Local Supported Features",      117 },
    { "Read Local Extended Features",       118 },
    { "Read Buffer Size",               119 },

    { "Read Country Code",              120 },
    { "Read BD ADDR",               121 },
    { "Read Failed Contact Counter",        122 },
    { "Reset Failed Contact Counter",       123 },
    { "Get Link Quality",               124 },
    { "Read RSSI",                  125 },
    { "Read AFH Channel Map",           126 },
    { "Read BD Clock",              127 },

    { "Read Loopback Mode",             128 },
    { "Write Loopback Mode",            129 },
    { "Enable Device Under Test Mode",      130 },
    { "Setup Synchronous Connection",       131 },
    { "Accept Synchronous Connection",      132 },
    { "Reject Synchronous Connection",      133 },
    { "Reserved",                   134 },
    { "Reserved",                   135 },

    { "Read Extended Inquiry Response",     136 },
    { "Write Extended Inquiry Response",        137 },
    { "Refresh Encryption Key",         138 },
    { "Reserved",                   139 },
    { "Sniff Subrating",                140 },
    { "Read Simple Pairing Mode",           141 },
    { "Write Simple Pairing Mode",          142 },
    { "Read Local OOB Data",            143 },

    { "Read Inquiry Response Transmit Power Level", 144 },
    { "Write Inquiry Transmit Power Level",     145 },
    { "Read Default Erroneous Data Reporting",  146 },
    { "Write Default Erroneous Data Reporting", 147 },
    { "Reserved",                   148 },
    { "Reserved",                   149 },
    { "Reserved",                   150 },
    { "IO Capability Request Reply",        151 },

    { "User Confirmation Request Reply",        152 },
    { "User Confirmation Request Negative Reply",   153 },
    { "User Passkey Request Reply",         154 },
    { "User Passkey Request Negative Reply",    155 },
    { "Remote OOB Data Request Reply",      156 },
    { "Write Simple Pairing Debug Mode",        157 },
    { "Enhanced Flush",             158 },
    { "Remote OOB Data Request Negative Reply", 159 },

    { "Reserved",                   160 },
    { "Reserved",                   161 },
    { "Send Keypress Notification",         162 },
    { "IO Capability Request Negative Reply",   163 },
    { "Read Encryption Key Size",           164 },
    { "Reserved",                   165 },
    { "Reserved",                   166 },
    { "Reserved",                   167 },

    { "Create Physical Link",           168 },
    { "Accept Physical Link",           169 },
    { "Disconnect Physical Link",           170 },
    { "Create Logical Link",            171 },
    { "Accept Logical Link",            172 },
    { "Disconnect Logical Link",            173 },
    { "Logical Link Cancel",            174 },
    { "Flow Specification Modify",          175 },

    { "Read Logical Link Accept Timeout",       176 },
    { "Write Logical Link Accept Timeout",      177 },
    { "Set Event Mask Page 2",          178 },
    { "Read Location Data",             179 },
    { "Write Location Data",            180 },
    { "Read Local AMP Info",            181 },
    { "Read Local AMP_ASSOC",           182 },
    { "Write Remote AMP_ASSOC",         183 },

    { "Read Flow Control Mode",         184 },
    { "Write Flow Control Mode",            185 },
    { "Read Data Block Size",           186 },
    { "Reserved",                   187 },
    { "Reserved",                   188 },
    { "Enable AMP Receiver Reports",        189 },
    { "AMP Test End",               190 },
    { "AMP Test Command",               191 },

    { "Read Enhanced Transmit Power Level",     192 },
    { "Reserved",                   193 },
    { "Read Best Effort Flush Timeout",     194 },
    { "Write Best Effort Flush Timeout",        195 },
    { "Short Range Mode",               196 },
    { "Read LE Host Support",           197 },
    { "Write LE Host Support",          198 },
    { "Reserved",                   199 },

    { "LE Set Event Mask",              200 },
    { "LE Read Buffer Size",            201 },
    { "LE Read Local Supported Features",       202 },
    { "Reserved",                   203 },
    { "LE Set Random Address",          204 },
    { "LE Set Advertising Parameters",      205 },
    { "LE Read Advertising Channel TX Power",   206 },
    { "LE Set Advertising Data",            207 },

    { "LE Set Scan Response Data",          208 },
    { "LE Set Advertise Enable",            209 },
    { "LE Set Scan Parameters",         210 },
    { "LE Set Scan Enable",             211 },
    { "LE Create Connection",           212 },
    { "LE Create Connection Cancel",        213 },
    { "LE Read White List Size",            214 },
    { "LE Clear White List",            215 },

    { "LE Add Device To White List",        216 },
    { "LE Remove Device From White List",       217 },
    { "LE Connection Update",           218 },
    { "LE Set Host Channel Classification",     219 },
    { "LE Read Channel Map",            220 },
    { "LE Read Remote Used Features",       221 },
    { "LE Encrypt",                 222 },
    { "LE Rand",                    223 },

    { "LE Start Encryption",            224 },
    { "LE Long Term Key Request Reply",     225 },
    { "LE Long Term Key Request Negative Reply",    226 },
    { "LE Read Supported States",           227 },
    { "LE Receiver Test",               228 },
    { "LE Transmitter Test",            229 },
    { "LE Test End",                230 },
    { "Reserved",                   231 },

    { NULL }
};

char *hci_cmdtostr(unsigned int cmd)
{
    return hci_uint2str(commands_map, cmd);
}

char *hci_commandstostr(uint8_t *commands, char *pref, int width)
{
    unsigned int maxwidth = width - 3;
    hci_map *m;
    char *off, *ptr, *str;
    int size = 10;

    m = commands_map;

    while (m->str) {
        if (commands[m->val / 8] & (1 << (m->val % 8)))
            size += strlen(m->str) + (pref ? strlen(pref) : 0) + 3;
        m++;
    }

    str = bt_malloc(size);
    if (!str)
        return NULL;

    ptr = str; *ptr = '\0';

    if (pref)
        ptr += sprintf(ptr, "%s", pref);

    off = ptr;

    m = commands_map;

    while (m->str) {
        if (commands[m->val / 8] & (1 << (m->val % 8))) {
            if (strlen(off) + strlen(m->str) > maxwidth) {
                ptr += sprintf(ptr, "\n%s", pref ? pref : "");
                off = ptr;
            }
            ptr += sprintf(ptr, "'%s' ", m->str);
        }
        m++;
    }

    return str;
}

/* Version mapping */
static hci_map ver_map[] = {
    { "1.0b",   0x00 },
    { "1.1",    0x01 },
    { "1.2",    0x02 },
    { "2.0",    0x03 },
    { "2.1",    0x04 },
    { "3.0",    0x05 },
    { "4.0",    0x06 },
    { "4.1",    0x07 },
    { "4.2",    0x08 },
    { NULL }
};

char *hci_vertostr(unsigned int ver)
{
    return hci_uint2str(ver_map, ver);
}

int hci_strtover(char *str, unsigned int *ver)
{
    return hci_str2uint(ver_map, str, ver);
}

char *lmp_vertostr(unsigned int ver)
{
    return hci_uint2str(ver_map, ver);
}

int lmp_strtover(char *str, unsigned int *ver)
{
    return hci_str2uint(ver_map, str, ver);
}

static hci_map pal_map[] = {
    { "3.0",    0x01 },
    { NULL }
};

char *pal_vertostr(unsigned int ver)
{
    return hci_uint2str(pal_map, ver);
}

int pal_strtover(char *str, unsigned int *ver)
{
    return hci_str2uint(pal_map, str, ver);
}

/* LMP features mapping */
static hci_map lmp_features_map[8][9] = {
    {   /* Byte 0 */
        { "<3-slot packets>",   LMP_3SLOT   },  /* Bit 0 */
        { "<5-slot packets>",   LMP_5SLOT   },  /* Bit 1 */
        { "<encryption>",   LMP_ENCRYPT },  /* Bit 2 */
        { "<slot offset>",  LMP_SOFFSET },  /* Bit 3 */
        { "<timing accuracy>",  LMP_TACCURACY   },  /* Bit 4 */
        { "<role switch>",  LMP_RSWITCH },  /* Bit 5 */
        { "<hold mode>",    LMP_HOLD    },  /* Bit 6 */
        { "<sniff mode>",   LMP_SNIFF   },  /* Bit 7 */
        { NULL }
    },
    {   /* Byte 1 */
        { "<park state>",   LMP_PARK    },  /* Bit 0 */
        { "<RSSI>",     LMP_RSSI    },  /* Bit 1 */
        { "<channel quality>",  LMP_QUALITY },  /* Bit 2 */
        { "<SCO link>",     LMP_SCO     },  /* Bit 3 */
        { "<HV2 packets>",  LMP_HV2     },  /* Bit 4 */
        { "<HV3 packets>",  LMP_HV3     },  /* Bit 5 */
        { "<u-law log>",    LMP_ULAW    },  /* Bit 6 */
        { "<A-law log>",    LMP_ALAW    },  /* Bit 7 */
        { NULL }
    },
    {   /* Byte 2 */
        { "<CVSD>",     LMP_CVSD    },  /* Bit 0 */
        { "<paging scheme>",    LMP_PSCHEME },  /* Bit 1 */
        { "<power control>",    LMP_PCONTROL    },  /* Bit 2 */
        { "<transparent SCO>",  LMP_TRSP_SCO    },  /* Bit 3 */
        { "<broadcast encrypt>",LMP_BCAST_ENC   },  /* Bit 7 */
        { NULL }
    },
    {   /* Byte 3 */
        { "<no. 24>",       0x01        },  /* Bit 0 */
        { "<EDR ACL 2 Mbps>",   LMP_EDR_ACL_2M  },  /* Bit 1 */
        { "<EDR ACL 3 Mbps>",   LMP_EDR_ACL_3M  },  /* Bit 2 */
        { "<enhanced iscan>",   LMP_ENH_ISCAN   },  /* Bit 3 */
        { "<interlaced iscan>", LMP_ILACE_ISCAN },  /* Bit 4 */
        { "<interlaced pscan>", LMP_ILACE_PSCAN },  /* Bit 5 */
        { "<inquiry with RSSI>",LMP_RSSI_INQ    },  /* Bit 6 */
        { "<extended SCO>", LMP_ESCO    },  /* Bit 7 */
        { NULL }
    },
    {   /* Byte 4 */
        { "<EV4 packets>",  LMP_EV4     },  /* Bit 0 */
        { "<EV5 packets>",  LMP_EV5     },  /* Bit 1 */
        { "<no. 34>",       0x04        },  /* Bit 2 */
        { "<AFH cap. slave>",   LMP_AFH_CAP_SLV },  /* Bit 3 */
        { "<AFH class. slave>", LMP_AFH_CLS_SLV },  /* Bit 4 */
        { "<BR/EDR not supp.>", LMP_NO_BREDR    },  /* Bit 5 */
        { "<LE support>",   LMP_LE      },  /* Bit 6 */
        { "<3-slot EDR ACL>",   LMP_EDR_3SLOT   },  /* Bit 7 */
        { NULL }
    },
    {   /* Byte 5 */
        { "<5-slot EDR ACL>",   LMP_EDR_5SLOT   },  /* Bit 0 */
        { "<sniff subrating>",  LMP_SNIFF_SUBR  },  /* Bit 1 */
        { "<pause encryption>", LMP_PAUSE_ENC   },  /* Bit 2 */
        { "<AFH cap. master>",  LMP_AFH_CAP_MST },  /* Bit 3 */
        { "<AFH class. master>",LMP_AFH_CLS_MST },  /* Bit 4 */
        { "<EDR eSCO 2 Mbps>",  LMP_EDR_ESCO_2M },  /* Bit 5 */
        { "<EDR eSCO 3 Mbps>",  LMP_EDR_ESCO_3M },  /* Bit 6 */
        { "<3-slot EDR eSCO>",  LMP_EDR_3S_ESCO },  /* Bit 7 */
        { NULL }
    },
    {   /* Byte 6 */
        { "<extended inquiry>", LMP_EXT_INQ },  /* Bit 0 */
        { "<LE and BR/EDR>",    LMP_LE_BREDR    },  /* Bit 1 */
        { "<no. 50>",       0x04        },  /* Bit 2 */
        { "<simple pairing>",   LMP_SIMPLE_PAIR },  /* Bit 3 */
        { "<encapsulated PDU>", LMP_ENCAPS_PDU  },  /* Bit 4 */
        { "<err. data report>", LMP_ERR_DAT_REP },  /* Bit 5 */
        { "<non-flush flag>",   LMP_NFLUSH_PKTS },  /* Bit 6 */
        { "<no. 55>",       0x80        },  /* Bit 7 */
        { NULL }
    },
    {   /* Byte 7 */
        { "<LSTO>",     LMP_LSTO    },  /* Bit 1 */
        { "<inquiry TX power>", LMP_INQ_TX_PWR  },  /* Bit 1 */
        { "<EPC>",      LMP_EPC     },  /* Bit 2 */
        { "<no. 59>",       0x08        },  /* Bit 3 */
        { "<no. 60>",       0x10        },  /* Bit 4 */
        { "<no. 61>",       0x20        },  /* Bit 5 */
        { "<no. 62>",       0x40        },  /* Bit 6 */
        { "<extended features>",LMP_EXT_FEAT    },  /* Bit 7 */
        { NULL }
    },
};

char *lmp_featurestostr(uint8_t *features, char *pref, int width)
{
    unsigned int maxwidth = width - 1;
    char *off, *ptr, *str;
    int i, size = 10;

    for (i = 0; i < 8; i++) {
        hci_map *m = lmp_features_map[i];

        while (m->str) {
            if (m->val & features[i])
                size += strlen(m->str) +
                        (pref ? strlen(pref) : 0) + 1;
            m++;
        }
    }

    str = bt_malloc(size);
    if (!str)
        return NULL;

    ptr = str; *ptr = '\0';

    if (pref)
        ptr += sprintf(ptr, "%s", pref);

    off = ptr;

    for (i = 0; i < 8; i++) {
        hci_map *m = lmp_features_map[i];

        while (m->str) {
            if (m->val & features[i]) {
                if (strlen(off) + strlen(m->str) > maxwidth) {
                    ptr += sprintf(ptr, "\n%s",
                            pref ? pref : "");
                    off = ptr;
                }
                ptr += sprintf(ptr, "%s ", m->str);
            }
            m++;
        }
    }

    return str;
}

/*  HCI functions that do not require open device */

int hci_for_each_dev(int flag, int (*func)(int dd, int dev_id, long arg),
            long arg)
{
    struct hci_dev_list_req *dl;
    struct hci_dev_req *dr;
    int dev_id = -1;
    int i, sk, err = 0;

    sk = socket(AF_BLUETOOTH, SOCK_RAW | SOCK_CLOEXEC, BTPROTO_HCI);
    if (sk < 0)
        return -1;

    dl = malloc(HCI_MAX_DEV * sizeof(*dr) + sizeof(*dl));
    if (!dl) {
        err = errno;
        goto done;
    }

    memset(dl, 0, HCI_MAX_DEV * sizeof(*dr) + sizeof(*dl));

    dl->dev_num = HCI_MAX_DEV;
    dr = dl->dev_req;

    if (ioctl(sk, HCIGETDEVLIST, (void *) dl) < 0) {
        err = errno;
        goto free;
    }

    for (i = 0; i < dl->dev_num; i++, dr++) {
        if (hci_test_bit(flag, &dr->dev_opt))
            if (!func || func(sk, dr->dev_id, arg)) {
                dev_id = dr->dev_id;
                break;
            }
    }

    if (dev_id < 0)
        err = ENODEV;

free:
    free(dl);

done:
    close(sk);
    errno = err;

    return dev_id;
}

static int __other_bdaddr(int dd, int dev_id, long arg)
{
    struct hci_dev_info di = { .dev_id = dev_id };

    if (ioctl(dd, HCIGETDEVINFO, (void *) &di))
        return 0;

    if (hci_test_bit(HCI_RAW, &di.flags))
        return 0;

    return bacmp((bdaddr_t *) arg, &di.bdaddr);
}

static int __same_bdaddr(int dd, int dev_id, long arg)
{
    struct hci_dev_info di = { .dev_id = dev_id };

    if (ioctl(dd, HCIGETDEVINFO, (void *) &di))
        return 0;

    return !bacmp((bdaddr_t *) arg, &di.bdaddr);
}

int hci_get_route(bdaddr_t *bdaddr)
{
    int dev_id;

    dev_id = hci_for_each_dev(HCI_UP, __other_bdaddr,
                (long) (bdaddr ? bdaddr : BDADDR_ANY));
    if (dev_id < 0)
        dev_id = hci_for_each_dev(HCI_UP, __same_bdaddr,
                (long) (bdaddr ? bdaddr : BDADDR_ANY));

    return dev_id;
}

int hci_devid(const char *str)
{
    bdaddr_t ba;
    int id = -1;

    if (!strncmp(str, "hci", 3) && strlen(str) >= 4) {
        id = atoi(str + 3);
        if (hci_devba(id, &ba) < 0)
            return -1;
    } else {
        errno = ENODEV;
        str2ba(str, &ba);
        id = hci_for_each_dev(HCI_UP, __same_bdaddr, (long) &ba);
    }

    return id;
}

int hci_devinfo(int dev_id, struct hci_dev_info *di)
{
    int dd, err, ret;

    dd = socket(AF_BLUETOOTH, SOCK_RAW | SOCK_CLOEXEC, BTPROTO_HCI);
    if (dd < 0)
        return dd;

    memset(di, 0, sizeof(struct hci_dev_info));

    di->dev_id = dev_id;
    ret = ioctl(dd, HCIGETDEVINFO, (void *) di);

    err = errno;
    close(dd);
    errno = err;

    return ret;
}

int hci_devba(int dev_id, bdaddr_t *bdaddr)
{
    struct hci_dev_info di;

    memset(&di, 0, sizeof(di));

    if (hci_devinfo(dev_id, &di))
        return -1;

    if (!hci_test_bit(HCI_UP, &di.flags)) {
        errno = ENETDOWN;
        return -1;
    }

    bacpy(bdaddr, &di.bdaddr);

    return 0;
}

int hci_inquiry(int dev_id, int len, int nrsp, const uint8_t *lap,
        inquiry_info **ii, long flags)
{
    struct hci_inquiry_req *ir;
    uint8_t num_rsp = nrsp;
    void *buf;
    int dd, size, err, ret = -1;

    if (nrsp <= 0) {
        num_rsp = 0;
        nrsp = 255;
    }

    if (dev_id < 0) {
        dev_id = hci_get_route(NULL);
        if (dev_id < 0) {
            errno = ENODEV;
            return -1;
        }
    }

    dd = socket(AF_BLUETOOTH, SOCK_RAW | SOCK_CLOEXEC, BTPROTO_HCI);
    if (dd < 0)
        return dd;

    buf = malloc(sizeof(*ir) + (sizeof(inquiry_info) * (nrsp)));
    if (!buf)
        goto done;

    ir = buf;
    ir->dev_id  = dev_id;
    ir->num_rsp = num_rsp;
    ir->length  = len;
    ir->flags   = flags;

    if (lap) {
        memcpy(ir->lap, lap, 3);
    } else {
        ir->lap[0] = 0x33;
        ir->lap[1] = 0x8b;
        ir->lap[2] = 0x9e;
    }

    ret = ioctl(dd, HCIINQUIRY, (unsigned long) buf);
    if (ret < 0)
        goto free;

    size = sizeof(inquiry_info) * ir->num_rsp;

    if (!*ii)
        *ii = malloc(size);

    if (*ii) {
        memcpy((void *) *ii, buf + sizeof(*ir), size);
        ret = ir->num_rsp;
    } else
        ret = -1;

free:
    free(buf);

done:
    err = errno;
    close(dd);
    errno = err;

    return ret;
}

int hci_open_dev(int dev_id)
{
    struct sockaddr_hci a;
    int dd, err;

    /* Check for valid device id */
    if (dev_id < 0) {
        errno = ENODEV;
        return -1;
    }

    /* Create HCI socket */
    dd = socket(AF_BLUETOOTH, SOCK_RAW | SOCK_CLOEXEC, BTPROTO_HCI);
    if (dd < 0)
        return dd;

    /* Bind socket to the HCI device */
    memset(&a, 0, sizeof(a));
    a.hci_family = AF_BLUETOOTH;
    a.hci_dev = dev_id;
    if (bind(dd, (struct sockaddr *) &a, sizeof(a)) < 0)
        goto failed;

    return dd;

failed:
    err = errno;
    close(dd);
    errno = err;

    return -1;
}

int hci_close_dev(int dd)
{
    return close(dd);
}

/* HCI functions that require open device */

int hci_send_cmd(int dd, uint16_t ogf, uint16_t ocf, uint8_t plen, void *param)
{
    uint8_t type = HCI_COMMAND_PKT;
    hci_command_hdr hc;
    struct iovec iv[3];
    int ivn;

    hc.opcode = htobs(cmd_opcode_pack(ogf, ocf));
    hc.plen= plen;

    iv[0].iov_base = &type;
    iv[0].iov_len  = 1;
    iv[1].iov_base = &hc;
    iv[1].iov_len  = HCI_COMMAND_HDR_SIZE;
    ivn = 2;

    if (plen) {
        iv[2].iov_base = param;
        iv[2].iov_len  = plen;
        ivn = 3;
    }

    while (writev(dd, iv, ivn) < 0) {
        if (errno == EAGAIN || errno == EINTR)
            continue;
        return -1;
    }
    return 0;
}

int hci_send_req(int dd, struct hci_request *r, int to)
{
    unsigned char buf[HCI_MAX_EVENT_SIZE], *ptr;
    uint16_t opcode = htobs(cmd_opcode_pack(r->ogf, r->ocf));
    struct hci_filter nf, of;
    socklen_t olen;
    hci_event_hdr *hdr;
    int err, try;

    olen = sizeof(of);
    if (getsockopt(dd, SOL_HCI, HCI_FILTER, &of, &olen) < 0)
        return -1;

    hci_filter_clear(&nf);
    hci_filter_set_ptype(HCI_EVENT_PKT,  &nf);
    hci_filter_set_event(EVT_CMD_STATUS, &nf);
    hci_filter_set_event(EVT_CMD_COMPLETE, &nf);
    hci_filter_set_event(EVT_LE_META_EVENT, &nf);
    hci_filter_set_event(r->event, &nf);
    hci_filter_set_opcode(opcode, &nf);
    if (setsockopt(dd, SOL_HCI, HCI_FILTER, &nf, sizeof(nf)) < 0)
        return -1;

    if (hci_send_cmd(dd, r->ogf, r->ocf, r->clen, r->cparam) < 0)
        goto failed;

    try = 10;
    while (try--) {
        evt_cmd_complete *cc;
        evt_cmd_status *cs;
        evt_remote_name_req_complete *rn;
        evt_le_meta_event *me;
        remote_name_req_cp *cp;
        int len;

        if (to) {
            struct pollfd p;
            int n;

            p.fd = dd; p.events = POLLIN;
            while ((n = poll(&p, 1, to)) < 0) {
                if (errno == EAGAIN || errno == EINTR)
                    continue;
                goto failed;
            }

            if (!n) {
                errno = ETIMEDOUT;
                goto failed;
            }

            to -= 10;
            if (to < 0)
                to = 0;

        }

        while ((len = read(dd, buf, sizeof(buf))) < 0) {
            if (errno == EAGAIN || errno == EINTR)
                continue;
            goto failed;
        }

        hdr = (void *) (buf + 1);
        ptr = buf + (1 + HCI_EVENT_HDR_SIZE);
        len -= (1 + HCI_EVENT_HDR_SIZE);

        switch (hdr->evt) {
        case EVT_CMD_STATUS:
            cs = (void *) ptr;

            if (cs->opcode != opcode)
                continue;

            if (r->event != EVT_CMD_STATUS) {
                if (cs->status) {
                    errno = EIO;
                    goto failed;
                }
                break;
            }

            r->rlen = MIN(len, r->rlen);
            memcpy(r->rparam, ptr, r->rlen);
            goto done;

        case EVT_CMD_COMPLETE:
            cc = (void *) ptr;

            if (cc->opcode != opcode)
                continue;

            ptr += EVT_CMD_COMPLETE_SIZE;
            len -= EVT_CMD_COMPLETE_SIZE;

            r->rlen = MIN(len, r->rlen);
            memcpy(r->rparam, ptr, r->rlen);
            goto done;

        case EVT_REMOTE_NAME_REQ_COMPLETE:
            if (hdr->evt != r->event)
                break;

            rn = (void *) ptr;
            cp = r->cparam;

            if (bacmp(&rn->bdaddr, &cp->bdaddr))
                continue;

            r->rlen = MIN(len, r->rlen);
            memcpy(r->rparam, ptr, r->rlen);
            goto done;

        case EVT_LE_META_EVENT:
            me = (void *) ptr;

            if (me->subevent != r->event)
                continue;

            len -= 1;
            r->rlen = MIN(len, r->rlen);
            memcpy(r->rparam, me->data, r->rlen);
            goto done;

        default:
            if (hdr->evt != r->event)
                break;

            r->rlen = MIN(len, r->rlen);
            memcpy(r->rparam, ptr, r->rlen);
            goto done;
        }
    }
    errno = ETIMEDOUT;

failed:
    err = errno;
    setsockopt(dd, SOL_HCI, HCI_FILTER, &of, sizeof(of));
    errno = err;
    return -1;

done:
    setsockopt(dd, SOL_HCI, HCI_FILTER, &of, sizeof(of));
    return 0;
}

int hci_create_connection(int dd, const bdaddr_t *bdaddr, uint16_t ptype,
                uint16_t clkoffset, uint8_t rswitch,
                uint16_t *handle, int to)
{
    evt_conn_complete rp;
    create_conn_cp cp;
    struct hci_request rq;

    memset(&cp, 0, sizeof(cp));
    bacpy(&cp.bdaddr, bdaddr);
    cp.pkt_type       = ptype;
    cp.pscan_rep_mode = 0x02;
    cp.clock_offset   = clkoffset;
    cp.role_switch    = rswitch;

    memset(&rq, 0, sizeof(rq));
    rq.ogf    = OGF_LINK_CTL;
    rq.ocf    = OCF_CREATE_CONN;
    rq.event  = EVT_CONN_COMPLETE;
    rq.cparam = &cp;
    rq.clen   = CREATE_CONN_CP_SIZE;
    rq.rparam = &rp;
    rq.rlen   = EVT_CONN_COMPLETE_SIZE;

    if (hci_send_req(dd, &rq, to) < 0)
        return -1;

    if (rp.status) {
        errno = EIO;
        return -1;
    }

    *handle = rp.handle;
    return 0;
}

int hci_disconnect(int dd, uint16_t handle, uint8_t reason, int to)
{
    evt_disconn_complete rp;
    disconnect_cp cp;
    struct hci_request rq;

    memset(&cp, 0, sizeof(cp));
    cp.handle = handle;
    cp.reason = reason;

    memset(&rq, 0, sizeof(rq));
    rq.ogf    = OGF_LINK_CTL;
    rq.ocf    = OCF_DISCONNECT;
    rq.event  = EVT_DISCONN_COMPLETE;
    rq.cparam = &cp;
    rq.clen   = DISCONNECT_CP_SIZE;
    rq.rparam = &rp;
    rq.rlen   = EVT_DISCONN_COMPLETE_SIZE;

    if (hci_send_req(dd, &rq, to) < 0)
        return -1;

    if (rp.status) {
        errno = EIO;
        return -1;
    }
    return 0;
}

int hci_le_add_white_list(int dd, const bdaddr_t *bdaddr, uint8_t type, int to)
{
    struct hci_request rq;
    le_add_device_to_white_list_cp cp;
    uint8_t status;

    memset(&cp, 0, sizeof(cp));
    cp.bdaddr_type = type;
    bacpy(&cp.bdaddr, bdaddr);

    memset(&rq, 0, sizeof(rq));
    rq.ogf = OGF_LE_CTL;
    rq.ocf = OCF_LE_ADD_DEVICE_TO_WHITE_LIST;
    rq.cparam = &cp;
    rq.clen = LE_ADD_DEVICE_TO_WHITE_LIST_CP_SIZE;
    rq.rparam = &status;
    rq.rlen = 1;

    if (hci_send_req(dd, &rq, to) < 0)
        return -1;

    if (status) {
        errno = EIO;
        return -1;
    }

    return 0;
}

int hci_le_rm_white_list(int dd, const bdaddr_t *bdaddr, uint8_t type, int to)
{
    struct hci_request rq;
    le_remove_device_from_white_list_cp cp;
    uint8_t status;

    memset(&cp, 0, sizeof(cp));
    cp.bdaddr_type = type;
    bacpy(&cp.bdaddr, bdaddr);

    memset(&rq, 0, sizeof(rq));
    rq.ogf = OGF_LE_CTL;
    rq.ocf = OCF_LE_REMOVE_DEVICE_FROM_WHITE_LIST;
    rq.cparam = &cp;
    rq.clen = LE_REMOVE_DEVICE_FROM_WHITE_LIST_CP_SIZE;
    rq.rparam = &status;
    rq.rlen = 1;

    if (hci_send_req(dd, &rq, to) < 0)
        return -1;

    if (status) {
        errno = EIO;
        return -1;
    }

    return 0;
}

int hci_le_read_white_list_size(int dd, uint8_t *size, int to)
{
    struct hci_request rq;
    le_read_white_list_size_rp rp;

    memset(&rp, 0, sizeof(rp));
    memset(&rq, 0, sizeof(rq));

    rq.ogf = OGF_LE_CTL;
    rq.ocf = OCF_LE_READ_WHITE_LIST_SIZE;
    rq.rparam = &rp;
    rq.rlen = LE_READ_WHITE_LIST_SIZE_RP_SIZE;

    if (hci_send_req(dd, &rq, to) < 0)
        return -1;

    if (rp.status) {
        errno = EIO;
        return -1;
    }

    if (size)
        *size = rp.size;

    return 0;
}

int hci_le_clear_white_list(int dd, int to)
{
    struct hci_request rq;
    uint8_t status;

    memset(&rq, 0, sizeof(rq));
    rq.ogf = OGF_LE_CTL;
    rq.ocf = OCF_LE_CLEAR_WHITE_LIST;
    rq.rparam = &status;
    rq.rlen = 1;

    if (hci_send_req(dd, &rq, to) < 0)
        return -1;

    if (status) {
        errno = EIO;
        return -1;
    }

    return 0;
}

int hci_le_add_resolving_list(int dd, const bdaddr_t *bdaddr, uint8_t type,
                uint8_t *peer_irk, uint8_t *local_irk, int to)
{
    struct hci_request rq;
    le_add_device_to_resolv_list_cp cp;
    uint8_t status;

    memset(&cp, 0, sizeof(cp));
    cp.bdaddr_type = type;
    bacpy(&cp.bdaddr, bdaddr);
    if (peer_irk)
        memcpy(cp.peer_irk, peer_irk, 16);
    if (local_irk)
        memcpy(cp.local_irk, local_irk, 16);

    memset(&rq, 0, sizeof(rq));
    rq.ogf = OGF_LE_CTL;
    rq.ocf = OCF_LE_ADD_DEVICE_TO_RESOLV_LIST;
    rq.cparam = &cp;
    rq.clen = LE_ADD_DEVICE_TO_RESOLV_LIST_CP_SIZE;
    rq.rparam = &status;
    rq.rlen = 1;

    if (hci_send_req(dd, &rq, to) < 0)
        return -1;

    if (status) {
        errno = EIO;
        return -1;
    }

    return 0;
}

int hci_le_rm_resolving_list(int dd, const bdaddr_t *bdaddr, uint8_t type, int to)
{
    struct hci_request rq;
    le_remove_device_from_resolv_list_cp cp;
    uint8_t status;

    memset(&cp, 0, sizeof(cp));
    cp.bdaddr_type = type;
    bacpy(&cp.bdaddr, bdaddr);

    memset(&rq, 0, sizeof(rq));
    rq.ogf = OGF_LE_CTL;
    rq.ocf = OCF_LE_REMOVE_DEVICE_FROM_RESOLV_LIST;
    rq.cparam = &cp;
    rq.clen = LE_REMOVE_DEVICE_FROM_RESOLV_LIST_CP_SIZE;
    rq.rparam = &status;
    rq.rlen = 1;

    if (hci_send_req(dd, &rq, to) < 0)
        return -1;

    if (status) {
        errno = EIO;
        return -1;
    }

    return 0;
}

int hci_le_clear_resolving_list(int dd, int to)
{
    struct hci_request rq;
    uint8_t status;

    memset(&rq, 0, sizeof(rq));
    rq.ogf = OGF_LE_CTL;
    rq.ocf = OCF_LE_CLEAR_RESOLV_LIST;
    rq.rparam = &status;
    rq.rlen = 1;

    if (hci_send_req(dd, &rq, to) < 0)
        return -1;

    if (status) {
        errno = EIO;
        return -1;
    }

    return 0;
}

int hci_le_read_resolving_list_size(int dd, uint8_t *size, int to)
{
    struct hci_request rq;
    le_read_resolv_list_size_rp rp;

    memset(&rp, 0, sizeof(rp));
    memset(&rq, 0, sizeof(rq));

    rq.ogf = OGF_LE_CTL;
    rq.ocf = OCF_LE_READ_RESOLV_LIST_SIZE;
    rq.rparam = &rp;
    rq.rlen = LE_READ_RESOLV_LIST_SIZE_RP_SIZE;

    if (hci_send_req(dd, &rq, to) < 0)
        return -1;

    if (rp.status) {
        errno = EIO;
        return -1;
    }

    if (size)
        *size = rp.size;

    return 0;
}

int hci_le_set_address_resolution_enable(int dd, uint8_t enable, int to)
{
    struct hci_request rq;
    le_set_address_resolution_enable_cp cp;
    uint8_t status;

    memset(&cp, 0, sizeof(cp));
    cp.enable = enable;

    memset(&rq, 0, sizeof(rq));
    rq.ogf = OGF_LE_CTL;
    rq.ocf = OCF_LE_SET_ADDRESS_RESOLUTION_ENABLE;
    rq.cparam = &cp;
    rq.clen = LE_SET_ADDRESS_RESOLUTION_ENABLE_CP_SIZE;
    rq.rparam = &status;
    rq.rlen = 1;

    if (hci_send_req(dd, &rq, to) < 0)
        return -1;

    if (status) {
        errno = EIO;
        return -1;
    }

    return 0;
}

int hci_read_local_name(int dd, int len, char *name, int to)
{
    read_local_name_rp rp;
    struct hci_request rq;

    memset(&rq, 0, sizeof(rq));
    rq.ogf    = OGF_HOST_CTL;
    rq.ocf    = OCF_READ_LOCAL_NAME;
    rq.rparam = &rp;
    rq.rlen   = READ_LOCAL_NAME_RP_SIZE;

    if (hci_send_req(dd, &rq, to) < 0)
        return -1;

    if (rp.status) {
        errno = EIO;
        return -1;
    }

    rp.name[247] = '\0';
    strncpy(name, (char *) rp.name, len);
    return 0;
}

int hci_write_local_name(int dd, const char *name, int to)
{
    change_local_name_cp cp;
    struct hci_request rq;

    memset(&cp, 0, sizeof(cp));
    strncpy((char *) cp.name, name, sizeof(cp.name));

    memset(&rq, 0, sizeof(rq));
    rq.ogf    = OGF_HOST_CTL;
    rq.ocf    = OCF_CHANGE_LOCAL_NAME;
    rq.cparam = &cp;
    rq.clen   = CHANGE_LOCAL_NAME_CP_SIZE;

    if (hci_send_req(dd, &rq, to) < 0)
        return -1;

    return 0;
}

int hci_read_remote_name_with_clock_offset(int dd, const bdaddr_t *bdaddr,
                        uint8_t pscan_rep_mode,
                        uint16_t clkoffset,
                        int len, char *name, int to)
{
    evt_remote_name_req_complete rn;
    remote_name_req_cp cp;
    struct hci_request rq;

    memset(&cp, 0, sizeof(cp));
    bacpy(&cp.bdaddr, bdaddr);
    cp.pscan_rep_mode = pscan_rep_mode;
    cp.clock_offset   = clkoffset;

    memset(&rq, 0, sizeof(rq));
    rq.ogf    = OGF_LINK_CTL;
    rq.ocf    = OCF_REMOTE_NAME_REQ;
    rq.cparam = &cp;
    rq.clen   = REMOTE_NAME_REQ_CP_SIZE;
    rq.event  = EVT_REMOTE_NAME_REQ_COMPLETE;
    rq.rparam = &rn;
    rq.rlen   = EVT_REMOTE_NAME_REQ_COMPLETE_SIZE;

    if (hci_send_req(dd, &rq, to) < 0)
        return -1;

    if (rn.status) {
        errno = EIO;
        return -1;
    }

    rn.name[247] = '\0';
    strncpy(name, (char *) rn.name, len);
    return 0;
}

int hci_read_remote_name(int dd, const bdaddr_t *bdaddr, int len, char *name,
                int to)
{
    return hci_read_remote_name_with_clock_offset(dd, bdaddr, 0x02, 0x0000,
                            len, name, to);
}

int hci_read_remote_name_cancel(int dd, const bdaddr_t *bdaddr, int to)
{
    remote_name_req_cancel_cp cp;
    struct hci_request rq;

    memset(&cp, 0, sizeof(cp));
    bacpy(&cp.bdaddr, bdaddr);

    memset(&rq, 0, sizeof(rq));
    rq.ogf    = OGF_LINK_CTL;
    rq.ocf    = OCF_REMOTE_NAME_REQ_CANCEL;
    rq.cparam = &cp;
    rq.clen   = REMOTE_NAME_REQ_CANCEL_CP_SIZE;

    if (hci_send_req(dd, &rq, to) < 0)
        return -1;

    return 0;
}

int hci_read_remote_version(int dd, uint16_t handle, struct hci_version *ver,
                int to)
{
    evt_read_remote_version_complete rp;
    read_remote_version_cp cp;
    struct hci_request rq;

    memset(&cp, 0, sizeof(cp));
    cp.handle = handle;

    memset(&rq, 0, sizeof(rq));
    rq.ogf    = OGF_LINK_CTL;
    rq.ocf    = OCF_READ_REMOTE_VERSION;
    rq.event  = EVT_READ_REMOTE_VERSION_COMPLETE;
    rq.cparam = &cp;
    rq.clen   = READ_REMOTE_VERSION_CP_SIZE;
    rq.rparam = &rp;
    rq.rlen   = EVT_READ_REMOTE_VERSION_COMPLETE_SIZE;

    if (hci_send_req(dd, &rq, to) < 0)
        return -1;

    if (rp.status) {
        errno = EIO;
        return -1;
    }

    ver->manufacturer = btohs(rp.manufacturer);
    ver->lmp_ver      = rp.lmp_ver;
    ver->lmp_subver   = btohs(rp.lmp_subver);
    return 0;
}

int hci_read_remote_features(int dd, uint16_t handle, uint8_t *features, int to)
{
    evt_read_remote_features_complete rp;
    read_remote_features_cp cp;
    struct hci_request rq;

    memset(&cp, 0, sizeof(cp));
    cp.handle = handle;

    memset(&rq, 0, sizeof(rq));
    rq.ogf    = OGF_LINK_CTL;
    rq.ocf    = OCF_READ_REMOTE_FEATURES;
    rq.event  = EVT_READ_REMOTE_FEATURES_COMPLETE;
    rq.cparam = &cp;
    rq.clen   = READ_REMOTE_FEATURES_CP_SIZE;
    rq.rparam = &rp;
    rq.rlen   = EVT_READ_REMOTE_FEATURES_COMPLETE_SIZE;

    if (hci_send_req(dd, &rq, to) < 0)
        return -1;

    if (rp.status) {
        errno = EIO;
        return -1;
    }

    if (features)
        memcpy(features, rp.features, 8);

    return 0;
}

int hci_read_remote_ext_features(int dd, uint16_t handle, uint8_t page,
                    uint8_t *max_page, uint8_t *features,
                    int to)
{
    evt_read_remote_ext_features_complete rp;
    read_remote_ext_features_cp cp;
    struct hci_request rq;

    memset(&cp, 0, sizeof(cp));
    cp.handle   = handle;
    cp.page_num = page;

    memset(&rq, 0, sizeof(rq));
    rq.ogf    = OGF_LINK_CTL;
    rq.ocf    = OCF_READ_REMOTE_EXT_FEATURES;
    rq.event  = EVT_READ_REMOTE_EXT_FEATURES_COMPLETE;
    rq.cparam = &cp;
    rq.clen   = READ_REMOTE_EXT_FEATURES_CP_SIZE;
    rq.rparam = &rp;
    rq.rlen   = EVT_READ_REMOTE_EXT_FEATURES_COMPLETE_SIZE;

    if (hci_send_req(dd, &rq, to) < 0)
        return -1;

    if (rp.status) {
        errno = EIO;
        return -1;
    }

    if (max_page)
        *max_page = rp.max_page_num;

    if (features)
        memcpy(features, rp.features, 8);

    return 0;
}

int hci_read_clock_offset(int dd, uint16_t handle, uint16_t *clkoffset, int to)
{
    evt_read_clock_offset_complete rp;
    read_clock_offset_cp cp;
    struct hci_request rq;

    memset(&cp, 0, sizeof(cp));
    cp.handle = handle;

    memset(&rq, 0, sizeof(rq));
    rq.ogf    = OGF_LINK_CTL;
    rq.ocf    = OCF_READ_CLOCK_OFFSET;
    rq.event  = EVT_READ_CLOCK_OFFSET_COMPLETE;
    rq.cparam = &cp;
    rq.clen   = READ_CLOCK_OFFSET_CP_SIZE;
    rq.rparam = &rp;
    rq.rlen   = EVT_READ_CLOCK_OFFSET_COMPLETE_SIZE;

    if (hci_send_req(dd, &rq, to) < 0)
        return -1;

    if (rp.status) {
        errno = EIO;
        return -1;
    }

    *clkoffset = rp.clock_offset;
    return 0;
}

int hci_read_local_version(int dd, struct hci_version *ver, int to)
{
    read_local_version_rp rp;
    struct hci_request rq;

    memset(&rq, 0, sizeof(rq));
    rq.ogf    = OGF_INFO_PARAM;
    rq.ocf    = OCF_READ_LOCAL_VERSION;
    rq.rparam = &rp;
    rq.rlen   = READ_LOCAL_VERSION_RP_SIZE;

    if (hci_send_req(dd, &rq, to) < 0)
        return -1;

    if (rp.status) {
        errno = EIO;
        return -1;
    }

    ver->manufacturer = btohs(rp.manufacturer);
    ver->hci_ver      = rp.hci_ver;
    ver->hci_rev      = btohs(rp.hci_rev);
    ver->lmp_ver      = rp.lmp_ver;
    ver->lmp_subver   = btohs(rp.lmp_subver);
    return 0;
}

int hci_read_local_commands(int dd, uint8_t *commands, int to)
{
    read_local_commands_rp rp;
    struct hci_request rq;

    memset(&rq, 0, sizeof(rq));
    rq.ogf    = OGF_INFO_PARAM;
    rq.ocf    = OCF_READ_LOCAL_COMMANDS;
    rq.rparam = &rp;
    rq.rlen   = READ_LOCAL_COMMANDS_RP_SIZE;

    if (hci_send_req(dd, &rq, to) < 0)
        return -1;

    if (rp.status) {
        errno = EIO;
        return -1;
    }

    if (commands)
        memcpy(commands, rp.commands, 64);

    return 0;
}

int hci_read_local_features(int dd, uint8_t *features, int to)
{
    read_local_features_rp rp;
    struct hci_request rq;

    memset(&rq, 0, sizeof(rq));
    rq.ogf    = OGF_INFO_PARAM;
    rq.ocf    = OCF_READ_LOCAL_FEATURES;
    rq.rparam = &rp;
    rq.rlen   = READ_LOCAL_FEATURES_RP_SIZE;

    if (hci_send_req(dd, &rq, to) < 0)
        return -1;

    if (rp.status) {
        errno = EIO;
        return -1;
    }

    if (features)
        memcpy(features, rp.features, 8);

    return 0;
}

int hci_read_local_ext_features(int dd, uint8_t page, uint8_t *max_page,
                uint8_t *features, int to)
{
    read_local_ext_features_cp cp;
    read_local_ext_features_rp rp;
    struct hci_request rq;

    cp.page_num = page;

    memset(&rq, 0, sizeof(rq));
    rq.ogf    = OGF_INFO_PARAM;
    rq.ocf    = OCF_READ_LOCAL_EXT_FEATURES;
    rq.cparam = &cp;
    rq.clen   = READ_LOCAL_EXT_FEATURES_CP_SIZE;
    rq.rparam = &rp;
    rq.rlen   = READ_LOCAL_EXT_FEATURES_RP_SIZE;

    if (hci_send_req(dd, &rq, to) < 0)
        return -1;

    if (rp.status) {
        errno = EIO;
        return -1;
    }

    if (max_page)
        *max_page = rp.max_page_num;

    if (features)
        memcpy(features, rp.features, 8);

    return 0;
}

int hci_read_bd_addr(int dd, bdaddr_t *bdaddr, int to)
{
    read_bd_addr_rp rp;
    struct hci_request rq;

    memset(&rq, 0, sizeof(rq));
    rq.ogf    = OGF_INFO_PARAM;
    rq.ocf    = OCF_READ_BD_ADDR;
    rq.rparam = &rp;
    rq.rlen   = READ_BD_ADDR_RP_SIZE;

    if (hci_send_req(dd, &rq, to) < 0)
        return -1;

    if (rp.status) {
        errno = EIO;
        return -1;
    }

    if (bdaddr)
        bacpy(bdaddr, &rp.bdaddr);

    return 0;
}

int hci_read_class_of_dev(int dd, uint8_t *cls, int to)
{
    read_class_of_dev_rp rp;
    struct hci_request rq;

    memset(&rq, 0, sizeof(rq));
    rq.ogf    = OGF_HOST_CTL;
    rq.ocf    = OCF_READ_CLASS_OF_DEV;
    rq.rparam = &rp;
    rq.rlen   = READ_CLASS_OF_DEV_RP_SIZE;

    if (hci_send_req(dd, &rq, to) < 0)
        return -1;

    if (rp.status) {
        errno = EIO;
        return -1;
    }

    memcpy(cls, rp.dev_class, 3);
    return 0;
}

int hci_write_class_of_dev(int dd, uint32_t cls, int to)
{
    write_class_of_dev_cp cp;
    struct hci_request rq;

    memset(&rq, 0, sizeof(rq));
    cp.dev_class[0] = cls & 0xff;
    cp.dev_class[1] = (cls >> 8) & 0xff;
    cp.dev_class[2] = (cls >> 16) & 0xff;
    rq.ogf    = OGF_HOST_CTL;
    rq.ocf    = OCF_WRITE_CLASS_OF_DEV;
    rq.cparam = &cp;
    rq.clen   = WRITE_CLASS_OF_DEV_CP_SIZE;
    return hci_send_req(dd, &rq, to);
}

int hci_read_voice_setting(int dd, uint16_t *vs, int to)
{
    read_voice_setting_rp rp;
    struct hci_request rq;

    memset(&rq, 0, sizeof(rq));
    rq.ogf    = OGF_HOST_CTL;
    rq.ocf    = OCF_READ_VOICE_SETTING;
    rq.rparam = &rp;
    rq.rlen   = READ_VOICE_SETTING_RP_SIZE;

    if (hci_send_req(dd, &rq, to) < 0)
        return -1;

    if (rp.status) {
        errno = EIO;
        return -1;
    }

    *vs = rp.voice_setting;
    return 0;
}

int hci_write_voice_setting(int dd, uint16_t vs, int to)
{
    write_voice_setting_cp cp;
    struct hci_request rq;

    memset(&rq, 0, sizeof(rq));
    cp.voice_setting = vs;
    rq.ogf    = OGF_HOST_CTL;
    rq.ocf    = OCF_WRITE_VOICE_SETTING;
    rq.cparam = &cp;
    rq.clen   = WRITE_VOICE_SETTING_CP_SIZE;

    return hci_send_req(dd, &rq, to);
}

int hci_read_current_iac_lap(int dd, uint8_t *num_iac, uint8_t *lap, int to)
{
    read_current_iac_lap_rp rp;
    struct hci_request rq;

    memset(&rq, 0, sizeof(rq));
    rq.ogf    = OGF_HOST_CTL;
    rq.ocf    = OCF_READ_CURRENT_IAC_LAP;
    rq.rparam = &rp;
    rq.rlen   = READ_CURRENT_IAC_LAP_RP_SIZE;

    if (hci_send_req(dd, &rq, to) < 0)
        return -1;

    if (rp.status) {
        errno = EIO;
        return -1;
    }

    *num_iac = rp.num_current_iac;
    memcpy(lap, rp.lap, rp.num_current_iac * 3);
    return 0;
}

int hci_write_current_iac_lap(int dd, uint8_t num_iac, uint8_t *lap, int to)
{
    write_current_iac_lap_cp cp;
    struct hci_request rq;

    memset(&cp, 0, sizeof(cp));
    cp.num_current_iac = num_iac;
    memcpy(&cp.lap, lap, num_iac * 3);

    memset(&rq, 0, sizeof(rq));
    rq.ogf    = OGF_HOST_CTL;
    rq.ocf    = OCF_WRITE_CURRENT_IAC_LAP;
    rq.cparam = &cp;
    rq.clen   = num_iac * 3 + 1;

    return hci_send_req(dd, &rq, to);
}

int hci_read_stored_link_key(int dd, bdaddr_t *bdaddr, uint8_t all, int to)
{
    read_stored_link_key_cp cp;
    struct hci_request rq;

    memset(&cp, 0, sizeof(cp));
    bacpy(&cp.bdaddr, bdaddr);
    cp.read_all = all;

    memset(&rq, 0, sizeof(rq));
    rq.ogf    = OGF_HOST_CTL;
    rq.ocf    = OCF_READ_STORED_LINK_KEY;
    rq.cparam = &cp;
    rq.clen   = READ_STORED_LINK_KEY_CP_SIZE;

    return hci_send_req(dd, &rq, to);
}

int hci_write_stored_link_key(int dd, bdaddr_t *bdaddr, uint8_t *key, int to)
{
    unsigned char cp[WRITE_STORED_LINK_KEY_CP_SIZE + 6 + 16];
    struct hci_request rq;

    memset(&cp, 0, sizeof(cp));
    cp[0] = 1;
    bacpy((bdaddr_t *) (cp + 1), bdaddr);
    memcpy(cp + 7, key, 16);

    memset(&rq, 0, sizeof(rq));
    rq.ogf    = OGF_HOST_CTL;
    rq.ocf    = OCF_WRITE_STORED_LINK_KEY;
    rq.cparam = &cp;
    rq.clen   = WRITE_STORED_LINK_KEY_CP_SIZE + 6 + 16;

    return hci_send_req(dd, &rq, to);
}

int hci_delete_stored_link_key(int dd, bdaddr_t *bdaddr, uint8_t all, int to)
{
    delete_stored_link_key_cp cp;
    struct hci_request rq;

    memset(&cp, 0, sizeof(cp));
    bacpy(&cp.bdaddr, bdaddr);
    cp.delete_all = all;

    memset(&rq, 0, sizeof(rq));
    rq.ogf    = OGF_HOST_CTL;
    rq.ocf    = OCF_DELETE_STORED_LINK_KEY;
    rq.cparam = &cp;
    rq.clen   = DELETE_STORED_LINK_KEY_CP_SIZE;

    return hci_send_req(dd, &rq, to);
}

int hci_authenticate_link(int dd, uint16_t handle, int to)
{
    auth_requested_cp cp;
    evt_auth_complete rp;
    struct hci_request rq;

    cp.handle = handle;

    rq.ogf    = OGF_LINK_CTL;
    rq.ocf    = OCF_AUTH_REQUESTED;
    rq.event  = EVT_AUTH_COMPLETE;
    rq.cparam = &cp;
    rq.clen   = AUTH_REQUESTED_CP_SIZE;
    rq.rparam = &rp;
    rq.rlen   = EVT_AUTH_COMPLETE_SIZE;

    if (hci_send_req(dd, &rq, to) < 0)
        return -1;

    if (rp.status) {
        errno = EIO;
        return -1;
    }

    return 0;
}

int hci_encrypt_link(int dd, uint16_t handle, uint8_t encrypt, int to)
{
    set_conn_encrypt_cp cp;
    evt_encrypt_change rp;
    struct hci_request rq;

    cp.handle  = handle;
    cp.encrypt = encrypt;

    rq.ogf     = OGF_LINK_CTL;
    rq.ocf     = OCF_SET_CONN_ENCRYPT;
    rq.event   = EVT_ENCRYPT_CHANGE;
    rq.cparam  = &cp;
    rq.clen    = SET_CONN_ENCRYPT_CP_SIZE;
    rq.rparam  = &rp;
    rq.rlen    = EVT_ENCRYPT_CHANGE_SIZE;

    if (hci_send_req(dd, &rq, to) < 0)
        return -1;

    if (rp.status) {
        errno = EIO;
        return -1;
    }

    return 0;
}

int hci_change_link_key(int dd, uint16_t handle, int to)
{
    change_conn_link_key_cp cp;
    evt_change_conn_link_key_complete rp;
    struct hci_request rq;

    cp.handle = handle;

    rq.ogf    = OGF_LINK_CTL;
    rq.ocf    = OCF_CHANGE_CONN_LINK_KEY;
    rq.event  = EVT_CHANGE_CONN_LINK_KEY_COMPLETE;
    rq.cparam = &cp;
    rq.clen   = CHANGE_CONN_LINK_KEY_CP_SIZE;
    rq.rparam = &rp;
    rq.rlen   = EVT_CHANGE_CONN_LINK_KEY_COMPLETE_SIZE;

    if (hci_send_req(dd, &rq, to) < 0)
        return -1;

    if (rp.status) {
        errno = EIO;
        return -1;
    }

    return 0;
}

int hci_switch_role(int dd, bdaddr_t *bdaddr, uint8_t role, int to)
{
    switch_role_cp cp;
    evt_role_change rp;
    struct hci_request rq;

    bacpy(&cp.bdaddr, bdaddr);
    cp.role   = role;
    rq.ogf    = OGF_LINK_POLICY;
    rq.ocf    = OCF_SWITCH_ROLE;
    rq.cparam = &cp;
    rq.clen   = SWITCH_ROLE_CP_SIZE;
    rq.rparam = &rp;
    rq.rlen   = EVT_ROLE_CHANGE_SIZE;
    rq.event  = EVT_ROLE_CHANGE;

    if (hci_send_req(dd, &rq, to) < 0)
        return -1;

    if (rp.status) {
        errno = EIO;
        return -1;
    }

    return 0;
}

int hci_park_mode(int dd, uint16_t handle, uint16_t max_interval,
            uint16_t min_interval, int to)
{
    park_mode_cp cp;
    evt_mode_change rp;
    struct hci_request rq;

    memset(&cp, 0, sizeof (cp));
    cp.handle       = handle;
    cp.max_interval = max_interval;
    cp.min_interval = min_interval;

    memset(&rq, 0, sizeof (rq));
    rq.ogf    = OGF_LINK_POLICY;
    rq.ocf    = OCF_PARK_MODE;
    rq.event  = EVT_MODE_CHANGE;
    rq.cparam = &cp;
    rq.clen   = PARK_MODE_CP_SIZE;
    rq.rparam = &rp;
    rq.rlen   = EVT_MODE_CHANGE_SIZE;

    if (hci_send_req(dd, &rq, to) < 0)
        return -1;

    if (rp.status) {
        errno = EIO;
        return -1;
    }

    return 0;
}

int hci_exit_park_mode(int dd, uint16_t handle, int to)
{
    exit_park_mode_cp cp;
    evt_mode_change rp;
    struct hci_request rq;

    memset(&cp, 0, sizeof (cp));
    cp.handle = handle;

    memset (&rq, 0, sizeof (rq));
    rq.ogf    = OGF_LINK_POLICY;
    rq.ocf    = OCF_EXIT_PARK_MODE;
    rq.event  = EVT_MODE_CHANGE;
    rq.cparam = &cp;
    rq.clen   = EXIT_PARK_MODE_CP_SIZE;
    rq.rparam = &rp;
    rq.rlen   = EVT_MODE_CHANGE_SIZE;

    if (hci_send_req(dd, &rq, to) < 0)
        return -1;

    if (rp.status) {
        errno = EIO;
        return -1;
    }

    return 0;
}

int hci_read_inquiry_scan_type(int dd, uint8_t *type, int to)
{
    read_inquiry_scan_type_rp rp;
    struct hci_request rq;

    memset(&rq, 0, sizeof(rq));
    rq.ogf    = OGF_HOST_CTL;
    rq.ocf    = OCF_READ_INQUIRY_SCAN_TYPE;
    rq.rparam = &rp;
    rq.rlen   = READ_INQUIRY_SCAN_TYPE_RP_SIZE;

    if (hci_send_req(dd, &rq, to) < 0)
        return -1;

    if (rp.status) {
        errno = EIO;
        return -1;
    }

    *type = rp.type;
    return 0;
}

int hci_write_inquiry_scan_type(int dd, uint8_t type, int to)
{
    write_inquiry_scan_type_cp cp;
    write_inquiry_scan_type_rp rp;
    struct hci_request rq;

    memset(&cp, 0, sizeof(cp));
    cp.type = type;

    memset(&rq, 0, sizeof(rq));
    rq.ogf    = OGF_HOST_CTL;
    rq.ocf    = OCF_WRITE_INQUIRY_SCAN_TYPE;
    rq.cparam = &cp;
    rq.clen   = WRITE_INQUIRY_SCAN_TYPE_CP_SIZE;
    rq.rparam = &rp;
    rq.rlen   = WRITE_INQUIRY_SCAN_TYPE_RP_SIZE;

    if (hci_send_req(dd, &rq, to) < 0)
        return -1;

    if (rp.status) {
        errno = EIO;
        return -1;
    }

    return 0;
}

int hci_read_inquiry_mode(int dd, uint8_t *mode, int to)
{
    read_inquiry_mode_rp rp;
    struct hci_request rq;

    memset(&rq, 0, sizeof(rq));
    rq.ogf    = OGF_HOST_CTL;
    rq.ocf    = OCF_READ_INQUIRY_MODE;
    rq.rparam = &rp;
    rq.rlen   = READ_INQUIRY_MODE_RP_SIZE;

    if (hci_send_req(dd, &rq, to) < 0)
        return -1;

    if (rp.status) {
        errno = EIO;
        return -1;
    }

    *mode = rp.mode;
    return 0;
}

int hci_write_inquiry_mode(int dd, uint8_t mode, int to)
{
    write_inquiry_mode_cp cp;
    write_inquiry_mode_rp rp;
    struct hci_request rq;

    memset(&cp, 0, sizeof(cp));
    cp.mode = mode;

    memset(&rq, 0, sizeof(rq));
    rq.ogf    = OGF_HOST_CTL;
    rq.ocf    = OCF_WRITE_INQUIRY_MODE;
    rq.cparam = &cp;
    rq.clen   = WRITE_INQUIRY_MODE_CP_SIZE;
    rq.rparam = &rp;
    rq.rlen   = WRITE_INQUIRY_MODE_RP_SIZE;

    if (hci_send_req(dd, &rq, to) < 0)
        return -1;

    if (rp.status) {
        errno = EIO;
        return -1;
    }

    return 0;
}

int hci_read_afh_mode(int dd, uint8_t *mode, int to)
{
    read_afh_mode_rp rp;
    struct hci_request rq;

    memset(&rq, 0, sizeof(rq));
    rq.ogf    = OGF_HOST_CTL;
    rq.ocf    = OCF_READ_AFH_MODE;
    rq.rparam = &rp;
    rq.rlen   = READ_AFH_MODE_RP_SIZE;

    if (hci_send_req(dd, &rq, to) < 0)
        return -1;

    if (rp.status) {
        errno = EIO;
        return -1;
    }

    *mode = rp.mode;
    return 0;
}

int hci_write_afh_mode(int dd, uint8_t mode, int to)
{
    write_afh_mode_cp cp;
    write_afh_mode_rp rp;
    struct hci_request rq;

    memset(&cp, 0, sizeof(cp));
    cp.mode = mode;

    memset(&rq, 0, sizeof(rq));
    rq.ogf    = OGF_HOST_CTL;
    rq.ocf    = OCF_WRITE_AFH_MODE;
    rq.cparam = &cp;
    rq.clen   = WRITE_AFH_MODE_CP_SIZE;
    rq.rparam = &rp;
    rq.rlen   = WRITE_AFH_MODE_RP_SIZE;

    if (hci_send_req(dd, &rq, to) < 0)
        return -1;

    if (rp.status) {
        errno = EIO;
        return -1;
    }

    return 0;
}

int hci_read_ext_inquiry_response(int dd, uint8_t *fec, uint8_t *data, int to)
{
    read_ext_inquiry_response_rp rp;
    struct hci_request rq;

    memset(&rq, 0, sizeof(rq));
    rq.ogf    = OGF_HOST_CTL;
    rq.ocf    = OCF_READ_EXT_INQUIRY_RESPONSE;
    rq.rparam = &rp;
    rq.rlen   = READ_EXT_INQUIRY_RESPONSE_RP_SIZE;

    if (hci_send_req(dd, &rq, to) < 0)
        return -1;

    if (rp.status) {
        errno = EIO;
        return -1;
    }

    *fec = rp.fec;
    memcpy(data, rp.data, HCI_MAX_EIR_LENGTH);

    return 0;
}

int hci_write_ext_inquiry_response(int dd, uint8_t fec, uint8_t *data, int to)
{
    write_ext_inquiry_response_cp cp;
    write_ext_inquiry_response_rp rp;
    struct hci_request rq;

    memset(&cp, 0, sizeof(cp));
    cp.fec = fec;
    memcpy(cp.data, data, HCI_MAX_EIR_LENGTH);

    memset(&rq, 0, sizeof(rq));
    rq.ogf    = OGF_HOST_CTL;
    rq.ocf    = OCF_WRITE_EXT_INQUIRY_RESPONSE;
    rq.cparam = &cp;
    rq.clen   = WRITE_EXT_INQUIRY_RESPONSE_CP_SIZE;
    rq.rparam = &rp;
    rq.rlen   = WRITE_EXT_INQUIRY_RESPONSE_RP_SIZE;

    if (hci_send_req(dd, &rq, to) < 0)
        return -1;

    if (rp.status) {
        errno = EIO;
        return -1;
    }

    return 0;
}

int hci_read_simple_pairing_mode(int dd, uint8_t *mode, int to)
{
    read_simple_pairing_mode_rp rp;
    struct hci_request rq;

    memset(&rq, 0, sizeof(rq));
    rq.ogf    = OGF_HOST_CTL;
    rq.ocf    = OCF_READ_SIMPLE_PAIRING_MODE;
    rq.rparam = &rp;
    rq.rlen   = READ_SIMPLE_PAIRING_MODE_RP_SIZE;

    if (hci_send_req(dd, &rq, to) < 0)
        return -1;

    if (rp.status) {
        errno = EIO;
        return -1;
    }

    *mode = rp.mode;
    return 0;
}

int hci_write_simple_pairing_mode(int dd, uint8_t mode, int to)
{
    write_simple_pairing_mode_cp cp;
    write_simple_pairing_mode_rp rp;
    struct hci_request rq;

    memset(&cp, 0, sizeof(cp));
    cp.mode = mode;

    memset(&rq, 0, sizeof(rq));
    rq.ogf    = OGF_HOST_CTL;
    rq.ocf    = OCF_WRITE_SIMPLE_PAIRING_MODE;
    rq.cparam = &cp;
    rq.clen   = WRITE_SIMPLE_PAIRING_MODE_CP_SIZE;
    rq.rparam = &rp;
    rq.rlen   = WRITE_SIMPLE_PAIRING_MODE_RP_SIZE;

    if (hci_send_req(dd, &rq, to) < 0)
        return -1;

    if (rp.status) {
        errno = EIO;
        return -1;
    }

    return 0;
}

int hci_read_local_oob_data(int dd, uint8_t *hash, uint8_t *randomizer, int to)
{
    read_local_oob_data_rp rp;
    struct hci_request rq;

    memset(&rq, 0, sizeof(rq));
    rq.ogf    = OGF_HOST_CTL;
    rq.ocf    = OCF_READ_LOCAL_OOB_DATA;
    rq.rparam = &rp;
    rq.rlen   = READ_LOCAL_OOB_DATA_RP_SIZE;

    if (hci_send_req(dd, &rq, to) < 0)
        return -1;

    if (rp.status) {
        errno = EIO;
        return -1;
    }

    memcpy(hash, rp.hash, 16);
    memcpy(randomizer, rp.randomizer, 16);
    return 0;
}

int hci_read_inq_response_tx_power_level(int dd, int8_t *level, int to)
{
    read_inq_response_tx_power_level_rp rp;
    struct hci_request rq;

    memset(&rq, 0, sizeof(rq));
    rq.ogf    = OGF_HOST_CTL;
    rq.ocf    = OCF_READ_INQ_RESPONSE_TX_POWER_LEVEL;
    rq.rparam = &rp;
    rq.rlen   = READ_INQ_RESPONSE_TX_POWER_LEVEL_RP_SIZE;

    if (hci_send_req(dd, &rq, to) < 0)
        return -1;

    if (rp.status) {
        errno = EIO;
        return -1;
    }

    *level = rp.level;
    return 0;
}

int hci_read_inquiry_transmit_power_level(int dd, int8_t *level, int to)
{
    return hci_read_inq_response_tx_power_level(dd, level, to);
}

int hci_write_inquiry_transmit_power_level(int dd, int8_t level, int to)
{
    write_inquiry_transmit_power_level_cp cp;
    write_inquiry_transmit_power_level_rp rp;
    struct hci_request rq;

    memset(&cp, 0, sizeof(cp));
    cp.level = level;

    memset(&rq, 0, sizeof(rq));
    rq.ogf    = OGF_HOST_CTL;
    rq.ocf    = OCF_WRITE_INQUIRY_TRANSMIT_POWER_LEVEL;
    rq.cparam = &cp;
    rq.clen   = WRITE_INQUIRY_TRANSMIT_POWER_LEVEL_CP_SIZE;
    rq.rparam = &rp;
    rq.rlen   = WRITE_INQUIRY_TRANSMIT_POWER_LEVEL_RP_SIZE;

    if (hci_send_req(dd, &rq, to) < 0)
        return -1;

    if (rp.status) {
        errno = EIO;
        return -1;
    }

    return 0;
}

int hci_read_transmit_power_level(int dd, uint16_t handle, uint8_t type,
                    int8_t *level, int to)
{
    read_transmit_power_level_cp cp;
    read_transmit_power_level_rp rp;
    struct hci_request rq;

    memset(&cp, 0, sizeof(cp));
    cp.handle = handle;
    cp.type   = type;

    memset(&rq, 0, sizeof(rq));
    rq.ogf    = OGF_HOST_CTL;
    rq.ocf    = OCF_READ_TRANSMIT_POWER_LEVEL;
    rq.cparam = &cp;
    rq.clen   = READ_TRANSMIT_POWER_LEVEL_CP_SIZE;
    rq.rparam = &rp;
    rq.rlen   = READ_TRANSMIT_POWER_LEVEL_RP_SIZE;

    if (hci_send_req(dd, &rq, to) < 0)
        return -1;

    if (rp.status) {
        errno = EIO;
        return -1;
    }

    *level = rp.level;
    return 0;
}

int hci_read_link_policy(int dd, uint16_t handle, uint16_t *policy, int to)
{
    read_link_policy_rp rp;
    struct hci_request rq;

    memset(&rq, 0, sizeof(rq));
    rq.ogf    = OGF_LINK_POLICY;
    rq.ocf    = OCF_READ_LINK_POLICY;
    rq.cparam = &handle;
    rq.clen   = 2;
    rq.rparam = &rp;
    rq.rlen   = READ_LINK_POLICY_RP_SIZE;

    if (hci_send_req(dd, &rq, to) < 0)
        return -1;

    if (rp.status) {
        errno = EIO;
        return -1;
    }

    *policy = rp.policy;
    return 0;
}

int hci_write_link_policy(int dd, uint16_t handle, uint16_t policy, int to)
{
    write_link_policy_cp cp;
    write_link_policy_rp rp;
    struct hci_request rq;

    memset(&cp, 0, sizeof(cp));
    cp.handle = handle;
    cp.policy = policy;

    memset(&rq, 0, sizeof(rq));
    rq.ogf    = OGF_LINK_POLICY;
    rq.ocf    = OCF_WRITE_LINK_POLICY;
    rq.cparam = &cp;
    rq.clen   = WRITE_LINK_POLICY_CP_SIZE;
    rq.rparam = &rp;
    rq.rlen   = WRITE_LINK_POLICY_RP_SIZE;

    if (hci_send_req(dd, &rq, to) < 0)
        return -1;

    if (rp.status) {
        errno = EIO;
        return -1;
    }

    return 0;
}

int hci_read_link_supervision_timeout(int dd, uint16_t handle,
                    uint16_t *timeout, int to)
{
    read_link_supervision_timeout_rp rp;
    struct hci_request rq;

    memset(&rq, 0, sizeof(rq));
    rq.ogf    = OGF_HOST_CTL;
    rq.ocf    = OCF_READ_LINK_SUPERVISION_TIMEOUT;
    rq.cparam = &handle;
    rq.clen   = 2;
    rq.rparam = &rp;
    rq.rlen   = READ_LINK_SUPERVISION_TIMEOUT_RP_SIZE;

    if (hci_send_req(dd, &rq, to) < 0)
        return -1;

    if (rp.status) {
        errno = EIO;
        return -1;
    }

    *timeout = rp.timeout;
    return 0;
}

int hci_write_link_supervision_timeout(int dd, uint16_t handle,
                    uint16_t timeout, int to)
{
    write_link_supervision_timeout_cp cp;
    write_link_supervision_timeout_rp rp;
    struct hci_request rq;

    memset(&cp, 0, sizeof(cp));
    cp.handle  = handle;
    cp.timeout = timeout;

    memset(&rq, 0, sizeof(rq));
    rq.ogf    = OGF_HOST_CTL;
    rq.ocf    = OCF_WRITE_LINK_SUPERVISION_TIMEOUT;
    rq.cparam = &cp;
    rq.clen   = WRITE_LINK_SUPERVISION_TIMEOUT_CP_SIZE;
    rq.rparam = &rp;
    rq.rlen   = WRITE_LINK_SUPERVISION_TIMEOUT_RP_SIZE;

    if (hci_send_req(dd, &rq, to) < 0)
        return -1;

    if (rp.status) {
        errno = EIO;
        return -1;
    }

    return 0;
}

int hci_set_afh_classification(int dd, uint8_t *map, int to)
{
    set_afh_classification_cp cp;
    set_afh_classification_rp rp;
    struct hci_request rq;

    memset(&cp, 0, sizeof(cp));
    memcpy(cp.map, map, 10);

    memset(&rq, 0, sizeof(rq));
    rq.ogf    = OGF_HOST_CTL;
    rq.ocf    = OCF_SET_AFH_CLASSIFICATION;
    rq.cparam = &cp;
    rq.clen   = SET_AFH_CLASSIFICATION_CP_SIZE;
    rq.rparam = &rp;
    rq.rlen   = SET_AFH_CLASSIFICATION_RP_SIZE;

    if (hci_send_req(dd, &rq, to) < 0)
        return -1;

    if (rp.status) {
        errno = EIO;
        return -1;
    }

    return 0;
}

int hci_read_link_quality(int dd, uint16_t handle, uint8_t *link_quality,
                int to)
{
    read_link_quality_rp rp;
    struct hci_request rq;

    memset(&rq, 0, sizeof(rq));
    rq.ogf    = OGF_STATUS_PARAM;
    rq.ocf    = OCF_READ_LINK_QUALITY;
    rq.cparam = &handle;
    rq.clen   = 2;
    rq.rparam = &rp;
    rq.rlen   = READ_LINK_QUALITY_RP_SIZE;

    if (hci_send_req(dd, &rq, to) < 0)
        return -1;

    if (rp.status) {
        errno = EIO;
        return -1;
    }

    *link_quality = rp.link_quality;
    return 0;
}

int hci_read_rssi(int dd, uint16_t handle, int8_t *rssi, int to)
{
    read_rssi_rp rp;
    struct hci_request rq;

    memset(&rq, 0, sizeof(rq));
    rq.ogf    = OGF_STATUS_PARAM;
    rq.ocf    = OCF_READ_RSSI;
    rq.cparam = &handle;
    rq.clen   = 2;
    rq.rparam = &rp;
    rq.rlen   = READ_RSSI_RP_SIZE;

    if (hci_send_req(dd, &rq, to) < 0)
        return -1;

    if (rp.status) {
        errno = EIO;
        return -1;
    }

    *rssi = rp.rssi;
    return 0;
}

int hci_read_afh_map(int dd, uint16_t handle, uint8_t *mode, uint8_t *map,
            int to)
{
    read_afh_map_rp rp;
    struct hci_request rq;

    memset(&rq, 0, sizeof(rq));
    rq.ogf    = OGF_STATUS_PARAM;
    rq.ocf    = OCF_READ_AFH_MAP;
    rq.cparam = &handle;
    rq.clen   = 2;
    rq.rparam = &rp;
    rq.rlen   = READ_AFH_MAP_RP_SIZE;

    if (hci_send_req(dd, &rq, to) < 0)
        return -1;

    if (rp.status) {
        errno = EIO;
        return -1;
    }

    *mode = rp.mode;
    memcpy(map, rp.map, 10);
    return 0;
}

int hci_read_clock(int dd, uint16_t handle, uint8_t which, uint32_t *clock,
            uint16_t *accuracy, int to)
{
    read_clock_cp cp;
    read_clock_rp rp;
    struct hci_request rq;

    memset(&cp, 0, sizeof(cp));
    cp.handle      = handle;
    cp.which_clock = which;

    memset(&rq, 0, sizeof(rq));
    rq.ogf    = OGF_STATUS_PARAM;
    rq.ocf    = OCF_READ_CLOCK;
    rq.cparam = &cp;
    rq.clen   = READ_CLOCK_CP_SIZE;
    rq.rparam = &rp;
    rq.rlen   = READ_CLOCK_RP_SIZE;

    if (hci_send_req(dd, &rq, to) < 0)
        return -1;

    if (rp.status) {
        errno = EIO;
        return -1;
    }

    *clock    = rp.clock;
    *accuracy = rp.accuracy;
    return 0;
}

int hci_le_set_scan_enable(int dd, uint8_t enable, uint8_t filter_dup, int to)
{
    struct hci_request rq;
    le_set_scan_enable_cp scan_cp;
    uint8_t status;

    memset(&scan_cp, 0, sizeof(scan_cp));
    scan_cp.enable = enable;
    scan_cp.filter_dup = filter_dup;

    memset(&rq, 0, sizeof(rq));
    rq.ogf = OGF_LE_CTL;
    rq.ocf = OCF_LE_SET_SCAN_ENABLE;
    rq.cparam = &scan_cp;
    rq.clen = LE_SET_SCAN_ENABLE_CP_SIZE;
    rq.rparam = &status;
    rq.rlen = 1;

    if (hci_send_req(dd, &rq, to) < 0)
        return -1;

    if (status) {
        errno = EIO;
        return -1;
    }

    return 0;
}

int hci_le_set_scan_parameters(int dd, uint8_t type,
                    uint16_t interval, uint16_t window,
                    uint8_t own_type, uint8_t filter, int to)
{
    struct hci_request rq;
    le_set_scan_parameters_cp param_cp;
    uint8_t status;

    memset(&param_cp, 0, sizeof(param_cp));
    param_cp.type = type;
    param_cp.interval = interval;
    param_cp.window = window;
    param_cp.own_bdaddr_type = own_type;
    param_cp.filter = filter;

    memset(&rq, 0, sizeof(rq));
    rq.ogf = OGF_LE_CTL;
    rq.ocf = OCF_LE_SET_SCAN_PARAMETERS;
    rq.cparam = &param_cp;
    rq.clen = LE_SET_SCAN_PARAMETERS_CP_SIZE;
    rq.rparam = &status;
    rq.rlen = 1;

    if (hci_send_req(dd, &rq, to) < 0)
        return -1;

    if (status) {
        errno = EIO;
        return -1;
    }

    return 0;
}

int hci_le_set_advertise_enable(int dd, uint8_t enable, int to)
{
    struct hci_request rq;
    le_set_advertise_enable_cp adv_cp;
    uint8_t status;

    memset(&adv_cp, 0, sizeof(adv_cp));
    adv_cp.enable = enable;

    memset(&rq, 0, sizeof(rq));
    rq.ogf = OGF_LE_CTL;
    rq.ocf = OCF_LE_SET_ADVERTISE_ENABLE;
    rq.cparam = &adv_cp;
    rq.clen = LE_SET_ADVERTISE_ENABLE_CP_SIZE;
    rq.rparam = &status;
    rq.rlen = 1;

    if (hci_send_req(dd, &rq, to) < 0)
        return -1;

    if (status) {
        errno = EIO;
        return -1;
    }

    return 0;
}

int hci_le_create_conn(int dd, uint16_t interval, uint16_t window,
        uint8_t initiator_filter, uint8_t peer_bdaddr_type,
        bdaddr_t peer_bdaddr, uint8_t own_bdaddr_type,
        uint16_t min_interval, uint16_t max_interval,
        uint16_t latency, uint16_t supervision_timeout,
        uint16_t min_ce_length, uint16_t max_ce_length,
        uint16_t *handle, int to)
{
    struct hci_request rq;
    le_create_connection_cp create_conn_cp;
    evt_le_connection_complete conn_complete_rp;

    memset(&create_conn_cp, 0, sizeof(create_conn_cp));
    create_conn_cp.interval = interval;
    create_conn_cp.window = window;
    create_conn_cp.initiator_filter = initiator_filter;
    create_conn_cp.peer_bdaddr_type = peer_bdaddr_type;
    create_conn_cp.peer_bdaddr = peer_bdaddr;
    create_conn_cp.own_bdaddr_type = own_bdaddr_type;
    create_conn_cp.min_interval = min_interval;
    create_conn_cp.max_interval = max_interval;
    create_conn_cp.latency = latency;
    create_conn_cp.supervision_timeout = supervision_timeout;
    create_conn_cp.min_ce_length = min_ce_length;
    create_conn_cp.max_ce_length = max_ce_length;

    memset(&rq, 0, sizeof(rq));
    rq.ogf = OGF_LE_CTL;
    rq.ocf = OCF_LE_CREATE_CONN;
    rq.event = EVT_LE_CONN_COMPLETE;
    rq.cparam = &create_conn_cp;
    rq.clen = LE_CREATE_CONN_CP_SIZE;
    rq.rparam = &conn_complete_rp;
    rq.rlen = EVT_CONN_COMPLETE_SIZE;

    if (hci_send_req(dd, &rq, to) < 0)
        return -1;

    if (conn_complete_rp.status) {
        errno = EIO;
        return -1;
    }

    if (handle)
        *handle = conn_complete_rp.handle;

    return 0;
}

int hci_le_conn_update(int dd, uint16_t handle, uint16_t min_interval,
            uint16_t max_interval, uint16_t latency,
            uint16_t supervision_timeout, int to)
{
    evt_le_connection_update_complete evt;
    le_connection_update_cp cp;
    struct hci_request rq;

    memset(&cp, 0, sizeof(cp));
    cp.handle = handle;
    cp.min_interval = min_interval;
    cp.max_interval = max_interval;
    cp.latency = latency;
    cp.supervision_timeout = supervision_timeout;
    cp.min_ce_length = htobs(0x0001);
    cp.max_ce_length = htobs(0x0001);

    memset(&rq, 0, sizeof(rq));
    rq.ogf = OGF_LE_CTL;
    rq.ocf = OCF_LE_CONN_UPDATE;
    rq.cparam = &cp;
    rq.clen = LE_CONN_UPDATE_CP_SIZE;
    rq.event = EVT_LE_CONN_UPDATE_COMPLETE;
    rq.rparam = &evt;
    rq.rlen = sizeof(evt);

    if (hci_send_req(dd, &rq, to) < 0)
        return -1;

    if (evt.status) {
        errno = EIO;
        return -1;
    }

    return 0;
}

int hci_le_read_remote_features(int dd, uint16_t handle, uint8_t *features, int to)
{
    evt_le_read_remote_used_features_complete rp;
    le_read_remote_used_features_cp cp;
    struct hci_request rq;

    memset(&cp, 0, sizeof(cp));
    cp.handle = handle;

    memset(&rq, 0, sizeof(rq));
    rq.ogf    = OGF_LE_CTL;
    rq.ocf    = OCF_LE_READ_REMOTE_USED_FEATURES;
    rq.event  = EVT_LE_READ_REMOTE_USED_FEATURES_COMPLETE;
    rq.cparam = &cp;
    rq.clen   = LE_READ_REMOTE_USED_FEATURES_CP_SIZE;
    rq.rparam = &rp;
    rq.rlen   = EVT_LE_READ_REMOTE_USED_FEATURES_COMPLETE_SIZE;

    if (hci_send_req(dd, &rq, to) < 0)
        return -1;

    if (rp.status) {
        errno = EIO;
        return -1;
    }

    if (features)
        memcpy(features, rp.features, 8);

    return 0;
}