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