lib/bluetooth.h

   1 /*
   2  *
   3  *  BlueZ - Bluetooth protocol stack for Linux
   4  *
   5  *  Copyright (C) 2000-2001  Qualcomm Incorporated
   6  *  Copyright (C) 2002-2003  Maxim Krasnyansky <maxk@qualcomm.com>
   7  *  Copyright (C) 2002-2010  Marcel Holtmann <marcel@holtmann.org>
   8  *
   9  *
  10  *  This program is free software; you can redistribute it and/or modify
  11  *  it under the terms of the GNU General Public License as published by
  12  *  the Free Software Foundation; either version 2 of the License, or
  13  *  (at your option) any later version.
  14  *
  15  *  This program is distributed in the hope that it will be useful,
  16  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  *  GNU General Public License for more details.
  19  *
  20  *  You should have received a copy of the GNU General Public License
  21  *  along with this program; if not, write to the Free Software
  22  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  23  *
  24  */
  25
  26 #ifndef __BLUETOOTH_H
  27 #define __BLUETOOTH_H
  28
  29 #ifdef __cplusplus
  30 extern "C" {
  31 #endif
  32
  33 #include <stdio.h>
  34 #include <stdint.h>
  35 #include <string.h>
  36 #include <endian.h>
  37 #include <byteswap.h>
  38 #include <netinet/in.h>
  39
  40 #ifndef AF_BLUETOOTH
  41 #define AF_BLUETOOTH    31
  42 #define PF_BLUETOOTH    AF_BLUETOOTH
  43 #endif
  44
  45 #define BTPROTO_L2CAP   0
  46 #define BTPROTO_HCI     1
  47 #define BTPROTO_SCO     2
  48 #define BTPROTO_RFCOMM  3
  49 #define BTPROTO_BNEP    4
  50 #define BTPROTO_CMTP    5
  51 #define BTPROTO_HIDP    6
  52 #define BTPROTO_AVDTP   7
  53
  54 #define SOL_HCI         0
  55 #define SOL_L2CAP       6
  56 #define SOL_SCO         17
  57 #define SOL_RFCOMM      18
  58
  59 #ifndef SOL_BLUETOOTH
  60 #define SOL_BLUETOOTH   274
  61 #endif
  62
  63 #define BT_SECURITY     4
  64 struct bt_security {
  65         uint8_t level;
  66         uint8_t key_size;
  67 };
  68 #define BT_SECURITY_SDP         0
  69 #define BT_SECURITY_LOW         1
  70 #define BT_SECURITY_MEDIUM      2
  71 #define BT_SECURITY_HIGH        3
  72
  73 #define BT_DEFER_SETUP  7
  74
  75 #define BT_FLUSHABLE    8
  76
  77 #define BT_FLUSHABLE_OFF        0
  78 #define BT_FLUSHABLE_ON         1
  79
  80 #define BT_POWER                9
  81 struct bt_power {
  82         uint8_t force_active;
  83 };
  84 #define BT_POWER_FORCE_ACTIVE_OFF 0
  85 #define BT_POWER_FORCE_ACTIVE_ON  1
  86
  87 #define BT_CHANNEL_POLICY       10
  88
  89 /* BR/EDR only (default policy)
  90  *   AMP controllers cannot be used.
  91  *   Channel move requests from the remote device are denied.
  92  *   If the L2CAP channel is currently using AMP, move the channel to BR/EDR.
  93  */
  94 #define BT_CHANNEL_POLICY_BREDR_ONLY            0
  95
  96 /* BR/EDR Preferred
  97  *   Allow use of AMP controllers.
  98  *   If the L2CAP channel is currently on AMP, move it to BR/EDR.
  99  *   Channel move requests from the remote device are allowed.
 100  */
 101 #define BT_CHANNEL_POLICY_BREDR_PREFERRED       1
 102
 103 /* AMP Preferred
 104  *   Allow use of AMP controllers
 105  *   If the L2CAP channel is currently on BR/EDR and AMP controller
 106  *     resources are available, initiate a channel move to AMP.
 107  *   Channel move requests from the remote device are allowed.
 108  *   If the L2CAP socket has not been connected yet, try to create
 109  *     and configure the channel directly on an AMP controller rather
 110  *     than BR/EDR.
 111  */
 112 #define BT_CHANNEL_POLICY_AMP_PREFERRED         2
 113
 114 #define BT_VOICE                11
 115 struct bt_voice {
 116         uint16_t setting;
 117 };
 118
 119 #define BT_SNDMTU               12
 120 #define BT_RCVMTU               13
 121
 122 #ifdef __TIZEN_PATCH__
 123 #define BT_LE_CONN_PARAM        14
 124 struct le_conn_param {
 125         uint16_t min;
 126         uint16_t max;
 127         uint16_t latency;
 128         uint16_t to_multiplier;
 129 };
 130 #endif
 131
 132 #define BT_VOICE_TRANSPARENT                    0x0003
 133 #define BT_VOICE_CVSD_16BIT                     0x0060
 134
 135 /* Connection and socket states */
 136 enum {
 137         BT_CONNECTED = 1, /* Equal to TCP_ESTABLISHED to make net code happy */
 138         BT_OPEN,
 139         BT_BOUND,
 140         BT_LISTEN,
 141         BT_CONNECT,
 142         BT_CONNECT2,
 143         BT_CONFIG,
 144         BT_DISCONN,
 145         BT_CLOSED
 146 };
 147
 148 /* Byte order conversions */
 149 #if __BYTE_ORDER == __LITTLE_ENDIAN
 150 #define htobs(d)  (d)
 151 #define htobl(d)  (d)
 152 #define htobll(d) (d)
 153 #define btohs(d)  (d)
 154 #define btohl(d)  (d)
 155 #define btohll(d) (d)
 156 #elif __BYTE_ORDER == __BIG_ENDIAN
 157 #define htobs(d)  bswap_16(d)
 158 #define htobl(d)  bswap_32(d)
 159 #define htobll(d) bswap_64(d)
 160 #define btohs(d)  bswap_16(d)
 161 #define btohl(d)  bswap_32(d)
 162 #define btohll(d) bswap_64(d)
 163 #else
 164 #error "Unknown byte order"
 165 #endif
 166
 167 /* Bluetooth unaligned access */
 168 #define bt_get_unaligned(ptr)                   \
 169 __extension__ ({                                \
 170         struct __attribute__((packed)) {        \
 171                 __typeof__(*(ptr)) __v;         \
 172         } *__p = (__typeof__(__p)) (ptr);       \
 173         __p->__v;                               \
 174 })
 175
 176 #define bt_put_unaligned(val, ptr)              \
 177 do {                                            \
 178         struct __attribute__((packed)) {        \
 179                 __typeof__(*(ptr)) __v;         \
 180         } *__p = (__typeof__(__p)) (ptr);       \
 181         __p->__v = (val);                       \
 182 } while(0)
 183
 184 #if __BYTE_ORDER == __LITTLE_ENDIAN
 185 static inline uint64_t bt_get_le64(const void *ptr)
 186 {
 187         return bt_get_unaligned((const uint64_t *) ptr);
 188 }
 189
 190 static inline uint64_t bt_get_be64(const void *ptr)
 191 {
 192         return bswap_64(bt_get_unaligned((const uint64_t *) ptr));
 193 }
 194
 195 static inline uint32_t bt_get_le32(const void *ptr)
 196 {
 197         return bt_get_unaligned((const uint32_t *) ptr);
 198 }
 199
 200 static inline uint32_t bt_get_be32(const void *ptr)
 201 {
 202         return bswap_32(bt_get_unaligned((const uint32_t *) ptr));
 203 }
 204
 205 static inline uint16_t bt_get_le16(const void *ptr)
 206 {
 207         return bt_get_unaligned((const uint16_t *) ptr);
 208 }
 209
 210 static inline uint16_t bt_get_be16(const void *ptr)
 211 {
 212         return bswap_16(bt_get_unaligned((const uint16_t *) ptr));
 213 }
 214
 215 static inline void bt_put_le64(uint64_t val, const void *ptr)
 216 {
 217         bt_put_unaligned(val, (uint64_t *) ptr);
 218 }
 219
 220 static inline void bt_put_be64(uint64_t val, const void *ptr)
 221 {
 222         bt_put_unaligned(bswap_64(val), (uint64_t *) ptr);
 223 }
 224
 225 static inline void bt_put_le32(uint32_t val, const void *ptr)
 226 {
 227         bt_put_unaligned(val, (uint32_t *) ptr);
 228 }
 229
 230 static inline void bt_put_be32(uint32_t val, const void *ptr)
 231 {
 232         bt_put_unaligned(bswap_32(val), (uint32_t *) ptr);
 233 }
 234
 235 static inline void bt_put_le16(uint16_t val, const void *ptr)
 236 {
 237         bt_put_unaligned(val, (uint16_t *) ptr);
 238 }
 239
 240 static inline void bt_put_be16(uint16_t val, const void *ptr)
 241 {
 242         bt_put_unaligned(bswap_16(val), (uint16_t *) ptr);
 243 }
 244
 245 #elif __BYTE_ORDER == __BIG_ENDIAN
 246 static inline uint64_t bt_get_le64(const void *ptr)
 247 {
 248         return bswap_64(bt_get_unaligned((const uint64_t *) ptr));
 249 }
 250
 251 static inline uint64_t bt_get_be64(const void *ptr)
 252 {
 253         return bt_get_unaligned((const uint64_t *) ptr);
 254 }
 255
 256 static inline uint32_t bt_get_le32(const void *ptr)
 257 {
 258         return bswap_32(bt_get_unaligned((const uint32_t *) ptr));
 259 }
 260
 261 static inline uint32_t bt_get_be32(const void *ptr)
 262 {
 263         return bt_get_unaligned((const uint32_t *) ptr);
 264 }
 265
 266 static inline uint16_t bt_get_le16(const void *ptr)
 267 {
 268         return bswap_16(bt_get_unaligned((const uint16_t *) ptr));
 269 }
 270
 271 static inline uint16_t bt_get_be16(const void *ptr)
 272 {
 273         return bt_get_unaligned((const uint16_t *) ptr);
 274 }
 275
 276 static inline void bt_put_le64(uint64_t val, const void *ptr)
 277 {
 278         bt_put_unaligned(bswap_64(val), (uint64_t *) ptr);
 279 }
 280
 281 static inline void bt_put_be64(uint64_t val, const void *ptr)
 282 {
 283         bt_put_unaligned(val, (uint64_t *) ptr);
 284 }
 285
 286 static inline void bt_put_le32(uint32_t val, const void *ptr)
 287 {
 288         bt_put_unaligned(bswap_32(val), (uint32_t *) ptr);
 289 }
 290
 291 static inline void bt_put_be32(uint32_t val, const void *ptr)
 292 {
 293         bt_put_unaligned(val, (uint32_t *) ptr);
 294 }
 295
 296 static inline void bt_put_le16(uint16_t val, const void *ptr)
 297 {
 298         bt_put_unaligned(bswap_16(val), (uint16_t *) ptr);
 299 }
 300
 301 static inline void bt_put_be16(uint16_t val, const void *ptr)
 302 {
 303         bt_put_unaligned(val, (uint16_t *) ptr);
 304 }
 305 #else
 306 #error "Unknown byte order"
 307 #endif
 308
 309 /* BD Address */
 310 typedef struct {
 311         uint8_t b[6];
 312 } __attribute__((packed)) bdaddr_t;
 313
 314 /* BD Address type */
 315 #define BDADDR_BREDR           0x00
 316 #define BDADDR_LE_PUBLIC       0x01
 317 #define BDADDR_LE_RANDOM       0x02
 318
 319 #define BDADDR_ANY   (&(bdaddr_t) {{0, 0, 0, 0, 0, 0}})
 320 #define BDADDR_ALL   (&(bdaddr_t) {{0xff, 0xff, 0xff, 0xff, 0xff, 0xff}})
 321 #define BDADDR_LOCAL (&(bdaddr_t) {{0, 0, 0, 0xff, 0xff, 0xff}})
 322
 323 /* Copy, swap, convert BD Address */
 324 static inline int bacmp(const bdaddr_t *ba1, const bdaddr_t *ba2)
 325 {
 326         return memcmp(ba1, ba2, sizeof(bdaddr_t));
 327 }
 328 static inline void bacpy(bdaddr_t *dst, const bdaddr_t *src)
 329 {
 330         memcpy(dst, src, sizeof(bdaddr_t));
 331 }
 332
 333 void baswap(bdaddr_t *dst, const bdaddr_t *src);
 334 bdaddr_t *strtoba(const char *str);
 335 char *batostr(const bdaddr_t *ba);
 336 int ba2str(const bdaddr_t *ba, char *str);
 337 int str2ba(const char *str, bdaddr_t *ba);
 338 int ba2oui(const bdaddr_t *ba, char *oui);
 339 int bachk(const char *str);
 340
 341 int baprintf(const char *format, ...);
 342 int bafprintf(FILE *stream, const char *format, ...);
 343 int basprintf(char *str, const char *format, ...);
 344 int basnprintf(char *str, size_t size, const char *format, ...);
 345
 346 void *bt_malloc(size_t size);
 347 void bt_free(void *ptr);
 348
 349 int bt_error(uint16_t code);
 350 const char *bt_compidtostr(int id);
 351
 352 typedef struct {
 353         uint8_t data[16];
 354 } uint128_t;
 355
 356 static inline void bswap_128(const void *src, void *dst)
 357 {
 358         const uint8_t *s = (const uint8_t *) src;
 359         uint8_t *d = (uint8_t *) dst;
 360         int i;
 361
 362         for (i = 0; i < 16; i++)
 363                 d[15 - i] = s[i];
 364 }
 365
 366 #if __BYTE_ORDER == __BIG_ENDIAN
 367
 368 #define ntoh64(x) (x)
 369
 370 static inline void ntoh128(const uint128_t *src, uint128_t *dst)
 371 {
 372         memcpy(dst, src, sizeof(uint128_t));
 373 }
 374
 375 static inline void btoh128(const uint128_t *src, uint128_t *dst)
 376 {
 377         bswap_128(src, dst);
 378 }
 379
 380 #else
 381
 382 static inline uint64_t ntoh64(uint64_t n)
 383 {
 384         uint64_t h;
 385         uint64_t tmp = ntohl(n & 0x00000000ffffffff);
 386
 387         h = ntohl(n >> 32);
 388         h |= tmp << 32;
 389
 390         return h;
 391 }
 392
 393 static inline void ntoh128(const uint128_t *src, uint128_t *dst)
 394 {
 395         bswap_128(src, dst);
 396 }
 397
 398 static inline void btoh128(const uint128_t *src, uint128_t *dst)
 399 {
 400         memcpy(dst, src, sizeof(uint128_t));
 401 }
 402
 403 #endif
 404
 405 #define hton64(x)     ntoh64(x)
 406 #define hton128(x, y) ntoh128(x, y)
 407 #define htob128(x, y) btoh128(x, y)
 408
 409 #ifdef __cplusplus
 410 }
 411 #endif
 412
 413 #endif /* __BLUETOOTH_H */