include/net/bluetooth/hci_core.h

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