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