bluetooth/bluetooth.h

   1 /*
   2    BlueZ - Bluetooth protocol stack for Linux
   3    Copyright (C) 2000-2001 Qualcomm Incorporated
   4
   5    Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License version 2 as
   9    published by the Free Software Foundation;
  10
  11    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  12    OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  13    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
  14    IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
  15    CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
  16    WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  17    ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  18    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  19
  20    ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
  21    COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
  22    SOFTWARE IS DISCLAIMED.
  23 */
  24
  25 #ifndef __BLUETOOTH_H
  26 #define __BLUETOOTH_H
  27
  28 #include <linux/poll.h>
  29 #include <net/sock.h>
  30 #include <linux/seq_file.h>
  31
  32 #define BT_SUBSYS_VERSION       2
  33 #define BT_SUBSYS_REVISION      22
  34
  35 #ifndef AF_BLUETOOTH
  36 #define AF_BLUETOOTH    31
  37 #define PF_BLUETOOTH    AF_BLUETOOTH
  38 #endif
  39
  40 /* Bluetooth versions */
  41 #define BLUETOOTH_VER_1_1       1
  42 #define BLUETOOTH_VER_1_2       2
  43 #define BLUETOOTH_VER_2_0       3
  44 #define BLUETOOTH_VER_2_1       4
  45 #define BLUETOOTH_VER_4_0       6
  46
  47 /* Reserv for core and drivers use */
  48 #define BT_SKB_RESERVE  8
  49
  50 #define BTPROTO_L2CAP   0
  51 #define BTPROTO_HCI     1
  52 #define BTPROTO_SCO     2
  53 #define BTPROTO_RFCOMM  3
  54 #define BTPROTO_BNEP    4
  55 #define BTPROTO_CMTP    5
  56 #define BTPROTO_HIDP    6
  57 #define BTPROTO_AVDTP   7
  58 #define BTPROTO_ISO     8
  59 #define BTPROTO_LAST    BTPROTO_ISO
  60
  61 #define SOL_HCI         0
  62 #define SOL_L2CAP       6
  63 #define SOL_SCO         17
  64 #define SOL_RFCOMM      18
  65
  66 #define BT_SECURITY     4
  67 struct bt_security {
  68         __u8 level;
  69         __u8 key_size;
  70 };
  71 #define BT_SECURITY_SDP         0
  72 #define BT_SECURITY_LOW         1
  73 #define BT_SECURITY_MEDIUM      2
  74 #define BT_SECURITY_HIGH        3
  75 #define BT_SECURITY_FIPS        4
  76
  77 #define BT_DEFER_SETUP  7
  78
  79 #define BT_FLUSHABLE    8
  80
  81 #define BT_FLUSHABLE_OFF        0
  82 #define BT_FLUSHABLE_ON         1
  83
  84 #define BT_POWER        9
  85 struct bt_power {
  86         __u8 force_active;
  87 };
  88 #define BT_POWER_FORCE_ACTIVE_OFF 0
  89 #define BT_POWER_FORCE_ACTIVE_ON  1
  90
  91 #define BT_CHANNEL_POLICY       10
  92
  93 /* BR/EDR only (default policy)
  94  *   AMP controllers cannot be used.
  95  *   Channel move requests from the remote device are denied.
  96  *   If the L2CAP channel is currently using AMP, move the channel to BR/EDR.
  97  */
  98 #define BT_CHANNEL_POLICY_BREDR_ONLY            0
  99
 100 /* BR/EDR Preferred
 101  *   Allow use of AMP controllers.
 102  *   If the L2CAP channel is currently on AMP, move it to BR/EDR.
 103  *   Channel move requests from the remote device are allowed.
 104  */
 105 #define BT_CHANNEL_POLICY_BREDR_PREFERRED       1
 106
 107 /* AMP Preferred
 108  *   Allow use of AMP controllers
 109  *   If the L2CAP channel is currently on BR/EDR and AMP controller
 110  *     resources are available, initiate a channel move to AMP.
 111  *   Channel move requests from the remote device are allowed.
 112  *   If the L2CAP socket has not been connected yet, try to create
 113  *     and configure the channel directly on an AMP controller rather
 114  *     than BR/EDR.
 115  */
 116 #define BT_CHANNEL_POLICY_AMP_PREFERRED         2
 117
 118 #define BT_VOICE                11
 119 struct bt_voice {
 120         __u16 setting;
 121 };
 122
 123 #define BT_VOICE_TRANSPARENT                    0x0003
 124 #define BT_VOICE_CVSD_16BIT                     0x0060
 125
 126 #define BT_SNDMTU               12
 127 #define BT_RCVMTU               13
 128 #define BT_PHY                  14
 129
 130 #define BT_PHY_BR_1M_1SLOT      0x00000001
 131 #define BT_PHY_BR_1M_3SLOT      0x00000002
 132 #define BT_PHY_BR_1M_5SLOT      0x00000004
 133 #define BT_PHY_EDR_2M_1SLOT     0x00000008
 134 #define BT_PHY_EDR_2M_3SLOT     0x00000010
 135 #define BT_PHY_EDR_2M_5SLOT     0x00000020
 136 #define BT_PHY_EDR_3M_1SLOT     0x00000040
 137 #define BT_PHY_EDR_3M_3SLOT     0x00000080
 138 #define BT_PHY_EDR_3M_5SLOT     0x00000100
 139 #define BT_PHY_LE_1M_TX         0x00000200
 140 #define BT_PHY_LE_1M_RX         0x00000400
 141 #define BT_PHY_LE_2M_TX         0x00000800
 142 #define BT_PHY_LE_2M_RX         0x00001000
 143 #define BT_PHY_LE_CODED_TX      0x00002000
 144 #define BT_PHY_LE_CODED_RX      0x00004000
 145
 146 #define BT_MODE                 15
 147
 148 #define BT_MODE_BASIC           0x00
 149 #define BT_MODE_ERTM            0x01
 150 #define BT_MODE_STREAMING       0x02
 151 #define BT_MODE_LE_FLOWCTL      0x03
 152 #define BT_MODE_EXT_FLOWCTL     0x04
 153
 154 #define BT_PKT_STATUS           16
 155
 156 #define BT_SCM_PKT_STATUS       0x03
 157
 158 #define BT_ISO_QOS              17
 159
 160 #define BT_ISO_QOS_CIG_UNSET    0xff
 161 #define BT_ISO_QOS_CIS_UNSET    0xff
 162
 163 #define BT_ISO_QOS_BIG_UNSET    0xff
 164 #define BT_ISO_QOS_BIS_UNSET    0xff
 165
 166 struct bt_iso_io_qos {
 167         __u32 interval;
 168         __u16 latency;
 169         __u16 sdu;
 170         __u8  phy;
 171         __u8  rtn;
 172 };
 173
 174 struct bt_iso_qos {
 175         union {
 176                 __u8  cig;
 177                 __u8  big;
 178         };
 179         union {
 180                 __u8  cis;
 181                 __u8  bis;
 182         };
 183         union {
 184                 __u8  sca;
 185                 __u8  sync_interval;
 186         };
 187         __u8  packing;
 188         __u8  framing;
 189         struct bt_iso_io_qos in;
 190         struct bt_iso_io_qos out;
 191 };
 192
 193 #define BT_ISO_PHY_1M           0x01
 194 #define BT_ISO_PHY_2M           0x02
 195 #define BT_ISO_PHY_CODED        0x04
 196 #define BT_ISO_PHY_ANY          (BT_ISO_PHY_1M | BT_ISO_PHY_2M | \
 197                                  BT_ISO_PHY_CODED)
 198
 199 #define BT_CODEC        19
 200
 201 struct  bt_codec_caps {
 202         __u8    len;
 203         __u8    data[];
 204 } __packed;
 205
 206 struct bt_codec {
 207         __u8    id;
 208         __u16   cid;
 209         __u16   vid;
 210         __u8    data_path;
 211         __u8    num_caps;
 212 } __packed;
 213
 214 struct bt_codecs {
 215         __u8            num_codecs;
 216         struct bt_codec codecs[];
 217 } __packed;
 218
 219 #define BT_CODEC_CVSD           0x02
 220 #define BT_CODEC_TRANSPARENT    0x03
 221 #define BT_CODEC_MSBC           0x05
 222
 223 #define BT_ISO_BASE             20
 224
 225 __printf(1, 2)
 226 void bt_info(const char *fmt, ...);
 227 __printf(1, 2)
 228 void bt_warn(const char *fmt, ...);
 229 __printf(1, 2)
 230 void bt_err(const char *fmt, ...);
 231 #if IS_ENABLED(CONFIG_BT_FEATURE_DEBUG)
 232 void bt_dbg_set(bool enable);
 233 bool bt_dbg_get(void);
 234 __printf(1, 2)
 235 void bt_dbg(const char *fmt, ...);
 236 #endif
 237 __printf(1, 2)
 238 void bt_warn_ratelimited(const char *fmt, ...);
 239 __printf(1, 2)
 240 void bt_err_ratelimited(const char *fmt, ...);
 241
 242 #define BT_INFO(fmt, ...)       bt_info(fmt "\n", ##__VA_ARGS__)
 243 #define BT_WARN(fmt, ...)       bt_warn(fmt "\n", ##__VA_ARGS__)
 244 #define BT_ERR(fmt, ...)        bt_err(fmt "\n", ##__VA_ARGS__)
 245
 246 #if IS_ENABLED(CONFIG_BT_FEATURE_DEBUG)
 247 #define BT_DBG(fmt, ...)        bt_dbg(fmt "\n", ##__VA_ARGS__)
 248 #else
 249 #define BT_DBG(fmt, ...)        pr_debug(fmt "\n", ##__VA_ARGS__)
 250 #endif
 251
 252 #define bt_dev_name(hdev) ((hdev) ? (hdev)->name : "null")
 253
 254 #define bt_dev_info(hdev, fmt, ...)                             \
 255         BT_INFO("%s: " fmt, bt_dev_name(hdev), ##__VA_ARGS__)
 256 #define bt_dev_warn(hdev, fmt, ...)                             \
 257         BT_WARN("%s: " fmt, bt_dev_name(hdev), ##__VA_ARGS__)
 258 #define bt_dev_err(hdev, fmt, ...)                              \
 259         BT_ERR("%s: " fmt, bt_dev_name(hdev), ##__VA_ARGS__)
 260 #define bt_dev_dbg(hdev, fmt, ...)                              \
 261         BT_DBG("%s: " fmt, bt_dev_name(hdev), ##__VA_ARGS__)
 262
 263 #define bt_dev_warn_ratelimited(hdev, fmt, ...)                 \
 264         bt_warn_ratelimited("%s: " fmt, bt_dev_name(hdev), ##__VA_ARGS__)
 265 #define bt_dev_err_ratelimited(hdev, fmt, ...)                  \
 266         bt_err_ratelimited("%s: " fmt, bt_dev_name(hdev), ##__VA_ARGS__)
 267
 268 /* Connection and socket states */
 269 enum {
 270         BT_CONNECTED = 1, /* Equal to TCP_ESTABLISHED to make net code happy */
 271         BT_OPEN,
 272         BT_BOUND,
 273         BT_LISTEN,
 274         BT_CONNECT,
 275         BT_CONNECT2,
 276         BT_CONFIG,
 277         BT_DISCONN,
 278         BT_CLOSED
 279 };
 280
 281 /* If unused will be removed by compiler */
 282 static inline const char *state_to_string(int state)
 283 {
 284         switch (state) {
 285         case BT_CONNECTED:
 286                 return "BT_CONNECTED";
 287         case BT_OPEN:
 288                 return "BT_OPEN";
 289         case BT_BOUND:
 290                 return "BT_BOUND";
 291         case BT_LISTEN:
 292                 return "BT_LISTEN";
 293         case BT_CONNECT:
 294                 return "BT_CONNECT";
 295         case BT_CONNECT2:
 296                 return "BT_CONNECT2";
 297         case BT_CONFIG:
 298                 return "BT_CONFIG";
 299         case BT_DISCONN:
 300                 return "BT_DISCONN";
 301         case BT_CLOSED:
 302                 return "BT_CLOSED";
 303         }
 304
 305         return "invalid state";
 306 }
 307
 308 /* BD Address */
 309 typedef struct {
 310         __u8 b[6];
 311 } __packed bdaddr_t;
 312
 313 /* BD Address type */
 314 #define BDADDR_BREDR            0x00
 315 #define BDADDR_LE_PUBLIC        0x01
 316 #define BDADDR_LE_RANDOM        0x02
 317
 318 static inline bool bdaddr_type_is_valid(u8 type)
 319 {
 320         switch (type) {
 321         case BDADDR_BREDR:
 322         case BDADDR_LE_PUBLIC:
 323         case BDADDR_LE_RANDOM:
 324                 return true;
 325         }
 326
 327         return false;
 328 }
 329
 330 static inline bool bdaddr_type_is_le(u8 type)
 331 {
 332         switch (type) {
 333         case BDADDR_LE_PUBLIC:
 334         case BDADDR_LE_RANDOM:
 335                 return true;
 336         }
 337
 338         return false;
 339 }
 340
 341 #define BDADDR_ANY  (&(bdaddr_t) {{0, 0, 0, 0, 0, 0}})
 342 #define BDADDR_NONE (&(bdaddr_t) {{0xff, 0xff, 0xff, 0xff, 0xff, 0xff}})
 343
 344 /* Copy, swap, convert BD Address */
 345 static inline int bacmp(const bdaddr_t *ba1, const bdaddr_t *ba2)
 346 {
 347         return memcmp(ba1, ba2, sizeof(bdaddr_t));
 348 }
 349 static inline void bacpy(bdaddr_t *dst, const bdaddr_t *src)
 350 {
 351         memcpy(dst, src, sizeof(bdaddr_t));
 352 }
 353
 354 void baswap(bdaddr_t *dst, const bdaddr_t *src);
 355
 356 /* Common socket structures and functions */
 357
 358 #define bt_sk(__sk) ((struct bt_sock *) __sk)
 359
 360 struct bt_sock {
 361         struct sock sk;
 362         struct list_head accept_q;
 363         struct sock *parent;
 364         unsigned long flags;
 365         void (*skb_msg_name)(struct sk_buff *, void *, int *);
 366         void (*skb_put_cmsg)(struct sk_buff *, struct msghdr *, struct sock *);
 367 };
 368
 369 enum {
 370         BT_SK_DEFER_SETUP,
 371         BT_SK_SUSPEND,
 372 };
 373
 374 struct bt_sock_list {
 375         struct hlist_head head;
 376         rwlock_t          lock;
 377 #ifdef CONFIG_PROC_FS
 378         int (* custom_seq_show)(struct seq_file *, void *);
 379 #endif
 380 };
 381
 382 int  bt_sock_register(int proto, const struct net_proto_family *ops);
 383 void bt_sock_unregister(int proto);
 384 void bt_sock_link(struct bt_sock_list *l, struct sock *s);
 385 void bt_sock_unlink(struct bt_sock_list *l, struct sock *s);
 386 int  bt_sock_recvmsg(struct socket *sock, struct msghdr *msg, size_t len,
 387                      int flags);
 388 int  bt_sock_stream_recvmsg(struct socket *sock, struct msghdr *msg,
 389                             size_t len, int flags);
 390 __poll_t bt_sock_poll(struct file *file, struct socket *sock, poll_table *wait);
 391 int  bt_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg);
 392 int  bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo);
 393 int  bt_sock_wait_ready(struct sock *sk, unsigned int msg_flags);
 394
 395 void bt_accept_enqueue(struct sock *parent, struct sock *sk, bool bh);
 396 void bt_accept_unlink(struct sock *sk);
 397 struct sock *bt_accept_dequeue(struct sock *parent, struct socket *newsock);
 398
 399 /* Skb helpers */
 400 struct l2cap_ctrl {
 401         u8      sframe:1,
 402                 poll:1,
 403                 final:1,
 404                 fcs:1,
 405                 sar:2,
 406                 super:2;
 407
 408         u16     reqseq;
 409         u16     txseq;
 410         u8      retries;
 411         __le16  psm;
 412         bdaddr_t bdaddr;
 413         struct l2cap_chan *chan;
 414 };
 415
 416 struct sco_ctrl {
 417         u8      pkt_status;
 418 };
 419
 420 struct hci_dev;
 421
 422 typedef void (*hci_req_complete_t)(struct hci_dev *hdev, u8 status, u16 opcode);
 423 typedef void (*hci_req_complete_skb_t)(struct hci_dev *hdev, u8 status,
 424                                        u16 opcode, struct sk_buff *skb);
 425
 426 #define HCI_REQ_START   BIT(0)
 427 #define HCI_REQ_SKB     BIT(1)
 428
 429 struct hci_ctrl {
 430         struct sock *sk;
 431         u16 opcode;
 432         u8 req_flags;
 433         u8 req_event;
 434         union {
 435                 hci_req_complete_t req_complete;
 436                 hci_req_complete_skb_t req_complete_skb;
 437         };
 438 };
 439
 440 struct mgmt_ctrl {
 441         struct hci_dev *hdev;
 442         u16 opcode;
 443 };
 444
 445 struct bt_skb_cb {
 446         u8 pkt_type;
 447         u8 force_active;
 448         u16 expect;
 449         u8 incoming:1;
 450         union {
 451                 struct l2cap_ctrl l2cap;
 452                 struct sco_ctrl sco;
 453                 struct hci_ctrl hci;
 454                 struct mgmt_ctrl mgmt;
 455         };
 456 };
 457 #define bt_cb(skb) ((struct bt_skb_cb *)((skb)->cb))
 458
 459 #define hci_skb_pkt_type(skb) bt_cb((skb))->pkt_type
 460 #define hci_skb_expect(skb) bt_cb((skb))->expect
 461 #define hci_skb_opcode(skb) bt_cb((skb))->hci.opcode
 462 #define hci_skb_event(skb) bt_cb((skb))->hci.req_event
 463 #define hci_skb_sk(skb) bt_cb((skb))->hci.sk
 464
 465 static inline struct sk_buff *bt_skb_alloc(unsigned int len, gfp_t how)
 466 {
 467         struct sk_buff *skb;
 468
 469         skb = alloc_skb(len + BT_SKB_RESERVE, how);
 470         if (skb)
 471                 skb_reserve(skb, BT_SKB_RESERVE);
 472         return skb;
 473 }
 474
 475 static inline struct sk_buff *bt_skb_send_alloc(struct sock *sk,
 476                                         unsigned long len, int nb, int *err)
 477 {
 478         struct sk_buff *skb;
 479
 480         skb = sock_alloc_send_skb(sk, len + BT_SKB_RESERVE, nb, err);
 481         if (skb)
 482                 skb_reserve(skb, BT_SKB_RESERVE);
 483
 484         if (!skb && *err)
 485                 return NULL;
 486
 487         *err = sock_error(sk);
 488         if (*err)
 489                 goto out;
 490
 491         if (sk->sk_shutdown) {
 492                 *err = -ECONNRESET;
 493                 goto out;
 494         }
 495
 496         return skb;
 497
 498 out:
 499         kfree_skb(skb);
 500         return NULL;
 501 }
 502
 503 /* Shall not be called with lock_sock held */
 504 static inline struct sk_buff *bt_skb_sendmsg(struct sock *sk,
 505                                              struct msghdr *msg,
 506                                              size_t len, size_t mtu,
 507                                              size_t headroom, size_t tailroom)
 508 {
 509         struct sk_buff *skb;
 510         size_t size = min_t(size_t, len, mtu);
 511         int err;
 512
 513         skb = bt_skb_send_alloc(sk, size + headroom + tailroom,
 514                                 msg->msg_flags & MSG_DONTWAIT, &err);
 515         if (!skb)
 516                 return ERR_PTR(err);
 517
 518         skb_reserve(skb, headroom);
 519         skb_tailroom_reserve(skb, mtu, tailroom);
 520
 521         if (!copy_from_iter_full(skb_put(skb, size), size, &msg->msg_iter)) {
 522                 kfree_skb(skb);
 523                 return ERR_PTR(-EFAULT);
 524         }
 525
 526         skb->priority = sk->sk_priority;
 527
 528         return skb;
 529 }
 530
 531 /* Similar to bt_skb_sendmsg but can split the msg into multiple fragments
 532  * accourding to the MTU.
 533  */
 534 static inline struct sk_buff *bt_skb_sendmmsg(struct sock *sk,
 535                                               struct msghdr *msg,
 536                                               size_t len, size_t mtu,
 537                                               size_t headroom, size_t tailroom)
 538 {
 539         struct sk_buff *skb, **frag;
 540
 541         skb = bt_skb_sendmsg(sk, msg, len, mtu, headroom, tailroom);
 542         if (IS_ERR(skb))
 543                 return skb;
 544
 545         len -= skb->len;
 546         if (!len)
 547                 return skb;
 548
 549         /* Add remaining data over MTU as continuation fragments */
 550         frag = &skb_shinfo(skb)->frag_list;
 551         while (len) {
 552                 struct sk_buff *tmp;
 553
 554                 tmp = bt_skb_sendmsg(sk, msg, len, mtu, headroom, tailroom);
 555                 if (IS_ERR(tmp)) {
 556                         return skb;
 557                 }
 558
 559                 len -= tmp->len;
 560
 561                 *frag = tmp;
 562                 frag = &(*frag)->next;
 563         }
 564
 565         return skb;
 566 }
 567
 568 int bt_to_errno(u16 code);
 569 __u8 bt_status(int err);
 570
 571 void hci_sock_set_flag(struct sock *sk, int nr);
 572 void hci_sock_clear_flag(struct sock *sk, int nr);
 573 int hci_sock_test_flag(struct sock *sk, int nr);
 574 unsigned short hci_sock_get_channel(struct sock *sk);
 575 u32 hci_sock_get_cookie(struct sock *sk);
 576
 577 int hci_sock_init(void);
 578 void hci_sock_cleanup(void);
 579
 580 int bt_sysfs_init(void);
 581 void bt_sysfs_cleanup(void);
 582
 583 int bt_procfs_init(struct net *net, const char *name,
 584                    struct bt_sock_list *sk_list,
 585                    int (*seq_show)(struct seq_file *, void *));
 586 void bt_procfs_cleanup(struct net *net, const char *name);
 587
 588 extern struct dentry *bt_debugfs;
 589
 590 int l2cap_init(void);
 591 void l2cap_exit(void);
 592
 593 #if IS_ENABLED(CONFIG_BT_BREDR)
 594 int sco_init(void);
 595 void sco_exit(void);
 596 #else
 597 static inline int sco_init(void)
 598 {
 599         return 0;
 600 }
 601
 602 static inline void sco_exit(void)
 603 {
 604 }
 605 #endif
 606
 607 #if IS_ENABLED(CONFIG_BT_LE)
 608 int iso_init(void);
 609 int iso_exit(void);
 610 bool iso_enabled(void);
 611 #else
 612 static inline int iso_init(void)
 613 {
 614         return 0;
 615 }
 616
 617 static inline int iso_exit(void)
 618 {
 619         return 0;
 620 }
 621
 622 static inline bool iso_enabled(void)
 623 {
 624         return false;
 625 }
 626 #endif
 627
 628 int mgmt_init(void);
 629 void mgmt_exit(void);
 630
 631 void bt_sock_reclassify_lock(struct sock *sk, int proto);
 632
 633 #endif /* __BLUETOOTH_H */