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