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