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