?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ocfs2: Make the left masklogs compat.
[taoma-kernel.git] / drivers / char / riscom8.c
blobaf4de1fe84454eca88f3921cfe786282e14fdf37
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 <linux/io.h>
37 #include <linux/kernel.h>
38 #include <linux/sched.h>
39 #include <linux/ioport.h>
40 #include <linux/interrupt.h>
41 #include <linux/errno.h>
42 #include <linux/tty.h>
43 #include <linux/mm.h>
44 #include <linux/serial.h>
45 #include <linux/fcntl.h>
46 #include <linux/major.h>
47 #include <linux/init.h>
48 #include <linux/delay.h>
49 #include <linux/tty_flip.h>
50 #include <linux/spinlock.h>
51 #include <linux/device.h>
52
53 #include <linux/uaccess.h>
54
55 #include "riscom8.h"
56 #include "riscom8_reg.h"
57
58 /* Am I paranoid or not ? ;-) */
59 #define RISCOM_PARANOIA_CHECK
60
61 /*
62 * Crazy InteliCom/8 boards sometimes have swapped CTS & DSR signals.
63 * You can slightly speed up things by #undefing the following option,
64 * if you are REALLY sure that your board is correct one.
65 */
66
67 #define RISCOM_BRAIN_DAMAGED_CTS
68
69 /*
70 * The following defines are mostly for testing purposes. But if you need
71 * some nice reporting in your syslog, you can define them also.
72 */
73 #undef RC_REPORT_FIFO
74 #undef RC_REPORT_OVERRUN
75
76
77 #define RISCOM_LEGAL_FLAGS \
78 (ASYNC_HUP_NOTIFY | ASYNC_SAK | ASYNC_SPLIT_TERMIOS | \
79 ASYNC_SPD_HI | ASYNC_SPEED_VHI | ASYNC_SESSION_LOCKOUT | \
80 ASYNC_PGRP_LOCKOUT | ASYNC_CALLOUT_NOHUP)
81
82 static struct tty_driver *riscom_driver;
83
84 static DEFINE_SPINLOCK(riscom_lock);
85
86 static struct riscom_board rc_board[RC_NBOARD] = {
87 {
88 .base = RC_IOBASE1,
89 },
90 {
91 .base = RC_IOBASE2,
92 },
93 {
94 .base = RC_IOBASE3,
95 },
96 {
97 .base = RC_IOBASE4,
98 },
99 };
100
101 static struct riscom_port rc_port[RC_NBOARD * RC_NPORT];
102
103 /* RISCom/8 I/O ports addresses (without address translation) */
104 static unsigned short rc_ioport[] = {
105 #if 1
106 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x09, 0x0a, 0x0b, 0x0c,
107 #else
108 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x09, 0x0a, 0x0b, 0x0c, 0x10,
109 0x11, 0x12, 0x18, 0x28, 0x31, 0x32, 0x39, 0x3a, 0x40, 0x41, 0x61, 0x62,
110 0x63, 0x64, 0x6b, 0x70, 0x71, 0x78, 0x7a, 0x7b, 0x7f, 0x100, 0x101
111 #endif
112 };
113 #define RC_NIOPORT ARRAY_SIZE(rc_ioport)
114
115
116 static int rc_paranoia_check(struct riscom_port const *port,
117 char *name, const char *routine)
118 {
119 #ifdef RISCOM_PARANOIA_CHECK
120 static const char badmagic[] = KERN_INFO
121 "rc: Warning: bad riscom port magic number for device %s in %s\n";
122 static const char badinfo[] = KERN_INFO
123 "rc: Warning: null riscom port for device %s in %s\n";
124
125 if (!port) {
126 printk(badinfo, name, routine);
127 return 1;
128 }
129 if (port->magic != RISCOM8_MAGIC) {
130 printk(badmagic, name, routine);
131 return 1;
132 }
133 #endif
134 return 0;
135 }
136
137 /*
138 *
139 * Service functions for RISCom/8 driver.
140 *
141 */
142
143 /* Get board number from pointer */
144 static inline int board_No(struct riscom_board const *bp)
145 {
146 return bp - rc_board;
147 }
148
149 /* Get port number from pointer */
150 static inline int port_No(struct riscom_port const *port)
151 {
152 return RC_PORT(port - rc_port);
153 }
154
155 /* Get pointer to board from pointer to port */
156 static inline struct riscom_board *port_Board(struct riscom_port const *port)
157 {
158 return &rc_board[RC_BOARD(port - rc_port)];
159 }
160
161 /* Input Byte from CL CD180 register */
162 static inline unsigned char rc_in(struct riscom_board const *bp,
163 unsigned short reg)
164 {
165 return inb(bp->base + RC_TO_ISA(reg));
166 }
167
168 /* Output Byte to CL CD180 register */
169 static inline void rc_out(struct riscom_board const *bp, unsigned short reg,
170 unsigned char val)
171 {
172 outb(val, bp->base + RC_TO_ISA(reg));
173 }
174
175 /* Wait for Channel Command Register ready */
176 static void rc_wait_CCR(struct riscom_board const *bp)
177 {
178 unsigned long delay;
179
180 /* FIXME: need something more descriptive then 100000 :) */
181 for (delay = 100000; delay; delay--)
182 if (!rc_in(bp, CD180_CCR))
183 return;
184
185 printk(KERN_INFO "rc%d: Timeout waiting for CCR.\n", board_No(bp));
186 }
187
188 /*
189 * RISCom/8 probe functions.
190 */
191
192 static int rc_request_io_range(struct riscom_board * const bp)
193 {
194 int i;
195
196 for (i = 0; i < RC_NIOPORT; i++)
197 if (!request_region(RC_TO_ISA(rc_ioport[i]) + bp->base, 1,
198 "RISCom/8")) {
199 goto out_release;
200 }
201 return 0;
202 out_release:
203 printk(KERN_INFO "rc%d: Skipping probe at 0x%03x. IO address in use.\n",
204 board_No(bp), bp->base);
205 while (--i >= 0)
206 release_region(RC_TO_ISA(rc_ioport[i]) + bp->base, 1);
207 return 1;
208 }
209
210 static void rc_release_io_range(struct riscom_board * const bp)
211 {
212 int i;
213
214 for (i = 0; i < RC_NIOPORT; i++)
215 release_region(RC_TO_ISA(rc_ioport[i]) + bp->base, 1);
216 }
217
218 /* Reset and setup CD180 chip */
219 static void __init rc_init_CD180(struct riscom_board const *bp)
220 {
221 unsigned long flags;
222
223 spin_lock_irqsave(&riscom_lock, flags);
224
225 rc_out(bp, RC_CTOUT, 0); /* Clear timeout */
226 rc_wait_CCR(bp); /* Wait for CCR ready */
227 rc_out(bp, CD180_CCR, CCR_HARDRESET); /* Reset CD180 chip */
228 spin_unlock_irqrestore(&riscom_lock, flags);
229 msleep(50); /* Delay 0.05 sec */
230 spin_lock_irqsave(&riscom_lock, flags);
231 rc_out(bp, CD180_GIVR, RC_ID); /* Set ID for this chip */
232 rc_out(bp, CD180_GICR, 0); /* Clear all bits */
233 rc_out(bp, CD180_PILR1, RC_ACK_MINT); /* Prio for modem intr */
234 rc_out(bp, CD180_PILR2, RC_ACK_TINT); /* Prio for tx intr */
235 rc_out(bp, CD180_PILR3, RC_ACK_RINT); /* Prio for rx intr */
236
237 /* Setting up prescaler. We need 4 ticks per 1 ms */
238 rc_out(bp, CD180_PPRH, (RC_OSCFREQ/(1000000/RISCOM_TPS)) >> 8);
239 rc_out(bp, CD180_PPRL, (RC_OSCFREQ/(1000000/RISCOM_TPS)) & 0xff);
240
241 spin_unlock_irqrestore(&riscom_lock, flags);
242 }
243
244 /* Main probing routine, also sets irq. */
245 static int __init rc_probe(struct riscom_board *bp)
246 {
247 unsigned char val1, val2;
248 int irqs = 0;
249 int retries;
250
251 bp->irq = 0;
252
253 if (rc_request_io_range(bp))
254 return 1;
255
256 /* Are the I/O ports here ? */
257 rc_out(bp, CD180_PPRL, 0x5a);
258 outb(0xff, 0x80);
259 val1 = rc_in(bp, CD180_PPRL);
260 rc_out(bp, CD180_PPRL, 0xa5);
261 outb(0x00, 0x80);
262 val2 = rc_in(bp, CD180_PPRL);
263
264 if ((val1 != 0x5a) || (val2 != 0xa5)) {
265 printk(KERN_ERR "rc%d: RISCom/8 Board at 0x%03x not found.\n",
266 board_No(bp), bp->base);
267 goto out_release;
268 }
269
270 /* It's time to find IRQ for this board */
271 for (retries = 0; retries < 5 && irqs <= 0; retries++) {
272 irqs = probe_irq_on();
273 rc_init_CD180(bp); /* Reset CD180 chip */
274 rc_out(bp, CD180_CAR, 2); /* Select port 2 */
275 rc_wait_CCR(bp);
276 rc_out(bp, CD180_CCR, CCR_TXEN); /* Enable transmitter */
277 rc_out(bp, CD180_IER, IER_TXRDY);/* Enable tx empty intr */
278 msleep(50);
279 irqs = probe_irq_off(irqs);
280 val1 = rc_in(bp, RC_BSR); /* Get Board Status reg */
281 val2 = rc_in(bp, RC_ACK_TINT); /* ACK interrupt */
282 rc_init_CD180(bp); /* Reset CD180 again */
283
284 if ((val1 & RC_BSR_TINT) || (val2 != (RC_ID | GIVR_IT_TX))) {
285 printk(KERN_ERR "rc%d: RISCom/8 Board at 0x%03x not "
286 "found.\n", board_No(bp), bp->base);
287 goto out_release;
288 }
289 }
290
291 if (irqs <= 0) {
292 printk(KERN_ERR "rc%d: Can't find IRQ for RISCom/8 board "
293 "at 0x%03x.\n", board_No(bp), bp->base);
294 goto out_release;
295 }
296 bp->irq = irqs;
297 bp->flags |= RC_BOARD_PRESENT;
298
299 printk(KERN_INFO "rc%d: RISCom/8 Rev. %c board detected at "
300 "0x%03x, IRQ %d.\n",
301 board_No(bp),
302 (rc_in(bp, CD180_GFRCR) & 0x0f) + 'A', /* Board revision */
303 bp->base, bp->irq);
304
305 return 0;
306 out_release:
307 rc_release_io_range(bp);
308 return 1;
309 }
310
311 /*
312 *
313 * Interrupt processing routines.
314 *
315 */
316
317 static struct riscom_port *rc_get_port(struct riscom_board const *bp,
318 unsigned char const *what)
319 {
320 unsigned char channel;
321 struct riscom_port *port;
322
323 channel = rc_in(bp, CD180_GICR) >> GICR_CHAN_OFF;
324 if (channel < CD180_NCH) {
325 port = &rc_port[board_No(bp) * RC_NPORT + channel];
326 if (port->port.flags & ASYNC_INITIALIZED)
327 return port;
328 }
329 printk(KERN_ERR "rc%d: %s interrupt from invalid port %d\n",
330 board_No(bp), what, channel);
331 return NULL;
332 }
333
334 static void rc_receive_exc(struct riscom_board const *bp)
335 {
336 struct riscom_port *port;
337 struct tty_struct *tty;
338 unsigned char status;
339 unsigned char ch, flag;
340
341 port = rc_get_port(bp, "Receive");
342 if (port == NULL)
343 return;
344
345 tty = tty_port_tty_get(&port->port);
346
347 #ifdef RC_REPORT_OVERRUN
348 status = rc_in(bp, CD180_RCSR);
349 if (status & RCSR_OE)
350 port->overrun++;
351 status &= port->mark_mask;
352 #else
353 status = rc_in(bp, CD180_RCSR) & port->mark_mask;
354 #endif
355 ch = rc_in(bp, CD180_RDR);
356 if (!status)
357 goto out;
358 if (status & RCSR_TOUT) {
359 printk(KERN_WARNING "rc%d: port %d: Receiver timeout. "
360 "Hardware problems ?\n",
361 board_No(bp), port_No(port));
362 goto out;
363
364 } else if (status & RCSR_BREAK) {
365 printk(KERN_INFO "rc%d: port %d: Handling break...\n",
366 board_No(bp), port_No(port));
367 flag = TTY_BREAK;
368 if (tty && (port->port.flags & ASYNC_SAK))
369 do_SAK(tty);
370
371 } else if (status & RCSR_PE)
372 flag = TTY_PARITY;
373
374 else if (status & RCSR_FE)
375 flag = TTY_FRAME;
376
377 else if (status & RCSR_OE)
378 flag = TTY_OVERRUN;
379 else
380 flag = TTY_NORMAL;
381
382 if (tty) {
383 tty_insert_flip_char(tty, ch, flag);
384 tty_flip_buffer_push(tty);
385 }
386 out:
387 tty_kref_put(tty);
388 }
389
390 static 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 port = rc_get_port(bp, "Receive");
397 if (port == NULL)
398 return;
399
400 tty = tty_port_tty_get(&port->port);
401
402 count = rc_in(bp, CD180_RDCR);
403
404 #ifdef RC_REPORT_FIFO
405 port->hits[count > 8 ? 9 : count]++;
406 #endif
407
408 while (count--) {
409 u8 ch = rc_in(bp, CD180_RDR);
410 if (tty)
411 tty_insert_flip_char(tty, ch, TTY_NORMAL);
412 }
413 if (tty) {
414 tty_flip_buffer_push(tty);
415 tty_kref_put(tty);
416 }
417 }
418
419 static 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 port = rc_get_port(bp, "Transmit");
426 if (port == NULL)
427 return;
428
429 tty = tty_port_tty_get(&port->port);
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 goto out;
437 }
438
439 if ((port->xmit_cnt <= 0 && !port->break_length)
440 || (tty && (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 goto out;
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 port->break_length -= count;
459 if (port->break_length == 0)
460 port->break_length--;
461 } else {
462 rc_out(bp, CD180_TDR, CD180_C_ESC);
463 rc_out(bp, CD180_TDR, CD180_C_EBRK);
464 rc_out(bp, CD180_COR2, port->COR2);
465 rc_wait_CCR(bp);
466 rc_out(bp, CD180_CCR, CCR_CORCHG2);
467 port->break_length = 0;
468 }
469 goto out;
470 }
471
472 count = CD180_NFIFO;
473 do {
474 rc_out(bp, CD180_TDR, port->port.xmit_buf[port->xmit_tail++]);
475 port->xmit_tail = port->xmit_tail & (SERIAL_XMIT_SIZE-1);
476 if (--port->xmit_cnt <= 0)
477 break;
478 } while (--count > 0);
479
480 if (port->xmit_cnt <= 0) {
481 rc_out(bp, CD180_CAR, port_No(port));
482 port->IER &= ~IER_TXRDY;
483 rc_out(bp, CD180_IER, port->IER);
484 }
485 if (tty && port->xmit_cnt <= port->wakeup_chars)
486 tty_wakeup(tty);
487 out:
488 tty_kref_put(tty);
489 }
490
491 static void rc_check_modem(struct riscom_board const *bp)
492 {
493 struct riscom_port *port;
494 struct tty_struct *tty;
495 unsigned char mcr;
496
497 port = rc_get_port(bp, "Modem");
498 if (port == NULL)
499 return;
500
501 tty = tty_port_tty_get(&port->port);
502
503 mcr = rc_in(bp, CD180_MCR);
504 if (mcr & MCR_CDCHG) {
505 if (rc_in(bp, CD180_MSVR) & MSVR_CD)
506 wake_up_interruptible(&port->port.open_wait);
507 else if (tty)
508 tty_hangup(tty);
509 }
510
511 #ifdef RISCOM_BRAIN_DAMAGED_CTS
512 if (mcr & MCR_CTSCHG) {
513 if (rc_in(bp, CD180_MSVR) & MSVR_CTS) {
514 port->IER |= IER_TXRDY;
515 if (tty) {
516 tty->hw_stopped = 0;
517 if (port->xmit_cnt <= port->wakeup_chars)
518 tty_wakeup(tty);
519 }
520 } else {
521 if (tty)
522 tty->hw_stopped = 1;
523 port->IER &= ~IER_TXRDY;
524 }
525 rc_out(bp, CD180_IER, port->IER);
526 }
527 if (mcr & MCR_DSRCHG) {
528 if (rc_in(bp, CD180_MSVR) & MSVR_DSR) {
529 port->IER |= IER_TXRDY;
530 if (tty) {
531 tty->hw_stopped = 0;
532 if (port->xmit_cnt <= port->wakeup_chars)
533 tty_wakeup(tty);
534 }
535 } else {
536 if (tty)
537 tty->hw_stopped = 1;
538 port->IER &= ~IER_TXRDY;
539 }
540 rc_out(bp, CD180_IER, port->IER);
541 }
542 #endif /* RISCOM_BRAIN_DAMAGED_CTS */
543
544 /* Clear change bits */
545 rc_out(bp, CD180_MCR, 0);
546 tty_kref_put(tty);
547 }
548
549 /* The main interrupt processing routine */
550 static irqreturn_t rc_interrupt(int dummy, void *dev_id)
551 {
552 unsigned char status;
553 unsigned char ack;
554 struct riscom_board *bp = dev_id;
555 unsigned long loop = 0;
556 int handled = 0;
557
558 if (!(bp->flags & RC_BOARD_ACTIVE))
559 return IRQ_NONE;
560
561 while ((++loop < 16) && ((status = ~(rc_in(bp, RC_BSR))) &
562 (RC_BSR_TOUT | RC_BSR_TINT |
563 RC_BSR_MINT | RC_BSR_RINT))) {
564 handled = 1;
565 if (status & RC_BSR_TOUT)
566 printk(KERN_WARNING "rc%d: Got timeout. Hardware "
567 "error?\n", board_No(bp));
568 else if (status & RC_BSR_RINT) {
569 ack = rc_in(bp, RC_ACK_RINT);
570 if (ack == (RC_ID | GIVR_IT_RCV))
571 rc_receive(bp);
572 else if (ack == (RC_ID | GIVR_IT_REXC))
573 rc_receive_exc(bp);
574 else
575 printk(KERN_WARNING "rc%d: Bad receive ack "
576 "0x%02x.\n",
577 board_No(bp), ack);
578 } else if (status & RC_BSR_TINT) {
579 ack = rc_in(bp, RC_ACK_TINT);
580 if (ack == (RC_ID | GIVR_IT_TX))
581 rc_transmit(bp);
582 else
583 printk(KERN_WARNING "rc%d: Bad transmit ack "
584 "0x%02x.\n",
585 board_No(bp), ack);
586 } else /* if (status & RC_BSR_MINT) */ {
587 ack = rc_in(bp, RC_ACK_MINT);
588 if (ack == (RC_ID | GIVR_IT_MODEM))
589 rc_check_modem(bp);
590 else
591 printk(KERN_WARNING "rc%d: Bad modem ack "
592 "0x%02x.\n",
593 board_No(bp), ack);
594 }
595 rc_out(bp, CD180_EOIR, 0); /* Mark end of interrupt */
596 rc_out(bp, RC_CTOUT, 0); /* Clear timeout flag */
597 }
598 return IRQ_RETVAL(handled);
599 }
600
601 /*
602 * Routines for open & close processing.
603 */
604
605 /* Called with disabled interrupts */
606 static int rc_setup_board(struct riscom_board *bp)
607 {
608 int error;
609
610 if (bp->flags & RC_BOARD_ACTIVE)
611 return 0;
612
613 error = request_irq(bp->irq, rc_interrupt, IRQF_DISABLED,
614 "RISCom/8", bp);
615 if (error)
616 return error;
617
618 rc_out(bp, RC_CTOUT, 0); /* Just in case */
619 bp->DTR = ~0;
620 rc_out(bp, RC_DTR, bp->DTR); /* Drop DTR on all ports */
621
622 bp->flags |= RC_BOARD_ACTIVE;
623
624 return 0;
625 }
626
627 /* Called with disabled interrupts */
628 static void rc_shutdown_board(struct riscom_board *bp)
629 {
630 if (!(bp->flags & RC_BOARD_ACTIVE))
631 return;
632
633 bp->flags &= ~RC_BOARD_ACTIVE;
634
635 free_irq(bp->irq, NULL);
636
637 bp->DTR = ~0;
638 rc_out(bp, RC_DTR, bp->DTR); /* Drop DTR on all ports */
639
640 }
641
642 /*
643 * Setting up port characteristics.
644 * Must be called with disabled interrupts
645 */
646 static void rc_change_speed(struct tty_struct *tty, struct riscom_board *bp,
647 struct riscom_port *port)
648 {
649 unsigned long baud;
650 long tmp;
651 unsigned char cor1 = 0, cor3 = 0;
652 unsigned char mcor1 = 0, mcor2 = 0;
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 if (C_CSTOPB(tty))
714 cor1 |= COR1_2SB;
715
716 cor1 |= COR1_IGNORE;
717 if (C_PARENB(tty)) {
718 cor1 |= COR1_NORMPAR;
719 if (C_PARODD(tty))
720 cor1 |= COR1_ODDP;
721 if (I_INPCK(tty))
722 cor1 &= ~COR1_IGNORE;
723 }
724 /* Set marking of some errors */
725 port->mark_mask = RCSR_OE | RCSR_TOUT;
726 if (I_INPCK(tty))
727 port->mark_mask |= RCSR_FE | RCSR_PE;
728 if (I_BRKINT(tty) || I_PARMRK(tty))
729 port->mark_mask |= RCSR_BREAK;
730 if (I_IGNPAR(tty))
731 port->mark_mask &= ~(RCSR_FE | RCSR_PE);
732 if (I_IGNBRK(tty)) {
733 port->mark_mask &= ~RCSR_BREAK;
734 if (I_IGNPAR(tty))
735 /* Real raw mode. Ignore all */
736 port->mark_mask &= ~RCSR_OE;
737 }
738 /* Enable Hardware Flow Control */
739 if (C_CRTSCTS(tty)) {
740 #ifdef RISCOM_BRAIN_DAMAGED_CTS
741 port->IER |= IER_DSR | IER_CTS;
742 mcor1 |= MCOR1_DSRZD | MCOR1_CTSZD;
743 mcor2 |= MCOR2_DSROD | MCOR2_CTSOD;
744 tty->hw_stopped = !(rc_in(bp, CD180_MSVR) &
745 (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_activate_port(struct tty_port *port, struct tty_struct *tty)
796 {
797 struct riscom_port *rp = container_of(port, struct riscom_port, port);
798 struct riscom_board *bp = port_Board(rp);
799 unsigned long flags;
800
801 if (tty_port_alloc_xmit_buf(port) < 0)
802 return -ENOMEM;
803
804 spin_lock_irqsave(&riscom_lock, flags);
805
806 clear_bit(TTY_IO_ERROR, &tty->flags);
807 bp->count++;
808 rp->xmit_cnt = rp->xmit_head = rp->xmit_tail = 0;
809 rc_change_speed(tty, bp, rp);
810 spin_unlock_irqrestore(&riscom_lock, flags);
811 return 0;
812 }
813
814 /* Must be called with interrupts disabled */
815 static void rc_shutdown_port(struct tty_struct *tty,
816 struct riscom_board *bp, struct riscom_port *port)
817 {
818 #ifdef RC_REPORT_OVERRUN
819 printk(KERN_INFO "rc%d: port %d: Total %ld overruns were detected.\n",
820 board_No(bp), port_No(port), port->overrun);
821 #endif
822 #ifdef RC_REPORT_FIFO
823 {
824 int i;
825
826 printk(KERN_INFO "rc%d: port %d: FIFO hits [ ",
827 board_No(bp), port_No(port));
828 for (i = 0; i < 10; i++)
829 printk("%ld ", port->hits[i]);
830 printk("].\n");
831 }
832 #endif
833 tty_port_free_xmit_buf(&port->port);
834
835 /* Select port */
836 rc_out(bp, CD180_CAR, port_No(port));
837 /* Reset port */
838 rc_wait_CCR(bp);
839 rc_out(bp, CD180_CCR, CCR_SOFTRESET);
840 /* Disable all interrupts from this port */
841 port->IER = 0;
842 rc_out(bp, CD180_IER, port->IER);
843
844 set_bit(TTY_IO_ERROR, &tty->flags);
845
846 if (--bp->count < 0) {
847 printk(KERN_INFO "rc%d: rc_shutdown_port: "
848 "bad board count: %d\n",
849 board_No(bp), bp->count);
850 bp->count = 0;
851 }
852 /*
853 * If this is the last opened port on the board
854 * shutdown whole board
855 */
856 if (!bp->count)
857 rc_shutdown_board(bp);
858 }
859
860 static int carrier_raised(struct tty_port *port)
861 {
862 struct riscom_port *p = container_of(port, struct riscom_port, port);
863 struct riscom_board *bp = port_Board(p);
864 unsigned long flags;
865 int CD;
866
867 spin_lock_irqsave(&riscom_lock, flags);
868 rc_out(bp, CD180_CAR, port_No(p));
869 CD = rc_in(bp, CD180_MSVR) & MSVR_CD;
870 rc_out(bp, CD180_MSVR, MSVR_RTS);
871 bp->DTR &= ~(1u << port_No(p));
872 rc_out(bp, RC_DTR, bp->DTR);
873 spin_unlock_irqrestore(&riscom_lock, flags);
874 return CD;
875 }
876
877 static void dtr_rts(struct tty_port *port, int onoff)
878 {
879 struct riscom_port *p = container_of(port, struct riscom_port, port);
880 struct riscom_board *bp = port_Board(p);
881 unsigned long flags;
882
883 spin_lock_irqsave(&riscom_lock, flags);
884 bp->DTR &= ~(1u << port_No(p));
885 if (onoff == 0)
886 bp->DTR |= (1u << port_No(p));
887 rc_out(bp, RC_DTR, bp->DTR);
888 spin_unlock_irqrestore(&riscom_lock, flags);
889 }
890
891 static int rc_open(struct tty_struct *tty, struct file *filp)
892 {
893 int board;
894 int error;
895 struct riscom_port *port;
896 struct riscom_board *bp;
897
898 board = RC_BOARD(tty->index);
899 if (board >= RC_NBOARD || !(rc_board[board].flags & RC_BOARD_PRESENT))
900 return -ENODEV;
901
902 bp = &rc_board[board];
903 port = rc_port + board * RC_NPORT + RC_PORT(tty->index);
904 if (rc_paranoia_check(port, tty->name, "rc_open"))
905 return -ENODEV;
906
907 error = rc_setup_board(bp);
908 if (error)
909 return error;
910
911 tty->driver_data = port;
912 return tty_port_open(&port->port, tty, filp);
913 }
914
915 static void rc_flush_buffer(struct tty_struct *tty)
916 {
917 struct riscom_port *port = tty->driver_data;
918 unsigned long flags;
919
920 if (rc_paranoia_check(port, tty->name, "rc_flush_buffer"))
921 return;
922
923 spin_lock_irqsave(&riscom_lock, flags);
924 port->xmit_cnt = port->xmit_head = port->xmit_tail = 0;
925 spin_unlock_irqrestore(&riscom_lock, flags);
926
927 tty_wakeup(tty);
928 }
929
930 static void rc_close_port(struct tty_port *port)
931 {
932 unsigned long flags;
933 struct riscom_port *rp = container_of(port, struct riscom_port, port);
934 struct riscom_board *bp = port_Board(rp);
935 unsigned long timeout;
936
937 /*
938 * At this point we stop accepting input. To do this, we
939 * disable the receive line status interrupts, and tell the
940 * interrupt driver to stop checking the data ready bit in the
941 * line status register.
942 */
943
944 spin_lock_irqsave(&riscom_lock, flags);
945 rp->IER &= ~IER_RXD;
946
947 rp->IER &= ~IER_TXRDY;
948 rp->IER |= IER_TXEMPTY;
949 rc_out(bp, CD180_CAR, port_No(rp));
950 rc_out(bp, CD180_IER, rp->IER);
951 /*
952 * Before we drop DTR, make sure the UART transmitter
953 * has completely drained; this is especially
954 * important if there is a transmit FIFO!
955 */
956 timeout = jiffies + HZ;
957 while (rp->IER & IER_TXEMPTY) {
958 spin_unlock_irqrestore(&riscom_lock, flags);
959 msleep_interruptible(jiffies_to_msecs(rp->timeout));
960 spin_lock_irqsave(&riscom_lock, flags);
961 if (time_after(jiffies, timeout))
962 break;
963 }
964 rc_shutdown_port(port->tty, bp, rp);
965 spin_unlock_irqrestore(&riscom_lock, flags);
966 }
967
968 static void rc_close(struct tty_struct *tty, struct file *filp)
969 {
970 struct riscom_port *port = tty->driver_data;
971
972 if (!port || rc_paranoia_check(port, tty->name, "close"))
973 return;
974 tty_port_close(&port->port, tty, filp);
975 }
976
977 static int rc_write(struct tty_struct *tty,
978 const unsigned char *buf, int count)
979 {
980 struct riscom_port *port = tty->driver_data;
981 struct riscom_board *bp;
982 int c, total = 0;
983 unsigned long flags;
984
985 if (rc_paranoia_check(port, tty->name, "rc_write"))
986 return 0;
987
988 bp = port_Board(port);
989
990 while (1) {
991 spin_lock_irqsave(&riscom_lock, flags);
992
993 c = min_t(int, count, min(SERIAL_XMIT_SIZE - port->xmit_cnt - 1,
994 SERIAL_XMIT_SIZE - port->xmit_head));
995 if (c <= 0)
996 break; /* lock continues to be held */
997
998 memcpy(port->port.xmit_buf + port->xmit_head, buf, c);
999 port->xmit_head = (port->xmit_head + c) & (SERIAL_XMIT_SIZE-1);
1000 port->xmit_cnt += c;
1001
1002 spin_unlock_irqrestore(&riscom_lock, flags);
1003
1004 buf += c;
1005 count -= c;
1006 total += c;
1007 }
1008
1009 if (port->xmit_cnt && !tty->stopped && !tty->hw_stopped &&
1010 !(port->IER & IER_TXRDY)) {
1011 port->IER |= IER_TXRDY;
1012 rc_out(bp, CD180_CAR, port_No(port));
1013 rc_out(bp, CD180_IER, port->IER);
1014 }
1015
1016 spin_unlock_irqrestore(&riscom_lock, flags);
1017
1018 return total;
1019 }
1020
1021 static int rc_put_char(struct tty_struct *tty, unsigned char ch)
1022 {
1023 struct riscom_port *port = tty->driver_data;
1024 unsigned long flags;
1025 int ret = 0;
1026
1027 if (rc_paranoia_check(port, tty->name, "rc_put_char"))
1028 return 0;
1029
1030 spin_lock_irqsave(&riscom_lock, flags);
1031
1032 if (port->xmit_cnt >= SERIAL_XMIT_SIZE - 1)
1033 goto out;
1034
1035 port->port.xmit_buf[port->xmit_head++] = ch;
1036 port->xmit_head &= SERIAL_XMIT_SIZE - 1;
1037 port->xmit_cnt++;
1038 ret = 1;
1039
1040 out:
1041 spin_unlock_irqrestore(&riscom_lock, flags);
1042 return ret;
1043 }
1044
1045 static void rc_flush_chars(struct tty_struct *tty)
1046 {
1047 struct riscom_port *port = tty->driver_data;
1048 unsigned long flags;
1049
1050 if (rc_paranoia_check(port, tty->name, "rc_flush_chars"))
1051 return;
1052
1053 if (port->xmit_cnt <= 0 || tty->stopped || tty->hw_stopped)
1054 return;
1055
1056 spin_lock_irqsave(&riscom_lock, flags);
1057
1058 port->IER |= IER_TXRDY;
1059 rc_out(port_Board(port), CD180_CAR, port_No(port));
1060 rc_out(port_Board(port), CD180_IER, port->IER);
1061
1062 spin_unlock_irqrestore(&riscom_lock, flags);
1063 }
1064
1065 static int rc_write_room(struct tty_struct *tty)
1066 {
1067 struct riscom_port *port = tty->driver_data;
1068 int ret;
1069
1070 if (rc_paranoia_check(port, tty->name, "rc_write_room"))
1071 return 0;
1072
1073 ret = SERIAL_XMIT_SIZE - port->xmit_cnt - 1;
1074 if (ret < 0)
1075 ret = 0;
1076 return ret;
1077 }
1078
1079 static int rc_chars_in_buffer(struct tty_struct *tty)
1080 {
1081 struct riscom_port *port = tty->driver_data;
1082
1083 if (rc_paranoia_check(port, tty->name, "rc_chars_in_buffer"))
1084 return 0;
1085
1086 return port->xmit_cnt;
1087 }
1088
1089 static int rc_tiocmget(struct tty_struct *tty, struct file *file)
1090 {
1091 struct riscom_port *port = tty->driver_data;
1092 struct riscom_board *bp;
1093 unsigned char status;
1094 unsigned int result;
1095 unsigned long flags;
1096
1097 if (rc_paranoia_check(port, tty->name, __func__))
1098 return -ENODEV;
1099
1100 bp = port_Board(port);
1101
1102 spin_lock_irqsave(&riscom_lock, flags);
1103
1104 rc_out(bp, CD180_CAR, port_No(port));
1105 status = rc_in(bp, CD180_MSVR);
1106 result = rc_in(bp, RC_RI) & (1u << port_No(port)) ? 0 : TIOCM_RNG;
1107
1108 spin_unlock_irqrestore(&riscom_lock, flags);
1109
1110 result |= ((status & MSVR_RTS) ? TIOCM_RTS : 0)
1111 | ((status & MSVR_DTR) ? TIOCM_DTR : 0)
1112 | ((status & MSVR_CD) ? TIOCM_CAR : 0)
1113 | ((status & MSVR_DSR) ? TIOCM_DSR : 0)
1114 | ((status & MSVR_CTS) ? TIOCM_CTS : 0);
1115 return result;
1116 }
1117
1118 static int rc_tiocmset(struct tty_struct *tty, struct file *file,
1119 unsigned int set, unsigned int clear)
1120 {
1121 struct riscom_port *port = tty->driver_data;
1122 unsigned long flags;
1123 struct riscom_board *bp;
1124
1125 if (rc_paranoia_check(port, tty->name, __func__))
1126 return -ENODEV;
1127
1128 bp = port_Board(port);
1129
1130 spin_lock_irqsave(&riscom_lock, flags);
1131
1132 if (set & TIOCM_RTS)
1133 port->MSVR |= MSVR_RTS;
1134 if (set & TIOCM_DTR)
1135 bp->DTR &= ~(1u << port_No(port));
1136
1137 if (clear & TIOCM_RTS)
1138 port->MSVR &= ~MSVR_RTS;
1139 if (clear & TIOCM_DTR)
1140 bp->DTR |= (1u << port_No(port));
1141
1142 rc_out(bp, CD180_CAR, port_No(port));
1143 rc_out(bp, CD180_MSVR, port->MSVR);
1144 rc_out(bp, RC_DTR, bp->DTR);
1145
1146 spin_unlock_irqrestore(&riscom_lock, flags);
1147
1148 return 0;
1149 }
1150
1151 static int rc_send_break(struct tty_struct *tty, int length)
1152 {
1153 struct riscom_port *port = tty->driver_data;
1154 struct riscom_board *bp = port_Board(port);
1155 unsigned long flags;
1156
1157 if (length == 0 || length == -1)
1158 return -EOPNOTSUPP;
1159
1160 spin_lock_irqsave(&riscom_lock, flags);
1161
1162 port->break_length = RISCOM_TPS / HZ * length;
1163 port->COR2 |= COR2_ETC;
1164 port->IER |= IER_TXRDY;
1165 rc_out(bp, CD180_CAR, port_No(port));
1166 rc_out(bp, CD180_COR2, port->COR2);
1167 rc_out(bp, CD180_IER, port->IER);
1168 rc_wait_CCR(bp);
1169 rc_out(bp, CD180_CCR, CCR_CORCHG2);
1170 rc_wait_CCR(bp);
1171
1172 spin_unlock_irqrestore(&riscom_lock, flags);
1173 return 0;
1174 }
1175
1176 static int rc_set_serial_info(struct tty_struct *tty, struct riscom_port *port,
1177 struct serial_struct __user *newinfo)
1178 {
1179 struct serial_struct tmp;
1180 struct riscom_board *bp = port_Board(port);
1181 int change_speed;
1182
1183 if (copy_from_user(&tmp, newinfo, sizeof(tmp)))
1184 return -EFAULT;
1185
1186 mutex_lock(&port->port.mutex);
1187 change_speed = ((port->port.flags & ASYNC_SPD_MASK) !=
1188 (tmp.flags & ASYNC_SPD_MASK));
1189
1190 if (!capable(CAP_SYS_ADMIN)) {
1191 if ((tmp.close_delay != port->port.close_delay) ||
1192 (tmp.closing_wait != port->port.closing_wait) ||
1193 ((tmp.flags & ~ASYNC_USR_MASK) !=
1194 (port->port.flags & ~ASYNC_USR_MASK))) {
1195 mutex_unlock(&port->port.mutex);
1196 return -EPERM;
1197 }
1198 port->port.flags = ((port->port.flags & ~ASYNC_USR_MASK) |
1199 (tmp.flags & ASYNC_USR_MASK));
1200 } else {
1201 port->port.flags = ((port->port.flags & ~ASYNC_FLAGS) |
1202 (tmp.flags & ASYNC_FLAGS));
1203 port->port.close_delay = tmp.close_delay;
1204 port->port.closing_wait = tmp.closing_wait;
1205 }
1206 if (change_speed) {
1207 unsigned long flags;
1208
1209 spin_lock_irqsave(&riscom_lock, flags);
1210 rc_change_speed(tty, bp, port);
1211 spin_unlock_irqrestore(&riscom_lock, flags);
1212 }
1213 mutex_unlock(&port->port.mutex);
1214 return 0;
1215 }
1216
1217 static int rc_get_serial_info(struct riscom_port *port,
1218 struct serial_struct __user *retinfo)
1219 {
1220 struct serial_struct tmp;
1221 struct riscom_board *bp = port_Board(port);
1222
1223 memset(&tmp, 0, sizeof(tmp));
1224 tmp.type = PORT_CIRRUS;
1225 tmp.line = port - rc_port;
1226
1227 mutex_lock(&port->port.mutex);
1228 tmp.port = bp->base;
1229 tmp.irq = bp->irq;
1230 tmp.flags = port->port.flags;
1231 tmp.baud_base = (RC_OSCFREQ + CD180_TPC/2) / CD180_TPC;
1232 tmp.close_delay = port->port.close_delay * HZ/100;
1233 tmp.closing_wait = port->port.closing_wait * HZ/100;
1234 mutex_unlock(&port->port.mutex);
1235 tmp.xmit_fifo_size = CD180_NFIFO;
1236 return copy_to_user(retinfo, &tmp, sizeof(tmp)) ? -EFAULT : 0;
1237 }
1238
1239 static int rc_ioctl(struct tty_struct *tty, struct file *filp,
1240 unsigned int cmd, unsigned long arg)
1241 {
1242 struct riscom_port *port = tty->driver_data;
1243 void __user *argp = (void __user *)arg;
1244 int retval;
1245
1246 if (rc_paranoia_check(port, tty->name, "rc_ioctl"))
1247 return -ENODEV;
1248
1249 switch (cmd) {
1250 case TIOCGSERIAL:
1251 retval = rc_get_serial_info(port, argp);
1252 break;
1253 case TIOCSSERIAL:
1254 retval = rc_set_serial_info(tty, port, argp);
1255 break;
1256 default:
1257 retval = -ENOIOCTLCMD;
1258 }
1259 return retval;
1260 }
1261
1262 static void rc_throttle(struct tty_struct *tty)
1263 {
1264 struct riscom_port *port = tty->driver_data;
1265 struct riscom_board *bp;
1266 unsigned long flags;
1267
1268 if (rc_paranoia_check(port, tty->name, "rc_throttle"))
1269 return;
1270 bp = port_Board(port);
1271
1272 spin_lock_irqsave(&riscom_lock, flags);
1273 port->MSVR &= ~MSVR_RTS;
1274 rc_out(bp, CD180_CAR, port_No(port));
1275 if (I_IXOFF(tty)) {
1276 rc_wait_CCR(bp);
1277 rc_out(bp, CD180_CCR, CCR_SSCH2);
1278 rc_wait_CCR(bp);
1279 }
1280 rc_out(bp, CD180_MSVR, port->MSVR);
1281 spin_unlock_irqrestore(&riscom_lock, flags);
1282 }
1283
1284 static void rc_unthrottle(struct tty_struct *tty)
1285 {
1286 struct riscom_port *port = tty->driver_data;
1287 struct riscom_board *bp;
1288 unsigned long flags;
1289
1290 if (rc_paranoia_check(port, tty->name, "rc_unthrottle"))
1291 return;
1292 bp = port_Board(port);
1293
1294 spin_lock_irqsave(&riscom_lock, flags);
1295 port->MSVR |= MSVR_RTS;
1296 rc_out(bp, CD180_CAR, port_No(port));
1297 if (I_IXOFF(tty)) {
1298 rc_wait_CCR(bp);
1299 rc_out(bp, CD180_CCR, CCR_SSCH1);
1300 rc_wait_CCR(bp);
1301 }
1302 rc_out(bp, CD180_MSVR, port->MSVR);
1303 spin_unlock_irqrestore(&riscom_lock, flags);
1304 }
1305
1306 static void rc_stop(struct tty_struct *tty)
1307 {
1308 struct riscom_port *port = tty->driver_data;
1309 struct riscom_board *bp;
1310 unsigned long flags;
1311
1312 if (rc_paranoia_check(port, tty->name, "rc_stop"))
1313 return;
1314
1315 bp = port_Board(port);
1316
1317 spin_lock_irqsave(&riscom_lock, flags);
1318 port->IER &= ~IER_TXRDY;
1319 rc_out(bp, CD180_CAR, port_No(port));
1320 rc_out(bp, CD180_IER, port->IER);
1321 spin_unlock_irqrestore(&riscom_lock, flags);
1322 }
1323
1324 static void rc_start(struct tty_struct *tty)
1325 {
1326 struct riscom_port *port = tty->driver_data;
1327 struct riscom_board *bp;
1328 unsigned long flags;
1329
1330 if (rc_paranoia_check(port, tty->name, "rc_start"))
1331 return;
1332
1333 bp = port_Board(port);
1334
1335 spin_lock_irqsave(&riscom_lock, flags);
1336
1337 if (port->xmit_cnt && port->port.xmit_buf && !(port->IER & IER_TXRDY)) {
1338 port->IER |= IER_TXRDY;
1339 rc_out(bp, CD180_CAR, port_No(port));
1340 rc_out(bp, CD180_IER, port->IER);
1341 }
1342 spin_unlock_irqrestore(&riscom_lock, flags);
1343 }
1344
1345 static void rc_hangup(struct tty_struct *tty)
1346 {
1347 struct riscom_port *port = tty->driver_data;
1348
1349 if (rc_paranoia_check(port, tty->name, "rc_hangup"))
1350 return;
1351
1352 tty_port_hangup(&port->port);
1353 }
1354
1355 static void rc_set_termios(struct tty_struct *tty,
1356 struct ktermios *old_termios)
1357 {
1358 struct riscom_port *port = tty->driver_data;
1359 unsigned long flags;
1360
1361 if (rc_paranoia_check(port, tty->name, "rc_set_termios"))
1362 return;
1363
1364 spin_lock_irqsave(&riscom_lock, flags);
1365 rc_change_speed(tty, port_Board(port), port);
1366 spin_unlock_irqrestore(&riscom_lock, flags);
1367
1368 if ((old_termios->c_cflag & CRTSCTS) &&
1369 !(tty->termios->c_cflag & CRTSCTS)) {
1370 tty->hw_stopped = 0;
1371 rc_start(tty);
1372 }
1373 }
1374
1375 static const struct tty_operations riscom_ops = {
1376 .open = rc_open,
1377 .close = rc_close,
1378 .write = rc_write,
1379 .put_char = rc_put_char,
1380 .flush_chars = rc_flush_chars,
1381 .write_room = rc_write_room,
1382 .chars_in_buffer = rc_chars_in_buffer,
1383 .flush_buffer = rc_flush_buffer,
1384 .ioctl = rc_ioctl,
1385 .throttle = rc_throttle,
1386 .unthrottle = rc_unthrottle,
1387 .set_termios = rc_set_termios,
1388 .stop = rc_stop,
1389 .start = rc_start,
1390 .hangup = rc_hangup,
1391 .tiocmget = rc_tiocmget,
1392 .tiocmset = rc_tiocmset,
1393 .break_ctl = rc_send_break,
1394 };
1395
1396 static const struct tty_port_operations riscom_port_ops = {
1397 .carrier_raised = carrier_raised,
1398 .dtr_rts = dtr_rts,
1399 .shutdown = rc_close_port,
1400 .activate = rc_activate_port,
1401 };
1402
1403
1404 static int __init rc_init_drivers(void)
1405 {
1406 int error;
1407 int i;
1408
1409 riscom_driver = alloc_tty_driver(RC_NBOARD * RC_NPORT);
1410 if (!riscom_driver)
1411 return -ENOMEM;
1412
1413 riscom_driver->owner = THIS_MODULE;
1414 riscom_driver->name = "ttyL";
1415 riscom_driver->major = RISCOM8_NORMAL_MAJOR;
1416 riscom_driver->type = TTY_DRIVER_TYPE_SERIAL;
1417 riscom_driver->subtype = SERIAL_TYPE_NORMAL;
1418 riscom_driver->init_termios = tty_std_termios;
1419 riscom_driver->init_termios.c_cflag =
1420 B9600 | CS8 | CREAD | HUPCL | CLOCAL;
1421 riscom_driver->init_termios.c_ispeed = 9600;
1422 riscom_driver->init_termios.c_ospeed = 9600;
1423 riscom_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_HARDWARE_BREAK;
1424 tty_set_operations(riscom_driver, &riscom_ops);
1425 error = tty_register_driver(riscom_driver);
1426 if (error != 0) {
1427 put_tty_driver(riscom_driver);
1428 printk(KERN_ERR "rc: Couldn't register RISCom/8 driver, "
1429 "error = %d\n", error);
1430 return 1;
1431 }
1432 memset(rc_port, 0, sizeof(rc_port));
1433 for (i = 0; i < RC_NPORT * RC_NBOARD; i++) {
1434 tty_port_init(&rc_port[i].port);
1435 rc_port[i].port.ops = &riscom_port_ops;
1436 rc_port[i].magic = RISCOM8_MAGIC;
1437 }
1438 return 0;
1439 }
1440
1441 static void rc_release_drivers(void)
1442 {
1443 tty_unregister_driver(riscom_driver);
1444 put_tty_driver(riscom_driver);
1445 }
1446
1447 #ifndef MODULE
1448 /*
1449 * Called at boot time.
1450 *
1451 * You can specify IO base for up to RC_NBOARD cards,
1452 * using line "riscom8=0xiobase1,0xiobase2,.." at LILO prompt.
1453 * Note that there will be no probing at default
1454 * addresses in this case.
1455 *
1456 */
1457 static int __init riscom8_setup(char *str)
1458 {
1459 int ints[RC_NBOARD];
1460 int i;
1461
1462 str = get_options(str, ARRAY_SIZE(ints), ints);
1463
1464 for (i = 0; i < RC_NBOARD; i++) {
1465 if (i < ints[0])
1466 rc_board[i].base = ints[i+1];
1467 else
1468 rc_board[i].base = 0;
1469 }
1470 return 1;
1471 }
1472
1473 __setup("riscom8=", riscom8_setup);
1474 #endif
1475
1476 static char banner[] __initdata =
1477 KERN_INFO "rc: SDL RISCom/8 card driver v1.1, (c) D.Gorodchanin "
1478 "1994-1996.\n";
1479 static char no_boards_msg[] __initdata =
1480 KERN_INFO "rc: No RISCom/8 boards detected.\n";
1481
1482 /*
1483 * This routine must be called by kernel at boot time
1484 */
1485 static int __init riscom8_init(void)
1486 {
1487 int i;
1488 int found = 0;
1489
1490 printk(banner);
1491
1492 if (rc_init_drivers())
1493 return -EIO;
1494
1495 for (i = 0; i < RC_NBOARD; i++)
1496 if (rc_board[i].base && !rc_probe(&rc_board[i]))
1497 found++;
1498 if (!found) {
1499 rc_release_drivers();
1500 printk(no_boards_msg);
1501 return -EIO;
1502 }
1503 return 0;
1504 }
1505
1506 #ifdef MODULE
1507 static int iobase;
1508 static int iobase1;
1509 static int iobase2;
1510 static int iobase3;
1511 module_param(iobase, int, 0);
1512 module_param(iobase1, int, 0);
1513 module_param(iobase2, int, 0);
1514 module_param(iobase3, int, 0);
1515
1516 MODULE_LICENSE("GPL");
1517 MODULE_ALIAS_CHARDEV_MAJOR(RISCOM8_NORMAL_MAJOR);
1518 #endif /* MODULE */
1519
1520 /*
1521 * You can setup up to 4 boards (current value of RC_NBOARD)
1522 * by specifying "iobase=0xXXX iobase1=0xXXX ..." as insmod parameter.
1523 *
1524 */
1525 static int __init riscom8_init_module(void)
1526 {
1527 #ifdef MODULE
1528 int i;
1529
1530 if (iobase || iobase1 || iobase2 || iobase3) {
1531 for (i = 0; i < RC_NBOARD; i++)
1532 rc_board[i].base = 0;
1533 }
1534
1535 if (iobase)
1536 rc_board[0].base = iobase;
1537 if (iobase1)
1538 rc_board[1].base = iobase1;
1539 if (iobase2)
1540 rc_board[2].base = iobase2;
1541 if (iobase3)
1542 rc_board[3].base = iobase3;
1543 #endif /* MODULE */
1544
1545 return riscom8_init();
1546 }
1547
1548 static void __exit riscom8_exit_module(void)
1549 {
1550 int i;
1551
1552 rc_release_drivers();
1553 for (i = 0; i < RC_NBOARD; i++)
1554 if (rc_board[i].flags & RC_BOARD_PRESENT)
1555 rc_release_io_range(&rc_board[i]);
1556
1557 }
1558
1559 module_init(riscom8_init_module);
1560 module_exit(riscom8_exit_module);
The kernel tree for Tao Ma.