include/net/bluetooth/hci_core.h



04fafe4ed76f
1da177e4c3f4
2d0a03460a8a
1da177e4c3f4


04fafe4ed76f


1da177e4c3f4

04fafe4ed76f

1da177e4c3f4


a6b7a407865a
1da177e4c3f4


5e59b791c356


1da177e4c3f4
1da177e4c3f4


1ebb92521d0b
1da177e4c3f4
41a96212b3b7
1da177e4c3f4


70f23020e6d8
1da177e4c3f4


70f23020e6d8
1da177e4c3f4
70f23020e6d8
1da177e4c3f4


fcd89c09a59a
1da177e4c3f4

73d80deb7bdf


f03585689fdf


2aeb9a1ae0e3


1aff6f09491f
2aeb9a1ae0e3

34918cd71b95


55ed8ca10f35


34918cd71b95

55ed8ca10f35

2763eda6ccaf


76c8686f8871


cd4c53919ed5
1da177e4c3f4


c13854cef475
943da25d95c7
1da177e4c3f4
1f6c6378c59f
80a1e1dbf62a
a9de9248064b
1aff6f09491f

1da177e4c3f4
971e3a4bbcbf
a9de9248064b
333140b57fa7
1143e5a6d4d6

d5859e22cd40
1143e5a6d4d6
d5859e22cd40
1da177e4c3f4
17fa4b9dff72
1da177e4c3f4

5b7f990927fe
1da177e4c3f4


04837f6447c7


928abaa77750


9f61656a60c9

1da177e4c3f4


6ed58ec520ad
1da177e4c3f4


6ed58ec520ad
1da177e4c3f4

6ed58ec520ad
1da177e4c3f4
1da177e4c3f4

6ed58ec520ad
1da177e4c3f4
f48fd9c8cd74

ab81cbf99c88
3243553fdc10
ab81cbf99c88
16ab91ab4828

ab81cbf99c88
6bd32326cdaa
1da177e4c3f4


cd4c53919ed5
1da177e4c3f4
a6a67efd7088
1da177e4c3f4


a5040efa2017

1da177e4c3f4
2e58ef3e11d0

1da177e4c3f4

ea4bd8ba804d
1da177e4c3f4
2aeb9a1ae0e3

55ed8ca10f35

2763eda6ccaf

76c8686f8871
3581508571b5
76c8686f8871
1da177e4c3f4


70f23020e6d8
1da177e4c3f4
ca325f698996

a91f2e396f5b

1da177e4c3f4
611b30f74b5d

70f23020e6d8
1da177e4c3f4


adc4266d87ba
adc4266d87ba

5a9d0a3ffbc4
adc4266d87ba


13d39315c22b
adc4266d87ba


726b4ffcaa45
adc4266d87ba


04837f6447c7
03b555e119de


adc4266d87ba
04837f6447c7
1da177e4c3f4
73d80deb7bdf
1da177e4c3f4
04837f6447c7

9f61656a60c9
04837f6447c7
f3784d834c71

b219e3ac6618

9eba32b86d17
b219e3ac6618
1da177e4c3f4


1da177e4c3f4

e9a416b5ce0c


1da177e4c3f4

73d80deb7bdf


1da177e4c3f4


70f23020e6d8

1da177e4c3f4


a02cec2155fb
1da177e4c3f4


5a9d0a3ffbc4

1da177e4c3f4


19f8def031bf
1da177e4c3f4
04837f6447c7

e73439d8c0e4
d26a23454813
1da177e4c3f4


fcd89c09a59a

1da177e4c3f4
fcd89c09a59a


1da177e4c3f4
fcd89c09a59a

1da177e4c3f4


fcd89c09a59a

1da177e4c3f4
fcd89c09a59a


1da177e4c3f4
fcd89c09a59a

1da177e4c3f4

52087a792c15


1da177e4c3f4
adc4266d87ba
1da177e4c3f4


adc4266d87ba
1da177e4c3f4


4c67bc74f016
adc4266d87ba
4c67bc74f016


73d80deb7bdf


4c67bc74f016
1da177e4c3f4

b6a0dc822497
e73439d8c0e4
1da177e4c3f4

a9de9248064b


1da177e4c3f4
73d80deb7bdf


5a9d0a3ffbc4

e7c29cb16c83
b3b1b061583b
0684e5f9fb9e
1da177e4c3f4
8c1b235594fb
1da177e4c3f4
14b12d0b98f8
04837f6447c7
1da177e4c3f4
9eba32b86d17


