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 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 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 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->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 116static 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 181static 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 218static 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 259static 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 */ 299static 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 319static 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 */ 342static DEFINE_MUTEX(irtty_mutex); 343 344/* notifier from sir_dev when irda% device gets opened (ifup) */ 345 346static 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 373static 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 401static 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 */ 421static 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 */ 471static 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 530out_put: 531 sirdev_put_instance(dev); 532out: 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 */ 543static 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 583static 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 600static 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 610static 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 620module_init(irtty_sir_init); 621module_exit(irtty_sir_cleanup); 622 623MODULE_AUTHOR("Dag Brattli <dagb@cs.uit.no>"); 624MODULE_DESCRIPTION("IrDA TTY device driver"); 625MODULE_ALIAS_LDISC(N_IRDA); 626MODULE_LICENSE("GPL"); 627