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#include <net/bluetooth/hci_sock.h>
30
31
32#define HCI_PRIO_MAX 7
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 __u8 ssp_mode;
44};
45
46struct inquiry_entry {
47 struct list_head all;
48 struct list_head list;
49 enum {
50 NAME_NOT_KNOWN,
51 NAME_NEEDED,
52 NAME_PENDING,
53 NAME_KNOWN,
54 } name_state;
55 __u32 timestamp;
56 struct inquiry_data data;
57};
58
59struct discovery_state {
60 int type;
61 enum {
62 DISCOVERY_STOPPED,
63 DISCOVERY_STARTING,
64 DISCOVERY_FINDING,
65 DISCOVERY_RESOLVING,
66 DISCOVERY_STOPPING,
67 } state;
68 struct list_head all;
69 struct list_head unknown;
70 struct list_head resolve;
71 __u32 timestamp;
72 bdaddr_t last_adv_addr;
73 u8 last_adv_addr_type;
74 s8 last_adv_rssi;
75 u32 last_adv_flags;
76 u8 last_adv_data[HCI_MAX_AD_LENGTH];
77 u8 last_adv_data_len;
78 bool report_invalid_rssi;
79 s8 rssi;
80 u16 uuid_count;
81 u8 (*uuids)[16];
82 unsigned long scan_start;
83 unsigned long scan_duration;
84};
85
86struct hci_conn_hash {
87 struct list_head list;
88 unsigned int acl_num;
89 unsigned int amp_num;
90 unsigned int sco_num;
91 unsigned int le_num;
92 unsigned int le_num_slave;
93};
94
95struct bdaddr_list {
96 struct list_head list;
97 bdaddr_t bdaddr;
98 u8 bdaddr_type;
99};
100
101struct bt_uuid {
102 struct list_head list;
103 u8 uuid[16];
104 u8 size;
105 u8 svc_hint;
106};
107
108struct smp_csrk {
109 bdaddr_t bdaddr;
110 u8 bdaddr_type;
111 u8 master;
112 u8 val[16];
113};
114
115struct smp_ltk {
116 struct list_head list;
117 struct rcu_head rcu;
118 bdaddr_t bdaddr;
119 u8 bdaddr_type;
120 u8 authenticated;
121 u8 type;
122 u8 enc_size;
123 __le16 ediv;
124 __le64 rand;
125 u8 val[16];
126};
127
128struct smp_irk {
129 struct list_head list;
130 struct rcu_head rcu;
131 bdaddr_t rpa;
132 bdaddr_t bdaddr;
133 u8 addr_type;
134 u8 val[16];
135};
136
137struct link_key {
138 struct list_head list;
139 struct rcu_head rcu;
140 bdaddr_t bdaddr;
141 u8 type;
142 u8 val[HCI_LINK_KEY_SIZE];
143 u8 pin_len;
144};
145
146struct oob_data {
147 struct list_head list;
148 bdaddr_t bdaddr;
149 u8 bdaddr_type;
150 u8 present;
151 u8 hash192[16];
152 u8 rand192[16];
153 u8 hash256[16];
154 u8 rand256[16];
155};
156
157#define HCI_MAX_SHORT_NAME_LENGTH 10
158
159
160#define HCI_DEFAULT_RPA_TIMEOUT (15 * 60)
161
162
163#define DEFAULT_CONN_INFO_MIN_AGE 1000
164#define DEFAULT_CONN_INFO_MAX_AGE 3000
165
166struct amp_assoc {
167 __u16 len;
168 __u16 offset;
169 __u16 rem_len;
170 __u16 len_so_far;
171 __u8 data[HCI_MAX_AMP_ASSOC_SIZE];
172};
173
174#define HCI_MAX_PAGES 3
175
176#define NUM_REASSEMBLY 4
177struct hci_dev {
178 struct list_head list;
179 struct mutex lock;
180
181 char name[8];
182 unsigned long flags;
183 __u16 id;
184 __u8 bus;
185 __u8 dev_type;
186 bdaddr_t bdaddr;
187 bdaddr_t setup_addr;
188 bdaddr_t public_addr;
189 bdaddr_t random_addr;
190 bdaddr_t static_addr;
191 __u8 adv_addr_type;
192 __u8 dev_name[HCI_MAX_NAME_LENGTH];
193 __u8 short_name[HCI_MAX_SHORT_NAME_LENGTH];
194 __u8 eir[HCI_MAX_EIR_LENGTH];
195 __u8 dev_class[3];
196 __u8 major_class;
197 __u8 minor_class;
198 __u8 max_page;
199 __u8 features[HCI_MAX_PAGES][8];
200 __u8 le_features[8];
201 __u8 le_white_list_size;
202 __u8 le_states[8];
203 __u8 commands[64];
204 __u8 hci_ver;
205 __u16 hci_rev;
206 __u8 lmp_ver;
207 __u16 manufacturer;
208 __u16 lmp_subver;
209 __u16 voice_setting;
210 __u8 num_iac;
211 __u8 stored_max_keys;
212 __u8 stored_num_keys;
213 __u8 io_capability;
214 __s8 inq_tx_power;
215 __u16 page_scan_interval;
216 __u16 page_scan_window;
217 __u8 page_scan_type;
218 __u8 le_adv_channel_map;
219 __u16 le_adv_min_interval;
220 __u16 le_adv_max_interval;
221 __u8 le_scan_type;
222 __u16 le_scan_interval;
223 __u16 le_scan_window;
224 __u16 le_conn_min_interval;
225 __u16 le_conn_max_interval;
226 __u16 le_conn_latency;
227 __u16 le_supv_timeout;
228 __u16 le_def_tx_len;
229 __u16 le_def_tx_time;
230 __u16 le_max_tx_len;
231 __u16 le_max_tx_time;
232 __u16 le_max_rx_len;
233 __u16 le_max_rx_time;
234 __u16 discov_interleaved_timeout;
235 __u16 conn_info_min_age;
236 __u16 conn_info_max_age;
237 __u8 ssp_debug_mode;
238 __u8 hw_error_code;
239 __u32 clock;
240
241 __u16 devid_source;
242 __u16 devid_vendor;
243 __u16 devid_product;
244 __u16 devid_version;
245
246 __u16 pkt_type;
247 __u16 esco_type;
248 __u16 link_policy;
249 __u16 link_mode;
250
251 __u32 idle_timeout;
252 __u16 sniff_min_interval;
253 __u16 sniff_max_interval;
254
255 __u8 amp_status;
256 __u32 amp_total_bw;
257 __u32 amp_max_bw;
258 __u32 amp_min_latency;
259 __u32 amp_max_pdu;
260 __u8 amp_type;
261 __u16 amp_pal_cap;
262 __u16 amp_assoc_size;
263 __u32 amp_max_flush_to;
264 __u32 amp_be_flush_to;
265
266 struct amp_assoc loc_assoc;
267
268 __u8 flow_ctl_mode;
269
270 unsigned int auto_accept_delay;
271
272 unsigned long quirks;
273
274 atomic_t cmd_cnt;
275 unsigned int acl_cnt;
276 unsigned int sco_cnt;
277 unsigned int le_cnt;
278
279 unsigned int acl_mtu;
280 unsigned int sco_mtu;
281 unsigned int le_mtu;
282 unsigned int acl_pkts;
283 unsigned int sco_pkts;
284 unsigned int le_pkts;
285
286 __u16 block_len;
287 __u16 block_mtu;
288 __u16 num_blocks;
289 __u16 block_cnt;
290
291 unsigned long acl_last_tx;
292 unsigned long sco_last_tx;
293 unsigned long le_last_tx;
294
295 struct workqueue_struct *workqueue;
296 struct workqueue_struct *req_workqueue;
297
298 struct work_struct power_on;
299 struct delayed_work power_off;
300 struct work_struct error_reset;
301
302 __u16 discov_timeout;
303 struct delayed_work discov_off;
304
305 struct delayed_work service_cache;
306
307 struct delayed_work cmd_timer;
308
309 struct work_struct rx_work;
310 struct work_struct cmd_work;
311 struct work_struct tx_work;
312
313 struct sk_buff_head rx_q;
314 struct sk_buff_head raw_q;
315 struct sk_buff_head cmd_q;
316
317 struct sk_buff *recv_evt;
318 struct sk_buff *sent_cmd;
319 struct sk_buff *reassembly[NUM_REASSEMBLY];
320
321 struct mutex req_lock;
322 wait_queue_head_t req_wait_q;
323 __u32 req_status;
324 __u32 req_result;
325
326 void *smp_data;
327 void *smp_bredr_data;
328
329 struct discovery_state discovery;
330 struct hci_conn_hash conn_hash;
331
332 struct list_head mgmt_pending;
333 struct list_head blacklist;
334 struct list_head whitelist;
335 struct list_head uuids;
336 struct list_head link_keys;
337 struct list_head long_term_keys;
338 struct list_head identity_resolving_keys;
339 struct list_head remote_oob_data;
340 struct list_head le_white_list;
341 struct list_head le_conn_params;
342 struct list_head pend_le_conns;
343 struct list_head pend_le_reports;
344
345 struct hci_dev_stats stat;
346
347 atomic_t promisc;
348
349 struct dentry *debugfs;
350
351 struct device dev;
352
353 struct rfkill *rfkill;
354
355 unsigned long dbg_flags;
356 unsigned long dev_flags;
357
358 struct delayed_work le_scan_disable;
359 struct delayed_work le_scan_restart;
360
361 __s8 adv_tx_power;
362 __u8 adv_data[HCI_MAX_AD_LENGTH];
363 __u8 adv_data_len;
364 __u8 scan_rsp_data[HCI_MAX_AD_LENGTH];
365 __u8 scan_rsp_data_len;
366
367 __u8 irk[16];
368 __u32 rpa_timeout;
369 struct delayed_work rpa_expired;
370 bdaddr_t rpa;
371
372 int (*open)(struct hci_dev *hdev);
373 int (*close)(struct hci_dev *hdev);
374 int (*flush)(struct hci_dev *hdev);
375 int (*setup)(struct hci_dev *hdev);
376 int (*send)(struct hci_dev *hdev, struct sk_buff *skb);
377 void (*notify)(struct hci_dev *hdev, unsigned int evt);
378 void (*hw_error)(struct hci_dev *hdev, u8 code);
379 int (*set_bdaddr)(struct hci_dev *hdev, const bdaddr_t *bdaddr);
380};
381
382#define HCI_PHY_HANDLE(handle) (handle & 0xff)
383
384struct hci_conn {
385 struct list_head list;
386
387 atomic_t refcnt;
388
389 bdaddr_t dst;
390 __u8 dst_type;
391 bdaddr_t src;
392 __u8 src_type;
393 bdaddr_t init_addr;
394 __u8 init_addr_type;
395 bdaddr_t resp_addr;
396 __u8 resp_addr_type;
397 __u16 handle;
398 __u16 state;
399 __u8 mode;
400 __u8 type;
401 __u8 role;
402 bool out;
403 __u8 attempt;
404 __u8 dev_class[3];
405 __u8 features[HCI_MAX_PAGES][8];
406 __u16 pkt_type;
407 __u16 link_policy;
408 __u8 key_type;
409 __u8 auth_type;
410 __u8 sec_level;
411 __u8 pending_sec_level;
412 __u8 pin_length;
413 __u8 enc_key_size;
414 __u8 io_capability;
415 __u32 passkey_notify;
416 __u8 passkey_entered;
417 __u16 disc_timeout;
418 __u16 conn_timeout;
419 __u16 setting;
420 __u16 le_conn_min_interval;
421 __u16 le_conn_max_interval;
422 __u16 le_conn_interval;
423 __u16 le_conn_latency;
424 __u16 le_supv_timeout;
425 __u8 le_adv_data[HCI_MAX_AD_LENGTH];
426 __u8 le_adv_data_len;
427 __s8 rssi;
428 __s8 tx_power;
429 __s8 max_tx_power;
430 unsigned long flags;
431
432 __u32 clock;
433 __u16 clock_accuracy;
434
435 unsigned long conn_info_timestamp;
436
437 __u8 remote_cap;
438 __u8 remote_auth;
439 __u8 remote_id;
440
441 unsigned int sent;
442
443 struct sk_buff_head data_q;
444 struct list_head chan_list;
445
446 struct delayed_work disc_work;
447 struct delayed_work auto_accept_work;
448 struct delayed_work idle_work;
449 struct delayed_work le_conn_timeout;
450
451 struct device dev;
452 struct dentry *debugfs;
453
454 struct hci_dev *hdev;
455 void *l2cap_data;
456 void *sco_data;
457 struct amp_mgr *amp_mgr;
458
459 struct hci_conn *link;
460
461 void (*connect_cfm_cb) (struct hci_conn *conn, u8 status);
462 void (*security_cfm_cb) (struct hci_conn *conn, u8 status);
463 void (*disconn_cfm_cb) (struct hci_conn *conn, u8 reason);
464};
465
466struct hci_chan {
467 struct list_head list;
468 __u16 handle;
469 struct hci_conn *conn;
470 struct sk_buff_head data_q;
471 unsigned int sent;
472 __u8 state;
473};
474
475struct hci_conn_params {
476 struct list_head list;
477 struct list_head action;
478
479 bdaddr_t addr;
480 u8 addr_type;
481
482 u16 conn_min_interval;
483 u16 conn_max_interval;
484 u16 conn_latency;
485 u16 supervision_timeout;
486
487 enum {
488 HCI_AUTO_CONN_DISABLED,
489 HCI_AUTO_CONN_REPORT,
490 HCI_AUTO_CONN_DIRECT,
491 HCI_AUTO_CONN_ALWAYS,
492 HCI_AUTO_CONN_LINK_LOSS,
493 } auto_connect;
494
495 struct hci_conn *conn;
496};
497
498extern struct list_head hci_dev_list;
499extern struct list_head hci_cb_list;
500extern rwlock_t hci_dev_list_lock;
501extern rwlock_t hci_cb_list_lock;
502
503
504int l2cap_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr);
505void l2cap_connect_cfm(struct hci_conn *hcon, u8 status);
506int l2cap_disconn_ind(struct hci_conn *hcon);
507void l2cap_disconn_cfm(struct hci_conn *hcon, u8 reason);
508int l2cap_security_cfm(struct hci_conn *hcon, u8 status, u8 encrypt);
509int l2cap_recv_acldata(struct hci_conn *hcon, struct sk_buff *skb, u16 flags);
510
511int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 *flags);
512void sco_connect_cfm(struct hci_conn *hcon, __u8 status);
513void sco_disconn_cfm(struct hci_conn *hcon, __u8 reason);
514int sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb);
515
516
517#define INQUIRY_CACHE_AGE_MAX (HZ*30)
518#define INQUIRY_ENTRY_AGE_MAX (HZ*60)
519
520static inline void discovery_init(struct hci_dev *hdev)
521{
522 hdev->discovery.state = DISCOVERY_STOPPED;
523 INIT_LIST_HEAD(&hdev->discovery.all);
524 INIT_LIST_HEAD(&hdev->discovery.unknown);
525 INIT_LIST_HEAD(&hdev->discovery.resolve);
526 hdev->discovery.report_invalid_rssi = true;
527 hdev->discovery.rssi = HCI_RSSI_INVALID;
528}
529
530static inline void hci_discovery_filter_clear(struct hci_dev *hdev)
531{
532 hdev->discovery.report_invalid_rssi = true;
533 hdev->discovery.rssi = HCI_RSSI_INVALID;
534 hdev->discovery.uuid_count = 0;
535 kfree(hdev->discovery.uuids);
536 hdev->discovery.uuids = NULL;
537 hdev->discovery.scan_start = 0;
538 hdev->discovery.scan_duration = 0;
539}
540
541bool hci_discovery_active(struct hci_dev *hdev);
542
543void hci_discovery_set_state(struct hci_dev *hdev, int state);
544
545static inline int inquiry_cache_empty(struct hci_dev *hdev)
546{
547 return list_empty(&hdev->discovery.all);
548}
549
550static inline long inquiry_cache_age(struct hci_dev *hdev)
551{
552 struct discovery_state *c = &hdev->discovery;
553 return jiffies - c->timestamp;
554}
555
556static inline long inquiry_entry_age(struct inquiry_entry *e)
557{
558 return jiffies - e->timestamp;
559}
560
561struct inquiry_entry *hci_inquiry_cache_lookup(struct hci_dev *hdev,
562 bdaddr_t *bdaddr);
563struct inquiry_entry *hci_inquiry_cache_lookup_unknown(struct hci_dev *hdev,
564 bdaddr_t *bdaddr);
565struct inquiry_entry *hci_inquiry_cache_lookup_resolve(struct hci_dev *hdev,
566 bdaddr_t *bdaddr,
567 int state);
568void hci_inquiry_cache_update_resolve(struct hci_dev *hdev,
569 struct inquiry_entry *ie);
570u32 hci_inquiry_cache_update(struct hci_dev *hdev, struct inquiry_data *data,
571 bool name_known);
572void hci_inquiry_cache_flush(struct hci_dev *hdev);
573
574
575enum {
576 HCI_CONN_AUTH_PEND,
577 HCI_CONN_REAUTH_PEND,
578 HCI_CONN_ENCRYPT_PEND,
579 HCI_CONN_RSWITCH_PEND,
580 HCI_CONN_MODE_CHANGE_PEND,
581 HCI_CONN_SCO_SETUP_PEND,
582 HCI_CONN_MGMT_CONNECTED,
583 HCI_CONN_SSP_ENABLED,
584 HCI_CONN_SC_ENABLED,
585 HCI_CONN_AES_CCM,
586 HCI_CONN_POWER_SAVE,
587 HCI_CONN_REMOTE_OOB,
588 HCI_CONN_FLUSH_KEY,
589 HCI_CONN_ENCRYPT,
590 HCI_CONN_AUTH,
591 HCI_CONN_SECURE,
592 HCI_CONN_FIPS,
593 HCI_CONN_STK_ENCRYPT,
594 HCI_CONN_AUTH_INITIATOR,
595 HCI_CONN_DROP,
596 HCI_CONN_PARAM_REMOVAL_PEND,
597 HCI_CONN_NEW_LINK_KEY,
598};
599
600static inline bool hci_conn_ssp_enabled(struct hci_conn *conn)
601{
602 struct hci_dev *hdev = conn->hdev;
603 return test_bit(HCI_SSP_ENABLED, &hdev->dev_flags) &&
604 test_bit(HCI_CONN_SSP_ENABLED, &conn->flags);
605}
606
607static inline bool hci_conn_sc_enabled(struct hci_conn *conn)
608{
609 struct hci_dev *hdev = conn->hdev;
610 return test_bit(HCI_SC_ENABLED, &hdev->dev_flags) &&
611 test_bit(HCI_CONN_SC_ENABLED, &conn->flags);
612}
613
614static inline void hci_conn_hash_add(struct hci_dev *hdev, struct hci_conn *c)
615{
616 struct hci_conn_hash *h = &hdev->conn_hash;
617 list_add_rcu(&c->list, &h->list);
618 switch (c->type) {
619 case ACL_LINK:
620 h->acl_num++;
621 break;
622 case AMP_LINK:
623 h->amp_num++;
624 break;
625 case LE_LINK:
626 h->le_num++;
627 if (c->role == HCI_ROLE_SLAVE)
628 h->le_num_slave++;
629 break;
630 case SCO_LINK:
631 case ESCO_LINK:
632 h->sco_num++;
633 break;
634 }
635}
636
637static inline void hci_conn_hash_del(struct hci_dev *hdev, struct hci_conn *c)
638{
639 struct hci_conn_hash *h = &hdev->conn_hash;
640
641 list_del_rcu(&c->list);
642 synchronize_rcu();
643
644 switch (c->type) {
645 case ACL_LINK:
646 h->acl_num--;
647 break;
648 case AMP_LINK:
649 h->amp_num--;
650 break;
651 case LE_LINK:
652 h->le_num--;
653 if (c->role == HCI_ROLE_SLAVE)
654 h->le_num_slave--;
655 break;
656 case SCO_LINK:
657 case ESCO_LINK:
658 h->sco_num--;
659 break;
660 }
661}
662
663static inline unsigned int hci_conn_num(struct hci_dev *hdev, __u8 type)
664{
665 struct hci_conn_hash *h = &hdev->conn_hash;
666 switch (type) {
667 case ACL_LINK:
668 return h->acl_num;
669 case AMP_LINK:
670 return h->amp_num;
671 case LE_LINK:
672 return h->le_num;
673 case SCO_LINK:
674 case ESCO_LINK:
675 return h->sco_num;
676 default:
677 return 0;
678 }
679}
680
681static inline unsigned int hci_conn_count(struct hci_dev *hdev)
682{
683 struct hci_conn_hash *c = &hdev->conn_hash;
684
685 return c->acl_num + c->amp_num + c->sco_num + c->le_num;
686}
687
688static inline __u8 hci_conn_lookup_type(struct hci_dev *hdev, __u16 handle)
689{
690 struct hci_conn_hash *h = &hdev->conn_hash;
691 struct hci_conn *c;
692 __u8 type = INVALID_LINK;
693
694 rcu_read_lock();
695
696 list_for_each_entry_rcu(c, &h->list, list) {
697 if (c->handle == handle) {
698 type = c->type;
699 break;
700 }
701 }
702
703 rcu_read_unlock();
704
705 return type;
706}
707
708static inline struct hci_conn *hci_conn_hash_lookup_handle(struct hci_dev *hdev,
709 __u16 handle)
710{
711 struct hci_conn_hash *h = &hdev->conn_hash;
712 struct hci_conn *c;
713
714 rcu_read_lock();
715
716 list_for_each_entry_rcu(c, &h->list, list) {
717 if (c->handle == handle) {
718 rcu_read_unlock();
719 return c;
720 }
721 }
722 rcu_read_unlock();
723
724 return NULL;
725}
726
727static inline struct hci_conn *hci_conn_hash_lookup_ba(struct hci_dev *hdev,
728 __u8 type, bdaddr_t *ba)
729{
730 struct hci_conn_hash *h = &hdev->conn_hash;
731 struct hci_conn *c;
732
733 rcu_read_lock();
734
735 list_for_each_entry_rcu(c, &h->list, list) {
736 if (c->type == type && !bacmp(&c->dst, ba)) {
737 rcu_read_unlock();
738 return c;
739 }
740 }
741
742 rcu_read_unlock();
743
744 return NULL;
745}
746
747static inline struct hci_conn *hci_conn_hash_lookup_state(struct hci_dev *hdev,
748 __u8 type, __u16 state)
749{
750 struct hci_conn_hash *h = &hdev->conn_hash;
751 struct hci_conn *c;
752
753 rcu_read_lock();
754
755 list_for_each_entry_rcu(c, &h->list, list) {
756 if (c->type == type && c->state == state) {
757 rcu_read_unlock();
758 return c;
759 }
760 }
761
762 rcu_read_unlock();
763
764 return NULL;
765}
766
767int hci_disconnect(struct hci_conn *conn, __u8 reason);
768bool hci_setup_sync(struct hci_conn *conn, __u16 handle);
769void hci_sco_setup(struct hci_conn *conn, __u8 status);
770
771struct hci_conn *hci_conn_add(struct hci_dev *hdev, int type, bdaddr_t *dst,
772 u8 role);
773int hci_conn_del(struct hci_conn *conn);
774void hci_conn_hash_flush(struct hci_dev *hdev);
775void hci_conn_check_pending(struct hci_dev *hdev);
776
777struct hci_chan *hci_chan_create(struct hci_conn *conn);
778void hci_chan_del(struct hci_chan *chan);
779void hci_chan_list_flush(struct hci_conn *conn);
780struct hci_chan *hci_chan_lookup_handle(struct hci_dev *hdev, __u16 handle);
781
782struct hci_conn *hci_connect_le(struct hci_dev *hdev, bdaddr_t *dst,
783 u8 dst_type, u8 sec_level, u16 conn_timeout,
784 u8 role);
785struct hci_conn *hci_connect_acl(struct hci_dev *hdev, bdaddr_t *dst,
786 u8 sec_level, u8 auth_type);
787struct hci_conn *hci_connect_sco(struct hci_dev *hdev, int type, bdaddr_t *dst,
788 __u16 setting);
789int hci_conn_check_link_mode(struct hci_conn *conn);
790int hci_conn_check_secure(struct hci_conn *conn, __u8 sec_level);
791int hci_conn_security(struct hci_conn *conn, __u8 sec_level, __u8 auth_type,
792 bool initiator);
793int hci_conn_switch_role(struct hci_conn *conn, __u8 role);
794
795void hci_conn_enter_active_mode(struct hci_conn *conn, __u8 force_active);
796
797void hci_le_conn_failed(struct hci_conn *conn, u8 status);
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820static inline struct hci_conn *hci_conn_get(struct hci_conn *conn)
821{
822 get_device(&conn->dev);
823 return conn;
824}
825
826static inline void hci_conn_put(struct hci_conn *conn)
827{
828 put_device(&conn->dev);
829}
830
831static inline void hci_conn_hold(struct hci_conn *conn)
832{
833 BT_DBG("hcon %p orig refcnt %d", conn, atomic_read(&conn->refcnt));
834
835 atomic_inc(&conn->refcnt);
836 cancel_delayed_work(&conn->disc_work);
837}
838
839static inline void hci_conn_drop(struct hci_conn *conn)
840{
841 BT_DBG("hcon %p orig refcnt %d", conn, atomic_read(&conn->refcnt));
842
843 if (atomic_dec_and_test(&conn->refcnt)) {
844 unsigned long timeo;
845
846 switch (conn->type) {
847 case ACL_LINK:
848 case LE_LINK:
849 cancel_delayed_work(&conn->idle_work);
850 if (conn->state == BT_CONNECTED) {
851 timeo = conn->disc_timeout;
852 if (!conn->out)
853 timeo *= 2;
854 } else {
855 timeo = 0;
856 }
857 break;
858
859 case AMP_LINK:
860 timeo = conn->disc_timeout;
861 break;
862
863 default:
864 timeo = 0;
865 break;
866 }
867
868 cancel_delayed_work(&conn->disc_work);
869 queue_delayed_work(conn->hdev->workqueue,
870 &conn->disc_work, timeo);
871 }
872}
873
874
875static inline void hci_dev_put(struct hci_dev *d)
876{
877 BT_DBG("%s orig refcnt %d", d->name,
878 atomic_read(&d->dev.kobj.kref.refcount));
879
880 put_device(&d->dev);
881}
882
883static inline struct hci_dev *hci_dev_hold(struct hci_dev *d)
884{
885 BT_DBG("%s orig refcnt %d", d->name,
886 atomic_read(&d->dev.kobj.kref.refcount));
887
888 get_device(&d->dev);
889 return d;
890}
891
892#define hci_dev_lock(d) mutex_lock(&d->lock)
893#define hci_dev_unlock(d) mutex_unlock(&d->lock)
894
895#define to_hci_dev(d) container_of(d, struct hci_dev, dev)
896#define to_hci_conn(c) container_of(c, struct hci_conn, dev)
897
898static inline void *hci_get_drvdata(struct hci_dev *hdev)
899{
900 return dev_get_drvdata(&hdev->dev);
901}
902
903static inline void hci_set_drvdata(struct hci_dev *hdev, void *data)
904{
905 dev_set_drvdata(&hdev->dev, data);
906}
907
908struct hci_dev *hci_dev_get(int index);
909struct hci_dev *hci_get_route(bdaddr_t *dst, bdaddr_t *src);
910
911struct hci_dev *hci_alloc_dev(void);
912void hci_free_dev(struct hci_dev *hdev);
913int hci_register_dev(struct hci_dev *hdev);
914void hci_unregister_dev(struct hci_dev *hdev);
915int hci_suspend_dev(struct hci_dev *hdev);
916int hci_resume_dev(struct hci_dev *hdev);
917int hci_reset_dev(struct hci_dev *hdev);
918int hci_dev_open(__u16 dev);
919int hci_dev_close(__u16 dev);
920int hci_dev_reset(__u16 dev);
921int hci_dev_reset_stat(__u16 dev);
922int hci_dev_cmd(unsigned int cmd, void __user *arg);
923int hci_get_dev_list(void __user *arg);
924int hci_get_dev_info(void __user *arg);
925int hci_get_conn_list(void __user *arg);
926int hci_get_conn_info(struct hci_dev *hdev, void __user *arg);
927int hci_get_auth_info(struct hci_dev *hdev, void __user *arg);
928int hci_inquiry(void __user *arg);
929
930struct bdaddr_list *hci_bdaddr_list_lookup(struct list_head *list,
931 bdaddr_t *bdaddr, u8 type);
932int hci_bdaddr_list_add(struct list_head *list, bdaddr_t *bdaddr, u8 type);
933int hci_bdaddr_list_del(struct list_head *list, bdaddr_t *bdaddr, u8 type);
934void hci_bdaddr_list_clear(struct list_head *list);
935
936struct hci_conn_params *hci_conn_params_lookup(struct hci_dev *hdev,
937 bdaddr_t *addr, u8 addr_type);
938struct hci_conn_params *hci_conn_params_add(struct hci_dev *hdev,
939 bdaddr_t *addr, u8 addr_type);
940void hci_conn_params_del(struct hci_dev *hdev, bdaddr_t *addr, u8 addr_type);
941void hci_conn_params_clear_all(struct hci_dev *hdev);
942void hci_conn_params_clear_disabled(struct hci_dev *hdev);
943
944struct hci_conn_params *hci_pend_le_action_lookup(struct list_head *list,
945 bdaddr_t *addr,
946 u8 addr_type);
947
948void hci_uuids_clear(struct hci_dev *hdev);
949
950void hci_link_keys_clear(struct hci_dev *hdev);
951struct link_key *hci_find_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr);
952struct link_key *hci_add_link_key(struct hci_dev *hdev, struct hci_conn *conn,
953 bdaddr_t *bdaddr, u8 *val, u8 type,
954 u8 pin_len, bool *persistent);
955struct smp_ltk *hci_add_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr,
956 u8 addr_type, u8 type, u8 authenticated,
957 u8 tk[16], u8 enc_size, __le16 ediv, __le64 rand);
958struct smp_ltk *hci_find_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr,
959 u8 addr_type, u8 role);
960int hci_remove_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 bdaddr_type);
961void hci_smp_ltks_clear(struct hci_dev *hdev);
962int hci_remove_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr);
963
964struct smp_irk *hci_find_irk_by_rpa(struct hci_dev *hdev, bdaddr_t *rpa);
965struct smp_irk *hci_find_irk_by_addr(struct hci_dev *hdev, bdaddr_t *bdaddr,
966 u8 addr_type);
967struct smp_irk *hci_add_irk(struct hci_dev *hdev, bdaddr_t *bdaddr,
968 u8 addr_type, u8 val[16], bdaddr_t *rpa);
969void hci_remove_irk(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 addr_type);
970void hci_smp_irks_clear(struct hci_dev *hdev);
971
972void hci_remote_oob_data_clear(struct hci_dev *hdev);
973struct oob_data *hci_find_remote_oob_data(struct hci_dev *hdev,
974 bdaddr_t *bdaddr, u8 bdaddr_type);
975int hci_add_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr,
976 u8 bdaddr_type, u8 *hash192, u8 *rand192,
977 u8 *hash256, u8 *rand256);
978int hci_remove_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr,
979 u8 bdaddr_type);
980
981void hci_event_packet(struct hci_dev *hdev, struct sk_buff *skb);
982
983int hci_recv_frame(struct hci_dev *hdev, struct sk_buff *skb);
984int hci_recv_stream_fragment(struct hci_dev *hdev, void *data, int count);
985
986void hci_init_sysfs(struct hci_dev *hdev);
987void hci_conn_init_sysfs(struct hci_conn *conn);
988void hci_conn_add_sysfs(struct hci_conn *conn);
989void hci_conn_del_sysfs(struct hci_conn *conn);
990
991#define SET_HCIDEV_DEV(hdev, pdev) ((hdev)->dev.parent = (pdev))
992
993
994#define lmp_encrypt_capable(dev) ((dev)->features[0][0] & LMP_ENCRYPT)
995#define lmp_rswitch_capable(dev) ((dev)->features[0][0] & LMP_RSWITCH)
996#define lmp_hold_capable(dev) ((dev)->features[0][0] & LMP_HOLD)
997#define lmp_sniff_capable(dev) ((dev)->features[0][0] & LMP_SNIFF)
998#define lmp_park_capable(dev) ((dev)->features[0][1] & LMP_PARK)
999#define lmp_inq_rssi_capable(dev) ((dev)->features[0][3] & LMP_RSSI_INQ)
1000#define lmp_esco_capable(dev) ((dev)->features[0][3] & LMP_ESCO)
1001#define lmp_bredr_capable(dev) (!((dev)->features[0][4] & LMP_NO_BREDR))
1002#define lmp_le_capable(dev) ((dev)->features[0][4] & LMP_LE)
1003#define lmp_sniffsubr_capable(dev) ((dev)->features[0][5] & LMP_SNIFF_SUBR)
1004#define lmp_pause_enc_capable(dev) ((dev)->features[0][5] & LMP_PAUSE_ENC)
1005#define lmp_ext_inq_capable(dev) ((dev)->features[0][6] & LMP_EXT_INQ)
1006#define lmp_le_br_capable(dev) (!!((dev)->features[0][6] & LMP_SIMUL_LE_BR))
1007#define lmp_ssp_capable(dev) ((dev)->features[0][6] & LMP_SIMPLE_PAIR)
1008#define lmp_no_flush_capable(dev) ((dev)->features[0][6] & LMP_NO_FLUSH)
1009#define lmp_lsto_capable(dev) ((dev)->features[0][7] & LMP_LSTO)
1010#define lmp_inq_tx_pwr_capable(dev) ((dev)->features[0][7] & LMP_INQ_TX_PWR)
1011#define lmp_ext_feat_capable(dev) ((dev)->features[0][7] & LMP_EXTFEATURES)
1012#define lmp_transp_capable(dev) ((dev)->features[0][2] & LMP_TRANSPARENT)
1013
1014
1015#define lmp_csb_master_capable(dev) ((dev)->features[2][0] & LMP_CSB_MASTER)
1016#define lmp_csb_slave_capable(dev) ((dev)->features[2][0] & LMP_CSB_SLAVE)
1017#define lmp_sync_train_capable(dev) ((dev)->features[2][0] & LMP_SYNC_TRAIN)
1018#define lmp_sync_scan_capable(dev) ((dev)->features[2][0] & LMP_SYNC_SCAN)
1019#define lmp_sc_capable(dev) ((dev)->features[2][1] & LMP_SC)
1020#define lmp_ping_capable(dev) ((dev)->features[2][1] & LMP_PING)
1021
1022
1023#define lmp_host_ssp_capable(dev) ((dev)->features[1][0] & LMP_HOST_SSP)
1024#define lmp_host_sc_capable(dev) ((dev)->features[1][0] & LMP_HOST_SC)
1025#define lmp_host_le_capable(dev) (!!((dev)->features[1][0] & LMP_HOST_LE))
1026#define lmp_host_le_br_capable(dev) (!!((dev)->features[1][0] & LMP_HOST_LE_BREDR))
1027
1028#define hdev_is_powered(hdev) (test_bit(HCI_UP, &hdev->flags) && \
1029 !test_bit(HCI_AUTO_OFF, &hdev->dev_flags))
1030#define bredr_sc_enabled(dev) (lmp_sc_capable(dev) && \
1031 test_bit(HCI_SC_ENABLED, &(dev)->dev_flags))
1032
1033
1034#define HCI_PROTO_DEFER 0x01
1035
1036static inline int hci_proto_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr,
1037 __u8 type, __u8 *flags)
1038{
1039 switch (type) {
1040 case ACL_LINK:
1041 return l2cap_connect_ind(hdev, bdaddr);
1042
1043 case SCO_LINK:
1044 case ESCO_LINK:
1045 return sco_connect_ind(hdev, bdaddr, flags);
1046
1047 default:
1048 BT_ERR("unknown link type %d", type);
1049 return -EINVAL;
1050 }
1051}
1052
1053static inline void hci_proto_connect_cfm(struct hci_conn *conn, __u8 status)
1054{
1055 switch (conn->type) {
1056 case ACL_LINK:
1057 case LE_LINK:
1058 l2cap_connect_cfm(conn, status);
1059 break;
1060
1061 case SCO_LINK:
1062 case ESCO_LINK:
1063 sco_connect_cfm(conn, status);
1064 break;
1065
1066 default:
1067 BT_ERR("unknown link type %d", conn->type);
1068 break;
1069 }
1070
1071 if (conn->connect_cfm_cb)
1072 conn->connect_cfm_cb(conn, status);
1073}
1074
1075static inline int hci_proto_disconn_ind(struct hci_conn *conn)
1076{
1077 if (conn->type != ACL_LINK && conn->type != LE_LINK)
1078 return HCI_ERROR_REMOTE_USER_TERM;
1079
1080 return l2cap_disconn_ind(conn);
1081}
1082
1083static inline void hci_proto_disconn_cfm(struct hci_conn *conn, __u8 reason)
1084{
1085 switch (conn->type) {
1086 case ACL_LINK:
1087 case LE_LINK:
1088 l2cap_disconn_cfm(conn, reason);
1089 break;
1090
1091 case SCO_LINK:
1092 case ESCO_LINK:
1093 sco_disconn_cfm(conn, reason);
1094 break;
1095
1096
1097 case AMP_LINK:
1098 break;
1099
1100 default:
1101 BT_ERR("unknown link type %d", conn->type);
1102 break;
1103 }
1104
1105 if (conn->disconn_cfm_cb)
1106 conn->disconn_cfm_cb(conn, reason);
1107}
1108
1109static inline void hci_proto_auth_cfm(struct hci_conn *conn, __u8 status)
1110{
1111 __u8 encrypt;
1112
1113 if (conn->type != ACL_LINK && conn->type != LE_LINK)
1114 return;
1115
1116 if (test_bit(HCI_CONN_ENCRYPT_PEND, &conn->flags))
1117 return;
1118
1119 encrypt = test_bit(HCI_CONN_ENCRYPT, &conn->flags) ? 0x01 : 0x00;
1120 l2cap_security_cfm(conn, status, encrypt);
1121
1122 if (conn->security_cfm_cb)
1123 conn->security_cfm_cb(conn, status);
1124}
1125
1126static inline void hci_proto_encrypt_cfm(struct hci_conn *conn, __u8 status,
1127 __u8 encrypt)
1128{
1129 if (conn->type != ACL_LINK && conn->type != LE_LINK)
1130 return;
1131
1132 l2cap_security_cfm(conn, status, encrypt);
1133
1134 if (conn->security_cfm_cb)
1135 conn->security_cfm_cb(conn, status);
1136}
1137
1138
1139struct hci_cb {
1140 struct list_head list;
1141
1142 char *name;
1143
1144 void (*security_cfm) (struct hci_conn *conn, __u8 status,
1145 __u8 encrypt);
1146 void (*key_change_cfm) (struct hci_conn *conn, __u8 status);
1147 void (*role_switch_cfm) (struct hci_conn *conn, __u8 status, __u8 role);
1148};
1149
1150static inline void hci_auth_cfm(struct hci_conn *conn, __u8 status)
1151{
1152 struct hci_cb *cb;
1153 __u8 encrypt;
1154
1155 hci_proto_auth_cfm(conn, status);
1156
1157 if (test_bit(HCI_CONN_ENCRYPT_PEND, &conn->flags))
1158 return;
1159
1160 encrypt = test_bit(HCI_CONN_ENCRYPT, &conn->flags) ? 0x01 : 0x00;
1161
1162 read_lock(&hci_cb_list_lock);
1163 list_for_each_entry(cb, &hci_cb_list, list) {
1164 if (cb->security_cfm)
1165 cb->security_cfm(conn, status, encrypt);
1166 }
1167 read_unlock(&hci_cb_list_lock);
1168}
1169
1170static inline void hci_encrypt_cfm(struct hci_conn *conn, __u8 status,
1171 __u8 encrypt)
1172{
1173 struct hci_cb *cb;
1174
1175 if (conn->sec_level == BT_SECURITY_SDP)
1176 conn->sec_level = BT_SECURITY_LOW;
1177
1178 if (conn->pending_sec_level > conn->sec_level)
1179 conn->sec_level = conn->pending_sec_level;
1180
1181 hci_proto_encrypt_cfm(conn, status, encrypt);
1182
1183 read_lock(&hci_cb_list_lock);
1184 list_for_each_entry(cb, &hci_cb_list, list) {
1185 if (cb->security_cfm)
1186 cb->security_cfm(conn, status, encrypt);
1187 }
1188 read_unlock(&hci_cb_list_lock);
1189}
1190
1191static inline void hci_key_change_cfm(struct hci_conn *conn, __u8 status)
1192{
1193 struct hci_cb *cb;
1194
1195 read_lock(&hci_cb_list_lock);
1196 list_for_each_entry(cb, &hci_cb_list, list) {
1197 if (cb->key_change_cfm)
1198 cb->key_change_cfm(conn, status);
1199 }
1200 read_unlock(&hci_cb_list_lock);
1201}
1202
1203static inline void hci_role_switch_cfm(struct hci_conn *conn, __u8 status,
1204 __u8 role)
1205{
1206 struct hci_cb *cb;
1207
1208 read_lock(&hci_cb_list_lock);
1209 list_for_each_entry(cb, &hci_cb_list, list) {
1210 if (cb->role_switch_cfm)
1211 cb->role_switch_cfm(conn, status, role);
1212 }
1213 read_unlock(&hci_cb_list_lock);
1214}
1215
1216static inline bool eir_has_data_type(u8 *data, size_t data_len, u8 type)
1217{
1218 size_t parsed = 0;
1219
1220 if (data_len < 2)
1221 return false;
1222
1223 while (parsed < data_len - 1) {
1224 u8 field_len = data[0];
1225
1226 if (field_len == 0)
1227 break;
1228
1229 parsed += field_len + 1;
1230
1231 if (parsed > data_len)
1232 break;
1233
1234 if (data[1] == type)
1235 return true;
1236
1237 data += field_len + 1;
1238 }
1239
1240 return false;
1241}
1242
1243static inline bool hci_bdaddr_is_rpa(bdaddr_t *bdaddr, u8 addr_type)
1244{
1245 if (addr_type != ADDR_LE_DEV_RANDOM)
1246 return false;
1247
1248 if ((bdaddr->b[5] & 0xc0) == 0x40)
1249 return true;
1250
1251 return false;
1252}
1253
1254static inline bool hci_is_identity_address(bdaddr_t *addr, u8 addr_type)
1255{
1256 if (addr_type == ADDR_LE_DEV_PUBLIC)
1257 return true;
1258
1259
1260 if ((addr->b[5] & 0xc0) == 0xc0)
1261 return true;
1262
1263 return false;
1264}
1265
1266static inline struct smp_irk *hci_get_irk(struct hci_dev *hdev,
1267 bdaddr_t *bdaddr, u8 addr_type)
1268{
1269 if (!hci_bdaddr_is_rpa(bdaddr, addr_type))
1270 return NULL;
1271
1272 return hci_find_irk_by_rpa(hdev, bdaddr);
1273}
1274
1275static inline int hci_check_conn_params(u16 min, u16 max, u16 latency,
1276 u16 to_multiplier)
1277{
1278 u16 max_latency;
1279
1280 if (min > max || min < 6 || max > 3200)
1281 return -EINVAL;
1282
1283 if (to_multiplier < 10 || to_multiplier > 3200)
1284 return -EINVAL;
1285
1286 if (max >= to_multiplier * 8)
1287 return -EINVAL;
1288
1289 max_latency = (to_multiplier * 8 / max) - 1;
1290 if (latency > 499 || latency > max_latency)
1291 return -EINVAL;
1292
1293 return 0;
1294}
1295
1296int hci_register_cb(struct hci_cb *hcb);
1297int hci_unregister_cb(struct hci_cb *hcb);
1298
1299bool hci_req_pending(struct hci_dev *hdev);
1300
1301struct sk_buff *__hci_cmd_sync(struct hci_dev *hdev, u16 opcode, u32 plen,
1302 const void *param, u32 timeout);
1303struct sk_buff *__hci_cmd_sync_ev(struct hci_dev *hdev, u16 opcode, u32 plen,
1304 const void *param, u8 event, u32 timeout);
1305
1306int hci_send_cmd(struct hci_dev *hdev, __u16 opcode, __u32 plen,
1307 const void *param);
1308void hci_send_acl(struct hci_chan *chan, struct sk_buff *skb, __u16 flags);
1309void hci_send_sco(struct hci_conn *conn, struct sk_buff *skb);
1310
1311void *hci_sent_cmd_data(struct hci_dev *hdev, __u16 opcode);
1312
1313
1314void hci_send_to_sock(struct hci_dev *hdev, struct sk_buff *skb);
1315void hci_send_to_control(struct sk_buff *skb, struct sock *skip_sk);
1316void hci_send_to_monitor(struct hci_dev *hdev, struct sk_buff *skb);
1317
1318void hci_sock_dev_event(struct hci_dev *hdev, int event);
1319
1320
1321#define DISCOV_TYPE_BREDR (BIT(BDADDR_BREDR))
1322#define DISCOV_TYPE_LE (BIT(BDADDR_LE_PUBLIC) | \
1323 BIT(BDADDR_LE_RANDOM))
1324#define DISCOV_TYPE_INTERLEAVED (BIT(BDADDR_BREDR) | \
1325 BIT(BDADDR_LE_PUBLIC) | \
1326 BIT(BDADDR_LE_RANDOM))
1327
1328
1329
1330
1331#define DISCOV_LE_SCAN_WIN 0x12
1332#define DISCOV_LE_SCAN_INT 0x12
1333#define DISCOV_LE_TIMEOUT 10240
1334#define DISCOV_INTERLEAVED_TIMEOUT 5120
1335#define DISCOV_INTERLEAVED_INQUIRY_LEN 0x04
1336#define DISCOV_BREDR_INQUIRY_LEN 0x08
1337#define DISCOV_LE_RESTART_DELAY msecs_to_jiffies(200)
1338
1339int mgmt_control(struct sock *sk, struct msghdr *msg, size_t len);
1340int mgmt_new_settings(struct hci_dev *hdev);
1341void mgmt_index_added(struct hci_dev *hdev);
1342void mgmt_index_removed(struct hci_dev *hdev);
1343void mgmt_set_powered_failed(struct hci_dev *hdev, int err);
1344int mgmt_powered(struct hci_dev *hdev, u8 powered);
1345int mgmt_update_adv_data(struct hci_dev *hdev);
1346void mgmt_discoverable_timeout(struct hci_dev *hdev);
1347void mgmt_new_link_key(struct hci_dev *hdev, struct link_key *key,
1348 bool persistent);
1349void mgmt_device_connected(struct hci_dev *hdev, struct hci_conn *conn,
1350 u32 flags, u8 *name, u8 name_len);
1351void mgmt_device_disconnected(struct hci_dev *hdev, bdaddr_t *bdaddr,
1352 u8 link_type, u8 addr_type, u8 reason,
1353 bool mgmt_connected);
1354void mgmt_disconnect_failed(struct hci_dev *hdev, bdaddr_t *bdaddr,
1355 u8 link_type, u8 addr_type, u8 status);
1356void mgmt_connect_failed(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type,
1357 u8 addr_type, u8 status);
1358void mgmt_pin_code_request(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 secure);
1359void mgmt_pin_code_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
1360 u8 status);
1361void mgmt_pin_code_neg_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
1362 u8 status);
1363int mgmt_user_confirm_request(struct hci_dev *hdev, bdaddr_t *bdaddr,
1364 u8 link_type, u8 addr_type, u32 value,
1365 u8 confirm_hint);
1366int mgmt_user_confirm_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
1367 u8 link_type, u8 addr_type, u8 status);
1368int mgmt_user_confirm_neg_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
1369 u8 link_type, u8 addr_type, u8 status);
1370int mgmt_user_passkey_request(struct hci_dev *hdev, bdaddr_t *bdaddr,
1371 u8 link_type, u8 addr_type);
1372int mgmt_user_passkey_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
1373 u8 link_type, u8 addr_type, u8 status);
1374int mgmt_user_passkey_neg_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
1375 u8 link_type, u8 addr_type, u8 status);
1376int mgmt_user_passkey_notify(struct hci_dev *hdev, bdaddr_t *bdaddr,
1377 u8 link_type, u8 addr_type, u32 passkey,
1378 u8 entered);
1379void mgmt_auth_failed(struct hci_conn *conn, u8 status);
1380void mgmt_auth_enable_complete(struct hci_dev *hdev, u8 status);
1381void mgmt_ssp_enable_complete(struct hci_dev *hdev, u8 enable, u8 status);
1382void mgmt_set_class_of_dev_complete(struct hci_dev *hdev, u8 *dev_class,
1383 u8 status);
1384void mgmt_set_local_name_complete(struct hci_dev *hdev, u8 *name, u8 status);
1385void mgmt_read_local_oob_data_complete(struct hci_dev *hdev, u8 *hash192,
1386 u8 *rand192, u8 *hash256, u8 *rand256,
1387 u8 status);
1388void mgmt_device_found(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type,
1389 u8 addr_type, u8 *dev_class, s8 rssi, u32 flags,
1390 u8 *eir, u16 eir_len, u8 *scan_rsp, u8 scan_rsp_len);
1391void mgmt_remote_name(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type,
1392 u8 addr_type, s8 rssi, u8 *name, u8 name_len);
1393void mgmt_discovering(struct hci_dev *hdev, u8 discovering);
1394bool mgmt_powering_down(struct hci_dev *hdev);
1395void mgmt_new_ltk(struct hci_dev *hdev, struct smp_ltk *key, bool persistent);
1396void mgmt_new_irk(struct hci_dev *hdev, struct smp_irk *irk);
1397void mgmt_new_csrk(struct hci_dev *hdev, struct smp_csrk *csrk,
1398 bool persistent);
1399void mgmt_new_conn_param(struct hci_dev *hdev, bdaddr_t *bdaddr,
1400 u8 bdaddr_type, u8 store_hint, u16 min_interval,
1401 u16 max_interval, u16 latency, u16 timeout);
1402void mgmt_reenable_advertising(struct hci_dev *hdev);
1403void mgmt_smp_complete(struct hci_conn *conn, bool complete);
1404
1405u8 hci_le_conn_update(struct hci_conn *conn, u16 min, u16 max, u16 latency,
1406 u16 to_multiplier);
1407void hci_le_start_enc(struct hci_conn *conn, __le16 ediv, __le64 rand,
1408 __u8 ltk[16]);
1409
1410void hci_copy_identity_address(struct hci_dev *hdev, bdaddr_t *bdaddr,
1411 u8 *bdaddr_type);
1412
1413#define SCO_AIRMODE_MASK 0x0003
1414#define SCO_AIRMODE_CVSD 0x0000
1415#define SCO_AIRMODE_TRANSP 0x0003
1416
1417#endif
1418
