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