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