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