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
 336         struct hci_conn *link;
 337
 338         void (*connect_cfm_cb)  (struct hci_conn *conn, u8 status);
 339         void (*security_cfm_cb) (struct hci_conn *conn, u8 status);
 340         void (*disconn_cfm_cb)  (struct hci_conn *conn, u8 reason);
 341 };
 342
 343 struct hci_chan {
 344         struct list_head list;
 345
 346         struct hci_conn *conn;
 347         struct sk_buff_head data_q;
 348         unsigned int    sent;
 349 };
 350
 351 extern struct list_head hci_dev_list;
 352 extern struct list_head hci_cb_list;
 353 extern rwlock_t hci_dev_list_lock;
 354 extern rwlock_t hci_cb_list_lock;
 355
 356 /* ----- HCI interface to upper protocols ----- */
 357 extern int l2cap_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr);
 358 extern int l2cap_connect_cfm(struct hci_conn *hcon, u8 status);
 359 extern int l2cap_disconn_ind(struct hci_conn *hcon);
 360 extern int l2cap_disconn_cfm(struct hci_conn *hcon, u8 reason);
 361 extern int l2cap_security_cfm(struct hci_conn *hcon, u8 status, u8 encrypt);
 362 extern int l2cap_recv_acldata(struct hci_conn *hcon, struct sk_buff *skb,
 363                               u16 flags);
 364
 365 extern int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr);
 366 extern int sco_connect_cfm(struct hci_conn *hcon, __u8 status);
 367 extern int sco_disconn_cfm(struct hci_conn *hcon, __u8 reason);
 368 extern int sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb);
 369
 370 /* ----- Inquiry cache ----- */
 371 #define INQUIRY_CACHE_AGE_MAX   (HZ*30)   /* 30 seconds */
 372 #define INQUIRY_ENTRY_AGE_MAX   (HZ*60)   /* 60 seconds */
 373
 374 static inline void discovery_init(struct hci_dev *hdev)
 375 {
 376         hdev->discovery.state = DISCOVERY_STOPPED;
 377         INIT_LIST_HEAD(&hdev->discovery.all);
 378         INIT_LIST_HEAD(&hdev->discovery.unknown);
 379         INIT_LIST_HEAD(&hdev->discovery.resolve);
 380 }
 381
 382 bool hci_discovery_active(struct hci_dev *hdev);
 383
 384 void hci_discovery_set_state(struct hci_dev *hdev, int state);
 385
 386 static inline int inquiry_cache_empty(struct hci_dev *hdev)
 387 {
 388         return list_empty(&hdev->discovery.all);
 389 }
 390
 391 static inline long inquiry_cache_age(struct hci_dev *hdev)
 392 {
 393         struct discovery_state *c = &hdev->discovery;
 394         return jiffies - c->timestamp;
 395 }
 396
 397 static inline long inquiry_entry_age(struct inquiry_entry *e)
 398 {
 399         return jiffies - e->timestamp;
 400 }
 401
 402 struct inquiry_entry *hci_inquiry_cache_lookup(struct hci_dev *hdev,
 403                                                bdaddr_t *bdaddr);
 404 struct inquiry_entry *hci_inquiry_cache_lookup_unknown(struct hci_dev *hdev,
 405                                                        bdaddr_t *bdaddr);
 406 struct inquiry_entry *hci_inquiry_cache_lookup_resolve(struct hci_dev *hdev,
 407                                                        bdaddr_t *bdaddr,
 408                                                        int state);
 409 void hci_inquiry_cache_update_resolve(struct hci_dev *hdev,
 410                                       struct inquiry_entry *ie);
 411 bool hci_inquiry_cache_update(struct hci_dev *hdev, struct inquiry_data *data,
 412                               bool name_known, bool *ssp);
 413
 414 /* ----- HCI Connections ----- */
 415 enum {
 416         HCI_CONN_AUTH_PEND,
 417         HCI_CONN_REAUTH_PEND,
 418         HCI_CONN_ENCRYPT_PEND,
 419         HCI_CONN_RSWITCH_PEND,
 420         HCI_CONN_MODE_CHANGE_PEND,
 421         HCI_CONN_SCO_SETUP_PEND,
 422         HCI_CONN_LE_SMP_PEND,
 423         HCI_CONN_MGMT_CONNECTED,
 424         HCI_CONN_SSP_ENABLED,
 425         HCI_CONN_POWER_SAVE,
 426         HCI_CONN_REMOTE_OOB,
 427 };
 428
 429 static inline bool hci_conn_ssp_enabled(struct hci_conn *conn)
 430 {
 431         struct hci_dev *hdev = conn->hdev;
 432         return test_bit(HCI_SSP_ENABLED, &hdev->dev_flags) &&
 433                test_bit(HCI_CONN_SSP_ENABLED, &conn->flags);
 434 }
 435
 436 static inline void hci_conn_hash_init(struct hci_dev *hdev)
 437 {
 438         struct hci_conn_hash *h = &hdev->conn_hash;
 439         INIT_LIST_HEAD(&h->list);
 440         h->acl_num = 0;
 441         h->sco_num = 0;
 442         h->le_num = 0;
 443 }
 444
 445 static inline void hci_conn_hash_add(struct hci_dev *hdev, struct hci_conn *c)
 446 {
 447         struct hci_conn_hash *h = &hdev->conn_hash;
 448         list_add_rcu(&c->list, &h->list);
 449         switch (c->type) {
 450         case ACL_LINK:
 451                 h->acl_num++;
 452                 break;
 453         case LE_LINK:
 454                 h->le_num++;
 455                 break;
 456         case SCO_LINK:
 457         case ESCO_LINK:
 458                 h->sco_num++;
 459                 break;
 460         }
 461 }
 462
 463 static inline void hci_conn_hash_del(struct hci_dev *hdev, struct hci_conn *c)
 464 {
 465         struct hci_conn_hash *h = &hdev->conn_hash;
 466
 467         list_del_rcu(&c->list);
 468         synchronize_rcu();
 469
 470         switch (c->type) {
 471         case ACL_LINK:
 472                 h->acl_num--;
 473                 break;
 474         case LE_LINK:
 475                 h->le_num--;
 476                 break;
 477         case SCO_LINK:
 478         case ESCO_LINK:
 479                 h->sco_num--;
 480                 break;
 481         }
 482 }
 483
 484 static inline unsigned int hci_conn_num(struct hci_dev *hdev, __u8 type)
 485 {
 486         struct hci_conn_hash *h = &hdev->conn_hash;
 487         switch (type) {
 488         case ACL_LINK:
 489                 return h->acl_num;
 490         case LE_LINK:
 491                 return h->le_num;
 492         case SCO_LINK:
 493         case ESCO_LINK:
 494                 return h->sco_num;
 495         default:
 496                 return 0;
 497         }
 498 }
 499
 500 static inline struct hci_conn *hci_conn_hash_lookup_handle(struct hci_dev *hdev,
 501                                                                 __u16 handle)
 502 {
 503         struct hci_conn_hash *h = &hdev->conn_hash;
 504         struct hci_conn  *c;
 505
 506         rcu_read_lock();
 507
 508         list_for_each_entry_rcu(c, &h->list, list) {
 509                 if (c->handle == handle) {
 510                         rcu_read_unlock();
 511                         return c;
 512                 }
 513         }
 514         rcu_read_unlock();
 515
 516         return NULL;
 517 }
 518
 519 static inline struct hci_conn *hci_conn_hash_lookup_ba(struct hci_dev *hdev,
 520                                                         __u8 type, bdaddr_t *ba)
 521 {
 522         struct hci_conn_hash *h = &hdev->conn_hash;
 523         struct hci_conn  *c;
 524
 525         rcu_read_lock();
 526
 527         list_for_each_entry_rcu(c, &h->list, list) {
 528                 if (c->type == type && !bacmp(&c->dst, ba)) {
 529                         rcu_read_unlock();
 530                         return c;
 531                 }
 532         }
 533
 534         rcu_read_unlock();
 535
 536         return NULL;
 537 }
 538
 539 static inline struct hci_conn *hci_conn_hash_lookup_state(struct hci_dev *hdev,
 540                                                         __u8 type, __u16 state)
 541 {
 542         struct hci_conn_hash *h = &hdev->conn_hash;
 543         struct hci_conn  *c;
 544
 545         rcu_read_lock();
 546
 547         list_for_each_entry_rcu(c, &h->list, list) {
 548                 if (c->type == type && c->state == state) {
 549                         rcu_read_unlock();
 550                         return c;
 551                 }
 552         }
 553
 554         rcu_read_unlock();
 555
 556         return NULL;
 557 }
 558
 559 void hci_acl_connect(struct hci_conn *conn);
 560 void hci_acl_disconn(struct hci_conn *conn, __u8 reason);
 561 void hci_add_sco(struct hci_conn *conn, __u16 handle);
 562 void hci_setup_sync(struct hci_conn *conn, __u16 handle);
 563 void hci_sco_setup(struct hci_conn *conn, __u8 status);
 564
 565 struct hci_conn *hci_conn_add(struct hci_dev *hdev, int type, bdaddr_t *dst);
 566 int hci_conn_del(struct hci_conn *conn);
 567 void hci_conn_hash_flush(struct hci_dev *hdev);
 568 void hci_conn_check_pending(struct hci_dev *hdev);
 569
 570 struct hci_chan *hci_chan_create(struct hci_conn *conn);
 571 int hci_chan_del(struct hci_chan *chan);
 572 void hci_chan_list_flush(struct hci_conn *conn);
 573
 574 struct hci_conn *hci_connect(struct hci_dev *hdev, int type, bdaddr_t *dst,
 575                              __u8 dst_type, __u8 sec_level, __u8 auth_type);
 576 int hci_conn_check_link_mode(struct hci_conn *conn);
 577 int hci_conn_check_secure(struct hci_conn *conn, __u8 sec_level);
 578 int hci_conn_security(struct hci_conn *conn, __u8 sec_level, __u8 auth_type);
 579 int hci_conn_change_link_key(struct hci_conn *conn);
 580 int hci_conn_switch_role(struct hci_conn *conn, __u8 role);
 581
 582 void hci_conn_enter_active_mode(struct hci_conn *conn, __u8 force_active);
 583
 584 void hci_conn_hold_device(struct hci_conn *conn);
 585 void hci_conn_put_device(struct hci_conn *conn);
 586
 587 static inline void hci_conn_hold(struct hci_conn *conn)
 588 {
 589         atomic_inc(&conn->refcnt);
 590         cancel_delayed_work(&conn->disc_work);
 591 }
 592
 593 static inline void hci_conn_put(struct hci_conn *conn)
 594 {
 595         if (atomic_dec_and_test(&conn->refcnt)) {
 596                 unsigned long timeo;
 597                 if (conn->type == ACL_LINK || conn->type == LE_LINK) {
 598                         del_timer(&conn->idle_timer);
 599                         if (conn->state == BT_CONNECTED) {
 600                                 timeo = msecs_to_jiffies(conn->disc_timeout);
 601                                 if (!conn->out)
 602                                         timeo *= 2;
 603                         } else {
 604                                 timeo = msecs_to_jiffies(10);
 605                         }
 606                 } else {
 607                         timeo = msecs_to_jiffies(10);
 608                 }
 609                 cancel_delayed_work(&conn->disc_work);
 610                 queue_delayed_work(conn->hdev->workqueue,
 611                                         &conn->disc_work, timeo);
 612         }
 613 }
 614
 615 /* ----- HCI Devices ----- */
 616 static inline void hci_dev_put(struct hci_dev *d)
 617 {
 618         put_device(&d->dev);
 619 }
 620
 621 static inline struct hci_dev *hci_dev_hold(struct hci_dev *d)
 622 {
 623         get_device(&d->dev);
 624         return d;
 625 }
 626
 627 #define hci_dev_lock(d)         mutex_lock(&d->lock)
 628 #define hci_dev_unlock(d)       mutex_unlock(&d->lock)
 629
 630 #define to_hci_dev(d) container_of(d, struct hci_dev, dev)
 631 #define to_hci_conn(c) container_of(c, struct hci_conn, dev)
 632
 633 static inline void *hci_get_drvdata(struct hci_dev *hdev)
 634 {
 635         return dev_get_drvdata(&hdev->dev);
 636 }
 637
 638 static inline void hci_set_drvdata(struct hci_dev *hdev, void *data)
 639 {
 640         dev_set_drvdata(&hdev->dev, data);
 641 }
 642
 643 struct hci_dev *hci_dev_get(int index);
 644 struct hci_dev *hci_get_route(bdaddr_t *src, bdaddr_t *dst);
 645
 646 struct hci_dev *hci_alloc_dev(void);
 647 void hci_free_dev(struct hci_dev *hdev);
 648 int hci_register_dev(struct hci_dev *hdev);
 649 void hci_unregister_dev(struct hci_dev *hdev);
 650 int hci_suspend_dev(struct hci_dev *hdev);
 651 int hci_resume_dev(struct hci_dev *hdev);
 652 int hci_dev_open(__u16 dev);
 653 int hci_dev_close(__u16 dev);
 654 int hci_dev_reset(__u16 dev);
 655 int hci_dev_reset_stat(__u16 dev);
 656 int hci_dev_cmd(unsigned int cmd, void __user *arg);
 657 int hci_get_dev_list(void __user *arg);
 658 int hci_get_dev_info(void __user *arg);
 659 int hci_get_conn_list(void __user *arg);
 660 int hci_get_conn_info(struct hci_dev *hdev, void __user *arg);
 661 int hci_get_auth_info(struct hci_dev *hdev, void __user *arg);
 662 int hci_inquiry(void __user *arg);
 663
 664 struct bdaddr_list *hci_blacklist_lookup(struct hci_dev *hdev,
 665                                          bdaddr_t *bdaddr);
 666 int hci_blacklist_clear(struct hci_dev *hdev);
 667 int hci_blacklist_add(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 type);
 668 int hci_blacklist_del(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 type);
 669
 670 int hci_uuids_clear(struct hci_dev *hdev);
 671
 672 int hci_link_keys_clear(struct hci_dev *hdev);
 673 struct link_key *hci_find_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr);
 674 int hci_add_link_key(struct hci_dev *hdev, struct hci_conn *conn, int new_key,
 675                      bdaddr_t *bdaddr, u8 *val, u8 type, u8 pin_len);
 676 struct smp_ltk *hci_find_ltk(struct hci_dev *hdev, __le16 ediv, u8 rand[8]);
 677 int hci_add_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 addr_type, u8 type,
 678                 int new_key, u8 authenticated, u8 tk[16], u8 enc_size,
 679                 __le16 ediv, u8 rand[8]);
 680 struct smp_ltk *hci_find_ltk_by_addr(struct hci_dev *hdev, bdaddr_t *bdaddr,
 681                                      u8 addr_type);
 682 int hci_remove_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr);
 683 int hci_smp_ltks_clear(struct hci_dev *hdev);
 684 int hci_remove_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr);
 685
 686 int hci_remote_oob_data_clear(struct hci_dev *hdev);
 687 struct oob_data *hci_find_remote_oob_data(struct hci_dev *hdev,
 688                                                         bdaddr_t *bdaddr);
 689 int hci_add_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 *hash,
 690                                                                 u8 *randomizer);
 691 int hci_remove_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr);
 692
 693 void hci_event_packet(struct hci_dev *hdev, struct sk_buff *skb);
 694
 695 int hci_recv_frame(struct sk_buff *skb);
 696 int hci_recv_fragment(struct hci_dev *hdev, int type, void *data, int count);
 697 int hci_recv_stream_fragment(struct hci_dev *hdev, void *data, int count);
 698
 699 void hci_init_sysfs(struct hci_dev *hdev);
 700 int hci_add_sysfs(struct hci_dev *hdev);
 701 void hci_del_sysfs(struct hci_dev *hdev);
 702 void hci_conn_init_sysfs(struct hci_conn *conn);
 703 void hci_conn_add_sysfs(struct hci_conn *conn);
 704 void hci_conn_del_sysfs(struct hci_conn *conn);
 705
 706 #define SET_HCIDEV_DEV(hdev, pdev) ((hdev)->dev.parent = (pdev))
 707
 708 /* ----- LMP capabilities ----- */
 709 #define lmp_rswitch_capable(dev)   ((dev)->features[0] & LMP_RSWITCH)
 710 #define lmp_encrypt_capable(dev)   ((dev)->features[0] & LMP_ENCRYPT)
 711 #define lmp_sniff_capable(dev)     ((dev)->features[0] & LMP_SNIFF)
 712 #define lmp_sniffsubr_capable(dev) ((dev)->features[5] & LMP_SNIFF_SUBR)
 713 #define lmp_esco_capable(dev)      ((dev)->features[3] & LMP_ESCO)
 714 #define lmp_ssp_capable(dev)       ((dev)->features[6] & LMP_SIMPLE_PAIR)
 715 #define lmp_no_flush_capable(dev)  ((dev)->features[6] & LMP_NO_FLUSH)
 716 #define lmp_le_capable(dev)        ((dev)->features[4] & LMP_LE)
 717 #define lmp_bredr_capable(dev)     (!((dev)->features[4] & LMP_NO_BREDR))
 718
 719 /* ----- Extended LMP capabilities ----- */
 720 #define lmp_host_le_capable(dev)   ((dev)->host_features[0] & LMP_HOST_LE)
 721
 722 /* ----- HCI protocols ----- */
 723 static inline int hci_proto_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr,
 724                                                                 __u8 type)
 725 {
 726         switch (type) {
 727         case ACL_LINK:
 728                 return l2cap_connect_ind(hdev, bdaddr);
 729
 730         case SCO_LINK:
 731         case ESCO_LINK:
 732                 return sco_connect_ind(hdev, bdaddr);
 733
 734         default:
 735                 BT_ERR("unknown link type %d", type);
 736                 return -EINVAL;
 737         }
 738 }
 739
 740 static inline void hci_proto_connect_cfm(struct hci_conn *conn, __u8 status)
 741 {
 742         switch (conn->type) {
 743         case ACL_LINK:
 744         case LE_LINK:
 745                 l2cap_connect_cfm(conn, status);
 746                 break;
 747
 748         case SCO_LINK:
 749         case ESCO_LINK:
 750                 sco_connect_cfm(conn, status);
 751                 break;
 752
 753         default:
 754                 BT_ERR("unknown link type %d", conn->type);
 755                 break;
 756         }
 757
 758         if (conn->connect_cfm_cb)
 759                 conn->connect_cfm_cb(conn, status);
 760 }
 761
 762 static inline int hci_proto_disconn_ind(struct hci_conn *conn)
 763 {
 764         if (conn->type != ACL_LINK && conn->type != LE_LINK)
 765                 return HCI_ERROR_REMOTE_USER_TERM;
 766
 767         return l2cap_disconn_ind(conn);
 768 }
 769
 770 static inline void hci_proto_disconn_cfm(struct hci_conn *conn, __u8 reason)
 771 {
 772         switch (conn->type) {
 773         case ACL_LINK:
 774         case LE_LINK:
 775                 l2cap_disconn_cfm(conn, reason);
 776                 break;
 777
 778         case SCO_LINK:
 779         case ESCO_LINK:
 780                 sco_disconn_cfm(conn, reason);
 781                 break;
 782
 783         default:
 784                 BT_ERR("unknown link type %d", conn->type);
 785                 break;
 786         }
 787
 788         if (conn->disconn_cfm_cb)
 789                 conn->disconn_cfm_cb(conn, reason);
 790 }
 791
 792 static inline void hci_proto_auth_cfm(struct hci_conn *conn, __u8 status)
 793 {
 794         __u8 encrypt;
 795
 796         if (conn->type != ACL_LINK && conn->type != LE_LINK)
 797                 return;
 798
 799         if (test_bit(HCI_CONN_ENCRYPT_PEND, &conn->flags))
 800                 return;
 801
 802         encrypt = (conn->link_mode & HCI_LM_ENCRYPT) ? 0x01 : 0x00;
 803         l2cap_security_cfm(conn, status, encrypt);
 804
 805         if (conn->security_cfm_cb)
 806                 conn->security_cfm_cb(conn, status);
 807 }
 808
 809 static inline void hci_proto_encrypt_cfm(struct hci_conn *conn, __u8 status,
 810                                                                 __u8 encrypt)
 811 {
 812         if (conn->type != ACL_LINK && conn->type != LE_LINK)
 813                 return;
 814
 815         l2cap_security_cfm(conn, status, encrypt);
 816
 817         if (conn->security_cfm_cb)
 818                 conn->security_cfm_cb(conn, status);
 819 }
 820
 821 /* ----- HCI callbacks ----- */
 822 struct hci_cb {
 823         struct list_head list;
 824
 825         char *name;
 826
 827         void (*security_cfm)    (struct hci_conn *conn, __u8 status,
 828                                                                 __u8 encrypt);
 829         void (*key_change_cfm)  (struct hci_conn *conn, __u8 status);
 830         void (*role_switch_cfm) (struct hci_conn *conn, __u8 status, __u8 role);
 831 };
 832
 833 static inline void hci_auth_cfm(struct hci_conn *conn, __u8 status)
 834 {
 835         struct list_head *p;
 836         __u8 encrypt;
 837
 838         hci_proto_auth_cfm(conn, status);
 839
 840         if (test_bit(HCI_CONN_ENCRYPT_PEND, &conn->flags))
 841                 return;
 842
 843         encrypt = (conn->link_mode & HCI_LM_ENCRYPT) ? 0x01 : 0x00;
 844
 845         read_lock(&hci_cb_list_lock);
 846         list_for_each(p, &hci_cb_list) {
 847                 struct hci_cb *cb = list_entry(p, struct hci_cb, list);
 848                 if (cb->security_cfm)
 849                         cb->security_cfm(conn, status, encrypt);
 850         }
 851         read_unlock(&hci_cb_list_lock);
 852 }
 853
 854 static inline void hci_encrypt_cfm(struct hci_conn *conn, __u8 status,
 855                                                                 __u8 encrypt)
 856 {
 857         struct list_head *p;
 858
 859         if (conn->sec_level == BT_SECURITY_SDP)
 860                 conn->sec_level = BT_SECURITY_LOW;
 861
 862         if (conn->pending_sec_level > conn->sec_level)
 863                 conn->sec_level = conn->pending_sec_level;
 864
 865         hci_proto_encrypt_cfm(conn, status, encrypt);
 866
 867         read_lock(&hci_cb_list_lock);
 868         list_for_each(p, &hci_cb_list) {
 869                 struct hci_cb *cb = list_entry(p, struct hci_cb, list);
 870                 if (cb->security_cfm)
 871                         cb->security_cfm(conn, status, encrypt);
 872         }
 873         read_unlock(&hci_cb_list_lock);
 874 }
 875
 876 static inline void hci_key_change_cfm(struct hci_conn *conn, __u8 status)
 877 {
 878         struct list_head *p;
 879
 880         read_lock(&hci_cb_list_lock);
 881         list_for_each(p, &hci_cb_list) {
 882                 struct hci_cb *cb = list_entry(p, struct hci_cb, list);
 883                 if (cb->key_change_cfm)
 884                         cb->key_change_cfm(conn, status);
 885         }
 886         read_unlock(&hci_cb_list_lock);
 887 }
 888
 889 static inline void hci_role_switch_cfm(struct hci_conn *conn, __u8 status,
 890                                                                 __u8 role)
 891 {
 892         struct list_head *p;
 893
 894         read_lock(&hci_cb_list_lock);
 895         list_for_each(p, &hci_cb_list) {
 896                 struct hci_cb *cb = list_entry(p, struct hci_cb, list);
 897                 if (cb->role_switch_cfm)
 898                         cb->role_switch_cfm(conn, status, role);
 899         }
 900         read_unlock(&hci_cb_list_lock);
 901 }
 902
 903 static inline bool eir_has_data_type(u8 *data, size_t data_len, u8 type)
 904 {
 905         size_t parsed = 0;
 906
 907         if (data_len < 2)
 908                 return false;
 909
 910         while (parsed < data_len - 1) {
 911                 u8 field_len = data[0];
 912
 913                 if (field_len == 0)
 914                         break;
 915
 916                 parsed += field_len + 1;
 917
 918                 if (parsed > data_len)
 919                         break;
 920
 921                 if (data[1] == type)
 922                         return true;
 923
 924                 data += field_len + 1;
 925         }
 926
 927         return false;
 928 }
 929
 930 static inline size_t eir_get_length(u8 *eir, size_t eir_len)
 931 {
 932         size_t parsed = 0;
 933
 934         while (parsed < eir_len) {
 935                 u8 field_len = eir[0];
 936
 937                 if (field_len == 0)
 938                         return parsed;
 939
 940                 parsed += field_len + 1;
 941                 eir += field_len + 1;
 942         }
 943
 944         return eir_len;
 945 }
 946
 947 static inline u16 eir_append_data(u8 *eir, u16 eir_len, u8 type, u8 *data,
 948                                   u8 data_len)
 949 {
 950         eir[eir_len++] = sizeof(type) + data_len;
 951         eir[eir_len++] = type;
 952         memcpy(&eir[eir_len], data, data_len);
 953         eir_len += data_len;
 954
 955         return eir_len;
 956 }
 957
 958 int hci_register_cb(struct hci_cb *hcb);
 959 int hci_unregister_cb(struct hci_cb *hcb);
 960
 961 int hci_send_cmd(struct hci_dev *hdev, __u16 opcode, __u32 plen, void *param);
 962 void hci_send_acl(struct hci_chan *chan, struct sk_buff *skb, __u16 flags);
 963 void hci_send_sco(struct hci_conn *conn, struct sk_buff *skb);
 964
 965 void *hci_sent_cmd_data(struct hci_dev *hdev, __u16 opcode);
 966
 967 /* ----- HCI Sockets ----- */
 968 void hci_send_to_sock(struct hci_dev *hdev, struct sk_buff *skb);
 969 void hci_send_to_control(struct sk_buff *skb, struct sock *skip_sk);
 970 void hci_send_to_monitor(struct hci_dev *hdev, struct sk_buff *skb);
 971
 972 void hci_sock_dev_event(struct hci_dev *hdev, int event);
 973
 974 /* Management interface */
 975 #define DISCOV_TYPE_BREDR               (BIT(BDADDR_BREDR))
 976 #define DISCOV_TYPE_LE                  (BIT(BDADDR_LE_PUBLIC) | \
 977                                          BIT(BDADDR_LE_RANDOM))
 978 #define DISCOV_TYPE_INTERLEAVED         (BIT(BDADDR_BREDR) | \
 979                                          BIT(BDADDR_LE_PUBLIC) | \
 980                                          BIT(BDADDR_LE_RANDOM))
 981
 982 int mgmt_control(struct sock *sk, struct msghdr *msg, size_t len);
 983 int mgmt_index_added(struct hci_dev *hdev);
 984 int mgmt_index_removed(struct hci_dev *hdev);
 985 int mgmt_powered(struct hci_dev *hdev, u8 powered);
 986 int mgmt_discoverable(struct hci_dev *hdev, u8 discoverable);
 987 int mgmt_connectable(struct hci_dev *hdev, u8 connectable);
 988 int mgmt_write_scan_failed(struct hci_dev *hdev, u8 scan, u8 status);
 989 int mgmt_new_link_key(struct hci_dev *hdev, struct link_key *key,
 990                       bool persistent);
 991 int mgmt_device_connected(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type,
 992                           u8 addr_type, u32 flags, u8 *name, u8 name_len,
 993                           u8 *dev_class);
 994 int mgmt_device_disconnected(struct hci_dev *hdev, bdaddr_t *bdaddr,
 995                              u8 link_type, u8 addr_type);
 996 int mgmt_disconnect_failed(struct hci_dev *hdev, bdaddr_t *bdaddr,
 997                            u8 link_type, u8 addr_type, u8 status);
 998 int mgmt_connect_failed(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type,
 999                         u8 addr_type, u8 status);
