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 };
  72
  73 struct hci_conn_hash {
  74         struct list_head list;
  75         unsigned int     acl_num;
  76         unsigned int     sco_num;
  77         unsigned int     le_num;
  78 };
  79
  80 struct bdaddr_list {
  81         struct list_head list;
  82         bdaddr_t bdaddr;
  83 };
  84
  85 struct bt_uuid {
  86         struct list_head list;
  87         u8 uuid[16];
  88         u8 svc_hint;
  89 };
  90
  91 struct smp_ltk {
  92         struct list_head list;
  93         bdaddr_t bdaddr;
  94         u8 bdaddr_type;
  95         u8 authenticated;
  96         u8 type;
  97         u8 enc_size;
  98         __le16 ediv;
  99         u8 rand[8];
 100         u8 val[16];
 101 } __packed;
 102
 103 struct link_key {
 104         struct list_head list;
 105         bdaddr_t bdaddr;
 106         u8 type;
 107         u8 val[HCI_LINK_KEY_SIZE];
 108         u8 pin_len;
 109 };
 110
 111 struct oob_data {
 112         struct list_head list;
 113         bdaddr_t bdaddr;
 114         u8 hash[16];
 115         u8 randomizer[16];
 116 };
 117
 118 struct adv_entry {
 119         struct list_head list;
 120         bdaddr_t bdaddr;
 121         u8 bdaddr_type;
 122 };
 123
 124 struct le_scan_params {
 125         u8 type;
 126         u16 interval;
 127         u16 window;
 128         int timeout;
 129 };
 130
 131 #define HCI_MAX_SHORT_NAME_LENGTH       10
 132
 133 #define NUM_REASSEMBLY 4
 134 struct hci_dev {
 135         struct list_head list;
 136         struct mutex    lock;
 137
 138         char            name[8];
 139         unsigned long   flags;
 140         __u16           id;
 141         __u8            bus;
 142         __u8            dev_type;
 143         bdaddr_t        bdaddr;
 144         __u8            dev_name[HCI_MAX_NAME_LENGTH];
 145         __u8            short_name[HCI_MAX_SHORT_NAME_LENGTH];
 146         __u8            eir[HCI_MAX_EIR_LENGTH];
 147         __u8            dev_class[3];
 148         __u8            major_class;
 149         __u8            minor_class;
 150         __u8            features[8];
 151         __u8            host_features[8];
 152         __u8            commands[64];
 153         __u8            hci_ver;
 154         __u16           hci_rev;
 155         __u8            lmp_ver;
 156         __u16           manufacturer;
 157         __u16           lmp_subver;
 158         __u16           voice_setting;
 159         __u8            io_capability;
 160         __s8            inq_tx_power;
 161         __u16           devid_source;
 162         __u16           devid_vendor;
 163         __u16           devid_product;
 164         __u16           devid_version;
 165
 166         __u16           pkt_type;
 167         __u16           esco_type;
 168         __u16           link_policy;
 169         __u16           link_mode;
 170
 171         __u32           idle_timeout;
 172         __u16           sniff_min_interval;
 173         __u16           sniff_max_interval;
 174
 175         __u8            amp_status;
 176         __u32           amp_total_bw;
 177         __u32           amp_max_bw;
 178         __u32           amp_min_latency;
 179         __u32           amp_max_pdu;
 180         __u8            amp_type;
 181         __u16           amp_pal_cap;
 182         __u16           amp_assoc_size;
 183         __u32           amp_max_flush_to;
 184         __u32           amp_be_flush_to;
 185
 186         __u8            flow_ctl_mode;
 187
 188         unsigned int    auto_accept_delay;
 189
 190         unsigned long   quirks;
 191
 192         atomic_t        cmd_cnt;
 193         unsigned int    acl_cnt;
 194         unsigned int    sco_cnt;
 195         unsigned int    le_cnt;
 196
 197         unsigned int    acl_mtu;
 198         unsigned int    sco_mtu;
 199         unsigned int    le_mtu;
 200         unsigned int    acl_pkts;
 201         unsigned int    sco_pkts;
 202         unsigned int    le_pkts;
 203
 204         __u16           block_len;
 205         __u16           block_mtu;
 206         __u16           num_blocks;
 207         __u16           block_cnt;
 208
 209         unsigned long   acl_last_tx;
 210         unsigned long   sco_last_tx;
 211         unsigned long   le_last_tx;
 212
 213         struct workqueue_struct *workqueue;
 214
 215         struct work_struct      power_on;
 216         struct delayed_work     power_off;
 217
 218         __u16                   discov_timeout;
 219         struct delayed_work     discov_off;
 220
 221         struct delayed_work     service_cache;
 222
 223         struct timer_list       cmd_timer;
 224
 225         struct work_struct      rx_work;
 226         struct work_struct      cmd_work;
 227         struct work_struct      tx_work;
 228
 229         struct sk_buff_head     rx_q;
 230         struct sk_buff_head     raw_q;
 231         struct sk_buff_head     cmd_q;
 232
 233         struct sk_buff          *sent_cmd;
 234         struct sk_buff          *reassembly[NUM_REASSEMBLY];
 235
 236         struct mutex            req_lock;
 237         wait_queue_head_t       req_wait_q;
 238         __u32                   req_status;
 239         __u32                   req_result;
 240
 241         __u16                   init_last_cmd;
 242
 243         struct list_head        mgmt_pending;
 244
 245         struct discovery_state  discovery;
 246         struct hci_conn_hash    conn_hash;
 247         struct list_head        blacklist;
 248
 249         struct list_head        uuids;
 250
 251         struct list_head        link_keys;
 252
 253         struct list_head        long_term_keys;
 254
 255         struct list_head        remote_oob_data;
 256
 257         struct hci_dev_stats    stat;
 258
 259         struct sk_buff_head     driver_init;
 260
 261         void                    *core_data;
 262
 263         atomic_t                promisc;
 264
 265         struct dentry           *debugfs;
 266
 267         struct device           dev;
 268
 269         struct rfkill           *rfkill;
 270
 271         unsigned long           dev_flags;
 272
 273         struct delayed_work     le_scan_disable;
 274
 275         struct work_struct      le_scan;
 276         struct le_scan_params   le_scan_params;
 277
 278         int (*open)(struct hci_dev *hdev);
 279         int (*close)(struct hci_dev *hdev);
 280         int (*flush)(struct hci_dev *hdev);
 281         int (*send)(struct sk_buff *skb);
 282         void (*notify)(struct hci_dev *hdev, unsigned int evt);
 283         int (*ioctl)(struct hci_dev *hdev, unsigned int cmd, unsigned long arg);
 284 };
 285
 286 struct hci_conn {
 287         struct list_head list;
 288
 289         atomic_t        refcnt;
 290
 291         bdaddr_t        dst;
 292         __u8            dst_type;
 293         __u16           handle;
 294         __u16           state;
 295         __u8            mode;
 296         __u8            type;
 297         bool            out;
 298         __u8            attempt;
 299         __u8            dev_class[3];
 300         __u8            features[8];
 301         __u16           interval;
 302         __u16           pkt_type;
 303         __u16           link_policy;
 304         __u32           link_mode;
 305         __u8            key_type;
 306         __u8            auth_type;
 307         __u8            sec_level;
 308         __u8            pending_sec_level;
 309         __u8            pin_length;
 310         __u8            enc_key_size;
 311         __u8            io_capability;
 312         __u16           disc_timeout;
 313         unsigned long   flags;
 314
 315         __u8            remote_cap;
 316         __u8            remote_auth;
 317         bool            flush_key;
 318
 319         unsigned int    sent;
 320
 321         struct sk_buff_head data_q;
 322         struct list_head chan_list;
 323
 324         struct delayed_work disc_work;
 325         struct timer_list idle_timer;
 326         struct timer_list auto_accept_timer;
 327
 328         struct device   dev;
 329         atomic_t        devref;
 330
 331         struct hci_dev  *hdev;
 332         void            *l2cap_data;
 333         void            *sco_data;
 334         void            *smp_conn;
 335         struct amp_mgr  *amp_mgr;
 336
 337         struct hci_conn *link;
 338
 339         void (*connect_cfm_cb)  (struct hci_conn *conn, u8 status);
 340         void (*security_cfm_cb) (struct hci_conn *conn, u8 status);
 341         void (*disconn_cfm_cb)  (struct hci_conn *conn, u8 reason);
 342 };
 343
 344 struct hci_chan {
 345         struct list_head list;
 346
 347         struct hci_conn *conn;
 348         struct sk_buff_head data_q;
 349         unsigned int    sent;
 350 };
 351
 352 extern struct list_head hci_dev_list;
 353 extern struct list_head hci_cb_list;
 354 extern rwlock_t hci_dev_list_lock;
 355 extern rwlock_t hci_cb_list_lock;
 356
 357 /* ----- HCI interface to upper protocols ----- */
 358 extern int l2cap_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr);
 359 extern int l2cap_connect_cfm(struct hci_conn *hcon, u8 status);
 360 extern int l2cap_disconn_ind(struct hci_conn *hcon);
 361 extern int l2cap_disconn_cfm(struct hci_conn *hcon, u8 reason);
 362 extern int l2cap_security_cfm(struct hci_conn *hcon, u8 status, u8 encrypt);
 363 extern int l2cap_recv_acldata(struct hci_conn *hcon, struct sk_buff *skb,
 364                               u16 flags);
 365
 366 extern int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr);
 367 extern int sco_connect_cfm(struct hci_conn *hcon, __u8 status);
 368 extern int sco_disconn_cfm(struct hci_conn *hcon, __u8 reason);
 369 extern int sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb);
 370
 371 /* ----- Inquiry cache ----- */
 372 #define INQUIRY_CACHE_AGE_MAX   (HZ*30)   /* 30 seconds */
 373 #define INQUIRY_ENTRY_AGE_MAX   (HZ*60)   /* 60 seconds */
 374
 375 static inline void discovery_init(struct hci_dev *hdev)
 376 {
 377         hdev->discovery.state = DISCOVERY_STOPPED;
 378         INIT_LIST_HEAD(&hdev->discovery.all);
 379         INIT_LIST_HEAD(&hdev->discovery.unknown);
 380         INIT_LIST_HEAD(&hdev->discovery.resolve);
 381 }
 382
 383 bool hci_discovery_active(struct hci_dev *hdev);
 384
 385 void hci_discovery_set_state(struct hci_dev *hdev, int state);
 386
 387 static inline int inquiry_cache_empty(struct hci_dev *hdev)
 388 {
 389         return list_empty(&hdev->discovery.all);
 390 }
 391
 392 static inline long inquiry_cache_age(struct hci_dev *hdev)
 393 {
 394         struct discovery_state *c = &hdev->discovery;
 395         return jiffies - c->timestamp;
 396 }
 397
 398 static inline long inquiry_entry_age(struct inquiry_entry *e)
 399 {
 400         return jiffies - e->timestamp;
 401 }
 402
 403 struct inquiry_entry *hci_inquiry_cache_lookup(struct hci_dev *hdev,
 404                                                bdaddr_t *bdaddr);
 405 struct inquiry_entry *hci_inquiry_cache_lookup_unknown(struct hci_dev *hdev,
 406                                                        bdaddr_t *bdaddr);
 407 struct inquiry_entry *hci_inquiry_cache_lookup_resolve(struct hci_dev *hdev,
 408                                                        bdaddr_t *bdaddr,
 409                                                        int state);
 410 void hci_inquiry_cache_update_resolve(struct hci_dev *hdev,
 411                                       struct inquiry_entry *ie);
 412 bool hci_inquiry_cache_update(struct hci_dev *hdev, struct inquiry_data *data,
 413                               bool name_known, bool *ssp);
 414
 415 /* ----- HCI Connections ----- */
 416 enum {
 417         HCI_CONN_AUTH_PEND,
 418         HCI_CONN_REAUTH_PEND,
 419         HCI_CONN_ENCRYPT_PEND,
 420         HCI_CONN_RSWITCH_PEND,
 421         HCI_CONN_MODE_CHANGE_PEND,
 422         HCI_CONN_SCO_SETUP_PEND,
 423         HCI_CONN_LE_SMP_PEND,
 424         HCI_CONN_MGMT_CONNECTED,
 425         HCI_CONN_SSP_ENABLED,
 426         HCI_CONN_POWER_SAVE,
 427         HCI_CONN_REMOTE_OOB,
 428 };
 429
 430 static inline bool hci_conn_ssp_enabled(struct hci_conn *conn)
 431 {
 432         struct hci_dev *hdev = conn->hdev;
 433         return test_bit(HCI_SSP_ENABLED, &hdev->dev_flags) &&
 434                test_bit(HCI_CONN_SSP_ENABLED, &conn->flags);
 435 }
 436
 437 static inline void hci_conn_hash_init(struct hci_dev *hdev)
 438 {
 439         struct hci_conn_hash *h = &hdev->conn_hash;
 440         INIT_LIST_HEAD(&h->list);
 441         h->acl_num = 0;
 442         h->sco_num = 0;
 443         h->le_num = 0;
 444 }
 445
 446 static inline void hci_conn_hash_add(struct hci_dev *hdev, struct hci_conn *c)
 447 {
 448         struct hci_conn_hash *h = &hdev->conn_hash;
 449         list_add_rcu(&c->list, &h->list);
 450         switch (c->type) {
 451         case ACL_LINK:
 452                 h->acl_num++;
 453                 break;
 454         case LE_LINK:
 455                 h->le_num++;
 456                 break;
 457         case SCO_LINK:
 458         case ESCO_LINK:
 459                 h->sco_num++;
 460                 break;
 461         }
 462 }
 463
 464 static inline void hci_conn_hash_del(struct hci_dev *hdev, struct hci_conn *c)
 465 {
 466         struct hci_conn_hash *h = &hdev->conn_hash;
 467
 468         list_del_rcu(&c->list);
 469         synchronize_rcu();
 470
 471         switch (c->type) {
 472         case ACL_LINK:
 473                 h->acl_num--;
 474                 break;
 475         case LE_LINK:
 476                 h->le_num--;
 477                 break;
 478         case SCO_LINK:
 479         case ESCO_LINK:
 480                 h->sco_num--;
 481                 break;
 482         }
 483 }
 484
 485 static inline unsigned int hci_conn_num(struct hci_dev *hdev, __u8 type)
 486 {
 487         struct hci_conn_hash *h = &hdev->conn_hash;
 488         switch (type) {
 489         case ACL_LINK:
 490                 return h->acl_num;
 491         case LE_LINK:
 492                 return h->le_num;
 493         case SCO_LINK:
 494         case ESCO_LINK:
 495                 return h->sco_num;
 496         default:
 497                 return 0;
 498         }
 499 }
 500
 501 static inline struct hci_conn *hci_conn_hash_lookup_handle(struct hci_dev *hdev,
 502                                                                 __u16 handle)
 503 {
 504         struct hci_conn_hash *h = &hdev->conn_hash;
 505         struct hci_conn  *c;
 506
 507         rcu_read_lock();
 508
 509         list_for_each_entry_rcu(c, &h->list, list) {
 510                 if (c->handle == handle) {
 511                         rcu_read_unlock();
 512                         return c;
 513                 }
 514         }
 515         rcu_read_unlock();
 516
 517         return NULL;
 518 }
 519
 520 static inline struct hci_conn *hci_conn_hash_lookup_ba(struct hci_dev *hdev,
 521                                                         __u8 type, bdaddr_t *ba)
 522 {
 523         struct hci_conn_hash *h = &hdev->conn_hash;
 524         struct hci_conn  *c;
 525
 526         rcu_read_lock();
 527
 528         list_for_each_entry_rcu(c, &h->list, list) {
 529                 if (c->type == type && !bacmp(&c->dst, ba)) {
 530                         rcu_read_unlock();
 531                         return c;
 532                 }
 533         }
 534
 535         rcu_read_unlock();
 536
 537         return NULL;
 538 }
 539
 540 static inline struct hci_conn *hci_conn_hash_lookup_state(struct hci_dev *hdev,
 541                                                         __u8 type, __u16 state)
 542 {
 543         struct hci_conn_hash *h = &hdev->conn_hash;
 544         struct hci_conn  *c;
 545
 546         rcu_read_lock();
 547
 548         list_for_each_entry_rcu(c, &h->list, list) {
 549                 if (c->type == type && c->state == state) {
 550                         rcu_read_unlock();
 551                         return c;
 552                 }
 553         }
 554
 555         rcu_read_unlock();
 556
 557         return NULL;
 558 }
 559
 560 void hci_acl_connect(struct hci_conn *conn);
 561 void hci_acl_disconn(struct hci_conn *conn, __u8 reason);
 562 void hci_add_sco(struct hci_conn *conn, __u16 handle);
 563 void hci_setup_sync(struct hci_conn *conn, __u16 handle);
 564 void hci_sco_setup(struct hci_conn *conn, __u8 status);
 565
 566 struct hci_conn *hci_conn_add(struct hci_dev *hdev, int type, bdaddr_t *dst);
 567 int hci_conn_del(struct hci_conn *conn);
 568 void hci_conn_hash_flush(struct hci_dev *hdev);
 569 void hci_conn_check_pending(struct hci_dev *hdev);
 570
 571 struct hci_chan *hci_chan_create(struct hci_conn *conn);
 572 int hci_chan_del(struct hci_chan *chan);
 573 void hci_chan_list_flush(struct hci_conn *conn);
 574
 575 struct hci_conn *hci_connect(struct hci_dev *hdev, int type, bdaddr_t *dst,
 576                              __u8 dst_type, __u8 sec_level, __u8 auth_type);
 577 int hci_conn_check_link_mode(struct hci_conn *conn);
 578 int hci_conn_check_secure(struct hci_conn *conn, __u8 sec_level);
 579 int hci_conn_security(struct hci_conn *conn, __u8 sec_level, __u8 auth_type);
 580 int hci_conn_change_link_key(struct hci_conn *conn);
 581 int hci_conn_switch_role(struct hci_conn *conn, __u8 role);
 582
 583 void hci_conn_enter_active_mode(struct hci_conn *conn, __u8 force_active);
 584
 585 void hci_conn_hold_device(struct hci_conn *conn);
 586 void hci_conn_put_device(struct hci_conn *conn);
 587
 588 static inline void hci_conn_hold(struct hci_conn *conn)
 589 {
 590         BT_DBG("hcon %p refcnt %d -> %d", conn, atomic_read(&conn->refcnt),
 591                atomic_read(&conn->refcnt) + 1);
 592
 593         atomic_inc(&conn->refcnt);
 594         cancel_delayed_work(&conn->disc_work);
 595 }
 596
 597 static inline void hci_conn_put(struct hci_conn *conn)
 598 {
 599         BT_DBG("hcon %p refcnt %d -> %d", conn, atomic_read(&conn->refcnt),
 600                atomic_read(&conn->refcnt) - 1);
 601
 602         if (atomic_dec_and_test(&conn->refcnt)) {
 603                 unsigned long timeo;
 604                 if (conn->type == ACL_LINK || conn->type == LE_LINK) {
 605                         del_timer(&conn->idle_timer);
 606                         if (conn->state == BT_CONNECTED) {
 607                                 timeo = conn->disc_timeout;
 608                                 if (!conn->out)
 609                                         timeo *= 2;
 610                         } else {
 611                                 timeo = msecs_to_jiffies(10);
 612                         }
 613                 } else {
 614                         timeo = msecs_to_jiffies(10);
 615                 }
 616                 cancel_delayed_work(&conn->disc_work);
 617                 queue_delayed_work(conn->hdev->workqueue,
 618                                         &conn->disc_work, timeo);
 619         }
 620 }
 621
 622 /* ----- HCI Devices ----- */
 623 static inline void hci_dev_put(struct hci_dev *d)
 624 {
 625         put_device(&d->dev);
 626 }
 627
 628 static inline struct hci_dev *hci_dev_hold(struct hci_dev *d)
 629 {
 630         get_device(&d->dev);
 631         return d;
 632 }
 633
 634 #define hci_dev_lock(d)         mutex_lock(&d->lock)
 635 #define hci_dev_unlock(d)       mutex_unlock(&d->lock)
 636
 637 #define to_hci_dev(d) container_of(d, struct hci_dev, dev)
 638 #define to_hci_conn(c) container_of(c, struct hci_conn, dev)
 639
 640 static inline void *hci_get_drvdata(struct hci_dev *hdev)
 641 {
 642         return dev_get_drvdata(&hdev->dev);
 643 }
 644
 645 static inline void hci_set_drvdata(struct hci_dev *hdev, void *data)
 646 {
 647         dev_set_drvdata(&hdev->dev, data);
 648 }
 649
 650 /* hci_dev_list shall be locked */
 651 static inline uint8_t __hci_num_ctrl(void)
 652 {
 653         uint8_t count = 0;
 654         struct list_head *p;
 655
 656         list_for_each(p, &hci_dev_list) {
 657                 count++;
 658         }
 659
 660         return count;
 661 }
 662
 663 struct hci_dev *hci_dev_get(int index);
 664 struct hci_dev *hci_get_route(bdaddr_t *src, bdaddr_t *dst);
 665
 666 struct hci_dev *hci_alloc_dev(void);
 667 void hci_free_dev(struct hci_dev *hdev);
 668 int hci_register_dev(struct hci_dev *hdev);
 669 void hci_unregister_dev(struct hci_dev *hdev);
 670 int hci_suspend_dev(struct hci_dev *hdev);
 671 int hci_resume_dev(struct hci_dev *hdev);
 672 int hci_dev_open(__u16 dev);
 673 int hci_dev_close(__u16 dev);
 674 int hci_dev_reset(__u16 dev);
 675 int hci_dev_reset_stat(__u16 dev);
 676 int hci_dev_cmd(unsigned int cmd, void __user *arg);
 677 int hci_get_dev_list(void __user *arg);
 678 int hci_get_dev_info(void __user *arg);
 679 int hci_get_conn_list(void __user *arg);
 680 int hci_get_conn_info(struct hci_dev *hdev, void __user *arg);
 681 int hci_get_auth_info(struct hci_dev *hdev, void __user *arg);
 682 int hci_inquiry(void __user *arg);
 683
 684 struct bdaddr_list *hci_blacklist_lookup(struct hci_dev *hdev,
 685                                          bdaddr_t *bdaddr);
 686 int hci_blacklist_clear(struct hci_dev *hdev);
 687 int hci_blacklist_add(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 type);
 688 int hci_blacklist_del(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 type);
 689
 690 int hci_uuids_clear(struct hci_dev *hdev);
 691
 692 int hci_link_keys_clear(struct hci_dev *hdev);
 693 struct link_key *hci_find_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr);
 694 int hci_add_link_key(struct hci_dev *hdev, struct hci_conn *conn, int new_key,
 695                      bdaddr_t *bdaddr, u8 *val, u8 type, u8 pin_len);
 696 struct smp_ltk *hci_find_ltk(struct hci_dev *hdev, __le16 ediv, u8 rand[8]);
 697 int hci_add_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 addr_type, u8 type,
 698                 int new_key, u8 authenticated, u8 tk[16], u8 enc_size,
 699                 __le16 ediv, u8 rand[8]);
 700 struct smp_ltk *hci_find_ltk_by_addr(struct hci_dev *hdev, bdaddr_t *bdaddr,
 701                                      u8 addr_type);
 702 int hci_remove_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr);
 703 int hci_smp_ltks_clear(struct hci_dev *hdev);
 704 int hci_remove_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr);
 705
 706 int hci_remote_oob_data_clear(struct hci_dev *hdev);
 707 struct oob_data *hci_find_remote_oob_data(struct hci_dev *hdev,
 708                                                         bdaddr_t *bdaddr);
 709 int hci_add_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 *hash,
 710                                                                 u8 *randomizer);
 711 int hci_remove_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr);
 712
 713 void hci_event_packet(struct hci_dev *hdev, struct sk_buff *skb);
 714
 715 int hci_recv_frame(struct sk_buff *skb);
 716 int hci_recv_fragment(struct hci_dev *hdev, int type, void *data, int count);
 717 int hci_recv_stream_fragment(struct hci_dev *hdev, void *data, int count);
 718
 719 void hci_init_sysfs(struct hci_dev *hdev);
 720 int hci_add_sysfs(struct hci_dev *hdev);
 721 void hci_del_sysfs(struct hci_dev *hdev);
 722 void hci_conn_init_sysfs(struct hci_conn *conn);
 723 void hci_conn_add_sysfs(struct hci_conn *conn);
 724 void hci_conn_del_sysfs(struct hci_conn *conn);
 725
 726 #define SET_HCIDEV_DEV(hdev, pdev) ((hdev)->dev.parent = (pdev))
 727
 728 /* ----- LMP capabilities ----- */
 729 #define lmp_rswitch_capable(dev)   ((dev)->features[0] & LMP_RSWITCH)
 730 #define lmp_encrypt_capable(dev)   ((dev)->features[0] & LMP_ENCRYPT)
 731 #define lmp_sniff_capable(dev)     ((dev)->features[0] & LMP_SNIFF)
 732 #define lmp_sniffsubr_capable(dev) ((dev)->features[5] & LMP_SNIFF_SUBR)
 733 #define lmp_esco_capable(dev)      ((dev)->features[3] & LMP_ESCO)
 734 #define lmp_ssp_capable(dev)       ((dev)->features[6] & LMP_SIMPLE_PAIR)
 735 #define lmp_no_flush_capable(dev)  ((dev)->features[6] & LMP_NO_FLUSH)
 736 #define lmp_le_capable(dev)        ((dev)->features[4] & LMP_LE)
 737 #define lmp_bredr_capable(dev)     (!((dev)->features[4] & LMP_NO_BREDR))
 738
 739 /* ----- Extended LMP capabilities ----- */
 740 #define lmp_host_le_capable(dev)   ((dev)->host_features[0] & LMP_HOST_LE)
 741
 742 /* ----- HCI protocols ----- */
 743 static inline int hci_proto_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr,
 744                                                                 __u8 type)
 745 {
 746         switch (type) {
 747         case ACL_LINK:
 748                 return l2cap_connect_ind(hdev, bdaddr);
 749
 750         case SCO_LINK:
 751         case ESCO_LINK:
 752                 return sco_connect_ind(hdev, bdaddr);
 753
 754         default:
 755                 BT_ERR("unknown link type %d", type);
 756                 return -EINVAL;
 757         }
 758 }
 759
 760 static inline void hci_proto_connect_cfm(struct hci_conn *conn, __u8 status)
 761 {
 762         switch (conn->type) {
 763         case ACL_LINK:
 764         case LE_LINK:
 765                 l2cap_connect_cfm(conn, status);
 766                 break;
 767
 768         case SCO_LINK:
 769         case ESCO_LINK:
 770                 sco_connect_cfm(conn, status);
 771                 break;
 772
 773         default:
 774                 BT_ERR("unknown link type %d", conn->type);
 775                 break;
 776         }
 777
 778         if (conn->connect_cfm_cb)
 779                 conn->connect_cfm_cb(conn, status);
 780 }
 781
 782 static inline int hci_proto_disconn_ind(struct hci_conn *conn)
 783 {
 784         if (conn->type != ACL_LINK && conn->type != LE_LINK)
 785                 return HCI_ERROR_REMOTE_USER_TERM;
 786
 787         return l2cap_disconn_ind(conn);
 788 }
 789
 790 static inline void hci_proto_disconn_cfm(struct hci_conn *conn, __u8 reason)
 791 {
 792         switch (conn->type) {
 793         case ACL_LINK:
 794         case LE_LINK:
 795                 l2cap_disconn_cfm(conn, reason);
 796                 break;
 797
 798         case SCO_LINK:
 799         case ESCO_LINK:
 800                 sco_disconn_cfm(conn, reason);
 801                 break;
 802
 803         default:
 804                 BT_ERR("unknown link type %d", conn->type);
 805                 break;
 806         }
 807
 808         if (conn->disconn_cfm_cb)
 809                 conn->disconn_cfm_cb(conn, reason);
 810 }
 811
 812 static inline void hci_proto_auth_cfm(struct hci_conn *conn, __u8 status)
 813 {
 814         __u8 encrypt;
 815
 816         if (conn->type != ACL_LINK && conn->type != LE_LINK)
 817                 return;
 818
 819         if (test_bit(HCI_CONN_ENCRYPT_PEND, &conn->flags))
 820                 return;
 821
 822         encrypt = (conn->link_mode & HCI_LM_ENCRYPT) ? 0x01 : 0x00;
 823         l2cap_security_cfm(conn, status, encrypt);
 824
 825         if (conn->security_cfm_cb)
 826                 conn->security_cfm_cb(conn, status);
 827 }
 828
 829 static inline void hci_proto_encrypt_cfm(struct hci_conn *conn, __u8 status,
 830                                                                 __u8 encrypt)
 831 {
 832         if (conn->type != ACL_LINK && conn->type != LE_LINK)
 833                 return;
 834
 835         l2cap_security_cfm(conn, status, encrypt);
 836
 837         if (conn->security_cfm_cb)
 838                 conn->security_cfm_cb(conn, status);
 839 }
 840
 841 /* ----- HCI callbacks ----- */
 842 struct hci_cb {
 843         struct list_head list;
 844
 845         char *name;
 846
 847         void (*security_cfm)    (struct hci_conn *conn, __u8 status,
 848                                                                 __u8 encrypt);
 849         void (*key_change_cfm)  (struct hci_conn *conn, __u8 status);
 850         void (*role_switch_cfm) (struct hci_conn *conn, __u8 status, __u8 role);
 851 };
 852
 853 static inline void hci_auth_cfm(struct hci_conn *conn, __u8 status)
 854 {
 855         struct list_head *p;
 856         __u8 encrypt;
 857
 858         hci_proto_auth_cfm(conn, status);
 859
 860         if (test_bit(HCI_CONN_ENCRYPT_PEND, &conn->flags))
 861                 return;
 862
 863         encrypt = (conn->link_mode & HCI_LM_ENCRYPT) ? 0x01 : 0x00;
 864
 865         read_lock(&hci_cb_list_lock);
 866         list_for_each(p, &hci_cb_list) {
 867                 struct hci_cb *cb = list_entry(p, struct hci_cb, list);
 868                 if (cb->security_cfm)
 869                         cb->security_cfm(conn, status, encrypt);
 870         }
 871         read_unlock(&hci_cb_list_lock);
 872 }
 873
 874 static inline void hci_encrypt_cfm(struct hci_conn *conn, __u8 status,
 875                                                                 __u8 encrypt)
 876 {
 877         struct list_head *p;
 878
 879         if (conn->sec_level == BT_SECURITY_SDP)
 880                 conn->sec_level = BT_SECURITY_LOW;
 881
 882         if (conn->pending_sec_level > conn->sec_level)
 883                 conn->sec_level = conn->pending_sec_level;
 884
 885         hci_proto_encrypt_cfm(conn, status, encrypt);
 886
 887         read_lock(&hci_cb_list_lock);
 888         list_for_each(p, &hci_cb_list) {
 889                 struct hci_cb *cb = list_entry(p, struct hci_cb, list);
 890                 if (cb->security_cfm)
 891                         cb->security_cfm(conn, status, encrypt);
 892         }
 893         read_unlock(&hci_cb_list_lock);
 894 }
 895
 896 static inline void hci_key_change_cfm(struct hci_conn *conn, __u8 status)
 897 {
 898         struct list_head *p;
 899
 900         read_lock(&hci_cb_list_lock);
 901         list_for_each(p, &hci_cb_list) {
 902                 struct hci_cb *cb = list_entry(p, struct hci_cb, list);
 903                 if (cb->key_change_cfm)
 904                         cb->key_change_cfm(conn, status);
 905         }
 906         read_unlock(&hci_cb_list_lock);
 907 }
 908
 909 static inline void hci_role_switch_cfm(struct hci_conn *conn, __u8 status,
 910                                                                 __u8 role)
 911 {
 912         struct list_head *p;
 913
 914         read_lock(&hci_cb_list_lock);
 915         list_for_each(p, &hci_cb_list) {
 916                 struct hci_cb *cb = list_entry(p, struct hci_cb, list);
 917                 if (cb->role_switch_cfm)
 918                         cb->role_switch_cfm(conn, status, role);
 919         }
 920         read_unlock(&hci_cb_list_lock);
 921 }
 922
 923 static inline bool eir_has_data_type(u8 *data, size_t data_len, u8 type)
 924 {
 925         size_t parsed = 0;
 926
 927         if (data_len < 2)
 928                 return false;
 929
 930         while (parsed < data_len - 1) {
 931                 u8 field_len = data[0];
 932
 933                 if (field_len == 0)
 934                         break;
 935
 936                 parsed += field_len + 1;
 937
 938                 if (parsed > data_len)
 939                         break;
 940
 941                 if (data[1] == type)
 942                         return true;
 943
 944                 data += field_len + 1;
 945         }
 946
 947         return false;
 948 }
 949
 950 static inline size_t eir_get_length(u8 *eir, size_t eir_len)
 951 {
 952         size_t parsed = 0;
 953
 954         while (parsed < eir_len) {
 955                 u8 field_len = eir[0];
 956
 957                 if (field_len == 0)
 958                         return parsed;
 959
 960                 parsed += field_len + 1;
 961                 eir += field_len + 1;
 962         }
 963
 964         return eir_len;
 965 }
 966
 967 static inline u16 eir_append_data(u8 *eir, u16 eir_len, u8 type, u8 *data,
 968                                   u8 data_len)
 969 {
 970         eir[eir_len++] = sizeof(type) + data_len;
 971         eir[eir_len++] = type;
 972         memcpy(&eir[eir_len], data, data_len);
 973         eir_len += data_len;
 974
 975         return eir_len;
 976 }
 977
 978 int hci_register_cb(struct hci_cb *hcb);
 979 int hci_unregister_cb(struct hci_cb *hcb);
 980
 981 int hci_send_cmd(struct hci_dev *hdev, __u16 opcode, __u32 plen, void *param);
 982 void hci_send_acl(struct hci_chan *chan, struct sk_buff *skb, __u16 flags);
 983 void hci_send_sco(struct hci_conn *conn, struct sk_buff *skb);
 984
 985 void *hci_sent_cmd_data(struct hci_dev *hdev, __u16 opcode);
 986
 987 /* ----- HCI Sockets ----- */
 988 void hci_send_to_sock(struct hci_dev *hdev, struct sk_buff *skb);
 989 void hci_send_to_control(struct sk_buff *skb, struct sock *skip_sk);
 990 void hci_send_to_monitor(struct hci_dev *hdev, struct sk_buff *skb);
 991
 992 void hci_sock_dev_event(struct hci_dev *hdev, int event);
 993
 994 /* Management interface */
 995 #define DISCOV_TYPE_BREDR               (BIT(BDADDR_BREDR))
 996 #define DISCOV_TYPE_LE                  (BIT(BDADDR_LE_PUBLIC) | \
 997                                          BIT(BDADDR_LE_RANDOM))
 998 #define DISCOV_TYPE_INTERLEAVED         (BIT(BDADDR_BREDR) | \
 999                                          BIT(BDADDR_LE_PUBLIC) | \
