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