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