1000                                          BIT(BDADDR_LE_RANDOM))
1001
1002 int mgmt_control(struct sock *sk, struct msghdr *msg, size_t len);
1003 int mgmt_index_added(struct hci_dev *hdev);
1004 int mgmt_index_removed(struct hci_dev *hdev);
1005 int mgmt_powered(struct hci_dev *hdev, u8 powered);
1006 int mgmt_discoverable(struct hci_dev *hdev, u8 discoverable);
1007 int mgmt_connectable(struct hci_dev *hdev, u8 connectable);
1008 int mgmt_write_scan_failed(struct hci_dev *hdev, u8 scan, u8 status);
1009 int mgmt_new_link_key(struct hci_dev *hdev, struct link_key *key,
1010                       bool persistent);
1011 int mgmt_device_connected(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type,
1012                           u8 addr_type, u32 flags, u8 *name, u8 name_len,
1013                           u8 *dev_class);
1014 int mgmt_device_disconnected(struct hci_dev *hdev, bdaddr_t *bdaddr,
1015                              u8 link_type, u8 addr_type);
1016 int mgmt_disconnect_failed(struct hci_dev *hdev, bdaddr_t *bdaddr,
1017                            u8 link_type, u8 addr_type, u8 status);
1018 int mgmt_connect_failed(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type,
1019                         u8 addr_type, u8 status);
1020 int mgmt_pin_code_request(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 secure);
1021 int mgmt_pin_code_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
1022                                  u8 status);
1023 int mgmt_pin_code_neg_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
1024                                      u8 status);
1025 int mgmt_user_confirm_request(struct hci_dev *hdev, bdaddr_t *bdaddr,
1026                               u8 link_type, u8 addr_type, __le32 value,
1027                               u8 confirm_hint);
1028 int mgmt_user_confirm_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
1029                                      u8 link_type, u8 addr_type, u8 status);
1030 int mgmt_user_confirm_neg_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
1031                                          u8 link_type, u8 addr_type, u8 status);
1032 int mgmt_user_passkey_request(struct hci_dev *hdev, bdaddr_t *bdaddr,
1033                               u8 link_type, u8 addr_type);
1034 int mgmt_user_passkey_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
1035                                      u8 link_type, u8 addr_type, u8 status);
1036 int mgmt_user_passkey_neg_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
1037                                          u8 link_type, u8 addr_type, u8 status);
1038 int mgmt_auth_failed(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type,
1039                      u8 addr_type, u8 status);
1040 int mgmt_auth_enable_complete(struct hci_dev *hdev, u8 status);
1041 int mgmt_ssp_enable_complete(struct hci_dev *hdev, u8 enable, u8 status);
1042 int mgmt_set_class_of_dev_complete(struct hci_dev *hdev, u8 *dev_class,
1043                                    u8 status);
1044 int mgmt_set_local_name_complete(struct hci_dev *hdev, u8 *name, u8 status);
1045 int mgmt_read_local_oob_data_reply_complete(struct hci_dev *hdev, u8 *hash,
1046                                             u8 *randomizer, u8 status);
1047 int mgmt_le_enable_complete(struct hci_dev *hdev, u8 enable, u8 status);
1048 int mgmt_device_found(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type,
1049                       u8 addr_type, u8 *dev_class, s8 rssi, u8 cfm_name,
1050                       u8 ssp, u8 *eir, u16 eir_len);
1051 int mgmt_remote_name(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type,
1052                      u8 addr_type, s8 rssi, u8 *name, u8 name_len);
1053 int mgmt_start_discovery_failed(struct hci_dev *hdev, u8 status);
1054 int mgmt_stop_discovery_failed(struct hci_dev *hdev, u8 status);
1055 int mgmt_discovering(struct hci_dev *hdev, u8 discovering);
1056 int mgmt_interleaved_discovery(struct hci_dev *hdev);
1057 int mgmt_device_blocked(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 type);
1058 int mgmt_device_unblocked(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 type);
1059
1060 int mgmt_new_ltk(struct hci_dev *hdev, struct smp_ltk *key, u8 persistent);
1061
1062 /* HCI info for socket */
1063 #define hci_pi(sk) ((struct hci_pinfo *) sk)
1064
1065 struct hci_pinfo {
1066         struct bt_sock    bt;
1067         struct hci_dev    *hdev;
1068         struct hci_filter filter;
1069         __u32             cmsg_mask;
1070         unsigned short   channel;
1071 };
1072
1073 /* HCI security filter */
1074 #define HCI_SFLT_MAX_OGF  5
1075
1076 struct hci_sec_filter {
1077         __u32 type_mask;
1078         __u32 event_mask[2];
1079         __u32 ocf_mask[HCI_SFLT_MAX_OGF + 1][4];
1080 };
1081
1082 /* ----- HCI requests ----- */
1083 #define HCI_REQ_DONE      0
1084 #define HCI_REQ_PEND      1
1085 #define HCI_REQ_CANCELED  2
1086
1087 #define hci_req_lock(d)         mutex_lock(&d->req_lock)
1088 #define hci_req_unlock(d)       mutex_unlock(&d->req_lock)
1089
1090 void hci_req_complete(struct hci_dev *hdev, __u16 cmd, int result);
1091
1092 void hci_le_conn_update(struct hci_conn *conn, u16 min, u16 max,
1093                                         u16 latency, u16 to_multiplier);
1094 void hci_le_start_enc(struct hci_conn *conn, __le16 ediv, __u8 rand[8],
1095                                                         __u8 ltk[16]);
1096 int hci_do_inquiry(struct hci_dev *hdev, u8 length);
1097 int hci_cancel_inquiry(struct hci_dev *hdev);
1098 int hci_le_scan(struct hci_dev *hdev, u8 type, u16 interval, u16 window,
1099                 int timeout);
1100 int hci_cancel_le_scan(struct hci_dev *hdev);
1101
1102 u8 bdaddr_to_le(u8 bdaddr_type);
1103
1104 #endif /* __HCI_CORE_H */