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