linux/drivers/net/irda/irtty-sir.c
<<
>>
Prefs
   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/slab.h>
  32#include <linux/tty.h>
  33#include <linux/init.h>
  34#include <asm/uaccess.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
  44static int qos_mtt_bits = 0x03;      /* 5 ms or more */
  45
  46module_param(qos_mtt_bits, int, 0);
  47MODULE_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
  60static 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 tty_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
  87static 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->ops->wait_until_sent) {
  97                tty->ops->wait_until_sent(tty, msecs_to_jiffies(100));
  98        }
  99        else {
 100                msleep(USBSERIAL_TX_DONE_DELAY);
 101        }
 102}
 103
 104/* 
 105 *  Function irtty_change_speed (dev, speed)
 106 *
 107 *    Change the speed of the serial port.
 108 *
 109 * This may sleep in set_termios (usbserial driver f.e.) and must
 110 * not be called from interrupt/timer/tasklet therefore.
 111 * All such invocations are deferred to kIrDAd now so we can sleep there.
 112 */
 113
 114static int irtty_change_speed(struct sir_dev *dev, unsigned speed)
 115{
 116        struct sirtty_cb *priv = dev->priv;
 117        struct tty_struct *tty;
 118        struct ktermios old_termios;
 119        int cflag;
 120
 121        IRDA_ASSERT(priv != NULL, return -1;);
 122        IRDA_ASSERT(priv->magic == IRTTY_MAGIC, return -1;);
 123
 124        tty = priv->tty;
 125
 126        mutex_lock(&tty->termios_mutex);
 127        old_termios = *(tty->termios);
 128        cflag = tty->termios->c_cflag;
 129        tty_encode_baud_rate(tty, speed, speed);
 130        if (tty->ops->set_termios)
 131                tty->ops->set_termios(tty, &old_termios);
 132        priv->io.speed = speed;
 133        mutex_unlock(&tty->termios_mutex);
 134
 135        return 0;
 136}
 137
 138/*
 139 * Function irtty_set_dtr_rts (dev, dtr, rts)
 140 *
 141 *    This function can be used by dongles etc. to set or reset the status
 142 *    of the dtr and rts lines
 143 */
 144
 145static int irtty_set_dtr_rts(struct sir_dev *dev, int dtr, int rts)
 146{
 147        struct sirtty_cb *priv = dev->priv;
 148        int set = 0;
 149        int clear = 0;
 150
 151        IRDA_ASSERT(priv != NULL, return -1;);
 152        IRDA_ASSERT(priv->magic == IRTTY_MAGIC, return -1;);
 153
 154        if (rts)
 155                set |= TIOCM_RTS;
 156        else
 157                clear |= TIOCM_RTS;
 158        if (dtr)
 159                set |= TIOCM_DTR;
 160        else
 161                clear |= TIOCM_DTR;
 162
 163        /*
 164         * We can't use ioctl() because it expects a non-null file structure,
 165         * and we don't have that here.
 166         * This function is not yet defined for all tty driver, so
 167         * let's be careful... Jean II
 168         */
 169        IRDA_ASSERT(priv->tty->ops->tiocmset != NULL, return -1;);
 170        priv->tty->ops->tiocmset(priv->tty, set, clear);
 171
 172        return 0;
 173}
 174
 175/* ------------------------------------------------------- */
 176
 177/* called from sir_dev when there is more data to send
 178 * context is either netdev->hard_xmit or some transmit-completion bh
 179 * i.e. we are under spinlock here and must not sleep.
 180 */
 181
 182static int irtty_do_write(struct sir_dev *dev, const unsigned char *ptr, size_t len)
 183{
 184        struct sirtty_cb *priv = dev->priv;
 185        struct tty_struct *tty;
 186        int writelen;
 187
 188        IRDA_ASSERT(priv != NULL, return -1;);
 189        IRDA_ASSERT(priv->magic == IRTTY_MAGIC, return -1;);
 190
 191        tty = priv->tty;
 192        if (!tty->ops->write)
 193                return 0;
 194        set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
 195        writelen = tty_write_room(tty);
 196        if (writelen > len)
 197                writelen = len;
 198        return tty->ops->write(tty, ptr, writelen);
 199}
 200
 201/* ------------------------------------------------------- */
 202
 203/* irda line discipline callbacks */
 204
 205/* 
 206 *  Function irtty_receive_buf( tty, cp, count)
 207 *
 208 *    Handle the 'receiver data ready' interrupt.  This function is called
 209 *    by the 'tty_io' module in the kernel when a block of IrDA data has
 210 *    been received, which can now be decapsulated and delivered for
 211 *    further processing 
 212 *
 213 * calling context depends on underlying driver and tty->low_latency!
 214 * for example (low_latency: 1 / 0):
 215 * serial.c:    uart-interrupt / softint
 216 * usbserial:   urb-complete-interrupt / softint
 217 */
 218
 219static void irtty_receive_buf(struct tty_struct *tty, const unsigned char *cp,
 220                              char *fp, int count) 
 221{
 222        struct sir_dev *dev;
 223        struct sirtty_cb *priv = tty->disc_data;
 224        int     i;
 225
 226        IRDA_ASSERT(priv != NULL, return;);
 227        IRDA_ASSERT(priv->magic == IRTTY_MAGIC, return;);
 228
 229        if (unlikely(count==0))         /* yes, this happens */
 230                return;
 231
 232        dev = priv->dev;
 233        if (!dev) {
 234                IRDA_WARNING("%s(), not ready yet!\n", __func__);
 235                return;
 236        }
 237
 238        for (i = 0; i < count; i++) {
 239                /* 
 240                 *  Characters received with a parity error, etc?
 241                 */
 242                if (fp && *fp++) { 
 243                        IRDA_DEBUG(0, "Framing or parity error!\n");
 244                        sirdev_receive(dev, NULL, 0);   /* notify sir_dev (updating stats) */
 245                        return;
 246                }
 247        }
 248
 249        sirdev_receive(dev, cp, count);
 250}
 251
 252/*
 253 * Function irtty_write_wakeup (tty)
 254 *
 255 *    Called by the driver when there's room for more data.  If we have
 256 *    more packets to send, we send them here.
 257 *
 258 */
 259static void irtty_write_wakeup(struct tty_struct *tty) 
 260{
 261        struct sirtty_cb *priv = tty->disc_data;
 262
 263        IRDA_ASSERT(priv != NULL, return;);
 264        IRDA_ASSERT(priv->magic == IRTTY_MAGIC, return;);
 265
 266        clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
 267        if (priv->dev)
 268                sirdev_write_complete(priv->dev);
 269}
 270
 271/* ------------------------------------------------------- */
 272
 273/*
 274 * Function irtty_stop_receiver (tty, stop)
 275 *
 276 */
 277
 278static inline void irtty_stop_receiver(struct tty_struct *tty, int stop)
 279{
 280        struct ktermios old_termios;
 281        int cflag;
 282
 283        mutex_lock(&tty->termios_mutex);
 284        old_termios = *(tty->termios);
 285        cflag = tty->termios->c_cflag;
 286        
 287        if (stop)
 288                cflag &= ~CREAD;
 289        else
 290                cflag |= CREAD;
 291
 292        tty->termios->c_cflag = cflag;
 293        if (tty->ops->set_termios)
 294                tty->ops->set_termios(tty, &old_termios);
 295        mutex_unlock(&tty->termios_mutex);
 296}
 297
 298/*****************************************************************/
 299
 300/* serialize ldisc open/close with sir_dev */
 301static DEFINE_MUTEX(irtty_mutex);
 302
 303/* notifier from sir_dev when irda% device gets opened (ifup) */
 304
 305static int irtty_start_dev(struct sir_dev *dev)
 306{
 307        struct sirtty_cb *priv;
 308        struct tty_struct *tty;
 309
 310        /* serialize with ldisc open/close */
 311        mutex_lock(&irtty_mutex);
 312
 313        priv = dev->priv;
 314        if (unlikely(!priv || priv->magic!=IRTTY_MAGIC)) {
 315                mutex_unlock(&irtty_mutex);
 316                return -ESTALE;
 317        }
 318
 319        tty = priv->tty;
 320
 321        if (tty->ops->start)
 322                tty->ops->start(tty);
 323        /* Make sure we can receive more data */
 324        irtty_stop_receiver(tty, FALSE);
 325
 326        mutex_unlock(&irtty_mutex);
 327        return 0;
 328}
 329
 330/* notifier from sir_dev when irda% device gets closed (ifdown) */
 331
 332static int irtty_stop_dev(struct sir_dev *dev)
 333{
 334        struct sirtty_cb *priv;
 335        struct tty_struct *tty;
 336
 337        /* serialize with ldisc open/close */
 338        mutex_lock(&irtty_mutex);
 339
 340        priv = dev->priv;
 341        if (unlikely(!priv || priv->magic!=IRTTY_MAGIC)) {
 342                mutex_unlock(&irtty_mutex);
 343                return -ESTALE;
 344        }
 345
 346        tty = priv->tty;
 347
 348        /* Make sure we don't receive more data */
 349        irtty_stop_receiver(tty, TRUE);
 350        if (tty->ops->stop)
 351                tty->ops->stop(tty);
 352
 353        mutex_unlock(&irtty_mutex);
 354
 355        return 0;
 356}
 357
 358/* ------------------------------------------------------- */
 359
 360static struct sir_driver sir_tty_drv = {
 361        .owner                  = THIS_MODULE,
 362        .driver_name            = "sir_tty",
 363        .start_dev              = irtty_start_dev,
 364        .stop_dev               = irtty_stop_dev,
 365        .do_write               = irtty_do_write,
 366        .chars_in_buffer        = irtty_chars_in_buffer,
 367        .wait_until_sent        = irtty_wait_until_sent,
 368        .set_speed              = irtty_change_speed,
 369        .set_dtr_rts            = irtty_set_dtr_rts,
 370};
 371
 372/* ------------------------------------------------------- */
 373
 374/*
 375 * Function irtty_ioctl (tty, file, cmd, arg)
 376 *
 377 *     The Swiss army knife of system calls :-)
 378 *
 379 */
 380static int irtty_ioctl(struct tty_struct *tty, struct file *file, unsigned int cmd, unsigned long arg)
 381{
 382        struct irtty_info { char name[6]; } info;
 383        struct sir_dev *dev;
 384        struct sirtty_cb *priv = tty->disc_data;
 385        int err = 0;
 386
 387        IRDA_ASSERT(priv != NULL, return -ENODEV;);
 388        IRDA_ASSERT(priv->magic == IRTTY_MAGIC, return -EBADR;);
 389
 390        IRDA_DEBUG(3, "%s(cmd=0x%X)\n", __func__, cmd);
 391
 392        dev = priv->dev;
 393        IRDA_ASSERT(dev != NULL, return -1;);
 394
 395        switch (cmd) {
 396        case IRTTY_IOCTDONGLE:
 397                /* this call blocks for completion */
 398                err = sirdev_set_dongle(dev, (IRDA_DONGLE) arg);
 399                break;
 400
 401        case IRTTY_IOCGET:
 402                IRDA_ASSERT(dev->netdev != NULL, return -1;);
 403
 404                memset(&info, 0, sizeof(info)); 
 405                strncpy(info.name, dev->netdev->name, sizeof(info.name)-1);
 406
 407                if (copy_to_user((void __user *)arg, &info, sizeof(info)))
 408                        err = -EFAULT;
 409                break;
 410        default:
 411                err = tty_mode_ioctl(tty, file, cmd, arg);
 412                break;
 413        }
 414        return err;
 415}
 416
 417
 418/* 
 419 *  Function irtty_open(tty)
 420 *
 421 *    This function is called by the TTY module when the IrDA line
 422 *    discipline is called for.  Because we are sure the tty line exists,
 423 *    we only have to link it to a free IrDA channel.  
 424 */
 425static int irtty_open(struct tty_struct *tty) 
 426{
 427        struct sir_dev *dev;
 428        struct sirtty_cb *priv;
 429        int ret = 0;
 430
 431        /* Module stuff handled via irda_ldisc.owner - Jean II */
 432
 433        /* First make sure we're not already connected. */
 434        if (tty->disc_data != NULL) {
 435                priv = tty->disc_data;
 436                if (priv && priv->magic == IRTTY_MAGIC) {
 437                        ret = -EEXIST;
 438                        goto out;
 439                }
 440                tty->disc_data = NULL;          /* ### */
 441        }
 442
 443        /* stop the underlying  driver */
 444        irtty_stop_receiver(tty, TRUE);
 445        if (tty->ops->stop)
 446                tty->ops->stop(tty);
 447
 448        tty_driver_flush_buffer(tty);
 449        
 450        /* apply mtt override */
 451        sir_tty_drv.qos_mtt_bits = qos_mtt_bits;
 452
 453        /* get a sir device instance for this driver */
 454        dev = sirdev_get_instance(&sir_tty_drv, tty->name);
 455        if (!dev) {
 456                ret = -ENODEV;
 457                goto out;
 458        }
 459
 460        /* allocate private device info block */
 461        priv = kzalloc(sizeof(*priv), GFP_KERNEL);
 462        if (!priv)
 463                goto out_put;
 464
 465        priv->magic = IRTTY_MAGIC;
 466        priv->tty = tty;
 467        priv->dev = dev;
 468
 469        /* serialize with start_dev - in case we were racing with ifup */
 470        mutex_lock(&irtty_mutex);
 471
 472        dev->priv = priv;
 473        tty->disc_data = priv;
 474        tty->receive_room = 65536;
 475
 476        mutex_unlock(&irtty_mutex);
 477
 478        IRDA_DEBUG(0, "%s - %s: irda line discipline opened\n", __func__, tty->name);
 479
 480        return 0;
 481
 482out_put:
 483        sirdev_put_instance(dev);
 484out:
 485        return ret;
 486}
 487
 488/* 
 489 *  Function irtty_close (tty)
 490 *
 491 *    Close down a IrDA channel. This means flushing out any pending queues,
 492 *    and then restoring the TTY line discipline to what it was before it got
 493 *    hooked to IrDA (which usually is TTY again).  
 494 */
 495static void irtty_close(struct tty_struct *tty) 
 496{
 497        struct sirtty_cb *priv = tty->disc_data;
 498
 499        IRDA_ASSERT(priv != NULL, return;);
 500        IRDA_ASSERT(priv->magic == IRTTY_MAGIC, return;);
 501
 502        /* Hm, with a dongle attached the dongle driver wants
 503         * to close the dongle - which requires the use of
 504         * some tty write and/or termios or ioctl operations.
 505         * Are we allowed to call those when already requested
 506         * to shutdown the ldisc?
 507         * If not, we should somehow mark the dev being staled.
 508         * Question remains, how to close the dongle in this case...
 509         * For now let's assume we are granted to issue tty driver calls
 510         * until we return here from the ldisc close. I'm just wondering
 511         * how this behaves with hotpluggable serial hardware like
 512         * rs232-pcmcia card or usb-serial...
 513         *
 514         * priv->tty = NULL?;
 515         */
 516
 517        /* we are dead now */
 518        tty->disc_data = NULL;
 519
 520        sirdev_put_instance(priv->dev);
 521
 522        /* Stop tty */
 523        irtty_stop_receiver(tty, TRUE);
 524        clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
 525        if (tty->ops->stop)
 526                tty->ops->stop(tty);
 527
 528        kfree(priv);
 529
 530        IRDA_DEBUG(0, "%s - %s: irda line discipline closed\n", __func__, tty->name);
 531}
 532
 533/* ------------------------------------------------------- */
 534
 535static struct tty_ldisc_ops irda_ldisc = {
 536        .magic          = TTY_LDISC_MAGIC,
 537        .name           = "irda",
 538        .flags          = 0,
 539        .open           = irtty_open,
 540        .close          = irtty_close,
 541        .read           = NULL,
 542        .write          = NULL,
 543        .ioctl          = irtty_ioctl,
 544        .poll           = NULL,
 545        .receive_buf    = irtty_receive_buf,
 546        .write_wakeup   = irtty_write_wakeup,
 547        .owner          = THIS_MODULE,
 548};
 549
 550/* ------------------------------------------------------- */
 551
 552static int __init irtty_sir_init(void)
 553{
 554        int err;
 555
 556        if ((err = tty_register_ldisc(N_IRDA, &irda_ldisc)) != 0)
 557                IRDA_ERROR("IrDA: can't register line discipline (err = %d)\n",
 558                           err);
 559        return err;
 560}
 561
 562static void __exit irtty_sir_cleanup(void) 
 563{
 564        int err;
 565
 566        if ((err = tty_unregister_ldisc(N_IRDA))) {
 567                IRDA_ERROR("%s(), can't unregister line discipline (err = %d)\n",
 568                           __func__, err);
 569        }
 570}
 571
 572module_init(irtty_sir_init);
 573module_exit(irtty_sir_cleanup);
 574
 575MODULE_AUTHOR("Dag Brattli <dagb@cs.uit.no>");
 576MODULE_DESCRIPTION("IrDA TTY device driver");
 577MODULE_ALIAS_LDISC(N_IRDA);
 578MODULE_LICENSE("GPL");
 579
 580