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