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