]> git.ipfire.org Git - thirdparty/kernel/stable.git/blame - include/net/bluetooth/hci_core.h
projects / thirdparty / kernel / stable.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge tag 'kvm-x86-docs-6.7' of https://github.com/kvm-x86/linux into HEAD
[thirdparty/kernel/stable.git] / include / net / bluetooth / hci_core.h
CommitLineData
04fafe4e 1/*
1da177e4 2 BlueZ - Bluetooth protocol stack for Linux
2d0a0346 3 Copyright (c) 2000-2001, 2010, Code Aurora Forum. All rights reserved.
0fe8c8d0 4 Copyright 2023 NXP
1da177e4
LT		 5
6 Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License version 2 as
10 published by the Free Software Foundation;
11
12 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
13 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
14 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
15 IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
04fafe4e
RS		 16 CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
17 WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
18 ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
1da177e4
LT		 19 OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
20
04fafe4e
RS		 21 ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
22 COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
1da177e4
LT		 23 SOFTWARE IS DISCLAIMED.
24*/
25
26#ifndef __HCI_CORE_H
27#define __HCI_CORE_H
28
e5e1e7fd 29#include <linux/idr.h>
6d5d2ee6 30#include <linux/leds.h>
b2d09103
IM		 31#include <linux/rculist.h>
32
1da177e4 33#include <net/bluetooth/hci.h>
6a98e383 34#include <net/bluetooth/hci_sync.h>
f49daa81 35#include <net/bluetooth/hci_sock.h>
9695ef87 36#include <net/bluetooth/coredump.h>
1da177e4 37
5e59b791
LAD		 38/* HCI priority */
39#define HCI_PRIO_MAX 7
40
103a2f32
II		 41/* HCI maximum id value */
42#define HCI_MAX_ID 10000
43
1da177e4 44/* HCI Core structures */
1da177e4
LT		 45struct inquiry_data {
46 bdaddr_t bdaddr;
47 __u8 pscan_rep_mode;
48 __u8 pscan_period_mode;
49 __u8 pscan_mode;
50 __u8 dev_class[3];
1ebb9252 51 __le16 clock_offset;
1da177e4 52 __s8 rssi;
41a96212 53 __u8 ssp_mode;
1da177e4
LT		 54};
55
56struct inquiry_entry {
561aafbc
JH		 57 struct list_head all; /* inq_cache.all */
58 struct list_head list; /* unknown or resolve */
59 enum {
60 NAME_NOT_KNOWN,
61 NAME_NEEDED,
62 NAME_PENDING,
63 NAME_KNOWN,
64 } name_state;
1da177e4
LT		 65 __u32 timestamp;
66 struct inquiry_data data;
67};
68
30883512 69struct discovery_state {
f64b993f 70 int type;
ff9ef578
JH		 71 enum {
72 DISCOVERY_STOPPED,
73 DISCOVERY_STARTING,
343f935b 74 DISCOVERY_FINDING,
30dc78e1 75 DISCOVERY_RESOLVING,
ff9ef578
JH		 76 DISCOVERY_STOPPING,
77 } state;
c3c7ea65 78 struct list_head all; /* All devices found during inquiry */
f64b993f
GP		 79 struct list_head unknown; /* Name state not known */
80 struct list_head resolve; /* Name needs to be resolved */
81 __u32 timestamp;
b9a6328f
JH		 82 bdaddr_t last_adv_addr;
83 u8 last_adv_addr_type;
ff5cd29f 84 s8 last_adv_rssi;
c70a7e4c 85 u32 last_adv_flags;
db08722f 86 u8 last_adv_data[HCI_MAX_EXT_AD_LENGTH];
b9a6328f 87 u8 last_adv_data_len;
da25cf6a 88 bool report_invalid_rssi;
82f8b651 89 bool result_filtering;
78b781ca 90 bool limited;
37eab042
JP		 91 s8 rssi;
92 u16 uuid_count;
93 u8 (*uuids)[16];
2d28cfe7
JP		 94 unsigned long scan_start;
95 unsigned long scan_duration;
dbf6811a 96 unsigned long name_resolve_timeout;
1da177e4
LT		 97};
98
9952d90e
APS		 99#define SUSPEND_NOTIFIER_TIMEOUT msecs_to_jiffies(2000) /* 2 seconds */
100
101enum suspend_tasks {
4867bd00
APS		 102 SUSPEND_PAUSE_DISCOVERY,
103 SUSPEND_UNPAUSE_DISCOVERY,
104
105 SUSPEND_PAUSE_ADVERTISING,
106 SUSPEND_UNPAUSE_ADVERTISING,
107
4f40afc6
APS		 108 SUSPEND_SCAN_DISABLE,
109 SUSPEND_SCAN_ENABLE,
110 SUSPEND_DISCONNECTING,
111
9952d90e
APS		 112 SUSPEND_POWERING_DOWN,
113
114 SUSPEND_PREPARE_NOTIFIER,
bf6a4e30
HC		 115
116 SUSPEND_SET_ADV_FILTER,
9952d90e
APS		 117 __SUSPEND_NUM_TASKS
118};
119
120enum suspended_state {
121 BT_RUNNING = 0,
4f40afc6 122 BT_SUSPEND_DISCONNECT,
0d2c9825 123 BT_SUSPEND_CONFIGURE_WAKE,
9952d90e
APS		 124};
125
1da177e4
LT		 126struct hci_conn_hash {
127 struct list_head list;
1da177e4 128 unsigned int acl_num;
bd1eb66b 129 unsigned int amp_num;
1da177e4 130 unsigned int sco_num;
26afbd82 131 unsigned int iso_num;
fcd89c09 132 unsigned int le_num;
39bc74ca 133 unsigned int le_num_peripheral;
1da177e4
LT		 134};
135
f0358568
JH		 136struct bdaddr_list {
137 struct list_head list;
138 bdaddr_t bdaddr;
b9ee0a78 139 u8 bdaddr_type;
f0358568 140};
2aeb9a1a 141
8961987f
K		 142struct codec_list {
143 struct list_head list;
144 u8 id;
145 __u16 cid;
146 __u16 vid;
147 u8 transport;
148 u8 num_caps;
149 u32 len;
150 struct hci_codec_caps caps[];
151};
152
b950aa88
AN		 153struct bdaddr_list_with_irk {
154 struct list_head list;
155 bdaddr_t bdaddr;
156 u8 bdaddr_type;
157 u8 peer_irk[16];
158 u8 local_irk[16];
159};
160
e1cff700 161/* Bitmask of connection flags */
7a92906f 162enum hci_conn_flags {
e1cff700
LT		 163 HCI_CONN_FLAG_REMOTE_WAKEUP = 1,
164 HCI_CONN_FLAG_DEVICE_PRIVACY = 2,
fe92ee64 165};
e1cff700 166typedef u8 hci_conn_flags_t;
fe92ee64
LAD		 167
168struct bdaddr_list_with_flags {
169 struct list_head list;
170 bdaddr_t bdaddr;
171 u8 bdaddr_type;
e1cff700 172 hci_conn_flags_t flags;
fe92ee64 173};
7a92906f 174
2aeb9a1a
JH		 175struct bt_uuid {
176 struct list_head list;
177 u8 uuid[16];
83be8eca 178 u8 size;
1aff6f09 179 u8 svc_hint;
2aeb9a1a
JH		 180};
181
600a8749
AM		 182struct blocked_key {
183 struct list_head list;
184 struct rcu_head rcu;
185 u8 type;
186 u8 val[16];
187};
188
7ee4ea36
MH		 189struct smp_csrk {
190 bdaddr_t bdaddr;
191 u8 bdaddr_type;
4cd3928a 192 u8 type;
7ee4ea36
MH		 193 u8 val[16];
194};
195
b899efaf
VCG		 196struct smp_ltk {
197 struct list_head list;
970d0f1b 198 struct rcu_head rcu;
b899efaf
VCG		 199 bdaddr_t bdaddr;
200 u8 bdaddr_type;
201 u8 authenticated;
202 u8 type;
203 u8 enc_size;
204 __le16 ediv;
fe39c7b2 205 __le64 rand;
b899efaf 206 u8 val[16];
03c515d7 207};
b899efaf 208
970c4e46
JH		 209struct smp_irk {
210 struct list_head list;
adae20cb 211 struct rcu_head rcu;
970c4e46
JH		 212 bdaddr_t rpa;
213 bdaddr_t bdaddr;
214 u8 addr_type;
215 u8 val[16];
216};
217
55ed8ca1
JH		 218struct link_key {
219 struct list_head list;
0378b597 220 struct rcu_head rcu;
55ed8ca1
JH		 221 bdaddr_t bdaddr;
222 u8 type;
9b3b4460 223 u8 val[HCI_LINK_KEY_SIZE];
55ed8ca1
JH		 224 u8 pin_len;
225};
226
2763eda6
SJ		 227struct oob_data {
228 struct list_head list;
229 bdaddr_t bdaddr;
6928a924 230 u8 bdaddr_type;
f7697b16 231 u8 present;
519ca9d0 232 u8 hash192[16];
38da1703 233 u8 rand192[16];
519ca9d0 234 u8 hash256[16];
38da1703 235 u8 rand256[16];
2763eda6
SJ		 236};
237
203fea01 238struct adv_info {
d2609b34 239 struct list_head list;
eca0ae4a
LAD		 240 bool enabled;
241 bool pending;
242 bool periodic;
b338d917 243 __u8 mesh;
203fea01
AU		 244 __u8 instance;
245 __u32 flags;
912098a6 246 __u16 timeout;
5d900e46 247 __u16 remaining_time;
d2609b34 248 __u16 duration;
203fea01 249 __u16 adv_data_len;
c9ed0a70 250 __u8 adv_data[HCI_MAX_EXT_AD_LENGTH];
34a718bc 251 bool adv_data_changed;
203fea01 252 __u16 scan_rsp_len;
c9ed0a70 253 __u8 scan_rsp_data[HCI_MAX_EXT_AD_LENGTH];
34a718bc 254 bool scan_rsp_changed;
eca0ae4a
LAD		 255 __u16 per_adv_data_len;
256 __u8 per_adv_data[HCI_MAX_PER_AD_LENGTH];
de181e88 257 __s8 tx_power;
9bf9f4b6
DW		 258 __u32 min_interval;
259 __u32 max_interval;
a73c046a
JK		 260 bdaddr_t random_addr;
261 bool rpa_expired;
262 struct delayed_work rpa_expired_cb;
203fea01
AU		 263};
264
db25be66 265#define HCI_MAX_ADV_INSTANCES 5
d2609b34
FG		 266#define HCI_DEFAULT_ADV_DURATION 2
267
12410572
DW		 268#define HCI_ADV_TX_POWER_NO_PREFERENCE 0x7F
269
34a718bc
LAD		 270#define DATA_CMP(_d1, _l1, _d2, _l2) \
271 (_l1 == _l2 ? memcmp(_d1, _d2, _l1) : _l1 - _l2)
272
273#define ADV_DATA_CMP(_adv, _data, _len) \
274 DATA_CMP((_adv)->adv_data, (_adv)->adv_data_len, _data, _len)
275
276#define SCAN_RSP_CMP(_adv, _data, _len) \
277 DATA_CMP((_adv)->scan_rsp_data, (_adv)->scan_rsp_len, _data, _len)
278
3368aa35
MM		 279struct monitored_device {
280 struct list_head list;
281
282 bdaddr_t bdaddr;
283 __u8 addr_type;
284 __u16 handle;
285 bool notified;
286};
287
e5e1e7fd
MC		 288struct adv_pattern {
289 struct list_head list;
290 __u8 ad_type;
291 __u8 offset;
292 __u8 length;
db08722f 293 __u8 value[HCI_MAX_EXT_AD_LENGTH];
e5e1e7fd
MC		 294};
295
b4a221ea
AP		 296struct adv_rssi_thresholds {
297 __s8 low_threshold;
298 __s8 high_threshold;
299 __u16 low_threshold_timeout;
300 __u16 high_threshold_timeout;
301 __u8 sampling_period;
302};
303
e5e1e7fd
MC		 304struct adv_monitor {
305 struct list_head patterns;
b4a221ea 306 struct adv_rssi_thresholds rssi;
e5e1e7fd 307 __u16 handle;
a2a4dedf
AP		 308
309 enum {
310 ADV_MONITOR_STATE_NOT_REGISTERED,
311 ADV_MONITOR_STATE_REGISTERED,
312 ADV_MONITOR_STATE_OFFLOADED
313 } state;
e5e1e7fd
MC		 314};
315
316#define HCI_MIN_ADV_MONITOR_HANDLE 1
a2a4dedf 317#define HCI_MAX_ADV_MONITOR_NUM_HANDLES 32
e5e1e7fd 318#define HCI_MAX_ADV_MONITOR_NUM_PATTERNS 16
a2a4dedf
AP		 319#define HCI_ADV_MONITOR_EXT_NONE 1
320#define HCI_ADV_MONITOR_EXT_MSFT 2
e5e1e7fd 321
490c5bab
JH		 322#define HCI_MAX_SHORT_NAME_LENGTH 10
323
d5ebaa7c 324#define HCI_CONN_HANDLE_MAX 0x0eff
9f78191c 325#define HCI_CONN_HANDLE_UNSET(_handle) (_handle > HCI_CONN_HANDLE_MAX)
d5ebaa7c 326
d5bb334a
MH		 327/* Min encryption key size to match with SMP */
328#define HCI_MIN_ENC_KEY_SIZE 7
329
d6bfd59c
JH		 330/* Default LE RPA expiry time, 15 minutes */
331#define HCI_DEFAULT_RPA_TIMEOUT (15 * 60)
332
31ad1691
AK		 333/* Default min/max age of connection information (1s/3s) */
334#define DEFAULT_CONN_INFO_MIN_AGE 1000
335#define DEFAULT_CONN_INFO_MAX_AGE 3000
302975cb
SRK		 336/* Default authenticated payload timeout 30s */
337#define DEFAULT_AUTH_PAYLOAD_TIMEOUT 0x0bb8
31ad1691 338
903e4541
AE		 339struct amp_assoc {
340 __u16 len;
341 __u16 offset;
93c284ee
AE		 342 __u16 rem_len;
343 __u16 len_so_far;
903e4541
AE		 344 __u8 data[HCI_MAX_AMP_ASSOC_SIZE];
345};
346
d2c5d77f 347#define HCI_MAX_PAGES 3
cad718ed 348
1da177e4
LT		 349struct hci_dev {
350 struct list_head list;
09fd0de5 351 struct mutex lock;
1da177e4 352
dcda1657 353 const char *name;
1da177e4
LT		 354 unsigned long flags;
355 __u16 id;
c13854ce 356 __u8 bus;
943da25d 357 __u8 dev_type;
1da177e4 358 bdaddr_t bdaddr;
e30d3f5f 359 bdaddr_t setup_addr;
24c457e2 360 bdaddr_t public_addr;
7a4cd51d 361 bdaddr_t random_addr;
d13eafce 362 bdaddr_t static_addr;
56ed2cb8 363 __u8 adv_addr_type;
1f6c6378 364 __u8 dev_name[HCI_MAX_NAME_LENGTH];
490c5bab 365 __u8 short_name[HCI_MAX_SHORT_NAME_LENGTH];
80a1e1db 366 __u8 eir[HCI_MAX_EIR_LENGTH];
c4960ecf 367 __u16 appearance;
a9de9248 368 __u8 dev_class[3];
1aff6f09
JH		 369 __u8 major_class;
370 __u8 minor_class;
d2c5d77f 371 __u8 max_page;
cad718ed 372 __u8 features[HCI_MAX_PAGES][8];
60e77321 373 __u8 le_features[8];
3d4f9c00 374 __u8 le_accept_list_size;
cfdb0c2d 375 __u8 le_resolv_list_size;
6b49bcb4 376 __u8 le_num_of_adv_sets;
9b008c04 377 __u8 le_states[8];
b338d917
BG		 378 __u8 mesh_ad_types[16];
379 __u8 mesh_send_ref;
a9de9248 380 __u8 commands[64];
1143e5a6
MH		 381 __u8 hci_ver;
382 __u16 hci_rev;
d5859e22 383 __u8 lmp_ver;
1143e5a6 384 __u16 manufacturer;
7d69230c 385 __u16 lmp_subver;
1da177e4 386 __u16 voice_setting;
b4cb9fb2 387 __u8 num_iac;
e88422bc
LAD		 388 __u16 stored_max_keys;
389 __u16 stored_num_keys;
17fa4b9d 390 __u8 io_capability;
91c4e9b1 391 __s8 inq_tx_power;
00bce3fb 392 __u8 err_data_reporting;
f332ec66
JH		 393 __u16 page_scan_interval;
394 __u16 page_scan_window;
395 __u8 page_scan_type;
3f959d46 396 __u8 le_adv_channel_map;
628531c9
GL		 397 __u16 le_adv_min_interval;
398 __u16 le_adv_max_interval;
533553f8 399 __u8 le_scan_type;
bef64738
MH		 400 __u16 le_scan_interval;
401 __u16 le_scan_window;
10873f99
AM		 402 __u16 le_scan_int_suspend;
403 __u16 le_scan_window_suspend;
404 __u16 le_scan_int_discovery;
405 __u16 le_scan_window_discovery;
406 __u16 le_scan_int_adv_monitor;
407 __u16 le_scan_window_adv_monitor;
408 __u16 le_scan_int_connect;
409 __u16 le_scan_window_connect;
4e70c7e7
MH		 410 __u16 le_conn_min_interval;
411 __u16 le_conn_max_interval;
04fb7d90
MH		 412 __u16 le_conn_latency;
413 __u16 le_supv_timeout;
a8e1bfaa
MH		 414 __u16 le_def_tx_len;
415 __u16 le_def_tx_time;
416 __u16 le_max_tx_len;
417 __u16 le_max_tx_time;
418 __u16 le_max_rx_len;
419 __u16 le_max_rx_time;
30d65e08
MK		 420 __u8 le_max_key_size;
421 __u8 le_min_key_size;
b9a7a61e 422 __u16 discov_interleaved_timeout;
31ad1691
AK		 423 __u16 conn_info_min_age;
424 __u16 conn_info_max_age;
302975cb 425 __u16 auth_payload_timeout;
58a96fc3 426 __u8 min_enc_key_size;
a4790360
MH		 427 __u8 max_enc_key_size;
428 __u8 pairing_opts;
06f5b778 429 __u8 ssp_debug_mode;
c7741d16 430 __u8 hw_error_code;
33f35721 431 __u32 clock;
c4f1f408
HC		 432 __u16 advmon_allowlist_duration;
433 __u16 advmon_no_filter_duration;
80af16a3 434 __u8 enable_advmon_interleave_scan;
f332ec66 435
2b9be137
MH		 436 __u16 devid_source;
437 __u16 devid_vendor;
438 __u16 devid_product;
439 __u16 devid_version;
1da177e4 440
10873f99
AM		 441 __u8 def_page_scan_type;
442 __u16 def_page_scan_int;
443 __u16 def_page_scan_window;
444 __u8 def_inq_scan_type;
445 __u16 def_inq_scan_int;
446 __u16 def_inq_scan_window;
447 __u16 def_br_lsto;
448 __u16 def_page_timeout;
449 __u16 def_multi_adv_rotation_duration;
49b020c1 450 __u16 def_le_autoconnect_timeout;
7c395ea5
DW		 451 __s8 min_le_tx_power;
452 __s8 max_le_tx_power;
10873f99 453
1da177e4 454 __u16 pkt_type;
5b7f9909 455 __u16 esco_type;
1da177e4
LT		 456 __u16 link_policy;
457 __u16 link_mode;
458
04837f64
MH		 459 __u32 idle_timeout;
460 __u16 sniff_min_interval;
461 __u16 sniff_max_interval;
462
928abaa7
AE		 463 __u8 amp_status;
464 __u32 amp_total_bw;
465 __u32 amp_max_bw;
466 __u32 amp_min_latency;
467 __u32 amp_max_pdu;
468 __u8 amp_type;
469 __u16 amp_pal_cap;
470 __u16 amp_assoc_size;
471 __u32 amp_max_flush_to;
472 __u32 amp_be_flush_to;
473
903e4541
AE		 474 struct amp_assoc loc_assoc;
475
1e89cffb
AE		 476 __u8 flow_ctl_mode;
477
9f61656a
JH		 478 unsigned int auto_accept_delay;
479
1da177e4
LT		 480 unsigned long quirks;
481
482 atomic_t cmd_cnt;
483 unsigned int acl_cnt;
484 unsigned int sco_cnt;
6ed58ec5 485 unsigned int le_cnt;
26afbd82 486 unsigned int iso_cnt;
1da177e4
LT		 487
488 unsigned int acl_mtu;
489 unsigned int sco_mtu;
6ed58ec5 490 unsigned int le_mtu;
26afbd82 491 unsigned int iso_mtu;
1da177e4
LT		 492 unsigned int acl_pkts;
493 unsigned int sco_pkts;
6ed58ec5 494 unsigned int le_pkts;
26afbd82 495 unsigned int iso_pkts;
1da177e4 496
350ee4cf
AE		 497 __u16 block_len;
498 __u16 block_mtu;
499 __u16 num_blocks;
500 __u16 block_cnt;
501
1da177e4
LT		 502 unsigned long acl_last_tx;
503 unsigned long sco_last_tx;
6ed58ec5 504 unsigned long le_last_tx;
1da177e4 505
6decb5b4
JK		 506 __u8 le_tx_def_phys;
507 __u8 le_rx_def_phys;
508
f48fd9c8 509 struct workqueue_struct *workqueue;
6ead1bbc 510 struct workqueue_struct *req_workqueue;
f48fd9c8 511
ab81cbf9 512 struct work_struct power_on;
3243553f 513 struct delayed_work power_off;
c7741d16 514 struct work_struct error_reset;
6a98e383
MH		 515 struct work_struct cmd_sync_work;
516 struct list_head cmd_sync_work_list;
517 struct mutex cmd_sync_work_lock;
1857c199 518 struct mutex unregister_lock;
744451c1 519 struct work_struct cmd_sync_cancel_work;
b338d917 520 struct work_struct reenable_adv_work;
ab81cbf9 521
16ab91ab
JH		 522 __u16 discov_timeout;
523 struct delayed_work discov_off;
524
7d78525d
JH		 525 struct delayed_work service_cache;
526
65cc2b49 527 struct delayed_work cmd_timer;
de75cd0d 528 struct delayed_work ncmd_timer;
b78752cc
MH		 529
530 struct work_struct rx_work;
c347b765 531 struct work_struct cmd_work;
3eff45ea 532 struct work_struct tx_work;
1da177e4 533
7c1fbed2
JH		 534 struct delayed_work le_scan_disable;
535 struct delayed_work le_scan_restart;
2e93e53b 536
1da177e4
LT		 537 struct sk_buff_head rx_q;
538 struct sk_buff_head raw_q;
539 struct sk_buff_head cmd_q;
540
541 struct sk_buff *sent_cmd;
dfe6d5c3 542 struct sk_buff *recv_event;
1da177e4 543
a6a67efd 544 struct mutex req_lock;
1da177e4
LT		 545 wait_queue_head_t req_wait_q;
546 __u32 req_status;
547 __u32 req_result;
f60cb305 548 struct sk_buff *req_skb;
a5040efa 549
70db83c4 550 void *smp_data;
ef8efe4b 551 void *smp_bredr_data;
2e58ef3e 552
30883512 553 struct discovery_state discovery;
9952d90e 554
4867bd00
APS		 555 int discovery_old_state;
556 bool discovery_paused;
557 int advertising_old_state;
558 bool advertising_paused;
559
9952d90e 560 struct notifier_block suspend_notifier;
9952d90e
APS		 561 enum suspended_state suspend_state_next;
562 enum suspended_state suspend_state;
4f40afc6
APS		 563 bool scanning_paused;
564 bool suspended;
2f20216c
APS		 565 u8 wake_reason;
566 bdaddr_t wake_addr;
567 u8 wake_addr_type;
9952d90e 568
1da177e4
LT		 569 struct hci_conn_hash conn_hash;
570
b338d917 571 struct list_head mesh_pending;
5c136e90 572 struct list_head mgmt_pending;
3d4f9c00
AP		 573 struct list_head reject_list;
574 struct list_head accept_list;
2aeb9a1a 575 struct list_head uuids;
55ed8ca1 576 struct list_head link_keys;
b899efaf 577 struct list_head long_term_keys;
970c4e46 578 struct list_head identity_resolving_keys;
2763eda6 579 struct list_head remote_oob_data;
3d4f9c00 580 struct list_head le_accept_list;
cfdb0c2d 581 struct list_head le_resolv_list;
15819a70 582 struct list_head le_conn_params;
77a77a30 583 struct list_head pend_le_conns;
66f8455a 584 struct list_head pend_le_reports;
600a8749 585 struct list_head blocked_keys;
8961987f 586 struct list_head local_codecs;
2763eda6 587
1da177e4
LT		 588 struct hci_dev_stats stat;
589
70f23020 590 atomic_t promisc;
1da177e4 591
5177a838
MH		 592 const char *hw_info;
593 const char *fw_info;
ca325f69
MH		 594 struct dentry *debugfs;
595
9695ef87 596 struct hci_devcoredump dump;
9695ef87 597
a91f2e39 598 struct device dev;
1da177e4 599
611b30f7
MH		 600 struct rfkill *rfkill;
601
eacb44df 602 DECLARE_BITMAP(dev_flags, __HCI_NUM_FLAGS);
e1cff700 603 hci_conn_flags_t conn_flags;
d23264a8 604
8fa19098 605 __s8 adv_tx_power;
c9ed0a70 606 __u8 adv_data[HCI_MAX_EXT_AD_LENGTH];
3f0f524b 607 __u8 adv_data_len;
c9ed0a70 608 __u8 scan_rsp_data[HCI_MAX_EXT_AD_LENGTH];
f8e808bd 609 __u8 scan_rsp_data_len;
eca0ae4a
LAD		 610 __u8 per_adv_data[HCI_MAX_PER_AD_LENGTH];
611 __u8 per_adv_data_len;
8fa19098 612
d2609b34
FG		 613 struct list_head adv_instances;
614 unsigned int adv_instance_cnt;
615 __u8 cur_adv_instance;
5d900e46
FG		 616 __u16 adv_instance_timeout;
617 struct delayed_work adv_instance_expire;
203fea01 618
e5e1e7fd
MC		 619 struct idr adv_monitors_idr;
620 unsigned int adv_monitors_cnt;
621
863efaf2 622 __u8 irk[16];
d6bfd59c
JH		 623 __u32 rpa_timeout;
624 struct delayed_work rpa_expired;
2b5224dc 625 bdaddr_t rpa;
863efaf2 626
b338d917
BG		 627 struct delayed_work mesh_send_done;
628
c4f1f408
HC		 629 enum {
630 INTERLEAVE_SCAN_NONE,
631 INTERLEAVE_SCAN_NO_FILTER,
632 INTERLEAVE_SCAN_ALLOWLIST
633 } interleave_scan_state;
634
635 struct delayed_work interleave_scan;
636
3368aa35 637 struct list_head monitored_devices;
8d7f1677 638 bool advmon_pend_notify;
3368aa35 639
53f863a6 640#if IS_ENABLED(CONFIG_BT_LEDS)
6d5d2ee6 641 struct led_trigger *power_led;
53f863a6 642#endif
6d5d2ee6 643
145373cb
MC		 644#if IS_ENABLED(CONFIG_BT_MSFTEXT)
645 __u16 msft_opcode;
646 void *msft_data;
a61d6718 647 bool msft_curve_validity;
145373cb
MC		 648#endif
649
f67743f9
MH		 650#if IS_ENABLED(CONFIG_BT_AOSPEXT)
651 bool aosp_capable;
749a6c59 652 bool aosp_quality_report;
f67743f9
MH		 653#endif
654
1da177e4
LT		 655 int (*open)(struct hci_dev *hdev);
656 int (*close)(struct hci_dev *hdev);
657 int (*flush)(struct hci_dev *hdev);
f41c70c4 658 int (*setup)(struct hci_dev *hdev);
a44fecbd 659 int (*shutdown)(struct hci_dev *hdev);
7bd8f09f 660 int (*send)(struct hci_dev *hdev, struct sk_buff *skb);
1da177e4 661 void (*notify)(struct hci_dev *hdev, unsigned int evt);
c7741d16 662 void (*hw_error)(struct hci_dev *hdev, u8 code);
98a63aaf 663 int (*post_init)(struct hci_dev *hdev);
4b4113d6 664 int (*set_diag)(struct hci_dev *hdev, bool enable);
24c457e2 665 int (*set_bdaddr)(struct hci_dev *hdev, const bdaddr_t *bdaddr);
e2bef384 666 void (*cmd_timeout)(struct hci_dev *hdev);
c9209b26 667 void (*reset)(struct hci_dev *hdev);
4539ca67 668 bool (*wakeup)(struct hci_dev *hdev);
ae7d925b 669 int (*set_quality_report)(struct hci_dev *hdev, bool enable);
248733e8 670 int (*get_data_path_id)(struct hci_dev *hdev, __u8 *data_path);
9798fbde
K		 671 int (*get_codec_config_data)(struct hci_dev *hdev, __u8 type,
672 struct bt_codec *codec, __u8 *vnd_len,
673 __u8 **vnd_data);
1da177e4
LT		 674};
675
53502d69
AE		 676#define HCI_PHY_HANDLE(handle) (handle & 0xff)
677
76b13996
MM		 678enum conn_reasons {
679 CONN_REASON_PAIR_DEVICE,
680 CONN_REASON_L2CAP_CHAN,
681 CONN_REASON_SCO_CONNECT,
26afbd82 682 CONN_REASON_ISO_CONNECT,
76b13996
MM		 683};
684
1da177e4
LT		 685struct hci_conn {
686 struct list_head list;
687
adc4266d 688 atomic_t refcnt;
adc4266d
SJ		 689
690 bdaddr_t dst;
5a9d0a3f 691 __u8 dst_type;
662e8820 692 bdaddr_t src;
e7c4096e 693 __u8 src_type;
cb1d68f7
JH		 694 bdaddr_t init_addr;
695 __u8 init_addr_type;
696 bdaddr_t resp_addr;
697 __u8 resp_addr_type;
7087c4f6 698 __u8 adv_instance;
adc4266d 699 __u16 handle;
eca0ae4a 700 __u16 sync_handle;
adc4266d
SJ		 701 __u16 state;
702 __u8 mode;
703 __u8 type;
40bef302 704 __u8 role;
a0c808b3 705 bool out;
adc4266d
SJ		 706 __u8 attempt;
707 __u8 dev_class[3];
cad718ed 708 __u8 features[HCI_MAX_PAGES][8];
adc4266d
SJ		 709 __u16 pkt_type;
710 __u16 link_policy;
13d39315 711 __u8 key_type;
adc4266d
SJ		 712 __u8 auth_type;
713 __u8 sec_level;
714 __u8 pending_sec_level;
715 __u8 pin_length;
726b4ffc 716 __u8 enc_key_size;
adc4266d 717 __u8 io_capability;
92a25256
JH		 718 __u32 passkey_notify;
719 __u8 passkey_entered;
adc4266d 720 __u16 disc_timeout;
09ae260b 721 __u16 conn_timeout;
10c62ddc 722 __u16 setting;
302975cb 723 __u16 auth_payload_timeout;
1e406eef
AG		 724 __u16 le_conn_min_interval;
725 __u16 le_conn_max_interval;
e04fde60
MH		 726 __u16 le_conn_interval;
727 __u16 le_conn_latency;
728 __u16 le_supv_timeout;
db08722f 729 __u8 le_adv_data[HCI_MAX_EXT_AD_LENGTH];
fd45ada9 730 __u8 le_adv_data_len;
eca0ae4a
LAD		 731 __u8 le_per_adv_data[HCI_MAX_PER_AD_LENGTH];
732 __u8 le_per_adv_data_len;
1efd927d
LAD		 733 __u8 le_tx_phy;
734 __u8 le_rx_phy;
5ae76a94 735 __s8 rssi;
5a134fae 736 __s8 tx_power;
d0455ed9 737 __s8 max_tx_power;
26afbd82 738 struct bt_iso_qos iso_qos;
51a8efd7 739 unsigned long flags;
04837f64 740
76b13996 741 enum conn_reasons conn_reason;
a13f316e 742 __u8 abort_reason;
76b13996 743
33f35721
JH		 744 __u32 clock;
745 __u16 clock_accuracy;
746
dd983808
AK		 747 unsigned long conn_info_timestamp;
748
03b555e1 749 __u8 remote_cap;
03b555e1 750 __u8 remote_auth;
3161ae1c 751 __u8 remote_id;
03b555e1 752
adc4266d 753 unsigned int sent;
04837f64 754
1da177e4 755 struct sk_buff_head data_q;
2c33c06a 756 struct list_head chan_list;
1da177e4 757
19c40e3b 758 struct delayed_work disc_work;
7bc18d9d 759 struct delayed_work auto_accept_work;
a74a84f6 760 struct delayed_work idle_work;
9489eca4 761 struct delayed_work le_conn_timeout;
04837f64 762
b219e3ac 763 struct device dev;
23b9ceb7 764 struct dentry *debugfs;
b219e3ac 765
1da177e4
LT		 766 struct hci_dev *hdev;
767 void *l2cap_data;
768 void *sco_data;
26afbd82 769 void *iso_data;
9740e49d 770 struct amp_mgr *amp_mgr;
1da177e4 771
06149746
LAD		 772 struct list_head link_list;
773 struct hci_conn *parent;
774 struct hci_link *link;
775
b2af264a 776 struct bt_codec codec;
e9a416b5
JH		 777
778 void (*connect_cfm_cb) (struct hci_conn *conn, u8 status);
779 void (*security_cfm_cb) (struct hci_conn *conn, u8 status);
780 void (*disconn_cfm_cb) (struct hci_conn *conn, u8 reason);
26afbd82
LAD		 781
782 void (*cleanup)(struct hci_conn *conn);
1da177e4
LT		 783};
784
06149746
LAD		 785struct hci_link {
786 struct list_head list;
787 struct hci_conn *conn;
788};
789
73d80deb
LAD		 790struct hci_chan {
791 struct list_head list;
42c4e53e 792 __u16 handle;
73d80deb
LAD		 793 struct hci_conn *conn;
794 struct sk_buff_head data_q;
795 unsigned int sent;
168df8e5 796 __u8 state;
5c4c8c95 797 bool amp;
73d80deb
LAD		 798};
799
15819a70
AG		 800struct hci_conn_params {
801 struct list_head list;
93450c75 802 struct list_head action;
15819a70
AG		 803
804 bdaddr_t addr;
805 u8 addr_type;
806
807 u16 conn_min_interval;
808 u16 conn_max_interval;
f044eb05
MH		 809 u16 conn_latency;
810 u16 supervision_timeout;
9fcb18ef
AG		 811
812 enum {
813 HCI_AUTO_CONN_DISABLED,
a3451d27 814 HCI_AUTO_CONN_REPORT,
4b9e7e75 815 HCI_AUTO_CONN_DIRECT,
9fcb18ef
AG		 816 HCI_AUTO_CONN_ALWAYS,
817 HCI_AUTO_CONN_LINK_LOSS,
158e9218 818 HCI_AUTO_CONN_EXPLICIT,
9fcb18ef 819 } auto_connect;
f161dd41
JH		 820
821 struct hci_conn *conn;
158e9218 822 bool explicit_connect;
195ef75e 823 /* Accessed without hdev->lock: */
e1cff700 824 hci_conn_flags_t flags;
853b70b5 825 u8 privacy_mode;
15819a70
AG		 826};
827
1da177e4
LT		 828extern struct list_head hci_dev_list;
829extern struct list_head hci_cb_list;
830extern rwlock_t hci_dev_list_lock;
fba7ecf0 831extern struct mutex hci_cb_list_lock;
1da177e4 832
eacb44df
MH		 833#define hci_dev_set_flag(hdev, nr) set_bit((nr), (hdev)->dev_flags)
834#define hci_dev_clear_flag(hdev, nr) clear_bit((nr), (hdev)->dev_flags)
835#define hci_dev_change_flag(hdev, nr) change_bit((nr), (hdev)->dev_flags)
836#define hci_dev_test_flag(hdev, nr) test_bit((nr), (hdev)->dev_flags)
837#define hci_dev_test_and_set_flag(hdev, nr) test_and_set_bit((nr), (hdev)->dev_flags)
838#define hci_dev_test_and_clear_flag(hdev, nr) test_and_clear_bit((nr), (hdev)->dev_flags)
839#define hci_dev_test_and_change_flag(hdev, nr) test_and_change_bit((nr), (hdev)->dev_flags)
840
841#define hci_dev_clear_volatile_flags(hdev) \
842 do { \
843 hci_dev_clear_flag(hdev, HCI_LE_SCAN); \
844 hci_dev_clear_flag(hdev, HCI_LE_ADV); \
2eb71a3a 845 hci_dev_clear_flag(hdev, HCI_LL_RPA_RESOLUTION);\
eacb44df 846 hci_dev_clear_flag(hdev, HCI_PERIODIC_INQ); \
ae7d925b 847 hci_dev_clear_flag(hdev, HCI_QUALITY_REPORT); \
eacb44df 848 } while (0)
516018a9 849
4fc9857a
LAD		 850#define hci_dev_le_state_simultaneous(hdev) \
851 (test_bit(HCI_QUIRK_VALID_LE_STATES, &hdev->quirks) && \
852 (hdev->le_states[4] & 0x08) && /* Central */ \
853 (hdev->le_states[4] & 0x40) && /* Peripheral */ \
854 (hdev->le_states[3] & 0x10)) /* Simultaneous */
855
686ebf28 856/* ----- HCI interface to upper protocols ----- */
e74e58f8 857int l2cap_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr);
e74e58f8 858int l2cap_disconn_ind(struct hci_conn *hcon);
9b4c3336 859void l2cap_recv_acldata(struct hci_conn *hcon, struct sk_buff *skb, u16 flags);
e74e58f8 860
ff50e8af 861#if IS_ENABLED(CONFIG_BT_BREDR)
e74e58f8 862int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 *flags);
9b4c3336 863void sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb);
ff50e8af
AW		 864#else
865static inline int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr,
866 __u8 *flags)
867{
868 return 0;
869}
870
871static inline void sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb)
872{
873}
874#endif
686ebf28 875
ccf74f23
LAD		 876#if IS_ENABLED(CONFIG_BT_LE)
877int iso_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 *flags);
878void iso_recv(struct hci_conn *hcon, struct sk_buff *skb, u16 flags);
879#else
880static inline int iso_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr,
881 __u8 *flags)
882{
883 return 0;
884}
885static inline void iso_recv(struct hci_conn *hcon, struct sk_buff *skb,
886 u16 flags)
887{
888}
889#endif
890
1da177e4 891/* ----- Inquiry cache ----- */
70f23020
AE		 892#define INQUIRY_CACHE_AGE_MAX (HZ*30) /* 30 seconds */
893#define INQUIRY_ENTRY_AGE_MAX (HZ*60) /* 60 seconds */
1da177e4 894
30883512 895static inline void discovery_init(struct hci_dev *hdev)
1da177e4 896{
ff9ef578 897 hdev->discovery.state = DISCOVERY_STOPPED;
30883512
JH		 898 INIT_LIST_HEAD(&hdev->discovery.all);
899 INIT_LIST_HEAD(&hdev->discovery.unknown);
900 INIT_LIST_HEAD(&hdev->discovery.resolve);
da25cf6a 901 hdev->discovery.report_invalid_rssi = true;
37eab042 902 hdev->discovery.rssi = HCI_RSSI_INVALID;
1da177e4
LT		 903}
904
0256325e
MH		 905static inline void hci_discovery_filter_clear(struct hci_dev *hdev)
906{
82f8b651 907 hdev->discovery.result_filtering = false;
da25cf6a 908 hdev->discovery.report_invalid_rssi = true;
0256325e
MH		 909 hdev->discovery.rssi = HCI_RSSI_INVALID;
910 hdev->discovery.uuid_count = 0;
911 kfree(hdev->discovery.uuids);
912 hdev->discovery.uuids = NULL;
2d28cfe7
JP		 913 hdev->discovery.scan_start = 0;
914 hdev->discovery.scan_duration = 0;
0256325e
MH		 915}
916
30dc78e1
JH		 917bool hci_discovery_active(struct hci_dev *hdev);
918
ff9ef578
JH		 919void hci_discovery_set_state(struct hci_dev *hdev, int state);
920
1da177e4
LT		 921static inline int inquiry_cache_empty(struct hci_dev *hdev)
922{
30883512 923 return list_empty(&hdev->discovery.all);
1da177e4
LT		 924}
925
926static inline long inquiry_cache_age(struct hci_dev *hdev)
927{
30883512 928 struct discovery_state *c = &hdev->discovery;
1da177e4
LT		 929 return jiffies - c->timestamp;
930}
931
932static inline long inquiry_entry_age(struct inquiry_entry *e)
933{
934 return jiffies - e->timestamp;
935}
936
5a9d0a3f 937struct inquiry_entry *hci_inquiry_cache_lookup(struct hci_dev *hdev,
04124681 938 bdaddr_t *bdaddr);
561aafbc 939struct inquiry_entry *hci_inquiry_cache_lookup_unknown(struct hci_dev *hdev,
04124681 940 bdaddr_t *bdaddr);
30dc78e1 941struct inquiry_entry *hci_inquiry_cache_lookup_resolve(struct hci_dev *hdev,
04124681
GP		 942 bdaddr_t *bdaddr,
943 int state);
a3d4e20a 944void hci_inquiry_cache_update_resolve(struct hci_dev *hdev,
04124681 945 struct inquiry_entry *ie);
af58925c
MH		 946u32 hci_inquiry_cache_update(struct hci_dev *hdev, struct inquiry_data *data,
947 bool name_known);
1f9b9a5d 948void hci_inquiry_cache_flush(struct hci_dev *hdev);
1da177e4
LT		 949
950/* ----- HCI Connections ----- */
951enum {
952 HCI_CONN_AUTH_PEND,
19f8def0 953 HCI_CONN_REAUTH_PEND,
1da177e4 954 HCI_CONN_ENCRYPT_PEND,
04837f64
MH		 955 HCI_CONN_RSWITCH_PEND,
956 HCI_CONN_MODE_CHANGE_PEND,
e73439d8 957 HCI_CONN_SCO_SETUP_PEND,
b644ba33 958 HCI_CONN_MGMT_CONNECTED,
58a681ef 959 HCI_CONN_SSP_ENABLED,
eb9a8f3f 960 HCI_CONN_SC_ENABLED,
abf76bad 961 HCI_CONN_AES_CCM,
58a681ef 962 HCI_CONN_POWER_SAVE,
af6a9c32 963 HCI_CONN_FLUSH_KEY,
4dae2798
JH		 964 HCI_CONN_ENCRYPT,
965 HCI_CONN_AUTH,
966 HCI_CONN_SECURE,
967 HCI_CONN_FIPS,
fe59a05f 968 HCI_CONN_STK_ENCRYPT,
977f8fce 969 HCI_CONN_AUTH_INITIATOR,
f94b665d 970 HCI_CONN_DROP,
b62e7220 971 HCI_CONN_CANCEL,
89cbb063 972 HCI_CONN_PARAM_REMOVAL_PEND,
fe8bc5ac 973 HCI_CONN_NEW_LINK_KEY,
158e9218 974 HCI_CONN_SCANNING,
160b9251 975 HCI_CONN_AUTH_FAILURE,
eca0ae4a 976 HCI_CONN_PER_ADV,
a0bfde16 977 HCI_CONN_BIG_CREATED,
7f74563e 978 HCI_CONN_CREATE_CIS,
f777d882
IT		 979 HCI_CONN_BIG_SYNC,
980 HCI_CONN_BIG_SYNC_FAILED,
fbdc4bc4
IT		 981 HCI_CONN_PA_SYNC,
982 HCI_CONN_PA_SYNC_FAILED,
1da177e4
LT		 983};
984
aa64a8b5
JH		 985static inline bool hci_conn_ssp_enabled(struct hci_conn *conn)
986{
987 struct hci_dev *hdev = conn->hdev;
d7a5a11d 988 return hci_dev_test_flag(hdev, HCI_SSP_ENABLED) &&
c3c7ea65 989 test_bit(HCI_CONN_SSP_ENABLED, &conn->flags);
aa64a8b5
JH		 990}
991
eb9a8f3f
MH		 992static inline bool hci_conn_sc_enabled(struct hci_conn *conn)
993{
994 struct hci_dev *hdev = conn->hdev;
d7a5a11d 995 return hci_dev_test_flag(hdev, HCI_SC_ENABLED) &&
eb9a8f3f
MH		 996 test_bit(HCI_CONN_SC_ENABLED, &conn->flags);
997}
998
1da177e4
LT		 999static inline void hci_conn_hash_add(struct hci_dev *hdev, struct hci_conn *c)
1000{
1001 struct hci_conn_hash *h = &hdev->conn_hash;
d4b20f0b 1002 list_add_tail_rcu(&c->list, &h->list);
fcd89c09
VT		 1003 switch (c->type) {
1004 case ACL_LINK:
1da177e4 1005 h->acl_num++;
fcd89c09 1006 break;
bd1eb66b
AE		 1007 case AMP_LINK:
1008 h->amp_num++;
1009 break;
fcd89c09
VT		 1010 case LE_LINK:
1011 h->le_num++;
f8218dc6 1012 if (c->role == HCI_ROLE_SLAVE)
39bc74ca 1013 h->le_num_peripheral++;
fcd89c09
VT		 1014 break;
1015 case SCO_LINK:
1016 case ESCO_LINK:
1da177e4 1017 h->sco_num++;
fcd89c09 1018 break;
26afbd82
LAD		 1019 case ISO_LINK:
1020 h->iso_num++;
1021 break;
fcd89c09 1022 }
1da177e4
LT		 1023}
1024
1025static inline void hci_conn_hash_del(struct hci_dev *hdev, struct hci_conn *c)
1026{
1027 struct hci_conn_hash *h = &hdev->conn_hash;
bf4c6325
GP		 1028
1029 list_del_rcu(&c->list);
1030 synchronize_rcu();
1031
fcd89c09
VT		 1032 switch (c->type) {
1033 case ACL_LINK:
1da177e4 1034 h->acl_num--;
fcd89c09 1035 break;
bd1eb66b
AE		 1036 case AMP_LINK:
1037 h->amp_num--;
1038 break;
fcd89c09
VT		 1039 case LE_LINK:
1040 h->le_num--;
f8218dc6 1041 if (c->role == HCI_ROLE_SLAVE)
39bc74ca 1042 h->le_num_peripheral--;
fcd89c09
VT		 1043 break;
1044 case SCO_LINK:
1045 case ESCO_LINK:
1da177e4 1046 h->sco_num--;
fcd89c09 1047 break;
26afbd82
LAD		 1048 case ISO_LINK:
1049 h->iso_num--;
1050 break;
fcd89c09 1051 }
1da177e4
LT		 1052}
1053
52087a79
LAD		 1054static inline unsigned int hci_conn_num(struct hci_dev *hdev, __u8 type)
1055{
1056 struct hci_conn_hash *h = &hdev->conn_hash;
1057 switch (type) {
1058 case ACL_LINK:
1059 return h->acl_num;
bd1eb66b
AE		 1060 case AMP_LINK:
1061 return h->amp_num;
52087a79
LAD		 1062 case LE_LINK:
1063 return h->le_num;
1064 case SCO_LINK:
1065 case ESCO_LINK:
1066 return h->sco_num;
26afbd82
LAD		 1067 case ISO_LINK:
1068 return h->iso_num;
52087a79
LAD		 1069 default:
1070 return 0;
1071 }
1072}
1073
f4f07505
JH		 1074static inline unsigned int hci_conn_count(struct hci_dev *hdev)
1075{
1076 struct hci_conn_hash *c = &hdev->conn_hash;
1077
26afbd82 1078 return c->acl_num + c->amp_num + c->sco_num + c->le_num + c->iso_num;
f4f07505
JH		 1079}
1080
845472e8
MH		 1081static inline __u8 hci_conn_lookup_type(struct hci_dev *hdev, __u16 handle)
1082{
1083 struct hci_conn_hash *h = &hdev->conn_hash;
1084 struct hci_conn *c;
1085 __u8 type = INVALID_LINK;
1086
1087 rcu_read_lock();
1088
1089 list_for_each_entry_rcu(c, &h->list, list) {
1090 if (c->handle == handle) {
1091 type = c->type;
1092 break;
1093 }
1094 }
1095
1096 rcu_read_unlock();
1097
1098 return type;
1099}
1100
eca0ae4a 1101static inline struct hci_conn *hci_conn_hash_lookup_bis(struct hci_dev *hdev,
6a42e9bf 1102 bdaddr_t *ba, __u8 bis)
eca0ae4a
LAD		 1103{
1104 struct hci_conn_hash *h = &hdev->conn_hash;
1105 struct hci_conn *c;
1106
1107 rcu_read_lock();
1108
1109 list_for_each_entry_rcu(c, &h->list, list) {
1110 if (bacmp(&c->dst, ba) || c->type != ISO_LINK)
1111 continue;
1112
6a42e9bf 1113 if (c->iso_qos.bcast.bis == bis) {
eca0ae4a
LAD		 1114 rcu_read_unlock();
1115 return c;
1116 }
1117 }
1118 rcu_read_unlock();
1119
1120 return NULL;
1121}
1122
a0bfde16
IT		 1123static inline struct hci_conn *
1124hci_conn_hash_lookup_per_adv_bis(struct hci_dev *hdev,
1125 bdaddr_t *ba,
1126 __u8 big, __u8 bis)
1127{
1128 struct hci_conn_hash *h = &hdev->conn_hash;
1129 struct hci_conn *c;
1130
1131 rcu_read_lock();
1132
1133 list_for_each_entry_rcu(c, &h->list, list) {
1134 if (bacmp(&c->dst, ba) || c->type != ISO_LINK ||
1135 !test_bit(HCI_CONN_PER_ADV, &c->flags))
1136 continue;
1137
1138 if (c->iso_qos.bcast.big == big &&
1139 c->iso_qos.bcast.bis == bis) {
1140 rcu_read_unlock();
1141 return c;
1142 }
1143 }
1144 rcu_read_unlock();
1145
1146 return NULL;
1147}
1148
1da177e4 1149static inline struct hci_conn *hci_conn_hash_lookup_handle(struct hci_dev *hdev,
adc4266d 1150 __u16 handle)
1da177e4
LT		 1151{
1152 struct hci_conn_hash *h = &hdev->conn_hash;
1da177e4
LT		 1153 struct hci_conn *c;
1154
bf4c6325
GP		 1155 rcu_read_lock();
1156
1157 list_for_each_entry_rcu(c, &h->list, list) {
1158 if (c->handle == handle) {
1159 rcu_read_unlock();
1da177e4 1160 return c;
bf4c6325 1161 }
1da177e4 1162 }
bf4c6325
GP		 1163 rcu_read_unlock();
1164
1da177e4
LT		 1165 return NULL;
1166}
1167
1168static inline struct hci_conn *hci_conn_hash_lookup_ba(struct hci_dev *hdev,
adc4266d 1169 __u8 type, bdaddr_t *ba)
1da177e4
LT		 1170{
1171 struct hci_conn_hash *h = &hdev->conn_hash;
1da177e4
LT		 1172 struct hci_conn *c;
1173
bf4c6325
GP		 1174 rcu_read_lock();
1175
1176 list_for_each_entry_rcu(c, &h->list, list) {
1177 if (c->type == type && !bacmp(&c->dst, ba)) {
1178 rcu_read_unlock();
1da177e4 1179 return c;
bf4c6325 1180 }
1da177e4 1181 }
bf4c6325
GP		 1182
1183 rcu_read_unlock();
1184
1da177e4
LT		 1185 return NULL;
1186}
1187
1b51c7b6
JH		 1188static inline struct hci_conn *hci_conn_hash_lookup_le(struct hci_dev *hdev,
1189 bdaddr_t *ba,
1190 __u8 ba_type)
1191{
1192 struct hci_conn_hash *h = &hdev->conn_hash;
1193 struct hci_conn *c;
1194
1195 rcu_read_lock();
1196
1197 list_for_each_entry_rcu(c, &h->list, list) {
1198 if (c->type != LE_LINK)
1199 continue;
1200
1201 if (ba_type == c->dst_type && !bacmp(&c->dst, ba)) {
1202 rcu_read_unlock();
1203 return c;
1204 }
1205 }
1206
1207 rcu_read_unlock();
1208
1209 return NULL;
1210}
1211
26afbd82
LAD		 1212static inline struct hci_conn *hci_conn_hash_lookup_cis(struct hci_dev *hdev,
1213 bdaddr_t *ba,
c14516fa
LAD		 1214 __u8 ba_type,
1215 __u8 cig,
1216 __u8 id)
26afbd82
LAD		 1217{
1218 struct hci_conn_hash *h = &hdev->conn_hash;
1219 struct hci_conn *c;
1220
1221 rcu_read_lock();
1222
1223 list_for_each_entry_rcu(c, &h->list, list) {
b5793de3 1224 if (c->type != ISO_LINK || !bacmp(&c->dst, BDADDR_ANY))
26afbd82
LAD		 1225 continue;
1226
c14516fa
LAD		 1227 /* Match CIG ID if set */
1228 if (cig != BT_ISO_QOS_CIG_UNSET && cig != c->iso_qos.ucast.cig)
1229 continue;
1230
1231 /* Match CIS ID if set */
1232 if (id != BT_ISO_QOS_CIS_UNSET && id != c->iso_qos.ucast.cis)
1233 continue;
1234
71e95884
PV		 1235 /* Match destination address if set */
1236 if (!ba || (ba_type == c->dst_type && !bacmp(&c->dst, ba))) {
26afbd82
LAD		 1237 rcu_read_unlock();
1238 return c;
1239 }
1240 }
1241
1242 rcu_read_unlock();
1243
1244 return NULL;
1245}
1246
1247static inline struct hci_conn *hci_conn_hash_lookup_cig(struct hci_dev *hdev,
1248 __u8 handle)
1249{
1250 struct hci_conn_hash *h = &hdev->conn_hash;
1251 struct hci_conn *c;
1252
1253 rcu_read_lock();
1254
1255 list_for_each_entry_rcu(c, &h->list, list) {
b5793de3 1256 if (c->type != ISO_LINK || !bacmp(&c->dst, BDADDR_ANY))
26afbd82
LAD		 1257 continue;
1258
0fe8c8d0 1259 if (handle == c->iso_qos.ucast.cig) {
26afbd82
LAD		 1260 rcu_read_unlock();
1261 return c;
1262 }
1263 }
1264
1265 rcu_read_unlock();
1266
1267 return NULL;
1268}
1269
eca0ae4a
LAD		 1270static inline struct hci_conn *hci_conn_hash_lookup_big(struct hci_dev *hdev,
1271 __u8 handle)
1272{
1273 struct hci_conn_hash *h = &hdev->conn_hash;
1274 struct hci_conn *c;
1275
1276 rcu_read_lock();
1277
1278 list_for_each_entry_rcu(c, &h->list, list) {
1279 if (bacmp(&c->dst, BDADDR_ANY) || c->type != ISO_LINK)
1280 continue;
1281
0fe8c8d0 1282 if (handle == c->iso_qos.bcast.big) {
eca0ae4a
LAD		 1283 rcu_read_unlock();
1284 return c;
1285 }
1286 }
1287
1288 rcu_read_unlock();
1289
1290 return NULL;
1291}
1292
f777d882
IT		 1293static inline struct hci_conn *hci_conn_hash_lookup_big_any_dst(struct hci_dev *hdev,
1294 __u8 handle)
1295{
1296 struct hci_conn_hash *h = &hdev->conn_hash;
1297 struct hci_conn *c;
1298
1299 rcu_read_lock();
1300
1301 list_for_each_entry_rcu(c, &h->list, list) {
1302 if (c->type != ISO_LINK)
1303 continue;
1304
fbdc4bc4 1305 if (handle != BT_ISO_QOS_BIG_UNSET && handle == c->iso_qos.bcast.big) {
f777d882
IT		 1306 rcu_read_unlock();
1307 return c;
1308 }
1309 }
1310
1311 rcu_read_unlock();
1312
1313 return NULL;
1314}
1315
fbdc4bc4
IT		 1316static inline struct hci_conn *
1317hci_conn_hash_lookup_pa_sync(struct hci_dev *hdev, __u8 big)
1318{
1319 struct hci_conn_hash *h = &hdev->conn_hash;
1320 struct hci_conn *c;
1321
1322 rcu_read_lock();
1323
1324 list_for_each_entry_rcu(c, &h->list, list) {
1325 if (c->type != ISO_LINK ||
1326 !test_bit(HCI_CONN_PA_SYNC, &c->flags))
1327 continue;
1328
1329 if (c->iso_qos.bcast.big == big) {
1330 rcu_read_unlock();
1331 return c;
1332 }
1333 }
1334 rcu_read_unlock();
1335
1336 return NULL;
1337}
1338
4c67bc74 1339static inline struct hci_conn *hci_conn_hash_lookup_state(struct hci_dev *hdev,
adc4266d 1340 __u8 type, __u16 state)
4c67bc74
MH		 1341{
1342 struct hci_conn_hash *h = &hdev->conn_hash;
4c67bc74
MH		 1343 struct hci_conn *c;
1344
bf4c6325
GP		 1345 rcu_read_lock();
1346
1347 list_for_each_entry_rcu(c, &h->list, list) {
1348 if (c->type == type && c->state == state) {
1349 rcu_read_unlock();
4c67bc74 1350 return c;
bf4c6325 1351 }
4c67bc74 1352 }
73d80deb 1353
bf4c6325 1354 rcu_read_unlock();
73d80deb 1355
4c67bc74 1356 return NULL;
73d80deb
LAD		 1357}
1358
26afbd82
LAD		 1359typedef void (*hci_conn_func_t)(struct hci_conn *conn, void *data);
1360static inline void hci_conn_hash_list_state(struct hci_dev *hdev,
1361 hci_conn_func_t func, __u8 type,
1362 __u16 state, void *data)
1363{
1364 struct hci_conn_hash *h = &hdev->conn_hash;
1365 struct hci_conn *c;
1366
1367 if (!func)
1368 return;
1369
1370 rcu_read_lock();
1371
1372 list_for_each_entry_rcu(c, &h->list, list) {
1373 if (c->type == type && c->state == state)
1374 func(c, data);
1375 }
1376
1377 rcu_read_unlock();
1378}
1379
e7d9ab73
JP		 1380static inline struct hci_conn *hci_lookup_le_connect(struct hci_dev *hdev)
1381{
1382 struct hci_conn_hash *h = &hdev->conn_hash;
1383 struct hci_conn *c;
1384
1385 rcu_read_lock();
1386
1387 list_for_each_entry_rcu(c, &h->list, list) {
1388 if (c->type == LE_LINK && c->state == BT_CONNECT &&
1389 !test_bit(HCI_CONN_SCANNING, &c->flags)) {
1390 rcu_read_unlock();
1391 return c;
1392 }
1393 }
1394
1395 rcu_read_unlock();
1396
1397 return NULL;
1398}
1399
f8867016
LAD		 1400/* Returns true if an le connection is in the scanning state */
1401static inline bool hci_is_le_conn_scanning(struct hci_dev *hdev)
1402{
1403 struct hci_conn_hash *h = &hdev->conn_hash;
1404 struct hci_conn *c;
1405
1406 rcu_read_lock();
1407
1408 list_for_each_entry_rcu(c, &h->list, list) {
1409 if (c->type == LE_LINK && c->state == BT_CONNECT &&
1410 test_bit(HCI_CONN_SCANNING, &c->flags)) {
1411 rcu_read_unlock();
1412 return true;
1413 }
1414 }
1415
1416 rcu_read_unlock();
1417
1418 return false;
1419}
1420
e3b679d5 1421int hci_disconnect(struct hci_conn *conn, __u8 reason);
2dea632f 1422bool hci_setup_sync(struct hci_conn *conn, __u16 handle);
e73439d8 1423void hci_sco_setup(struct hci_conn *conn, __u8 status);
26afbd82 1424bool hci_iso_setup_path(struct hci_conn *conn);
7f74563e
PV		 1425int hci_le_create_cis_pending(struct hci_dev *hdev);
1426int hci_conn_check_create_cis(struct hci_conn *conn);
1da177e4 1427
a5c4e309
JH		 1428struct hci_conn *hci_conn_add(struct hci_dev *hdev, int type, bdaddr_t *dst,
1429 u8 role);
a2ac591c 1430void hci_conn_del(struct hci_conn *conn);
a9de9248
MH		 1431void hci_conn_hash_flush(struct hci_dev *hdev);
1432void hci_conn_check_pending(struct hci_dev *hdev);
1da177e4 1433
73d80deb 1434struct hci_chan *hci_chan_create(struct hci_conn *conn);
9472007c 1435void hci_chan_del(struct hci_chan *chan);
2c33c06a 1436void hci_chan_list_flush(struct hci_conn *conn);
42c4e53e 1437struct hci_chan *hci_chan_lookup_handle(struct hci_dev *hdev, __u16 handle);
73d80deb 1438
f75113a2
JP		 1439struct hci_conn *hci_connect_le_scan(struct hci_dev *hdev, bdaddr_t *dst,
1440 u8 dst_type, u8 sec_level,
76b13996
MM		 1441 u16 conn_timeout,
1442 enum conn_reasons conn_reason);
04a6c589 1443struct hci_conn *hci_connect_le(struct hci_dev *hdev, bdaddr_t *dst,
d850bf08 1444 u8 dst_type, bool dst_resolved, u8 sec_level,
8e8b92ee 1445 u16 conn_timeout, u8 role);
04a6c589 1446struct hci_conn *hci_connect_acl(struct hci_dev *hdev, bdaddr_t *dst,
76b13996
MM		 1447 u8 sec_level, u8 auth_type,
1448 enum conn_reasons conn_reason);
10c62ddc 1449struct hci_conn *hci_connect_sco(struct hci_dev *hdev, int type, bdaddr_t *dst,
b2af264a 1450 __u16 setting, struct bt_codec *codec);
26afbd82
LAD		 1451struct hci_conn *hci_bind_cis(struct hci_dev *hdev, bdaddr_t *dst,
1452 __u8 dst_type, struct bt_iso_qos *qos);
a0bfde16
IT		 1453struct hci_conn *hci_bind_bis(struct hci_dev *hdev, bdaddr_t *dst,
1454 struct bt_iso_qos *qos,
1455 __u8 base_len, __u8 *base);
26afbd82
LAD		 1456struct hci_conn *hci_connect_cis(struct hci_dev *hdev, bdaddr_t *dst,
1457 __u8 dst_type, struct bt_iso_qos *qos);
eca0ae4a
LAD		 1458struct hci_conn *hci_connect_bis(struct hci_dev *hdev, bdaddr_t *dst,
1459 __u8 dst_type, struct bt_iso_qos *qos,
1460 __u8 data_len, __u8 *data);
1461int hci_pa_create_sync(struct hci_dev *hdev, bdaddr_t *dst, __u8 dst_type,
0fe8c8d0 1462 __u8 sid, struct bt_iso_qos *qos);
fbdc4bc4
IT		 1463int hci_le_big_create_sync(struct hci_dev *hdev, struct hci_conn *hcon,
1464 struct bt_iso_qos *qos,
eca0ae4a 1465 __u16 sync_handle, __u8 num_bis, __u8 bis[]);
e7c29cb1 1466int hci_conn_check_link_mode(struct hci_conn *conn);
b3b1b061 1467int hci_conn_check_secure(struct hci_conn *conn, __u8 sec_level);
e7cafc45
JH		 1468int hci_conn_security(struct hci_conn *conn, __u8 sec_level, __u8 auth_type,
1469 bool initiator);
8c1b2355 1470int hci_conn_switch_role(struct hci_conn *conn, __u8 role);
1da177e4 1471
14b12d0b 1472void hci_conn_enter_active_mode(struct hci_conn *conn, __u8 force_active);
1da177e4 1473
9b3628d7 1474void hci_conn_failed(struct hci_conn *conn, u8 status);
16e3b642 1475u8 hci_conn_set_handle(struct hci_conn *conn, u16 handle);
06c053fb 1476
8d12356f
DR		 1477/*
1478 * hci_conn_get() and hci_conn_put() are used to control the life-time of an
1479 * "hci_conn" object. They do not guarantee that the hci_conn object is running,
1480 * working or anything else. They just guarantee that the object is available
1481 * and can be dereferenced. So you can use its locks, local variables and any
1482 * other constant data.
1483 * Before accessing runtime data, you _must_ lock the object and then check that
1484 * it is still running. As soon as you release the locks, the connection might
1485 * get dropped, though.
1486 *
1487 * On the other hand, hci_conn_hold() and hci_conn_drop() are used to control
1488 * how long the underlying connection is held. So every channel that runs on the
1489 * hci_conn object calls this to prevent the connection from disappearing. As
1490 * long as you hold a device, you must also guarantee that you have a valid
1491 * reference to the device via hci_conn_get() (or the initial reference from
1492 * hci_conn_add()).
1493 * The hold()/drop() ref-count is known to drop below 0 sometimes, which doesn't
1494 * break because nobody cares for that. But this means, we cannot use
1495 * _get()/_drop() in it, but require the caller to have a valid ref (FIXME).
1496 */
1497
51bb8457 1498static inline struct hci_conn *hci_conn_get(struct hci_conn *conn)
8d12356f
DR		 1499{
1500 get_device(&conn->dev);
51bb8457 1501 return conn;
8d12356f
DR		 1502}
1503
1504static inline void hci_conn_put(struct hci_conn *conn)
1505{
1506 put_device(&conn->dev);
1507}
1508
06149746 1509static inline struct hci_conn *hci_conn_hold(struct hci_conn *conn)
1da177e4 1510{
71becf0c 1511 BT_DBG("hcon %p orig refcnt %d", conn, atomic_read(&conn->refcnt));
38b3fef1 1512
1da177e4 1513 atomic_inc(&conn->refcnt);
2f304d1e 1514 cancel_delayed_work(&conn->disc_work);
06149746
LAD		 1515
1516 return conn;
1da177e4
LT		 1517}
1518
76a68ba0 1519static inline void hci_conn_drop(struct hci_conn *conn)
1da177e4 1520{
71becf0c 1521 BT_DBG("hcon %p orig refcnt %d", conn, atomic_read(&conn->refcnt));
38b3fef1 1522
1da177e4 1523 if (atomic_dec_and_test(&conn->refcnt)) {
04837f64 1524 unsigned long timeo;
716e4ab5
AE		 1525
1526 switch (conn->type) {
1527 case ACL_LINK:
1528 case LE_LINK:
a74a84f6 1529 cancel_delayed_work(&conn->idle_work);
6ac59344 1530 if (conn->state == BT_CONNECTED) {
5f246e89 1531 timeo = conn->disc_timeout;
6ac59344 1532 if (!conn->out)
052b30b0 1533 timeo *= 2;
5a9d0a3f 1534 } else {
eb78d7e5 1535 timeo = 0;
5a9d0a3f 1536 }
716e4ab5
AE		 1537 break;
1538
1539 case AMP_LINK:
1540 timeo = conn->disc_timeout;
1541 break;
1542
1543 default:
eb78d7e5 1544 timeo = 0;
716e4ab5 1545 break;
5a9d0a3f 1546 }
716e4ab5 1547
2f304d1e 1548 cancel_delayed_work(&conn->disc_work);
19c40e3b 1549 queue_delayed_work(conn->hdev->workqueue,
716e4ab5 1550 &conn->disc_work, timeo);
1da177e4
LT		 1551 }
1552}
1553
1da177e4 1554/* ----- HCI Devices ----- */
dc946bd8 1555static inline void hci_dev_put(struct hci_dev *d)
1da177e4 1556{
376261ae 1557 BT_DBG("%s orig refcnt %d", d->name,
2c935bc5 1558 kref_read(&d->dev.kobj.kref));
376261ae 1559
4c724c71 1560 put_device(&d->dev);
1da177e4
LT		 1561}
1562
dc946bd8 1563static inline struct hci_dev *hci_dev_hold(struct hci_dev *d)
1da177e4 1564{
376261ae 1565 BT_DBG("%s orig refcnt %d", d->name,
2c935bc5 1566 kref_read(&d->dev.kobj.kref));
376261ae 1567
4c724c71 1568 get_device(&d->dev);
1da177e4
LT		 1569 return d;
1570}
1571
09fd0de5
GP		 1572#define hci_dev_lock(d) mutex_lock(&d->lock)
1573#define hci_dev_unlock(d) mutex_unlock(&d->lock)
1da177e4 1574
aa2b86d7 1575#define to_hci_dev(d) container_of(d, struct hci_dev, dev)
3dc07322 1576#define to_hci_conn(c) container_of(c, struct hci_conn, dev)
aa2b86d7 1577
155961e8
DR		 1578static inline void *hci_get_drvdata(struct hci_dev *hdev)
1579{
1580 return dev_get_drvdata(&hdev->dev);
1581}
1582
1583static inline void hci_set_drvdata(struct hci_dev *hdev, void *data)
1584{
1585 dev_set_drvdata(&hdev->dev, data);
1586}
1587
6ec56613
THJA		 1588static inline void *hci_get_priv(struct hci_dev *hdev)
1589{
1590 return (char *)hdev + sizeof(*hdev);
1591}
1592
1da177e4 1593struct hci_dev *hci_dev_get(int index);
39385cb5 1594struct hci_dev *hci_get_route(bdaddr_t *dst, bdaddr_t *src, u8 src_type);
1da177e4 1595
6ec56613
THJA		 1596struct hci_dev *hci_alloc_dev_priv(int sizeof_priv);
1597
1598static inline struct hci_dev *hci_alloc_dev(void)
1599{
1600 return hci_alloc_dev_priv(0);
1601}
1602
1da177e4
LT		 1603void hci_free_dev(struct hci_dev *hdev);
1604int hci_register_dev(struct hci_dev *hdev);
59735631 1605void hci_unregister_dev(struct hci_dev *hdev);
58ce6d5b 1606void hci_release_dev(struct hci_dev *hdev);
359ee4f8
APS		 1607int hci_register_suspend_notifier(struct hci_dev *hdev);
1608int hci_unregister_suspend_notifier(struct hci_dev *hdev);
1da177e4
LT		 1609int hci_suspend_dev(struct hci_dev *hdev);
1610int hci_resume_dev(struct hci_dev *hdev);
75e0569f 1611int hci_reset_dev(struct hci_dev *hdev);
f962fe32
MH		 1612int hci_recv_frame(struct hci_dev *hdev, struct sk_buff *skb);
1613int hci_recv_diag(struct hci_dev *hdev, struct sk_buff *skb);
1aabbbce
NI		 1614__printf(2, 3) void hci_set_hw_info(struct hci_dev *hdev, const char *fmt, ...);
1615__printf(2, 3) void hci_set_fw_info(struct hci_dev *hdev, const char *fmt, ...);
145373cb
MC		 1616
1617static inline void hci_set_msft_opcode(struct hci_dev *hdev, __u16 opcode)
1618{
1619#if IS_ENABLED(CONFIG_BT_MSFTEXT)
1620 hdev->msft_opcode = opcode;
1621#endif
1622}
1623
f67743f9
MH		 1624static inline void hci_set_aosp_capable(struct hci_dev *hdev)
1625{
1626#if IS_ENABLED(CONFIG_BT_AOSPEXT)
1627 hdev->aosp_capable = true;
1628#endif
1629}
1630
9695ef87
APS		 1631static inline void hci_devcd_setup(struct hci_dev *hdev)
1632{
1633#ifdef CONFIG_DEV_COREDUMP
1634 INIT_WORK(&hdev->dump.dump_rx, hci_devcd_rx);
1635 INIT_DELAYED_WORK(&hdev->dump.dump_timeout, hci_devcd_timeout);
1636 skb_queue_head_init(&hdev->dump.dump_q);
1637#endif
1638}
1639
1da177e4
LT		 1640int hci_dev_open(__u16 dev);
1641int hci_dev_close(__u16 dev);
6b3cc1db 1642int hci_dev_do_close(struct hci_dev *hdev);
1da177e4
LT		 1643int hci_dev_reset(__u16 dev);
1644int hci_dev_reset_stat(__u16 dev);
1645int hci_dev_cmd(unsigned int cmd, void __user *arg);
1646int hci_get_dev_list(void __user *arg);
1647int hci_get_dev_info(void __user *arg);
1648int hci_get_conn_list(void __user *arg);
1649int hci_get_conn_info(struct hci_dev *hdev, void __user *arg);
40be492f 1650int hci_get_auth_info(struct hci_dev *hdev, void __user *arg);
1da177e4
LT		 1651int hci_inquiry(void __user *arg);
1652
dcc36c16
JH		 1653struct bdaddr_list *hci_bdaddr_list_lookup(struct list_head *list,
1654 bdaddr_t *bdaddr, u8 type);
b950aa88
AN		 1655struct bdaddr_list_with_irk *hci_bdaddr_list_lookup_with_irk(
1656 struct list_head *list, bdaddr_t *bdaddr,
1657 u8 type);
8baaa403
APS		 1658struct bdaddr_list_with_flags *
1659hci_bdaddr_list_lookup_with_flags(struct list_head *list, bdaddr_t *bdaddr,
1660 u8 type);
dcc36c16 1661int hci_bdaddr_list_add(struct list_head *list, bdaddr_t *bdaddr, u8 type);
b950aa88 1662int hci_bdaddr_list_add_with_irk(struct list_head *list, bdaddr_t *bdaddr,
8baaa403
APS		 1663 u8 type, u8 *peer_irk, u8 *local_irk);
1664int hci_bdaddr_list_add_with_flags(struct list_head *list, bdaddr_t *bdaddr,
1665 u8 type, u32 flags);
dcc36c16 1666int hci_bdaddr_list_del(struct list_head *list, bdaddr_t *bdaddr, u8 type);
b950aa88 1667int hci_bdaddr_list_del_with_irk(struct list_head *list, bdaddr_t *bdaddr,
8baaa403
APS		 1668 u8 type);
1669int hci_bdaddr_list_del_with_flags(struct list_head *list, bdaddr_t *bdaddr,
1670 u8 type);
dcc36c16 1671void hci_bdaddr_list_clear(struct list_head *list);
d2ab0ac1 1672
15819a70
AG		 1673struct hci_conn_params *hci_conn_params_lookup(struct hci_dev *hdev,
1674 bdaddr_t *addr, u8 addr_type);
51d167c0
MH		 1675struct hci_conn_params *hci_conn_params_add(struct hci_dev *hdev,
1676 bdaddr_t *addr, u8 addr_type);
15819a70 1677void hci_conn_params_del(struct hci_dev *hdev, bdaddr_t *addr, u8 addr_type);
55af49a8 1678void hci_conn_params_clear_disabled(struct hci_dev *hdev);
195ef75e 1679void hci_conn_params_free(struct hci_conn_params *param);
15819a70 1680
195ef75e
PV		 1681void hci_pend_le_list_del_init(struct hci_conn_params *param);
1682void hci_pend_le_list_add(struct hci_conn_params *param,
1683 struct list_head *list);
501f8827
JH		 1684struct hci_conn_params *hci_pend_le_action_lookup(struct list_head *list,
1685 bdaddr_t *addr,
1686 u8 addr_type);
77a77a30 1687
35f7498a 1688void hci_uuids_clear(struct hci_dev *hdev);
2aeb9a1a 1689
35f7498a 1690void hci_link_keys_clear(struct hci_dev *hdev);
55ed8ca1 1691struct link_key *hci_find_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr);
567fa2aa 1692struct link_key *hci_add_link_key(struct hci_dev *hdev, struct hci_conn *conn,
7652ff6a
JH		 1693 bdaddr_t *bdaddr, u8 *val, u8 type,
1694 u8 pin_len, bool *persistent);
ca9142b8 1695struct smp_ltk *hci_add_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr,
35d70271 1696 u8 addr_type, u8 type, u8 authenticated,
fe39c7b2 1697 u8 tk[16], u8 enc_size, __le16 ediv, __le64 rand);
f3a73d97
JH		 1698struct smp_ltk *hci_find_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr,
1699 u8 addr_type, u8 role);
e0b2b27e 1700int hci_remove_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 bdaddr_type);
35f7498a 1701void hci_smp_ltks_clear(struct hci_dev *hdev);
55ed8ca1
JH		 1702int hci_remove_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr);
1703
970c4e46
JH		 1704struct smp_irk *hci_find_irk_by_rpa(struct hci_dev *hdev, bdaddr_t *rpa);
1705struct smp_irk *hci_find_irk_by_addr(struct hci_dev *hdev, bdaddr_t *bdaddr,
1706 u8 addr_type);
ca9142b8
JH		 1707struct smp_irk *hci_add_irk(struct hci_dev *hdev, bdaddr_t *bdaddr,
1708 u8 addr_type, u8 val[16], bdaddr_t *rpa);
a7ec7338 1709void hci_remove_irk(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 addr_type);
600a8749
AM		 1710bool hci_is_blocked_key(struct hci_dev *hdev, u8 type, u8 val[16]);
1711void hci_blocked_keys_clear(struct hci_dev *hdev);
970c4e46
JH		 1712void hci_smp_irks_clear(struct hci_dev *hdev);
1713
55e76b38
JH		 1714bool hci_bdaddr_is_paired(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 type);
1715
35f7498a 1716void hci_remote_oob_data_clear(struct hci_dev *hdev);
2763eda6 1717struct oob_data *hci_find_remote_oob_data(struct hci_dev *hdev,
6928a924 1718 bdaddr_t *bdaddr, u8 bdaddr_type);
0798872e 1719int hci_add_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr,
6928a924 1720 u8 bdaddr_type, u8 *hash192, u8 *rand192,
81328d5c 1721 u8 *hash256, u8 *rand256);
6928a924
JH		 1722int hci_remove_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr,
1723 u8 bdaddr_type);
2763eda6 1724
d2609b34
FG		 1725void hci_adv_instances_clear(struct hci_dev *hdev);
1726struct adv_info *hci_find_adv_instance(struct hci_dev *hdev, u8 instance);
1727struct adv_info *hci_get_next_instance(struct hci_dev *hdev, u8 instance);
eca0ae4a
LAD		 1728struct adv_info *hci_add_adv_instance(struct hci_dev *hdev, u8 instance,
1729 u32 flags, u16 adv_data_len, u8 *adv_data,
1730 u16 scan_rsp_len, u8 *scan_rsp_data,
1731 u16 timeout, u16 duration, s8 tx_power,
b338d917
BG		 1732 u32 min_interval, u32 max_interval,
1733 u8 mesh_handle);
eca0ae4a
LAD		 1734struct adv_info *hci_add_per_instance(struct hci_dev *hdev, u8 instance,
1735 u32 flags, u8 data_len, u8 *data,
1736 u32 min_interval, u32 max_interval);
31aab5c2
DW		 1737int hci_set_adv_instance_data(struct hci_dev *hdev, u8 instance,
1738 u16 adv_data_len, u8 *adv_data,
1739 u16 scan_rsp_len, u8 *scan_rsp_data);
d2609b34 1740int hci_remove_adv_instance(struct hci_dev *hdev, u8 instance);
a73c046a 1741void hci_adv_instances_set_rpa_expired(struct hci_dev *hdev, bool rpa_expired);
01ce70b0
LAD		 1742u32 hci_adv_instance_flags(struct hci_dev *hdev, u8 instance);
1743bool hci_adv_instance_is_scannable(struct hci_dev *hdev, u8 instance);
d2609b34 1744
e5e1e7fd 1745void hci_adv_monitors_clear(struct hci_dev *hdev);
66bd095a 1746void hci_free_adv_monitor(struct hci_dev *hdev, struct adv_monitor *monitor);
b747a836 1747int hci_add_adv_monitor(struct hci_dev *hdev, struct adv_monitor *monitor);
7cf5c297
MM		 1748int hci_remove_single_adv_monitor(struct hci_dev *hdev, u16 handle);
1749int hci_remove_all_adv_monitor(struct hci_dev *hdev);
8208f5a9 1750bool hci_is_adv_monitoring(struct hci_dev *hdev);
a2a4dedf 1751int hci_get_adv_monitor_offload_ext(struct hci_dev *hdev);
e5e1e7fd 1752
1da177e4
LT		 1753void hci_event_packet(struct hci_dev *hdev, struct sk_buff *skb);
1754
0ac7e700 1755void hci_init_sysfs(struct hci_dev *hdev);
a67e899c 1756void hci_conn_init_sysfs(struct hci_conn *conn);
b219e3ac
MH		 1757void hci_conn_add_sysfs(struct hci_conn *conn);
1758void hci_conn_del_sysfs(struct hci_conn *conn);
1da177e4 1759
6935e0f5 1760#define SET_HCIDEV_DEV(hdev, pdev) ((hdev)->dev.parent = (pdev))
294d749b 1761#define GET_HCIDEV_DEV(hdev) ((hdev)->dev.parent)
1da177e4
LT		 1762
1763/* ----- LMP capabilities ----- */
cad718ed
JH		 1764#define lmp_encrypt_capable(dev) ((dev)->features[0][0] & LMP_ENCRYPT)
1765#define lmp_rswitch_capable(dev) ((dev)->features[0][0] & LMP_RSWITCH)
1766#define lmp_hold_capable(dev) ((dev)->features[0][0] & LMP_HOLD)
1767#define lmp_sniff_capable(dev) ((dev)->features[0][0] & LMP_SNIFF)
1768#define lmp_park_capable(dev) ((dev)->features[0][1] & LMP_PARK)
1769#define lmp_inq_rssi_capable(dev) ((dev)->features[0][3] & LMP_RSSI_INQ)
1770#define lmp_esco_capable(dev) ((dev)->features[0][3] & LMP_ESCO)
1771#define lmp_bredr_capable(dev) (!((dev)->features[0][4] & LMP_NO_BREDR))
1772#define lmp_le_capable(dev) ((dev)->features[0][4] & LMP_LE)
1773#define lmp_sniffsubr_capable(dev) ((dev)->features[0][5] & LMP_SNIFF_SUBR)
1774#define lmp_pause_enc_capable(dev) ((dev)->features[0][5] & LMP_PAUSE_ENC)
8b1c324c 1775#define lmp_esco_2m_capable(dev) ((dev)->features[0][5] & LMP_EDR_ESCO_2M)
cad718ed
JH		 1776#define lmp_ext_inq_capable(dev) ((dev)->features[0][6] & LMP_EXT_INQ)
1777#define lmp_le_br_capable(dev) (!!((dev)->features[0][6] & LMP_SIMUL_LE_BR))
1778#define lmp_ssp_capable(dev) ((dev)->features[0][6] & LMP_SIMPLE_PAIR)
1779#define lmp_no_flush_capable(dev) ((dev)->features[0][6] & LMP_NO_FLUSH)
1780#define lmp_lsto_capable(dev) ((dev)->features[0][7] & LMP_LSTO)
1781#define lmp_inq_tx_pwr_capable(dev) ((dev)->features[0][7] & LMP_INQ_TX_PWR)
1782#define lmp_ext_feat_capable(dev) ((dev)->features[0][7] & LMP_EXTFEATURES)
07a5c61e 1783#define lmp_transp_capable(dev) ((dev)->features[0][2] & LMP_TRANSPARENT)
5075b972
JK		 1784#define lmp_edr_2m_capable(dev) ((dev)->features[0][3] & LMP_EDR_2M)
1785#define lmp_edr_3m_capable(dev) ((dev)->features[0][3] & LMP_EDR_3M)
1786#define lmp_edr_3slot_capable(dev) ((dev)->features[0][4] & LMP_EDR_3SLOT)
1787#define lmp_edr_5slot_capable(dev) ((dev)->features[0][5] & LMP_EDR_5SLOT)
1da177e4 1788
eead27da 1789/* ----- Extended LMP capabilities ----- */
6397729b
AP		 1790#define lmp_cpb_central_capable(dev) ((dev)->features[2][0] & LMP_CPB_CENTRAL)
1791#define lmp_cpb_peripheral_capable(dev) ((dev)->features[2][0] & LMP_CPB_PERIPHERAL)
53b834d2
MH		 1792#define lmp_sync_train_capable(dev) ((dev)->features[2][0] & LMP_SYNC_TRAIN)
1793#define lmp_sync_scan_capable(dev) ((dev)->features[2][0] & LMP_SYNC_SCAN)
d5991585
MH		 1794#define lmp_sc_capable(dev) ((dev)->features[2][1] & LMP_SC)
1795#define lmp_ping_capable(dev) ((dev)->features[2][1] & LMP_PING)
53b834d2
MH		 1796
1797/* ----- Host capabilities ----- */
cad718ed 1798#define lmp_host_ssp_capable(dev) ((dev)->features[1][0] & LMP_HOST_SSP)
d5991585 1799#define lmp_host_sc_capable(dev) ((dev)->features[1][0] & LMP_HOST_SC)
cad718ed
JH		 1800#define lmp_host_le_capable(dev) (!!((dev)->features[1][0] & LMP_HOST_LE))
1801#define lmp_host_le_br_capable(dev) (!!((dev)->features[1][0] & LMP_HOST_LE_BREDR))
eead27da 1802
d7a5a11d
MH		 1803#define hdev_is_powered(dev) (test_bit(HCI_UP, &(dev)->flags) && \
1804 !hci_dev_test_flag(dev, HCI_AUTO_OFF))
1805#define bredr_sc_enabled(dev) (lmp_sc_capable(dev) && \
1806 hci_dev_test_flag(dev, HCI_SC_ENABLED))
c45074d6
LAD		 1807#define rpa_valid(dev) (bacmp(&dev->rpa, BDADDR_ANY) && \
1808 !hci_dev_test_flag(dev, HCI_RPA_EXPIRED))
1809#define adv_rpa_valid(adv) (bacmp(&adv->random_addr, BDADDR_ANY) && \
1810 !adv->rpa_expired)
432df05e 1811
45bdd86e
JK		 1812#define scan_1m(dev) (((dev)->le_tx_def_phys & HCI_LE_SET_PHY_1M) || \
1813 ((dev)->le_rx_def_phys & HCI_LE_SET_PHY_1M))
1814
288c9022
LAD		 1815#define le_2m_capable(dev) (((dev)->le_features[1] & HCI_LE_PHY_2M))
1816
45bdd86e
JK		 1817#define scan_2m(dev) (((dev)->le_tx_def_phys & HCI_LE_SET_PHY_2M) || \
1818 ((dev)->le_rx_def_phys & HCI_LE_SET_PHY_2M))
1819
253f3399
LAD		 1820#define le_coded_capable(dev) (((dev)->le_features[1] & HCI_LE_PHY_CODED) && \
1821 !test_bit(HCI_QUIRK_BROKEN_LE_CODED, \
1822 &(dev)->quirks))
288c9022 1823
45bdd86e
JK		 1824#define scan_coded(dev) (((dev)->le_tx_def_phys & HCI_LE_SET_PHY_CODED) || \
1825 ((dev)->le_rx_def_phys & HCI_LE_SET_PHY_CODED))
1826
ad383c2c
LAD		 1827#define ll_privacy_capable(dev) ((dev)->le_features[0] & HCI_LE_LL_PRIVACY)
1828
e1d57235 1829/* Use LL Privacy based address resolution if supported */
ad383c2c
LAD		 1830#define use_ll_privacy(dev) (ll_privacy_capable(dev) && \
1831 hci_dev_test_flag(dev, HCI_ENABLE_LL_PRIVACY))
e1d57235 1832
6126ffab
LAD		 1833#define privacy_mode_capable(dev) (use_ll_privacy(dev) && \
1834 (hdev->commands[39] & 0x04))
1835
05abad85
LAD		 1836/* Use enhanced synchronous connection if command is supported and its quirk
1837 * has not been set.
1838 */
1839#define enhanced_sync_conn_capable(dev) \
1840 (((dev)->commands[29] & 0x08) && \
1841 !test_bit(HCI_QUIRK_BROKEN_ENHANCED_SETUP_SYNC_CONN, &(dev)->quirks))
b2af264a 1842
a2344b9e
JK		 1843/* Use ext scanning if set ext scan param and ext scan enable is supported */
1844#define use_ext_scan(dev) (((dev)->commands[37] & 0x20) && \
392fca35
SP		 1845 ((dev)->commands[37] & 0x40) && \
1846 !test_bit(HCI_QUIRK_BROKEN_EXT_SCAN, &(dev)->quirks))
1847
4d94f95d
JK		 1848/* Use ext create connection if command is supported */
1849#define use_ext_conn(dev) ((dev)->commands[37] & 0x80)
a2344b9e 1850
6b49bcb4
JK		 1851/* Extended advertising support */
1852#define ext_adv_capable(dev) (((dev)->le_features[1] & HCI_LE_EXT_ADV))
1853
112b5090
LAD		 1854/* Maximum advertising length */
1855#define max_adv_len(dev) \
1856 (ext_adv_capable(dev) ? HCI_MAX_EXT_AD_LENGTH : HCI_MAX_AD_LENGTH)
1857
a56a1138
LAD		 1858/* BLUETOOTH CORE SPECIFICATION Version 5.3 | Vol 4, Part E page 1789:
1859 *
1860 * C24: Mandatory if the LE Controller supports Connection State and either
1861 * LE Feature (LL Privacy) or LE Feature (Extended Advertising) is supported
1862 */
1863#define use_enhanced_conn_complete(dev) (ll_privacy_capable(dev) || \
1864 ext_adv_capable(dev))
1865
eca0ae4a
LAD		 1866/* Periodic advertising support */
1867#define per_adv_capable(dev) (((dev)->le_features[1] & HCI_LE_PERIODIC_ADV))
1868
1869/* CIS Master/Slave and BIS support */
1870#define iso_capable(dev) (cis_capable(dev) || bis_capable(dev))
26afbd82
LAD		 1871#define cis_capable(dev) \
1872 (cis_central_capable(dev) || cis_peripheral_capable(dev))
1873#define cis_central_capable(dev) \
1874 ((dev)->le_features[3] & HCI_LE_CIS_CENTRAL)
1875#define cis_peripheral_capable(dev) \
1876 ((dev)->le_features[3] & HCI_LE_CIS_PERIPHERAL)
eca0ae4a 1877#define bis_capable(dev) ((dev)->le_features[3] & HCI_LE_ISO_BROADCASTER)
ae753361 1878#define sync_recv_capable(dev) ((dev)->le_features[3] & HCI_LE_ISO_SYNC_RECEIVER)
26afbd82 1879
ffcb0a44
SP		 1880#define mws_transport_config_capable(dev) (((dev)->commands[30] & 0x08) && \
1881 (!test_bit(HCI_QUIRK_BROKEN_MWS_TRANSPORT_CONFIG, &(dev)->quirks)))
1882
1da177e4 1883/* ----- HCI protocols ----- */
20714bfe
FD		 1884#define HCI_PROTO_DEFER 0x01
1885
5a9d0a3f 1886static inline int hci_proto_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr,
20714bfe 1887 __u8 type, __u8 *flags)
1da177e4 1888{
686ebf28
UF		 1889 switch (type) {
1890 case ACL_LINK:
1891 return l2cap_connect_ind(hdev, bdaddr);
1da177e4 1892
686ebf28
UF		 1893 case SCO_LINK:
1894 case ESCO_LINK:
20714bfe 1895 return sco_connect_ind(hdev, bdaddr, flags);
1da177e4 1896
26afbd82 1897 case ISO_LINK:
ccf74f23 1898 return iso_connect_ind(hdev, bdaddr, flags);
26afbd82 1899
686ebf28
UF		 1900 default:
1901 BT_ERR("unknown link type %d", type);
1902 return -EINVAL;
1903 }
1da177e4
LT		 1904}
1905
2950f21a 1906static inline int hci_proto_disconn_ind(struct hci_conn *conn)
1da177e4 1907{
686ebf28
UF		 1908 if (conn->type != ACL_LINK && conn->type != LE_LINK)
1909 return HCI_ERROR_REMOTE_USER_TERM;
1da177e4 1910
686ebf28 1911 return l2cap_disconn_ind(conn);
2950f21a
MH		 1912}
1913
1da177e4
LT		 1914/* ----- HCI callbacks ----- */
1915struct hci_cb {
1916 struct list_head list;
1917
1918 char *name;
1919
539c496d 1920 void (*connect_cfm) (struct hci_conn *conn, __u8 status);
3a6d576b 1921 void (*disconn_cfm) (struct hci_conn *conn, __u8 status);
5a9d0a3f
WR		 1922 void (*security_cfm) (struct hci_conn *conn, __u8 status,
1923 __u8 encrypt);
1da177e4
LT		 1924 void (*key_change_cfm) (struct hci_conn *conn, __u8 status);
1925 void (*role_switch_cfm) (struct hci_conn *conn, __u8 status, __u8 role);
1926};
1927
539c496d
JH		 1928static inline void hci_connect_cfm(struct hci_conn *conn, __u8 status)
1929{
1930 struct hci_cb *cb;
1931
1932 mutex_lock(&hci_cb_list_lock);
1933 list_for_each_entry(cb, &hci_cb_list, list) {
1934 if (cb->connect_cfm)
1935 cb->connect_cfm(conn, status);
1936 }
1937 mutex_unlock(&hci_cb_list_lock);
1938
1939 if (conn->connect_cfm_cb)
1940 conn->connect_cfm_cb(conn, status);
1941}
1942
3a6d576b
JH		 1943static inline void hci_disconn_cfm(struct hci_conn *conn, __u8 reason)
1944{
1945 struct hci_cb *cb;
1946
1947 mutex_lock(&hci_cb_list_lock);
1948 list_for_each_entry(cb, &hci_cb_list, list) {
1949 if (cb->disconn_cfm)
1950 cb->disconn_cfm(conn, reason);
1951 }
1952 mutex_unlock(&hci_cb_list_lock);
1953
1954 if (conn->disconn_cfm_cb)
1955 conn->disconn_cfm_cb(conn, reason);
1956}
1957
1da177e4
LT		 1958static inline void hci_auth_cfm(struct hci_conn *conn, __u8 status)
1959{
711584ea 1960 struct hci_cb *cb;
8c1b2355 1961 __u8 encrypt;
1da177e4 1962
51a8efd7 1963 if (test_bit(HCI_CONN_ENCRYPT_PEND, &conn->flags))
8c1b2355
MH		 1964 return;
1965
4dae2798 1966 encrypt = test_bit(HCI_CONN_ENCRYPT, &conn->flags) ? 0x01 : 0x00;
8c1b2355 1967
fba7ecf0 1968 mutex_lock(&hci_cb_list_lock);
711584ea 1969 list_for_each_entry(cb, &hci_cb_list, list) {
8c1b2355
MH		 1970 if (cb->security_cfm)
1971 cb->security_cfm(conn, status, encrypt);
1da177e4 1972 }
fba7ecf0 1973 mutex_unlock(&hci_cb_list_lock);
354fe804
JH		 1974
1975 if (conn->security_cfm_cb)
1976 conn->security_cfm_cb(conn, status);
1da177e4
LT		 1977}
1978
3ca44c16 1979static inline void hci_encrypt_cfm(struct hci_conn *conn, __u8 status)
1da177e4 1980{
711584ea 1981 struct hci_cb *cb;
3ca44c16
LAD		 1982 __u8 encrypt;
1983
1984 if (conn->state == BT_CONFIG) {
339ddaa6 1985 if (!status)
3ca44c16
LAD		 1986 conn->state = BT_CONNECTED;
1987
1988 hci_connect_cfm(conn, status);
1989 hci_conn_drop(conn);
1990 return;
1991 }
1992
1993 if (!test_bit(HCI_CONN_ENCRYPT, &conn->flags))
1994 encrypt = 0x00;
1995 else if (test_bit(HCI_CONN_AES_CCM, &conn->flags))
1996 encrypt = 0x02;
1997 else
1998 encrypt = 0x01;
1da177e4 1999
8746f135
LAD		 2000 if (!status) {
2001 if (conn->sec_level == BT_SECURITY_SDP)
2002 conn->sec_level = BT_SECURITY_LOW;
435fef20 2003
8746f135
LAD		 2004 if (conn->pending_sec_level > conn->sec_level)
2005 conn->sec_level = conn->pending_sec_level;
2006 }
88167aed 2007
fba7ecf0 2008 mutex_lock(&hci_cb_list_lock);
711584ea 2009 list_for_each_entry(cb, &hci_cb_list, list) {
8c1b2355
MH		 2010 if (cb->security_cfm)
2011 cb->security_cfm(conn, status, encrypt);
1da177e4 2012 }
fba7ecf0 2013 mutex_unlock(&hci_cb_list_lock);
354fe804
JH		 2014
2015 if (conn->security_cfm_cb)
2016 conn->security_cfm_cb(conn, status);
1da177e4
LT		 2017}
2018
2019static inline void hci_key_change_cfm(struct hci_conn *conn, __u8 status)
2020{
711584ea 2021 struct hci_cb *cb;
1da177e4 2022
fba7ecf0 2023 mutex_lock(&hci_cb_list_lock);
711584ea 2024 list_for_each_entry(cb, &hci_cb_list, list) {
1da177e4
LT		 2025 if (cb->key_change_cfm)
2026 cb->key_change_cfm(conn, status);
2027 }
fba7ecf0 2028 mutex_unlock(&hci_cb_list_lock);
1da177e4
LT		 2029}
2030
5a9d0a3f
WR		 2031static inline void hci_role_switch_cfm(struct hci_conn *conn, __u8 status,
2032 __u8 role)
1da177e4 2033{
711584ea 2034 struct hci_cb *cb;
1da177e4 2035
fba7ecf0 2036 mutex_lock(&hci_cb_list_lock);
711584ea 2037 list_for_each_entry(cb, &hci_cb_list, list) {
1da177e4
LT		 2038 if (cb->role_switch_cfm)
2039 cb->role_switch_cfm(conn, status, role);
2040 }
fba7ecf0 2041 mutex_unlock(&hci_cb_list_lock);
1da177e4
LT		 2042}
2043
301cb2d8
JH		 2044static inline bool hci_bdaddr_is_rpa(bdaddr_t *bdaddr, u8 addr_type)
2045{
dbbfa2ab 2046 if (addr_type != ADDR_LE_DEV_RANDOM)
301cb2d8
JH		 2047 return false;
2048
2049 if ((bdaddr->b[5] & 0xc0) == 0x40)
2050 return true;
2051
2052 return false;
2053}
2054
c46245b3
JH		 2055static inline bool hci_is_identity_address(bdaddr_t *addr, u8 addr_type)
2056{
2057 if (addr_type == ADDR_LE_DEV_PUBLIC)
2058 return true;
2059
2060 /* Check for Random Static address type */
2061 if ((addr->b[5] & 0xc0) == 0xc0)
2062 return true;
2063
2064 return false;
2065}
2066
2426f3a5
JH		 2067static inline struct smp_irk *hci_get_irk(struct hci_dev *hdev,
2068 bdaddr_t *bdaddr, u8 addr_type)
2069{
2070 if (!hci_bdaddr_is_rpa(bdaddr, addr_type))
2071 return NULL;
2072
2073 return hci_find_irk_by_rpa(hdev, bdaddr);
2074}
2075
d4905f24
AG		 2076static inline int hci_check_conn_params(u16 min, u16 max, u16 latency,
2077 u16 to_multiplier)
2078{
2079 u16 max_latency;
2080
2081 if (min > max || min < 6 || max > 3200)
2082 return -EINVAL;
2083
2084 if (to_multiplier < 10 || to_multiplier > 3200)
2085 return -EINVAL;
2086
2087 if (max >= to_multiplier * 8)
2088 return -EINVAL;
2089
8757825b 2090 max_latency = (to_multiplier * 4 / max) - 1;
d4905f24
AG		 2091 if (latency > 499 || latency > max_latency)
2092 return -EINVAL;
2093
2094 return 0;
2095}
2096
1da177e4
LT		 2097int hci_register_cb(struct hci_cb *hcb);
2098int hci_unregister_cb(struct hci_cb *hcb);
2099
d6ee6ad7
LP		 2100int __hci_cmd_send(struct hci_dev *hdev, u16 opcode, u32 plen,
2101 const void *param);
75e84b7c 2102
07dc93dd
JH		 2103int hci_send_cmd(struct hci_dev *hdev, __u16 opcode, __u32 plen,
2104 const void *param);
73d80deb 2105void hci_send_acl(struct hci_chan *chan, struct sk_buff *skb, __u16 flags);
0d861d8b 2106void hci_send_sco(struct hci_conn *conn, struct sk_buff *skb);
26afbd82 2107void hci_send_iso(struct hci_conn *conn, struct sk_buff *skb);
1da177e4 2108
a9de9248 2109void *hci_sent_cmd_data(struct hci_dev *hdev, __u16 opcode);
dfe6d5c3 2110void *hci_recv_event_data(struct hci_dev *hdev, __u8 event);
1da177e4 2111
eab2404b
LAD		 2112u32 hci_conn_get_phy(struct hci_conn *conn);
2113
1da177e4 2114/* ----- HCI Sockets ----- */
470fe1b5 2115void hci_send_to_sock(struct hci_dev *hdev, struct sk_buff *skb);
7129069e 2116void hci_send_to_channel(unsigned short channel, struct sk_buff *skb,
c08b1a1d 2117 int flag, struct sock *skip_sk);
cd82e61c 2118void hci_send_to_monitor(struct hci_dev *hdev, struct sk_buff *skb);
38ceaa00
MH		 2119void hci_send_monitor_ctrl_event(struct hci_dev *hdev, u16 event,
2120 void *data, u16 data_len, ktime_t tstamp,
2121 int flag, struct sock *skip_sk);
1da177e4 2122
040030ef
MH		 2123void hci_sock_dev_event(struct hci_dev *hdev, int event);
2124
a958452a
MH		 2125#define HCI_MGMT_VAR_LEN BIT(0)
2126#define HCI_MGMT_NO_HDEV BIT(1)
2127#define HCI_MGMT_UNTRUSTED BIT(2)
2128#define HCI_MGMT_UNCONFIGURED BIT(3)
d5cc6626 2129#define HCI_MGMT_HDEV_OPTIONAL BIT(4)
b9a245fb 2130
801c1e8d
JH		 2131struct hci_mgmt_handler {
2132 int (*func) (struct sock *sk, struct hci_dev *hdev, void *data,
2133 u16 data_len);
801c1e8d 2134 size_t data_len;
b9a245fb 2135 unsigned long flags;
801c1e8d
JH		 2136};
2137
2138struct hci_mgmt_chan {
2139 struct list_head list;
2140 unsigned short channel;
2141 size_t handler_count;
2142 const struct hci_mgmt_handler *handlers;
88b94ce9 2143 void (*hdev_init) (struct sock *sk, struct hci_dev *hdev);
801c1e8d
JH		 2144};
2145
2146int hci_mgmt_chan_register(struct hci_mgmt_chan *c);
2147void hci_mgmt_chan_unregister(struct hci_mgmt_chan *c);
2148
0381101f 2149/* Management interface */
591f47f3
AG		 2150#define DISCOV_TYPE_BREDR (BIT(BDADDR_BREDR))
2151#define DISCOV_TYPE_LE (BIT(BDADDR_LE_PUBLIC) | \
2152 BIT(BDADDR_LE_RANDOM))
2153#define DISCOV_TYPE_INTERLEAVED (BIT(BDADDR_BREDR) | \
2154 BIT(BDADDR_LE_PUBLIC) | \
2155 BIT(BDADDR_LE_RANDOM))
f39799f5 2156
0d8cc935
AG		 2157/* These LE scan and inquiry parameters were chosen according to LE General
2158 * Discovery Procedure specification.
2159 */
2160#define DISCOV_LE_SCAN_WIN 0x12
2161#define DISCOV_LE_SCAN_INT 0x12
3d5a76f0 2162#define DISCOV_LE_TIMEOUT 10240 /* msec */
ae55f598 2163#define DISCOV_INTERLEAVED_TIMEOUT 5120 /* msec */
0d8cc935
AG		 2164#define DISCOV_INTERLEAVED_INQUIRY_LEN 0x04
2165#define DISCOV_BREDR_INQUIRY_LEN 0x08
4b0e0ced 2166#define DISCOV_LE_RESTART_DELAY msecs_to_jiffies(200) /* msec */
cfa15cca
MH		 2167#define DISCOV_LE_FAST_ADV_INT_MIN 0x00A0 /* 100 msec */
2168#define DISCOV_LE_FAST_ADV_INT_MAX 0x00F0 /* 150 msec */
eca0ae4a
LAD		 2169#define DISCOV_LE_PER_ADV_INT_MIN 0x00A0 /* 200 msec */
2170#define DISCOV_LE_PER_ADV_INT_MAX 0x00A0 /* 200 msec */
b338d917
BG		 2171#define DISCOV_LE_ADV_MESH_MIN 0x00A0 /* 100 msec */
2172#define DISCOV_LE_ADV_MESH_MAX 0x00A0 /* 100 msec */
2173#define INTERVAL_TO_MS(x) (((x) * 10) / 0x10)
0d8cc935 2174
dbf6811a
AP		 2175#define NAME_RESOLVE_DURATION msecs_to_jiffies(10240) /* 10.24 sec */
2176
03c979c4 2177void mgmt_fill_version_info(void *ver);
91a668b0 2178int mgmt_new_settings(struct hci_dev *hdev);
bf6b56db
MH		 2179void mgmt_index_added(struct hci_dev *hdev);
2180void mgmt_index_removed(struct hci_dev *hdev);
3eec705e 2181void mgmt_set_powered_failed(struct hci_dev *hdev, int err);
2ff13894
JH		 2182void mgmt_power_on(struct hci_dev *hdev, int err);
2183void __mgmt_power_off(struct hci_dev *hdev);
dc4a5ee2
MH		 2184void mgmt_new_link_key(struct hci_dev *hdev, struct link_key *key,
2185 bool persistent);
48ec92fa 2186void mgmt_device_connected(struct hci_dev *hdev, struct hci_conn *conn,
1c6ed31b 2187 u8 *name, u8 name_len);
9b80ec5e 2188void mgmt_device_disconnected(struct hci_dev *hdev, bdaddr_t *bdaddr,
12d4a3b2
JH		 2189 u8 link_type, u8 addr_type, u8 reason,
2190 bool mgmt_connected);
7892924c
MH		 2191void mgmt_disconnect_failed(struct hci_dev *hdev, bdaddr_t *bdaddr,
2192 u8 link_type, u8 addr_type, u8 status);
445608d0
MH		 2193void mgmt_connect_failed(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type,
2194 u8 addr_type, u8 status);
ce0e4a0d 2195void mgmt_pin_code_request(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 secure);
e669cf80
MH		 2196void mgmt_pin_code_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
2197 u8 status);
3eb38528
MH		 2198void mgmt_pin_code_neg_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
2199 u8 status);
744cf19e 2200int mgmt_user_confirm_request(struct hci_dev *hdev, bdaddr_t *bdaddr,
39adbffe 2201 u8 link_type, u8 addr_type, u32 value,
04124681 2202 u8 confirm_hint);
744cf19e 2203int mgmt_user_confirm_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
04124681 2204 u8 link_type, u8 addr_type, u8 status);
272d90df 2205int mgmt_user_confirm_neg_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
04124681 2206 u8 link_type, u8 addr_type, u8 status);
272d90df 2207int mgmt_user_passkey_request(struct hci_dev *hdev, bdaddr_t *bdaddr,
04124681 2208 u8 link_type, u8 addr_type);
604086b7 2209int mgmt_user_passkey_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
04124681 2210 u8 link_type, u8 addr_type, u8 status);
272d90df 2211int mgmt_user_passkey_neg_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
04124681 2212 u8 link_type, u8 addr_type, u8 status);
92a25256
JH		 2213int mgmt_user_passkey_notify(struct hci_dev *hdev, bdaddr_t *bdaddr,
2214 u8 link_type, u8 addr_type, u32 passkey,
2215 u8 entered);
e1e930f5 2216void mgmt_auth_failed(struct hci_conn *conn, u8 status);
464996ae 2217void mgmt_auth_enable_complete(struct hci_dev *hdev, u8 status);
4e1b0245
MH		 2218void mgmt_set_class_of_dev_complete(struct hci_dev *hdev, u8 *dev_class,
2219 u8 status);
7667da34 2220void mgmt_set_local_name_complete(struct hci_dev *hdev, u8 *name, u8 status);
e68f072b 2221void mgmt_start_discovery_complete(struct hci_dev *hdev, u8 status);
2154d3f4 2222void mgmt_stop_discovery_complete(struct hci_dev *hdev, u8 status);
901801b9 2223void mgmt_device_found(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type,
af58925c 2224 u8 addr_type, u8 *dev_class, s8 rssi, u32 flags,
b338d917
BG		 2225 u8 *eir, u16 eir_len, u8 *scan_rsp, u8 scan_rsp_len,
2226 u64 instant);
9cf12aee
MH		 2227void mgmt_remote_name(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type,
2228 u8 addr_type, s8 rssi, u8 *name, u8 name_len);
2f1e063b 2229void mgmt_discovering(struct hci_dev *hdev, u8 discovering);
346ce5b7
APS		 2230void mgmt_suspending(struct hci_dev *hdev, u8 state);
2231void mgmt_resuming(struct hci_dev *hdev, u8 reason, bdaddr_t *bdaddr,
2232 u8 addr_type);
84c61d92 2233bool mgmt_powering_down(struct hci_dev *hdev);
53ac6ab6 2234void mgmt_new_ltk(struct hci_dev *hdev, struct smp_ltk *key, bool persistent);
cad20c27 2235void mgmt_new_irk(struct hci_dev *hdev, struct smp_irk *irk, bool persistent);
53ac6ab6
MH		 2236void mgmt_new_csrk(struct hci_dev *hdev, struct smp_csrk *csrk,
2237 bool persistent);
ffb5a827 2238void mgmt_new_conn_param(struct hci_dev *hdev, bdaddr_t *bdaddr,
f4869e2a
JH		 2239 u8 bdaddr_type, u8 store_hint, u16 min_interval,
2240 u16 max_interval, u16 latency, u16 timeout);
f4a407be 2241void mgmt_smp_complete(struct hci_conn *conn, bool complete);
f2252570
JH		 2242bool mgmt_get_connectable(struct hci_dev *hdev);
2243u8 mgmt_get_adv_discov_flags(struct hci_dev *hdev);
2244void mgmt_advertising_added(struct sock *sk, struct hci_dev *hdev,
2245 u8 instance);
2246void mgmt_advertising_removed(struct sock *sk, struct hci_dev *hdev,
2247 u8 instance);
66bd095a 2248void mgmt_adv_monitor_removed(struct hci_dev *hdev, u16 handle);
b7c23df8 2249int mgmt_phy_configuration_changed(struct hci_dev *hdev, struct sock *skip);
8d7f1677
MM		 2250void mgmt_adv_monitor_device_lost(struct hci_dev *hdev, u16 handle,
2251 bdaddr_t *bdaddr, u8 addr_type);
346af67b 2252
1a942de0 2253int hci_abort_conn(struct hci_conn *conn, u8 reason);
7d6ca693
JH		 2254u8 hci_le_conn_update(struct hci_conn *conn, u16 min, u16 max, u16 latency,
2255 u16 to_multiplier);
fe39c7b2 2256void hci_le_start_enc(struct hci_conn *conn, __le16 ediv, __le64 rand,
8b76ce34 2257 __u8 ltk[16], __u8 key_size);
2519a1fc 2258
a1f4c318
JH		 2259void hci_copy_identity_address(struct hci_dev *hdev, bdaddr_t *bdaddr,
2260 u8 *bdaddr_type);
ebd3a747 2261
5d4d62f6
FD		 2262#define SCO_AIRMODE_MASK 0x0003
2263#define SCO_AIRMODE_CVSD 0x0000
2264#define SCO_AIRMODE_TRANSP 0x0003
2265
8961987f
K		 2266#define LOCAL_CODEC_ACL_MASK BIT(0)
2267#define LOCAL_CODEC_SCO_MASK BIT(1)
2268
2269#define TRANSPORT_TYPE_MAX 0x04
2270
1da177e4 2271#endif /* __HCI_CORE_H */
Mirror https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git