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