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