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