1 /*
2 BlueZ - Bluetooth protocol stack for Linux
3 Copyright (c) 2000-2001, 2010, Code Aurora Forum. All rights reserved.
4 Copyright 2023-2024 NXP
5
6 Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License version 2 as
10 published by the Free Software Foundation;
11
12 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
13 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
14 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
15 IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
16 CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
17 WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
18 ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
19 OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
20
21 ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
22 COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
23 SOFTWARE IS DISCLAIMED.
24 */
25
26 #ifndef __HCI_CORE_H
27 #define __HCI_CORE_H
28
29 #include <linux/idr.h>
30 #include <linux/leds.h>
31 #include <linux/rculist.h>
32 #include <linux/spinlock.h>
33 #include <linux/srcu.h>
34
35 #include <net/bluetooth/hci.h>
36 #include <net/bluetooth/hci_drv.h>
37 #include <net/bluetooth/hci_sync.h>
38 #include <net/bluetooth/hci_sock.h>
39 #include <net/bluetooth/coredump.h>
40
41 /* HCI priority */
42 #define HCI_PRIO_MAX 7
43
44 /* HCI maximum id value */
45 #define HCI_MAX_ID 10000
46
47 /* HCI Core structures */
48 struct inquiry_data {
49 bdaddr_t bdaddr;
50 __u8 pscan_rep_mode;
51 __u8 pscan_period_mode;
52 __u8 pscan_mode;
53 __u8 dev_class[3];
54 __le16 clock_offset;
55 __s8 rssi;
56 __u8 ssp_mode;
57 };
58
59 struct inquiry_entry {
60 struct list_head all; /* inq_cache.all */
61 struct list_head list; /* unknown or resolve */
62 enum {
63 NAME_NOT_KNOWN,
64 NAME_NEEDED,
65 NAME_PENDING,
66 NAME_KNOWN,
67 } name_state;
68 __u32 timestamp;
69 struct inquiry_data data;
70 };
71
72 struct discovery_state {
73 int type;
74 enum {
75 DISCOVERY_STOPPED,
76 DISCOVERY_STARTING,
77 DISCOVERY_FINDING,
78 DISCOVERY_RESOLVING,
79 DISCOVERY_STOPPING,
80 } state;
81 struct list_head all; /* All devices found during inquiry */
82 struct list_head unknown; /* Name state not known */
83 struct list_head resolve; /* Name needs to be resolved */
84 __u32 timestamp;
85 bdaddr_t last_adv_addr;
86 u8 last_adv_addr_type;
87 s8 last_adv_rssi;
88 u32 last_adv_flags;
89 u8 last_adv_data[HCI_MAX_EXT_AD_LENGTH];
90 u8 last_adv_data_len;
91 bool report_invalid_rssi;
92 bool result_filtering;
93 bool limited;
94 s8 rssi;
95 u16 uuid_count;
96 u8 (*uuids)[16];
97 unsigned long name_resolve_timeout;
98 spinlock_t lock;
99 };
100
101 #define SUSPEND_NOTIFIER_TIMEOUT msecs_to_jiffies(2000) /* 2 seconds */
102
103 enum suspend_tasks {
104 SUSPEND_PAUSE_DISCOVERY,
105 SUSPEND_UNPAUSE_DISCOVERY,
106
107 SUSPEND_PAUSE_ADVERTISING,
108 SUSPEND_UNPAUSE_ADVERTISING,
109
110 SUSPEND_SCAN_DISABLE,
111 SUSPEND_SCAN_ENABLE,
112 SUSPEND_DISCONNECTING,
113
114 SUSPEND_POWERING_DOWN,
115
116 SUSPEND_PREPARE_NOTIFIER,
117
118 SUSPEND_SET_ADV_FILTER,
119 __SUSPEND_NUM_TASKS
120 };
121
122 enum suspended_state {
123 BT_RUNNING = 0,
124 BT_SUSPEND_DISCONNECT,
125 BT_SUSPEND_CONFIGURE_WAKE,
126 };
127
128 struct hci_conn_hash {
129 struct list_head list;
130 unsigned int acl_num;
131 unsigned int sco_num;
132 unsigned int cis_num;
133 unsigned int bis_num;
134 unsigned int pa_num;
135 unsigned int le_num;
136 unsigned int le_num_peripheral;
137 };
138
139 struct bdaddr_list {
140 struct list_head list;
141 bdaddr_t bdaddr;
142 u8 bdaddr_type;
143 };
144
145 struct codec_list {
146 struct list_head list;
147 u8 id;
148 __u16 cid;
149 __u16 vid;
150 u8 transport;
151 u8 num_caps;
152 u32 len;
153 struct hci_codec_caps caps[];
154 };
155
156 struct bdaddr_list_with_irk {
157 struct list_head list;
158 bdaddr_t bdaddr;
159 u8 bdaddr_type;
160 u8 peer_irk[16];
161 u8 local_irk[16];
162 };
163
164 /* Bitmask of connection flags */
165 enum hci_conn_flags {
166 HCI_CONN_FLAG_REMOTE_WAKEUP = BIT(0),
167 HCI_CONN_FLAG_DEVICE_PRIVACY = BIT(1),
168 HCI_CONN_FLAG_ADDRESS_RESOLUTION = BIT(2),
169 };
170 typedef u8 hci_conn_flags_t;
171
172 struct bdaddr_list_with_flags {
173 struct list_head list;
174 bdaddr_t bdaddr;
175 u8 bdaddr_type;
176 hci_conn_flags_t flags;
177 };
178
179 struct bt_uuid {
180 struct list_head list;
181 u8 uuid[16];
182 u8 size;
183 u8 svc_hint;
184 };
185
186 struct blocked_key {
187 struct list_head list;
188 struct rcu_head rcu;
189 u8 type;
190 u8 val[16];
191 };
192
193 struct smp_csrk {
194 bdaddr_t bdaddr;
195 u8 bdaddr_type;
196 u8 type;
197 u8 val[16];
198 };
199
200 struct smp_ltk {
201 struct list_head list;
202 struct rcu_head rcu;
203 bdaddr_t bdaddr;
204 u8 bdaddr_type;
205 u8 authenticated;
206 u8 type;
207 u8 enc_size;
208 __le16 ediv;
209 __le64 rand;
210 u8 val[16];
211 };
212
213 struct smp_irk {
214 struct list_head list;
215 struct rcu_head rcu;
216 bdaddr_t rpa;
217 bdaddr_t bdaddr;
218 u8 addr_type;
219 u8 val[16];
220 };
221
222 struct link_key {
223 struct list_head list;
224 struct rcu_head rcu;
225 bdaddr_t bdaddr;
226 u8 type;
227 u8 val[HCI_LINK_KEY_SIZE];
228 u8 pin_len;
229 };
230
231 struct oob_data {
232 struct list_head list;
233 bdaddr_t bdaddr;
234 u8 bdaddr_type;
235 u8 present;
236 u8 hash192[16];
237 u8 rand192[16];
238 u8 hash256[16];
239 u8 rand256[16];
240 };
241
242 struct adv_info {
243 struct list_head list;
244 bool enabled;
245 bool pending;
246 bool periodic;
247 __u8 mesh;
248 __u8 instance;
249 __u8 handle;
250 __u8 sid;
251 __u32 flags;
252 __u16 timeout;
253 __u16 remaining_time;
254 __u16 duration;
255 __u16 adv_data_len;
256 __u8 adv_data[HCI_MAX_EXT_AD_LENGTH];
257 bool adv_data_changed;
258 __u16 scan_rsp_len;
259 __u8 scan_rsp_data[HCI_MAX_EXT_AD_LENGTH];
260 bool scan_rsp_changed;
261 __u16 per_adv_data_len;
262 __u8 per_adv_data[HCI_MAX_PER_AD_LENGTH];
263 __s8 tx_power;
264 __u32 min_interval;
265 __u32 max_interval;
266 bdaddr_t random_addr;
267 bool rpa_expired;
268 struct delayed_work rpa_expired_cb;
269 };
270
271 struct tx_queue {
272 struct sk_buff_head queue;
273 unsigned int extra;
274 unsigned int tracked;
275 };
276
277 #define HCI_MAX_ADV_INSTANCES 5
278 #define HCI_DEFAULT_ADV_DURATION 2
279
280 #define HCI_ADV_TX_POWER_NO_PREFERENCE 0x7F
281
282 #define DATA_CMP(_d1, _l1, _d2, _l2) \
283 (_l1 == _l2 ? memcmp(_d1, _d2, _l1) : _l1 - _l2)
284
285 #define ADV_DATA_CMP(_adv, _data, _len) \
286 DATA_CMP((_adv)->adv_data, (_adv)->adv_data_len, _data, _len)
287
288 #define SCAN_RSP_CMP(_adv, _data, _len) \
289 DATA_CMP((_adv)->scan_rsp_data, (_adv)->scan_rsp_len, _data, _len)
290
291 struct monitored_device {
292 struct list_head list;
293
294 bdaddr_t bdaddr;
295 __u8 addr_type;
296 __u16 handle;
297 bool notified;
298 };
299
300 struct adv_pattern {
301 struct list_head list;
302 __u8 ad_type;
303 __u8 offset;
304 __u8 length;
305 __u8 value[HCI_MAX_EXT_AD_LENGTH];
306 };
307
308 struct adv_rssi_thresholds {
309 __s8 low_threshold;
310 __s8 high_threshold;
311 __u16 low_threshold_timeout;
312 __u16 high_threshold_timeout;
313 __u8 sampling_period;
314 };
315
316 struct adv_monitor {
317 struct list_head patterns;
318 struct adv_rssi_thresholds rssi;
319 __u16 handle;
320
321 enum {
322 ADV_MONITOR_STATE_NOT_REGISTERED,
323 ADV_MONITOR_STATE_REGISTERED,
324 ADV_MONITOR_STATE_OFFLOADED
325 } state;
326 };
327
328 #define HCI_MIN_ADV_MONITOR_HANDLE 1
329 #define HCI_MAX_ADV_MONITOR_NUM_HANDLES 32
330 #define HCI_MAX_ADV_MONITOR_NUM_PATTERNS 16
331 #define HCI_ADV_MONITOR_EXT_NONE 1
332 #define HCI_ADV_MONITOR_EXT_MSFT 2
333
334 #define HCI_MAX_SHORT_NAME_LENGTH 10
335
336 #define HCI_CONN_HANDLE_MAX 0x0eff
337 #define HCI_CONN_HANDLE_UNSET(_handle) (_handle > HCI_CONN_HANDLE_MAX)
338
339 /* Min encryption key size to match with SMP */
340 #define HCI_MIN_ENC_KEY_SIZE 7
341
342 /* Default LE RPA expiry time, 15 minutes */
343 #define HCI_DEFAULT_RPA_TIMEOUT (15 * 60)
344
345 /* Default min/max age of connection information (1s/3s) */
346 #define DEFAULT_CONN_INFO_MIN_AGE 1000
347 #define DEFAULT_CONN_INFO_MAX_AGE 3000
348 /* Default authenticated payload timeout 30s */
349 #define DEFAULT_AUTH_PAYLOAD_TIMEOUT 0x0bb8
350
351 #define HCI_MAX_PAGES 3
352
353 struct hci_dev {
354 struct list_head list;
355 struct srcu_struct srcu;
356 struct mutex lock;
357
358 struct ida unset_handle_ida;
359
360 const char *name;
361 unsigned long flags;
362 __u16 id;
363 __u8 bus;
364 bdaddr_t bdaddr;
365 bdaddr_t setup_addr;
366 bdaddr_t public_addr;
367 bdaddr_t random_addr;
368 bdaddr_t static_addr;
369 __u8 adv_addr_type;
370 __u8 dev_name[HCI_MAX_NAME_LENGTH];
371 __u8 short_name[HCI_MAX_SHORT_NAME_LENGTH];
372 __u8 eir[HCI_MAX_EIR_LENGTH];
373 __u16 appearance;
374 __u8 dev_class[3];
375 __u8 major_class;
376 __u8 minor_class;
377 __u8 max_page;
378 __u8 features[HCI_MAX_PAGES][8];
379 __u8 le_features[8];
380 __u8 le_accept_list_size;
381 __u8 le_resolv_list_size;
382 __u8 le_num_of_adv_sets;
383 __u8 le_states[8];
384 __u8 mesh_ad_types[16];
385 __u8 mesh_send_ref;
386 __u8 commands[64];
387 __u8 hci_ver;
388 __u16 hci_rev;
389 __u8 lmp_ver;
390 __u16 manufacturer;
391 __u16 lmp_subver;
392 __u16 voice_setting;
393 __u8 num_iac;
394 __u16 stored_max_keys;
395 __u16 stored_num_keys;
396 __u8 io_capability;
397 __s8 inq_tx_power;
398 __u8 err_data_reporting;
399 __u16 page_scan_interval;
400 __u16 page_scan_window;
401 __u8 page_scan_type;
402 __u8 le_adv_channel_map;
403 __u16 le_adv_min_interval;
404 __u16 le_adv_max_interval;
405 __u8 le_scan_type;
406 __u16 le_scan_interval;
407 __u16 le_scan_window;
408 __u16 le_scan_int_suspend;
409 __u16 le_scan_window_suspend;
410 __u16 le_scan_int_discovery;
411 __u16 le_scan_window_discovery;
412 __u16 le_scan_int_adv_monitor;
413 __u16 le_scan_window_adv_monitor;
414 __u16 le_scan_int_connect;
415 __u16 le_scan_window_connect;
416 __u16 le_conn_min_interval;
417 __u16 le_conn_max_interval;
418 __u16 le_conn_latency;
419 __u16 le_supv_timeout;
420 __u16 le_def_tx_len;
421 __u16 le_def_tx_time;
422 __u16 le_max_tx_len;
423 __u16 le_max_tx_time;
424 __u16 le_max_rx_len;
425 __u16 le_max_rx_time;
426 __u8 le_max_key_size;
427 __u8 le_min_key_size;
428 __u16 discov_interleaved_timeout;
429 __u16 conn_info_min_age;
430 __u16 conn_info_max_age;
431 __u16 auth_payload_timeout;
432 __u8 min_enc_key_size;
433 __u8 max_enc_key_size;
434 __u8 pairing_opts;
435 __u8 ssp_debug_mode;
436 __u8 hw_error_code;
437 __u32 clock;
438 __u16 advmon_allowlist_duration;
439 __u16 advmon_no_filter_duration;
440 __u8 enable_advmon_interleave_scan;
441
442 __u16 devid_source;
443 __u16 devid_vendor;
444 __u16 devid_product;
445 __u16 devid_version;
446
447 __u8 def_page_scan_type;
448 __u16 def_page_scan_int;
449 __u16 def_page_scan_window;
450 __u8 def_inq_scan_type;
451 __u16 def_inq_scan_int;
452 __u16 def_inq_scan_window;
453 __u16 def_br_lsto;
454 __u16 def_page_timeout;
455 __u16 def_multi_adv_rotation_duration;
456 __u16 def_le_autoconnect_timeout;
457 __s8 min_le_tx_power;
458 __s8 max_le_tx_power;
459
460 __u16 pkt_type;
461 __u16 esco_type;
462 __u16 link_policy;
463 __u16 link_mode;
464
465 __u32 idle_timeout;
466 __u16 sniff_min_interval;
467 __u16 sniff_max_interval;
468
469 unsigned int auto_accept_delay;
470
471 DECLARE_BITMAP(quirk_flags, __HCI_NUM_QUIRKS);
472
473 atomic_t cmd_cnt;
474 unsigned int acl_cnt;
475 unsigned int sco_cnt;
476 unsigned int le_cnt;
477 unsigned int iso_cnt;
478
479 unsigned int acl_mtu;
480 unsigned int sco_mtu;
481 unsigned int le_mtu;
482 unsigned int iso_mtu;
483 unsigned int acl_pkts;
484 unsigned int sco_pkts;
485 unsigned int le_pkts;
486 unsigned int iso_pkts;
487
488 unsigned long acl_last_tx;
489 unsigned long le_last_tx;
490
491 __u8 le_tx_def_phys;
492 __u8 le_rx_def_phys;
493
494 struct workqueue_struct *workqueue;
495 struct workqueue_struct *req_workqueue;
496
497 struct work_struct power_on;
498 struct delayed_work power_off;
499 struct work_struct error_reset;
500 struct work_struct cmd_sync_work;
501 struct list_head cmd_sync_work_list;
502 struct mutex cmd_sync_work_lock;
503 struct mutex unregister_lock;
504 struct work_struct cmd_sync_cancel_work;
505 struct work_struct reenable_adv_work;
506
507 __u16 discov_timeout;
508 struct delayed_work discov_off;
509
510 struct delayed_work service_cache;
511
512 struct delayed_work cmd_timer;
513 struct delayed_work ncmd_timer;
514
515 struct work_struct rx_work;
516 struct work_struct cmd_work;
517 struct work_struct tx_work;
518
519 struct delayed_work le_scan_disable;
520
521 struct sk_buff_head rx_q;
522 struct sk_buff_head raw_q;
523 struct sk_buff_head cmd_q;
524
525 struct sk_buff *sent_cmd;
526 struct sk_buff *recv_event;
527
528 struct mutex req_lock;
529 wait_queue_head_t req_wait_q;
530 __u32 req_status;
531 __u32 req_result;
532 struct sk_buff *req_skb;
533 struct sk_buff *req_rsp;
534
535 void *smp_data;
536 void *smp_bredr_data;
537
538 struct discovery_state discovery;
539
540 bool discovery_paused;
541 int advertising_old_state;
542 bool advertising_paused;
543
544 struct notifier_block suspend_notifier;
545 enum suspended_state suspend_state_next;
546 enum suspended_state suspend_state;
547 bool scanning_paused;
548 bool suspended;
549 u8 wake_reason;
550 bdaddr_t wake_addr;
551 u8 wake_addr_type;
552
553 struct hci_conn_hash conn_hash;
554
555 struct list_head mesh_pending;
556 struct mutex mgmt_pending_lock;
557 struct list_head mgmt_pending;
558 struct list_head reject_list;
559 struct list_head accept_list;
560 struct list_head uuids;
561 struct list_head link_keys;
562 struct list_head long_term_keys;
563 struct list_head identity_resolving_keys;
564 struct list_head remote_oob_data;
565 struct list_head le_accept_list;
566 struct list_head le_resolv_list;
567 struct list_head le_conn_params;
568 struct list_head pend_le_conns;
569 struct list_head pend_le_reports;
570 struct list_head blocked_keys;
571 struct list_head local_codecs;
572
573 struct hci_dev_stats stat;
574
575 atomic_t promisc;
576
577 const char *hw_info;
578 const char *fw_info;
579 struct dentry *debugfs;
580
581 struct hci_devcoredump dump;
582
583 struct device dev;
584
585 struct rfkill *rfkill;
586
587 DECLARE_BITMAP(dev_flags, __HCI_NUM_FLAGS);
588 hci_conn_flags_t conn_flags;
589
590 __s8 adv_tx_power;
591 __u8 adv_data[HCI_MAX_EXT_AD_LENGTH];
592 __u8 adv_data_len;
593 __u8 scan_rsp_data[HCI_MAX_EXT_AD_LENGTH];
594 __u8 scan_rsp_data_len;
595 __u8 per_adv_data[HCI_MAX_PER_AD_LENGTH];
596 __u8 per_adv_data_len;
597
598 struct list_head adv_instances;
599 unsigned int adv_instance_cnt;
600 __u8 cur_adv_instance;
601 __u16 adv_instance_timeout;
602 struct delayed_work adv_instance_expire;
603
604 struct idr adv_monitors_idr;
605 unsigned int adv_monitors_cnt;
606
607 __u8 irk[16];
608 __u32 rpa_timeout;
609 struct delayed_work rpa_expired;
610 bdaddr_t rpa;
611
612 struct delayed_work mesh_send_done;
613
614 enum {
615 INTERLEAVE_SCAN_NONE,
616 INTERLEAVE_SCAN_NO_FILTER,
617 INTERLEAVE_SCAN_ALLOWLIST
618 } interleave_scan_state;
619
620 struct delayed_work interleave_scan;
621
622 struct list_head monitored_devices;
623 bool advmon_pend_notify;
624
625 struct hci_drv *hci_drv;
626
627 #if IS_ENABLED(CONFIG_BT_LEDS)
628 struct led_trigger *power_led;
629 #endif
630
631 #if IS_ENABLED(CONFIG_BT_MSFTEXT)
632 __u16 msft_opcode;
633 void *msft_data;
634 bool msft_curve_validity;
635 #endif
636
637 #if IS_ENABLED(CONFIG_BT_AOSPEXT)
638 bool aosp_capable;
639 bool aosp_quality_report;
640 #endif
641
642 int (*open)(struct hci_dev *hdev);
643 int (*close)(struct hci_dev *hdev);
644 int (*flush)(struct hci_dev *hdev);
645 int (*setup)(struct hci_dev *hdev);
646 int (*shutdown)(struct hci_dev *hdev);
647 int (*send)(struct hci_dev *hdev, struct sk_buff *skb);
648 void (*notify)(struct hci_dev *hdev, unsigned int evt);
649 void (*hw_error)(struct hci_dev *hdev, u8 code);
650 int (*post_init)(struct hci_dev *hdev);
651 int (*set_diag)(struct hci_dev *hdev, bool enable);
652 int (*set_bdaddr)(struct hci_dev *hdev, const bdaddr_t *bdaddr);
653 void (*reset)(struct hci_dev *hdev);
654 bool (*wakeup)(struct hci_dev *hdev);
655 int (*set_quality_report)(struct hci_dev *hdev, bool enable);
656 int (*get_data_path_id)(struct hci_dev *hdev, __u8 *data_path);
657 int (*get_codec_config_data)(struct hci_dev *hdev, __u8 type,
658 struct bt_codec *codec, __u8 *vnd_len,
659 __u8 **vnd_data);
660 u8 (*classify_pkt_type)(struct hci_dev *hdev, struct sk_buff *skb);
661 };
662
663 #define hci_set_quirk(hdev, nr) set_bit((nr), (hdev)->quirk_flags)
664 #define hci_clear_quirk(hdev, nr) clear_bit((nr), (hdev)->quirk_flags)
665 #define hci_test_quirk(hdev, nr) test_bit((nr), (hdev)->quirk_flags)
666
667 #define HCI_PHY_HANDLE(handle) (handle & 0xff)
668
669 enum conn_reasons {
670 CONN_REASON_PAIR_DEVICE,
671 CONN_REASON_L2CAP_CHAN,
672 CONN_REASON_SCO_CONNECT,
673 CONN_REASON_ISO_CONNECT,
674 };
675
676 struct hci_conn {
677 struct list_head list;
678
679 atomic_t refcnt;
680
681 bdaddr_t dst;
682 __u8 dst_type;
683 bdaddr_t src;
684 __u8 src_type;
685 bdaddr_t init_addr;
686 __u8 init_addr_type;
687 bdaddr_t resp_addr;
688 __u8 resp_addr_type;
689 __u8 adv_instance;
690 __u16 handle;
691 __u16 sync_handle;
692 __u8 sid;
693 __u16 state;
694 __u16 mtu;
695 __u8 mode;
696 __u8 type;
697 __u8 role;
698 bool out;
699 __u8 attempt;
700 __u8 dev_class[3];
701 __u8 features[HCI_MAX_PAGES][8];
702 __u16 pkt_type;
703 __u16 link_policy;
704 __u8 key_type;
705 __u8 auth_type;
706 __u8 sec_level;
707 __u8 pending_sec_level;
708 __u8 pin_length;
709 __u8 enc_key_size;
710 __u8 io_capability;
711 __u32 passkey_notify;
712 __u8 passkey_entered;
713 __u16 disc_timeout;
714 __u16 conn_timeout;
715 __u16 setting;
716 __u16 auth_payload_timeout;
717 __u16 le_conn_min_interval;
718 __u16 le_conn_max_interval;
719 __u16 le_conn_interval;
720 __u16 le_conn_latency;
721 __u16 le_supv_timeout;
722 __u8 le_adv_data[HCI_MAX_EXT_AD_LENGTH];
723 __u8 le_adv_data_len;
724 __u8 le_per_adv_data[HCI_MAX_PER_AD_TOT_LEN];
725 __u16 le_per_adv_data_len;
726 __u16 le_per_adv_data_offset;
727 __u8 le_adv_phy;
728 __u8 le_adv_sec_phy;
729 __u8 le_tx_phy;
730 __u8 le_rx_phy;
731 __s8 rssi;
732 __s8 tx_power;
733 __s8 max_tx_power;
734 struct bt_iso_qos iso_qos;
735 __u8 num_bis;
736 __u8 bis[HCI_MAX_ISO_BIS];
737
738 unsigned long flags;
739
740 enum conn_reasons conn_reason;
741 __u8 abort_reason;
742
743 __u32 clock;
744 __u16 clock_accuracy;
745
746 unsigned long conn_info_timestamp;
747
748 __u8 remote_cap;
749 __u8 remote_auth;
750 __u8 remote_id;
751
752 unsigned int sent;
753
754 struct sk_buff_head data_q;
755 struct list_head chan_list;
756
757 struct tx_queue tx_q;
758
759 struct delayed_work disc_work;
760 struct delayed_work auto_accept_work;
761 struct delayed_work idle_work;
762 struct delayed_work le_conn_timeout;
763
764 struct device dev;
765 struct dentry *debugfs;
766
767 struct hci_dev *hdev;
768 void *l2cap_data;
769 void *sco_data;
770 void *iso_data;
771
772 struct list_head link_list;
773 struct hci_conn *parent;
774 struct hci_link *link;
775
776 struct bt_codec codec;
777
778 void (*connect_cfm_cb) (struct hci_conn *conn, u8 status);
779 void (*security_cfm_cb) (struct hci_conn *conn, u8 status);
780 void (*disconn_cfm_cb) (struct hci_conn *conn, u8 reason);
781
782 void (*cleanup)(struct hci_conn *conn);
783 };
784
785 struct hci_link {
786 struct list_head list;
787 struct hci_conn *conn;
788 };
789
790 struct hci_chan {
791 struct list_head list;
792 __u16 handle;
793 struct hci_conn *conn;
794 struct sk_buff_head data_q;
795 unsigned int sent;
796 __u8 state;
797 };
798
799 struct hci_conn_params {
800 struct list_head list;
801 struct list_head action;
802
803 bdaddr_t addr;
804 u8 addr_type;
805
806 u16 conn_min_interval;
807 u16 conn_max_interval;
808 u16 conn_latency;
809 u16 supervision_timeout;
810
811 enum {
812 HCI_AUTO_CONN_DISABLED,
813 HCI_AUTO_CONN_REPORT,
814 HCI_AUTO_CONN_DIRECT,
815 HCI_AUTO_CONN_ALWAYS,
816 HCI_AUTO_CONN_LINK_LOSS,
817 HCI_AUTO_CONN_EXPLICIT,
818 } auto_connect;
819
820 struct hci_conn *conn;
821 bool explicit_connect;
822 /* Accessed without hdev->lock: */
823 hci_conn_flags_t flags;
824 u8 privacy_mode;
825 };
826
827 extern struct list_head hci_dev_list;
828 extern struct list_head hci_cb_list;
829 extern rwlock_t hci_dev_list_lock;
830 extern struct mutex hci_cb_list_lock;
831
832 #define hci_dev_set_flag(hdev, nr) set_bit((nr), (hdev)->dev_flags)
833 #define hci_dev_clear_flag(hdev, nr) clear_bit((nr), (hdev)->dev_flags)
834 #define hci_dev_change_flag(hdev, nr) change_bit((nr), (hdev)->dev_flags)
835 #define hci_dev_test_flag(hdev, nr) test_bit((nr), (hdev)->dev_flags)
836 #define hci_dev_test_and_set_flag(hdev, nr) test_and_set_bit((nr), (hdev)->dev_flags)
837 #define hci_dev_test_and_clear_flag(hdev, nr) test_and_clear_bit((nr), (hdev)->dev_flags)
838 #define hci_dev_test_and_change_flag(hdev, nr) test_and_change_bit((nr), (hdev)->dev_flags)
839
840 #define hci_dev_clear_volatile_flags(hdev) \
841 do { \
842 hci_dev_clear_flag((hdev), HCI_LE_SCAN); \
843 hci_dev_clear_flag((hdev), HCI_LE_ADV); \
844 hci_dev_clear_flag((hdev), HCI_LL_RPA_RESOLUTION); \
845 hci_dev_clear_flag((hdev), HCI_PERIODIC_INQ); \
846 hci_dev_clear_flag((hdev), HCI_QUALITY_REPORT); \
847 } while (0)
848
849 #define hci_dev_le_state_simultaneous(hdev) \
850 (!hci_test_quirk((hdev), HCI_QUIRK_BROKEN_LE_STATES) && \
851 ((hdev)->le_states[4] & 0x08) && /* Central */ \
852 ((hdev)->le_states[4] & 0x40) && /* Peripheral */ \
853 ((hdev)->le_states[3] & 0x10)) /* Simultaneous */
854
855 /* ----- HCI interface to upper protocols ----- */
856 int l2cap_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr);
857 int l2cap_disconn_ind(struct hci_conn *hcon);
858 void l2cap_recv_acldata(struct hci_conn *hcon, struct sk_buff *skb, u16 flags);
859
860 #if IS_ENABLED(CONFIG_BT_BREDR)
861 int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 *flags);
862 void sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb);
863 #else
sco_connect_ind(struct hci_dev * hdev,bdaddr_t * bdaddr,__u8 * flags)864 static inline int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr,
865 __u8 *flags)
866 {
867 return 0;
868 }
869
sco_recv_scodata(struct hci_conn * hcon,struct sk_buff * skb)870 static inline void sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb)
871 {
872 }
873 #endif
874
875 #if IS_ENABLED(CONFIG_BT_LE)
876 int iso_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 *flags);
877 void iso_recv(struct hci_conn *hcon, struct sk_buff *skb, u16 flags);
878 #else
iso_connect_ind(struct hci_dev * hdev,bdaddr_t * bdaddr,__u8 * flags)879 static inline int iso_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr,
880 __u8 *flags)
881 {
882 return 0;
883 }
iso_recv(struct hci_conn * hcon,struct sk_buff * skb,u16 flags)884 static inline void iso_recv(struct hci_conn *hcon, struct sk_buff *skb,
885 u16 flags)
886 {
887 }
888 #endif
889
890 /* ----- Inquiry cache ----- */
891 #define INQUIRY_CACHE_AGE_MAX (HZ*30) /* 30 seconds */
892 #define INQUIRY_ENTRY_AGE_MAX (HZ*60) /* 60 seconds */
893
discovery_init(struct hci_dev * hdev)894 static inline void discovery_init(struct hci_dev *hdev)
895 {
896 spin_lock_init(&hdev->discovery.lock);
897 hdev->discovery.state = DISCOVERY_STOPPED;
898 INIT_LIST_HEAD(&hdev->discovery.all);
899 INIT_LIST_HEAD(&hdev->discovery.unknown);
900 INIT_LIST_HEAD(&hdev->discovery.resolve);
901 hdev->discovery.report_invalid_rssi = true;
902 hdev->discovery.rssi = HCI_RSSI_INVALID;
903 }
904
hci_discovery_filter_clear(struct hci_dev * hdev)905 static inline void hci_discovery_filter_clear(struct hci_dev *hdev)
906 {
907 hdev->discovery.result_filtering = false;
908 hdev->discovery.report_invalid_rssi = true;
909 hdev->discovery.rssi = HCI_RSSI_INVALID;
910 hdev->discovery.uuid_count = 0;
911
912 spin_lock(&hdev->discovery.lock);
913 kfree(hdev->discovery.uuids);
914 hdev->discovery.uuids = NULL;
915 spin_unlock(&hdev->discovery.lock);
916 }
917
918 bool hci_discovery_active(struct hci_dev *hdev);
919
920 void hci_discovery_set_state(struct hci_dev *hdev, int state);
921
inquiry_cache_empty(struct hci_dev * hdev)922 static inline int inquiry_cache_empty(struct hci_dev *hdev)
923 {
924 return list_empty(&hdev->discovery.all);
925 }
926
inquiry_cache_age(struct hci_dev * hdev)927 static inline long inquiry_cache_age(struct hci_dev *hdev)
928 {
929 struct discovery_state *c = &hdev->discovery;
930 return jiffies - c->timestamp;
931 }
932
inquiry_entry_age(struct inquiry_entry * e)933 static inline long inquiry_entry_age(struct inquiry_entry *e)
934 {
935 return jiffies - e->timestamp;
936 }
937
938 struct inquiry_entry *hci_inquiry_cache_lookup(struct hci_dev *hdev,
939 bdaddr_t *bdaddr);
940 struct inquiry_entry *hci_inquiry_cache_lookup_unknown(struct hci_dev *hdev,
941 bdaddr_t *bdaddr);
942 struct inquiry_entry *hci_inquiry_cache_lookup_resolve(struct hci_dev *hdev,
943 bdaddr_t *bdaddr,
944 int state);
945 void hci_inquiry_cache_update_resolve(struct hci_dev *hdev,
946 struct inquiry_entry *ie);
947 u32 hci_inquiry_cache_update(struct hci_dev *hdev, struct inquiry_data *data,
948 bool name_known);
949 void hci_inquiry_cache_flush(struct hci_dev *hdev);
950
951 /* ----- HCI Connections ----- */
952 enum {
953 HCI_CONN_AUTH_PEND,
954 HCI_CONN_ENCRYPT_PEND,
955 HCI_CONN_RSWITCH_PEND,
956 HCI_CONN_MODE_CHANGE_PEND,
957 HCI_CONN_SCO_SETUP_PEND,
958 HCI_CONN_MGMT_CONNECTED,
959 HCI_CONN_SSP_ENABLED,
960 HCI_CONN_SC_ENABLED,
961 HCI_CONN_AES_CCM,
962 HCI_CONN_POWER_SAVE,
963 HCI_CONN_FLUSH_KEY,
964 HCI_CONN_ENCRYPT,
965 HCI_CONN_AUTH,
966 HCI_CONN_SECURE,
967 HCI_CONN_FIPS,
968 HCI_CONN_STK_ENCRYPT,
969 HCI_CONN_AUTH_INITIATOR,
970 HCI_CONN_DROP,
971 HCI_CONN_CANCEL,
972 HCI_CONN_PARAM_REMOVAL_PEND,
973 HCI_CONN_NEW_LINK_KEY,
974 HCI_CONN_SCANNING,
975 HCI_CONN_AUTH_FAILURE,
976 HCI_CONN_PER_ADV,
977 HCI_CONN_BIG_CREATED,
978 HCI_CONN_CREATE_CIS,
979 HCI_CONN_CREATE_BIG_SYNC,
980 HCI_CONN_BIG_SYNC,
981 HCI_CONN_BIG_SYNC_FAILED,
982 HCI_CONN_CREATE_PA_SYNC,
983 HCI_CONN_PA_SYNC,
984 HCI_CONN_PA_SYNC_FAILED,
985 };
986
hci_conn_ssp_enabled(struct hci_conn * conn)987 static inline bool hci_conn_ssp_enabled(struct hci_conn *conn)
988 {
989 struct hci_dev *hdev = conn->hdev;
990 return hci_dev_test_flag(hdev, HCI_SSP_ENABLED) &&
991 test_bit(HCI_CONN_SSP_ENABLED, &conn->flags);
992 }
993
hci_conn_sc_enabled(struct hci_conn * conn)994 static inline bool hci_conn_sc_enabled(struct hci_conn *conn)
995 {
996 struct hci_dev *hdev = conn->hdev;
997 return hci_dev_test_flag(hdev, HCI_SC_ENABLED) &&
998 test_bit(HCI_CONN_SC_ENABLED, &conn->flags);
999 }
1000
hci_conn_hash_add(struct hci_dev * hdev,struct hci_conn * c)1001 static inline void hci_conn_hash_add(struct hci_dev *hdev, struct hci_conn *c)
1002 {
1003 struct hci_conn_hash *h = &hdev->conn_hash;
1004 list_add_tail_rcu(&c->list, &h->list);
1005 switch (c->type) {
1006 case ACL_LINK:
1007 h->acl_num++;
1008 break;
1009 case LE_LINK:
1010 h->le_num++;
1011 if (c->role == HCI_ROLE_SLAVE)
1012 h->le_num_peripheral++;
1013 break;
1014 case SCO_LINK:
1015 case ESCO_LINK:
1016 h->sco_num++;
1017 break;
1018 case CIS_LINK:
1019 h->cis_num++;
1020 break;
1021 case BIS_LINK:
1022 h->bis_num++;
1023 break;
1024 case PA_LINK:
1025 h->pa_num++;
1026 break;
1027 }
1028 }
1029
hci_conn_hash_del(struct hci_dev * hdev,struct hci_conn * c)1030 static inline void hci_conn_hash_del(struct hci_dev *hdev, struct hci_conn *c)
1031 {
1032 struct hci_conn_hash *h = &hdev->conn_hash;
1033
1034 list_del_rcu(&c->list);
1035 synchronize_rcu();
1036
1037 switch (c->type) {
1038 case ACL_LINK:
1039 h->acl_num--;
1040 break;
1041 case LE_LINK:
1042 h->le_num--;
1043 if (c->role == HCI_ROLE_SLAVE)
1044 h->le_num_peripheral--;
1045 break;
1046 case SCO_LINK:
1047 case ESCO_LINK:
1048 h->sco_num--;
1049 break;
1050 case CIS_LINK:
1051 h->cis_num--;
1052 break;
1053 case BIS_LINK:
1054 h->bis_num--;
1055 break;
1056 case PA_LINK:
1057 h->pa_num--;
1058 break;
1059 }
1060 }
1061
hci_conn_num(struct hci_dev * hdev,__u8 type)1062 static inline unsigned int hci_conn_num(struct hci_dev *hdev, __u8 type)
1063 {
1064 struct hci_conn_hash *h = &hdev->conn_hash;
1065 switch (type) {
1066 case ACL_LINK:
1067 return h->acl_num;
1068 case LE_LINK:
1069 return h->le_num;
1070 case SCO_LINK:
1071 case ESCO_LINK:
1072 return h->sco_num;
1073 case CIS_LINK:
1074 return h->cis_num;
1075 case BIS_LINK:
1076 return h->bis_num;
1077 case PA_LINK:
1078 return h->pa_num;
1079 default:
1080 return 0;
1081 }
1082 }
1083
hci_conn_count(struct hci_dev * hdev)1084 static inline unsigned int hci_conn_count(struct hci_dev *hdev)
1085 {
1086 struct hci_conn_hash *c = &hdev->conn_hash;
1087
1088 return c->acl_num + c->sco_num + c->le_num + c->cis_num + c->bis_num +
1089 c->pa_num;
1090 }
1091
hci_iso_count(struct hci_dev * hdev)1092 static inline unsigned int hci_iso_count(struct hci_dev *hdev)
1093 {
1094 struct hci_conn_hash *c = &hdev->conn_hash;
1095
1096 return c->cis_num + c->bis_num;
1097 }
1098
hci_conn_valid(struct hci_dev * hdev,struct hci_conn * conn)1099 static inline bool hci_conn_valid(struct hci_dev *hdev, struct hci_conn *conn)
1100 {
1101 struct hci_conn_hash *h = &hdev->conn_hash;
1102 struct hci_conn *c;
1103
1104 rcu_read_lock();
1105
1106 list_for_each_entry_rcu(c, &h->list, list) {
1107 if (c == conn) {
1108 rcu_read_unlock();
1109 return true;
1110 }
1111 }
1112 rcu_read_unlock();
1113
1114 return false;
1115 }
1116
hci_conn_lookup_type(struct hci_dev * hdev,__u16 handle)1117 static inline __u8 hci_conn_lookup_type(struct hci_dev *hdev, __u16 handle)
1118 {
1119 struct hci_conn_hash *h = &hdev->conn_hash;
1120 struct hci_conn *c;
1121 __u8 type = INVALID_LINK;
1122
1123 rcu_read_lock();
1124
1125 list_for_each_entry_rcu(c, &h->list, list) {
1126 if (c->handle == handle) {
1127 type = c->type;
1128 break;
1129 }
1130 }
1131
1132 rcu_read_unlock();
1133
1134 return type;
1135 }
1136
hci_conn_hash_lookup_bis(struct hci_dev * hdev,bdaddr_t * ba,__u8 bis)1137 static inline struct hci_conn *hci_conn_hash_lookup_bis(struct hci_dev *hdev,
1138 bdaddr_t *ba, __u8 bis)
1139 {
1140 struct hci_conn_hash *h = &hdev->conn_hash;
1141 struct hci_conn *c;
1142
1143 rcu_read_lock();
1144
1145 list_for_each_entry_rcu(c, &h->list, list) {
1146 if (bacmp(&c->dst, ba) || c->type != BIS_LINK)
1147 continue;
1148
1149 if (c->iso_qos.bcast.bis == bis) {
1150 rcu_read_unlock();
1151 return c;
1152 }
1153 }
1154 rcu_read_unlock();
1155
1156 return NULL;
1157 }
1158
1159 static inline struct hci_conn *
hci_conn_hash_lookup_create_pa_sync(struct hci_dev * hdev)1160 hci_conn_hash_lookup_create_pa_sync(struct hci_dev *hdev)
1161 {
1162 struct hci_conn_hash *h = &hdev->conn_hash;
1163 struct hci_conn *c;
1164
1165 rcu_read_lock();
1166
1167 list_for_each_entry_rcu(c, &h->list, list) {
1168 if (c->type != PA_LINK)
1169 continue;
1170
1171 if (!test_bit(HCI_CONN_CREATE_PA_SYNC, &c->flags))
1172 continue;
1173
1174 rcu_read_unlock();
1175 return c;
1176 }
1177
1178 rcu_read_unlock();
1179
1180 return NULL;
1181 }
1182
1183 static inline struct hci_conn *
hci_conn_hash_lookup_per_adv_bis(struct hci_dev * hdev,bdaddr_t * ba,__u8 big,__u8 bis)1184 hci_conn_hash_lookup_per_adv_bis(struct hci_dev *hdev,
1185 bdaddr_t *ba,
1186 __u8 big, __u8 bis)
1187 {
1188 struct hci_conn_hash *h = &hdev->conn_hash;
1189 struct hci_conn *c;
1190
1191 rcu_read_lock();
1192
1193 list_for_each_entry_rcu(c, &h->list, list) {
1194 if (bacmp(&c->dst, ba) || c->type != BIS_LINK ||
1195 !test_bit(HCI_CONN_PER_ADV, &c->flags))
1196 continue;
1197
1198 if (c->iso_qos.bcast.big == big &&
1199 c->iso_qos.bcast.bis == bis) {
1200 rcu_read_unlock();
1201 return c;
1202 }
1203 }
1204 rcu_read_unlock();
1205
1206 return NULL;
1207 }
1208
hci_conn_hash_lookup_handle(struct hci_dev * hdev,__u16 handle)1209 static inline struct hci_conn *hci_conn_hash_lookup_handle(struct hci_dev *hdev,
1210 __u16 handle)
1211 {
1212 struct hci_conn_hash *h = &hdev->conn_hash;
1213 struct hci_conn *c;
1214
1215 rcu_read_lock();
1216
1217 list_for_each_entry_rcu(c, &h->list, list) {
1218 if (c->handle == handle) {
1219 rcu_read_unlock();
1220 return c;
1221 }
1222 }
1223 rcu_read_unlock();
1224
1225 return NULL;
1226 }
1227
hci_conn_hash_lookup_ba(struct hci_dev * hdev,__u8 type,bdaddr_t * ba)1228 static inline struct hci_conn *hci_conn_hash_lookup_ba(struct hci_dev *hdev,
1229 __u8 type, bdaddr_t *ba)
1230 {
1231 struct hci_conn_hash *h = &hdev->conn_hash;
1232 struct hci_conn *c;
1233
1234 rcu_read_lock();
1235
1236 list_for_each_entry_rcu(c, &h->list, list) {
1237 if (c->type == type && !bacmp(&c->dst, ba)) {
1238 rcu_read_unlock();
1239 return c;
1240 }
1241 }
1242
1243 rcu_read_unlock();
1244
1245 return NULL;
1246 }
1247
hci_conn_hash_lookup_le(struct hci_dev * hdev,bdaddr_t * ba,__u8 ba_type)1248 static inline struct hci_conn *hci_conn_hash_lookup_le(struct hci_dev *hdev,
1249 bdaddr_t *ba,
1250 __u8 ba_type)
1251 {
1252 struct hci_conn_hash *h = &hdev->conn_hash;
1253 struct hci_conn *c;
1254
1255 rcu_read_lock();
1256
1257 list_for_each_entry_rcu(c, &h->list, list) {
1258 if (c->type != LE_LINK)
1259 continue;
1260
1261 if (ba_type == c->dst_type && !bacmp(&c->dst, ba)) {
1262 rcu_read_unlock();
1263 return c;
1264 }
1265 }
1266
1267 rcu_read_unlock();
1268
1269 return NULL;
1270 }
1271
hci_conn_hash_lookup_cis(struct hci_dev * hdev,bdaddr_t * ba,__u8 ba_type,__u8 cig,__u8 id)1272 static inline struct hci_conn *hci_conn_hash_lookup_cis(struct hci_dev *hdev,
1273 bdaddr_t *ba,
1274 __u8 ba_type,
1275 __u8 cig,
1276 __u8 id)
1277 {
1278 struct hci_conn_hash *h = &hdev->conn_hash;
1279 struct hci_conn *c;
1280
1281 rcu_read_lock();
1282
1283 list_for_each_entry_rcu(c, &h->list, list) {
1284 if (c->type != CIS_LINK)
1285 continue;
1286
1287 /* Match CIG ID if set */
1288 if (cig != c->iso_qos.ucast.cig)
1289 continue;
1290
1291 /* Match CIS ID if set */
1292 if (id != c->iso_qos.ucast.cis)
1293 continue;
1294
1295 /* Match destination address if set */
1296 if (!ba || (ba_type == c->dst_type && !bacmp(&c->dst, ba))) {
1297 rcu_read_unlock();
1298 return c;
1299 }
1300 }
1301
1302 rcu_read_unlock();
1303
1304 return NULL;
1305 }
1306
hci_conn_hash_lookup_cig(struct hci_dev * hdev,__u8 handle)1307 static inline struct hci_conn *hci_conn_hash_lookup_cig(struct hci_dev *hdev,
1308 __u8 handle)
1309 {
1310 struct hci_conn_hash *h = &hdev->conn_hash;
1311 struct hci_conn *c;
1312
1313 rcu_read_lock();
1314
1315 list_for_each_entry_rcu(c, &h->list, list) {
1316 if (c->type != CIS_LINK)
1317 continue;
1318
1319 if (handle == c->iso_qos.ucast.cig) {
1320 rcu_read_unlock();
1321 return c;
1322 }
1323 }
1324
1325 rcu_read_unlock();
1326
1327 return NULL;
1328 }
1329
hci_conn_hash_lookup_big(struct hci_dev * hdev,__u8 handle)1330 static inline struct hci_conn *hci_conn_hash_lookup_big(struct hci_dev *hdev,
1331 __u8 handle)
1332 {
1333 struct hci_conn_hash *h = &hdev->conn_hash;
1334 struct hci_conn *c;
1335
1336 rcu_read_lock();
1337
1338 list_for_each_entry_rcu(c, &h->list, list) {
1339 if (c->type != BIS_LINK)
1340 continue;
1341
1342 if (handle == c->iso_qos.bcast.big) {
1343 rcu_read_unlock();
1344 return c;
1345 }
1346 }
1347
1348 rcu_read_unlock();
1349
1350 return NULL;
1351 }
1352
1353 static inline struct hci_conn *
hci_conn_hash_lookup_big_sync_pend(struct hci_dev * hdev,__u8 handle,__u8 num_bis)1354 hci_conn_hash_lookup_big_sync_pend(struct hci_dev *hdev,
1355 __u8 handle, __u8 num_bis)
1356 {
1357 struct hci_conn_hash *h = &hdev->conn_hash;
1358 struct hci_conn *c;
1359
1360 rcu_read_lock();
1361
1362 list_for_each_entry_rcu(c, &h->list, list) {
1363 if (c->type != PA_LINK)
1364 continue;
1365
1366 if (handle == c->iso_qos.bcast.big && num_bis == c->num_bis) {
1367 rcu_read_unlock();
1368 return c;
1369 }
1370 }
1371
1372 rcu_read_unlock();
1373
1374 return NULL;
1375 }
1376
1377 static inline struct hci_conn *
hci_conn_hash_lookup_big_state(struct hci_dev * hdev,__u8 handle,__u16 state,__u8 role)1378 hci_conn_hash_lookup_big_state(struct hci_dev *hdev, __u8 handle, __u16 state,
1379 __u8 role)
1380 {
1381 struct hci_conn_hash *h = &hdev->conn_hash;
1382 struct hci_conn *c;
1383
1384 rcu_read_lock();
1385
1386 list_for_each_entry_rcu(c, &h->list, list) {
1387 if (c->type != BIS_LINK || c->state != state || c->role != role)
1388 continue;
1389
1390 if (handle == c->iso_qos.bcast.big) {
1391 rcu_read_unlock();
1392 return c;
1393 }
1394 }
1395
1396 rcu_read_unlock();
1397
1398 return NULL;
1399 }
1400
1401 static inline struct hci_conn *
hci_conn_hash_lookup_pa_sync_big_handle(struct hci_dev * hdev,__u8 big)1402 hci_conn_hash_lookup_pa_sync_big_handle(struct hci_dev *hdev, __u8 big)
1403 {
1404 struct hci_conn_hash *h = &hdev->conn_hash;
1405 struct hci_conn *c;
1406
1407 rcu_read_lock();
1408
1409 list_for_each_entry_rcu(c, &h->list, list) {
1410 if (c->type != BIS_LINK ||
1411 !test_bit(HCI_CONN_PA_SYNC, &c->flags))
1412 continue;
1413
1414 if (c->iso_qos.bcast.big == big) {
1415 rcu_read_unlock();
1416 return c;
1417 }
1418 }
1419 rcu_read_unlock();
1420
1421 return NULL;
1422 }
1423
1424 static inline struct hci_conn *
hci_conn_hash_lookup_pa_sync_handle(struct hci_dev * hdev,__u16 sync_handle)1425 hci_conn_hash_lookup_pa_sync_handle(struct hci_dev *hdev, __u16 sync_handle)
1426 {
1427 struct hci_conn_hash *h = &hdev->conn_hash;
1428 struct hci_conn *c;
1429
1430 rcu_read_lock();
1431
1432 list_for_each_entry_rcu(c, &h->list, list) {
1433 if (c->type != PA_LINK)
1434 continue;
1435
1436 /* Ignore the listen hcon, we are looking
1437 * for the child hcon that was created as
1438 * a result of the PA sync established event.
1439 */
1440 if (c->state == BT_LISTEN)
1441 continue;
1442
1443 if (c->sync_handle == sync_handle) {
1444 rcu_read_unlock();
1445 return c;
1446 }
1447 }
1448 rcu_read_unlock();
1449
1450 return NULL;
1451 }
1452
1453 typedef void (*hci_conn_func_t)(struct hci_conn *conn, void *data);
hci_conn_hash_list_state(struct hci_dev * hdev,hci_conn_func_t func,__u8 type,__u16 state,void * data)1454 static inline void hci_conn_hash_list_state(struct hci_dev *hdev,
1455 hci_conn_func_t func, __u8 type,
1456 __u16 state, void *data)
1457 {
1458 struct hci_conn_hash *h = &hdev->conn_hash;
1459 struct hci_conn *c;
1460
1461 if (!func)
1462 return;
1463
1464 rcu_read_lock();
1465
1466 list_for_each_entry_rcu(c, &h->list, list) {
1467 if (c->type == type && c->state == state)
1468 func(c, data);
1469 }
1470
1471 rcu_read_unlock();
1472 }
1473
hci_conn_hash_list_flag(struct hci_dev * hdev,hci_conn_func_t func,__u8 type,__u8 flag,void * data)1474 static inline void hci_conn_hash_list_flag(struct hci_dev *hdev,
1475 hci_conn_func_t func, __u8 type,
1476 __u8 flag, void *data)
1477 {
1478 struct hci_conn_hash *h = &hdev->conn_hash;
1479 struct hci_conn *c;
1480
1481 if (!func)
1482 return;
1483
1484 rcu_read_lock();
1485
1486 list_for_each_entry_rcu(c, &h->list, list) {
1487 if (c->type == type && test_bit(flag, &c->flags))
1488 func(c, data);
1489 }
1490
1491 rcu_read_unlock();
1492 }
1493
hci_lookup_le_connect(struct hci_dev * hdev)1494 static inline struct hci_conn *hci_lookup_le_connect(struct hci_dev *hdev)
1495 {
1496 struct hci_conn_hash *h = &hdev->conn_hash;
1497 struct hci_conn *c;
1498
1499 rcu_read_lock();
1500
1501 list_for_each_entry_rcu(c, &h->list, list) {
1502 if (c->type == LE_LINK && c->state == BT_CONNECT &&
1503 !test_bit(HCI_CONN_SCANNING, &c->flags)) {
1504 rcu_read_unlock();
1505 return c;
1506 }
1507 }
1508
1509 rcu_read_unlock();
1510
1511 return NULL;
1512 }
1513
1514 /* Returns true if an le connection is in the scanning state */
hci_is_le_conn_scanning(struct hci_dev * hdev)1515 static inline bool hci_is_le_conn_scanning(struct hci_dev *hdev)
1516 {
1517 struct hci_conn_hash *h = &hdev->conn_hash;
1518 struct hci_conn *c;
1519
1520 rcu_read_lock();
1521
1522 list_for_each_entry_rcu(c, &h->list, list) {
1523 if (c->type == LE_LINK && c->state == BT_CONNECT &&
1524 test_bit(HCI_CONN_SCANNING, &c->flags)) {
1525 rcu_read_unlock();
1526 return true;
1527 }
1528 }
1529
1530 rcu_read_unlock();
1531
1532 return false;
1533 }
1534
1535 int hci_disconnect(struct hci_conn *conn, __u8 reason);
1536 bool hci_setup_sync(struct hci_conn *conn, __u16 handle);
1537 void hci_sco_setup(struct hci_conn *conn, __u8 status);
1538 bool hci_iso_setup_path(struct hci_conn *conn);
1539 int hci_le_create_cis_pending(struct hci_dev *hdev);
1540 int hci_conn_check_create_cis(struct hci_conn *conn);
1541
1542 struct hci_conn *hci_conn_add(struct hci_dev *hdev, int type, bdaddr_t *dst,
1543 u8 role, u16 handle);
1544 struct hci_conn *hci_conn_add_unset(struct hci_dev *hdev, int type,
1545 bdaddr_t *dst, u8 role);
1546 void hci_conn_del(struct hci_conn *conn);
1547 void hci_conn_hash_flush(struct hci_dev *hdev);
1548
1549 struct hci_chan *hci_chan_create(struct hci_conn *conn);
1550 void hci_chan_del(struct hci_chan *chan);
1551 void hci_chan_list_flush(struct hci_conn *conn);
1552 struct hci_chan *hci_chan_lookup_handle(struct hci_dev *hdev, __u16 handle);
1553
1554 struct hci_conn *hci_connect_le_scan(struct hci_dev *hdev, bdaddr_t *dst,
1555 u8 dst_type, u8 sec_level,
1556 u16 conn_timeout,
1557 enum conn_reasons conn_reason);
1558 struct hci_conn *hci_connect_le(struct hci_dev *hdev, bdaddr_t *dst,
1559 u8 dst_type, bool dst_resolved, u8 sec_level,
1560 u16 conn_timeout, u8 role, u8 phy, u8 sec_phy);
1561 void hci_connect_le_scan_cleanup(struct hci_conn *conn, u8 status);
1562 struct hci_conn *hci_connect_acl(struct hci_dev *hdev, bdaddr_t *dst,
1563 u8 sec_level, u8 auth_type,
1564 enum conn_reasons conn_reason, u16 timeout);
1565 struct hci_conn *hci_connect_sco(struct hci_dev *hdev, int type, bdaddr_t *dst,
1566 __u16 setting, struct bt_codec *codec,
1567 u16 timeout);
1568 struct hci_conn *hci_bind_cis(struct hci_dev *hdev, bdaddr_t *dst,
1569 __u8 dst_type, struct bt_iso_qos *qos);
1570 struct hci_conn *hci_bind_bis(struct hci_dev *hdev, bdaddr_t *dst, __u8 sid,
1571 struct bt_iso_qos *qos,
1572 __u8 base_len, __u8 *base);
1573 struct hci_conn *hci_connect_cis(struct hci_dev *hdev, bdaddr_t *dst,
1574 __u8 dst_type, struct bt_iso_qos *qos);
1575 struct hci_conn *hci_connect_bis(struct hci_dev *hdev, bdaddr_t *dst,
1576 __u8 dst_type, __u8 sid,
1577 struct bt_iso_qos *qos,
1578 __u8 data_len, __u8 *data);
1579 struct hci_conn *hci_pa_create_sync(struct hci_dev *hdev, bdaddr_t *dst,
1580 __u8 dst_type, __u8 sid, struct bt_iso_qos *qos);
1581 int hci_conn_big_create_sync(struct hci_dev *hdev, struct hci_conn *hcon,
1582 struct bt_iso_qos *qos, __u16 sync_handle,
1583 __u8 num_bis, __u8 bis[]);
1584 int hci_conn_check_link_mode(struct hci_conn *conn);
1585 int hci_conn_check_secure(struct hci_conn *conn, __u8 sec_level);
1586 int hci_conn_security(struct hci_conn *conn, __u8 sec_level, __u8 auth_type,
1587 bool initiator);
1588 int hci_conn_switch_role(struct hci_conn *conn, __u8 role);
1589
1590 void hci_conn_enter_active_mode(struct hci_conn *conn, __u8 force_active);
1591
1592 void hci_conn_failed(struct hci_conn *conn, u8 status);
1593 u8 hci_conn_set_handle(struct hci_conn *conn, u16 handle);
1594
1595 void hci_conn_tx_queue(struct hci_conn *conn, struct sk_buff *skb);
1596 void hci_conn_tx_dequeue(struct hci_conn *conn);
1597 void hci_setup_tx_timestamp(struct sk_buff *skb, size_t key_offset,
1598 const struct sockcm_cookie *sockc);
1599
hci_sockcm_init(struct sockcm_cookie * sockc,struct sock * sk)1600 static inline void hci_sockcm_init(struct sockcm_cookie *sockc, struct sock *sk)
1601 {
1602 *sockc = (struct sockcm_cookie) {
1603 .tsflags = READ_ONCE(sk->sk_tsflags),
1604 };
1605 }
1606
1607 /*
1608 * hci_conn_get() and hci_conn_put() are used to control the life-time of an
1609 * "hci_conn" object. They do not guarantee that the hci_conn object is running,
1610 * working or anything else. They just guarantee that the object is available
1611 * and can be dereferenced. So you can use its locks, local variables and any
1612 * other constant data.
1613 * Before accessing runtime data, you _must_ lock the object and then check that
1614 * it is still running. As soon as you release the locks, the connection might
1615 * get dropped, though.
1616 *
1617 * On the other hand, hci_conn_hold() and hci_conn_drop() are used to control
1618 * how long the underlying connection is held. So every channel that runs on the
1619 * hci_conn object calls this to prevent the connection from disappearing. As
1620 * long as you hold a device, you must also guarantee that you have a valid
1621 * reference to the device via hci_conn_get() (or the initial reference from
1622 * hci_conn_add()).
1623 * The hold()/drop() ref-count is known to drop below 0 sometimes, which doesn't
1624 * break because nobody cares for that. But this means, we cannot use
1625 * _get()/_drop() in it, but require the caller to have a valid ref (FIXME).
1626 */
1627
hci_conn_get(struct hci_conn * conn)1628 static inline struct hci_conn *hci_conn_get(struct hci_conn *conn)
1629 {
1630 get_device(&conn->dev);
1631 return conn;
1632 }
1633
hci_conn_put(struct hci_conn * conn)1634 static inline void hci_conn_put(struct hci_conn *conn)
1635 {
1636 put_device(&conn->dev);
1637 }
1638
hci_conn_hold(struct hci_conn * conn)1639 static inline struct hci_conn *hci_conn_hold(struct hci_conn *conn)
1640 {
1641 BT_DBG("hcon %p orig refcnt %d", conn, atomic_read(&conn->refcnt));
1642
1643 atomic_inc(&conn->refcnt);
1644 cancel_delayed_work(&conn->disc_work);
1645
1646 return conn;
1647 }
1648
hci_conn_drop(struct hci_conn * conn)1649 static inline void hci_conn_drop(struct hci_conn *conn)
1650 {
1651 BT_DBG("hcon %p orig refcnt %d", conn, atomic_read(&conn->refcnt));
1652
1653 if (atomic_dec_and_test(&conn->refcnt)) {
1654 unsigned long timeo;
1655
1656 switch (conn->type) {
1657 case ACL_LINK:
1658 case LE_LINK:
1659 cancel_delayed_work(&conn->idle_work);
1660 if (conn->state == BT_CONNECTED) {
1661 timeo = conn->disc_timeout;
1662 if (!conn->out)
1663 timeo *= 2;
1664 } else {
1665 timeo = 0;
1666 }
1667 break;
1668
1669 default:
1670 timeo = 0;
1671 break;
1672 }
1673
1674 cancel_delayed_work(&conn->disc_work);
1675 queue_delayed_work(conn->hdev->workqueue,
1676 &conn->disc_work, timeo);
1677 }
1678 }
1679
1680 /* ----- HCI Devices ----- */
hci_dev_put(struct hci_dev * d)1681 static inline void hci_dev_put(struct hci_dev *d)
1682 {
1683 BT_DBG("%s orig refcnt %d", d->name,
1684 kref_read(&d->dev.kobj.kref));
1685
1686 put_device(&d->dev);
1687 }
1688
hci_dev_hold(struct hci_dev * d)1689 static inline struct hci_dev *hci_dev_hold(struct hci_dev *d)
1690 {
1691 BT_DBG("%s orig refcnt %d", d->name,
1692 kref_read(&d->dev.kobj.kref));
1693
1694 get_device(&d->dev);
1695 return d;
1696 }
1697
1698 #define hci_dev_lock(d) mutex_lock(&d->lock)
1699 #define hci_dev_unlock(d) mutex_unlock(&d->lock)
1700
1701 #define to_hci_dev(d) container_of(d, struct hci_dev, dev)
1702 #define to_hci_conn(c) container_of(c, struct hci_conn, dev)
1703
hci_get_drvdata(struct hci_dev * hdev)1704 static inline void *hci_get_drvdata(struct hci_dev *hdev)
1705 {
1706 return dev_get_drvdata(&hdev->dev);
1707 }
1708
hci_set_drvdata(struct hci_dev * hdev,void * data)1709 static inline void hci_set_drvdata(struct hci_dev *hdev, void *data)
1710 {
1711 dev_set_drvdata(&hdev->dev, data);
1712 }
1713
hci_get_priv(struct hci_dev * hdev)1714 static inline void *hci_get_priv(struct hci_dev *hdev)
1715 {
1716 return (char *)hdev + sizeof(*hdev);
1717 }
1718
1719 struct hci_dev *hci_dev_get(int index);
1720 struct hci_dev *hci_get_route(bdaddr_t *dst, bdaddr_t *src, u8 src_type);
1721
1722 struct hci_dev *hci_alloc_dev_priv(int sizeof_priv);
1723
hci_alloc_dev(void)1724 static inline struct hci_dev *hci_alloc_dev(void)
1725 {
1726 return hci_alloc_dev_priv(0);
1727 }
1728
1729 void hci_free_dev(struct hci_dev *hdev);
1730 int hci_register_dev(struct hci_dev *hdev);
1731 void hci_unregister_dev(struct hci_dev *hdev);
1732 void hci_release_dev(struct hci_dev *hdev);
1733 int hci_register_suspend_notifier(struct hci_dev *hdev);
1734 int hci_unregister_suspend_notifier(struct hci_dev *hdev);
1735 int hci_suspend_dev(struct hci_dev *hdev);
1736 int hci_resume_dev(struct hci_dev *hdev);
1737 int hci_reset_dev(struct hci_dev *hdev);
1738 int hci_recv_frame(struct hci_dev *hdev, struct sk_buff *skb);
1739 int hci_recv_diag(struct hci_dev *hdev, struct sk_buff *skb);
1740 __printf(2, 3) void hci_set_hw_info(struct hci_dev *hdev, const char *fmt, ...);
1741 __printf(2, 3) void hci_set_fw_info(struct hci_dev *hdev, const char *fmt, ...);
1742
hci_set_msft_opcode(struct hci_dev * hdev,__u16 opcode)1743 static inline void hci_set_msft_opcode(struct hci_dev *hdev, __u16 opcode)
1744 {
1745 #if IS_ENABLED(CONFIG_BT_MSFTEXT)
1746 hdev->msft_opcode = opcode;
1747 #endif
1748 }
1749
hci_set_aosp_capable(struct hci_dev * hdev)1750 static inline void hci_set_aosp_capable(struct hci_dev *hdev)
1751 {
1752 #if IS_ENABLED(CONFIG_BT_AOSPEXT)
1753 hdev->aosp_capable = true;
1754 #endif
1755 }
1756
hci_devcd_setup(struct hci_dev * hdev)1757 static inline void hci_devcd_setup(struct hci_dev *hdev)
1758 {
1759 #ifdef CONFIG_DEV_COREDUMP
1760 INIT_WORK(&hdev->dump.dump_rx, hci_devcd_rx);
1761 INIT_DELAYED_WORK(&hdev->dump.dump_timeout, hci_devcd_timeout);
1762 skb_queue_head_init(&hdev->dump.dump_q);
1763 #endif
1764 }
1765
1766 int hci_dev_open(__u16 dev);
1767 int hci_dev_close(__u16 dev);
1768 int hci_dev_do_close(struct hci_dev *hdev);
1769 int hci_dev_reset(__u16 dev);
1770 int hci_dev_reset_stat(__u16 dev);
1771 int hci_dev_cmd(unsigned int cmd, void __user *arg);
1772 int hci_get_dev_list(void __user *arg);
1773 int hci_get_dev_info(void __user *arg);
1774 int hci_get_conn_list(void __user *arg);
1775 int hci_get_conn_info(struct hci_dev *hdev, void __user *arg);
1776 int hci_get_auth_info(struct hci_dev *hdev, void __user *arg);
1777 int hci_inquiry(void __user *arg);
1778
1779 struct bdaddr_list *hci_bdaddr_list_lookup(struct list_head *list,
1780 bdaddr_t *bdaddr, u8 type);
1781 struct bdaddr_list_with_irk *hci_bdaddr_list_lookup_with_irk(
1782 struct list_head *list, bdaddr_t *bdaddr,
1783 u8 type);
1784 struct bdaddr_list_with_flags *
1785 hci_bdaddr_list_lookup_with_flags(struct list_head *list, bdaddr_t *bdaddr,
1786 u8 type);
1787 int hci_bdaddr_list_add(struct list_head *list, bdaddr_t *bdaddr, u8 type);
1788 int hci_bdaddr_list_add_with_irk(struct list_head *list, bdaddr_t *bdaddr,
1789 u8 type, u8 *peer_irk, u8 *local_irk);
1790 int hci_bdaddr_list_add_with_flags(struct list_head *list, bdaddr_t *bdaddr,
1791 u8 type, u32 flags);
1792 int hci_bdaddr_list_del(struct list_head *list, bdaddr_t *bdaddr, u8 type);
1793 int hci_bdaddr_list_del_with_irk(struct list_head *list, bdaddr_t *bdaddr,
1794 u8 type);
1795 void hci_bdaddr_list_clear(struct list_head *list);
1796
1797 struct hci_conn_params *hci_conn_params_lookup(struct hci_dev *hdev,
1798 bdaddr_t *addr, u8 addr_type);
1799 struct hci_conn_params *hci_conn_params_add(struct hci_dev *hdev,
1800 bdaddr_t *addr, u8 addr_type);
1801 void hci_conn_params_del(struct hci_dev *hdev, bdaddr_t *addr, u8 addr_type);
1802 void hci_conn_params_clear_disabled(struct hci_dev *hdev);
1803 void hci_conn_params_free(struct hci_conn_params *param);
1804
1805 void hci_pend_le_list_del_init(struct hci_conn_params *param);
1806 void hci_pend_le_list_add(struct hci_conn_params *param,
1807 struct list_head *list);
1808 struct hci_conn_params *hci_pend_le_action_lookup(struct list_head *list,
1809 bdaddr_t *addr,
1810 u8 addr_type);
1811
1812 void hci_uuids_clear(struct hci_dev *hdev);
1813
1814 void hci_link_keys_clear(struct hci_dev *hdev);
1815 u8 *hci_conn_key_enc_size(struct hci_conn *conn);
1816 struct link_key *hci_find_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr);
1817 struct link_key *hci_add_link_key(struct hci_dev *hdev, struct hci_conn *conn,
1818 bdaddr_t *bdaddr, u8 *val, u8 type,
1819 u8 pin_len, bool *persistent);
1820 struct smp_ltk *hci_add_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr,
1821 u8 addr_type, u8 type, u8 authenticated,
1822 u8 tk[16], u8 enc_size, __le16 ediv, __le64 rand);
1823 struct smp_ltk *hci_find_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr,
1824 u8 addr_type, u8 role);
1825 int hci_remove_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 bdaddr_type);
1826 void hci_smp_ltks_clear(struct hci_dev *hdev);
1827 int hci_remove_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr);
1828
1829 struct smp_irk *hci_find_irk_by_rpa(struct hci_dev *hdev, bdaddr_t *rpa);
1830 struct smp_irk *hci_find_irk_by_addr(struct hci_dev *hdev, bdaddr_t *bdaddr,
1831 u8 addr_type);
1832 struct smp_irk *hci_add_irk(struct hci_dev *hdev, bdaddr_t *bdaddr,
1833 u8 addr_type, u8 val[16], bdaddr_t *rpa);
1834 void hci_remove_irk(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 addr_type);
1835 bool hci_is_blocked_key(struct hci_dev *hdev, u8 type, u8 val[16]);
1836 void hci_blocked_keys_clear(struct hci_dev *hdev);
1837 void hci_smp_irks_clear(struct hci_dev *hdev);
1838
1839 bool hci_bdaddr_is_paired(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 type);
1840
1841 void hci_remote_oob_data_clear(struct hci_dev *hdev);
1842 struct oob_data *hci_find_remote_oob_data(struct hci_dev *hdev,
1843 bdaddr_t *bdaddr, u8 bdaddr_type);
1844 int hci_add_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr,
1845 u8 bdaddr_type, u8 *hash192, u8 *rand192,
1846 u8 *hash256, u8 *rand256);
1847 int hci_remove_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr,
1848 u8 bdaddr_type);
1849
1850 void hci_adv_instances_clear(struct hci_dev *hdev);
1851 struct adv_info *hci_find_adv_instance(struct hci_dev *hdev, u8 instance);
1852 struct adv_info *hci_find_adv_sid(struct hci_dev *hdev, u8 sid);
1853 struct adv_info *hci_get_next_instance(struct hci_dev *hdev, u8 instance);
1854 struct adv_info *hci_add_adv_instance(struct hci_dev *hdev, u8 instance,
1855 u32 flags, u16 adv_data_len, u8 *adv_data,
1856 u16 scan_rsp_len, u8 *scan_rsp_data,
1857 u16 timeout, u16 duration, s8 tx_power,
1858 u32 min_interval, u32 max_interval,
1859 u8 mesh_handle);
1860 struct adv_info *hci_add_per_instance(struct hci_dev *hdev, u8 instance, u8 sid,
1861 u32 flags, u8 data_len, u8 *data,
1862 u32 min_interval, u32 max_interval);
1863 int hci_set_adv_instance_data(struct hci_dev *hdev, u8 instance,
1864 u16 adv_data_len, u8 *adv_data,
1865 u16 scan_rsp_len, u8 *scan_rsp_data);
1866 int hci_remove_adv_instance(struct hci_dev *hdev, u8 instance);
1867 void hci_adv_instances_set_rpa_expired(struct hci_dev *hdev, bool rpa_expired);
1868 u32 hci_adv_instance_flags(struct hci_dev *hdev, u8 instance);
1869 bool hci_adv_instance_is_scannable(struct hci_dev *hdev, u8 instance);
1870
1871 void hci_adv_monitors_clear(struct hci_dev *hdev);
1872 void hci_free_adv_monitor(struct hci_dev *hdev, struct adv_monitor *monitor);
1873 int hci_add_adv_monitor(struct hci_dev *hdev, struct adv_monitor *monitor);
1874 int hci_remove_single_adv_monitor(struct hci_dev *hdev, u16 handle);
1875 int hci_remove_all_adv_monitor(struct hci_dev *hdev);
1876 bool hci_is_adv_monitoring(struct hci_dev *hdev);
1877 int hci_get_adv_monitor_offload_ext(struct hci_dev *hdev);
1878
1879 void hci_event_packet(struct hci_dev *hdev, struct sk_buff *skb);
1880
1881 void hci_init_sysfs(struct hci_dev *hdev);
1882 void hci_conn_init_sysfs(struct hci_conn *conn);
1883 void hci_conn_add_sysfs(struct hci_conn *conn);
1884 void hci_conn_del_sysfs(struct hci_conn *conn);
1885
1886 #define SET_HCIDEV_DEV(hdev, pdev) ((hdev)->dev.parent = (pdev))
1887 #define GET_HCIDEV_DEV(hdev) ((hdev)->dev.parent)
1888
1889 /* ----- LMP capabilities ----- */
1890 #define lmp_encrypt_capable(dev) ((dev)->features[0][0] & LMP_ENCRYPT)
1891 #define lmp_rswitch_capable(dev) ((dev)->features[0][0] & LMP_RSWITCH)
1892 #define lmp_hold_capable(dev) ((dev)->features[0][0] & LMP_HOLD)
1893 #define lmp_sniff_capable(dev) ((dev)->features[0][0] & LMP_SNIFF)
1894 #define lmp_park_capable(dev) ((dev)->features[0][1] & LMP_PARK)
1895 #define lmp_sco_capable(dev) ((dev)->features[0][1] & LMP_SCO)
1896 #define lmp_inq_rssi_capable(dev) ((dev)->features[0][3] & LMP_RSSI_INQ)
1897 #define lmp_esco_capable(dev) ((dev)->features[0][3] & LMP_ESCO)
1898 #define lmp_bredr_capable(dev) (!((dev)->features[0][4] & LMP_NO_BREDR))
1899 #define lmp_le_capable(dev) ((dev)->features[0][4] & LMP_LE)
1900 #define lmp_sniffsubr_capable(dev) ((dev)->features[0][5] & LMP_SNIFF_SUBR)
1901 #define lmp_pause_enc_capable(dev) ((dev)->features[0][5] & LMP_PAUSE_ENC)
1902 #define lmp_esco_2m_capable(dev) ((dev)->features[0][5] & LMP_EDR_ESCO_2M)
1903 #define lmp_ext_inq_capable(dev) ((dev)->features[0][6] & LMP_EXT_INQ)
1904 #define lmp_le_br_capable(dev) (!!((dev)->features[0][6] & LMP_SIMUL_LE_BR))
1905 #define lmp_ssp_capable(dev) ((dev)->features[0][6] & LMP_SIMPLE_PAIR)
1906 #define lmp_no_flush_capable(dev) ((dev)->features[0][6] & LMP_NO_FLUSH)
1907 #define lmp_lsto_capable(dev) ((dev)->features[0][7] & LMP_LSTO)
1908 #define lmp_inq_tx_pwr_capable(dev) ((dev)->features[0][7] & LMP_INQ_TX_PWR)
1909 #define lmp_ext_feat_capable(dev) ((dev)->features[0][7] & LMP_EXTFEATURES)
1910 #define lmp_transp_capable(dev) ((dev)->features[0][2] & LMP_TRANSPARENT)
1911 #define lmp_edr_2m_capable(dev) ((dev)->features[0][3] & LMP_EDR_2M)
1912 #define lmp_edr_3m_capable(dev) ((dev)->features[0][3] & LMP_EDR_3M)
1913 #define lmp_edr_3slot_capable(dev) ((dev)->features[0][4] & LMP_EDR_3SLOT)
1914 #define lmp_edr_5slot_capable(dev) ((dev)->features[0][5] & LMP_EDR_5SLOT)
1915
1916 /* ----- Extended LMP capabilities ----- */
1917 #define lmp_cpb_central_capable(dev) ((dev)->features[2][0] & LMP_CPB_CENTRAL)
1918 #define lmp_cpb_peripheral_capable(dev) ((dev)->features[2][0] & LMP_CPB_PERIPHERAL)
1919 #define lmp_sync_train_capable(dev) ((dev)->features[2][0] & LMP_SYNC_TRAIN)
1920 #define lmp_sync_scan_capable(dev) ((dev)->features[2][0] & LMP_SYNC_SCAN)
1921 #define lmp_sc_capable(dev) ((dev)->features[2][1] & LMP_SC)
1922 #define lmp_ping_capable(dev) ((dev)->features[2][1] & LMP_PING)
1923
1924 /* ----- Host capabilities ----- */
1925 #define lmp_host_ssp_capable(dev) ((dev)->features[1][0] & LMP_HOST_SSP)
1926 #define lmp_host_sc_capable(dev) ((dev)->features[1][0] & LMP_HOST_SC)
1927 #define lmp_host_le_capable(dev) (!!((dev)->features[1][0] & LMP_HOST_LE))
1928 #define lmp_host_le_br_capable(dev) (!!((dev)->features[1][0] & LMP_HOST_LE_BREDR))
1929
1930 #define hdev_is_powered(dev) (test_bit(HCI_UP, &(dev)->flags) && \
1931 !hci_dev_test_flag(dev, HCI_AUTO_OFF))
1932 #define bredr_sc_enabled(dev) (lmp_sc_capable(dev) && \
1933 hci_dev_test_flag(dev, HCI_SC_ENABLED))
1934 #define rpa_valid(dev) (bacmp(&dev->rpa, BDADDR_ANY) && \
1935 !hci_dev_test_flag(dev, HCI_RPA_EXPIRED))
1936 #define adv_rpa_valid(adv) (bacmp(&adv->random_addr, BDADDR_ANY) && \
1937 !adv->rpa_expired)
1938 #define le_enabled(dev) (lmp_le_capable(dev) && \
1939 hci_dev_test_flag(dev, HCI_LE_ENABLED))
1940
1941 #define scan_1m(dev) (((dev)->le_tx_def_phys & HCI_LE_SET_PHY_1M) || \
1942 ((dev)->le_rx_def_phys & HCI_LE_SET_PHY_1M))
1943
1944 #define le_2m_capable(dev) (((dev)->le_features[1] & HCI_LE_PHY_2M))
1945
1946 #define scan_2m(dev) (((dev)->le_tx_def_phys & HCI_LE_SET_PHY_2M) || \
1947 ((dev)->le_rx_def_phys & HCI_LE_SET_PHY_2M))
1948
1949 #define le_coded_capable(dev) (((dev)->le_features[1] & HCI_LE_PHY_CODED) && \
1950 !hci_test_quirk((dev), \
1951 HCI_QUIRK_BROKEN_LE_CODED))
1952
1953 #define scan_coded(dev) (((dev)->le_tx_def_phys & HCI_LE_SET_PHY_CODED) || \
1954 ((dev)->le_rx_def_phys & HCI_LE_SET_PHY_CODED))
1955
1956 #define ll_privacy_capable(dev) ((dev)->le_features[0] & HCI_LE_LL_PRIVACY)
1957 #define ll_privacy_enabled(dev) (le_enabled(dev) && ll_privacy_capable(dev))
1958
1959 #define privacy_mode_capable(dev) (ll_privacy_capable(dev) && \
1960 ((dev)->commands[39] & 0x04))
1961
1962 #define read_key_size_capable(dev) \
1963 ((dev)->commands[20] & 0x10 && \
1964 !hci_test_quirk((dev), HCI_QUIRK_BROKEN_READ_ENC_KEY_SIZE))
1965
1966 #define read_voice_setting_capable(dev) \
1967 ((dev)->commands[9] & 0x04 && \
1968 !hci_test_quirk((dev), HCI_QUIRK_BROKEN_READ_VOICE_SETTING))
1969
1970 /* Use enhanced synchronous connection if command is supported and its quirk
1971 * has not been set.
1972 */
1973 #define enhanced_sync_conn_capable(dev) \
1974 (((dev)->commands[29] & 0x08) && \
1975 !hci_test_quirk((dev), HCI_QUIRK_BROKEN_ENHANCED_SETUP_SYNC_CONN))
1976
1977 /* Use ext scanning if set ext scan param and ext scan enable is supported */
1978 #define use_ext_scan(dev) (((dev)->commands[37] & 0x20) && \
1979 ((dev)->commands[37] & 0x40) && \
1980 !hci_test_quirk((dev), HCI_QUIRK_BROKEN_EXT_SCAN))
1981
1982 /* Use ext create connection if command is supported */
1983 #define use_ext_conn(dev) (((dev)->commands[37] & 0x80) && \
1984 !hci_test_quirk((dev), HCI_QUIRK_BROKEN_EXT_CREATE_CONN))
1985 /* Extended advertising support */
1986 #define ext_adv_capable(dev) (((dev)->le_features[1] & HCI_LE_EXT_ADV))
1987
1988 /* Maximum advertising length */
1989 #define max_adv_len(dev) \
1990 (ext_adv_capable(dev) ? HCI_MAX_EXT_AD_LENGTH : HCI_MAX_AD_LENGTH)
1991
1992 /* BLUETOOTH CORE SPECIFICATION Version 5.3 | Vol 4, Part E page 1789:
1993 *
1994 * C24: Mandatory if the LE Controller supports Connection State and either
1995 * LE Feature (LL Privacy) or LE Feature (Extended Advertising) is supported
1996 */
1997 #define use_enhanced_conn_complete(dev) ((ll_privacy_capable(dev) || \
1998 ext_adv_capable(dev)) && \
1999 !hci_test_quirk((dev), \
2000 HCI_QUIRK_BROKEN_EXT_CREATE_CONN))
2001
2002 /* Periodic advertising support */
2003 #define per_adv_capable(dev) (((dev)->le_features[1] & HCI_LE_PERIODIC_ADV))
2004
2005 /* CIS Master/Slave and BIS support */
2006 #define iso_capable(dev) (cis_capable(dev) || bis_capable(dev))
2007 #define iso_enabled(dev) (le_enabled(dev) && iso_capable(dev))
2008 #define cis_capable(dev) \
2009 (cis_central_capable(dev) || cis_peripheral_capable(dev))
2010 #define cis_enabled(dev) (le_enabled(dev) && cis_capable(dev))
2011 #define cis_central_capable(dev) \
2012 ((dev)->le_features[3] & HCI_LE_CIS_CENTRAL)
2013 #define cis_central_enabled(dev) \
2014 (le_enabled(dev) && cis_central_capable(dev))
2015 #define cis_peripheral_capable(dev) \
2016 ((dev)->le_features[3] & HCI_LE_CIS_PERIPHERAL)
2017 #define cis_peripheral_enabled(dev) \
2018 (le_enabled(dev) && cis_peripheral_capable(dev))
2019 #define bis_capable(dev) ((dev)->le_features[3] & HCI_LE_ISO_BROADCASTER)
2020 #define bis_enabled(dev) (le_enabled(dev) && bis_capable(dev))
2021 #define sync_recv_capable(dev) \
2022 ((dev)->le_features[3] & HCI_LE_ISO_SYNC_RECEIVER)
2023 #define sync_recv_enabled(dev) (le_enabled(dev) && sync_recv_capable(dev))
2024
2025 #define mws_transport_config_capable(dev) (((dev)->commands[30] & 0x08) && \
2026 (!hci_test_quirk((dev), HCI_QUIRK_BROKEN_MWS_TRANSPORT_CONFIG)))
2027
2028 /* ----- HCI protocols ----- */
2029 #define HCI_PROTO_DEFER 0x01
2030
hci_proto_connect_ind(struct hci_dev * hdev,bdaddr_t * bdaddr,__u8 type,__u8 * flags)2031 static inline int hci_proto_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr,
2032 __u8 type, __u8 *flags)
2033 {
2034 switch (type) {
2035 case ACL_LINK:
2036 return l2cap_connect_ind(hdev, bdaddr);
2037
2038 case SCO_LINK:
2039 case ESCO_LINK:
2040 return sco_connect_ind(hdev, bdaddr, flags);
2041
2042 case CIS_LINK:
2043 case BIS_LINK:
2044 case PA_LINK:
2045 return iso_connect_ind(hdev, bdaddr, flags);
2046
2047 default:
2048 BT_ERR("unknown link type %d", type);
2049 return -EINVAL;
2050 }
2051 }
2052
hci_proto_disconn_ind(struct hci_conn * conn)2053 static inline int hci_proto_disconn_ind(struct hci_conn *conn)
2054 {
2055 if (conn->type != ACL_LINK && conn->type != LE_LINK)
2056 return HCI_ERROR_REMOTE_USER_TERM;
2057
2058 return l2cap_disconn_ind(conn);
2059 }
2060
2061 /* ----- HCI callbacks ----- */
2062 struct hci_cb {
2063 struct list_head list;
2064
2065 char *name;
2066
2067 void (*connect_cfm) (struct hci_conn *conn, __u8 status);
2068 void (*disconn_cfm) (struct hci_conn *conn, __u8 status);
2069 void (*security_cfm) (struct hci_conn *conn, __u8 status,
2070 __u8 encrypt);
2071 void (*key_change_cfm) (struct hci_conn *conn, __u8 status);
2072 void (*role_switch_cfm) (struct hci_conn *conn, __u8 status, __u8 role);
2073 };
2074
hci_connect_cfm(struct hci_conn * conn,__u8 status)2075 static inline void hci_connect_cfm(struct hci_conn *conn, __u8 status)
2076 {
2077 struct hci_cb *cb;
2078
2079 mutex_lock(&hci_cb_list_lock);
2080 list_for_each_entry(cb, &hci_cb_list, list) {
2081 if (cb->connect_cfm)
2082 cb->connect_cfm(conn, status);
2083 }
2084 mutex_unlock(&hci_cb_list_lock);
2085
2086 if (conn->connect_cfm_cb)
2087 conn->connect_cfm_cb(conn, status);
2088 }
2089
hci_disconn_cfm(struct hci_conn * conn,__u8 reason)2090 static inline void hci_disconn_cfm(struct hci_conn *conn, __u8 reason)
2091 {
2092 struct hci_cb *cb;
2093
2094 mutex_lock(&hci_cb_list_lock);
2095 list_for_each_entry(cb, &hci_cb_list, list) {
2096 if (cb->disconn_cfm)
2097 cb->disconn_cfm(conn, reason);
2098 }
2099 mutex_unlock(&hci_cb_list_lock);
2100
2101 if (conn->disconn_cfm_cb)
2102 conn->disconn_cfm_cb(conn, reason);
2103 }
2104
hci_auth_cfm(struct hci_conn * conn,__u8 status)2105 static inline void hci_auth_cfm(struct hci_conn *conn, __u8 status)
2106 {
2107 struct hci_cb *cb;
2108 __u8 encrypt;
2109
2110 if (test_bit(HCI_CONN_ENCRYPT_PEND, &conn->flags))
2111 return;
2112
2113 encrypt = test_bit(HCI_CONN_ENCRYPT, &conn->flags) ? 0x01 : 0x00;
2114
2115 mutex_lock(&hci_cb_list_lock);
2116 list_for_each_entry(cb, &hci_cb_list, list) {
2117 if (cb->security_cfm)
2118 cb->security_cfm(conn, status, encrypt);
2119 }
2120 mutex_unlock(&hci_cb_list_lock);
2121
2122 if (conn->security_cfm_cb)
2123 conn->security_cfm_cb(conn, status);
2124 }
2125
hci_encrypt_cfm(struct hci_conn * conn,__u8 status)2126 static inline void hci_encrypt_cfm(struct hci_conn *conn, __u8 status)
2127 {
2128 struct hci_cb *cb;
2129 __u8 encrypt;
2130
2131 if (conn->state == BT_CONFIG) {
2132 if (!status)
2133 conn->state = BT_CONNECTED;
2134
2135 hci_connect_cfm(conn, status);
2136 hci_conn_drop(conn);
2137 return;
2138 }
2139
2140 if (!test_bit(HCI_CONN_ENCRYPT, &conn->flags))
2141 encrypt = 0x00;
2142 else if (test_bit(HCI_CONN_AES_CCM, &conn->flags))
2143 encrypt = 0x02;
2144 else
2145 encrypt = 0x01;
2146
2147 if (!status) {
2148 if (conn->sec_level == BT_SECURITY_SDP)
2149 conn->sec_level = BT_SECURITY_LOW;
2150
2151 if (conn->pending_sec_level > conn->sec_level)
2152 conn->sec_level = conn->pending_sec_level;
2153 }
2154
2155 mutex_lock(&hci_cb_list_lock);
2156 list_for_each_entry(cb, &hci_cb_list, list) {
2157 if (cb->security_cfm)
2158 cb->security_cfm(conn, status, encrypt);
2159 }
2160 mutex_unlock(&hci_cb_list_lock);
2161
2162 if (conn->security_cfm_cb)
2163 conn->security_cfm_cb(conn, status);
2164 }
2165
hci_key_change_cfm(struct hci_conn * conn,__u8 status)2166 static inline void hci_key_change_cfm(struct hci_conn *conn, __u8 status)
2167 {
2168 struct hci_cb *cb;
2169
2170 mutex_lock(&hci_cb_list_lock);
2171 list_for_each_entry(cb, &hci_cb_list, list) {
2172 if (cb->key_change_cfm)
2173 cb->key_change_cfm(conn, status);
2174 }
2175 mutex_unlock(&hci_cb_list_lock);
2176 }
2177
hci_role_switch_cfm(struct hci_conn * conn,__u8 status,__u8 role)2178 static inline void hci_role_switch_cfm(struct hci_conn *conn, __u8 status,
2179 __u8 role)
2180 {
2181 struct hci_cb *cb;
2182
2183 mutex_lock(&hci_cb_list_lock);
2184 list_for_each_entry(cb, &hci_cb_list, list) {
2185 if (cb->role_switch_cfm)
2186 cb->role_switch_cfm(conn, status, role);
2187 }
2188 mutex_unlock(&hci_cb_list_lock);
2189 }
2190
hci_bdaddr_is_rpa(bdaddr_t * bdaddr,u8 addr_type)2191 static inline bool hci_bdaddr_is_rpa(bdaddr_t *bdaddr, u8 addr_type)
2192 {
2193 if (addr_type != ADDR_LE_DEV_RANDOM)
2194 return false;
2195
2196 if ((bdaddr->b[5] & 0xc0) == 0x40)
2197 return true;
2198
2199 return false;
2200 }
2201
hci_is_identity_address(bdaddr_t * addr,u8 addr_type)2202 static inline bool hci_is_identity_address(bdaddr_t *addr, u8 addr_type)
2203 {
2204 if (addr_type == ADDR_LE_DEV_PUBLIC)
2205 return true;
2206
2207 /* Check for Random Static address type */
2208 if ((addr->b[5] & 0xc0) == 0xc0)
2209 return true;
2210
2211 return false;
2212 }
2213
hci_get_irk(struct hci_dev * hdev,bdaddr_t * bdaddr,u8 addr_type)2214 static inline struct smp_irk *hci_get_irk(struct hci_dev *hdev,
2215 bdaddr_t *bdaddr, u8 addr_type)
2216 {
2217 if (!hci_bdaddr_is_rpa(bdaddr, addr_type))
2218 return NULL;
2219
2220 return hci_find_irk_by_rpa(hdev, bdaddr);
2221 }
2222
hci_check_conn_params(u16 min,u16 max,u16 latency,u16 to_multiplier)2223 static inline int hci_check_conn_params(u16 min, u16 max, u16 latency,
2224 u16 to_multiplier)
2225 {
2226 u16 max_latency;
2227
2228 if (min > max) {
2229 BT_WARN("min %d > max %d", min, max);
2230 return -EINVAL;
2231 }
2232
2233 if (min < 6) {
2234 BT_WARN("min %d < 6", min);
2235 return -EINVAL;
2236 }
2237
2238 if (max > 3200) {
2239 BT_WARN("max %d > 3200", max);
2240 return -EINVAL;
2241 }
2242
2243 if (to_multiplier < 10) {
2244 BT_WARN("to_multiplier %d < 10", to_multiplier);
2245 return -EINVAL;
2246 }
2247
2248 if (to_multiplier > 3200) {
2249 BT_WARN("to_multiplier %d > 3200", to_multiplier);
2250 return -EINVAL;
2251 }
2252
2253 if (max >= to_multiplier * 8) {
2254 BT_WARN("max %d >= to_multiplier %d * 8", max, to_multiplier);
2255 return -EINVAL;
2256 }
2257
2258 max_latency = (to_multiplier * 4 / max) - 1;
2259 if (latency > 499) {
2260 BT_WARN("latency %d > 499", latency);
2261 return -EINVAL;
2262 }
2263
2264 if (latency > max_latency) {
2265 BT_WARN("latency %d > max_latency %d", latency, max_latency);
2266 return -EINVAL;
2267 }
2268
2269 return 0;
2270 }
2271
2272 int hci_register_cb(struct hci_cb *hcb);
2273 int hci_unregister_cb(struct hci_cb *hcb);
2274
2275 int __hci_cmd_send(struct hci_dev *hdev, u16 opcode, u32 plen,
2276 const void *param);
2277
2278 int hci_send_cmd(struct hci_dev *hdev, __u16 opcode, __u32 plen,
2279 const void *param);
2280 void hci_send_acl(struct hci_chan *chan, struct sk_buff *skb, __u16 flags);
2281 void hci_send_sco(struct hci_conn *conn, struct sk_buff *skb);
2282 void hci_send_iso(struct hci_conn *conn, struct sk_buff *skb);
2283
2284 void *hci_sent_cmd_data(struct hci_dev *hdev, __u16 opcode);
2285 void *hci_recv_event_data(struct hci_dev *hdev, __u8 event);
2286
2287 u32 hci_conn_get_phy(struct hci_conn *conn);
2288
2289 /* ----- HCI Sockets ----- */
2290 void hci_send_to_sock(struct hci_dev *hdev, struct sk_buff *skb);
2291 void hci_send_to_channel(unsigned short channel, struct sk_buff *skb,
2292 int flag, struct sock *skip_sk);
2293 void hci_send_to_monitor(struct hci_dev *hdev, struct sk_buff *skb);
2294 void hci_send_monitor_ctrl_event(struct hci_dev *hdev, u16 event,
2295 void *data, u16 data_len, ktime_t tstamp,
2296 int flag, struct sock *skip_sk);
2297
2298 void hci_sock_dev_event(struct hci_dev *hdev, int event);
2299
2300 #define HCI_MGMT_VAR_LEN BIT(0)
2301 #define HCI_MGMT_NO_HDEV BIT(1)
2302 #define HCI_MGMT_UNTRUSTED BIT(2)
2303 #define HCI_MGMT_UNCONFIGURED BIT(3)
2304 #define HCI_MGMT_HDEV_OPTIONAL BIT(4)
2305
2306 struct hci_mgmt_handler {
2307 int (*func) (struct sock *sk, struct hci_dev *hdev, void *data,
2308 u16 data_len);
2309 size_t data_len;
2310 unsigned long flags;
2311 };
2312
2313 struct hci_mgmt_chan {
2314 struct list_head list;
2315 unsigned short channel;
2316 size_t handler_count;
2317 const struct hci_mgmt_handler *handlers;
2318 void (*hdev_init) (struct sock *sk, struct hci_dev *hdev);
2319 };
2320
2321 int hci_mgmt_chan_register(struct hci_mgmt_chan *c);
2322 void hci_mgmt_chan_unregister(struct hci_mgmt_chan *c);
2323
2324 /* Management interface */
2325 #define DISCOV_TYPE_BREDR (BIT(BDADDR_BREDR))
2326 #define DISCOV_TYPE_LE (BIT(BDADDR_LE_PUBLIC) | \
2327 BIT(BDADDR_LE_RANDOM))
2328 #define DISCOV_TYPE_INTERLEAVED (BIT(BDADDR_BREDR) | \
2329 BIT(BDADDR_LE_PUBLIC) | \
2330 BIT(BDADDR_LE_RANDOM))
2331
2332 /* These LE scan and inquiry parameters were chosen according to LE General
2333 * Discovery Procedure specification.
2334 */
2335 #define DISCOV_LE_SCAN_WIN 0x0012 /* 11.25 msec */
2336 #define DISCOV_LE_SCAN_INT 0x0012 /* 11.25 msec */
2337 #define DISCOV_LE_SCAN_INT_FAST 0x0060 /* 60 msec */
2338 #define DISCOV_LE_SCAN_WIN_FAST 0x0030 /* 30 msec */
2339 #define DISCOV_LE_SCAN_INT_CONN 0x0060 /* 60 msec */
2340 #define DISCOV_LE_SCAN_WIN_CONN 0x0060 /* 60 msec */
2341 #define DISCOV_LE_SCAN_INT_SLOW1 0x0800 /* 1.28 sec */
2342 #define DISCOV_LE_SCAN_WIN_SLOW1 0x0012 /* 11.25 msec */
2343 #define DISCOV_LE_SCAN_INT_SLOW2 0x1000 /* 2.56 sec */
2344 #define DISCOV_LE_SCAN_WIN_SLOW2 0x0024 /* 22.5 msec */
2345 #define DISCOV_CODED_SCAN_INT_FAST 0x0120 /* 180 msec */
2346 #define DISCOV_CODED_SCAN_WIN_FAST 0x0090 /* 90 msec */
2347 #define DISCOV_CODED_SCAN_INT_SLOW1 0x1800 /* 3.84 sec */
2348 #define DISCOV_CODED_SCAN_WIN_SLOW1 0x0036 /* 33.75 msec */
2349 #define DISCOV_CODED_SCAN_INT_SLOW2 0x3000 /* 7.68 sec */
2350 #define DISCOV_CODED_SCAN_WIN_SLOW2 0x006c /* 67.5 msec */
2351 #define DISCOV_LE_TIMEOUT 10240 /* msec */
2352 #define DISCOV_INTERLEAVED_TIMEOUT 5120 /* msec */
2353 #define DISCOV_INTERLEAVED_INQUIRY_LEN 0x04
2354 #define DISCOV_BREDR_INQUIRY_LEN 0x08
2355 #define DISCOV_LE_RESTART_DELAY msecs_to_jiffies(200) /* msec */
2356 #define DISCOV_LE_FAST_ADV_INT_MIN 0x00A0 /* 100 msec */
2357 #define DISCOV_LE_FAST_ADV_INT_MAX 0x00F0 /* 150 msec */
2358 #define DISCOV_LE_PER_ADV_INT_MIN 0x00A0 /* 200 msec */
2359 #define DISCOV_LE_PER_ADV_INT_MAX 0x00A0 /* 200 msec */
2360 #define DISCOV_LE_ADV_MESH_MIN 0x00A0 /* 100 msec */
2361 #define DISCOV_LE_ADV_MESH_MAX 0x00A0 /* 100 msec */
2362 #define INTERVAL_TO_MS(x) (((x) * 10) / 0x10)
2363
2364 #define NAME_RESOLVE_DURATION msecs_to_jiffies(10240) /* 10.24 sec */
2365
2366 void mgmt_fill_version_info(void *ver);
2367 int mgmt_new_settings(struct hci_dev *hdev);
2368 void mgmt_index_added(struct hci_dev *hdev);
2369 void mgmt_index_removed(struct hci_dev *hdev);
2370 void mgmt_set_powered_failed(struct hci_dev *hdev, int err);
2371 void mgmt_power_on(struct hci_dev *hdev, int err);
2372 void __mgmt_power_off(struct hci_dev *hdev);
2373 void mgmt_new_link_key(struct hci_dev *hdev, struct link_key *key,
2374 bool persistent);
2375 void mgmt_device_connected(struct hci_dev *hdev, struct hci_conn *conn,
2376 u8 *name, u8 name_len);
2377 void mgmt_device_disconnected(struct hci_dev *hdev, bdaddr_t *bdaddr,
2378 u8 link_type, u8 addr_type, u8 reason,
2379 bool mgmt_connected);
2380 void mgmt_disconnect_failed(struct hci_dev *hdev, bdaddr_t *bdaddr,
2381 u8 link_type, u8 addr_type, u8 status);
2382 void mgmt_connect_failed(struct hci_dev *hdev, struct hci_conn *conn,
2383 u8 status);
2384 void mgmt_pin_code_request(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 secure);
2385 void mgmt_pin_code_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
2386 u8 status);
2387 void mgmt_pin_code_neg_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
2388 u8 status);
2389 int mgmt_user_confirm_request(struct hci_dev *hdev, bdaddr_t *bdaddr,
2390 u8 link_type, u8 addr_type, u32 value,
2391 u8 confirm_hint);
2392 int mgmt_user_confirm_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
2393 u8 link_type, u8 addr_type, u8 status);
2394 int mgmt_user_confirm_neg_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
2395 u8 link_type, u8 addr_type, u8 status);
2396 int mgmt_user_passkey_request(struct hci_dev *hdev, bdaddr_t *bdaddr,
2397 u8 link_type, u8 addr_type);
2398 int mgmt_user_passkey_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
2399 u8 link_type, u8 addr_type, u8 status);
2400 int mgmt_user_passkey_neg_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
2401 u8 link_type, u8 addr_type, u8 status);
2402 int mgmt_user_passkey_notify(struct hci_dev *hdev, bdaddr_t *bdaddr,
2403 u8 link_type, u8 addr_type, u32 passkey,
2404 u8 entered);
2405 void mgmt_auth_failed(struct hci_conn *conn, u8 status);
2406 void mgmt_auth_enable_complete(struct hci_dev *hdev, u8 status);
2407 void mgmt_set_class_of_dev_complete(struct hci_dev *hdev, u8 *dev_class,
2408 u8 status);
2409 void mgmt_set_local_name_complete(struct hci_dev *hdev, u8 *name, u8 status);
2410 void mgmt_device_found(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type,
2411 u8 addr_type, u8 *dev_class, s8 rssi, u32 flags,
2412 u8 *eir, u16 eir_len, u8 *scan_rsp, u8 scan_rsp_len,
2413 u64 instant);
2414 void mgmt_remote_name(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type,
2415 u8 addr_type, s8 rssi, u8 *name, u8 name_len);
2416 void mgmt_discovering(struct hci_dev *hdev, u8 discovering);
2417 void mgmt_suspending(struct hci_dev *hdev, u8 state);
2418 void mgmt_resuming(struct hci_dev *hdev, u8 reason, bdaddr_t *bdaddr,
2419 u8 addr_type);
2420 bool mgmt_powering_down(struct hci_dev *hdev);
2421 void mgmt_new_ltk(struct hci_dev *hdev, struct smp_ltk *key, bool persistent);
2422 void mgmt_new_irk(struct hci_dev *hdev, struct smp_irk *irk, bool persistent);
2423 void mgmt_new_csrk(struct hci_dev *hdev, struct smp_csrk *csrk,
2424 bool persistent);
2425 void mgmt_new_conn_param(struct hci_dev *hdev, bdaddr_t *bdaddr,
2426 u8 bdaddr_type, u8 store_hint, u16 min_interval,
2427 u16 max_interval, u16 latency, u16 timeout);
2428 void mgmt_smp_complete(struct hci_conn *conn, bool complete);
2429 bool mgmt_get_connectable(struct hci_dev *hdev);
2430 u8 mgmt_get_adv_discov_flags(struct hci_dev *hdev);
2431 void mgmt_advertising_added(struct sock *sk, struct hci_dev *hdev,
2432 u8 instance);
2433 void mgmt_advertising_removed(struct sock *sk, struct hci_dev *hdev,
2434 u8 instance);
2435 int mgmt_phy_configuration_changed(struct hci_dev *hdev, struct sock *skip);
2436 void mgmt_adv_monitor_device_lost(struct hci_dev *hdev, u16 handle,
2437 bdaddr_t *bdaddr, u8 addr_type);
2438
2439 int hci_abort_conn(struct hci_conn *conn, u8 reason);
2440 u8 hci_le_conn_update(struct hci_conn *conn, u16 min, u16 max, u16 latency,
2441 u16 to_multiplier);
2442 void hci_le_start_enc(struct hci_conn *conn, __le16 ediv, __le64 rand,
2443 __u8 ltk[16], __u8 key_size);
2444
2445 void hci_copy_identity_address(struct hci_dev *hdev, bdaddr_t *bdaddr,
2446 u8 *bdaddr_type);
2447
2448 #define SCO_AIRMODE_MASK 0x0003
2449 #define SCO_AIRMODE_CVSD 0x0000
2450 #define SCO_AIRMODE_TRANSP 0x0003
2451
2452 #define LOCAL_CODEC_ACL_MASK BIT(0)
2453 #define LOCAL_CODEC_SCO_MASK BIT(1)
2454
2455 #define TRANSPORT_TYPE_MAX 0x04
2456
2457 #endif /* __HCI_CORE_H */
2458