2 * linux/drivers/char/riscom.c -- RISCom/8 multiport serial driver.
4 * Copyright (C) 1994-1996 Dmitry Gorodchanin (pgmdsg@ibi.com)
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.
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.
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.
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.
30 * Arnaldo Carvalho de Melo <acme@conectiva.com.br> - 27-Jun-2001
31 * - get rid of check_region and several cleanups
34 #include <linux/module.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>
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>
52 #include <linux/uaccess.h>
55 #include "riscom8_reg.h"
57 /* Am I paranoid or not ? ;-) */
58 #define RISCOM_PARANOIA_CHECK
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.
66 #define RISCOM_BRAIN_DAMAGED_CTS
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.
73 #undef RC_REPORT_OVERRUN
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)
81 static struct tty_driver *riscom_driver;
83 static DEFINE_SPINLOCK(riscom_lock);
85 static struct riscom_board rc_board[RC_NBOARD] = {
100 static struct riscom_port rc_port[RC_NBOARD * RC_NPORT];
102 /* RISCom/8 I/O ports addresses (without address translation) */
103 static unsigned short rc_ioport[] = {
105 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x09, 0x0a, 0x0b, 0x0c,
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
112 #define RC_NIOPORT ARRAY_SIZE(rc_ioport)
115 static int rc_paranoia_check(struct riscom_port const *port,
116 char *name, const char *routine)
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";
125 printk(badinfo, name, routine);
128 if (port->magic != RISCOM8_MAGIC) {
129 printk(badmagic, name, routine);
138 * Service functions for RISCom/8 driver.
142 /* Get board number from pointer */
143 static inline int board_No(struct riscom_board const *bp)
145 return bp - rc_board;
148 /* Get port number from pointer */
149 static inline int port_No(struct riscom_port const *port)
151 return RC_PORT(port - rc_port);
154 /* Get pointer to board from pointer to port */
155 static inline struct riscom_board *port_Board(struct riscom_port const *port)
157 return &rc_board[RC_BOARD(port - rc_port)];
160 /* Input Byte from CL CD180 register */
161 static inline unsigned char rc_in(struct riscom_board const *bp,
164 return inb(bp->base + RC_TO_ISA(reg));
167 /* Output Byte to CL CD180 register */
168 static inline void rc_out(struct riscom_board const *bp, unsigned short reg,
171 outb(val, bp->base + RC_TO_ISA(reg));
174 /* Wait for Channel Command Register ready */
175 static void rc_wait_CCR(struct riscom_board const *bp)
179 /* FIXME: need something more descriptive then 100000 :) */
180 for (delay = 100000; delay; delay--)
181 if (!rc_in(bp, CD180_CCR))
184 printk(KERN_INFO "rc%d: Timeout waiting for CCR.\n", board_No(bp));
188 * RISCom/8 probe functions.
191 static int rc_request_io_range(struct riscom_board * const bp)
195 for (i = 0; i < RC_NIOPORT; i++)
196 if (!request_region(RC_TO_ISA(rc_ioport[i]) + bp->base, 1,
202 printk(KERN_INFO "rc%d: Skipping probe at 0x%03x. IO address in use.\n",
203 board_No(bp), bp->base);
205 release_region(RC_TO_ISA(rc_ioport[i]) + bp->base, 1);
209 static void rc_release_io_range(struct riscom_board * const bp)
213 for (i = 0; i < RC_NIOPORT; i++)
214 release_region(RC_TO_ISA(rc_ioport[i]) + bp->base, 1);
217 /* Reset and setup CD180 chip */
218 static void __init rc_init_CD180(struct riscom_board const *bp)
222 spin_lock_irqsave(&riscom_lock, flags);
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 */
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);
240 spin_unlock_irqrestore(&riscom_lock, flags);
243 /* Main probing routine, also sets irq. */
244 static int __init rc_probe(struct riscom_board *bp)
246 unsigned char val1, val2;
252 if (rc_request_io_range(bp))
255 /* Are the I/O ports here ? */
256 rc_out(bp, CD180_PPRL, 0x5a);
258 val1 = rc_in(bp, CD180_PPRL);
259 rc_out(bp, CD180_PPRL, 0xa5);
261 val2 = rc_in(bp, CD180_PPRL);
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);
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 */
275 rc_out(bp, CD180_CCR, CCR_TXEN); /* Enable transmitter */
276 rc_out(bp, CD180_IER, IER_TXRDY);/* Enable tx empty intr */
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 */
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);
291 printk(KERN_ERR "rc%d: Can't find IRQ for RISCom/8 board "
292 "at 0x%03x.\n", board_No(bp), bp->base);
296 bp->flags |= RC_BOARD_PRESENT;
298 printk(KERN_INFO "rc%d: RISCom/8 Rev. %c board detected at "
301 (rc_in(bp, CD180_GFRCR) & 0x0f) + 'A', /* Board revision */
306 rc_release_io_range(bp);
312 * Interrupt processing routines.
316 static struct riscom_port *rc_get_port(struct riscom_board const *bp,
317 unsigned char const *what)
319 unsigned char channel;
320 struct riscom_port *port;
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)
328 printk(KERN_ERR "rc%d: %s interrupt from invalid port %d\n",
329 board_No(bp), what, channel);
333 static void rc_receive_exc(struct riscom_board const *bp)
335 struct riscom_port *port;
336 struct tty_struct *tty;
337 unsigned char status;
338 unsigned char ch, flag;
340 port = rc_get_port(bp, "Receive");
344 tty = port->port.tty;
346 #ifdef RC_REPORT_OVERRUN
347 status = rc_in(bp, CD180_RCSR);
348 if (status & RCSR_OE)
350 status &= port->mark_mask;
352 status = rc_in(bp, CD180_RCSR) & port->mark_mask;
354 ch = rc_in(bp, CD180_RDR);
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));
363 } else if (status & RCSR_BREAK) {
364 printk(KERN_INFO "rc%d: port %d: Handling break...\n",
365 board_No(bp), port_No(port));
367 if (port->port.flags & ASYNC_SAK)
370 } else if (status & RCSR_PE)
373 else if (status & RCSR_FE)
376 else if (status & RCSR_OE)
381 tty_insert_flip_char(tty, ch, flag);
382 tty_flip_buffer_push(tty);
385 static void rc_receive(struct riscom_board const *bp)
387 struct riscom_port *port;
388 struct tty_struct *tty;
391 port = rc_get_port(bp, "Receive");
395 tty = port->port.tty;
397 count = rc_in(bp, CD180_RDCR);
399 #ifdef RC_REPORT_FIFO
400 port->hits[count > 8 ? 9 : 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));
410 tty_insert_flip_char(tty, rc_in(bp, CD180_RDR), TTY_NORMAL);
412 tty_flip_buffer_push(tty);
415 static void rc_transmit(struct riscom_board const *bp)
417 struct riscom_port *port;
418 struct tty_struct *tty;
421 port = rc_get_port(bp, "Transmit");
425 tty = port->port.tty;
427 if (port->IER & IER_TXEMPTY) {
429 rc_out(bp, CD180_CAR, port_No(port));
430 port->IER &= ~IER_TXEMPTY;
431 rc_out(bp, CD180_IER, port->IER);
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);
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;
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--;
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);
462 rc_out(bp, CD180_CCR, CCR_CORCHG2);
463 port->break_length = 0;
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)
474 } while (--count > 0);
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);
481 if (port->xmit_cnt <= port->wakeup_chars)
485 static void rc_check_modem(struct riscom_board const *bp)
487 struct riscom_port *port;
488 struct tty_struct *tty;
491 port = rc_get_port(bp, "Modem");
495 tty = port->port.tty;
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);
505 #ifdef RISCOM_BRAIN_DAMAGED_CTS
506 if (mcr & MCR_CTSCHG) {
507 if (rc_in(bp, CD180_MSVR) & MSVR_CTS) {
509 port->IER |= IER_TXRDY;
510 if (port->xmit_cnt <= port->wakeup_chars)
514 port->IER &= ~IER_TXRDY;
516 rc_out(bp, CD180_IER, port->IER);
518 if (mcr & MCR_DSRCHG) {
519 if (rc_in(bp, CD180_MSVR) & MSVR_DSR) {
521 port->IER |= IER_TXRDY;
522 if (port->xmit_cnt <= port->wakeup_chars)
526 port->IER &= ~IER_TXRDY;
528 rc_out(bp, CD180_IER, port->IER);
530 #endif /* RISCOM_BRAIN_DAMAGED_CTS */
532 /* Clear change bits */
533 rc_out(bp, CD180_MCR, 0);
536 /* The main interrupt processing routine */
537 static irqreturn_t rc_interrupt(int dummy, void *dev_id)
539 unsigned char status;
541 struct riscom_board *bp = dev_id;
542 unsigned long loop = 0;
545 if (!(bp->flags & RC_BOARD_ACTIVE))
548 while ((++loop < 16) && ((status = ~(rc_in(bp, RC_BSR))) &
549 (RC_BSR_TOUT | RC_BSR_TINT |
550 RC_BSR_MINT | RC_BSR_RINT))) {
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))
559 else if (ack == (RC_ID | GIVR_IT_REXC))
562 printk(KERN_WARNING "rc%d: Bad receive ack "
565 } else if (status & RC_BSR_TINT) {
566 ack = rc_in(bp, RC_ACK_TINT);
567 if (ack == (RC_ID | GIVR_IT_TX))
570 printk(KERN_WARNING "rc%d: Bad transmit ack "
573 } else /* if (status & RC_BSR_MINT) */ {
574 ack = rc_in(bp, RC_ACK_MINT);
575 if (ack == (RC_ID | GIVR_IT_MODEM))
578 printk(KERN_WARNING "rc%d: Bad modem ack "
582 rc_out(bp, CD180_EOIR, 0); /* Mark end of interrupt */
583 rc_out(bp, RC_CTOUT, 0); /* Clear timeout flag */
585 return IRQ_RETVAL(handled);
589 * Routines for open & close processing.
592 /* Called with disabled interrupts */
593 static int rc_setup_board(struct riscom_board *bp)
597 if (bp->flags & RC_BOARD_ACTIVE)
600 error = request_irq(bp->irq, rc_interrupt, IRQF_DISABLED,
605 rc_out(bp, RC_CTOUT, 0); /* Just in case */
607 rc_out(bp, RC_DTR, bp->DTR); /* Drop DTR on all ports */
609 bp->flags |= RC_BOARD_ACTIVE;
614 /* Called with disabled interrupts */
615 static void rc_shutdown_board(struct riscom_board *bp)
617 if (!(bp->flags & RC_BOARD_ACTIVE))
620 bp->flags &= ~RC_BOARD_ACTIVE;
622 free_irq(bp->irq, NULL);
625 rc_out(bp, RC_DTR, bp->DTR); /* Drop DTR on all ports */
630 * Setting up port characteristics.
631 * Must be called with disabled interrupts
633 static void rc_change_speed(struct riscom_board *bp, struct riscom_port *port)
635 struct tty_struct *tty = port->port.tty;
638 unsigned char cor1 = 0, cor3 = 0;
639 unsigned char mcor1 = 0, mcor2 = 0;
643 port->MSVR = MSVR_RTS;
645 baud = tty_get_baud_rate(tty);
647 /* Select port on the board */
648 rc_out(bp, CD180_CAR, port_No(port));
651 /* Drop DTR & exit */
652 bp->DTR |= (1u << port_No(port));
653 rc_out(bp, RC_DTR, bp->DTR);
657 bp->DTR &= ~(1u << port_No(port));
658 rc_out(bp, RC_DTR, bp->DTR);
662 * Now we must calculate some speed depended things
665 /* Set baud rate for port */
666 tmp = (((RC_OSCFREQ + baud/2) / baud +
667 CD180_TPC/2) / CD180_TPC);
669 rc_out(bp, CD180_RBPRH, (tmp >> 8) & 0xff);
670 rc_out(bp, CD180_TBPRH, (tmp >> 8) & 0xff);
671 rc_out(bp, CD180_RBPRL, tmp & 0xff);
672 rc_out(bp, CD180_TBPRL, tmp & 0xff);
674 baud = (baud + 5) / 10; /* Estimated CPS */
676 /* Two timer ticks seems enough to wakeup something like SLIP driver */
677 tmp = ((baud + HZ/2) / HZ) * 2 - CD180_NFIFO;
678 port->wakeup_chars = (tmp < 0) ? 0 : ((tmp >= SERIAL_XMIT_SIZE) ?
679 SERIAL_XMIT_SIZE - 1 : tmp);
681 /* Receiver timeout will be transmission time for 1.5 chars */
682 tmp = (RISCOM_TPS + RISCOM_TPS/2 + baud/2) / baud;
683 tmp = (tmp > 0xff) ? 0xff : tmp;
684 rc_out(bp, CD180_RTPR, tmp);
686 switch (C_CSIZE(tty)) {
705 cor1 |= COR1_NORMPAR;
709 cor1 &= ~COR1_IGNORE;
711 /* Set marking of some errors */
712 port->mark_mask = RCSR_OE | RCSR_TOUT;
714 port->mark_mask |= RCSR_FE | RCSR_PE;
715 if (I_BRKINT(tty) || I_PARMRK(tty))
716 port->mark_mask |= RCSR_BREAK;
718 port->mark_mask &= ~(RCSR_FE | RCSR_PE);
720 port->mark_mask &= ~RCSR_BREAK;
722 /* Real raw mode. Ignore all */
723 port->mark_mask &= ~RCSR_OE;
725 /* Enable Hardware Flow Control */
726 if (C_CRTSCTS(tty)) {
727 #ifdef RISCOM_BRAIN_DAMAGED_CTS
728 port->IER |= IER_DSR | IER_CTS;
729 mcor1 |= MCOR1_DSRZD | MCOR1_CTSZD;
730 mcor2 |= MCOR2_DSROD | MCOR2_CTSOD;
731 tty->hw_stopped = !(rc_in(bp, CD180_MSVR) &
732 (MSVR_CTS|MSVR_DSR));
734 port->COR2 |= COR2_CTSAE;
737 /* Enable Software Flow Control. FIXME: I'm not sure about this */
738 /* Some people reported that it works, but I still doubt */
740 port->COR2 |= COR2_TXIBE;
741 cor3 |= (COR3_FCT | COR3_SCDE);
743 port->COR2 |= COR2_IXM;
744 rc_out(bp, CD180_SCHR1, START_CHAR(tty));
745 rc_out(bp, CD180_SCHR2, STOP_CHAR(tty));
746 rc_out(bp, CD180_SCHR3, START_CHAR(tty));
747 rc_out(bp, CD180_SCHR4, STOP_CHAR(tty));
749 if (!C_CLOCAL(tty)) {
750 /* Enable CD check */
757 /* Enable receiver */
758 port->IER |= IER_RXD;
760 /* Set input FIFO size (1-8 bytes) */
761 cor3 |= RISCOM_RXFIFO;
762 /* Setting up CD180 channel registers */
763 rc_out(bp, CD180_COR1, cor1);
764 rc_out(bp, CD180_COR2, port->COR2);
765 rc_out(bp, CD180_COR3, cor3);
766 /* Make CD180 know about registers change */
768 rc_out(bp, CD180_CCR, CCR_CORCHG1 | CCR_CORCHG2 | CCR_CORCHG3);
769 /* Setting up modem option registers */
770 rc_out(bp, CD180_MCOR1, mcor1);
771 rc_out(bp, CD180_MCOR2, mcor2);
772 /* Enable CD180 transmitter & receiver */
774 rc_out(bp, CD180_CCR, CCR_TXEN | CCR_RXEN);
775 /* Enable interrupts */
776 rc_out(bp, CD180_IER, port->IER);
777 /* And finally set RTS on */
778 rc_out(bp, CD180_MSVR, port->MSVR);
781 /* Must be called with interrupts enabled */
782 static int rc_setup_port(struct riscom_board *bp, struct riscom_port *port)
786 if (port->port.flags & ASYNC_INITIALIZED)
789 if (tty_port_alloc_xmit_buf(&port->port) < 0)
792 spin_lock_irqsave(&riscom_lock, flags);
794 clear_bit(TTY_IO_ERROR, &port->port.tty->flags);
795 if (port->port.count == 1)
797 port->xmit_cnt = port->xmit_head = port->xmit_tail = 0;
798 rc_change_speed(bp, port);
799 port->port.flags |= ASYNC_INITIALIZED;
801 spin_unlock_irqrestore(&riscom_lock, flags);
805 /* Must be called with interrupts disabled */
806 static void rc_shutdown_port(struct tty_struct *tty,
807 struct riscom_board *bp, struct riscom_port *port)
809 if (!(port->port.flags & ASYNC_INITIALIZED))
812 #ifdef RC_REPORT_OVERRUN
813 printk(KERN_INFO "rc%d: port %d: Total %ld overruns were detected.\n",
814 board_No(bp), port_No(port), port->overrun);
816 #ifdef RC_REPORT_FIFO
820 printk(KERN_INFO "rc%d: port %d: FIFO hits [ ",
821 board_No(bp), port_No(port));
822 for (i = 0; i < 10; i++)
823 printk("%ld ", port->hits[i]);
827 tty_port_free_xmit_buf(&port->port);
830 bp->DTR |= (1u << port_No(port));
831 rc_out(bp, RC_DTR, bp->DTR);
835 rc_out(bp, CD180_CAR, port_No(port));
838 rc_out(bp, CD180_CCR, CCR_SOFTRESET);
839 /* Disable all interrupts from this port */
841 rc_out(bp, CD180_IER, port->IER);
843 set_bit(TTY_IO_ERROR, &tty->flags);
844 port->port.flags &= ~ASYNC_INITIALIZED;
846 if (--bp->count < 0) {
847 printk(KERN_INFO "rc%d: rc_shutdown_port: "
848 "bad board count: %d\n",
849 board_No(bp), bp->count);
853 * If this is the last opened port on the board
854 * shutdown whole board
857 rc_shutdown_board(bp);
860 static int carrier_raised(struct tty_port *port)
862 struct riscom_port *p = container_of(port, struct riscom_port, port);
863 struct riscom_board *bp = port_Board(p);
867 spin_lock_irqsave(&riscom_lock, flags);
868 rc_out(bp, CD180_CAR, port_No(p));
869 CD = rc_in(bp, CD180_MSVR) & MSVR_CD;
870 rc_out(bp, CD180_MSVR, MSVR_RTS);
871 bp->DTR &= ~(1u << port_No(p));
872 rc_out(bp, RC_DTR, bp->DTR);
873 spin_unlock_irqrestore(&riscom_lock, flags);
877 static int block_til_ready(struct tty_struct *tty, struct file *filp,
878 struct riscom_port *rp)
880 DECLARE_WAITQUEUE(wait, current);
885 struct tty_port *port = &rp->port;
888 * If the device is in the middle of being closed, then block
889 * until it's done, and then try again.
891 if (tty_hung_up_p(filp) || port->flags & ASYNC_CLOSING) {
892 interruptible_sleep_on(&port->close_wait);
893 if (port->flags & ASYNC_HUP_NOTIFY)
900 * If non-blocking mode is set, or the port is not enabled,
901 * then make the check up front and then exit.
903 if ((filp->f_flags & O_NONBLOCK) ||
904 (tty->flags & (1 << TTY_IO_ERROR))) {
905 port->flags |= ASYNC_NORMAL_ACTIVE;
913 * Block waiting for the carrier detect and the line to become
914 * free (i.e., not in use by the callout). While we are in
915 * this loop, info->count is dropped by one, so that
916 * rs_close() knows when to free things. We restore it upon
917 * exit, either normal or abnormal.
920 add_wait_queue(&port->open_wait, &wait);
922 spin_lock_irqsave(&riscom_lock, flags);
924 if (!tty_hung_up_p(filp))
927 spin_unlock_irqrestore(&riscom_lock, flags);
929 port->blocked_open++;
932 CD = tty_port_carrier_raised(port);
933 set_current_state(TASK_INTERRUPTIBLE);
934 if (tty_hung_up_p(filp) ||
935 !(port->flags & ASYNC_INITIALIZED)) {
936 if (port->flags & ASYNC_HUP_NOTIFY)
939 retval = -ERESTARTSYS;
942 if (!(port->flags & ASYNC_CLOSING) &&
945 if (signal_pending(current)) {
946 retval = -ERESTARTSYS;
951 __set_current_state(TASK_RUNNING);
952 remove_wait_queue(&port->open_wait, &wait);
953 if (!tty_hung_up_p(filp))
955 port->blocked_open--;
959 port->flags |= ASYNC_NORMAL_ACTIVE;
963 static int rc_open(struct tty_struct *tty, struct file *filp)
967 struct riscom_port *port;
968 struct riscom_board *bp;
970 board = RC_BOARD(tty->index);
971 if (board >= RC_NBOARD || !(rc_board[board].flags & RC_BOARD_PRESENT))
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"))
979 error = rc_setup_board(bp);
984 tty->driver_data = port;
985 port->port.tty = tty;
987 error = rc_setup_port(bp, port);
989 error = block_til_ready(tty, filp, port);
993 static void rc_flush_buffer(struct tty_struct *tty)
995 struct riscom_port *port = (struct riscom_port *)tty->driver_data;
998 if (rc_paranoia_check(port, tty->name, "rc_flush_buffer"))
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);
1008 static void rc_close(struct tty_struct *tty, struct file *filp)
1010 struct riscom_port *port = (struct riscom_port *) tty->driver_data;
1011 struct riscom_board *bp;
1012 unsigned long flags;
1013 unsigned long timeout;
1015 if (!port || rc_paranoia_check(port, tty->name, "close"))
1018 spin_lock_irqsave(&riscom_lock, flags);
1020 if (tty_hung_up_p(filp))
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;
1030 if (--port->port.count < 0) {
1031 printk(KERN_INFO "rc%d: rc_close: bad port count "
1033 board_No(bp), port_No(port), port->port.count);
1034 port->port.count = 0;
1036 if (port->port.count)
1038 port->port.flags |= ASYNC_CLOSING;
1040 * Now we wait for the transmit buffer to clear; and we notify
1041 * the line discipline to only process XON/XOFF characters.
1044 if (port->port.closing_wait != ASYNC_CLOSING_WAIT_NONE)
1045 tty_wait_until_sent(tty, port->port.closing_wait);
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.
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);
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!
1063 timeout = jiffies + HZ;
1064 while (port->IER & IER_TXEMPTY) {
1065 msleep_interruptible(jiffies_to_msecs(port->timeout));
1066 if (time_after(jiffies, timeout))
1070 rc_shutdown_port(tty, bp, port);
1071 rc_flush_buffer(tty);
1072 tty_ldisc_flush(tty);
1075 port->port.tty = NULL;
1076 if (port->port.blocked_open) {
1077 if (port->port.close_delay)
1078 msleep_interruptible(jiffies_to_msecs(port->port.close_delay));
1079 wake_up_interruptible(&port->port.open_wait);
1081 port->port.flags &= ~(ASYNC_NORMAL_ACTIVE|ASYNC_CLOSING);
1082 wake_up_interruptible(&port->port.close_wait);
1085 spin_unlock_irqrestore(&riscom_lock, flags);
1088 static int rc_write(struct tty_struct *tty,
1089 const unsigned char *buf, int count)
1091 struct riscom_port *port = (struct riscom_port *)tty->driver_data;
1092 struct riscom_board *bp;
1094 unsigned long flags;
1096 if (rc_paranoia_check(port, tty->name, "rc_write"))
1099 bp = port_Board(port);
1102 spin_lock_irqsave(&riscom_lock, flags);
1104 c = min_t(int, count, min(SERIAL_XMIT_SIZE - port->xmit_cnt - 1,
1105 SERIAL_XMIT_SIZE - port->xmit_head));
1107 break; /* lock continues to be held */
1109 memcpy(port->port.xmit_buf + port->xmit_head, buf, c);
1110 port->xmit_head = (port->xmit_head + c) & (SERIAL_XMIT_SIZE-1);
1111 port->xmit_cnt += c;
1113 spin_unlock_irqrestore(&riscom_lock, flags);
1120 if (port->xmit_cnt && !tty->stopped && !tty->hw_stopped &&
1121 !(port->IER & IER_TXRDY)) {
1122 port->IER |= IER_TXRDY;
1123 rc_out(bp, CD180_CAR, port_No(port));
1124 rc_out(bp, CD180_IER, port->IER);
1127 spin_unlock_irqrestore(&riscom_lock, flags);
1132 static int rc_put_char(struct tty_struct *tty, unsigned char ch)
1134 struct riscom_port *port = (struct riscom_port *)tty->driver_data;
1135 unsigned long flags;
1138 if (rc_paranoia_check(port, tty->name, "rc_put_char"))
1141 spin_lock_irqsave(&riscom_lock, flags);
1143 if (port->xmit_cnt >= SERIAL_XMIT_SIZE - 1)
1146 port->port.xmit_buf[port->xmit_head++] = ch;
1147 port->xmit_head &= SERIAL_XMIT_SIZE - 1;
1152 spin_unlock_irqrestore(&riscom_lock, flags);
1156 static void rc_flush_chars(struct tty_struct *tty)
1158 struct riscom_port *port = (struct riscom_port *)tty->driver_data;
1159 unsigned long flags;
1161 if (rc_paranoia_check(port, tty->name, "rc_flush_chars"))
1164 if (port->xmit_cnt <= 0 || tty->stopped || tty->hw_stopped)
1167 spin_lock_irqsave(&riscom_lock, flags);
1169 port->IER |= IER_TXRDY;
1170 rc_out(port_Board(port), CD180_CAR, port_No(port));
1171 rc_out(port_Board(port), CD180_IER, port->IER);
1173 spin_unlock_irqrestore(&riscom_lock, flags);
1176 static int rc_write_room(struct tty_struct *tty)
1178 struct riscom_port *port = (struct riscom_port *)tty->driver_data;
1181 if (rc_paranoia_check(port, tty->name, "rc_write_room"))
1184 ret = SERIAL_XMIT_SIZE - port->xmit_cnt - 1;
1190 static int rc_chars_in_buffer(struct tty_struct *tty)
1192 struct riscom_port *port = (struct riscom_port *)tty->driver_data;
1194 if (rc_paranoia_check(port, tty->name, "rc_chars_in_buffer"))
1197 return port->xmit_cnt;
1200 static int rc_tiocmget(struct tty_struct *tty, struct file *file)
1202 struct riscom_port *port = (struct riscom_port *)tty->driver_data;
1203 struct riscom_board *bp;
1204 unsigned char status;
1205 unsigned int result;
1206 unsigned long flags;
1208 if (rc_paranoia_check(port, tty->name, __func__))
1211 bp = port_Board(port);
1213 spin_lock_irqsave(&riscom_lock, flags);
1215 rc_out(bp, CD180_CAR, port_No(port));
1216 status = rc_in(bp, CD180_MSVR);
1217 result = rc_in(bp, RC_RI) & (1u << port_No(port)) ? 0 : TIOCM_RNG;
1219 spin_unlock_irqrestore(&riscom_lock, flags);
1221 result |= ((status & MSVR_RTS) ? TIOCM_RTS : 0)
1222 | ((status & MSVR_DTR) ? TIOCM_DTR : 0)
1223 | ((status & MSVR_CD) ? TIOCM_CAR : 0)
1224 | ((status & MSVR_DSR) ? TIOCM_DSR : 0)
1225 | ((status & MSVR_CTS) ? TIOCM_CTS : 0);
1229 static int rc_tiocmset(struct tty_struct *tty, struct file *file,
1230 unsigned int set, unsigned int clear)
1232 struct riscom_port *port = (struct riscom_port *)tty->driver_data;
1233 unsigned long flags;
1234 struct riscom_board *bp;
1236 if (rc_paranoia_check(port, tty->name, __func__))
1239 bp = port_Board(port);
1241 spin_lock_irqsave(&riscom_lock, flags);
1243 if (set & TIOCM_RTS)
1244 port->MSVR |= MSVR_RTS;
1245 if (set & TIOCM_DTR)
1246 bp->DTR &= ~(1u << port_No(port));
1248 if (clear & TIOCM_RTS)
1249 port->MSVR &= ~MSVR_RTS;
1250 if (clear & TIOCM_DTR)
1251 bp->DTR |= (1u << port_No(port));
1253 rc_out(bp, CD180_CAR, port_No(port));
1254 rc_out(bp, CD180_MSVR, port->MSVR);
1255 rc_out(bp, RC_DTR, bp->DTR);
1257 spin_unlock_irqrestore(&riscom_lock, flags);
1262 static int rc_send_break(struct tty_struct *tty, int length)
1264 struct riscom_port *port = (struct riscom_port *)tty->driver_data;
1265 struct riscom_board *bp = port_Board(port);
1266 unsigned long flags;
1268 if (length == 0 || length == -1)
1271 spin_lock_irqsave(&riscom_lock, flags);
1273 port->break_length = RISCOM_TPS / HZ * length;
1274 port->COR2 |= COR2_ETC;
1275 port->IER |= IER_TXRDY;
1276 rc_out(bp, CD180_CAR, port_No(port));
1277 rc_out(bp, CD180_COR2, port->COR2);
1278 rc_out(bp, CD180_IER, port->IER);
1280 rc_out(bp, CD180_CCR, CCR_CORCHG2);
1283 spin_unlock_irqrestore(&riscom_lock, flags);
1287 static int rc_set_serial_info(struct riscom_port *port,
1288 struct serial_struct __user *newinfo)
1290 struct serial_struct tmp;
1291 struct riscom_board *bp = port_Board(port);
1294 if (copy_from_user(&tmp, newinfo, sizeof(tmp)))
1298 if ((tmp.irq != bp->irq) ||
1299 (tmp.port != bp->base) ||
1300 (tmp.type != PORT_CIRRUS) ||
1301 (tmp.baud_base != (RC_OSCFREQ + CD180_TPC/2) / CD180_TPC) ||
1302 (tmp.custom_divisor != 0) ||
1303 (tmp.xmit_fifo_size != CD180_NFIFO) ||
1304 (tmp.flags & ~RISCOM_LEGAL_FLAGS))
1308 change_speed = ((port->port.flags & ASYNC_SPD_MASK) !=
1309 (tmp.flags & ASYNC_SPD_MASK));
1311 if (!capable(CAP_SYS_ADMIN)) {
1312 if ((tmp.close_delay != port->port.close_delay) ||
1313 (tmp.closing_wait != port->port.closing_wait) ||
1314 ((tmp.flags & ~ASYNC_USR_MASK) !=
1315 (port->port.flags & ~ASYNC_USR_MASK)))
1317 port->port.flags = ((port->port.flags & ~ASYNC_USR_MASK) |
1318 (tmp.flags & ASYNC_USR_MASK));
1320 port->port.flags = ((port->port.flags & ~ASYNC_FLAGS) |
1321 (tmp.flags & ASYNC_FLAGS));
1322 port->port.close_delay = tmp.close_delay;
1323 port->port.closing_wait = tmp.closing_wait;
1326 unsigned long flags;
1328 spin_lock_irqsave(&riscom_lock, flags);
1329 rc_change_speed(bp, port);
1330 spin_unlock_irqrestore(&riscom_lock, flags);
1335 static int rc_get_serial_info(struct riscom_port *port,
1336 struct serial_struct __user *retinfo)
1338 struct serial_struct tmp;
1339 struct riscom_board *bp = port_Board(port);
1341 memset(&tmp, 0, sizeof(tmp));
1342 tmp.type = PORT_CIRRUS;
1343 tmp.line = port - rc_port;
1344 tmp.port = bp->base;
1346 tmp.flags = port->port.flags;
1347 tmp.baud_base = (RC_OSCFREQ + CD180_TPC/2) / CD180_TPC;
1348 tmp.close_delay = port->port.close_delay * HZ/100;
1349 tmp.closing_wait = port->port.closing_wait * HZ/100;
1350 tmp.xmit_fifo_size = CD180_NFIFO;
1351 return copy_to_user(retinfo, &tmp, sizeof(tmp)) ? -EFAULT : 0;
1354 static int rc_ioctl(struct tty_struct *tty, struct file *filp,
1355 unsigned int cmd, unsigned long arg)
1357 struct riscom_port *port = (struct riscom_port *)tty->driver_data;
1358 void __user *argp = (void __user *)arg;
1361 if (rc_paranoia_check(port, tty->name, "rc_ioctl"))
1367 retval = rc_get_serial_info(port, argp);
1372 retval = rc_set_serial_info(port, argp);
1376 retval = -ENOIOCTLCMD;
1381 static void rc_throttle(struct tty_struct *tty)
1383 struct riscom_port *port = (struct riscom_port *)tty->driver_data;
1384 struct riscom_board *bp;
1385 unsigned long flags;
1387 if (rc_paranoia_check(port, tty->name, "rc_throttle"))
1389 bp = port_Board(port);
1391 spin_lock_irqsave(&riscom_lock, flags);
1392 port->MSVR &= ~MSVR_RTS;
1393 rc_out(bp, CD180_CAR, port_No(port));
1396 rc_out(bp, CD180_CCR, CCR_SSCH2);
1399 rc_out(bp, CD180_MSVR, port->MSVR);
1400 spin_unlock_irqrestore(&riscom_lock, flags);
1403 static void rc_unthrottle(struct tty_struct *tty)
1405 struct riscom_port *port = (struct riscom_port *)tty->driver_data;
1406 struct riscom_board *bp;
1407 unsigned long flags;
1409 if (rc_paranoia_check(port, tty->name, "rc_unthrottle"))
1411 bp = port_Board(port);
1413 spin_lock_irqsave(&riscom_lock, flags);
1414 port->MSVR |= MSVR_RTS;
1415 rc_out(bp, CD180_CAR, port_No(port));
1418 rc_out(bp, CD180_CCR, CCR_SSCH1);
1421 rc_out(bp, CD180_MSVR, port->MSVR);
1422 spin_unlock_irqrestore(&riscom_lock, flags);
1425 static void rc_stop(struct tty_struct *tty)
1427 struct riscom_port *port = (struct riscom_port *)tty->driver_data;
1428 struct riscom_board *bp;
1429 unsigned long flags;
1431 if (rc_paranoia_check(port, tty->name, "rc_stop"))
1434 bp = port_Board(port);
1436 spin_lock_irqsave(&riscom_lock, flags);
1437 port->IER &= ~IER_TXRDY;
1438 rc_out(bp, CD180_CAR, port_No(port));
1439 rc_out(bp, CD180_IER, port->IER);
1440 spin_unlock_irqrestore(&riscom_lock, flags);
1443 static void rc_start(struct tty_struct *tty)
1445 struct riscom_port *port = (struct riscom_port *)tty->driver_data;
1446 struct riscom_board *bp;
1447 unsigned long flags;
1449 if (rc_paranoia_check(port, tty->name, "rc_start"))
1452 bp = port_Board(port);
1454 spin_lock_irqsave(&riscom_lock, flags);
1456 if (port->xmit_cnt && port->port.xmit_buf && !(port->IER & IER_TXRDY)) {
1457 port->IER |= IER_TXRDY;
1458 rc_out(bp, CD180_CAR, port_No(port));
1459 rc_out(bp, CD180_IER, port->IER);
1461 spin_unlock_irqrestore(&riscom_lock, flags);
1464 static void rc_hangup(struct tty_struct *tty)
1466 struct riscom_port *port = (struct riscom_port *)tty->driver_data;
1467 struct riscom_board *bp;
1469 if (rc_paranoia_check(port, tty->name, "rc_hangup"))
1472 bp = port_Board(port);
1474 rc_shutdown_port(tty, bp, port);
1475 port->port.count = 0;
1476 port->port.flags &= ~ASYNC_NORMAL_ACTIVE;
1477 port->port.tty = NULL;
1478 wake_up_interruptible(&port->port.open_wait);
1481 static void rc_set_termios(struct tty_struct *tty,
1482 struct ktermios *old_termios)
1484 struct riscom_port *port = (struct riscom_port *)tty->driver_data;
1485 unsigned long flags;
1487 if (rc_paranoia_check(port, tty->name, "rc_set_termios"))
1490 spin_lock_irqsave(&riscom_lock, flags);
1491 rc_change_speed(port_Board(port), port);
1492 spin_unlock_irqrestore(&riscom_lock, flags);
1494 if ((old_termios->c_cflag & CRTSCTS) &&
1495 !(tty->termios->c_cflag & CRTSCTS)) {
1496 tty->hw_stopped = 0;
1501 static const struct tty_operations riscom_ops = {
1505 .put_char = rc_put_char,
1506 .flush_chars = rc_flush_chars,
1507 .write_room = rc_write_room,
1508 .chars_in_buffer = rc_chars_in_buffer,
1509 .flush_buffer = rc_flush_buffer,
1511 .throttle = rc_throttle,
1512 .unthrottle = rc_unthrottle,
1513 .set_termios = rc_set_termios,
1516 .hangup = rc_hangup,
1517 .tiocmget = rc_tiocmget,
1518 .tiocmset = rc_tiocmset,
1519 .break_ctl = rc_send_break,
1522 static const struct tty_port_operations riscom_port_ops = {
1523 .carrier_raised = carrier_raised,
1527 static int __init rc_init_drivers(void)
1532 riscom_driver = alloc_tty_driver(RC_NBOARD * RC_NPORT);
1536 riscom_driver->owner = THIS_MODULE;
1537 riscom_driver->name = "ttyL";
1538 riscom_driver->major = RISCOM8_NORMAL_MAJOR;
1539 riscom_driver->type = TTY_DRIVER_TYPE_SERIAL;
1540 riscom_driver->subtype = SERIAL_TYPE_NORMAL;
1541 riscom_driver->init_termios = tty_std_termios;
1542 riscom_driver->init_termios.c_cflag =
1543 B9600 | CS8 | CREAD | HUPCL | CLOCAL;
1544 riscom_driver->init_termios.c_ispeed = 9600;
1545 riscom_driver->init_termios.c_ospeed = 9600;
1546 riscom_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_HARDWARE_BREAK;
1547 tty_set_operations(riscom_driver, &riscom_ops);
1548 error = tty_register_driver(riscom_driver);
1550 put_tty_driver(riscom_driver);
1551 printk(KERN_ERR "rc: Couldn't register RISCom/8 driver, "
1552 "error = %d\n", error);
1555 memset(rc_port, 0, sizeof(rc_port));
1556 for (i = 0; i < RC_NPORT * RC_NBOARD; i++) {
1557 tty_port_init(&rc_port[i].port);
1558 rc_port[i].port.ops = &riscom_port_ops;
1559 rc_port[i].magic = RISCOM8_MAGIC;
1564 static void rc_release_drivers(void)
1566 tty_unregister_driver(riscom_driver);
1567 put_tty_driver(riscom_driver);
1572 * Called at boot time.
1574 * You can specify IO base for up to RC_NBOARD cards,
1575 * using line "riscom8=0xiobase1,0xiobase2,.." at LILO prompt.
1576 * Note that there will be no probing at default
1577 * addresses in this case.
1580 static int __init riscom8_setup(char *str)
1582 int ints[RC_NBOARD];
1585 str = get_options(str, ARRAY_SIZE(ints), ints);
1587 for (i = 0; i < RC_NBOARD; i++) {
1589 rc_board[i].base = ints[i+1];
1591 rc_board[i].base = 0;
1596 __setup("riscom8=", riscom8_setup);
1599 static char banner[] __initdata =
1600 KERN_INFO "rc: SDL RISCom/8 card driver v1.1, (c) D.Gorodchanin "
1602 static char no_boards_msg[] __initdata =
1603 KERN_INFO "rc: No RISCom/8 boards detected.\n";
1606 * This routine must be called by kernel at boot time
1608 static int __init riscom8_init(void)
1615 if (rc_init_drivers())
1618 for (i = 0; i < RC_NBOARD; i++)
1619 if (rc_board[i].base && !rc_probe(&rc_board[i]))
1622 rc_release_drivers();
1623 printk(no_boards_msg);
1634 module_param(iobase, int, 0);
1635 module_param(iobase1, int, 0);
1636 module_param(iobase2, int, 0);
1637 module_param(iobase3, int, 0);
1639 MODULE_LICENSE("GPL");
1643 * You can setup up to 4 boards (current value of RC_NBOARD)
1644 * by specifying "iobase=0xXXX iobase1=0xXXX ..." as insmod parameter.
1647 static int __init riscom8_init_module(void)
1652 if (iobase || iobase1 || iobase2 || iobase3) {
1653 for (i = 0; i < RC_NBOARD; i++)
1654 rc_board[i].base = 0;
1658 rc_board[0].base = iobase;
1660 rc_board[1].base = iobase1;
1662 rc_board[2].base = iobase2;
1664 rc_board[3].base = iobase3;
1667 return riscom8_init();
1670 static void __exit riscom8_exit_module(void)
1674 rc_release_drivers();
1675 for (i = 0; i < RC_NBOARD; i++)
1676 if (rc_board[i].flags & RC_BOARD_PRESENT)
1677 rc_release_io_range(&rc_board[i]);
1681 module_init(riscom8_init_module);
1682 module_exit(riscom8_exit_module);