1da177e4c3f4


04837f6447c7
1da177e4c3f4


04837f6447c7
454d48ff70c2
04837f6447c7
6ac59344ef25
052b30b0a8ee
6ac59344ef25
052b30b0a8ee
5a9d0a3ffbc4
6ac59344ef25
5a9d0a3ffbc4

04837f6447c7
5a9d0a3ffbc4
04837f6447c7
1da177e4c3f4


1da177e4c3f4


1d58996da6a8


1da177e4c3f4


1d58996da6a8


1da177e4c3f4


59735631d24e
1da177e4c3f4


40be492fe4fa
1da177e4c3f4

f03585689fdf

b2a66aad8620

f03585689fdf
2aeb9a1ae0e3

55ed8ca10f35

d25e28abe58d

75d262c2ad92


726b4ffcaa45
55ed8ca10f35

2763eda6ccaf


3581508571b5
76c8686f8871


ab81cbf99c88

1da177e4c3f4

76bca88012e1
ef222013fc8c
998115108638
ef222013fc8c
0ac7e7002c4d
ce242970f093

a67e899cf38a
b219e3ac6618

1da177e4c3f4
a91f2e396f5b
1da177e4c3f4

04837f6447c7


5b7f990927fe
769be974d0c7
e702112ff68a
6ed58ec520ad
1da177e4c3f4
eead27da60df


1da177e4c3f4

8c1b235594fb
1da177e4c3f4


5a9d0a3ffbc4

1da177e4c3f4
2950f21acb0f

5a9d0a3ffbc4

1da177e4c3f4
5a9d0a3ffbc4

1da177e4c3f4

5a9d0a3ffbc4

1da177e4c3f4


8c1b235594fb
1da177e4c3f4


e9a416b5ce0c


1da177e4c3f4

2950f21acb0f
1da177e4c3f4

9f5a0d7bf079
1da177e4c3f4


2950f21acb0f
1da177e4c3f4


2950f21acb0f


e9a416b5ce0c


1da177e4c3f4


8c1b235594fb


1da177e4c3f4

8c1b235594fb

1da177e4c3f4

8c1b235594fb

e9a416b5ce0c


1da177e4c3f4

5a9d0a3ffbc4

1da177e4c3f4


8c1b235594fb

1da177e4c3f4

8c1b235594fb

e9a416b5ce0c


1da177e4c3f4


5a9d0a3ffbc4

1da177e4c3f4


8c1b235594fb
1da177e4c3f4


8c1b235594fb


1da177e4c3f4


8c1b235594fb

1da177e4c3f4


5a9d0a3ffbc4

1da177e4c3f4


435fef20acfc


88167aed0d2e


9719f8afce34
1da177e4c3f4


8c1b235594fb

1da177e4c3f4


5a9d0a3ffbc4

1da177e4c3f4


a9de9248064b
73d80deb7bdf
0d861d8b8edd
1da177e4c3f4
a9de9248064b
1da177e4c3f4


eec8d2bcc841

1da177e4c3f4
0381101fd6a7

744cf19eadcf


a5c296832b4f
744cf19eadcf

c35938b2f565
744cf19eadcf


0381101fd6a7
1da177e4c3f4


c02178d22b3e
1da177e4c3f4


a6a67efd7088

1da177e4c3f4
23bb57633df9
1da177e4c3f4
2ce603ebe1f1

a7a595f675f1


2519a1fc8249
023d50498d04
2519a1fc8249
1da177e4c3f4

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988

  
/*
   BlueZ - Bluetooth protocol stack for Linux
   Copyright (c) 2000-2001, 2010, Code Aurora Forum. All rights reserved.

   Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License version 2 as
   published by the Free Software Foundation;

   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
   OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
   IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
   CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
   WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
   ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
   OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

   ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
   COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
   SOFTWARE IS DISCLAIMED.
*/

#ifndef __HCI_CORE_H
#define __HCI_CORE_H

#include <linux/interrupt.h>
#include <net/bluetooth/hci.h>

/* HCI upper protocols */
#define HCI_PROTO_L2CAP	0
#define HCI_PROTO_SCO	1

/* HCI priority */
#define HCI_PRIO_MAX	7

/* HCI Core structures */
struct inquiry_data {
	bdaddr_t	bdaddr;
	__u8		pscan_rep_mode;
	__u8		pscan_period_mode;
	__u8		pscan_mode;
	__u8		dev_class[3];
	__le16		clock_offset;
	__s8		rssi;
	__u8		ssp_mode;
};

