1/* 2 * Serial driver for the amiga builtin port. 3 * 4 * This code was created by taking serial.c version 4.30 from kernel 5 * release 2.3.22, replacing all hardware related stuff with the 6 * corresponding amiga hardware actions, and removing all irrelevant 7 * code. As a consequence, it uses many of the constants and names 8 * associated with the registers and bits of 16550 compatible UARTS - 9 * but only to keep track of status, etc in the state variables. It 10 * was done this was to make it easier to keep the code in line with 11 * (non hardware specific) changes to serial.c. 12 * 13 * The port is registered with the tty driver as minor device 64, and 14 * therefore other ports should should only use 65 upwards. 15 * 16 * Richard Lucock 28/12/99 17 * 18 * Copyright (C) 1991, 1992 Linus Torvalds 19 * Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 20 * 1998, 1999 Theodore Ts'o 21 * 22 */ 23 24/* 25 * Serial driver configuration section. Here are the various options: 26 * 27 * SERIAL_PARANOIA_CHECK 28 * Check the magic number for the async_structure where 29 * ever possible. 30 */ 31 32#include <linux/delay.h> 33 34#undef SERIAL_PARANOIA_CHECK 35#define SERIAL_DO_RESTART 36 37/* Set of debugging defines */ 38 39#undef SERIAL_DEBUG_INTR 40#undef SERIAL_DEBUG_OPEN 41#undef SERIAL_DEBUG_FLOW 42#undef SERIAL_DEBUG_RS_WAIT_UNTIL_SENT 43 44/* Sanity checks */ 45 46#if defined(MODULE) && defined(SERIAL_DEBUG_MCOUNT) 47#define DBG_CNT(s) printk("(%s): [%x] refc=%d, serc=%d, ttyc=%d -> %s\n", \ 48 tty->name, (info->flags), serial_driver->refcount,info->count,tty->count,s) 49#else 50#define DBG_CNT(s) 51#endif 52 53/* 54 * End of serial driver configuration section. 55 */ 56 57#include <linux/module.h> 58 59#include <linux/types.h> 60#include <linux/serial.h> 61#include <linux/serialP.h> 62#include <linux/serial_reg.h> 63static char *serial_version = "4.30"; 64 65#include <linux/errno.h> 66#include <linux/signal.h> 67#include <linux/sched.h> 68#include <linux/kernel.h> 69#include <linux/timer.h> 70#include <linux/interrupt.h> 71#include <linux/tty.h> 72#include <linux/tty_flip.h> 73#include <linux/console.h> 74#include <linux/major.h> 75#include <linux/string.h> 76#include <linux/fcntl.h> 77#include <linux/ptrace.h> 78#include <linux/ioport.h> 79#include <linux/mm.h> 80#include <linux/seq_file.h> 81#include <linux/slab.h> 82#include <linux/init.h> 83#include <linux/bitops.h> 84#include <linux/platform_device.h> 85 86#include <asm/setup.h> 87 88#include <asm/system.h> 89 90#include <asm/irq.h> 91 92#include <asm/amigahw.h> 93#include <asm/amigaints.h> 94 95#define custom amiga_custom 96static char *serial_name = "Amiga-builtin serial driver"; 97 98static struct tty_driver *serial_driver; 99 100/* number of characters left in xmit buffer before we ask for more */ 101#define WAKEUP_CHARS 256 102 103static struct async_struct *IRQ_ports; 104 105static unsigned char current_ctl_bits; 106 107static void change_speed(struct async_struct *info, struct ktermios *old); 108static void rs_wait_until_sent(struct tty_struct *tty, int timeout); 109 110 111static struct serial_state rs_table[1]; 112 113#define NR_PORTS ARRAY_SIZE(rs_table) 114 115#include <asm/uaccess.h> 116 117#define serial_isroot() (capable(CAP_SYS_ADMIN)) 118 119 120static inline int serial_paranoia_check(struct async_struct *info, 121 char *name, const char *routine) 122{ 123#ifdef SERIAL_PARANOIA_CHECK 124 static const char *badmagic = 125 "Warning: bad magic number for serial struct (%s) in %s\n"; 126 static const char *badinfo = 127 "Warning: null async_struct for (%s) in %s\n"; 128 129 if (!info) { 130 printk(badinfo, name, routine); 131 return 1; 132 } 133 if (info->magic != SERIAL_MAGIC) { 134 printk(badmagic, name, routine); 135 return 1; 136 } 137#endif 138 return 0; 139} 140 141/* some serial hardware definitions */ 142#define SDR_OVRUN (1<<15) 143#define SDR_RBF (1<<14) 144#define SDR_TBE (1<<13) 145#define SDR_TSRE (1<<12) 146 147#define SERPER_PARENB (1<<15) 148 149#define AC_SETCLR (1<<15) 150#define AC_UARTBRK (1<<11) 151 152#define SER_DTR (1<<7) 153#define SER_RTS (1<<6) 154#define SER_DCD (1<<5) 155#define SER_CTS (1<<4) 156#define SER_DSR (1<<3) 157 158static __inline__ void rtsdtr_ctrl(int bits) 159{ 160 ciab.pra = ((bits & (SER_RTS | SER_DTR)) ^ (SER_RTS | SER_DTR)) | (ciab.pra & ~(SER_RTS | SER_DTR)); 161} 162 163/* 164 * ------------------------------------------------------------ 165 * rs_stop() and rs_start() 166 * 167 * This routines are called before setting or resetting tty->stopped. 168 * They enable or disable transmitter interrupts, as necessary. 169 * ------------------------------------------------------------ 170 */ 171static void rs_stop(struct tty_struct *tty) 172{ 173 struct async_struct *info = tty->driver_data; 174 unsigned long flags; 175 176 if (serial_paranoia_check(info, tty->name, "rs_stop")) 177 return; 178 179 local_irq_save(flags); 180 if (info->IER & UART_IER_THRI) { 181 info->IER &= ~UART_IER_THRI; 182 /* disable Tx interrupt and remove any pending interrupts */ 183 custom.intena = IF_TBE; 184 mb(); 185 custom.intreq = IF_TBE; 186 mb(); 187 } 188 local_irq_restore(flags); 189} 190 191static void rs_start(struct tty_struct *tty) 192{ 193 struct async_struct *info = tty->driver_data; 194 unsigned long flags; 195 196 if (serial_paranoia_check(info, tty->name, "rs_start")) 197 return; 198 199 local_irq_save(flags); 200 if (info->xmit.head != info->xmit.tail 201 && info->xmit.buf 202 && !(info->IER & UART_IER_THRI)) { 203 info->IER |= UART_IER_THRI; 204 custom.intena = IF_SETCLR | IF_TBE; 205 mb(); 206 /* set a pending Tx Interrupt, transmitter should restart now */ 207 custom.intreq = IF_SETCLR | IF_TBE; 208 mb(); 209 } 210 local_irq_restore(flags); 211} 212 213/* 214 * ---------------------------------------------------------------------- 215 * 216 * Here starts the interrupt handling routines. All of the following 217 * subroutines are declared as inline and are folded into 218 * rs_interrupt(). They were separated out for readability's sake. 219 * 220 * Note: rs_interrupt() is a "fast" interrupt, which means that it 221 * runs with interrupts turned off. People who may want to modify 222 * rs_interrupt() should try to keep the interrupt handler as fast as 223 * possible. After you are done making modifications, it is not a bad 224 * idea to do: 225 * 226 * gcc -S -DKERNEL -Wall -Wstrict-prototypes -O6 -fomit-frame-pointer serial.c 227 * 228 * and look at the resulting assemble code in serial.s. 229 * 230 * - Ted Ts'o (tytso@mit.edu), 7-Mar-93 231 * ----------------------------------------------------------------------- 232 */ 233 234/* 235 * This routine is used by the interrupt handler to schedule 236 * processing in the software interrupt portion of the driver. 237 */ 238static void rs_sched_event(struct async_struct *info, 239 int event) 240{ 241 info->event |= 1 << event; 242 tasklet_schedule(&info->tlet); 243} 244 245static void receive_chars(struct async_struct *info) 246{ 247 int status; 248 int serdatr; 249 struct tty_struct *tty = info->tty; 250 unsigned char ch, flag; 251 struct async_icount *icount; 252 int oe = 0; 253 254 icount = &info->state->icount; 255 256 status = UART_LSR_DR; /* We obviously have a character! */ 257 serdatr = custom.serdatr; 258 mb(); 259 custom.intreq = IF_RBF; 260 mb(); 261 262 if((serdatr & 0x1ff) == 0) 263 status |= UART_LSR_BI; 264 if(serdatr & SDR_OVRUN) 265 status |= UART_LSR_OE; 266 267 ch = serdatr & 0xff; 268 icount->rx++; 269 270#ifdef SERIAL_DEBUG_INTR 271 printk("DR%02x:%02x...", ch, status); 272#endif 273 flag = TTY_NORMAL; 274 275 /* 276 * We don't handle parity or frame errors - but I have left 277 * the code in, since I'm not sure that the errors can't be 278 * detected. 279 */ 280 281 if (status & (UART_LSR_BI | UART_LSR_PE | 282 UART_LSR_FE | UART_LSR_OE)) { 283 /* 284 * For statistics only 285 */ 286 if (status & UART_LSR_BI) { 287 status &= ~(UART_LSR_FE | UART_LSR_PE); 288 icount->brk++; 289 } else if (status & UART_LSR_PE) 290 icount->parity++; 291 else if (status & UART_LSR_FE) 292 icount->frame++; 293 if (status & UART_LSR_OE) 294 icount->overrun++; 295 296 /* 297 * Now check to see if character should be 298 * ignored, and mask off conditions which 299 * should be ignored. 300 */ 301 if (status & info->ignore_status_mask) 302 goto out; 303 304 status &= info->read_status_mask; 305 306 if (status & (UART_LSR_BI)) { 307#ifdef SERIAL_DEBUG_INTR 308 printk("handling break...."); 309#endif 310 flag = TTY_BREAK; 311 if (info->flags & ASYNC_SAK) 312 do_SAK(tty); 313 } else if (status & UART_LSR_PE) 314 flag = TTY_PARITY; 315 else if (status & UART_LSR_FE) 316 flag = TTY_FRAME; 317 if (status & UART_LSR_OE) { 318 /* 319 * Overrun is special, since it's 320 * reported immediately, and doesn't 321 * affect the current character 322 */ 323 oe = 1; 324 } 325 } 326 tty_insert_flip_char(tty, ch, flag); 327 if (oe == 1) 328 tty_insert_flip_char(tty, 0, TTY_OVERRUN); 329 tty_flip_buffer_push(tty); 330out: 331 return; 332} 333 334static void transmit_chars(struct async_struct *info) 335{ 336 custom.intreq = IF_TBE; 337 mb(); 338 if (info->x_char) { 339 custom.serdat = info->x_char | 0x100; 340 mb(); 341 info->state->icount.tx++; 342 info->x_char = 0; 343 return; 344 } 345 if (info->xmit.head == info->xmit.tail 346 || info->tty->stopped 347 || info->tty->hw_stopped) { 348 info->IER &= ~UART_IER_THRI; 349 custom.intena = IF_TBE; 350 mb(); 351 return; 352 } 353 354 custom.serdat = info->xmit.buf[info->xmit.tail++] | 0x100; 355 mb(); 356 info->xmit.tail = info->xmit.tail & (SERIAL_XMIT_SIZE-1); 357 info->state->icount.tx++; 358 359 if (CIRC_CNT(info->xmit.head, 360 info->xmit.tail, 361 SERIAL_XMIT_SIZE) < WAKEUP_CHARS) 362 rs_sched_event(info, RS_EVENT_WRITE_WAKEUP); 363 364#ifdef SERIAL_DEBUG_INTR 365 printk("THRE..."); 366#endif 367 if (info->xmit.head == info->xmit.tail) { 368 custom.intena = IF_TBE; 369 mb(); 370 info->IER &= ~UART_IER_THRI; 371 } 372} 373 374static void check_modem_status(struct async_struct *info) 375{ 376 unsigned char status = ciab.pra & (SER_DCD | SER_CTS | SER_DSR); 377 unsigned char dstatus; 378 struct async_icount *icount; 379 380 /* Determine bits that have changed */ 381 dstatus = status ^ current_ctl_bits; 382 current_ctl_bits = status; 383 384 if (dstatus) { 385 icount = &info->state->icount; 386 /* update input line counters */ 387 if (dstatus & SER_DSR) 388 icount->dsr++; 389 if (dstatus & SER_DCD) { 390 icount->dcd++; 391#ifdef CONFIG_HARD_PPS 392 if ((info->flags & ASYNC_HARDPPS_CD) && 393 !(status & SER_DCD)) 394 hardpps(); 395#endif 396 } 397 if (dstatus & SER_CTS) 398 icount->cts++; 399 wake_up_interruptible(&info->delta_msr_wait); 400 } 401 402 if ((info->flags & ASYNC_CHECK_CD) && (dstatus & SER_DCD)) { 403#if (defined(SERIAL_DEBUG_OPEN) || defined(SERIAL_DEBUG_INTR)) 404 printk("ttyS%d CD now %s...", info->line, 405 (!(status & SER_DCD)) ? "on" : "off"); 406#endif 407 if (!(status & SER_DCD)) 408 wake_up_interruptible(&info->open_wait); 409 else { 410#ifdef SERIAL_DEBUG_OPEN 411 printk("doing serial hangup..."); 412#endif 413 if (info->tty) 414 tty_hangup(info->tty); 415 } 416 } 417 if (info->flags & ASYNC_CTS_FLOW) { 418 if (info->tty->hw_stopped) { 419 if (!(status & SER_CTS)) { 420#if (defined(SERIAL_DEBUG_INTR) || defined(SERIAL_DEBUG_FLOW)) 421 printk("CTS tx start..."); 422#endif 423 info->tty->hw_stopped = 0; 424 info->IER |= UART_IER_THRI; 425 custom.intena = IF_SETCLR | IF_TBE; 426 mb(); 427 /* set a pending Tx Interrupt, transmitter should restart now */ 428 custom.intreq = IF_SETCLR | IF_TBE; 429 mb(); 430 rs_sched_event(info, RS_EVENT_WRITE_WAKEUP); 431 return; 432 } 433 } else { 434 if ((status & SER_CTS)) { 435#if (defined(SERIAL_DEBUG_INTR) || defined(SERIAL_DEBUG_FLOW)) 436 printk("CTS tx stop..."); 437#endif 438 info->tty->hw_stopped = 1; 439 info->IER &= ~UART_IER_THRI; 440 /* disable Tx interrupt and remove any pending interrupts */ 441 custom.intena = IF_TBE; 442 mb(); 443 custom.intreq = IF_TBE; 444 mb(); 445 } 446 } 447 } 448} 449 450static irqreturn_t ser_vbl_int( int irq, void *data) 451{ 452 /* vbl is just a periodic interrupt we tie into to update modem status */ 453 struct async_struct * info = IRQ_ports; 454 /* 455 * TBD - is it better to unregister from this interrupt or to 456 * ignore it if MSI is clear ? 457 */ 458 if(info->IER & UART_IER_MSI) 459 check_modem_status(info); 460 return IRQ_HANDLED; 461} 462 463static irqreturn_t ser_rx_int(int irq, void *dev_id) 464{ 465 struct async_struct * info; 466 467#ifdef SERIAL_DEBUG_INTR 468 printk("ser_rx_int..."); 469#endif 470 471 info = IRQ_ports; 472 if (!info || !info->tty) 473 return IRQ_NONE; 474 475 receive_chars(info); 476 info->last_active = jiffies; 477#ifdef SERIAL_DEBUG_INTR 478 printk("end.\n"); 479#endif 480 return IRQ_HANDLED; 481} 482 483static irqreturn_t ser_tx_int(int irq, void *dev_id) 484{ 485 struct async_struct * info; 486 487 if (custom.serdatr & SDR_TBE) { 488#ifdef SERIAL_DEBUG_INTR 489 printk("ser_tx_int..."); 490#endif 491 492 info = IRQ_ports; 493 if (!info || !info->tty) 494 return IRQ_NONE; 495 496 transmit_chars(info); 497 info->last_active = jiffies; 498#ifdef SERIAL_DEBUG_INTR 499 printk("end.\n"); 500#endif 501 } 502 return IRQ_HANDLED; 503} 504 505/* 506 * ------------------------------------------------------------------- 507 * Here ends the serial interrupt routines. 508 * ------------------------------------------------------------------- 509 */ 510 511/* 512 * This routine is used to handle the "bottom half" processing for the 513 * serial driver, known also the "software interrupt" processing. 514 * This processing is done at the kernel interrupt level, after the 515 * rs_interrupt() has returned, BUT WITH INTERRUPTS TURNED ON. This 516 * is where time-consuming activities which can not be done in the 517 * interrupt driver proper are done; the interrupt driver schedules 518 * them using rs_sched_event(), and they get done here. 519 */ 520 521static void do_softint(unsigned long private_) 522{ 523 struct async_struct *info = (struct async_struct *) private_; 524 struct tty_struct *tty; 525 526 tty = info->tty; 527 if (!tty) 528 return; 529 530 if (test_and_clear_bit(RS_EVENT_WRITE_WAKEUP, &info->event)) 531 tty_wakeup(tty); 532} 533 534/* 535 * --------------------------------------------------------------- 536 * Low level utility subroutines for the serial driver: routines to 537 * figure out the appropriate timeout for an interrupt chain, routines 538 * to initialize and startup a serial port, and routines to shutdown a 539 * serial port. Useful stuff like that. 540 * --------------------------------------------------------------- 541 */ 542 543static int startup(struct async_struct * info) 544{ 545 unsigned long flags; 546 int retval=0; 547 unsigned long page; 548 549 page = get_zeroed_page(GFP_KERNEL); 550 if (!page) 551 return -ENOMEM; 552 553 local_irq_save(flags); 554 555 if (info->flags & ASYNC_INITIALIZED) { 556 free_page(page); 557 goto errout; 558 } 559 560 if (info->xmit.buf) 561 free_page(page); 562 else 563 info->xmit.buf = (unsigned char *) page; 564 565#ifdef SERIAL_DEBUG_OPEN 566 printk("starting up ttys%d ...", info->line); 567#endif 568 569 /* Clear anything in the input buffer */ 570 571 custom.intreq = IF_RBF; 572 mb(); 573 574 retval = request_irq(IRQ_AMIGA_VERTB, ser_vbl_int, 0, "serial status", info); 575 if (retval) { 576 if (serial_isroot()) { 577 if (info->tty) 578 set_bit(TTY_IO_ERROR, 579 &info->tty->flags); 580 retval = 0; 581 } 582 goto errout; 583 } 584 585 /* enable both Rx and Tx interrupts */ 586 custom.intena = IF_SETCLR | IF_RBF | IF_TBE; 587 mb(); 588 info->IER = UART_IER_MSI; 589 590 /* remember current state of the DCD and CTS bits */ 591 current_ctl_bits = ciab.pra & (SER_DCD | SER_CTS | SER_DSR); 592 593 IRQ_ports = info; 594 595 info->MCR = 0; 596 if (info->tty->termios->c_cflag & CBAUD) 597 info->MCR = SER_DTR | SER_RTS; 598 rtsdtr_ctrl(info->MCR); 599 600 if (info->tty) 601 clear_bit(TTY_IO_ERROR, &info->tty->flags); 602 info->xmit.head = info->xmit.tail = 0; 603 604 /* 605 * Set up the tty->alt_speed kludge 606 */ 607 if (info->tty) { 608 if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI) 609 info->tty->alt_speed = 57600; 610 if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI) 611 info->tty->alt_speed = 115200; 612 if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_SHI) 613 info->tty->alt_speed = 230400; 614 if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_WARP) 615 info->tty->alt_speed = 460800; 616 } 617 618 /* 619 * and set the speed of the serial port 620 */ 621 change_speed(info, NULL); 622 623 info->flags |= ASYNC_INITIALIZED; 624 local_irq_restore(flags); 625 return 0; 626 627errout: 628 local_irq_restore(flags); 629 return retval; 630} 631 632/* 633 * This routine will shutdown a serial port; interrupts are disabled, and 634 * DTR is dropped if the hangup on close termio flag is on. 635 */ 636static void shutdown(struct async_struct * info) 637{ 638 unsigned long flags; 639 struct serial_state *state; 640 641 if (!(info->flags & ASYNC_INITIALIZED)) 642 return; 643 644 state = info->state; 645 646#ifdef SERIAL_DEBUG_OPEN 647 printk("Shutting down serial port %d ....\n", info->line); 648#endif 649 650 local_irq_save(flags); /* Disable interrupts */ 651 652 /* 653 * clear delta_msr_wait queue to avoid mem leaks: we may free the irq 654 * here so the queue might never be waken up 655 */ 656 wake_up_interruptible(&info->delta_msr_wait); 657 658 IRQ_ports = NULL; 659 660 /* 661 * Free the IRQ, if necessary 662 */ 663 free_irq(IRQ_AMIGA_VERTB, info); 664 665 if (info->xmit.buf) { 666 free_page((unsigned long) info->xmit.buf); 667 info->xmit.buf = NULL; 668 } 669 670 info->IER = 0; 671 custom.intena = IF_RBF | IF_TBE; 672 mb(); 673 674 /* disable break condition */ 675 custom.adkcon = AC_UARTBRK; 676 mb(); 677 678 if (!info->tty || (info->tty->termios->c_cflag & HUPCL)) 679 info->MCR &= ~(SER_DTR|SER_RTS); 680 rtsdtr_ctrl(info->MCR); 681 682 if (info->tty) 683 set_bit(TTY_IO_ERROR, &info->tty->flags); 684 685 info->flags &= ~ASYNC_INITIALIZED; 686 local_irq_restore(flags); 687} 688 689 690/* 691 * This routine is called to set the UART divisor registers to match 692 * the specified baud rate for a serial port. 693 */ 694static void change_speed(struct async_struct *info, 695 struct ktermios *old_termios) 696{ 697 int quot = 0, baud_base, baud; 698 unsigned cflag, cval = 0; 699 int bits; 700 unsigned long flags; 701 702 if (!info->tty || !info->tty->termios) 703 return; 704 cflag = info->tty->termios->c_cflag; 705 706 /* Byte size is always 8 bits plus parity bit if requested */ 707 708 cval = 3; bits = 10; 709 if (cflag & CSTOPB) { 710 cval |= 0x04; 711 bits++; 712 } 713 if (cflag & PARENB) { 714 cval |= UART_LCR_PARITY; 715 bits++; 716 } 717 if (!(cflag & PARODD)) 718 cval |= UART_LCR_EPAR; 719#ifdef CMSPAR 720 if (cflag & CMSPAR) 721 cval |= UART_LCR_SPAR; 722#endif 723 724 /* Determine divisor based on baud rate */ 725 baud = tty_get_baud_rate(info->tty); 726 if (!baud) 727 baud = 9600; /* B0 transition handled in rs_set_termios */ 728 baud_base = info->state->baud_base; 729 if (baud == 38400 && 730 ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_CUST)) 731 quot = info->state->custom_divisor; 732 else { 733 if (baud == 134) 734 /* Special case since 134 is really 134.5 */ 735 quot = (2*baud_base / 269); 736 else if (baud) 737 quot = baud_base / baud; 738 } 739 /* If the quotient is zero refuse the change */ 740 if (!quot && old_termios) { 741 /* FIXME: Will need updating for new tty in the end */ 742 info->tty->termios->c_cflag &= ~CBAUD; 743 info->tty->termios->c_cflag |= (old_termios->c_cflag & CBAUD); 744 baud = tty_get_baud_rate(info->tty); 745 if (!baud) 746 baud = 9600; 747 if (baud == 38400 && 748 ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_CUST)) 749 quot = info->state->custom_divisor; 750 else { 751 if (baud == 134) 752 /* Special case since 134 is really 134.5 */ 753 quot = (2*baud_base / 269); 754 else if (baud) 755 quot = baud_base / baud; 756 } 757 } 758 /* As a last resort, if the quotient is zero, default to 9600 bps */ 759 if (!quot) 760 quot = baud_base / 9600; 761 info->quot = quot; 762 info->timeout = ((info->xmit_fifo_size*HZ*bits*quot) / baud_base); 763 info->timeout += HZ/50; /* Add .02 seconds of slop */ 764 765 /* CTS flow control flag and modem status interrupts */ 766 info->IER &= ~UART_IER_MSI; 767 if (info->flags & ASYNC_HARDPPS_CD) 768 info->IER |= UART_IER_MSI; 769 if (cflag & CRTSCTS) { 770 info->flags |= ASYNC_CTS_FLOW; 771 info->IER |= UART_IER_MSI; 772 } else 773 info->flags &= ~ASYNC_CTS_FLOW; 774 if (cflag & CLOCAL) 775 info->flags &= ~ASYNC_CHECK_CD; 776 else { 777 info->flags |= ASYNC_CHECK_CD; 778 info->IER |= UART_IER_MSI; 779 } 780 /* TBD: 781 * Does clearing IER_MSI imply that we should disable the VBL interrupt ? 782 */ 783 784 /* 785 * Set up parity check flag 786 */ 787 788 info->read_status_mask = UART_LSR_OE | UART_LSR_DR; 789 if (I_INPCK(info->tty)) 790 info->read_status_mask |= UART_LSR_FE | UART_LSR_PE; 791 if (I_BRKINT(info->tty) || I_PARMRK(info->tty)) 792 info->read_status_mask |= UART_LSR_BI; 793 794 /* 795 * Characters to ignore 796 */ 797 info->ignore_status_mask = 0; 798 if (I_IGNPAR(info->tty)) 799 info->ignore_status_mask |= UART_LSR_PE | UART_LSR_FE; 800 if (I_IGNBRK(info->tty)) { 801 info->ignore_status_mask |= UART_LSR_BI; 802 /* 803 * If we're ignore parity and break indicators, ignore 804 * overruns too. (For real raw support). 805 */ 806 if (I_IGNPAR(info->tty)) 807 info->ignore_status_mask |= UART_LSR_OE; 808 } 809 /* 810 * !!! ignore all characters if CREAD is not set 811 */ 812 if ((cflag & CREAD) == 0) 813 info->ignore_status_mask |= UART_LSR_DR; 814 local_irq_save(flags); 815 816 { 817 short serper; 818 819 /* Set up the baud rate */ 820 serper = quot - 1; 821 822 /* Enable or disable parity bit */ 823 824 if(cval & UART_LCR_PARITY) 825 serper |= (SERPER_PARENB); 826 827 custom.serper = serper; 828 mb(); 829 } 830 831 info->LCR = cval; /* Save LCR */ 832 local_irq_restore(flags); 833} 834 835static int rs_put_char(struct tty_struct *tty, unsigned char ch) 836{ 837 struct async_struct *info; 838 unsigned long flags; 839 840 info = tty->driver_data; 841 842 if (serial_paranoia_check(info, tty->name, "rs_put_char")) 843 return 0; 844 845 if (!info->xmit.buf) 846 return 0; 847 848 local_irq_save(flags); 849 if (CIRC_SPACE(info->xmit.head, 850 info->xmit.tail, 851 SERIAL_XMIT_SIZE) == 0) { 852 local_irq_restore(flags); 853 return 0; 854 } 855 856 info->xmit.buf[info->xmit.head++] = ch; 857 info->xmit.head &= SERIAL_XMIT_SIZE-1; 858 local_irq_restore(flags); 859 return 1; 860} 861 862static void rs_flush_chars(struct tty_struct *tty) 863{ 864 struct async_struct *info = tty->driver_data; 865 unsigned long flags; 866 867 if (serial_paranoia_check(info, tty->name, "rs_flush_chars")) 868 return; 869 870 if (info->xmit.head == info->xmit.tail 871 || tty->stopped 872 || tty->hw_stopped 873 || !info->xmit.buf) 874 return; 875 876 local_irq_save(flags); 877 info->IER |= UART_IER_THRI; 878 custom.intena = IF_SETCLR | IF_TBE; 879 mb(); 880 /* set a pending Tx Interrupt, transmitter should restart now */ 881 custom.intreq = IF_SETCLR | IF_TBE; 882 mb(); 883 local_irq_restore(flags); 884} 885 886static int rs_write(struct tty_struct * tty, const unsigned char *buf, int count) 887{ 888 int c, ret = 0; 889 struct async_struct *info; 890 unsigned long flags; 891 892 info = tty->driver_data; 893 894 if (serial_paranoia_check(info, tty->name, "rs_write")) 895 return 0; 896 897 if (!info->xmit.buf) 898 return 0; 899 900 local_irq_save(flags); 901 while (1) { 902 c = CIRC_SPACE_TO_END(info->xmit.head, 903 info->xmit.tail, 904 SERIAL_XMIT_SIZE); 905 if (count < c) 906 c = count; 907 if (c <= 0) { 908 break; 909 } 910 memcpy(info->xmit.buf + info->xmit.head, buf, c); 911 info->xmit.head = ((info->xmit.head + c) & 912 (SERIAL_XMIT_SIZE-1)); 913 buf += c; 914 count -= c; 915 ret += c; 916 } 917 local_irq_restore(flags); 918 919 if (info->xmit.head != info->xmit.tail 920 && !tty->stopped 921 && !tty->hw_stopped 922 && !(info->IER & UART_IER_THRI)) { 923 info->IER |= UART_IER_THRI; 924 local_irq_disable(); 925 custom.intena = IF_SETCLR | IF_TBE; 926 mb(); 927 /* set a pending Tx Interrupt, transmitter should restart now */ 928 custom.intreq = IF_SETCLR | IF_TBE; 929 mb(); 930 local_irq_restore(flags); 931 } 932 return ret; 933} 934 935static int rs_write_room(struct tty_struct *tty) 936{ 937 struct async_struct *info = tty->driver_data; 938 939 if (serial_paranoia_check(info, tty->name, "rs_write_room")) 940 return 0; 941 return CIRC_SPACE(info->xmit.head, info->xmit.tail, SERIAL_XMIT_SIZE); 942} 943 944static int rs_chars_in_buffer(struct tty_struct *tty) 945{ 946 struct async_struct *info = tty->driver_data; 947 948 if (serial_paranoia_check(info, tty->name, "rs_chars_in_buffer")) 949 return 0; 950 return CIRC_CNT(info->xmit.head, info->xmit.tail, SERIAL_XMIT_SIZE); 951} 952 953static void rs_flush_buffer(struct tty_struct *tty) 954{ 955 struct async_struct *info = tty->driver_data; 956 unsigned long flags; 957 958 if (serial_paranoia_check(info, tty->name, "rs_flush_buffer")) 959 return; 960 local_irq_save(flags); 961 info->xmit.head = info->xmit.tail = 0; 962 local_irq_restore(flags); 963 tty_wakeup(tty); 964} 965 966/* 967 * This function is used to send a high-priority XON/XOFF character to 968 * the device 969 */ 970static void rs_send_xchar(struct tty_struct *tty, char ch) 971{ 972 struct async_struct *info = tty->driver_data; 973 unsigned long flags; 974 975 if (serial_paranoia_check(info, tty->name, "rs_send_char")) 976 return; 977 978 info->x_char = ch; 979 if (ch) { 980 /* Make sure transmit interrupts are on */ 981 982 /* Check this ! */ 983 local_irq_save(flags); 984 if(!(custom.intenar & IF_TBE)) { 985 custom.intena = IF_SETCLR | IF_TBE; 986 mb(); 987 /* set a pending Tx Interrupt, transmitter should restart now */ 988 custom.intreq = IF_SETCLR | IF_TBE; 989 mb(); 990 } 991 local_irq_restore(flags); 992 993 info->IER |= UART_IER_THRI; 994 } 995} 996 997/* 998 * ------------------------------------------------------------ 999 * rs_throttle() 1000 * 1001 * This routine is called by the upper-layer tty layer to signal that 1002 * incoming characters should be throttled. 1003 * ------------------------------------------------------------ 1004 */ 1005static void rs_throttle(struct tty_struct * tty) 1006{ 1007 struct async_struct *info = tty->driver_data; 1008 unsigned long flags; 1009#ifdef SERIAL_DEBUG_THROTTLE 1010 char buf[64]; 1011 1012 printk("throttle %s: %d....\n", tty_name(tty, buf), 1013 tty->ldisc.chars_in_buffer(tty)); 1014#endif 1015 1016 if (serial_paranoia_check(info, tty->name, "rs_throttle")) 1017 return; 1018 1019 if (I_IXOFF(tty)) 1020 rs_send_xchar(tty, STOP_CHAR(tty)); 1021 1022 if (tty->termios->c_cflag & CRTSCTS) 1023 info->MCR &= ~SER_RTS; 1024 1025 local_irq_save(flags); 1026 rtsdtr_ctrl(info->MCR); 1027 local_irq_restore(flags); 1028} 1029 1030static void rs_unthrottle(struct tty_struct * tty) 1031{ 1032 struct async_struct *info = tty->driver_data; 1033 unsigned long flags; 1034#ifdef SERIAL_DEBUG_THROTTLE 1035 char buf[64]; 1036 1037 printk("unthrottle %s: %d....\n", tty_name(tty, buf), 1038 tty->ldisc.chars_in_buffer(tty)); 1039#endif 1040 1041 if (serial_paranoia_check(info, tty->name, "rs_unthrottle")) 1042 return; 1043 1044 if (I_IXOFF(tty)) { 1045 if (info->x_char) 1046 info->x_char = 0; 1047 else 1048 rs_send_xchar(tty, START_CHAR(tty)); 1049 } 1050 if (tty->termios->c_cflag & CRTSCTS) 1051 info->MCR |= SER_RTS; 1052 local_irq_save(flags); 1053 rtsdtr_ctrl(info->MCR); 1054 local_irq_restore(flags); 1055} 1056 1057/* 1058 * ------------------------------------------------------------ 1059 * rs_ioctl() and friends 1060 * ------------------------------------------------------------ 1061 */ 1062 1063static int get_serial_info(struct async_struct * info, 1064 struct serial_struct __user * retinfo) 1065{ 1066 struct serial_struct tmp; 1067 struct serial_state *state = info->state; 1068 1069 if (!retinfo) 1070 return -EFAULT; 1071 memset(&tmp, 0, sizeof(tmp)); 1072 tty_lock(); 1073 tmp.type = state->type; 1074 tmp.line = state->line; 1075 tmp.port = state->port; 1076 tmp.irq = state->irq; 1077 tmp.flags = state->flags; 1078 tmp.xmit_fifo_size = state->xmit_fifo_size; 1079 tmp.baud_base = state->baud_base; 1080 tmp.close_delay = state->close_delay; 1081 tmp.closing_wait = state->closing_wait; 1082 tmp.custom_divisor = state->custom_divisor; 1083 tty_unlock(); 1084 if (copy_to_user(retinfo,&tmp,sizeof(*retinfo))) 1085 return -EFAULT; 1086 return 0; 1087} 1088 1089static int set_serial_info(struct async_struct * info, 1090 struct serial_struct __user * new_info) 1091{ 1092 struct serial_struct new_serial; 1093 struct serial_state old_state, *state; 1094 unsigned int change_irq,change_port; 1095 int retval = 0; 1096 1097 if (copy_from_user(&new_serial,new_info,sizeof(new_serial))) 1098 return -EFAULT; 1099 1100 tty_lock(); 1101 state = info->state; 1102 old_state = *state; 1103 1104 change_irq = new_serial.irq != state->irq; 1105 change_port = (new_serial.port != state->port); 1106 if(change_irq || change_port || (new_serial.xmit_fifo_size != state->xmit_fifo_size)) { 1107 tty_unlock(); 1108 return -EINVAL; 1109 } 1110 1111 if (!serial_isroot()) { 1112 if ((new_serial.baud_base != state->baud_base) || 1113 (new_serial.close_delay != state->close_delay) || 1114 (new_serial.xmit_fifo_size != state->xmit_fifo_size) || 1115 ((new_serial.flags & ~ASYNC_USR_MASK) != 1116 (state->flags & ~ASYNC_USR_MASK))) 1117 return -EPERM; 1118 state->flags = ((state->flags & ~ASYNC_USR_MASK) | 1119 (new_serial.flags & ASYNC_USR_MASK)); 1120 info->flags = ((info->flags & ~ASYNC_USR_MASK) | 1121 (new_serial.flags & ASYNC_USR_MASK)); 1122 state->custom_divisor = new_serial.custom_divisor; 1123 goto check_and_exit; 1124 } 1125 1126 if (new_serial.baud_base < 9600) { 1127 tty_unlock(); 1128 return -EINVAL; 1129 } 1130 1131 /* 1132 * OK, past this point, all the error checking has been done. 1133 * At this point, we start making changes..... 1134 */ 1135 1136 state->baud_base = new_serial.baud_base; 1137 state->flags = ((state->flags & ~ASYNC_FLAGS) | 1138 (new_serial.flags & ASYNC_FLAGS)); 1139 info->flags = ((state->flags & ~ASYNC_INTERNAL_FLAGS) | 1140 (info->flags & ASYNC_INTERNAL_FLAGS)); 1141 state->custom_divisor = new_serial.custom_divisor; 1142 state->close_delay = new_serial.close_delay * HZ/100; 1143 state->closing_wait = new_serial.closing_wait * HZ/100; 1144 info->tty->low_latency = (info->flags & ASYNC_LOW_LATENCY) ? 1 : 0; 1145 1146check_and_exit: 1147 if (info->flags & ASYNC_INITIALIZED) { 1148 if (((old_state.flags & ASYNC_SPD_MASK) != 1149 (state->flags & ASYNC_SPD_MASK)) || 1150 (old_state.custom_divisor != state->custom_divisor)) { 1151 if ((state->flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI) 1152 info->tty->alt_speed = 57600; 1153 if ((state->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI) 1154 info->tty->alt_speed = 115200; 1155 if ((state->flags & ASYNC_SPD_MASK) == ASYNC_SPD_SHI) 1156 info->tty->alt_speed = 230400; 1157 if ((state->flags & ASYNC_SPD_MASK) == ASYNC_SPD_WARP) 1158 info->tty->alt_speed = 460800; 1159 change_speed(info, NULL); 1160 } 1161 } else 1162 retval = startup(info); 1163 tty_unlock(); 1164 return retval; 1165} 1166 1167 1168/* 1169 * get_lsr_info - get line status register info 1170 * 1171 * Purpose: Let user call ioctl() to get info when the UART physically 1172 * is emptied. On bus types like RS485, the transmitter must 1173 * release the bus after transmitting. This must be done when 1174 * the transmit shift register is empty, not be done when the 1175 * transmit holding register is empty. This functionality 1176 * allows an RS485 driver to be written in user space. 1177 */ 1178static int get_lsr_info(struct async_struct * info, unsigned int __user *value) 1179{ 1180 unsigned char status; 1181 unsigned int result; 1182 unsigned long flags; 1183 1184 local_irq_save(flags); 1185 status = custom.serdatr; 1186 mb(); 1187 local_irq_restore(flags); 1188 result = ((status & SDR_TSRE) ? TIOCSER_TEMT : 0); 1189 if (copy_to_user(value, &result, sizeof(int))) 1190 return -EFAULT; 1191 return 0; 1192} 1193 1194 1195static int rs_tiocmget(struct tty_struct *tty) 1196{ 1197 struct async_struct * info = tty->driver_data; 1198 unsigned char control, status; 1199 unsigned long flags; 1200 1201 if (serial_paranoia_check(info, tty->name, "rs_ioctl")) 1202 return -ENODEV; 1203 if (tty->flags & (1 << TTY_IO_ERROR)) 1204 return -EIO; 1205 1206 control = info->MCR; 1207 local_irq_save(flags); 1208 status = ciab.pra; 1209 local_irq_restore(flags); 1210 return ((control & SER_RTS) ? TIOCM_RTS : 0) 1211 | ((control & SER_DTR) ? TIOCM_DTR : 0) 1212 | (!(status & SER_DCD) ? TIOCM_CAR : 0) 1213 | (!(status & SER_DSR) ? TIOCM_DSR : 0) 1214 | (!(status & SER_CTS) ? TIOCM_CTS : 0); 1215} 1216 1217static int rs_tiocmset(struct tty_struct *tty, unsigned int set, 1218 unsigned int clear) 1219{ 1220 struct async_struct * info = tty->driver_data; 1221 unsigned long flags; 1222 1223 if (serial_paranoia_check(info, tty->name, "rs_ioctl")) 1224 return -ENODEV; 1225 if (tty->flags & (1 << TTY_IO_ERROR)) 1226 return -EIO; 1227 1228 local_irq_save(flags); 1229 if (set & TIOCM_RTS) 1230 info->MCR |= SER_RTS; 1231 if (set & TIOCM_DTR) 1232 info->MCR |= SER_DTR; 1233 if (clear & TIOCM_RTS) 1234 info->MCR &= ~SER_RTS; 1235 if (clear & TIOCM_DTR) 1236 info->MCR &= ~SER_DTR; 1237 rtsdtr_ctrl(info->MCR); 1238 local_irq_restore(flags); 1239 return 0; 1240} 1241 1242/* 1243 * rs_break() --- routine which turns the break handling on or off 1244 */ 1245static int rs_break(struct tty_struct *tty, int break_state) 1246{ 1247 struct async_struct * info = tty->driver_data; 1248 unsigned long flags; 1249 1250 if (serial_paranoia_check(info, tty->name, "rs_break")) 1251 return -EINVAL; 1252 1253 local_irq_save(flags); 1254 if (break_state == -1) 1255 custom.adkcon = AC_SETCLR | AC_UARTBRK; 1256 else 1257 custom.adkcon = AC_UARTBRK; 1258 mb(); 1259 local_irq_restore(flags); 1260 return 0; 1261} 1262 1263/* 1264 * Get counter of input serial line interrupts (DCD,RI,DSR,CTS) 1265 * Return: write counters to the user passed counter struct 1266 * NB: both 1->0 and 0->1 transitions are counted except for 1267 * RI where only 0->1 is counted. 1268 */ 1269static int rs_get_icount(struct tty_struct *tty, 1270 struct serial_icounter_struct *icount) 1271{ 1272 struct async_struct *info = tty->driver_data; 1273 struct async_icount cnow; 1274 unsigned long flags; 1275 1276 local_irq_save(flags); 1277 cnow = info->state->icount; 1278 local_irq_restore(flags); 1279 icount->cts = cnow.cts; 1280 icount->dsr = cnow.dsr; 1281 icount->rng = cnow.rng; 1282 icount->dcd = cnow.dcd; 1283 icount->rx = cnow.rx; 1284 icount->tx = cnow.tx; 1285 icount->frame = cnow.frame; 1286 icount->overrun = cnow.overrun; 1287 icount->parity = cnow.parity; 1288 icount->brk = cnow.brk; 1289 icount->buf_overrun = cnow.buf_overrun; 1290 1291 return 0; 1292} 1293 1294static int rs_ioctl(struct tty_struct *tty, 1295 unsigned int cmd, unsigned long arg) 1296{ 1297 struct async_struct * info = tty->driver_data; 1298 struct async_icount cprev, cnow; /* kernel counter temps */ 1299 void __user *argp = (void __user *)arg; 1300 unsigned long flags; 1301 1302 if (serial_paranoia_check(info, tty->name, "rs_ioctl")) 1303 return -ENODEV; 1304 1305 if ((cmd != TIOCGSERIAL) && (cmd != TIOCSSERIAL) && 1306 (cmd != TIOCSERCONFIG) && (cmd != TIOCSERGSTRUCT) && 1307 (cmd != TIOCMIWAIT) && (cmd != TIOCGICOUNT)) { 1308 if (tty->flags & (1 << TTY_IO_ERROR)) 1309 return -EIO; 1310 } 1311 1312 switch (cmd) { 1313 case TIOCGSERIAL: 1314 return get_serial_info(info, argp); 1315 case TIOCSSERIAL: 1316 return set_serial_info(info, argp); 1317 case TIOCSERCONFIG: 1318 return 0; 1319 1320 case TIOCSERGETLSR: /* Get line status register */ 1321 return get_lsr_info(info, argp); 1322 1323 case TIOCSERGSTRUCT: 1324 if (copy_to_user(argp, 1325 info, sizeof(struct async_struct))) 1326 return -EFAULT; 1327 return 0; 1328 1329 /* 1330 * Wait for any of the 4 modem inputs (DCD,RI,DSR,CTS) to change 1331 * - mask passed in arg for lines of interest 1332 * (use |'ed TIOCM_RNG/DSR/CD/CTS for masking) 1333 * Caller should use TIOCGICOUNT to see which one it was 1334 */ 1335 case TIOCMIWAIT: 1336 local_irq_save(flags); 1337 /* note the counters on entry */ 1338 cprev = info->state->icount; 1339 local_irq_restore(flags); 1340 while (1) { 1341 interruptible_sleep_on(&info->delta_msr_wait); 1342 /* see if a signal did it */ 1343 if (signal_pending(current)) 1344 return -ERESTARTSYS; 1345 local_irq_save(flags); 1346 cnow = info->state->icount; /* atomic copy */ 1347 local_irq_restore(flags); 1348 if (cnow.rng == cprev.rng && cnow.dsr == cprev.dsr && 1349 cnow.dcd == cprev.dcd && cnow.cts == cprev.cts) 1350 return -EIO; /* no change => error */ 1351 if ( ((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) || 1352 ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) || 1353 ((arg & TIOCM_CD) && (cnow.dcd != cprev.dcd)) || 1354 ((arg & TIOCM_CTS) && (cnow.cts != cprev.cts)) ) { 1355 return 0; 1356 } 1357 cprev = cnow; 1358 } 1359 /* NOTREACHED */ 1360 1361 case TIOCSERGWILD: 1362 case TIOCSERSWILD: 1363 /* "setserial -W" is called in Debian boot */ 1364 printk ("TIOCSER?WILD ioctl obsolete, ignored.\n"); 1365 return 0; 1366 1367 default: 1368 return -ENOIOCTLCMD; 1369 } 1370 return 0; 1371} 1372 1373static void rs_set_termios(struct tty_struct *tty, struct ktermios *old_termios) 1374{ 1375 struct async_struct *info = tty->driver_data; 1376 unsigned long flags; 1377 unsigned int cflag = tty->termios->c_cflag; 1378 1379 change_speed(info, old_termios); 1380 1381 /* Handle transition to B0 status */ 1382 if ((old_termios->c_cflag & CBAUD) && 1383 !(cflag & CBAUD)) { 1384 info->MCR &= ~(SER_DTR|SER_RTS); 1385 local_irq_save(flags); 1386 rtsdtr_ctrl(info->MCR); 1387 local_irq_restore(flags); 1388 } 1389 1390 /* Handle transition away from B0 status */ 1391 if (!(old_termios->c_cflag & CBAUD) && 1392 (cflag & CBAUD)) { 1393 info->MCR |= SER_DTR; 1394 if (!(tty->termios->c_cflag & CRTSCTS) || 1395 !test_bit(TTY_THROTTLED, &tty->flags)) { 1396 info->MCR |= SER_RTS; 1397 } 1398 local_irq_save(flags); 1399 rtsdtr_ctrl(info->MCR); 1400 local_irq_restore(flags); 1401 } 1402 1403 /* Handle turning off CRTSCTS */ 1404 if ((old_termios->c_cflag & CRTSCTS) && 1405 !(tty->termios->c_cflag & CRTSCTS)) { 1406 tty->hw_stopped = 0; 1407 rs_start(tty); 1408 } 1409 1410#if 0 1411 /* 1412 * No need to wake up processes in open wait, since they 1413 * sample the CLOCAL flag once, and don't recheck it. 1414 * XXX It's not clear whether the current behavior is correct 1415 * or not. Hence, this may change..... 1416 */ 1417 if (!(old_termios->c_cflag & CLOCAL) && 1418 (tty->termios->c_cflag & CLOCAL)) 1419 wake_up_interruptible(&info->open_wait); 1420#endif 1421} 1422 1423/* 1424 * ------------------------------------------------------------ 1425 * rs_close() 1426 * 1427 * This routine is called when the serial port gets closed. First, we 1428 * wait for the last remaining data to be sent. Then, we unlink its 1429 * async structure from the interrupt chain if necessary, and we free 1430 * that IRQ if nothing is left in the chain. 1431 * ------------------------------------------------------------ 1432 */ 1433static void rs_close(struct tty_struct *tty, struct file * filp) 1434{ 1435 struct async_struct * info = tty->driver_data; 1436 struct serial_state *state; 1437 unsigned long flags; 1438 1439 if (!info || serial_paranoia_check(info, tty->name, "rs_close")) 1440 return; 1441 1442 state = info->state; 1443 1444 local_irq_save(flags); 1445 1446 if (tty_hung_up_p(filp)) { 1447 DBG_CNT("before DEC-hung"); 1448 local_irq_restore(flags); 1449 return; 1450 } 1451 1452#ifdef SERIAL_DEBUG_OPEN 1453 printk("rs_close ttys%d, count = %d\n", info->line, state->count); 1454#endif 1455 if ((tty->count == 1) && (state->count != 1)) { 1456 /* 1457 * Uh, oh. tty->count is 1, which means that the tty 1458 * structure will be freed. state->count should always 1459 * be one in these conditions. If it's greater than 1460 * one, we've got real problems, since it means the 1461 * serial port won't be shutdown. 1462 */ 1463 printk("rs_close: bad serial port count; tty->count is 1, " 1464 "state->count is %d\n", state->count); 1465 state->count = 1; 1466 } 1467 if (--state->count < 0) { 1468 printk("rs_close: bad serial port count for ttys%d: %d\n", 1469 info->line, state->count); 1470 state->count = 0; 1471 } 1472 if (state->count) { 1473 DBG_CNT("before DEC-2"); 1474 local_irq_restore(flags); 1475 return; 1476 } 1477 info->flags |= ASYNC_CLOSING; 1478 /* 1479 * Now we wait for the transmit buffer to clear; and we notify 1480 * the line discipline to only process XON/XOFF characters. 1481 */ 1482 tty->closing = 1; 1483 if (info->closing_wait != ASYNC_CLOSING_WAIT_NONE) 1484 tty_wait_until_sent(tty, info->closing_wait); 1485 /* 1486 * At this point we stop accepting input. To do this, we 1487 * disable the receive line status interrupts, and tell the 1488 * interrupt driver to stop checking the data ready bit in the 1489 * line status register. 1490 */ 1491 info->read_status_mask &= ~UART_LSR_DR; 1492 if (info->flags & ASYNC_INITIALIZED) { 1493 /* disable receive interrupts */ 1494 custom.intena = IF_RBF; 1495 mb(); 1496 /* clear any pending receive interrupt */ 1497 custom.intreq = IF_RBF; 1498 mb(); 1499 1500 /* 1501 * Before we drop DTR, make sure the UART transmitter 1502 * has completely drained; this is especially 1503 * important if there is a transmit FIFO! 1504 */ 1505 rs_wait_until_sent(tty, info->timeout); 1506 } 1507 shutdown(info); 1508 rs_flush_buffer(tty); 1509 1510 tty_ldisc_flush(tty); 1511 tty->closing = 0; 1512 info->event = 0; 1513 info->tty = NULL; 1514 if (info->blocked_open) { 1515 if (info->close_delay) { 1516 msleep_interruptible(jiffies_to_msecs(info->close_delay)); 1517 } 1518 wake_up_interruptible(&info->open_wait); 1519 } 1520 info->flags &= ~(ASYNC_NORMAL_ACTIVE|ASYNC_CLOSING); 1521 wake_up_interruptible(&info->close_wait); 1522 local_irq_restore(flags); 1523} 1524 1525/* 1526 * rs_wait_until_sent() --- wait until the transmitter is empty 1527 */ 1528static void rs_wait_until_sent(struct tty_struct *tty, int timeout) 1529{ 1530 struct async_struct * info = tty->driver_data; 1531 unsigned long orig_jiffies, char_time; 1532 int lsr; 1533 1534 if (serial_paranoia_check(info, tty->name, "rs_wait_until_sent")) 1535 return; 1536 1537 if (info->xmit_fifo_size == 0) 1538 return; /* Just in case.... */ 1539 1540 orig_jiffies = jiffies; 1541 1542 /* 1543 * Set the check interval to be 1/5 of the estimated time to 1544 * send a single character, and make it at least 1. The check 1545 * interval should also be less than the timeout. 1546 * 1547 * Note: we have to use pretty tight timings here to satisfy 1548 * the NIST-PCTS. 1549 */ 1550 char_time = (info->timeout - HZ/50) / info->xmit_fifo_size; 1551 char_time = char_time / 5; 1552 if (char_time == 0) 1553 char_time = 1; 1554 if (timeout) 1555 char_time = min_t(unsigned long, char_time, timeout); 1556 /* 1557 * If the transmitter hasn't cleared in twice the approximate 1558 * amount of time to send the entire FIFO, it probably won't 1559 * ever clear. This assumes the UART isn't doing flow 1560 * control, which is currently the case. Hence, if it ever 1561 * takes longer than info->timeout, this is probably due to a 1562 * UART bug of some kind. So, we clamp the timeout parameter at 1563 * 2*info->timeout. 1564 */ 1565 if (!timeout || timeout > 2*info->timeout) 1566 timeout = 2*info->timeout; 1567#ifdef SERIAL_DEBUG_RS_WAIT_UNTIL_SENT 1568 printk("In rs_wait_until_sent(%d) check=%lu...", timeout, char_time); 1569 printk("jiff=%lu...", jiffies); 1570#endif 1571 while(!((lsr = custom.serdatr) & SDR_TSRE)) { 1572#ifdef SERIAL_DEBUG_RS_WAIT_UNTIL_SENT 1573 printk("serdatr = %d (jiff=%lu)...", lsr, jiffies); 1574#endif 1575 msleep_interruptible(jiffies_to_msecs(char_time)); 1576 if (signal_pending(current)) 1577 break; 1578 if (timeout && time_after(jiffies, orig_jiffies + timeout)) 1579 break; 1580 } 1581 __set_current_state(TASK_RUNNING); 1582 1583#ifdef SERIAL_DEBUG_RS_WAIT_UNTIL_SENT 1584 printk("lsr = %d (jiff=%lu)...done\n", lsr, jiffies); 1585#endif 1586} 1587 1588/* 1589 * rs_hangup() --- called by tty_hangup() when a hangup is signaled. 1590 */ 1591static void rs_hangup(struct tty_struct *tty) 1592{ 1593 struct async_struct * info = tty->driver_data; 1594 struct serial_state *state = info->state; 1595 1596 if (serial_paranoia_check(info, tty->name, "rs_hangup")) 1597 return; 1598 1599 state = info->state; 1600 1601 rs_flush_buffer(tty); 1602 shutdown(info); 1603 info->event = 0; 1604 state->count = 0; 1605 info->flags &= ~ASYNC_NORMAL_ACTIVE; 1606 info->tty = NULL; 1607 wake_up_interruptible(&info->open_wait); 1608} 1609 1610/* 1611 * ------------------------------------------------------------ 1612 * rs_open() and friends 1613 * ------------------------------------------------------------ 1614 */ 1615static int block_til_ready(struct tty_struct *tty, struct file * filp, 1616 struct async_struct *info) 1617{ 1618#ifdef DECLARE_WAITQUEUE 1619 DECLARE_WAITQUEUE(wait, current); 1620#else 1621 struct wait_queue wait = { current, NULL }; 1622#endif 1623 struct serial_state *state = info->state; 1624 int retval; 1625 int do_clocal = 0, extra_count = 0; 1626 unsigned long flags; 1627 1628 /* 1629 * If the device is in the middle of being closed, then block 1630 * until it's done, and then try again. 1631 */ 1632 if (tty_hung_up_p(filp) || 1633 (info->flags & ASYNC_CLOSING)) { 1634 if (info->flags & ASYNC_CLOSING) 1635 interruptible_sleep_on(&info->close_wait); 1636#ifdef SERIAL_DO_RESTART 1637 return ((info->flags & ASYNC_HUP_NOTIFY) ? 1638 -EAGAIN : -ERESTARTSYS); 1639#else 1640 return -EAGAIN; 1641#endif 1642 } 1643 1644 /* 1645 * If non-blocking mode is set, or the port is not enabled, 1646 * then make the check up front and then exit. 1647 */ 1648 if ((filp->f_flags & O_NONBLOCK) || 1649 (tty->flags & (1 << TTY_IO_ERROR))) { 1650 info->flags |= ASYNC_NORMAL_ACTIVE; 1651 return 0; 1652 } 1653 1654 if (tty->termios->c_cflag & CLOCAL) 1655 do_clocal = 1; 1656 1657 /* 1658 * Block waiting for the carrier detect and the line to become 1659 * free (i.e., not in use by the callout). While we are in 1660 * this loop, state->count is dropped by one, so that 1661 * rs_close() knows when to free things. We restore it upon 1662 * exit, either normal or abnormal. 1663 */ 1664 retval = 0; 1665 add_wait_queue(&info->open_wait, &wait); 1666#ifdef SERIAL_DEBUG_OPEN 1667 printk("block_til_ready before block: ttys%d, count = %d\n", 1668 state->line, state->count); 1669#endif 1670 local_irq_save(flags); 1671 if (!tty_hung_up_p(filp)) { 1672 extra_count = 1; 1673 state->count--; 1674 } 1675 local_irq_restore(flags); 1676 info->blocked_open++; 1677 while (1) { 1678 local_irq_save(flags); 1679 if (tty->termios->c_cflag & CBAUD) 1680 rtsdtr_ctrl(SER_DTR|SER_RTS); 1681 local_irq_restore(flags); 1682 set_current_state(TASK_INTERRUPTIBLE); 1683 if (tty_hung_up_p(filp) || 1684 !(info->flags & ASYNC_INITIALIZED)) { 1685#ifdef SERIAL_DO_RESTART 1686 if (info->flags & ASYNC_HUP_NOTIFY) 1687 retval = -EAGAIN; 1688 else 1689 retval = -ERESTARTSYS; 1690#else 1691 retval = -EAGAIN; 1692#endif 1693 break; 1694 } 1695 if (!(info->flags & ASYNC_CLOSING) && 1696 (do_clocal || (!(ciab.pra & SER_DCD)) )) 1697 break; 1698 if (signal_pending(current)) { 1699 retval = -ERESTARTSYS; 1700 break; 1701 } 1702#ifdef SERIAL_DEBUG_OPEN 1703 printk("block_til_ready blocking: ttys%d, count = %d\n", 1704 info->line, state->count); 1705#endif 1706 tty_unlock(); 1707 schedule(); 1708 tty_lock(); 1709 } 1710 __set_current_state(TASK_RUNNING); 1711 remove_wait_queue(&info->open_wait, &wait); 1712 if (extra_count) 1713 state->count++; 1714 info->blocked_open--; 1715#ifdef SERIAL_DEBUG_OPEN 1716 printk("block_til_ready after blocking: ttys%d, count = %d\n", 1717 info->line, state->count); 1718#endif 1719 if (retval) 1720 return retval; 1721 info->flags |= ASYNC_NORMAL_ACTIVE; 1722 return 0; 1723} 1724 1725static int get_async_struct(int line, struct async_struct **ret_info) 1726{ 1727 struct async_struct *info; 1728 struct serial_state *sstate; 1729 1730 sstate = rs_table + line; 1731 sstate->count++; 1732 if (sstate->info) { 1733 *ret_info = sstate->info; 1734 return 0; 1735 } 1736 info = kzalloc(sizeof(struct async_struct), GFP_KERNEL); 1737 if (!info) { 1738 sstate->count--; 1739 return -ENOMEM; 1740 } 1741#ifdef DECLARE_WAITQUEUE 1742 init_waitqueue_head(&info->open_wait); 1743 init_waitqueue_head(&info->close_wait); 1744 init_waitqueue_head(&info->delta_msr_wait); 1745#endif 1746 info->magic = SERIAL_MAGIC; 1747 info->port = sstate->port; 1748 info->flags = sstate->flags; 1749 info->xmit_fifo_size = sstate->xmit_fifo_size; 1750 info->line = line; 1751 tasklet_init(&info->tlet, do_softint, (unsigned long)info); 1752 info->state = sstate; 1753 if (sstate->info) { 1754 kfree(info); 1755 *ret_info = sstate->info; 1756 return 0; 1757 } 1758 *ret_info = sstate->info = info; 1759 return 0; 1760} 1761 1762/* 1763 * This routine is called whenever a serial port is opened. It 1764 * enables interrupts for a serial port, linking in its async structure into 1765 * the IRQ chain. It also performs the serial-specific 1766 * initialization for the tty structure. 1767 */ 1768static int rs_open(struct tty_struct *tty, struct file * filp) 1769{ 1770 struct async_struct *info; 1771 int retval, line; 1772 1773 line = tty->index; 1774 if ((line < 0) || (line >= NR_PORTS)) { 1775 return -ENODEV; 1776 } 1777 retval = get_async_struct(line, &info); 1778 if (retval) { 1779 return retval; 1780 } 1781 tty->driver_data = info; 1782 info->tty = tty; 1783 if (serial_paranoia_check(info, tty->name, "rs_open")) 1784 return -ENODEV; 1785 1786#ifdef SERIAL_DEBUG_OPEN 1787 printk("rs_open %s, count = %d\n", tty->name, info->state->count); 1788#endif 1789 info->tty->low_latency = (info->flags & ASYNC_LOW_LATENCY) ? 1 : 0; 1790 1791 /* 1792 * If the port is the middle of closing, bail out now 1793 */ 1794 if (tty_hung_up_p(filp) || 1795 (info->flags & ASYNC_CLOSING)) { 1796 if (info->flags & ASYNC_CLOSING) 1797 interruptible_sleep_on(&info->close_wait); 1798#ifdef SERIAL_DO_RESTART 1799 return ((info->flags & ASYNC_HUP_NOTIFY) ? 1800 -EAGAIN : -ERESTARTSYS); 1801#else 1802 return -EAGAIN; 1803#endif 1804 } 1805 1806 /* 1807 * Start up serial port 1808 */ 1809 retval = startup(info); 1810 if (retval) { 1811 return retval; 1812 } 1813 1814 retval = block_til_ready(tty, filp, info); 1815 if (retval) { 1816#ifdef SERIAL_DEBUG_OPEN 1817 printk("rs_open returning after block_til_ready with %d\n", 1818 retval); 1819#endif 1820 return retval; 1821 } 1822 1823#ifdef SERIAL_DEBUG_OPEN 1824 printk("rs_open %s successful...", tty->name); 1825#endif 1826 return 0; 1827} 1828 1829/* 1830 * /proc fs routines.... 1831 */ 1832 1833static inline void line_info(struct seq_file *m, struct serial_state *state) 1834{ 1835 struct async_struct *info = state->info, scr_info; 1836 char stat_buf[30], control, status; 1837 unsigned long flags; 1838 1839 seq_printf(m, "%d: uart:amiga_builtin",state->line); 1840 1841 /* 1842 * Figure out the current RS-232 lines 1843 */ 1844 if (!info) { 1845 info = &scr_info; /* This is just for serial_{in,out} */ 1846 1847 info->magic = SERIAL_MAGIC; 1848 info->flags = state->flags; 1849 info->quot = 0; 1850 info->tty = NULL; 1851 } 1852 local_irq_save(flags); 1853 status = ciab.pra; 1854 control = info ? info->MCR : status; 1855 local_irq_restore(flags); 1856 1857 stat_buf[0] = 0; 1858 stat_buf[1] = 0; 1859 if(!(control & SER_RTS)) 1860 strcat(stat_buf, "|RTS"); 1861 if(!(status & SER_CTS)) 1862 strcat(stat_buf, "|CTS"); 1863 if(!(control & SER_DTR)) 1864 strcat(stat_buf, "|DTR"); 1865 if(!(status & SER_DSR)) 1866 strcat(stat_buf, "|DSR"); 1867 if(!(status & SER_DCD)) 1868 strcat(stat_buf, "|CD"); 1869 1870 if (info->quot) { 1871 seq_printf(m, " baud:%d", state->baud_base / info->quot); 1872 } 1873 1874 seq_printf(m, " tx:%d rx:%d", state->icount.tx, state->icount.rx); 1875 1876 if (state->icount.frame) 1877 seq_printf(m, " fe:%d", state->icount.frame); 1878 1879 if (state->icount.parity) 1880 seq_printf(m, " pe:%d", state->icount.parity); 1881 1882 if (state->icount.brk) 1883 seq_printf(m, " brk:%d", state->icount.brk); 1884 1885 if (state->icount.overrun) 1886 seq_printf(m, " oe:%d", state->icount.overrun); 1887 1888 /* 1889 * Last thing is the RS-232 status lines 1890 */ 1891 seq_printf(m, " %s\n", stat_buf+1); 1892} 1893 1894static int rs_proc_show(struct seq_file *m, void *v) 1895{ 1896 seq_printf(m, "serinfo:1.0 driver:%s\n", serial_version); 1897 line_info(m, &rs_table[0]); 1898 return 0; 1899} 1900 1901static int rs_proc_open(struct inode *inode, struct file *file) 1902{ 1903 return single_open(file, rs_proc_show, NULL); 1904} 1905 1906static const struct file_operations rs_proc_fops = { 1907 .owner = THIS_MODULE, 1908 .open = rs_proc_open, 1909 .read = seq_read, 1910 .llseek = seq_lseek, 1911 .release = single_release, 1912}; 1913 1914/* 1915 * --------------------------------------------------------------------- 1916 * rs_init() and friends 1917 * 1918 * rs_init() is called at boot-time to initialize the serial driver. 1919 * --------------------------------------------------------------------- 1920 */ 1921 1922/* 1923 * This routine prints out the appropriate serial driver version 1924 * number, and identifies which options were configured into this 1925 * driver. 1926 */ 1927static void show_serial_version(void) 1928{ 1929 printk(KERN_INFO "%s version %s\n", serial_name, serial_version); 1930} 1931 1932 1933static const struct tty_operations serial_ops = { 1934 .open = rs_open, 1935 .close = rs_close, 1936 .write = rs_write, 1937 .put_char = rs_put_char, 1938 .flush_chars = rs_flush_chars, 1939 .write_room = rs_write_room, 1940 .chars_in_buffer = rs_chars_in_buffer, 1941 .flush_buffer = rs_flush_buffer, 1942 .ioctl = rs_ioctl, 1943 .throttle = rs_throttle, 1944 .unthrottle = rs_unthrottle, 1945 .set_termios = rs_set_termios, 1946 .stop = rs_stop, 1947 .start = rs_start, 1948 .hangup = rs_hangup, 1949 .break_ctl = rs_break, 1950 .send_xchar = rs_send_xchar, 1951 .wait_until_sent = rs_wait_until_sent, 1952 .tiocmget = rs_tiocmget, 1953 .tiocmset = rs_tiocmset, 1954 .get_icount = rs_get_icount, 1955 .proc_fops = &rs_proc_fops, 1956}; 1957 1958/* 1959 * The serial driver boot-time initialization code! 1960 */ 1961static int __init amiga_serial_probe(struct platform_device *pdev) 1962{ 1963 unsigned long flags; 1964 struct serial_state * state; 1965 int error; 1966 1967 serial_driver = alloc_tty_driver(1); 1968 if (!serial_driver) 1969 return -ENOMEM; 1970 1971 IRQ_ports = NULL; 1972 1973 show_serial_version(); 1974 1975 /* Initialize the tty_driver structure */ 1976 1977 serial_driver->owner = THIS_MODULE; 1978 serial_driver->driver_name = "amiserial"; 1979 serial_driver->name = "ttyS"; 1980 serial_driver->major = TTY_MAJOR; 1981 serial_driver->minor_start = 64; 1982 serial_driver->type = TTY_DRIVER_TYPE_SERIAL; 1983 serial_driver->subtype = SERIAL_TYPE_NORMAL; 1984 serial_driver->init_termios = tty_std_termios; 1985 serial_driver->init_termios.c_cflag = 1986 B9600 | CS8 | CREAD | HUPCL | CLOCAL; 1987 serial_driver->flags = TTY_DRIVER_REAL_RAW; 1988 tty_set_operations(serial_driver, &serial_ops); 1989 1990 error = tty_register_driver(serial_driver); 1991 if (error) 1992 goto fail_put_tty_driver; 1993 1994 state = rs_table; 1995 state->magic = SSTATE_MAGIC; 1996 state->port = (int)&custom.serdatr; /* Just to give it a value */ 1997 state->line = 0; 1998 state->custom_divisor = 0; 1999 state->close_delay = 5*HZ/10; 2000 state->closing_wait = 30*HZ; 2001 state->icount.cts = state->icount.dsr = 2002 state->icount.rng = state->icount.dcd = 0; 2003 state->icount.rx = state->icount.tx = 0; 2004 state->icount.frame = state->icount.parity = 0; 2005 state->icount.overrun = state->icount.brk = 0; 2006 2007 printk(KERN_INFO "ttyS%d is the amiga builtin serial port\n", 2008 state->line); 2009 2010 /* Hardware set up */ 2011 2012 state->baud_base = amiga_colorclock; 2013 state->xmit_fifo_size = 1; 2014 2015 /* set ISRs, and then disable the rx interrupts */ 2016 error = request_irq(IRQ_AMIGA_TBE, ser_tx_int, 0, "serial TX", state); 2017 if (error) 2018 goto fail_unregister; 2019 2020 error = request_irq(IRQ_AMIGA_RBF, ser_rx_int, 0, 2021 "serial RX", state); 2022 if (error) 2023 goto fail_free_irq; 2024 2025 local_irq_save(flags); 2026 2027 /* turn off Rx and Tx interrupts */ 2028 custom.intena = IF_RBF | IF_TBE; 2029 mb(); 2030 2031 /* clear any pending interrupt */ 2032 custom.intreq = IF_RBF | IF_TBE; 2033 mb(); 2034 2035 local_irq_restore(flags); 2036 2037 /* 2038 * set the appropriate directions for the modem control flags, 2039 * and clear RTS and DTR 2040 */ 2041 ciab.ddra |= (SER_DTR | SER_RTS); /* outputs */ 2042 ciab.ddra &= ~(SER_DCD | SER_CTS | SER_DSR); /* inputs */ 2043 2044 platform_set_drvdata(pdev, state); 2045 2046 return 0; 2047 2048fail_free_irq: 2049 free_irq(IRQ_AMIGA_TBE, state); 2050fail_unregister: 2051 tty_unregister_driver(serial_driver); 2052fail_put_tty_driver: 2053 put_tty_driver(serial_driver); 2054 return error; 2055} 2056 2057static int __exit amiga_serial_remove(struct platform_device *pdev) 2058{ 2059 int error; 2060 struct serial_state *state = platform_get_drvdata(pdev); 2061 struct async_struct *info = state->info; 2062 2063 /* printk("Unloading %s: version %s\n", serial_name, serial_version); */ 2064 tasklet_kill(&info->tlet); 2065 if ((error = tty_unregister_driver(serial_driver))) 2066 printk("SERIAL: failed to unregister serial driver (%d)\n", 2067 error); 2068 put_tty_driver(serial_driver); 2069 2070 rs_table[0].info = NULL; 2071 kfree(info); 2072 2073 free_irq(IRQ_AMIGA_TBE, rs_table); 2074 free_irq(IRQ_AMIGA_RBF, rs_table); 2075 2076 platform_set_drvdata(pdev, NULL); 2077 2078 return error; 2079} 2080 2081static struct platform_driver amiga_serial_driver = { 2082 .remove = __exit_p(amiga_serial_remove), 2083 .driver = { 2084 .name = "amiga-serial", 2085 .owner = THIS_MODULE, 2086 }, 2087}; 2088 2089static int __init amiga_serial_init(void) 2090{ 2091 return platform_driver_probe(&amiga_serial_driver, amiga_serial_probe); 2092} 2093 2094module_init(amiga_serial_init); 2095 2096static void __exit amiga_serial_exit(void) 2097{ 2098 platform_driver_unregister(&amiga_serial_driver); 2099} 2100 2101module_exit(amiga_serial_exit); 2102 2103 2104#if defined(CONFIG_SERIAL_CONSOLE) && !defined(MODULE) 2105 2106/* 2107 * ------------------------------------------------------------ 2108 * Serial console driver 2109 * ------------------------------------------------------------ 2110 */ 2111 2112static void amiga_serial_putc(char c) 2113{ 2114 custom.serdat = (unsigned char)c | 0x100; 2115 while (!(custom.serdatr & 0x2000)) 2116 barrier(); 2117} 2118 2119/* 2120 * Print a string to the serial port trying not to disturb 2121 * any possible real use of the port... 2122 * 2123 * The console must be locked when we get here. 2124 */ 2125static void serial_console_write(struct console *co, const char *s, 2126 unsigned count) 2127{ 2128 unsigned short intena = custom.intenar; 2129 2130 custom.intena = IF_TBE; 2131 2132 while (count--) { 2133 if (*s == '\n') 2134 amiga_serial_putc('\r'); 2135 amiga_serial_putc(*s++); 2136 } 2137 2138 custom.intena = IF_SETCLR | (intena & IF_TBE); 2139} 2140 2141static struct tty_driver *serial_console_device(struct console *c, int *index) 2142{ 2143 *index = 0; 2144 return serial_driver; 2145} 2146 2147static struct console sercons = { 2148 .name = "ttyS", 2149 .write = serial_console_write, 2150 .device = serial_console_device, 2151 .flags = CON_PRINTBUFFER, 2152 .index = -1, 2153}; 2154 2155/* 2156 * Register console. 2157 */ 2158static int __init amiserial_console_init(void) 2159{ 2160 register_console(&sercons); 2161 return 0; 2162} 2163console_initcall(amiserial_console_init); 2164 2165#endif /* CONFIG_SERIAL_CONSOLE && !MODULE */ 2166 2167MODULE_LICENSE("GPL"); 2168MODULE_ALIAS("platform:amiga-serial"); 2169