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
   5    Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License version 2 as
   9    published by the Free Software Foundation;
  10
  11    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  12    OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  13    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
  14    IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
  15    CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
  16    WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  17    ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  18    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  19
  20    ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
  21    COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
  22    SOFTWARE IS DISCLAIMED.
  23 */
  24
  25 #ifndef __HCI_CORE_H
  26 #define __HCI_CORE_H
  27
  28 #include <linux/idr.h>
  29 #include <linux/leds.h>
  30 #include <linux/rculist.h>
  31
  32 #include <net/bluetooth/hci.h>
  33 #include <net/bluetooth/hci_sock.h>
  34
  35 /* HCI priority */
  36 #define HCI_PRIO_MAX    7
  37
  38 /* HCI Core structures */
  39 struct inquiry_data {
  40         bdaddr_t        bdaddr;
  41         __u8            pscan_rep_mode;
  42         __u8            pscan_period_mode;
  43         __u8            pscan_mode;
  44         __u8            dev_class[3];
  45         __le16          clock_offset;
  46         __s8            rssi;
  47         __u8            ssp_mode;
  48 };
  49
  50 struct inquiry_entry {
  51         struct list_head        all;            /* inq_cache.all */
  52         struct list_head        list;           /* unknown or resolve */
  53         enum {
  54                 NAME_NOT_KNOWN,
  55                 NAME_NEEDED,
  56                 NAME_PENDING,
  57                 NAME_KNOWN,
  58         } name_state;
  59         __u32                   timestamp;
  60         struct inquiry_data     data;
  61 };
  62
  63 struct discovery_state {
  64         int                     type;
  65         enum {
  66                 DISCOVERY_STOPPED,
  67                 DISCOVERY_STARTING,
  68                 DISCOVERY_FINDING,
  69                 DISCOVERY_RESOLVING,
  70                 DISCOVERY_STOPPING,
  71         } state;
  72         struct list_head        all;    /* All devices found during inquiry */
  73         struct list_head        unknown;        /* Name state not known */
  74         struct list_head        resolve;        /* Name needs to be resolved */
  75         __u32                   timestamp;
  76         bdaddr_t                last_adv_addr;
  77         u8                      last_adv_addr_type;
  78         s8                      last_adv_rssi;
  79         u32                     last_adv_flags;
  80         u8                      last_adv_data[HCI_MAX_AD_LENGTH];
  81         u8                      last_adv_data_len;
  82         bool                    report_invalid_rssi;
  83         bool                    result_filtering;
  84         bool                    limited;
  85         s8                      rssi;
  86         u16                     uuid_count;
  87         u8                      (*uuids)[16];
  88         unsigned long           scan_start;
  89         unsigned long           scan_duration;
  90 };
  91
  92 #define SUSPEND_NOTIFIER_TIMEOUT        msecs_to_jiffies(2000) /* 2 seconds */
  93
  94 enum suspend_tasks {
  95         SUSPEND_PAUSE_DISCOVERY,
  96         SUSPEND_UNPAUSE_DISCOVERY,
  97
  98         SUSPEND_PAUSE_ADVERTISING,
  99         SUSPEND_UNPAUSE_ADVERTISING,
 100
 101         SUSPEND_SCAN_DISABLE,
 102         SUSPEND_SCAN_ENABLE,
 103         SUSPEND_DISCONNECTING,
 104
 105         SUSPEND_POWERING_DOWN,
 106
 107         SUSPEND_PREPARE_NOTIFIER,
 108         __SUSPEND_NUM_TASKS
 109 };
 110
 111 enum suspended_state {
 112         BT_RUNNING = 0,
 113         BT_SUSPEND_DISCONNECT,
 114         BT_SUSPEND_CONFIGURE_WAKE,
 115 };
 116
 117 struct hci_conn_hash {
 118         struct list_head list;
 119         unsigned int     acl_num;
 120         unsigned int     amp_num;
 121         unsigned int     sco_num;
 122         unsigned int     le_num;
 123         unsigned int     le_num_slave;
 124 };
 125
 126 struct bdaddr_list {
 127         struct list_head list;
 128         bdaddr_t bdaddr;
 129         u8 bdaddr_type;
 130 };
 131
 132 struct bdaddr_list_with_irk {
 133         struct list_head list;
 134         bdaddr_t bdaddr;
 135         u8 bdaddr_type;
 136         u8 peer_irk[16];
 137         u8 local_irk[16];
 138 };
 139
 140 struct bdaddr_list_with_flags {
 141         struct list_head list;
 142         bdaddr_t bdaddr;
 143         u8 bdaddr_type;
 144         u32 current_flags;
 145 };
 146
 147 enum hci_conn_flags {
 148         HCI_CONN_FLAG_REMOTE_WAKEUP,
 149         HCI_CONN_FLAG_MAX
 150 };
 151
 152 #define hci_conn_test_flag(nr, flags) ((flags) & (1U << nr))
 153
 154 /* Make sure number of flags doesn't exceed sizeof(current_flags) */
 155 static_assert(HCI_CONN_FLAG_MAX < 32);
 156
 157 struct bt_uuid {
 158         struct list_head list;
 159         u8 uuid[16];
 160         u8 size;
 161         u8 svc_hint;
 162 };
 163
 164 struct blocked_key {
 165         struct list_head list;
 166         struct rcu_head rcu;
 167         u8 type;
 168         u8 val[16];
 169 };
 170
 171 struct smp_csrk {
 172         bdaddr_t bdaddr;
 173         u8 bdaddr_type;
 174         u8 type;
 175         u8 val[16];
 176 };
 177
 178 struct smp_ltk {
 179         struct list_head list;
 180         struct rcu_head rcu;
 181         bdaddr_t bdaddr;
 182         u8 bdaddr_type;
 183         u8 authenticated;
 184         u8 type;
 185         u8 enc_size;
 186         __le16 ediv;
 187         __le64 rand;
 188         u8 val[16];
 189 };
 190
 191 struct smp_irk {
 192         struct list_head list;
 193         struct rcu_head rcu;
 194         bdaddr_t rpa;
 195         bdaddr_t bdaddr;
 196         u8 addr_type;
 197         u8 val[16];
 198 };
 199
 200 struct link_key {
 201         struct list_head list;
 202         struct rcu_head rcu;
 203         bdaddr_t bdaddr;
 204         u8 type;
 205         u8 val[HCI_LINK_KEY_SIZE];
 206         u8 pin_len;
 207 };
 208
 209 struct oob_data {
 210         struct list_head list;
 211         bdaddr_t bdaddr;
 212         u8 bdaddr_type;
 213         u8 present;
 214         u8 hash192[16];
 215         u8 rand192[16];
 216         u8 hash256[16];
 217         u8 rand256[16];
 218 };
 219
 220 struct adv_info {
 221         struct list_head list;
 222         bool pending;
 223         __u8    instance;
 224         __u32   flags;
 225         __u16   timeout;
 226         __u16   remaining_time;
 227         __u16   duration;
 228         __u16   adv_data_len;
 229         __u8    adv_data[HCI_MAX_AD_LENGTH];
 230         __u16   scan_rsp_len;
 231         __u8    scan_rsp_data[HCI_MAX_AD_LENGTH];
 232         __s8    tx_power;
 233         bdaddr_t        random_addr;
 234         bool            rpa_expired;
 235         struct delayed_work     rpa_expired_cb;
 236 };
 237
 238 #define HCI_MAX_ADV_INSTANCES           5
 239 #define HCI_DEFAULT_ADV_DURATION        2
 240
 241 struct adv_pattern {
 242         struct list_head list;
 243         __u8 ad_type;
 244         __u8 offset;
 245         __u8 length;
 246         __u8 value[HCI_MAX_AD_LENGTH];
 247 };
 248
 249 struct adv_monitor {
 250         struct list_head patterns;
 251         bool            active;
 252         __u16           handle;
 253 };
 254
 255 #define HCI_MIN_ADV_MONITOR_HANDLE              1
 256 #define HCI_MAX_ADV_MONITOR_NUM_HANDLES 32
 257 #define HCI_MAX_ADV_MONITOR_NUM_PATTERNS        16
 258
 259 #define HCI_MAX_SHORT_NAME_LENGTH       10
 260
 261 /* Min encryption key size to match with SMP */
 262 #define HCI_MIN_ENC_KEY_SIZE            7
 263
 264 /* Default LE RPA expiry time, 15 minutes */
 265 #define HCI_DEFAULT_RPA_TIMEOUT         (15 * 60)
 266
 267 /* Default min/max age of connection information (1s/3s) */
 268 #define DEFAULT_CONN_INFO_MIN_AGE       1000
 269 #define DEFAULT_CONN_INFO_MAX_AGE       3000
 270 /* Default authenticated payload timeout 30s */
 271 #define DEFAULT_AUTH_PAYLOAD_TIMEOUT   0x0bb8
 272
 273 struct amp_assoc {
 274         __u16   len;
 275         __u16   offset;
 276         __u16   rem_len;
 277         __u16   len_so_far;
 278         __u8    data[HCI_MAX_AMP_ASSOC_SIZE];
 279 };
 280
 281 #define HCI_MAX_PAGES   3
 282
 283 struct hci_dev {
 284         struct list_head list;
 285         struct mutex    lock;
 286
 287         char            name[8];
 288         unsigned long   flags;
 289         __u16           id;
 290         __u8            bus;
 291         __u8            dev_type;
 292         bdaddr_t        bdaddr;
 293         bdaddr_t        setup_addr;
 294         bdaddr_t        public_addr;
 295         bdaddr_t        random_addr;
 296         bdaddr_t        static_addr;
 297         __u8            adv_addr_type;
 298         __u8            dev_name[HCI_MAX_NAME_LENGTH];
 299         __u8            short_name[HCI_MAX_SHORT_NAME_LENGTH];
 300         __u8            eir[HCI_MAX_EIR_LENGTH];
 301         __u16           appearance;
 302         __u8            dev_class[3];
 303         __u8            major_class;
 304         __u8            minor_class;
 305         __u8            max_page;
 306         __u8            features[HCI_MAX_PAGES][8];
 307         __u8            le_features[8];
 308         __u8            le_white_list_size;
 309         __u8            le_resolv_list_size;
 310         __u8            le_num_of_adv_sets;
 311         __u8            le_states[8];
 312         __u8            commands[64];
 313         __u8            hci_ver;
 314         __u16           hci_rev;
 315         __u8            lmp_ver;
 316         __u16           manufacturer;
 317         __u16           lmp_subver;
 318         __u16           voice_setting;
 319         __u8            num_iac;
 320         __u8            stored_max_keys;
 321         __u8            stored_num_keys;
 322         __u8            io_capability;
 323         __s8            inq_tx_power;
 324         __u8            err_data_reporting;
 325         __u16           page_scan_interval;
 326         __u16           page_scan_window;
 327         __u8            page_scan_type;
 328         __u8            le_adv_channel_map;
 329         __u16           le_adv_min_interval;
 330         __u16           le_adv_max_interval;
 331         __u8            le_scan_type;
 332         __u16           le_scan_interval;
 333         __u16           le_scan_window;
 334         __u16           le_scan_int_suspend;
 335         __u16           le_scan_window_suspend;
 336         __u16           le_scan_int_discovery;
 337         __u16           le_scan_window_discovery;
 338         __u16           le_scan_int_adv_monitor;
 339         __u16           le_scan_window_adv_monitor;
 340         __u16           le_scan_int_connect;
 341         __u16           le_scan_window_connect;
 342         __u16           le_conn_min_interval;
 343         __u16           le_conn_max_interval;
 344         __u16           le_conn_latency;
 345         __u16           le_supv_timeout;
 346         __u16           le_def_tx_len;
 347         __u16           le_def_tx_time;
 348         __u16           le_max_tx_len;
 349         __u16           le_max_tx_time;
 350         __u16           le_max_rx_len;
 351         __u16           le_max_rx_time;
 352         __u8            le_max_key_size;
 353         __u8            le_min_key_size;
 354         __u16           discov_interleaved_timeout;
 355         __u16           conn_info_min_age;
 356         __u16           conn_info_max_age;
 357         __u16           auth_payload_timeout;
 358         __u8            min_enc_key_size;
 359         __u8            max_enc_key_size;
 360         __u8            pairing_opts;
 361         __u8            ssp_debug_mode;
 362         __u8            hw_error_code;
 363         __u32           clock;
 364
 365         __u16           devid_source;
 366         __u16           devid_vendor;
 367         __u16           devid_product;
 368         __u16           devid_version;
 369
 370         __u8            def_page_scan_type;
 371         __u16           def_page_scan_int;
 372         __u16           def_page_scan_window;
 373         __u8            def_inq_scan_type;
 374         __u16           def_inq_scan_int;
 375         __u16           def_inq_scan_window;
 376         __u16           def_br_lsto;
 377         __u16           def_page_timeout;
 378         __u16           def_multi_adv_rotation_duration;
 379         __u16           def_le_autoconnect_timeout;
 380
 381         __u16           pkt_type;
 382         __u16           esco_type;
 383         __u16           link_policy;
 384         __u16           link_mode;
 385
 386         __u32           idle_timeout;
 387         __u16           sniff_min_interval;
 388         __u16           sniff_max_interval;
 389
 390         __u8            amp_status;
 391         __u32           amp_total_bw;
 392         __u32           amp_max_bw;
 393         __u32           amp_min_latency;
 394         __u32           amp_max_pdu;
 395         __u8            amp_type;
 396         __u16           amp_pal_cap;
 397         __u16           amp_assoc_size;
 398         __u32           amp_max_flush_to;
 399         __u32           amp_be_flush_to;
 400
 401         struct amp_assoc        loc_assoc;
 402
 403         __u8            flow_ctl_mode;
 404
 405         unsigned int    auto_accept_delay;
 406
 407         unsigned long   quirks;
 408
 409         atomic_t        cmd_cnt;
 410         unsigned int    acl_cnt;
 411         unsigned int    sco_cnt;
 412         unsigned int    le_cnt;
 413
 414         unsigned int    acl_mtu;
 415         unsigned int    sco_mtu;
 416         unsigned int    le_mtu;
 417         unsigned int    acl_pkts;
 418         unsigned int    sco_pkts;
 419         unsigned int    le_pkts;
 420
 421         __u16           block_len;
 422         __u16           block_mtu;
 423         __u16           num_blocks;
 424         __u16           block_cnt;
 425
 426         unsigned long   acl_last_tx;
 427         unsigned long   sco_last_tx;
 428         unsigned long   le_last_tx;
 429
 430         __u8            le_tx_def_phys;
 431         __u8            le_rx_def_phys;
 432
 433         struct workqueue_struct *workqueue;
 434         struct workqueue_struct *req_workqueue;
 435
 436         struct work_struct      power_on;
 437         struct delayed_work     power_off;
 438         struct work_struct      error_reset;
 439
 440         __u16                   discov_timeout;
 441         struct delayed_work     discov_off;
 442
 443         struct delayed_work     service_cache;
 444
 445         struct delayed_work     cmd_timer;
 446
 447         struct work_struct      rx_work;
 448         struct work_struct      cmd_work;
 449         struct work_struct      tx_work;
 450
 451         struct work_struct      discov_update;
 452         struct work_struct      bg_scan_update;
 453         struct work_struct      scan_update;
 454         struct work_struct      connectable_update;
 455         struct work_struct      discoverable_update;
 456         struct delayed_work     le_scan_disable;
 457         struct delayed_work     le_scan_restart;
 458
 459         struct sk_buff_head     rx_q;
 460         struct sk_buff_head     raw_q;
 461         struct sk_buff_head     cmd_q;
 462
 463         struct sk_buff          *sent_cmd;
 464
 465         struct mutex            req_lock;
 466         wait_queue_head_t       req_wait_q;
 467         __u32                   req_status;
 468         __u32                   req_result;
 469         struct sk_buff          *req_skb;
 470
 471         void                    *smp_data;
 472         void                    *smp_bredr_data;
 473
 474         struct discovery_state  discovery;
 475
 476         int                     discovery_old_state;
 477         bool                    discovery_paused;
 478         int                     advertising_old_state;
 479         bool                    advertising_paused;
 480
 481         struct notifier_block   suspend_notifier;
 482         struct work_struct      suspend_prepare;
 483         enum suspended_state    suspend_state_next;
 484         enum suspended_state    suspend_state;
 485         bool                    scanning_paused;
 486         bool                    suspended;
 487
 488         wait_queue_head_t       suspend_wait_q;
 489         DECLARE_BITMAP(suspend_tasks, __SUSPEND_NUM_TASKS);
 490
 491         struct hci_conn_hash    conn_hash;
 492
 493         struct list_head        mgmt_pending;
 494         struct list_head        blacklist;
 495         struct list_head        whitelist;
 496         struct list_head        uuids;
 497         struct list_head        link_keys;
 498         struct list_head        long_term_keys;
 499         struct list_head        identity_resolving_keys;
 500         struct list_head        remote_oob_data;
 501         struct list_head        le_white_list;
 502         struct list_head        le_resolv_list;
 503         struct list_head        le_conn_params;
 504         struct list_head        pend_le_conns;
 505         struct list_head        pend_le_reports;
 506         struct list_head        blocked_keys;
 507
 508         struct hci_dev_stats    stat;
 509
 510         atomic_t                promisc;
 511
 512         const char              *hw_info;
 513         const char              *fw_info;
 514         struct dentry           *debugfs;
 515
 516         struct device           dev;
 517
 518         struct rfkill           *rfkill;
 519
 520         DECLARE_BITMAP(dev_flags, __HCI_NUM_FLAGS);
 521
 522         __s8                    adv_tx_power;
 523         __u8                    adv_data[HCI_MAX_AD_LENGTH];
 524         __u8                    adv_data_len;
 525         __u8                    scan_rsp_data[HCI_MAX_AD_LENGTH];
 526         __u8                    scan_rsp_data_len;
 527
 528         struct list_head        adv_instances;
 529         unsigned int            adv_instance_cnt;
 530         __u8                    cur_adv_instance;
 531         __u16                   adv_instance_timeout;
 532         struct delayed_work     adv_instance_expire;
 533
 534         struct idr              adv_monitors_idr;
 535         unsigned int            adv_monitors_cnt;
 536
 537         __u8                    irk[16];
 538         __u32                   rpa_timeout;
 539         struct delayed_work     rpa_expired;
 540         bdaddr_t                rpa;
 541
 542 #if IS_ENABLED(CONFIG_BT_LEDS)
 543         struct led_trigger      *power_led;
 544 #endif
 545
 546 #if IS_ENABLED(CONFIG_BT_MSFTEXT)
 547         __u16                   msft_opcode;
 548         void                    *msft_data;
 549 #endif
 550
 551         int (*open)(struct hci_dev *hdev);
 552         int (*close)(struct hci_dev *hdev);
 553         int (*flush)(struct hci_dev *hdev);
 554         int (*setup)(struct hci_dev *hdev);
 555         int (*shutdown)(struct hci_dev *hdev);
 556         int (*send)(struct hci_dev *hdev, struct sk_buff *skb);
 557         void (*notify)(struct hci_dev *hdev, unsigned int evt);
 558         void (*hw_error)(struct hci_dev *hdev, u8 code);
 559         int (*post_init)(struct hci_dev *hdev);
 560         int (*set_diag)(struct hci_dev *hdev, bool enable);
 561         int (*set_bdaddr)(struct hci_dev *hdev, const bdaddr_t *bdaddr);
 562         void (*cmd_timeout)(struct hci_dev *hdev);
 563         bool (*prevent_wake)(struct hci_dev *hdev);
 564 };
 565
 566 #define HCI_PHY_HANDLE(handle)  (handle & 0xff)
 567
 568 enum conn_reasons {
 569         CONN_REASON_PAIR_DEVICE,
 570         CONN_REASON_L2CAP_CHAN,
 571         CONN_REASON_SCO_CONNECT,
 572 };
 573
 574 struct hci_conn {
 575         struct list_head list;
 576
 577         atomic_t        refcnt;
 578
 579         bdaddr_t        dst;
 580         __u8            dst_type;
 581         bdaddr_t        src;
 582         __u8            src_type;
 583         bdaddr_t        init_addr;
 584         __u8            init_addr_type;
 585         bdaddr_t        resp_addr;
 586         __u8            resp_addr_type;
 587         __u16           handle;
 588         __u16           state;
 589         __u8            mode;
 590         __u8            type;
 591         __u8            role;
 592         bool            out;
 593         __u8            attempt;
 594         __u8            dev_class[3];
 595         __u8            features[HCI_MAX_PAGES][8];
 596         __u16           pkt_type;
 597         __u16           link_policy;
 598         __u8            key_type;
 599         __u8            auth_type;
 600         __u8            sec_level;
 601         __u8            pending_sec_level;
 602         __u8            pin_length;
 603         __u8            enc_key_size;
 604         __u8            io_capability;
 605         __u32           passkey_notify;
 606         __u8            passkey_entered;
 607         __u16           disc_timeout;
 608         __u16           conn_timeout;
 609         __u16           setting;
 610         __u16           auth_payload_timeout;
 611         __u16           le_conn_min_interval;
 612         __u16           le_conn_max_interval;
 613         __u16           le_conn_interval;
 614         __u16           le_conn_latency;
 615         __u16           le_supv_timeout;
 616         __u8            le_adv_data[HCI_MAX_AD_LENGTH];
 617         __u8            le_adv_data_len;
 618         __u8            le_tx_phy;
 619         __u8            le_rx_phy;
 620         __s8            rssi;
 621         __s8            tx_power;
 622         __s8            max_tx_power;
 623         unsigned long   flags;
 624
 625         enum conn_reasons conn_reason;
 626
 627         __u32           clock;
 628         __u16           clock_accuracy;
 629
 630         unsigned long   conn_info_timestamp;
 631
 632         __u8            remote_cap;
 633         __u8            remote_auth;
 634         __u8            remote_id;
 635
 636         unsigned int    sent;
 637
 638         struct sk_buff_head data_q;
 639         struct list_head chan_list;
 640
 641         struct delayed_work disc_work;
 642         struct delayed_work auto_accept_work;
 643         struct delayed_work idle_work;
 644         struct delayed_work le_conn_timeout;
 645         struct work_struct  le_scan_cleanup;
 646
 647         struct device   dev;
 648         struct dentry   *debugfs;
 649
 650         struct hci_dev  *hdev;
 651         void            *l2cap_data;
 652         void            *sco_data;
 653         struct amp_mgr  *amp_mgr;
 654
 655         struct hci_conn *link;
 656
 657         void (*connect_cfm_cb)  (struct hci_conn *conn, u8 status);
 658         void (*security_cfm_cb) (struct hci_conn *conn, u8 status);
 659         void (*disconn_cfm_cb)  (struct hci_conn *conn, u8 reason);
 660 };
 661
 662 struct hci_chan {
 663         struct list_head list;
 664         __u16 handle;
 665         struct hci_conn *conn;
 666         struct sk_buff_head data_q;
 667         unsigned int    sent;
 668         __u8            state;
 669 };
 670
 671 struct hci_conn_params {
 672         struct list_head list;
 673         struct list_head action;
 674
 675         bdaddr_t addr;
 676         u8 addr_type;
 677
 678         u16 conn_min_interval;
 679         u16 conn_max_interval;
 680         u16 conn_latency;
 681         u16 supervision_timeout;
 682
 683         enum {
 684                 HCI_AUTO_CONN_DISABLED,
 685                 HCI_AUTO_CONN_REPORT,
 686                 HCI_AUTO_CONN_DIRECT,
 687                 HCI_AUTO_CONN_ALWAYS,
 688                 HCI_AUTO_CONN_LINK_LOSS,
 689                 HCI_AUTO_CONN_EXPLICIT,
 690         } auto_connect;
 691
 692         struct hci_conn *conn;
 693         bool explicit_connect;
 694         u32 current_flags;
 695 };
 696
 697 extern struct list_head hci_dev_list;
 698 extern struct list_head hci_cb_list;
 699 extern rwlock_t hci_dev_list_lock;
 700 extern struct mutex hci_cb_list_lock;
 701
 702 #define hci_dev_set_flag(hdev, nr)             set_bit((nr), (hdev)->dev_flags)
 703 #define hci_dev_clear_flag(hdev, nr)           clear_bit((nr), (hdev)->dev_flags)
 704 #define hci_dev_change_flag(hdev, nr)          change_bit((nr), (hdev)->dev_flags)
 705 #define hci_dev_test_flag(hdev, nr)            test_bit((nr), (hdev)->dev_flags)
 706 #define hci_dev_test_and_set_flag(hdev, nr)    test_and_set_bit((nr), (hdev)->dev_flags)
 707 #define hci_dev_test_and_clear_flag(hdev, nr)  test_and_clear_bit((nr), (hdev)->dev_flags)
 708 #define hci_dev_test_and_change_flag(hdev, nr) test_and_change_bit((nr), (hdev)->dev_flags)
 709
 710 #define hci_dev_clear_volatile_flags(hdev)                      \
 711         do {                                                    \
 712                 hci_dev_clear_flag(hdev, HCI_LE_SCAN);          \
 713                 hci_dev_clear_flag(hdev, HCI_LE_ADV);           \
 714                 hci_dev_clear_flag(hdev, HCI_LL_RPA_RESOLUTION);\
 715                 hci_dev_clear_flag(hdev, HCI_PERIODIC_INQ);     \
 716         } while (0)
 717
 718 /* ----- HCI interface to upper protocols ----- */
 719 int l2cap_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr);
 720 int l2cap_disconn_ind(struct hci_conn *hcon);
 721 void l2cap_recv_acldata(struct hci_conn *hcon, struct sk_buff *skb, u16 flags);
 722
 723 #if IS_ENABLED(CONFIG_BT_BREDR)
 724 int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 *flags);
 725 void sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb);
 726 #else
 727 static inline int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr,
 728                                   __u8 *flags)
 729 {
 730         return 0;
 731 }
 732
 733 static inline void sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb)
 734 {
 735 }
 736 #endif
 737
 738 /* ----- Inquiry cache ----- */
 739 #define INQUIRY_CACHE_AGE_MAX   (HZ*30)   /* 30 seconds */
 740 #define INQUIRY_ENTRY_AGE_MAX   (HZ*60)   /* 60 seconds */
 741
 742 static inline void discovery_init(struct hci_dev *hdev)
 743 {
 744         hdev->discovery.state = DISCOVERY_STOPPED;
 745         INIT_LIST_HEAD(&hdev->discovery.all);
 746         INIT_LIST_HEAD(&hdev->discovery.unknown);
 747         INIT_LIST_HEAD(&hdev->discovery.resolve);
 748         hdev->discovery.report_invalid_rssi = true;
 749         hdev->discovery.rssi = HCI_RSSI_INVALID;
 750 }
 751
 752 static inline void hci_discovery_filter_clear(struct hci_dev *hdev)
 753 {
 754         hdev->discovery.result_filtering = false;
 755         hdev->discovery.report_invalid_rssi = true;
 756         hdev->discovery.rssi = HCI_RSSI_INVALID;
 757         hdev->discovery.uuid_count = 0;
 758         kfree(hdev->discovery.uuids);
 759         hdev->discovery.uuids = NULL;
 760         hdev->discovery.scan_start = 0;
 761         hdev->discovery.scan_duration = 0;
 762 }
 763
 764 bool hci_discovery_active(struct hci_dev *hdev);
 765
 766 void hci_discovery_set_state(struct hci_dev *hdev, int state);
 767
 768 static inline int inquiry_cache_empty(struct hci_dev *hdev)
 769 {
 770         return list_empty(&hdev->discovery.all);
 771 }
 772
 773 static inline long inquiry_cache_age(struct hci_dev *hdev)
 774 {
 775         struct discovery_state *c = &hdev->discovery;
 776         return jiffies - c->timestamp;
 777 }
 778
 779 static inline long inquiry_entry_age(struct inquiry_entry *e)
 780 {
 781         return jiffies - e->timestamp;
 782 }
 783
 784 struct inquiry_entry *hci_inquiry_cache_lookup(struct hci_dev *hdev,
 785                                                bdaddr_t *bdaddr);
 786 struct inquiry_entry *hci_inquiry_cache_lookup_unknown(struct hci_dev *hdev,
 787                                                        bdaddr_t *bdaddr);
 788 struct inquiry_entry *hci_inquiry_cache_lookup_resolve(struct hci_dev *hdev,
 789                                                        bdaddr_t *bdaddr,
 790                                                        int state);
 791 void hci_inquiry_cache_update_resolve(struct hci_dev *hdev,
 792                                       struct inquiry_entry *ie);
 793 u32 hci_inquiry_cache_update(struct hci_dev *hdev, struct inquiry_data *data,
 794                              bool name_known);
 795 void hci_inquiry_cache_flush(struct hci_dev *hdev);
 796
 797 /* ----- HCI Connections ----- */
 798 enum {
 799         HCI_CONN_AUTH_PEND,
 800         HCI_CONN_REAUTH_PEND,
 801         HCI_CONN_ENCRYPT_PEND,
 802         HCI_CONN_RSWITCH_PEND,
 803         HCI_CONN_MODE_CHANGE_PEND,
 804         HCI_CONN_SCO_SETUP_PEND,
 805         HCI_CONN_MGMT_CONNECTED,
 806         HCI_CONN_SSP_ENABLED,
 807         HCI_CONN_SC_ENABLED,
 808         HCI_CONN_AES_CCM,
 809         HCI_CONN_POWER_SAVE,
 810         HCI_CONN_FLUSH_KEY,
 811         HCI_CONN_ENCRYPT,
 812         HCI_CONN_AUTH,
 813         HCI_CONN_SECURE,
 814         HCI_CONN_FIPS,
 815         HCI_CONN_STK_ENCRYPT,
 816         HCI_CONN_AUTH_INITIATOR,
 817         HCI_CONN_DROP,
 818         HCI_CONN_PARAM_REMOVAL_PEND,
 819         HCI_CONN_NEW_LINK_KEY,
 820         HCI_CONN_SCANNING,
 821         HCI_CONN_AUTH_FAILURE,
 822 };
 823
 824 static inline bool hci_conn_ssp_enabled(struct hci_conn *conn)
 825 {
 826         struct hci_dev *hdev = conn->hdev;
 827         return hci_dev_test_flag(hdev, HCI_SSP_ENABLED) &&
 828                test_bit(HCI_CONN_SSP_ENABLED, &conn->flags);
 829 }
 830
 831 static inline bool hci_conn_sc_enabled(struct hci_conn *conn)
 832 {
 833         struct hci_dev *hdev = conn->hdev;
 834         return hci_dev_test_flag(hdev, HCI_SC_ENABLED) &&
 835                test_bit(HCI_CONN_SC_ENABLED, &conn->flags);
 836 }
 837
 838 static inline void hci_conn_hash_add(struct hci_dev *hdev, struct hci_conn *c)
 839 {
 840         struct hci_conn_hash *h = &hdev->conn_hash;
 841         list_add_rcu(&c->list, &h->list);
 842         switch (c->type) {
 843         case ACL_LINK:
 844                 h->acl_num++;
 845                 break;
 846         case AMP_LINK:
 847                 h->amp_num++;
 848                 break;
 849         case LE_LINK:
 850                 h->le_num++;
 851                 if (c->role == HCI_ROLE_SLAVE)
 852                         h->le_num_slave++;
 853                 break;
 854         case SCO_LINK:
 855         case ESCO_LINK:
 856                 h->sco_num++;
 857                 break;
 858         }
 859 }
 860
 861 static inline void hci_conn_hash_del(struct hci_dev *hdev, struct hci_conn *c)
 862 {
 863         struct hci_conn_hash *h = &hdev->conn_hash;
 864
 865         list_del_rcu(&c->list);
 866         synchronize_rcu();
 867
 868         switch (c->type) {
 869         case ACL_LINK:
 870                 h->acl_num--;
 871                 break;
 872         case AMP_LINK:
 873                 h->amp_num--;
 874                 break;
 875         case LE_LINK:
 876                 h->le_num--;
 877                 if (c->role == HCI_ROLE_SLAVE)
 878                         h->le_num_slave--;
 879                 break;
 880         case SCO_LINK:
 881         case ESCO_LINK:
 882                 h->sco_num--;
 883                 break;
 884         }
 885 }
 886
 887 static inline unsigned int hci_conn_num(struct hci_dev *hdev, __u8 type)
 888 {
 889         struct hci_conn_hash *h = &hdev->conn_hash;
 890         switch (type) {
 891         case ACL_LINK:
 892                 return h->acl_num;
 893         case AMP_LINK:
 894                 return h->amp_num;
 895         case LE_LINK:
 896                 return h->le_num;
 897         case SCO_LINK:
 898         case ESCO_LINK:
 899                 return h->sco_num;
 900         default:
 901                 return 0;
 902         }
 903 }
 904
 905 static inline unsigned int hci_conn_count(struct hci_dev *hdev)
 906 {
 907         struct hci_conn_hash *c = &hdev->conn_hash;
 908
 909         return c->acl_num + c->amp_num + c->sco_num + c->le_num;
 910 }
 911
 912 static inline __u8 hci_conn_lookup_type(struct hci_dev *hdev, __u16 handle)
 913 {
 914         struct hci_conn_hash *h = &hdev->conn_hash;
 915         struct hci_conn *c;
 916         __u8 type = INVALID_LINK;
 917
 918         rcu_read_lock();
 919
 920         list_for_each_entry_rcu(c, &h->list, list) {
 921                 if (c->handle == handle) {
 922                         type = c->type;
 923                         break;
 924                 }
 925         }
 926
 927         rcu_read_unlock();
 928
 929         return type;
 930 }
 931
 932 static inline struct hci_conn *hci_conn_hash_lookup_handle(struct hci_dev *hdev,
 933                                                                 __u16 handle)
 934 {
 935         struct hci_conn_hash *h = &hdev->conn_hash;
 936         struct hci_conn  *c;
 937
 938         rcu_read_lock();
 939
 940         list_for_each_entry_rcu(c, &h->list, list) {
 941                 if (c->handle == handle) {
 942                         rcu_read_unlock();
 943                         return c;
 944                 }
 945         }
 946         rcu_read_unlock();
 947
 948         return NULL;
 949 }
 950
 951 static inline struct hci_conn *hci_conn_hash_lookup_ba(struct hci_dev *hdev,
 952                                                         __u8 type, bdaddr_t *ba)
 953 {
 954         struct hci_conn_hash *h = &hdev->conn_hash;
 955         struct hci_conn  *c;
 956
 957         rcu_read_lock();
 958
 959         list_for_each_entry_rcu(c, &h->list, list) {
 960                 if (c->type == type && !bacmp(&c->dst, ba)) {
 961                         rcu_read_unlock();
 962                         return c;
 963                 }
 964         }
 965
 966         rcu_read_unlock();
 967
 968         return NULL;
 969 }
 970
 971 static inline struct hci_conn *hci_conn_hash_lookup_le(struct hci_dev *hdev,
 972                                                        bdaddr_t *ba,
 973                                                        __u8 ba_type)
 974 {
 975         struct hci_conn_hash *h = &hdev->conn_hash;
 976         struct hci_conn  *c;
 977
 978         rcu_read_lock();
 979
 980         list_for_each_entry_rcu(c, &h->list, list) {
 981                 if (c->type != LE_LINK)
 982                        continue;
 983
 984                 if (ba_type == c->dst_type && !bacmp(&c->dst, ba)) {
 985                         rcu_read_unlock();
 986                         return c;
 987                 }
 988         }
 989
 990         rcu_read_unlock();
 991
 992         return NULL;
 993 }
 994
 995 static inline struct hci_conn *hci_conn_hash_lookup_state(struct hci_dev *hdev,
 996                                                         __u8 type, __u16 state)
 997 {
 998         struct hci_conn_hash *h = &hdev->conn_hash;
 999         struct hci_conn  *c;
1000
1001         rcu_read_lock();
1002
1003         list_for_each_entry_rcu(c, &h->list, list) {
1004                 if (c->type == type && c->state == state) {
1005                         rcu_read_unlock();
1006                         return c;
1007                 }
1008         }
1009
1010         rcu_read_unlock();
1011
1012         return NULL;
1013 }
1014
1015 static inline struct hci_conn *hci_lookup_le_connect(struct hci_dev *hdev)
1016 {
1017         struct hci_conn_hash *h = &hdev->conn_hash;
1018         struct hci_conn  *c;
1019
1020         rcu_read_lock();
1021
1022         list_for_each_entry_rcu(c, &h->list, list) {
1023                 if (c->type == LE_LINK && c->state == BT_CONNECT &&
1024                     !test_bit(HCI_CONN_SCANNING, &c->flags)) {
1025                         rcu_read_unlock();
1026                         return c;
1027                 }
1028         }
1029
1030         rcu_read_unlock();
1031
1032         return NULL;
1033 }
1034
1035 int hci_disconnect(struct hci_conn *conn, __u8 reason);
1036 bool hci_setup_sync(struct hci_conn *conn, __u16 handle);
1037 void hci_sco_setup(struct hci_conn *conn, __u8 status);
1038
1039 struct hci_conn *hci_conn_add(struct hci_dev *hdev, int type, bdaddr_t *dst,
1040                               u8 role);
1041 int hci_conn_del(struct hci_conn *conn);
1042 void hci_conn_hash_flush(struct hci_dev *hdev);
1043 void hci_conn_check_pending(struct hci_dev *hdev);
1044
1045 struct hci_chan *hci_chan_create(struct hci_conn *conn);
1046 void hci_chan_del(struct hci_chan *chan);
1047 void hci_chan_list_flush(struct hci_conn *conn);
1048 struct hci_chan *hci_chan_lookup_handle(struct hci_dev *hdev, __u16 handle);
1049
1050 struct hci_conn *hci_connect_le_scan(struct hci_dev *hdev, bdaddr_t *dst,
1051                                      u8 dst_type, u8 sec_level,
1052                                      u16 conn_timeout,
1053                                      enum conn_reasons conn_reason);
1054 struct hci_conn *hci_connect_le(struct hci_dev *hdev, bdaddr_t *dst,
1055                                 u8 dst_type, u8 sec_level, u16 conn_timeout,
1056                                 u8 role, bdaddr_t *direct_rpa);
1057 struct hci_conn *hci_connect_acl(struct hci_dev *hdev, bdaddr_t *dst,
1058                                  u8 sec_level, u8 auth_type,
1059                                  enum conn_reasons conn_reason);
1060 struct hci_conn *hci_connect_sco(struct hci_dev *hdev, int type, bdaddr_t *dst,
1061                                  __u16 setting);
1062 int hci_conn_check_link_mode(struct hci_conn *conn);
1063 int hci_conn_check_secure(struct hci_conn *conn, __u8 sec_level);
1064 int hci_conn_security(struct hci_conn *conn, __u8 sec_level, __u8 auth_type,
1065                       bool initiator);
1066 int hci_conn_switch_role(struct hci_conn *conn, __u8 role);
1067
1068 void hci_conn_enter_active_mode(struct hci_conn *conn, __u8 force_active);
1069
1070 void hci_le_conn_failed(struct hci_conn *conn, u8 status);
1071
1072 /*
1073  * hci_conn_get() and hci_conn_put() are used to control the life-time of an
1074  * "hci_conn" object. They do not guarantee that the hci_conn object is running,
1075  * working or anything else. They just guarantee that the object is available
1076  * and can be dereferenced. So you can use its locks, local variables and any
1077  * other constant data.
1078  * Before accessing runtime data, you _must_ lock the object and then check that
1079  * it is still running. As soon as you release the locks, the connection might
1080  * get dropped, though.
1081  *
1082  * On the other hand, hci_conn_hold() and hci_conn_drop() are used to control
1083  * how long the underlying connection is held. So every channel that runs on the
1084  * hci_conn object calls this to prevent the connection from disappearing. As
1085  * long as you hold a device, you must also guarantee that you have a valid
1086  * reference to the device via hci_conn_get() (or the initial reference from
1087  * hci_conn_add()).
1088  * The hold()/drop() ref-count is known to drop below 0 sometimes, which doesn't
1089  * break because nobody cares for that. But this means, we cannot use
1090  * _get()/_drop() in it, but require the caller to have a valid ref (FIXME).
1091  */
1092
1093 static inline struct hci_conn *hci_conn_get(struct hci_conn *conn)
1094 {
1095         get_device(&conn->dev);
1096         return conn;
1097 }
1098
1099 static inline void hci_conn_put(struct hci_conn *conn)
1100 {
1101         put_device(&conn->dev);
1102 }
1103
1104 static inline void hci_conn_hold(struct hci_conn *conn)
1105 {
1106         BT_DBG("hcon %p orig refcnt %d", conn, atomic_read(&conn->refcnt));
1107
1108         atomic_inc(&conn->refcnt);
1109         cancel_delayed_work(&conn->disc_work);
1110 }
1111
1112 static inline void hci_conn_drop(struct hci_conn *conn)
1113 {
1114         BT_DBG("hcon %p orig refcnt %d", conn, atomic_read(&conn->refcnt));
1115
1116         if (atomic_dec_and_test(&conn->refcnt)) {
1117                 unsigned long timeo;
1118
1119                 switch (conn->type) {
1120                 case ACL_LINK:
1121                 case LE_LINK:
1122                         cancel_delayed_work(&conn->idle_work);
1123                         if (conn->state == BT_CONNECTED) {
1124                                 timeo = conn->disc_timeout;
1125                                 if (!conn->out)
1126                                         timeo *= 2;
1127                         } else {
1128                                 timeo = 0;
1129                         }
1130                         break;
1131
1132                 case AMP_LINK:
1133                         timeo = conn->disc_timeout;
1134                         break;
1135
1136                 default:
1137                         timeo = 0;
1138                         break;
1139                 }
1140
1141                 cancel_delayed_work(&conn->disc_work);
1142                 queue_delayed_work(conn->hdev->workqueue,
1143                                    &conn->disc_work, timeo);
1144         }
1145 }
1146
1147 /* ----- HCI Devices ----- */
1148 static inline void hci_dev_put(struct hci_dev *d)
1149 {
1150         BT_DBG("%s orig refcnt %d", d->name,
1151                kref_read(&d->dev.kobj.kref));
1152
1153         put_device(&d->dev);
1154 }
1155
1156 static inline struct hci_dev *hci_dev_hold(struct hci_dev *d)
1157 {
1158         BT_DBG("%s orig refcnt %d", d->name,
1159                kref_read(&d->dev.kobj.kref));
1160
1161         get_device(&d->dev);
1162         return d;
1163 }
1164
1165 #define hci_dev_lock(d)         mutex_lock(&d->lock)
1166 #define hci_dev_unlock(d)       mutex_unlock(&d->lock)
1167
1168 #define to_hci_dev(d) container_of(d, struct hci_dev, dev)
1169 #define to_hci_conn(c) container_of(c, struct hci_conn, dev)
1170
1171 static inline void *hci_get_drvdata(struct hci_dev *hdev)
1172 {
1173         return dev_get_drvdata(&hdev->dev);
1174 }
1175
1176 static inline void hci_set_drvdata(struct hci_dev *hdev, void *data)
1177 {
1178         dev_set_drvdata(&hdev->dev, data);
1179 }
1180
1181 struct hci_dev *hci_dev_get(int index);
1182 struct hci_dev *hci_get_route(bdaddr_t *dst, bdaddr_t *src, u8 src_type);
1183
1184 struct hci_dev *hci_alloc_dev(void);
1185 void hci_free_dev(struct hci_dev *hdev);
1186 int hci_register_dev(struct hci_dev *hdev);
1187 void hci_unregister_dev(struct hci_dev *hdev);
1188 int hci_suspend_dev(struct hci_dev *hdev);
1189 int hci_resume_dev(struct hci_dev *hdev);
1190 int hci_reset_dev(struct hci_dev *hdev);
1191 int hci_recv_frame(struct hci_dev *hdev, struct sk_buff *skb);
1192 int hci_recv_diag(struct hci_dev *hdev, struct sk_buff *skb);
1193 __printf(2, 3) void hci_set_hw_info(struct hci_dev *hdev, const char *fmt, ...);
1194 __printf(2, 3) void hci_set_fw_info(struct hci_dev *hdev, const char *fmt, ...);
1195
1196 static inline void hci_set_msft_opcode(struct hci_dev *hdev, __u16 opcode)
1197 {
1198 #if IS_ENABLED(CONFIG_BT_MSFTEXT)
1199         hdev->msft_opcode = opcode;
1200 #endif
1201 }
1202
1203 int hci_dev_open(__u16 dev);
1204 int hci_dev_close(__u16 dev);
1205 int hci_dev_do_close(struct hci_dev *hdev);
1206 int hci_dev_reset(__u16 dev);
1207 int hci_dev_reset_stat(__u16 dev);
1208 int hci_dev_cmd(unsigned int cmd, void __user *arg);
1209 int hci_get_dev_list(void __user *arg);
1210 int hci_get_dev_info(void __user *arg);
1211 int hci_get_conn_list(void __user *arg);
1212 int hci_get_conn_info(struct hci_dev *hdev, void __user *arg);
1213 int hci_get_auth_info(struct hci_dev *hdev, void __user *arg);
1214 int hci_inquiry(void __user *arg);
1215
1216 struct bdaddr_list *hci_bdaddr_list_lookup(struct list_head *list,
1217                                            bdaddr_t *bdaddr, u8 type);
1218 struct bdaddr_list_with_irk *hci_bdaddr_list_lookup_with_irk(
1219                                     struct list_head *list, bdaddr_t *bdaddr,
1220                                     u8 type);
1221 struct bdaddr_list_with_flags *
1222 hci_bdaddr_list_lookup_with_flags(struct list_head *list, bdaddr_t *bdaddr,
1223                                   u8 type);
1224 int hci_bdaddr_list_add(struct list_head *list, bdaddr_t *bdaddr, u8 type);
1225 int hci_bdaddr_list_add_with_irk(struct list_head *list, bdaddr_t *bdaddr,
1226                                  u8 type, u8 *peer_irk, u8 *local_irk);
1227 int hci_bdaddr_list_add_with_flags(struct list_head *list, bdaddr_t *bdaddr,
1228                                    u8 type, u32 flags);
1229 int hci_bdaddr_list_del(struct list_head *list, bdaddr_t *bdaddr, u8 type);
1230 int hci_bdaddr_list_del_with_irk(struct list_head *list, bdaddr_t *bdaddr,
1231                                  u8 type);
1232 int hci_bdaddr_list_del_with_flags(struct list_head *list, bdaddr_t *bdaddr,
1233                                    u8 type);
1234 void hci_bdaddr_list_clear(struct list_head *list);
1235
1236 struct hci_conn_params *hci_conn_params_lookup(struct hci_dev *hdev,
1237                                                bdaddr_t *addr, u8 addr_type);
1238 struct hci_conn_params *hci_conn_params_add(struct hci_dev *hdev,
1239                                             bdaddr_t *addr, u8 addr_type);
1240 void hci_conn_params_del(struct hci_dev *hdev, bdaddr_t *addr, u8 addr_type);
1241 void hci_conn_params_clear_disabled(struct hci_dev *hdev);
1242
1243 struct hci_conn_params *hci_pend_le_action_lookup(struct list_head *list,
1244                                                   bdaddr_t *addr,
1245                                                   u8 addr_type);
1246
1247 void hci_uuids_clear(struct hci_dev *hdev);
1248
1249 void hci_link_keys_clear(struct hci_dev *hdev);
1250 struct link_key *hci_find_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr);
1251 struct link_key *hci_add_link_key(struct hci_dev *hdev, struct hci_conn *conn,
1252                                   bdaddr_t *bdaddr, u8 *val, u8 type,
1253                                   u8 pin_len, bool *persistent);
1254 struct smp_ltk *hci_add_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr,
1255                             u8 addr_type, u8 type, u8 authenticated,
1256                             u8 tk[16], u8 enc_size, __le16 ediv, __le64 rand);
1257 struct smp_ltk *hci_find_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr,
1258                              u8 addr_type, u8 role);
1259 int hci_remove_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 bdaddr_type);
1260 void hci_smp_ltks_clear(struct hci_dev *hdev);
1261 int hci_remove_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr);
1262
1263 struct smp_irk *hci_find_irk_by_rpa(struct hci_dev *hdev, bdaddr_t *rpa);
1264 struct smp_irk *hci_find_irk_by_addr(struct hci_dev *hdev, bdaddr_t *bdaddr,
1265                                      u8 addr_type);
1266 struct smp_irk *hci_add_irk(struct hci_dev *hdev, bdaddr_t *bdaddr,
1267                             u8 addr_type, u8 val[16], bdaddr_t *rpa);
1268 void hci_remove_irk(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 addr_type);
1269 bool hci_is_blocked_key(struct hci_dev *hdev, u8 type, u8 val[16]);
1270 void hci_blocked_keys_clear(struct hci_dev *hdev);
1271 void hci_smp_irks_clear(struct hci_dev *hdev);
1272
1273 bool hci_bdaddr_is_paired(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 type);
1274
1275 void hci_remote_oob_data_clear(struct hci_dev *hdev);
1276 struct oob_data *hci_find_remote_oob_data(struct hci_dev *hdev,
1277                                           bdaddr_t *bdaddr, u8 bdaddr_type);
1278 int hci_add_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr,
1279                             u8 bdaddr_type, u8 *hash192, u8 *rand192,
1280                             u8 *hash256, u8 *rand256);
1281 int hci_remove_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr,
1282                                u8 bdaddr_type);
1283
1284 void hci_adv_instances_clear(struct hci_dev *hdev);
1285 struct adv_info *hci_find_adv_instance(struct hci_dev *hdev, u8 instance);
1286 struct adv_info *hci_get_next_instance(struct hci_dev *hdev, u8 instance);
1287 int hci_add_adv_instance(struct hci_dev *hdev, u8 instance, u32 flags,
1288                          u16 adv_data_len, u8 *adv_data,
1289                          u16 scan_rsp_len, u8 *scan_rsp_data,
1290                          u16 timeout, u16 duration);
1291 int hci_remove_adv_instance(struct hci_dev *hdev, u8 instance);
1292 void hci_adv_instances_set_rpa_expired(struct hci_dev *hdev, bool rpa_expired);
1293
1294 void hci_adv_monitors_clear(struct hci_dev *hdev);
1295 void hci_free_adv_monitor(struct adv_monitor *monitor);
1296 int hci_add_adv_monitor(struct hci_dev *hdev, struct adv_monitor *monitor);
1297 int hci_remove_adv_monitor(struct hci_dev *hdev, u16 handle);
1298 bool hci_is_adv_monitoring(struct hci_dev *hdev);
1299
1300 void hci_event_packet(struct hci_dev *hdev, struct sk_buff *skb);
1301
1302 void hci_init_sysfs(struct hci_dev *hdev);
1303 void hci_conn_init_sysfs(struct hci_conn *conn);
1304 void hci_conn_add_sysfs(struct hci_conn *conn);
1305 void hci_conn_del_sysfs(struct hci_conn *conn);
1306
1307 #define SET_HCIDEV_DEV(hdev, pdev) ((hdev)->dev.parent = (pdev))
1308
1309 /* ----- LMP capabilities ----- */
1310 #define lmp_encrypt_capable(dev)   ((dev)->features[0][0] & LMP_ENCRYPT)
1311 #define lmp_rswitch_capable(dev)   ((dev)->features[0][0] & LMP_RSWITCH)
1312 #define lmp_hold_capable(dev)      ((dev)->features[0][0] & LMP_HOLD)
1313 #define lmp_sniff_capable(dev)     ((dev)->features[0][0] & LMP_SNIFF)
1314 #define lmp_park_capable(dev)      ((dev)->features[0][1] & LMP_PARK)
1315 #define lmp_inq_rssi_capable(dev)  ((dev)->features[0][3] & LMP_RSSI_INQ)
1316 #define lmp_esco_capable(dev)      ((dev)->features[0][3] & LMP_ESCO)
1317 #define lmp_bredr_capable(dev)     (!((dev)->features[0][4] & LMP_NO_BREDR))
1318 #define lmp_le_capable(dev)        ((dev)->features[0][4] & LMP_LE)
1319 #define lmp_sniffsubr_capable(dev) ((dev)->features[0][5] & LMP_SNIFF_SUBR)
1320 #define lmp_pause_enc_capable(dev) ((dev)->features[0][5] & LMP_PAUSE_ENC)
1321 #define lmp_ext_inq_capable(dev)   ((dev)->features[0][6] & LMP_EXT_INQ)
1322 #define lmp_le_br_capable(dev)     (!!((dev)->features[0][6] & LMP_SIMUL_LE_BR))
1323 #define lmp_ssp_capable(dev)       ((dev)->features[0][6] & LMP_SIMPLE_PAIR)
1324 #define lmp_no_flush_capable(dev)  ((dev)->features[0][6] & LMP_NO_FLUSH)
1325 #define lmp_lsto_capable(dev)      ((dev)->features[0][7] & LMP_LSTO)
1326 #define lmp_inq_tx_pwr_capable(dev) ((dev)->features[0][7] & LMP_INQ_TX_PWR)
1327 #define lmp_ext_feat_capable(dev)  ((dev)->features[0][7] & LMP_EXTFEATURES)
1328 #define lmp_transp_capable(dev)    ((dev)->features[0][2] & LMP_TRANSPARENT)
1329 #define lmp_edr_2m_capable(dev)    ((dev)->features[0][3] & LMP_EDR_2M)
1330 #define lmp_edr_3m_capable(dev)    ((dev)->features[0][3] & LMP_EDR_3M)
1331 #define lmp_edr_3slot_capable(dev) ((dev)->features[0][4] & LMP_EDR_3SLOT)
1332 #define lmp_edr_5slot_capable(dev) ((dev)->features[0][5] & LMP_EDR_5SLOT)
1333
1334 /* ----- Extended LMP capabilities ----- */
1335 #define lmp_csb_master_capable(dev) ((dev)->features[2][0] & LMP_CSB_MASTER)
1336 #define lmp_csb_slave_capable(dev)  ((dev)->features[2][0] & LMP_CSB_SLAVE)
1337 #define lmp_sync_train_capable(dev) ((dev)->features[2][0] & LMP_SYNC_TRAIN)
1338 #define lmp_sync_scan_capable(dev)  ((dev)->features[2][0] & LMP_SYNC_SCAN)
1339 #define lmp_sc_capable(dev)         ((dev)->features[2][1] & LMP_SC)
1340 #define lmp_ping_capable(dev)       ((dev)->features[2][1] & LMP_PING)
1341
1342 /* ----- Host capabilities ----- */
1343 #define lmp_host_ssp_capable(dev)  ((dev)->features[1][0] & LMP_HOST_SSP)
1344 #define lmp_host_sc_capable(dev)   ((dev)->features[1][0] & LMP_HOST_SC)
1345 #define lmp_host_le_capable(dev)   (!!((dev)->features[1][0] & LMP_HOST_LE))
1346 #define lmp_host_le_br_capable(dev) (!!((dev)->features[1][0] & LMP_HOST_LE_BREDR))
1347
1348 #define hdev_is_powered(dev)   (test_bit(HCI_UP, &(dev)->flags) && \
1349                                 !hci_dev_test_flag(dev, HCI_AUTO_OFF))
1350 #define bredr_sc_enabled(dev)  (lmp_sc_capable(dev) && \
1351                                 hci_dev_test_flag(dev, HCI_SC_ENABLED))
1352
1353 #define scan_1m(dev) (((dev)->le_tx_def_phys & HCI_LE_SET_PHY_1M) || \
1354                       ((dev)->le_rx_def_phys & HCI_LE_SET_PHY_1M))
1355
1356 #define scan_2m(dev) (((dev)->le_tx_def_phys & HCI_LE_SET_PHY_2M) || \
1357                       ((dev)->le_rx_def_phys & HCI_LE_SET_PHY_2M))
1358
1359 #define scan_coded(dev) (((dev)->le_tx_def_phys & HCI_LE_SET_PHY_CODED) || \
1360                          ((dev)->le_rx_def_phys & HCI_LE_SET_PHY_CODED))
1361
1362 /* Use LL Privacy based address resolution if supported */
1363 #define use_ll_privacy(dev) ((dev)->le_features[0] & HCI_LE_LL_PRIVACY)
1364
1365 /* Use ext scanning if set ext scan param and ext scan enable is supported */
1366 #define use_ext_scan(dev) (((dev)->commands[37] & 0x20) && \
1367                            ((dev)->commands[37] & 0x40))
1368 /* Use ext create connection if command is supported */
1369 #define use_ext_conn(dev) ((dev)->commands[37] & 0x80)
1370
1371 /* Extended advertising support */
1372 #define ext_adv_capable(dev) (((dev)->le_features[1] & HCI_LE_EXT_ADV))
1373
1374 /* ----- HCI protocols ----- */
1375 #define HCI_PROTO_DEFER             0x01
1376
1377 static inline int hci_proto_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr,
1378                                         __u8 type, __u8 *flags)
1379 {
1380         switch (type) {
1381         case ACL_LINK:
1382                 return l2cap_connect_ind(hdev, bdaddr);
1383
1384         case SCO_LINK:
1385         case ESCO_LINK:
1386                 return sco_connect_ind(hdev, bdaddr, flags);
1387
1388         default:
1389                 BT_ERR("unknown link type %d", type);
1390                 return -EINVAL;
1391         }
1392 }
1393
1394 static inline int hci_proto_disconn_ind(struct hci_conn *conn)
1395 {
1396         if (conn->type != ACL_LINK && conn->type != LE_LINK)
1397                 return HCI_ERROR_REMOTE_USER_TERM;
1398
1399         return l2cap_disconn_ind(conn);
1400 }
1401
1402 /* ----- HCI callbacks ----- */
1403 struct hci_cb {
1404         struct list_head list;
1405
1406         char *name;
1407
1408         void (*connect_cfm)     (struct hci_conn *conn, __u8 status);
1409         void (*disconn_cfm)     (struct hci_conn *conn, __u8 status);
1410         void (*security_cfm)    (struct hci_conn *conn, __u8 status,
1411                                                                 __u8 encrypt);
1412         void (*key_change_cfm)  (struct hci_conn *conn, __u8 status);
1413         void (*role_switch_cfm) (struct hci_conn *conn, __u8 status, __u8 role);
1414 };
1415
1416 static inline void hci_connect_cfm(struct hci_conn *conn, __u8 status)
1417 {
1418         struct hci_cb *cb;
1419
1420         mutex_lock(&hci_cb_list_lock);
1421         list_for_each_entry(cb, &hci_cb_list, list) {
1422                 if (cb->connect_cfm)
1423                         cb->connect_cfm(conn, status);
1424         }
1425         mutex_unlock(&hci_cb_list_lock);
1426
1427         if (conn->connect_cfm_cb)
1428                 conn->connect_cfm_cb(conn, status);
1429 }
1430
1431 static inline void hci_disconn_cfm(struct hci_conn *conn, __u8 reason)
1432 {
1433         struct hci_cb *cb;
1434
1435         mutex_lock(&hci_cb_list_lock);
1436         list_for_each_entry(cb, &hci_cb_list, list) {
1437                 if (cb->disconn_cfm)
1438                         cb->disconn_cfm(conn, reason);
1439         }
1440         mutex_unlock(&hci_cb_list_lock);
1441
1442         if (conn->disconn_cfm_cb)
1443                 conn->disconn_cfm_cb(conn, reason);
1444 }
1445
1446 static inline void hci_auth_cfm(struct hci_conn *conn, __u8 status)
1447 {
1448         struct hci_cb *cb;
1449         __u8 encrypt;
1450
1451         if (test_bit(HCI_CONN_ENCRYPT_PEND, &conn->flags))
1452                 return;
1453
1454         encrypt = test_bit(HCI_CONN_ENCRYPT, &conn->flags) ? 0x01 : 0x00;
1455
1456         mutex_lock(&hci_cb_list_lock);
1457         list_for_each_entry(cb, &hci_cb_list, list) {
1458                 if (cb->security_cfm)
1459                         cb->security_cfm(conn, status, encrypt);
1460         }
1461         mutex_unlock(&hci_cb_list_lock);
1462
1463         if (conn->security_cfm_cb)
1464                 conn->security_cfm_cb(conn, status);
1465 }
1466
1467 static inline void hci_encrypt_cfm(struct hci_conn *conn, __u8 status)
1468 {
1469         struct hci_cb *cb;
1470         __u8 encrypt;
1471
1472         if (conn->state == BT_CONFIG) {
1473                 if (!status)
1474                         conn->state = BT_CONNECTED;
1475
1476                 hci_connect_cfm(conn, status);
1477                 hci_conn_drop(conn);
1478                 return;
1479         }
1480
1481         if (!test_bit(HCI_CONN_ENCRYPT, &conn->flags))
1482                 encrypt = 0x00;
1483         else if (test_bit(HCI_CONN_AES_CCM, &conn->flags))
1484                 encrypt = 0x02;
1485         else
1486                 encrypt = 0x01;
1487
1488         if (!status) {
1489                 if (conn->sec_level == BT_SECURITY_SDP)
1490                         conn->sec_level = BT_SECURITY_LOW;
1491
1492                 if (conn->pending_sec_level > conn->sec_level)
1493                         conn->sec_level = conn->pending_sec_level;
1494         }
1495
1496         mutex_lock(&hci_cb_list_lock);
1497         list_for_each_entry(cb, &hci_cb_list, list) {
1498                 if (cb->security_cfm)
1499                         cb->security_cfm(conn, status, encrypt);
1500         }
1501         mutex_unlock(&hci_cb_list_lock);
1502
1503         if (conn->security_cfm_cb)
1504                 conn->security_cfm_cb(conn, status);
1505 }
1506
1507 static inline void hci_key_change_cfm(struct hci_conn *conn, __u8 status)
1508 {
1509         struct hci_cb *cb;
1510
1511         mutex_lock(&hci_cb_list_lock);
1512         list_for_each_entry(cb, &hci_cb_list, list) {
1513                 if (cb->key_change_cfm)
1514                         cb->key_change_cfm(conn, status);
1515         }
1516         mutex_unlock(&hci_cb_list_lock);
1517 }
1518
1519 static inline void hci_role_switch_cfm(struct hci_conn *conn, __u8 status,
1520                                                                 __u8 role)
1521 {
1522         struct hci_cb *cb;
1523
1524         mutex_lock(&hci_cb_list_lock);
1525         list_for_each_entry(cb, &hci_cb_list, list) {
1526                 if (cb->role_switch_cfm)
1527                         cb->role_switch_cfm(conn, status, role);
1528         }
1529         mutex_unlock(&hci_cb_list_lock);
1530 }
1531
1532 static inline void *eir_get_data(u8 *eir, size_t eir_len, u8 type,
1533                                  size_t *data_len)
1534 {
1535         size_t parsed = 0;
1536
1537         if (eir_len < 2)
1538                 return NULL;
1539
1540         while (parsed < eir_len - 1) {
1541                 u8 field_len = eir[0];
1542
1543                 if (field_len == 0)
1544                         break;
1545
1546                 parsed += field_len + 1;
1547
1548                 if (parsed > eir_len)
1549                         break;
1550
1551                 if (eir[1] != type) {
1552                         eir += field_len + 1;
1553                         continue;
1554                 }
1555
1556                 /* Zero length data */
1557                 if (field_len == 1)
1558                         return NULL;
1559
1560                 if (data_len)
1561                         *data_len = field_len - 1;
1562
1563                 return &eir[2];
1564         }
1565
1566         return NULL;
1567 }
1568
1569 static inline bool hci_bdaddr_is_rpa(bdaddr_t *bdaddr, u8 addr_type)
1570 {
1571         if (addr_type != ADDR_LE_DEV_RANDOM)
1572                 return false;
1573
1574         if ((bdaddr->b[5] & 0xc0) == 0x40)
1575                return true;
1576
1577         return false;
1578 }
1579
1580 static inline bool hci_is_identity_address(bdaddr_t *addr, u8 addr_type)
1581 {
1582         if (addr_type == ADDR_LE_DEV_PUBLIC)
1583                 return true;
1584
1585         /* Check for Random Static address type */
1586         if ((addr->b[5] & 0xc0) == 0xc0)
1587                 return true;
1588
1589         return false;
1590 }
1591
1592 static inline struct smp_irk *hci_get_irk(struct hci_dev *hdev,
1593                                           bdaddr_t *bdaddr, u8 addr_type)
1594 {
1595         if (!hci_bdaddr_is_rpa(bdaddr, addr_type))
1596                 return NULL;
1597
1598         return hci_find_irk_by_rpa(hdev, bdaddr);
1599 }
1600
1601 static inline int hci_check_conn_params(u16 min, u16 max, u16 latency,
1602                                         u16 to_multiplier)
1603 {
1604         u16 max_latency;
1605
1606         if (min > max || min < 6 || max > 3200)
1607                 return -EINVAL;
1608
1609         if (to_multiplier < 10 || to_multiplier > 3200)
1610                 return -EINVAL;
1611
1612         if (max >= to_multiplier * 8)
1613                 return -EINVAL;
1614
1615         max_latency = (to_multiplier * 4 / max) - 1;
1616         if (latency > 499 || latency > max_latency)
1617                 return -EINVAL;
1618
1619         return 0;
1620 }
1621
1622 int hci_register_cb(struct hci_cb *hcb);
1623 int hci_unregister_cb(struct hci_cb *hcb);
1624
1625 struct sk_buff *__hci_cmd_sync(struct hci_dev *hdev, u16 opcode, u32 plen,
1626                                const void *param, u32 timeout);
1627 struct sk_buff *__hci_cmd_sync_ev(struct hci_dev *hdev, u16 opcode, u32 plen,
1628                                   const void *param, u8 event, u32 timeout);
1629 int __hci_cmd_send(struct hci_dev *hdev, u16 opcode, u32 plen,
1630                    const void *param);
1631
1632 int hci_send_cmd(struct hci_dev *hdev, __u16 opcode, __u32 plen,
1633                  const void *param);
1634 void hci_send_acl(struct hci_chan *chan, struct sk_buff *skb, __u16 flags);
1635 void hci_send_sco(struct hci_conn *conn, struct sk_buff *skb);
1636
1637 void *hci_sent_cmd_data(struct hci_dev *hdev, __u16 opcode);
1638
1639 struct sk_buff *hci_cmd_sync(struct hci_dev *hdev, u16 opcode, u32 plen,
1640                              const void *param, u32 timeout);
1641
1642 u32 hci_conn_get_phy(struct hci_conn *conn);
1643
1644 /* ----- HCI Sockets ----- */
1645 void hci_send_to_sock(struct hci_dev *hdev, struct sk_buff *skb);
1646 void hci_send_to_channel(unsigned short channel, struct sk_buff *skb,
1647                          int flag, struct sock *skip_sk);
1648 void hci_send_to_monitor(struct hci_dev *hdev, struct sk_buff *skb);
1649 void hci_send_monitor_ctrl_event(struct hci_dev *hdev, u16 event,
1650                                  void *data, u16 data_len, ktime_t tstamp,
1651                                  int flag, struct sock *skip_sk);
1652
1653 void hci_sock_dev_event(struct hci_dev *hdev, int event);
1654
1655 #define HCI_MGMT_VAR_LEN        BIT(0)
1656 #define HCI_MGMT_NO_HDEV        BIT(1)
1657 #define HCI_MGMT_UNTRUSTED      BIT(2)
1658 #define HCI_MGMT_UNCONFIGURED   BIT(3)
1659 #define HCI_MGMT_HDEV_OPTIONAL  BIT(4)
1660
1661 struct hci_mgmt_handler {
1662         int (*func) (struct sock *sk, struct hci_dev *hdev, void *data,
1663                      u16 data_len);
1664         size_t data_len;
1665         unsigned long flags;
1666 };
1667
1668 struct hci_mgmt_chan {
1669         struct list_head list;
1670         unsigned short channel;
1671         size_t handler_count;
1672         const struct hci_mgmt_handler *handlers;
1673         void (*hdev_init) (struct sock *sk, struct hci_dev *hdev);
1674 };
1675
1676 int hci_mgmt_chan_register(struct hci_mgmt_chan *c);
1677 void hci_mgmt_chan_unregister(struct hci_mgmt_chan *c);
1678
1679 /* Management interface */
1680 #define DISCOV_TYPE_BREDR               (BIT(BDADDR_BREDR))
1681 #define DISCOV_TYPE_LE                  (BIT(BDADDR_LE_PUBLIC) | \
1682                                          BIT(BDADDR_LE_RANDOM))
1683 #define DISCOV_TYPE_INTERLEAVED         (BIT(BDADDR_BREDR) | \
1684                                          BIT(BDADDR_LE_PUBLIC) | \
1685                                          BIT(BDADDR_LE_RANDOM))
1686
1687 /* These LE scan and inquiry parameters were chosen according to LE General
1688  * Discovery Procedure specification.
1689  */
1690 #define DISCOV_LE_SCAN_WIN              0x12
1691 #define DISCOV_LE_SCAN_INT              0x12
1692 #define DISCOV_LE_TIMEOUT               10240   /* msec */
1693 #define DISCOV_INTERLEAVED_TIMEOUT      5120    /* msec */
1694 #define DISCOV_INTERLEAVED_INQUIRY_LEN  0x04
1695 #define DISCOV_BREDR_INQUIRY_LEN        0x08
1696 #define DISCOV_LE_RESTART_DELAY         msecs_to_jiffies(200)   /* msec */
1697 #define DISCOV_LE_FAST_ADV_INT_MIN     100     /* msec */
1698 #define DISCOV_LE_FAST_ADV_INT_MAX     150     /* msec */
1699
1700 void mgmt_fill_version_info(void *ver);
1701 int mgmt_new_settings(struct hci_dev *hdev);
1702 void mgmt_index_added(struct hci_dev *hdev);
1703 void mgmt_index_removed(struct hci_dev *hdev);
1704 void mgmt_set_powered_failed(struct hci_dev *hdev, int err);
1705 void mgmt_power_on(struct hci_dev *hdev, int err);
1706 void __mgmt_power_off(struct hci_dev *hdev);
1707 void mgmt_new_link_key(struct hci_dev *hdev, struct link_key *key,
1708                        bool persistent);
1709 void mgmt_device_connected(struct hci_dev *hdev, struct hci_conn *conn,
1710                            u32 flags, u8 *name, u8 name_len);
1711 void mgmt_device_disconnected(struct hci_dev *hdev, bdaddr_t *bdaddr,
1712                               u8 link_type, u8 addr_type, u8 reason,
1713                               bool mgmt_connected);
1714 void mgmt_disconnect_failed(struct hci_dev *hdev, bdaddr_t *bdaddr,
1715                             u8 link_type, u8 addr_type, u8 status);
1716 void mgmt_connect_failed(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type,
1717                          u8 addr_type, u8 status);
1718 void mgmt_pin_code_request(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 secure);
1719 void mgmt_pin_code_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
1720                                   u8 status);
1721 void mgmt_pin_code_neg_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
1722                                       u8 status);
1723 int mgmt_user_confirm_request(struct hci_dev *hdev, bdaddr_t *bdaddr,
1724                               u8 link_type, u8 addr_type, u32 value,
1725                               u8 confirm_hint);
1726 int mgmt_user_confirm_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
1727                                      u8 link_type, u8 addr_type, u8 status);
1728 int mgmt_user_confirm_neg_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
1729                                          u8 link_type, u8 addr_type, u8 status);
1730 int mgmt_user_passkey_request(struct hci_dev *hdev, bdaddr_t *bdaddr,
1731                               u8 link_type, u8 addr_type);
1732 int mgmt_user_passkey_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
1733                                      u8 link_type, u8 addr_type, u8 status);
1734 int mgmt_user_passkey_neg_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
1735                                          u8 link_type, u8 addr_type, u8 status);
1736 int mgmt_user_passkey_notify(struct hci_dev *hdev, bdaddr_t *bdaddr,
1737                              u8 link_type, u8 addr_type, u32 passkey,
1738                              u8 entered);
1739 void mgmt_auth_failed(struct hci_conn *conn, u8 status);
1740 void mgmt_auth_enable_complete(struct hci_dev *hdev, u8 status);
1741 void mgmt_ssp_enable_complete(struct hci_dev *hdev, u8 enable, u8 status);
1742 void mgmt_set_class_of_dev_complete(struct hci_dev *hdev, u8 *dev_class,
1743                                     u8 status);
1744 void mgmt_set_local_name_complete(struct hci_dev *hdev, u8 *name, u8 status);
1745 void mgmt_start_discovery_complete(struct hci_dev *hdev, u8 status);
1746 void mgmt_stop_discovery_complete(struct hci_dev *hdev, u8 status);
1747 void mgmt_device_found(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type,
1748                        u8 addr_type, u8 *dev_class, s8 rssi, u32 flags,
1749                        u8 *eir, u16 eir_len, u8 *scan_rsp, u8 scan_rsp_len);
1750 void mgmt_remote_name(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type,
1751                       u8 addr_type, s8 rssi, u8 *name, u8 name_len);
1752 void mgmt_discovering(struct hci_dev *hdev, u8 discovering);
1753 bool mgmt_powering_down(struct hci_dev *hdev);
1754 void mgmt_new_ltk(struct hci_dev *hdev, struct smp_ltk *key, bool persistent);
1755 void mgmt_new_irk(struct hci_dev *hdev, struct smp_irk *irk, bool persistent);
1756 void mgmt_new_csrk(struct hci_dev *hdev, struct smp_csrk *csrk,
1757                    bool persistent);
1758 void mgmt_new_conn_param(struct hci_dev *hdev, bdaddr_t *bdaddr,
1759                          u8 bdaddr_type, u8 store_hint, u16 min_interval,
1760                          u16 max_interval, u16 latency, u16 timeout);
1761 void mgmt_smp_complete(struct hci_conn *conn, bool complete);
1762 bool mgmt_get_connectable(struct hci_dev *hdev);
1763 void mgmt_set_connectable_complete(struct hci_dev *hdev, u8 status);
1764 void mgmt_set_discoverable_complete(struct hci_dev *hdev, u8 status);
1765 u8 mgmt_get_adv_discov_flags(struct hci_dev *hdev);
1766 void mgmt_advertising_added(struct sock *sk, struct hci_dev *hdev,
1767                             u8 instance);
1768 void mgmt_advertising_removed(struct sock *sk, struct hci_dev *hdev,
1769                               u8 instance);
1770 int mgmt_phy_configuration_changed(struct hci_dev *hdev, struct sock *skip);
1771
1772 u8 hci_le_conn_update(struct hci_conn *conn, u16 min, u16 max, u16 latency,
1773                       u16 to_multiplier);
1774 void hci_le_start_enc(struct hci_conn *conn, __le16 ediv, __le64 rand,
1775                       __u8 ltk[16], __u8 key_size);
1776
1777 void hci_copy_identity_address(struct hci_dev *hdev, bdaddr_t *bdaddr,
1778                                u8 *bdaddr_type);
1779
1780 #define SCO_AIRMODE_MASK       0x0003
1781 #define SCO_AIRMODE_CVSD       0x0000
1782 #define SCO_AIRMODE_TRANSP     0x0003
1783
1784 #endif /* __HCI_CORE_H */