struct inquiry_entry {
	struct inquiry_entry	*next;
	__u32			timestamp;
	struct inquiry_data	data;
};

struct inquiry_cache {
	spinlock_t		lock;
	__u32			timestamp;
	struct inquiry_entry	*list;
};

struct hci_conn_hash {
	struct list_head list;
	spinlock_t       lock;
	unsigned int     acl_num;
	unsigned int     sco_num;
	unsigned int     le_num;
};

struct hci_chan_hash {
	struct list_head list;
	spinlock_t       lock;
	unsigned int     num;
};

struct bdaddr_list {
	struct list_head list;
	bdaddr_t bdaddr;
};

struct bt_uuid {
	struct list_head list;
	u8 uuid[16];
	u8 svc_hint;
};

struct key_master_id {
	__le16 ediv;
	u8 rand[8];
} __packed;

struct link_key_data {
	bdaddr_t bdaddr;
	u8 type;
	u8 val[16];
	u8 pin_len;
	u8 dlen;
	u8 data[0];
} __packed;

struct link_key {
	struct list_head list;
	bdaddr_t bdaddr;
	u8 type;
	u8 val[16];
	u8 pin_len;
	u8 dlen;
	u8 data[0];
};

struct oob_data {
	struct list_head list;
	bdaddr_t bdaddr;
	u8 hash[16];
	u8 randomizer[16];
};

struct adv_entry {
	struct list_head list;
	bdaddr_t bdaddr;
	u8 bdaddr_type;
};

#define NUM_REASSEMBLY 4
struct hci_dev {
	struct list_head list;
	spinlock_t	lock;
	atomic_t	refcnt;

	char		name[8];
	unsigned long	flags;
	__u16		id;
	__u8		bus;
	__u8		dev_type;
	bdaddr_t	bdaddr;
	__u8		dev_name[HCI_MAX_NAME_LENGTH];
	__u8		eir[HCI_MAX_EIR_LENGTH];
	__u8		dev_class[3];
	__u8		major_class;
	__u8		minor_class;
	__u8		features[8];
	__u8		extfeatures[8];
	__u8		commands[64];
	__u8		ssp_mode;
	__u8		hci_ver;
	__u16		hci_rev;
	__u8		lmp_ver;
	__u16		manufacturer;
	__le16		lmp_subver;
	__u16		voice_setting;
	__u8		io_capability;

	__u16		pkt_type;
	__u16		esco_type;
	__u16		link_policy;
	__u16		link_mode;

	__u32		idle_timeout;
	__u16		sniff_min_interval;
	__u16		sniff_max_interval;

	__u8		amp_status;
	__u32		amp_total_bw;
	__u32		amp_max_bw;
	__u32		amp_min_latency;
	__u32		amp_max_pdu;
	__u8		amp_type;
	__u16		amp_pal_cap;
	__u16		amp_assoc_size;
	__u32		amp_max_flush_to;
	__u32		amp_be_flush_to;

	unsigned int	auto_accept_delay;

	unsigned long	quirks;

	atomic_t	cmd_cnt;
	unsigned int	acl_cnt;
	unsigned int	sco_cnt;
	unsigned int	le_cnt;

	unsigned int	acl_mtu;
	unsigned int	sco_mtu;
	unsigned int	le_mtu;
	unsigned int	acl_pkts;
	unsigned int	sco_pkts;
	unsigned int	le_pkts;

	unsigned long	acl_last_tx;
	unsigned long	sco_last_tx;
	unsigned long	le_last_tx;

	struct workqueue_struct	*workqueue;

	struct work_struct	power_on;
	struct delayed_work	power_off;

	__u16			discov_timeout;
	struct delayed_work	discov_off;

	struct timer_list	cmd_timer;
	struct tasklet_struct	cmd_task;
	struct tasklet_struct	rx_task;
	struct tasklet_struct	tx_task;

	struct sk_buff_head	rx_q;
	struct sk_buff_head	raw_q;
	struct sk_buff_head	cmd_q;

	struct sk_buff		*sent_cmd;
	struct sk_buff		*reassembly[NUM_REASSEMBLY];

	struct mutex		req_lock;
	wait_queue_head_t	req_wait_q;
	__u32			req_status;
	__u32			req_result;

	__u16			init_last_cmd;

	struct list_head	mgmt_pending;

	struct inquiry_cache	inq_cache;
	struct hci_conn_hash	conn_hash;
	struct list_head	blacklist;

	struct list_head	uuids;

	struct list_head	link_keys;

