1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34#include <linux/module.h>
35
36#include <linux/io.h>
37#include <linux/kernel.h>
38#include <linux/sched.h>
39#include <linux/ioport.h>
40#include <linux/interrupt.h>
41#include <linux/errno.h>
42#include <linux/tty.h>
43#include <linux/mm.h>
44#include <linux/serial.h>
45#include <linux/fcntl.h>
46#include <linux/major.h>
47#include <linux/init.h>
48#include <linux/delay.h>
49#include <linux/tty_flip.h>
50#include <linux/smp_lock.h>
51#include <linux/spinlock.h>
52#include <linux/device.h>
53
54#include <linux/uaccess.h>
55
56#include "riscom8.h"
57#include "riscom8_reg.h"
58
59
60#define RISCOM_PARANOIA_CHECK
61
62
63
64
65
66
67
68#define RISCOM_BRAIN_DAMAGED_CTS
69
70
71
72
73
74#undef RC_REPORT_FIFO
75#undef RC_REPORT_OVERRUN
76
77
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)
82
83static struct tty_driver *riscom_driver;
84
85static DEFINE_SPINLOCK(riscom_lock);
86
87static struct riscom_board rc_board[RC_NBOARD] = {
88 {
89 .base = RC_IOBASE1,
90 },
91 {
92 .base = RC_IOBASE2,
93 },
94 {
95 .base = RC_IOBASE3,
96 },
97 {
98 .base = RC_IOBASE4,
99 },
100};
101
102static struct riscom_port rc_port[RC_NBOARD * RC_NPORT];
103
104
105static unsigned short rc_ioport[] = {
106#if 1
107 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x09, 0x0a, 0x0b, 0x0c,
108#else
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
112#endif
113};
114#define RC_NIOPORT ARRAY_SIZE(rc_ioport)
115
116
117static int rc_paranoia_check(struct riscom_port const *port,
118 char *name, const char *routine)
119{
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";
125
126 if (!port) {
127 printk(badinfo, name, routine);
128 return 1;
129 }
130 if (port->magic != RISCOM8_MAGIC) {
131 printk(badmagic, name, routine);
132 return 1;
133 }
134#endif
135 return 0;
136}
137
138
139
140
141
142
143
144
145static inline int board_No(struct riscom_board const *bp)
146{
147 return bp - rc_board;
148}
149
150
151static inline int port_No(struct riscom_port const *port)
152{
153 return RC_PORT(port - rc_port);
154}
155
156
157static inline struct riscom_board *port_Board(struct riscom_port const *port)
158{
159 return &rc_board[RC_BOARD(port - rc_port)];
160}
161
162
163static inline unsigned char rc_in(struct riscom_board const *bp,
164 unsigned short reg)
165{
166 return inb(bp->base + RC_TO_ISA(reg));
167}
168
169
170static inline void rc_out(struct riscom_board const *bp, unsigned short reg,
171 unsigned char val)
172{
173 outb(val, bp->base + RC_TO_ISA(reg));
174}
175
176
177static void rc_wait_CCR(struct riscom_board const *bp)
178{
179 unsigned long delay;
180
181
182 for (delay = 100000; delay; delay--)
183 if (!rc_in(bp, CD180_CCR))
184 return;
185
186 printk(KERN_INFO "rc%d: Timeout waiting for CCR.\n", board_No(bp));
187}
188
189
190
191
192
193static int rc_request_io_range(struct riscom_board * const bp)
194{
195 int i;
196
197 for (i = 0; i < RC_NIOPORT; i++)
198 if (!request_region(RC_TO_ISA(rc_ioport[i]) + bp->base, 1,
199 "RISCom/8")) {
200 goto out_release;
201 }
202 return 0;
203out_release:
204 printk(KERN_INFO "rc%d: Skipping probe at 0x%03x. IO address in use.\n",
205 board_No(bp), bp->base);
206 while (--i >= 0)
207 release_region(RC_TO_ISA(rc_ioport[i]) + bp->base, 1);
208 return 1;
209}
210
211static void rc_release_io_range(struct riscom_board * const bp)
212{
213 int i;
214
215 for (i = 0; i < RC_NIOPORT; i++)
216 release_region(RC_TO_ISA(rc_ioport[i]) + bp->base, 1);
217}
218
219
220static void __init rc_init_CD180(struct riscom_board const *bp)
221{
222 unsigned long flags;
223
224 spin_lock_irqsave(&riscom_lock, flags);
225
226 rc_out(bp, RC_CTOUT, 0);
227 rc_wait_CCR(bp);
228 rc_out(bp, CD180_CCR, CCR_HARDRESET);
229 spin_unlock_irqrestore(&riscom_lock, flags);
230 msleep(50);
231 spin_lock_irqsave(&riscom_lock, flags);
232 rc_out(bp, CD180_GIVR, RC_ID);
233 rc_out(bp, CD180_GICR, 0);
234 rc_out(bp, CD180_PILR1, RC_ACK_MINT);
235 rc_out(bp, CD180_PILR2, RC_ACK_TINT);
236 rc_out(bp, CD180_PILR3, RC_ACK_RINT);
237
238
239 rc_out(bp, CD180_PPRH, (RC_OSCFREQ/(1000000/RISCOM_TPS)) >> 8);
240 rc_out(bp, CD180_PPRL, (RC_OSCFREQ/(1000000/RISCOM_TPS)) & 0xff);
241
242 spin_unlock_irqrestore(&riscom_lock, flags);
243}
244
245
246static int __init rc_probe(struct riscom_board *bp)
247{
248 unsigned char val1, val2;
249 int irqs = 0;
250 int retries;
251
252 bp->irq = 0;
253
254 if (rc_request_io_range(bp))
255 return 1;
256
257
258 rc_out(bp, CD180_PPRL, 0x5a);
259 outb(0xff, 0x80);
260 val1 = rc_in(bp, CD180_PPRL);
261 rc_out(bp, CD180_PPRL, 0xa5);
262 outb(0x00, 0x80);
263 val2 = rc_in(bp, CD180_PPRL);
264
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);
268 goto out_release;
269 }
270
271
272 for (retries = 0; retries < 5 && irqs <= 0; retries++) {
273 irqs = probe_irq_on();
274 rc_init_CD180(bp);
275 rc_out(bp, CD180_CAR, 2);
276 rc_wait_CCR(bp);
277 rc_out(bp, CD180_CCR, CCR_TXEN);
278 rc_out(bp, CD180_IER, IER_TXRDY);
279 msleep(50);
280 irqs = probe_irq_off(irqs);
281 val1 = rc_in(bp, RC_BSR);
282 val2 = rc_in(bp, RC_ACK_TINT);
283 rc_init_CD180(bp);
284
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);
288 goto out_release;
289 }
290 }
291
292 if (irqs <= 0) {
293 printk(KERN_ERR "rc%d: Can't find IRQ for RISCom/8 board "
294 "at 0x%03x.\n", board_No(bp), bp->base);
295 goto out_release;
296 }
297 bp->irq = irqs;
298 bp->flags |= RC_BOARD_PRESENT;
299
300 printk(KERN_INFO "rc%d: RISCom/8 Rev. %c board detected at "
301 "0x%03x, IRQ %d.\n",
302 board_No(bp),
303 (rc_in(bp, CD180_GFRCR) & 0x0f) + 'A',
304 bp->base, bp->irq);
305
306 return 0;
307out_release:
308 rc_release_io_range(bp);
309 return 1;
310}
311
312
313
314
315
316
317
318static struct riscom_port *rc_get_port(struct riscom_board const *bp,
319 unsigned char const *what)
320{
321 unsigned char channel;
322 struct riscom_port *port;
323
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)
328 return port;
329 }
330 printk(KERN_ERR "rc%d: %s interrupt from invalid port %d\n",
331 board_No(bp), what, channel);
332 return NULL;
333}
334
335static void rc_receive_exc(struct riscom_board const *bp)
336{
337 struct riscom_port *port;
338 struct tty_struct *tty;
339 unsigned char status;
340 unsigned char ch, flag;
341
342 port = rc_get_port(bp, "Receive");
343 if (port == NULL)
344 return;
345
346 tty = tty_port_tty_get(&port->port);
347
348#ifdef RC_REPORT_OVERRUN
349 status = rc_in(bp, CD180_RCSR);
350 if (status & RCSR_OE)
351 port->overrun++;
352 status &= port->mark_mask;
353#else
354 status = rc_in(bp, CD180_RCSR) & port->mark_mask;
355#endif
356 ch = rc_in(bp, CD180_RDR);
357 if (!status)
358 goto out;
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));
363 goto out;
364
365 } else if (status & RCSR_BREAK) {
366 printk(KERN_INFO "rc%d: port %d: Handling break...\n",
367 board_No(bp), port_No(port));
368 flag = TTY_BREAK;
369 if (tty && (port->port.flags & ASYNC_SAK))
370 do_SAK(tty);
371
372 } else if (status & RCSR_PE)
373 flag = TTY_PARITY;
374
375 else if (status & RCSR_FE)
376 flag = TTY_FRAME;
377
378 else if (status & RCSR_OE)
379 flag = TTY_OVERRUN;
380 else
381 flag = TTY_NORMAL;
382
383 if (tty) {
384 tty_insert_flip_char(tty, ch, flag);
385 tty_flip_buffer_push(tty);
386 }
387out:
388 tty_kref_put(tty);
389}
390
391static void rc_receive(struct riscom_board const *bp)
392{
393 struct riscom_port *port;
394 struct tty_struct *tty;
395 unsigned char count;
396
397 port = rc_get_port(bp, "Receive");
398 if (port == NULL)
399 return;
400
401 tty = tty_port_tty_get(&port->port);
402
403 count = rc_in(bp, CD180_RDCR);
404
405#ifdef RC_REPORT_FIFO
406 port->hits[count > 8 ? 9 : count]++;
407#endif
408
409 while (count--) {
410 u8 ch = rc_in(bp, CD180_RDR);
411 if (tty)
412 tty_insert_flip_char(tty, ch, TTY_NORMAL);
413 }
414 if (tty) {
415 tty_flip_buffer_push(tty);
416 tty_kref_put(tty);
417 }
418}
419
420static void rc_transmit(struct riscom_board const *bp)
421{
422 struct riscom_port *port;
423 struct tty_struct *tty;
424 unsigned char count;
425
426 port = rc_get_port(bp, "Transmit");
427 if (port == NULL)
428 return;
429
430 tty = tty_port_tty_get(&port->port);
431
432 if (port->IER & IER_TXEMPTY) {
433
434 rc_out(bp, CD180_CAR, port_No(port));
435 port->IER &= ~IER_TXEMPTY;
436 rc_out(bp, CD180_IER, port->IER);
437 goto out;
438 }
439
440 if ((port->xmit_cnt <= 0 && !port->break_length)
441 || (tty && (tty->stopped || tty->hw_stopped))) {
442 rc_out(bp, CD180_CAR, port_No(port));
443 port->IER &= ~IER_TXRDY;
444 rc_out(bp, CD180_IER, port->IER);
445 goto out;
446 }
447
448 if (port->break_length) {
449 if (port->break_length > 0) {
450 if (port->COR2 & COR2_ETC) {
451 rc_out(bp, CD180_TDR, CD180_C_ESC);
452 rc_out(bp, CD180_TDR, CD180_C_SBRK);
453 port->COR2 &= ~COR2_ETC;
454 }
455 count = min_t(int, port->break_length, 0xff);
456 rc_out(bp, CD180_TDR, CD180_C_ESC);
457 rc_out(bp, CD180_TDR, CD180_C_DELAY);
458 rc_out(bp, CD180_TDR, count);
459 port->break_length -= count;
460 if (port->break_length == 0)
461 port->break_length--;
462 } else {
463 rc_out(bp, CD180_TDR, CD180_C_ESC);
464 rc_out(bp, CD180_TDR, CD180_C_EBRK);
465 rc_out(bp, CD180_COR2, port->COR2);
466 rc_wait_CCR(bp);
467 rc_out(bp, CD180_CCR, CCR_CORCHG2);
468 port->break_length = 0;
469 }
470 goto out;
471 }
472
473 count = CD180_NFIFO;
474 do {
475 rc_out(bp, CD180_TDR, port->port.xmit_buf[port->xmit_tail++]);
476 port->xmit_tail = port->xmit_tail & (SERIAL_XMIT_SIZE-1);
477 if (--port->xmit_cnt <= 0)
478 break;
479 } while (--count > 0);
480
481 if (port->xmit_cnt <= 0) {
482 rc_out(bp, CD180_CAR, port_No(port));
483 port->IER &= ~IER_TXRDY;
484 rc_out(bp, CD180_IER, port->IER);
485 }
486 if (tty && port->xmit_cnt <= port->wakeup_chars)
487 tty_wakeup(tty);
488out:
489 tty_kref_put(tty);
490}
491
492static void rc_check_modem(struct riscom_board const *bp)
493{
494 struct riscom_port *port;
495 struct tty_struct *tty;
496 unsigned char mcr;
497
498 port = rc_get_port(bp, "Modem");
499 if (port == NULL)
500 return;
501
502 tty = tty_port_tty_get(&port->port);
503
504 mcr = rc_in(bp, CD180_MCR);
505 if (mcr & MCR_CDCHG) {
506 if (rc_in(bp, CD180_MSVR) & MSVR_CD)
507 wake_up_interruptible(&port->port.open_wait);
508 else if (tty)
509 tty_hangup(tty);
510 }
511
512#ifdef RISCOM_BRAIN_DAMAGED_CTS
513 if (mcr & MCR_CTSCHG) {
514 if (rc_in(bp, CD180_MSVR) & MSVR_CTS) {
515 port->IER |= IER_TXRDY;
516 if (tty) {
517 tty->hw_stopped = 0;
518 if (port->xmit_cnt <= port->wakeup_chars)
519 tty_wakeup(tty);
520 }
521 } else {
522 if (tty)
523 tty->hw_stopped = 1;
524 port->IER &= ~IER_TXRDY;
525 }
526 rc_out(bp, CD180_IER, port->IER);
527 }
528 if (mcr & MCR_DSRCHG) {
529 if (rc_in(bp, CD180_MSVR) & MSVR_DSR) {
530 port->IER |= IER_TXRDY;
531 if (tty) {
532 tty->hw_stopped = 0;
533 if (port->xmit_cnt <= port->wakeup_chars)
534 tty_wakeup(tty);
535 }
536 } else {
537 if (tty)
538 tty->hw_stopped = 1;
539 port->IER &= ~IER_TXRDY;
540 }
541 rc_out(bp, CD180_IER, port->IER);
542 }
543#endif
544
545
546 rc_out(bp, CD180_MCR, 0);
547 tty_kref_put(tty);
548}
549
550
551static irqreturn_t rc_interrupt(int dummy, void *dev_id)
552{
553 unsigned char status;
554 unsigned char ack;
555 struct riscom_board *bp = dev_id;
556 unsigned long loop = 0;
557 int handled = 0;
558
559 if (!(bp->flags & RC_BOARD_ACTIVE))
560 return IRQ_NONE;
561
562 while ((++loop < 16) && ((status = ~(rc_in(bp, RC_BSR))) &
563 (RC_BSR_TOUT | RC_BSR_TINT |
564 RC_BSR_MINT | RC_BSR_RINT))) {
565 handled = 1;
566 if (status & RC_BSR_TOUT)
567 printk(KERN_WARNING "rc%d: Got timeout. Hardware "
568 "error?\n", board_No(bp));
569 else if (status & RC_BSR_RINT) {
570 ack = rc_in(bp, RC_ACK_RINT);
571 if (ack == (RC_ID | GIVR_IT_RCV))
572 rc_receive(bp);
573 else if (ack == (RC_ID | GIVR_IT_REXC))
574 rc_receive_exc(bp);
575 else
576 printk(KERN_WARNING "rc%d: Bad receive ack "
577 "0x%02x.\n",
578 board_No(bp), ack);
579 } else if (status & RC_BSR_TINT) {
580 ack = rc_in(bp, RC_ACK_TINT);
581 if (ack == (RC_ID | GIVR_IT_TX))
582 rc_transmit(bp);
583 else
584 printk(KERN_WARNING "rc%d: Bad transmit ack "
585 "0x%02x.\n",
586 board_No(bp), ack);
587 } else {
588 ack = rc_in(bp, RC_ACK_MINT);
589 if (ack == (RC_ID | GIVR_IT_MODEM))
590 rc_check_modem(bp);
591 else
592 printk(KERN_WARNING "rc%d: Bad modem ack "
593 "0x%02x.\n",
594 board_No(bp), ack);
595 }
596 rc_out(bp, CD180_EOIR, 0);
597 rc_out(bp, RC_CTOUT, 0);
598 }
599 return IRQ_RETVAL(handled);
600}
601
602
603
604
605
606
607static int rc_setup_board(struct riscom_board *bp)
608{
609 int error;
610
611 if (bp->flags & RC_BOARD_ACTIVE)
612 return 0;
613
614 error = request_irq(bp->irq, rc_interrupt, IRQF_DISABLED,
615 "RISCom/8", bp);
616 if (error)
617 return error;
618
619 rc_out(bp, RC_CTOUT, 0);
620 bp->DTR = ~0;
621 rc_out(bp, RC_DTR, bp->DTR);
622
623 bp->flags |= RC_BOARD_ACTIVE;
624
625 return 0;
626}
627
628
629static void rc_shutdown_board(struct riscom_board *bp)
630{
631 if (!(bp->flags & RC_BOARD_ACTIVE))
632 return;
633
634 bp->flags &= ~RC_BOARD_ACTIVE;
635
636 free_irq(bp->irq, NULL);
637
638 bp->DTR = ~0;
639 rc_out(bp, RC_DTR, bp->DTR);
640
641}
642
643
644
645
646
647static void rc_change_speed(struct tty_struct *tty, struct riscom_board *bp,
648 struct riscom_port *port)
649{
650 unsigned long baud;
651 long tmp;
652 unsigned char cor1 = 0, cor3 = 0;
653 unsigned char mcor1 = 0, mcor2 = 0;
654
655 port->IER = 0;
656 port->COR2 = 0;
657 port->MSVR = MSVR_RTS;
658
659 baud = tty_get_baud_rate(tty);
660
661
662 rc_out(bp, CD180_CAR, port_No(port));
663
664 if (!baud) {
665
666 bp->DTR |= (1u << port_No(port));
667 rc_out(bp, RC_DTR, bp->DTR);
668 return;
669 } else {
670
671 bp->DTR &= ~(1u << port_No(port));
672 rc_out(bp, RC_DTR, bp->DTR);
673 }
674
675
676
677
678
679
680 tmp = (((RC_OSCFREQ + baud/2) / baud +
681 CD180_TPC/2) / CD180_TPC);
682
683 rc_out(bp, CD180_RBPRH, (tmp >> 8) & 0xff);
684 rc_out(bp, CD180_TBPRH, (tmp >> 8) & 0xff);
685 rc_out(bp, CD180_RBPRL, tmp & 0xff);
686 rc_out(bp, CD180_TBPRL, tmp & 0xff);
687
688 baud = (baud + 5) / 10;
689
690
691 tmp = ((baud + HZ/2) / HZ) * 2 - CD180_NFIFO;
692 port->wakeup_chars = (tmp < 0) ? 0 : ((tmp >= SERIAL_XMIT_SIZE) ?
693 SERIAL_XMIT_SIZE - 1 : tmp);
694
695
696 tmp = (RISCOM_TPS + RISCOM_TPS/2 + baud/2) / baud;
697 tmp = (tmp > 0xff) ? 0xff : tmp;
698 rc_out(bp, CD180_RTPR, tmp);
699
700 switch (C_CSIZE(tty)) {
701 case CS5:
702 cor1 |= COR1_5BITS;
703 break;
704 case CS6:
705 cor1 |= COR1_6BITS;
706 break;
707 case CS7:
708 cor1 |= COR1_7BITS;
709 break;
710 case CS8:
711 cor1 |= COR1_8BITS;
712 break;
713 }
714 if (C_CSTOPB(tty))
715 cor1 |= COR1_2SB;
716
717 cor1 |= COR1_IGNORE;
718 if (C_PARENB(tty)) {
719 cor1 |= COR1_NORMPAR;
720 if (C_PARODD(tty))
721 cor1 |= COR1_ODDP;
722 if (I_INPCK(tty))
723 cor1 &= ~COR1_IGNORE;
724 }
725
726 port->mark_mask = RCSR_OE | RCSR_TOUT;
727 if (I_INPCK(tty))
728 port->mark_mask |= RCSR_FE | RCSR_PE;
729 if (I_BRKINT(tty) || I_PARMRK(tty))
730 port->mark_mask |= RCSR_BREAK;
731 if (I_IGNPAR(tty))
732 port->mark_mask &= ~(RCSR_FE | RCSR_PE);
733 if (I_IGNBRK(tty)) {
734 port->mark_mask &= ~RCSR_BREAK;
735 if (I_IGNPAR(tty))
736
737 port->mark_mask &= ~RCSR_OE;
738 }
739
740 if (C_CRTSCTS(tty)) {
741#ifdef RISCOM_BRAIN_DAMAGED_CTS
742 port->IER |= IER_DSR | IER_CTS;
743 mcor1 |= MCOR1_DSRZD | MCOR1_CTSZD;
744 mcor2 |= MCOR2_DSROD | MCOR2_CTSOD;
745 tty->hw_stopped = !(rc_in(bp, CD180_MSVR) &
746 (MSVR_CTS|MSVR_DSR));
747#else
748 port->COR2 |= COR2_CTSAE;
749#endif
750 }
751
752
753 if (I_IXON(tty)) {
754 port->COR2 |= COR2_TXIBE;
755 cor3 |= (COR3_FCT | COR3_SCDE);
756 if (I_IXANY(tty))
757 port->COR2 |= COR2_IXM;
758 rc_out(bp, CD180_SCHR1, START_CHAR(tty));
759 rc_out(bp, CD180_SCHR2, STOP_CHAR(tty));
760 rc_out(bp, CD180_SCHR3, START_CHAR(tty));
761 rc_out(bp, CD180_SCHR4, STOP_CHAR(tty));
762 }
763 if (!C_CLOCAL(tty)) {
764
765 port->IER |= IER_CD;
766 mcor1 |= MCOR1_CDZD;
767 mcor2 |= MCOR2_CDOD;
768 }
769
770 if (C_CREAD(tty))
771
772 port->IER |= IER_RXD;
773
774
775 cor3 |= RISCOM_RXFIFO;
776
777 rc_out(bp, CD180_COR1, cor1);
778 rc_out(bp, CD180_COR2, port->COR2);
779 rc_out(bp, CD180_COR3, cor3);
780
781 rc_wait_CCR(bp);
782 rc_out(bp, CD180_CCR, CCR_CORCHG1 | CCR_CORCHG2 | CCR_CORCHG3);
783
784 rc_out(bp, CD180_MCOR1, mcor1);
785 rc_out(bp, CD180_MCOR2, mcor2);
786
787 rc_wait_CCR(bp);
788 rc_out(bp, CD180_CCR, CCR_TXEN | CCR_RXEN);
789
790 rc_out(bp, CD180_IER, port->IER);
791
792 rc_out(bp, CD180_MSVR, port->MSVR);
793}
794
795
796static int rc_setup_port(struct tty_struct *tty, struct riscom_board *bp,
797 struct riscom_port *port)
798{
799 unsigned long flags;
800
801 if (port->port.flags & ASYNC_INITIALIZED)
802 return 0;
803
804 if (tty_port_alloc_xmit_buf(&port->port) < 0)
805 return -ENOMEM;
806
807 spin_lock_irqsave(&riscom_lock, flags);
808
809 clear_bit(TTY_IO_ERROR, &tty->flags);
810 if (port->port.count == 1)
811 bp->count++;
812 port->xmit_cnt = port->xmit_head = port->xmit_tail = 0;
813 rc_change_speed(tty, bp, port);
814 port->port.flags |= ASYNC_INITIALIZED;
815
816 spin_unlock_irqrestore(&riscom_lock, flags);
817 return 0;
818}
819
820
821static void rc_shutdown_port(struct tty_struct *tty,
822 struct riscom_board *bp, struct riscom_port *port)
823{
824 if (!(port->port.flags & ASYNC_INITIALIZED))
825 return;
826
827#ifdef RC_REPORT_OVERRUN
828 printk(KERN_INFO "rc%d: port %d: Total %ld overruns were detected.\n",
829 board_No(bp), port_No(port), port->overrun);
830#endif
831#ifdef RC_REPORT_FIFO
832 {
833 int i;
834
835 printk(KERN_INFO "rc%d: port %d: FIFO hits [ ",
836 board_No(bp), port_No(port));
837 for (i = 0; i < 10; i++)
838 printk("%ld ", port->hits[i]);
839 printk("].\n");
840 }
841#endif
842 tty_port_free_xmit_buf(&port->port);
843 if (C_HUPCL(tty)) {
844
845 bp->DTR |= (1u << port_No(port));
846 rc_out(bp, RC_DTR, bp->DTR);
847 }
848
849
850 rc_out(bp, CD180_CAR, port_No(port));
851
852 rc_wait_CCR(bp);
853 rc_out(bp, CD180_CCR, CCR_SOFTRESET);
854
855 port->IER = 0;
856 rc_out(bp, CD180_IER, port->IER);
857
858 set_bit(TTY_IO_ERROR, &tty->flags);
859 port->port.flags &= ~ASYNC_INITIALIZED;
860
861 if (--bp->count < 0) {
862 printk(KERN_INFO "rc%d: rc_shutdown_port: "
863 "bad board count: %d\n",
864 board_No(bp), bp->count);
865 bp->count = 0;
866 }
867
868
869
870
871 if (!bp->count)
872 rc_shutdown_board(bp);
873}
874
875static int carrier_raised(struct tty_port *port)
876{
877 struct riscom_port *p = container_of(port, struct riscom_port, port);
878 struct riscom_board *bp = port_Board(p);
879 unsigned long flags;
880 int CD;
881
882 spin_lock_irqsave(&riscom_lock, flags);
883 rc_out(bp, CD180_CAR, port_No(p));
884 CD = rc_in(bp, CD180_MSVR) & MSVR_CD;
885 rc_out(bp, CD180_MSVR, MSVR_RTS);
886 bp->DTR &= ~(1u << port_No(p));
887 rc_out(bp, RC_DTR, bp->DTR);
888 spin_unlock_irqrestore(&riscom_lock, flags);
889 return CD;
890}
891
892static int rc_open(struct tty_struct *tty, struct file *filp)
893{
894 int board;
895 int error;
896 struct riscom_port *port;
897 struct riscom_board *bp;
898
899 board = RC_BOARD(tty->index);
900 if (board >= RC_NBOARD || !(rc_board[board].flags & RC_BOARD_PRESENT))
901 return -ENODEV;
902
903 bp = &rc_board[board];
904 port = rc_port + board * RC_NPORT + RC_PORT(tty->index);
905 if (rc_paranoia_check(port, tty->name, "rc_open"))
906 return -ENODEV;
907
908 error = rc_setup_board(bp);
909 if (error)
910 return error;
911
912 port->port.count++;
913 tty->driver_data = port;
914 tty_port_tty_set(&port->port, tty);
915
916 error = rc_setup_port(tty, bp, port);
917 if (error == 0)
918 error = tty_port_block_til_ready(&port->port, tty, filp);
919 return error;
920}
921
922static void rc_flush_buffer(struct tty_struct *tty)
923{
924 struct riscom_port *port = tty->driver_data;
925 unsigned long flags;
926
927 if (rc_paranoia_check(port, tty->name, "rc_flush_buffer"))
928 return;
929
930 spin_lock_irqsave(&riscom_lock, flags);
931 port->xmit_cnt = port->xmit_head = port->xmit_tail = 0;
932 spin_unlock_irqrestore(&riscom_lock, flags);
933
934 tty_wakeup(tty);
935}
936
937static void rc_close_port(struct tty_port *port)
938{
939 unsigned long flags;
940 struct riscom_port *rp = container_of(port, struct riscom_port, port);
941 struct riscom_board *bp = port_Board(rp);
942 unsigned long timeout;
943
944
945
946
947
948
949
950
951 spin_lock_irqsave(&riscom_lock, flags);
952 rp->IER &= ~IER_RXD;
953 if (port->flags & ASYNC_INITIALIZED) {
954 rp->IER &= ~IER_TXRDY;
955 rp->IER |= IER_TXEMPTY;
956 rc_out(bp, CD180_CAR, port_No(rp));
957 rc_out(bp, CD180_IER, rp->IER);
958
959
960
961
962
963 timeout = jiffies + HZ;
964 while (rp->IER & IER_TXEMPTY) {
965 spin_unlock_irqrestore(&riscom_lock, flags);
966 msleep_interruptible(jiffies_to_msecs(rp->timeout));
967 spin_lock_irqsave(&riscom_lock, flags);
968 if (time_after(jiffies, timeout))
969 break;
970 }
971 }
972 rc_shutdown_port(port->tty, bp, rp);
973 spin_unlock_irqrestore(&riscom_lock, flags);
974}
975
976static void rc_close(struct tty_struct *tty, struct file *filp)
977{
978 struct riscom_port *port = tty->driver_data;
979
980 if (!port || rc_paranoia_check(port, tty->name, "close"))
981 return;
982 tty_port_close(&port->port, tty, filp);
983}
984
985static int rc_write(struct tty_struct *tty,
986 const unsigned char *buf, int count)
987{
988 struct riscom_port *port = tty->driver_data;
989 struct riscom_board *bp;
990 int c, total = 0;
991 unsigned long flags;
992
993 if (rc_paranoia_check(port, tty->name, "rc_write"))
994 return 0;
995
996 bp = port_Board(port);
997
998 while (1) {
999 spin_lock_irqsave(&riscom_lock, flags);
1000
1001 c = min_t(int, count, min(SERIAL_XMIT_SIZE - port->xmit_cnt - 1,
1002 SERIAL_XMIT_SIZE - port->xmit_head));
1003 if (c <= 0)
1004 break;
1005
1006 memcpy(port->port.xmit_buf + port->xmit_head, buf, c);
1007 port->xmit_head = (port->xmit_head + c) & (SERIAL_XMIT_SIZE-1);
1008 port->xmit_cnt += c;
1009
1010 spin_unlock_irqrestore(&riscom_lock, flags);
1011
1012 buf += c;
1013 count -= c;
1014 total += c;
1015 }
1016
1017 if (port->xmit_cnt && !tty->stopped && !tty->hw_stopped &&
1018 !(port->IER & IER_TXRDY)) {
1019 port->IER |= IER_TXRDY;
1020 rc_out(bp, CD180_CAR, port_No(port));
1021 rc_out(bp, CD180_IER, port->IER);
1022 }
1023
1024 spin_unlock_irqrestore(&riscom_lock, flags);
1025
1026 return total;
1027}
1028
1029static int rc_put_char(struct tty_struct *tty, unsigned char ch)
1030{
1031 struct riscom_port *port = tty->driver_data;
1032 unsigned long flags;
1033 int ret = 0;
1034
1035 if (rc_paranoia_check(port, tty->name, "rc_put_char"))
1036 return 0;
1037
1038 spin_lock_irqsave(&riscom_lock, flags);
1039
1040 if (port->xmit_cnt >= SERIAL_XMIT_SIZE - 1)
1041 goto out;
1042
1043 port->port.xmit_buf[port->xmit_head++] = ch;
1044 port->xmit_head &= SERIAL_XMIT_SIZE - 1;
1045 port->xmit_cnt++;
1046 ret = 1;
1047
1048out:
1049 spin_unlock_irqrestore(&riscom_lock, flags);
1050 return ret;
1051}
1052
1053static void rc_flush_chars(struct tty_struct *tty)
1054{
1055 struct riscom_port *port = tty->driver_data;
1056 unsigned long flags;
1057
1058 if (rc_paranoia_check(port, tty->name, "rc_flush_chars"))
1059 return;
1060
1061 if (port->xmit_cnt <= 0 || tty->stopped || tty->hw_stopped)
1062 return;
1063
1064 spin_lock_irqsave(&riscom_lock, flags);
1065
1066 port->IER |= IER_TXRDY;
1067 rc_out(port_Board(port), CD180_CAR, port_No(port));
1068 rc_out(port_Board(port), CD180_IER, port->IER);
1069
1070 spin_unlock_irqrestore(&riscom_lock, flags);
1071}
1072
1073static int rc_write_room(struct tty_struct *tty)
1074{
1075 struct riscom_port *port = tty->driver_data;
1076 int ret;
1077
1078 if (rc_paranoia_check(port, tty->name, "rc_write_room"))
1079 return 0;
1080
1081 ret = SERIAL_XMIT_SIZE - port->xmit_cnt - 1;
1082 if (ret < 0)
1083 ret = 0;
1084 return ret;
1085}
1086
1087static int rc_chars_in_buffer(struct tty_struct *tty)
1088{
1089 struct riscom_port *port = tty->driver_data;
1090
1091 if (rc_paranoia_check(port, tty->name, "rc_chars_in_buffer"))
1092 return 0;
1093
1094 return port->xmit_cnt;
1095}
1096
1097static int rc_tiocmget(struct tty_struct *tty, struct file *file)
1098{
1099 struct riscom_port *port = tty->driver_data;
1100 struct riscom_board *bp;
1101 unsigned char status;
1102 unsigned int result;
1103 unsigned long flags;
1104
1105 if (rc_paranoia_check(port, tty->name, __func__))
1106 return -ENODEV;
1107
1108 bp = port_Board(port);
1109
1110 spin_lock_irqsave(&riscom_lock, flags);
1111
1112 rc_out(bp, CD180_CAR, port_No(port));
1113 status = rc_in(bp, CD180_MSVR);
1114 result = rc_in(bp, RC_RI) & (1u << port_No(port)) ? 0 : TIOCM_RNG;
1115
1116 spin_unlock_irqrestore(&riscom_lock, flags);
1117
1118 result |= ((status & MSVR_RTS) ? TIOCM_RTS : 0)
1119 | ((status & MSVR_DTR) ? TIOCM_DTR : 0)
1120 | ((status & MSVR_CD) ? TIOCM_CAR : 0)
1121 | ((status & MSVR_DSR) ? TIOCM_DSR : 0)
1122 | ((status & MSVR_CTS) ? TIOCM_CTS : 0);
1123 return result;
1124}
1125
1126static int rc_tiocmset(struct tty_struct *tty, struct file *file,
1127 unsigned int set, unsigned int clear)
1128{
1129 struct riscom_port *port = tty->driver_data;
1130 unsigned long flags;
1131 struct riscom_board *bp;
1132
1133 if (rc_paranoia_check(port, tty->name, __func__))
1134 return -ENODEV;
1135
1136 bp = port_Board(port);
1137
1138 spin_lock_irqsave(&riscom_lock, flags);
1139
1140 if (set & TIOCM_RTS)
1141 port->MSVR |= MSVR_RTS;
1142 if (set & TIOCM_DTR)
1143 bp->DTR &= ~(1u << port_No(port));
1144
1145 if (clear & TIOCM_RTS)
1146 port->MSVR &= ~MSVR_RTS;
1147 if (clear & TIOCM_DTR)
1148 bp->DTR |= (1u << port_No(port));
1149
1150 rc_out(bp, CD180_CAR, port_No(port));
1151 rc_out(bp, CD180_MSVR, port->MSVR);
1152 rc_out(bp, RC_DTR, bp->DTR);
1153
1154 spin_unlock_irqrestore(&riscom_lock, flags);
1155
1156 return 0;
1157}
1158
1159static int rc_send_break(struct tty_struct *tty, int length)
1160{
1161 struct riscom_port *port = tty->driver_data;
1162 struct riscom_board *bp = port_Board(port);
1163 unsigned long flags;
1164
1165 if (length == 0 || length == -1)
1166 return -EOPNOTSUPP;
1167
1168 spin_lock_irqsave(&riscom_lock, flags);
1169
1170 port->break_length = RISCOM_TPS / HZ * length;
1171 port->COR2 |= COR2_ETC;
1172 port->IER |= IER_TXRDY;
1173 rc_out(bp, CD180_CAR, port_No(port));
1174 rc_out(bp, CD180_COR2, port->COR2);
1175 rc_out(bp, CD180_IER, port->IER);
1176 rc_wait_CCR(bp);
1177 rc_out(bp, CD180_CCR, CCR_CORCHG2);
1178 rc_wait_CCR(bp);
1179
1180 spin_unlock_irqrestore(&riscom_lock, flags);
1181 return 0;
1182}
1183
1184static int rc_set_serial_info(struct tty_struct *tty, struct riscom_port *port,
1185 struct serial_struct __user *newinfo)
1186{
1187 struct serial_struct tmp;
1188 struct riscom_board *bp = port_Board(port);
1189 int change_speed;
1190
1191 if (copy_from_user(&tmp, newinfo, sizeof(tmp)))
1192 return -EFAULT;
1193
1194 change_speed = ((port->port.flags & ASYNC_SPD_MASK) !=
1195 (tmp.flags & ASYNC_SPD_MASK));
1196
1197 if (!capable(CAP_SYS_ADMIN)) {
1198 if ((tmp.close_delay != port->port.close_delay) ||
1199 (tmp.closing_wait != port->port.closing_wait) ||
1200 ((tmp.flags & ~ASYNC_USR_MASK) !=
1201 (port->port.flags & ~ASYNC_USR_MASK)))
1202 return -EPERM;
1203 port->port.flags = ((port->port.flags & ~ASYNC_USR_MASK) |
1204 (tmp.flags & ASYNC_USR_MASK));
1205 } else {
1206 port->port.flags = ((port->port.flags & ~ASYNC_FLAGS) |
1207 (tmp.flags & ASYNC_FLAGS));
1208 port->port.close_delay = tmp.close_delay;
1209 port->port.closing_wait = tmp.closing_wait;
1210 }
1211 if (change_speed) {
1212 unsigned long flags;
1213
1214 spin_lock_irqsave(&riscom_lock, flags);
1215 rc_change_speed(tty, bp, port);
1216 spin_unlock_irqrestore(&riscom_lock, flags);
1217 }
1218 return 0;
1219}
1220
1221static int rc_get_serial_info(struct riscom_port *port,
1222 struct serial_struct __user *retinfo)
1223{
1224 struct serial_struct tmp;
1225 struct riscom_board *bp = port_Board(port);
1226
1227 memset(&tmp, 0, sizeof(tmp));
1228 tmp.type = PORT_CIRRUS;
1229 tmp.line = port - rc_port;
1230 tmp.port = bp->base;
1231 tmp.irq = bp->irq;
1232 tmp.flags = port->port.flags;
1233 tmp.baud_base = (RC_OSCFREQ + CD180_TPC/2) / CD180_TPC;
1234 tmp.close_delay = port->port.close_delay * HZ/100;
1235 tmp.closing_wait = port->port.closing_wait * HZ/100;
1236 tmp.xmit_fifo_size = CD180_NFIFO;
1237 return copy_to_user(retinfo, &tmp, sizeof(tmp)) ? -EFAULT : 0;
1238}
1239
1240static int rc_ioctl(struct tty_struct *tty, struct file *filp,
1241 unsigned int cmd, unsigned long arg)
1242{
1243 struct riscom_port *port = tty->driver_data;
1244 void __user *argp = (void __user *)arg;
1245 int retval;
1246
1247 if (rc_paranoia_check(port, tty->name, "rc_ioctl"))
1248 return -ENODEV;
1249
1250 switch (cmd) {
1251 case TIOCGSERIAL:
1252 lock_kernel();
1253 retval = rc_get_serial_info(port, argp);
1254 unlock_kernel();
1255 break;
1256 case TIOCSSERIAL:
1257 lock_kernel();
1258 retval = rc_set_serial_info(tty, port, argp);
1259 unlock_kernel();
1260 break;
1261 default:
1262 retval = -ENOIOCTLCMD;
1263 }
1264 return retval;
1265}
1266
1267static void rc_throttle(struct tty_struct *tty)
1268{
1269 struct riscom_port *port = tty->driver_data;
1270 struct riscom_board *bp;
1271 unsigned long flags;
1272
1273 if (rc_paranoia_check(port, tty->name, "rc_throttle"))
1274 return;
1275 bp = port_Board(port);
1276
1277 spin_lock_irqsave(&riscom_lock, flags);
1278 port->MSVR &= ~MSVR_RTS;
1279 rc_out(bp, CD180_CAR, port_No(port));
1280 if (I_IXOFF(tty)) {
1281 rc_wait_CCR(bp);
1282 rc_out(bp, CD180_CCR, CCR_SSCH2);
1283 rc_wait_CCR(bp);
1284 }
1285 rc_out(bp, CD180_MSVR, port->MSVR);
1286 spin_unlock_irqrestore(&riscom_lock, flags);
1287}
1288
1289static void rc_unthrottle(struct tty_struct *tty)
1290{
1291 struct riscom_port *port = tty->driver_data;
1292 struct riscom_board *bp;
1293 unsigned long flags;
1294
1295 if (rc_paranoia_check(port, tty->name, "rc_unthrottle"))
1296 return;
1297 bp = port_Board(port);
1298
1299 spin_lock_irqsave(&riscom_lock, flags);
1300 port->MSVR |= MSVR_RTS;
1301 rc_out(bp, CD180_CAR, port_No(port));
1302 if (I_IXOFF(tty)) {
1303 rc_wait_CCR(bp);
1304 rc_out(bp, CD180_CCR, CCR_SSCH1);
1305 rc_wait_CCR(bp);
1306 }
1307 rc_out(bp, CD180_MSVR, port->MSVR);
1308 spin_unlock_irqrestore(&riscom_lock, flags);
1309}
1310
1311static void rc_stop(struct tty_struct *tty)
1312{
1313 struct riscom_port *port = tty->driver_data;
1314 struct riscom_board *bp;
1315 unsigned long flags;
1316
1317 if (rc_paranoia_check(port, tty->name, "rc_stop"))
1318 return;
1319
1320 bp = port_Board(port);
1321
1322 spin_lock_irqsave(&riscom_lock, flags);
1323 port->IER &= ~IER_TXRDY;
1324 rc_out(bp, CD180_CAR, port_No(port));
1325 rc_out(bp, CD180_IER, port->IER);
1326 spin_unlock_irqrestore(&riscom_lock, flags);
1327}
1328
1329static void rc_start(struct tty_struct *tty)
1330{
1331 struct riscom_port *port = tty->driver_data;
1332 struct riscom_board *bp;
1333 unsigned long flags;
1334
1335 if (rc_paranoia_check(port, tty->name, "rc_start"))
1336 return;
1337
1338 bp = port_Board(port);
1339
1340 spin_lock_irqsave(&riscom_lock, flags);
1341
1342 if (port->xmit_cnt && port->port.xmit_buf && !(port->IER & IER_TXRDY)) {
1343 port->IER |= IER_TXRDY;
1344 rc_out(bp, CD180_CAR, port_No(port));
1345 rc_out(bp, CD180_IER, port->IER);
1346 }
1347 spin_unlock_irqrestore(&riscom_lock, flags);
1348}
1349
1350static void rc_hangup(struct tty_struct *tty)
1351{
1352 struct riscom_port *port = tty->driver_data;
1353
1354 if (rc_paranoia_check(port, tty->name, "rc_hangup"))
1355 return;
1356
1357 rc_shutdown_port(tty, port_Board(port), port);
1358 tty_port_hangup(&port->port);
1359}
1360
1361static void rc_set_termios(struct tty_struct *tty,
1362 struct ktermios *old_termios)
1363{
1364 struct riscom_port *port = tty->driver_data;
1365 unsigned long flags;
1366
1367 if (rc_paranoia_check(port, tty->name, "rc_set_termios"))
1368 return;
1369
1370 spin_lock_irqsave(&riscom_lock, flags);
1371 rc_change_speed(tty, port_Board(port), port);
1372 spin_unlock_irqrestore(&riscom_lock, flags);
1373
1374 if ((old_termios->c_cflag & CRTSCTS) &&
1375 !(tty->termios->c_cflag & CRTSCTS)) {
1376 tty->hw_stopped = 0;
1377 rc_start(tty);
1378 }
1379}
1380
1381static const struct tty_operations riscom_ops = {
1382 .open = rc_open,
1383 .close = rc_close,
1384 .write = rc_write,
1385 .put_char = rc_put_char,
1386 .flush_chars = rc_flush_chars,
1387 .write_room = rc_write_room,
1388 .chars_in_buffer = rc_chars_in_buffer,
1389 .flush_buffer = rc_flush_buffer,
1390 .ioctl = rc_ioctl,
1391 .throttle = rc_throttle,
1392 .unthrottle = rc_unthrottle,
1393 .set_termios = rc_set_termios,
1394 .stop = rc_stop,
1395 .start = rc_start,
1396 .hangup = rc_hangup,
1397 .tiocmget = rc_tiocmget,
1398 .tiocmset = rc_tiocmset,
1399 .break_ctl = rc_send_break,
1400};
1401
1402static const struct tty_port_operations riscom_port_ops = {
1403 .carrier_raised = carrier_raised,
1404 .shutdown = rc_close_port,
1405};
1406
1407
1408static int __init rc_init_drivers(void)
1409{
1410 int error;
1411 int i;
1412
1413 riscom_driver = alloc_tty_driver(RC_NBOARD * RC_NPORT);
1414 if (!riscom_driver)
1415 return -ENOMEM;
1416
1417 riscom_driver->owner = THIS_MODULE;
1418 riscom_driver->name = "ttyL";
1419 riscom_driver->major = RISCOM8_NORMAL_MAJOR;
1420 riscom_driver->type = TTY_DRIVER_TYPE_SERIAL;
1421 riscom_driver->subtype = SERIAL_TYPE_NORMAL;
1422 riscom_driver->init_termios = tty_std_termios;
1423 riscom_driver->init_termios.c_cflag =
1424 B9600 | CS8 | CREAD | HUPCL | CLOCAL;
1425 riscom_driver->init_termios.c_ispeed = 9600;
1426 riscom_driver->init_termios.c_ospeed = 9600;
1427 riscom_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_HARDWARE_BREAK;
1428 tty_set_operations(riscom_driver, &riscom_ops);
1429 error = tty_register_driver(riscom_driver);
1430 if (error != 0) {
1431 put_tty_driver(riscom_driver);
1432 printk(KERN_ERR "rc: Couldn't register RISCom/8 driver, "
1433 "error = %d\n", error);
1434 return 1;
1435 }
1436 memset(rc_port, 0, sizeof(rc_port));
1437 for (i = 0; i < RC_NPORT * RC_NBOARD; i++) {
1438 tty_port_init(&rc_port[i].port);
1439 rc_port[i].port.ops = &riscom_port_ops;
1440 rc_port[i].magic = RISCOM8_MAGIC;
1441 }
1442 return 0;
1443}
1444
1445static void rc_release_drivers(void)
1446{
1447 tty_unregister_driver(riscom_driver);
1448 put_tty_driver(riscom_driver);
1449}
1450
1451#ifndef MODULE
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461static int __init riscom8_setup(char *str)
1462{
1463 int ints[RC_NBOARD];
1464 int i;
1465
1466 str = get_options(str, ARRAY_SIZE(ints), ints);
1467
1468 for (i = 0; i < RC_NBOARD; i++) {
1469 if (i < ints[0])
1470 rc_board[i].base = ints[i+1];
1471 else
1472 rc_board[i].base = 0;
1473 }
1474 return 1;
1475}
1476
1477__setup("riscom8=", riscom8_setup);
1478#endif
1479
1480static char banner[] __initdata =
1481 KERN_INFO "rc: SDL RISCom/8 card driver v1.1, (c) D.Gorodchanin "
1482 "1994-1996.\n";
1483static char no_boards_msg[] __initdata =
1484 KERN_INFO "rc: No RISCom/8 boards detected.\n";
1485
1486
1487
1488
1489static int __init riscom8_init(void)
1490{
1491 int i;
1492 int found = 0;
1493
1494 printk(banner);
1495
1496 if (rc_init_drivers())
1497 return -EIO;
1498
1499 for (i = 0; i < RC_NBOARD; i++)
1500 if (rc_board[i].base && !rc_probe(&rc_board[i]))
1501 found++;
1502 if (!found) {
1503 rc_release_drivers();
1504 printk(no_boards_msg);
1505 return -EIO;
1506 }
1507 return 0;
1508}
1509
1510#ifdef MODULE
1511static int iobase;
1512static int iobase1;
1513static int iobase2;
1514static int iobase3;
1515module_param(iobase, int, 0);
1516module_param(iobase1, int, 0);
1517module_param(iobase2, int, 0);
1518module_param(iobase3, int, 0);
1519
1520MODULE_LICENSE("GPL");
1521MODULE_ALIAS_CHARDEV_MAJOR(RISCOM8_NORMAL_MAJOR);
1522#endif
1523
1524
1525
1526
1527
1528
1529static int __init riscom8_init_module(void)
1530{
1531#ifdef MODULE
1532 int i;
1533
1534 if (iobase || iobase1 || iobase2 || iobase3) {
1535 for (i = 0; i < RC_NBOARD; i++)
1536 rc_board[i].base = 0;
1537 }
1538
1539 if (iobase)
1540 rc_board[0].base = iobase;
1541 if (iobase1)
1542 rc_board[1].base = iobase1;
1543 if (iobase2)
1544 rc_board[2].base = iobase2;
1545 if (iobase3)
1546 rc_board[3].base = iobase3;
1547#endif
1548
1549 return riscom8_init();
1550}
1551
1552static void __exit riscom8_exit_module(void)
1553{
1554 int i;
1555
1556 rc_release_drivers();
1557 for (i = 0; i < RC_NBOARD; i++)
1558 if (rc_board[i].flags & RC_BOARD_PRESENT)
1559 rc_release_io_range(&rc_board[i]);
1560
1561}
1562
1563module_init(riscom8_init_module);
1564module_exit(riscom8_exit_module);
1565
