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