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