drivers/tty/amiserial.c

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