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