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 __HCI_CORE_H
26#define __HCI_CORE_H
27
28#include <net/bluetooth/hci.h>
29
30
31#define HCI_PRIO_MAX 7
32
33
34struct inquiry_data {
35 bdaddr_t bdaddr;
36 __u8 pscan_rep_mode;
37 __u8 pscan_period_mode;
38 __u8 pscan_mode;
39 __u8 dev_class[3];
40 __le16 clock_offset;
41 __s8 rssi;
42 __u8 ssp_mode;
43};
44
45struct inquiry_entry {
46 struct list_head all;
47 struct list_head list;
48 enum {
49 NAME_NOT_KNOWN,
50 NAME_NEEDED,
51 NAME_PENDING,
52 NAME_KNOWN,
53 } name_state;
54 __u32 timestamp;
55 struct inquiry_data data;
56};
57
58struct discovery_state {
59 int type;
60 enum {
61 DISCOVERY_STOPPED,
62 DISCOVERY_STARTING,
63 DISCOVERY_FINDING,
64 DISCOVERY_RESOLVING,
65 DISCOVERY_STOPPING,
66 } state;
67 struct list_head all;
68 struct list_head unknown;
69 struct list_head resolve;
70 __u32 timestamp;
71};
72
73struct hci_conn_hash {
74 struct list_head list;
75 unsigned int acl_num;
76 unsigned int amp_num;
77 unsigned int sco_num;
78 unsigned int le_num;
79};
80
81struct bdaddr_list {
82 struct list_head list;
83 bdaddr_t bdaddr;
84};
85
86struct bt_uuid {
87 struct list_head list;
88 u8 uuid[16];
89 u8 size;
90 u8 svc_hint;
91};
92
93struct smp_ltk {
94 struct list_head list;
95 bdaddr_t bdaddr;
96 u8 bdaddr_type;
97 u8 authenticated;
98 u8 type;
99 u8 enc_size;
100 __le16 ediv;
101 u8 rand[8];
102 u8 val[16];
103} __packed;
104
105struct link_key {
106 struct list_head list;
107 bdaddr_t bdaddr;
108 u8 type;
109 u8 val[HCI_LINK_KEY_SIZE];
110 u8 pin_len;
111};
112
113struct oob_data {
114 struct list_head list;
115 bdaddr_t bdaddr;
116 u8 hash[16];
117 u8 randomizer[16];
118};
119
120struct le_scan_params {
121 u8 type;
122 u16 interval;
123 u16 window;
124 int timeout;
125};
126
127#define HCI_MAX_SHORT_NAME_LENGTH 10
128
129struct amp_assoc {
130 __u16 len;
131 __u16 offset;
132 __u16 rem_len;
133 __u16 len_so_far;
134 __u8 data[HCI_MAX_AMP_ASSOC_SIZE];
135};
136
137#define HCI_MAX_PAGES 3
138
139#define NUM_REASSEMBLY 4
140struct hci_dev {
141 struct list_head list;
142 struct mutex lock;
143
144 char name[8];
145 unsigned long flags;
146 __u16 id;
147 __u8 bus;
148 __u8 dev_type;
149 bdaddr_t bdaddr;
150 __u8 dev_name[HCI_MAX_NAME_LENGTH];
151 __u8 short_name[HCI_MAX_SHORT_NAME_LENGTH];
152 __u8 eir[HCI_MAX_EIR_LENGTH];
153 __u8 dev_class[3];
154 __u8 major_class;
155 __u8 minor_class;
156 __u8 max_page;
157 __u8 features[HCI_MAX_PAGES][8];
158 __u8 le_features[8];
159 __u8 le_white_list_size;
160 __u8 le_states[8];
161 __u8 commands[64];
162 __u8 hci_ver;
163 __u16 hci_rev;
164 __u8 lmp_ver;
165 __u16 manufacturer;
166 __u16 lmp_subver;
167 __u16 voice_setting;
168 __u8 io_capability;
169 __s8 inq_tx_power;
170 __u16 page_scan_interval;
171 __u16 page_scan_window;
172 __u8 page_scan_type;
173
174 __u16 devid_source;
175 __u16 devid_vendor;
176 __u16 devid_product;
177 __u16 devid_version;
178
179 __u16 pkt_type;
180 __u16 esco_type;
181 __u16 link_policy;
182 __u16 link_mode;
183
184 __u32 idle_timeout;
185 __u16 sniff_min_interval;
186 __u16 sniff_max_interval;
187
188 __u8 amp_status;
189 __u32 amp_total_bw;
190 __u32 amp_max_bw;
191 __u32 amp_min_latency;
192 __u32 amp_max_pdu;
193 __u8 amp_type;
194 __u16 amp_pal_cap;
195 __u16 amp_assoc_size;
196 __u32 amp_max_flush_to;
197 __u32 amp_be_flush_to;
198
199 struct amp_assoc loc_assoc;
200
201 __u8 flow_ctl_mode;
202
203 unsigned int auto_accept_delay;
204
205 unsigned long quirks;
206
207 atomic_t cmd_cnt;
208 unsigned int acl_cnt;
209 unsigned int sco_cnt;
210 unsigned int le_cnt;
211
212 unsigned int acl_mtu;
213 unsigned int sco_mtu;
214 unsigned int le_mtu;
215 unsigned int acl_pkts;
216 unsigned int sco_pkts;
217 unsigned int le_pkts;
218
219 __u16 block_len;
220 __u16 block_mtu;
221 __u16 num_blocks;
222 __u16 block_cnt;
223
224 unsigned long acl_last_tx;
225 unsigned long sco_last_tx;
226 unsigned long le_last_tx;
227
228 struct workqueue_struct *workqueue;
229 struct workqueue_struct *req_workqueue;
230
231 struct work_struct power_on;
232 struct delayed_work power_off;
233
234 __u16 discov_timeout;
235 struct delayed_work discov_off;
236
237 struct delayed_work service_cache;
238
239 struct timer_list cmd_timer;
240
241 struct work_struct rx_work;
242 struct work_struct cmd_work;
243 struct work_struct tx_work;
244
245 struct sk_buff_head rx_q;
246 struct sk_buff_head raw_q;
247 struct sk_buff_head cmd_q;
248
249 struct sk_buff *recv_evt;
250 struct sk_buff *sent_cmd;
251 struct sk_buff *reassembly[NUM_REASSEMBLY];
252
253 struct mutex req_lock;
254 wait_queue_head_t req_wait_q;
255 __u32 req_status;
256 __u32 req_result;
257
258 struct list_head mgmt_pending;
259
260 struct discovery_state discovery;
261 struct hci_conn_hash conn_hash;
262 struct list_head blacklist;
263
264 struct list_head uuids;
265
266 struct list_head link_keys;
267
268 struct list_head long_term_keys;
269
270 struct list_head remote_oob_data;
271
272 struct hci_dev_stats stat;
273
274 atomic_t promisc;
275
276 struct dentry *debugfs;
277
278 struct device dev;
279
280 struct rfkill *rfkill;
281
282 unsigned long dev_flags;
283
284 struct delayed_work le_scan_disable;
285
286 struct work_struct le_scan;
287 struct le_scan_params le_scan_params;
288
289 __s8 adv_tx_power;
290 __u8 adv_data[HCI_MAX_AD_LENGTH];
291 __u8 adv_data_len;
292
293 int (*open)(struct hci_dev *hdev);
294 int (*close)(struct hci_dev *hdev);
295 int (*flush)(struct hci_dev *hdev);
296 int (*setup)(struct hci_dev *hdev);
297 int (*send)(struct sk_buff *skb);
298 void (*notify)(struct hci_dev *hdev, unsigned int evt);
299 int (*ioctl)(struct hci_dev *hdev, unsigned int cmd, unsigned long arg);
300};
301
302#define HCI_PHY_HANDLE(handle) (handle & 0xff)
303
304struct hci_conn {
305 struct list_head list;
306
307 atomic_t refcnt;
308
309 bdaddr_t dst;
310 __u8 dst_type;
311 __u16 handle;
312 __u16 state;
313 __u8 mode;
314 __u8 type;
315 bool out;
316 __u8 attempt;
317 __u8 dev_class[3];
318 __u8 features[HCI_MAX_PAGES][8];
319 __u16 interval;
320 __u16 pkt_type;
321 __u16 link_policy;
322 __u32 link_mode;
323 __u8 key_type;
324 __u8 auth_type;
325 __u8 sec_level;
326 __u8 pending_sec_level;
327 __u8 pin_length;
328 __u8 enc_key_size;
329 __u8 io_capability;
330 __u32 passkey_notify;
331 __u8 passkey_entered;
332 __u16 disc_timeout;
333 unsigned long flags;
334
335 __u8 remote_cap;
336 __u8 remote_auth;
337 __u8 remote_id;
338 bool flush_key;
339
340 unsigned int sent;
341
342 struct sk_buff_head data_q;
343 struct list_head chan_list;
344
345 struct delayed_work disc_work;
346 struct timer_list idle_timer;
347 struct timer_list auto_accept_timer;
348
349 struct device dev;
350
351 struct hci_dev *hdev;
352 void *l2cap_data;
353 void *sco_data;
354 void *smp_conn;
355 struct amp_mgr *amp_mgr;
356
357 struct hci_conn *link;
358
359 void (*connect_cfm_cb) (struct hci_conn *conn, u8 status);
360 void (*security_cfm_cb) (struct hci_conn *conn, u8 status);
361 void (*disconn_cfm_cb) (struct hci_conn *conn, u8 reason);
362};
363
364struct hci_chan {
365 struct list_head list;
366 __u16 handle;
367 struct hci_conn *conn;
368 struct sk_buff_head data_q;
369 unsigned int sent;
370 __u8 state;
371};
372
373extern struct list_head hci_dev_list;
374extern struct list_head hci_cb_list;
375extern rwlock_t hci_dev_list_lock;
376extern rwlock_t hci_cb_list_lock;
377
378
379extern int l2cap_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr);
380extern void l2cap_connect_cfm(struct hci_conn *hcon, u8 status);
381extern int l2cap_disconn_ind(struct hci_conn *hcon);
382extern void l2cap_disconn_cfm(struct hci_conn *hcon, u8 reason);
383extern int l2cap_security_cfm(struct hci_conn *hcon, u8 status, u8 encrypt);
384extern int l2cap_recv_acldata(struct hci_conn *hcon, struct sk_buff *skb,
385 u16 flags);
386
387extern int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 *flags);
388extern void sco_connect_cfm(struct hci_conn *hcon, __u8 status);
389extern void sco_disconn_cfm(struct hci_conn *hcon, __u8 reason);
390extern int sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb);
391
392
393#define INQUIRY_CACHE_AGE_MAX (HZ*30)
394#define INQUIRY_ENTRY_AGE_MAX (HZ*60)
395
396static inline void discovery_init(struct hci_dev *hdev)
397{
398 hdev->discovery.state = DISCOVERY_STOPPED;
399 INIT_LIST_HEAD(&hdev->discovery.all);
400 INIT_LIST_HEAD(&hdev->discovery.unknown);
401 INIT_LIST_HEAD(&hdev->discovery.resolve);
402}
403
404bool hci_discovery_active(struct hci_dev *hdev);
405
406void hci_discovery_set_state(struct hci_dev *hdev, int state);
407
408static inline int inquiry_cache_empty(struct hci_dev *hdev)
409{
410 return list_empty(&hdev->discovery.all);
411}
412
413static inline long inquiry_cache_age(struct hci_dev *hdev)
414{
415 struct discovery_state *c = &hdev->discovery;
416 return jiffies - c->timestamp;
417}
418
419static inline long inquiry_entry_age(struct inquiry_entry *e)
420{
421 return jiffies - e->timestamp;
422}
423
424struct inquiry_entry *hci_inquiry_cache_lookup(struct hci_dev *hdev,
425 bdaddr_t *bdaddr);
426struct inquiry_entry *hci_inquiry_cache_lookup_unknown(struct hci_dev *hdev,
427 bdaddr_t *bdaddr);
428struct inquiry_entry *hci_inquiry_cache_lookup_resolve(struct hci_dev *hdev,
429 bdaddr_t *bdaddr,
430 int state);
431void hci_inquiry_cache_update_resolve(struct hci_dev *hdev,
432 struct inquiry_entry *ie);
433bool hci_inquiry_cache_update(struct hci_dev *hdev, struct inquiry_data *data,
434 bool name_known, bool *ssp);
435
436
437enum {
438 HCI_CONN_AUTH_PEND,
439 HCI_CONN_REAUTH_PEND,
440 HCI_CONN_ENCRYPT_PEND,
441 HCI_CONN_RSWITCH_PEND,
442 HCI_CONN_MODE_CHANGE_PEND,
443 HCI_CONN_SCO_SETUP_PEND,
444 HCI_CONN_LE_SMP_PEND,
445 HCI_CONN_MGMT_CONNECTED,
446 HCI_CONN_SSP_ENABLED,
447 HCI_CONN_POWER_SAVE,
448 HCI_CONN_REMOTE_OOB,
449};
450
451static inline bool hci_conn_ssp_enabled(struct hci_conn *conn)
452{
453 struct hci_dev *hdev = conn->hdev;
454 return test_bit(HCI_SSP_ENABLED, &hdev->dev_flags) &&
455 test_bit(HCI_CONN_SSP_ENABLED, &conn->flags);
456}
457
458static inline void hci_conn_hash_add(struct hci_dev *hdev, struct hci_conn *c)
459{
460 struct hci_conn_hash *h = &hdev->conn_hash;
461 list_add_rcu(&c->list, &h->list);
462 switch (c->type) {
463 case ACL_LINK:
464 h->acl_num++;
465 break;
466 case AMP_LINK:
467 h->amp_num++;
468 break;
469 case LE_LINK:
470 h->le_num++;
471 break;
472 case SCO_LINK:
473 case ESCO_LINK:
474 h->sco_num++;
475 break;
476 }
477}
478
479static inline void hci_conn_hash_del(struct hci_dev *hdev, struct hci_conn *c)
480{
481 struct hci_conn_hash *h = &hdev->conn_hash;
482
483 list_del_rcu(&c->list);
484 synchronize_rcu();
485
486 switch (c->type) {
487 case ACL_LINK:
488 h->acl_num--;
489 break;
490 case AMP_LINK:
491 h->amp_num--;
492 break;
493 case LE_LINK:
494 h->le_num--;
495 break;
496 case SCO_LINK:
497 case ESCO_LINK:
498 h->sco_num--;
499 break;
500 }
501}
502
503static inline unsigned int hci_conn_num(struct hci_dev *hdev, __u8 type)
504{
505 struct hci_conn_hash *h = &hdev->conn_hash;
506 switch (type) {
507 case ACL_LINK:
508 return h->acl_num;
509 case AMP_LINK:
510 return h->amp_num;
511 case LE_LINK:
512 return h->le_num;
513 case SCO_LINK:
514 case ESCO_LINK:
515 return h->sco_num;
516 default:
517 return 0;
518 }
519}
520
521static inline struct hci_conn *hci_conn_hash_lookup_handle(struct hci_dev *hdev,
522 __u16 handle)
523{
524 struct hci_conn_hash *h = &hdev->conn_hash;
525 struct hci_conn *c;
526
527 rcu_read_lock();
528
529 list_for_each_entry_rcu(c, &h->list, list) {
530 if (c->handle == handle) {
531 rcu_read_unlock();
532 return c;
533 }
534 }
535 rcu_read_unlock();
536
537 return NULL;
538}
539
540static inline struct hci_conn *hci_conn_hash_lookup_ba(struct hci_dev *hdev,
541 __u8 type, bdaddr_t *ba)
542{
543 struct hci_conn_hash *h = &hdev->conn_hash;
544 struct hci_conn *c;
545
546 rcu_read_lock();
547
548 list_for_each_entry_rcu(c, &h->list, list) {
549 if (c->type == type && !bacmp(&c->dst, ba)) {
550 rcu_read_unlock();
551 return c;
552 }
553 }
554
555 rcu_read_unlock();
556
557 return NULL;
558}
559
560static inline struct hci_conn *hci_conn_hash_lookup_state(struct hci_dev *hdev,
561 __u8 type, __u16 state)
562{
563 struct hci_conn_hash *h = &hdev->conn_hash;
564 struct hci_conn *c;
565
566 rcu_read_lock();
567
568 list_for_each_entry_rcu(c, &h->list, list) {
569 if (c->type == type && c->state == state) {
570 rcu_read_unlock();
571 return c;
572 }
573 }
574
575 rcu_read_unlock();
576
577 return NULL;
578}
579
580void hci_disconnect(struct hci_conn *conn, __u8 reason);
581void hci_setup_sync(struct hci_conn *conn, __u16 handle);
582void hci_sco_setup(struct hci_conn *conn, __u8 status);
583
584struct hci_conn *hci_conn_add(struct hci_dev *hdev, int type, bdaddr_t *dst);
585int hci_conn_del(struct hci_conn *conn);
586void hci_conn_hash_flush(struct hci_dev *hdev);
587void hci_conn_check_pending(struct hci_dev *hdev);
588
589struct hci_chan *hci_chan_create(struct hci_conn *conn);
590void hci_chan_del(struct hci_chan *chan);
591void hci_chan_list_flush(struct hci_conn *conn);
592struct hci_chan *hci_chan_lookup_handle(struct hci_dev *hdev, __u16 handle);
593
594struct hci_conn *hci_connect(struct hci_dev *hdev, int type, bdaddr_t *dst,
595 __u8 dst_type, __u8 sec_level, __u8 auth_type);
596int hci_conn_check_link_mode(struct hci_conn *conn);
597int hci_conn_check_secure(struct hci_conn *conn, __u8 sec_level);
598int hci_conn_security(struct hci_conn *conn, __u8 sec_level, __u8 auth_type);
599int hci_conn_change_link_key(struct hci_conn *conn);
600int hci_conn_switch_role(struct hci_conn *conn, __u8 role);
601
602void hci_conn_enter_active_mode(struct hci_conn *conn, __u8 force_active);
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625static inline void hci_conn_get(struct hci_conn *conn)
626{
627 get_device(&conn->dev);
628}
629
630static inline void hci_conn_put(struct hci_conn *conn)
631{
632 put_device(&conn->dev);
633}
634
635static inline void hci_conn_hold(struct hci_conn *conn)
636{
637 BT_DBG("hcon %p orig refcnt %d", conn, atomic_read(&conn->refcnt));
638
639 atomic_inc(&conn->refcnt);
640 cancel_delayed_work(&conn->disc_work);
641}
642
643static inline void hci_conn_drop(struct hci_conn *conn)
644{
645 BT_DBG("hcon %p orig refcnt %d", conn, atomic_read(&conn->refcnt));
646
647 if (atomic_dec_and_test(&conn->refcnt)) {
648 unsigned long timeo;
649
650 switch (conn->type) {
651 case ACL_LINK:
652 case LE_LINK:
653 del_timer(&conn->idle_timer);
654 if (conn->state == BT_CONNECTED) {
655 timeo = conn->disc_timeout;
656 if (!conn->out)
657 timeo *= 2;
658 } else {
659 timeo = msecs_to_jiffies(10);
660 }
661 break;
662
663 case AMP_LINK:
664 timeo = conn->disc_timeout;
665 break;
666
667 default:
668 timeo = msecs_to_jiffies(10);
669 break;
670 }
671
672 cancel_delayed_work(&conn->disc_work);
673 queue_delayed_work(conn->hdev->workqueue,
674 &conn->disc_work, timeo);
675 }
676}
677
678
679static inline void hci_dev_put(struct hci_dev *d)
680{
681 BT_DBG("%s orig refcnt %d", d->name,
682 atomic_read(&d->dev.kobj.kref.refcount));
683
684 put_device(&d->dev);
685}
686
687static inline struct hci_dev *hci_dev_hold(struct hci_dev *d)
688{
689 BT_DBG("%s orig refcnt %d", d->name,
690 atomic_read(&d->dev.kobj.kref.refcount));
691
692 get_device(&d->dev);
693 return d;
694}
695
696#define hci_dev_lock(d) mutex_lock(&d->lock)
697#define hci_dev_unlock(d) mutex_unlock(&d->lock)
698
699#define to_hci_dev(d) container_of(d, struct hci_dev, dev)
700#define to_hci_conn(c) container_of(c, struct hci_conn, dev)
701
702static inline void *hci_get_drvdata(struct hci_dev *hdev)
703{
704 return dev_get_drvdata(&hdev->dev);
705}
706
707static inline void hci_set_drvdata(struct hci_dev *hdev, void *data)
708{
709 dev_set_drvdata(&hdev->dev, data);
710}
711
712
713static inline uint8_t __hci_num_ctrl(void)
714{
715 uint8_t count = 0;
716 struct list_head *p;
717
718 list_for_each(p, &hci_dev_list) {
719 count++;
720 }
721
722 return count;
723}
724
725struct hci_dev *hci_dev_get(int index);
726struct hci_dev *hci_get_route(bdaddr_t *dst, bdaddr_t *src);
727
728struct hci_dev *hci_alloc_dev(void);
729void hci_free_dev(struct hci_dev *hdev);
730int hci_register_dev(struct hci_dev *hdev);
731void hci_unregister_dev(struct hci_dev *hdev);
732int hci_suspend_dev(struct hci_dev *hdev);
733int hci_resume_dev(struct hci_dev *hdev);
734int hci_dev_open(__u16 dev);
735int hci_dev_close(__u16 dev);
736int hci_dev_reset(__u16 dev);
737int hci_dev_reset_stat(__u16 dev);
738int hci_dev_cmd(unsigned int cmd, void __user *arg);
739int hci_get_dev_list(void __user *arg);
740int hci_get_dev_info(void __user *arg);
741int hci_get_conn_list(void __user *arg);
742int hci_get_conn_info(struct hci_dev *hdev, void __user *arg);
743int hci_get_auth_info(struct hci_dev *hdev, void __user *arg);
744int hci_inquiry(void __user *arg);
745
746struct bdaddr_list *hci_blacklist_lookup(struct hci_dev *hdev,
747 bdaddr_t *bdaddr);
748int hci_blacklist_clear(struct hci_dev *hdev);
749int hci_blacklist_add(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 type);
750int hci_blacklist_del(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 type);
751
752int hci_uuids_clear(struct hci_dev *hdev);
753
754int hci_link_keys_clear(struct hci_dev *hdev);
755struct link_key *hci_find_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr);
756int hci_add_link_key(struct hci_dev *hdev, struct hci_conn *conn, int new_key,
757 bdaddr_t *bdaddr, u8 *val, u8 type, u8 pin_len);
758struct smp_ltk *hci_find_ltk(struct hci_dev *hdev, __le16 ediv, u8 rand[8]);
759int hci_add_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 addr_type, u8 type,
760 int new_key, u8 authenticated, u8 tk[16], u8 enc_size,
761 __le16 ediv, u8 rand[8]);
762struct smp_ltk *hci_find_ltk_by_addr(struct hci_dev *hdev, bdaddr_t *bdaddr,
763 u8 addr_type);
764int hci_remove_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr);
765int hci_smp_ltks_clear(struct hci_dev *hdev);
766int hci_remove_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr);
767
768int hci_remote_oob_data_clear(struct hci_dev *hdev);
769struct oob_data *hci_find_remote_oob_data(struct hci_dev *hdev,
770 bdaddr_t *bdaddr);
771int hci_add_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 *hash,
772 u8 *randomizer);
773int hci_remove_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr);
774
775void hci_event_packet(struct hci_dev *hdev, struct sk_buff *skb);
776
777int hci_recv_frame(struct sk_buff *skb);
778int hci_recv_fragment(struct hci_dev *hdev, int type, void *data, int count);
779int hci_recv_stream_fragment(struct hci_dev *hdev, void *data, int count);
780
781void hci_init_sysfs(struct hci_dev *hdev);
782int hci_add_sysfs(struct hci_dev *hdev);
783void hci_del_sysfs(struct hci_dev *hdev);
784void hci_conn_init_sysfs(struct hci_conn *conn);
785void hci_conn_add_sysfs(struct hci_conn *conn);
786void hci_conn_del_sysfs(struct hci_conn *conn);
787
788#define SET_HCIDEV_DEV(hdev, pdev) ((hdev)->dev.parent = (pdev))
789
790
791#define lmp_encrypt_capable(dev) ((dev)->features[0][0] & LMP_ENCRYPT)
792#define lmp_rswitch_capable(dev) ((dev)->features[0][0] & LMP_RSWITCH)
793#define lmp_hold_capable(dev) ((dev)->features[0][0] & LMP_HOLD)
794#define lmp_sniff_capable(dev) ((dev)->features[0][0] & LMP_SNIFF)
795#define lmp_park_capable(dev) ((dev)->features[0][1] & LMP_PARK)
796#define lmp_inq_rssi_capable(dev) ((dev)->features[0][3] & LMP_RSSI_INQ)
797#define lmp_esco_capable(dev) ((dev)->features[0][3] & LMP_ESCO)
798#define lmp_bredr_capable(dev) (!((dev)->features[0][4] & LMP_NO_BREDR))
799#define lmp_le_capable(dev) ((dev)->features[0][4] & LMP_LE)
800#define lmp_sniffsubr_capable(dev) ((dev)->features[0][5] & LMP_SNIFF_SUBR)
801#define lmp_pause_enc_capable(dev) ((dev)->features[0][5] & LMP_PAUSE_ENC)
802#define lmp_ext_inq_capable(dev) ((dev)->features[0][6] & LMP_EXT_INQ)
803#define lmp_le_br_capable(dev) (!!((dev)->features[0][6] & LMP_SIMUL_LE_BR))
804#define lmp_ssp_capable(dev) ((dev)->features[0][6] & LMP_SIMPLE_PAIR)
805#define lmp_no_flush_capable(dev) ((dev)->features[0][6] & LMP_NO_FLUSH)
806#define lmp_lsto_capable(dev) ((dev)->features[0][7] & LMP_LSTO)
807#define lmp_inq_tx_pwr_capable(dev) ((dev)->features[0][7] & LMP_INQ_TX_PWR)
808#define lmp_ext_feat_capable(dev) ((dev)->features[0][7] & LMP_EXTFEATURES)
809
810
811#define lmp_host_ssp_capable(dev) ((dev)->features[1][0] & LMP_HOST_SSP)
812#define lmp_host_le_capable(dev) (!!((dev)->features[1][0] & LMP_HOST_LE))
813#define lmp_host_le_br_capable(dev) (!!((dev)->features[1][0] & LMP_HOST_LE_BREDR))
814
815
816static inline bool hci_amp_capable(void)
817{
818 struct hci_dev *hdev;
819 bool ret = false;
820
821 read_lock(&hci_dev_list_lock);
822 list_for_each_entry(hdev, &hci_dev_list, list)
823 if (hdev->amp_type == HCI_AMP &&
824 test_bit(HCI_UP, &hdev->flags))
825 ret = true;
826 read_unlock(&hci_dev_list_lock);
827
828 return ret;
829}
830
831
832#define HCI_PROTO_DEFER 0x01
833
834static inline int hci_proto_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr,
835 __u8 type, __u8 *flags)
836{
837 switch (type) {
838 case ACL_LINK:
839 return l2cap_connect_ind(hdev, bdaddr);
840
841 case SCO_LINK:
842 case ESCO_LINK:
843 return sco_connect_ind(hdev, bdaddr, flags);
844
845 default:
846 BT_ERR("unknown link type %d", type);
847 return -EINVAL;
848 }
849}
850
851static inline void hci_proto_connect_cfm(struct hci_conn *conn, __u8 status)
852{
853 switch (conn->type) {
854 case ACL_LINK:
855 case LE_LINK:
856 l2cap_connect_cfm(conn, status);
857 break;
858
859 case SCO_LINK:
860 case ESCO_LINK:
861 sco_connect_cfm(conn, status);
862 break;
863
864 default:
865 BT_ERR("unknown link type %d", conn->type);
866 break;
867 }
868
869 if (conn->connect_cfm_cb)
870 conn->connect_cfm_cb(conn, status);
871}
872
873static inline int hci_proto_disconn_ind(struct hci_conn *conn)
874{
875 if (conn->type != ACL_LINK && conn->type != LE_LINK)
876 return HCI_ERROR_REMOTE_USER_TERM;
877
878 return l2cap_disconn_ind(conn);
879}
880
881static inline void hci_proto_disconn_cfm(struct hci_conn *conn, __u8 reason)
882{
883 switch (conn->type) {
884 case ACL_LINK:
885 case LE_LINK:
886 l2cap_disconn_cfm(conn, reason);
887 break;
888
889 case SCO_LINK:
890 case ESCO_LINK:
891 sco_disconn_cfm(conn, reason);
892 break;
893
894
895 case AMP_LINK:
896 break;
897
898 default:
899 BT_ERR("unknown link type %d", conn->type);
900 break;
901 }
902
903 if (conn->disconn_cfm_cb)
904 conn->disconn_cfm_cb(conn, reason);
905}
906
907static inline void hci_proto_auth_cfm(struct hci_conn *conn, __u8 status)
908{
909 __u8 encrypt;
910
911 if (conn->type != ACL_LINK && conn->type != LE_LINK)
912 return;
913
914 if (test_bit(HCI_CONN_ENCRYPT_PEND, &conn->flags))
915 return;
916
917 encrypt = (conn->link_mode & HCI_LM_ENCRYPT) ? 0x01 : 0x00;
918 l2cap_security_cfm(conn, status, encrypt);
919
920 if (conn->security_cfm_cb)
921 conn->security_cfm_cb(conn, status);
922}
923
924static inline void hci_proto_encrypt_cfm(struct hci_conn *conn, __u8 status,
925 __u8 encrypt)
926{
927 if (conn->type != ACL_LINK && conn->type != LE_LINK)
928 return;
929
930 l2cap_security_cfm(conn, status, encrypt);
931
932 if (conn->security_cfm_cb)
933 conn->security_cfm_cb(conn, status);
934}
935
936
937struct hci_cb {
938 struct list_head list;
939
940 char *name;
941
942 void (*security_cfm) (struct hci_conn *conn, __u8 status,
943 __u8 encrypt);
944 void (*key_change_cfm) (struct hci_conn *conn, __u8 status);
945 void (*role_switch_cfm) (struct hci_conn *conn, __u8 status, __u8 role);
946};
947
948static inline void hci_auth_cfm(struct hci_conn *conn, __u8 status)
949{
950 struct hci_cb *cb;
951 __u8 encrypt;
952
953 hci_proto_auth_cfm(conn, status);
954
955 if (test_bit(HCI_CONN_ENCRYPT_PEND, &conn->flags))
956 return;
957
958 encrypt = (conn->link_mode & HCI_LM_ENCRYPT) ? 0x01 : 0x00;
959
960 read_lock(&hci_cb_list_lock);
961 list_for_each_entry(cb, &hci_cb_list, list) {
962 if (cb->security_cfm)
963 cb->security_cfm(conn, status, encrypt);
964 }
965 read_unlock(&hci_cb_list_lock);
966}
967
968static inline void hci_encrypt_cfm(struct hci_conn *conn, __u8 status,
969 __u8 encrypt)
970{
971 struct hci_cb *cb;
972
973 if (conn->sec_level == BT_SECURITY_SDP)
974 conn->sec_level = BT_SECURITY_LOW;
975
976 if (conn->pending_sec_level > conn->sec_level)
977 conn->sec_level = conn->pending_sec_level;
978
979 hci_proto_encrypt_cfm(conn, status, encrypt);
980
981 read_lock(&hci_cb_list_lock);
982 list_for_each_entry(cb, &hci_cb_list, list) {
983 if (cb->security_cfm)
984 cb->security_cfm(conn, status, encrypt);
985 }
986 read_unlock(&hci_cb_list_lock);
987}
988
989static inline void hci_key_change_cfm(struct hci_conn *conn, __u8 status)
990{
991 struct hci_cb *cb;
992
993 read_lock(&hci_cb_list_lock);
994 list_for_each_entry(cb, &hci_cb_list, list) {
995 if (cb->key_change_cfm)
996 cb->key_change_cfm(conn, status);
997 }
998 read_unlock(&hci_cb_list_lock);
999}
1000
1001static inline void hci_role_switch_cfm(struct hci_conn *conn, __u8 status,
1002 __u8 role)
1003{
1004 struct hci_cb *cb;
1005
1006 read_lock(&hci_cb_list_lock);
1007 list_for_each_entry(cb, &hci_cb_list, list) {
1008 if (cb->role_switch_cfm)
1009 cb->role_switch_cfm(conn, status, role);
1010 }
1011 read_unlock(&hci_cb_list_lock);
1012}
1013
1014static inline bool eir_has_data_type(u8 *data, size_t data_len, u8 type)
1015{
1016 size_t parsed = 0;
1017
1018 if (data_len < 2)
1019 return false;
1020
1021 while (parsed < data_len - 1) {
1022 u8 field_len = data[0];
1023
1024 if (field_len == 0)
1025 break;
1026
1027 parsed += field_len + 1;
1028
1029 if (parsed > data_len)
1030 break;
1031
1032 if (data[1] == type)
1033 return true;
1034
1035 data += field_len + 1;
1036 }
1037
1038 return false;
1039}
1040
1041static inline size_t eir_get_length(u8 *eir, size_t eir_len)
1042{
1043 size_t parsed = 0;
1044
1045 while (parsed < eir_len) {
1046 u8 field_len = eir[0];
1047
1048 if (field_len == 0)
1049 return parsed;
1050
1051 parsed += field_len + 1;
1052 eir += field_len + 1;
1053 }
1054
1055 return eir_len;
1056}
1057
1058static inline u16 eir_append_data(u8 *eir, u16 eir_len, u8 type, u8 *data,
1059 u8 data_len)
1060{
1061 eir[eir_len++] = sizeof(type) + data_len;
1062 eir[eir_len++] = type;
1063 memcpy(&eir[eir_len], data, data_len);
1064 eir_len += data_len;
1065
1066 return eir_len;
1067}
1068
1069int hci_register_cb(struct hci_cb *hcb);
1070int hci_unregister_cb(struct hci_cb *hcb);
1071
1072struct hci_request {
1073 struct hci_dev *hdev;
1074 struct sk_buff_head cmd_q;
1075
1076
1077
1078
1079 int err;
1080};
1081
1082void hci_req_init(struct hci_request *req, struct hci_dev *hdev);
1083int hci_req_run(struct hci_request *req, hci_req_complete_t complete);
1084void hci_req_add(struct hci_request *req, u16 opcode, u32 plen,
1085 const void *param);
1086void hci_req_add_ev(struct hci_request *req, u16 opcode, u32 plen,
1087 const void *param, u8 event);
1088void hci_req_cmd_complete(struct hci_dev *hdev, u16 opcode, u8 status);
1089
1090struct sk_buff *__hci_cmd_sync(struct hci_dev *hdev, u16 opcode, u32 plen,
1091 const void *param, u32 timeout);
1092struct sk_buff *__hci_cmd_sync_ev(struct hci_dev *hdev, u16 opcode, u32 plen,
1093 const void *param, u8 event, u32 timeout);
1094
1095int hci_send_cmd(struct hci_dev *hdev, __u16 opcode, __u32 plen,
1096 const void *param);
1097void hci_send_acl(struct hci_chan *chan, struct sk_buff *skb, __u16 flags);
1098void hci_send_sco(struct hci_conn *conn, struct sk_buff *skb);
1099
1100void *hci_sent_cmd_data(struct hci_dev *hdev, __u16 opcode);
1101
1102
1103void hci_send_to_sock(struct hci_dev *hdev, struct sk_buff *skb);
1104void hci_send_to_control(struct sk_buff *skb, struct sock *skip_sk);
1105void hci_send_to_monitor(struct hci_dev *hdev, struct sk_buff *skb);
1106
1107void hci_sock_dev_event(struct hci_dev *hdev, int event);
1108
1109
1110#define DISCOV_TYPE_BREDR (BIT(BDADDR_BREDR))
1111#define DISCOV_TYPE_LE (BIT(BDADDR_LE_PUBLIC) | \
1112 BIT(BDADDR_LE_RANDOM))
1113#define DISCOV_TYPE_INTERLEAVED (BIT(BDADDR_BREDR) | \
1114 BIT(BDADDR_LE_PUBLIC) | \
1115 BIT(BDADDR_LE_RANDOM))
1116
1117int mgmt_control(struct sock *sk, struct msghdr *msg, size_t len);
1118int mgmt_index_added(struct hci_dev *hdev);
1119int mgmt_index_removed(struct hci_dev *hdev);
1120int mgmt_set_powered_failed(struct hci_dev *hdev, int err);
1121int mgmt_powered(struct hci_dev *hdev, u8 powered);
1122int mgmt_discoverable(struct hci_dev *hdev, u8 discoverable);
1123int mgmt_connectable(struct hci_dev *hdev, u8 connectable);
1124int mgmt_write_scan_failed(struct hci_dev *hdev, u8 scan, u8 status);
1125int mgmt_new_link_key(struct hci_dev *hdev, struct link_key *key,
1126 bool persistent);
1127int mgmt_device_connected(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type,
1128 u8 addr_type, u32 flags, u8 *name, u8 name_len,
1129 u8 *dev_class);
1130int mgmt_device_disconnected(struct hci_dev *hdev, bdaddr_t *bdaddr,
1131 u8 link_type, u8 addr_type, u8 reason);
1132int mgmt_disconnect_failed(struct hci_dev *hdev, bdaddr_t *bdaddr,
1133 u8 link_type, u8 addr_type, u8 status);
1134int mgmt_connect_failed(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type,
1135 u8 addr_type, u8 status);
1136int mgmt_pin_code_request(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 secure);
1137int mgmt_pin_code_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
1138 u8 status);
1139int mgmt_pin_code_neg_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
1140 u8 status);
1141int mgmt_user_confirm_request(struct hci_dev *hdev, bdaddr_t *bdaddr,
1142 u8 link_type, u8 addr_type, __le32 value,
1143 u8 confirm_hint);
1144int mgmt_user_confirm_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
1145 u8 link_type, u8 addr_type, u8 status);
1146int mgmt_user_confirm_neg_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
1147 u8 link_type, u8 addr_type, u8 status);
1148int mgmt_user_passkey_request(struct hci_dev *hdev, bdaddr_t *bdaddr,
1149 u8 link_type, u8 addr_type);
1150int mgmt_user_passkey_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
1151 u8 link_type, u8 addr_type, u8 status);
1152int mgmt_user_passkey_neg_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
1153 u8 link_type, u8 addr_type, u8 status);
1154int mgmt_user_passkey_notify(struct hci_dev *hdev, bdaddr_t *bdaddr,
1155 u8 link_type, u8 addr_type, u32 passkey,
1156 u8 entered);
1157int mgmt_auth_failed(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type,
1158 u8 addr_type, u8 status);
1159int mgmt_auth_enable_complete(struct hci_dev *hdev, u8 status);
1160int mgmt_ssp_enable_complete(struct hci_dev *hdev, u8 enable, u8 status);
1161int mgmt_set_class_of_dev_complete(struct hci_dev *hdev, u8 *dev_class,
1162 u8 status);
1163int mgmt_set_local_name_complete(struct hci_dev *hdev, u8 *name, u8 status);
1164int mgmt_read_local_oob_data_reply_complete(struct hci_dev *hdev, u8 *hash,
1165 u8 *randomizer, u8 status);
1166int mgmt_le_enable_complete(struct hci_dev *hdev, u8 enable, u8 status);
1167int mgmt_device_found(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type,
1168 u8 addr_type, u8 *dev_class, s8 rssi, u8 cfm_name,
1169 u8 ssp, u8 *eir, u16 eir_len);
1170int mgmt_remote_name(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type,
1171 u8 addr_type, s8 rssi, u8 *name, u8 name_len);
1172int mgmt_start_discovery_failed(struct hci_dev *hdev, u8 status);
1173int mgmt_stop_discovery_failed(struct hci_dev *hdev, u8 status);
1174int mgmt_discovering(struct hci_dev *hdev, u8 discovering);
1175int mgmt_interleaved_discovery(struct hci_dev *hdev);
1176int mgmt_device_blocked(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 type);
1177int mgmt_device_unblocked(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 type);
1178bool mgmt_valid_hdev(struct hci_dev *hdev);
1179int mgmt_new_ltk(struct hci_dev *hdev, struct smp_ltk *key, u8 persistent);
1180
1181
1182#define hci_pi(sk) ((struct hci_pinfo *) sk)
1183
1184struct hci_pinfo {
1185 struct bt_sock bt;
1186 struct hci_dev *hdev;
1187 struct hci_filter filter;
1188 __u32 cmsg_mask;
1189 unsigned short channel;
1190};
1191
1192
1193#define HCI_SFLT_MAX_OGF 5
1194
1195struct hci_sec_filter {
1196 __u32 type_mask;
1197 __u32 event_mask[2];
1198 __u32 ocf_mask[HCI_SFLT_MAX_OGF + 1][4];
1199};
1200
1201
1202#define HCI_REQ_DONE 0
1203#define HCI_REQ_PEND 1
1204#define HCI_REQ_CANCELED 2
1205
1206#define hci_req_lock(d) mutex_lock(&d->req_lock)
1207#define hci_req_unlock(d) mutex_unlock(&d->req_lock)
1208
1209void hci_update_ad(struct hci_request *req);
1210
1211void hci_le_conn_update(struct hci_conn *conn, u16 min, u16 max,
1212 u16 latency, u16 to_multiplier);
1213void hci_le_start_enc(struct hci_conn *conn, __le16 ediv, __u8 rand[8],
1214 __u8 ltk[16]);
1215int hci_do_inquiry(struct hci_dev *hdev, u8 length);
1216int hci_cancel_inquiry(struct hci_dev *hdev);
1217int hci_le_scan(struct hci_dev *hdev, u8 type, u16 interval, u16 window,
1218 int timeout);
1219int hci_cancel_le_scan(struct hci_dev *hdev);
1220
1221u8 bdaddr_to_le(u8 bdaddr_type);
1222
1223#endif
1224