?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 2.6.20.7
[linux/fpc-iii.git] / drivers / char / riscom8.c
blobe2a94bfb2a436dd5d24e68fb8388721351a6acdb
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 wake_up_interruptible(&tty->write_wait);
1233 tty_wakeup(tty);
1234 }
1235
1236 static int rc_tiocmget(struct tty_struct *tty, struct file *file)
1237 {
1238 struct riscom_port *port = (struct riscom_port *)tty->driver_data;
1239 struct riscom_board * bp;
1240 unsigned char status;
1241 unsigned int result;
1242 unsigned long flags;
1243
1244 if (rc_paranoia_check(port, tty->name, __FUNCTION__))
1245 return -ENODEV;
1246
1247 bp = port_Board(port);
1248 save_flags(flags); cli();
1249 rc_out(bp, CD180_CAR, port_No(port));
1250 status = rc_in(bp, CD180_MSVR);
1251 result = rc_in(bp, RC_RI) & (1u << port_No(port)) ? 0 : TIOCM_RNG;
1252 restore_flags(flags);
1253 result |= ((status & MSVR_RTS) ? TIOCM_RTS : 0)
1254 | ((status & MSVR_DTR) ? TIOCM_DTR : 0)
1255 | ((status & MSVR_CD) ? TIOCM_CAR : 0)
1256 | ((status & MSVR_DSR) ? TIOCM_DSR : 0)
1257 | ((status & MSVR_CTS) ? TIOCM_CTS : 0);
1258 return result;
1259 }
1260
1261 static int rc_tiocmset(struct tty_struct *tty, struct file *file,
1262 unsigned int set, unsigned int clear)
1263 {
1264 struct riscom_port *port = (struct riscom_port *)tty->driver_data;
1265 unsigned long flags;
1266 struct riscom_board *bp;
1267
1268 if (rc_paranoia_check(port, tty->name, __FUNCTION__))
1269 return -ENODEV;
1270
1271 bp = port_Board(port);
1272
1273 save_flags(flags); cli();
1274 if (set & TIOCM_RTS)
1275 port->MSVR |= MSVR_RTS;
1276 if (set & TIOCM_DTR)
1277 bp->DTR &= ~(1u << port_No(port));
1278
1279 if (clear & TIOCM_RTS)
1280 port->MSVR &= ~MSVR_RTS;
1281 if (clear & TIOCM_DTR)
1282 bp->DTR |= (1u << port_No(port));
1283
1284 rc_out(bp, CD180_CAR, port_No(port));
1285 rc_out(bp, CD180_MSVR, port->MSVR);
1286 rc_out(bp, RC_DTR, bp->DTR);
1287 restore_flags(flags);
1288 return 0;
1289 }
1290
1291 static inline void rc_send_break(struct riscom_port * port, unsigned long length)
1292 {
1293 struct riscom_board *bp = port_Board(port);
1294 unsigned long flags;
1295
1296 save_flags(flags); cli();
1297 port->break_length = RISCOM_TPS / HZ * length;
1298 port->COR2 |= COR2_ETC;
1299 port->IER |= IER_TXRDY;
1300 rc_out(bp, CD180_CAR, port_No(port));
1301 rc_out(bp, CD180_COR2, port->COR2);
1302 rc_out(bp, CD180_IER, port->IER);
1303 rc_wait_CCR(bp);
1304 rc_out(bp, CD180_CCR, CCR_CORCHG2);
1305 rc_wait_CCR(bp);
1306 restore_flags(flags);
1307 }
1308
1309 static inline int rc_set_serial_info(struct riscom_port * port,
1310 struct serial_struct __user * newinfo)
1311 {
1312 struct serial_struct tmp;
1313 struct riscom_board *bp = port_Board(port);
1314 int change_speed;
1315 unsigned long flags;
1316
1317 if (copy_from_user(&tmp, newinfo, sizeof(tmp)))
1318 return -EFAULT;
1319
1320 #if 0
1321 if ((tmp.irq != bp->irq) ||
1322 (tmp.port != bp->base) ||
1323 (tmp.type != PORT_CIRRUS) ||
1324 (tmp.baud_base != (RC_OSCFREQ + CD180_TPC/2) / CD180_TPC) ||
1325 (tmp.custom_divisor != 0) ||
1326 (tmp.xmit_fifo_size != CD180_NFIFO) ||
1327 (tmp.flags & ~RISCOM_LEGAL_FLAGS))
1328 return -EINVAL;
1329 #endif
1330
1331 change_speed = ((port->flags & ASYNC_SPD_MASK) !=
1332 (tmp.flags & ASYNC_SPD_MASK));
1333
1334 if (!capable(CAP_SYS_ADMIN)) {
1335 if ((tmp.close_delay != port->close_delay) ||
1336 (tmp.closing_wait != port->closing_wait) ||
1337 ((tmp.flags & ~ASYNC_USR_MASK) !=
1338 (port->flags & ~ASYNC_USR_MASK)))
1339 return -EPERM;
1340 port->flags = ((port->flags & ~ASYNC_USR_MASK) |
1341 (tmp.flags & ASYNC_USR_MASK));
1342 } else {
1343 port->flags = ((port->flags & ~ASYNC_FLAGS) |
1344 (tmp.flags & ASYNC_FLAGS));
1345 port->close_delay = tmp.close_delay;
1346 port->closing_wait = tmp.closing_wait;
1347 }
1348 if (change_speed) {
1349 save_flags(flags); cli();
1350 rc_change_speed(bp, port);
1351 restore_flags(flags);
1352 }
1353 return 0;
1354 }
1355
1356 static inline int rc_get_serial_info(struct riscom_port * port,
1357 struct serial_struct __user *retinfo)
1358 {
1359 struct serial_struct tmp;
1360 struct riscom_board *bp = port_Board(port);
1361
1362 memset(&tmp, 0, sizeof(tmp));
1363 tmp.type = PORT_CIRRUS;
1364 tmp.line = port - rc_port;
1365 tmp.port = bp->base;
1366 tmp.irq = bp->irq;
1367 tmp.flags = port->flags;
1368 tmp.baud_base = (RC_OSCFREQ + CD180_TPC/2) / CD180_TPC;
1369 tmp.close_delay = port->close_delay * HZ/100;
1370 tmp.closing_wait = port->closing_wait * HZ/100;
1371 tmp.xmit_fifo_size = CD180_NFIFO;
1372 return copy_to_user(retinfo, &tmp, sizeof(tmp)) ? -EFAULT : 0;
1373 }
1374
1375 static int rc_ioctl(struct tty_struct * tty, struct file * filp,
1376 unsigned int cmd, unsigned long arg)
1377
1378 {
1379 struct riscom_port *port = (struct riscom_port *)tty->driver_data;
1380 void __user *argp = (void __user *)arg;
1381 int retval;
1382
1383 if (rc_paranoia_check(port, tty->name, "rc_ioctl"))
1384 return -ENODEV;
1385
1386 switch (cmd) {
1387 case TCSBRK: /* SVID version: non-zero arg --> no break */
1388 retval = tty_check_change(tty);
1389 if (retval)
1390 return retval;
1391 tty_wait_until_sent(tty, 0);
1392 if (!arg)
1393 rc_send_break(port, HZ/4); /* 1/4 second */
1394 break;
1395 case TCSBRKP: /* support for POSIX tcsendbreak() */
1396 retval = tty_check_change(tty);
1397 if (retval)
1398 return retval;
1399 tty_wait_until_sent(tty, 0);
1400 rc_send_break(port, arg ? arg*(HZ/10) : HZ/4);
1401 break;
1402 case TIOCGSOFTCAR:
1403 return put_user(C_CLOCAL(tty) ? 1 : 0, (unsigned __user *)argp);
1404 case TIOCSSOFTCAR:
1405 if (get_user(arg,(unsigned __user *) argp))
1406 return -EFAULT;
1407 tty->termios->c_cflag =
1408 ((tty->termios->c_cflag & ~CLOCAL) |
1409 (arg ? CLOCAL : 0));
1410 break;
1411 case TIOCGSERIAL:
1412 return rc_get_serial_info(port, argp);
1413 case TIOCSSERIAL:
1414 return rc_set_serial_info(port, argp);
1415 default:
1416 return -ENOIOCTLCMD;
1417 }
1418 return 0;
1419 }
1420
1421 static void rc_throttle(struct tty_struct * tty)
1422 {
1423 struct riscom_port *port = (struct riscom_port *)tty->driver_data;
1424 struct riscom_board *bp;
1425 unsigned long flags;
1426
1427 if (rc_paranoia_check(port, tty->name, "rc_throttle"))
1428 return;
1429
1430 bp = port_Board(port);
1431
1432 save_flags(flags); cli();
1433 port->MSVR &= ~MSVR_RTS;
1434 rc_out(bp, CD180_CAR, port_No(port));
1435 if (I_IXOFF(tty)) {
1436 rc_wait_CCR(bp);
1437 rc_out(bp, CD180_CCR, CCR_SSCH2);
1438 rc_wait_CCR(bp);
1439 }
1440 rc_out(bp, CD180_MSVR, port->MSVR);
1441 restore_flags(flags);
1442 }
1443
1444 static void rc_unthrottle(struct tty_struct * tty)
1445 {
1446 struct riscom_port *port = (struct riscom_port *)tty->driver_data;
1447 struct riscom_board *bp;
1448 unsigned long flags;
1449
1450 if (rc_paranoia_check(port, tty->name, "rc_unthrottle"))
1451 return;
1452
1453 bp = port_Board(port);
1454
1455 save_flags(flags); cli();
1456 port->MSVR |= MSVR_RTS;
1457 rc_out(bp, CD180_CAR, port_No(port));
1458 if (I_IXOFF(tty)) {
1459 rc_wait_CCR(bp);
1460 rc_out(bp, CD180_CCR, CCR_SSCH1);
1461 rc_wait_CCR(bp);
1462 }
1463 rc_out(bp, CD180_MSVR, port->MSVR);
1464 restore_flags(flags);
1465 }
1466
1467 static void rc_stop(struct tty_struct * tty)
1468 {
1469 struct riscom_port *port = (struct riscom_port *)tty->driver_data;
1470 struct riscom_board *bp;
1471 unsigned long flags;
1472
1473 if (rc_paranoia_check(port, tty->name, "rc_stop"))
1474 return;
1475
1476 bp = port_Board(port);
1477
1478 save_flags(flags); cli();
1479 port->IER &= ~IER_TXRDY;
1480 rc_out(bp, CD180_CAR, port_No(port));
1481 rc_out(bp, CD180_IER, port->IER);
1482 restore_flags(flags);
1483 }
1484
1485 static void rc_start(struct tty_struct * tty)
1486 {
1487 struct riscom_port *port = (struct riscom_port *)tty->driver_data;
1488 struct riscom_board *bp;
1489 unsigned long flags;
1490
1491 if (rc_paranoia_check(port, tty->name, "rc_start"))
1492 return;
1493
1494 bp = port_Board(port);
1495
1496 save_flags(flags); cli();
1497 if (port->xmit_cnt && port->xmit_buf && !(port->IER & IER_TXRDY)) {
1498 port->IER |= IER_TXRDY;
1499 rc_out(bp, CD180_CAR, port_No(port));
1500 rc_out(bp, CD180_IER, port->IER);
1501 }
1502 restore_flags(flags);
1503 }
1504
1505 /*
1506 * This routine is called from the work queue when the interrupt
1507 * routine has signalled that a hangup has occurred. The path of
1508 * hangup processing is:
1509 *
1510 * serial interrupt routine -> (workqueue) ->
1511 * do_rc_hangup() -> tty->hangup() -> rc_hangup()
1512 *
1513 */
1514 static void do_rc_hangup(struct work_struct *ugly_api)
1515 {
1516 struct riscom_port *port = container_of(ugly_api, struct riscom_port, tqueue_hangup);
1517 struct tty_struct *tty;
1518
1519 tty = port->tty;
1520 if (tty)
1521 tty_hangup(tty); /* FIXME: module removal race still here */
1522 }
1523
1524 static void rc_hangup(struct tty_struct * tty)
1525 {
1526 struct riscom_port *port = (struct riscom_port *)tty->driver_data;
1527 struct riscom_board *bp;
1528
1529 if (rc_paranoia_check(port, tty->name, "rc_hangup"))
1530 return;
1531
1532 bp = port_Board(port);
1533
1534 rc_shutdown_port(bp, port);
1535 port->event = 0;
1536 port->count = 0;
1537 port->flags &= ~ASYNC_NORMAL_ACTIVE;
1538 port->tty = NULL;
1539 wake_up_interruptible(&port->open_wait);
1540 }
1541
1542 static void rc_set_termios(struct tty_struct * tty, struct ktermios * old_termios)
1543 {
1544 struct riscom_port *port = (struct riscom_port *)tty->driver_data;
1545 unsigned long flags;
1546
1547 if (rc_paranoia_check(port, tty->name, "rc_set_termios"))
1548 return;
1549
1550 if (tty->termios->c_cflag == old_termios->c_cflag &&
1551 tty->termios->c_iflag == old_termios->c_iflag)
1552 return;
1553
1554 save_flags(flags); cli();
1555 rc_change_speed(port_Board(port), port);
1556 restore_flags(flags);
1557
1558 if ((old_termios->c_cflag & CRTSCTS) &&
1559 !(tty->termios->c_cflag & CRTSCTS)) {
1560 tty->hw_stopped = 0;
1561 rc_start(tty);
1562 }
1563 }
1564
1565 static void do_softint(struct work_struct *ugly_api)
1566 {
1567 struct riscom_port *port = container_of(ugly_api, struct riscom_port, tqueue);
1568 struct tty_struct *tty;
1569
1570 if(!(tty = port->tty))
1571 return;
1572
1573 if (test_and_clear_bit(RS_EVENT_WRITE_WAKEUP, &port->event)) {
1574 tty_wakeup(tty);
1575 wake_up_interruptible(&tty->write_wait);
1576 }
1577 }
1578
1579 static const struct tty_operations riscom_ops = {
1580 .open = rc_open,
1581 .close = rc_close,
1582 .write = rc_write,
1583 .put_char = rc_put_char,
1584 .flush_chars = rc_flush_chars,
1585 .write_room = rc_write_room,
1586 .chars_in_buffer = rc_chars_in_buffer,
1587 .flush_buffer = rc_flush_buffer,
1588 .ioctl = rc_ioctl,
1589 .throttle = rc_throttle,
1590 .unthrottle = rc_unthrottle,
1591 .set_termios = rc_set_termios,
1592 .stop = rc_stop,
1593 .start = rc_start,
1594 .hangup = rc_hangup,
1595 .tiocmget = rc_tiocmget,
1596 .tiocmset = rc_tiocmset,
1597 };
1598
1599 static inline int rc_init_drivers(void)
1600 {
1601 int error;
1602 int i;
1603
1604 riscom_driver = alloc_tty_driver(RC_NBOARD * RC_NPORT);
1605 if (!riscom_driver)
1606 return -ENOMEM;
1607
1608 memset(IRQ_to_board, 0, sizeof(IRQ_to_board));
1609 riscom_driver->owner = THIS_MODULE;
1610 riscom_driver->name = "ttyL";
1611 riscom_driver->major = RISCOM8_NORMAL_MAJOR;
1612 riscom_driver->type = TTY_DRIVER_TYPE_SERIAL;
1613 riscom_driver->subtype = SERIAL_TYPE_NORMAL;
1614 riscom_driver->init_termios = tty_std_termios;
1615 riscom_driver->init_termios.c_cflag =
1616 B9600 | CS8 | CREAD | HUPCL | CLOCAL;
1617 riscom_driver->init_termios.c_ispeed = 9600;
1618 riscom_driver->init_termios.c_ospeed = 9600;
1619 riscom_driver->flags = TTY_DRIVER_REAL_RAW;
1620 tty_set_operations(riscom_driver, &riscom_ops);
1621 if ((error = tty_register_driver(riscom_driver))) {
1622 put_tty_driver(riscom_driver);
1623 printk(KERN_ERR "rc: Couldn't register RISCom/8 driver, "
1624 "error = %d\n",
1625 error);
1626 return 1;
1627 }
1628
1629 memset(rc_port, 0, sizeof(rc_port));
1630 for (i = 0; i < RC_NPORT * RC_NBOARD; i++) {
1631 rc_port[i].magic = RISCOM8_MAGIC;
1632 INIT_WORK(&rc_port[i].tqueue, do_softint);
1633 INIT_WORK(&rc_port[i].tqueue_hangup, do_rc_hangup);
1634 rc_port[i].close_delay = 50 * HZ/100;
1635 rc_port[i].closing_wait = 3000 * HZ/100;
1636 init_waitqueue_head(&rc_port[i].open_wait);
1637 init_waitqueue_head(&rc_port[i].close_wait);
1638 }
1639
1640 return 0;
1641 }
1642
1643 static void rc_release_drivers(void)
1644 {
1645 unsigned long flags;
1646
1647 save_flags(flags);
1648 cli();
1649 tty_unregister_driver(riscom_driver);
1650 put_tty_driver(riscom_driver);
1651 restore_flags(flags);
1652 }
1653
1654 #ifndef MODULE
1655 /*
1656 * Called at boot time.
1657 *
1658 * You can specify IO base for up to RC_NBOARD cards,
1659 * using line "riscom8=0xiobase1,0xiobase2,.." at LILO prompt.
1660 * Note that there will be no probing at default
1661 * addresses in this case.
1662 *
1663 */
1664 static int __init riscom8_setup(char *str)
1665 {
1666 int ints[RC_NBOARD];
1667 int i;
1668
1669 str = get_options(str, ARRAY_SIZE(ints), ints);
1670
1671 for (i = 0; i < RC_NBOARD; i++) {
1672 if (i < ints[0])
1673 rc_board[i].base = ints[i+1];
1674 else
1675 rc_board[i].base = 0;
1676 }
1677 return 1;
1678 }
1679
1680 __setup("riscom8=", riscom8_setup);
1681 #endif
1682
1683 static char banner[] __initdata =
1684 KERN_INFO "rc: SDL RISCom/8 card driver v1.1, (c) D.Gorodchanin "
1685 "1994-1996.\n";
1686 static char no_boards_msg[] __initdata =
1687 KERN_INFO "rc: No RISCom/8 boards detected.\n";
1688
1689 /*
1690 * This routine must be called by kernel at boot time
1691 */
1692 static int __init riscom8_init(void)
1693 {
1694 int i;
1695 int found = 0;
1696
1697 printk(banner);
1698
1699 if (rc_init_drivers())
1700 return -EIO;
1701
1702 for (i = 0; i < RC_NBOARD; i++)
1703 if (rc_board[i].base && !rc_probe(&rc_board[i]))
1704 found++;
1705
1706 if (!found) {
1707 rc_release_drivers();
1708 printk(no_boards_msg);
1709 return -EIO;
1710 }
1711 return 0;
1712 }
1713
1714 #ifdef MODULE
1715 static int iobase;
1716 static int iobase1;
1717 static int iobase2;
1718 static int iobase3;
1719 module_param(iobase, int, 0);
1720 module_param(iobase1, int, 0);
1721 module_param(iobase2, int, 0);
1722 module_param(iobase3, int, 0);
1723
1724 MODULE_LICENSE("GPL");
1725 #endif /* MODULE */
1726
1727 /*
1728 * You can setup up to 4 boards (current value of RC_NBOARD)
1729 * by specifying "iobase=0xXXX iobase1=0xXXX ..." as insmod parameter.
1730 *
1731 */
1732 static int __init riscom8_init_module (void)
1733 {
1734 #ifdef MODULE
1735 int i;
1736
1737 if (iobase || iobase1 || iobase2 || iobase3) {
1738 for(i = 0; i < RC_NBOARD; i++)
1739 rc_board[0].base = 0;
1740 }
1741
1742 if (iobase)
1743 rc_board[0].base = iobase;
1744 if (iobase1)
1745 rc_board[1].base = iobase1;
1746 if (iobase2)
1747 rc_board[2].base = iobase2;
1748 if (iobase3)
1749 rc_board[3].base = iobase3;
1750 #endif /* MODULE */
1751
1752 return riscom8_init();
1753 }
1754
1755 static void __exit riscom8_exit_module (void)
1756 {
1757 int i;
1758
1759 rc_release_drivers();
1760 for (i = 0; i < RC_NBOARD; i++)
1761 if (rc_board[i].flags & RC_BOARD_PRESENT)
1762 rc_release_io_range(&rc_board[i]);
1763
1764 }
1765
1766 module_init(riscom8_init_module);
1767 module_exit(riscom8_exit_module);
1768
Linux with added FPC-III support