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