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