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