	struct list_head	remote_oob_data;

	struct list_head	adv_entries;
	struct timer_list	adv_timer;

	struct hci_dev_stats	stat;

	struct sk_buff_head	driver_init;

	void			*driver_data;
	void			*core_data;

	atomic_t		promisc;

	struct dentry		*debugfs;

	struct device		*parent;
	struct device		dev;

	struct rfkill		*rfkill;

	struct module		*owner;

	int (*open)(struct hci_dev *hdev);
	int (*close)(struct hci_dev *hdev);
	int (*flush)(struct hci_dev *hdev);
	int (*send)(struct sk_buff *skb);
	void (*destruct)(struct hci_dev *hdev);
	void (*notify)(struct hci_dev *hdev, unsigned int evt);
	int (*ioctl)(struct hci_dev *hdev, unsigned int cmd, unsigned long arg);
};

struct hci_conn {
	struct list_head list;

	atomic_t	refcnt;

	bdaddr_t	dst;
	__u8		dst_type;
	__u16		handle;
	__u16		state;
	__u8		mode;
	__u8		type;
	__u8		out;
	__u8		attempt;
	__u8		dev_class[3];
	__u8		features[8];
	__u8		ssp_mode;
	__u16		interval;
	__u16		pkt_type;
	__u16		link_policy;
	__u32		link_mode;
	__u8		key_type;
	__u8		auth_type;
	__u8		sec_level;
	__u8		pending_sec_level;
	__u8		pin_length;
	__u8		enc_key_size;
	__u8		io_capability;
	__u8		power_save;
	__u16		disc_timeout;
	unsigned long	pend;

	__u8		remote_cap;
	__u8		remote_oob;
	__u8		remote_auth;

	unsigned int	sent;

	struct sk_buff_head data_q;
	struct hci_chan_hash chan_hash;

	struct timer_list disc_timer;
	struct timer_list idle_timer;
	struct timer_list auto_accept_timer;

	struct work_struct work_add;
	struct work_struct work_del;

	struct device	dev;
	atomic_t	devref;

	struct hci_dev	*hdev;
	void		*l2cap_data;
	void		*sco_data;

	struct hci_conn	*link;

	void (*connect_cfm_cb)	(struct hci_conn *conn, u8 status);
	void (*security_cfm_cb)	(struct hci_conn *conn, u8 status);
	void (*disconn_cfm_cb)	(struct hci_conn *conn, u8 reason);
};

struct hci_chan {
	struct list_head list;

	struct hci_conn *conn;
	struct sk_buff_head data_q;
	unsigned int	sent;
};

extern struct hci_proto *hci_proto[];
extern struct list_head hci_dev_list;
extern struct list_head hci_cb_list;
extern rwlock_t hci_dev_list_lock;
extern rwlock_t hci_cb_list_lock;

/* ----- Inquiry cache ----- */
#define INQUIRY_CACHE_AGE_MAX   (HZ*30)   /* 30 seconds */
#define INQUIRY_ENTRY_AGE_MAX   (HZ*60)   /* 60 seconds */

#define inquiry_cache_lock(c)		spin_lock(&c->lock)
#define inquiry_cache_unlock(c)		spin_unlock(&c->lock)
#define inquiry_cache_lock_bh(c)	spin_lock_bh(&c->lock)
#define inquiry_cache_unlock_bh(c)	spin_unlock_bh(&c->lock)

static inline void inquiry_cache_init(struct hci_dev *hdev)
{
	struct inquiry_cache *c = &hdev->inq_cache;
	spin_lock_init(&c->lock);
	c->list = NULL;
}

static inline int inquiry_cache_empty(struct hci_dev *hdev)
{
	struct inquiry_cache *c = &hdev->inq_cache;
	return c->list == NULL;
}

static inline long inquiry_cache_age(struct hci_dev *hdev)
{
	struct inquiry_cache *c = &hdev->inq_cache;
	return jiffies - c->timestamp;
}

static inline long inquiry_entry_age(struct inquiry_entry *e)
{
	return jiffies - e->timestamp;
}

struct inquiry_entry *hci_inquiry_cache_lookup(struct hci_dev *hdev,
							bdaddr_t *bdaddr);
void hci_inquiry_cache_update(struct hci_dev *hdev, struct inquiry_data *data);

/* ----- HCI Connections ----- */
enum {
	HCI_CONN_AUTH_PEND,
	HCI_CONN_REAUTH_PEND,
	HCI_CONN_ENCRYPT_PEND,
	HCI_CONN_RSWITCH_PEND,
	HCI_CONN_MODE_CHANGE_PEND,
	HCI_CONN_SCO_SETUP_PEND,
	HCI_CONN_LE_SMP_PEND,
};

