drivers/bluetooth/hci_ldisc.c

   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  * Bluetooth HCI UART driver.
  27  *
  28  * $Id: hci_ldisc.c,v 1.5 2002/10/02 18:37:20 maxk Exp $
  29  */
  30 #define VERSION "2.1"
  31
  32 #include <linux/config.h>
  33 #include <linux/module.h>
  34
  35 #include <linux/kernel.h>
  36 #include <linux/init.h>
  37 #include <linux/sched.h>
  38 #include <linux/types.h>
  39 #include <linux/fcntl.h>
  40 #include <linux/interrupt.h>
  41 #include <linux/ptrace.h>
  42 #include <linux/poll.h>
  43
  44 #include <linux/slab.h>
  45 #include <linux/tty.h>
  46 #include <linux/errno.h>
  47 #include <linux/string.h>
  48 #include <linux/signal.h>
  49 #include <linux/ioctl.h>
  50 #include <linux/skbuff.h>
  51
  52 #include <net/bluetooth/bluetooth.h>
  53 #include <net/bluetooth/hci_core.h>
  54 #include "hci_uart.h"
  55
  56 #ifndef CONFIG_BT_HCIUART_DEBUG
  57 #undef  BT_DBG
  58 #define BT_DBG( A... )
  59 #undef  BT_DMP
  60 #define BT_DMP( A... )
  61 #endif
  62
  63 static struct hci_uart_proto *hup[HCI_UART_MAX_PROTO];
  64
  65 int hci_uart_register_proto(struct hci_uart_proto *p)
  66 {
  67         if (p->id >= HCI_UART_MAX_PROTO)
  68                 return -EINVAL;
  69
  70         if (hup[p->id])
  71                 return -EEXIST;
  72
  73         hup[p->id] = p;
  74         return 0;
  75 }
  76
  77 int hci_uart_unregister_proto(struct hci_uart_proto *p)
  78 {
  79         if (p->id >= HCI_UART_MAX_PROTO)
  80                 return -EINVAL;
  81
  82         if (!hup[p->id])
  83                 return -EINVAL;
  84
  85         hup[p->id] = NULL;
  86         return 0;
  87 }
  88
  89 static struct hci_uart_proto *hci_uart_get_proto(unsigned int id)
  90 {
  91         if (id >= HCI_UART_MAX_PROTO)
  92                 return NULL;
  93         return hup[id];
  94 }
  95
  96 static inline void hci_uart_tx_complete(struct hci_uart *hu, int pkt_type)
  97 {
  98         struct hci_dev *hdev = hu->hdev;
  99
 100         /* Update HCI stat counters */
 101         switch (pkt_type) {
 102         case HCI_COMMAND_PKT:
 103                 hdev->stat.cmd_tx++;
 104                 break;
 105
 106         case HCI_ACLDATA_PKT:
 107                 hdev->stat.acl_tx++;
 108                 break;
 109
 110         case HCI_SCODATA_PKT:
 111                 hdev->stat.cmd_tx++;
 112                 break;
 113         }
 114 }
 115
 116 static inline struct sk_buff *hci_uart_dequeue(struct hci_uart *hu)
 117 {
 118         struct sk_buff *skb = hu->tx_skb;
 119         if (!skb)
 120                 skb = hu->proto->dequeue(hu);
 121         else
 122                 hu->tx_skb = NULL;
 123         return skb;
 124 }
 125
 126 int hci_uart_tx_wakeup(struct hci_uart *hu)
 127 {
 128         struct tty_struct *tty = hu->tty;
 129         struct hci_dev *hdev = hu->hdev;
 130         struct sk_buff *skb;
 131
 132         if (test_and_set_bit(HCI_UART_SENDING, &hu->tx_state)) {
 133                 set_bit(HCI_UART_TX_WAKEUP, &hu->tx_state);
 134                 return 0;
 135         }
 136
 137         BT_DBG("");
 138
 139 restart:
 140         clear_bit(HCI_UART_TX_WAKEUP, &hu->tx_state);
 141
 142         while ((skb = hci_uart_dequeue(hu))) {
 143                 int len;
 144
 145                 set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
 146                 len = tty->driver->write(tty, 0, skb->data, skb->len);
 147                 hdev->stat.byte_tx += len;
 148
 149                 skb_pull(skb, len);
 150                 if (skb->len) {
 151                         hu->tx_skb = skb;
 152                         break;
 153                 }
 154
 155                 hci_uart_tx_complete(hu, skb->pkt_type);
 156                 kfree_skb(skb);
 157         }
 158
 159         if (test_bit(HCI_UART_TX_WAKEUP, &hu->tx_state))
 160                 goto restart;
 161
 162         clear_bit(HCI_UART_SENDING, &hu->tx_state);
 163         return 0;
 164 }
 165
 166 /* ------- Interface to HCI layer ------ */
 167 /* Initialize device */
 168 static int hci_uart_open(struct hci_dev *hdev)
 169 {
 170         BT_DBG("%s %p", hdev->name, hdev);
 171
 172         /* Nothing to do for UART driver */
 173
 174         set_bit(HCI_RUNNING, &hdev->flags);
 175         return 0;
 176 }
 177
 178 /* Reset device */
 179 static int hci_uart_flush(struct hci_dev *hdev)
 180 {
 181         struct hci_uart *hu  = (struct hci_uart *) hdev->driver_data;
 182         struct tty_struct *tty = hu->tty;
 183
 184         BT_DBG("hdev %p tty %p", hdev, tty);
 185
 186         if (hu->tx_skb) {
 187                 kfree_skb(hu->tx_skb); hu->tx_skb = NULL;
 188         }
 189
 190         /* Flush any pending characters in the driver and discipline. */
 191         if (tty->ldisc.flush_buffer)
 192                 tty->ldisc.flush_buffer(tty);
 193
 194         if (tty->driver->flush_buffer)
 195                 tty->driver->flush_buffer(tty);
 196
 197         if (test_bit(HCI_UART_PROTO_SET, &hu->flags))
 198                 hu->proto->flush(hu);
 199
 200         return 0;
 201 }
 202
 203 /* Close device */
 204 static int hci_uart_close(struct hci_dev *hdev)
 205 {
 206         BT_DBG("hdev %p", hdev);
 207
 208         if (!test_and_clear_bit(HCI_RUNNING, &hdev->flags))
 209                 return 0;
 210
 211         hci_uart_flush(hdev);
 212         return 0;
 213 }
 214
 215 /* Send frames from HCI layer */
 216 static int hci_uart_send_frame(struct sk_buff *skb)
 217 {
 218         struct hci_dev* hdev = (struct hci_dev *) skb->dev;
 219         struct tty_struct *tty;
 220         struct hci_uart *hu;
 221
 222         if (!hdev) {
 223                 BT_ERR("Frame for uknown device (hdev=NULL)");
 224                 return -ENODEV;
 225         }
 226
 227         if (!test_bit(HCI_RUNNING, &hdev->flags))
 228                 return -EBUSY;
 229
 230         hu = (struct hci_uart *) hdev->driver_data;
 231         tty = hu->tty;
 232
 233         BT_DBG("%s: type %d len %d", hdev->name, skb->pkt_type, skb->len);
 234
 235         hu->proto->enqueue(hu, skb);
 236
 237         hci_uart_tx_wakeup(hu);
 238         return 0;
 239 }
 240
 241 static void hci_uart_destruct(struct hci_dev *hdev)
 242 {
 243         struct hci_uart *hu;
 244
 245         if (!hdev) return;
 246
 247         BT_DBG("%s", hdev->name);
 248
 249         hu = (struct hci_uart *) hdev->driver_data;
 250         kfree(hu);
 251 }
 252
 253 /* ------ LDISC part ------ */
 254 /* hci_uart_tty_open
 255  *
 256  *     Called when line discipline changed to HCI_UART.
 257  *
 258  * Arguments:
 259  *     tty    pointer to tty info structure
 260  * Return Value:
 261  *     0 if success, otherwise error code
 262  */
 263 static int hci_uart_tty_open(struct tty_struct *tty)
 264 {
 265         struct hci_uart *hu = (void *) tty->disc_data;
 266
 267         BT_DBG("tty %p", tty);
 268
 269         if (hu)
 270                 return -EEXIST;
 271
 272         if (!(hu = kmalloc(sizeof(struct hci_uart), GFP_KERNEL))) {
 273                 BT_ERR("Can't allocate controll structure");
 274                 return -ENFILE;
 275         }
 276         memset(hu, 0, sizeof(struct hci_uart));
 277
 278         tty->disc_data = hu;
 279         hu->tty = tty;
 280
 281         spin_lock_init(&hu->rx_lock);
 282
 283         /* Flush any pending characters in the driver and line discipline */
 284         if (tty->ldisc.flush_buffer)
 285                 tty->ldisc.flush_buffer(tty);
 286
 287         if (tty->driver->flush_buffer)
 288                 tty->driver->flush_buffer(tty);
 289
 290         return 0;
 291 }
 292
 293 /* hci_uart_tty_close()
 294  *
 295  *    Called when the line discipline is changed to something
 296  *    else, the tty is closed, or the tty detects a hangup.
 297  */
 298 static void hci_uart_tty_close(struct tty_struct *tty)
 299 {
 300         struct hci_uart *hu = (void *)tty->disc_data;
 301
 302         BT_DBG("tty %p", tty);
 303
 304         /* Detach from the tty */
 305         tty->disc_data = NULL;
 306
 307         if (hu) {
 308                 struct hci_dev *hdev = hu->hdev;
 309                 hci_uart_close(hdev);
 310
 311                 if (test_and_clear_bit(HCI_UART_PROTO_SET, &hu->flags)) {
 312                         hu->proto->close(hu);
 313                         hci_unregister_dev(hdev);
 314                         hci_free_dev(hdev);
 315                 }
 316         }
 317 }
 318
 319 /* hci_uart_tty_wakeup()
 320  *
 321  *    Callback for transmit wakeup. Called when low level
 322  *    device driver can accept more send data.
 323  *
 324  * Arguments:        tty    pointer to associated tty instance data
 325  * Return Value:    None
 326  */
 327 static void hci_uart_tty_wakeup(struct tty_struct *tty)
 328 {
 329         struct hci_uart *hu = (void *)tty->disc_data;
 330
 331         BT_DBG("");
 332
 333         if (!hu)
 334                 return;
 335
 336         clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
 337
 338         if (tty != hu->tty)
 339                 return;
 340
 341         if (test_bit(HCI_UART_PROTO_SET, &hu->flags))
 342                 hci_uart_tx_wakeup(hu);
 343 }
 344
 345 /* hci_uart_tty_room()
 346  *
 347  *    Callback function from tty driver. Return the amount of
 348  *    space left in the receiver's buffer to decide if remote
 349  *    transmitter is to be throttled.
 350  *
 351  * Arguments:        tty    pointer to associated tty instance data
 352  * Return Value:    number of bytes left in receive buffer
 353  */
 354 static int hci_uart_tty_room (struct tty_struct *tty)
 355 {
 356         return 65536;
 357 }
 358
 359 /* hci_uart_tty_receive()
 360  *
 361  *     Called by tty low level driver when receive data is
 362  *     available.
 363  *
 364  * Arguments:  tty          pointer to tty isntance data
 365  *             data         pointer to received data
 366  *             flags        pointer to flags for data
 367  *             count        count of received data in bytes
 368  *
 369  * Return Value:    None
 370  */
 371 static void hci_uart_tty_receive(struct tty_struct *tty, const __u8 *data, char *flags, int count)
 372 {
 373         struct hci_uart *hu = (void *)tty->disc_data;
 374
 375         if (!hu || tty != hu->tty)
 376                 return;
 377
 378         if (!test_bit(HCI_UART_PROTO_SET, &hu->flags))
 379                 return;
 380
 381         spin_lock(&hu->rx_lock);
 382         hu->proto->recv(hu, (void *) data, count);
 383         hu->hdev->stat.byte_rx += count;
 384         spin_unlock(&hu->rx_lock);
 385
 386         if (test_and_clear_bit(TTY_THROTTLED,&tty->flags) && tty->driver->unthrottle)
 387                 tty->driver->unthrottle(tty);
 388 }
 389
 390 static int hci_uart_register_dev(struct hci_uart *hu)
 391 {
 392         struct hci_dev *hdev;
 393
 394         BT_DBG("");
 395
 396         /* Initialize and register HCI device */
 397         hdev = hci_alloc_dev();
 398         if (!hdev) {
 399                 BT_ERR("Can't allocate HCI device");
 400                 return -ENOMEM;
 401         }
 402
 403         hu->hdev = hdev;
 404
 405         hdev->type = HCI_UART;
 406         hdev->driver_data = hu;
 407
 408         hdev->open  = hci_uart_open;
 409         hdev->close = hci_uart_close;
 410         hdev->flush = hci_uart_flush;
 411         hdev->send  = hci_uart_send_frame;
 412         hdev->destruct = hci_uart_destruct;
 413
 414         hdev->owner = THIS_MODULE;
 415
 416         if (hci_register_dev(hdev) < 0) {
 417                 BT_ERR("Can't register HCI device");
 418                 hci_free_dev(hdev);
 419                 return -ENODEV;
 420         }
 421
 422         return 0;
 423 }
 424
 425 static int hci_uart_set_proto(struct hci_uart *hu, int id)
 426 {
 427         struct hci_uart_proto *p;
 428         int err;
 429
 430         p = hci_uart_get_proto(id);
 431         if (!p)
 432                 return -EPROTONOSUPPORT;
 433
 434         err = p->open(hu);
 435         if (err)
 436                 return err;
 437
 438         hu->proto = p;
 439
 440         err = hci_uart_register_dev(hu);
 441         if (err) {
 442                 p->close(hu);
 443                 return err;
 444         }
 445         return 0;
 446 }
 447
 448 /* hci_uart_tty_ioctl()
 449  *
 450  *    Process IOCTL system call for the tty device.
 451  *
 452  * Arguments:
 453  *
 454  *    tty        pointer to tty instance data
 455  *    file       pointer to open file object for device
 456  *    cmd        IOCTL command code
 457  *    arg        argument for IOCTL call (cmd dependent)
 458  *
 459  * Return Value:    Command dependent
 460  */
 461 static int hci_uart_tty_ioctl(struct tty_struct *tty, struct file * file,
 462                             unsigned int cmd, unsigned long arg)
 463 {
 464         struct hci_uart *hu = (void *)tty->disc_data;
 465         int err = 0;
 466
 467         BT_DBG("");
 468
 469         /* Verify the status of the device */
 470         if (!hu)
 471                 return -EBADF;
 472
 473         switch (cmd) {
 474         case HCIUARTSETPROTO:
 475                 if (!test_and_set_bit(HCI_UART_PROTO_SET, &hu->flags)) {
 476                         err = hci_uart_set_proto(hu, arg);
 477                         if (err) {
 478                                 clear_bit(HCI_UART_PROTO_SET, &hu->flags);
 479                                 return err;
 480                         }
 481                         tty->low_latency = 1;
 482                 } else
 483                         return -EBUSY;
 484
 485         case HCIUARTGETPROTO:
 486                 if (test_bit(HCI_UART_PROTO_SET, &hu->flags))
 487                         return hu->proto->id;
 488                 return -EUNATCH;
 489
 490         default:
 491                 err = n_tty_ioctl(tty, file, cmd, arg);
 492                 break;
 493         };
 494
 495         return err;
 496 }
 497
 498 /*
 499  * We don't provide read/write/poll interface for user space.
 500  */
 501 static ssize_t hci_uart_tty_read(struct tty_struct *tty, struct file *file, unsigned char *buf, size_t nr)
 502 {
 503         return 0;
 504 }
 505 static ssize_t hci_uart_tty_write(struct tty_struct *tty, struct file *file, const unsigned char *data, size_t count)
 506 {
 507         return 0;
 508 }
 509 static unsigned int hci_uart_tty_poll(struct tty_struct *tty, struct file *filp, poll_table *wait)
 510 {
 511         return 0;
 512 }
 513
 514 #ifdef CONFIG_BT_HCIUART_H4
 515 int h4_init(void);
 516 int h4_deinit(void);
 517 #endif
 518 #ifdef CONFIG_BT_HCIUART_BCSP
 519 int bcsp_init(void);
 520 int bcsp_deinit(void);
 521 #endif
 522
 523 static int __init hci_uart_init(void)
 524 {
 525         static struct tty_ldisc hci_uart_ldisc;
 526         int err;
 527
 528         BT_INFO("HCI UART driver ver %s", VERSION);
 529
 530         /* Register the tty discipline */
 531
 532         memset(&hci_uart_ldisc, 0, sizeof (hci_uart_ldisc));
 533         hci_uart_ldisc.magic       = TTY_LDISC_MAGIC;
 534         hci_uart_ldisc.name        = "n_hci";
 535         hci_uart_ldisc.open        = hci_uart_tty_open;
 536         hci_uart_ldisc.close       = hci_uart_tty_close;
 537         hci_uart_ldisc.read        = hci_uart_tty_read;
 538         hci_uart_ldisc.write       = hci_uart_tty_write;
 539         hci_uart_ldisc.ioctl       = hci_uart_tty_ioctl;
 540         hci_uart_ldisc.poll        = hci_uart_tty_poll;
 541         hci_uart_ldisc.receive_room= hci_uart_tty_room;
 542         hci_uart_ldisc.receive_buf = hci_uart_tty_receive;
 543         hci_uart_ldisc.write_wakeup= hci_uart_tty_wakeup;
 544         hci_uart_ldisc.owner       = THIS_MODULE;
 545
 546         if ((err = tty_register_ldisc(N_HCI, &hci_uart_ldisc))) {
 547                 BT_ERR("HCI line discipline registration failed. (%d)", err);
 548                 return err;
 549         }
 550
 551 #ifdef CONFIG_BT_HCIUART_H4
 552         h4_init();
 553 #endif
 554 #ifdef CONFIG_BT_HCIUART_BCSP
 555         bcsp_init();
 556 #endif
 557
 558         return 0;
 559 }
 560
 561 static void __exit hci_uart_exit(void)
 562 {
 563         int err;
 564
 565 #ifdef CONFIG_BT_HCIUART_H4
 566         h4_deinit();
 567 #endif
 568 #ifdef CONFIG_BT_HCIUART_BCSP
 569         bcsp_deinit();
 570 #endif
 571
 572         /* Release tty registration of line discipline */
 573         if ((err = tty_register_ldisc(N_HCI, NULL)))
 574                 BT_ERR("Can't unregister HCI line discipline (%d)", err);
 575 }
 576
 577 module_init(hci_uart_init);
 578 module_exit(hci_uart_exit);
 579
 580 MODULE_AUTHOR("Maxim Krasnyansky <maxk@qualcomm.com>");
 581 MODULE_DESCRIPTION("Bluetooth HCI UART driver ver " VERSION);
 582 MODULE_VERSION(VERSION);
 583 MODULE_LICENSE("GPL");
 584 MODULE_ALIAS_LDISC(N_HCI);