Pileus Git - ~andy/linux/blob - 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 <linux/interrupt.h>
  29 #include <net/bluetooth/hci.h>
  30
  31 /* HCI upper protocols */
  32 #define HCI_PROTO_L2CAP 0
  33 #define HCI_PROTO_SCO   1
  34
  35 /* HCI priority */
  36 #define HCI_PRIO_MAX    7
  37
  38 /* HCI Core structures */
  39 struct inquiry_data {
  40         bdaddr_t        bdaddr;
  41         __u8            pscan_rep_mode;
  42         __u8            pscan_period_mode;
  43         __u8            pscan_mode;
  44         __u8            dev_class[3];
  45         __le16          clock_offset;
  46         __s8            rssi;
  47         __u8            ssp_mode;
  48 };
  49
  50 struct inquiry_entry {
  51         struct inquiry_entry    *next;
  52         __u32                   timestamp;
  53         struct inquiry_data     data;
  54 };
  55
  56 struct inquiry_cache {
  57         spinlock_t              lock;
  58         __u32                   timestamp;
  59         struct inquiry_entry    *list;
  60 };
  61
  62 struct hci_conn_hash {
  63         struct list_head list;
  64         spinlock_t       lock;
  65         unsigned int     acl_num;
  66         unsigned int     sco_num;
  67         unsigned int     le_num;
  68 };
  69
  70 struct bdaddr_list {
  71         struct list_head list;
  72         bdaddr_t bdaddr;
  73 };
  74
  75 struct bt_uuid {
  76         struct list_head list;
  77         u8 uuid[16];
  78         u8 svc_hint;
  79 };
  80
  81 struct key_master_id {
  82         __le16 ediv;
  83         u8 rand[8];
  84 } __packed;
  85
  86 struct link_key_data {
  87         bdaddr_t bdaddr;
  88         u8 type;
  89         u8 val[16];
  90         u8 pin_len;
  91         u8 dlen;
  92         u8 data[0];
  93 } __packed;
  94
  95 struct link_key {
  96         struct list_head list;
  97         bdaddr_t bdaddr;
  98         u8 type;
  99         u8 val[16];
 100         u8 pin_len;
 101         u8 dlen;
 102         u8 data[0];
 103 };
 104
 105 struct oob_data {
 106         struct list_head list;
 107         bdaddr_t bdaddr;
 108         u8 hash[16];
 109         u8 randomizer[16];
 110 };
 111
 112 struct adv_entry {
 113         struct list_head list;
 114         bdaddr_t bdaddr;
 115         u8 bdaddr_type;
 116 };
 117
 118 #define NUM_REASSEMBLY 4
 119 struct hci_dev {
 120         struct list_head list;
 121         spinlock_t      lock;
 122         atomic_t        refcnt;
 123
 124         char            name[8];
 125         unsigned long   flags;
 126         __u16           id;
 127         __u8            bus;
 128         __u8            dev_type;
 129         bdaddr_t        bdaddr;
 130         __u8            dev_name[HCI_MAX_NAME_LENGTH];
 131         __u8            eir[HCI_MAX_EIR_LENGTH];
 132         __u8            dev_class[3];
 133         __u8            major_class;
 134         __u8            minor_class;
 135         __u8            features[8];
 136         __u8            extfeatures[8];
 137         __u8            commands[64];
 138         __u8            ssp_mode;
 139         __u8            hci_ver;
 140         __u16           hci_rev;
 141         __u8            lmp_ver;
 142         __u16           manufacturer;
 143         __le16          lmp_subver;
 144         __u16           voice_setting;
 145         __u8            io_capability;
 146
 147         __u16           pkt_type;
 148         __u16           esco_type;
 149         __u16           link_policy;
 150         __u16           link_mode;
 151
 152         __u32           idle_timeout;
 153         __u16           sniff_min_interval;
 154         __u16           sniff_max_interval;
 155
 156         __u8            amp_status;
 157         __u32           amp_total_bw;
 158         __u32           amp_max_bw;
 159         __u32           amp_min_latency;
 160         __u32           amp_max_pdu;
 161         __u8            amp_type;
 162         __u16           amp_pal_cap;
 163         __u16           amp_assoc_size;
 164         __u32           amp_max_flush_to;
 165         __u32           amp_be_flush_to;
 166
 167         unsigned int    auto_accept_delay;
 168
 169         unsigned long   quirks;
 170
 171         atomic_t        cmd_cnt;
 172         unsigned int    acl_cnt;
 173         unsigned int    sco_cnt;
 174         unsigned int    le_cnt;
 175
 176         unsigned int    acl_mtu;
 177         unsigned int    sco_mtu;
 178         unsigned int    le_mtu;
 179         unsigned int    acl_pkts;
 180         unsigned int    sco_pkts;
 181         unsigned int    le_pkts;
 182
 183         unsigned long   acl_last_tx;
 184         unsigned long   sco_last_tx;
 185         unsigned long   le_last_tx;
 186
 187         struct workqueue_struct *workqueue;
 188
 189         struct work_struct      power_on;
 190         struct work_struct      power_off;
 191         struct timer_list       off_timer;
 192
 193         struct timer_list       cmd_timer;
 194         struct tasklet_struct   cmd_task;
 195         struct tasklet_struct   rx_task;
 196         struct tasklet_struct   tx_task;
 197
 198         struct sk_buff_head     rx_q;
 199         struct sk_buff_head     raw_q;
 200         struct sk_buff_head     cmd_q;
 201
 202         struct sk_buff          *sent_cmd;
 203         struct sk_buff          *reassembly[NUM_REASSEMBLY];
 204
 205         struct mutex            req_lock;
 206         wait_queue_head_t       req_wait_q;
 207         __u32                   req_status;
 208         __u32                   req_result;
 209
 210         __u16                   init_last_cmd;
 211
 212         struct inquiry_cache    inq_cache;
 213         struct hci_conn_hash    conn_hash;
 214         struct list_head        blacklist;
 215
 216         struct list_head        uuids;
 217
 218         struct list_head        link_keys;
 219
 220         struct list_head        remote_oob_data;
 221
 222         struct list_head        adv_entries;
 223         struct timer_list       adv_timer;
 224
 225         struct hci_dev_stats    stat;
 226
 227         struct sk_buff_head     driver_init;
 228
 229         void                    *driver_data;
 230         void                    *core_data;
 231
 232         atomic_t                promisc;
 233
 234         struct dentry           *debugfs;
 235
 236         struct device           *parent;
 237         struct device           dev;
 238
 239         struct rfkill           *rfkill;
 240
 241         struct module           *owner;
 242
 243         int (*open)(struct hci_dev *hdev);
 244         int (*close)(struct hci_dev *hdev);
 245         int (*flush)(struct hci_dev *hdev);
 246         int (*send)(struct sk_buff *skb);
 247         void (*destruct)(struct hci_dev *hdev);
 248         void (*notify)(struct hci_dev *hdev, unsigned int evt);
 249         int (*ioctl)(struct hci_dev *hdev, unsigned int cmd, unsigned long arg);
 250 };
 251
 252 struct hci_conn {
 253         struct list_head list;
 254
 255         atomic_t        refcnt;
 256
 257         bdaddr_t        dst;
 258         __u8            dst_type;
 259         __u16           handle;
 260         __u16           state;
 261         __u8            mode;
 262         __u8            type;
 263         __u8            out;
 264         __u8            attempt;
 265         __u8            dev_class[3];
 266         __u8            features[8];
 267         __u8            ssp_mode;
 268         __u16           interval;
 269         __u16           pkt_type;
 270         __u16           link_policy;
 271         __u32           link_mode;
 272         __u8            key_type;
 273         __u8            auth_type;
 274         __u8            sec_level;
 275         __u8            pending_sec_level;
 276         __u8            pin_length;
 277         __u8            enc_key_size;
 278         __u8            io_capability;
 279         __u8            power_save;
 280         __u16           disc_timeout;
 281         unsigned long   pend;
 282
 283         __u8            remote_cap;
 284         __u8            remote_oob;
 285         __u8            remote_auth;
 286
 287         unsigned int    sent;
 288
 289         struct sk_buff_head data_q;
 290
 291         struct timer_list disc_timer;
 292         struct timer_list idle_timer;
 293         struct timer_list auto_accept_timer;
 294
 295         struct work_struct work_add;
 296         struct work_struct work_del;
 297
 298         struct device   dev;
 299         atomic_t        devref;
 300
 301         struct hci_dev  *hdev;
 302         void            *l2cap_data;
 303         void            *sco_data;
 304
 305         struct hci_conn *link;
 306
 307         void (*connect_cfm_cb)  (struct hci_conn *conn, u8 status);
 308         void (*security_cfm_cb) (struct hci_conn *conn, u8 status);
 309         void (*disconn_cfm_cb)  (struct hci_conn *conn, u8 reason);
 310 };
 311
 312 extern struct hci_proto *hci_proto[];
 313 extern struct list_head hci_dev_list;
 314 extern struct list_head hci_cb_list;
 315 extern rwlock_t hci_dev_list_lock;
 316 extern rwlock_t hci_cb_list_lock;
 317
 318 /* ----- Inquiry cache ----- */
 319 #define INQUIRY_CACHE_AGE_MAX   (HZ*30)   /* 30 seconds */
 320 #define INQUIRY_ENTRY_AGE_MAX   (HZ*60)   /* 60 seconds */
 321
 322 #define inquiry_cache_lock(c)           spin_lock(&c->lock)
 323 #define inquiry_cache_unlock(c)         spin_unlock(&c->lock)
 324 #define inquiry_cache_lock_bh(c)        spin_lock_bh(&c->lock)
 325 #define inquiry_cache_unlock_bh(c)      spin_unlock_bh(&c->lock)
 326
 327 static inline void inquiry_cache_init(struct hci_dev *hdev)
 328 {
 329         struct inquiry_cache *c = &hdev->inq_cache;
 330         spin_lock_init(&c->lock);
 331         c->list = NULL;
 332 }
 333
 334 static inline int inquiry_cache_empty(struct hci_dev *hdev)
 335 {
 336         struct inquiry_cache *c = &hdev->inq_cache;
 337         return c->list == NULL;
 338 }
 339
 340 static inline long inquiry_cache_age(struct hci_dev *hdev)
 341 {
 342         struct inquiry_cache *c = &hdev->inq_cache;
 343         return jiffies - c->timestamp;
 344 }
 345
 346 static inline long inquiry_entry_age(struct inquiry_entry *e)
 347 {
 348         return jiffies - e->timestamp;
 349 }
 350
 351 struct inquiry_entry *hci_inquiry_cache_lookup(struct hci_dev *hdev,
 352                                                         bdaddr_t *bdaddr);
 353 void hci_inquiry_cache_update(struct hci_dev *hdev, struct inquiry_data *data);
 354
 355 /* ----- HCI Connections ----- */
 356 enum {
 357         HCI_CONN_AUTH_PEND,
 358         HCI_CONN_REAUTH_PEND,
 359         HCI_CONN_ENCRYPT_PEND,
 360         HCI_CONN_RSWITCH_PEND,
 361         HCI_CONN_MODE_CHANGE_PEND,
 362         HCI_CONN_SCO_SETUP_PEND,
 363         HCI_CONN_LE_SMP_PEND,
 364 };
 365
 366 static inline void hci_conn_hash_init(struct hci_dev *hdev)
 367 {
 368         struct hci_conn_hash *h = &hdev->conn_hash;
 369         INIT_LIST_HEAD(&h->list);
 370         spin_lock_init(&h->lock);
 371         h->acl_num = 0;
 372         h->sco_num = 0;
 373 }
 374
 375 static inline void hci_conn_hash_add(struct hci_dev *hdev, struct hci_conn *c)
 376 {
 377         struct hci_conn_hash *h = &hdev->conn_hash;
 378         list_add(&c->list, &h->list);
 379         switch (c->type) {
 380         case ACL_LINK:
 381                 h->acl_num++;
 382                 break;
 383         case LE_LINK:
 384                 h->le_num++;
 385                 break;
 386         case SCO_LINK:
 387         case ESCO_LINK:
 388                 h->sco_num++;
 389                 break;
 390         }
 391 }
 392
 393 static inline void hci_conn_hash_del(struct hci_dev *hdev, struct hci_conn *c)
 394 {
 395         struct hci_conn_hash *h = &hdev->conn_hash;
 396         list_del(&c->list);
 397         switch (c->type) {
 398         case ACL_LINK:
 399                 h->acl_num--;
 400                 break;
 401         case LE_LINK:
 402                 h->le_num--;
 403                 break;
 404         case SCO_LINK:
 405         case ESCO_LINK:
 406                 h->sco_num--;
 407                 break;
 408         }
 409 }
 410
 411 static inline unsigned int hci_conn_num(struct hci_dev *hdev, __u8 type)
 412 {
 413         struct hci_conn_hash *h = &hdev->conn_hash;
 414         switch (type) {
 415         case ACL_LINK:
 416                 return h->acl_num;
 417         case LE_LINK:
 418                 return h->le_num;
 419         case SCO_LINK:
 420         case ESCO_LINK:
 421                 return h->sco_num;
 422         default:
 423                 return 0;
 424         }
 425 }
 426
 427 static inline struct hci_conn *hci_conn_hash_lookup_handle(struct hci_dev *hdev,
 428                                                                 __u16 handle)
 429 {
 430         struct hci_conn_hash *h = &hdev->conn_hash;
 431         struct list_head *p;
 432         struct hci_conn  *c;
 433
 434         list_for_each(p, &h->list) {
 435                 c = list_entry(p, struct hci_conn, list);
 436                 if (c->handle == handle)
 437                         return c;
 438         }
 439         return NULL;
 440 }
 441
 442 static inline struct hci_conn *hci_conn_hash_lookup_ba(struct hci_dev *hdev,
 443                                                         __u8 type, bdaddr_t *ba)
 444 {
 445         struct hci_conn_hash *h = &hdev->conn_hash;
 446         struct list_head *p;
 447         struct hci_conn  *c;
 448
 449         list_for_each(p, &h->list) {
 450                 c = list_entry(p, struct hci_conn, list);
 451                 if (c->type == type && !bacmp(&c->dst, ba))
 452                         return c;
 453         }
 454         return NULL;
 455 }
 456
 457 static inline struct hci_conn *hci_conn_hash_lookup_state(struct hci_dev *hdev,
 458                                                         __u8 type, __u16 state)
 459 {
 460         struct hci_conn_hash *h = &hdev->conn_hash;
 461         struct list_head *p;
 462         struct hci_conn  *c;
 463
 464         list_for_each(p, &h->list) {
 465                 c = list_entry(p, struct hci_conn, list);
 466                 if (c->type == type && c->state == state)
 467                         return c;
 468         }
 469         return NULL;
 470 }
 471
 472 void hci_acl_connect(struct hci_conn *conn);
 473 void hci_acl_disconn(struct hci_conn *conn, __u8 reason);
 474 void hci_add_sco(struct hci_conn *conn, __u16 handle);
 475 void hci_setup_sync(struct hci_conn *conn, __u16 handle);
 476 void hci_sco_setup(struct hci_conn *conn, __u8 status);
 477
 478 struct hci_conn *hci_conn_add(struct hci_dev *hdev, int type, bdaddr_t *dst);
 479 int hci_conn_del(struct hci_conn *conn);
 480 void hci_conn_hash_flush(struct hci_dev *hdev);
 481 void hci_conn_check_pending(struct hci_dev *hdev);
 482
 483 struct hci_conn *hci_connect(struct hci_dev *hdev, int type, bdaddr_t *dst,
 484                                                 __u8 sec_level, __u8 auth_type);
 485 int hci_conn_check_link_mode(struct hci_conn *conn);
 486 int hci_conn_check_secure(struct hci_conn *conn, __u8 sec_level);
 487 int hci_conn_security(struct hci_conn *conn, __u8 sec_level, __u8 auth_type);
 488 int hci_conn_change_link_key(struct hci_conn *conn);
 489 int hci_conn_switch_role(struct hci_conn *conn, __u8 role);
 490
 491 void hci_conn_enter_active_mode(struct hci_conn *conn, __u8 force_active);
 492 void hci_conn_enter_sniff_mode(struct hci_conn *conn);
 493
 494 void hci_conn_hold_device(struct hci_conn *conn);
 495 void hci_conn_put_device(struct hci_conn *conn);
 496
 497 static inline void hci_conn_hold(struct hci_conn *conn)
 498 {
 499         atomic_inc(&conn->refcnt);
 500         del_timer(&conn->disc_timer);
 501 }
 502
 503 static inline void hci_conn_put(struct hci_conn *conn)
 504 {
 505         if (atomic_dec_and_test(&conn->refcnt)) {
 506                 unsigned long timeo;
 507                 if (conn->type == ACL_LINK || conn->type == LE_LINK) {
 508                         del_timer(&conn->idle_timer);
 509                         if (conn->state == BT_CONNECTED) {
 510                                 timeo = msecs_to_jiffies(conn->disc_timeout);
 511                                 if (!conn->out)
 512                                         timeo *= 2;
 513                         } else {
 514                                 timeo = msecs_to_jiffies(10);
 515                         }
 516                 } else {
 517                         timeo = msecs_to_jiffies(10);
 518                 }
 519                 mod_timer(&conn->disc_timer, jiffies + timeo);
 520         }
 521 }
 522
 523 /* ----- HCI Devices ----- */
 524 static inline void __hci_dev_put(struct hci_dev *d)
 525 {
 526         if (atomic_dec_and_test(&d->refcnt))
 527                 d->destruct(d);
 528 }
 529
 530 static inline void hci_dev_put(struct hci_dev *d)
 531 {
 532         __hci_dev_put(d);
 533         module_put(d->owner);
 534 }
 535
 536 static inline struct hci_dev *__hci_dev_hold(struct hci_dev *d)
 537 {
 538         atomic_inc(&d->refcnt);
 539         return d;
 540 }
 541
 542 static inline struct hci_dev *hci_dev_hold(struct hci_dev *d)
 543 {
 544         if (try_module_get(d->owner))
 545                 return __hci_dev_hold(d);
 546         return NULL;
 547 }
 548
 549 #define hci_dev_lock(d)         spin_lock(&d->lock)
 550 #define hci_dev_unlock(d)       spin_unlock(&d->lock)
 551 #define hci_dev_lock_bh(d)      spin_lock_bh(&d->lock)
 552 #define hci_dev_unlock_bh(d)    spin_unlock_bh(&d->lock)
 553
 554 struct hci_dev *hci_dev_get(int index);
 555 struct hci_dev *hci_get_route(bdaddr_t *src, bdaddr_t *dst);
 556
 557 struct hci_dev *hci_alloc_dev(void);
 558 void hci_free_dev(struct hci_dev *hdev);
 559 int hci_register_dev(struct hci_dev *hdev);
 560 void hci_unregister_dev(struct hci_dev *hdev);
 561 int hci_suspend_dev(struct hci_dev *hdev);
 562 int hci_resume_dev(struct hci_dev *hdev);
 563 int hci_dev_open(__u16 dev);
 564 int hci_dev_close(__u16 dev);
 565 int hci_dev_reset(__u16 dev);
 566 int hci_dev_reset_stat(__u16 dev);
 567 int hci_dev_cmd(unsigned int cmd, void __user *arg);
 568 int hci_get_dev_list(void __user *arg);
 569 int hci_get_dev_info(void __user *arg);
 570 int hci_get_conn_list(void __user *arg);
 571 int hci_get_conn_info(struct hci_dev *hdev, void __user *arg);
 572 int hci_get_auth_info(struct hci_dev *hdev, void __user *arg);
 573 int hci_inquiry(void __user *arg);
 574
 575 struct bdaddr_list *hci_blacklist_lookup(struct hci_dev *hdev, bdaddr_t *bdaddr);
 576 int hci_blacklist_clear(struct hci_dev *hdev);
 577 int hci_blacklist_add(struct hci_dev *hdev, bdaddr_t *bdaddr);
 578 int hci_blacklist_del(struct hci_dev *hdev, bdaddr_t *bdaddr);
 579
 580 int hci_uuids_clear(struct hci_dev *hdev);
 581
 582 int hci_link_keys_clear(struct hci_dev *hdev);
 583 struct link_key *hci_find_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr);
 584 int hci_add_link_key(struct hci_dev *hdev, struct hci_conn *conn, int new_key,
 585                         bdaddr_t *bdaddr, u8 *val, u8 type, u8 pin_len);
 586 struct link_key *hci_find_ltk(struct hci_dev *hdev, __le16 ediv, u8 rand[8]);
 587 struct link_key *hci_find_link_key_type(struct hci_dev *hdev,
 588                                         bdaddr_t *bdaddr, u8 type);
 589 int hci_add_ltk(struct hci_dev *hdev, int new_key, bdaddr_t *bdaddr,
 590                         u8 key_size, __le16 ediv, u8 rand[8], u8 ltk[16]);
 591 int hci_remove_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr);
 592
 593 int hci_remote_oob_data_clear(struct hci_dev *hdev);
 594 struct oob_data *hci_find_remote_oob_data(struct hci_dev *hdev,
 595                                                         bdaddr_t *bdaddr);
 596 int hci_add_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 *hash,
 597                                                                 u8 *randomizer);
 598 int hci_remove_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr);
 599
 600 #define ADV_CLEAR_TIMEOUT (3*60*HZ) /* Three minutes */
 601 int hci_adv_entries_clear(struct hci_dev *hdev);
 602 struct adv_entry *hci_find_adv_entry(struct hci_dev *hdev, bdaddr_t *bdaddr);
 603 int hci_add_adv_entry(struct hci_dev *hdev,
 604                                         struct hci_ev_le_advertising_info *ev);
 605
 606 void hci_del_off_timer(struct hci_dev *hdev);
 607
 608 void hci_event_packet(struct hci_dev *hdev, struct sk_buff *skb);
 609
 610 int hci_recv_frame(struct sk_buff *skb);
 611 int hci_recv_fragment(struct hci_dev *hdev, int type, void *data, int count);
 612 int hci_recv_stream_fragment(struct hci_dev *hdev, void *data, int count);
 613
 614 void hci_init_sysfs(struct hci_dev *hdev);
 615 int hci_add_sysfs(struct hci_dev *hdev);
 616 void hci_del_sysfs(struct hci_dev *hdev);
 617 void hci_conn_init_sysfs(struct hci_conn *conn);
 618 void hci_conn_add_sysfs(struct hci_conn *conn);
 619 void hci_conn_del_sysfs(struct hci_conn *conn);
 620
 621 #define SET_HCIDEV_DEV(hdev, pdev) ((hdev)->parent = (pdev))
 622
 623 /* ----- LMP capabilities ----- */
 624 #define lmp_rswitch_capable(dev)   ((dev)->features[0] & LMP_RSWITCH)
 625 #define lmp_encrypt_capable(dev)   ((dev)->features[0] & LMP_ENCRYPT)
 626 #define lmp_sniff_capable(dev)     ((dev)->features[0] & LMP_SNIFF)
 627 #define lmp_sniffsubr_capable(dev) ((dev)->features[5] & LMP_SNIFF_SUBR)
 628 #define lmp_esco_capable(dev)      ((dev)->features[3] & LMP_ESCO)
 629 #define lmp_ssp_capable(dev)       ((dev)->features[6] & LMP_SIMPLE_PAIR)
 630 #define lmp_no_flush_capable(dev)  ((dev)->features[6] & LMP_NO_FLUSH)
 631 #define lmp_le_capable(dev)        ((dev)->features[4] & LMP_LE)
 632
 633 /* ----- Extended LMP capabilities ----- */
 634 #define lmp_host_le_capable(dev)   ((dev)->extfeatures[0] & LMP_HOST_LE)
 635
 636 /* ----- HCI protocols ----- */
 637 struct hci_proto {
 638         char            *name;
 639         unsigned int    id;
 640         unsigned long   flags;
 641
 642         void            *priv;
 643
 644         int (*connect_ind)      (struct hci_dev *hdev, bdaddr_t *bdaddr,
 645                                                                 __u8 type);
 646         int (*connect_cfm)      (struct hci_conn *conn, __u8 status);
 647         int (*disconn_ind)      (struct hci_conn *conn);
 648         int (*disconn_cfm)      (struct hci_conn *conn, __u8 reason);
 649         int (*recv_acldata)     (struct hci_conn *conn, struct sk_buff *skb,
 650                                                                 __u16 flags);
 651         int (*recv_scodata)     (struct hci_conn *conn, struct sk_buff *skb);
 652         int (*security_cfm)     (struct hci_conn *conn, __u8 status,
 653                                                                 __u8 encrypt);
 654 };
 655
 656 static inline int hci_proto_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr,
 657                                                                 __u8 type)
 658 {
 659         register struct hci_proto *hp;
 660         int mask = 0;
 661
 662         hp = hci_proto[HCI_PROTO_L2CAP];
 663         if (hp && hp->connect_ind)
 664                 mask |= hp->connect_ind(hdev, bdaddr, type);
 665
 666         hp = hci_proto[HCI_PROTO_SCO];
 667         if (hp && hp->connect_ind)
 668                 mask |= hp->connect_ind(hdev, bdaddr, type);
 669
 670         return mask;
 671 }
 672
 673 static inline void hci_proto_connect_cfm(struct hci_conn *conn, __u8 status)
 674 {
 675         register struct hci_proto *hp;
 676
 677         hp = hci_proto[HCI_PROTO_L2CAP];
 678         if (hp && hp->connect_cfm)
 679                 hp->connect_cfm(conn, status);
 680
 681         hp = hci_proto[HCI_PROTO_SCO];
 682         if (hp && hp->connect_cfm)
 683                 hp->connect_cfm(conn, status);
 684
 685         if (conn->connect_cfm_cb)
 686                 conn->connect_cfm_cb(conn, status);
 687 }
 688
 689 static inline int hci_proto_disconn_ind(struct hci_conn *conn)
 690 {
 691         register struct hci_proto *hp;
 692         int reason = 0x13;
 693
 694         hp = hci_proto[HCI_PROTO_L2CAP];
 695         if (hp && hp->disconn_ind)
 696                 reason = hp->disconn_ind(conn);
 697
 698         hp = hci_proto[HCI_PROTO_SCO];
 699         if (hp && hp->disconn_ind)
 700                 reason = hp->disconn_ind(conn);
 701
 702         return reason;
 703 }
 704
 705 static inline void hci_proto_disconn_cfm(struct hci_conn *conn, __u8 reason)
 706 {
 707         register struct hci_proto *hp;
 708
 709         hp = hci_proto[HCI_PROTO_L2CAP];
 710         if (hp && hp->disconn_cfm)
 711                 hp->disconn_cfm(conn, reason);
 712
 713         hp = hci_proto[HCI_PROTO_SCO];
 714         if (hp && hp->disconn_cfm)
 715                 hp->disconn_cfm(conn, reason);
 716
 717         if (conn->disconn_cfm_cb)
 718                 conn->disconn_cfm_cb(conn, reason);
 719 }
 720
 721 static inline void hci_proto_auth_cfm(struct hci_conn *conn, __u8 status)
 722 {
 723         register struct hci_proto *hp;
 724         __u8 encrypt;
 725
 726         if (test_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend))
 727                 return;
 728
 729         encrypt = (conn->link_mode & HCI_LM_ENCRYPT) ? 0x01 : 0x00;
 730
 731         hp = hci_proto[HCI_PROTO_L2CAP];
 732         if (hp && hp->security_cfm)
 733                 hp->security_cfm(conn, status, encrypt);
 734
 735         hp = hci_proto[HCI_PROTO_SCO];
 736         if (hp && hp->security_cfm)
 737                 hp->security_cfm(conn, status, encrypt);
 738
 739         if (conn->security_cfm_cb)
 740                 conn->security_cfm_cb(conn, status);
 741 }
 742
 743 static inline void hci_proto_encrypt_cfm(struct hci_conn *conn, __u8 status,
 744                                                                 __u8 encrypt)
 745 {
 746         register struct hci_proto *hp;
 747
 748         hp = hci_proto[HCI_PROTO_L2CAP];
 749         if (hp && hp->security_cfm)
 750                 hp->security_cfm(conn, status, encrypt);
 751
 752         hp = hci_proto[HCI_PROTO_SCO];
 753         if (hp && hp->security_cfm)
 754                 hp->security_cfm(conn, status, encrypt);
 755
 756         if (conn->security_cfm_cb)
 757                 conn->security_cfm_cb(conn, status);
 758 }
 759
 760 int hci_register_proto(struct hci_proto *hproto);
 761 int hci_unregister_proto(struct hci_proto *hproto);
 762
 763 /* ----- HCI callbacks ----- */
 764 struct hci_cb {
 765         struct list_head list;
 766
 767         char *name;
 768
 769         void (*security_cfm)    (struct hci_conn *conn, __u8 status,
 770                                                                 __u8 encrypt);
 771         void (*key_change_cfm)  (struct hci_conn *conn, __u8 status);
 772         void (*role_switch_cfm) (struct hci_conn *conn, __u8 status, __u8 role);
 773 };
 774
 775 static inline void hci_auth_cfm(struct hci_conn *conn, __u8 status)
 776 {
 777         struct list_head *p;
 778         __u8 encrypt;
 779
 780         hci_proto_auth_cfm(conn, status);
 781
 782         if (test_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend))
 783                 return;
 784
 785         encrypt = (conn->link_mode & HCI_LM_ENCRYPT) ? 0x01 : 0x00;
 786
 787         read_lock_bh(&hci_cb_list_lock);
 788         list_for_each(p, &hci_cb_list) {
 789                 struct hci_cb *cb = list_entry(p, struct hci_cb, list);
 790                 if (cb->security_cfm)
 791                         cb->security_cfm(conn, status, encrypt);
 792         }
 793         read_unlock_bh(&hci_cb_list_lock);
 794 }
 795
 796 static inline void hci_encrypt_cfm(struct hci_conn *conn, __u8 status,
 797                                                                 __u8 encrypt)
 798 {
 799         struct list_head *p;
 800
 801         if (conn->sec_level == BT_SECURITY_SDP)
 802                 conn->sec_level = BT_SECURITY_LOW;
 803
 804         if (conn->pending_sec_level > conn->sec_level)
 805                 conn->sec_level = conn->pending_sec_level;
 806
 807         hci_proto_encrypt_cfm(conn, status, encrypt);
 808
 809         read_lock_bh(&hci_cb_list_lock);
 810         list_for_each(p, &hci_cb_list) {
 811                 struct hci_cb *cb = list_entry(p, struct hci_cb, list);
 812                 if (cb->security_cfm)
 813                         cb->security_cfm(conn, status, encrypt);
 814         }
 815         read_unlock_bh(&hci_cb_list_lock);
 816 }
 817
 818 static inline void hci_key_change_cfm(struct hci_conn *conn, __u8 status)
 819 {
 820         struct list_head *p;
 821
 822         read_lock_bh(&hci_cb_list_lock);
 823         list_for_each(p, &hci_cb_list) {
 824                 struct hci_cb *cb = list_entry(p, struct hci_cb, list);
 825                 if (cb->key_change_cfm)
 826                         cb->key_change_cfm(conn, status);
 827         }
 828         read_unlock_bh(&hci_cb_list_lock);
 829 }
 830
 831 static inline void hci_role_switch_cfm(struct hci_conn *conn, __u8 status,
 832                                                                 __u8 role)
 833 {
 834         struct list_head *p;
 835
 836         read_lock_bh(&hci_cb_list_lock);
 837         list_for_each(p, &hci_cb_list) {
 838                 struct hci_cb *cb = list_entry(p, struct hci_cb, list);
 839                 if (cb->role_switch_cfm)
 840                         cb->role_switch_cfm(conn, status, role);
 841         }
 842         read_unlock_bh(&hci_cb_list_lock);
 843 }
 844
 845 int hci_register_cb(struct hci_cb *hcb);
 846 int hci_unregister_cb(struct hci_cb *hcb);
 847
 848 int hci_register_notifier(struct notifier_block *nb);
 849 int hci_unregister_notifier(struct notifier_block *nb);
 850
 851 int hci_send_cmd(struct hci_dev *hdev, __u16 opcode, __u32 plen, void *param);
 852 void hci_send_acl(struct hci_conn *conn, struct sk_buff *skb, __u16 flags);
 853 void hci_send_sco(struct hci_conn *conn, struct sk_buff *skb);
 854
 855 void *hci_sent_cmd_data(struct hci_dev *hdev, __u16 opcode);
 856
 857 void hci_si_event(struct hci_dev *hdev, int type, int dlen, void *data);
 858
 859 /* ----- HCI Sockets ----- */
 860 void hci_send_to_sock(struct hci_dev *hdev, struct sk_buff *skb,
 861                                                         struct sock *skip_sk);
 862
 863 /* Management interface */
 864 int mgmt_control(struct sock *sk, struct msghdr *msg, size_t len);
 865 int mgmt_index_added(u16 index);
 866 int mgmt_index_removed(u16 index);
 867 int mgmt_powered(u16 index, u8 powered);
 868 int mgmt_discoverable(u16 index, u8 discoverable);
 869 int mgmt_connectable(u16 index, u8 connectable);
 870 int mgmt_new_key(u16 index, struct link_key *key, u8 persistent);
 871 int mgmt_connected(u16 index, bdaddr_t *bdaddr, u8 link_type);
 872 int mgmt_disconnected(u16 index, bdaddr_t *bdaddr);
 873 int mgmt_disconnect_failed(u16 index);
 874 int mgmt_connect_failed(u16 index, bdaddr_t *bdaddr, u8 status);
 875 int mgmt_pin_code_request(u16 index, bdaddr_t *bdaddr, u8 secure);
 876 int mgmt_pin_code_reply_complete(u16 index, bdaddr_t *bdaddr, u8 status);
 877 int mgmt_pin_code_neg_reply_complete(u16 index, bdaddr_t *bdaddr, u8 status);
 878 int mgmt_user_confirm_request(u16 index, bdaddr_t *bdaddr, __le32 value,
 879                                                         u8 confirm_hint);
 880 int mgmt_user_confirm_reply_complete(u16 index, bdaddr_t *bdaddr, u8 status);
 881 int mgmt_user_confirm_neg_reply_complete(u16 index, bdaddr_t *bdaddr,
 882                                                                 u8 status);
 883 int mgmt_auth_failed(u16 index, bdaddr_t *bdaddr, u8 status);
 884 int mgmt_set_local_name_complete(u16 index, u8 *name, u8 status);
 885 int mgmt_read_local_oob_data_reply_complete(u16 index, u8 *hash, u8 *randomizer,
 886                                                                 u8 status);
 887 int mgmt_device_found(u16 index, bdaddr_t *bdaddr, u8 *dev_class, s8 rssi,
 888                                                                 u8 *eir);
 889 int mgmt_remote_name(u16 index, bdaddr_t *bdaddr, u8 *name);
 890 int mgmt_discovering(u16 index, u8 discovering);
 891 int mgmt_device_blocked(u16 index, bdaddr_t *bdaddr);
 892 int mgmt_device_unblocked(u16 index, bdaddr_t *bdaddr);
 893
 894 /* HCI info for socket */
 895 #define hci_pi(sk) ((struct hci_pinfo *) sk)
 896
 897 struct hci_pinfo {
 898         struct bt_sock    bt;
 899         struct hci_dev    *hdev;
 900         struct hci_filter filter;
 901         __u32             cmsg_mask;
 902         unsigned short   channel;
 903 };
 904
 905 /* HCI security filter */
 906 #define HCI_SFLT_MAX_OGF  5
 907
 908 struct hci_sec_filter {
 909         __u32 type_mask;
 910         __u32 event_mask[2];
 911         __u32 ocf_mask[HCI_SFLT_MAX_OGF + 1][4];
 912 };
 913
 914 /* ----- HCI requests ----- */
 915 #define HCI_REQ_DONE      0
 916 #define HCI_REQ_PEND      1
 917 #define HCI_REQ_CANCELED  2
 918
 919 #define hci_req_lock(d)         mutex_lock(&d->req_lock)
 920 #define hci_req_unlock(d)       mutex_unlock(&d->req_lock)
 921
 922 void hci_req_complete(struct hci_dev *hdev, __u16 cmd, int result);
 923
 924 void hci_le_conn_update(struct hci_conn *conn, u16 min, u16 max,
 925                                         u16 latency, u16 to_multiplier);
 926 void hci_le_start_enc(struct hci_conn *conn, __le16 ediv, __u8 rand[8],
 927                                                         __u8 ltk[16]);
 928 void hci_le_ltk_reply(struct hci_conn *conn, u8 ltk[16]);
 929 void hci_le_ltk_neg_reply(struct hci_conn *conn);
 930
 931 #endif /* __HCI_CORE_H */