1000 int mgmt_pin_code_request(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 secure);
1001 int mgmt_pin_code_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
1002                                  u8 status);
1003 int mgmt_pin_code_neg_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
1004                                      u8 status);
1005 int mgmt_user_confirm_request(struct hci_dev *hdev, bdaddr_t *bdaddr,
1006                               u8 link_type, u8 addr_type, __le32 value,
1007                               u8 confirm_hint);
1008 int mgmt_user_confirm_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
1009                                      u8 link_type, u8 addr_type, u8 status);
1010 int mgmt_user_confirm_neg_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
1011                                          u8 link_type, u8 addr_type, u8 status);
1012 int mgmt_user_passkey_request(struct hci_dev *hdev, bdaddr_t *bdaddr,
1013                               u8 link_type, u8 addr_type);
1014 int mgmt_user_passkey_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
1015                                      u8 link_type, u8 addr_type, u8 status);
1016 int mgmt_user_passkey_neg_reply_complete(struct hci_dev *hdev, bdaddr_t *bdaddr,
1017                                          u8 link_type, u8 addr_type, u8 status);
1018 int mgmt_auth_failed(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type,
1019                      u8 addr_type, u8 status);
1020 int mgmt_auth_enable_complete(struct hci_dev *hdev, u8 status);
1021 int mgmt_ssp_enable_complete(struct hci_dev *hdev, u8 enable, u8 status);
1022 int mgmt_set_class_of_dev_complete(struct hci_dev *hdev, u8 *dev_class,
1023                                    u8 status);
1024 int mgmt_set_local_name_complete(struct hci_dev *hdev, u8 *name, u8 status);
1025 int mgmt_read_local_oob_data_reply_complete(struct hci_dev *hdev, u8 *hash,
1026                                             u8 *randomizer, u8 status);
1027 int mgmt_le_enable_complete(struct hci_dev *hdev, u8 enable, u8 status);
1028 int mgmt_device_found(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type,
1029                       u8 addr_type, u8 *dev_class, s8 rssi, u8 cfm_name,
1030                       u8 ssp, u8 *eir, u16 eir_len);
1031 int mgmt_remote_name(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type,
1032                      u8 addr_type, s8 rssi, u8 *name, u8 name_len);
1033 int mgmt_start_discovery_failed(struct hci_dev *hdev, u8 status);
1034 int mgmt_stop_discovery_failed(struct hci_dev *hdev, u8 status);
1035 int mgmt_discovering(struct hci_dev *hdev, u8 discovering);
1036 int mgmt_interleaved_discovery(struct hci_dev *hdev);
1037 int mgmt_device_blocked(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 type);
1038 int mgmt_device_unblocked(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 type);
1039
1040 int mgmt_new_ltk(struct hci_dev *hdev, struct smp_ltk *key, u8 persistent);
1041
1042 /* HCI info for socket */
1043 #define hci_pi(sk) ((struct hci_pinfo *) sk)
1044
1045 struct hci_pinfo {
1046         struct bt_sock    bt;
1047         struct hci_dev    *hdev;
1048         struct hci_filter filter;
1049         __u32             cmsg_mask;
1050         unsigned short   channel;
1051 };
1052
1053 /* HCI security filter */
1054 #define HCI_SFLT_MAX_OGF  5
1055
1056 struct hci_sec_filter {
1057         __u32 type_mask;
1058         __u32 event_mask[2];
1059         __u32 ocf_mask[HCI_SFLT_MAX_OGF + 1][4];
1060 };
1061
1062 /* ----- HCI requests ----- */
1063 #define HCI_REQ_DONE      0
1064 #define HCI_REQ_PEND      1
1065 #define HCI_REQ_CANCELED  2
1066
1067 #define hci_req_lock(d)         mutex_lock(&d->req_lock)
1068 #define hci_req_unlock(d)       mutex_unlock(&d->req_lock)
1069
1070 void hci_req_complete(struct hci_dev *hdev, __u16 cmd, int result);
1071
1072 void hci_le_conn_update(struct hci_conn *conn, u16 min, u16 max,
1073                                         u16 latency, u16 to_multiplier);
1074 void hci_le_start_enc(struct hci_conn *conn, __le16 ediv, __u8 rand[8],
1075                                                         __u8 ltk[16]);
1076 int hci_do_inquiry(struct hci_dev *hdev, u8 length);
1077 int hci_cancel_inquiry(struct hci_dev *hdev);
1078 int hci_le_scan(struct hci_dev *hdev, u8 type, u16 interval, u16 window,
1079                 int timeout);
1080 int hci_cancel_le_scan(struct hci_dev *hdev);
1081
1082 u8 bdaddr_to_le(u8 bdaddr_type);
1083
1084 #endif /* __HCI_CORE_H */