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/smp_lock.h>
51 #include <linux/spinlock.h>
52 #include <linux/device.h>
54 #include <linux/uaccess.h>
57 #include "riscom8_reg.h"
59 /* Am I paranoid or not ? ;-) */
60 #define RISCOM_PARANOIA_CHECK
63 * Crazy InteliCom/8 boards sometimes have swapped CTS & DSR signals.
64 * You can slightly speed up things by #undefing the following option,
65 * if you are REALLY sure that your board is correct one.
68 #define RISCOM_BRAIN_DAMAGED_CTS
71 * The following defines are mostly for testing purposes. But if you need
72 * some nice reporting in your syslog, you can define them also.
75 #undef RC_REPORT_OVERRUN
78 #define RISCOM_LEGAL_FLAGS \
79 (ASYNC_HUP_NOTIFY | ASYNC_SAK | ASYNC_SPLIT_TERMIOS | \
80 ASYNC_SPD_HI | ASYNC_SPEED_VHI | ASYNC_SESSION_LOCKOUT | \
81 ASYNC_PGRP_LOCKOUT | ASYNC_CALLOUT_NOHUP)
83 static struct tty_driver *riscom_driver;
85 static DEFINE_SPINLOCK(riscom_lock);
87 static struct riscom_board rc_board[RC_NBOARD] = {
102 static struct riscom_port rc_port[RC_NBOARD * RC_NPORT];
104 /* RISCom/8 I/O ports addresses (without address translation) */
105 static unsigned short rc_ioport[] = {
107 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x09, 0x0a, 0x0b, 0x0c,
109 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x09, 0x0a, 0x0b, 0x0c, 0x10,
110 0x11, 0x12, 0x18, 0x28, 0x31, 0x32, 0x39, 0x3a, 0x40, 0x41, 0x61, 0x62,
111 0x63, 0x64, 0x6b, 0x70, 0x71, 0x78, 0x7a, 0x7b, 0x7f, 0x100, 0x101
114 #define RC_NIOPORT ARRAY_SIZE(rc_ioport)
117 static int rc_paranoia_check(struct riscom_port const *port,
118 char *name, const char *routine)
120 #ifdef RISCOM_PARANOIA_CHECK
121 static const char badmagic[] = KERN_INFO
122 "rc: Warning: bad riscom port magic number for device %s in %s\n";
123 static const char badinfo[] = KERN_INFO
124 "rc: Warning: null riscom port for device %s in %s\n";
127 printk(badinfo, name, routine);
130 if (port->magic != RISCOM8_MAGIC) {
131 printk(badmagic, name, routine);
140 * Service functions for RISCom/8 driver.
144 /* Get board number from pointer */
145 static inline int board_No(struct riscom_board const *bp)
147 return bp - rc_board;
150 /* Get port number from pointer */
151 static inline int port_No(struct riscom_port const *port)
153 return RC_PORT(port - rc_port);
156 /* Get pointer to board from pointer to port */
157 static inline struct riscom_board *port_Board(struct riscom_port const *port)
159 return &rc_board[RC_BOARD(port - rc_port)];
162 /* Input Byte from CL CD180 register */
163 static inline unsigned char rc_in(struct riscom_board const *bp,
166 return inb(bp->base + RC_TO_ISA(reg));
169 /* Output Byte to CL CD180 register */
170 static inline void rc_out(struct riscom_board const *bp, unsigned short reg,
173 outb(val, bp->base + RC_TO_ISA(reg));
176 /* Wait for Channel Command Register ready */
177 static void rc_wait_CCR(struct riscom_board const *bp)
181 /* FIXME: need something more descriptive then 100000 :) */
182 for (delay = 100000; delay; delay--)
183 if (!rc_in(bp, CD180_CCR))
186 printk(KERN_INFO "rc%d: Timeout waiting for CCR.\n", board_No(bp));
190 * RISCom/8 probe functions.
193 static int rc_request_io_range(struct riscom_board * const bp)
197 for (i = 0; i < RC_NIOPORT; i++)
198 if (!request_region(RC_TO_ISA(rc_ioport[i]) + bp->base, 1,
204 printk(KERN_INFO "rc%d: Skipping probe at 0x%03x. IO address in use.\n",
205 board_No(bp), bp->base);
207 release_region(RC_TO_ISA(rc_ioport[i]) + bp->base, 1);
211 static void rc_release_io_range(struct riscom_board * const bp)
215 for (i = 0; i < RC_NIOPORT; i++)
216 release_region(RC_TO_ISA(rc_ioport[i]) + bp->base, 1);
219 /* Reset and setup CD180 chip */
220 static void __init rc_init_CD180(struct riscom_board const *bp)
224 spin_lock_irqsave(&riscom_lock, flags);
226 rc_out(bp, RC_CTOUT, 0); /* Clear timeout */
227 rc_wait_CCR(bp); /* Wait for CCR ready */
228 rc_out(bp, CD180_CCR, CCR_HARDRESET); /* Reset CD180 chip */
229 spin_unlock_irqrestore(&riscom_lock, flags);
230 msleep(50); /* Delay 0.05 sec */
231 spin_lock_irqsave(&riscom_lock, flags);
232 rc_out(bp, CD180_GIVR, RC_ID); /* Set ID for this chip */
233 rc_out(bp, CD180_GICR, 0); /* Clear all bits */
234 rc_out(bp, CD180_PILR1, RC_ACK_MINT); /* Prio for modem intr */
235 rc_out(bp, CD180_PILR2, RC_ACK_TINT); /* Prio for tx intr */
236 rc_out(bp, CD180_PILR3, RC_ACK_RINT); /* Prio for rx intr */
238 /* Setting up prescaler. We need 4 ticks per 1 ms */
239 rc_out(bp, CD180_PPRH, (RC_OSCFREQ/(1000000/RISCOM_TPS)) >> 8);
240 rc_out(bp, CD180_PPRL, (RC_OSCFREQ/(1000000/RISCOM_TPS)) & 0xff);
242 spin_unlock_irqrestore(&riscom_lock, flags);
245 /* Main probing routine, also sets irq. */
246 static int __init rc_probe(struct riscom_board *bp)
248 unsigned char val1, val2;
254 if (rc_request_io_range(bp))
257 /* Are the I/O ports here ? */
258 rc_out(bp, CD180_PPRL, 0x5a);
260 val1 = rc_in(bp, CD180_PPRL);
261 rc_out(bp, CD180_PPRL, 0xa5);
263 val2 = rc_in(bp, CD180_PPRL);
265 if ((val1 != 0x5a) || (val2 != 0xa5)) {
266 printk(KERN_ERR "rc%d: RISCom/8 Board at 0x%03x not found.\n",
267 board_No(bp), bp->base);
271 /* It's time to find IRQ for this board */
272 for (retries = 0; retries < 5 && irqs <= 0; retries++) {
273 irqs = probe_irq_on();
274 rc_init_CD180(bp); /* Reset CD180 chip */
275 rc_out(bp, CD180_CAR, 2); /* Select port 2 */
277 rc_out(bp, CD180_CCR, CCR_TXEN); /* Enable transmitter */
278 rc_out(bp, CD180_IER, IER_TXRDY);/* Enable tx empty intr */
280 irqs = probe_irq_off(irqs);
281 val1 = rc_in(bp, RC_BSR); /* Get Board Status reg */
282 val2 = rc_in(bp, RC_ACK_TINT); /* ACK interrupt */
283 rc_init_CD180(bp); /* Reset CD180 again */
285 if ((val1 & RC_BSR_TINT) || (val2 != (RC_ID | GIVR_IT_TX))) {
286 printk(KERN_ERR "rc%d: RISCom/8 Board at 0x%03x not "
287 "found.\n", board_No(bp), bp->base);
293 printk(KERN_ERR "rc%d: Can't find IRQ for RISCom/8 board "
294 "at 0x%03x.\n", board_No(bp), bp->base);
298 bp->flags |= RC_BOARD_PRESENT;
300 printk(KERN_INFO "rc%d: RISCom/8 Rev. %c board detected at "
303 (rc_in(bp, CD180_GFRCR) & 0x0f) + 'A', /* Board revision */
308 rc_release_io_range(bp);
314 * Interrupt processing routines.
318 static struct riscom_port *rc_get_port(struct riscom_board const *bp,
319 unsigned char const *what)
321 unsigned char channel;
322 struct riscom_port *port;
324 channel = rc_in(bp, CD180_GICR) >> GICR_CHAN_OFF;
325 if (channel < CD180_NCH) {
326 port = &rc_port[board_No(bp) * RC_NPORT + channel];
327 if (port->port.flags & ASYNC_INITIALIZED)
330 printk(KERN_ERR "rc%d: %s interrupt from invalid port %d\n",
331 board_No(bp), what, channel);
335 static void rc_receive_exc(struct riscom_board const *bp)
337 struct riscom_port *port;
338 struct tty_struct *tty;
339 unsigned char status;
340 unsigned char ch, flag;
342 port = rc_get_port(bp, "Receive");
346 tty = port->port.tty;
348 #ifdef RC_REPORT_OVERRUN
349 status = rc_in(bp, CD180_RCSR);
350 if (status & RCSR_OE)
352 status &= port->mark_mask;
354 status = rc_in(bp, CD180_RCSR) & port->mark_mask;
356 ch = rc_in(bp, CD180_RDR);
359 if (status & RCSR_TOUT) {
360 printk(KERN_WARNING "rc%d: port %d: Receiver timeout. "
361 "Hardware problems ?\n",
362 board_No(bp), port_No(port));
365 } else if (status & RCSR_BREAK) {
366 printk(KERN_INFO "rc%d: port %d: Handling break...\n",
367 board_No(bp), port_No(port));
369 if (port->port.flags & ASYNC_SAK)
372 } else if (status & RCSR_PE)
375 else if (status & RCSR_FE)
378 else if (status & RCSR_OE)
383 tty_insert_flip_char(tty, ch, flag);
384 tty_flip_buffer_push(tty);
387 static void rc_receive(struct riscom_board const *bp)
389 struct riscom_port *port;
390 struct tty_struct *tty;
393 port = rc_get_port(bp, "Receive");
397 tty = port->port.tty;
399 count = rc_in(bp, CD180_RDCR);
401 #ifdef RC_REPORT_FIFO
402 port->hits[count > 8 ? 9 : count]++;
406 if (tty_buffer_request_room(tty, 1) == 0) {
407 printk(KERN_WARNING "rc%d: port %d: Working around "
408 "flip buffer overflow.\n",
409 board_No(bp), port_No(port));
412 tty_insert_flip_char(tty, rc_in(bp, CD180_RDR), TTY_NORMAL);
414 tty_flip_buffer_push(tty);
417 static void rc_transmit(struct riscom_board const *bp)
419 struct riscom_port *port;
420 struct tty_struct *tty;
423 port = rc_get_port(bp, "Transmit");
427 tty = port->port.tty;
429 if (port->IER & IER_TXEMPTY) {
431 rc_out(bp, CD180_CAR, port_No(port));
432 port->IER &= ~IER_TXEMPTY;
433 rc_out(bp, CD180_IER, port->IER);
437 if ((port->xmit_cnt <= 0 && !port->break_length)
438 || tty->stopped || tty->hw_stopped) {
439 rc_out(bp, CD180_CAR, port_No(port));
440 port->IER &= ~IER_TXRDY;
441 rc_out(bp, CD180_IER, port->IER);
445 if (port->break_length) {
446 if (port->break_length > 0) {
447 if (port->COR2 & COR2_ETC) {
448 rc_out(bp, CD180_TDR, CD180_C_ESC);
449 rc_out(bp, CD180_TDR, CD180_C_SBRK);
450 port->COR2 &= ~COR2_ETC;
452 count = min_t(int, port->break_length, 0xff);
453 rc_out(bp, CD180_TDR, CD180_C_ESC);
454 rc_out(bp, CD180_TDR, CD180_C_DELAY);
455 rc_out(bp, CD180_TDR, count);
456 port->break_length -= count;
457 if (port->break_length == 0)
458 port->break_length--;
460 rc_out(bp, CD180_TDR, CD180_C_ESC);
461 rc_out(bp, CD180_TDR, CD180_C_EBRK);
462 rc_out(bp, CD180_COR2, port->COR2);
464 rc_out(bp, CD180_CCR, CCR_CORCHG2);
465 port->break_length = 0;
472 rc_out(bp, CD180_TDR, port->port.xmit_buf[port->xmit_tail++]);
473 port->xmit_tail = port->xmit_tail & (SERIAL_XMIT_SIZE-1);
474 if (--port->xmit_cnt <= 0)
476 } while (--count > 0);
478 if (port->xmit_cnt <= 0) {
479 rc_out(bp, CD180_CAR, port_No(port));
480 port->IER &= ~IER_TXRDY;
481 rc_out(bp, CD180_IER, port->IER);
483 if (port->xmit_cnt <= port->wakeup_chars)
487 static void rc_check_modem(struct riscom_board const *bp)
489 struct riscom_port *port;
490 struct tty_struct *tty;
493 port = rc_get_port(bp, "Modem");
497 tty = port->port.tty;
499 mcr = rc_in(bp, CD180_MCR);
500 if (mcr & MCR_CDCHG) {
501 if (rc_in(bp, CD180_MSVR) & MSVR_CD)
502 wake_up_interruptible(&port->port.open_wait);
507 #ifdef RISCOM_BRAIN_DAMAGED_CTS
508 if (mcr & MCR_CTSCHG) {
509 if (rc_in(bp, CD180_MSVR) & MSVR_CTS) {
511 port->IER |= IER_TXRDY;
512 if (port->xmit_cnt <= port->wakeup_chars)
516 port->IER &= ~IER_TXRDY;
518 rc_out(bp, CD180_IER, port->IER);
520 if (mcr & MCR_DSRCHG) {
521 if (rc_in(bp, CD180_MSVR) & MSVR_DSR) {
523 port->IER |= IER_TXRDY;
524 if (port->xmit_cnt <= port->wakeup_chars)
528 port->IER &= ~IER_TXRDY;
530 rc_out(bp, CD180_IER, port->IER);
532 #endif /* RISCOM_BRAIN_DAMAGED_CTS */
534 /* Clear change bits */
535 rc_out(bp, CD180_MCR, 0);
538 /* The main interrupt processing routine */
539 static irqreturn_t rc_interrupt(int dummy, void *dev_id)
541 unsigned char status;
543 struct riscom_board *bp = dev_id;
544 unsigned long loop = 0;
547 if (!(bp->flags & RC_BOARD_ACTIVE))
550 while ((++loop < 16) && ((status = ~(rc_in(bp, RC_BSR))) &
551 (RC_BSR_TOUT | RC_BSR_TINT |
552 RC_BSR_MINT | RC_BSR_RINT))) {
554 if (status & RC_BSR_TOUT)
555 printk(KERN_WARNING "rc%d: Got timeout. Hardware "
556 "error?\n", board_No(bp));
557 else if (status & RC_BSR_RINT) {
558 ack = rc_in(bp, RC_ACK_RINT);
559 if (ack == (RC_ID | GIVR_IT_RCV))
561 else if (ack == (RC_ID | GIVR_IT_REXC))
564 printk(KERN_WARNING "rc%d: Bad receive ack "
567 } else if (status & RC_BSR_TINT) {
568 ack = rc_in(bp, RC_ACK_TINT);
569 if (ack == (RC_ID | GIVR_IT_TX))
572 printk(KERN_WARNING "rc%d: Bad transmit ack "
575 } else /* if (status & RC_BSR_MINT) */ {
576 ack = rc_in(bp, RC_ACK_MINT);
577 if (ack == (RC_ID | GIVR_IT_MODEM))
580 printk(KERN_WARNING "rc%d: Bad modem ack "
584 rc_out(bp, CD180_EOIR, 0); /* Mark end of interrupt */
585 rc_out(bp, RC_CTOUT, 0); /* Clear timeout flag */
587 return IRQ_RETVAL(handled);
591 * Routines for open & close processing.
594 /* Called with disabled interrupts */
595 static int rc_setup_board(struct riscom_board *bp)
599 if (bp->flags & RC_BOARD_ACTIVE)
602 error = request_irq(bp->irq, rc_interrupt, IRQF_DISABLED,
607 rc_out(bp, RC_CTOUT, 0); /* Just in case */
609 rc_out(bp, RC_DTR, bp->DTR); /* Drop DTR on all ports */
611 bp->flags |= RC_BOARD_ACTIVE;
616 /* Called with disabled interrupts */
617 static void rc_shutdown_board(struct riscom_board *bp)
619 if (!(bp->flags & RC_BOARD_ACTIVE))
622 bp->flags &= ~RC_BOARD_ACTIVE;
624 free_irq(bp->irq, NULL);
627 rc_out(bp, RC_DTR, bp->DTR); /* Drop DTR on all ports */
632 * Setting up port characteristics.
633 * Must be called with disabled interrupts
635 static void rc_change_speed(struct riscom_board *bp, struct riscom_port *port)
637 struct tty_struct *tty = port->port.tty;
640 unsigned char cor1 = 0, cor3 = 0;
641 unsigned char mcor1 = 0, mcor2 = 0;
645 port->MSVR = MSVR_RTS;
647 baud = tty_get_baud_rate(tty);
649 /* Select port on the board */
650 rc_out(bp, CD180_CAR, port_No(port));
653 /* Drop DTR & exit */
654 bp->DTR |= (1u << port_No(port));
655 rc_out(bp, RC_DTR, bp->DTR);
659 bp->DTR &= ~(1u << port_No(port));
660 rc_out(bp, RC_DTR, bp->DTR);
664 * Now we must calculate some speed depended things
667 /* Set baud rate for port */
668 tmp = (((RC_OSCFREQ + baud/2) / baud +
669 CD180_TPC/2) / CD180_TPC);
671 rc_out(bp, CD180_RBPRH, (tmp >> 8) & 0xff);
672 rc_out(bp, CD180_TBPRH, (tmp >> 8) & 0xff);
673 rc_out(bp, CD180_RBPRL, tmp & 0xff);
674 rc_out(bp, CD180_TBPRL, tmp & 0xff);
676 baud = (baud + 5) / 10; /* Estimated CPS */
678 /* Two timer ticks seems enough to wakeup something like SLIP driver */
679 tmp = ((baud + HZ/2) / HZ) * 2 - CD180_NFIFO;
680 port->wakeup_chars = (tmp < 0) ? 0 : ((tmp >= SERIAL_XMIT_SIZE) ?
681 SERIAL_XMIT_SIZE - 1 : tmp);
683 /* Receiver timeout will be transmission time for 1.5 chars */
684 tmp = (RISCOM_TPS + RISCOM_TPS/2 + baud/2) / baud;
685 tmp = (tmp > 0xff) ? 0xff : tmp;
686 rc_out(bp, CD180_RTPR, tmp);
688 switch (C_CSIZE(tty)) {
707 cor1 |= COR1_NORMPAR;
711 cor1 &= ~COR1_IGNORE;
713 /* Set marking of some errors */
714 port->mark_mask = RCSR_OE | RCSR_TOUT;
716 port->mark_mask |= RCSR_FE | RCSR_PE;
717 if (I_BRKINT(tty) || I_PARMRK(tty))
718 port->mark_mask |= RCSR_BREAK;
720 port->mark_mask &= ~(RCSR_FE | RCSR_PE);
722 port->mark_mask &= ~RCSR_BREAK;
724 /* Real raw mode. Ignore all */
725 port->mark_mask &= ~RCSR_OE;
727 /* Enable Hardware Flow Control */
728 if (C_CRTSCTS(tty)) {
729 #ifdef RISCOM_BRAIN_DAMAGED_CTS
730 port->IER |= IER_DSR | IER_CTS;
731 mcor1 |= MCOR1_DSRZD | MCOR1_CTSZD;
732 mcor2 |= MCOR2_DSROD | MCOR2_CTSOD;
733 tty->hw_stopped = !(rc_in(bp, CD180_MSVR) &
734 (MSVR_CTS|MSVR_DSR));
736 port->COR2 |= COR2_CTSAE;
739 /* Enable Software Flow Control. FIXME: I'm not sure about this */
740 /* Some people reported that it works, but I still doubt */
742 port->COR2 |= COR2_TXIBE;
743 cor3 |= (COR3_FCT | COR3_SCDE);
745 port->COR2 |= COR2_IXM;
746 rc_out(bp, CD180_SCHR1, START_CHAR(tty));
747 rc_out(bp, CD180_SCHR2, STOP_CHAR(tty));
748 rc_out(bp, CD180_SCHR3, START_CHAR(tty));
749 rc_out(bp, CD180_SCHR4, STOP_CHAR(tty));
751 if (!C_CLOCAL(tty)) {
752 /* Enable CD check */
759 /* Enable receiver */
760 port->IER |= IER_RXD;
762 /* Set input FIFO size (1-8 bytes) */
763 cor3 |= RISCOM_RXFIFO;
764 /* Setting up CD180 channel registers */
765 rc_out(bp, CD180_COR1, cor1);
766 rc_out(bp, CD180_COR2, port->COR2);
767 rc_out(bp, CD180_COR3, cor3);
768 /* Make CD180 know about registers change */
770 rc_out(bp, CD180_CCR, CCR_CORCHG1 | CCR_CORCHG2 | CCR_CORCHG3);
771 /* Setting up modem option registers */
772 rc_out(bp, CD180_MCOR1, mcor1);
773 rc_out(bp, CD180_MCOR2, mcor2);
774 /* Enable CD180 transmitter & receiver */
776 rc_out(bp, CD180_CCR, CCR_TXEN | CCR_RXEN);
777 /* Enable interrupts */
778 rc_out(bp, CD180_IER, port->IER);
779 /* And finally set RTS on */
780 rc_out(bp, CD180_MSVR, port->MSVR);
783 /* Must be called with interrupts enabled */
784 static int rc_setup_port(struct riscom_board *bp, struct riscom_port *port)
788 if (port->port.flags & ASYNC_INITIALIZED)
791 if (tty_port_alloc_xmit_buf(&port->port) < 0)
794 spin_lock_irqsave(&riscom_lock, flags);
796 clear_bit(TTY_IO_ERROR, &port->port.tty->flags);
797 if (port->port.count == 1)
799 port->xmit_cnt = port->xmit_head = port->xmit_tail = 0;
800 rc_change_speed(bp, port);
801 port->port.flags |= ASYNC_INITIALIZED;
803 spin_unlock_irqrestore(&riscom_lock, flags);
807 /* Must be called with interrupts disabled */
808 static void rc_shutdown_port(struct tty_struct *tty,
809 struct riscom_board *bp, struct riscom_port *port)
811 if (!(port->port.flags & ASYNC_INITIALIZED))
814 #ifdef RC_REPORT_OVERRUN
815 printk(KERN_INFO "rc%d: port %d: Total %ld overruns were detected.\n",
816 board_No(bp), port_No(port), port->overrun);
818 #ifdef RC_REPORT_FIFO
822 printk(KERN_INFO "rc%d: port %d: FIFO hits [ ",
823 board_No(bp), port_No(port));
824 for (i = 0; i < 10; i++)
825 printk("%ld ", port->hits[i]);
829 tty_port_free_xmit_buf(&port->port);
832 bp->DTR |= (1u << port_No(port));
833 rc_out(bp, RC_DTR, bp->DTR);
837 rc_out(bp, CD180_CAR, port_No(port));
840 rc_out(bp, CD180_CCR, CCR_SOFTRESET);
841 /* Disable all interrupts from this port */
843 rc_out(bp, CD180_IER, port->IER);
845 set_bit(TTY_IO_ERROR, &tty->flags);
846 port->port.flags &= ~ASYNC_INITIALIZED;
848 if (--bp->count < 0) {
849 printk(KERN_INFO "rc%d: rc_shutdown_port: "
850 "bad board count: %d\n",
851 board_No(bp), bp->count);
855 * If this is the last opened port on the board
856 * shutdown whole board
859 rc_shutdown_board(bp);
862 static int carrier_raised(struct tty_port *port)
864 struct riscom_port *p = container_of(port, struct riscom_port, port);
865 struct riscom_board *bp = port_Board(p);
869 spin_lock_irqsave(&riscom_lock, flags);
870 rc_out(bp, CD180_CAR, port_No(p));
871 CD = rc_in(bp, CD180_MSVR) & MSVR_CD;
872 rc_out(bp, CD180_MSVR, MSVR_RTS);
873 bp->DTR &= ~(1u << port_No(p));
874 rc_out(bp, RC_DTR, bp->DTR);
875 spin_unlock_irqrestore(&riscom_lock, flags);
879 static int rc_open(struct tty_struct *tty, struct file *filp)
883 struct riscom_port *port;
884 struct riscom_board *bp;
886 board = RC_BOARD(tty->index);
887 if (board >= RC_NBOARD || !(rc_board[board].flags & RC_BOARD_PRESENT))
890 bp = &rc_board[board];
891 port = rc_port + board * RC_NPORT + RC_PORT(tty->index);
892 if (rc_paranoia_check(port, tty->name, "rc_open"))
895 error = rc_setup_board(bp);
900 tty->driver_data = port;
901 port->port.tty = tty;
903 error = rc_setup_port(bp, port);
905 error = tty_port_block_til_ready(&port->port, tty, filp);
909 static void rc_flush_buffer(struct tty_struct *tty)
911 struct riscom_port *port = tty->driver_data;
914 if (rc_paranoia_check(port, tty->name, "rc_flush_buffer"))
917 spin_lock_irqsave(&riscom_lock, flags);
918 port->xmit_cnt = port->xmit_head = port->xmit_tail = 0;
919 spin_unlock_irqrestore(&riscom_lock, flags);
924 static void rc_close_port(struct tty_struct *tty, struct tty_port *port)
927 struct riscom_port *rp = container_of(port, struct riscom_port, port);
928 struct riscom_board *bp = port_Board(rp);
929 unsigned long timeout;
932 * At this point we stop accepting input. To do this, we
933 * disable the receive line status interrupts, and tell the
934 * interrupt driver to stop checking the data ready bit in the
935 * line status register.
938 spin_lock_irqsave(&riscom_lock, flags);
940 if (port->flags & ASYNC_INITIALIZED) {
941 rp->IER &= ~IER_TXRDY;
942 rp->IER |= IER_TXEMPTY;
943 rc_out(bp, CD180_CAR, port_No(rp));
944 rc_out(bp, CD180_IER, rp->IER);
946 * Before we drop DTR, make sure the UART transmitter
947 * has completely drained; this is especially
948 * important if there is a transmit FIFO!
950 timeout = jiffies + HZ;
951 while (rp->IER & IER_TXEMPTY) {
952 spin_unlock_irqrestore(&riscom_lock, flags);
953 msleep_interruptible(jiffies_to_msecs(rp->timeout));
954 spin_lock_irqsave(&riscom_lock, flags);
955 if (time_after(jiffies, timeout))
959 rc_shutdown_port(tty, bp, rp);
960 spin_unlock_irqrestore(&riscom_lock, flags);
963 static void rc_close(struct tty_struct *tty, struct file *filp)
965 struct riscom_port *port = tty->driver_data;
967 if (!port || rc_paranoia_check(port, tty->name, "close"))
970 if (tty_port_close_start(&port->port, tty, filp) == 0)
973 rc_close_port(tty, &port->port);
974 rc_flush_buffer(tty);
976 tty_port_close_end(&port->port, tty);
979 static int rc_write(struct tty_struct *tty,
980 const unsigned char *buf, int count)
982 struct riscom_port *port = tty->driver_data;
983 struct riscom_board *bp;
987 if (rc_paranoia_check(port, tty->name, "rc_write"))
990 bp = port_Board(port);
993 spin_lock_irqsave(&riscom_lock, flags);
995 c = min_t(int, count, min(SERIAL_XMIT_SIZE - port->xmit_cnt - 1,
996 SERIAL_XMIT_SIZE - port->xmit_head));
998 break; /* lock continues to be held */
1000 memcpy(port->port.xmit_buf + port->xmit_head, buf, c);
1001 port->xmit_head = (port->xmit_head + c) & (SERIAL_XMIT_SIZE-1);
1002 port->xmit_cnt += c;
1004 spin_unlock_irqrestore(&riscom_lock, flags);
1011 if (port->xmit_cnt && !tty->stopped && !tty->hw_stopped &&
1012 !(port->IER & IER_TXRDY)) {
1013 port->IER |= IER_TXRDY;
1014 rc_out(bp, CD180_CAR, port_No(port));
1015 rc_out(bp, CD180_IER, port->IER);
1018 spin_unlock_irqrestore(&riscom_lock, flags);
1023 static int rc_put_char(struct tty_struct *tty, unsigned char ch)
1025 struct riscom_port *port = tty->driver_data;
1026 unsigned long flags;
1029 if (rc_paranoia_check(port, tty->name, "rc_put_char"))
1032 spin_lock_irqsave(&riscom_lock, flags);
1034 if (port->xmit_cnt >= SERIAL_XMIT_SIZE - 1)
1037 port->port.xmit_buf[port->xmit_head++] = ch;
1038 port->xmit_head &= SERIAL_XMIT_SIZE - 1;
1043 spin_unlock_irqrestore(&riscom_lock, flags);
1047 static void rc_flush_chars(struct tty_struct *tty)
1049 struct riscom_port *port = tty->driver_data;
1050 unsigned long flags;
1052 if (rc_paranoia_check(port, tty->name, "rc_flush_chars"))
1055 if (port->xmit_cnt <= 0 || tty->stopped || tty->hw_stopped)
1058 spin_lock_irqsave(&riscom_lock, flags);
1060 port->IER |= IER_TXRDY;
1061 rc_out(port_Board(port), CD180_CAR, port_No(port));
1062 rc_out(port_Board(port), CD180_IER, port->IER);
1064 spin_unlock_irqrestore(&riscom_lock, flags);
1067 static int rc_write_room(struct tty_struct *tty)
1069 struct riscom_port *port = tty->driver_data;
1072 if (rc_paranoia_check(port, tty->name, "rc_write_room"))
1075 ret = SERIAL_XMIT_SIZE - port->xmit_cnt - 1;
1081 static int rc_chars_in_buffer(struct tty_struct *tty)
1083 struct riscom_port *port = tty->driver_data;
1085 if (rc_paranoia_check(port, tty->name, "rc_chars_in_buffer"))
1088 return port->xmit_cnt;
1091 static int rc_tiocmget(struct tty_struct *tty, struct file *file)
1093 struct riscom_port *port = tty->driver_data;
1094 struct riscom_board *bp;
1095 unsigned char status;
1096 unsigned int result;
1097 unsigned long flags;
1099 if (rc_paranoia_check(port, tty->name, __func__))
1102 bp = port_Board(port);
1104 spin_lock_irqsave(&riscom_lock, flags);
1106 rc_out(bp, CD180_CAR, port_No(port));
1107 status = rc_in(bp, CD180_MSVR);
1108 result = rc_in(bp, RC_RI) & (1u << port_No(port)) ? 0 : TIOCM_RNG;
1110 spin_unlock_irqrestore(&riscom_lock, flags);
1112 result |= ((status & MSVR_RTS) ? TIOCM_RTS : 0)
1113 | ((status & MSVR_DTR) ? TIOCM_DTR : 0)
1114 | ((status & MSVR_CD) ? TIOCM_CAR : 0)
1115 | ((status & MSVR_DSR) ? TIOCM_DSR : 0)
1116 | ((status & MSVR_CTS) ? TIOCM_CTS : 0);
1120 static int rc_tiocmset(struct tty_struct *tty, struct file *file,
1121 unsigned int set, unsigned int clear)
1123 struct riscom_port *port = tty->driver_data;
1124 unsigned long flags;
1125 struct riscom_board *bp;
1127 if (rc_paranoia_check(port, tty->name, __func__))
1130 bp = port_Board(port);
1132 spin_lock_irqsave(&riscom_lock, flags);
1134 if (set & TIOCM_RTS)
1135 port->MSVR |= MSVR_RTS;
1136 if (set & TIOCM_DTR)
1137 bp->DTR &= ~(1u << port_No(port));
1139 if (clear & TIOCM_RTS)
1140 port->MSVR &= ~MSVR_RTS;
1141 if (clear & TIOCM_DTR)
1142 bp->DTR |= (1u << port_No(port));
1144 rc_out(bp, CD180_CAR, port_No(port));
1145 rc_out(bp, CD180_MSVR, port->MSVR);
1146 rc_out(bp, RC_DTR, bp->DTR);
1148 spin_unlock_irqrestore(&riscom_lock, flags);
1153 static int rc_send_break(struct tty_struct *tty, int length)
1155 struct riscom_port *port = tty->driver_data;
1156 struct riscom_board *bp = port_Board(port);
1157 unsigned long flags;
1159 if (length == 0 || length == -1)
1162 spin_lock_irqsave(&riscom_lock, flags);
1164 port->break_length = RISCOM_TPS / HZ * length;
1165 port->COR2 |= COR2_ETC;
1166 port->IER |= IER_TXRDY;
1167 rc_out(bp, CD180_CAR, port_No(port));
1168 rc_out(bp, CD180_COR2, port->COR2);
1169 rc_out(bp, CD180_IER, port->IER);
1171 rc_out(bp, CD180_CCR, CCR_CORCHG2);
1174 spin_unlock_irqrestore(&riscom_lock, flags);
1178 static int rc_set_serial_info(struct riscom_port *port,
1179 struct serial_struct __user *newinfo)
1181 struct serial_struct tmp;
1182 struct riscom_board *bp = port_Board(port);
1185 if (copy_from_user(&tmp, newinfo, sizeof(tmp)))
1189 if ((tmp.irq != bp->irq) ||
1190 (tmp.port != bp->base) ||
1191 (tmp.type != PORT_CIRRUS) ||
1192 (tmp.baud_base != (RC_OSCFREQ + CD180_TPC/2) / CD180_TPC) ||
1193 (tmp.custom_divisor != 0) ||
1194 (tmp.xmit_fifo_size != CD180_NFIFO) ||
1195 (tmp.flags & ~RISCOM_LEGAL_FLAGS))
1199 change_speed = ((port->port.flags & ASYNC_SPD_MASK) !=
1200 (tmp.flags & ASYNC_SPD_MASK));
1202 if (!capable(CAP_SYS_ADMIN)) {
1203 if ((tmp.close_delay != port->port.close_delay) ||
1204 (tmp.closing_wait != port->port.closing_wait) ||
1205 ((tmp.flags & ~ASYNC_USR_MASK) !=
1206 (port->port.flags & ~ASYNC_USR_MASK)))
1208 port->port.flags = ((port->port.flags & ~ASYNC_USR_MASK) |
1209 (tmp.flags & ASYNC_USR_MASK));
1211 port->port.flags = ((port->port.flags & ~ASYNC_FLAGS) |
1212 (tmp.flags & ASYNC_FLAGS));
1213 port->port.close_delay = tmp.close_delay;
1214 port->port.closing_wait = tmp.closing_wait;
1217 unsigned long flags;
1219 spin_lock_irqsave(&riscom_lock, flags);
1220 rc_change_speed(bp, port);
1221 spin_unlock_irqrestore(&riscom_lock, flags);
1226 static int rc_get_serial_info(struct riscom_port *port,
1227 struct serial_struct __user *retinfo)
1229 struct serial_struct tmp;
1230 struct riscom_board *bp = port_Board(port);
1232 memset(&tmp, 0, sizeof(tmp));
1233 tmp.type = PORT_CIRRUS;
1234 tmp.line = port - rc_port;
1235 tmp.port = bp->base;
1237 tmp.flags = port->port.flags;
1238 tmp.baud_base = (RC_OSCFREQ + CD180_TPC/2) / CD180_TPC;
1239 tmp.close_delay = port->port.close_delay * HZ/100;
1240 tmp.closing_wait = port->port.closing_wait * HZ/100;
1241 tmp.xmit_fifo_size = CD180_NFIFO;
1242 return copy_to_user(retinfo, &tmp, sizeof(tmp)) ? -EFAULT : 0;
1245 static int rc_ioctl(struct tty_struct *tty, struct file *filp,
1246 unsigned int cmd, unsigned long arg)
1248 struct riscom_port *port = tty->driver_data;
1249 void __user *argp = (void __user *)arg;
1252 if (rc_paranoia_check(port, tty->name, "rc_ioctl"))
1258 retval = rc_get_serial_info(port, argp);
1263 retval = rc_set_serial_info(port, argp);
1267 retval = -ENOIOCTLCMD;
1272 static void rc_throttle(struct tty_struct *tty)
1274 struct riscom_port *port = tty->driver_data;
1275 struct riscom_board *bp;
1276 unsigned long flags;
1278 if (rc_paranoia_check(port, tty->name, "rc_throttle"))
1280 bp = port_Board(port);
1282 spin_lock_irqsave(&riscom_lock, flags);
1283 port->MSVR &= ~MSVR_RTS;
1284 rc_out(bp, CD180_CAR, port_No(port));
1287 rc_out(bp, CD180_CCR, CCR_SSCH2);
1290 rc_out(bp, CD180_MSVR, port->MSVR);
1291 spin_unlock_irqrestore(&riscom_lock, flags);
1294 static void rc_unthrottle(struct tty_struct *tty)
1296 struct riscom_port *port = tty->driver_data;
1297 struct riscom_board *bp;
1298 unsigned long flags;
1300 if (rc_paranoia_check(port, tty->name, "rc_unthrottle"))
1302 bp = port_Board(port);
1304 spin_lock_irqsave(&riscom_lock, flags);
1305 port->MSVR |= MSVR_RTS;
1306 rc_out(bp, CD180_CAR, port_No(port));
1309 rc_out(bp, CD180_CCR, CCR_SSCH1);
1312 rc_out(bp, CD180_MSVR, port->MSVR);
1313 spin_unlock_irqrestore(&riscom_lock, flags);
1316 static void rc_stop(struct tty_struct *tty)
1318 struct riscom_port *port = tty->driver_data;
1319 struct riscom_board *bp;
1320 unsigned long flags;
1322 if (rc_paranoia_check(port, tty->name, "rc_stop"))
1325 bp = port_Board(port);
1327 spin_lock_irqsave(&riscom_lock, flags);
1328 port->IER &= ~IER_TXRDY;
1329 rc_out(bp, CD180_CAR, port_No(port));
1330 rc_out(bp, CD180_IER, port->IER);
1331 spin_unlock_irqrestore(&riscom_lock, flags);
1334 static void rc_start(struct tty_struct *tty)
1336 struct riscom_port *port = tty->driver_data;
1337 struct riscom_board *bp;
1338 unsigned long flags;
1340 if (rc_paranoia_check(port, tty->name, "rc_start"))
1343 bp = port_Board(port);
1345 spin_lock_irqsave(&riscom_lock, flags);
1347 if (port->xmit_cnt && port->port.xmit_buf && !(port->IER & IER_TXRDY)) {
1348 port->IER |= IER_TXRDY;
1349 rc_out(bp, CD180_CAR, port_No(port));
1350 rc_out(bp, CD180_IER, port->IER);
1352 spin_unlock_irqrestore(&riscom_lock, flags);
1355 static void rc_hangup(struct tty_struct *tty)
1357 struct riscom_port *port = tty->driver_data;
1358 struct riscom_board *bp;
1359 unsigned long flags;
1361 if (rc_paranoia_check(port, tty->name, "rc_hangup"))
1364 bp = port_Board(port);
1366 rc_shutdown_port(tty, bp, port);
1367 spin_lock_irqsave(&port->port.lock, flags);
1368 port->port.count = 0;
1369 port->port.flags &= ~ASYNC_NORMAL_ACTIVE;
1370 port->port.tty = NULL;
1371 wake_up_interruptible(&port->port.open_wait);
1372 spin_unlock_irqrestore(&port->port.lock, flags);
1375 static void rc_set_termios(struct tty_struct *tty,
1376 struct ktermios *old_termios)
1378 struct riscom_port *port = tty->driver_data;
1379 unsigned long flags;
1381 if (rc_paranoia_check(port, tty->name, "rc_set_termios"))
1384 spin_lock_irqsave(&riscom_lock, flags);
1385 rc_change_speed(port_Board(port), port);
1386 spin_unlock_irqrestore(&riscom_lock, flags);
1388 if ((old_termios->c_cflag & CRTSCTS) &&
1389 !(tty->termios->c_cflag & CRTSCTS)) {
1390 tty->hw_stopped = 0;
1395 static const struct tty_operations riscom_ops = {
1399 .put_char = rc_put_char,
1400 .flush_chars = rc_flush_chars,
1401 .write_room = rc_write_room,
1402 .chars_in_buffer = rc_chars_in_buffer,
1403 .flush_buffer = rc_flush_buffer,
1405 .throttle = rc_throttle,
1406 .unthrottle = rc_unthrottle,
1407 .set_termios = rc_set_termios,
1410 .hangup = rc_hangup,
1411 .tiocmget = rc_tiocmget,
1412 .tiocmset = rc_tiocmset,
1413 .break_ctl = rc_send_break,
1416 static const struct tty_port_operations riscom_port_ops = {
1417 .carrier_raised = carrier_raised,
1421 static int __init rc_init_drivers(void)
1426 riscom_driver = alloc_tty_driver(RC_NBOARD * RC_NPORT);
1430 riscom_driver->owner = THIS_MODULE;
1431 riscom_driver->name = "ttyL";
1432 riscom_driver->major = RISCOM8_NORMAL_MAJOR;
1433 riscom_driver->type = TTY_DRIVER_TYPE_SERIAL;
1434 riscom_driver->subtype = SERIAL_TYPE_NORMAL;
1435 riscom_driver->init_termios = tty_std_termios;
1436 riscom_driver->init_termios.c_cflag =
1437 B9600 | CS8 | CREAD | HUPCL | CLOCAL;
1438 riscom_driver->init_termios.c_ispeed = 9600;
1439 riscom_driver->init_termios.c_ospeed = 9600;
1440 riscom_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_HARDWARE_BREAK;
1441 tty_set_operations(riscom_driver, &riscom_ops);
1442 error = tty_register_driver(riscom_driver);
1444 put_tty_driver(riscom_driver);
1445 printk(KERN_ERR "rc: Couldn't register RISCom/8 driver, "
1446 "error = %d\n", error);
1449 memset(rc_port, 0, sizeof(rc_port));
1450 for (i = 0; i < RC_NPORT * RC_NBOARD; i++) {
1451 tty_port_init(&rc_port[i].port);
1452 rc_port[i].port.ops = &riscom_port_ops;
1453 rc_port[i].magic = RISCOM8_MAGIC;
1458 static void rc_release_drivers(void)
1460 tty_unregister_driver(riscom_driver);
1461 put_tty_driver(riscom_driver);
1466 * Called at boot time.
1468 * You can specify IO base for up to RC_NBOARD cards,
1469 * using line "riscom8=0xiobase1,0xiobase2,.." at LILO prompt.
1470 * Note that there will be no probing at default
1471 * addresses in this case.
1474 static int __init riscom8_setup(char *str)
1476 int ints[RC_NBOARD];
1479 str = get_options(str, ARRAY_SIZE(ints), ints);
1481 for (i = 0; i < RC_NBOARD; i++) {
1483 rc_board[i].base = ints[i+1];
1485 rc_board[i].base = 0;
1490 __setup("riscom8=", riscom8_setup);
1493 static char banner[] __initdata =
1494 KERN_INFO "rc: SDL RISCom/8 card driver v1.1, (c) D.Gorodchanin "
1496 static char no_boards_msg[] __initdata =
1497 KERN_INFO "rc: No RISCom/8 boards detected.\n";
1500 * This routine must be called by kernel at boot time
1502 static int __init riscom8_init(void)
1509 if (rc_init_drivers())
1512 for (i = 0; i < RC_NBOARD; i++)
1513 if (rc_board[i].base && !rc_probe(&rc_board[i]))
1516 rc_release_drivers();
1517 printk(no_boards_msg);
1528 module_param(iobase, int, 0);
1529 module_param(iobase1, int, 0);
1530 module_param(iobase2, int, 0);
1531 module_param(iobase3, int, 0);
1533 MODULE_LICENSE("GPL");
1534 MODULE_ALIAS_CHARDEV_MAJOR(RISCOM8_NORMAL_MAJOR);
1538 * You can setup up to 4 boards (current value of RC_NBOARD)
1539 * by specifying "iobase=0xXXX iobase1=0xXXX ..." as insmod parameter.
1542 static int __init riscom8_init_module(void)
1547 if (iobase || iobase1 || iobase2 || iobase3) {
1548 for (i = 0; i < RC_NBOARD; i++)
1549 rc_board[i].base = 0;
1553 rc_board[0].base = iobase;
1555 rc_board[1].base = iobase1;
1557 rc_board[2].base = iobase2;
1559 rc_board[3].base = iobase3;
1562 return riscom8_init();
1565 static void __exit riscom8_exit_module(void)
1569 rc_release_drivers();
1570 for (i = 0; i < RC_NBOARD; i++)
1571 if (rc_board[i].flags & RC_BOARD_PRESENT)
1572 rc_release_io_range(&rc_board[i]);
1576 module_init(riscom8_init_module);
1577 module_exit(riscom8_exit_module);