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