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