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