1/********************************************************************* 2 * 3 * Filename: ircomm_tty.c 4 * Version: 1.0 5 * Description: IrCOMM serial TTY driver 6 * Status: Experimental. 7 * Author: Dag Brattli <dagb@cs.uit.no> 8 * Created at: Sun Jun 6 21:00:56 1999 9 * Modified at: Wed Feb 23 00:09:02 2000 10 * Modified by: Dag Brattli <dagb@cs.uit.no> 11 * Sources: serial.c and previous IrCOMM work by Takahide Higuchi 12 * 13 * Copyright (c) 1999-2000 Dag Brattli, All Rights Reserved. 14 * Copyright (c) 2000-2003 Jean Tourrilhes <jt@hpl.hp.com> 15 * 16 * This program is free software; you can redistribute it and/or 17 * modify it under the terms of the GNU General Public License as 18 * published by the Free Software Foundation; either version 2 of 19 * the License, or (at your option) any later version. 20 * 21 * This program is distributed in the hope that it will be useful, 22 * but WITHOUT ANY WARRANTY; without even the implied warranty of 23 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 24 * GNU General Public License for more details. 25 * 26 * You should have received a copy of the GNU General Public License 27 * along with this program; if not, write to the Free Software 28 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, 29 * MA 02111-1307 USA 30 * 31 ********************************************************************/ 32 33#include <linux/init.h> 34#include <linux/module.h> 35#include <linux/fs.h> 36#include <linux/slab.h> 37#include <linux/sched.h> 38#include <linux/seq_file.h> 39#include <linux/termios.h> 40#include <linux/tty.h> 41#include <linux/interrupt.h> 42#include <linux/device.h> /* for MODULE_ALIAS_CHARDEV_MAJOR */ 43 44#include <asm/uaccess.h> 45 46#include <net/irda/irda.h> 47#include <net/irda/irmod.h> 48 49#include <net/irda/ircomm_core.h> 50#include <net/irda/ircomm_param.h> 51#include <net/irda/ircomm_tty_attach.h> 52#include <net/irda/ircomm_tty.h> 53 54static int ircomm_tty_open(struct tty_struct *tty, struct file *filp); 55static void ircomm_tty_close(struct tty_struct * tty, struct file *filp); 56static int ircomm_tty_write(struct tty_struct * tty, 57 const unsigned char *buf, int count); 58static int ircomm_tty_write_room(struct tty_struct *tty); 59static void ircomm_tty_throttle(struct tty_struct *tty); 60static void ircomm_tty_unthrottle(struct tty_struct *tty); 61static int ircomm_tty_chars_in_buffer(struct tty_struct *tty); 62static void ircomm_tty_flush_buffer(struct tty_struct *tty); 63static void ircomm_tty_send_xchar(struct tty_struct *tty, char ch); 64static void ircomm_tty_wait_until_sent(struct tty_struct *tty, int timeout); 65static void ircomm_tty_hangup(struct tty_struct *tty); 66static void ircomm_tty_do_softint(struct work_struct *work); 67static void ircomm_tty_shutdown(struct ircomm_tty_cb *self); 68static void ircomm_tty_stop(struct tty_struct *tty); 69 70static int ircomm_tty_data_indication(void *instance, void *sap, 71 struct sk_buff *skb); 72static int ircomm_tty_control_indication(void *instance, void *sap, 73 struct sk_buff *skb); 74static void ircomm_tty_flow_indication(void *instance, void *sap, 75 LOCAL_FLOW cmd); 76#ifdef CONFIG_PROC_FS 77static const struct file_operations ircomm_tty_proc_fops; 78#endif /* CONFIG_PROC_FS */ 79static struct tty_driver *driver; 80 81static hashbin_t *ircomm_tty = NULL; 82 83static const struct tty_operations ops = { 84 .open = ircomm_tty_open, 85 .close = ircomm_tty_close, 86 .write = ircomm_tty_write, 87 .write_room = ircomm_tty_write_room, 88 .chars_in_buffer = ircomm_tty_chars_in_buffer, 89 .flush_buffer = ircomm_tty_flush_buffer, 90 .ioctl = ircomm_tty_ioctl, /* ircomm_tty_ioctl.c */ 91 .tiocmget = ircomm_tty_tiocmget, /* ircomm_tty_ioctl.c */ 92 .tiocmset = ircomm_tty_tiocmset, /* ircomm_tty_ioctl.c */ 93 .throttle = ircomm_tty_throttle, 94 .unthrottle = ircomm_tty_unthrottle, 95 .send_xchar = ircomm_tty_send_xchar, 96 .set_termios = ircomm_tty_set_termios, 97 .stop = ircomm_tty_stop, 98 .start = ircomm_tty_start, 99 .hangup = ircomm_tty_hangup, 100 .wait_until_sent = ircomm_tty_wait_until_sent, 101#ifdef CONFIG_PROC_FS 102 .proc_fops = &ircomm_tty_proc_fops, 103#endif /* CONFIG_PROC_FS */ 104}; 105 106/* 107 * Function ircomm_tty_init() 108 * 109 * Init IrCOMM TTY layer/driver 110 * 111 */ 112static int __init ircomm_tty_init(void) 113{ 114 driver = alloc_tty_driver(IRCOMM_TTY_PORTS); 115 if (!driver) 116 return -ENOMEM; 117 ircomm_tty = hashbin_new(HB_LOCK); 118 if (ircomm_tty == NULL) { 119 IRDA_ERROR("%s(), can't allocate hashbin!\n", __func__); 120 put_tty_driver(driver); 121 return -ENOMEM; 122 } 123 124 driver->owner = THIS_MODULE; 125 driver->driver_name = "ircomm"; 126 driver->name = "ircomm"; 127 driver->major = IRCOMM_TTY_MAJOR; 128 driver->minor_start = IRCOMM_TTY_MINOR; 129 driver->type = TTY_DRIVER_TYPE_SERIAL; 130 driver->subtype = SERIAL_TYPE_NORMAL; 131 driver->init_termios = tty_std_termios; 132 driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL; 133 driver->flags = TTY_DRIVER_REAL_RAW; 134 tty_set_operations(driver, &ops); 135 if (tty_register_driver(driver)) { 136 IRDA_ERROR("%s(): Couldn't register serial driver\n", 137 __func__); 138 put_tty_driver(driver); 139 return -1; 140 } 141 return 0; 142} 143 144static void __exit __ircomm_tty_cleanup(struct ircomm_tty_cb *self) 145{ 146 IRDA_DEBUG(0, "%s()\n", __func__ ); 147 148 IRDA_ASSERT(self != NULL, return;); 149 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;); 150 151 ircomm_tty_shutdown(self); 152 153 self->magic = 0; 154 kfree(self); 155} 156 157/* 158 * Function ircomm_tty_cleanup () 159 * 160 * Remove IrCOMM TTY layer/driver 161 * 162 */ 163static void __exit ircomm_tty_cleanup(void) 164{ 165 int ret; 166 167 IRDA_DEBUG(4, "%s()\n", __func__ ); 168 169 ret = tty_unregister_driver(driver); 170 if (ret) { 171 IRDA_ERROR("%s(), failed to unregister driver\n", 172 __func__); 173 return; 174 } 175 176 hashbin_delete(ircomm_tty, (FREE_FUNC) __ircomm_tty_cleanup); 177 put_tty_driver(driver); 178} 179 180/* 181 * Function ircomm_startup (self) 182 * 183 * 184 * 185 */ 186static int ircomm_tty_startup(struct ircomm_tty_cb *self) 187{ 188 notify_t notify; 189 int ret = -ENODEV; 190 191 IRDA_DEBUG(2, "%s()\n", __func__ ); 192 193 IRDA_ASSERT(self != NULL, return -1;); 194 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;); 195 196 /* Check if already open */ 197 if (test_and_set_bit(ASYNC_B_INITIALIZED, &self->flags)) { 198 IRDA_DEBUG(2, "%s(), already open so break out!\n", __func__ ); 199 return 0; 200 } 201 202 /* Register with IrCOMM */ 203 irda_notify_init(¬ify); 204 /* These callbacks we must handle ourselves */ 205 notify.data_indication = ircomm_tty_data_indication; 206 notify.udata_indication = ircomm_tty_control_indication; 207 notify.flow_indication = ircomm_tty_flow_indication; 208 209 /* Use the ircomm_tty interface for these ones */ 210 notify.disconnect_indication = ircomm_tty_disconnect_indication; 211 notify.connect_confirm = ircomm_tty_connect_confirm; 212 notify.connect_indication = ircomm_tty_connect_indication; 213 strlcpy(notify.name, "ircomm_tty", sizeof(notify.name)); 214 notify.instance = self; 215 216 if (!self->ircomm) { 217 self->ircomm = ircomm_open(¬ify, self->service_type, 218 self->line); 219 } 220 if (!self->ircomm) 221 goto err; 222 223 self->slsap_sel = self->ircomm->slsap_sel; 224 225 /* Connect IrCOMM link with remote device */ 226 ret = ircomm_tty_attach_cable(self); 227 if (ret < 0) { 228 IRDA_ERROR("%s(), error attaching cable!\n", __func__); 229 goto err; 230 } 231 232 return 0; 233err: 234 clear_bit(ASYNC_B_INITIALIZED, &self->flags); 235 return ret; 236} 237 238/* 239 * Function ircomm_block_til_ready (self, filp) 240 * 241 * 242 * 243 */ 244static int ircomm_tty_block_til_ready(struct ircomm_tty_cb *self, 245 struct file *filp) 246{ 247 DECLARE_WAITQUEUE(wait, current); 248 int retval; 249 int do_clocal = 0, extra_count = 0; 250 unsigned long flags; 251 struct tty_struct *tty; 252 253 IRDA_DEBUG(2, "%s()\n", __func__ ); 254 255 tty = self->tty; 256 257 /* 258 * If non-blocking mode is set, or the port is not enabled, 259 * then make the check up front and then exit. 260 */ 261 if (filp->f_flags & O_NONBLOCK || tty->flags & (1 << TTY_IO_ERROR)){ 262 /* nonblock mode is set or port is not enabled */ 263 self->flags |= ASYNC_NORMAL_ACTIVE; 264 IRDA_DEBUG(1, "%s(), O_NONBLOCK requested!\n", __func__ ); 265 return 0; 266 } 267 268 if (tty->termios->c_cflag & CLOCAL) { 269 IRDA_DEBUG(1, "%s(), doing CLOCAL!\n", __func__ ); 270 do_clocal = 1; 271 } 272 273 /* Wait for carrier detect and the line to become 274 * free (i.e., not in use by the callout). While we are in 275 * this loop, self->open_count is dropped by one, so that 276 * mgsl_close() knows when to free things. We restore it upon 277 * exit, either normal or abnormal. 278 */ 279 280 retval = 0; 281 add_wait_queue(&self->open_wait, &wait); 282 283 IRDA_DEBUG(2, "%s(%d):block_til_ready before block on %s open_count=%d\n", 284 __FILE__,__LINE__, tty->driver->name, self->open_count ); 285 286 /* As far as I can see, we protect open_count - Jean II */ 287 spin_lock_irqsave(&self->spinlock, flags); 288 if (!tty_hung_up_p(filp)) { 289 extra_count = 1; 290 self->open_count--; 291 } 292 spin_unlock_irqrestore(&self->spinlock, flags); 293 self->blocked_open++; 294 295 while (1) { 296 if (tty->termios->c_cflag & CBAUD) { 297 /* Here, we use to lock those two guys, but 298 * as ircomm_param_request() does it itself, 299 * I don't see the point (and I see the deadlock). 300 * Jean II */ 301 self->settings.dte |= IRCOMM_RTS + IRCOMM_DTR; 302 303 ircomm_param_request(self, IRCOMM_DTE, TRUE); 304 } 305 306 current->state = TASK_INTERRUPTIBLE; 307 308 if (tty_hung_up_p(filp) || 309 !test_bit(ASYNC_B_INITIALIZED, &self->flags)) { 310 retval = (self->flags & ASYNC_HUP_NOTIFY) ? 311 -EAGAIN : -ERESTARTSYS; 312 break; 313 } 314 315 /* 316 * Check if link is ready now. Even if CLOCAL is 317 * specified, we cannot return before the IrCOMM link is 318 * ready 319 */ 320 if (!test_bit(ASYNC_B_CLOSING, &self->flags) && 321 (do_clocal || (self->settings.dce & IRCOMM_CD)) && 322 self->state == IRCOMM_TTY_READY) 323 { 324 break; 325 } 326 327 if (signal_pending(current)) { 328 retval = -ERESTARTSYS; 329 break; 330 } 331 332 IRDA_DEBUG(1, "%s(%d):block_til_ready blocking on %s open_count=%d\n", 333 __FILE__,__LINE__, tty->driver->name, self->open_count ); 334 335 schedule(); 336 } 337 338 __set_current_state(TASK_RUNNING); 339 remove_wait_queue(&self->open_wait, &wait); 340 341 if (extra_count) { 342 /* ++ is not atomic, so this should be protected - Jean II */ 343 spin_lock_irqsave(&self->spinlock, flags); 344 self->open_count++; 345 spin_unlock_irqrestore(&self->spinlock, flags); 346 } 347 self->blocked_open--; 348 349 IRDA_DEBUG(1, "%s(%d):block_til_ready after blocking on %s open_count=%d\n", 350 __FILE__,__LINE__, tty->driver->name, self->open_count); 351 352 if (!retval) 353 self->flags |= ASYNC_NORMAL_ACTIVE; 354 355 return retval; 356} 357 358/* 359 * Function ircomm_tty_open (tty, filp) 360 * 361 * This routine is called when a particular tty device is opened. This 362 * routine is mandatory; if this routine is not filled in, the attempted 363 * open will fail with ENODEV. 364 */ 365static int ircomm_tty_open(struct tty_struct *tty, struct file *filp) 366{ 367 struct ircomm_tty_cb *self; 368 unsigned int line; 369 unsigned long flags; 370 int ret; 371 372 IRDA_DEBUG(2, "%s()\n", __func__ ); 373 374 line = tty->index; 375 if (line >= IRCOMM_TTY_PORTS) 376 return -ENODEV; 377 378 /* Check if instance already exists */ 379 self = hashbin_lock_find(ircomm_tty, line, NULL); 380 if (!self) { 381 /* No, so make new instance */ 382 self = kzalloc(sizeof(struct ircomm_tty_cb), GFP_KERNEL); 383 if (self == NULL) { 384 IRDA_ERROR("%s(), kmalloc failed!\n", __func__); 385 return -ENOMEM; 386 } 387 388 self->magic = IRCOMM_TTY_MAGIC; 389 self->flow = FLOW_STOP; 390 391 self->line = line; 392 INIT_WORK(&self->tqueue, ircomm_tty_do_softint); 393 self->max_header_size = IRCOMM_TTY_HDR_UNINITIALISED; 394 self->max_data_size = IRCOMM_TTY_DATA_UNINITIALISED; 395 self->close_delay = 5*HZ/10; 396 self->closing_wait = 30*HZ; 397 398 /* Init some important stuff */ 399 init_timer(&self->watchdog_timer); 400 init_waitqueue_head(&self->open_wait); 401 init_waitqueue_head(&self->close_wait); 402 spin_lock_init(&self->spinlock); 403 404 /* 405 * Force TTY into raw mode by default which is usually what 406 * we want for IrCOMM and IrLPT. This way applications will 407 * not have to twiddle with printcap etc. 408 * 409 * Note this is completely usafe and doesn't work properly 410 */ 411 tty->termios->c_iflag = 0; 412 tty->termios->c_oflag = 0; 413 414 /* Insert into hash */ 415 hashbin_insert(ircomm_tty, (irda_queue_t *) self, line, NULL); 416 } 417 /* ++ is not atomic, so this should be protected - Jean II */ 418 spin_lock_irqsave(&self->spinlock, flags); 419 self->open_count++; 420 421 tty->driver_data = self; 422 self->tty = tty; 423 spin_unlock_irqrestore(&self->spinlock, flags); 424 425 IRDA_DEBUG(1, "%s(), %s%d, count = %d\n", __func__ , tty->driver->name, 426 self->line, self->open_count); 427 428 /* Not really used by us, but lets do it anyway */ 429 self->tty->low_latency = (self->flags & ASYNC_LOW_LATENCY) ? 1 : 0; 430 431 /* 432 * If the port is the middle of closing, bail out now 433 */ 434 if (tty_hung_up_p(filp) || 435 test_bit(ASYNC_B_CLOSING, &self->flags)) { 436 437 /* Hm, why are we blocking on ASYNC_CLOSING if we 438 * do return -EAGAIN/-ERESTARTSYS below anyway? 439 * IMHO it's either not needed in the first place 440 * or for some reason we need to make sure the async 441 * closing has been finished - if so, wouldn't we 442 * probably better sleep uninterruptible? 443 */ 444 445 if (wait_event_interruptible(self->close_wait, !test_bit(ASYNC_B_CLOSING, &self->flags))) { 446 IRDA_WARNING("%s - got signal while blocking on ASYNC_CLOSING!\n", 447 __func__); 448 return -ERESTARTSYS; 449 } 450 451#ifdef SERIAL_DO_RESTART 452 return ((self->flags & ASYNC_HUP_NOTIFY) ? 453 -EAGAIN : -ERESTARTSYS); 454#else 455 return -EAGAIN; 456#endif 457 } 458 459 /* Check if this is a "normal" ircomm device, or an irlpt device */ 460 if (line < 0x10) { 461 self->service_type = IRCOMM_3_WIRE | IRCOMM_9_WIRE; 462 self->settings.service_type = IRCOMM_9_WIRE; /* 9 wire as default */ 463 /* Jan Kiszka -> add DSR/RI -> Conform to IrCOMM spec */ 464 self->settings.dce = IRCOMM_CTS | IRCOMM_CD | IRCOMM_DSR | IRCOMM_RI; /* Default line settings */ 465 IRDA_DEBUG(2, "%s(), IrCOMM device\n", __func__ ); 466 } else { 467 IRDA_DEBUG(2, "%s(), IrLPT device\n", __func__ ); 468 self->service_type = IRCOMM_3_WIRE_RAW; 469 self->settings.service_type = IRCOMM_3_WIRE_RAW; /* Default */ 470 } 471 472 ret = ircomm_tty_startup(self); 473 if (ret) 474 return ret; 475 476 ret = ircomm_tty_block_til_ready(self, filp); 477 if (ret) { 478 IRDA_DEBUG(2, 479 "%s(), returning after block_til_ready with %d\n", __func__ , 480 ret); 481 482 return ret; 483 } 484 return 0; 485} 486 487/* 488 * Function ircomm_tty_close (tty, filp) 489 * 490 * This routine is called when a particular tty device is closed. 491 * 492 */ 493static void ircomm_tty_close(struct tty_struct *tty, struct file *filp) 494{ 495 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data; 496 unsigned long flags; 497 498 IRDA_DEBUG(0, "%s()\n", __func__ ); 499 500 IRDA_ASSERT(self != NULL, return;); 501 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;); 502 503 spin_lock_irqsave(&self->spinlock, flags); 504 505 if (tty_hung_up_p(filp)) { 506 spin_unlock_irqrestore(&self->spinlock, flags); 507 508 IRDA_DEBUG(0, "%s(), returning 1\n", __func__ ); 509 return; 510 } 511 512 if ((tty->count == 1) && (self->open_count != 1)) { 513 /* 514 * Uh, oh. tty->count is 1, which means that the tty 515 * structure will be freed. state->count should always 516 * be one in these conditions. If it's greater than 517 * one, we've got real problems, since it means the 518 * serial port won't be shutdown. 519 */ 520 IRDA_DEBUG(0, "%s(), bad serial port count; " 521 "tty->count is 1, state->count is %d\n", __func__ , 522 self->open_count); 523 self->open_count = 1; 524 } 525 526 if (--self->open_count < 0) { 527 IRDA_ERROR("%s(), bad serial port count for ttys%d: %d\n", 528 __func__, self->line, self->open_count); 529 self->open_count = 0; 530 } 531 if (self->open_count) { 532 spin_unlock_irqrestore(&self->spinlock, flags); 533 534 IRDA_DEBUG(0, "%s(), open count > 0\n", __func__ ); 535 return; 536 } 537 538 /* Hum... Should be test_and_set_bit ??? - Jean II */ 539 set_bit(ASYNC_B_CLOSING, &self->flags); 540 541 /* We need to unlock here (we were unlocking at the end of this 542 * function), because tty_wait_until_sent() may schedule. 543 * I don't know if the rest should be protected somehow, 544 * so someone should check. - Jean II */ 545 spin_unlock_irqrestore(&self->spinlock, flags); 546 547 /* 548 * Now we wait for the transmit buffer to clear; and we notify 549 * the line discipline to only process XON/XOFF characters. 550 */ 551 tty->closing = 1; 552 if (self->closing_wait != ASYNC_CLOSING_WAIT_NONE) 553 tty_wait_until_sent(tty, self->closing_wait); 554 555 ircomm_tty_shutdown(self); 556 557 tty_driver_flush_buffer(tty); 558 tty_ldisc_flush(tty); 559 560 tty->closing = 0; 561 self->tty = NULL; 562 563 if (self->blocked_open) { 564 if (self->close_delay) 565 schedule_timeout_interruptible(self->close_delay); 566 wake_up_interruptible(&self->open_wait); 567 } 568 569 self->flags &= ~(ASYNC_NORMAL_ACTIVE|ASYNC_CLOSING); 570 wake_up_interruptible(&self->close_wait); 571} 572 573/* 574 * Function ircomm_tty_flush_buffer (tty) 575 * 576 * 577 * 578 */ 579static void ircomm_tty_flush_buffer(struct tty_struct *tty) 580{ 581 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data; 582 583 IRDA_ASSERT(self != NULL, return;); 584 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;); 585 586 /* 587 * Let do_softint() do this to avoid race condition with 588 * do_softint() ;-) 589 */ 590 schedule_work(&self->tqueue); 591} 592 593/* 594 * Function ircomm_tty_do_softint (work) 595 * 596 * We use this routine to give the write wakeup to the user at at a 597 * safe time (as fast as possible after write have completed). This 598 * can be compared to the Tx interrupt. 599 */ 600static void ircomm_tty_do_softint(struct work_struct *work) 601{ 602 struct ircomm_tty_cb *self = 603 container_of(work, struct ircomm_tty_cb, tqueue); 604 struct tty_struct *tty; 605 unsigned long flags; 606 struct sk_buff *skb, *ctrl_skb; 607 608 IRDA_DEBUG(2, "%s()\n", __func__ ); 609 610 if (!self || self->magic != IRCOMM_TTY_MAGIC) 611 return; 612 613 tty = self->tty; 614 if (!tty) 615 return; 616 617 /* Unlink control buffer */ 618 spin_lock_irqsave(&self->spinlock, flags); 619 620 ctrl_skb = self->ctrl_skb; 621 self->ctrl_skb = NULL; 622 623 spin_unlock_irqrestore(&self->spinlock, flags); 624 625 /* Flush control buffer if any */ 626 if(ctrl_skb) { 627 if(self->flow == FLOW_START) 628 ircomm_control_request(self->ircomm, ctrl_skb); 629 /* Drop reference count - see ircomm_ttp_data_request(). */ 630 dev_kfree_skb(ctrl_skb); 631 } 632 633 if (tty->hw_stopped) 634 return; 635 636 /* Unlink transmit buffer */ 637 spin_lock_irqsave(&self->spinlock, flags); 638 639 skb = self->tx_skb; 640 self->tx_skb = NULL; 641 642 spin_unlock_irqrestore(&self->spinlock, flags); 643 644 /* Flush transmit buffer if any */ 645 if (skb) { 646 ircomm_tty_do_event(self, IRCOMM_TTY_DATA_REQUEST, skb, NULL); 647 /* Drop reference count - see ircomm_ttp_data_request(). */ 648 dev_kfree_skb(skb); 649 } 650 651 /* Check if user (still) wants to be waken up */ 652 tty_wakeup(tty); 653} 654 655/* 656 * Function ircomm_tty_write (tty, buf, count) 657 * 658 * This routine is called by the kernel to write a series of characters 659 * to the tty device. The characters may come from user space or kernel 660 * space. This routine will return the number of characters actually 661 * accepted for writing. This routine is mandatory. 662 */ 663static int ircomm_tty_write(struct tty_struct *tty, 664 const unsigned char *buf, int count) 665{ 666 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data; 667 unsigned long flags; 668 struct sk_buff *skb; 669 int tailroom = 0; 670 int len = 0; 671 int size; 672 673 IRDA_DEBUG(2, "%s(), count=%d, hw_stopped=%d\n", __func__ , count, 674 tty->hw_stopped); 675 676 IRDA_ASSERT(self != NULL, return -1;); 677 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;); 678 679 /* We may receive packets from the TTY even before we have finished 680 * our setup. Not cool. 681 * The problem is that we don't know the final header and data size 682 * to create the proper skb, so any skb we would create would have 683 * bogus header and data size, so need care. 684 * We use a bogus header size to safely detect this condition. 685 * Another problem is that hw_stopped was set to 0 way before it 686 * should be, so we would drop this skb. It should now be fixed. 687 * One option is to not accept data until we are properly setup. 688 * But, I suspect that when it happens, the ppp line discipline 689 * just "drops" the data, which might screw up connect scripts. 690 * The second option is to create a "safe skb", with large header 691 * and small size (see ircomm_tty_open() for values). 692 * We just need to make sure that when the real values get filled, 693 * we don't mess up the original "safe skb" (see tx_data_size). 694 * Jean II */ 695 if (self->max_header_size == IRCOMM_TTY_HDR_UNINITIALISED) { 696 IRDA_DEBUG(1, "%s() : not initialised\n", __func__); 697#ifdef IRCOMM_NO_TX_BEFORE_INIT 698 /* We didn't consume anything, TTY will retry */ 699 return 0; 700#endif 701 } 702 703 if (count < 1) 704 return 0; 705 706 /* Protect our manipulation of self->tx_skb and related */ 707 spin_lock_irqsave(&self->spinlock, flags); 708 709 /* Fetch current transmit buffer */ 710 skb = self->tx_skb; 711 712 /* 713 * Send out all the data we get, possibly as multiple fragmented 714 * frames, but this will only happen if the data is larger than the 715 * max data size. The normal case however is just the opposite, and 716 * this function may be called multiple times, and will then actually 717 * defragment the data and send it out as one packet as soon as 718 * possible, but at a safer point in time 719 */ 720 while (count) { 721 size = count; 722 723 /* Adjust data size to the max data size */ 724 if (size > self->max_data_size) 725 size = self->max_data_size; 726 727 /* 728 * Do we already have a buffer ready for transmit, or do 729 * we need to allocate a new frame 730 */ 731 if (skb) { 732 /* 733 * Any room for more data at the end of the current 734 * transmit buffer? Cannot use skb_tailroom, since 735 * dev_alloc_skb gives us a larger skb than we 736 * requested 737 * Note : use tx_data_size, because max_data_size 738 * may have changed and we don't want to overwrite 739 * the skb. - Jean II 740 */ 741 if ((tailroom = (self->tx_data_size - skb->len)) > 0) { 742 /* Adjust data to tailroom */ 743 if (size > tailroom) 744 size = tailroom; 745 } else { 746 /* 747 * Current transmit frame is full, so break 748 * out, so we can send it as soon as possible 749 */ 750 break; 751 } 752 } else { 753 /* Prepare a full sized frame */ 754 skb = alloc_skb(self->max_data_size+ 755 self->max_header_size, 756 GFP_ATOMIC); 757 if (!skb) { 758 spin_unlock_irqrestore(&self->spinlock, flags); 759 return -ENOBUFS; 760 } 761 skb_reserve(skb, self->max_header_size); 762 self->tx_skb = skb; 763 /* Remember skb size because max_data_size may 764 * change later on - Jean II */ 765 self->tx_data_size = self->max_data_size; 766 } 767 768 /* Copy data */ 769 memcpy(skb_put(skb,size), buf + len, size); 770 771 count -= size; 772 len += size; 773 } 774 775 spin_unlock_irqrestore(&self->spinlock, flags); 776 777 /* 778 * Schedule a new thread which will transmit the frame as soon 779 * as possible, but at a safe point in time. We do this so the 780 * "user" can give us data multiple times, as PPP does (because of 781 * its 256 byte tx buffer). We will then defragment and send out 782 * all this data as one single packet. 783 */ 784 schedule_work(&self->tqueue); 785 786 return len; 787} 788 789/* 790 * Function ircomm_tty_write_room (tty) 791 * 792 * This routine returns the numbers of characters the tty driver will 793 * accept for queuing to be written. This number is subject to change as 794 * output buffers get emptied, or if the output flow control is acted. 795 */ 796static int ircomm_tty_write_room(struct tty_struct *tty) 797{ 798 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data; 799 unsigned long flags; 800 int ret; 801 802 IRDA_ASSERT(self != NULL, return -1;); 803 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;); 804 805#ifdef IRCOMM_NO_TX_BEFORE_INIT 806 /* max_header_size tells us if the channel is initialised or not. */ 807 if (self->max_header_size == IRCOMM_TTY_HDR_UNINITIALISED) 808 /* Don't bother us yet */ 809 return 0; 810#endif 811 812 /* Check if we are allowed to transmit any data. 813 * hw_stopped is the regular flow control. 814 * Jean II */ 815 if (tty->hw_stopped) 816 ret = 0; 817 else { 818 spin_lock_irqsave(&self->spinlock, flags); 819 if (self->tx_skb) 820 ret = self->tx_data_size - self->tx_skb->len; 821 else 822 ret = self->max_data_size; 823 spin_unlock_irqrestore(&self->spinlock, flags); 824 } 825 IRDA_DEBUG(2, "%s(), ret=%d\n", __func__ , ret); 826 827 return ret; 828} 829 830/* 831 * Function ircomm_tty_wait_until_sent (tty, timeout) 832 * 833 * This routine waits until the device has written out all of the 834 * characters in its transmitter FIFO. 835 */ 836static void ircomm_tty_wait_until_sent(struct tty_struct *tty, int timeout) 837{ 838 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data; 839 unsigned long orig_jiffies, poll_time; 840 unsigned long flags; 841 842 IRDA_DEBUG(2, "%s()\n", __func__ ); 843 844 IRDA_ASSERT(self != NULL, return;); 845 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;); 846 847 orig_jiffies = jiffies; 848 849 /* Set poll time to 200 ms */ 850 poll_time = IRDA_MIN(timeout, msecs_to_jiffies(200)); 851 852 spin_lock_irqsave(&self->spinlock, flags); 853 while (self->tx_skb && self->tx_skb->len) { 854 spin_unlock_irqrestore(&self->spinlock, flags); 855 schedule_timeout_interruptible(poll_time); 856 spin_lock_irqsave(&self->spinlock, flags); 857 if (signal_pending(current)) 858 break; 859 if (timeout && time_after(jiffies, orig_jiffies + timeout)) 860 break; 861 } 862 spin_unlock_irqrestore(&self->spinlock, flags); 863 current->state = TASK_RUNNING; 864} 865 866/* 867 * Function ircomm_tty_throttle (tty) 868 * 869 * This routine notifies the tty driver that input buffers for the line 870 * discipline are close to full, and it should somehow signal that no 871 * more characters should be sent to the tty. 872 */ 873static void ircomm_tty_throttle(struct tty_struct *tty) 874{ 875 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data; 876 877 IRDA_DEBUG(2, "%s()\n", __func__ ); 878 879 IRDA_ASSERT(self != NULL, return;); 880 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;); 881 882 /* Software flow control? */ 883 if (I_IXOFF(tty)) 884 ircomm_tty_send_xchar(tty, STOP_CHAR(tty)); 885 886 /* Hardware flow control? */ 887 if (tty->termios->c_cflag & CRTSCTS) { 888 self->settings.dte &= ~IRCOMM_RTS; 889 self->settings.dte |= IRCOMM_DELTA_RTS; 890 891 ircomm_param_request(self, IRCOMM_DTE, TRUE); 892 } 893 894 ircomm_flow_request(self->ircomm, FLOW_STOP); 895} 896 897/* 898 * Function ircomm_tty_unthrottle (tty) 899 * 900 * This routine notifies the tty drivers that it should signals that 901 * characters can now be sent to the tty without fear of overrunning the 902 * input buffers of the line disciplines. 903 */ 904static void ircomm_tty_unthrottle(struct tty_struct *tty) 905{ 906 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data; 907 908 IRDA_DEBUG(2, "%s()\n", __func__ ); 909 910 IRDA_ASSERT(self != NULL, return;); 911 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;); 912 913 /* Using software flow control? */ 914 if (I_IXOFF(tty)) { 915 ircomm_tty_send_xchar(tty, START_CHAR(tty)); 916 } 917 918 /* Using hardware flow control? */ 919 if (tty->termios->c_cflag & CRTSCTS) { 920 self->settings.dte |= (IRCOMM_RTS|IRCOMM_DELTA_RTS); 921 922 ircomm_param_request(self, IRCOMM_DTE, TRUE); 923 IRDA_DEBUG(1, "%s(), FLOW_START\n", __func__ ); 924 } 925 ircomm_flow_request(self->ircomm, FLOW_START); 926} 927 928/* 929 * Function ircomm_tty_chars_in_buffer (tty) 930 * 931 * Indicates if there are any data in the buffer 932 * 933 */ 934static int ircomm_tty_chars_in_buffer(struct tty_struct *tty) 935{ 936 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data; 937 unsigned long flags; 938 int len = 0; 939 940 IRDA_ASSERT(self != NULL, return -1;); 941 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;); 942 943 spin_lock_irqsave(&self->spinlock, flags); 944 945 if (self->tx_skb) 946 len = self->tx_skb->len; 947 948 spin_unlock_irqrestore(&self->spinlock, flags); 949 950 return len; 951} 952 953static void ircomm_tty_shutdown(struct ircomm_tty_cb *self) 954{ 955 unsigned long flags; 956 957 IRDA_ASSERT(self != NULL, return;); 958 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;); 959 960 IRDA_DEBUG(0, "%s()\n", __func__ ); 961 962 if (!test_and_clear_bit(ASYNC_B_INITIALIZED, &self->flags)) 963 return; 964 965 ircomm_tty_detach_cable(self); 966 967 spin_lock_irqsave(&self->spinlock, flags); 968 969 del_timer(&self->watchdog_timer); 970 971 /* Free parameter buffer */ 972 if (self->ctrl_skb) { 973 dev_kfree_skb(self->ctrl_skb); 974 self->ctrl_skb = NULL; 975 } 976 977 /* Free transmit buffer */ 978 if (self->tx_skb) { 979 dev_kfree_skb(self->tx_skb); 980 self->tx_skb = NULL; 981 } 982 983 if (self->ircomm) { 984 ircomm_close(self->ircomm); 985 self->ircomm = NULL; 986 } 987 988 spin_unlock_irqrestore(&self->spinlock, flags); 989} 990 991/* 992 * Function ircomm_tty_hangup (tty) 993 * 994 * This routine notifies the tty driver that it should hangup the tty 995 * device. 996 * 997 */ 998static void ircomm_tty_hangup(struct tty_struct *tty) 999{ 1000 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data; 1001 unsigned long flags; 1002 1003 IRDA_DEBUG(0, "%s()\n", __func__ ); 1004 1005 IRDA_ASSERT(self != NULL, return;); 1006 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;); 1007 1008 /* ircomm_tty_flush_buffer(tty); */ 1009 ircomm_tty_shutdown(self); 1010 1011 /* I guess we need to lock here - Jean II */ 1012 spin_lock_irqsave(&self->spinlock, flags); 1013 self->flags &= ~ASYNC_NORMAL_ACTIVE; 1014 self->tty = NULL; 1015 self->open_count = 0; 1016 spin_unlock_irqrestore(&self->spinlock, flags); 1017 1018 wake_up_interruptible(&self->open_wait); 1019} 1020 1021/* 1022 * Function ircomm_tty_send_xchar (tty, ch) 1023 * 1024 * This routine is used to send a high-priority XON/XOFF character to 1025 * the device. 1026 */ 1027static void ircomm_tty_send_xchar(struct tty_struct *tty, char ch) 1028{ 1029 IRDA_DEBUG(0, "%s(), not impl\n", __func__ ); 1030} 1031 1032/* 1033 * Function ircomm_tty_start (tty) 1034 * 1035 * This routine notifies the tty driver that it resume sending 1036 * characters to the tty device. 1037 */ 1038void ircomm_tty_start(struct tty_struct *tty) 1039{ 1040 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data; 1041 1042 ircomm_flow_request(self->ircomm, FLOW_START); 1043} 1044 1045/* 1046 * Function ircomm_tty_stop (tty) 1047 * 1048 * This routine notifies the tty driver that it should stop outputting 1049 * characters to the tty device. 1050 */ 1051static void ircomm_tty_stop(struct tty_struct *tty) 1052{ 1053 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data; 1054 1055 IRDA_ASSERT(self != NULL, return;); 1056 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;); 1057 1058 ircomm_flow_request(self->ircomm, FLOW_STOP); 1059} 1060 1061/* 1062 * Function ircomm_check_modem_status (self) 1063 * 1064 * Check for any changes in the DCE's line settings. This function should 1065 * be called whenever the dce parameter settings changes, to update the 1066 * flow control settings and other things 1067 */ 1068void ircomm_tty_check_modem_status(struct ircomm_tty_cb *self) 1069{ 1070 struct tty_struct *tty; 1071 int status; 1072 1073 IRDA_DEBUG(0, "%s()\n", __func__ ); 1074 1075 IRDA_ASSERT(self != NULL, return;); 1076 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;); 1077 1078 tty = self->tty; 1079 1080 status = self->settings.dce; 1081 1082 if (status & IRCOMM_DCE_DELTA_ANY) { 1083 /*wake_up_interruptible(&self->delta_msr_wait);*/ 1084 } 1085 if ((self->flags & ASYNC_CHECK_CD) && (status & IRCOMM_DELTA_CD)) { 1086 IRDA_DEBUG(2, 1087 "%s(), ircomm%d CD now %s...\n", __func__ , self->line, 1088 (status & IRCOMM_CD) ? "on" : "off"); 1089 1090 if (status & IRCOMM_CD) { 1091 wake_up_interruptible(&self->open_wait); 1092 } else { 1093 IRDA_DEBUG(2, 1094 "%s(), Doing serial hangup..\n", __func__ ); 1095 if (tty) 1096 tty_hangup(tty); 1097 1098 /* Hangup will remote the tty, so better break out */ 1099 return; 1100 } 1101 } 1102 if (self->flags & ASYNC_CTS_FLOW) { 1103 if (tty->hw_stopped) { 1104 if (status & IRCOMM_CTS) { 1105 IRDA_DEBUG(2, 1106 "%s(), CTS tx start...\n", __func__ ); 1107 tty->hw_stopped = 0; 1108 1109 /* Wake up processes blocked on open */ 1110 wake_up_interruptible(&self->open_wait); 1111 1112 schedule_work(&self->tqueue); 1113 return; 1114 } 1115 } else { 1116 if (!(status & IRCOMM_CTS)) { 1117 IRDA_DEBUG(2, 1118 "%s(), CTS tx stop...\n", __func__ ); 1119 tty->hw_stopped = 1; 1120 } 1121 } 1122 } 1123} 1124 1125/* 1126 * Function ircomm_tty_data_indication (instance, sap, skb) 1127 * 1128 * Handle incoming data, and deliver it to the line discipline 1129 * 1130 */ 1131static int ircomm_tty_data_indication(void *instance, void *sap, 1132 struct sk_buff *skb) 1133{ 1134 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance; 1135 struct tty_ldisc *ld; 1136 1137 IRDA_DEBUG(2, "%s()\n", __func__ ); 1138 1139 IRDA_ASSERT(self != NULL, return -1;); 1140 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;); 1141 IRDA_ASSERT(skb != NULL, return -1;); 1142 1143 if (!self->tty) { 1144 IRDA_DEBUG(0, "%s(), no tty!\n", __func__ ); 1145 return 0; 1146 } 1147 1148 /* 1149 * If we receive data when hardware is stopped then something is wrong. 1150 * We try to poll the peers line settings to check if we are up todate. 1151 * Devices like WinCE can do this, and since they don't send any 1152 * params, we can just as well declare the hardware for running. 1153 */ 1154 if (self->tty->hw_stopped && (self->flow == FLOW_START)) { 1155 IRDA_DEBUG(0, "%s(), polling for line settings!\n", __func__ ); 1156 ircomm_param_request(self, IRCOMM_POLL, TRUE); 1157 1158 /* We can just as well declare the hardware for running */ 1159 ircomm_tty_send_initial_parameters(self); 1160 ircomm_tty_link_established(self); 1161 } 1162 1163 /* 1164 * Just give it over to the line discipline. There is no need to 1165 * involve the flip buffers, since we are not running in an interrupt 1166 * handler 1167 */ 1168 1169 ld = tty_ldisc_ref(self->tty); 1170 if (ld) 1171 ld->ops->receive_buf(self->tty, skb->data, NULL, skb->len); 1172 tty_ldisc_deref(ld); 1173 1174 /* No need to kfree_skb - see ircomm_ttp_data_indication() */ 1175 1176 return 0; 1177} 1178 1179/* 1180 * Function ircomm_tty_control_indication (instance, sap, skb) 1181 * 1182 * Parse all incoming parameters (easy!) 1183 * 1184 */ 1185static int ircomm_tty_control_indication(void *instance, void *sap, 1186 struct sk_buff *skb) 1187{ 1188 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance; 1189 int clen; 1190 1191 IRDA_DEBUG(4, "%s()\n", __func__ ); 1192 1193 IRDA_ASSERT(self != NULL, return -1;); 1194 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;); 1195 IRDA_ASSERT(skb != NULL, return -1;); 1196 1197 clen = skb->data[0]; 1198 1199 irda_param_extract_all(self, skb->data+1, IRDA_MIN(skb->len-1, clen), 1200 &ircomm_param_info); 1201 1202 /* No need to kfree_skb - see ircomm_control_indication() */ 1203 1204 return 0; 1205} 1206 1207/* 1208 * Function ircomm_tty_flow_indication (instance, sap, cmd) 1209 * 1210 * This function is called by IrTTP when it wants us to slow down the 1211 * transmission of data. We just mark the hardware as stopped, and wait 1212 * for IrTTP to notify us that things are OK again. 1213 */ 1214static void ircomm_tty_flow_indication(void *instance, void *sap, 1215 LOCAL_FLOW cmd) 1216{ 1217 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance; 1218 struct tty_struct *tty; 1219 1220 IRDA_ASSERT(self != NULL, return;); 1221 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;); 1222 1223 tty = self->tty; 1224 1225 switch (cmd) { 1226 case FLOW_START: 1227 IRDA_DEBUG(2, "%s(), hw start!\n", __func__ ); 1228 tty->hw_stopped = 0; 1229 1230 /* ircomm_tty_do_softint will take care of the rest */ 1231 schedule_work(&self->tqueue); 1232 break; 1233 default: /* If we get here, something is very wrong, better stop */ 1234 case FLOW_STOP: 1235 IRDA_DEBUG(2, "%s(), hw stopped!\n", __func__ ); 1236 tty->hw_stopped = 1; 1237 break; 1238 } 1239 self->flow = cmd; 1240} 1241 1242#ifdef CONFIG_PROC_FS 1243static void ircomm_tty_line_info(struct ircomm_tty_cb *self, struct seq_file *m) 1244{ 1245 char sep; 1246 1247 seq_printf(m, "State: %s\n", ircomm_tty_state[self->state]); 1248 1249 seq_puts(m, "Service type: "); 1250 if (self->service_type & IRCOMM_9_WIRE) 1251 seq_puts(m, "9_WIRE"); 1252 else if (self->service_type & IRCOMM_3_WIRE) 1253 seq_puts(m, "3_WIRE"); 1254 else if (self->service_type & IRCOMM_3_WIRE_RAW) 1255 seq_puts(m, "3_WIRE_RAW"); 1256 else 1257 seq_puts(m, "No common service type!\n"); 1258 seq_putc(m, '\n'); 1259 1260 seq_printf(m, "Port name: %s\n", self->settings.port_name); 1261 1262 seq_printf(m, "DTE status:"); 1263 sep = ' '; 1264 if (self->settings.dte & IRCOMM_RTS) { 1265 seq_printf(m, "%cRTS", sep); 1266 sep = '|'; 1267 } 1268 if (self->settings.dte & IRCOMM_DTR) { 1269 seq_printf(m, "%cDTR", sep); 1270 sep = '|'; 1271 } 1272 seq_putc(m, '\n'); 1273 1274 seq_puts(m, "DCE status:"); 1275 sep = ' '; 1276 if (self->settings.dce & IRCOMM_CTS) { 1277 seq_printf(m, "%cCTS", sep); 1278 sep = '|'; 1279 } 1280 if (self->settings.dce & IRCOMM_DSR) { 1281 seq_printf(m, "%cDSR", sep); 1282 sep = '|'; 1283 } 1284 if (self->settings.dce & IRCOMM_CD) { 1285 seq_printf(m, "%cCD", sep); 1286 sep = '|'; 1287 } 1288 if (self->settings.dce & IRCOMM_RI) { 1289 seq_printf(m, "%cRI", sep); 1290 sep = '|'; 1291 } 1292 seq_putc(m, '\n'); 1293 1294 seq_puts(m, "Configuration: "); 1295 if (!self->settings.null_modem) 1296 seq_puts(m, "DTE <-> DCE\n"); 1297 else 1298 seq_puts(m, "DTE <-> DTE (null modem emulation)\n"); 1299 1300 seq_printf(m, "Data rate: %d\n", self->settings.data_rate); 1301 1302 seq_puts(m, "Flow control:"); 1303 sep = ' '; 1304 if (self->settings.flow_control & IRCOMM_XON_XOFF_IN) { 1305 seq_printf(m, "%cXON_XOFF_IN", sep); 1306 sep = '|'; 1307 } 1308 if (self->settings.flow_control & IRCOMM_XON_XOFF_OUT) { 1309 seq_printf(m, "%cXON_XOFF_OUT", sep); 1310 sep = '|'; 1311 } 1312 if (self->settings.flow_control & IRCOMM_RTS_CTS_IN) { 1313 seq_printf(m, "%cRTS_CTS_IN", sep); 1314 sep = '|'; 1315 } 1316 if (self->settings.flow_control & IRCOMM_RTS_CTS_OUT) { 1317 seq_printf(m, "%cRTS_CTS_OUT", sep); 1318 sep = '|'; 1319 } 1320 if (self->settings.flow_control & IRCOMM_DSR_DTR_IN) { 1321 seq_printf(m, "%cDSR_DTR_IN", sep); 1322 sep = '|'; 1323 } 1324 if (self->settings.flow_control & IRCOMM_DSR_DTR_OUT) { 1325 seq_printf(m, "%cDSR_DTR_OUT", sep); 1326 sep = '|'; 1327 } 1328 if (self->settings.flow_control & IRCOMM_ENQ_ACK_IN) { 1329 seq_printf(m, "%cENQ_ACK_IN", sep); 1330 sep = '|'; 1331 } 1332 if (self->settings.flow_control & IRCOMM_ENQ_ACK_OUT) { 1333 seq_printf(m, "%cENQ_ACK_OUT", sep); 1334 sep = '|'; 1335 } 1336 seq_putc(m, '\n'); 1337 1338 seq_puts(m, "Flags:"); 1339 sep = ' '; 1340 if (self->flags & ASYNC_CTS_FLOW) { 1341 seq_printf(m, "%cASYNC_CTS_FLOW", sep); 1342 sep = '|'; 1343 } 1344 if (self->flags & ASYNC_CHECK_CD) { 1345 seq_printf(m, "%cASYNC_CHECK_CD", sep); 1346 sep = '|'; 1347 } 1348 if (self->flags & ASYNC_INITIALIZED) { 1349 seq_printf(m, "%cASYNC_INITIALIZED", sep); 1350 sep = '|'; 1351 } 1352 if (self->flags & ASYNC_LOW_LATENCY) { 1353 seq_printf(m, "%cASYNC_LOW_LATENCY", sep); 1354 sep = '|'; 1355 } 1356 if (self->flags & ASYNC_CLOSING) { 1357 seq_printf(m, "%cASYNC_CLOSING", sep); 1358 sep = '|'; 1359 } 1360 if (self->flags & ASYNC_NORMAL_ACTIVE) { 1361 seq_printf(m, "%cASYNC_NORMAL_ACTIVE", sep); 1362 sep = '|'; 1363 } 1364 seq_putc(m, '\n'); 1365 1366 seq_printf(m, "Role: %s\n", self->client ? "client" : "server"); 1367 seq_printf(m, "Open count: %d\n", self->open_count); 1368 seq_printf(m, "Max data size: %d\n", self->max_data_size); 1369 seq_printf(m, "Max header size: %d\n", self->max_header_size); 1370 1371 if (self->tty) 1372 seq_printf(m, "Hardware: %s\n", 1373 self->tty->hw_stopped ? "Stopped" : "Running"); 1374} 1375 1376static int ircomm_tty_proc_show(struct seq_file *m, void *v) 1377{ 1378 struct ircomm_tty_cb *self; 1379 unsigned long flags; 1380 1381 spin_lock_irqsave(&ircomm_tty->hb_spinlock, flags); 1382 1383 self = (struct ircomm_tty_cb *) hashbin_get_first(ircomm_tty); 1384 while (self != NULL) { 1385 if (self->magic != IRCOMM_TTY_MAGIC) 1386 break; 1387 1388 ircomm_tty_line_info(self, m); 1389 self = (struct ircomm_tty_cb *) hashbin_get_next(ircomm_tty); 1390 } 1391 spin_unlock_irqrestore(&ircomm_tty->hb_spinlock, flags); 1392 return 0; 1393} 1394 1395static int ircomm_tty_proc_open(struct inode *inode, struct file *file) 1396{ 1397 return single_open(file, ircomm_tty_proc_show, NULL); 1398} 1399 1400static const struct file_operations ircomm_tty_proc_fops = { 1401 .owner = THIS_MODULE, 1402 .open = ircomm_tty_proc_open, 1403 .read = seq_read, 1404 .llseek = seq_lseek, 1405 .release = single_release, 1406}; 1407#endif /* CONFIG_PROC_FS */ 1408 1409MODULE_AUTHOR("Dag Brattli <dagb@cs.uit.no>"); 1410MODULE_DESCRIPTION("IrCOMM serial TTY driver"); 1411MODULE_LICENSE("GPL"); 1412MODULE_ALIAS_CHARDEV_MAJOR(IRCOMM_TTY_MAJOR); 1413 1414module_init(ircomm_tty_init); 1415module_exit(ircomm_tty_cleanup); 1416