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  * BlueZ 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/version.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 HCI_UART_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         tty_ldisc_flush(tty);
 192
 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, 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         MOD_DEC_USE_COUNT;
 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         tty_ldisc_flush(tty);
 288
 289         if (tty->driver.flush_buffer)
 290                 tty->driver.flush_buffer(tty);
 291
 292         MOD_INC_USE_COUNT;
 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                 }
 318
 319                 MOD_DEC_USE_COUNT;
 320         }
 321 }
 322
 323 /* hci_uart_tty_wakeup()
 324  *
 325  *    Callback for transmit wakeup. Called when low level
 326  *    device driver can accept more send data.
 327  *
 328  * Arguments:        tty    pointer to associated tty instance data
 329  * Return Value:    None
 330  */
 331 static void hci_uart_tty_wakeup(struct tty_struct *tty)
 332 {
 333         struct hci_uart *hu = (void *)tty->disc_data;
 334
 335         BT_DBG("");
 336
 337         if (!hu)
 338                 return;
 339
 340         clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
 341
 342         if (tty != hu->tty)
 343                 return;
 344
 345         if (test_bit(HCI_UART_PROTO_SET, &hu->flags))
 346                 hci_uart_tx_wakeup(hu);
 347 }
 348
 349 /* hci_uart_tty_room()
 350  *
 351  *    Callback function from tty driver. Return the amount of
 352  *    space left in the receiver's buffer to decide if remote
 353  *    transmitter is to be throttled.
 354  *
 355  * Arguments:        tty    pointer to associated tty instance data
 356  * Return Value:    number of bytes left in receive buffer
 357  */
 358 static int hci_uart_tty_room (struct tty_struct *tty)
 359 {
 360         return 65536;
 361 }
 362
 363 /* hci_uart_tty_receive()
 364  *
 365  *     Called by tty low level driver when receive data is
 366  *     available.
 367  *
 368  * Arguments:  tty          pointer to tty isntance data
 369  *             data         pointer to received data
 370  *             flags        pointer to flags for data
 371  *             count        count of received data in bytes
 372  *
 373  * Return Value:    None
 374  */
 375 static void hci_uart_tty_receive(struct tty_struct *tty, const __u8 *data, char *flags, int count)
 376 {
 377         struct hci_uart *hu = (void *)tty->disc_data;
 378
 379         if (!hu || tty != hu->tty)
 380                 return;
 381
 382         if (!test_bit(HCI_UART_PROTO_SET, &hu->flags))
 383                 return;
 384
 385         spin_lock(&hu->rx_lock);
 386         hu->proto->recv(hu, (void *) data, count);
 387         hu->hdev.stat.byte_rx += count;
 388         spin_unlock(&hu->rx_lock);
 389
 390         if (test_and_clear_bit(TTY_THROTTLED,&tty->flags) && tty->driver.unthrottle)
 391                 tty->driver.unthrottle(tty);
 392 }
 393
 394 static int hci_uart_register_dev(struct hci_uart *hu)
 395 {
 396         struct hci_dev *hdev;
 397
 398         BT_DBG("");
 399
 400         /* Initialize and register HCI device */
 401         hdev = &hu->hdev;
 402
 403         hdev->type = HCI_UART;
 404         hdev->driver_data = hu;
 405
 406         hdev->open  = hci_uart_open;
 407         hdev->close = hci_uart_close;
 408         hdev->flush = hci_uart_flush;
 409         hdev->send  = hci_uart_send_frame;
 410         hdev->destruct = hci_uart_destruct;
 411
 412         if (hci_register_dev(hdev) < 0) {
 413                 BT_ERR("Can't register HCI device %s", hdev->name);
 414                 return -ENODEV;
 415         }
 416         MOD_INC_USE_COUNT;
 417         return 0;
 418 }
 419
 420 static int hci_uart_set_proto(struct hci_uart *hu, int id)
 421 {
 422         struct hci_uart_proto *p;
 423         int err;
 424
 425         p = hci_uart_get_proto(id);
 426         if (!p)
 427                 return -EPROTONOSUPPORT;
 428
 429         err = p->open(hu);
 430         if (err)
 431                 return err;
 432
 433         hu->proto = p;
 434
 435         err = hci_uart_register_dev(hu);
 436         if (err) {
 437                 p->close(hu);
 438                 return err;
 439         }
 440         return 0;
 441 }
 442
 443 /* hci_uart_tty_ioctl()
 444  *
 445  *    Process IOCTL system call for the tty device.
 446  *
 447  * Arguments:
 448  *
 449  *    tty        pointer to tty instance data
 450  *    file       pointer to open file object for device
 451  *    cmd        IOCTL command code
 452  *    arg        argument for IOCTL call (cmd dependent)
 453  *
 454  * Return Value:    Command dependent
 455  */
 456 static int hci_uart_tty_ioctl(struct tty_struct *tty, struct file * file,
 457                             unsigned int cmd, unsigned long arg)
 458 {
 459         struct hci_uart *hu = (void *)tty->disc_data;
 460         int err = 0;
 461
 462         BT_DBG("");
 463
 464         /* Verify the status of the device */
 465         if (!hu)
 466                 return -EBADF;
 467
 468         switch (cmd) {
 469         case HCIUARTSETPROTO:
 470                 if (!test_and_set_bit(HCI_UART_PROTO_SET, &hu->flags)) {
 471                         err = hci_uart_set_proto(hu, arg);
 472                         if (err) {
 473                                 clear_bit(HCI_UART_PROTO_SET, &hu->flags);
 474                                 return err;
 475                         }
 476                         tty->low_latency = 1;
 477                 } else
 478                         return -EBUSY;
 479
 480         case HCIUARTGETPROTO:
 481                 if (test_bit(HCI_UART_PROTO_SET, &hu->flags))
 482                         return hu->proto->id;
 483                 return -EUNATCH;
 484
 485         default:
 486                 err = n_tty_ioctl(tty, file, cmd, arg);
 487                 break;
 488         };
 489
 490         return err;
 491 }
 492
 493 /*
 494  * We don't provide read/write/poll interface for user space.
 495  */
 496 static ssize_t hci_uart_tty_read(struct tty_struct *tty, struct file *file, unsigned char *buf, size_t nr)
 497 {
 498         return 0;
 499 }
 500 static ssize_t hci_uart_tty_write(struct tty_struct *tty, struct file *file, const unsigned char *data, size_t count)
 501 {
 502         return 0;
 503 }
 504 static unsigned int hci_uart_tty_poll(struct tty_struct *tty, struct file *filp, poll_table *wait)
 505 {
 506         return 0;
 507 }
 508
 509 #ifdef CONFIG_BLUEZ_HCIUART_H4
 510 int h4_init(void);
 511 int h4_deinit(void);
 512 #endif
 513 #ifdef CONFIG_BLUEZ_HCIUART_BCSP
 514 int bcsp_init(void);
 515 int bcsp_deinit(void);
 516 #endif
 517
 518 int __init hci_uart_init(void)
 519 {
 520         static struct tty_ldisc hci_uart_ldisc;
 521         int err;
 522
 523         BT_INFO("BlueZ HCI UART driver ver %s Copyright (C) 2000,2001 Qualcomm Inc",
 524                 VERSION);
 525         BT_INFO("Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>");
 526
 527         /* Register the tty discipline */
 528
 529         memset(&hci_uart_ldisc, 0, sizeof (hci_uart_ldisc));
 530         hci_uart_ldisc.magic       = TTY_LDISC_MAGIC;
 531         hci_uart_ldisc.name        = "n_hci";
 532         hci_uart_ldisc.open        = hci_uart_tty_open;
 533         hci_uart_ldisc.close       = hci_uart_tty_close;
 534         hci_uart_ldisc.read        = hci_uart_tty_read;
 535         hci_uart_ldisc.write       = hci_uart_tty_write;
 536         hci_uart_ldisc.ioctl       = hci_uart_tty_ioctl;
 537         hci_uart_ldisc.poll        = hci_uart_tty_poll;
 538         hci_uart_ldisc.receive_room= hci_uart_tty_room;
 539         hci_uart_ldisc.receive_buf = hci_uart_tty_receive;
 540         hci_uart_ldisc.write_wakeup= hci_uart_tty_wakeup;
 541
 542         if ((err = tty_register_ldisc(N_HCI, &hci_uart_ldisc))) {
 543                 BT_ERR("Can't register HCI line discipline (%d)", err);
 544                 return err;
 545         }
 546
 547 #ifdef CONFIG_BLUEZ_HCIUART_H4
 548         h4_init();
 549 #endif
 550 #ifdef CONFIG_BLUEZ_HCIUART_BCSP
 551         bcsp_init();
 552 #endif
 553
 554         return 0;
 555 }
 556
 557 void hci_uart_cleanup(void)
 558 {
 559         int err;
 560
 561 #ifdef CONFIG_BLUEZ_HCIUART_H4
 562         h4_deinit();
 563 #endif
 564 #ifdef CONFIG_BLUEZ_HCIUART_BCSP
 565         bcsp_deinit();
 566 #endif
 567
 568         /* Release tty registration of line discipline */
 569         if ((err = tty_register_ldisc(N_HCI, NULL)))
 570                 BT_ERR("Can't unregister HCI line discipline (%d)", err);
 571 }
 572
 573 module_init(hci_uart_init);
 574 module_exit(hci_uart_cleanup);
 575
 576 MODULE_AUTHOR("Maxim Krasnyansky <maxk@qualcomm.com>");
 577 MODULE_DESCRIPTION("BlueZ HCI UART driver ver " VERSION);
 578 MODULE_LICENSE("GPL");