include/net/bluetooth/hci_core.h

   1 /*
   2    BlueZ - Bluetooth protocol stack for Linux
   3    Copyright (C) 2000-2001 Qualcomm Incorporated
   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 upper protocols */
  31 #define HCI_PROTO_L2CAP 0
  32 #define HCI_PROTO_SCO   1
  33
  34 /* HCI Core structures */
  35 struct inquiry_data {
  36         bdaddr_t        bdaddr;
  37         __u8            pscan_rep_mode;
  38         __u8            pscan_period_mode;
  39         __u8            pscan_mode;
  40         __u8            dev_class[3];
  41         __le16          clock_offset;
  42         __s8            rssi;
  43 };
  44
  45 struct inquiry_entry {
  46         struct inquiry_entry    *next;
  47         __u32                   timestamp;
  48         struct inquiry_data     data;
  49 };
  50
  51 struct inquiry_cache {
  52         spinlock_t              lock;
  53         __u32                   timestamp;
  54         struct inquiry_entry    *list;
  55 };
  56
  57 struct hci_conn_hash {
  58         struct list_head list;
  59         spinlock_t       lock;
  60         unsigned int     acl_num;
  61         unsigned int     sco_num;
  62 };
  63
  64 struct hci_dev {
  65         struct list_head list;
  66         spinlock_t      lock;
  67         atomic_t        refcnt;
  68
  69         char            name[8];
  70         unsigned long   flags;
  71         __u16           id;
  72         __u8            type;
  73         bdaddr_t        bdaddr;
  74         __u8            dev_name[248];
  75         __u8            dev_class[3];
  76         __u8            features[8];
  77         __u8            commands[64];
  78         __u8            ssp_mode;
  79         __u8            hci_ver;
  80         __u16           hci_rev;
  81         __u16           manufacturer;
  82         __u16           voice_setting;
  83
  84         __u16           pkt_type;
  85         __u16           esco_type;
  86         __u16           link_policy;
  87         __u16           link_mode;
  88
  89         __u32           idle_timeout;
  90         __u16           sniff_min_interval;
  91         __u16           sniff_max_interval;
  92
  93         unsigned long   quirks;
  94
  95         atomic_t        cmd_cnt;
  96         unsigned int    acl_cnt;
  97         unsigned int    sco_cnt;
  98
  99         unsigned int    acl_mtu;
 100         unsigned int    sco_mtu;
 101         unsigned int    acl_pkts;
 102         unsigned int    sco_pkts;
 103
 104         unsigned long   cmd_last_tx;
 105         unsigned long   acl_last_tx;
 106         unsigned long   sco_last_tx;
 107
 108         struct tasklet_struct   cmd_task;
 109         struct tasklet_struct   rx_task;
 110         struct tasklet_struct   tx_task;
 111
 112         struct sk_buff_head     rx_q;
 113         struct sk_buff_head     raw_q;
 114         struct sk_buff_head     cmd_q;
 115
 116         struct sk_buff          *sent_cmd;
 117         struct sk_buff          *reassembly[3];
 118
 119         struct semaphore        req_lock;
 120         wait_queue_head_t       req_wait_q;
 121         __u32                   req_status;
 122         __u32                   req_result;
 123
 124         struct inquiry_cache    inq_cache;
 125         struct hci_conn_hash    conn_hash;
 126
 127         struct hci_dev_stats    stat;
 128
 129         struct sk_buff_head     driver_init;
 130
 131         void                    *driver_data;
 132         void                    *core_data;
 133
 134         atomic_t                promisc;
 135
 136         struct device           *parent;
 137         struct device           dev;
 138
 139         struct module           *owner;
 140
 141         int (*open)(struct hci_dev *hdev);
 142         int (*close)(struct hci_dev *hdev);
 143         int (*flush)(struct hci_dev *hdev);
 144         int (*send)(struct sk_buff *skb);
 145         void (*destruct)(struct hci_dev *hdev);
 146         void (*notify)(struct hci_dev *hdev, unsigned int evt);
 147         int (*ioctl)(struct hci_dev *hdev, unsigned int cmd, unsigned long arg);
 148 };
 149
 150 struct hci_conn {
 151         struct list_head list;
 152
 153         atomic_t         refcnt;
 154         spinlock_t       lock;
 155
 156         bdaddr_t         dst;
 157         __u16            handle;
 158         __u16            state;
 159         __u8             mode;
 160         __u8             type;
 161         __u8             out;
 162         __u8             attempt;
 163         __u8             dev_class[3];
 164         __u8             features[8];
 165         __u16            interval;
 166         __u16            pkt_type;
 167         __u16            link_policy;
 168         __u32            link_mode;
 169         __u8             power_save;
 170         unsigned long    pend;
 171
 172         unsigned int     sent;
 173
 174         struct sk_buff_head data_q;
 175
 176         struct timer_list disc_timer;
 177         struct timer_list idle_timer;
 178
 179         struct work_struct work;
 180
 181         struct device   dev;
 182
 183         struct hci_dev  *hdev;
 184         void            *l2cap_data;
 185         void            *sco_data;
 186         void            *priv;
 187
 188         struct hci_conn *link;
 189 };
 190
 191 extern struct hci_proto *hci_proto[];
 192 extern struct list_head hci_dev_list;
 193 extern struct list_head hci_cb_list;
 194 extern rwlock_t hci_dev_list_lock;
 195 extern rwlock_t hci_cb_list_lock;
 196
 197 /* ----- Inquiry cache ----- */
 198 #define INQUIRY_CACHE_AGE_MAX   (HZ*30)   // 30 seconds
 199 #define INQUIRY_ENTRY_AGE_MAX   (HZ*60)   // 60 seconds
 200
 201 #define inquiry_cache_lock(c)           spin_lock(&c->lock)
 202 #define inquiry_cache_unlock(c)         spin_unlock(&c->lock)
 203 #define inquiry_cache_lock_bh(c)        spin_lock_bh(&c->lock)
 204 #define inquiry_cache_unlock_bh(c)      spin_unlock_bh(&c->lock)
 205
 206 static inline void inquiry_cache_init(struct hci_dev *hdev)
 207 {
 208         struct inquiry_cache *c = &hdev->inq_cache;
 209         spin_lock_init(&c->lock);
 210         c->list = NULL;
 211 }
 212
 213 static inline int inquiry_cache_empty(struct hci_dev *hdev)
 214 {
 215         struct inquiry_cache *c = &hdev->inq_cache;
 216         return (c->list == NULL);
 217 }
 218
 219 static inline long inquiry_cache_age(struct hci_dev *hdev)
 220 {
 221         struct inquiry_cache *c = &hdev->inq_cache;
 222         return jiffies - c->timestamp;
 223 }
 224
 225 static inline long inquiry_entry_age(struct inquiry_entry *e)
 226 {
 227         return jiffies - e->timestamp;
 228 }
 229
 230 struct inquiry_entry *hci_inquiry_cache_lookup(struct hci_dev *hdev, bdaddr_t *bdaddr);
 231 void hci_inquiry_cache_update(struct hci_dev *hdev, struct inquiry_data *data);
 232
 233 /* ----- HCI Connections ----- */
 234 enum {
 235         HCI_CONN_AUTH_PEND,
 236         HCI_CONN_ENCRYPT_PEND,
 237         HCI_CONN_RSWITCH_PEND,
 238         HCI_CONN_MODE_CHANGE_PEND,
 239 };
 240
 241 static inline void hci_conn_hash_init(struct hci_dev *hdev)
 242 {
 243         struct hci_conn_hash *h = &hdev->conn_hash;
 244         INIT_LIST_HEAD(&h->list);
 245         spin_lock_init(&h->lock);
 246         h->acl_num = 0;
 247         h->sco_num = 0;
 248 }
 249
 250 static inline void hci_conn_hash_add(struct hci_dev *hdev, struct hci_conn *c)
 251 {
 252         struct hci_conn_hash *h = &hdev->conn_hash;
 253         list_add(&c->list, &h->list);
 254         if (c->type == ACL_LINK)
 255                 h->acl_num++;
 256         else
 257                 h->sco_num++;
 258 }
 259
 260 static inline void hci_conn_hash_del(struct hci_dev *hdev, struct hci_conn *c)
 261 {
 262         struct hci_conn_hash *h = &hdev->conn_hash;
 263         list_del(&c->list);
 264         if (c->type == ACL_LINK)
 265                 h->acl_num--;
 266         else
 267                 h->sco_num--;
 268 }
 269
 270 static inline struct hci_conn *hci_conn_hash_lookup_handle(struct hci_dev *hdev,
 271                                         __u16 handle)
 272 {
 273         struct hci_conn_hash *h = &hdev->conn_hash;
 274         struct list_head *p;
 275         struct hci_conn  *c;
 276
 277         list_for_each(p, &h->list) {
 278                 c = list_entry(p, struct hci_conn, list);
 279                 if (c->handle == handle)
 280                         return c;
 281         }
 282         return NULL;
 283 }
 284
 285 static inline struct hci_conn *hci_conn_hash_lookup_ba(struct hci_dev *hdev,
 286                                         __u8 type, bdaddr_t *ba)
 287 {
 288         struct hci_conn_hash *h = &hdev->conn_hash;
 289         struct list_head *p;
 290         struct hci_conn  *c;
 291
 292         list_for_each(p, &h->list) {
 293                 c = list_entry(p, struct hci_conn, list);
 294                 if (c->type == type && !bacmp(&c->dst, ba))
 295                         return c;
 296         }
 297         return NULL;
 298 }
 299
 300 static inline struct hci_conn *hci_conn_hash_lookup_state(struct hci_dev *hdev,
 301                                         __u8 type, __u16 state)
 302 {
 303         struct hci_conn_hash *h = &hdev->conn_hash;
 304         struct list_head *p;
 305         struct hci_conn  *c;
 306
 307         list_for_each(p, &h->list) {
 308                 c = list_entry(p, struct hci_conn, list);
 309                 if (c->type == type && c->state == state)
 310                         return c;
 311         }
 312         return NULL;
 313 }
 314
 315 void hci_acl_connect(struct hci_conn *conn);
 316 void hci_acl_disconn(struct hci_conn *conn, __u8 reason);
 317 void hci_add_sco(struct hci_conn *conn, __u16 handle);
 318 void hci_setup_sync(struct hci_conn *conn, __u16 handle);
 319
 320 struct hci_conn *hci_conn_add(struct hci_dev *hdev, int type, bdaddr_t *dst);
 321 int hci_conn_del(struct hci_conn *conn);
 322 void hci_conn_hash_flush(struct hci_dev *hdev);
 323 void hci_conn_check_pending(struct hci_dev *hdev);
 324
 325 struct hci_conn *hci_connect(struct hci_dev *hdev, int type, bdaddr_t *src);
 326 int hci_conn_auth(struct hci_conn *conn);
 327 int hci_conn_encrypt(struct hci_conn *conn);
 328 int hci_conn_change_link_key(struct hci_conn *conn);
 329 int hci_conn_switch_role(struct hci_conn *conn, uint8_t role);
 330
 331 void hci_conn_enter_active_mode(struct hci_conn *conn);
 332 void hci_conn_enter_sniff_mode(struct hci_conn *conn);
 333
 334 static inline void hci_conn_hold(struct hci_conn *conn)
 335 {
 336         atomic_inc(&conn->refcnt);
 337         del_timer(&conn->disc_timer);
 338 }
 339
 340 static inline void hci_conn_put(struct hci_conn *conn)
 341 {
 342         if (atomic_dec_and_test(&conn->refcnt)) {
 343                 unsigned long timeo;
 344                 if (conn->type == ACL_LINK) {
 345                         del_timer(&conn->idle_timer);
 346                         if (conn->state == BT_CONNECTED) {
 347                                 timeo = msecs_to_jiffies(HCI_DISCONN_TIMEOUT);
 348                                 if (!conn->out)
 349                                         timeo *= 2;
 350                         } else
 351                                 timeo = msecs_to_jiffies(10);
 352                 } else
 353                         timeo = msecs_to_jiffies(10);
 354                 mod_timer(&conn->disc_timer, jiffies + timeo);
 355         }
 356 }
 357
 358 /* ----- HCI tasks ----- */
 359 static inline void hci_sched_cmd(struct hci_dev *hdev)
 360 {
 361         tasklet_schedule(&hdev->cmd_task);
 362 }
 363
 364 static inline void hci_sched_rx(struct hci_dev *hdev)
 365 {
 366         tasklet_schedule(&hdev->rx_task);
 367 }
 368
 369 static inline void hci_sched_tx(struct hci_dev *hdev)
 370 {
 371         tasklet_schedule(&hdev->tx_task);
 372 }
 373
 374 /* ----- HCI Devices ----- */
 375 static inline void __hci_dev_put(struct hci_dev *d)
 376 {
 377         if (atomic_dec_and_test(&d->refcnt))
 378                 d->destruct(d);
 379 }
 380
 381 static inline void hci_dev_put(struct hci_dev *d)
 382 {
 383         __hci_dev_put(d);
 384         module_put(d->owner);
 385 }
 386
 387 static inline struct hci_dev *__hci_dev_hold(struct hci_dev *d)
 388 {
 389         atomic_inc(&d->refcnt);
 390         return d;
 391 }
 392
 393 static inline struct hci_dev *hci_dev_hold(struct hci_dev *d)
 394 {
 395         if (try_module_get(d->owner))
 396                 return __hci_dev_hold(d);
 397         return NULL;
 398 }
 399
 400 #define hci_dev_lock(d)         spin_lock(&d->lock)
 401 #define hci_dev_unlock(d)       spin_unlock(&d->lock)
 402 #define hci_dev_lock_bh(d)      spin_lock_bh(&d->lock)
 403 #define hci_dev_unlock_bh(d)    spin_unlock_bh(&d->lock)
 404
 405 struct hci_dev *hci_dev_get(int index);
 406 struct hci_dev *hci_get_route(bdaddr_t *src, bdaddr_t *dst);
 407
 408 struct hci_dev *hci_alloc_dev(void);
 409 void hci_free_dev(struct hci_dev *hdev);
 410 int hci_register_dev(struct hci_dev *hdev);
 411 int hci_unregister_dev(struct hci_dev *hdev);
 412 int hci_suspend_dev(struct hci_dev *hdev);
 413 int hci_resume_dev(struct hci_dev *hdev);
 414 int hci_dev_open(__u16 dev);
 415 int hci_dev_close(__u16 dev);
 416 int hci_dev_reset(__u16 dev);
 417 int hci_dev_reset_stat(__u16 dev);
 418 int hci_dev_cmd(unsigned int cmd, void __user *arg);
 419 int hci_get_dev_list(void __user *arg);
 420 int hci_get_dev_info(void __user *arg);
 421 int hci_get_conn_list(void __user *arg);
 422 int hci_get_conn_info(struct hci_dev *hdev, void __user *arg);
 423 int hci_inquiry(void __user *arg);
 424
 425 void hci_event_packet(struct hci_dev *hdev, struct sk_buff *skb);
 426
 427 /* Receive frame from HCI drivers */
 428 static inline int hci_recv_frame(struct sk_buff *skb)
 429 {
 430         struct hci_dev *hdev = (struct hci_dev *) skb->dev;
 431         if (!hdev || (!test_bit(HCI_UP, &hdev->flags)
 432                         && !test_bit(HCI_INIT, &hdev->flags))) {
 433                 kfree_skb(skb);
 434                 return -ENXIO;
 435         }
 436
 437         /* Incomming skb */
 438         bt_cb(skb)->incoming = 1;
 439
 440         /* Time stamp */
 441         __net_timestamp(skb);
 442
 443         /* Queue frame for rx task */
 444         skb_queue_tail(&hdev->rx_q, skb);
 445         hci_sched_rx(hdev);
 446         return 0;
 447 }
 448
 449 int hci_recv_fragment(struct hci_dev *hdev, int type, void *data, int count);
 450
 451 int hci_register_sysfs(struct hci_dev *hdev);
 452 void hci_unregister_sysfs(struct hci_dev *hdev);
 453 void hci_conn_add_sysfs(struct hci_conn *conn);
 454 void hci_conn_del_sysfs(struct hci_conn *conn);
 455
 456 #define SET_HCIDEV_DEV(hdev, pdev) ((hdev)->parent = (pdev))
 457
 458 /* ----- LMP capabilities ----- */
 459 #define lmp_rswitch_capable(dev)   ((dev)->features[0] & LMP_RSWITCH)
 460 #define lmp_encrypt_capable(dev)   ((dev)->features[0] & LMP_ENCRYPT)
 461 #define lmp_sniff_capable(dev)     ((dev)->features[0] & LMP_SNIFF)
 462 #define lmp_sniffsubr_capable(dev) ((dev)->features[5] & LMP_SNIFF_SUBR)
 463 #define lmp_esco_capable(dev)      ((dev)->features[3] & LMP_ESCO)
 464
 465 /* ----- HCI protocols ----- */
 466 struct hci_proto {
 467         char            *name;
 468         unsigned int    id;
 469         unsigned long   flags;
 470
 471         void            *priv;
 472
 473         int (*connect_ind)      (struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 type);
 474         int (*connect_cfm)      (struct hci_conn *conn, __u8 status);
 475         int (*disconn_ind)      (struct hci_conn *conn, __u8 reason);
 476         int (*recv_acldata)     (struct hci_conn *conn, struct sk_buff *skb, __u16 flags);
 477         int (*recv_scodata)     (struct hci_conn *conn, struct sk_buff *skb);
 478         int (*auth_cfm)         (struct hci_conn *conn, __u8 status);
 479         int (*encrypt_cfm)      (struct hci_conn *conn, __u8 status, __u8 encrypt);
 480 };
 481
 482 static inline int hci_proto_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 type)
 483 {
 484         register struct hci_proto *hp;
 485         int mask = 0;
 486
 487         hp = hci_proto[HCI_PROTO_L2CAP];
 488         if (hp && hp->connect_ind)
 489                 mask |= hp->connect_ind(hdev, bdaddr, type);
 490
 491         hp = hci_proto[HCI_PROTO_SCO];
 492         if (hp && hp->connect_ind)
 493                 mask |= hp->connect_ind(hdev, bdaddr, type);
 494
 495         return mask;
 496 }
 497
 498 static inline void hci_proto_connect_cfm(struct hci_conn *conn, __u8 status)
 499 {
 500         register struct hci_proto *hp;
 501
 502         hp = hci_proto[HCI_PROTO_L2CAP];
 503         if (hp && hp->connect_cfm)
 504                 hp->connect_cfm(conn, status);
 505
 506         hp = hci_proto[HCI_PROTO_SCO];
 507         if (hp && hp->connect_cfm)
 508                 hp->connect_cfm(conn, status);
 509 }
 510
 511 static inline void hci_proto_disconn_ind(struct hci_conn *conn, __u8 reason)
 512 {
 513         register struct hci_proto *hp;
 514
 515         hp = hci_proto[HCI_PROTO_L2CAP];
 516         if (hp && hp->disconn_ind)
 517                 hp->disconn_ind(conn, reason);
 518
 519         hp = hci_proto[HCI_PROTO_SCO];
 520         if (hp && hp->disconn_ind)
 521                 hp->disconn_ind(conn, reason);
 522 }
 523
 524 static inline void hci_proto_auth_cfm(struct hci_conn *conn, __u8 status)
 525 {
 526         register struct hci_proto *hp;
 527
 528         hp = hci_proto[HCI_PROTO_L2CAP];
 529         if (hp && hp->auth_cfm)
 530                 hp->auth_cfm(conn, status);
 531
 532         hp = hci_proto[HCI_PROTO_SCO];
 533         if (hp && hp->auth_cfm)
 534                 hp->auth_cfm(conn, status);
 535 }
 536
 537 static inline void hci_proto_encrypt_cfm(struct hci_conn *conn, __u8 status, __u8 encrypt)
 538 {
 539         register struct hci_proto *hp;
 540
 541         hp = hci_proto[HCI_PROTO_L2CAP];
 542         if (hp && hp->encrypt_cfm)
 543                 hp->encrypt_cfm(conn, status, encrypt);
 544
 545         hp = hci_proto[HCI_PROTO_SCO];
 546         if (hp && hp->encrypt_cfm)
 547                 hp->encrypt_cfm(conn, status, encrypt);
 548 }
 549
 550 int hci_register_proto(struct hci_proto *hproto);
 551 int hci_unregister_proto(struct hci_proto *hproto);
 552
 553 /* ----- HCI callbacks ----- */
 554 struct hci_cb {
 555         struct list_head list;
 556
 557         char *name;
 558
 559         void (*auth_cfm)        (struct hci_conn *conn, __u8 status);
 560         void (*encrypt_cfm)     (struct hci_conn *conn, __u8 status, __u8 encrypt);
 561         void (*key_change_cfm)  (struct hci_conn *conn, __u8 status);
 562         void (*role_switch_cfm) (struct hci_conn *conn, __u8 status, __u8 role);
 563 };
 564
 565 static inline void hci_auth_cfm(struct hci_conn *conn, __u8 status)
 566 {
 567         struct list_head *p;
 568
 569         hci_proto_auth_cfm(conn, status);
 570
 571         read_lock_bh(&hci_cb_list_lock);
 572         list_for_each(p, &hci_cb_list) {
 573                 struct hci_cb *cb = list_entry(p, struct hci_cb, list);
 574                 if (cb->auth_cfm)
 575                         cb->auth_cfm(conn, status);
 576         }
 577         read_unlock_bh(&hci_cb_list_lock);
 578 }
 579
 580 static inline void hci_encrypt_cfm(struct hci_conn *conn, __u8 status, __u8 encrypt)
 581 {
 582         struct list_head *p;
 583
 584         hci_proto_encrypt_cfm(conn, status, encrypt);
 585
 586         read_lock_bh(&hci_cb_list_lock);
 587         list_for_each(p, &hci_cb_list) {
 588                 struct hci_cb *cb = list_entry(p, struct hci_cb, list);
 589                 if (cb->encrypt_cfm)
 590                         cb->encrypt_cfm(conn, status, encrypt);
 591         }
 592         read_unlock_bh(&hci_cb_list_lock);
 593 }
 594
 595 static inline void hci_key_change_cfm(struct hci_conn *conn, __u8 status)
 596 {
 597         struct list_head *p;
 598
 599         read_lock_bh(&hci_cb_list_lock);
 600         list_for_each(p, &hci_cb_list) {
 601                 struct hci_cb *cb = list_entry(p, struct hci_cb, list);
 602                 if (cb->key_change_cfm)
 603                         cb->key_change_cfm(conn, status);
 604         }
 605         read_unlock_bh(&hci_cb_list_lock);
 606 }
 607
 608 static inline void hci_role_switch_cfm(struct hci_conn *conn, __u8 status, __u8 role)
 609 {
 610         struct list_head *p;
 611
 612         read_lock_bh(&hci_cb_list_lock);
 613         list_for_each(p, &hci_cb_list) {
 614                 struct hci_cb *cb = list_entry(p, struct hci_cb, list);
 615                 if (cb->role_switch_cfm)
 616                         cb->role_switch_cfm(conn, status, role);
 617         }
 618         read_unlock_bh(&hci_cb_list_lock);
 619 }
 620
 621 int hci_register_cb(struct hci_cb *hcb);
 622 int hci_unregister_cb(struct hci_cb *hcb);
 623
 624 int hci_register_notifier(struct notifier_block *nb);
 625 int hci_unregister_notifier(struct notifier_block *nb);
 626
 627 int hci_send_cmd(struct hci_dev *hdev, __u16 opcode, __u32 plen, void *param);
 628 int hci_send_acl(struct hci_conn *conn, struct sk_buff *skb, __u16 flags);
 629 int hci_send_sco(struct hci_conn *conn, struct sk_buff *skb);
 630
 631 void *hci_sent_cmd_data(struct hci_dev *hdev, __u16 opcode);
 632
 633 void hci_si_event(struct hci_dev *hdev, int type, int dlen, void *data);
 634
 635 /* ----- HCI Sockets ----- */
 636 void hci_send_to_sock(struct hci_dev *hdev, struct sk_buff *skb);
 637
 638 /* HCI info for socket */
 639 #define hci_pi(sk) ((struct hci_pinfo *) sk)
 640
 641 struct hci_pinfo {
 642         struct bt_sock    bt;
 643         struct hci_dev    *hdev;
 644         struct hci_filter filter;
 645         __u32             cmsg_mask;
 646 };
 647
 648 /* HCI security filter */
 649 #define HCI_SFLT_MAX_OGF  5
 650
 651 struct hci_sec_filter {
 652         __u32 type_mask;
 653         __u32 event_mask[2];
 654         __u32 ocf_mask[HCI_SFLT_MAX_OGF + 1][4];
 655 };
 656
 657 /* ----- HCI requests ----- */
 658 #define HCI_REQ_DONE      0
 659 #define HCI_REQ_PEND      1
 660 #define HCI_REQ_CANCELED  2
 661
 662 #define hci_req_lock(d)         down(&d->req_lock)
 663 #define hci_req_unlock(d)       up(&d->req_lock)
 664
 665 void hci_req_complete(struct hci_dev *hdev, int result);
 666
 667 #endif /* __HCI_CORE_H */