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