| /* |
| * |
| * 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"; |
| case HCI_SPI: |
| return "SPI"; |
| case HCI_I2C: |
| return "I2C"; |
| default: |
| return "Unknown"; |
| } |
| } |
| |
| char *hci_dtypetostr(int type) |
| { |
| return hci_bustostr(type & 0x0f); |
| } |
| |
| char *hci_typetostr(int type) |
| { |
| switch (type) { |
| case HCI_PRIMARY: |
| return "Primary"; |
| 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 } |
| }; |
| |
| 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; |
| } |
| |
| /* Open HCI device. |
| * Returns device descriptor (dd). */ |
| 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 |
| * dd - Device descriptor returned by hci_open_dev. */ |
| |
| 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_page_scan_type(int dd, uint8_t *type, int to) |
| { |
| read_page_scan_type_rp rp; |
| struct hci_request rq; |
| |
| memset(&rq, 0, sizeof(rq)); |
| rq.ogf = OGF_HOST_CTL; |
| rq.ocf = OCF_READ_PAGE_SCAN_TYPE; |
| rq.rparam = &rp; |
| rq.rlen = READ_PAGE_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_page_scan_type(int dd, uint8_t type, int to) |
| { |
| write_page_scan_type_cp cp; |
| write_page_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_PAGE_SCAN_TYPE; |
| rq.cparam = &cp; |
| rq.clen = WRITE_PAGE_SCAN_TYPE_CP_SIZE; |
| rq.rparam = &rp; |
| rq.rlen = WRITE_PAGE_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; |
|