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