drivers/char/riscom8.c

   1 /*
   2  *      linux/drivers/char/riscom.c  -- RISCom/8 multiport serial driver.
   3  *
   4  *      Copyright (C) 1994-1996  Dmitry Gorodchanin (pgmdsg@ibi.com)
   5  *
   6  *      This code is loosely based on the Linux serial driver, written by
   7  *      Linus Torvalds, Theodore T'so and others. The RISCom/8 card
   8  *      programming info was obtained from various drivers for other OSes
   9  *      (FreeBSD, ISC, etc), but no source code from those drivers were
  10  *      directly included in this driver.
  11  *
  12  *
  13  *      This program is free software; you can redistribute it and/or modify
  14  *      it under the terms of the GNU General Public License as published by
  15  *      the Free Software Foundation; either version 2 of the License, or
  16  *      (at your option) any later version.
  17  *
  18  *      This program is distributed in the hope that it will be useful,
  19  *      but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  *      GNU General Public License for more details.
  22  *
  23  *      You should have received a copy of the GNU General Public License
  24  *      along with this program; if not, write to the Free Software
  25  *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  26  *
  27  *      Revision 1.1
  28  *
  29  *      ChangeLog:
  30  *      Arnaldo Carvalho de Melo <acme@conectiva.com.br> - 27-Jun-2001
  31  *      - get rid of check_region and several cleanups
  32  */
  33
  34 #include <linux/module.h>
  35
  36 #include <linux/io.h>
  37 #include <linux/kernel.h>
  38 #include <linux/sched.h>
  39 #include <linux/ioport.h>
  40 #include <linux/interrupt.h>
  41 #include <linux/errno.h>
  42 #include <linux/tty.h>
  43 #include <linux/mm.h>
  44 #include <linux/serial.h>
  45 #include <linux/fcntl.h>
  46 #include <linux/major.h>
  47 #include <linux/init.h>
  48 #include <linux/delay.h>
  49 #include <linux/tty_flip.h>
  50 #include <linux/spinlock.h>
  51 #include <linux/device.h>
  52
  53 #include <linux/uaccess.h>
  54
  55 #include "riscom8.h"
  56 #include "riscom8_reg.h"
  57
  58 /* Am I paranoid or not ? ;-) */
  59 #define RISCOM_PARANOIA_CHECK
  60
  61 /*
  62  * Crazy InteliCom/8 boards sometimes have swapped CTS & DSR signals.
  63  * You can slightly speed up things by #undefing the following option,
  64  * if you are REALLY sure that your board is correct one.
  65  */
  66
  67 #define RISCOM_BRAIN_DAMAGED_CTS
  68
  69 /*
  70  * The following defines are mostly for testing purposes. But if you need
  71  * some nice reporting in your syslog, you can define them also.
  72  */
  73 #undef RC_REPORT_FIFO
  74 #undef RC_REPORT_OVERRUN
  75
  76
  77 #define RISCOM_LEGAL_FLAGS \
  78         (ASYNC_HUP_NOTIFY   | ASYNC_SAK          | ASYNC_SPLIT_TERMIOS   | \
  79          ASYNC_SPD_HI       | ASYNC_SPEED_VHI    | ASYNC_SESSION_LOCKOUT | \
  80          ASYNC_PGRP_LOCKOUT | ASYNC_CALLOUT_NOHUP)
  81
  82 static struct tty_driver *riscom_driver;
  83
  84 static DEFINE_SPINLOCK(riscom_lock);
  85
  86 static struct riscom_board rc_board[RC_NBOARD] =  {
  87         {
  88                 .base   = RC_IOBASE1,
  89         },
  90         {
  91                 .base   = RC_IOBASE2,
  92         },
  93         {
  94                 .base   = RC_IOBASE3,
  95         },
  96         {
  97                 .base   = RC_IOBASE4,
  98         },
  99 };
 100
 101 static struct riscom_port rc_port[RC_NBOARD * RC_NPORT];
 102
 103 /* RISCom/8 I/O ports addresses (without address translation) */
 104 static unsigned short rc_ioport[] =  {
 105 #if 1
 106         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x09, 0x0a, 0x0b, 0x0c,
 107 #else
 108         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x09, 0x0a, 0x0b, 0x0c, 0x10,
 109         0x11, 0x12, 0x18, 0x28, 0x31, 0x32, 0x39, 0x3a, 0x40, 0x41, 0x61, 0x62,
 110         0x63, 0x64, 0x6b, 0x70, 0x71, 0x78, 0x7a, 0x7b, 0x7f, 0x100, 0x101
 111 #endif
 112 };
 113 #define RC_NIOPORT      ARRAY_SIZE(rc_ioport)
 114
 115
 116 static int rc_paranoia_check(struct riscom_port const *port,
 117                                     char *name, const char *routine)
 118 {
 119 #ifdef RISCOM_PARANOIA_CHECK
 120         static const char badmagic[] = KERN_INFO
 121                 "rc: Warning: bad riscom port magic number for device %s in %s\n";
 122         static const char badinfo[] = KERN_INFO
 123                 "rc: Warning: null riscom port for device %s in %s\n";
 124
 125         if (!port) {
 126                 printk(badinfo, name, routine);
 127                 return 1;
 128         }
 129         if (port->magic != RISCOM8_MAGIC) {
 130                 printk(badmagic, name, routine);
 131                 return 1;
 132         }
 133 #endif
 134         return 0;
 135 }
 136
 137 /*
 138  *
 139  *  Service functions for RISCom/8 driver.
 140  *
 141  */
 142
 143 /* Get board number from pointer */
 144 static inline int board_No(struct riscom_board const *bp)
 145 {
 146         return bp - rc_board;
 147 }
 148
 149 /* Get port number from pointer */
 150 static inline int port_No(struct riscom_port const *port)
 151 {
 152         return RC_PORT(port - rc_port);
 153 }
 154
 155 /* Get pointer to board from pointer to port */
 156 static inline struct riscom_board *port_Board(struct riscom_port const *port)
 157 {
 158         return &rc_board[RC_BOARD(port - rc_port)];
 159 }
 160
 161 /* Input Byte from CL CD180 register */
 162 static inline unsigned char rc_in(struct riscom_board const *bp,
 163                                                         unsigned short reg)
 164 {
 165         return inb(bp->base + RC_TO_ISA(reg));
 166 }
 167
 168 /* Output Byte to CL CD180 register */
 169 static inline void rc_out(struct riscom_board const *bp, unsigned short reg,
 170                           unsigned char val)
 171 {
 172         outb(val, bp->base + RC_TO_ISA(reg));
 173 }
 174
 175 /* Wait for Channel Command Register ready */
 176 static void rc_wait_CCR(struct riscom_board const *bp)
 177 {
 178         unsigned long delay;
 179
 180         /* FIXME: need something more descriptive then 100000 :) */
 181         for (delay = 100000; delay; delay--)
 182                 if (!rc_in(bp, CD180_CCR))
 183                         return;
 184
 185         printk(KERN_INFO "rc%d: Timeout waiting for CCR.\n", board_No(bp));
 186 }
 187
 188 /*
 189  *  RISCom/8 probe functions.
 190  */
 191
 192 static int rc_request_io_range(struct riscom_board * const bp)
 193 {
 194         int i;
 195
 196         for (i = 0; i < RC_NIOPORT; i++)
 197                 if (!request_region(RC_TO_ISA(rc_ioport[i]) + bp->base, 1,
 198                                    "RISCom/8"))  {
 199                         goto out_release;
 200                 }
 201         return 0;
 202 out_release:
 203         printk(KERN_INFO "rc%d: Skipping probe at 0x%03x. IO address in use.\n",
 204                          board_No(bp), bp->base);
 205         while (--i >= 0)
 206                 release_region(RC_TO_ISA(rc_ioport[i]) + bp->base, 1);
 207         return 1;
 208 }
 209
 210 static void rc_release_io_range(struct riscom_board * const bp)
 211 {
 212         int i;
 213
 214         for (i = 0; i < RC_NIOPORT; i++)
 215                 release_region(RC_TO_ISA(rc_ioport[i]) + bp->base, 1);
 216 }
 217
 218 /* Reset and setup CD180 chip */
 219 static void __init rc_init_CD180(struct riscom_board const *bp)
 220 {
 221         unsigned long flags;
 222
 223         spin_lock_irqsave(&riscom_lock, flags);
 224
 225         rc_out(bp, RC_CTOUT, 0);                   /* Clear timeout        */
 226         rc_wait_CCR(bp);                           /* Wait for CCR ready   */
 227         rc_out(bp, CD180_CCR, CCR_HARDRESET);      /* Reset CD180 chip     */
 228         spin_unlock_irqrestore(&riscom_lock, flags);
 229         msleep(50);                                /* Delay 0.05 sec       */
 230         spin_lock_irqsave(&riscom_lock, flags);
 231         rc_out(bp, CD180_GIVR, RC_ID);             /* Set ID for this chip */
 232         rc_out(bp, CD180_GICR, 0);                 /* Clear all bits       */
 233         rc_out(bp, CD180_PILR1, RC_ACK_MINT);      /* Prio for modem intr  */
 234         rc_out(bp, CD180_PILR2, RC_ACK_TINT);      /* Prio for tx intr     */
 235         rc_out(bp, CD180_PILR3, RC_ACK_RINT);      /* Prio for rx intr     */
 236
 237         /* Setting up prescaler. We need 4 ticks per 1 ms */
 238         rc_out(bp, CD180_PPRH, (RC_OSCFREQ/(1000000/RISCOM_TPS)) >> 8);
 239         rc_out(bp, CD180_PPRL, (RC_OSCFREQ/(1000000/RISCOM_TPS)) & 0xff);
 240
 241         spin_unlock_irqrestore(&riscom_lock, flags);
 242 }
 243
 244 /* Main probing routine, also sets irq. */
 245 static int __init rc_probe(struct riscom_board *bp)
 246 {
 247         unsigned char val1, val2;
 248         int irqs = 0;
 249         int retries;
 250
 251         bp->irq = 0;
 252
 253         if (rc_request_io_range(bp))
 254                 return 1;
 255
 256         /* Are the I/O ports here ? */
 257         rc_out(bp, CD180_PPRL, 0x5a);
 258         outb(0xff, 0x80);
 259         val1 = rc_in(bp, CD180_PPRL);
 260         rc_out(bp, CD180_PPRL, 0xa5);
 261         outb(0x00, 0x80);
 262         val2 = rc_in(bp, CD180_PPRL);
 263
 264         if ((val1 != 0x5a) || (val2 != 0xa5))  {
 265                 printk(KERN_ERR "rc%d: RISCom/8 Board at 0x%03x not found.\n",
 266                        board_No(bp), bp->base);
 267                 goto out_release;
 268         }
 269
 270         /* It's time to find IRQ for this board */
 271         for (retries = 0; retries < 5 && irqs <= 0; retries++) {
 272                 irqs = probe_irq_on();
 273                 rc_init_CD180(bp);               /* Reset CD180 chip         */
 274                 rc_out(bp, CD180_CAR, 2);        /* Select port 2            */
 275                 rc_wait_CCR(bp);
 276                 rc_out(bp, CD180_CCR, CCR_TXEN); /* Enable transmitter       */
 277                 rc_out(bp, CD180_IER, IER_TXRDY);/* Enable tx empty intr     */
 278                 msleep(50);
 279                 irqs = probe_irq_off(irqs);
 280                 val1 = rc_in(bp, RC_BSR);       /* Get Board Status reg      */
 281                 val2 = rc_in(bp, RC_ACK_TINT);  /* ACK interrupt             */
 282                 rc_init_CD180(bp);              /* Reset CD180 again         */
 283
 284                 if ((val1 & RC_BSR_TINT) || (val2 != (RC_ID | GIVR_IT_TX)))  {
 285                         printk(KERN_ERR "rc%d: RISCom/8 Board at 0x%03x not "
 286                                         "found.\n", board_No(bp), bp->base);
 287                         goto out_release;
 288                 }
 289         }
 290
 291         if (irqs <= 0)  {
 292                 printk(KERN_ERR "rc%d: Can't find IRQ for RISCom/8 board "
 293                                 "at 0x%03x.\n", board_No(bp), bp->base);
 294                 goto out_release;
 295         }
 296         bp->irq = irqs;
 297         bp->flags |= RC_BOARD_PRESENT;
 298
 299         printk(KERN_INFO "rc%d: RISCom/8 Rev. %c board detected at "
 300                          "0x%03x, IRQ %d.\n",
 301                board_No(bp),
 302                (rc_in(bp, CD180_GFRCR) & 0x0f) + 'A',   /* Board revision */
 303                bp->base, bp->irq);
 304
 305         return 0;
 306 out_release:
 307         rc_release_io_range(bp);
 308         return 1;
 309 }
 310
 311 /*
 312  *
 313  *  Interrupt processing routines.
 314  *
 315  */
 316
 317 static struct riscom_port *rc_get_port(struct riscom_board const *bp,
 318                                                unsigned char const *what)
 319 {
 320         unsigned char channel;
 321         struct riscom_port *port;
 322
 323         channel = rc_in(bp, CD180_GICR) >> GICR_CHAN_OFF;
 324         if (channel < CD180_NCH)  {
 325                 port = &rc_port[board_No(bp) * RC_NPORT + channel];
 326                 if (port->port.flags & ASYNC_INITIALIZED)
 327                         return port;
 328         }
 329         printk(KERN_ERR "rc%d: %s interrupt from invalid port %d\n",
 330                board_No(bp), what, channel);
 331         return NULL;
 332 }
 333
 334 static void rc_receive_exc(struct riscom_board const *bp)
 335 {
 336         struct riscom_port *port;
 337         struct tty_struct *tty;
 338         unsigned char status;
 339         unsigned char ch, flag;
 340
 341         port = rc_get_port(bp, "Receive");
 342         if (port == NULL)
 343                 return;
 344
 345         tty = tty_port_tty_get(&port->port);
 346
 347 #ifdef RC_REPORT_OVERRUN
 348         status = rc_in(bp, CD180_RCSR);
 349         if (status & RCSR_OE)
 350                 port->overrun++;
 351         status &= port->mark_mask;
 352 #else
 353         status = rc_in(bp, CD180_RCSR) & port->mark_mask;
 354 #endif
 355         ch = rc_in(bp, CD180_RDR);
 356         if (!status)
 357                 goto out;
 358         if (status & RCSR_TOUT)  {
 359                 printk(KERN_WARNING "rc%d: port %d: Receiver timeout. "
 360                                     "Hardware problems ?\n",
 361                        board_No(bp), port_No(port));
 362                 goto out;
 363
 364         } else if (status & RCSR_BREAK)  {
 365                 printk(KERN_INFO "rc%d: port %d: Handling break...\n",
 366                        board_No(bp), port_No(port));
 367                 flag = TTY_BREAK;
 368                 if (tty && (port->port.flags & ASYNC_SAK))
 369                         do_SAK(tty);
 370
 371         } else if (status & RCSR_PE)
 372                 flag = TTY_PARITY;
 373
 374         else if (status & RCSR_FE)
 375                 flag = TTY_FRAME;
 376
 377         else if (status & RCSR_OE)
 378                 flag = TTY_OVERRUN;
 379         else
 380                 flag = TTY_NORMAL;
 381
 382         if (tty) {
 383                 tty_insert_flip_char(tty, ch, flag);
 384                 tty_flip_buffer_push(tty);
 385         }
 386 out:
 387         tty_kref_put(tty);
 388 }
 389
 390 static void rc_receive(struct riscom_board const *bp)
 391 {
 392         struct riscom_port *port;
 393         struct tty_struct *tty;
 394         unsigned char count;
 395
 396         port = rc_get_port(bp, "Receive");
 397         if (port == NULL)
 398                 return;
 399
 400         tty = tty_port_tty_get(&port->port);
 401
 402         count = rc_in(bp, CD180_RDCR);
 403
 404 #ifdef RC_REPORT_FIFO
 405         port->hits[count > 8 ? 9 : count]++;
 406 #endif
 407
 408         while (count--)  {
 409                 u8 ch = rc_in(bp, CD180_RDR);
 410                 if (tty)
 411                         tty_insert_flip_char(tty, ch, TTY_NORMAL);
 412         }
 413         if (tty) {
 414                 tty_flip_buffer_push(tty);
 415                 tty_kref_put(tty);
 416         }
 417 }
 418
 419 static void rc_transmit(struct riscom_board const *bp)
 420 {
 421         struct riscom_port *port;
 422         struct tty_struct *tty;
 423         unsigned char count;
 424
 425         port = rc_get_port(bp, "Transmit");
 426         if (port == NULL)
 427                 return;
 428
 429         tty = tty_port_tty_get(&port->port);
 430
 431         if (port->IER & IER_TXEMPTY) {
 432                 /* FIFO drained */
 433                 rc_out(bp, CD180_CAR, port_No(port));
 434                 port->IER &= ~IER_TXEMPTY;
 435                 rc_out(bp, CD180_IER, port->IER);
 436                 goto out;
 437         }
 438
 439         if ((port->xmit_cnt <= 0 && !port->break_length)
 440             || (tty && (tty->stopped || tty->hw_stopped)))  {
 441                 rc_out(bp, CD180_CAR, port_No(port));
 442                 port->IER &= ~IER_TXRDY;
 443                 rc_out(bp, CD180_IER, port->IER);
 444                 goto out;
 445         }
 446
 447         if (port->break_length)  {
 448                 if (port->break_length > 0)  {
 449                         if (port->COR2 & COR2_ETC)  {
 450                                 rc_out(bp, CD180_TDR, CD180_C_ESC);
 451                                 rc_out(bp, CD180_TDR, CD180_C_SBRK);
 452                                 port->COR2 &= ~COR2_ETC;
 453                         }
 454                         count = min_t(int, port->break_length, 0xff);
 455                         rc_out(bp, CD180_TDR, CD180_C_ESC);
 456                         rc_out(bp, CD180_TDR, CD180_C_DELAY);
 457                         rc_out(bp, CD180_TDR, count);
 458                         port->break_length -= count;
 459                         if (port->break_length == 0)
 460                                 port->break_length--;
 461                 } else  {
 462                         rc_out(bp, CD180_TDR, CD180_C_ESC);
 463                         rc_out(bp, CD180_TDR, CD180_C_EBRK);
 464                         rc_out(bp, CD180_COR2, port->COR2);
 465                         rc_wait_CCR(bp);
 466                         rc_out(bp, CD180_CCR, CCR_CORCHG2);
 467                         port->break_length = 0;
 468                 }
 469                 goto out;
 470         }
 471
 472         count = CD180_NFIFO;
 473         do {
 474                 rc_out(bp, CD180_TDR, port->port.xmit_buf[port->xmit_tail++]);
 475                 port->xmit_tail = port->xmit_tail & (SERIAL_XMIT_SIZE-1);
 476                 if (--port->xmit_cnt <= 0)
 477                         break;
 478         } while (--count > 0);
 479
 480         if (port->xmit_cnt <= 0)  {
 481                 rc_out(bp, CD180_CAR, port_No(port));
 482                 port->IER &= ~IER_TXRDY;
 483                 rc_out(bp, CD180_IER, port->IER);
 484         }
 485         if (tty && port->xmit_cnt <= port->wakeup_chars)
 486                 tty_wakeup(tty);
 487 out:
 488         tty_kref_put(tty);
 489 }
 490
 491 static void rc_check_modem(struct riscom_board const *bp)
 492 {
 493         struct riscom_port *port;
 494         struct tty_struct *tty;
 495         unsigned char mcr;
 496
 497         port = rc_get_port(bp, "Modem");
 498         if (port == NULL)
 499                 return;
 500
 501         tty = tty_port_tty_get(&port->port);
 502
 503         mcr = rc_in(bp, CD180_MCR);
 504         if (mcr & MCR_CDCHG) {
 505                 if (rc_in(bp, CD180_MSVR) & MSVR_CD)
 506                         wake_up_interruptible(&port->port.open_wait);
 507                 else if (tty)
 508                         tty_hangup(tty);
 509         }
 510
 511 #ifdef RISCOM_BRAIN_DAMAGED_CTS
 512         if (mcr & MCR_CTSCHG)  {
 513                 if (rc_in(bp, CD180_MSVR) & MSVR_CTS)  {
 514                         port->IER |= IER_TXRDY;
 515                         if (tty) {
 516                                 tty->hw_stopped = 0;
 517                                 if (port->xmit_cnt <= port->wakeup_chars)
 518                                         tty_wakeup(tty);
 519                         }
 520                 } else  {
 521                         if (tty)
 522                                 tty->hw_stopped = 1;
 523                         port->IER &= ~IER_TXRDY;
 524                 }
 525                 rc_out(bp, CD180_IER, port->IER);
 526         }
 527         if (mcr & MCR_DSRCHG)  {
 528                 if (rc_in(bp, CD180_MSVR) & MSVR_DSR)  {
 529                         port->IER |= IER_TXRDY;
 530                         if (tty) {
 531                                 tty->hw_stopped = 0;
 532                                 if (port->xmit_cnt <= port->wakeup_chars)
 533                                         tty_wakeup(tty);
 534                         }
 535                 } else  {
 536                         if (tty)
 537                                 tty->hw_stopped = 1;
 538                         port->IER &= ~IER_TXRDY;
 539                 }
 540                 rc_out(bp, CD180_IER, port->IER);
 541         }
 542 #endif /* RISCOM_BRAIN_DAMAGED_CTS */
 543
 544         /* Clear change bits */
 545         rc_out(bp, CD180_MCR, 0);
 546         tty_kref_put(tty);
 547 }
 548
 549 /* The main interrupt processing routine */
 550 static irqreturn_t rc_interrupt(int dummy, void *dev_id)
 551 {
 552         unsigned char status;
 553         unsigned char ack;
 554         struct riscom_board *bp = dev_id;
 555         unsigned long loop = 0;
 556         int handled = 0;
 557
 558         if (!(bp->flags & RC_BOARD_ACTIVE))
 559                 return IRQ_NONE;
 560
 561         while ((++loop < 16) && ((status = ~(rc_in(bp, RC_BSR))) &
 562                                  (RC_BSR_TOUT | RC_BSR_TINT |
 563                                   RC_BSR_MINT | RC_BSR_RINT))) {
 564                 handled = 1;
 565                 if (status & RC_BSR_TOUT)
 566                         printk(KERN_WARNING "rc%d: Got timeout. Hardware "
 567                                             "error?\n", board_No(bp));
 568                 else if (status & RC_BSR_RINT) {
 569                         ack = rc_in(bp, RC_ACK_RINT);
 570                         if (ack == (RC_ID | GIVR_IT_RCV))
 571                                 rc_receive(bp);
 572                         else if (ack == (RC_ID | GIVR_IT_REXC))
 573                                 rc_receive_exc(bp);
 574                         else
 575                                 printk(KERN_WARNING "rc%d: Bad receive ack "
 576                                                     "0x%02x.\n",
 577                                        board_No(bp), ack);
 578                 } else if (status & RC_BSR_TINT) {
 579                         ack = rc_in(bp, RC_ACK_TINT);
 580                         if (ack == (RC_ID | GIVR_IT_TX))
 581                                 rc_transmit(bp);
 582                         else
 583                                 printk(KERN_WARNING "rc%d: Bad transmit ack "
 584                                                     "0x%02x.\n",
 585                                        board_No(bp), ack);
 586                 } else /* if (status & RC_BSR_MINT) */ {
 587                         ack = rc_in(bp, RC_ACK_MINT);
 588                         if (ack == (RC_ID | GIVR_IT_MODEM))
 589                                 rc_check_modem(bp);
 590                         else
 591                                 printk(KERN_WARNING "rc%d: Bad modem ack "
 592                                                     "0x%02x.\n",
 593                                        board_No(bp), ack);
 594                 }
 595                 rc_out(bp, CD180_EOIR, 0);   /* Mark end of interrupt */
 596                 rc_out(bp, RC_CTOUT, 0);     /* Clear timeout flag    */
 597         }
 598         return IRQ_RETVAL(handled);
 599 }
 600
 601 /*
 602  *  Routines for open & close processing.
 603  */
 604
 605 /* Called with disabled interrupts */
 606 static int rc_setup_board(struct riscom_board *bp)
 607 {
 608         int error;
 609
 610         if (bp->flags & RC_BOARD_ACTIVE)
 611                 return 0;
 612
 613         error = request_irq(bp->irq, rc_interrupt, IRQF_DISABLED,
 614                             "RISCom/8", bp);
 615         if (error)
 616                 return error;
 617
 618         rc_out(bp, RC_CTOUT, 0);                /* Just in case         */
 619         bp->DTR = ~0;
 620         rc_out(bp, RC_DTR, bp->DTR);            /* Drop DTR on all ports */
 621
 622         bp->flags |= RC_BOARD_ACTIVE;
 623
 624         return 0;
 625 }
 626
 627 /* Called with disabled interrupts */
 628 static void rc_shutdown_board(struct riscom_board *bp)
 629 {
 630         if (!(bp->flags & RC_BOARD_ACTIVE))
 631                 return;
 632
 633         bp->flags &= ~RC_BOARD_ACTIVE;
 634
 635         free_irq(bp->irq, NULL);
 636
 637         bp->DTR = ~0;
 638         rc_out(bp, RC_DTR, bp->DTR);           /* Drop DTR on all ports */
 639
 640 }
 641
 642 /*
 643  * Setting up port characteristics.
 644  * Must be called with disabled interrupts
 645  */
 646 static void rc_change_speed(struct tty_struct *tty, struct riscom_board *bp,
 647                                                 struct riscom_port *port)
 648 {
 649         unsigned long baud;
 650         long tmp;
 651         unsigned char cor1 = 0, cor3 = 0;
 652         unsigned char mcor1 = 0, mcor2 = 0;
 653
 654         port->IER  = 0;
 655         port->COR2 = 0;
 656         port->MSVR = MSVR_RTS;
 657
 658         baud = tty_get_baud_rate(tty);
 659
 660         /* Select port on the board */
 661         rc_out(bp, CD180_CAR, port_No(port));
 662
 663         if (!baud)  {
 664                 /* Drop DTR & exit */
 665                 bp->DTR |= (1u << port_No(port));
 666                 rc_out(bp, RC_DTR, bp->DTR);
 667                 return;
 668         } else  {
 669                 /* Set DTR on */
 670                 bp->DTR &= ~(1u << port_No(port));
 671                 rc_out(bp, RC_DTR, bp->DTR);
 672         }
 673
 674         /*
 675          * Now we must calculate some speed depended things
 676          */
 677
 678         /* Set baud rate for port */
 679         tmp = (((RC_OSCFREQ + baud/2) / baud +
 680                 CD180_TPC/2) / CD180_TPC);
 681
 682         rc_out(bp, CD180_RBPRH, (tmp >> 8) & 0xff);
 683         rc_out(bp, CD180_TBPRH, (tmp >> 8) & 0xff);
 684         rc_out(bp, CD180_RBPRL, tmp & 0xff);
 685         rc_out(bp, CD180_TBPRL, tmp & 0xff);
 686
 687         baud = (baud + 5) / 10;   /* Estimated CPS */
 688
 689         /* Two timer ticks seems enough to wakeup something like SLIP driver */
 690         tmp = ((baud + HZ/2) / HZ) * 2 - CD180_NFIFO;
 691         port->wakeup_chars = (tmp < 0) ? 0 : ((tmp >= SERIAL_XMIT_SIZE) ?
 692                                               SERIAL_XMIT_SIZE - 1 : tmp);
 693
 694         /* Receiver timeout will be transmission time for 1.5 chars */
 695         tmp = (RISCOM_TPS + RISCOM_TPS/2 + baud/2) / baud;
 696         tmp = (tmp > 0xff) ? 0xff : tmp;
 697         rc_out(bp, CD180_RTPR, tmp);
 698
 699         switch (C_CSIZE(tty)) {
 700         case CS5:
 701                 cor1 |= COR1_5BITS;
 702                 break;
 703         case CS6:
 704                 cor1 |= COR1_6BITS;
 705                 break;
 706         case CS7:
 707                 cor1 |= COR1_7BITS;
 708                 break;
 709         case CS8:
 710                 cor1 |= COR1_8BITS;
 711                 break;
 712         }
 713         if (C_CSTOPB(tty))
 714                 cor1 |= COR1_2SB;
 715
 716         cor1 |= COR1_IGNORE;
 717         if (C_PARENB(tty)) {
 718                 cor1 |= COR1_NORMPAR;
 719                 if (C_PARODD(tty))
 720                         cor1 |= COR1_ODDP;
 721                 if (I_INPCK(tty))
 722                         cor1 &= ~COR1_IGNORE;
 723         }
 724         /* Set marking of some errors */
 725         port->mark_mask = RCSR_OE | RCSR_TOUT;
 726         if (I_INPCK(tty))
 727                 port->mark_mask |= RCSR_FE | RCSR_PE;
 728         if (I_BRKINT(tty) || I_PARMRK(tty))
 729                 port->mark_mask |= RCSR_BREAK;
 730         if (I_IGNPAR(tty))
 731                 port->mark_mask &= ~(RCSR_FE | RCSR_PE);
 732         if (I_IGNBRK(tty)) {
 733                 port->mark_mask &= ~RCSR_BREAK;
 734                 if (I_IGNPAR(tty))
 735                         /* Real raw mode. Ignore all */
 736                         port->mark_mask &= ~RCSR_OE;
 737         }
 738         /* Enable Hardware Flow Control */
 739         if (C_CRTSCTS(tty))  {
 740 #ifdef RISCOM_BRAIN_DAMAGED_CTS
 741                 port->IER |= IER_DSR | IER_CTS;
 742                 mcor1 |= MCOR1_DSRZD | MCOR1_CTSZD;
 743                 mcor2 |= MCOR2_DSROD | MCOR2_CTSOD;
 744                 tty->hw_stopped = !(rc_in(bp, CD180_MSVR) &
 745                                                 (MSVR_CTS|MSVR_DSR));
 746 #else
 747                 port->COR2 |= COR2_CTSAE;
 748 #endif
 749         }
 750         /* Enable Software Flow Control. FIXME: I'm not sure about this */
 751         /* Some people reported that it works, but I still doubt */
 752         if (I_IXON(tty))  {
 753                 port->COR2 |= COR2_TXIBE;
 754                 cor3 |= (COR3_FCT | COR3_SCDE);
 755                 if (I_IXANY(tty))
 756                         port->COR2 |= COR2_IXM;
 757                 rc_out(bp, CD180_SCHR1, START_CHAR(tty));
 758                 rc_out(bp, CD180_SCHR2, STOP_CHAR(tty));
 759                 rc_out(bp, CD180_SCHR3, START_CHAR(tty));
 760                 rc_out(bp, CD180_SCHR4, STOP_CHAR(tty));
 761         }
 762         if (!C_CLOCAL(tty))  {
 763                 /* Enable CD check */
 764                 port->IER |= IER_CD;
 765                 mcor1 |= MCOR1_CDZD;
 766                 mcor2 |= MCOR2_CDOD;
 767         }
 768
 769         if (C_CREAD(tty))
 770                 /* Enable receiver */
 771                 port->IER |= IER_RXD;
 772
 773         /* Set input FIFO size (1-8 bytes) */
 774         cor3 |= RISCOM_RXFIFO;
 775         /* Setting up CD180 channel registers */
 776         rc_out(bp, CD180_COR1, cor1);
 777         rc_out(bp, CD180_COR2, port->COR2);
 778         rc_out(bp, CD180_COR3, cor3);
 779         /* Make CD180 know about registers change */
 780         rc_wait_CCR(bp);
 781         rc_out(bp, CD180_CCR, CCR_CORCHG1 | CCR_CORCHG2 | CCR_CORCHG3);
 782         /* Setting up modem option registers */
 783         rc_out(bp, CD180_MCOR1, mcor1);
 784         rc_out(bp, CD180_MCOR2, mcor2);
 785         /* Enable CD180 transmitter & receiver */
 786         rc_wait_CCR(bp);
 787         rc_out(bp, CD180_CCR, CCR_TXEN | CCR_RXEN);
 788         /* Enable interrupts */
 789         rc_out(bp, CD180_IER, port->IER);
 790         /* And finally set RTS on */
 791         rc_out(bp, CD180_MSVR, port->MSVR);
 792 }
 793
 794 /* Must be called with interrupts enabled */
 795 static int rc_activate_port(struct tty_port *port, struct tty_struct *tty)
 796 {
 797         struct riscom_port *rp = container_of(port, struct riscom_port, port);
 798         struct riscom_board *bp = port_Board(rp);
 799         unsigned long flags;
 800
 801         if (tty_port_alloc_xmit_buf(port) < 0)
 802                 return -ENOMEM;
 803
 804         spin_lock_irqsave(&riscom_lock, flags);
 805
 806         clear_bit(TTY_IO_ERROR, &tty->flags);
 807         bp->count++;
 808         rp->xmit_cnt = rp->xmit_head = rp->xmit_tail = 0;
 809         rc_change_speed(tty, bp, rp);
 810         spin_unlock_irqrestore(&riscom_lock, flags);
 811         return 0;
 812 }
 813
 814 /* Must be called with interrupts disabled */
 815 static void rc_shutdown_port(struct tty_struct *tty,
 816                         struct riscom_board *bp, struct riscom_port *port)
 817 {
 818 #ifdef RC_REPORT_OVERRUN
 819         printk(KERN_INFO "rc%d: port %d: Total %ld overruns were detected.\n",
 820                board_No(bp), port_No(port), port->overrun);
 821 #endif
 822 #ifdef RC_REPORT_FIFO
 823         {
 824                 int i;
 825
 826                 printk(KERN_INFO "rc%d: port %d: FIFO hits [ ",
 827                        board_No(bp), port_No(port));
 828                 for (i = 0; i < 10; i++)
 829                         printk("%ld ", port->hits[i]);
 830                 printk("].\n");
 831         }
 832 #endif
 833         tty_port_free_xmit_buf(&port->port);
 834
 835         /* Select port */
 836         rc_out(bp, CD180_CAR, port_No(port));
 837         /* Reset port */
 838         rc_wait_CCR(bp);
 839         rc_out(bp, CD180_CCR, CCR_SOFTRESET);
 840         /* Disable all interrupts from this port */
 841         port->IER = 0;
 842         rc_out(bp, CD180_IER, port->IER);
 843
 844         set_bit(TTY_IO_ERROR, &tty->flags);
 845
 846         if (--bp->count < 0)  {
 847                 printk(KERN_INFO "rc%d: rc_shutdown_port: "
 848                                  "bad board count: %d\n",
 849                        board_No(bp), bp->count);
 850                 bp->count = 0;
 851         }
 852         /*
 853          * If this is the last opened port on the board
 854          * shutdown whole board
 855          */
 856         if (!bp->count)
 857                 rc_shutdown_board(bp);
 858 }
 859
 860 static int carrier_raised(struct tty_port *port)
 861 {
 862         struct riscom_port *p = container_of(port, struct riscom_port, port);
 863         struct riscom_board *bp = port_Board(p);
 864         unsigned long flags;
 865         int CD;
 866
 867         spin_lock_irqsave(&riscom_lock, flags);
 868         rc_out(bp, CD180_CAR, port_No(p));
 869         CD = rc_in(bp, CD180_MSVR) & MSVR_CD;
 870         rc_out(bp, CD180_MSVR, MSVR_RTS);
 871         bp->DTR &= ~(1u << port_No(p));
 872         rc_out(bp, RC_DTR, bp->DTR);
 873         spin_unlock_irqrestore(&riscom_lock, flags);
 874         return CD;
 875 }
 876
 877 static void dtr_rts(struct tty_port *port, int onoff)
 878 {
 879         struct riscom_port *p = container_of(port, struct riscom_port, port);
 880         struct riscom_board *bp = port_Board(p);
 881         unsigned long flags;
 882
 883         spin_lock_irqsave(&riscom_lock, flags);
 884         bp->DTR &= ~(1u << port_No(p));
 885         if (onoff == 0)
 886                 bp->DTR |= (1u << port_No(p));
 887         rc_out(bp, RC_DTR, bp->DTR);
 888         spin_unlock_irqrestore(&riscom_lock, flags);
 889 }
 890
 891 static int rc_open(struct tty_struct *tty, struct file *filp)
 892 {
 893         int board;
 894         int error;
 895         struct riscom_port *port;
 896         struct riscom_board *bp;
 897
 898         board = RC_BOARD(tty->index);
 899         if (board >= RC_NBOARD || !(rc_board[board].flags & RC_BOARD_PRESENT))
 900                 return -ENODEV;
 901
 902         bp = &rc_board[board];
 903         port = rc_port + board * RC_NPORT + RC_PORT(tty->index);
 904         if (rc_paranoia_check(port, tty->name, "rc_open"))
 905                 return -ENODEV;
 906
 907         error = rc_setup_board(bp);
 908         if (error)
 909                 return error;
 910
 911         tty->driver_data = port;
 912         return tty_port_open(&port->port, tty, filp);
 913 }
 914
 915 static void rc_flush_buffer(struct tty_struct *tty)
 916 {
 917         struct riscom_port *port = tty->driver_data;
 918         unsigned long flags;
 919
 920         if (rc_paranoia_check(port, tty->name, "rc_flush_buffer"))
 921                 return;
 922
 923         spin_lock_irqsave(&riscom_lock, flags);
 924         port->xmit_cnt = port->xmit_head = port->xmit_tail = 0;
 925         spin_unlock_irqrestore(&riscom_lock, flags);
 926
 927         tty_wakeup(tty);
 928 }
 929
 930 static void rc_close_port(struct tty_port *port)
 931 {
 932         unsigned long flags;
 933         struct riscom_port *rp = container_of(port, struct riscom_port, port);
 934         struct riscom_board *bp = port_Board(rp);
 935         unsigned long timeout;
 936
 937         /*
 938          * At this point we stop accepting input.  To do this, we
 939          * disable the receive line status interrupts, and tell the
 940          * interrupt driver to stop checking the data ready bit in the
 941          * line status register.
 942          */
 943
 944         spin_lock_irqsave(&riscom_lock, flags);
 945         rp->IER &= ~IER_RXD;
 946
 947         rp->IER &= ~IER_TXRDY;
 948         rp->IER |= IER_TXEMPTY;
 949         rc_out(bp, CD180_CAR, port_No(rp));
 950         rc_out(bp, CD180_IER, rp->IER);
 951         /*
 952          * Before we drop DTR, make sure the UART transmitter
 953          * has completely drained; this is especially
 954          * important if there is a transmit FIFO!
 955          */
 956         timeout = jiffies + HZ;
 957         while (rp->IER & IER_TXEMPTY) {
 958                 spin_unlock_irqrestore(&riscom_lock, flags);
 959                 msleep_interruptible(jiffies_to_msecs(rp->timeout));
 960                 spin_lock_irqsave(&riscom_lock, flags);
 961                 if (time_after(jiffies, timeout))
 962                         break;
 963         }
 964         rc_shutdown_port(port->tty, bp, rp);
 965         spin_unlock_irqrestore(&riscom_lock, flags);
 966 }
 967
 968 static void rc_close(struct tty_struct *tty, struct file *filp)
 969 {
 970         struct riscom_port *port = tty->driver_data;
 971
 972         if (!port || rc_paranoia_check(port, tty->name, "close"))
 973                 return;
 974         tty_port_close(&port->port, tty, filp);
 975 }
 976
 977 static int rc_write(struct tty_struct *tty,
 978                     const unsigned char *buf, int count)
 979 {
 980         struct riscom_port *port = tty->driver_data;
 981         struct riscom_board *bp;
 982         int c, total = 0;
 983         unsigned long flags;
 984
 985         if (rc_paranoia_check(port, tty->name, "rc_write"))
 986                 return 0;
 987
 988         bp = port_Board(port);
 989
 990         while (1) {
 991                 spin_lock_irqsave(&riscom_lock, flags);
 992
 993                 c = min_t(int, count, min(SERIAL_XMIT_SIZE - port->xmit_cnt - 1,
 994                                           SERIAL_XMIT_SIZE - port->xmit_head));
 995                 if (c <= 0)
 996                         break;  /* lock continues to be held */
 997
 998                 memcpy(port->port.xmit_buf + port->xmit_head, buf, c);
 999                 port->xmit_head = (port->xmit_head + c) & (SERIAL_XMIT_SIZE-1);
1000                 port->xmit_cnt += c;
1001
1002                 spin_unlock_irqrestore(&riscom_lock, flags);
1003
1004                 buf += c;
1005                 count -= c;
1006                 total += c;
1007         }
1008
1009         if (port->xmit_cnt && !tty->stopped && !tty->hw_stopped &&
1010             !(port->IER & IER_TXRDY)) {
1011                 port->IER |= IER_TXRDY;
1012                 rc_out(bp, CD180_CAR, port_No(port));
1013                 rc_out(bp, CD180_IER, port->IER);
1014         }
1015
1016         spin_unlock_irqrestore(&riscom_lock, flags);
1017
1018         return total;
1019 }
1020
1021 static int rc_put_char(struct tty_struct *tty, unsigned char ch)
1022 {
1023         struct riscom_port *port = tty->driver_data;
1024         unsigned long flags;
1025         int ret = 0;
1026
1027         if (rc_paranoia_check(port, tty->name, "rc_put_char"))
1028                 return 0;
1029
1030         spin_lock_irqsave(&riscom_lock, flags);
1031
1032         if (port->xmit_cnt >= SERIAL_XMIT_SIZE - 1)
1033                 goto out;
1034
1035         port->port.xmit_buf[port->xmit_head++] = ch;
1036         port->xmit_head &= SERIAL_XMIT_SIZE - 1;
1037         port->xmit_cnt++;
1038         ret = 1;
1039
1040 out:
1041         spin_unlock_irqrestore(&riscom_lock, flags);
1042         return ret;
1043 }
1044
1045 static void rc_flush_chars(struct tty_struct *tty)
1046 {
1047         struct riscom_port *port = tty->driver_data;
1048         unsigned long flags;
1049
1050         if (rc_paranoia_check(port, tty->name, "rc_flush_chars"))
1051                 return;
1052
1053         if (port->xmit_cnt <= 0 || tty->stopped || tty->hw_stopped)
1054                 return;
1055
1056         spin_lock_irqsave(&riscom_lock, flags);
1057
1058         port->IER |= IER_TXRDY;
1059         rc_out(port_Board(port), CD180_CAR, port_No(port));
1060         rc_out(port_Board(port), CD180_IER, port->IER);
1061
1062         spin_unlock_irqrestore(&riscom_lock, flags);
1063 }
1064
1065 static int rc_write_room(struct tty_struct *tty)
1066 {
1067         struct riscom_port *port = tty->driver_data;
1068         int     ret;
1069
1070         if (rc_paranoia_check(port, tty->name, "rc_write_room"))
1071                 return 0;
1072
1073         ret = SERIAL_XMIT_SIZE - port->xmit_cnt - 1;
1074         if (ret < 0)
1075                 ret = 0;
1076         return ret;
1077 }
1078
1079 static int rc_chars_in_buffer(struct tty_struct *tty)
1080 {
1081         struct riscom_port *port = tty->driver_data;
1082
1083         if (rc_paranoia_check(port, tty->name, "rc_chars_in_buffer"))
1084                 return 0;
1085
1086         return port->xmit_cnt;
1087 }
1088
1089 static int rc_tiocmget(struct tty_struct *tty, struct file *file)
1090 {
1091         struct riscom_port *port = tty->driver_data;
1092         struct riscom_board *bp;
1093         unsigned char status;
1094         unsigned int result;
1095         unsigned long flags;
1096
1097         if (rc_paranoia_check(port, tty->name, __func__))
1098                 return -ENODEV;
1099
1100         bp = port_Board(port);
1101
1102         spin_lock_irqsave(&riscom_lock, flags);
1103
1104         rc_out(bp, CD180_CAR, port_No(port));
1105         status = rc_in(bp, CD180_MSVR);
1106         result = rc_in(bp, RC_RI) & (1u << port_No(port)) ? 0 : TIOCM_RNG;
1107
1108         spin_unlock_irqrestore(&riscom_lock, flags);
1109
1110         result |= ((status & MSVR_RTS) ? TIOCM_RTS : 0)
1111                 | ((status & MSVR_DTR) ? TIOCM_DTR : 0)
1112                 | ((status & MSVR_CD)  ? TIOCM_CAR : 0)
1113                 | ((status & MSVR_DSR) ? TIOCM_DSR : 0)
1114                 | ((status & MSVR_CTS) ? TIOCM_CTS : 0);
1115         return result;
1116 }
1117
1118 static int rc_tiocmset(struct tty_struct *tty, struct file *file,
1119                        unsigned int set, unsigned int clear)
1120 {
1121         struct riscom_port *port = tty->driver_data;
1122         unsigned long flags;
1123         struct riscom_board *bp;
1124
1125         if (rc_paranoia_check(port, tty->name, __func__))
1126                 return -ENODEV;
1127
1128         bp = port_Board(port);
1129
1130         spin_lock_irqsave(&riscom_lock, flags);
1131
1132         if (set & TIOCM_RTS)
1133                 port->MSVR |= MSVR_RTS;
1134         if (set & TIOCM_DTR)
1135                 bp->DTR &= ~(1u << port_No(port));
1136
1137         if (clear & TIOCM_RTS)
1138                 port->MSVR &= ~MSVR_RTS;
1139         if (clear & TIOCM_DTR)
1140                 bp->DTR |= (1u << port_No(port));
1141
1142         rc_out(bp, CD180_CAR, port_No(port));
1143         rc_out(bp, CD180_MSVR, port->MSVR);
1144         rc_out(bp, RC_DTR, bp->DTR);
1145
1146         spin_unlock_irqrestore(&riscom_lock, flags);
1147
1148         return 0;
1149 }
1150
1151 static int rc_send_break(struct tty_struct *tty, int length)
1152 {
1153         struct riscom_port *port = tty->driver_data;
1154         struct riscom_board *bp = port_Board(port);
1155         unsigned long flags;
1156
1157         if (length == 0 || length == -1)
1158                 return -EOPNOTSUPP;
1159
1160         spin_lock_irqsave(&riscom_lock, flags);
1161
1162         port->break_length = RISCOM_TPS / HZ * length;
1163         port->COR2 |= COR2_ETC;
1164         port->IER  |= IER_TXRDY;
1165         rc_out(bp, CD180_CAR, port_No(port));
1166         rc_out(bp, CD180_COR2, port->COR2);
1167         rc_out(bp, CD180_IER, port->IER);
1168         rc_wait_CCR(bp);
1169         rc_out(bp, CD180_CCR, CCR_CORCHG2);
1170         rc_wait_CCR(bp);
1171
1172         spin_unlock_irqrestore(&riscom_lock, flags);
1173         return 0;
1174 }
1175
1176 static int rc_set_serial_info(struct tty_struct *tty, struct riscom_port *port,
1177                                      struct serial_struct __user *newinfo)
1178 {
1179         struct serial_struct tmp;
1180         struct riscom_board *bp = port_Board(port);
1181         int change_speed;
1182
1183         if (copy_from_user(&tmp, newinfo, sizeof(tmp)))
1184                 return -EFAULT;
1185
1186         mutex_lock(&port->port.mutex);
1187         change_speed = ((port->port.flags & ASYNC_SPD_MASK) !=
1188                         (tmp.flags & ASYNC_SPD_MASK));
1189
1190         if (!capable(CAP_SYS_ADMIN)) {
1191                 if ((tmp.close_delay != port->port.close_delay) ||
1192                     (tmp.closing_wait != port->port.closing_wait) ||
1193                     ((tmp.flags & ~ASYNC_USR_MASK) !=
1194                      (port->port.flags & ~ASYNC_USR_MASK))) {
1195                         mutex_unlock(&port->port.mutex);
1196                         return -EPERM;
1197                 }
1198                 port->port.flags = ((port->port.flags & ~ASYNC_USR_MASK) |
1199                                (tmp.flags & ASYNC_USR_MASK));
1200         } else  {
1201                 port->port.flags = ((port->port.flags & ~ASYNC_FLAGS) |
1202                                (tmp.flags & ASYNC_FLAGS));
1203                 port->port.close_delay = tmp.close_delay;
1204                 port->port.closing_wait = tmp.closing_wait;
1205         }
1206         if (change_speed)  {
1207                 unsigned long flags;
1208
1209                 spin_lock_irqsave(&riscom_lock, flags);
1210                 rc_change_speed(tty, bp, port);
1211                 spin_unlock_irqrestore(&riscom_lock, flags);
1212         }
1213         mutex_unlock(&port->port.mutex);
1214         return 0;
1215 }
1216
1217 static int rc_get_serial_info(struct riscom_port *port,
1218                                      struct serial_struct __user *retinfo)
1219 {
1220         struct serial_struct tmp;
1221         struct riscom_board *bp = port_Board(port);
1222
1223         memset(&tmp, 0, sizeof(tmp));
1224         tmp.type = PORT_CIRRUS;
1225         tmp.line = port - rc_port;
1226
1227         mutex_lock(&port->port.mutex);
1228         tmp.port = bp->base;
1229         tmp.irq  = bp->irq;
1230         tmp.flags = port->port.flags;
1231         tmp.baud_base = (RC_OSCFREQ + CD180_TPC/2) / CD180_TPC;
1232         tmp.close_delay = port->port.close_delay * HZ/100;
1233         tmp.closing_wait = port->port.closing_wait * HZ/100;
1234         mutex_unlock(&port->port.mutex);
1235         tmp.xmit_fifo_size = CD180_NFIFO;
1236         return copy_to_user(retinfo, &tmp, sizeof(tmp)) ? -EFAULT : 0;
1237 }
1238
1239 static int rc_ioctl(struct tty_struct *tty, struct file *filp,
1240                     unsigned int cmd, unsigned long arg)
1241 {
1242         struct riscom_port *port = tty->driver_data;
1243         void __user *argp = (void __user *)arg;
1244         int retval;
1245
1246         if (rc_paranoia_check(port, tty->name, "rc_ioctl"))
1247                 return -ENODEV;
1248
1249         switch (cmd) {
1250         case TIOCGSERIAL:
1251                 retval = rc_get_serial_info(port, argp);
1252                 break;
1253         case TIOCSSERIAL:
1254                 retval = rc_set_serial_info(tty, port, argp);
1255                 break;
1256         default:
1257                 retval = -ENOIOCTLCMD;
1258         }
1259         return retval;
1260 }
1261
1262 static void rc_throttle(struct tty_struct *tty)
1263 {
1264         struct riscom_port *port = tty->driver_data;
1265         struct riscom_board *bp;
1266         unsigned long flags;
1267
1268         if (rc_paranoia_check(port, tty->name, "rc_throttle"))
1269                 return;
1270         bp = port_Board(port);
1271
1272         spin_lock_irqsave(&riscom_lock, flags);
1273         port->MSVR &= ~MSVR_RTS;
1274         rc_out(bp, CD180_CAR, port_No(port));
1275         if (I_IXOFF(tty)) {
1276                 rc_wait_CCR(bp);
1277                 rc_out(bp, CD180_CCR, CCR_SSCH2);
1278                 rc_wait_CCR(bp);
1279         }
1280         rc_out(bp, CD180_MSVR, port->MSVR);
1281         spin_unlock_irqrestore(&riscom_lock, flags);
1282 }
1283
1284 static void rc_unthrottle(struct tty_struct *tty)
1285 {
1286         struct riscom_port *port = tty->driver_data;
1287         struct riscom_board *bp;
1288         unsigned long flags;
1289
1290         if (rc_paranoia_check(port, tty->name, "rc_unthrottle"))
1291                 return;
1292         bp = port_Board(port);
1293
1294         spin_lock_irqsave(&riscom_lock, flags);
1295         port->MSVR |= MSVR_RTS;
1296         rc_out(bp, CD180_CAR, port_No(port));
1297         if (I_IXOFF(tty))  {
1298                 rc_wait_CCR(bp);
1299                 rc_out(bp, CD180_CCR, CCR_SSCH1);
1300                 rc_wait_CCR(bp);
1301         }
1302         rc_out(bp, CD180_MSVR, port->MSVR);
1303         spin_unlock_irqrestore(&riscom_lock, flags);
1304 }
1305
1306 static void rc_stop(struct tty_struct *tty)
1307 {
1308         struct riscom_port *port = tty->driver_data;
1309         struct riscom_board *bp;
1310         unsigned long flags;
1311
1312         if (rc_paranoia_check(port, tty->name, "rc_stop"))
1313                 return;
1314
1315         bp = port_Board(port);
1316
1317         spin_lock_irqsave(&riscom_lock, flags);
1318         port->IER &= ~IER_TXRDY;
1319         rc_out(bp, CD180_CAR, port_No(port));
1320         rc_out(bp, CD180_IER, port->IER);
1321         spin_unlock_irqrestore(&riscom_lock, flags);
1322 }
1323
1324 static void rc_start(struct tty_struct *tty)
1325 {
1326         struct riscom_port *port = tty->driver_data;
1327         struct riscom_board *bp;
1328         unsigned long flags;
1329
1330         if (rc_paranoia_check(port, tty->name, "rc_start"))
1331                 return;
1332
1333         bp = port_Board(port);
1334
1335         spin_lock_irqsave(&riscom_lock, flags);
1336
1337         if (port->xmit_cnt && port->port.xmit_buf && !(port->IER & IER_TXRDY)) {
1338                 port->IER |= IER_TXRDY;
1339                 rc_out(bp, CD180_CAR, port_No(port));
1340                 rc_out(bp, CD180_IER, port->IER);
1341         }
1342         spin_unlock_irqrestore(&riscom_lock, flags);
1343 }
1344
1345 static void rc_hangup(struct tty_struct *tty)
1346 {
1347         struct riscom_port *port = tty->driver_data;
1348
1349         if (rc_paranoia_check(port, tty->name, "rc_hangup"))
1350                 return;
1351
1352         tty_port_hangup(&port->port);
1353 }
1354
1355 static void rc_set_termios(struct tty_struct *tty,
1356                                         struct ktermios *old_termios)
1357 {
1358         struct riscom_port *port = tty->driver_data;
1359         unsigned long flags;
1360
1361         if (rc_paranoia_check(port, tty->name, "rc_set_termios"))
1362                 return;
1363
1364         spin_lock_irqsave(&riscom_lock, flags);
1365         rc_change_speed(tty, port_Board(port), port);
1366         spin_unlock_irqrestore(&riscom_lock, flags);
1367
1368         if ((old_termios->c_cflag & CRTSCTS) &&
1369             !(tty->termios->c_cflag & CRTSCTS)) {
1370                 tty->hw_stopped = 0;
1371                 rc_start(tty);
1372         }
1373 }
1374
1375 static const struct tty_operations riscom_ops = {
1376         .open  = rc_open,
1377         .close = rc_close,
1378         .write = rc_write,
1379         .put_char = rc_put_char,
1380         .flush_chars = rc_flush_chars,
1381         .write_room = rc_write_room,
1382         .chars_in_buffer = rc_chars_in_buffer,
1383         .flush_buffer = rc_flush_buffer,
1384         .ioctl = rc_ioctl,
1385         .throttle = rc_throttle,
1386         .unthrottle = rc_unthrottle,
1387         .set_termios = rc_set_termios,
1388         .stop = rc_stop,
1389         .start = rc_start,
1390         .hangup = rc_hangup,
1391         .tiocmget = rc_tiocmget,
1392         .tiocmset = rc_tiocmset,
1393         .break_ctl = rc_send_break,
1394 };
1395
1396 static const struct tty_port_operations riscom_port_ops = {
1397         .carrier_raised = carrier_raised,
1398         .dtr_rts = dtr_rts,
1399         .shutdown = rc_close_port,
1400         .activate = rc_activate_port,
1401 };
1402
1403
1404 static int __init rc_init_drivers(void)
1405 {
1406         int error;
1407         int i;
1408
1409         riscom_driver = alloc_tty_driver(RC_NBOARD * RC_NPORT);
1410         if (!riscom_driver)
1411                 return -ENOMEM;
1412
1413         riscom_driver->owner = THIS_MODULE;
1414         riscom_driver->name = "ttyL";
1415         riscom_driver->major = RISCOM8_NORMAL_MAJOR;
1416         riscom_driver->type = TTY_DRIVER_TYPE_SERIAL;
1417         riscom_driver->subtype = SERIAL_TYPE_NORMAL;
1418         riscom_driver->init_termios = tty_std_termios;
1419         riscom_driver->init_termios.c_cflag =
1420                 B9600 | CS8 | CREAD | HUPCL | CLOCAL;
1421         riscom_driver->init_termios.c_ispeed = 9600;
1422         riscom_driver->init_termios.c_ospeed = 9600;
1423         riscom_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_HARDWARE_BREAK;
1424         tty_set_operations(riscom_driver, &riscom_ops);
1425         error = tty_register_driver(riscom_driver);
1426         if (error != 0) {
1427                 put_tty_driver(riscom_driver);
1428                 printk(KERN_ERR "rc: Couldn't register RISCom/8 driver, "
1429                                 "error = %d\n", error);
1430                 return 1;
1431         }
1432         memset(rc_port, 0, sizeof(rc_port));
1433         for (i = 0; i < RC_NPORT * RC_NBOARD; i++)  {
1434                 tty_port_init(&rc_port[i].port);
1435                 rc_port[i].port.ops = &riscom_port_ops;
1436                 rc_port[i].magic = RISCOM8_MAGIC;
1437         }
1438         return 0;
1439 }
1440
1441 static void rc_release_drivers(void)
1442 {
1443         tty_unregister_driver(riscom_driver);
1444         put_tty_driver(riscom_driver);
1445 }
1446
1447 #ifndef MODULE
1448 /*
1449  * Called at boot time.
1450  *
1451  * You can specify IO base for up to RC_NBOARD cards,
1452  * using line "riscom8=0xiobase1,0xiobase2,.." at LILO prompt.
1453  * Note that there will be no probing at default
1454  * addresses in this case.
1455  *
1456  */
1457 static int __init riscom8_setup(char *str)
1458 {
1459         int ints[RC_NBOARD];
1460         int i;
1461
1462         str = get_options(str, ARRAY_SIZE(ints), ints);
1463
1464         for (i = 0; i < RC_NBOARD; i++) {
1465                 if (i < ints[0])
1466                         rc_board[i].base = ints[i+1];
1467                 else
1468                         rc_board[i].base = 0;
1469         }
1470         return 1;
1471 }
1472
1473 __setup("riscom8=", riscom8_setup);
1474 #endif
1475
1476 static char banner[] __initdata =
1477         KERN_INFO "rc: SDL RISCom/8 card driver v1.1, (c) D.Gorodchanin "
1478                   "1994-1996.\n";
1479 static char no_boards_msg[] __initdata =
1480         KERN_INFO "rc: No RISCom/8 boards detected.\n";
1481
1482 /*
1483  * This routine must be called by kernel at boot time
1484  */
1485 static int __init riscom8_init(void)
1486 {
1487         int i;
1488         int found = 0;
1489
1490         printk(banner);
1491
1492         if (rc_init_drivers())
1493                 return -EIO;
1494
1495         for (i = 0; i < RC_NBOARD; i++)
1496                 if (rc_board[i].base && !rc_probe(&rc_board[i]))
1497                         found++;
1498         if (!found)  {
1499                 rc_release_drivers();
1500                 printk(no_boards_msg);
1501                 return -EIO;
1502         }
1503         return 0;
1504 }
1505
1506 #ifdef MODULE
1507 static int iobase;
1508 static int iobase1;
1509 static int iobase2;
1510 static int iobase3;
1511 module_param(iobase, int, 0);
1512 module_param(iobase1, int, 0);
1513 module_param(iobase2, int, 0);
1514 module_param(iobase3, int, 0);
1515
1516 MODULE_LICENSE("GPL");
1517 MODULE_ALIAS_CHARDEV_MAJOR(RISCOM8_NORMAL_MAJOR);
1518 #endif /* MODULE */
1519
1520 /*
1521  * You can setup up to 4 boards (current value of RC_NBOARD)
1522  * by specifying "iobase=0xXXX iobase1=0xXXX ..." as insmod parameter.
1523  *
1524  */
1525 static int __init riscom8_init_module(void)
1526 {
1527 #ifdef MODULE
1528         int i;
1529
1530         if (iobase || iobase1 || iobase2 || iobase3) {
1531                 for (i = 0; i < RC_NBOARD; i++)
1532                         rc_board[i].base = 0;
1533         }
1534
1535         if (iobase)
1536                 rc_board[0].base = iobase;
1537         if (iobase1)
1538                 rc_board[1].base = iobase1;
1539         if (iobase2)
1540                 rc_board[2].base = iobase2;
1541         if (iobase3)
1542                 rc_board[3].base = iobase3;
1543 #endif /* MODULE */
1544
1545         return riscom8_init();
1546 }
1547
1548 static void __exit riscom8_exit_module(void)
1549 {
1550         int i;
1551
1552         rc_release_drivers();
1553         for (i = 0; i < RC_NBOARD; i++)
1554                 if (rc_board[i].flags & RC_BOARD_PRESENT)
1555                         rc_release_io_range(&rc_board[i]);
1556
1557 }
1558
1559 module_init(riscom8_init_module);
1560 module_exit(riscom8_exit_module);