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