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