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