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_PROTO_L2CAP 0
32#define HCI_PROTO_SCO 1
33
34
35struct inquiry_data {
36 bdaddr_t bdaddr;
37 __u8 pscan_rep_mode;
38 __u8 pscan_period_mode;
39 __u8 pscan_mode;
40 __u8 dev_class[3];
41 __le16 clock_offset;
42 __s8 rssi;
43};
44
45struct inquiry_entry {
46 struct inquiry_entry *next;
47 __u32 timestamp;
48 struct inquiry_data data;
49};
50
51struct inquiry_cache {
52 spinlock_t lock;
53 __u32 timestamp;
54 struct inquiry_entry *list;
55};
56
57struct hci_conn_hash {
58 struct list_head list;
59 spinlock_t lock;
60 unsigned int acl_num;
61 unsigned int sco_num;
62};
63
64struct hci_dev {
65 struct list_head list;
66 spinlock_t lock;
67 atomic_t refcnt;
68
69 char name[8];
70 unsigned long flags;
71 __u16 id;
72 __u8 type;
73 bdaddr_t bdaddr;
74 __u8 dev_name[248];
75 __u8 dev_class[3];
76 __u8 features[8];
77 __u8 commands[64];
78 __u8 hci_ver;
79 __u16 hci_rev;
80 __u16 manufacturer;
81 __u16 voice_setting;
82
83 __u16 pkt_type;
84 __u16 esco_type;
85 __u16 link_policy;
86 __u16 link_mode;
87
88 __u32 idle_timeout;
89 __u16 sniff_min_interval;
90 __u16 sniff_max_interval;
91
92 unsigned long quirks;
93
94 atomic_t cmd_cnt;
95 unsigned int acl_cnt;
96 unsigned int sco_cnt;
97
98 unsigned int acl_mtu;
99 unsigned int sco_mtu;
100 unsigned int acl_pkts;
101 unsigned int sco_pkts;
102
103 unsigned long cmd_last_tx;
104 unsigned long acl_last_tx;
105 unsigned long sco_last_tx;
106
107 struct tasklet_struct cmd_task;
108 struct tasklet_struct rx_task;
109 struct tasklet_struct tx_task;
110
111 struct sk_buff_head rx_q;
112 struct sk_buff_head raw_q;
113 struct sk_buff_head cmd_q;
114
115 struct sk_buff *sent_cmd;
116 struct sk_buff *reassembly[3];
117
118 struct semaphore req_lock;
119 wait_queue_head_t req_wait_q;
120 __u32 req_status;
121 __u32 req_result;
122
123 struct inquiry_cache inq_cache;
124 struct hci_conn_hash conn_hash;
125
126 struct hci_dev_stats stat;
127
128 struct sk_buff_head driver_init;
129
130 void *driver_data;
131 void *core_data;
132
133 atomic_t promisc;
134
135 struct device *parent;
136 struct device dev;
137
138 struct module *owner;
139
140 int (*open)(struct hci_dev *hdev);
141 int (*close)(struct hci_dev *hdev);
142 int (*flush)(struct hci_dev *hdev);
143 int (*send)(struct sk_buff *skb);
144 void (*destruct)(struct hci_dev *hdev);
145 void (*notify)(struct hci_dev *hdev, unsigned int evt);
146 int (*ioctl)(struct hci_dev *hdev, unsigned int cmd, unsigned long arg);
147};
148
149struct hci_conn {
150 struct list_head list;
151
152 atomic_t refcnt;
153 spinlock_t lock;
154
155 bdaddr_t dst;
156 __u16 handle;
157 __u16 state;
158 __u8 mode;
159 __u8 type;
160 __u8 out;
161 __u8 attempt;
162 __u8 dev_class[3];
163 __u8 features[8];
164 __u16 interval;
165 __u16 link_policy;
166 __u32 link_mode;
167 __u8 power_save;
168 unsigned long pend;
169
170 unsigned int sent;
171
172 struct sk_buff_head data_q;
173
174 struct timer_list disc_timer;
175 struct timer_list idle_timer;
176
177 struct work_struct work;
178
179 struct device dev;
180
181 struct hci_dev *hdev;
182 void *l2cap_data;
183 void *sco_data;
184 void *priv;
185
186 struct hci_conn *link;
187};
188
189extern struct hci_proto *hci_proto[];
190extern struct list_head hci_dev_list;
191extern struct list_head hci_cb_list;
192extern rwlock_t hci_dev_list_lock;
193extern rwlock_t hci_cb_list_lock;
194
195
196#define INQUIRY_CACHE_AGE_MAX (HZ*30)
197#define INQUIRY_ENTRY_AGE_MAX (HZ*60)
198
199#define inquiry_cache_lock(c) spin_lock(&c->lock)
200#define inquiry_cache_unlock(c) spin_unlock(&c->lock)
201#define inquiry_cache_lock_bh(c) spin_lock_bh(&c->lock)
202#define inquiry_cache_unlock_bh(c) spin_unlock_bh(&c->lock)
203
204static inline void inquiry_cache_init(struct hci_dev *hdev)
205{
206 struct inquiry_cache *c = &hdev->inq_cache;
207 spin_lock_init(&c->lock);
208 c->list = NULL;
209}
210
211static inline int inquiry_cache_empty(struct hci_dev *hdev)
212{
213 struct inquiry_cache *c = &hdev->inq_cache;
214 return (c->list == NULL);
215}
216
217static inline long inquiry_cache_age(struct hci_dev *hdev)
218{
219 struct inquiry_cache *c = &hdev->inq_cache;
220 return jiffies - c->timestamp;
221}
222
223static inline long inquiry_entry_age(struct inquiry_entry *e)
224{
225 return jiffies - e->timestamp;
226}
227
228struct inquiry_entry *hci_inquiry_cache_lookup(struct hci_dev *hdev, bdaddr_t *bdaddr);
229void hci_inquiry_cache_update(struct hci_dev *hdev, struct inquiry_data *data);
230
231
232enum {
233 HCI_CONN_AUTH_PEND,
234 HCI_CONN_ENCRYPT_PEND,
235 HCI_CONN_RSWITCH_PEND,
236 HCI_CONN_MODE_CHANGE_PEND,
237};
238
239static inline void hci_conn_hash_init(struct hci_dev *hdev)
240{
241 struct hci_conn_hash *h = &hdev->conn_hash;
242 INIT_LIST_HEAD(&h->list);
243 spin_lock_init(&h->lock);
244 h->acl_num = 0;
245 h->sco_num = 0;
246}
247
248static inline void hci_conn_hash_add(struct hci_dev *hdev, struct hci_conn *c)
249{
250 struct hci_conn_hash *h = &hdev->conn_hash;
251 list_add(&c->list, &h->list);
252 if (c->type == ACL_LINK)
253 h->acl_num++;
254 else
255 h->sco_num++;
256}
257
258static inline void hci_conn_hash_del(struct hci_dev *hdev, struct hci_conn *c)
259{
260 struct hci_conn_hash *h = &hdev->conn_hash;
261 list_del(&c->list);
262 if (c->type == ACL_LINK)
263 h->acl_num--;
264 else
265 h->sco_num--;
266}
267
268static inline struct hci_conn *hci_conn_hash_lookup_handle(struct hci_dev *hdev,
269 __u16 handle)
270{
271 struct hci_conn_hash *h = &hdev->conn_hash;
272 struct list_head *p;
273 struct hci_conn *c;
274
275 list_for_each(p, &h->list) {
276 c = list_entry(p, struct hci_conn, list);
277 if (c->handle == handle)
278 return c;
279 }
280 return NULL;
281}
282
283static inline struct hci_conn *hci_conn_hash_lookup_ba(struct hci_dev *hdev,
284 __u8 type, bdaddr_t *ba)
285{
286 struct hci_conn_hash *h = &hdev->conn_hash;
287 struct list_head *p;
288 struct hci_conn *c;
289
290 list_for_each(p, &h->list) {
291 c = list_entry(p, struct hci_conn, list);
292 if (c->type == type && !bacmp(&c->dst, ba))
293 return c;
294 }
295 return NULL;
296}
297
298static inline struct hci_conn *hci_conn_hash_lookup_state(struct hci_dev *hdev,
299 __u8 type, __u16 state)
300{
301 struct hci_conn_hash *h = &hdev->conn_hash;
302 struct list_head *p;
303 struct hci_conn *c;
304
305 list_for_each(p, &h->list) {
306 c = list_entry(p, struct hci_conn, list);
307 if (c->type == type && c->state == state)
308 return c;
309 }
310 return NULL;
311}
312
313void hci_acl_connect(struct hci_conn *conn);
314void hci_acl_disconn(struct hci_conn *conn, __u8 reason);
315void hci_add_sco(struct hci_conn *conn, __u16 handle);
316void hci_setup_sync(struct hci_conn *conn, __u16 handle);
317
318struct hci_conn *hci_conn_add(struct hci_dev *hdev, int type, bdaddr_t *dst);
319int hci_conn_del(struct hci_conn *conn);
320void hci_conn_hash_flush(struct hci_dev *hdev);
321void hci_conn_check_pending(struct hci_dev *hdev);
322
323struct hci_conn *hci_connect(struct hci_dev *hdev, int type, bdaddr_t *src);
324int hci_conn_auth(struct hci_conn *conn);
325int hci_conn_encrypt(struct hci_conn *conn);
326int hci_conn_change_link_key(struct hci_conn *conn);
327int hci_conn_switch_role(struct hci_conn *conn, uint8_t role);
328
329void hci_conn_enter_active_mode(struct hci_conn *conn);
330void hci_conn_enter_sniff_mode(struct hci_conn *conn);
331
332static inline void hci_conn_hold(struct hci_conn *conn)
333{
334 atomic_inc(&conn->refcnt);
335 del_timer(&conn->disc_timer);
336}
337
338static inline void hci_conn_put(struct hci_conn *conn)
339{
340 if (atomic_dec_and_test(&conn->refcnt)) {
341 unsigned long timeo;
342 if (conn->type == ACL_LINK) {
343 del_timer(&conn->idle_timer);
344 if (conn->state == BT_CONNECTED) {
345 timeo = msecs_to_jiffies(HCI_DISCONN_TIMEOUT);
346 if (!conn->out)
347 timeo *= 2;
348 } else
349 timeo = msecs_to_jiffies(10);
350 } else
351 timeo = msecs_to_jiffies(10);
352 mod_timer(&conn->disc_timer, jiffies + timeo);
353 }
354}
355
356
357static inline void hci_sched_cmd(struct hci_dev *hdev)
358{
359 tasklet_schedule(&hdev->cmd_task);
360}
361
362static inline void hci_sched_rx(struct hci_dev *hdev)
363{
364 tasklet_schedule(&hdev->rx_task);
365}
366
367static inline void hci_sched_tx(struct hci_dev *hdev)
368{
369 tasklet_schedule(&hdev->tx_task);
370}
371
372
373static inline void __hci_dev_put(struct hci_dev *d)
374{
375 if (atomic_dec_and_test(&d->refcnt))
376 d->destruct(d);
377}
378
379static inline void hci_dev_put(struct hci_dev *d)
380{
381 __hci_dev_put(d);
382 module_put(d->owner);
383}
384
385static inline struct hci_dev *__hci_dev_hold(struct hci_dev *d)
386{
387 atomic_inc(&d->refcnt);
388 return d;
389}
390
391static inline struct hci_dev *hci_dev_hold(struct hci_dev *d)
392{
393 if (try_module_get(d->owner))
394 return __hci_dev_hold(d);
395 return NULL;
396}
397
398#define hci_dev_lock(d) spin_lock(&d->lock)
399#define hci_dev_unlock(d) spin_unlock(&d->lock)
400#define hci_dev_lock_bh(d) spin_lock_bh(&d->lock)
401#define hci_dev_unlock_bh(d) spin_unlock_bh(&d->lock)
402
403struct hci_dev *hci_dev_get(int index);
404struct hci_dev *hci_get_route(bdaddr_t *src, bdaddr_t *dst);
405
406struct hci_dev *hci_alloc_dev(void);
407void hci_free_dev(struct hci_dev *hdev);
408int hci_register_dev(struct hci_dev *hdev);
409int hci_unregister_dev(struct hci_dev *hdev);
410int hci_suspend_dev(struct hci_dev *hdev);
411int hci_resume_dev(struct hci_dev *hdev);
412int hci_dev_open(__u16 dev);
413int hci_dev_close(__u16 dev);
414int hci_dev_reset(__u16 dev);
415int hci_dev_reset_stat(__u16 dev);
416int hci_dev_cmd(unsigned int cmd, void __user *arg);
417int hci_get_dev_list(void __user *arg);
418int hci_get_dev_info(void __user *arg);
419int hci_get_conn_list(void __user *arg);
420int hci_get_conn_info(struct hci_dev *hdev, void __user *arg);
421int hci_inquiry(void __user *arg);
422
423void hci_event_packet(struct hci_dev *hdev, struct sk_buff *skb);
424
425
426static inline int hci_recv_frame(struct sk_buff *skb)
427{
428 struct hci_dev *hdev = (struct hci_dev *) skb->dev;
429 if (!hdev || (!test_bit(HCI_UP, &hdev->flags)
430 && !test_bit(HCI_INIT, &hdev->flags))) {
431 kfree_skb(skb);
432 return -ENXIO;
433 }
434
435
436 bt_cb(skb)->incoming = 1;
437
438
439 __net_timestamp(skb);
440
441
442 skb_queue_tail(&hdev->rx_q, skb);
443 hci_sched_rx(hdev);
444 return 0;
445}
446
447int hci_recv_fragment(struct hci_dev *hdev, int type, void *data, int count);
448
449int hci_register_sysfs(struct hci_dev *hdev);
450void hci_unregister_sysfs(struct hci_dev *hdev);
451void hci_conn_add_sysfs(struct hci_conn *conn);
452void hci_conn_del_sysfs(struct hci_conn *conn);
453
454#define SET_HCIDEV_DEV(hdev, pdev) ((hdev)->parent = (pdev))
455
456
457#define lmp_rswitch_capable(dev) ((dev)->features[0] & LMP_RSWITCH)
458#define lmp_encrypt_capable(dev) ((dev)->features[0] & LMP_ENCRYPT)
459#define lmp_sniff_capable(dev) ((dev)->features[0] & LMP_SNIFF)
460#define lmp_sniffsubr_capable(dev) ((dev)->features[5] & LMP_SNIFF_SUBR)
461#define lmp_esco_capable(dev) ((dev)->features[3] & LMP_ESCO)
462
463
464struct hci_proto {
465 char *name;
466 unsigned int id;
467 unsigned long flags;
468
469 void *priv;
470
471 int (*connect_ind) (struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 type);
472 int (*connect_cfm) (struct hci_conn *conn, __u8 status);
473 int (*disconn_ind) (struct hci_conn *conn, __u8 reason);
474 int (*recv_acldata) (struct hci_conn *conn, struct sk_buff *skb, __u16 flags);
475 int (*recv_scodata) (struct hci_conn *conn, struct sk_buff *skb);
476 int (*auth_cfm) (struct hci_conn *conn, __u8 status);
477 int (*encrypt_cfm) (struct hci_conn *conn, __u8 status);
478};
479
480static inline int hci_proto_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 type)
481{
482 register struct hci_proto *hp;
483 int mask = 0;
484
485 hp = hci_proto[HCI_PROTO_L2CAP];
486 if (hp && hp->connect_ind)
487 mask |= hp->connect_ind(hdev, bdaddr, type);
488
489 hp = hci_proto[HCI_PROTO_SCO];
490 if (hp && hp->connect_ind)
491 mask |= hp->connect_ind(hdev, bdaddr, type);
492
493 return mask;
494}
495
496static inline void hci_proto_connect_cfm(struct hci_conn *conn, __u8 status)
497{
498 register struct hci_proto *hp;
499
500 hp = hci_proto[HCI_PROTO_L2CAP];
501 if (hp && hp->connect_cfm)
502 hp->connect_cfm(conn, status);
503
504 hp = hci_proto[HCI_PROTO_SCO];
505 if (hp && hp->connect_cfm)
506 hp->connect_cfm(conn, status);
507}
508
509static inline void hci_proto_disconn_ind(struct hci_conn *conn, __u8 reason)
510{
511 register struct hci_proto *hp;
512
513 hp = hci_proto[HCI_PROTO_L2CAP];
514 if (hp && hp->disconn_ind)
515 hp->disconn_ind(conn, reason);
516
517 hp = hci_proto[HCI_PROTO_SCO];
518 if (hp && hp->disconn_ind)
519 hp->disconn_ind(conn, reason);
520}
521
522static inline void hci_proto_auth_cfm(struct hci_conn *conn, __u8 status)
523{
524 register struct hci_proto *hp;
525
526 hp = hci_proto[HCI_PROTO_L2CAP];
527 if (hp && hp->auth_cfm)
528 hp->auth_cfm(conn, status);
529
530 hp = hci_proto[HCI_PROTO_SCO];
531 if (hp && hp->auth_cfm)
532 hp->auth_cfm(conn, status);
533}
534
535static inline void hci_proto_encrypt_cfm(struct hci_conn *conn, __u8 status)
536{
537 register struct hci_proto *hp;
538
539 hp = hci_proto[HCI_PROTO_L2CAP];
540 if (hp && hp->encrypt_cfm)
541 hp->encrypt_cfm(conn, status);
542
543 hp = hci_proto[HCI_PROTO_SCO];
544 if (hp && hp->encrypt_cfm)
545 hp->encrypt_cfm(conn, status);
546}
547
548int hci_register_proto(struct hci_proto *hproto);
549int hci_unregister_proto(struct hci_proto *hproto);
550
551
552struct hci_cb {
553 struct list_head list;
554
555 char *name;
556
557 void (*auth_cfm) (struct hci_conn *conn, __u8 status);
558 void (*encrypt_cfm) (struct hci_conn *conn, __u8 status, __u8 encrypt);
559 void (*key_change_cfm) (struct hci_conn *conn, __u8 status);
560 void (*role_switch_cfm) (struct hci_conn *conn, __u8 status, __u8 role);
561};
562
563static inline void hci_auth_cfm(struct hci_conn *conn, __u8 status)
564{
565 struct list_head *p;
566
567 hci_proto_auth_cfm(conn, status);
568
569 read_lock_bh(&hci_cb_list_lock);
570 list_for_each(p, &hci_cb_list) {
571 struct hci_cb *cb = list_entry(p, struct hci_cb, list);
572 if (cb->auth_cfm)
573 cb->auth_cfm(conn, status);
574 }
575 read_unlock_bh(&hci_cb_list_lock);
576}
577
578static inline void hci_encrypt_cfm(struct hci_conn *conn, __u8 status, __u8 encrypt)
579{
580 struct list_head *p;
581
582 hci_proto_encrypt_cfm(conn, status);
583
584 read_lock_bh(&hci_cb_list_lock);
585 list_for_each(p, &hci_cb_list) {
586 struct hci_cb *cb = list_entry(p, struct hci_cb, list);
587 if (cb->encrypt_cfm)
588 cb->encrypt_cfm(conn, status, encrypt);
589 }
590 read_unlock_bh(&hci_cb_list_lock);
591}
592
593static inline void hci_key_change_cfm(struct hci_conn *conn, __u8 status)
594{
595 struct list_head *p;
596
597 read_lock_bh(&hci_cb_list_lock);
598 list_for_each(p, &hci_cb_list) {
599 struct hci_cb *cb = list_entry(p, struct hci_cb, list);
600 if (cb->key_change_cfm)
601 cb->key_change_cfm(conn, status);
602 }
603 read_unlock_bh(&hci_cb_list_lock);
604}
605
606static inline void hci_role_switch_cfm(struct hci_conn *conn, __u8 status, __u8 role)
607{
608 struct list_head *p;
609
610 read_lock_bh(&hci_cb_list_lock);
611 list_for_each(p, &hci_cb_list) {
612 struct hci_cb *cb = list_entry(p, struct hci_cb, list);
613 if (cb->role_switch_cfm)
614 cb->role_switch_cfm(conn, status, role);
615 }
616 read_unlock_bh(&hci_cb_list_lock);
617}
618
619int hci_register_cb(struct hci_cb *hcb);
620int hci_unregister_cb(struct hci_cb *hcb);
621
622int hci_register_notifier(struct notifier_block *nb);
623int hci_unregister_notifier(struct notifier_block *nb);
624
625int hci_send_cmd(struct hci_dev *hdev, __u16 opcode, __u32 plen, void *param);
626int hci_send_acl(struct hci_conn *conn, struct sk_buff *skb, __u16 flags);
627int hci_send_sco(struct hci_conn *conn, struct sk_buff *skb);
628
629void *hci_sent_cmd_data(struct hci_dev *hdev, __u16 opcode);
630
631void hci_si_event(struct hci_dev *hdev, int type, int dlen, void *data);
632
633
634void hci_send_to_sock(struct hci_dev *hdev, struct sk_buff *skb);
635
636
637#define hci_pi(sk) ((struct hci_pinfo *) sk)
638
639struct hci_pinfo {
640 struct bt_sock bt;
641 struct hci_dev *hdev;
642 struct hci_filter filter;
643 __u32 cmsg_mask;
644};
645
646
647#define HCI_SFLT_MAX_OGF 5
648
649struct hci_sec_filter {
650 __u32 type_mask;
651 __u32 event_mask[2];
652 __u32 ocf_mask[HCI_SFLT_MAX_OGF + 1][4];
653};
654
655
656#define HCI_REQ_DONE 0
657#define HCI_REQ_PEND 1
658#define HCI_REQ_CANCELED 2
659
660#define hci_req_lock(d) down(&d->req_lock)
661#define hci_req_unlock(d) up(&d->req_lock)
662
663void hci_req_complete(struct hci_dev *hdev, int result);
664
665#endif
666
