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