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