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 <linux/idr.h>
29#include <linux/leds.h>
30#include <linux/rculist.h>
31
32#include <net/bluetooth/hci.h>
33#include <net/bluetooth/hci_sock.h>
34
35
36#define HCI_PRIO_MAX 7
37
38
39struct inquiry_data {
40 bdaddr_t bdaddr;
41 __u8 pscan_rep_mode;
42 __u8 pscan_period_mode;
43 __u8 pscan_mode;
44 __u8 dev_class[3];
45 __le16 clock_offset;
46 __s8 rssi;
47 __u8 ssp_mode;
48};
49
50struct inquiry_entry {
51 struct list_head all;
52 struct list_head list;
53 enum {
54 NAME_NOT_KNOWN,
55 NAME_NEEDED,
56 NAME_PENDING,
57 NAME_KNOWN,
58 } name_state;
59 __u32 timestamp;
60 struct inquiry_data data;
61};
62
63struct discovery_state {
64 int type;
65 enum {
66 DISCOVERY_STOPPED,
67 DISCOVERY_STARTING,
68 DISCOVERY_FINDING,
69 DISCOVERY_RESOLVING,
70 DISCOVERY_STOPPING,
71 } state;
72 struct list_head all;
73 struct list_head unknown;
74 struct list_head resolve;
75 __u32 timestamp;
76 bdaddr_t last_adv_addr;
77 u8 last_adv_addr_type;
78 s8 last_adv_rssi;
79 u32 last_adv_flags;
80 u8 last_adv_data[HCI_MAX_AD_LENGTH];
81 u8 last_adv_data_len;
82 bool report_invalid_rssi;
83 bool result_filtering;
84 bool limited;
85 s8 rssi;
86 u16 uuid_count;
87 u8 (*uuids)[16];
88 unsigned long scan_start;
89 unsigned long scan_duration;
90};
91
92#define SUSPEND_NOTIFIER_TIMEOUT msecs_to_jiffies(2000)
93
94enum suspend_tasks {
95 SUSPEND_PAUSE_DISCOVERY,
96 SUSPEND_UNPAUSE_DISCOVERY,
97
98 SUSPEND_PAUSE_ADVERTISING,
99 SUSPEND_UNPAUSE_ADVERTISING,
100
101 SUSPEND_SCAN_DISABLE,
102 SUSPEND_SCAN_ENABLE,
103 SUSPEND_DISCONNECTING,
104
105 SUSPEND_POWERING_DOWN,
106
107 SUSPEND_PREPARE_NOTIFIER,
108
109 SUSPEND_SET_ADV_FILTER,
110 __SUSPEND_NUM_TASKS
111};
112
113enum suspended_state {
114 BT_RUNNING = 0,
115 BT_SUSPEND_DISCONNECT,
116 BT_SUSPEND_CONFIGURE_WAKE,
117};
118
119struct hci_conn_hash {
120 struct list_head list;
121 unsigned int acl_num;
122 unsigned int amp_num;
123 unsigned int sco_num;
124 unsigned int le_num;
125 unsigned int le_num_slave;
126};
127
128struct bdaddr_list {
129 struct list_head list;
130 bdaddr_t bdaddr;
131 u8 bdaddr_type;
132};
133
134struct bdaddr_list_with_irk {
135 struct list_head list;
136 bdaddr_t bdaddr;
137 u8 bdaddr_type;
138 u8 peer_irk[16];
139 u8 local_irk[16];
140};
141
142struct bdaddr_list_with_flags {
143 struct list_head list;
144 bdaddr_t bdaddr;
145 u8 bdaddr_type;
146 u32 current_flags;
147};
148
149enum hci_conn_flags {
150 HCI_CONN_FLAG_REMOTE_WAKEUP,
151 HCI_CONN_FLAG_MAX
152};
153
154#define hci_conn_test_flag(nr, flags) ((flags) & (1U << nr))
155
156
157static_assert(HCI_CONN_FLAG_MAX < 32);
158
159struct bt_uuid {
160 struct list_head list;
161 u8 uuid[16];
162 u8 size;
163 u8 svc_hint;
164};
165
166struct blocked_key {
167 struct list_head list;
168 struct rcu_head rcu;
169 u8 type;
170 u8 val[16];
171};
172
173struct smp_csrk {
174 bdaddr_t bdaddr;
175 u8 bdaddr_type;
176 u8 type;
177 u8 val[16];
178};
179
180struct smp_ltk {
181 struct list_head list;
182 struct rcu_head rcu;
183 bdaddr_t bdaddr;
184 u8 bdaddr_type;
185 u8 authenticated;
186 u8 type;
187 u8 enc_size;
188 __le16 ediv;
189 __le64 rand;
190 u8 val[16];
191};
192
193struct smp_irk {
194 struct list_head list;
195 struct rcu_head rcu;
196 bdaddr_t rpa;
197 bdaddr_t bdaddr;
198 u8 addr_type;
199 u8 val[16];
200};
201
202struct link_key {
203 struct list_head list;
204 struct rcu_head rcu;
205 bdaddr_t bdaddr;
206 u8 type;
207 u8 val[HCI_LINK_KEY_SIZE];
208 u8 pin_len;
209};
210
211struct oob_data {
212 struct list_head list;
213 bdaddr_t bdaddr;
214 u8 bdaddr_type;
215 u8 present;
216 u8 hash192[16];
217 u8 rand192[16];
218 u8 hash256[16];
219 u8 rand256[16];
220};
221
222struct adv_info {
223 struct list_head list;
224 bool pending;
225 __u8 instance;
226 __u32 flags;
227 __u16 timeout;
228 __u16 remaining_time;
229 __u16 duration;
230 __u16 adv_data_len;
231 __u8 adv_data[HCI_MAX_AD_LENGTH];
232 __u16 scan_rsp_len;
233 __u8 scan_rsp_data[HCI_MAX_AD_LENGTH];
234 __s8 tx_power;
235 __u32 min_interval;
236 __u32 max_interval;
237 bdaddr_t random_addr;
238 bool rpa_expired;
239 struct delayed_work rpa_expired_cb;
240};
241
242#define HCI_MAX_ADV_INSTANCES 5
243#define HCI_DEFAULT_ADV_DURATION 2
244
245#define HCI_ADV_TX_POWER_NO_PREFERENCE 0x7F
246
247struct adv_pattern {
248 struct list_head list;
249 __u8 ad_type;
250 __u8 offset;
251 __u8 length;
252 __u8 value[HCI_MAX_AD_LENGTH];
253};
254
255struct adv_rssi_thresholds {
256 __s8 low_threshold;
257 __s8 high_threshold;
258 __u16 low_threshold_timeout;
259 __u16 high_threshold_timeout;
260 __u8 sampling_period;
261};
262
263struct adv_monitor {
264 struct list_head patterns;
265 struct adv_rssi_thresholds rssi;
266 __u16 handle;
267
268 enum {
269 ADV_MONITOR_STATE_NOT_REGISTERED,
270 ADV_MONITOR_STATE_REGISTERED,
271 ADV_MONITOR_STATE_OFFLOADED
272 } state;
273};
274
275#define HCI_MIN_ADV_MONITOR_HANDLE 1
276#define HCI_MAX_ADV_MONITOR_NUM_HANDLES 32
277#define HCI_MAX_ADV_MONITOR_NUM_PATTERNS 16
278#define HCI_ADV_MONITOR_EXT_NONE 1
279#define HCI_ADV_MONITOR_EXT_MSFT 2
280
281#define HCI_MAX_SHORT_NAME_LENGTH 10
282
283
284#define HCI_MIN_ENC_KEY_SIZE 7
285
286
287#define HCI_DEFAULT_RPA_TIMEOUT (15 * 60)
288
289
290#define DEFAULT_CONN_INFO_MIN_AGE 1000
291#define DEFAULT_CONN_INFO_MAX_AGE 3000
292
293#define DEFAULT_AUTH_PAYLOAD_TIMEOUT 0x0bb8
294
295struct amp_assoc {
296 __u16 len;
297 __u16 offset;
298 __u16 rem_len;
299 __u16 len_so_far;
300 __u8 data[HCI_MAX_AMP_ASSOC_SIZE];
301};
302
303#define HCI_MAX_PAGES 3
304
305struct hci_dev {
306 struct list_head list;
307 struct mutex lock;
308
309 char name[8];
310 unsigned long flags;
311 __u16 id;
312 __u8 bus;
313 __u8 dev_type;
314 bdaddr_t bdaddr;
315 bdaddr_t setup_addr;
316 bdaddr_t public_addr;
317 bdaddr_t random_addr;
318 bdaddr_t static_addr;
319 __u8 adv_addr_type;
320 __u8 dev_name[HCI_MAX_NAME_LENGTH];
321 __u8 short_name[HCI_MAX_SHORT_NAME_LENGTH];
322 __u8 eir[HCI_MAX_EIR_LENGTH];
323 __u16 appearance;
324 __u8 dev_class[3];
325 __u8 major_class;
326 __u8 minor_class;
327 __u8 max_page;
328 __u8 features[HCI_MAX_PAGES][8];
329 __u8 le_features[8];
330 __u8 le_white_list_size;
331 __u8 le_resolv_list_size;
332 __u8 le_num_of_adv_sets;
333 __u8 le_states[8];
334 __u8 commands[64];
335 __u8 hci_ver;
336 __u16 hci_rev;
337 __u8 lmp_ver;
338 __u16 manufacturer;
339 __u16 lmp_subver;
340 __u16 voice_setting;
341 __u8 num_iac;
342 __u8 stored_max_keys;
343 __u8 stored_num_keys;
344 __u8 io_capability;
345 __s8 inq_tx_power;
346 __u8 err_data_reporting;
347 __u16 page_scan_interval;
348 __u16 page_scan_window;
349 __u8 page_scan_type;
350 __u8 le_adv_channel_map;
351 __u16 le_adv_min_interval;
352 __u16 le_adv_max_interval;
353 __u8 le_scan_type;
354 __u16 le_scan_interval;
355 __u16 le_scan_window;
356 __u16 le_scan_int_suspend;
357 __u16 le_scan_window_suspend;
358 __u16 le_scan_int_discovery;
359 __u16 le_scan_window_discovery;
360 __u16 le_scan_int_adv_monitor;
361 __u16 le_scan_window_adv_monitor;
362 __u16 le_scan_int_connect;
363 __u16 le_scan_window_connect;
364 __u16 le_conn_min_interval;
365 __u16 le_conn_max_interval;
366 __u16 le_conn_latency;
367 __u16 le_supv_timeout;
368 __u16 le_def_tx_len;
369 __u16 le_def_tx_time;
370 __u16 le_max_tx_len;
371 __u16 le_max_tx_time;
372 __u16 le_max_rx_len;
373 __u16 le_max_rx_time;
374 __u8 le_max_key_size;
375 __u8 le_min_key_size;
376 __u16 discov_interleaved_timeout;
377 __u16 conn_info_min_age;
378 __u16 conn_info_max_age;
379 __u16 auth_payload_timeout;
380 __u8 min_enc_key_size;
381 __u8 max_enc_key_size;
382 __u8 pairing_opts;
383 __u8 ssp_debug_mode;
384 __u8 hw_error_code;
385 __u32 clock;
386 __u16 advmon_allowlist_duration;
387 __u16 advmon_no_filter_duration;
388 __u8 enable_advmon_interleave_scan;
389
390 __u16 devid_source;
391 __u16 devid_vendor;
392 __u16 devid_product;
393 __u16 devid_version;
394
395 __u8 def_page_scan_type;
396 __u16 def_page_scan_int;
397 __u16 def_page_scan_window;
398 __u8 def_inq_scan_type;
399 __u16 def_inq_scan_int;
400 __u16 def_inq_scan_window;
401 __u16 def_br_lsto;
402 __u16 def_page_timeout;
403 __u16 def_multi_adv_rotation_duration;
404 __u16 def_le_autoconnect_timeout;
405 __s8 min_le_tx_power;
406 __s8 max_le_tx_power;
407
408 __u16 pkt_type;
409 __u16 esco_type;
410 __u16 link_policy;
411 __u16 link_mode;
412
413 __u32 idle_timeout;
414 __u16 sniff_min_interval;
415 __u16 sniff_max_interval;
416
417 __u8 amp_status;
418 __u32 amp_total_bw;
419 __u32 amp_max_bw;
420 __u32 amp_min_latency;
421 __u32 amp_max_pdu;
422 __u8 amp_type;
423 __u16 amp_pal_cap;
424 __u16 amp_assoc_size;
425 __u32 amp_max_flush_to;
426 __u32 amp_be_flush_to;
427
428 struct amp_assoc loc_assoc;
429
430 __u8 flow_ctl_mode;
431
432 unsigned int auto_accept_delay;
433
434 unsigned long quirks;
435
436 atomic_t cmd_cnt;
437 unsigned int acl_cnt;
438 unsigned int sco_cnt;
439 unsigned int le_cnt;
440
441 unsigned int acl_mtu;
442 unsigned int sco_mtu;
443 unsigned int le_mtu;
444 unsigned int acl_pkts;
445 unsigned int sco_pkts;
446 unsigned int le_pkts;
447
448 __u16 block_len;
449 __u16 block_mtu;
450 __u16 num_blocks;
451 __u16 block_cnt;
452
453 unsigned long acl_last_tx;
454 unsigned long sco_last_tx;
455 unsigned long le_last_tx;
456
457 __u8 le_tx_def_phys;
458 __u8 le_rx_def_phys;
459
460 struct workqueue_struct *workqueue;
461 struct workqueue_struct *req_workqueue;
462
463 struct work_struct power_on;
464 struct delayed_work power_off;
465 struct work_struct error_reset;
466
467 __u16 discov_timeout;
468 struct delayed_work discov_off;
469
470 struct delayed_work service_cache;
471
472 struct delayed_work cmd_timer;
473
474 struct work_struct rx_work;
475 struct work_struct cmd_work;
476 struct work_struct tx_work;
477
478 struct work_struct discov_update;
479 struct work_struct bg_scan_update;
480 struct work_struct scan_update;
481 struct work_struct connectable_update;
482 struct work_struct discoverable_update;
483 struct delayed_work le_scan_disable;
484 struct delayed_work le_scan_restart;
485
486 struct sk_buff_head rx_q;
487 struct sk_buff_head raw_q;
488 struct sk_buff_head cmd_q;
489
490 struct sk_buff *sent_cmd;
491
492 struct mutex req_lock;
493 wait_queue_head_t req_wait_q;
494 __u32 req_status;
495 __u32 req_result;
496 struct sk_buff *req_skb;
497
498 void *smp_data;
499 void *smp_bredr_data;
500
501 struct discovery_state discovery;
502
503 int discovery_old_state;
504 bool discovery_paused;
505 int advertising_old_state;
506 bool advertising_paused;
507
508 struct notifier_block suspend_notifier;
509 struct work_struct suspend_prepare;
510 enum suspended_state suspend_state_next;
511 enum suspended_state suspend_state;
512 bool scanning_paused;
513 bool suspended;
514 u8 wake_reason;
515 bdaddr_t wake_addr;
516 u8 wake_addr_type;
517
518 wait_queue_head_t suspend_wait_q;
519 DECLARE_BITMAP(suspend_tasks, __SUSPEND_NUM_TASKS);
520
521 struct hci_conn_hash conn_hash;
522
523 struct list_head mgmt_pending;
524 struct list_head blacklist;
525 struct list_head whitelist;
526 struct list_head uuids;
527 struct list_head link_keys;
528 struct list_head long_term_keys;
529 struct list_head identity_resolving_keys;
530 struct list_head remote_oob_data;
531 struct list_head le_white_list;
532 struct list_head le_resolv_list;
533 struct list_head le_conn_params;
534 struct list_head pend_le_conns;
535 struct list_head pend_le_reports;
536 struct list_head blocked_keys;
537
538 struct hci_dev_stats stat;
539
540 atomic_t promisc;
541
542 const char *hw_info;
543 const char *fw_info;
544 struct dentry *debugfs;
545
546 struct device dev;
547
548 struct rfkill *rfkill;
549
550 DECLARE_BITMAP(dev_flags, __HCI_NUM_FLAGS);
551
552 __s8 adv_tx_power;
553 __u8 adv_data[HCI_MAX_AD_LENGTH];
554 __u8 adv_data_len;
555 __u8 scan_rsp_data[HCI_MAX_AD_LENGTH];
556 __u8 scan_rsp_data_len;
557
558 struct list_head adv_instances;
559 unsigned int adv_instance_cnt;
560 __u8 cur_adv_instance;
561 __u16 adv_instance_timeout;
562 struct delayed_work adv_instance_expire;
563
564 struct idr adv_monitors_idr;
565 unsigned int adv_monitors_cnt;
566
567 __u8 irk[16];
568 __u32 rpa_timeout;
569 struct delayed_work rpa_expired;
570 bdaddr_t rpa;
571
572 enum {
573 INTERLEAVE_SCAN_NONE,
574 INTERLEAVE_SCAN_NO_FILTER,
575 INTERLEAVE_SCAN_ALLOWLIST
576 } interleave_scan_state;
577
578 struct delayed_work interleave_scan;
579
580#if IS_ENABLED(CONFIG_BT_LEDS)
581 struct led_trigger *power_led;
582#endif
583
584#if IS_ENABLED(CONFIG_BT_MSFTEXT)
585 __u16 msft_opcode;
586 void *msft_data;
587 bool msft_curve_validity;
588#endif
589
590#if IS_ENABLED(CONFIG_BT_AOSPEXT)
591 bool aosp_capable;
592#endif
593
594 int (*open)(struct hci_dev *hdev);
595 int (*close)(struct hci_dev *hdev);
596 int (*flush)(struct hci_dev *hdev);
597 int (*setup)(struct hci_dev *hdev);
598 int (*shutdown)(struct hci_dev *hdev);
599 int (*send)(struct hci_dev *hdev, struct sk_buff *skb);
600 void (*notify)(struct hci_dev *hdev, unsigned int evt);
601 void (*hw_error)(struct hci_dev *hdev, u8 code);
602 int (*post_init)(struct hci_dev *hdev);
603 int (*set_diag)(struct hci_dev *hdev, bool enable);
604 int (*set_bdaddr)(struct hci_dev *hdev, const bdaddr_t *bdaddr);
605 void (*cmd_timeout)(struct hci_dev *hdev);
606 bool (*prevent_wake)(struct hci_dev *hdev);
607};
608
609#define HCI_PHY_HANDLE(handle) (handle & 0xff)
610
611enum conn_reasons {
612 CONN_REASON_PAIR_DEVICE,
613 CONN_REASON_L2CAP_CHAN,
614 CONN_REASON_SCO_CONNECT,
615};
616
617struct hci_conn {
618 struct list_head list;
619
620 atomic_t refcnt;
621
622 bdaddr_t dst;
623 __u8 dst_type;
624 bdaddr_t src;
625 __u8 src_type;
626 bdaddr_t init_addr;
627 __u8 init_addr_type;
628 bdaddr_t resp_addr;
629 __u8 resp_addr_type;
630 __u16 handle;
631 __u16 state;
632 __u8 mode;
633 __u8 type;
634 __u8 role;
635 bool out;
636 __u8 attempt;
637 __u8 dev_class[3];
638 __u8 features[HCI_MAX_PAGES][8];
639 __u16 pkt_type;
640 __u16 link_policy;
641 __u8 key_type;
642 __u8 auth_type;
643 __u8 sec_level;
644 __u8 pending_sec_level;
645 __u8 pin_length;
646 __u8 enc_key_size;
647 __u8 io_capability;
648 __u32 passkey_notify;
649 __u8 passkey_entered;
650 __u16 disc_timeout;
651 __u16 conn_timeout;
652 __u16 setting;
653 __u16 auth_payload_timeout;
654 __u16 le_conn_min_interval;
655 __u16 le_conn_max_interval;
656 __u16 le_conn_interval;
657 __u16 le_conn_latency;
658 __u16 le_supv_timeout;
659 __u8 le_adv_data[HCI_MAX_AD_LENGTH];
660 __u8 le_adv_data_len;
661 __u8 le_tx_phy;
662 __u8 le_rx_phy;
663 __s8 rssi;
664 __s8 tx_power;
665 __s8 max_tx_power;
666 unsigned long flags;
667
668 enum conn_reasons conn_reason;
669
670 __u32 clock;
671 __u16 clock_accuracy;
672
673 unsigned long conn_info_timestamp;
674
675 __u8 remote_cap;
676 __u8 remote_auth;
677 __u8 remote_id;
678
679 unsigned int sent;
680
681 struct sk_buff_head data_q;
682 struct list_head chan_list;
683
684 struct delayed_work disc_work;
685 struct delayed_work auto_accept_work;
686 struct delayed_work idle_work;
687 struct delayed_work le_conn_timeout;
688 struct work_struct le_scan_cleanup;
689
690 struct device dev;
691 struct dentry *debugfs;
692
693 struct hci_dev *hdev;
694 void *l2cap_data;
695 void *sco_data;
696 struct amp_mgr *amp_mgr;
697
698 struct hci_conn *link;
699
700 void (*connect_cfm_cb) (struct hci_conn *conn, u8 status);
701 void (*security_cfm_cb) (struct hci_conn *conn, u8 status);
702 void (*disconn_cfm_cb) (struct hci_conn *conn, u8 reason);
703};
704
705struct hci_chan {
706 struct list_head list;
707 __u16 handle;
708 struct hci_conn *conn;
709 struct sk_buff_head data_q;
710 unsigned int sent;
711 __u8 state;
712 bool amp;
713};
714
715struct hci_conn_params {
716 struct list_head list;
717 struct list_head action;
718
719 bdaddr_t addr;
720 u8 addr_type;
721
722 u16 conn_min_interval;
723 u16 conn_max_interval;
724 u16 conn_latency;
725 u16 supervision_timeout;
726
727 enum {
728 HCI_AUTO_CONN_DISABLED,
729 HCI_AUTO_CONN_REPORT,
730 HCI_AUTO_CONN_DIRECT,
731 HCI_AUTO_CONN_ALWAYS,
732 HCI_AUTO_CONN_LINK_LOSS,
733 HCI_AUTO_CONN_EXPLICIT,
734 } auto_connect;
735
736 struct hci_conn *conn;
737 bool explicit_connect;
738 u32 current_flags;
739};
740
741extern struct list_head hci_dev_list;
742extern struct list_head hci_cb_list;
743extern rwlock_t hci_dev_list_lock;
744extern struct mutex hci_cb_list_lock;
745
746#define hci_dev_set_flag(hdev, nr) set_bit((nr), (hdev)->dev_flags)
747#define hci_dev_clear_flag(hdev, nr) clear_bit((nr), (hdev)->dev_flags)
748#define hci_dev_change_flag(hdev, nr) change_bit((nr), (hdev)->dev_flags)
749#define hci_dev_test_flag(hdev, nr) test_bit((nr), (hdev)->dev_flags)
750#define hci_dev_test_and_set_flag(hdev, nr) test_and_set_bit((nr), (hdev)->dev_flags)
751#define hci_dev_test_and_clear_flag(hdev, nr) test_and_clear_bit((nr), (hdev)->dev_flags)
752#define hci_dev_test_and_change_flag(hdev, nr) test_and_change_bit((nr), (hdev)->dev_flags)
753
754#define hci_dev_clear_volatile_flags(hdev) \
755 do { \
756 hci_dev_clear_flag(hdev, HCI_LE_SCAN); \
757 hci_dev_clear_flag(hdev, HCI_LE_ADV); \
758 hci_dev_clear_flag(hdev, HCI_LL_RPA_RESOLUTION);\
759 hci_dev_clear_flag(hdev, HCI_PERIODIC_INQ); \
760 } while (0)
761
762
763int l2cap_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr);
764int l2cap_disconn_ind(struct hci_conn *hcon);
765void l2cap_recv_acldata(struct hci_conn *hcon, struct sk_buff *skb, u16 flags);
766
767#if IS_ENABLED(CONFIG_BT_BREDR)
768int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 *flags);
769void sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb);
770#else
771static inline int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr,
772 __u8 *flags)
773{
774 return 0;
775}
776
777static inline void sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb)
778{
779}
780#endif
781
782
783#define INQUIRY_CACHE_AGE_MAX (HZ*30)
784#define INQUIRY_ENTRY_AGE_MAX (HZ*60)
785
786static inline void discovery_init(struct hci_dev *hdev)
787{
788 hdev->discovery.state = DISCOVERY_STOPPED;
789 INIT_LIST_HEAD(&hdev->discovery.all);
790 INIT_LIST_HEAD(&hdev->discovery.unknown);
791 INIT_LIST_HEAD(&hdev->discovery.resolve);
792 hdev->discovery.report_invalid_rssi = true;
793 hdev->discovery.rssi = HCI_RSSI_INVALID;
794}
795
796static inline void hci_discovery_filter_clear(struct hci_dev *hdev)
797{
798 hdev->discovery.result_filtering = false;
799 hdev->discovery.report_invalid_rssi = true;
800 hdev->discovery.rssi = HCI_RSSI_INVALID;
801 hdev->discovery.uuid_count = 0;
802 kfree(hdev->discovery.uuids);
803 hdev->discovery.uuids = NULL;
804 hdev->discovery.scan_start = 0;
805 hdev->discovery.scan_duration = 0;
806}
807
808bool hci_discovery_active(struct hci_dev *hdev);
809
810void hci_discovery_set_state(struct hci_dev *hdev, int state);
811
812static inline int inquiry_cache_empty(struct hci_dev *hdev)
813{
814 return list_empty(&hdev->discovery.all);
815}
816
817static inline long inquiry_cache_age(struct hci_dev *hdev)
818{
819 struct discovery_state *c = &hdev->discovery;
820 return jiffies - c->timestamp;
821}
822
823static inline long inquiry_entry_age(struct inquiry_entry *e)
824{
825 return jiffies - e->timestamp;
826}
827
828struct inquiry_entry *hci_inquiry_cache_lookup(struct hci_dev *hdev,
829 bdaddr_t *bdaddr);
830struct inquiry_entry *hci_inquiry_cache_lookup_unknown(struct hci_dev *hdev,
831 bdaddr_t *bdaddr);
832struct inquiry_entry *hci_inquiry_cache_lookup_resolve(struct hci_dev *hdev,
833 bdaddr_t *bdaddr,
834 int state);
835void hci_inquiry_cache_update_resolve(struct hci_dev *hdev,
836 struct inquiry_entry *ie);
837u32 hci_inquiry_cache_update(struct hci_dev *hdev, struct inquiry_data *data,
838 bool name_known);
839void hci_inquiry_cache_flush(struct hci_dev *hdev);
840
841
842enum {
843 HCI_CONN_AUTH_PEND,
844 HCI_CONN_REAUTH_PEND,
845 HCI_CONN_ENCRYPT_PEND,
846 HCI_CONN_RSWITCH_PEND,
847 HCI_CONN_MODE_CHANGE_PEND,
848 HCI_CONN_SCO_SETUP_PEND,
849 HCI_CONN_MGMT_CONNECTED,
850 HCI_CONN_SSP_ENABLED,
851 HCI_CONN_SC_ENABLED,
852 HCI_CONN_AES_CCM,
853 HCI_CONN_POWER_SAVE,
854 HCI_CONN_FLUSH_KEY,
855 HCI_CONN_ENCRYPT,
856 HCI_CONN_AUTH,
857 HCI_CONN_SECURE,
858 HCI_CONN_FIPS,
859 HCI_CONN_STK_ENCRYPT,
860 HCI_CONN_AUTH_INITIATOR,
861 HCI_CONN_DROP,
862 HCI_CONN_PARAM_REMOVAL_PEND,
863 HCI_CONN_NEW_LINK_KEY,
864 HCI_CONN_SCANNING,
865 HCI_CONN_AUTH_FAILURE,
866};
867
868static inline bool hci_conn_ssp_enabled(struct hci_conn *conn)
869{
870 struct hci_dev *hdev = conn->hdev;
871 return hci_dev_test_flag(hdev, HCI_SSP_ENABLED) &&
872 test_bit(HCI_CONN_SSP_ENABLED, &conn->flags);
873}
874
875static inline bool hci_conn_sc_enabled(struct hci_conn *conn)
876{
877 struct hci_dev *hdev = conn->hdev;
878 return hci_dev_test_flag(hdev, HCI_SC_ENABLED) &&
879 test_bit(HCI_CONN_SC_ENABLED, &conn->flags);
880}
881
882static inline void hci_conn_hash_add(struct hci_dev *hdev, struct hci_conn *c)
883{
884 struct hci_conn_hash *h = &hdev->conn_hash;
885 list_add_rcu(&c->list, &h->list);
886 switch (c->type) {
887 case ACL_LINK:
888 h->acl_num++;
889 break;
890 case AMP_LINK:
891 h->amp_num++;
892 break;
893 case LE_LINK:
894 h->le_num++;
895 if (c->role == HCI_ROLE_SLAVE)
896 h->le_num_slave++;
897 break;
898 case SCO_LINK:
899 case ESCO_LINK:
900 h->sco_num++;
901 break;
902 }
903}
904
905static inline void hci_conn_hash_del(struct hci_dev *hdev, struct hci_conn *c)
906{
907 struct hci_conn_hash *h = &hdev->conn_hash;
908
909 list_del_rcu(&c->list);
910 synchronize_rcu();
911
912 switch (c->type) {
913 case ACL_LINK:
914 h->acl_num--;
915 break;
916 case AMP_LINK:
917 h->amp_num--;
918 break;
919 case LE_LINK:
920 h->le_num--;
921 if (c->role == HCI_ROLE_SLAVE)
922 h->le_num_slave--;
923 break;
924 case SCO_LINK:
925 case ESCO_LINK:
926 h->sco_num--;
927 break;
928 }
929}
930
931static inline unsigned int hci_conn_num(struct hci_dev *hdev, __u8 type)
932{
933 struct hci_conn_hash *h = &hdev->conn_hash;
934 switch (type) {
935 case ACL_LINK:
936 return h->acl_num;
937 case AMP_LINK:
938 return h->amp_num;
939 case LE_LINK:
940 return h->le_num;
941 case SCO_LINK:
942 case ESCO_LINK:
943 return h->sco_num;
944 default:
945 return 0;
946 }
947}
948
949static inline unsigned int hci_conn_count(struct hci_dev *hdev)
950{
951 struct hci_conn_hash *c = &hdev->conn_hash;
952
953 return c->acl_num + c->amp_num + c->sco_num + c->le_num;
954}
955
956static inline __u8 hci_conn_lookup_type(struct hci_dev *hdev, __u16 handle)
957{
958 struct hci_conn_hash *h = &hdev->conn_hash;
959 struct hci_conn *c;
960 __u8 type = INVALID_LINK;
961
962 rcu_read_lock();
963
964 list_for_each_entry_rcu(c, &h->list, list) {
965 if (c->handle == handle) {
966 type = c->type;
967 break;
968 }
969 }
970
971 rcu_read_unlock();
972
973 return type;
974}
975
976static inline struct hci_conn *hci_conn_hash_lookup_handle(struct hci_dev *hdev,
977 __u16 handle)
978{
979 struct hci_conn_hash *h = &hdev->conn_hash;
980 struct hci_conn *c;
981
982 rcu_read_lock();
983
984 list_for_each_entry_rcu(c, &h->list, list) {
985 if (c->handle == handle) {
986 rcu_read_unlock();
987 return c;
988 }
989 }
990 rcu_read_unlock();
991
992 return NULL;
993}
994
995static inline struct hci_conn *hci_conn_hash_lookup_ba(struct hci_dev *hdev,
996 __u8 type, bdaddr_t *ba)
997{
998 struct hci_conn_hash *h = &hdev->conn_hash;
999 struct hci_conn *c;
1000
1001 rcu_read_lock();
1002
1003 list_for_each_entry_rcu(c, &h->list, list) {
1004 if (c->type == type && !bacmp(&c->dst, ba)) {
1005 rcu_read_unlock();
1006 return c;
1007 }
1008 }
1009
1010 rcu_read_unlock();
1011
1012 return NULL;
1013}
1014
1015static inline struct hci_conn *hci_conn_hash_lookup_le(struct hci_dev *hdev,
1016 bdaddr_t *ba,
1017 __u8 ba_type)
1018{
1019 struct hci_conn_hash *h = &hdev->conn_hash;
1020 struct hci_conn *c;
1021
1022 rcu_read_lock();
1023
1024 list_for_each_entry_rcu(c, &h->list, list) {
1025 if (c->type != LE_LINK)
1026 continue;
1027
1028 if (ba_type == c->dst_type && !bacmp(&c->dst, ba)) {
1029 rcu_read_unlock();
1030 return c;
1031 }
1032 }
1033
1034 rcu_read_unlock();
1035
1036 return NULL;
1037}
1038
1039static inline struct hci_conn *hci_conn_hash_lookup_state(struct hci_dev *hdev,
1040 __u8 type, __u16 state)
1041{
1042 struct hci_conn_hash *h = &hdev->conn_hash;
1043 struct hci_conn *c;
1044
1045 rcu_read_lock();
1046
1047 list_for_each_entry_rcu(c, &h->list, list) {
1048 if (c->type == type && c->state == state) {
1049 rcu_read_unlock();
1050 return c;
1051 }
1052 }
1053
1054 rcu_read_unlock();
1055
1056 return NULL;
1057}
1058
1059static inline struct hci_conn *hci_lookup_le_connect(struct hci_dev *hdev)
1060{
1061 struct hci_conn_hash *h = &hdev->conn_hash;
1062 struct hci_conn *c;
1063
1064 rcu_read_lock();
1065
1066 list_for_each_entry_rcu(c, &h->list, list) {
1067 if (c->type == LE_LINK && c->state == BT_CONNECT &&
1068 !test_bit(HCI_CONN_SCANNING, &c->flags)) {
1069 rcu_read_unlock();
1070 return c;
1071 }
1072 }
1073
1074 rcu_read_unlock();
1075
1076 return NULL;
1077}
1078
1079int hci_disconnect(struct hci_conn *conn, __u8 reason);
1080bool hci_setup_sync(struct hci_conn *conn, __u16 handle);
1081void hci_sco_setup(struct hci_conn *conn, __u8 status);
1082
1083struct hci_conn *hci_conn_add(struct hci_dev *hdev, int type, bdaddr_t *dst,
1084 u8 role);
1085int hci_conn_del(struct hci_conn *conn);
1086void hci_conn_hash_flush(struct hci_dev *hdev);
1087void hci_conn_check_pending(struct hci_dev *hdev);
1088
1089struct hci_chan *hci_chan_create(struct hci_conn *conn);
1090void hci_chan_del(struct hci_chan *chan);
1091void hci_chan_list_flush(struct hci_conn *conn);
1092struct hci_chan *hci_chan_lookup_handle(struct hci_dev *hdev, __u16 handle);
1093
1094struct hci_conn *hci_connect_le_scan(struct hci_dev *hdev, bdaddr_t *dst,
1095 u8 dst_type, u8 sec_level,
1096 u16 conn_timeout,
1097 enum conn_reasons conn_reason);
1098struct hci_conn *hci_connect_le(struct hci_dev *hdev, bdaddr_t *dst,
1099 u8 dst_type, u8 sec_level, u16 conn_timeout,
1100 u8 role, bdaddr_t *direct_rpa);
1101struct hci_conn *hci_connect_acl(struct hci_dev *hdev, bdaddr_t *dst,
1102 u8 sec_level, u8 auth_type,
1103 enum conn_reasons conn_reason);
1104struct hci_conn *hci_connect_sco(struct hci_dev *hdev, int type, bdaddr_t *dst,
1105 __u16 setting);
1106int hci_conn_check_link_mode(struct hci_conn *conn);
1107int hci_conn_check_secure(struct hci_conn *conn, __u8 sec_level);
1108int hci_conn_security(struct hci_conn *conn, __u8 sec_level, __u8 auth_type,
1109 bool initiator);
1110int hci_conn_switch_role(struct hci_conn *conn, __u8 role);
1111
1112void hci_conn_enter_active_mode(struct hci_conn *conn, __u8 force_active);
1113
1114void hci_le_conn_failed(struct hci_conn *conn, u8 status);
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137static inline struct hci_conn *hci_conn_get(struct hci_conn *conn)
1138{
1139 get_device(&conn->dev);
1140 return conn;
1141}
1142
1143static inline void hci_conn_put(struct hci_conn *conn)
1144{
1145 put_device(&conn->dev);
1146}
1147
1148static inline void hci_conn_hold(struct hci_conn *conn)
1149{
1150 BT_DBG("hcon %p orig refcnt %d", conn, atomic_read(&conn->refcnt));
1151
1152 atomic_inc(&conn->refcnt);
1153 cancel_delayed_work(&conn->disc_work);
1154}
1155
1156static inline void hci_conn_drop(struct hci_conn *conn)
1157{
1158 BT_DBG("hcon %p orig refcnt %d", conn, atomic_read(&conn->refcnt));
1159
1160 if (atomic_dec_and_test(&conn->refcnt)) {
1161 unsigned long timeo;
1162
1163 switch (conn->type) {
1164 case ACL_LINK:
1165 case LE_LINK:
1166 cancel_delayed_work(&conn->idle_work);
1167 if (conn->state == BT_CONNECTED) {
1168 timeo = conn->disc_timeout;
1169 if (!conn->out)
1170 timeo *= 2;
1171 } else {
1172 timeo = 0;
1173 }
1174 break;
1175
1176 case AMP_LINK:
1177 timeo = conn->disc_timeout;
1178 break;
1179
1180 default:
1181 timeo = 0;
1182 break;
1183 }
1184
1185 cancel_delayed_work(&conn->disc_work);
1186 queue_delayed_work(conn->hdev->workqueue,
1187 &conn->disc_work, timeo);
1188 }
1189}
1190
1191
1192static inline void hci_dev_put(struct hci_dev *d)
1193{
1194 BT_DBG("%s orig refcnt %d", d->name,
1195 kref_read(&d->dev.kobj.kref));
1196
1197 put_device(&d->dev);
1198}
1199
1200static inline struct hci_dev *hci_dev_hold(struct hci_dev *d)
1201{
1202 BT_DBG("%s orig refcnt %d", d->name,
1203 kref_read(&d->dev.kobj.kref));
1204
1205 get_device(&d->dev);
1206 return d;
1207}
1208
1209#define hci_dev_lock(d) mutex_lock(&d->lock)
1210#define hci_dev_unlock(d) mutex_unlock(&d->lock)
1211
1212#define to_hci_dev(d) container_of(d, struct hci_dev, dev)
1213#define to_hci_conn(c) container_of(c, struct hci_conn, dev)
1214
1215static inline void *hci_get_drvdata(struct hci_dev *hdev)
1216{
1217 return dev_get_drvdata(&hdev->dev);
1218}
1219
1220static inline void hci_set_drvdata(struct hci_dev *hdev, void *data)
1221{
1222 dev_set_drvdata(&hdev->dev, data);
1223}
1224
1225struct hci_dev *hci_dev_get(int index);
1226struct hci_dev *hci_get_route(bdaddr_t *dst, bdaddr_t *src, u8 src_type);
1227
1228struct hci_dev *hci_alloc_dev(void);
1229void hci_free_dev(struct hci_dev *hdev);
1230int hci_register_dev(struct hci_dev *hdev);
1231void hci_unregister_dev(struct hci_dev *hdev);
1232int hci_suspend_dev(struct hci_dev *hdev);
1233int hci_resume_dev(struct hci_dev *hdev);
1234int hci_reset_dev(struct hci_dev *hdev);
1235int hci_recv_frame(struct hci_dev *hdev, struct sk_buff *skb);
1236int hci_recv_diag(struct hci_dev *hdev, struct sk_buff *skb);
1237__printf(2, 3) void hci_set_hw_info(struct hci_dev *hdev, const char *fmt, ...);
1238__printf(2, 3) void hci_set_fw_info(struct hci_dev *hdev, const char *fmt, ...);
1239
1240static inline void hci_set_msft_opcode(struct hci_dev *hdev, __u16 opcode)
1241{
1242#if IS_ENABLED(CONFIG_BT_MSFTEXT)
1243 hdev->msft_opcode = opcode;
1244#endif
1245}
1246
1247static inline void hci_set_aosp_capable(struct hci_dev *hdev)
1248{
1249#if IS_ENABLED(CONFIG_BT_AOSPEXT)
1250 hdev->aosp_capable = true;
1251#endif
1252}
1253
1254int hci_dev_open(__u16 dev);
1255int hci_dev_close(__u16 dev);
1256int hci_dev_do_close(struct hci_dev *hdev);
1257int hci_dev_reset(__u16 dev);
1258int hci_dev_reset_stat(__u16 dev);
1259int hci_dev_cmd(unsigned int cmd, void __user *arg);
1260int hci_get_dev_list(void __user *arg);
1261int hci_get_dev_info(void __user *arg);
1262int hci_get_conn_list(void __user *arg);
1263int hci_get_conn_info(struct hci_dev *hdev, void __user *arg);
1264int hci_get_auth_info(struct hci_dev *hdev, void __user *arg);
1265int hci_inquiry(void __user *arg);
1266
1267struct bdaddr_list *hci_bdaddr_list_lookup(struct list_head *list,
1268 bdaddr_t *bdaddr, u8 type);
1269struct bdaddr_list_with_irk *hci_bdaddr_list_lookup_with_irk(
1270 struct list_head *list, bdaddr_t *bdaddr,
1271 u8 type);
1272struct bdaddr_list_with_flags *
1273hci_bdaddr_list_lookup_with_flags(struct list_head *list, bdaddr_t *bdaddr,
1274 u8 type);
1275int hci_bdaddr_list_add(struct list_head *list, bdaddr_t *bdaddr, u8 type);
1276int hci_bdaddr_list_add_with_irk(struct list_head *list, bdaddr_t *bdaddr,
1277 u8 type, u8 *peer_irk, u8 *local_irk);
1278int hci_bdaddr_list_add_with_flags(struct list_head *list, bdaddr_t *bdaddr,
1279 u8 type, u32 flags);
1280int hci_bdaddr_list_del(struct list_head *list, bdaddr_t *bdaddr, u8 type);
1281int hci_bdaddr_list_del_with_irk(struct list_head *list, bdaddr_t *bdaddr,
1282 u8 type);
1283int hci_bdaddr_list_del_with_flags(struct list_head *list, bdaddr_t *bdaddr,
1284 u8 type);
1285void hci_bdaddr_list_clear(struct list_head *list);
1286
1287struct hci_conn_params *hci_conn_params_lookup(struct hci_dev *hdev,
1288 bdaddr_t *addr, u8 addr_type);
1289struct hci_conn_params *hci_conn_params_add(struct hci_dev *hdev,
1290 bdaddr_t *addr, u8 addr_type);
1291void hci_conn_params_del(struct hci_dev *hdev, bdaddr_t *addr, u8 addr_type);
1292void hci_conn_params_clear_disabled(struct hci_dev *hdev);
1293
1294struct hci_conn_params *hci_pend_le_action_lookup(struct list_head *list,
1295 bdaddr_t *addr,
1296 u8 addr_type);
1297
1298void hci_uuids_clear(struct hci_dev *hdev);
1299
1300void hci_link_keys_clear(struct hci_dev *hdev);
1301struct link_key *hci_find_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr);
1302struct link_key *hci_add_link_key(struct hci_dev *hdev, struct hci_conn *conn,
1303 bdaddr_t *bdaddr, u8 *val, u8 type,
1304 u8 pin_len, bool *persistent);
1305struct smp_ltk *hci_add_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr,
1306 u8 addr_type, u8 type, u8 authenticated,
1307 u8 tk[16], u8 enc_size, __le16 ediv, __le64 rand);
1308struct smp_ltk *hci_find_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr,
1309 u8 addr_type, u8 role);
1310int hci_remove_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 bdaddr_type);
1311void hci_smp_ltks_clear(struct hci_dev *hdev);
1312int hci_remove_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr);
1313
1314struct smp_irk *hci_find_irk_by_rpa(struct hci_dev *hdev, bdaddr_t *rpa);
1315struct smp_irk *hci_find_irk_by_addr(struct hci_dev *hdev, bdaddr_t *bdaddr,
1316 u8 addr_type);
1317struct smp_irk *hci_add_irk(struct hci_dev *hdev, bdaddr_t *bdaddr,
1318 u8 addr_type, u8 val[16], bdaddr_t *rpa);
1319void hci_remove_irk(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 addr_type);
1320bool hci_is_blocked_key(struct hci_dev *hdev, u8 type, u8 val[16]);
1321void hci_blocked_keys_clear(struct hci_dev *hdev);
1322void hci_smp_irks_clear(struct hci_dev *hdev);
1323
1324bool hci_bdaddr_is_paired(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 type);
1325
1326void hci_remote_oob_data_clear(struct hci_dev *hdev);
1327struct oob_data *hci_find_remote_oob_data(struct hci_dev *hdev,
1328 bdaddr_t *bdaddr, u8 bdaddr_type);
1329int hci_add_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr,
1330 u8 bdaddr_type, u8 *hash192, u8 *rand192,
1331 u8 *hash256, u8 *rand256);
1332int hci_remove_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr,
1333 u8 bdaddr_type);
1334
1335void hci_adv_instances_clear(struct hci_dev *hdev);
1336struct adv_info *hci_find_adv_instance(struct hci_dev *hdev, u8 instance);
1337struct adv_info *hci_get_next_instance(struct hci_dev *hdev, u8 instance);
1338int hci_add_adv_instance(struct hci_dev *hdev, u8 instance, u32 flags,
1339 u16 adv_data_len, u8 *adv_data,
1340 u16 scan_rsp_len, u8 *scan_rsp_data,
1341 u16 timeout, u16 duration, s8 tx_power,
1342 u32 min_interval, u32 max_interval);
1343int hci_set_adv_instance_data(struct hci_dev *hdev, u8 instance,
1344 u16 adv_data_len, u8 *adv_data,
1345 u16 scan_rsp_len, u8 *scan_rsp_data);
1346int hci_remove_adv_instance(struct hci_dev *hdev, u8 instance);
1347void hci_adv_instances_set_rpa_expired(struct hci_dev *hdev, bool rpa_expired);
1348
1349void hci_adv_monitors_clear(struct hci_dev *hdev);
1350void hci_free_adv_monitor(struct hci_dev *hdev, struct adv_monitor *monitor);
1351int hci_add_adv_patterns_monitor_complete(struct hci_dev *hdev, u8 status);
1352int hci_remove_adv_monitor_complete(struct hci_dev *hdev, u8 status);
1353bool hci_add_adv_monitor(struct hci_dev *hdev, struct adv_monitor *monitor,
1354 int *err);
1355bool hci_remove_single_adv_monitor(struct hci_dev *hdev, u16 handle, int *err);
1356bool hci_remove_all_adv_monitor(struct hci_dev *hdev, int *err);
1357bool hci_is_adv_monitoring(struct hci_dev *hdev);
1358int hci_get_adv_monitor_offload_ext(struct hci_dev *hdev);
1359
1360void hci_event_packet(struct hci_dev *hdev, struct sk_buff *skb);
1361
1362void hci_init_sysfs(struct hci_dev *hdev);
1363void hci_conn_init_sysfs(struct hci_conn *conn);
1364void hci_conn_add_sysfs(struct hci_conn *conn);
1365void hci_conn_del_sysfs(struct hci_conn *conn);
1366
1367#define SET_HCIDEV_DEV(hdev, pdev) ((hdev)->dev.parent = (pdev))
1368
1369
1370#define lmp_encrypt_capable(dev) ((dev)->features[0][0] & LMP_ENCRYPT)
1371#define lmp_rswitch_capable(dev) ((dev)->features[0][0] & LMP_RSWITCH)
1372#define lmp_hold_capable(dev) ((dev)->features[0][0] & LMP_HOLD)
1373#define lmp_sniff_capable(dev) ((dev)->features[0][0] & LMP_SNIFF)
1374#define lmp_park_capable(dev) ((dev)->features[0][1] & LMP_PARK)
1375#define lmp_inq_rssi_capable(dev) ((dev)->features[0][3] & LMP_RSSI_INQ)
1376#define lmp_esco_capable(dev) ((dev)->features[0][3] & LMP_ESCO)
1377#define lmp_bredr_capable(dev) (!((dev)->features[0][4] & LMP_NO_BREDR))
1378#define lmp_le_capable(dev) ((dev)->features[0][4] & LMP_LE)
1379#define lmp_sniffsubr_capable(dev) ((dev)->features[0][5] & LMP_SNIFF_SUBR)
1380#define lmp_pause_enc_capable(dev) ((dev)->features[0][5] & LMP_PAUSE_ENC)
1381#define lmp_esco_2m_capable(dev) ((dev)->features[0][5] & LMP_EDR_ESCO_2M)
1382#define lmp_ext_inq_capable(dev) ((dev)->features[0][6] & LMP_EXT_INQ)
1383#define lmp_le_br_capable(dev) (!!((dev)->features[0][6] & LMP_SIMUL_LE_BR))
1384#define lmp_ssp_capable(dev) ((dev)->features[0][6] & LMP_SIMPLE_PAIR)
1385#define lmp_no_flush_capable(dev) ((dev)->features[0][6] & LMP_NO_FLUSH)
1386#define lmp_lsto_capable(dev) ((dev)->features[0][7] & LMP_LSTO)
1387#define lmp_inq_tx_pwr_capable(dev) ((dev)->features[0][7] & LMP_INQ_TX_PWR)
1388#define lmp_ext_feat_capable(dev) ((dev)->features[0][7] & LMP_EXTFEATURES)
1389#define lmp_transp_capable(dev) ((dev)->features[0][2] & LMP_TRANSPARENT)
1390#define lmp_edr_2m_capable(dev) ((dev)->features[0][3] & LMP_EDR_2M)
1391#define lmp_edr_3m_capable(dev) ((dev)->features[0][3] & LMP_EDR_3M)
1392#define lmp_edr_3slot_capable(dev) ((dev)->features[0][4] & LMP_EDR_3SLOT)
1393#define lmp_edr_5slot_capable(dev) ((dev)->features[0][5] & LMP_EDR_5SLOT)
1394
1395
1396#define lmp_csb_master_capable(dev) ((dev)->features[2][0] & LMP_CSB_MASTER)
1397#define lmp_csb_slave_capable(dev) ((dev)->features[2][0] & LMP_CSB_SLAVE)
1398#define lmp_sync_train_capable(dev) ((dev)->features[2][0] & LMP_SYNC_TRAIN)
1399#define lmp_sync_scan_capable(dev) ((dev)->features[2][0] & LMP_SYNC_SCAN)
1400#define lmp_sc_capable(dev) ((dev)->features[2][1] & LMP_SC)
1401#define lmp_ping_capable(dev) ((dev)->features[2][1] & LMP_PING)
1402
1403
1404#define lmp_host_ssp_capable(dev) ((dev)->features[1][0] & LMP_HOST_SSP)
1405#define lmp_host_sc_capable(dev) ((dev)->features[1][0] & LMP_HOST_SC)
1406#define lmp_host_le_capable(dev) (!!((dev)->features[1][0] & LMP_HOST_LE))
1407#define lmp_host_le_br_capable(dev) (!!((dev)->features[1][0] & LMP_HOST_LE_BREDR))
1408
1409#define hdev_is_powered(dev) (test_bit(HCI_UP, &(dev)->flags) && \
1410 !hci_dev_test_flag(dev, HCI_AUTO_OFF))
1411#define bredr_sc_enabled(dev) (lmp_sc_capable(dev) && \
1412 hci_dev_test_flag(dev, HCI_SC_ENABLED))
1413
1414#define scan_1m(dev) (((dev)->le_tx_def_phys & HCI_LE_SET_PHY_1M) || \
1415 ((dev)->le_rx_def_phys & HCI_LE_SET_PHY_1M))
1416
1417#define scan_2m(dev) (((dev)->le_tx_def_phys & HCI_LE_SET_PHY_2M) || \
1418 ((dev)->le_rx_def_phys & HCI_LE_SET_PHY_2M))
1419
1420#define scan_coded(dev) (((dev)->le_tx_def_phys & HCI_LE_SET_PHY_CODED) || \
1421 ((dev)->le_rx_def_phys & HCI_LE_SET_PHY_CODED))
1422
1423
1424#define use_ll_privacy(dev) ((dev)->le_features[0] & HCI_LE_LL_PRIVACY)
1425
1426
1427#define use_ext_scan(dev) (((dev)->commands[37] & 0x20) && \
1428 ((dev)->commands[37] & 0x40))
1429
1430#define use_ext_conn(dev) ((dev)->commands[37] & 0x80)
1431
1432
1433#define ext_adv_capable(dev) (((dev)->le_features[1] & HCI_LE_EXT_ADV))
1434
1435
1436#define HCI_PROTO_DEFER 0x01
1437
1438static inline int hci_proto_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr,
1439 __u8 type, __u8 *flags)
1440{
1441 switch (type) {
1442 case ACL_LINK:
1443 return l2cap_connect_ind(hdev, bdaddr);
1444
1445 case SCO_LINK:
1446 case ESCO_LINK:
1447 return sco_connect_ind(hdev, bdaddr, flags);
1448
1449 default:
1450 BT_ERR("unknown link type %d", type);
1451 return -EINVAL;
1452 }
1453}
1454
1455static inline int hci_proto_disconn_ind(struct hci_conn *conn)
1456{
1457 if (conn->type != ACL_LINK && conn->type != LE_LINK)
1458 return HCI_ERROR_REMOTE_USER_TERM;
1459
1460 return l2cap_disconn_ind(conn);
1461}
1462
1463
1464struct hci_cb {
1465 struct list_head list;
1466
1467 char *name;
1468
1469 void (*connect_cfm) (struct hci_conn *conn, __u8 status);
1470 void (*disconn_cfm) (struct hci_conn *conn, __u8 status);
1471 void (*security_cfm) (struct hci_conn *conn, __u8 status,
1472 __u8 encrypt);
1473 void (*key_change_cfm) (struct hci_conn *conn, __u8 status);
1474 void (*role_switch_cfm) (struct hci_conn *conn, __u8 status, __u8 role);
1475};
1476
1477static inline void hci_connect_cfm(struct hci_conn *conn, __u8 status)
1478{
1479 struct hci_cb *cb;
1480
1481 mutex_lock(&hci_cb_list_lock);
1482 list_for_each_entry(cb, &hci_cb_list, list) {
1483 if (cb->connect_cfm)
1484 cb->connect_cfm(conn, status);
1485 }
1486 mutex_unlock(&hci_cb_list_lock);
1487
1488 if (conn->connect_cfm_cb)
1489 conn->connect_cfm_cb(conn, status);
1490}
1491
1492static inline void hci_disconn_cfm(struct hci_conn *conn, __u8 reason)
1493{
1494 struct hci_cb *cb;
1495
1496 mutex_lock(&hci_cb_list_lock);
1497 list_for_each_entry(cb, &hci_cb_list, list) {
1498 if (cb->disconn_cfm)
1499 cb->disconn_cfm(conn, reason);
1500 }
1501 mutex_unlock(&hci_cb_list_lock);
1502
1503 if (conn->disconn_cfm_cb)
1504 conn->disconn_cfm_cb(conn, reason);
1505}
1506
1507static inline void hci_auth_cfm(struct hci_conn *conn, __u8 status)
1508{
1509 struct hci_cb *cb;
1510 __u8 encrypt;
1511
1512 if (test_bit(HCI_CONN_ENCRYPT_PEND, &conn->flags))
1513 return;
1514
1515 encrypt = test_bit(HCI_CONN_ENCRYPT, &conn->flags) ? 0x01 : 0x00;
1516
1517 mutex_lock(&hci_cb_list_lock);
1518 list_for_each_entry(cb, &hci_cb_list, list) {
1519 if (cb->security_cfm)
1520 cb->security_cfm(conn, status, encrypt);
1521 }
1522 mutex_unlock(&hci_cb_list_lock);
1523
1524 if (conn->security_cfm_cb)
1525 conn->security_cfm_cb(conn, status);
1526}
1527
1528static inline void hci_encrypt_cfm(struct hci_conn *conn, __u8 status)
1529{
1530 struct hci_cb *cb;
1531 __u8 encrypt;
1532
1533 if (conn->state == BT_CONFIG) {
1534 if (!status)
1535 conn->state = BT_CONNECTED;
1536
1537 hci_connect_cfm(conn, status);
1538 hci_conn_drop(conn);
1539 return;
1540 }
1541
1542 if (!test_bit(HCI_CONN_ENCRYPT, &conn->flags))
1543 encrypt = 0x00;
1544 else if (test_bit(HCI_CONN_AES_CCM, &conn->flags))
1545 encrypt = 0x02;
1546 else
1547 encrypt = 0x01;
1548
1549 if (!status) {
1550 if (conn->sec_level == BT_SECURITY_SDP)
1551 conn->sec_level = BT_SECURITY_LOW;
1552
1553 if (conn->pending_sec_level > conn->sec_level)
1554 conn->sec_level = conn->pending_sec_level;
1555 }
1556
1557 mutex_lock(&hci_cb_list_lock);
1558 list_for_each_entry(cb, &hci_cb_list, list) {
1559 if (cb->security_cfm)
1560 cb->security_cfm(conn, status, encrypt);
1561 }
1562 mutex_unlock(&hci_cb_list_lock);
1563
1564 if (conn->security_cfm_cb)
1565 conn->security_cfm_cb(conn, status);
1566}
1567
1568static inline void hci_key_change_cfm(struct hci_conn *conn, __u8 status)
1569{
1570 struct hci_cb *cb;
1571
1572 mutex_lock(&hci_cb_list_lock);
1573 list_for_each_entry(cb, &hci_cb_list, list) {
1574 if (cb->key_change_cfm)
1575 cb->key_change_cfm(conn, status);
1576 }
1577 mutex_unlock(&hci_cb_list_lock);
1578}
1579
1580static inline void hci_role_switch_cfm(struct hci_conn *conn, __u8 status,
1581 __u8 role)
1582{
1583 struct hci_cb *cb;
1584
1585 mutex_lock(&hci_cb_list_lock);
1586 list_for_each_entry(cb, &hci_cb_list, list) {
1587 if (cb->role_switch_cfm)
1588 cb->role_switch_cfm(conn, status, role);
1589 }
1590 mutex_unlock(&hci_cb_list_lock);
1591}
1592
1593static inline void *eir_get_data(u8 *eir, size_t eir_len, u8 type,
1594 size_t *data_len)
1595{
1596 size_t parsed = 0;
1597
1598 if (eir_len < 2)
1599 return NULL;
1600
1601 while (parsed < eir_len - 1) {
1602 u8 field_len = eir[0];
1603
1604 if (field_len == 0)
1605 break;
1606
1607 parsed += field_len + 1;
1608
1609 if (parsed > eir_len)
1610 break;
1611
1612 if (eir[1] != type) {
1613 eir += field_len + 1;
1614 continue;
1615 }
1616
1617
1618 if (field_len == 1)
1619 return NULL;
1620
1621 if (data_len)
1622 *data_len = field_len - 1;
1623
1624 return &eir[2];
1625 }
1626
1627 return NULL;
1628}
1629
1630static inline bool hci_bdaddr_is_rpa(bdaddr_t *bdaddr, u8 addr_type)
1631{
1632 if (addr_type != ADDR_LE_DEV_RANDOM)
1633 return false;
1634
1635 if ((bdaddr->b[5] & 0xc0) == 0x40)
1636 return true;
1637
1638 return false;
1639}
1640
1641static inline bool hci_is_identity_address(bdaddr_t *addr, u8 addr_type)
1642{
1643 if (addr_type == ADDR_LE_DEV_PUBLIC)
1644 return true;
1645
1646
1647 if ((addr->b[5] & 0xc0) == 0xc0)
1648 return true;
1649
1650 return false;
1651}
1652
1653static inline struct smp_irk *hci_get_irk(struct hci_dev *hdev,
1654 bdaddr_t *bdaddr, u8 addr_type)
1655{
1656 if (!hci_bdaddr_is_rpa(bdaddr, addr_type))
1657 return NULL;
1658
1659 return hci_find_irk_by_rpa(hdev, bdaddr);
1660}
1661
1662static inline int hci_check_conn_params(u16 min, u16 max, u16 latency,
1663 u16 to_multiplier)
1664{
1665 u16 max_latency;
1666
1667 if (min > max || min < 6 || max > 3200)
1668 return -EINVAL;
1669
1670 if (to_multiplier < 10 || to_multiplier > 3200)
1671 return -EINVAL;
1672
1673 if (max >= to_multiplier * 8)
1674 return -EINVAL;
1675
1676 max_latency = (to_multiplier * 4 / max) - 1;
1677 if (latency > 499 || latency > max_latency)
1678 return -EINVAL;
1679
1680 return 0;
1681}
1682
1683int hci_register_cb(struct hci_cb *hcb);
1684int hci_unregister_cb(struct hci_cb *hcb);
1685
1686struct sk_buff *__hci_cmd_sync(struct hci_dev *hdev, u16 opcode, u32 plen,
1687 const void *param, u32 timeout);
1688struct sk_buff *__hci_cmd_sync_ev(struct hci_dev *hdev, u16 opcode, u32 plen,
1689 const void *param, u8 event, u32 timeout);
1690int __hci_cmd_send(struct hci_dev *hdev, u16 opcode, u32 plen,
1691 const void *param);
1692
1693int hci_send_cmd(struct hci_dev *hdev, __u16 opcode, __u32 plen,
1694 const void *param);
1695void hci_send_acl(struct hci_chan *chan, struct sk_buff *skb, __u16 flags);
1696void hci_send_sco(struct hci_conn *conn, struct sk_buff *skb);
1697
1698void *hci_sent_cmd_data(struct hci_dev *hdev, __u16 opcode);
1699
1700struct sk_buff *hci_cmd_sync(struct hci_dev *hdev, u16 opcode, u32 plen,
1701 const void *param, u32 timeout);
1702
1703u32 hci_conn_get_phy(struct hci_conn *conn);
1704
1705
1706void hci_send_to_sock(struct hci_dev *hdev, struct sk_buff *skb);
1707void hci_send_to_channel(unsigned short channel, struct sk_buff *skb,
1708 int flag, struct sock *skip_sk);
1709void hci_send_to_monitor(struct hci_dev *hdev, struct sk_buff *skb);
1710void hci_send_monitor_ctrl_event(struct hci_dev *hdev, u16 event,
1711 void *data, u16 data_len, ktime_t tstamp,
1712 int flag, struct sock *skip_sk);
1713
1714void hci_sock_dev_event(struct hci_dev *hdev, int event);
1715
1716#define HCI_MGMT_VAR_LEN BIT(0)
1717#define HCI_MGMT_NO_HDEV BIT(1)
1718#define HCI_MGMT_UNTRUSTED BIT(2)
1719#define HCI_MGMT_UNCONFIGURED BIT(3)
1720#define HCI_MGMT_HDEV_OPTIONAL BIT(4)
1721
1722struct hci_mgmt_handler {
1723 int (*func) (struct sock *sk, struct hci_dev *hdev, void *data,
1724 u16 data_len);
1725 size_t data_len;
1726 unsigned long flags;
1727};
1728
1729struct hci_mgmt_chan {
1730 struct list_head list;
1731 unsigned short channel;
1732 size_t handler_count;
1733 const struct hci_mgmt_handler *handlers;
1734 void (*hdev_init) (struct sock *sk, struct hci_dev *hdev);
1735};
1736
1737int hci_mgmt_chan_register(struct hci_mgmt_chan *c);
1738void hci_mgmt_chan_unregister(struct hci_mgmt_chan *c);
1739
1740
1741#define DISCOV_TYPE_BREDR (BIT(BDADDR_BREDR))
1742#define DISCOV_TYPE_LE (BIT(BDADDR_LE_PUBLIC) | \
1743 BIT(BDADDR_LE_RANDOM))
1744#define DISCOV_TYPE_INTERLEAVED (BIT(BDADDR_BREDR) | \
1745 BIT(BDADDR_LE_PUBLIC) | \
1746 BIT(BDADDR_LE_RANDOM))
1747
1748
1749
1750
1751#define DISCOV_LE_SCAN_WIN 0x12
1752#define DISCOV_LE_SCAN_INT 0x12
1753#define DISCOV_LE_TIMEOUT 10240
1754#define DISCOV_INTERLEAVED_TIMEOUT 5120
1755#define DISCOV_INTERLEAVED_INQUIRY_LEN 0x04
1756#define DISCOV_BREDR_INQUIRY_LEN 0x08
1757#define DISCOV_LE_RESTART_DELAY msecs_to_jiffies(200)
1758#define DISCOV_LE_FAST_ADV_INT_MIN 0x00A0
1759#define DISCOV_LE_FAST_ADV_INT_MAX 0x00F0
1760
1761void mgmt_fill_version_info(void *ver);
1762int mgmt_new_settings(struct hci_dev *hdev);
1763void mgmt_index_added(struct hci_dev *hdev);
1764void mgmt_index_removed(struct hci_dev *hdev);
1765void mgmt_set_powered_failed(struct hci_dev *hdev, int err);
1766void mgmt_power_on(struct hci_dev *hdev, int err);
1767void __mgmt_power_off(struct hci_dev *hdev);
1768void mgmt_new_link_key(struct hci_dev *hdev, struct link_key *key,
1769 bool persistent);
1770void mgmt_device_connected(struct hci_dev *hdev, struct hci_conn *conn,
1771 u32 flags, u8 *name, u8 name_len);
1772void mgmt_device_disconnected(struct hci_dev *hdev, bdaddr_t *bdaddr,
1773 u8 link_type, u8 addr_type, u8 reason,
1774 bool mgmt_connected);
1775void mgmt_disconnect_failed(struct hci_dev *hdev, bdaddr_t *bdaddr,
1776 u8 link_type, u8 addr_type, u8 status);
1777void mgmt_connect_failed(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type,
1778 u8 addr_type, u8 status);
1779void mgmt_pin_code_request(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 secure);
1780void mgmt_pin_code_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
1781 u8 status);
1782void mgmt_pin_code_neg_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
1783 u8 status);
1784int mgmt_user_confirm_request(struct hci_dev *hdev, bdaddr_t *bdaddr,
1785 u8 link_type, u8 addr_type, u32 value,
1786 u8 confirm_hint);
1787int mgmt_user_confirm_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
1788 u8 link_type, u8 addr_type, u8 status);
1789int mgmt_user_confirm_neg_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
1790 u8 link_type, u8 addr_type, u8 status);
1791int mgmt_user_passkey_request(struct hci_dev *hdev, bdaddr_t *bdaddr,
1792 u8 link_type, u8 addr_type);
1793int mgmt_user_passkey_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
1794 u8 link_type, u8 addr_type, u8 status);
1795int mgmt_user_passkey_neg_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
1796 u8 link_type, u8 addr_type, u8 status);
1797int mgmt_user_passkey_notify(struct hci_dev *hdev, bdaddr_t *bdaddr,
1798 u8 link_type, u8 addr_type, u32 passkey,
1799 u8 entered);
1800void mgmt_auth_failed(struct hci_conn *conn, u8 status);
1801void mgmt_auth_enable_complete(struct hci_dev *hdev, u8 status);
1802void mgmt_ssp_enable_complete(struct hci_dev *hdev, u8 enable, u8 status);
1803void mgmt_set_class_of_dev_complete(struct hci_dev *hdev, u8 *dev_class,
1804 u8 status);
1805void mgmt_set_local_name_complete(struct hci_dev *hdev, u8 *name, u8 status);
1806void mgmt_start_discovery_complete(struct hci_dev *hdev, u8 status);
1807void mgmt_stop_discovery_complete(struct hci_dev *hdev, u8 status);
1808void mgmt_device_found(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type,
1809 u8 addr_type, u8 *dev_class, s8 rssi, u32 flags,
1810 u8 *eir, u16 eir_len, u8 *scan_rsp, u8 scan_rsp_len);
1811void mgmt_remote_name(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type,
1812 u8 addr_type, s8 rssi, u8 *name, u8 name_len);
1813void mgmt_discovering(struct hci_dev *hdev, u8 discovering);
1814void mgmt_suspending(struct hci_dev *hdev, u8 state);
1815void mgmt_resuming(struct hci_dev *hdev, u8 reason, bdaddr_t *bdaddr,
1816 u8 addr_type);
1817bool mgmt_powering_down(struct hci_dev *hdev);
1818void mgmt_new_ltk(struct hci_dev *hdev, struct smp_ltk *key, bool persistent);
1819void mgmt_new_irk(struct hci_dev *hdev, struct smp_irk *irk, bool persistent);
1820void mgmt_new_csrk(struct hci_dev *hdev, struct smp_csrk *csrk,
1821 bool persistent);
1822void mgmt_new_conn_param(struct hci_dev *hdev, bdaddr_t *bdaddr,
1823 u8 bdaddr_type, u8 store_hint, u16 min_interval,
1824 u16 max_interval, u16 latency, u16 timeout);
1825void mgmt_smp_complete(struct hci_conn *conn, bool complete);
1826bool mgmt_get_connectable(struct hci_dev *hdev);
1827void mgmt_set_connectable_complete(struct hci_dev *hdev, u8 status);
1828void mgmt_set_discoverable_complete(struct hci_dev *hdev, u8 status);
1829u8 mgmt_get_adv_discov_flags(struct hci_dev *hdev);
1830void mgmt_advertising_added(struct sock *sk, struct hci_dev *hdev,
1831 u8 instance);
1832void mgmt_advertising_removed(struct sock *sk, struct hci_dev *hdev,
1833 u8 instance);
1834void mgmt_adv_monitor_removed(struct hci_dev *hdev, u16 handle);
1835int mgmt_phy_configuration_changed(struct hci_dev *hdev, struct sock *skip);
1836int mgmt_add_adv_patterns_monitor_complete(struct hci_dev *hdev, u8 status);
1837int mgmt_remove_adv_monitor_complete(struct hci_dev *hdev, u8 status);
1838
1839u8 hci_le_conn_update(struct hci_conn *conn, u16 min, u16 max, u16 latency,
1840 u16 to_multiplier);
1841void hci_le_start_enc(struct hci_conn *conn, __le16 ediv, __le64 rand,
1842 __u8 ltk[16], __u8 key_size);
1843
1844void hci_copy_identity_address(struct hci_dev *hdev, bdaddr_t *bdaddr,
1845 u8 *bdaddr_type);
1846
1847#define SCO_AIRMODE_MASK 0x0003
1848#define SCO_AIRMODE_CVSD 0x0000
1849#define SCO_AIRMODE_TRANSP 0x0003
1850
1851#endif
1852
