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/config.h>
  36 #include <linux/kernel.h>
  37 #include <linux/init.h>
  38 #include <linux/sched.h>
  39 #include <linux/types.h>
  40 #include <linux/fcntl.h>
  41 #include <linux/interrupt.h>
  42 #include <linux/ptrace.h>
  43 #include <linux/poll.h>
  44
  45 #include <linux/slab.h>
  46 #include <linux/tty.h>
  47 #include <linux/errno.h>
  48 #include <linux/string.h>
  49 #include <linux/signal.h>
  50 #include <linux/ioctl.h>
  51 #include <linux/skbuff.h>
  52
  53 #include <net/bluetooth/bluetooth.h>
  54 #include <net/bluetooth/hci_core.h>
  55 #include "hci_uart.h"
  56
  57 #ifndef CONFIG_BT_HCIUART_DEBUG
  58 #undef  BT_DBG
  59 #define BT_DBG( A... )
  60 #undef  BT_DMP
  61 #define BT_DMP( A... )
  62 #endif
  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, 0, 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, 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         if (tty->ldisc.flush_buffer)
 193                 tty->ldisc.flush_buffer(tty);
 194
 195         if (tty->driver->flush_buffer)
 196                 tty->driver->flush_buffer(tty);
 197
 198         if (test_bit(HCI_UART_PROTO_SET, &hu->flags))
 199                 hu->proto->flush(hu);
 200
 201         return 0;
 202 }
 203
 204 /* Close device */
 205 static int hci_uart_close(struct hci_dev *hdev)
 206 {
 207         BT_DBG("hdev %p", hdev);
 208
 209         if (!test_and_clear_bit(HCI_RUNNING, &hdev->flags))
 210                 return 0;
 211
 212         hci_uart_flush(hdev);
 213         return 0;
 214 }
 215
 216 /* Send frames from HCI layer */
 217 static int hci_uart_send_frame(struct sk_buff *skb)
 218 {
 219         struct hci_dev* hdev = (struct hci_dev *) skb->dev;
 220         struct tty_struct *tty;
 221         struct hci_uart *hu;
 222
 223         if (!hdev) {
 224                 BT_ERR("Frame for uknown device (hdev=NULL)");
 225                 return -ENODEV;
 226         }
 227
 228         if (!test_bit(HCI_RUNNING, &hdev->flags))
 229                 return -EBUSY;
 230
 231         hu = (struct hci_uart *) hdev->driver_data;
 232         tty = hu->tty;
 233
 234         BT_DBG("%s: type %d len %d", hdev->name, skb->pkt_type, skb->len);
 235
 236         hu->proto->enqueue(hu, skb);
 237
 238         hci_uart_tx_wakeup(hu);
 239         return 0;
 240 }
 241
 242 static void hci_uart_destruct(struct hci_dev *hdev)
 243 {
 244         struct hci_uart *hu;
 245
 246         if (!hdev) return;
 247
 248         BT_DBG("%s", hdev->name);
 249
 250         hu = (struct hci_uart *) hdev->driver_data;
 251         kfree(hu);
 252 }
 253
 254 /* ------ LDISC part ------ */
 255 /* hci_uart_tty_open
 256  *
 257  *     Called when line discipline changed to HCI_UART.
 258  *
 259  * Arguments:
 260  *     tty    pointer to tty info structure
 261  * Return Value:
 262  *     0 if success, otherwise error code
 263  */
 264 static int hci_uart_tty_open(struct tty_struct *tty)
 265 {
 266         struct hci_uart *hu = (void *) tty->disc_data;
 267
 268         BT_DBG("tty %p", tty);
 269
 270         if (hu)
 271                 return -EEXIST;
 272
 273         if (!(hu = kmalloc(sizeof(struct hci_uart), GFP_KERNEL))) {
 274                 BT_ERR("Can't allocate controll structure");
 275                 return -ENFILE;
 276         }
 277         memset(hu, 0, sizeof(struct hci_uart));
 278
 279         tty->disc_data = hu;
 280         hu->tty = tty;
 281
 282         spin_lock_init(&hu->rx_lock);
 283
 284         /* Flush any pending characters in the driver and line discipline */
 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 (hci_register_dev(hdev) < 0) {
 418                 BT_ERR("Can't register HCI device");
 419                 hci_free_dev(hdev);
 420                 return -ENODEV;
 421         }
 422
 423         return 0;
 424 }
 425
 426 static int hci_uart_set_proto(struct hci_uart *hu, int id)
 427 {
 428         struct hci_uart_proto *p;
 429         int err;
 430
 431         p = hci_uart_get_proto(id);
 432         if (!p)
 433                 return -EPROTONOSUPPORT;
 434
 435         err = p->open(hu);
 436         if (err)
 437                 return err;
 438
 439         hu->proto = p;
 440
 441         err = hci_uart_register_dev(hu);
 442         if (err) {
 443                 p->close(hu);
 444                 return err;
 445         }
 446         return 0;
 447 }
 448
 449 /* hci_uart_tty_ioctl()
 450  *
 451  *    Process IOCTL system call for the tty device.
 452  *
 453  * Arguments:
 454  *
 455  *    tty        pointer to tty instance data
 456  *    file       pointer to open file object for device
 457  *    cmd        IOCTL command code
 458  *    arg        argument for IOCTL call (cmd dependent)
 459  *
 460  * Return Value:    Command dependent
 461  */
 462 static int hci_uart_tty_ioctl(struct tty_struct *tty, struct file * file,
 463                             unsigned int cmd, unsigned long arg)
 464 {
 465         struct hci_uart *hu = (void *)tty->disc_data;
 466         int err = 0;
 467
 468         BT_DBG("");
 469
 470         /* Verify the status of the device */
 471         if (!hu)
 472                 return -EBADF;
 473
 474         switch (cmd) {
 475         case HCIUARTSETPROTO:
 476                 if (!test_and_set_bit(HCI_UART_PROTO_SET, &hu->flags)) {
 477                         err = hci_uart_set_proto(hu, arg);
 478                         if (err) {
 479                                 clear_bit(HCI_UART_PROTO_SET, &hu->flags);
 480                                 return err;
 481                         }
 482                         tty->low_latency = 1;
 483                 } else
 484                         return -EBUSY;
 485
 486         case HCIUARTGETPROTO:
 487                 if (test_bit(HCI_UART_PROTO_SET, &hu->flags))
 488                         return hu->proto->id;
 489                 return -EUNATCH;
 490
 491         default:
 492                 err = n_tty_ioctl(tty, file, cmd, arg);
 493                 break;
 494         };
 495
 496         return err;
 497 }
 498
 499 /*
 500  * We don't provide read/write/poll interface for user space.
 501  */
 502 static ssize_t hci_uart_tty_read(struct tty_struct *tty, struct file *file, unsigned char *buf, size_t nr)
 503 {
 504         return 0;
 505 }
 506 static ssize_t hci_uart_tty_write(struct tty_struct *tty, struct file *file, const unsigned char *data, size_t count)
 507 {
 508         return 0;
 509 }
 510 static unsigned int hci_uart_tty_poll(struct tty_struct *tty, struct file *filp, poll_table *wait)
 511 {
 512         return 0;
 513 }
 514
 515 #ifdef CONFIG_BT_HCIUART_H4
 516 int h4_init(void);
 517 int h4_deinit(void);
 518 #endif
 519 #ifdef CONFIG_BT_HCIUART_BCSP
 520 int bcsp_init(void);
 521 int bcsp_deinit(void);
 522 #endif
 523
 524 static int __init hci_uart_init(void)
 525 {
 526         static struct tty_ldisc hci_uart_ldisc;
 527         int err;
 528
 529         BT_INFO("HCI UART driver ver %s", VERSION);
 530
 531         /* Register the tty discipline */
 532
 533         memset(&hci_uart_ldisc, 0, sizeof (hci_uart_ldisc));
 534         hci_uart_ldisc.magic       = TTY_LDISC_MAGIC;
 535         hci_uart_ldisc.name        = "n_hci";
 536         hci_uart_ldisc.open        = hci_uart_tty_open;
 537         hci_uart_ldisc.close       = hci_uart_tty_close;
 538         hci_uart_ldisc.read        = hci_uart_tty_read;
 539         hci_uart_ldisc.write       = hci_uart_tty_write;
 540         hci_uart_ldisc.ioctl       = hci_uart_tty_ioctl;
 541         hci_uart_ldisc.poll        = hci_uart_tty_poll;
 542         hci_uart_ldisc.receive_room= hci_uart_tty_room;
 543         hci_uart_ldisc.receive_buf = hci_uart_tty_receive;
 544         hci_uart_ldisc.write_wakeup= hci_uart_tty_wakeup;
 545         hci_uart_ldisc.owner       = THIS_MODULE;
 546
 547         if ((err = tty_register_ldisc(N_HCI, &hci_uart_ldisc))) {
 548                 BT_ERR("HCI line discipline registration failed. (%d)", err);
 549                 return err;
 550         }
 551
 552 #ifdef CONFIG_BT_HCIUART_H4
 553         h4_init();
 554 #endif
 555 #ifdef CONFIG_BT_HCIUART_BCSP
 556         bcsp_init();
 557 #endif
 558
 559         return 0;
 560 }
 561
 562 static void __exit hci_uart_exit(void)
 563 {
 564         int err;
 565
 566 #ifdef CONFIG_BT_HCIUART_H4
 567         h4_deinit();
 568 #endif
 569 #ifdef CONFIG_BT_HCIUART_BCSP
 570         bcsp_deinit();
 571 #endif
 572
 573         /* Release tty registration of line discipline */
 574         if ((err = tty_register_ldisc(N_HCI, NULL)))
 575                 BT_ERR("Can't unregister HCI line discipline (%d)", err);
 576 }
 577
 578 module_init(hci_uart_init);
 579 module_exit(hci_uart_exit);
 580
 581 MODULE_AUTHOR("Maxim Krasnyansky <maxk@qualcomm.com>");
 582 MODULE_DESCRIPTION("Bluetooth HCI UART driver ver " VERSION);
 583 MODULE_VERSION(VERSION);
 584 MODULE_LICENSE("GPL");
 585 MODULE_ALIAS_LDISC(N_HCI);