1/*
   2   BlueZ - Bluetooth protocol stack for Linux
   3   Copyright (c) 2000-2001, 2010, Code Aurora Forum. All rights reserved.
   4
   5   Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>
   6
   7   This program is free software; you can redistribute it and/or modify
   8   it under the terms of the GNU General Public License version 2 as
   9   published by the Free Software Foundation;
  10
  11   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  12   OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  13   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
  14   IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
  15   CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
  16   WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  17   ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  18   OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  19
  20   ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
  21   COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
  22   SOFTWARE IS DISCLAIMED.
  23*/
  24
  25#ifndef __HCI_CORE_H
  26#define __HCI_CORE_H
  27
  28#include <linux/leds.h>
  29#include <linux/rculist.h>
  30
  31#include <net/bluetooth/hci.h>
  32#include <net/bluetooth/hci_sock.h>
  33
  34/* HCI priority */
  35#define HCI_PRIO_MAX	7
  36
  37/* HCI Core structures */
  38struct inquiry_data {
  39	bdaddr_t	bdaddr;
  40	__u8		pscan_rep_mode;
  41	__u8		pscan_period_mode;
  42	__u8		pscan_mode;
  43	__u8		dev_class[3];
  44	__le16		clock_offset;
  45	__s8		rssi;
  46	__u8		ssp_mode;
  47};
  48
  49struct inquiry_entry {
  50	struct list_head	all;		/* inq_cache.all */
  51	struct list_head	list;		/* unknown or resolve */
  52	enum {
  53		NAME_NOT_KNOWN,
  54		NAME_NEEDED,
  55		NAME_PENDING,
  56		NAME_KNOWN,
  57	} name_state;
  58	__u32			timestamp;
  59	struct inquiry_data	data;
  60};
  61
  62struct discovery_state {
  63	int			type;
  64	enum {
  65		DISCOVERY_STOPPED,
  66		DISCOVERY_STARTING,
  67		DISCOVERY_FINDING,
  68		DISCOVERY_RESOLVING,
  69		DISCOVERY_STOPPING,
  70	} state;
  71	struct list_head	all;	/* All devices found during inquiry */
  72	struct list_head	unknown;	/* Name state not known */
  73	struct list_head	resolve;	/* Name needs to be resolved */
  74	__u32			timestamp;
  75	bdaddr_t		last_adv_addr;
  76	u8			last_adv_addr_type;
  77	s8			last_adv_rssi;
  78	u32			last_adv_flags;
  79	u8			last_adv_data[HCI_MAX_AD_LENGTH];
  80	u8			last_adv_data_len;
  81	bool			report_invalid_rssi;
  82	bool			result_filtering;
  83	bool			limited;
  84	s8			rssi;
  85	u16			uuid_count;
  86	u8			(*uuids)[16];
  87	unsigned long		scan_start;
  88	unsigned long		scan_duration;
  89};
  90
  91struct hci_conn_hash {
  92	struct list_head list;
  93	unsigned int     acl_num;
  94	unsigned int     amp_num;
  95	unsigned int     sco_num;
  96	unsigned int     le_num;
  97	unsigned int     le_num_slave;
  98};
  99
 100struct bdaddr_list {
 101	struct list_head list;
 102	bdaddr_t bdaddr;
 103	u8 bdaddr_type;
 104};
 105
 106struct bdaddr_list_with_irk {
 107	struct list_head list;
 108	bdaddr_t bdaddr;
 109	u8 bdaddr_type;
 110	u8 peer_irk[16];
 111	u8 local_irk[16];
 112};
 113
 114struct bt_uuid {
 115	struct list_head list;
 116	u8 uuid[16];
 117	u8 size;
 118	u8 svc_hint;
 119};
 120
 121struct smp_csrk {
 122	bdaddr_t bdaddr;
 123	u8 bdaddr_type;
 124	u8 type;
 125	u8 val[16];
 126};
 127
 128struct smp_ltk {
 129	struct list_head list;
 130	struct rcu_head rcu;
 131	bdaddr_t bdaddr;
 132	u8 bdaddr_type;
 133	u8 authenticated;
 134	u8 type;
 135	u8 enc_size;
 136	__le16 ediv;
 137	__le64 rand;
 138	u8 val[16];
 139};
 140
 141struct smp_irk {
 142	struct list_head list;
 143	struct rcu_head rcu;
 144	bdaddr_t rpa;
 145	bdaddr_t bdaddr;
 146	u8 addr_type;
 147	u8 val[16];
 148};
 149
 150struct link_key {
 151	struct list_head list;
 152	struct rcu_head rcu;
 153	bdaddr_t bdaddr;
 154	u8 type;
 155	u8 val[HCI_LINK_KEY_SIZE];
 156	u8 pin_len;
 157};
 158
 159struct oob_data {
 160	struct list_head list;
 161	bdaddr_t bdaddr;
 162	u8 bdaddr_type;
 163	u8 present;
 164	u8 hash192[16];
 165	u8 rand192[16];
 166	u8 hash256[16];
 167	u8 rand256[16];
 168};
 169
 170struct adv_info {
 171	struct list_head list;
 172	bool pending;
 173	__u8	instance;
 174	__u32	flags;
 175	__u16	timeout;
 176	__u16	remaining_time;
 177	__u16	duration;
 178	__u16	adv_data_len;
 179	__u8	adv_data[HCI_MAX_AD_LENGTH];
 180	__u16	scan_rsp_len;
 181	__u8	scan_rsp_data[HCI_MAX_AD_LENGTH];
 182	__s8	tx_power;
 183	bdaddr_t	random_addr;
 184	bool 		rpa_expired;
 185	struct delayed_work	rpa_expired_cb;
 186};
 187
 188#define HCI_MAX_ADV_INSTANCES		5
 189#define HCI_DEFAULT_ADV_DURATION	2
 190
 191#define HCI_MAX_SHORT_NAME_LENGTH	10
 192
 193/* Min encryption key size to match with SMP */
 194#define HCI_MIN_ENC_KEY_SIZE		7
 195
 196/* Default LE RPA expiry time, 15 minutes */
 197#define HCI_DEFAULT_RPA_TIMEOUT		(15 * 60)
 198
 199/* Default min/max age of connection information (1s/3s) */
 200#define DEFAULT_CONN_INFO_MIN_AGE	1000
 201#define DEFAULT_CONN_INFO_MAX_AGE	3000
 202/* Default authenticated payload timeout 30s */
 203#define DEFAULT_AUTH_PAYLOAD_TIMEOUT   0x0bb8
 204
 205struct amp_assoc {
 206	__u16	len;
 207	__u16	offset;
 208	__u16	rem_len;
 209	__u16	len_so_far;
 210	__u8	data[HCI_MAX_AMP_ASSOC_SIZE];
 211};
 212
 213#define HCI_MAX_PAGES	3
 214
 215struct hci_dev {
 216	struct list_head list;
 217	struct mutex	lock;
 218
 219	char		name[8];
 220	unsigned long	flags;
 221	__u16		id;
 222	__u8		bus;
 223	__u8		dev_type;
 224	bdaddr_t	bdaddr;
 225	bdaddr_t	setup_addr;
 226	bdaddr_t	public_addr;
 227	bdaddr_t	random_addr;
 228	bdaddr_t	static_addr;
 229	__u8		adv_addr_type;
 230	__u8		dev_name[HCI_MAX_NAME_LENGTH];
 231	__u8		short_name[HCI_MAX_SHORT_NAME_LENGTH];
 232	__u8		eir[HCI_MAX_EIR_LENGTH];
 233	__u16		appearance;
 234	__u8		dev_class[3];
 235	__u8		major_class;
 236	__u8		minor_class;
 237	__u8		max_page;
 238	__u8		features[HCI_MAX_PAGES][8];
 239	__u8		le_features[8];
 240	__u8		le_white_list_size;
 241	__u8		le_resolv_list_size;
 242	__u8		le_num_of_adv_sets;
 243	__u8		le_states[8];
 244	__u8		commands[64];
 245	__u8		hci_ver;
 246	__u16		hci_rev;
 247	__u8		lmp_ver;
 248	__u16		manufacturer;
 249	__u16		lmp_subver;
 250	__u16		voice_setting;
 251	__u8		num_iac;
 252	__u8		stored_max_keys;
 253	__u8		stored_num_keys;
 254	__u8		io_capability;
 255	__s8		inq_tx_power;
 256	__u16		page_scan_interval;
 257	__u16		page_scan_window;
 258	__u8		page_scan_type;
 259	__u8		le_adv_channel_map;
 260	__u16		le_adv_min_interval;
 261	__u16		le_adv_max_interval;
 262	__u8		le_scan_type;
 263	__u16		le_scan_interval;
 264	__u16		le_scan_window;
 265	__u16		le_conn_min_interval;
 266	__u16		le_conn_max_interval;
 267	__u16		le_conn_latency;
 268	__u16		le_supv_timeout;
 269	__u16		le_def_tx_len;
 270	__u16		le_def_tx_time;
 271	__u16		le_max_tx_len;
 272	__u16		le_max_tx_time;
 273	__u16		le_max_rx_len;
 274	__u16		le_max_rx_time;
 275	__u8		le_max_key_size;
 276	__u8		le_min_key_size;
 277	__u16		discov_interleaved_timeout;
 278	__u16		conn_info_min_age;
 279	__u16		conn_info_max_age;
 280	__u16		auth_payload_timeout;
 281	__u8		min_enc_key_size;
 282	__u8		ssp_debug_mode;
 283	__u8		hw_error_code;
 284	__u32		clock;
 285
 286	__u16		devid_source;
 287	__u16		devid_vendor;
 288	__u16		devid_product;
 289	__u16		devid_version;
 290
 291	__u16		pkt_type;
 292	__u16		esco_type;
 293	__u16		link_policy;
 294	__u16		link_mode;
 295
 296	__u32		idle_timeout;
 297	__u16		sniff_min_interval;
 298	__u16		sniff_max_interval;
 299
 300	__u8		amp_status;
 301	__u32		amp_total_bw;
 302	__u32		amp_max_bw;
 303	__u32		amp_min_latency;
 304	__u32		amp_max_pdu;
 305	__u8		amp_type;
 306	__u16		amp_pal_cap;
 307	__u16		amp_assoc_size;
 308	__u32		amp_max_flush_to;
 309	__u32		amp_be_flush_to;
 310
 311	struct amp_assoc	loc_assoc;
 312
 313	__u8		flow_ctl_mode;
 314
 315	unsigned int	auto_accept_delay;
 316
 317	unsigned long	quirks;
 318
 319	atomic_t	cmd_cnt;
 320	unsigned int	acl_cnt;
 321	unsigned int	sco_cnt;
 322	unsigned int	le_cnt;
 323
 324	unsigned int	acl_mtu;
 325	unsigned int	sco_mtu;
 326	unsigned int	le_mtu;
 327	unsigned int	acl_pkts;
 328	unsigned int	sco_pkts;
 329	unsigned int	le_pkts;
 330
 331	__u16		block_len;
 332	__u16		block_mtu;
 333	__u16		num_blocks;
 334	__u16		block_cnt;
 335
 336	unsigned long	acl_last_tx;
 337	unsigned long	sco_last_tx;
 338	unsigned long	le_last_tx;
 339
 340	__u8		le_tx_def_phys;
 341	__u8		le_rx_def_phys;
 342
 343	struct workqueue_struct	*workqueue;
 344	struct workqueue_struct	*req_workqueue;
 345
 346	struct work_struct	power_on;
 347	struct delayed_work	power_off;
 348	struct work_struct	error_reset;
 349
 350	__u16			discov_timeout;
 351	struct delayed_work	discov_off;
 352
 353	struct delayed_work	service_cache;
 354
 355	struct delayed_work	cmd_timer;
 356
 357	struct work_struct	rx_work;
 358	struct work_struct	cmd_work;
 359	struct work_struct	tx_work;
 360
 361	struct work_struct	discov_update;
 362	struct work_struct	bg_scan_update;
 363	struct work_struct	scan_update;
 364	struct work_struct	connectable_update;
 365	struct work_struct	discoverable_update;
 366	struct delayed_work	le_scan_disable;
 367	struct delayed_work	le_scan_restart;
 368
 369	struct sk_buff_head	rx_q;
 370	struct sk_buff_head	raw_q;
 371	struct sk_buff_head	cmd_q;
 372
 373	struct sk_buff		*sent_cmd;
 374
 375	struct mutex		req_lock;
 376	wait_queue_head_t	req_wait_q;
 377	__u32			req_status;
 378	__u32			req_result;
 379	struct sk_buff		*req_skb;
 380
 381	void			*smp_data;
 382	void			*smp_bredr_data;
 383
 384	struct discovery_state	discovery;
 385	struct hci_conn_hash	conn_hash;
 386
 387	struct list_head	mgmt_pending;
 388	struct list_head	blacklist;
 389	struct list_head	whitelist;
 390	struct list_head	uuids;
 391	struct list_head	link_keys;
 392	struct list_head	long_term_keys;
 393	struct list_head	identity_resolving_keys;
 394	struct list_head	remote_oob_data;
 395	struct list_head	le_white_list;
 396	struct list_head	le_resolv_list;
 397	struct list_head	le_conn_params;
 398	struct list_head	pend_le_conns;
 399	struct list_head	pend_le_reports;
 400
 401	struct hci_dev_stats	stat;
 402
 403	atomic_t		promisc;
 404
 405	const char		*hw_info;
 406	const char		*fw_info;
 407	struct dentry		*debugfs;
 408
 409	struct device		dev;
 410
 411	struct rfkill		*rfkill;
 412
 413	DECLARE_BITMAP(dev_flags, __HCI_NUM_FLAGS);
 414
 415	__s8			adv_tx_power;
 416	__u8			adv_data[HCI_MAX_AD_LENGTH];
 417	__u8			adv_data_len;
 418	__u8			scan_rsp_data[HCI_MAX_AD_LENGTH];
 419	__u8			scan_rsp_data_len;
 420
 421	struct list_head	adv_instances;
 422	unsigned int		adv_instance_cnt;
 423	__u8			cur_adv_instance;
 424	__u16			adv_instance_timeout;
 425	struct delayed_work	adv_instance_expire;
 426
 427	__u8			irk[16];
 428	__u32			rpa_timeout;
 429	struct delayed_work	rpa_expired;
 430	bdaddr_t		rpa;
 431
 432#if IS_ENABLED(CONFIG_BT_LEDS)
 433	struct led_trigger	*power_led;
 434#endif
 435
 436	int (*open)(struct hci_dev *hdev);
 437	int (*close)(struct hci_dev *hdev);
 438	int (*flush)(struct hci_dev *hdev);
 439	int (*setup)(struct hci_dev *hdev);
 440	int (*shutdown)(struct hci_dev *hdev);
 441	int (*send)(struct hci_dev *hdev, struct sk_buff *skb);
 442	void (*notify)(struct hci_dev *hdev, unsigned int evt);
 443	void (*hw_error)(struct hci_dev *hdev, u8 code);
 444	int (*post_init)(struct hci_dev *hdev);
 445	int (*set_diag)(struct hci_dev *hdev, bool enable);
 446	int (*set_bdaddr)(struct hci_dev *hdev, const bdaddr_t *bdaddr);
 447	void (*cmd_timeout)(struct hci_dev *hdev);
 448};
 449
 450#define HCI_PHY_HANDLE(handle)	(handle & 0xff)
 451
 452struct hci_conn {
 453	struct list_head list;
 454
 455	atomic_t	refcnt;
 456
 457	bdaddr_t	dst;
 458	__u8		dst_type;
 459	bdaddr_t	src;
 460	__u8		src_type;
 461	bdaddr_t	init_addr;
 462	__u8		init_addr_type;
 463	bdaddr_t	resp_addr;
 464	__u8		resp_addr_type;
 465	__u16		handle;
 466	__u16		state;
 467	__u8		mode;
 468	__u8		type;
 469	__u8		role;
 470	bool		out;
 471	__u8		attempt;
 472	__u8		dev_class[3];
 473	__u8		features[HCI_MAX_PAGES][8];
 474	__u16		pkt_type;
 475	__u16		link_policy;
 476	__u8		key_type;
 477	__u8		auth_type;
 478	__u8		sec_level;
 479	__u8		pending_sec_level;
 480	__u8		pin_length;
 481	__u8		enc_key_size;
 482	__u8		io_capability;
 483	__u32		passkey_notify;
 484	__u8		passkey_entered;
 485	__u16		disc_timeout;
 486	__u16		conn_timeout;
 487	__u16		setting;
 488	__u16		auth_payload_timeout;
 489	__u16		le_conn_min_interval;
 490	__u16		le_conn_max_interval;
 491	__u16		le_conn_interval;
 492	__u16		le_conn_latency;
 493	__u16		le_supv_timeout;
 494	__u8		le_adv_data[HCI_MAX_AD_LENGTH];
 495	__u8		le_adv_data_len;
 496	__s8		rssi;
 497	__s8		tx_power;
 498	__s8		max_tx_power;
 499	unsigned long	flags;
 500
 501	__u32		clock;
 502	__u16		clock_accuracy;
 503
 504	unsigned long	conn_info_timestamp;
 505
 506	__u8		remote_cap;
 507	__u8		remote_auth;
 508	__u8		remote_id;
 509
 510	unsigned int	sent;
 511
 512	struct sk_buff_head data_q;
 513	struct list_head chan_list;
 514
 515	struct delayed_work disc_work;
 516	struct delayed_work auto_accept_work;
 517	struct delayed_work idle_work;
 518	struct delayed_work le_conn_timeout;
 519	struct work_struct  le_scan_cleanup;
 520
 521	struct device	dev;
 522	struct dentry	*debugfs;
 523
 524	struct hci_dev	*hdev;
 525	void		*l2cap_data;
 526	void		*sco_data;
 527	struct amp_mgr	*amp_mgr;
 528
 529	struct hci_conn	*link;
 530
 531	void (*connect_cfm_cb)	(struct hci_conn *conn, u8 status);
 532	void (*security_cfm_cb)	(struct hci_conn *conn, u8 status);
 533	void (*disconn_cfm_cb)	(struct hci_conn *conn, u8 reason);
 534};
 535
 536struct hci_chan {
 537	struct list_head list;
 538	__u16 handle;
 539	struct hci_conn *conn;
 540	struct sk_buff_head data_q;
 541	unsigned int	sent;
 542	__u8		state;
 543};
 544
 545struct hci_conn_params {
 546	struct list_head list;
 547	struct list_head action;
 548
 549	bdaddr_t addr;
 550	u8 addr_type;
 551
 552	u16 conn_min_interval;
 553	u16 conn_max_interval;
 554	u16 conn_latency;
 555	u16 supervision_timeout;
 556
 557	enum {
 558		HCI_AUTO_CONN_DISABLED,
 559		HCI_AUTO_CONN_REPORT,
 560		HCI_AUTO_CONN_DIRECT,
 561		HCI_AUTO_CONN_ALWAYS,
 562		HCI_AUTO_CONN_LINK_LOSS,
 563		HCI_AUTO_CONN_EXPLICIT,
 564	} auto_connect;
 565
 566	struct hci_conn *conn;
 567	bool explicit_connect;
 568};
 569
 570extern struct list_head hci_dev_list;
 571extern struct list_head hci_cb_list;
 572extern rwlock_t hci_dev_list_lock;
 573extern struct mutex hci_cb_list_lock;
 574
 575#define hci_dev_set_flag(hdev, nr)             set_bit((nr), (hdev)->dev_flags)
 576#define hci_dev_clear_flag(hdev, nr)           clear_bit((nr), (hdev)->dev_flags)
 577#define hci_dev_change_flag(hdev, nr)          change_bit((nr), (hdev)->dev_flags)
 578#define hci_dev_test_flag(hdev, nr)            test_bit((nr), (hdev)->dev_flags)
 579#define hci_dev_test_and_set_flag(hdev, nr)    test_and_set_bit((nr), (hdev)->dev_flags)
 580#define hci_dev_test_and_clear_flag(hdev, nr)  test_and_clear_bit((nr), (hdev)->dev_flags)
 581#define hci_dev_test_and_change_flag(hdev, nr) test_and_change_bit((nr), (hdev)->dev_flags)
 582
 583#define hci_dev_clear_volatile_flags(hdev)			\
 584	do {							\
 585		hci_dev_clear_flag(hdev, HCI_LE_SCAN);		\
 586		hci_dev_clear_flag(hdev, HCI_LE_ADV);		\
 587		hci_dev_clear_flag(hdev, HCI_PERIODIC_INQ);	\
 588	} while (0)
 589
 590/* ----- HCI interface to upper protocols ----- */
 591int l2cap_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr);
 592int l2cap_disconn_ind(struct hci_conn *hcon);
 593void l2cap_recv_acldata(struct hci_conn *hcon, struct sk_buff *skb, u16 flags);
 594
 595#if IS_ENABLED(CONFIG_BT_BREDR)
 596int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 *flags);
 597void sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb);
 598#else
 599static inline int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr,
 600				  __u8 *flags)
 601{
 602	return 0;
 603}
 604
 605static inline void sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb)
 606{
 607}
 608#endif
 609
 610/* ----- Inquiry cache ----- */
 611#define INQUIRY_CACHE_AGE_MAX   (HZ*30)   /* 30 seconds */
 612#define INQUIRY_ENTRY_AGE_MAX   (HZ*60)   /* 60 seconds */
 613
 614static inline void discovery_init(struct hci_dev *hdev)
 615{
 616	hdev->discovery.state = DISCOVERY_STOPPED;
 617	INIT_LIST_HEAD(&hdev->discovery.all);
 618	INIT_LIST_HEAD(&hdev->discovery.unknown);
 619	INIT_LIST_HEAD(&hdev->discovery.resolve);
 620	hdev->discovery.report_invalid_rssi = true;
 621	hdev->discovery.rssi = HCI_RSSI_INVALID;
 622}
 623
 624static inline void hci_discovery_filter_clear(struct hci_dev *hdev)
 625{
 626	hdev->discovery.result_filtering = false;
 627	hdev->discovery.report_invalid_rssi = true;
 628	hdev->discovery.rssi = HCI_RSSI_INVALID;
 629	hdev->discovery.uuid_count = 0;
 630	kfree(hdev->discovery.uuids);
 631	hdev->discovery.uuids = NULL;
 632	hdev->discovery.scan_start = 0;
 633	hdev->discovery.scan_duration = 0;
 634}
 635
 636bool hci_discovery_active(struct hci_dev *hdev);
 637
 638void hci_discovery_set_state(struct hci_dev *hdev, int state);
 639
 640static inline int inquiry_cache_empty(struct hci_dev *hdev)
 641{
 642	return list_empty(&hdev->discovery.all);
 643}
 644
 645static inline long inquiry_cache_age(struct hci_dev *hdev)
 646{
 647	struct discovery_state *c = &hdev->discovery;
 648	return jiffies - c->timestamp;
 649}
 650
 651static inline long inquiry_entry_age(struct inquiry_entry *e)
 652{
 653	return jiffies - e->timestamp;
 654}
 655
 656struct inquiry_entry *hci_inquiry_cache_lookup(struct hci_dev *hdev,
 657					       bdaddr_t *bdaddr);
 658struct inquiry_entry *hci_inquiry_cache_lookup_unknown(struct hci_dev *hdev,
 659						       bdaddr_t *bdaddr);
 660struct inquiry_entry *hci_inquiry_cache_lookup_resolve(struct hci_dev *hdev,
 661						       bdaddr_t *bdaddr,
 662						       int state);
 663void hci_inquiry_cache_update_resolve(struct hci_dev *hdev,
 664				      struct inquiry_entry *ie);
 665u32 hci_inquiry_cache_update(struct hci_dev *hdev, struct inquiry_data *data,
 666			     bool name_known);
 667void hci_inquiry_cache_flush(struct hci_dev *hdev);
 668
 669/* ----- HCI Connections ----- */
 670enum {
 671	HCI_CONN_AUTH_PEND,
 672	HCI_CONN_REAUTH_PEND,
 673	HCI_CONN_ENCRYPT_PEND,
 674	HCI_CONN_RSWITCH_PEND,
 675	HCI_CONN_MODE_CHANGE_PEND,
 676	HCI_CONN_SCO_SETUP_PEND,
 677	HCI_CONN_MGMT_CONNECTED,
 678	HCI_CONN_SSP_ENABLED,
 679	HCI_CONN_SC_ENABLED,
 680	HCI_CONN_AES_CCM,
 681	HCI_CONN_POWER_SAVE,
 682	HCI_CONN_FLUSH_KEY,
 683	HCI_CONN_ENCRYPT,
 684	HCI_CONN_AUTH,
 685	HCI_CONN_SECURE,
 686	HCI_CONN_FIPS,
 687	HCI_CONN_STK_ENCRYPT,
 688	HCI_CONN_AUTH_INITIATOR,
 689	HCI_CONN_DROP,
 690	HCI_CONN_PARAM_REMOVAL_PEND,
 691	HCI_CONN_NEW_LINK_KEY,
 692	HCI_CONN_SCANNING,
 693	HCI_CONN_AUTH_FAILURE,
 694};
 695
 696static inline bool hci_conn_ssp_enabled(struct hci_conn *conn)
 697{
 698	struct hci_dev *hdev = conn->hdev;
 699	return hci_dev_test_flag(hdev, HCI_SSP_ENABLED) &&
 700	       test_bit(HCI_CONN_SSP_ENABLED, &conn->flags);
 701}
 702
 703static inline bool hci_conn_sc_enabled(struct hci_conn *conn)
 704{
 705	struct hci_dev *hdev = conn->hdev;
 706	return hci_dev_test_flag(hdev, HCI_SC_ENABLED) &&
 707	       test_bit(HCI_CONN_SC_ENABLED, &conn->flags);
 708}
 709
 710static inline void hci_conn_hash_add(struct hci_dev *hdev, struct hci_conn *c)
 711{
 712	struct hci_conn_hash *h = &hdev->conn_hash;
 713	list_add_rcu(&c->list, &h->list);
 714	switch (c->type) {
 715	case ACL_LINK:
 716		h->acl_num++;
 717		break;
 718	case AMP_LINK:
 719		h->amp_num++;
 720		break;
 721	case LE_LINK:
 722		h->le_num++;
 723		if (c->role == HCI_ROLE_SLAVE)
 724			h->le_num_slave++;
 725		break;
 726	case SCO_LINK:
 727	case ESCO_LINK:
 728		h->sco_num++;
 729		break;
 730	}
 731}
 732
 733static inline void hci_conn_hash_del(struct hci_dev *hdev, struct hci_conn *c)
 734{
 735	struct hci_conn_hash *h = &hdev->conn_hash;
 736
 737	list_del_rcu(&c->list);
 738	synchronize_rcu();
 739
 740	switch (c->type) {
 741	case ACL_LINK:
 742		h->acl_num--;
 743		break;
 744	case AMP_LINK:
 745		h->amp_num--;
 746		break;
 747	case LE_LINK:
 748		h->le_num--;
 749		if (c->role == HCI_ROLE_SLAVE)
 750			h->le_num_slave--;
 751		break;
 752	case SCO_LINK:
 753	case ESCO_LINK:
 754		h->sco_num--;
 755		break;
 756	}
 757}
 758
 759static inline unsigned int hci_conn_num(struct hci_dev *hdev, __u8 type)
 760{
 761	struct hci_conn_hash *h = &hdev->conn_hash;
 762	switch (type) {
 763	case ACL_LINK:
 764		return h->acl_num;
 765	case AMP_LINK:
 766		return h->amp_num;
 767	case LE_LINK:
 768		return h->le_num;
 769	case SCO_LINK:
 770	case ESCO_LINK:
 771		return h->sco_num;
 772	default:
 773		return 0;
 774	}
 775}
 776
 777static inline unsigned int hci_conn_count(struct hci_dev *hdev)
 778{
 779	struct hci_conn_hash *c = &hdev->conn_hash;
 780
 781	return c->acl_num + c->amp_num + c->sco_num + c->le_num;
 782}
 783
 784static inline __u8 hci_conn_lookup_type(struct hci_dev *hdev, __u16 handle)
 785{
 786	struct hci_conn_hash *h = &hdev->conn_hash;
 787	struct hci_conn *c;
 788	__u8 type = INVALID_LINK;
 789
 790	rcu_read_lock();
 791
 792	list_for_each_entry_rcu(c, &h->list, list) {
 793		if (c->handle == handle) {
 794			type = c->type;
 795			break;
 796		}
 797	}
 798
 799	rcu_read_unlock();
 800
 801	return type;
 802}
 803
 804static inline struct hci_conn *hci_conn_hash_lookup_handle(struct hci_dev *hdev,
 805								__u16 handle)
 806{
 807	struct hci_conn_hash *h = &hdev->conn_hash;
 808	struct hci_conn  *c;
 809
 810	rcu_read_lock();
 811
 812	list_for_each_entry_rcu(c, &h->list, list) {
 813		if (c->handle == handle) {
 814			rcu_read_unlock();
 815			return c;
 816		}
 817	}
 818	rcu_read_unlock();
 819
 820	return NULL;
 821}
 822
 823static inline struct hci_conn *hci_conn_hash_lookup_ba(struct hci_dev *hdev,
 824							__u8 type, bdaddr_t *ba)
 825{
 826	struct hci_conn_hash *h = &hdev->conn_hash;
 827	struct hci_conn  *c;
 828
 829	rcu_read_lock();
 830
 831	list_for_each_entry_rcu(c, &h->list, list) {
 832		if (c->type == type && !bacmp(&c->dst, ba)) {
 833			rcu_read_unlock();
 834			return c;
 835		}
 836	}
 837
 838	rcu_read_unlock();
 839
 840	return NULL;
 841}
 842
 843static inline struct hci_conn *hci_conn_hash_lookup_le(struct hci_dev *hdev,
 844						       bdaddr_t *ba,
 845						       __u8 ba_type)
 846{
 847	struct hci_conn_hash *h = &hdev->conn_hash;
 848	struct hci_conn  *c;
 849
 850	rcu_read_lock();
 851
 852	list_for_each_entry_rcu(c, &h->list, list) {
 853		if (c->type != LE_LINK)
 854		       continue;
 855
 856		if (ba_type == c->dst_type && !bacmp(&c->dst, ba)) {
 857			rcu_read_unlock();
 858			return c;
 859		}
 860	}
 861
 862	rcu_read_unlock();
 863
 864	return NULL;
 865}
 866
 867static inline struct hci_conn *hci_conn_hash_lookup_state(struct hci_dev *hdev,
 868							__u8 type, __u16 state)
 869{
 870	struct hci_conn_hash *h = &hdev->conn_hash;
 871	struct hci_conn  *c;
 872
 873	rcu_read_lock();
 874
 875	list_for_each_entry_rcu(c, &h->list, list) {
 876		if (c->type == type && c->state == state) {
 877			rcu_read_unlock();
 878			return c;
 879		}
 880	}
 881
 882	rcu_read_unlock();
 883
 884	return NULL;
 885}
 886
 887static inline struct hci_conn *hci_lookup_le_connect(struct hci_dev *hdev)
 888{
 889	struct hci_conn_hash *h = &hdev->conn_hash;
 890	struct hci_conn  *c;
 891
 892	rcu_read_lock();
 893
 894	list_for_each_entry_rcu(c, &h->list, list) {
 895		if (c->type == LE_LINK && c->state == BT_CONNECT &&
 896		    !test_bit(HCI_CONN_SCANNING, &c->flags)) {
 897			rcu_read_unlock();
 898			return c;
 899		}
 900	}
 901
 902	rcu_read_unlock();
 903
 904	return NULL;
 905}
 906
 907int hci_disconnect(struct hci_conn *conn, __u8 reason);
 908bool hci_setup_sync(struct hci_conn *conn, __u16 handle);
 909void hci_sco_setup(struct hci_conn *conn, __u8 status);
 910
 911struct hci_conn *hci_conn_add(struct hci_dev *hdev, int type, bdaddr_t *dst,
 912			      u8 role);
 913int hci_conn_del(struct hci_conn *conn);
 914void hci_conn_hash_flush(struct hci_dev *hdev);
 915void hci_conn_check_pending(struct hci_dev *hdev);
 916
 917struct hci_chan *hci_chan_create(struct hci_conn *conn);
 918void hci_chan_del(struct hci_chan *chan);
 919void hci_chan_list_flush(struct hci_conn *conn);
 920struct hci_chan *hci_chan_lookup_handle(struct hci_dev *hdev, __u16 handle);
 921
 922struct hci_conn *hci_connect_le_scan(struct hci_dev *hdev, bdaddr_t *dst,
 923				     u8 dst_type, u8 sec_level,
 924				     u16 conn_timeout);
 925struct hci_conn *hci_connect_le(struct hci_dev *hdev, bdaddr_t *dst,
 926				u8 dst_type, u8 sec_level, u16 conn_timeout,
 927				u8 role, bdaddr_t *direct_rpa);
 928struct hci_conn *hci_connect_acl(struct hci_dev *hdev, bdaddr_t *dst,
 929				 u8 sec_level, u8 auth_type);
 930struct hci_conn *hci_connect_sco(struct hci_dev *hdev, int type, bdaddr_t *dst,
 931				 __u16 setting);
 932int hci_conn_check_link_mode(struct hci_conn *conn);
 933int hci_conn_check_secure(struct hci_conn *conn, __u8 sec_level);
 934int hci_conn_security(struct hci_conn *conn, __u8 sec_level, __u8 auth_type,
 935		      bool initiator);
 936int hci_conn_switch_role(struct hci_conn *conn, __u8 role);
 937
 938void hci_conn_enter_active_mode(struct hci_conn *conn, __u8 force_active);
 939
 940void hci_le_conn_failed(struct hci_conn *conn, u8 status);
 941
 942/*
 943 * hci_conn_get() and hci_conn_put() are used to control the life-time of an
 944 * "hci_conn" object. They do not guarantee that the hci_conn object is running,
 945 * working or anything else. They just guarantee that the object is available
 946 * and can be dereferenced. So you can use its locks, local variables and any
 947 * other constant data.
 948 * Before accessing runtime data, you _must_ lock the object and then check that
 949 * it is still running. As soon as you release the locks, the connection might
 950 * get dropped, though.
 951 *
 952 * On the other hand, hci_conn_hold() and hci_conn_drop() are used to control
 953 * how long the underlying connection is held. So every channel that runs on the
 954 * hci_conn object calls this to prevent the connection from disappearing. As
 955 * long as you hold a device, you must also guarantee that you have a valid
 956 * reference to the device via hci_conn_get() (or the initial reference from
 957 * hci_conn_add()).
 958 * The hold()/drop() ref-count is known to drop below 0 sometimes, which doesn't
 959 * break because nobody cares for that. But this means, we cannot use
 960 * _get()/_drop() in it, but require the caller to have a valid ref (FIXME).
 961 */
 962
 963static inline struct hci_conn *hci_conn_get(struct hci_conn *conn)
 964{
 965	get_device(&conn->dev);
 966	return conn;
 967}
 968
 969static inline void hci_conn_put(struct hci_conn *conn)
 970{
 971	put_device(&conn->dev);
 972}
 973
 974static inline void hci_conn_hold(struct hci_conn *conn)
 975{
 976	BT_DBG("hcon %p orig refcnt %d", conn, atomic_read(&conn->refcnt));
 977
 978	atomic_inc(&conn->refcnt);
 979	cancel_delayed_work(&conn->disc_work);
 980}
 981
 982static inline void hci_conn_drop(struct hci_conn *conn)
 983{
 984	BT_DBG("hcon %p orig refcnt %d", conn, atomic_read(&conn->refcnt));
 985
 986	if (atomic_dec_and_test(&conn->refcnt)) {
 987		unsigned long timeo;
 988
 989		switch (conn->type) {
 990		case ACL_LINK:
 991		case LE_LINK:
 992			cancel_delayed_work(&conn->idle_work);
 993			if (conn->state == BT_CONNECTED) {
 994				timeo = conn->disc_timeout;
 995				if (!conn->out)
 996					timeo *= 2;
 997			} else {
 998				timeo = 0;
 999			}
1000			break;
1001
1002		case AMP_LINK:
1003			timeo = conn->disc_timeout;
1004			break;
1005
1006		default:
1007			timeo = 0;
1008			break;
1009		}
1010
1011		cancel_delayed_work(&conn->disc_work);
1012		queue_delayed_work(conn->hdev->workqueue,
1013				   &conn->disc_work, timeo);
1014	}
1015}
1016
1017/* ----- HCI Devices ----- */
1018static inline void hci_dev_put(struct hci_dev *d)
1019{
1020	BT_DBG("%s orig refcnt %d", d->name,
1021	       kref_read(&d->dev.kobj.kref));
1022
1023	put_device(&d->dev);
1024}
1025
1026static inline struct hci_dev *hci_dev_hold(struct hci_dev *d)
1027{
1028	BT_DBG("%s orig refcnt %d", d->name,
1029	       kref_read(&d->dev.kobj.kref));
1030
1031	get_device(&d->dev);
1032	return d;
1033}
1034
1035#define hci_dev_lock(d)		mutex_lock(&d->lock)
1036#define hci_dev_unlock(d)	mutex_unlock(&d->lock)
1037
1038#define to_hci_dev(d) container_of(d, struct hci_dev, dev)
1039#define to_hci_conn(c) container_of(c, struct hci_conn, dev)
1040
1041static inline void *hci_get_drvdata(struct hci_dev *hdev)
1042{
1043	return dev_get_drvdata(&hdev->dev);
1044}
1045
1046static inline void hci_set_drvdata(struct hci_dev *hdev, void *data)
1047{
1048	dev_set_drvdata(&hdev->dev, data);
1049}
1050
1051struct hci_dev *hci_dev_get(int index);
1052struct hci_dev *hci_get_route(bdaddr_t *dst, bdaddr_t *src, u8 src_type);
1053
1054struct hci_dev *hci_alloc_dev(void);
1055void hci_free_dev(struct hci_dev *hdev);
1056int hci_register_dev(struct hci_dev *hdev);
1057void hci_unregister_dev(struct hci_dev *hdev);
1058int hci_suspend_dev(struct hci_dev *hdev);
1059int hci_resume_dev(struct hci_dev *hdev);
1060int hci_reset_dev(struct hci_dev *hdev);
1061int hci_recv_frame(struct hci_dev *hdev, struct sk_buff *skb);
1062int hci_recv_diag(struct hci_dev *hdev, struct sk_buff *skb);
1063__printf(2, 3) void hci_set_hw_info(struct hci_dev *hdev, const char *fmt, ...);
1064__printf(2, 3) void hci_set_fw_info(struct hci_dev *hdev, const char *fmt, ...);
1065int hci_dev_open(__u16 dev);
1066int hci_dev_close(__u16 dev);
1067int hci_dev_do_close(struct hci_dev *hdev);
1068int hci_dev_reset(__u16 dev);
1069int hci_dev_reset_stat(__u16 dev);
1070int hci_dev_cmd(unsigned int cmd, void __user *arg);
1071int hci_get_dev_list(void __user *arg);
1072int hci_get_dev_info(void __user *arg);
1073int hci_get_conn_list(void __user *arg);
1074int hci_get_conn_info(struct hci_dev *hdev, void __user *arg);
1075int hci_get_auth_info(struct hci_dev *hdev, void __user *arg);
1076int hci_inquiry(void __user *arg);
1077
1078struct bdaddr_list *hci_bdaddr_list_lookup(struct list_head *list,
1079					   bdaddr_t *bdaddr, u8 type);
1080struct bdaddr_list_with_irk *hci_bdaddr_list_lookup_with_irk(
1081				    struct list_head *list, bdaddr_t *bdaddr,
1082				    u8 type);
1083int hci_bdaddr_list_add(struct list_head *list, bdaddr_t *bdaddr, u8 type);
1084int hci_bdaddr_list_add_with_irk(struct list_head *list, bdaddr_t *bdaddr,
1085					u8 type, u8 *peer_irk, u8 *local_irk);
1086int hci_bdaddr_list_del(struct list_head *list, bdaddr_t *bdaddr, u8 type);
1087int hci_bdaddr_list_del_with_irk(struct list_head *list, bdaddr_t *bdaddr,
1088								u8 type);
1089void hci_bdaddr_list_clear(struct list_head *list);
1090
1091struct hci_conn_params *hci_conn_params_lookup(struct hci_dev *hdev,
1092					       bdaddr_t *addr, u8 addr_type);
1093struct hci_conn_params *hci_conn_params_add(struct hci_dev *hdev,
1094					    bdaddr_t *addr, u8 addr_type);
1095void hci_conn_params_del(struct hci_dev *hdev, bdaddr_t *addr, u8 addr_type);
1096void hci_conn_params_clear_disabled(struct hci_dev *hdev);
1097
1098struct hci_conn_params *hci_pend_le_action_lookup(struct list_head *list,
1099						  bdaddr_t *addr,
1100						  u8 addr_type);
1101
1102void hci_uuids_clear(struct hci_dev *hdev);
1103
1104void hci_link_keys_clear(struct hci_dev *hdev);
1105struct link_key *hci_find_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr);
1106struct link_key *hci_add_link_key(struct hci_dev *hdev, struct hci_conn *conn,
1107				  bdaddr_t *bdaddr, u8 *val, u8 type,
1108				  u8 pin_len, bool *persistent);
1109struct smp_ltk *hci_add_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr,
1110			    u8 addr_type, u8 type, u8 authenticated,
1111			    u8 tk[16], u8 enc_size, __le16 ediv, __le64 rand);
1112struct smp_ltk *hci_find_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr,
1113			     u8 addr_type, u8 role);
1114int hci_remove_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 bdaddr_type);
1115void hci_smp_ltks_clear(struct hci_dev *hdev);
1116int hci_remove_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr);
1117
1118struct smp_irk *hci_find_irk_by_rpa(struct hci_dev *hdev, bdaddr_t *rpa);
1119struct smp_irk *hci_find_irk_by_addr(struct hci_dev *hdev, bdaddr_t *bdaddr,
1120				     u8 addr_type);
1121struct smp_irk *hci_add_irk(struct hci_dev *hdev, bdaddr_t *bdaddr,
1122			    u8 addr_type, u8 val[16], bdaddr_t *rpa);
1123void hci_remove_irk(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 addr_type);
1124void hci_smp_irks_clear(struct hci_dev *hdev);
1125
1126bool hci_bdaddr_is_paired(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 type);
1127
1128void hci_remote_oob_data_clear(struct hci_dev *hdev);
1129struct oob_data *hci_find_remote_oob_data(struct hci_dev *hdev,
1130					  bdaddr_t *bdaddr, u8 bdaddr_type);
1131int hci_add_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr,
1132			    u8 bdaddr_type, u8 *hash192, u8 *rand192,
1133			    u8 *hash256, u8 *rand256);
1134int hci_remove_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr,
1135			       u8 bdaddr_type);
1136
1137void hci_adv_instances_clear(struct hci_dev *hdev);
1138struct adv_info *hci_find_adv_instance(struct hci_dev *hdev, u8 instance);
1139struct adv_info *hci_get_next_instance(struct hci_dev *hdev, u8 instance);
1140int hci_add_adv_instance(struct hci_dev *hdev, u8 instance, u32 flags,
1141			 u16 adv_data_len, u8 *adv_data,
1142			 u16 scan_rsp_len, u8 *scan_rsp_data,
1143			 u16 timeout, u16 duration);
1144int hci_remove_adv_instance(struct hci_dev *hdev, u8 instance);
1145void hci_adv_instances_set_rpa_expired(struct hci_dev *hdev, bool rpa_expired);
1146
1147void hci_event_packet(struct hci_dev *hdev, struct sk_buff *skb);
1148
1149void hci_init_sysfs(struct hci_dev *hdev);
1150void hci_conn_init_sysfs(struct hci_conn *conn);
1151void hci_conn_add_sysfs(struct hci_conn *conn);
1152void hci_conn_del_sysfs(struct hci_conn *conn);
1153
1154#define SET_HCIDEV_DEV(hdev, pdev) ((hdev)->dev.parent = (pdev))
1155
1156/* ----- LMP capabilities ----- */
1157#define lmp_encrypt_capable(dev)   ((dev)->features[0][0] & LMP_ENCRYPT)
1158#define lmp_rswitch_capable(dev)   ((dev)->features[0][0] & LMP_RSWITCH)
1159#define lmp_hold_capable(dev)      ((dev)->features[0][0] & LMP_HOLD)
1160#define lmp_sniff_capable(dev)     ((dev)->features[0][0] & LMP_SNIFF)
1161#define lmp_park_capable(dev)      ((dev)->features[0][1] & LMP_PARK)
1162#define lmp_inq_rssi_capable(dev)  ((dev)->features[0][3] & LMP_RSSI_INQ)
1163#define lmp_esco_capable(dev)      ((dev)->features[0][3] & LMP_ESCO)
1164#define lmp_bredr_capable(dev)     (!((dev)->features[0][4] & LMP_NO_BREDR))
1165#define lmp_le_capable(dev)        ((dev)->features[0][4] & LMP_LE)
1166#define lmp_sniffsubr_capable(dev) ((dev)->features[0][5] & LMP_SNIFF_SUBR)
1167#define lmp_pause_enc_capable(dev) ((dev)->features[0][5] & LMP_PAUSE_ENC)
1168#define lmp_ext_inq_capable(dev)   ((dev)->features[0][6] & LMP_EXT_INQ)
1169#define lmp_le_br_capable(dev)     (!!((dev)->features[0][6] & LMP_SIMUL_LE_BR))
1170#define lmp_ssp_capable(dev)       ((dev)->features[0][6] & LMP_SIMPLE_PAIR)
1171#define lmp_no_flush_capable(dev)  ((dev)->features[0][6] & LMP_NO_FLUSH)
1172#define lmp_lsto_capable(dev)      ((dev)->features[0][7] & LMP_LSTO)
1173#define lmp_inq_tx_pwr_capable(dev) ((dev)->features[0][7] & LMP_INQ_TX_PWR)
1174#define lmp_ext_feat_capable(dev)  ((dev)->features[0][7] & LMP_EXTFEATURES)
1175#define lmp_transp_capable(dev)    ((dev)->features[0][2] & LMP_TRANSPARENT)
1176#define lmp_edr_2m_capable(dev)    ((dev)->features[0][3] & LMP_EDR_2M)
1177#define lmp_edr_3m_capable(dev)    ((dev)->features[0][3] & LMP_EDR_3M)
1178#define lmp_edr_3slot_capable(dev) ((dev)->features[0][4] & LMP_EDR_3SLOT)
1179#define lmp_edr_5slot_capable(dev) ((dev)->features[0][5] & LMP_EDR_5SLOT)
1180
1181/* ----- Extended LMP capabilities ----- */
1182#define lmp_csb_master_capable(dev) ((dev)->features[2][0] & LMP_CSB_MASTER)
1183#define lmp_csb_slave_capable(dev)  ((dev)->features[2][0] & LMP_CSB_SLAVE)
1184#define lmp_sync_train_capable(dev) ((dev)->features[2][0] & LMP_SYNC_TRAIN)
1185#define lmp_sync_scan_capable(dev)  ((dev)->features[2][0] & LMP_SYNC_SCAN)
1186#define lmp_sc_capable(dev)         ((dev)->features[2][1] & LMP_SC)
1187#define lmp_ping_capable(dev)       ((dev)->features[2][1] & LMP_PING)
1188
1189/* ----- Host capabilities ----- */
1190#define lmp_host_ssp_capable(dev)  ((dev)->features[1][0] & LMP_HOST_SSP)
1191#define lmp_host_sc_capable(dev)   ((dev)->features[1][0] & LMP_HOST_SC)
1192#define lmp_host_le_capable(dev)   (!!((dev)->features[1][0] & LMP_HOST_LE))
1193#define lmp_host_le_br_capable(dev) (!!((dev)->features[1][0] & LMP_HOST_LE_BREDR))
1194
1195#define hdev_is_powered(dev)   (test_bit(HCI_UP, &(dev)->flags) && \
1196				!hci_dev_test_flag(dev, HCI_AUTO_OFF))
1197#define bredr_sc_enabled(dev)  (lmp_sc_capable(dev) && \
1198				hci_dev_test_flag(dev, HCI_SC_ENABLED))
1199
1200#define scan_1m(dev) (((dev)->le_tx_def_phys & HCI_LE_SET_PHY_1M) || \
1201		      ((dev)->le_rx_def_phys & HCI_LE_SET_PHY_1M))
1202
1203#define scan_2m(dev) (((dev)->le_tx_def_phys & HCI_LE_SET_PHY_2M) || \
1204		      ((dev)->le_rx_def_phys & HCI_LE_SET_PHY_2M))
1205
1206#define scan_coded(dev) (((dev)->le_tx_def_phys & HCI_LE_SET_PHY_CODED) || \
1207			 ((dev)->le_rx_def_phys & HCI_LE_SET_PHY_CODED))
1208
1209/* Use ext scanning if set ext scan param and ext scan enable is supported */
1210#define use_ext_scan(dev) (((dev)->commands[37] & 0x20) && \
1211			   ((dev)->commands[37] & 0x40))
1212/* Use ext create connection if command is supported */
1213#define use_ext_conn(dev) ((dev)->commands[37] & 0x80)
1214
1215/* Extended advertising support */
1216#define ext_adv_capable(dev) (((dev)->le_features[1] & HCI_LE_EXT_ADV))
1217
1218/* ----- HCI protocols ----- */
1219#define HCI_PROTO_DEFER             0x01
1220
1221static inline int hci_proto_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr,
1222					__u8 type, __u8 *flags)
1223{
1224	switch (type) {
1225	case ACL_LINK:
1226		return l2cap_connect_ind(hdev, bdaddr);
1227
1228	case SCO_LINK:
1229	case ESCO_LINK:
1230		return sco_connect_ind(hdev, bdaddr, flags);
1231
1232	default:
1233		BT_ERR("unknown link type %d", type);
1234		return -EINVAL;
1235	}
1236}
1237
1238static inline int hci_proto_disconn_ind(struct hci_conn *conn)
1239{
1240	if (conn->type != ACL_LINK && conn->type != LE_LINK)
1241		return HCI_ERROR_REMOTE_USER_TERM;
1242
1243	return l2cap_disconn_ind(conn);
1244}
1245
1246/* ----- HCI callbacks ----- */
1247struct hci_cb {
1248	struct list_head list;
1249
1250	char *name;
1251
1252	void (*connect_cfm)	(struct hci_conn *conn, __u8 status);
1253	void (*disconn_cfm)	(struct hci_conn *conn, __u8 status);
1254	void (*security_cfm)	(struct hci_conn *conn, __u8 status,
1255								__u8 encrypt);
1256	void (*key_change_cfm)	(struct hci_conn *conn, __u8 status);
1257	void (*role_switch_cfm)	(struct hci_conn *conn, __u8 status, __u8 role);
1258};
1259
1260static inline void hci_connect_cfm(struct hci_conn *conn, __u8 status)
1261{
1262	struct hci_cb *cb;
1263
1264	mutex_lock(&hci_cb_list_lock);
1265	list_for_each_entry(cb, &hci_cb_list, list) {
1266		if (cb->connect_cfm)
1267			cb->connect_cfm(conn, status);
1268	}
1269	mutex_unlock(&hci_cb_list_lock);
1270
1271	if (conn->connect_cfm_cb)
1272		conn->connect_cfm_cb(conn, status);
1273}
1274
1275static inline void hci_disconn_cfm(struct hci_conn *conn, __u8 reason)
1276{
1277	struct hci_cb *cb;
1278
1279	mutex_lock(&hci_cb_list_lock);
1280	list_for_each_entry(cb, &hci_cb_list, list) {
1281		if (cb->disconn_cfm)
1282			cb->disconn_cfm(conn, reason);
1283	}
1284	mutex_unlock(&hci_cb_list_lock);
1285
1286	if (conn->disconn_cfm_cb)
1287		conn->disconn_cfm_cb(conn, reason);
1288}
1289
1290static inline void hci_auth_cfm(struct hci_conn *conn, __u8 status)
1291{
1292	struct hci_cb *cb;
1293	__u8 encrypt;
1294
1295	if (test_bit(HCI_CONN_ENCRYPT_PEND, &conn->flags))
1296		return;
1297
1298	encrypt = test_bit(HCI_CONN_ENCRYPT, &conn->flags) ? 0x01 : 0x00;
1299
1300	mutex_lock(&hci_cb_list_lock);
1301	list_for_each_entry(cb, &hci_cb_list, list) {
1302		if (cb->security_cfm)
1303			cb->security_cfm(conn, status, encrypt);
1304	}
1305	mutex_unlock(&hci_cb_list_lock);
1306
1307	if (conn->security_cfm_cb)
1308		conn->security_cfm_cb(conn, status);
1309}
1310
1311static inline void hci_encrypt_cfm(struct hci_conn *conn, __u8 status,
1312								__u8 encrypt)
1313{
1314	struct hci_cb *cb;
1315
1316	if (conn->sec_level == BT_SECURITY_SDP)
1317		conn->sec_level = BT_SECURITY_LOW;
1318
1319	if (conn->pending_sec_level > conn->sec_level)
1320		conn->sec_level = conn->pending_sec_level;
1321
1322	mutex_lock(&hci_cb_list_lock);
1323	list_for_each_entry(cb, &hci_cb_list, list) {
1324		if (cb->security_cfm)
1325			cb->security_cfm(conn, status, encrypt);
1326	}
1327	mutex_unlock(&hci_cb_list_lock);
1328
1329	if (conn->security_cfm_cb)
1330		conn->security_cfm_cb(conn, status);
1331}
1332
1333static inline void hci_key_change_cfm(struct hci_conn *conn, __u8 status)
1334{
1335	struct hci_cb *cb;
1336
1337	mutex_lock(&hci_cb_list_lock);
1338	list_for_each_entry(cb, &hci_cb_list, list) {
1339		if (cb->key_change_cfm)
1340			cb->key_change_cfm(conn, status);
1341	}
1342	mutex_unlock(&hci_cb_list_lock);
1343}
1344
1345static inline void hci_role_switch_cfm(struct hci_conn *conn, __u8 status,
1346								__u8 role)
1347{
1348	struct hci_cb *cb;
1349
1350	mutex_lock(&hci_cb_list_lock);
1351	list_for_each_entry(cb, &hci_cb_list, list) {
1352		if (cb->role_switch_cfm)
1353			cb->role_switch_cfm(conn, status, role);
1354	}
1355	mutex_unlock(&hci_cb_list_lock);
1356}
1357
1358static inline void *eir_get_data(u8 *eir, size_t eir_len, u8 type,
1359				 size_t *data_len)
1360{
1361	size_t parsed = 0;
1362
1363	if (eir_len < 2)
1364		return NULL;
1365
1366	while (parsed < eir_len - 1) {
1367		u8 field_len = eir[0];
1368
1369		if (field_len == 0)
1370			break;
1371
1372		parsed += field_len + 1;
1373
1374		if (parsed > eir_len)
1375			break;
1376
1377		if (eir[1] != type) {
1378			eir += field_len + 1;
1379			continue;
1380		}
1381
1382		/* Zero length data */
1383		if (field_len == 1)
1384			return NULL;
1385
1386		if (data_len)
1387			*data_len = field_len - 1;
1388
1389		return &eir[2];
1390	}
1391
1392	return NULL;
1393}
1394
1395static inline bool hci_bdaddr_is_rpa(bdaddr_t *bdaddr, u8 addr_type)
1396{
1397	if (addr_type != ADDR_LE_DEV_RANDOM)
1398		return false;
1399
1400	if ((bdaddr->b[5] & 0xc0) == 0x40)
1401	       return true;
1402
1403	return false;
1404}
1405
1406static inline bool hci_is_identity_address(bdaddr_t *addr, u8 addr_type)
1407{
1408	if (addr_type == ADDR_LE_DEV_PUBLIC)
1409		return true;
1410
1411	/* Check for Random Static address type */
1412	if ((addr->b[5] & 0xc0) == 0xc0)
1413		return true;
1414
1415	return false;
1416}
1417
1418static inline struct smp_irk *hci_get_irk(struct hci_dev *hdev,
1419					  bdaddr_t *bdaddr, u8 addr_type)
1420{
1421	if (!hci_bdaddr_is_rpa(bdaddr, addr_type))
1422		return NULL;
1423
1424	return hci_find_irk_by_rpa(hdev, bdaddr);
1425}
1426
1427static inline int hci_check_conn_params(u16 min, u16 max, u16 latency,
1428					u16 to_multiplier)
1429{
1430	u16 max_latency;
1431
1432	if (min > max || min < 6 || max > 3200)
1433		return -EINVAL;
1434
1435	if (to_multiplier < 10 || to_multiplier > 3200)
1436		return -EINVAL;
1437
1438	if (max >= to_multiplier * 8)
1439		return -EINVAL;
1440
1441	max_latency = (to_multiplier * 4 / max) - 1;
1442	if (latency > 499 || latency > max_latency)
1443		return -EINVAL;
1444
1445	return 0;
1446}
1447
1448int hci_register_cb(struct hci_cb *hcb);
1449int hci_unregister_cb(struct hci_cb *hcb);
1450
1451struct sk_buff *__hci_cmd_sync(struct hci_dev *hdev, u16 opcode, u32 plen,
1452			       const void *param, u32 timeout);
1453struct sk_buff *__hci_cmd_sync_ev(struct hci_dev *hdev, u16 opcode, u32 plen,
1454				  const void *param, u8 event, u32 timeout);
1455int __hci_cmd_send(struct hci_dev *hdev, u16 opcode, u32 plen,
1456		   const void *param);
1457
1458int hci_send_cmd(struct hci_dev *hdev, __u16 opcode, __u32 plen,
1459		 const void *param);
1460void hci_send_acl(struct hci_chan *chan, struct sk_buff *skb, __u16 flags);
1461void hci_send_sco(struct hci_conn *conn, struct sk_buff *skb);
1462
1463void *hci_sent_cmd_data(struct hci_dev *hdev, __u16 opcode);
1464
1465struct sk_buff *hci_cmd_sync(struct hci_dev *hdev, u16 opcode, u32 plen,
1466			     const void *param, u32 timeout);
1467
1468/* ----- HCI Sockets ----- */
1469void hci_send_to_sock(struct hci_dev *hdev, struct sk_buff *skb);
1470void hci_send_to_channel(unsigned short channel, struct sk_buff *skb,
1471			 int flag, struct sock *skip_sk);
1472void hci_send_to_monitor(struct hci_dev *hdev, struct sk_buff *skb);
1473void hci_send_monitor_ctrl_event(struct hci_dev *hdev, u16 event,
1474				 void *data, u16 data_len, ktime_t tstamp,
1475				 int flag, struct sock *skip_sk);
1476
1477void hci_sock_dev_event(struct hci_dev *hdev, int event);
1478
1479#define HCI_MGMT_VAR_LEN	BIT(0)
1480#define HCI_MGMT_NO_HDEV	BIT(1)
1481#define HCI_MGMT_UNTRUSTED	BIT(2)
1482#define HCI_MGMT_UNCONFIGURED	BIT(3)
1483
1484struct hci_mgmt_handler {
1485	int (*func) (struct sock *sk, struct hci_dev *hdev, void *data,
1486		     u16 data_len);
1487	size_t data_len;
1488	unsigned long flags;
1489};
1490
1491struct hci_mgmt_chan {
1492	struct list_head list;
1493	unsigned short channel;
1494	size_t handler_count;
1495	const struct hci_mgmt_handler *handlers;
1496	void (*hdev_init) (struct sock *sk, struct hci_dev *hdev);
1497};
1498
1499int hci_mgmt_chan_register(struct hci_mgmt_chan *c);
1500void hci_mgmt_chan_unregister(struct hci_mgmt_chan *c);
1501
1502/* Management interface */
1503#define DISCOV_TYPE_BREDR		(BIT(BDADDR_BREDR))
1504#define DISCOV_TYPE_LE			(BIT(BDADDR_LE_PUBLIC) | \
1505					 BIT(BDADDR_LE_RANDOM))
1506#define DISCOV_TYPE_INTERLEAVED		(BIT(BDADDR_BREDR) | \
1507					 BIT(BDADDR_LE_PUBLIC) | \
1508					 BIT(BDADDR_LE_RANDOM))
1509
1510/* These LE scan and inquiry parameters were chosen according to LE General
1511 * Discovery Procedure specification.
1512 */
1513#define DISCOV_LE_SCAN_WIN		0x12
1514#define DISCOV_LE_SCAN_INT		0x12
1515#define DISCOV_LE_TIMEOUT		10240	/* msec */
1516#define DISCOV_INTERLEAVED_TIMEOUT	5120	/* msec */
1517#define DISCOV_INTERLEAVED_INQUIRY_LEN	0x04
1518#define DISCOV_BREDR_INQUIRY_LEN	0x08
1519#define DISCOV_LE_RESTART_DELAY		msecs_to_jiffies(200)	/* msec */
1520#define DISCOV_LE_FAST_ADV_INT_MIN     100     /* msec */
1521#define DISCOV_LE_FAST_ADV_INT_MAX     150     /* msec */
1522
1523void mgmt_fill_version_info(void *ver);
1524int mgmt_new_settings(struct hci_dev *hdev);
1525void mgmt_index_added(struct hci_dev *hdev);
1526void mgmt_index_removed(struct hci_dev *hdev);
1527void mgmt_set_powered_failed(struct hci_dev *hdev, int err);
1528void mgmt_power_on(struct hci_dev *hdev, int err);
1529void __mgmt_power_off(struct hci_dev *hdev);
1530void mgmt_new_link_key(struct hci_dev *hdev, struct link_key *key,
1531		       bool persistent);
1532void mgmt_device_connected(struct hci_dev *hdev, struct hci_conn *conn,
1533			   u32 flags, u8 *name, u8 name_len);
1534void mgmt_device_disconnected(struct hci_dev *hdev, bdaddr_t *bdaddr,
1535			      u8 link_type, u8 addr_type, u8 reason,
1536			      bool mgmt_connected);
1537void mgmt_disconnect_failed(struct hci_dev *hdev, bdaddr_t *bdaddr,
1538			    u8 link_type, u8 addr_type, u8 status);
1539void mgmt_connect_failed(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type,
1540			 u8 addr_type, u8 status);
1541void mgmt_pin_code_request(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 secure);
1542void mgmt_pin_code_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
1543				  u8 status);
1544void mgmt_pin_code_neg_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
1545				      u8 status);
1546int mgmt_user_confirm_request(struct hci_dev *hdev, bdaddr_t *bdaddr,
1547			      u8 link_type, u8 addr_type, u32 value,
1548			      u8 confirm_hint);
1549int mgmt_user_confirm_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
1550				     u8 link_type, u8 addr_type, u8 status);
1551int mgmt_user_confirm_neg_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
1552					 u8 link_type, u8 addr_type, u8 status);
1553int mgmt_user_passkey_request(struct hci_dev *hdev, bdaddr_t *bdaddr,
1554			      u8 link_type, u8 addr_type);
1555int mgmt_user_passkey_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
1556				     u8 link_type, u8 addr_type, u8 status);
1557int mgmt_user_passkey_neg_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
1558					 u8 link_type, u8 addr_type, u8 status);
1559int mgmt_user_passkey_notify(struct hci_dev *hdev, bdaddr_t *bdaddr,
1560			     u8 link_type, u8 addr_type, u32 passkey,
1561			     u8 entered);
1562void mgmt_auth_failed(struct hci_conn *conn, u8 status);
1563void mgmt_auth_enable_complete(struct hci_dev *hdev, u8 status);
1564void mgmt_ssp_enable_complete(struct hci_dev *hdev, u8 enable, u8 status);
1565void mgmt_set_class_of_dev_complete(struct hci_dev *hdev, u8 *dev_class,
1566				    u8 status);
1567void mgmt_set_local_name_complete(struct hci_dev *hdev, u8 *name, u8 status);
1568void mgmt_start_discovery_complete(struct hci_dev *hdev, u8 status);
1569void mgmt_stop_discovery_complete(struct hci_dev *hdev, u8 status);
1570void mgmt_device_found(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type,
1571		       u8 addr_type, u8 *dev_class, s8 rssi, u32 flags,
1572		       u8 *eir, u16 eir_len, u8 *scan_rsp, u8 scan_rsp_len);
1573void mgmt_remote_name(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type,
1574		      u8 addr_type, s8 rssi, u8 *name, u8 name_len);
1575void mgmt_discovering(struct hci_dev *hdev, u8 discovering);
1576bool mgmt_powering_down(struct hci_dev *hdev);
1577void mgmt_new_ltk(struct hci_dev *hdev, struct smp_ltk *key, bool persistent);
1578void mgmt_new_irk(struct hci_dev *hdev, struct smp_irk *irk, bool persistent);
1579void mgmt_new_csrk(struct hci_dev *hdev, struct smp_csrk *csrk,
1580		   bool persistent);
1581void mgmt_new_conn_param(struct hci_dev *hdev, bdaddr_t *bdaddr,
1582			 u8 bdaddr_type, u8 store_hint, u16 min_interval,
1583			 u16 max_interval, u16 latency, u16 timeout);
1584void mgmt_smp_complete(struct hci_conn *conn, bool complete);
1585bool mgmt_get_connectable(struct hci_dev *hdev);
1586void mgmt_set_connectable_complete(struct hci_dev *hdev, u8 status);
1587void mgmt_set_discoverable_complete(struct hci_dev *hdev, u8 status);
1588u8 mgmt_get_adv_discov_flags(struct hci_dev *hdev);
1589void mgmt_advertising_added(struct sock *sk, struct hci_dev *hdev,
1590			    u8 instance);
1591void mgmt_advertising_removed(struct sock *sk, struct hci_dev *hdev,
1592			      u8 instance);
1593int mgmt_phy_configuration_changed(struct hci_dev *hdev, struct sock *skip);
1594
1595u8 hci_le_conn_update(struct hci_conn *conn, u16 min, u16 max, u16 latency,
1596		      u16 to_multiplier);
1597void hci_le_start_enc(struct hci_conn *conn, __le16 ediv, __le64 rand,
1598		      __u8 ltk[16], __u8 key_size);
1599
1600void hci_copy_identity_address(struct hci_dev *hdev, bdaddr_t *bdaddr,
1601			       u8 *bdaddr_type);
1602
1603#define SCO_AIRMODE_MASK       0x0003
1604#define SCO_AIRMODE_CVSD       0x0000
1605#define SCO_AIRMODE_TRANSP     0x0003
1606
1607#endif /* __HCI_CORE_H */