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->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->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->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->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->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->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->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->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->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->port.flags & ASYNC_INITIALIZED)
 790                 return 0;
 791
 792         if (tty_port_alloc_xmit_buf(&port->port) < 0)
 793                 return -ENOMEM;
 794
 795         spin_lock_irqsave(&riscom_lock, flags);
 796
 797         if (port->port.tty)
 798                 clear_bit(TTY_IO_ERROR, &port->port.tty->flags);
 799         if (port->port.count == 1)
 800                 bp->count++;
 801         port->xmit_cnt = port->xmit_head = port->xmit_tail = 0;
 802         rc_change_speed(bp, port);
 803         port->port.flags |= ASYNC_INITIALIZED;
 804
 805         spin_unlock_irqrestore(&riscom_lock, flags);
 806         return 0;
 807 }
 808
 809 /* Must be called with interrupts disabled */
 810 static void rc_shutdown_port(struct riscom_board *bp, struct riscom_port *port)
 811 {
 812         struct tty_struct *tty;
 813
 814         if (!(port->port.flags & ASYNC_INITIALIZED))
 815                 return;
 816
 817 #ifdef RC_REPORT_OVERRUN
 818         printk(KERN_INFO "rc%d: port %d: Total %ld overruns were detected.\n",
 819                board_No(bp), port_No(port), port->overrun);
 820 #endif
 821 #ifdef RC_REPORT_FIFO
 822         {
 823                 int i;
 824
 825                 printk(KERN_INFO "rc%d: port %d: FIFO hits [ ",
 826                        board_No(bp), port_No(port));
 827                 for (i = 0; i < 10; i++)
 828                         printk("%ld ", port->hits[i]);
 829                 printk("].\n");
 830         }
 831 #endif
 832         tty_port_free_xmit_buf(&port->port);
 833
 834         tty = port->port.tty;
 835
 836         if (tty == NULL || C_HUPCL(tty)) {
 837                 /* Drop DTR */
 838                 bp->DTR |= (1u << port_No(port));
 839                 rc_out(bp, RC_DTR, bp->DTR);
 840         }
 841
 842         /* Select port */
 843         rc_out(bp, CD180_CAR, port_No(port));
 844         /* Reset port */
 845         rc_wait_CCR(bp);
 846         rc_out(bp, CD180_CCR, CCR_SOFTRESET);
 847         /* Disable all interrupts from this port */
 848         port->IER = 0;
 849         rc_out(bp, CD180_IER, port->IER);
 850
 851         if (tty)
 852                 set_bit(TTY_IO_ERROR, &tty->flags);
 853         port->port.flags &= ~ASYNC_INITIALIZED;
 854
 855         if (--bp->count < 0)  {
 856                 printk(KERN_INFO "rc%d: rc_shutdown_port: "
 857                                  "bad board count: %d\n",
 858                        board_No(bp), bp->count);
 859                 bp->count = 0;
 860         }
 861         /*
 862          * If this is the last opened port on the board
 863          * shutdown whole board
 864          */
 865         if (!bp->count)
 866                 rc_shutdown_board(bp);
 867 }
 868
 869 static int block_til_ready(struct tty_struct *tty, struct file *filp,
 870                            struct riscom_port *port)
 871 {
 872         DECLARE_WAITQUEUE(wait, current);
 873         struct riscom_board *bp = port_Board(port);
 874         int    retval;
 875         int    do_clocal = 0;
 876         int    CD;
 877         unsigned long flags;
 878
 879         /*
 880          * If the device is in the middle of being closed, then block
 881          * until it's done, and then try again.
 882          */
 883         if (tty_hung_up_p(filp) || port->port.flags & ASYNC_CLOSING) {
 884                 interruptible_sleep_on(&port->port.close_wait);
 885                 if (port->port.flags & ASYNC_HUP_NOTIFY)
 886                         return -EAGAIN;
 887                 else
 888                         return -ERESTARTSYS;
 889         }
 890
 891         /*
 892          * If non-blocking mode is set, or the port is not enabled,
 893          * then make the check up front and then exit.
 894          */
 895         if ((filp->f_flags & O_NONBLOCK) ||
 896             (tty->flags & (1 << TTY_IO_ERROR))) {
 897                 port->port.flags |= ASYNC_NORMAL_ACTIVE;
 898                 return 0;
 899         }
 900
 901         if (C_CLOCAL(tty))
 902                 do_clocal = 1;
 903
 904         /*
 905          * Block waiting for the carrier detect and the line to become
 906          * free (i.e., not in use by the callout).  While we are in
 907          * this loop, info->count is dropped by one, so that
 908          * rs_close() knows when to free things.  We restore it upon
 909          * exit, either normal or abnormal.
 910          */
 911         retval = 0;
 912         add_wait_queue(&port->port.open_wait, &wait);
 913
 914         spin_lock_irqsave(&riscom_lock, flags);
 915
 916         if (!tty_hung_up_p(filp))
 917                 port->port.count--;
 918
 919         spin_unlock_irqrestore(&riscom_lock, flags);
 920
 921         port->port.blocked_open++;
 922         while (1) {
 923                 spin_lock_irqsave(&riscom_lock, flags);
 924
 925                 rc_out(bp, CD180_CAR, port_No(port));
 926                 CD = rc_in(bp, CD180_MSVR) & MSVR_CD;
 927                 rc_out(bp, CD180_MSVR, MSVR_RTS);
 928                 bp->DTR &= ~(1u << port_No(port));
 929                 rc_out(bp, RC_DTR, bp->DTR);
 930
 931                 spin_unlock_irqrestore(&riscom_lock, flags);
 932
 933                 set_current_state(TASK_INTERRUPTIBLE);
 934                 if (tty_hung_up_p(filp) ||
 935                     !(port->port.flags & ASYNC_INITIALIZED)) {
 936                         if (port->port.flags & ASYNC_HUP_NOTIFY)
 937                                 retval = -EAGAIN;
 938                         else
 939                                 retval = -ERESTARTSYS;
 940                         break;
 941                 }
 942                 if (!(port->port.flags & ASYNC_CLOSING) &&
 943                     (do_clocal || CD))
 944                         break;
 945                 if (signal_pending(current)) {
 946                         retval = -ERESTARTSYS;
 947                         break;
 948                 }
 949                 schedule();
 950         }
 951         __set_current_state(TASK_RUNNING);
 952         remove_wait_queue(&port->port.open_wait, &wait);
 953         if (!tty_hung_up_p(filp))
 954                 port->port.count++;
 955         port->port.blocked_open--;
 956         if (retval)
 957                 return retval;
 958
 959         port->port.flags |= ASYNC_NORMAL_ACTIVE;
 960         return 0;
 961 }
 962
 963 static int rc_open(struct tty_struct *tty, struct file *filp)
 964 {
 965         int board;
 966         int error;
 967         struct riscom_port *port;
 968         struct riscom_board *bp;
 969
 970         board = RC_BOARD(tty->index);
 971         if (board >= RC_NBOARD || !(rc_board[board].flags & RC_BOARD_PRESENT))
 972                 return -ENODEV;
 973
 974         bp = &rc_board[board];
 975         port = rc_port + board * RC_NPORT + RC_PORT(tty->index);
 976         if (rc_paranoia_check(port, tty->name, "rc_open"))
 977                 return -ENODEV;
 978
 979         error = rc_setup_board(bp);
 980         if (error)
 981                 return error;
 982
 983         port->port.count++;
 984         tty->driver_data = port;
 985         port->port.tty = tty;
 986
 987         error = rc_setup_port(bp, port);
 988         if (error == 0)
 989                 error = block_til_ready(tty, filp, port);
 990         return error;
 991 }
 992
 993 static void rc_flush_buffer(struct tty_struct *tty)
 994 {
 995         struct riscom_port *port = (struct riscom_port *)tty->driver_data;
 996         unsigned long flags;
 997
 998         if (rc_paranoia_check(port, tty->name, "rc_flush_buffer"))
 999                 return;
1000
1001         spin_lock_irqsave(&riscom_lock, flags);
1002         port->xmit_cnt = port->xmit_head = port->xmit_tail = 0;
1003         spin_unlock_irqrestore(&riscom_lock, flags);
1004
1005         tty_wakeup(tty);
1006 }
1007
1008 static void rc_close(struct tty_struct *tty, struct file *filp)
1009 {
1010         struct riscom_port *port = (struct riscom_port *) tty->driver_data;
1011         struct riscom_board *bp;
1012         unsigned long flags;
1013         unsigned long timeout;
1014
1015         if (!port || rc_paranoia_check(port, tty->name, "close"))
1016                 return;
1017
1018         spin_lock_irqsave(&riscom_lock, flags);
1019
1020         if (tty_hung_up_p(filp))
1021                 goto out;
1022
1023         bp = port_Board(port);
1024         if ((tty->count == 1) && (port->port.count != 1))  {
1025                 printk(KERN_INFO "rc%d: rc_close: bad port count;"
1026                        " tty->count is 1, port count is %d\n",
1027                        board_No(bp), port->port.count);
1028                 port->port.count = 1;
1029         }
1030         if (--port->port.count < 0)  {
1031                 printk(KERN_INFO "rc%d: rc_close: bad port count "
1032                                  "for tty%d: %d\n",
1033                        board_No(bp), port_No(port), port->port.count);
1034                 port->port.count = 0;
1035         }
1036         if (port->port.count)
1037                 goto out;
1038         port->port.flags |= ASYNC_CLOSING;
1039         /*
1040          * Now we wait for the transmit buffer to clear; and we notify
1041          * the line discipline to only process XON/XOFF characters.
1042          */
1043         tty->closing = 1;
1044         if (port->closing_wait != ASYNC_CLOSING_WAIT_NONE)
1045                 tty_wait_until_sent(tty, port->closing_wait);
1046         /*
1047          * At this point we stop accepting input.  To do this, we
1048          * disable the receive line status interrupts, and tell the
1049          * interrupt driver to stop checking the data ready bit in the
1050          * line status register.
1051          */
1052         port->IER &= ~IER_RXD;
1053         if (port->port.flags & ASYNC_INITIALIZED) {
1054                 port->IER &= ~IER_TXRDY;
1055                 port->IER |= IER_TXEMPTY;
1056                 rc_out(bp, CD180_CAR, port_No(port));
1057                 rc_out(bp, CD180_IER, port->IER);
1058                 /*
1059                  * Before we drop DTR, make sure the UART transmitter
1060                  * has completely drained; this is especially
1061                  * important if there is a transmit FIFO!
1062                  */
1063                 timeout = jiffies + HZ;
1064                 while (port->IER & IER_TXEMPTY) {
1065                         msleep_interruptible(jiffies_to_msecs(port->timeout));
1066                         if (time_after(jiffies, timeout))
1067                                 break;
1068                 }
1069         }
1070         rc_shutdown_port(bp, port);
1071         rc_flush_buffer(tty);
1072         tty_ldisc_flush(tty);
1073
1074         tty->closing = 0;
1075         port->port.tty = NULL;
1076         if (port->port.blocked_open) {
1077                 if (port->close_delay)
1078                         msleep_interruptible(jiffies_to_msecs(port->close_delay));
1079                 wake_up_interruptible(&port->port.open_wait);
1080         }
1081         port->port.flags &= ~(ASYNC_NORMAL_ACTIVE|ASYNC_CLOSING);
1082         wake_up_interruptible(&port->port.close_wait);
1083
1084 out:
1085         spin_unlock_irqrestore(&riscom_lock, flags);
1086 }
1087
1088 static int rc_write(struct tty_struct *tty,
1089                     const unsigned char *buf, int count)
1090 {
1091         struct riscom_port *port = (struct riscom_port *)tty->driver_data;
1092         struct riscom_board *bp;
1093         int c, total = 0;
1094         unsigned long flags;
1095
1096         if (rc_paranoia_check(port, tty->name, "rc_write"))
1097                 return 0;
1098
1099         bp = port_Board(port);
1100
1101         if (!tty || !port->port.xmit_buf)
1102                 return 0;
1103
1104         while (1) {
1105                 spin_lock_irqsave(&riscom_lock, flags);
1106
1107                 c = min_t(int, count, min(SERIAL_XMIT_SIZE - port->xmit_cnt - 1,
1108                                           SERIAL_XMIT_SIZE - port->xmit_head));
1109                 if (c <= 0)
1110                         break;  /* lock continues to be held */
1111
1112                 memcpy(port->port.xmit_buf + port->xmit_head, buf, c);
1113                 port->xmit_head = (port->xmit_head + c) & (SERIAL_XMIT_SIZE-1);
1114                 port->xmit_cnt += c;
1115
1116                 spin_unlock_irqrestore(&riscom_lock, flags);
1117
1118                 buf += c;
1119                 count -= c;
1120                 total += c;
1121         }
1122
1123         if (port->xmit_cnt && !tty->stopped && !tty->hw_stopped &&
1124             !(port->IER & IER_TXRDY)) {
1125                 port->IER |= IER_TXRDY;
1126                 rc_out(bp, CD180_CAR, port_No(port));
1127                 rc_out(bp, CD180_IER, port->IER);
1128         }
1129
1130         spin_unlock_irqrestore(&riscom_lock, flags);
1131
1132         return total;
1133 }
1134
1135 static int rc_put_char(struct tty_struct *tty, unsigned char ch)
1136 {
1137         struct riscom_port *port = (struct riscom_port *)tty->driver_data;
1138         unsigned long flags;
1139         int ret = 0;
1140
1141         if (rc_paranoia_check(port, tty->name, "rc_put_char"))
1142                 return 0;
1143
1144         if (!tty || !port->port.xmit_buf)
1145                 return 0;
1146
1147         spin_lock_irqsave(&riscom_lock, flags);
1148
1149         if (port->xmit_cnt >= SERIAL_XMIT_SIZE - 1)
1150                 goto out;
1151
1152         port->port.xmit_buf[port->xmit_head++] = ch;
1153         port->xmit_head &= SERIAL_XMIT_SIZE - 1;
1154         port->xmit_cnt++;
1155         ret = 1;
1156
1157 out:
1158         spin_unlock_irqrestore(&riscom_lock, flags);
1159         return ret;
1160 }
1161
1162 static void rc_flush_chars(struct tty_struct *tty)
1163 {
1164         struct riscom_port *port = (struct riscom_port *)tty->driver_data;
1165         unsigned long flags;
1166
1167         if (rc_paranoia_check(port, tty->name, "rc_flush_chars"))
1168                 return;
1169
1170         if (port->xmit_cnt <= 0 || tty->stopped || tty->hw_stopped ||
1171             !port->port.xmit_buf)
1172                 return;
1173
1174         spin_lock_irqsave(&riscom_lock, flags);
1175
1176         port->IER |= IER_TXRDY;
1177         rc_out(port_Board(port), CD180_CAR, port_No(port));
1178         rc_out(port_Board(port), CD180_IER, port->IER);
1179
1180         spin_unlock_irqrestore(&riscom_lock, flags);
1181 }
1182
1183 static int rc_write_room(struct tty_struct *tty)
1184 {
1185         struct riscom_port *port = (struct riscom_port *)tty->driver_data;
1186         int     ret;
1187
1188         if (rc_paranoia_check(port, tty->name, "rc_write_room"))
1189                 return 0;
1190
1191         ret = SERIAL_XMIT_SIZE - port->xmit_cnt - 1;
1192         if (ret < 0)
1193                 ret = 0;
1194         return ret;
1195 }
1196
1197 static int rc_chars_in_buffer(struct tty_struct *tty)
1198 {
1199         struct riscom_port *port = (struct riscom_port *)tty->driver_data;
1200
1201         if (rc_paranoia_check(port, tty->name, "rc_chars_in_buffer"))
1202                 return 0;
1203
1204         return port->xmit_cnt;
1205 }
1206
1207 static int rc_tiocmget(struct tty_struct *tty, struct file *file)
1208 {
1209         struct riscom_port *port = (struct riscom_port *)tty->driver_data;
1210         struct riscom_board *bp;
1211         unsigned char status;
1212         unsigned int result;
1213         unsigned long flags;
1214
1215         if (rc_paranoia_check(port, tty->name, __func__))
1216                 return -ENODEV;
1217
1218         bp = port_Board(port);
1219
1220         spin_lock_irqsave(&riscom_lock, flags);
1221
1222         rc_out(bp, CD180_CAR, port_No(port));
1223         status = rc_in(bp, CD180_MSVR);
1224         result = rc_in(bp, RC_RI) & (1u << port_No(port)) ? 0 : TIOCM_RNG;
1225
1226         spin_unlock_irqrestore(&riscom_lock, flags);
1227
1228         result |= ((status & MSVR_RTS) ? TIOCM_RTS : 0)
1229                 | ((status & MSVR_DTR) ? TIOCM_DTR : 0)
1230                 | ((status & MSVR_CD)  ? TIOCM_CAR : 0)
1231                 | ((status & MSVR_DSR) ? TIOCM_DSR : 0)
1232                 | ((status & MSVR_CTS) ? TIOCM_CTS : 0);
1233         return result;
1234 }
1235
1236 static int rc_tiocmset(struct tty_struct *tty, struct file *file,
1237                        unsigned int set, unsigned int clear)
1238 {
1239         struct riscom_port *port = (struct riscom_port *)tty->driver_data;
1240         unsigned long flags;
1241         struct riscom_board *bp;
1242
1243         if (rc_paranoia_check(port, tty->name, __func__))
1244                 return -ENODEV;
1245
1246         bp = port_Board(port);
1247
1248         spin_lock_irqsave(&riscom_lock, flags);
1249
1250         if (set & TIOCM_RTS)
1251                 port->MSVR |= MSVR_RTS;
1252         if (set & TIOCM_DTR)
1253                 bp->DTR &= ~(1u << port_No(port));
1254
1255         if (clear & TIOCM_RTS)
1256                 port->MSVR &= ~MSVR_RTS;
1257         if (clear & TIOCM_DTR)
1258                 bp->DTR |= (1u << port_No(port));
1259
1260         rc_out(bp, CD180_CAR, port_No(port));
1261         rc_out(bp, CD180_MSVR, port->MSVR);
1262         rc_out(bp, RC_DTR, bp->DTR);
1263
1264         spin_unlock_irqrestore(&riscom_lock, flags);
1265
1266         return 0;
1267 }
1268
1269 static void rc_send_break(struct riscom_port *port, unsigned long length)
1270 {
1271         struct riscom_board *bp = port_Board(port);
1272         unsigned long flags;
1273
1274         spin_lock_irqsave(&riscom_lock, flags);
1275
1276         port->break_length = RISCOM_TPS / HZ * length;
1277         port->COR2 |= COR2_ETC;
1278         port->IER  |= IER_TXRDY;
1279         rc_out(bp, CD180_CAR, port_No(port));
1280         rc_out(bp, CD180_COR2, port->COR2);
1281         rc_out(bp, CD180_IER, port->IER);
1282         rc_wait_CCR(bp);
1283         rc_out(bp, CD180_CCR, CCR_CORCHG2);
1284         rc_wait_CCR(bp);
1285
1286         spin_unlock_irqrestore(&riscom_lock, flags);
1287 }
1288
1289 static int rc_set_serial_info(struct riscom_port *port,
1290                                      struct serial_struct __user *newinfo)
1291 {
1292         struct serial_struct tmp;
1293         struct riscom_board *bp = port_Board(port);
1294         int change_speed;
1295
1296         if (copy_from_user(&tmp, newinfo, sizeof(tmp)))
1297                 return -EFAULT;
1298
1299 #if 0
1300         if ((tmp.irq != bp->irq) ||
1301             (tmp.port != bp->base) ||
1302             (tmp.type != PORT_CIRRUS) ||
1303             (tmp.baud_base != (RC_OSCFREQ + CD180_TPC/2) / CD180_TPC) ||
1304             (tmp.custom_divisor != 0) ||
1305             (tmp.xmit_fifo_size != CD180_NFIFO) ||
1306             (tmp.flags & ~RISCOM_LEGAL_FLAGS))
1307                 return -EINVAL;
1308 #endif
1309
1310         change_speed = ((port->port.flags & ASYNC_SPD_MASK) !=
1311                         (tmp.flags & ASYNC_SPD_MASK));
1312
1313         if (!capable(CAP_SYS_ADMIN)) {
1314                 if ((tmp.close_delay != port->close_delay) ||
1315                     (tmp.closing_wait != port->closing_wait) ||
1316                     ((tmp.flags & ~ASYNC_USR_MASK) !=
1317                      (port->port.flags & ~ASYNC_USR_MASK)))
1318                         return -EPERM;
1319                 port->port.flags = ((port->port.flags & ~ASYNC_USR_MASK) |
1320                                (tmp.flags & ASYNC_USR_MASK));
1321         } else  {
1322                 port->port.flags = ((port->port.flags & ~ASYNC_FLAGS) |
1323                                (tmp.flags & ASYNC_FLAGS));
1324                 port->close_delay = tmp.close_delay;
1325                 port->closing_wait = tmp.closing_wait;
1326         }
1327         if (change_speed)  {
1328                 unsigned long flags;
1329
1330                 spin_lock_irqsave(&riscom_lock, flags);
1331                 rc_change_speed(bp, port);
1332                 spin_unlock_irqrestore(&riscom_lock, flags);
1333         }
1334         return 0;
1335 }
1336
1337 static int rc_get_serial_info(struct riscom_port *port,
1338                                      struct serial_struct __user *retinfo)
1339 {
1340         struct serial_struct tmp;
1341         struct riscom_board *bp = port_Board(port);
1342
1343         memset(&tmp, 0, sizeof(tmp));
1344         tmp.type = PORT_CIRRUS;
1345         tmp.line = port - rc_port;
1346         tmp.port = bp->base;
1347         tmp.irq  = bp->irq;
1348         tmp.flags = port->port.flags;
1349         tmp.baud_base = (RC_OSCFREQ + CD180_TPC/2) / CD180_TPC;
1350         tmp.close_delay = port->close_delay * HZ/100;
1351         tmp.closing_wait = port->closing_wait * HZ/100;
1352         tmp.xmit_fifo_size = CD180_NFIFO;
1353         return copy_to_user(retinfo, &tmp, sizeof(tmp)) ? -EFAULT : 0;
1354 }
1355
1356 static int rc_ioctl(struct tty_struct *tty, struct file *filp,
1357                     unsigned int cmd, unsigned long arg)
1358 {
1359         struct riscom_port *port = (struct riscom_port *)tty->driver_data;
1360         void __user *argp = (void __user *)arg;
1361         int retval = 0;
1362
1363         if (rc_paranoia_check(port, tty->name, "rc_ioctl"))
1364                 return -ENODEV;
1365
1366         switch (cmd) {
1367         case TCSBRK:    /* SVID version: non-zero arg --> no break */
1368                 retval = tty_check_change(tty);
1369                 if (retval)
1370                         return retval;
1371                 tty_wait_until_sent(tty, 0);
1372                 if (!arg)
1373                         rc_send_break(port, HZ/4);      /* 1/4 second */
1374                 break;
1375         case TCSBRKP:   /* support for POSIX tcsendbreak() */
1376                 retval = tty_check_change(tty);
1377                 if (retval)
1378                         return retval;
1379                 tty_wait_until_sent(tty, 0);
1380                 rc_send_break(port, arg ? arg*(HZ/10) : HZ/4);
1381                 break;
1382         case TIOCGSERIAL:
1383                 lock_kernel();
1384                 retval = rc_get_serial_info(port, argp);
1385                 unlock_kernel();
1386                 break;
1387         case TIOCSSERIAL:
1388                 lock_kernel();
1389                 retval = rc_set_serial_info(port, argp);
1390                 unlock_kernel();
1391                 break;
1392         default:
1393                 retval = -ENOIOCTLCMD;
1394         }
1395         return retval;
1396 }
1397
1398 static void rc_throttle(struct tty_struct *tty)
1399 {
1400         struct riscom_port *port = (struct riscom_port *)tty->driver_data;
1401         struct riscom_board *bp;
1402         unsigned long flags;
1403
1404         if (rc_paranoia_check(port, tty->name, "rc_throttle"))
1405                 return;
1406         bp = port_Board(port);
1407
1408         spin_lock_irqsave(&riscom_lock, flags);
1409         port->MSVR &= ~MSVR_RTS;
1410         rc_out(bp, CD180_CAR, port_No(port));
1411         if (I_IXOFF(tty)) {
1412                 rc_wait_CCR(bp);
1413                 rc_out(bp, CD180_CCR, CCR_SSCH2);
1414                 rc_wait_CCR(bp);
1415         }
1416         rc_out(bp, CD180_MSVR, port->MSVR);
1417         spin_unlock_irqrestore(&riscom_lock, flags);
1418 }
1419
1420 static void rc_unthrottle(struct tty_struct *tty)
1421 {
1422         struct riscom_port *port = (struct riscom_port *)tty->driver_data;
1423         struct riscom_board *bp;
1424         unsigned long flags;
1425
1426         if (rc_paranoia_check(port, tty->name, "rc_unthrottle"))
1427                 return;
1428         bp = port_Board(port);
1429
1430         spin_lock_irqsave(&riscom_lock, flags);
1431         port->MSVR |= MSVR_RTS;
1432         rc_out(bp, CD180_CAR, port_No(port));
1433         if (I_IXOFF(tty))  {
1434                 rc_wait_CCR(bp);
1435                 rc_out(bp, CD180_CCR, CCR_SSCH1);
1436                 rc_wait_CCR(bp);
1437         }
1438         rc_out(bp, CD180_MSVR, port->MSVR);
1439         spin_unlock_irqrestore(&riscom_lock, flags);
1440 }
1441
1442 static void rc_stop(struct tty_struct *tty)
1443 {
1444         struct riscom_port *port = (struct riscom_port *)tty->driver_data;
1445         struct riscom_board *bp;
1446         unsigned long flags;
1447
1448         if (rc_paranoia_check(port, tty->name, "rc_stop"))
1449                 return;
1450
1451         bp = port_Board(port);
1452
1453         spin_lock_irqsave(&riscom_lock, flags);
1454         port->IER &= ~IER_TXRDY;
1455         rc_out(bp, CD180_CAR, port_No(port));
1456         rc_out(bp, CD180_IER, port->IER);
1457         spin_unlock_irqrestore(&riscom_lock, flags);
1458 }
1459
1460 static void rc_start(struct tty_struct *tty)
1461 {
1462         struct riscom_port *port = (struct riscom_port *)tty->driver_data;
1463         struct riscom_board *bp;
1464         unsigned long flags;
1465
1466         if (rc_paranoia_check(port, tty->name, "rc_start"))
1467                 return;
1468
1469         bp = port_Board(port);
1470
1471         spin_lock_irqsave(&riscom_lock, flags);
1472
1473         if (port->xmit_cnt && port->port.xmit_buf && !(port->IER & IER_TXRDY)) {
1474                 port->IER |= IER_TXRDY;
1475                 rc_out(bp, CD180_CAR, port_No(port));
1476                 rc_out(bp, CD180_IER, port->IER);
1477         }
1478         spin_unlock_irqrestore(&riscom_lock, flags);
1479 }
1480
1481 static void rc_hangup(struct tty_struct *tty)
1482 {
1483         struct riscom_port *port = (struct riscom_port *)tty->driver_data;
1484         struct riscom_board *bp;
1485
1486         if (rc_paranoia_check(port, tty->name, "rc_hangup"))
1487                 return;
1488
1489         bp = port_Board(port);
1490
1491         rc_shutdown_port(bp, port);
1492         port->port.count = 0;
1493         port->port.flags &= ~ASYNC_NORMAL_ACTIVE;
1494         port->port.tty = NULL;
1495         wake_up_interruptible(&port->port.open_wait);
1496 }
1497
1498 static void rc_set_termios(struct tty_struct *tty,
1499                                         struct ktermios *old_termios)
1500 {
1501         struct riscom_port *port = (struct riscom_port *)tty->driver_data;
1502         unsigned long flags;
1503
1504         if (rc_paranoia_check(port, tty->name, "rc_set_termios"))
1505                 return;
1506
1507         spin_lock_irqsave(&riscom_lock, flags);
1508         rc_change_speed(port_Board(port), port);
1509         spin_unlock_irqrestore(&riscom_lock, flags);
1510
1511         if ((old_termios->c_cflag & CRTSCTS) &&
1512             !(tty->termios->c_cflag & CRTSCTS)) {
1513                 tty->hw_stopped = 0;
1514                 rc_start(tty);
1515         }
1516 }
1517
1518 static const struct tty_operations riscom_ops = {
1519         .open  = rc_open,
1520         .close = rc_close,
1521         .write = rc_write,
1522         .put_char = rc_put_char,
1523         .flush_chars = rc_flush_chars,
1524         .write_room = rc_write_room,
1525         .chars_in_buffer = rc_chars_in_buffer,
1526         .flush_buffer = rc_flush_buffer,
1527         .ioctl = rc_ioctl,
1528         .throttle = rc_throttle,
1529         .unthrottle = rc_unthrottle,
1530         .set_termios = rc_set_termios,
1531         .stop = rc_stop,
1532         .start = rc_start,
1533         .hangup = rc_hangup,
1534         .tiocmget = rc_tiocmget,
1535         .tiocmset = rc_tiocmset,
1536 };
1537
1538 static int __init rc_init_drivers(void)
1539 {
1540         int error;
1541         int i;
1542
1543         riscom_driver = alloc_tty_driver(RC_NBOARD * RC_NPORT);
1544         if (!riscom_driver)
1545                 return -ENOMEM;
1546
1547         riscom_driver->owner = THIS_MODULE;
1548         riscom_driver->name = "ttyL";
1549         riscom_driver->major = RISCOM8_NORMAL_MAJOR;
1550         riscom_driver->type = TTY_DRIVER_TYPE_SERIAL;
1551         riscom_driver->subtype = SERIAL_TYPE_NORMAL;
1552         riscom_driver->init_termios = tty_std_termios;
1553         riscom_driver->init_termios.c_cflag =
1554                 B9600 | CS8 | CREAD | HUPCL | CLOCAL;
1555         riscom_driver->init_termios.c_ispeed = 9600;
1556         riscom_driver->init_termios.c_ospeed = 9600;
1557         riscom_driver->flags = TTY_DRIVER_REAL_RAW;
1558         tty_set_operations(riscom_driver, &riscom_ops);
1559         error = tty_register_driver(riscom_driver);
1560         if (error != 0) {
1561                 put_tty_driver(riscom_driver);
1562                 printk(KERN_ERR "rc: Couldn't register RISCom/8 driver, "
1563                                 "error = %d\n", error);
1564                 return 1;
1565         }
1566         memset(rc_port, 0, sizeof(rc_port));
1567         for (i = 0; i < RC_NPORT * RC_NBOARD; i++)  {
1568                 rc_port[i].magic = RISCOM8_MAGIC;
1569                 rc_port[i].close_delay = 50 * HZ / 100;
1570                 rc_port[i].closing_wait = 3000 * HZ / 100;
1571                 tty_port_init(&rc_port[i].port);
1572         }
1573         return 0;
1574 }
1575
1576 static void rc_release_drivers(void)
1577 {
1578         tty_unregister_driver(riscom_driver);
1579         put_tty_driver(riscom_driver);
1580 }
1581
1582 #ifndef MODULE
1583 /*
1584  * Called at boot time.
1585  *
1586  * You can specify IO base for up to RC_NBOARD cards,
1587  * using line "riscom8=0xiobase1,0xiobase2,.." at LILO prompt.
1588  * Note that there will be no probing at default
1589  * addresses in this case.
1590  *
1591  */
1592 static int __init riscom8_setup(char *str)
1593 {
1594         int ints[RC_NBOARD];
1595         int i;
1596
1597         str = get_options(str, ARRAY_SIZE(ints), ints);
1598
1599         for (i = 0; i < RC_NBOARD; i++) {
1600                 if (i < ints[0])
1601                         rc_board[i].base = ints[i+1];
1602                 else
1603                         rc_board[i].base = 0;
1604         }
1605         return 1;
1606 }
1607
1608 __setup("riscom8=", riscom8_setup);
1609 #endif
1610
1611 static char banner[] __initdata =
1612         KERN_INFO "rc: SDL RISCom/8 card driver v1.1, (c) D.Gorodchanin "
1613                   "1994-1996.\n";
1614 static char no_boards_msg[] __initdata =
1615         KERN_INFO "rc: No RISCom/8 boards detected.\n";
1616
1617 /*
1618  * This routine must be called by kernel at boot time
1619  */
1620 static int __init riscom8_init(void)
1621 {
1622         int i;
1623         int found = 0;
1624
1625         printk(banner);
1626
1627         if (rc_init_drivers())
1628                 return -EIO;
1629
1630         for (i = 0; i < RC_NBOARD; i++)
1631                 if (rc_board[i].base && !rc_probe(&rc_board[i]))
1632                         found++;
1633         if (!found)  {
1634                 rc_release_drivers();
1635                 printk(no_boards_msg);
1636                 return -EIO;
1637         }
1638         return 0;
1639 }
1640
1641 #ifdef MODULE
1642 static int iobase;
1643 static int iobase1;
1644 static int iobase2;
1645 static int iobase3;
1646 module_param(iobase, int, 0);
1647 module_param(iobase1, int, 0);
1648 module_param(iobase2, int, 0);
1649 module_param(iobase3, int, 0);
1650
1651 MODULE_LICENSE("GPL");
1652 #endif /* MODULE */
1653
1654 /*
1655  * You can setup up to 4 boards (current value of RC_NBOARD)
1656  * by specifying "iobase=0xXXX iobase1=0xXXX ..." as insmod parameter.
1657  *
1658  */
1659 static int __init riscom8_init_module(void)
1660 {
1661 #ifdef MODULE
1662         int i;
1663
1664         if (iobase || iobase1 || iobase2 || iobase3) {
1665                 for (i = 0; i < RC_NBOARD; i++)
1666                         rc_board[i].base = 0;
1667         }
1668
1669         if (iobase)
1670                 rc_board[0].base = iobase;
1671         if (iobase1)
1672                 rc_board[1].base = iobase1;
1673         if (iobase2)
1674                 rc_board[2].base = iobase2;
1675         if (iobase3)
1676                 rc_board[3].base = iobase3;
1677 #endif /* MODULE */
1678
1679         return riscom8_init();
1680 }
1681
1682 static void __exit riscom8_exit_module(void)
1683 {
1684         int i;
1685
1686         rc_release_drivers();
1687         for (i = 0; i < RC_NBOARD; i++)
1688                 if (rc_board[i].flags & RC_BOARD_PRESENT)
1689                         rc_release_io_range(&rc_board[i]);
1690
1691 }
1692
1693 module_init(riscom8_init_module);
1694 module_exit(riscom8_exit_module);