1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
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
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
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
59#define SOL_HCI 0
60#define SOL_L2CAP 6
61#define SOL_SCO 17
62#define SOL_RFCOMM 18
63
64#define BT_SECURITY 4
65struct bt_security {
66 __u8 level;
67 __u8 key_size;
68};
69#define BT_SECURITY_SDP 0
70#define BT_SECURITY_LOW 1
71#define BT_SECURITY_MEDIUM 2
72#define BT_SECURITY_HIGH 3
73#define BT_SECURITY_FIPS 4
74
75#define BT_DEFER_SETUP 7
76
77#define BT_FLUSHABLE 8
78
79#define BT_FLUSHABLE_OFF 0
80#define BT_FLUSHABLE_ON 1
81
82#define BT_POWER 9
83struct bt_power {
84 __u8 force_active;
85};
86#define BT_POWER_FORCE_ACTIVE_OFF 0
87#define BT_POWER_FORCE_ACTIVE_ON 1
88
89#define BT_CHANNEL_POLICY 10
90
91
92
93
94
95
96#define BT_CHANNEL_POLICY_BREDR_ONLY 0
97
98
99
100
101
102
103#define BT_CHANNEL_POLICY_BREDR_PREFERRED 1
104
105
106
107
108
109
110
111
112
113
114#define BT_CHANNEL_POLICY_AMP_PREFERRED 2
115
116#define BT_VOICE 11
117struct bt_voice {
118 __u16 setting;
119};
120
121#define BT_VOICE_TRANSPARENT 0x0003
122#define BT_VOICE_CVSD_16BIT 0x0060
123
124#define BT_SNDMTU 12
125#define BT_RCVMTU 13
126#define BT_PHY 14
127
128#define BT_PHY_BR_1M_1SLOT 0x00000001
129#define BT_PHY_BR_1M_3SLOT 0x00000002
130#define BT_PHY_BR_1M_5SLOT 0x00000004
131#define BT_PHY_EDR_2M_1SLOT 0x00000008
132#define BT_PHY_EDR_2M_3SLOT 0x00000010
133#define BT_PHY_EDR_2M_5SLOT 0x00000020
134#define BT_PHY_EDR_3M_1SLOT 0x00000040
135#define BT_PHY_EDR_3M_3SLOT 0x00000080
136#define BT_PHY_EDR_3M_5SLOT 0x00000100
137#define BT_PHY_LE_1M_TX 0x00000200
138#define BT_PHY_LE_1M_RX 0x00000400
139#define BT_PHY_LE_2M_TX 0x00000800
140#define BT_PHY_LE_2M_RX 0x00001000
141#define BT_PHY_LE_CODED_TX 0x00002000
142#define BT_PHY_LE_CODED_RX 0x00004000
143
144#define BT_MODE 15
145
146#define BT_MODE_BASIC 0x00
147#define BT_MODE_ERTM 0x01
148#define BT_MODE_STREAMING 0x02
149#define BT_MODE_LE_FLOWCTL 0x03
150#define BT_MODE_EXT_FLOWCTL 0x04
151
152#define BT_PKT_STATUS 16
153
154#define BT_SCM_PKT_STATUS 0x03
155
156#define BT_CODEC 19
157
158struct bt_codec_caps {
159 __u8 len;
160 __u8 data[];
161} __packed;
162
163struct bt_codec {
164 __u8 id;
165 __u16 cid;
166 __u16 vid;
167 __u8 data_path;
168 __u8 num_caps;
169} __packed;
170
171struct bt_codecs {
172 __u8 num_codecs;
173 struct bt_codec codecs[];
174} __packed;
175
176#define BT_CODEC_CVSD 0x02
177#define BT_CODEC_TRANSPARENT 0x03
178#define BT_CODEC_MSBC 0x05
179
180__printf(1, 2)
181void bt_info(const char *fmt, ...);
182__printf(1, 2)
183void bt_warn(const char *fmt, ...);
184__printf(1, 2)
185void bt_err(const char *fmt, ...);
186#if IS_ENABLED(CONFIG_BT_FEATURE_DEBUG)
187void bt_dbg_set(bool enable);
188bool bt_dbg_get(void);
189__printf(1, 2)
190void bt_dbg(const char *fmt, ...);
191#endif
192__printf(1, 2)
193void bt_warn_ratelimited(const char *fmt, ...);
194__printf(1, 2)
195void bt_err_ratelimited(const char *fmt, ...);
196
197#define BT_INFO(fmt, ...) bt_info(fmt "\n", ##__VA_ARGS__)
198#define BT_WARN(fmt, ...) bt_warn(fmt "\n", ##__VA_ARGS__)
199#define BT_ERR(fmt, ...) bt_err(fmt "\n", ##__VA_ARGS__)
200
201#if IS_ENABLED(CONFIG_BT_FEATURE_DEBUG)
202#define BT_DBG(fmt, ...) bt_dbg(fmt "\n", ##__VA_ARGS__)
203#else
204#define BT_DBG(fmt, ...) pr_debug(fmt "\n", ##__VA_ARGS__)
205#endif
206
207#define bt_dev_info(hdev, fmt, ...) \
208 BT_INFO("%s: " fmt, (hdev)->name, ##__VA_ARGS__)
209#define bt_dev_warn(hdev, fmt, ...) \
210 BT_WARN("%s: " fmt, (hdev)->name, ##__VA_ARGS__)
211#define bt_dev_err(hdev, fmt, ...) \
212 BT_ERR("%s: " fmt, (hdev)->name, ##__VA_ARGS__)
213#define bt_dev_dbg(hdev, fmt, ...) \
214 BT_DBG("%s: " fmt, (hdev)->name, ##__VA_ARGS__)
215
216#define bt_dev_warn_ratelimited(hdev, fmt, ...) \
217 bt_warn_ratelimited("%s: " fmt, (hdev)->name, ##__VA_ARGS__)
218#define bt_dev_err_ratelimited(hdev, fmt, ...) \
219 bt_err_ratelimited("%s: " fmt, (hdev)->name, ##__VA_ARGS__)
220
221
222enum {
223 BT_CONNECTED = 1,
224 BT_OPEN,
225 BT_BOUND,
226 BT_LISTEN,
227 BT_CONNECT,
228 BT_CONNECT2,
229 BT_CONFIG,
230 BT_DISCONN,
231 BT_CLOSED
232};
233
234
235static inline const char *state_to_string(int state)
236{
237 switch (state) {
238 case BT_CONNECTED:
239 return "BT_CONNECTED";
240 case BT_OPEN:
241 return "BT_OPEN";
242 case BT_BOUND:
243 return "BT_BOUND";
244 case BT_LISTEN:
245 return "BT_LISTEN";
246 case BT_CONNECT:
247 return "BT_CONNECT";
248 case BT_CONNECT2:
249 return "BT_CONNECT2";
250 case BT_CONFIG:
251 return "BT_CONFIG";
252 case BT_DISCONN:
253 return "BT_DISCONN";
254 case BT_CLOSED:
255 return "BT_CLOSED";
256 }
257
258 return "invalid state";
259}
260
261
262typedef struct {
263 __u8 b[6];
264} __packed bdaddr_t;
265
266
267#define BDADDR_BREDR 0x00
268#define BDADDR_LE_PUBLIC 0x01
269#define BDADDR_LE_RANDOM 0x02
270
271static inline bool bdaddr_type_is_valid(u8 type)
272{
273 switch (type) {
274 case BDADDR_BREDR:
275 case BDADDR_LE_PUBLIC:
276 case BDADDR_LE_RANDOM:
277 return true;
278 }
279
280 return false;
281}
282
283static inline bool bdaddr_type_is_le(u8 type)
284{
285 switch (type) {
286 case BDADDR_LE_PUBLIC:
287 case BDADDR_LE_RANDOM:
288 return true;
289 }
290
291 return false;
292}
293
294#define BDADDR_ANY (&(bdaddr_t) {{0, 0, 0, 0, 0, 0}})
295#define BDADDR_NONE (&(bdaddr_t) {{0xff, 0xff, 0xff, 0xff, 0xff, 0xff}})
296
297
298static inline int bacmp(const bdaddr_t *ba1, const bdaddr_t *ba2)
299{
300 return memcmp(ba1, ba2, sizeof(bdaddr_t));
301}
302static inline void bacpy(bdaddr_t *dst, const bdaddr_t *src)
303{
304 memcpy(dst, src, sizeof(bdaddr_t));
305}
306
307void baswap(bdaddr_t *dst, const bdaddr_t *src);
308
309
310
311#define bt_sk(__sk) ((struct bt_sock *) __sk)
312
313struct bt_sock {
314 struct sock sk;
315 struct list_head accept_q;
316 struct sock *parent;
317 unsigned long flags;
318 void (*skb_msg_name)(struct sk_buff *, void *, int *);
319 void (*skb_put_cmsg)(struct sk_buff *, struct msghdr *, struct sock *);
320};
321
322enum {
323 BT_SK_DEFER_SETUP,
324 BT_SK_SUSPEND,
325};
326
327struct bt_sock_list {
328 struct hlist_head head;
329 rwlock_t lock;
330#ifdef CONFIG_PROC_FS
331 int (* custom_seq_show)(struct seq_file *, void *);
332#endif
333};
334
335int bt_sock_register(int proto, const struct net_proto_family *ops);
336void bt_sock_unregister(int proto);
337void bt_sock_link(struct bt_sock_list *l, struct sock *s);
338void bt_sock_unlink(struct bt_sock_list *l, struct sock *s);
339int bt_sock_recvmsg(struct socket *sock, struct msghdr *msg, size_t len,
340 int flags);
341int bt_sock_stream_recvmsg(struct socket *sock, struct msghdr *msg,
342 size_t len, int flags);
343__poll_t bt_sock_poll(struct file *file, struct socket *sock, poll_table *wait);
344int bt_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg);
345int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo);
346int bt_sock_wait_ready(struct sock *sk, unsigned long flags);
347
348void bt_accept_enqueue(struct sock *parent, struct sock *sk, bool bh);
349void bt_accept_unlink(struct sock *sk);
350struct sock *bt_accept_dequeue(struct sock *parent, struct socket *newsock);
351
352
353struct l2cap_ctrl {
354 u8 sframe:1,
355 poll:1,
356 final:1,
357 fcs:1,
358 sar:2,
359 super:2;
360
361 u16 reqseq;
362 u16 txseq;
363 u8 retries;
364 __le16 psm;
365 bdaddr_t bdaddr;
366 struct l2cap_chan *chan;
367};
368
369struct sco_ctrl {
370 u8 pkt_status;
371};
372
373struct hci_dev;
374
375typedef void (*hci_req_complete_t)(struct hci_dev *hdev, u8 status, u16 opcode);
376typedef void (*hci_req_complete_skb_t)(struct hci_dev *hdev, u8 status,
377 u16 opcode, struct sk_buff *skb);
378
379#define HCI_REQ_START BIT(0)
380#define HCI_REQ_SKB BIT(1)
381
382struct hci_ctrl {
383 u16 opcode;
384 u8 req_flags;
385 u8 req_event;
386 union {
387 hci_req_complete_t req_complete;
388 hci_req_complete_skb_t req_complete_skb;
389 };
390};
391
392struct bt_skb_cb {
393 u8 pkt_type;
394 u8 force_active;
395 u16 expect;
396 u8 incoming:1;
397 union {
398 struct l2cap_ctrl l2cap;
399 struct sco_ctrl sco;
400 struct hci_ctrl hci;
401 };
402};
403#define bt_cb(skb) ((struct bt_skb_cb *)((skb)->cb))
404
405#define hci_skb_pkt_type(skb) bt_cb((skb))->pkt_type
406#define hci_skb_expect(skb) bt_cb((skb))->expect
407#define hci_skb_opcode(skb) bt_cb((skb))->hci.opcode
408
409static inline struct sk_buff *bt_skb_alloc(unsigned int len, gfp_t how)
410{
411 struct sk_buff *skb;
412
413 skb = alloc_skb(len + BT_SKB_RESERVE, how);
414 if (skb)
415 skb_reserve(skb, BT_SKB_RESERVE);
416 return skb;
417}
418
419static inline struct sk_buff *bt_skb_send_alloc(struct sock *sk,
420 unsigned long len, int nb, int *err)
421{
422 struct sk_buff *skb;
423
424 skb = sock_alloc_send_skb(sk, len + BT_SKB_RESERVE, nb, err);
425 if (skb)
426 skb_reserve(skb, BT_SKB_RESERVE);
427
428 if (!skb && *err)
429 return NULL;
430
431 *err = sock_error(sk);
432 if (*err)
433 goto out;
434
435 if (sk->sk_shutdown) {
436 *err = -ECONNRESET;
437 goto out;
438 }
439
440 return skb;
441
442out:
443 kfree_skb(skb);
444 return NULL;
445}
446
447
448static inline struct sk_buff *bt_skb_sendmsg(struct sock *sk,
449 struct msghdr *msg,
450 size_t len, size_t mtu,
451 size_t headroom, size_t tailroom)
452{
453 struct sk_buff *skb;
454 size_t size = min_t(size_t, len, mtu);
455 int err;
456
457 skb = bt_skb_send_alloc(sk, size + headroom + tailroom,
458 msg->msg_flags & MSG_DONTWAIT, &err);
459 if (!skb)
460 return ERR_PTR(err);
461
462 skb_reserve(skb, headroom);
463 skb_tailroom_reserve(skb, mtu, tailroom);
464
465 if (!copy_from_iter_full(skb_put(skb, size), size, &msg->msg_iter)) {
466 kfree_skb(skb);
467 return ERR_PTR(-EFAULT);
468 }
469
470 skb->priority = sk->sk_priority;
471
472 return skb;
473}
474
475
476
477
478static inline struct sk_buff *bt_skb_sendmmsg(struct sock *sk,
479 struct msghdr *msg,
480 size_t len, size_t mtu,
481 size_t headroom, size_t tailroom)
482{
483 struct sk_buff *skb, **frag;
484
485 skb = bt_skb_sendmsg(sk, msg, len, mtu, headroom, tailroom);
486 if (IS_ERR_OR_NULL(skb))
487 return skb;
488
489 len -= skb->len;
490 if (!len)
491 return skb;
492
493
494 frag = &skb_shinfo(skb)->frag_list;
495 while (len) {
496 struct sk_buff *tmp;
497
498 tmp = bt_skb_sendmsg(sk, msg, len, mtu, headroom, tailroom);
499 if (IS_ERR(tmp)) {
500 kfree_skb(skb);
501 return tmp;
502 }
503
504 len -= tmp->len;
505
506 *frag = tmp;
507 frag = &(*frag)->next;
508 }
509
510 return skb;
511}
512
513int bt_to_errno(u16 code);
514
515void hci_sock_set_flag(struct sock *sk, int nr);
516void hci_sock_clear_flag(struct sock *sk, int nr);
517int hci_sock_test_flag(struct sock *sk, int nr);
518unsigned short hci_sock_get_channel(struct sock *sk);
519u32 hci_sock_get_cookie(struct sock *sk);
520
521int hci_sock_init(void);
522void hci_sock_cleanup(void);
523
524int bt_sysfs_init(void);
525void bt_sysfs_cleanup(void);
526
527int bt_procfs_init(struct net *net, const char *name,
528 struct bt_sock_list *sk_list,
529 int (*seq_show)(struct seq_file *, void *));
530void bt_procfs_cleanup(struct net *net, const char *name);
531
532extern struct dentry *bt_debugfs;
533
534int l2cap_init(void);
535void l2cap_exit(void);
536
537#if IS_ENABLED(CONFIG_BT_BREDR)
538int sco_init(void);
539void sco_exit(void);
540#else
541static inline int sco_init(void)
542{
543 return 0;
544}
545
546static inline void sco_exit(void)
547{
548}
549#endif
550
551int mgmt_init(void);
552void mgmt_exit(void);
553
554void bt_sock_reclassify_lock(struct sock *sk, int proto);
555
556#endif
557