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 /*
  26  * $Id: hci_core.h,v 1.3 2002/04/17 18:55:21 maxk Exp $
  27  */
  28
  29 #ifndef __HCI_CORE_H
  30 #define __HCI_CORE_H
  31
  32 #include <linux/proc_fs.h>
  33 #include <net/bluetooth/hci.h>
  34
  35 /* HCI upper protocols */
  36 #define HCI_PROTO_L2CAP 0
  37 #define HCI_PROTO_SCO   1
  38
  39 #define HCI_INIT_TIMEOUT (HZ * 10)
  40
  41 extern struct proc_dir_entry *proc_bt_hci;
  42
  43 /* HCI Core structures */
  44
  45 struct inquiry_entry {
  46         struct inquiry_entry    *next;
  47         __u32                   timestamp;
  48         struct inquiry_info     info;
  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     num;
  61 };
  62
  63 struct hci_dev {
  64         struct list_head list;
  65         spinlock_t      lock;
  66         atomic_t        refcnt;
  67
  68         char            name[8];
  69         unsigned long   flags;
  70         __u16           id;
  71         __u8            type;
  72         bdaddr_t        bdaddr;
  73         __u8            features[8];
  74         __u16           voice_setting;
  75
  76         __u16           pkt_type;
  77         __u16           link_policy;
  78         __u16           link_mode;
  79
  80         unsigned long   quirks;
  81
  82         atomic_t        cmd_cnt;
  83         unsigned int    acl_cnt;
  84         unsigned int    sco_cnt;
  85
  86         unsigned int    acl_mtu;
  87         unsigned int    sco_mtu;
  88         unsigned int    acl_pkts;
  89         unsigned int    sco_pkts;
  90
  91         unsigned long   cmd_last_tx;
  92         unsigned long   acl_last_tx;
  93         unsigned long   sco_last_tx;
  94
  95         struct tasklet_struct   cmd_task;
  96         struct tasklet_struct   rx_task;
  97         struct tasklet_struct   tx_task;
  98
  99         struct sk_buff_head     rx_q;
 100         struct sk_buff_head     raw_q;
 101         struct sk_buff_head     cmd_q;
 102
 103         struct sk_buff          *sent_cmd;
 104
 105         struct semaphore        req_lock;
 106         wait_queue_head_t       req_wait_q;
 107         __u32                   req_status;
 108         __u32                   req_result;
 109
 110         struct inquiry_cache    inq_cache;
 111         struct hci_conn_hash    conn_hash;
 112
 113         struct hci_dev_stats    stat;
 114
 115         void                    *driver_data;
 116         void                    *core_data;
 117
 118         atomic_t                promisc;
 119
 120 #ifdef CONFIG_PROC_FS
 121         struct proc_dir_entry   *proc;
 122 #endif
 123
 124         struct class_device     class_dev;
 125
 126         struct module           *owner;
 127
 128         int (*open)(struct hci_dev *hdev);
 129         int (*close)(struct hci_dev *hdev);
 130         int (*flush)(struct hci_dev *hdev);
 131         int (*send)(struct sk_buff *skb);
 132         void (*destruct)(struct hci_dev *hdev);
 133         void (*notify)(struct hci_dev *hdev, unsigned int evt);
 134         int (*ioctl)(struct hci_dev *hdev, unsigned int cmd, unsigned long arg);
 135 };
 136
 137 struct hci_conn {
 138         struct list_head list;
 139
 140         atomic_t         refcnt;
 141         spinlock_t       lock;
 142
 143         bdaddr_t         dst;
 144         __u16            handle;
 145         __u16            state;
 146         __u8             type;
 147         __u8             out;
 148         __u32            link_mode;
 149         unsigned long    pend;
 150
 151         unsigned int     sent;
 152
 153         struct sk_buff_head data_q;
 154
 155         struct timer_list timer;
 156
 157         struct hci_dev  *hdev;
 158         void            *l2cap_data;
 159         void            *sco_data;
 160         void            *priv;
 161
 162         struct hci_conn *link;
 163 };
 164
 165 extern struct hci_proto *hci_proto[];
 166 extern struct list_head hci_dev_list;
 167 extern rwlock_t hci_dev_list_lock;
 168
 169 /* ----- Inquiry cache ----- */
 170 #define INQUIRY_CACHE_AGE_MAX   (HZ*30)   // 30 seconds
 171 #define INQUIRY_ENTRY_AGE_MAX   (HZ*60)   // 60 seconds
 172
 173 #define inquiry_cache_lock(c)           spin_lock(&c->lock)
 174 #define inquiry_cache_unlock(c)         spin_unlock(&c->lock)
 175 #define inquiry_cache_lock_bh(c)        spin_lock_bh(&c->lock)
 176 #define inquiry_cache_unlock_bh(c)      spin_unlock_bh(&c->lock)
 177
 178 static inline void inquiry_cache_init(struct hci_dev *hdev)
 179 {
 180         struct inquiry_cache *c = &hdev->inq_cache;
 181         spin_lock_init(&c->lock);
 182         c->list = NULL;
 183 }
 184
 185 static inline int inquiry_cache_empty(struct hci_dev *hdev)
 186 {
 187         struct inquiry_cache *c = &hdev->inq_cache;
 188         return (c->list == NULL);
 189 }
 190
 191 static inline long inquiry_cache_age(struct hci_dev *hdev)
 192 {
 193         struct inquiry_cache *c = &hdev->inq_cache;
 194         return jiffies - c->timestamp;
 195 }
 196
 197 static inline long inquiry_entry_age(struct inquiry_entry *e)
 198 {
 199         return jiffies - e->timestamp;
 200 }
 201
 202 struct inquiry_entry *inquiry_cache_lookup(struct hci_dev *hdev, bdaddr_t *bdaddr);
 203 void inquiry_cache_update(struct hci_dev *hdev, struct inquiry_info *info);
 204 void inquiry_cache_flush(struct hci_dev *hdev);
 205 int  inquiry_cache_dump(struct hci_dev *hdev, int num, __u8 *buf);
 206
 207 /* ----- HCI Connections ----- */
 208 enum {
 209         HCI_CONN_AUTH_PEND,
 210         HCI_CONN_ENCRYPT_PEND
 211 };
 212
 213 static inline void hci_conn_hash_init(struct hci_dev *hdev)
 214 {
 215         struct hci_conn_hash *h = &hdev->conn_hash;
 216         INIT_LIST_HEAD(&h->list);
 217         spin_lock_init(&h->lock);
 218         h->num = 0;
 219 }
 220
 221 static inline void hci_conn_hash_add(struct hci_dev *hdev, struct hci_conn *c)
 222 {
 223         struct hci_conn_hash *h = &hdev->conn_hash;
 224         list_add(&c->list, &h->list);
 225         h->num++;
 226 }
 227
 228 static inline void hci_conn_hash_del(struct hci_dev *hdev, struct hci_conn *c)
 229 {
 230         struct hci_conn_hash *h = &hdev->conn_hash;
 231         list_del(&c->list);
 232         h->num--;
 233 }
 234
 235 static inline struct hci_conn *hci_conn_hash_lookup_handle(struct hci_dev *hdev,
 236                                         __u16 handle)
 237 {
 238         struct hci_conn_hash *h = &hdev->conn_hash;
 239         struct list_head *p;
 240         struct hci_conn  *c;
 241
 242         list_for_each(p, &h->list) {
 243                 c = list_entry(p, struct hci_conn, list);
 244                 if (c->handle == handle)
 245                         return c;
 246         }
 247         return NULL;
 248 }
 249
 250 static inline struct hci_conn *hci_conn_hash_lookup_ba(struct hci_dev *hdev,
 251                                         __u8 type, bdaddr_t *ba)
 252 {
 253         struct hci_conn_hash *h = &hdev->conn_hash;
 254         struct list_head *p;
 255         struct hci_conn  *c;
 256
 257         list_for_each(p, &h->list) {
 258                 c = list_entry(p, struct hci_conn, list);
 259                 if (c->type == type && !bacmp(&c->dst, ba))
 260                         return c;
 261         }
 262         return NULL;
 263 }
 264
 265 void hci_acl_connect(struct hci_conn *conn);
 266 void hci_acl_disconn(struct hci_conn *conn, __u8 reason);
 267 void hci_add_sco(struct hci_conn *conn, __u16 handle);
 268
 269 struct hci_conn *hci_conn_add(struct hci_dev *hdev, int type, bdaddr_t *dst);
 270 int    hci_conn_del(struct hci_conn *conn);
 271 void   hci_conn_hash_flush(struct hci_dev *hdev);
 272
 273 struct hci_conn *hci_connect(struct hci_dev *hdev, int type, bdaddr_t *src);
 274 int hci_conn_auth(struct hci_conn *conn);
 275 int hci_conn_encrypt(struct hci_conn *conn);
 276
 277 static inline void hci_conn_set_timer(struct hci_conn *conn, unsigned long timeout)
 278 {
 279         mod_timer(&conn->timer, jiffies + timeout);
 280 }
 281
 282 static inline void hci_conn_del_timer(struct hci_conn *conn)
 283 {
 284         del_timer(&conn->timer);
 285 }
 286
 287 static inline void hci_conn_hold(struct hci_conn *conn)
 288 {
 289         atomic_inc(&conn->refcnt);
 290         hci_conn_del_timer(conn);
 291 }
 292
 293 static inline void hci_conn_put(struct hci_conn *conn)
 294 {
 295         if (atomic_dec_and_test(&conn->refcnt)) {
 296                 if (conn->type == ACL_LINK) {
 297                         unsigned long timeo = (conn->out) ?
 298                                 HCI_DISCONN_TIMEOUT : HCI_DISCONN_TIMEOUT * 2;
 299                         hci_conn_set_timer(conn, timeo);
 300                 } else
 301                         hci_conn_set_timer(conn, HZ / 100);
 302         }
 303 }
 304
 305 /* ----- HCI tasks ----- */
 306 static inline void hci_sched_cmd(struct hci_dev *hdev)
 307 {
 308         tasklet_schedule(&hdev->cmd_task);
 309 }
 310
 311 static inline void hci_sched_rx(struct hci_dev *hdev)
 312 {
 313         tasklet_schedule(&hdev->rx_task);
 314 }
 315
 316 static inline void hci_sched_tx(struct hci_dev *hdev)
 317 {
 318         tasklet_schedule(&hdev->tx_task);
 319 }
 320
 321 /* ----- HCI Devices ----- */
 322 static inline void __hci_dev_put(struct hci_dev *d)
 323 {
 324         if (atomic_dec_and_test(&d->refcnt))
 325                 d->destruct(d);
 326 }
 327
 328 static inline void hci_dev_put(struct hci_dev *d)
 329 {
 330         __hci_dev_put(d);
 331         module_put(d->owner);
 332 }
 333
 334 static inline struct hci_dev *__hci_dev_hold(struct hci_dev *d)
 335 {
 336         atomic_inc(&d->refcnt);
 337         return d;
 338 }
 339
 340 static inline struct hci_dev *hci_dev_hold(struct hci_dev *d)
 341 {
 342         if (try_module_get(d->owner))
 343                 return __hci_dev_hold(d);
 344         return NULL;
 345 }
 346
 347 #define hci_dev_lock(d)         spin_lock(&d->lock)
 348 #define hci_dev_unlock(d)       spin_unlock(&d->lock)
 349 #define hci_dev_lock_bh(d)      spin_lock_bh(&d->lock)
 350 #define hci_dev_unlock_bh(d)    spin_unlock_bh(&d->lock)
 351
 352 struct hci_dev *hci_dev_get(int index);
 353 struct hci_dev *hci_get_route(bdaddr_t *src, bdaddr_t *dst);
 354
 355 struct hci_dev *hci_alloc_dev(void);
 356 void hci_free_dev(struct hci_dev *hdev);
 357 int hci_register_dev(struct hci_dev *hdev);
 358 int hci_unregister_dev(struct hci_dev *hdev);
 359 int hci_suspend_dev(struct hci_dev *hdev);
 360 int hci_resume_dev(struct hci_dev *hdev);
 361 int hci_dev_open(__u16 dev);
 362 int hci_dev_close(__u16 dev);
 363 int hci_dev_reset(__u16 dev);
 364 int hci_dev_reset_stat(__u16 dev);
 365 int hci_dev_cmd(unsigned int cmd, unsigned long arg);
 366 int hci_get_dev_list(unsigned long arg);
 367 int hci_get_dev_info(unsigned long arg);
 368 int hci_get_conn_list(unsigned long arg);
 369 int hci_get_conn_info(struct hci_dev *hdev, unsigned long arg);
 370 int hci_inquiry(unsigned long arg);
 371
 372 void hci_event_packet(struct hci_dev *hdev, struct sk_buff *skb);
 373
 374 /* Receive frame from HCI drivers */
 375 static inline int hci_recv_frame(struct sk_buff *skb)
 376 {
 377         struct hci_dev *hdev = (struct hci_dev *) skb->dev;
 378         if (!hdev || (!test_bit(HCI_UP, &hdev->flags)
 379                         && !test_bit(HCI_INIT, &hdev->flags))) {
 380                 kfree_skb(skb);
 381                 return -ENXIO;
 382         }
 383
 384         /* Incomming skb */
 385         bt_cb(skb)->incoming = 1;
 386
 387         /* Time stamp */
 388         do_gettimeofday(&skb->stamp);
 389
 390         /* Queue frame for rx task */
 391         skb_queue_tail(&hdev->rx_q, skb);
 392         hci_sched_rx(hdev);
 393         return 0;
 394 }
 395
 396 int hci_register_sysfs(struct hci_dev *hdev);
 397 void hci_unregister_sysfs(struct hci_dev *hdev);
 398
 399 #define SET_HCIDEV_DEV(hdev, pdev) ((hdev)->class_dev.dev = (pdev))
 400
 401 /* ----- LMP capabilities ----- */
 402 #define lmp_rswitch_capable(dev) (dev->features[0] & LMP_RSWITCH)
 403 #define lmp_encrypt_capable(dev) (dev->features[0] & LMP_ENCRYPT)
 404
 405 /* ----- HCI protocols ----- */
 406 struct hci_proto {
 407         char            *name;
 408         unsigned int    id;
 409         unsigned long   flags;
 410
 411         void            *priv;
 412
 413         int (*connect_ind)      (struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 type);
 414         int (*connect_cfm)      (struct hci_conn *conn, __u8 status);
 415         int (*disconn_ind)      (struct hci_conn *conn, __u8 reason);
 416         int (*recv_acldata)     (struct hci_conn *conn, struct sk_buff *skb, __u16 flags);
 417         int (*recv_scodata)     (struct hci_conn *conn, struct sk_buff *skb);
 418         int (*auth_cfm)         (struct hci_conn *conn, __u8 status);
 419         int (*encrypt_cfm)      (struct hci_conn *conn, __u8 status);
 420 };
 421
 422 static inline int hci_proto_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 type)
 423 {
 424         register struct hci_proto *hp;
 425         int mask = 0;
 426
 427         hp = hci_proto[HCI_PROTO_L2CAP];
 428         if (hp && hp->connect_ind)
 429                 mask |= hp->connect_ind(hdev, bdaddr, type);
 430
 431         hp = hci_proto[HCI_PROTO_SCO];
 432         if (hp && hp->connect_ind)
 433                 mask |= hp->connect_ind(hdev, bdaddr, type);
 434
 435         return mask;
 436 }
 437
 438 static inline void hci_proto_connect_cfm(struct hci_conn *conn, __u8 status)
 439 {
 440         register struct hci_proto *hp;
 441
 442         hp = hci_proto[HCI_PROTO_L2CAP];
 443         if (hp && hp->connect_cfm)
 444                 hp->connect_cfm(conn, status);
 445
 446         hp = hci_proto[HCI_PROTO_SCO];
 447         if (hp && hp->connect_cfm)
 448                 hp->connect_cfm(conn, status);
 449 }
 450
 451 static inline void hci_proto_disconn_ind(struct hci_conn *conn, __u8 reason)
 452 {
 453         register struct hci_proto *hp;
 454
 455         hp = hci_proto[HCI_PROTO_L2CAP];
 456         if (hp && hp->disconn_ind)
 457                 hp->disconn_ind(conn, reason);
 458
 459         hp = hci_proto[HCI_PROTO_SCO];
 460         if (hp && hp->disconn_ind)
 461                 hp->disconn_ind(conn, reason);
 462 }
 463
 464 static inline void hci_proto_auth_cfm(struct hci_conn *conn, __u8 status)
 465 {
 466         register struct hci_proto *hp;
 467
 468         hp = hci_proto[HCI_PROTO_L2CAP];
 469         if (hp && hp->auth_cfm)
 470                 hp->auth_cfm(conn, status);
 471
 472         hp = hci_proto[HCI_PROTO_SCO];
 473         if (hp && hp->auth_cfm)
 474                 hp->auth_cfm(conn, status);
 475 }
 476
 477 static inline void hci_proto_encrypt_cfm(struct hci_conn *conn, __u8 status)
 478 {
 479         register struct hci_proto *hp;
 480
 481         hp = hci_proto[HCI_PROTO_L2CAP];
 482         if (hp && hp->encrypt_cfm)
 483                 hp->encrypt_cfm(conn, status);
 484
 485         hp = hci_proto[HCI_PROTO_SCO];
 486         if (hp && hp->encrypt_cfm)
 487                 hp->encrypt_cfm(conn, status);
 488 }
 489
 490 int hci_register_proto(struct hci_proto *hproto);
 491 int hci_unregister_proto(struct hci_proto *hproto);
 492 int hci_register_notifier(struct notifier_block *nb);
 493 int hci_unregister_notifier(struct notifier_block *nb);
 494
 495 int hci_send_cmd(struct hci_dev *hdev, __u16 ogf, __u16 ocf, __u32 plen, void *param);
 496 int hci_send_acl(struct hci_conn *conn, struct sk_buff *skb, __u16 flags);
 497 int hci_send_sco(struct hci_conn *conn, struct sk_buff *skb);
 498
 499 void *hci_sent_cmd_data(struct hci_dev *hdev, __u16 ogf, __u16 ocf);
 500
 501 void hci_si_event(struct hci_dev *hdev, int type, int dlen, void *data);
 502
 503 /* ----- HCI Sockets ----- */
 504 void hci_send_to_sock(struct hci_dev *hdev, struct sk_buff *skb);
 505
 506 /* HCI info for socket */
 507 #define hci_pi(sk)      ((struct hci_pinfo *)sk->sk_protinfo)
 508 struct hci_pinfo {
 509         struct hci_dev    *hdev;
 510         struct hci_filter filter;
 511         __u32             cmsg_mask;
 512 };
 513
 514 /* HCI security filter */
 515 #define HCI_SFLT_MAX_OGF  5
 516
 517 struct hci_sec_filter {
 518         __u32 type_mask;
 519         __u32 event_mask[2];
 520         __u32 ocf_mask[HCI_SFLT_MAX_OGF + 1][4];
 521 };
 522
 523 /* ----- HCI requests ----- */
 524 #define HCI_REQ_DONE      0
 525 #define HCI_REQ_PEND      1
 526 #define HCI_REQ_CANCELED  2
 527
 528 #define hci_req_lock(d)         down(&d->req_lock)
 529 #define hci_req_unlock(d)       up(&d->req_lock)
 530
 531 void hci_req_complete(struct hci_dev *hdev, int result);
 532 void hci_req_cancel(struct hci_dev *hdev, int err);
 533
 534 #endif /* __HCI_CORE_H */