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