static inline void hci_conn_hash_init(struct hci_dev *hdev)
{
	struct hci_conn_hash *h = &hdev->conn_hash;
	INIT_LIST_HEAD(&h->list);
	spin_lock_init(&h->lock);
	h->acl_num = 0;
	h->sco_num = 0;
}

static inline void hci_conn_hash_add(struct hci_dev *hdev, struct hci_conn *c)
{
	struct hci_conn_hash *h = &hdev->conn_hash;
	list_add(&c->list, &h->list);
	switch (c->type) {
	case ACL_LINK:
		h->acl_num++;
		break;
	case LE_LINK:
		h->le_num++;
		break;
	case SCO_LINK:
	case ESCO_LINK:
		h->sco_num++;
		break;
	}
}

static inline void hci_conn_hash_del(struct hci_dev *hdev, struct hci_conn *c)
{
	struct hci_conn_hash *h = &hdev->conn_hash;
	list_del(&c->list);
	switch (c->type) {
	case ACL_LINK:
		h->acl_num--;
		break;
	case LE_LINK:
		h->le_num--;
		break;
	case SCO_LINK:
	case ESCO_LINK:
		h->sco_num--;
		break;
	}
}

static inline unsigned int hci_conn_num(struct hci_dev *hdev, __u8 type)
{
	struct hci_conn_hash *h = &hdev->conn_hash;
	switch (type) {
	case ACL_LINK:
		return h->acl_num;
	case LE_LINK:
		return h->le_num;
	case SCO_LINK:
	case ESCO_LINK:
		return h->sco_num;
	default:
		return 0;
	}
}

static inline struct hci_conn *hci_conn_hash_lookup_handle(struct hci_dev *hdev,
								__u16 handle)
{
	struct hci_conn_hash *h = &hdev->conn_hash;
	struct list_head *p;
	struct hci_conn  *c;

	list_for_each(p, &h->list) {
		c = list_entry(p, struct hci_conn, list);
		if (c->handle == handle)
			return c;
	}
	return NULL;
}

static inline struct hci_conn *hci_conn_hash_lookup_ba(struct hci_dev *hdev,
							__u8 type, bdaddr_t *ba)
{
	struct hci_conn_hash *h = &hdev->conn_hash;
	struct list_head *p;
	struct hci_conn  *c;

	list_for_each(p, &h->list) {
		c = list_entry(p, struct hci_conn, list);
		if (c->type == type && !bacmp(&c->dst, ba))
			return c;
	}
	return NULL;
}

static inline struct hci_conn *hci_conn_hash_lookup_state(struct hci_dev *hdev,
							__u8 type, __u16 state)
{
	struct hci_conn_hash *h = &hdev->conn_hash;
	struct list_head *p;
	struct hci_conn  *c;

	list_for_each(p, &h->list) {
		c = list_entry(p, struct hci_conn, list);
		if (c->type == type && c->state == state)
			return c;
	}
	return NULL;
}

static inline void hci_chan_hash_init(struct hci_conn *c)
{
	struct hci_chan_hash *h = &c->chan_hash;
	INIT_LIST_HEAD(&h->list);
	spin_lock_init(&h->lock);
	h->num = 0;
}

static inline void hci_chan_hash_add(struct hci_conn *c, struct hci_chan *chan)
{
	struct hci_chan_hash *h = &c->chan_hash;
	list_add(&chan->list, &h->list);
	h->num++;
}

static inline void hci_chan_hash_del(struct hci_conn *c, struct hci_chan *chan)
{
	struct hci_chan_hash *h = &c->chan_hash;
	list_del(&chan->list);
	h->num--;
}

void hci_acl_connect(struct hci_conn *conn);
void hci_acl_disconn(struct hci_conn *conn, __u8 reason);
void hci_add_sco(struct hci_conn *conn, __u16 handle);
void hci_setup_sync(struct hci_conn *conn, __u16 handle);
void hci_sco_setup(struct hci_conn *conn, __u8 status);

struct hci_conn *hci_conn_add(struct hci_dev *hdev, int type, bdaddr_t *dst);
int hci_conn_del(struct hci_conn *conn);
void hci_conn_hash_flush(struct hci_dev *hdev);
void hci_conn_check_pending(struct hci_dev *hdev);

struct hci_chan *hci_chan_create(struct hci_conn *conn);