drivers/net/irda/irtty-sir.c

   1 /*********************************************************************
   2  *
   3  * Filename:      irtty-sir.c
   4  * Version:       2.0
   5  * Description:   IrDA line discipline implementation
   6  * Status:        Experimental.
   7  * Author:        Dag Brattli <dagb@cs.uit.no>
   8  * Created at:    Tue Dec  9 21:18:38 1997
   9  * Modified at:   Sun Oct 27 22:13:30 2002
  10  * Modified by:   Martin Diehl <mad@mdiehl.de>
  11  * Sources:       slip.c by Laurence Culhane,   <loz@holmes.demon.co.uk>
  12  *                          Fred N. van Kempen, <waltje@uwalt.nl.mugnet.org>
  13  *
  14  *     Copyright (c) 1998-2000 Dag Brattli,
  15  *     Copyright (c) 2002 Martin Diehl,
  16  *     All Rights Reserved.
  17  *
  18  *     This program is free software; you can redistribute it and/or
  19  *     modify it under the terms of the GNU General Public License as
  20  *     published by the Free Software Foundation; either version 2 of
  21  *     the License, or (at your option) any later version.
  22  *
  23  *     Neither Dag Brattli nor University of Tromsø admit liability nor
  24  *     provide warranty for any of this software. This material is
  25  *     provided "AS-IS" and at no charge.
  26  *
  27  ********************************************************************/
  28
  29 #include <linux/module.h>
  30 #include <linux/kernel.h>
  31 #include <linux/tty.h>
  32 #include <linux/init.h>
  33 #include <asm/uaccess.h>
  34 #include <linux/smp_lock.h>
  35 #include <linux/delay.h>
  36 #include <linux/mutex.h>
  37
  38 #include <net/irda/irda.h>
  39 #include <net/irda/irda_device.h>
  40
  41 #include "sir-dev.h"
  42 #include "irtty-sir.h"
  43
  44 static int qos_mtt_bits = 0x03;      /* 5 ms or more */
  45
  46 module_param(qos_mtt_bits, int, 0);
  47 MODULE_PARM_DESC(qos_mtt_bits, "Minimum Turn Time");
  48
  49 /* ------------------------------------------------------- */
  50
  51 /* device configuration callbacks always invoked with irda-thread context */
  52
  53 /* find out, how many chars we have in buffers below us
  54  * this is allowed to lie, i.e. return less chars than we
  55  * actually have. The returned value is used to determine
  56  * how long the irdathread should wait before doing the
  57  * real blocking wait_until_sent()
  58  */
  59
  60 static int irtty_chars_in_buffer(struct sir_dev *dev)
  61 {
  62         struct sirtty_cb *priv = dev->priv;
  63
  64         IRDA_ASSERT(priv != NULL, return -1;);
  65         IRDA_ASSERT(priv->magic == IRTTY_MAGIC, return -1;);
  66
  67         return priv->tty->driver->chars_in_buffer(priv->tty);
  68 }
  69
  70 /* Wait (sleep) until underlaying hardware finished transmission
  71  * i.e. hardware buffers are drained
  72  * this must block and not return before all characters are really sent
  73  *
  74  * If the tty sits on top of a 16550A-like uart, there are typically
  75  * up to 16 bytes in the fifo - f.e. 9600 bps 8N1 needs 16.7 msec
  76  *
  77  * With usbserial the uart-fifo is basically replaced by the converter's
  78  * outgoing endpoint buffer, which can usually hold 64 bytes (at least).
  79  * With pl2303 it appears we are safe with 60msec here.
  80  *
  81  * I really wish all serial drivers would provide
  82  * correct implementation of wait_until_sent()
  83  */
  84
  85 #define USBSERIAL_TX_DONE_DELAY 60
  86
  87 static void irtty_wait_until_sent(struct sir_dev *dev)
  88 {
  89         struct sirtty_cb *priv = dev->priv;
  90         struct tty_struct *tty;
  91
  92         IRDA_ASSERT(priv != NULL, return;);
  93         IRDA_ASSERT(priv->magic == IRTTY_MAGIC, return;);
  94
  95         tty = priv->tty;
  96         if (tty->driver->wait_until_sent) {
  97                 lock_kernel();
  98                 tty->driver->wait_until_sent(tty, msecs_to_jiffies(100));
  99                 unlock_kernel();
 100         }
 101         else {
 102                 msleep(USBSERIAL_TX_DONE_DELAY);
 103         }
 104 }
 105
 106 /*
 107  *  Function irtty_change_speed (dev, speed)
 108  *
 109  *    Change the speed of the serial port.
 110  *
 111  * This may sleep in set_termios (usbserial driver f.e.) and must
 112  * not be called from interrupt/timer/tasklet therefore.
 113  * All such invocations are deferred to kIrDAd now so we can sleep there.
 114  */
 115
 116 static int irtty_change_speed(struct sir_dev *dev, unsigned speed)
 117 {
 118         struct sirtty_cb *priv = dev->priv;
 119         struct tty_struct *tty;
 120         struct ktermios old_termios;
 121         int cflag;
 122
 123         IRDA_ASSERT(priv != NULL, return -1;);
 124         IRDA_ASSERT(priv->magic == IRTTY_MAGIC, return -1;);
 125
 126         tty = priv->tty;
 127
 128         lock_kernel();
 129         old_termios = *(tty->termios);
 130         cflag = tty->termios->c_cflag;
 131
 132         cflag &= ~CBAUD;
 133
 134         IRDA_DEBUG(2, "%s(), Setting speed to %d\n", __FUNCTION__, speed);
 135
 136         switch (speed) {
 137         case 1200:
 138                 cflag |= B1200;
 139                 break;
 140         case 2400:
 141                 cflag |= B2400;
 142                 break;
 143         case 4800:
 144                 cflag |= B4800;
 145                 break;
 146         case 19200:
 147                 cflag |= B19200;
 148                 break;
 149         case 38400:
 150                 cflag |= B38400;
 151                 break;
 152         case 57600:
 153                 cflag |= B57600;
 154                 break;
 155         case 115200:
 156                 cflag |= B115200;
 157                 break;
 158         case 9600:
 159         default:
 160                 cflag |= B9600;
 161                 break;
 162         }
 163
 164         tty->termios->c_cflag = cflag;
 165         if (tty->driver->set_termios)
 166                 tty->driver->set_termios(tty, &old_termios);
 167         unlock_kernel();
 168
 169         priv->io.speed = speed;
 170
 171         return 0;
 172 }
 173
 174 /*
 175  * Function irtty_set_dtr_rts (dev, dtr, rts)
 176  *
 177  *    This function can be used by dongles etc. to set or reset the status
 178  *    of the dtr and rts lines
 179  */
 180
 181 static int irtty_set_dtr_rts(struct sir_dev *dev, int dtr, int rts)
 182 {
 183         struct sirtty_cb *priv = dev->priv;
 184         int set = 0;
 185         int clear = 0;
 186
 187         IRDA_ASSERT(priv != NULL, return -1;);
 188         IRDA_ASSERT(priv->magic == IRTTY_MAGIC, return -1;);
 189
 190         if (rts)
 191                 set |= TIOCM_RTS;
 192         else
 193                 clear |= TIOCM_RTS;
 194         if (dtr)
 195                 set |= TIOCM_DTR;
 196         else
 197                 clear |= TIOCM_DTR;
 198
 199         /*
 200          * We can't use ioctl() because it expects a non-null file structure,
 201          * and we don't have that here.
 202          * This function is not yet defined for all tty driver, so
 203          * let's be careful... Jean II
 204          */
 205         IRDA_ASSERT(priv->tty->driver->tiocmset != NULL, return -1;);
 206         priv->tty->driver->tiocmset(priv->tty, NULL, set, clear);
 207
 208         return 0;
 209 }
 210
 211 /* ------------------------------------------------------- */
 212
 213 /* called from sir_dev when there is more data to send
 214  * context is either netdev->hard_xmit or some transmit-completion bh
 215  * i.e. we are under spinlock here and must not sleep.
 216  */
 217
 218 static int irtty_do_write(struct sir_dev *dev, const unsigned char *ptr, size_t len)
 219 {
 220         struct sirtty_cb *priv = dev->priv;
 221         struct tty_struct *tty;
 222         int writelen;
 223
 224         IRDA_ASSERT(priv != NULL, return -1;);
 225         IRDA_ASSERT(priv->magic == IRTTY_MAGIC, return -1;);
 226
 227         tty = priv->tty;
 228         if (!tty->driver->write)
 229                 return 0;
 230         tty->flags |= (1 << TTY_DO_WRITE_WAKEUP);
 231         if (tty->driver->write_room) {
 232                 writelen = tty->driver->write_room(tty);
 233                 if (writelen > len)
 234                         writelen = len;
 235         }
 236         else
 237                 writelen = len;
 238         return tty->driver->write(tty, ptr, writelen);
 239 }
 240
 241 /* ------------------------------------------------------- */
 242
 243 /* irda line discipline callbacks */
 244
 245 /*
 246  *  Function irtty_receive_buf( tty, cp, count)
 247  *
 248  *    Handle the 'receiver data ready' interrupt.  This function is called
 249  *    by the 'tty_io' module in the kernel when a block of IrDA data has
 250  *    been received, which can now be decapsulated and delivered for
 251  *    further processing
 252  *
 253  * calling context depends on underlying driver and tty->low_latency!
 254  * for example (low_latency: 1 / 0):
 255  * serial.c:    uart-interrupt / softint
 256  * usbserial:   urb-complete-interrupt / softint
 257  */
 258
 259 static void irtty_receive_buf(struct tty_struct *tty, const unsigned char *cp,
 260                               char *fp, int count)
 261 {
 262         struct sir_dev *dev;
 263         struct sirtty_cb *priv = tty->disc_data;
 264         int     i;
 265
 266         IRDA_ASSERT(priv != NULL, return;);
 267         IRDA_ASSERT(priv->magic == IRTTY_MAGIC, return;);
 268
 269         if (unlikely(count==0))         /* yes, this happens */
 270                 return;
 271
 272         dev = priv->dev;
 273         if (!dev) {
 274                 IRDA_WARNING("%s(), not ready yet!\n", __FUNCTION__);
 275                 return;
 276         }
 277
 278         for (i = 0; i < count; i++) {
 279                 /*
 280                  *  Characters received with a parity error, etc?
 281                  */
 282                 if (fp && *fp++) {
 283                         IRDA_DEBUG(0, "Framing or parity error!\n");
 284                         sirdev_receive(dev, NULL, 0);   /* notify sir_dev (updating stats) */
 285                         return;
 286                 }
 287         }
 288
 289         sirdev_receive(dev, cp, count);
 290 }
 291
 292 /*
 293  * Function irtty_write_wakeup (tty)
 294  *
 295  *    Called by the driver when there's room for more data.  If we have
 296  *    more packets to send, we send them here.
 297  *
 298  */
 299 static void irtty_write_wakeup(struct tty_struct *tty)
 300 {
 301         struct sirtty_cb *priv = tty->disc_data;
 302
 303         IRDA_ASSERT(priv != NULL, return;);
 304         IRDA_ASSERT(priv->magic == IRTTY_MAGIC, return;);
 305
 306         tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP);
 307
 308         if (priv->dev)
 309                 sirdev_write_complete(priv->dev);
 310 }
 311
 312 /* ------------------------------------------------------- */
 313
 314 /*
 315  * Function irtty_stop_receiver (tty, stop)
 316  *
 317  */
 318
 319 static inline void irtty_stop_receiver(struct tty_struct *tty, int stop)
 320 {
 321         struct ktermios old_termios;
 322         int cflag;
 323
 324         lock_kernel();
 325         old_termios = *(tty->termios);
 326         cflag = tty->termios->c_cflag;
 327
 328         if (stop)
 329                 cflag &= ~CREAD;
 330         else
 331                 cflag |= CREAD;
 332
 333         tty->termios->c_cflag = cflag;
 334         if (tty->driver->set_termios)
 335                 tty->driver->set_termios(tty, &old_termios);
 336         unlock_kernel();
 337 }
 338
 339 /*****************************************************************/
 340
 341 /* serialize ldisc open/close with sir_dev */
 342 static DEFINE_MUTEX(irtty_mutex);
 343
 344 /* notifier from sir_dev when irda% device gets opened (ifup) */
 345
 346 static int irtty_start_dev(struct sir_dev *dev)
 347 {
 348         struct sirtty_cb *priv;
 349         struct tty_struct *tty;
 350
 351         /* serialize with ldisc open/close */
 352         mutex_lock(&irtty_mutex);
 353
 354         priv = dev->priv;
 355         if (unlikely(!priv || priv->magic!=IRTTY_MAGIC)) {
 356                 mutex_unlock(&irtty_mutex);
 357                 return -ESTALE;
 358         }
 359
 360         tty = priv->tty;
 361
 362         if (tty->driver->start)
 363                 tty->driver->start(tty);
 364         /* Make sure we can receive more data */
 365         irtty_stop_receiver(tty, FALSE);
 366
 367         mutex_unlock(&irtty_mutex);
 368         return 0;
 369 }
 370
 371 /* notifier from sir_dev when irda% device gets closed (ifdown) */
 372
 373 static int irtty_stop_dev(struct sir_dev *dev)
 374 {
 375         struct sirtty_cb *priv;
 376         struct tty_struct *tty;
 377
 378         /* serialize with ldisc open/close */
 379         mutex_lock(&irtty_mutex);
 380
 381         priv = dev->priv;
 382         if (unlikely(!priv || priv->magic!=IRTTY_MAGIC)) {
 383                 mutex_unlock(&irtty_mutex);
 384                 return -ESTALE;
 385         }
 386
 387         tty = priv->tty;
 388
 389         /* Make sure we don't receive more data */
 390         irtty_stop_receiver(tty, TRUE);
 391         if (tty->driver->stop)
 392                 tty->driver->stop(tty);
 393
 394         mutex_unlock(&irtty_mutex);
 395
 396         return 0;
 397 }
 398
 399 /* ------------------------------------------------------- */
 400
 401 static struct sir_driver sir_tty_drv = {
 402         .owner                  = THIS_MODULE,
 403         .driver_name            = "sir_tty",
 404         .start_dev              = irtty_start_dev,
 405         .stop_dev               = irtty_stop_dev,
 406         .do_write               = irtty_do_write,
 407         .chars_in_buffer        = irtty_chars_in_buffer,
 408         .wait_until_sent        = irtty_wait_until_sent,
 409         .set_speed              = irtty_change_speed,
 410         .set_dtr_rts            = irtty_set_dtr_rts,
 411 };
 412
 413 /* ------------------------------------------------------- */
 414
 415 /*
 416  * Function irtty_ioctl (tty, file, cmd, arg)
 417  *
 418  *     The Swiss army knife of system calls :-)
 419  *
 420  */
 421 static int irtty_ioctl(struct tty_struct *tty, struct file *file, unsigned int cmd, unsigned long arg)
 422 {
 423         struct irtty_info { char name[6]; } info;
 424         struct sir_dev *dev;
 425         struct sirtty_cb *priv = tty->disc_data;
 426         int err = 0;
 427
 428         IRDA_ASSERT(priv != NULL, return -ENODEV;);
 429         IRDA_ASSERT(priv->magic == IRTTY_MAGIC, return -EBADR;);
 430
 431         IRDA_DEBUG(3, "%s(cmd=0x%X)\n", __FUNCTION__, cmd);
 432
 433         dev = priv->dev;
 434         IRDA_ASSERT(dev != NULL, return -1;);
 435
 436         switch (cmd) {
 437         case TCGETS:
 438         case TCGETA:
 439                 err = n_tty_ioctl(tty, file, cmd, arg);
 440                 break;
 441
 442         case IRTTY_IOCTDONGLE:
 443                 /* this call blocks for completion */
 444                 err = sirdev_set_dongle(dev, (IRDA_DONGLE) arg);
 445                 break;
 446
 447         case IRTTY_IOCGET:
 448                 IRDA_ASSERT(dev->netdev != NULL, return -1;);
 449
 450                 memset(&info, 0, sizeof(info));
 451                 strncpy(info.name, dev->netdev->name, sizeof(info.name)-1);
 452
 453                 if (copy_to_user((void __user *)arg, &info, sizeof(info)))
 454                         err = -EFAULT;
 455                 break;
 456         default:
 457                 err = -ENOIOCTLCMD;
 458                 break;
 459         }
 460         return err;
 461 }
 462
 463
 464 /*
 465  *  Function irtty_open(tty)
 466  *
 467  *    This function is called by the TTY module when the IrDA line
 468  *    discipline is called for.  Because we are sure the tty line exists,
 469  *    we only have to link it to a free IrDA channel.
 470  */
 471 static int irtty_open(struct tty_struct *tty)
 472 {
 473         struct sir_dev *dev;
 474         struct sirtty_cb *priv;
 475         int ret = 0;
 476
 477         /* Module stuff handled via irda_ldisc.owner - Jean II */
 478
 479         /* First make sure we're not already connected. */
 480         if (tty->disc_data != NULL) {
 481                 priv = tty->disc_data;
 482                 if (priv && priv->magic == IRTTY_MAGIC) {
 483                         ret = -EEXIST;
 484                         goto out;
 485                 }
 486                 tty->disc_data = NULL;          /* ### */
 487         }
 488
 489         /* stop the underlying  driver */
 490         irtty_stop_receiver(tty, TRUE);
 491         if (tty->driver->stop)
 492                 tty->driver->stop(tty);
 493
 494         if (tty->driver->flush_buffer)
 495                 tty->driver->flush_buffer(tty);
 496
 497         /* apply mtt override */
 498         sir_tty_drv.qos_mtt_bits = qos_mtt_bits;
 499
 500         /* get a sir device instance for this driver */
 501         dev = sirdev_get_instance(&sir_tty_drv, tty->name);
 502         if (!dev) {
 503                 ret = -ENODEV;
 504                 goto out;
 505         }
 506
 507         /* allocate private device info block */
 508         priv = kmalloc(sizeof(*priv), GFP_KERNEL);
 509         if (!priv)
 510                 goto out_put;
 511         memset(priv, 0, sizeof(*priv));
 512
 513         priv->magic = IRTTY_MAGIC;
 514         priv->tty = tty;
 515         priv->dev = dev;
 516
 517         /* serialize with start_dev - in case we were racing with ifup */
 518         mutex_lock(&irtty_mutex);
 519
 520         dev->priv = priv;
 521         tty->disc_data = priv;
 522         tty->receive_room = 65536;
 523
 524         mutex_unlock(&irtty_mutex);
 525
 526         IRDA_DEBUG(0, "%s - %s: irda line discipline opened\n", __FUNCTION__, tty->name);
 527
 528         return 0;
 529
 530 out_put:
 531         sirdev_put_instance(dev);
 532 out:
 533         return ret;
 534 }
 535
 536 /*
 537  *  Function irtty_close (tty)
 538  *
 539  *    Close down a IrDA channel. This means flushing out any pending queues,
 540  *    and then restoring the TTY line discipline to what it was before it got
 541  *    hooked to IrDA (which usually is TTY again).
 542  */
 543 static void irtty_close(struct tty_struct *tty)
 544 {
 545         struct sirtty_cb *priv = tty->disc_data;
 546
 547         IRDA_ASSERT(priv != NULL, return;);
 548         IRDA_ASSERT(priv->magic == IRTTY_MAGIC, return;);
 549
 550         /* Hm, with a dongle attached the dongle driver wants
 551          * to close the dongle - which requires the use of
 552          * some tty write and/or termios or ioctl operations.
 553          * Are we allowed to call those when already requested
 554          * to shutdown the ldisc?
 555          * If not, we should somehow mark the dev being staled.
 556          * Question remains, how to close the dongle in this case...
 557          * For now let's assume we are granted to issue tty driver calls
 558          * until we return here from the ldisc close. I'm just wondering
 559          * how this behaves with hotpluggable serial hardware like
 560          * rs232-pcmcia card or usb-serial...
 561          *
 562          * priv->tty = NULL?;
 563          */
 564
 565         /* we are dead now */
 566         tty->disc_data = NULL;
 567
 568         sirdev_put_instance(priv->dev);
 569
 570         /* Stop tty */
 571         irtty_stop_receiver(tty, TRUE);
 572         tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP);
 573         if (tty->driver->stop)
 574                 tty->driver->stop(tty);
 575
 576         kfree(priv);
 577
 578         IRDA_DEBUG(0, "%s - %s: irda line discipline closed\n", __FUNCTION__, tty->name);
 579 }
 580
 581 /* ------------------------------------------------------- */
 582
 583 static struct tty_ldisc irda_ldisc = {
 584         .magic          = TTY_LDISC_MAGIC,
 585         .name           = "irda",
 586         .flags          = 0,
 587         .open           = irtty_open,
 588         .close          = irtty_close,
 589         .read           = NULL,
 590         .write          = NULL,
 591         .ioctl          = irtty_ioctl,
 592         .poll           = NULL,
 593         .receive_buf    = irtty_receive_buf,
 594         .write_wakeup   = irtty_write_wakeup,
 595         .owner          = THIS_MODULE,
 596 };
 597
 598 /* ------------------------------------------------------- */
 599
 600 static int __init irtty_sir_init(void)
 601 {
 602         int err;
 603
 604         if ((err = tty_register_ldisc(N_IRDA, &irda_ldisc)) != 0)
 605                 IRDA_ERROR("IrDA: can't register line discipline (err = %d)\n",
 606                            err);
 607         return err;
 608 }
 609
 610 static void __exit irtty_sir_cleanup(void)
 611 {
 612         int err;
 613
 614         if ((err = tty_unregister_ldisc(N_IRDA))) {
 615                 IRDA_ERROR("%s(), can't unregister line discipline (err = %d)\n",
 616                            __FUNCTION__, err);
 617         }
 618 }
 619
 620 module_init(irtty_sir_init);
 621 module_exit(irtty_sir_cleanup);
 622
 623 MODULE_AUTHOR("Dag Brattli <dagb@cs.uit.no>");
 624 MODULE_DESCRIPTION("IrDA TTY device driver");
 625 MODULE_ALIAS_LDISC(N_IRDA);
 626 MODULE_LICENSE("GPL");
 627