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