hci_core.h

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