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_struct *ss)
1000 {
1001         struct serial_state *state = tty->driver_data;
1002
1003         tty_lock(tty);
1004         ss->line = tty->index;
1005         ss->port = state->port;
1006         ss->flags = state->tport.flags;
1007         ss->xmit_fifo_size = state->xmit_fifo_size;
1008         ss->baud_base = state->baud_base;
1009         ss->close_delay = state->tport.close_delay;
1010         ss->closing_wait = state->tport.closing_wait;
1011         ss->custom_divisor = state->custom_divisor;
1012         tty_unlock(tty);
1013         return 0;
1014 }
1015
1016 static int set_serial_info(struct tty_struct *tty, struct serial_struct *ss)
1017 {
1018         struct serial_state *state = tty->driver_data;
1019         struct tty_port *port = &state->tport;
1020         bool change_spd;
1021         int                     retval = 0;
1022
1023         tty_lock(tty);
1024         change_spd = ((ss->flags ^ port->flags) & ASYNC_SPD_MASK) ||
1025                 ss->custom_divisor != state->custom_divisor;
1026         if (ss->irq || ss->port != state->port ||
1027                         ss->xmit_fifo_size != state->xmit_fifo_size) {
1028                 tty_unlock(tty);
1029                 return -EINVAL;
1030         }
1031
1032         if (!serial_isroot()) {
1033                 if ((ss->baud_base != state->baud_base) ||
1034                     (ss->close_delay != port->close_delay) ||
1035                     (ss->xmit_fifo_size != state->xmit_fifo_size) ||
1036                     ((ss->flags & ~ASYNC_USR_MASK) !=
1037                      (port->flags & ~ASYNC_USR_MASK))) {
1038                         tty_unlock(tty);
1039                         return -EPERM;
1040                 }
1041                 port->flags = ((port->flags & ~ASYNC_USR_MASK) |
1042                                (ss->flags & ASYNC_USR_MASK));
1043                 state->custom_divisor = ss->custom_divisor;
1044                 goto check_and_exit;
1045         }
1046
1047         if (ss->baud_base < 9600) {
1048                 tty_unlock(tty);
1049                 return -EINVAL;
1050         }
1051
1052         /*
1053          * OK, past this point, all the error checking has been done.
1054          * At this point, we start making changes.....
1055          */
1056
1057         state->baud_base = ss->baud_base;
1058         port->flags = ((port->flags & ~ASYNC_FLAGS) |
1059                         (ss->flags & ASYNC_FLAGS));
1060         state->custom_divisor = ss->custom_divisor;
1061         port->close_delay = ss->close_delay * HZ/100;
1062         port->closing_wait = ss->closing_wait * HZ/100;
1063         port->low_latency = (port->flags & ASYNC_LOW_LATENCY) ? 1 : 0;
1064
1065 check_and_exit:
1066         if (tty_port_initialized(port)) {
1067                 if (change_spd) {
1068                         /* warn about deprecation unless clearing */
1069                         if (ss->flags & ASYNC_SPD_MASK)
1070                                 dev_warn_ratelimited(tty->dev, "use of SPD flags is deprecated\n");
1071                         change_speed(tty, state, NULL);
1072                 }
1073         } else
1074                 retval = startup(tty, state);
1075         tty_unlock(tty);
1076         return retval;
1077 }
1078
1079 /*
1080  * get_lsr_info - get line status register info
1081  *
1082  * Purpose: Let user call ioctl() to get info when the UART physically
1083  *          is emptied.  On bus types like RS485, the transmitter must
1084  *          release the bus after transmitting. This must be done when
1085  *          the transmit shift register is empty, not be done when the
1086  *          transmit holding register is empty.  This functionality
1087  *          allows an RS485 driver to be written in user space.
1088  */
1089 static int get_lsr_info(struct serial_state *info, unsigned int __user *value)
1090 {
1091         unsigned char status;
1092         unsigned int result;
1093         unsigned long flags;
1094
1095         local_irq_save(flags);
1096         status = custom.serdatr;
1097         mb();
1098         local_irq_restore(flags);
1099         result = ((status & SDR_TSRE) ? TIOCSER_TEMT : 0);
1100         if (copy_to_user(value, &result, sizeof(int)))
1101                 return -EFAULT;
1102         return 0;
1103 }
1104
1105
1106 static int rs_tiocmget(struct tty_struct *tty)
1107 {
1108         struct serial_state *info = tty->driver_data;
1109         unsigned char control, status;
1110         unsigned long flags;
1111
1112         if (serial_paranoia_check(info, tty->name, "rs_ioctl"))
1113                 return -ENODEV;
1114         if (tty_io_error(tty))
1115                 return -EIO;
1116
1117         control = info->MCR;
1118         local_irq_save(flags);
1119         status = ciab.pra;
1120         local_irq_restore(flags);
1121         return    ((control & SER_RTS) ? TIOCM_RTS : 0)
1122                 | ((control & SER_DTR) ? TIOCM_DTR : 0)
1123                 | (!(status  & SER_DCD) ? TIOCM_CAR : 0)
1124                 | (!(status  & SER_DSR) ? TIOCM_DSR : 0)
1125                 | (!(status  & SER_CTS) ? TIOCM_CTS : 0);
1126 }
1127
1128 static int rs_tiocmset(struct tty_struct *tty, unsigned int set,
1129                                                 unsigned int clear)
1130 {
1131         struct serial_state *info = tty->driver_data;
1132         unsigned long flags;
1133
1134         if (serial_paranoia_check(info, tty->name, "rs_ioctl"))
1135                 return -ENODEV;
1136         if (tty_io_error(tty))
1137                 return -EIO;
1138
1139         local_irq_save(flags);
1140         if (set & TIOCM_RTS)
1141                 info->MCR |= SER_RTS;
1142         if (set & TIOCM_DTR)
1143                 info->MCR |= SER_DTR;
1144         if (clear & TIOCM_RTS)
1145                 info->MCR &= ~SER_RTS;
1146         if (clear & TIOCM_DTR)
1147                 info->MCR &= ~SER_DTR;
1148         rtsdtr_ctrl(info->MCR);
1149         local_irq_restore(flags);
1150         return 0;
1151 }
1152
1153 /*
1154  * rs_break() --- routine which turns the break handling on or off
1155  */
1156 static int rs_break(struct tty_struct *tty, int break_state)
1157 {
1158         struct serial_state *info = tty->driver_data;
1159         unsigned long flags;
1160
1161         if (serial_paranoia_check(info, tty->name, "rs_break"))
1162                 return -EINVAL;
1163
1164         local_irq_save(flags);
1165         if (break_state == -1)
1166           custom.adkcon = AC_SETCLR | AC_UARTBRK;
1167         else
1168           custom.adkcon = AC_UARTBRK;
1169         mb();
1170         local_irq_restore(flags);
1171         return 0;
1172 }
1173
1174 /*
1175  * Get counter of input serial line interrupts (DCD,RI,DSR,CTS)
1176  * Return: write counters to the user passed counter struct
1177  * NB: both 1->0 and 0->1 transitions are counted except for
1178  *     RI where only 0->1 is counted.
1179  */
1180 static int rs_get_icount(struct tty_struct *tty,
1181                                 struct serial_icounter_struct *icount)
1182 {
1183         struct serial_state *info = tty->driver_data;
1184         struct async_icount cnow;
1185         unsigned long flags;
1186
1187         local_irq_save(flags);
1188         cnow = info->icount;
1189         local_irq_restore(flags);
1190         icount->cts = cnow.cts;
1191         icount->dsr = cnow.dsr;
1192         icount->rng = cnow.rng;
1193         icount->dcd = cnow.dcd;
1194         icount->rx = cnow.rx;
1195         icount->tx = cnow.tx;
1196         icount->frame = cnow.frame;
1197         icount->overrun = cnow.overrun;
1198         icount->parity = cnow.parity;
1199         icount->brk = cnow.brk;
1200         icount->buf_overrun = cnow.buf_overrun;
1201
1202         return 0;
1203 }
1204
1205 static int rs_ioctl(struct tty_struct *tty,
1206                     unsigned int cmd, unsigned long arg)
1207 {
1208         struct serial_state *info = tty->driver_data;
1209         struct async_icount cprev, cnow;        /* kernel counter temps */
1210         void __user *argp = (void __user *)arg;
1211         unsigned long flags;
1212         DEFINE_WAIT(wait);
1213         int ret;
1214
1215         if (serial_paranoia_check(info, tty->name, "rs_ioctl"))
1216                 return -ENODEV;
1217
1218         if ((cmd != TIOCSERCONFIG) &&
1219             (cmd != TIOCMIWAIT) && (cmd != TIOCGICOUNT)) {
1220                 if (tty_io_error(tty))
1221                     return -EIO;
1222         }
1223
1224         switch (cmd) {
1225                 case TIOCSERCONFIG:
1226                         return 0;
1227
1228                 case TIOCSERGETLSR: /* Get line status register */
1229                         return get_lsr_info(info, argp);
1230
1231                 /*
1232                  * Wait for any of the 4 modem inputs (DCD,RI,DSR,CTS) to change
1233                  * - mask passed in arg for lines of interest
1234                  *   (use |'ed TIOCM_RNG/DSR/CD/CTS for masking)
1235                  * Caller should use TIOCGICOUNT to see which one it was
1236                  */
1237                 case TIOCMIWAIT:
1238                         local_irq_save(flags);
1239                         /* note the counters on entry */
1240                         cprev = info->icount;
1241                         local_irq_restore(flags);
1242                         while (1) {
1243                                 prepare_to_wait(&info->tport.delta_msr_wait,
1244                                                 &wait, TASK_INTERRUPTIBLE);
1245                                 local_irq_save(flags);
1246                                 cnow = info->icount; /* atomic copy */
1247                                 local_irq_restore(flags);
1248                                 if (cnow.rng == cprev.rng && cnow.dsr == cprev.dsr &&
1249                                     cnow.dcd == cprev.dcd && cnow.cts == cprev.cts) {
1250                                         ret = -EIO; /* no change => error */
1251                                         break;
1252                                 }
1253                                 if ( ((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) ||
1254                                      ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) ||
1255                                      ((arg & TIOCM_CD)  && (cnow.dcd != cprev.dcd)) ||
1256                                      ((arg & TIOCM_CTS) && (cnow.cts != cprev.cts)) ) {
1257                                         ret = 0;
1258                                         break;
1259                                 }
1260                                 schedule();
1261                                 /* see if a signal did it */
1262                                 if (signal_pending(current)) {
1263                                         ret = -ERESTARTSYS;
1264                                         break;
1265                                 }
1266                                 cprev = cnow;
1267                         }
1268                         finish_wait(&info->tport.delta_msr_wait, &wait);
1269                         return ret;
1270
1271                 default:
1272                         return -ENOIOCTLCMD;
1273                 }
1274         return 0;
1275 }
1276
1277 static void rs_set_termios(struct tty_struct *tty, struct ktermios *old_termios)
1278 {
1279         struct serial_state *info = tty->driver_data;
1280         unsigned long flags;
1281         unsigned int cflag = tty->termios.c_cflag;
1282
1283         change_speed(tty, info, old_termios);
1284
1285         /* Handle transition to B0 status */
1286         if ((old_termios->c_cflag & CBAUD) && !(cflag & CBAUD)) {
1287                 info->MCR &= ~(SER_DTR|SER_RTS);
1288                 local_irq_save(flags);
1289                 rtsdtr_ctrl(info->MCR);
1290                 local_irq_restore(flags);
1291         }
1292
1293         /* Handle transition away from B0 status */
1294         if (!(old_termios->c_cflag & CBAUD) && (cflag & CBAUD)) {
1295                 info->MCR |= SER_DTR;
1296                 if (!C_CRTSCTS(tty) || !tty_throttled(tty))
1297                         info->MCR |= SER_RTS;
1298                 local_irq_save(flags);
1299                 rtsdtr_ctrl(info->MCR);
1300                 local_irq_restore(flags);
1301         }
1302
1303         /* Handle turning off CRTSCTS */
1304         if ((old_termios->c_cflag & CRTSCTS) && !C_CRTSCTS(tty)) {
1305                 tty->hw_stopped = 0;
1306                 rs_start(tty);
1307         }
1308
1309 #if 0
1310         /*
1311          * No need to wake up processes in open wait, since they
1312          * sample the CLOCAL flag once, and don't recheck it.
1313          * XXX  It's not clear whether the current behavior is correct
1314          * or not.  Hence, this may change.....
1315          */
1316         if (!(old_termios->c_cflag & CLOCAL) && C_CLOCAL(tty))
1317                 wake_up_interruptible(&info->open_wait);
1318 #endif
1319 }
1320
1321 /*
1322  * ------------------------------------------------------------
1323  * rs_close()
1324  *
1325  * This routine is called when the serial port gets closed.  First, we
1326  * wait for the last remaining data to be sent.  Then, we unlink its
1327  * async structure from the interrupt chain if necessary, and we free
1328  * that IRQ if nothing is left in the chain.
1329  * ------------------------------------------------------------
1330  */
1331 static void rs_close(struct tty_struct *tty, struct file * filp)
1332 {
1333         struct serial_state *state = tty->driver_data;
1334         struct tty_port *port = &state->tport;
1335
1336         if (serial_paranoia_check(state, tty->name, "rs_close"))
1337                 return;
1338
1339         if (tty_port_close_start(port, tty, filp) == 0)
1340                 return;
1341
1342         /*
1343          * At this point we stop accepting input.  To do this, we
1344          * disable the receive line status interrupts, and tell the
1345          * interrupt driver to stop checking the data ready bit in the
1346          * line status register.
1347          */
1348         state->read_status_mask &= ~UART_LSR_DR;
1349         if (tty_port_initialized(port)) {
1350                 /* disable receive interrupts */
1351                 custom.intena = IF_RBF;
1352                 mb();
1353                 /* clear any pending receive interrupt */
1354                 custom.intreq = IF_RBF;
1355                 mb();
1356
1357                 /*
1358                  * Before we drop DTR, make sure the UART transmitter
1359                  * has completely drained; this is especially
1360                  * important if there is a transmit FIFO!
1361                  */
1362                 rs_wait_until_sent(tty, state->timeout);
1363         }
1364         shutdown(tty, state);
1365         rs_flush_buffer(tty);
1366
1367         tty_ldisc_flush(tty);
1368         port->tty = NULL;
1369
1370         tty_port_close_end(port, tty);
1371 }
1372
1373 /*
1374  * rs_wait_until_sent() --- wait until the transmitter is empty
1375  */
1376 static void rs_wait_until_sent(struct tty_struct *tty, int timeout)
1377 {
1378         struct serial_state *info = tty->driver_data;
1379         unsigned long orig_jiffies, char_time;
1380         int lsr;
1381
1382         if (serial_paranoia_check(info, tty->name, "rs_wait_until_sent"))
1383                 return;
1384
1385         if (info->xmit_fifo_size == 0)
1386                 return; /* Just in case.... */
1387
1388         orig_jiffies = jiffies;
1389
1390         /*
1391          * Set the check interval to be 1/5 of the estimated time to
1392          * send a single character, and make it at least 1.  The check
1393          * interval should also be less than the timeout.
1394          *
1395          * Note: we have to use pretty tight timings here to satisfy
1396          * the NIST-PCTS.
1397          */
1398         char_time = (info->timeout - HZ/50) / info->xmit_fifo_size;
1399         char_time = char_time / 5;
1400         if (char_time == 0)
1401                 char_time = 1;
1402         if (timeout)
1403           char_time = min_t(unsigned long, char_time, timeout);
1404         /*
1405          * If the transmitter hasn't cleared in twice the approximate
1406          * amount of time to send the entire FIFO, it probably won't
1407          * ever clear.  This assumes the UART isn't doing flow
1408          * control, which is currently the case.  Hence, if it ever
1409          * takes longer than info->timeout, this is probably due to a
1410          * UART bug of some kind.  So, we clamp the timeout parameter at
1411          * 2*info->timeout.
1412          */
1413         if (!timeout || timeout > 2*info->timeout)
1414                 timeout = 2*info->timeout;
1415 #ifdef SERIAL_DEBUG_RS_WAIT_UNTIL_SENT
1416         printk("In rs_wait_until_sent(%d) check=%lu...", timeout, char_time);
1417         printk("jiff=%lu...", jiffies);
1418 #endif
1419         while(!((lsr = custom.serdatr) & SDR_TSRE)) {
1420 #ifdef SERIAL_DEBUG_RS_WAIT_UNTIL_SENT
1421                 printk("serdatr = %d (jiff=%lu)...", lsr, jiffies);
1422 #endif
1423                 msleep_interruptible(jiffies_to_msecs(char_time));
1424                 if (signal_pending(current))
1425                         break;
1426                 if (timeout && time_after(jiffies, orig_jiffies + timeout))
1427                         break;
1428         }
1429         __set_current_state(TASK_RUNNING);
1430
1431 #ifdef SERIAL_DEBUG_RS_WAIT_UNTIL_SENT
1432         printk("lsr = %d (jiff=%lu)...done\n", lsr, jiffies);
1433 #endif
1434 }
1435
1436 /*
1437  * rs_hangup() --- called by tty_hangup() when a hangup is signaled.
1438  */
1439 static void rs_hangup(struct tty_struct *tty)
1440 {
1441         struct serial_state *info = tty->driver_data;
1442
1443         if (serial_paranoia_check(info, tty->name, "rs_hangup"))
1444                 return;
1445
1446         rs_flush_buffer(tty);
1447         shutdown(tty, info);
1448         info->tport.count = 0;
1449         tty_port_set_active(&info->tport, 0);
1450         info->tport.tty = NULL;
1451         wake_up_interruptible(&info->tport.open_wait);
1452 }
1453
1454 /*
1455  * This routine is called whenever a serial port is opened.  It
1456  * enables interrupts for a serial port, linking in its async structure into
1457  * the IRQ chain.   It also performs the serial-specific
1458  * initialization for the tty structure.
1459  */
1460 static int rs_open(struct tty_struct *tty, struct file * filp)
1461 {
1462         struct serial_state *info = rs_table + tty->index;
1463         struct tty_port *port = &info->tport;
1464         int retval;
1465
1466         port->count++;
1467         port->tty = tty;
1468         tty->driver_data = info;
1469         tty->port = port;
1470         if (serial_paranoia_check(info, tty->name, "rs_open"))
1471                 return -ENODEV;
1472
1473         port->low_latency = (port->flags & ASYNC_LOW_LATENCY) ? 1 : 0;
1474
1475         retval = startup(tty, info);
1476         if (retval) {
1477                 return retval;
1478         }
1479
1480         return tty_port_block_til_ready(port, tty, filp);
1481 }
1482
1483 /*
1484  * /proc fs routines....
1485  */
1486
1487 static inline void line_info(struct seq_file *m, int line,
1488                 struct serial_state *state)
1489 {
1490         char    stat_buf[30], control, status;
1491         unsigned long flags;
1492
1493         seq_printf(m, "%d: uart:amiga_builtin", line);
1494
1495         local_irq_save(flags);
1496         status = ciab.pra;
1497         control = tty_port_initialized(&state->tport) ? state->MCR : status;
1498         local_irq_restore(flags);
1499
1500         stat_buf[0] = 0;
1501         stat_buf[1] = 0;
1502         if(!(control & SER_RTS))
1503                 strcat(stat_buf, "|RTS");
1504         if(!(status & SER_CTS))
1505                 strcat(stat_buf, "|CTS");
1506         if(!(control & SER_DTR))
1507                 strcat(stat_buf, "|DTR");
1508         if(!(status & SER_DSR))
1509                 strcat(stat_buf, "|DSR");
1510         if(!(status & SER_DCD))
1511                 strcat(stat_buf, "|CD");
1512
1513         if (state->quot)
1514                 seq_printf(m, " baud:%d", state->baud_base / state->quot);
1515
1516         seq_printf(m, " tx:%d rx:%d", state->icount.tx, state->icount.rx);
1517
1518         if (state->icount.frame)
1519                 seq_printf(m, " fe:%d", state->icount.frame);
1520
1521         if (state->icount.parity)
1522                 seq_printf(m, " pe:%d", state->icount.parity);
1523
1524         if (state->icount.brk)
1525                 seq_printf(m, " brk:%d", state->icount.brk);
1526
1527         if (state->icount.overrun)
1528                 seq_printf(m, " oe:%d", state->icount.overrun);
1529
1530         /*
1531          * Last thing is the RS-232 status lines
1532          */
1533         seq_printf(m, " %s\n", stat_buf+1);
1534 }
1535
1536 static int rs_proc_show(struct seq_file *m, void *v)
1537 {
1538         seq_printf(m, "serinfo:1.0 driver:%s\n", serial_version);
1539         line_info(m, 0, &rs_table[0]);
1540         return 0;
1541 }
1542
1543 /*
1544  * ---------------------------------------------------------------------
1545  * rs_init() and friends
1546  *
1547  * rs_init() is called at boot-time to initialize the serial driver.
1548  * ---------------------------------------------------------------------
1549  */
1550
1551 /*
1552  * This routine prints out the appropriate serial driver version
1553  * number, and identifies which options were configured into this
1554  * driver.
1555  */
1556 static void show_serial_version(void)
1557 {
1558         printk(KERN_INFO "%s version %s\n", serial_name, serial_version);
1559 }
1560
1561
1562 static const struct tty_operations serial_ops = {
1563         .open = rs_open,
1564         .close = rs_close,
1565         .write = rs_write,
1566         .put_char = rs_put_char,
1567         .flush_chars = rs_flush_chars,
1568         .write_room = rs_write_room,
1569         .chars_in_buffer = rs_chars_in_buffer,
1570         .flush_buffer = rs_flush_buffer,
1571         .ioctl = rs_ioctl,
1572         .throttle = rs_throttle,
1573         .unthrottle = rs_unthrottle,
1574         .set_termios = rs_set_termios,
1575         .stop = rs_stop,
1576         .start = rs_start,
1577         .hangup = rs_hangup,
1578         .break_ctl = rs_break,
1579         .send_xchar = rs_send_xchar,
1580         .wait_until_sent = rs_wait_until_sent,
1581         .tiocmget = rs_tiocmget,
1582         .tiocmset = rs_tiocmset,
1583         .get_icount = rs_get_icount,
1584         .set_serial = set_serial_info,
1585         .get_serial = get_serial_info,
1586         .proc_show = rs_proc_show,
1587 };
1588
1589 static int amiga_carrier_raised(struct tty_port *port)
1590 {
1591         return !(ciab.pra & SER_DCD);
1592 }
1593
1594 static void amiga_dtr_rts(struct tty_port *port, int raise)
1595 {
1596         struct serial_state *info = container_of(port, struct serial_state,
1597                         tport);
1598         unsigned long flags;
1599
1600         if (raise)
1601                 info->MCR |= SER_DTR|SER_RTS;
1602         else
1603                 info->MCR &= ~(SER_DTR|SER_RTS);
1604
1605         local_irq_save(flags);
1606         rtsdtr_ctrl(info->MCR);
1607         local_irq_restore(flags);
1608 }
1609
1610 static const struct tty_port_operations amiga_port_ops = {
1611         .carrier_raised = amiga_carrier_raised,
1612         .dtr_rts = amiga_dtr_rts,
1613 };
1614
1615 /*
1616  * The serial driver boot-time initialization code!
1617  */
1618 static int __init amiga_serial_probe(struct platform_device *pdev)
1619 {
1620         unsigned long flags;
1621         struct serial_state * state;
1622         int error;
1623
1624         serial_driver = alloc_tty_driver(NR_PORTS);
1625         if (!serial_driver)
1626                 return -ENOMEM;
1627
1628         show_serial_version();
1629
1630         /* Initialize the tty_driver structure */
1631
1632         serial_driver->driver_name = "amiserial";
1633         serial_driver->name = "ttyS";
1634         serial_driver->major = TTY_MAJOR;
1635         serial_driver->minor_start = 64;
1636         serial_driver->type = TTY_DRIVER_TYPE_SERIAL;
1637         serial_driver->subtype = SERIAL_TYPE_NORMAL;
1638         serial_driver->init_termios = tty_std_termios;
1639         serial_driver->init_termios.c_cflag =
1640                 B9600 | CS8 | CREAD | HUPCL | CLOCAL;
1641         serial_driver->flags = TTY_DRIVER_REAL_RAW;
1642         tty_set_operations(serial_driver, &serial_ops);
1643
1644         state = rs_table;
1645         state->port = (int)&custom.serdatr; /* Just to give it a value */
1646         state->custom_divisor = 0;
1647         state->icount.cts = state->icount.dsr =
1648           state->icount.rng = state->icount.dcd = 0;
1649         state->icount.rx = state->icount.tx = 0;
1650         state->icount.frame = state->icount.parity = 0;
1651         state->icount.overrun = state->icount.brk = 0;
1652         tty_port_init(&state->tport);
1653         state->tport.ops = &amiga_port_ops;
1654         tty_port_link_device(&state->tport, serial_driver, 0);
1655
1656         error = tty_register_driver(serial_driver);
1657         if (error)
1658                 goto fail_put_tty_driver;
1659
1660         printk(KERN_INFO "ttyS0 is the amiga builtin serial port\n");
1661
1662         /* Hardware set up */
1663
1664         state->baud_base = amiga_colorclock;
1665         state->xmit_fifo_size = 1;
1666
1667         /* set ISRs, and then disable the rx interrupts */
1668         error = request_irq(IRQ_AMIGA_TBE, ser_tx_int, 0, "serial TX", state);
1669         if (error)
1670                 goto fail_unregister;
1671
1672         error = request_irq(IRQ_AMIGA_RBF, ser_rx_int, 0,
1673                             "serial RX", state);
1674         if (error)
1675                 goto fail_free_irq;
1676
1677         local_irq_save(flags);
1678
1679         /* turn off Rx and Tx interrupts */
1680         custom.intena = IF_RBF | IF_TBE;
1681         mb();
1682
1683         /* clear any pending interrupt */
1684         custom.intreq = IF_RBF | IF_TBE;
1685         mb();
1686
1687         local_irq_restore(flags);
1688
1689         /*
1690          * set the appropriate directions for the modem control flags,
1691          * and clear RTS and DTR
1692          */
1693         ciab.ddra |= (SER_DTR | SER_RTS);   /* outputs */
1694         ciab.ddra &= ~(SER_DCD | SER_CTS | SER_DSR);  /* inputs */
1695
1696         platform_set_drvdata(pdev, state);
1697
1698         return 0;
1699
1700 fail_free_irq:
1701         free_irq(IRQ_AMIGA_TBE, state);
1702 fail_unregister:
1703         tty_unregister_driver(serial_driver);
1704 fail_put_tty_driver:
1705         tty_port_destroy(&state->tport);
1706         put_tty_driver(serial_driver);
1707         return error;
1708 }
1709
1710 static int __exit amiga_serial_remove(struct platform_device *pdev)
1711 {
1712         int error;
1713         struct serial_state *state = platform_get_drvdata(pdev);
1714
1715         /* printk("Unloading %s: version %s\n", serial_name, serial_version); */
1716         error = tty_unregister_driver(serial_driver);
1717         if (error)
1718                 printk("SERIAL: failed to unregister serial driver (%d)\n",
1719                        error);
1720         put_tty_driver(serial_driver);
1721         tty_port_destroy(&state->tport);
1722
1723         free_irq(IRQ_AMIGA_TBE, state);
1724         free_irq(IRQ_AMIGA_RBF, state);
1725
1726         return error;
1727 }
1728
1729 static struct platform_driver amiga_serial_driver = {
1730         .remove = __exit_p(amiga_serial_remove),
1731         .driver   = {
1732                 .name   = "amiga-serial",
1733         },
1734 };
1735
1736 module_platform_driver_probe(amiga_serial_driver, amiga_serial_probe);
1737
1738
1739 #if defined(CONFIG_SERIAL_CONSOLE) && !defined(MODULE)
1740
1741 /*
1742  * ------------------------------------------------------------
1743  * Serial console driver
1744  * ------------------------------------------------------------
1745  */
1746
1747 static void amiga_serial_putc(char c)
1748 {
1749         custom.serdat = (unsigned char)c | 0x100;
1750         while (!(custom.serdatr & 0x2000))
1751                 barrier();
1752 }
1753
1754 /*
1755  *      Print a string to the serial port trying not to disturb
1756  *      any possible real use of the port...
1757  *
1758  *      The console must be locked when we get here.
1759  */
1760 static void serial_console_write(struct console *co, const char *s,
1761                                 unsigned count)
1762 {
1763         unsigned short intena = custom.intenar;
1764
1765         custom.intena = IF_TBE;
1766
1767         while (count--) {
1768                 if (*s == '\n')
1769                         amiga_serial_putc('\r');
1770                 amiga_serial_putc(*s++);
1771         }
1772
1773         custom.intena = IF_SETCLR | (intena & IF_TBE);
1774 }
1775
1776 static struct tty_driver *serial_console_device(struct console *c, int *index)
1777 {
1778         *index = 0;
1779         return serial_driver;
1780 }
1781
1782 static struct console sercons = {
1783         .name =         "ttyS",
1784         .write =        serial_console_write,
1785         .device =       serial_console_device,
1786         .flags =        CON_PRINTBUFFER,
1787         .index =        -1,
1788 };
1789
1790 /*
1791  *      Register console.
1792  */
1793 static int __init amiserial_console_init(void)
1794 {
1795         if (!MACH_IS_AMIGA)
1796                 return -ENODEV;
1797
1798         register_console(&sercons);
1799         return 0;
1800 }
1801 console_initcall(amiserial_console_init);
1802
1803 #endif /* CONFIG_SERIAL_CONSOLE && !MODULE */
1804
1805 MODULE_LICENSE("GPL");
1806 MODULE_ALIAS("platform:amiga-serial");