?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge git://git.kernel.org/pub/scm/linux/kernel/git/mason/btrfs-unstable
[linux-2.6/mini2440.git] / drivers / char / riscom8.c
blob217660451237a79c7cd186d38697bad07f9dbcf8
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 = port->port.tty;
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 return;
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 return;
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 (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 tty_insert_flip_char(tty, ch, flag);
383 tty_flip_buffer_push(tty);
384 }
385
386 static void rc_receive(struct riscom_board const *bp)
387 {
388 struct riscom_port *port;
389 struct tty_struct *tty;
390 unsigned char count;
391
392 port = rc_get_port(bp, "Receive");
393 if (port == NULL)
394 return;
395
396 tty = port->port.tty;
397
398 count = rc_in(bp, CD180_RDCR);
399
400 #ifdef RC_REPORT_FIFO
401 port->hits[count > 8 ? 9 : count]++;
402 #endif
403
404 while (count--) {
405 if (tty_buffer_request_room(tty, 1) == 0) {
406 printk(KERN_WARNING "rc%d: port %d: Working around "
407 "flip buffer overflow.\n",
408 board_No(bp), port_No(port));
409 break;
410 }
411 tty_insert_flip_char(tty, rc_in(bp, CD180_RDR), TTY_NORMAL);
412 }
413 tty_flip_buffer_push(tty);
414 }
415
416 static void rc_transmit(struct riscom_board const *bp)
417 {
418 struct riscom_port *port;
419 struct tty_struct *tty;
420 unsigned char count;
421
422 port = rc_get_port(bp, "Transmit");
423 if (port == NULL)
424 return;
425
426 tty = port->port.tty;
427
428 if (port->IER & IER_TXEMPTY) {
429 /* FIFO drained */
430 rc_out(bp, CD180_CAR, port_No(port));
431 port->IER &= ~IER_TXEMPTY;
432 rc_out(bp, CD180_IER, port->IER);
433 return;
434 }
435
436 if ((port->xmit_cnt <= 0 && !port->break_length)
437 || tty->stopped || tty->hw_stopped) {
438 rc_out(bp, CD180_CAR, port_No(port));
439 port->IER &= ~IER_TXRDY;
440 rc_out(bp, CD180_IER, port->IER);
441 return;
442 }
443
444 if (port->break_length) {
445 if (port->break_length > 0) {
446 if (port->COR2 & COR2_ETC) {
447 rc_out(bp, CD180_TDR, CD180_C_ESC);
448 rc_out(bp, CD180_TDR, CD180_C_SBRK);
449 port->COR2 &= ~COR2_ETC;
450 }
451 count = min_t(int, port->break_length, 0xff);
452 rc_out(bp, CD180_TDR, CD180_C_ESC);
453 rc_out(bp, CD180_TDR, CD180_C_DELAY);
454 rc_out(bp, CD180_TDR, count);
455 port->break_length -= count;
456 if (port->break_length == 0)
457 port->break_length--;
458 } else {
459 rc_out(bp, CD180_TDR, CD180_C_ESC);
460 rc_out(bp, CD180_TDR, CD180_C_EBRK);
461 rc_out(bp, CD180_COR2, port->COR2);
462 rc_wait_CCR(bp);
463 rc_out(bp, CD180_CCR, CCR_CORCHG2);
464 port->break_length = 0;
465 }
466 return;
467 }
468
469 count = CD180_NFIFO;
470 do {
471 rc_out(bp, CD180_TDR, port->port.xmit_buf[port->xmit_tail++]);
472 port->xmit_tail = port->xmit_tail & (SERIAL_XMIT_SIZE-1);
473 if (--port->xmit_cnt <= 0)
474 break;
475 } while (--count > 0);
476
477 if (port->xmit_cnt <= 0) {
478 rc_out(bp, CD180_CAR, port_No(port));
479 port->IER &= ~IER_TXRDY;
480 rc_out(bp, CD180_IER, port->IER);
481 }
482 if (port->xmit_cnt <= port->wakeup_chars)
483 tty_wakeup(tty);
484 }
485
486 static void rc_check_modem(struct riscom_board const *bp)
487 {
488 struct riscom_port *port;
489 struct tty_struct *tty;
490 unsigned char mcr;
491
492 port = rc_get_port(bp, "Modem");
493 if (port == NULL)
494 return;
495
496 tty = port->port.tty;
497
498 mcr = rc_in(bp, CD180_MCR);
499 if (mcr & MCR_CDCHG) {
500 if (rc_in(bp, CD180_MSVR) & MSVR_CD)
501 wake_up_interruptible(&port->port.open_wait);
502 else
503 tty_hangup(tty);
504 }
505
506 #ifdef RISCOM_BRAIN_DAMAGED_CTS
507 if (mcr & MCR_CTSCHG) {
508 if (rc_in(bp, CD180_MSVR) & MSVR_CTS) {
509 tty->hw_stopped = 0;
510 port->IER |= IER_TXRDY;
511 if (port->xmit_cnt <= port->wakeup_chars)
512 tty_wakeup(tty);
513 } else {
514 tty->hw_stopped = 1;
515 port->IER &= ~IER_TXRDY;
516 }
517 rc_out(bp, CD180_IER, port->IER);
518 }
519 if (mcr & MCR_DSRCHG) {
520 if (rc_in(bp, CD180_MSVR) & MSVR_DSR) {
521 tty->hw_stopped = 0;
522 port->IER |= IER_TXRDY;
523 if (port->xmit_cnt <= port->wakeup_chars)
524 tty_wakeup(tty);
525 } else {
526 tty->hw_stopped = 1;
527 port->IER &= ~IER_TXRDY;
528 }
529 rc_out(bp, CD180_IER, port->IER);
530 }
531 #endif /* RISCOM_BRAIN_DAMAGED_CTS */
532
533 /* Clear change bits */
534 rc_out(bp, CD180_MCR, 0);
535 }
536
537 /* The main interrupt processing routine */
538 static irqreturn_t rc_interrupt(int dummy, void *dev_id)
539 {
540 unsigned char status;
541 unsigned char ack;
542 struct riscom_board *bp = dev_id;
543 unsigned long loop = 0;
544 int handled = 0;
545
546 if (!(bp->flags & RC_BOARD_ACTIVE))
547 return IRQ_NONE;
548
549 while ((++loop < 16) && ((status = ~(rc_in(bp, RC_BSR))) &
550 (RC_BSR_TOUT | RC_BSR_TINT |
551 RC_BSR_MINT | RC_BSR_RINT))) {
552 handled = 1;
553 if (status & RC_BSR_TOUT)
554 printk(KERN_WARNING "rc%d: Got timeout. Hardware "
555 "error?\n", board_No(bp));
556 else if (status & RC_BSR_RINT) {
557 ack = rc_in(bp, RC_ACK_RINT);
558 if (ack == (RC_ID | GIVR_IT_RCV))
559 rc_receive(bp);
560 else if (ack == (RC_ID | GIVR_IT_REXC))
561 rc_receive_exc(bp);
562 else
563 printk(KERN_WARNING "rc%d: Bad receive ack "
564 "0x%02x.\n",
565 board_No(bp), ack);
566 } else if (status & RC_BSR_TINT) {
567 ack = rc_in(bp, RC_ACK_TINT);
568 if (ack == (RC_ID | GIVR_IT_TX))
569 rc_transmit(bp);
570 else
571 printk(KERN_WARNING "rc%d: Bad transmit ack "
572 "0x%02x.\n",
573 board_No(bp), ack);
574 } else /* if (status & RC_BSR_MINT) */ {
575 ack = rc_in(bp, RC_ACK_MINT);
576 if (ack == (RC_ID | GIVR_IT_MODEM))
577 rc_check_modem(bp);
578 else
579 printk(KERN_WARNING "rc%d: Bad modem ack "
580 "0x%02x.\n",
581 board_No(bp), ack);
582 }
583 rc_out(bp, CD180_EOIR, 0); /* Mark end of interrupt */
584 rc_out(bp, RC_CTOUT, 0); /* Clear timeout flag */
585 }
586 return IRQ_RETVAL(handled);
587 }
588
589 /*
590 * Routines for open & close processing.
591 */
592
593 /* Called with disabled interrupts */
594 static int rc_setup_board(struct riscom_board *bp)
595 {
596 int error;
597
598 if (bp->flags & RC_BOARD_ACTIVE)
599 return 0;
600
601 error = request_irq(bp->irq, rc_interrupt, IRQF_DISABLED,
602 "RISCom/8", bp);
603 if (error)
604 return error;
605
606 rc_out(bp, RC_CTOUT, 0); /* Just in case */
607 bp->DTR = ~0;
608 rc_out(bp, RC_DTR, bp->DTR); /* Drop DTR on all ports */
609
610 bp->flags |= RC_BOARD_ACTIVE;
611
612 return 0;
613 }
614
615 /* Called with disabled interrupts */
616 static void rc_shutdown_board(struct riscom_board *bp)
617 {
618 if (!(bp->flags & RC_BOARD_ACTIVE))
619 return;
620
621 bp->flags &= ~RC_BOARD_ACTIVE;
622
623 free_irq(bp->irq, NULL);
624
625 bp->DTR = ~0;
626 rc_out(bp, RC_DTR, bp->DTR); /* Drop DTR on all ports */
627
628 }
629
630 /*
631 * Setting up port characteristics.
632 * Must be called with disabled interrupts
633 */
634 static void rc_change_speed(struct riscom_board *bp, struct riscom_port *port)
635 {
636 struct tty_struct *tty = port->port.tty;
637 unsigned long baud;
638 long tmp;
639 unsigned char cor1 = 0, cor3 = 0;
640 unsigned char mcor1 = 0, mcor2 = 0;
641
642 port->IER = 0;
643 port->COR2 = 0;
644 port->MSVR = MSVR_RTS;
645
646 baud = tty_get_baud_rate(tty);
647
648 /* Select port on the board */
649 rc_out(bp, CD180_CAR, port_No(port));
650
651 if (!baud) {
652 /* Drop DTR & exit */
653 bp->DTR |= (1u << port_No(port));
654 rc_out(bp, RC_DTR, bp->DTR);
655 return;
656 } else {
657 /* Set DTR on */
658 bp->DTR &= ~(1u << port_No(port));
659 rc_out(bp, RC_DTR, bp->DTR);
660 }
661
662 /*
663 * Now we must calculate some speed depended things
664 */
665
666 /* Set baud rate for port */
667 tmp = (((RC_OSCFREQ + baud/2) / baud +
668 CD180_TPC/2) / CD180_TPC);
669
670 rc_out(bp, CD180_RBPRH, (tmp >> 8) & 0xff);
671 rc_out(bp, CD180_TBPRH, (tmp >> 8) & 0xff);
672 rc_out(bp, CD180_RBPRL, tmp & 0xff);
673 rc_out(bp, CD180_TBPRL, tmp & 0xff);
674
675 baud = (baud + 5) / 10; /* Estimated CPS */
676
677 /* Two timer ticks seems enough to wakeup something like SLIP driver */
678 tmp = ((baud + HZ/2) / HZ) * 2 - CD180_NFIFO;
679 port->wakeup_chars = (tmp < 0) ? 0 : ((tmp >= SERIAL_XMIT_SIZE) ?
680 SERIAL_XMIT_SIZE - 1 : tmp);
681
682 /* Receiver timeout will be transmission time for 1.5 chars */
683 tmp = (RISCOM_TPS + RISCOM_TPS/2 + baud/2) / baud;
684 tmp = (tmp > 0xff) ? 0xff : tmp;
685 rc_out(bp, CD180_RTPR, tmp);
686
687 switch (C_CSIZE(tty)) {
688 case CS5:
689 cor1 |= COR1_5BITS;
690 break;
691 case CS6:
692 cor1 |= COR1_6BITS;
693 break;
694 case CS7:
695 cor1 |= COR1_7BITS;
696 break;
697 case CS8:
698 cor1 |= COR1_8BITS;
699 break;
700 }
701 if (C_CSTOPB(tty))
702 cor1 |= COR1_2SB;
703
704 cor1 |= COR1_IGNORE;
705 if (C_PARENB(tty)) {
706 cor1 |= COR1_NORMPAR;
707 if (C_PARODD(tty))
708 cor1 |= COR1_ODDP;
709 if (I_INPCK(tty))
710 cor1 &= ~COR1_IGNORE;
711 }
712 /* Set marking of some errors */
713 port->mark_mask = RCSR_OE | RCSR_TOUT;
714 if (I_INPCK(tty))
715 port->mark_mask |= RCSR_FE | RCSR_PE;
716 if (I_BRKINT(tty) || I_PARMRK(tty))
717 port->mark_mask |= RCSR_BREAK;
718 if (I_IGNPAR(tty))
719 port->mark_mask &= ~(RCSR_FE | RCSR_PE);
720 if (I_IGNBRK(tty)) {
721 port->mark_mask &= ~RCSR_BREAK;
722 if (I_IGNPAR(tty))
723 /* Real raw mode. Ignore all */
724 port->mark_mask &= ~RCSR_OE;
725 }
726 /* Enable Hardware Flow Control */
727 if (C_CRTSCTS(tty)) {
728 #ifdef RISCOM_BRAIN_DAMAGED_CTS
729 port->IER |= IER_DSR | IER_CTS;
730 mcor1 |= MCOR1_DSRZD | MCOR1_CTSZD;
731 mcor2 |= MCOR2_DSROD | MCOR2_CTSOD;
732 tty->hw_stopped = !(rc_in(bp, CD180_MSVR) &
733 (MSVR_CTS|MSVR_DSR));
734 #else
735 port->COR2 |= COR2_CTSAE;
736 #endif
737 }
738 /* Enable Software Flow Control. FIXME: I'm not sure about this */
739 /* Some people reported that it works, but I still doubt */
740 if (I_IXON(tty)) {
741 port->COR2 |= COR2_TXIBE;
742 cor3 |= (COR3_FCT | COR3_SCDE);
743 if (I_IXANY(tty))
744 port->COR2 |= COR2_IXM;
745 rc_out(bp, CD180_SCHR1, START_CHAR(tty));
746 rc_out(bp, CD180_SCHR2, STOP_CHAR(tty));
747 rc_out(bp, CD180_SCHR3, START_CHAR(tty));
748 rc_out(bp, CD180_SCHR4, STOP_CHAR(tty));
749 }
750 if (!C_CLOCAL(tty)) {
751 /* Enable CD check */
752 port->IER |= IER_CD;
753 mcor1 |= MCOR1_CDZD;
754 mcor2 |= MCOR2_CDOD;
755 }
756
757 if (C_CREAD(tty))
758 /* Enable receiver */
759 port->IER |= IER_RXD;
760
761 /* Set input FIFO size (1-8 bytes) */
762 cor3 |= RISCOM_RXFIFO;
763 /* Setting up CD180 channel registers */
764 rc_out(bp, CD180_COR1, cor1);
765 rc_out(bp, CD180_COR2, port->COR2);
766 rc_out(bp, CD180_COR3, cor3);
767 /* Make CD180 know about registers change */
768 rc_wait_CCR(bp);
769 rc_out(bp, CD180_CCR, CCR_CORCHG1 | CCR_CORCHG2 | CCR_CORCHG3);
770 /* Setting up modem option registers */
771 rc_out(bp, CD180_MCOR1, mcor1);
772 rc_out(bp, CD180_MCOR2, mcor2);
773 /* Enable CD180 transmitter & receiver */
774 rc_wait_CCR(bp);
775 rc_out(bp, CD180_CCR, CCR_TXEN | CCR_RXEN);
776 /* Enable interrupts */
777 rc_out(bp, CD180_IER, port->IER);
778 /* And finally set RTS on */
779 rc_out(bp, CD180_MSVR, port->MSVR);
780 }
781
782 /* Must be called with interrupts enabled */
783 static int rc_setup_port(struct riscom_board *bp, struct riscom_port *port)
784 {
785 unsigned long flags;
786
787 if (port->port.flags & ASYNC_INITIALIZED)
788 return 0;
789
790 if (tty_port_alloc_xmit_buf(&port->port) < 0)
791 return -ENOMEM;
792
793 spin_lock_irqsave(&riscom_lock, flags);
794
795 clear_bit(TTY_IO_ERROR, &port->port.tty->flags);
796 if (port->port.count == 1)
797 bp->count++;
798 port->xmit_cnt = port->xmit_head = port->xmit_tail = 0;
799 rc_change_speed(bp, port);
800 port->port.flags |= ASYNC_INITIALIZED;
801
802 spin_unlock_irqrestore(&riscom_lock, flags);
803 return 0;
804 }
805
806 /* Must be called with interrupts disabled */
807 static void rc_shutdown_port(struct tty_struct *tty,
808 struct riscom_board *bp, struct riscom_port *port)
809 {
810 if (!(port->port.flags & ASYNC_INITIALIZED))
811 return;
812
813 #ifdef RC_REPORT_OVERRUN
814 printk(KERN_INFO "rc%d: port %d: Total %ld overruns were detected.\n",
815 board_No(bp), port_No(port), port->overrun);
816 #endif
817 #ifdef RC_REPORT_FIFO
818 {
819 int i;
820
821 printk(KERN_INFO "rc%d: port %d: FIFO hits [ ",
822 board_No(bp), port_No(port));
823 for (i = 0; i < 10; i++)
824 printk("%ld ", port->hits[i]);
825 printk("].\n");
826 }
827 #endif
828 tty_port_free_xmit_buf(&port->port);
829 if (C_HUPCL(tty)) {
830 /* Drop DTR */
831 bp->DTR |= (1u << port_No(port));
832 rc_out(bp, RC_DTR, bp->DTR);
833 }
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 port->port.flags &= ~ASYNC_INITIALIZED;
846
847 if (--bp->count < 0) {
848 printk(KERN_INFO "rc%d: rc_shutdown_port: "
849 "bad board count: %d\n",
850 board_No(bp), bp->count);
851 bp->count = 0;
852 }
853 /*
854 * If this is the last opened port on the board
855 * shutdown whole board
856 */
857 if (!bp->count)
858 rc_shutdown_board(bp);
859 }
860
861 static int carrier_raised(struct tty_port *port)
862 {
863 struct riscom_port *p = container_of(port, struct riscom_port, port);
864 struct riscom_board *bp = port_Board(p);
865 unsigned long flags;
866 int CD;
867
868 spin_lock_irqsave(&riscom_lock, flags);
869 rc_out(bp, CD180_CAR, port_No(p));
870 CD = rc_in(bp, CD180_MSVR) & MSVR_CD;
871 rc_out(bp, CD180_MSVR, MSVR_RTS);
872 bp->DTR &= ~(1u << port_No(p));
873 rc_out(bp, RC_DTR, bp->DTR);
874 spin_unlock_irqrestore(&riscom_lock, flags);
875 return CD;
876 }
877
878 static int rc_open(struct tty_struct *tty, struct file *filp)
879 {
880 int board;
881 int error;
882 struct riscom_port *port;
883 struct riscom_board *bp;
884
885 board = RC_BOARD(tty->index);
886 if (board >= RC_NBOARD || !(rc_board[board].flags & RC_BOARD_PRESENT))
887 return -ENODEV;
888
889 bp = &rc_board[board];
890 port = rc_port + board * RC_NPORT + RC_PORT(tty->index);
891 if (rc_paranoia_check(port, tty->name, "rc_open"))
892 return -ENODEV;
893
894 error = rc_setup_board(bp);
895 if (error)
896 return error;
897
898 port->port.count++;
899 tty->driver_data = port;
900 port->port.tty = tty;
901
902 error = rc_setup_port(bp, port);
903 if (error == 0)
904 error = tty_port_block_til_ready(&port->port, tty, filp);
905 return error;
906 }
907
908 static void rc_flush_buffer(struct tty_struct *tty)
909 {
910 struct riscom_port *port = tty->driver_data;
911 unsigned long flags;
912
913 if (rc_paranoia_check(port, tty->name, "rc_flush_buffer"))
914 return;
915
916 spin_lock_irqsave(&riscom_lock, flags);
917 port->xmit_cnt = port->xmit_head = port->xmit_tail = 0;
918 spin_unlock_irqrestore(&riscom_lock, flags);
919
920 tty_wakeup(tty);
921 }
922
923 static void rc_close(struct tty_struct *tty, struct file *filp)
924 {
925 struct riscom_port *port = tty->driver_data;
926 struct riscom_board *bp;
927 unsigned long flags;
928 unsigned long timeout;
929
930 if (!port || rc_paranoia_check(port, tty->name, "close"))
931 return;
932
933 bp = port_Board(port);
934
935 if (tty_port_close_start(&port->port, tty, filp) == 0)
936 return;
937
938 /*
939 * At this point we stop accepting input. To do this, we
940 * disable the receive line status interrupts, and tell the
941 * interrupt driver to stop checking the data ready bit in the
942 * line status register.
943 */
944
945 spin_lock_irqsave(&riscom_lock, flags);
946 port->IER &= ~IER_RXD;
947 if (port->port.flags & ASYNC_INITIALIZED) {
948 port->IER &= ~IER_TXRDY;
949 port->IER |= IER_TXEMPTY;
950 rc_out(bp, CD180_CAR, port_No(port));
951 rc_out(bp, CD180_IER, port->IER);
952 /*
953 * Before we drop DTR, make sure the UART transmitter
954 * has completely drained; this is especially
955 * important if there is a transmit FIFO!
956 */
957 timeout = jiffies + HZ;
958 while (port->IER & IER_TXEMPTY) {
959 spin_unlock_irqrestore(&riscom_lock, flags);
960 msleep_interruptible(jiffies_to_msecs(port->timeout));
961 spin_lock_irqsave(&riscom_lock, flags);
962 if (time_after(jiffies, timeout))
963 break;
964 }
965 }
966 rc_shutdown_port(tty, bp, port);
967 rc_flush_buffer(tty);
968 spin_unlock_irqrestore(&riscom_lock, flags);
969
970 tty_port_close_end(&port->port, tty);
971 }
972
973 static int rc_write(struct tty_struct *tty,
974 const unsigned char *buf, int count)
975 {
976 struct riscom_port *port = tty->driver_data;
977 struct riscom_board *bp;
978 int c, total = 0;
979 unsigned long flags;
980
981 if (rc_paranoia_check(port, tty->name, "rc_write"))
982 return 0;
983
984 bp = port_Board(port);
985
986 while (1) {
987 spin_lock_irqsave(&riscom_lock, flags);
988
989 c = min_t(int, count, min(SERIAL_XMIT_SIZE - port->xmit_cnt - 1,
990 SERIAL_XMIT_SIZE - port->xmit_head));
991 if (c <= 0)
992 break; /* lock continues to be held */
993
994 memcpy(port->port.xmit_buf + port->xmit_head, buf, c);
995 port->xmit_head = (port->xmit_head + c) & (SERIAL_XMIT_SIZE-1);
996 port->xmit_cnt += c;
997
998 spin_unlock_irqrestore(&riscom_lock, flags);
999
1000 buf += c;
1001 count -= c;
1002 total += c;
1003 }
1004
1005 if (port->xmit_cnt && !tty->stopped && !tty->hw_stopped &&
1006 !(port->IER & IER_TXRDY)) {
1007 port->IER |= IER_TXRDY;
1008 rc_out(bp, CD180_CAR, port_No(port));
1009 rc_out(bp, CD180_IER, port->IER);
1010 }
1011
1012 spin_unlock_irqrestore(&riscom_lock, flags);
1013
1014 return total;
1015 }
1016
1017 static int rc_put_char(struct tty_struct *tty, unsigned char ch)
1018 {
1019 struct riscom_port *port = tty->driver_data;
1020 unsigned long flags;
1021 int ret = 0;
1022
1023 if (rc_paranoia_check(port, tty->name, "rc_put_char"))
1024 return 0;
1025
1026 spin_lock_irqsave(&riscom_lock, flags);
1027
1028 if (port->xmit_cnt >= SERIAL_XMIT_SIZE - 1)
1029 goto out;
1030
1031 port->port.xmit_buf[port->xmit_head++] = ch;
1032 port->xmit_head &= SERIAL_XMIT_SIZE - 1;
1033 port->xmit_cnt++;
1034 ret = 1;
1035
1036 out:
1037 spin_unlock_irqrestore(&riscom_lock, flags);
1038 return ret;
1039 }
1040
1041 static void rc_flush_chars(struct tty_struct *tty)
1042 {
1043 struct riscom_port *port = tty->driver_data;
1044 unsigned long flags;
1045
1046 if (rc_paranoia_check(port, tty->name, "rc_flush_chars"))
1047 return;
1048
1049 if (port->xmit_cnt <= 0 || tty->stopped || tty->hw_stopped)
1050 return;
1051
1052 spin_lock_irqsave(&riscom_lock, flags);
1053
1054 port->IER |= IER_TXRDY;
1055 rc_out(port_Board(port), CD180_CAR, port_No(port));
1056 rc_out(port_Board(port), CD180_IER, port->IER);
1057
1058 spin_unlock_irqrestore(&riscom_lock, flags);
1059 }
1060
1061 static int rc_write_room(struct tty_struct *tty)
1062 {
1063 struct riscom_port *port = tty->driver_data;
1064 int ret;
1065
1066 if (rc_paranoia_check(port, tty->name, "rc_write_room"))
1067 return 0;
1068
1069 ret = SERIAL_XMIT_SIZE - port->xmit_cnt - 1;
1070 if (ret < 0)
1071 ret = 0;
1072 return ret;
1073 }
1074
1075 static int rc_chars_in_buffer(struct tty_struct *tty)
1076 {
1077 struct riscom_port *port = tty->driver_data;
1078
1079 if (rc_paranoia_check(port, tty->name, "rc_chars_in_buffer"))
1080 return 0;
1081
1082 return port->xmit_cnt;
1083 }
1084
1085 static int rc_tiocmget(struct tty_struct *tty, struct file *file)
1086 {
1087 struct riscom_port *port = tty->driver_data;
1088 struct riscom_board *bp;
1089 unsigned char status;
1090 unsigned int result;
1091 unsigned long flags;
1092
1093 if (rc_paranoia_check(port, tty->name, __func__))
1094 return -ENODEV;
1095
1096 bp = port_Board(port);
1097
1098 spin_lock_irqsave(&riscom_lock, flags);
1099
1100 rc_out(bp, CD180_CAR, port_No(port));
1101 status = rc_in(bp, CD180_MSVR);
1102 result = rc_in(bp, RC_RI) & (1u << port_No(port)) ? 0 : TIOCM_RNG;
1103
1104 spin_unlock_irqrestore(&riscom_lock, flags);
1105
1106 result |= ((status & MSVR_RTS) ? TIOCM_RTS : 0)
1107 | ((status & MSVR_DTR) ? TIOCM_DTR : 0)
1108 | ((status & MSVR_CD) ? TIOCM_CAR : 0)
1109 | ((status & MSVR_DSR) ? TIOCM_DSR : 0)
1110 | ((status & MSVR_CTS) ? TIOCM_CTS : 0);
1111 return result;
1112 }
1113
1114 static int rc_tiocmset(struct tty_struct *tty, struct file *file,
1115 unsigned int set, unsigned int clear)
1116 {
1117 struct riscom_port *port = tty->driver_data;
1118 unsigned long flags;
1119 struct riscom_board *bp;
1120
1121 if (rc_paranoia_check(port, tty->name, __func__))
1122 return -ENODEV;
1123
1124 bp = port_Board(port);
1125
1126 spin_lock_irqsave(&riscom_lock, flags);
1127
1128 if (set & TIOCM_RTS)
1129 port->MSVR |= MSVR_RTS;
1130 if (set & TIOCM_DTR)
1131 bp->DTR &= ~(1u << port_No(port));
1132
1133 if (clear & TIOCM_RTS)
1134 port->MSVR &= ~MSVR_RTS;
1135 if (clear & TIOCM_DTR)
1136 bp->DTR |= (1u << port_No(port));
1137
1138 rc_out(bp, CD180_CAR, port_No(port));
1139 rc_out(bp, CD180_MSVR, port->MSVR);
1140 rc_out(bp, RC_DTR, bp->DTR);
1141
1142 spin_unlock_irqrestore(&riscom_lock, flags);
1143
1144 return 0;
1145 }
1146
1147 static int rc_send_break(struct tty_struct *tty, int length)
1148 {
1149 struct riscom_port *port = tty->driver_data;
1150 struct riscom_board *bp = port_Board(port);
1151 unsigned long flags;
1152
1153 if (length == 0 || length == -1)
1154 return -EOPNOTSUPP;
1155
1156 spin_lock_irqsave(&riscom_lock, flags);
1157
1158 port->break_length = RISCOM_TPS / HZ * length;
1159 port->COR2 |= COR2_ETC;
1160 port->IER |= IER_TXRDY;
1161 rc_out(bp, CD180_CAR, port_No(port));
1162 rc_out(bp, CD180_COR2, port->COR2);
1163 rc_out(bp, CD180_IER, port->IER);
1164 rc_wait_CCR(bp);
1165 rc_out(bp, CD180_CCR, CCR_CORCHG2);
1166 rc_wait_CCR(bp);
1167
1168 spin_unlock_irqrestore(&riscom_lock, flags);
1169 return 0;
1170 }
1171
1172 static int rc_set_serial_info(struct riscom_port *port,
1173 struct serial_struct __user *newinfo)
1174 {
1175 struct serial_struct tmp;
1176 struct riscom_board *bp = port_Board(port);
1177 int change_speed;
1178
1179 if (copy_from_user(&tmp, newinfo, sizeof(tmp)))
1180 return -EFAULT;
1181
1182 #if 0
1183 if ((tmp.irq != bp->irq) ||
1184 (tmp.port != bp->base) ||
1185 (tmp.type != PORT_CIRRUS) ||
1186 (tmp.baud_base != (RC_OSCFREQ + CD180_TPC/2) / CD180_TPC) ||
1187 (tmp.custom_divisor != 0) ||
1188 (tmp.xmit_fifo_size != CD180_NFIFO) ||
1189 (tmp.flags & ~RISCOM_LEGAL_FLAGS))
1190 return -EINVAL;
1191 #endif
1192
1193 change_speed = ((port->port.flags & ASYNC_SPD_MASK) !=
1194 (tmp.flags & ASYNC_SPD_MASK));
1195
1196 if (!capable(CAP_SYS_ADMIN)) {
1197 if ((tmp.close_delay != port->port.close_delay) ||
1198 (tmp.closing_wait != port->port.closing_wait) ||
1199 ((tmp.flags & ~ASYNC_USR_MASK) !=
1200 (port->port.flags & ~ASYNC_USR_MASK)))
1201 return -EPERM;
1202 port->port.flags = ((port->port.flags & ~ASYNC_USR_MASK) |
1203 (tmp.flags & ASYNC_USR_MASK));
1204 } else {
1205 port->port.flags = ((port->port.flags & ~ASYNC_FLAGS) |
1206 (tmp.flags & ASYNC_FLAGS));
1207 port->port.close_delay = tmp.close_delay;
1208 port->port.closing_wait = tmp.closing_wait;
1209 }
1210 if (change_speed) {
1211 unsigned long flags;
1212
1213 spin_lock_irqsave(&riscom_lock, flags);
1214 rc_change_speed(bp, port);
1215 spin_unlock_irqrestore(&riscom_lock, flags);
1216 }
1217 return 0;
1218 }
1219
1220 static int rc_get_serial_info(struct riscom_port *port,
1221 struct serial_struct __user *retinfo)
1222 {
1223 struct serial_struct tmp;
1224 struct riscom_board *bp = port_Board(port);
1225
1226 memset(&tmp, 0, sizeof(tmp));
1227 tmp.type = PORT_CIRRUS;
1228 tmp.line = port - rc_port;
1229 tmp.port = bp->base;
1230 tmp.irq = bp->irq;
1231 tmp.flags = port->port.flags;
1232 tmp.baud_base = (RC_OSCFREQ + CD180_TPC/2) / CD180_TPC;
1233 tmp.close_delay = port->port.close_delay * HZ/100;
1234 tmp.closing_wait = port->port.closing_wait * HZ/100;
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 lock_kernel();
1252 retval = rc_get_serial_info(port, argp);
1253 unlock_kernel();
1254 break;
1255 case TIOCSSERIAL:
1256 lock_kernel();
1257 retval = rc_set_serial_info(port, argp);
1258 unlock_kernel();
1259 break;
1260 default:
1261 retval = -ENOIOCTLCMD;
1262 }
1263 return retval;
1264 }
1265
1266 static void rc_throttle(struct tty_struct *tty)
1267 {
1268 struct riscom_port *port = tty->driver_data;
1269 struct riscom_board *bp;
1270 unsigned long flags;
1271
1272 if (rc_paranoia_check(port, tty->name, "rc_throttle"))
1273 return;
1274 bp = port_Board(port);
1275
1276 spin_lock_irqsave(&riscom_lock, flags);
1277 port->MSVR &= ~MSVR_RTS;
1278 rc_out(bp, CD180_CAR, port_No(port));
1279 if (I_IXOFF(tty)) {
1280 rc_wait_CCR(bp);
1281 rc_out(bp, CD180_CCR, CCR_SSCH2);
1282 rc_wait_CCR(bp);
1283 }
1284 rc_out(bp, CD180_MSVR, port->MSVR);
1285 spin_unlock_irqrestore(&riscom_lock, flags);
1286 }
1287
1288 static void rc_unthrottle(struct tty_struct *tty)
1289 {
1290 struct riscom_port *port = tty->driver_data;
1291 struct riscom_board *bp;
1292 unsigned long flags;
1293
1294 if (rc_paranoia_check(port, tty->name, "rc_unthrottle"))
1295 return;
1296 bp = port_Board(port);
1297
1298 spin_lock_irqsave(&riscom_lock, flags);
1299 port->MSVR |= MSVR_RTS;
1300 rc_out(bp, CD180_CAR, port_No(port));
1301 if (I_IXOFF(tty)) {
1302 rc_wait_CCR(bp);
1303 rc_out(bp, CD180_CCR, CCR_SSCH1);
1304 rc_wait_CCR(bp);
1305 }
1306 rc_out(bp, CD180_MSVR, port->MSVR);
1307 spin_unlock_irqrestore(&riscom_lock, flags);
1308 }
1309
1310 static void rc_stop(struct tty_struct *tty)
1311 {
1312 struct riscom_port *port = tty->driver_data;
1313 struct riscom_board *bp;
1314 unsigned long flags;
1315
1316 if (rc_paranoia_check(port, tty->name, "rc_stop"))
1317 return;
1318
1319 bp = port_Board(port);
1320
1321 spin_lock_irqsave(&riscom_lock, flags);
1322 port->IER &= ~IER_TXRDY;
1323 rc_out(bp, CD180_CAR, port_No(port));
1324 rc_out(bp, CD180_IER, port->IER);
1325 spin_unlock_irqrestore(&riscom_lock, flags);
1326 }
1327
1328 static void rc_start(struct tty_struct *tty)
1329 {
1330 struct riscom_port *port = tty->driver_data;
1331 struct riscom_board *bp;
1332 unsigned long flags;
1333
1334 if (rc_paranoia_check(port, tty->name, "rc_start"))
1335 return;
1336
1337 bp = port_Board(port);
1338
1339 spin_lock_irqsave(&riscom_lock, flags);
1340
1341 if (port->xmit_cnt && port->port.xmit_buf && !(port->IER & IER_TXRDY)) {
1342 port->IER |= IER_TXRDY;
1343 rc_out(bp, CD180_CAR, port_No(port));
1344 rc_out(bp, CD180_IER, port->IER);
1345 }
1346 spin_unlock_irqrestore(&riscom_lock, flags);
1347 }
1348
1349 static void rc_hangup(struct tty_struct *tty)
1350 {
1351 struct riscom_port *port = tty->driver_data;
1352 struct riscom_board *bp;
1353 unsigned long flags;
1354
1355 if (rc_paranoia_check(port, tty->name, "rc_hangup"))
1356 return;
1357
1358 bp = port_Board(port);
1359
1360 rc_shutdown_port(tty, bp, port);
1361 spin_lock_irqsave(&port->port.lock, flags);
1362 port->port.count = 0;
1363 port->port.flags &= ~ASYNC_NORMAL_ACTIVE;
1364 port->port.tty = NULL;
1365 wake_up_interruptible(&port->port.open_wait);
1366 spin_unlock_irqrestore(&port->port.lock, flags);
1367 }
1368
1369 static void rc_set_termios(struct tty_struct *tty,
1370 struct ktermios *old_termios)
1371 {
1372 struct riscom_port *port = tty->driver_data;
1373 unsigned long flags;
1374
1375 if (rc_paranoia_check(port, tty->name, "rc_set_termios"))
1376 return;
1377
1378 spin_lock_irqsave(&riscom_lock, flags);
1379 rc_change_speed(port_Board(port), port);
1380 spin_unlock_irqrestore(&riscom_lock, flags);
1381
1382 if ((old_termios->c_cflag & CRTSCTS) &&
1383 !(tty->termios->c_cflag & CRTSCTS)) {
1384 tty->hw_stopped = 0;
1385 rc_start(tty);
1386 }
1387 }
1388
1389 static const struct tty_operations riscom_ops = {
1390 .open = rc_open,
1391 .close = rc_close,
1392 .write = rc_write,
1393 .put_char = rc_put_char,
1394 .flush_chars = rc_flush_chars,
1395 .write_room = rc_write_room,
1396 .chars_in_buffer = rc_chars_in_buffer,
1397 .flush_buffer = rc_flush_buffer,
1398 .ioctl = rc_ioctl,
1399 .throttle = rc_throttle,
1400 .unthrottle = rc_unthrottle,
1401 .set_termios = rc_set_termios,
1402 .stop = rc_stop,
1403 .start = rc_start,
1404 .hangup = rc_hangup,
1405 .tiocmget = rc_tiocmget,
1406 .tiocmset = rc_tiocmset,
1407 .break_ctl = rc_send_break,
1408 };
1409
1410 static const struct tty_port_operations riscom_port_ops = {
1411 .carrier_raised = carrier_raised,
1412 };
1413
1414
1415 static int __init rc_init_drivers(void)
1416 {
1417 int error;
1418 int i;
1419
1420 riscom_driver = alloc_tty_driver(RC_NBOARD * RC_NPORT);
1421 if (!riscom_driver)
1422 return -ENOMEM;
1423
1424 riscom_driver->owner = THIS_MODULE;
1425 riscom_driver->name = "ttyL";
1426 riscom_driver->major = RISCOM8_NORMAL_MAJOR;
1427 riscom_driver->type = TTY_DRIVER_TYPE_SERIAL;
1428 riscom_driver->subtype = SERIAL_TYPE_NORMAL;
1429 riscom_driver->init_termios = tty_std_termios;
1430 riscom_driver->init_termios.c_cflag =
1431 B9600 | CS8 | CREAD | HUPCL | CLOCAL;
1432 riscom_driver->init_termios.c_ispeed = 9600;
1433 riscom_driver->init_termios.c_ospeed = 9600;
1434 riscom_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_HARDWARE_BREAK;
1435 tty_set_operations(riscom_driver, &riscom_ops);
1436 error = tty_register_driver(riscom_driver);
1437 if (error != 0) {
1438 put_tty_driver(riscom_driver);
1439 printk(KERN_ERR "rc: Couldn't register RISCom/8 driver, "
1440 "error = %d\n", error);
1441 return 1;
1442 }
1443 memset(rc_port, 0, sizeof(rc_port));
1444 for (i = 0; i < RC_NPORT * RC_NBOARD; i++) {
1445 tty_port_init(&rc_port[i].port);
1446 rc_port[i].port.ops = &riscom_port_ops;
1447 rc_port[i].magic = RISCOM8_MAGIC;
1448 }
1449 return 0;
1450 }
1451
1452 static void rc_release_drivers(void)
1453 {
1454 tty_unregister_driver(riscom_driver);
1455 put_tty_driver(riscom_driver);
1456 }
1457
1458 #ifndef MODULE
1459 /*
1460 * Called at boot time.
1461 *
1462 * You can specify IO base for up to RC_NBOARD cards,
1463 * using line "riscom8=0xiobase1,0xiobase2,.." at LILO prompt.
1464 * Note that there will be no probing at default
1465 * addresses in this case.
1466 *
1467 */
1468 static int __init riscom8_setup(char *str)
1469 {
1470 int ints[RC_NBOARD];
1471 int i;
1472
1473 str = get_options(str, ARRAY_SIZE(ints), ints);
1474
1475 for (i = 0; i < RC_NBOARD; i++) {
1476 if (i < ints[0])
1477 rc_board[i].base = ints[i+1];
1478 else
1479 rc_board[i].base = 0;
1480 }
1481 return 1;
1482 }
1483
1484 __setup("riscom8=", riscom8_setup);
1485 #endif
1486
1487 static char banner[] __initdata =
1488 KERN_INFO "rc: SDL RISCom/8 card driver v1.1, (c) D.Gorodchanin "
1489 "1994-1996.\n";
1490 static char no_boards_msg[] __initdata =
1491 KERN_INFO "rc: No RISCom/8 boards detected.\n";
1492
1493 /*
1494 * This routine must be called by kernel at boot time
1495 */
1496 static int __init riscom8_init(void)
1497 {
1498 int i;
1499 int found = 0;
1500
1501 printk(banner);
1502
1503 if (rc_init_drivers())
1504 return -EIO;
1505
1506 for (i = 0; i < RC_NBOARD; i++)
1507 if (rc_board[i].base && !rc_probe(&rc_board[i]))
1508 found++;
1509 if (!found) {
1510 rc_release_drivers();
1511 printk(no_boards_msg);
1512 return -EIO;
1513 }
1514 return 0;
1515 }
1516
1517 #ifdef MODULE
1518 static int iobase;
1519 static int iobase1;
1520 static int iobase2;
1521 static int iobase3;
1522 module_param(iobase, int, 0);
1523 module_param(iobase1, int, 0);
1524 module_param(iobase2, int, 0);
1525 module_param(iobase3, int, 0);
1526
1527 MODULE_LICENSE("GPL");
1528 MODULE_ALIAS_CHARDEV_MAJOR(RISCOM8_NORMAL_MAJOR);
1529 #endif /* MODULE */
1530
1531 /*
1532 * You can setup up to 4 boards (current value of RC_NBOARD)
1533 * by specifying "iobase=0xXXX iobase1=0xXXX ..." as insmod parameter.
1534 *
1535 */
1536 static int __init riscom8_init_module(void)
1537 {
1538 #ifdef MODULE
1539 int i;
1540
1541 if (iobase || iobase1 || iobase2 || iobase3) {
1542 for (i = 0; i < RC_NBOARD; i++)
1543 rc_board[i].base = 0;
1544 }
1545
1546 if (iobase)
1547 rc_board[0].base = iobase;
1548 if (iobase1)
1549 rc_board[1].base = iobase1;
1550 if (iobase2)
1551 rc_board[2].base = iobase2;
1552 if (iobase3)
1553 rc_board[3].base = iobase3;
1554 #endif /* MODULE */
1555
1556 return riscom8_init();
1557 }
1558
1559 static void __exit riscom8_exit_module(void)
1560 {
1561 int i;
1562
1563 rc_release_drivers();
1564 for (i = 0; i < RC_NBOARD; i++)
1565 if (rc_board[i].flags & RC_BOARD_PRESENT)
1566 rc_release_io_range(&rc_board[i]);
1567
1568 }
1569
1570 module_init(riscom8_init_module);
1571 module_exit(riscom8_exit_module);
Support for the Chinese Samsung S3C2440 based development boards