Merge commit 'upstream/master'
[linux-2.6] / drivers / char / riscom8.c
1 /*
2  *      linux/drivers/char/riscom.c  -- RISCom/8 multiport serial driver.
3  *
4  *      Copyright (C) 1994-1996  Dmitry Gorodchanin (pgmdsg@ibi.com)
5  *
6  *      This code is loosely based on the Linux serial driver, written by
7  *      Linus Torvalds, Theodore T'so and others. The RISCom/8 card
8  *      programming info was obtained from various drivers for other OSes
9  *      (FreeBSD, ISC, etc), but no source code from those drivers were
10  *      directly included in this driver.
11  *
12  *
13  *      This program is free software; you can redistribute it and/or modify
14  *      it under the terms of the GNU General Public License as published by
15  *      the Free Software Foundation; either version 2 of the License, or
16  *      (at your option) any later version.
17  *
18  *      This program is distributed in the hope that it will be useful,
19  *      but WITHOUT ANY WARRANTY; without even the implied warranty of
20  *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
21  *      GNU General Public License for more details.
22  *
23  *      You should have received a copy of the GNU General Public License
24  *      along with this program; if not, write to the Free Software
25  *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
26  *
27  *      Revision 1.1
28  *
29  *      ChangeLog:
30  *      Arnaldo Carvalho de Melo <acme@conectiva.com.br> - 27-Jun-2001
31  *      - get rid of check_region and several cleanups
32  */
33
34 #include <linux/module.h>
35
36 #include <linux/io.h>
37 #include <linux/kernel.h>
38 #include <linux/sched.h>
39 #include <linux/ioport.h>
40 #include <linux/interrupt.h>
41 #include <linux/errno.h>
42 #include <linux/tty.h>
43 #include <linux/mm.h>
44 #include <linux/serial.h>
45 #include <linux/fcntl.h>
46 #include <linux/major.h>
47 #include <linux/init.h>
48 #include <linux/delay.h>
49 #include <linux/tty_flip.h>
50 #include <linux/spinlock.h>
51
52 #include <linux/uaccess.h>
53
54 #include "riscom8.h"
55 #include "riscom8_reg.h"
56
57 /* Am I paranoid or not ? ;-) */
58 #define RISCOM_PARANOIA_CHECK
59
60 /*
61  * Crazy InteliCom/8 boards sometimes have swapped CTS & DSR signals.
62  * You can slightly speed up things by #undefing the following option,
63  * if you are REALLY sure that your board is correct one.
64  */
65
66 #define RISCOM_BRAIN_DAMAGED_CTS
67
68 /*
69  * The following defines are mostly for testing purposes. But if you need
70  * some nice reporting in your syslog, you can define them also.
71  */
72 #undef RC_REPORT_FIFO
73 #undef RC_REPORT_OVERRUN
74
75
76 #define RISCOM_LEGAL_FLAGS \
77         (ASYNC_HUP_NOTIFY   | ASYNC_SAK          | ASYNC_SPLIT_TERMIOS   | \
78          ASYNC_SPD_HI       | ASYNC_SPEED_VHI    | ASYNC_SESSION_LOCKOUT | \
79          ASYNC_PGRP_LOCKOUT | ASYNC_CALLOUT_NOHUP)
80
81 static struct tty_driver *riscom_driver;
82
83 static DEFINE_SPINLOCK(riscom_lock);
84
85 static struct riscom_board rc_board[RC_NBOARD] =  {
86         {
87                 .base   = RC_IOBASE1,
88         },
89         {
90                 .base   = RC_IOBASE2,
91         },
92         {
93                 .base   = RC_IOBASE3,
94         },
95         {
96                 .base   = RC_IOBASE4,
97         },
98 };
99
100 static struct riscom_port rc_port[RC_NBOARD * RC_NPORT];
101
102 /* RISCom/8 I/O ports addresses (without address translation) */
103 static unsigned short rc_ioport[] =  {
104 #if 1
105         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x09, 0x0a, 0x0b, 0x0c,
106 #else
107         0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x09, 0x0a, 0x0b, 0x0c, 0x10,
108         0x11, 0x12, 0x18, 0x28, 0x31, 0x32, 0x39, 0x3a, 0x40, 0x41, 0x61, 0x62,
109         0x63, 0x64, 0x6b, 0x70, 0x71, 0x78, 0x7a, 0x7b, 0x7f, 0x100, 0x101
110 #endif
111 };
112 #define RC_NIOPORT      ARRAY_SIZE(rc_ioport)
113
114
115 static int rc_paranoia_check(struct riscom_port const *port,
116                                     char *name, const char *routine)
117 {
118 #ifdef RISCOM_PARANOIA_CHECK
119         static const char badmagic[] = KERN_INFO
120                 "rc: Warning: bad riscom port magic number for device %s in %s\n";
121         static const char badinfo[] = KERN_INFO
122                 "rc: Warning: null riscom port for device %s in %s\n";
123
124         if (!port) {
125                 printk(badinfo, name, routine);
126                 return 1;
127         }
128         if (port->magic != RISCOM8_MAGIC) {
129                 printk(badmagic, name, routine);
130                 return 1;
131         }
132 #endif
133         return 0;
134 }
135
136 /*
137  *
138  *  Service functions for RISCom/8 driver.
139  *
140  */
141
142 /* Get board number from pointer */
143 static inline int board_No(struct riscom_board const *bp)
144 {
145         return bp - rc_board;
146 }
147
148 /* Get port number from pointer */
149 static inline int port_No(struct riscom_port const *port)
150 {
151         return RC_PORT(port - rc_port);
152 }
153
154 /* Get pointer to board from pointer to port */
155 static inline struct riscom_board *port_Board(struct riscom_port const *port)
156 {
157         return &rc_board[RC_BOARD(port - rc_port)];
158 }
159
160 /* Input Byte from CL CD180 register */
161 static inline unsigned char rc_in(struct riscom_board const *bp,
162                                                         unsigned short reg)
163 {
164         return inb(bp->base + RC_TO_ISA(reg));
165 }
166
167 /* Output Byte to CL CD180 register */
168 static inline void rc_out(struct riscom_board const *bp, unsigned short reg,
169                           unsigned char val)
170 {
171         outb(val, bp->base + RC_TO_ISA(reg));
172 }
173
174 /* Wait for Channel Command Register ready */
175 static void rc_wait_CCR(struct riscom_board const *bp)
176 {
177         unsigned long delay;
178
179         /* FIXME: need something more descriptive then 100000 :) */
180         for (delay = 100000; delay; delay--)
181                 if (!rc_in(bp, CD180_CCR))
182                         return;
183
184         printk(KERN_INFO "rc%d: Timeout waiting for CCR.\n", board_No(bp));
185 }
186
187 /*
188  *  RISCom/8 probe functions.
189  */
190
191 static int rc_request_io_range(struct riscom_board * const bp)
192 {
193         int i;
194
195         for (i = 0; i < RC_NIOPORT; i++)
196                 if (!request_region(RC_TO_ISA(rc_ioport[i]) + bp->base, 1,
197                                    "RISCom/8"))  {
198                         goto out_release;
199                 }
200         return 0;
201 out_release:
202         printk(KERN_INFO "rc%d: Skipping probe at 0x%03x. IO address in use.\n",
203                          board_No(bp), bp->base);
204         while (--i >= 0)
205                 release_region(RC_TO_ISA(rc_ioport[i]) + bp->base, 1);
206         return 1;
207 }
208
209 static void rc_release_io_range(struct riscom_board * const bp)
210 {
211         int i;
212
213         for (i = 0; i < RC_NIOPORT; i++)
214                 release_region(RC_TO_ISA(rc_ioport[i]) + bp->base, 1);
215 }
216
217 /* Reset and setup CD180 chip */
218 static void __init rc_init_CD180(struct riscom_board const *bp)
219 {
220         unsigned long flags;
221
222         spin_lock_irqsave(&riscom_lock, flags);
223
224         rc_out(bp, RC_CTOUT, 0);                   /* Clear timeout        */
225         rc_wait_CCR(bp);                           /* Wait for CCR ready   */
226         rc_out(bp, CD180_CCR, CCR_HARDRESET);      /* Reset CD180 chip     */
227         spin_unlock_irqrestore(&riscom_lock, flags);
228         msleep(50);                                /* Delay 0.05 sec       */
229         spin_lock_irqsave(&riscom_lock, flags);
230         rc_out(bp, CD180_GIVR, RC_ID);             /* Set ID for this chip */
231         rc_out(bp, CD180_GICR, 0);                 /* Clear all bits       */
232         rc_out(bp, CD180_PILR1, RC_ACK_MINT);      /* Prio for modem intr  */
233         rc_out(bp, CD180_PILR2, RC_ACK_TINT);      /* Prio for tx intr     */
234         rc_out(bp, CD180_PILR3, RC_ACK_RINT);      /* Prio for rx intr     */
235
236         /* Setting up prescaler. We need 4 ticks per 1 ms */
237         rc_out(bp, CD180_PPRH, (RC_OSCFREQ/(1000000/RISCOM_TPS)) >> 8);
238         rc_out(bp, CD180_PPRL, (RC_OSCFREQ/(1000000/RISCOM_TPS)) & 0xff);
239
240         spin_unlock_irqrestore(&riscom_lock, flags);
241 }
242
243 /* Main probing routine, also sets irq. */
244 static int __init rc_probe(struct riscom_board *bp)
245 {
246         unsigned char val1, val2;
247         int irqs = 0;
248         int retries;
249
250         bp->irq = 0;
251
252         if (rc_request_io_range(bp))
253                 return 1;
254
255         /* Are the I/O ports here ? */
256         rc_out(bp, CD180_PPRL, 0x5a);
257         outb(0xff, 0x80);
258         val1 = rc_in(bp, CD180_PPRL);
259         rc_out(bp, CD180_PPRL, 0xa5);
260         outb(0x00, 0x80);
261         val2 = rc_in(bp, CD180_PPRL);
262
263         if ((val1 != 0x5a) || (val2 != 0xa5))  {
264                 printk(KERN_ERR "rc%d: RISCom/8 Board at 0x%03x not found.\n",
265                        board_No(bp), bp->base);
266                 goto out_release;
267         }
268
269         /* It's time to find IRQ for this board */
270         for (retries = 0; retries < 5 && irqs <= 0; retries++) {
271                 irqs = probe_irq_on();
272                 rc_init_CD180(bp);               /* Reset CD180 chip         */
273                 rc_out(bp, CD180_CAR, 2);        /* Select port 2            */
274                 rc_wait_CCR(bp);
275                 rc_out(bp, CD180_CCR, CCR_TXEN); /* Enable transmitter       */
276                 rc_out(bp, CD180_IER, IER_TXRDY);/* Enable tx empty intr     */
277                 msleep(50);
278                 irqs = probe_irq_off(irqs);
279                 val1 = rc_in(bp, RC_BSR);       /* Get Board Status reg      */
280                 val2 = rc_in(bp, RC_ACK_TINT);  /* ACK interrupt             */
281                 rc_init_CD180(bp);              /* Reset CD180 again         */
282
283                 if ((val1 & RC_BSR_TINT) || (val2 != (RC_ID | GIVR_IT_TX)))  {
284                         printk(KERN_ERR "rc%d: RISCom/8 Board at 0x%03x not "
285                                         "found.\n", board_No(bp), bp->base);
286                         goto out_release;
287                 }
288         }
289
290         if (irqs <= 0)  {
291                 printk(KERN_ERR "rc%d: Can't find IRQ for RISCom/8 board "
292                                 "at 0x%03x.\n", board_No(bp), bp->base);
293                 goto out_release;
294         }
295         bp->irq = irqs;
296         bp->flags |= RC_BOARD_PRESENT;
297
298         printk(KERN_INFO "rc%d: RISCom/8 Rev. %c board detected at "
299                          "0x%03x, IRQ %d.\n",
300                board_No(bp),
301                (rc_in(bp, CD180_GFRCR) & 0x0f) + 'A',   /* Board revision */
302                bp->base, bp->irq);
303
304         return 0;
305 out_release:
306         rc_release_io_range(bp);
307         return 1;
308 }
309
310 /*
311  *
312  *  Interrupt processing routines.
313  *
314  */
315
316 static struct riscom_port *rc_get_port(struct riscom_board const *bp,
317                                                unsigned char const *what)
318 {
319         unsigned char channel;
320         struct riscom_port *port;
321
322         channel = rc_in(bp, CD180_GICR) >> GICR_CHAN_OFF;
323         if (channel < CD180_NCH)  {
324                 port = &rc_port[board_No(bp) * RC_NPORT + channel];
325                 if (port->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 int rc_send_break(struct tty_struct *tty, int length)
1254 {
1255         struct riscom_port *port = (struct riscom_port *)tty->driver_data;
1256         struct riscom_board *bp = port_Board(port);
1257         unsigned long flags;
1258
1259         if (length == 0 || length == -1)
1260                 return -EOPNOTSUPP;
1261
1262         spin_lock_irqsave(&riscom_lock, flags);
1263
1264         port->break_length = RISCOM_TPS / HZ * length;
1265         port->COR2 |= COR2_ETC;
1266         port->IER  |= IER_TXRDY;
1267         rc_out(bp, CD180_CAR, port_No(port));
1268         rc_out(bp, CD180_COR2, port->COR2);
1269         rc_out(bp, CD180_IER, port->IER);
1270         rc_wait_CCR(bp);
1271         rc_out(bp, CD180_CCR, CCR_CORCHG2);
1272         rc_wait_CCR(bp);
1273
1274         spin_unlock_irqrestore(&riscom_lock, flags);
1275         return 0;
1276 }
1277
1278 static int rc_set_serial_info(struct riscom_port *port,
1279                                      struct serial_struct __user *newinfo)
1280 {
1281         struct serial_struct tmp;
1282         struct riscom_board *bp = port_Board(port);
1283         int change_speed;
1284
1285         if (copy_from_user(&tmp, newinfo, sizeof(tmp)))
1286                 return -EFAULT;
1287
1288 #if 0
1289         if ((tmp.irq != bp->irq) ||
1290             (tmp.port != bp->base) ||
1291             (tmp.type != PORT_CIRRUS) ||
1292             (tmp.baud_base != (RC_OSCFREQ + CD180_TPC/2) / CD180_TPC) ||
1293             (tmp.custom_divisor != 0) ||
1294             (tmp.xmit_fifo_size != CD180_NFIFO) ||
1295             (tmp.flags & ~RISCOM_LEGAL_FLAGS))
1296                 return -EINVAL;
1297 #endif
1298
1299         change_speed = ((port->port.flags & ASYNC_SPD_MASK) !=
1300                         (tmp.flags & ASYNC_SPD_MASK));
1301
1302         if (!capable(CAP_SYS_ADMIN)) {
1303                 if ((tmp.close_delay != port->port.close_delay) ||
1304                     (tmp.closing_wait != port->port.closing_wait) ||
1305                     ((tmp.flags & ~ASYNC_USR_MASK) !=
1306                      (port->port.flags & ~ASYNC_USR_MASK)))
1307                         return -EPERM;
1308                 port->port.flags = ((port->port.flags & ~ASYNC_USR_MASK) |
1309                                (tmp.flags & ASYNC_USR_MASK));
1310         } else  {
1311                 port->port.flags = ((port->port.flags & ~ASYNC_FLAGS) |
1312                                (tmp.flags & ASYNC_FLAGS));
1313                 port->port.close_delay = tmp.close_delay;
1314                 port->port.closing_wait = tmp.closing_wait;
1315         }
1316         if (change_speed)  {
1317                 unsigned long flags;
1318
1319                 spin_lock_irqsave(&riscom_lock, flags);
1320                 rc_change_speed(bp, port);
1321                 spin_unlock_irqrestore(&riscom_lock, flags);
1322         }
1323         return 0;
1324 }
1325
1326 static int rc_get_serial_info(struct riscom_port *port,
1327                                      struct serial_struct __user *retinfo)
1328 {
1329         struct serial_struct tmp;
1330         struct riscom_board *bp = port_Board(port);
1331
1332         memset(&tmp, 0, sizeof(tmp));
1333         tmp.type = PORT_CIRRUS;
1334         tmp.line = port - rc_port;
1335         tmp.port = bp->base;
1336         tmp.irq  = bp->irq;
1337         tmp.flags = port->port.flags;
1338         tmp.baud_base = (RC_OSCFREQ + CD180_TPC/2) / CD180_TPC;
1339         tmp.close_delay = port->port.close_delay * HZ/100;
1340         tmp.closing_wait = port->port.closing_wait * HZ/100;
1341         tmp.xmit_fifo_size = CD180_NFIFO;
1342         return copy_to_user(retinfo, &tmp, sizeof(tmp)) ? -EFAULT : 0;
1343 }
1344
1345 static int rc_ioctl(struct tty_struct *tty, struct file *filp,
1346                     unsigned int cmd, unsigned long arg)
1347 {
1348         struct riscom_port *port = (struct riscom_port *)tty->driver_data;
1349         void __user *argp = (void __user *)arg;
1350         int retval;
1351
1352         if (rc_paranoia_check(port, tty->name, "rc_ioctl"))
1353                 return -ENODEV;
1354
1355         switch (cmd) {
1356         case TIOCGSERIAL:
1357                 lock_kernel();
1358                 retval = rc_get_serial_info(port, argp);
1359                 unlock_kernel();
1360                 break;
1361         case TIOCSSERIAL:
1362                 lock_kernel();
1363                 retval = rc_set_serial_info(port, argp);
1364                 unlock_kernel();
1365                 break;
1366         default:
1367                 retval = -ENOIOCTLCMD;
1368         }
1369         return retval;
1370 }
1371
1372 static void rc_throttle(struct tty_struct *tty)
1373 {
1374         struct riscom_port *port = (struct riscom_port *)tty->driver_data;
1375         struct riscom_board *bp;
1376         unsigned long flags;
1377
1378         if (rc_paranoia_check(port, tty->name, "rc_throttle"))
1379                 return;
1380         bp = port_Board(port);
1381
1382         spin_lock_irqsave(&riscom_lock, flags);
1383         port->MSVR &= ~MSVR_RTS;
1384         rc_out(bp, CD180_CAR, port_No(port));
1385         if (I_IXOFF(tty)) {
1386                 rc_wait_CCR(bp);
1387                 rc_out(bp, CD180_CCR, CCR_SSCH2);
1388                 rc_wait_CCR(bp);
1389         }
1390         rc_out(bp, CD180_MSVR, port->MSVR);
1391         spin_unlock_irqrestore(&riscom_lock, flags);
1392 }
1393
1394 static void rc_unthrottle(struct tty_struct *tty)
1395 {
1396         struct riscom_port *port = (struct riscom_port *)tty->driver_data;
1397         struct riscom_board *bp;
1398         unsigned long flags;
1399
1400         if (rc_paranoia_check(port, tty->name, "rc_unthrottle"))
1401                 return;
1402         bp = port_Board(port);
1403
1404         spin_lock_irqsave(&riscom_lock, flags);
1405         port->MSVR |= MSVR_RTS;
1406         rc_out(bp, CD180_CAR, port_No(port));
1407         if (I_IXOFF(tty))  {
1408                 rc_wait_CCR(bp);
1409                 rc_out(bp, CD180_CCR, CCR_SSCH1);
1410                 rc_wait_CCR(bp);
1411         }
1412         rc_out(bp, CD180_MSVR, port->MSVR);
1413         spin_unlock_irqrestore(&riscom_lock, flags);
1414 }
1415
1416 static void rc_stop(struct tty_struct *tty)
1417 {
1418         struct riscom_port *port = (struct riscom_port *)tty->driver_data;
1419         struct riscom_board *bp;
1420         unsigned long flags;
1421
1422         if (rc_paranoia_check(port, tty->name, "rc_stop"))
1423                 return;
1424
1425         bp = port_Board(port);
1426
1427         spin_lock_irqsave(&riscom_lock, flags);
1428         port->IER &= ~IER_TXRDY;
1429         rc_out(bp, CD180_CAR, port_No(port));
1430         rc_out(bp, CD180_IER, port->IER);
1431         spin_unlock_irqrestore(&riscom_lock, flags);
1432 }
1433
1434 static void rc_start(struct tty_struct *tty)
1435 {
1436         struct riscom_port *port = (struct riscom_port *)tty->driver_data;
1437         struct riscom_board *bp;
1438         unsigned long flags;
1439
1440         if (rc_paranoia_check(port, tty->name, "rc_start"))
1441                 return;
1442
1443         bp = port_Board(port);
1444
1445         spin_lock_irqsave(&riscom_lock, flags);
1446
1447         if (port->xmit_cnt && port->port.xmit_buf && !(port->IER & IER_TXRDY)) {
1448                 port->IER |= IER_TXRDY;
1449                 rc_out(bp, CD180_CAR, port_No(port));
1450                 rc_out(bp, CD180_IER, port->IER);
1451         }
1452         spin_unlock_irqrestore(&riscom_lock, flags);
1453 }
1454
1455 static void rc_hangup(struct tty_struct *tty)
1456 {
1457         struct riscom_port *port = (struct riscom_port *)tty->driver_data;
1458         struct riscom_board *bp;
1459
1460         if (rc_paranoia_check(port, tty->name, "rc_hangup"))
1461                 return;
1462
1463         bp = port_Board(port);
1464
1465         rc_shutdown_port(tty, bp, port);
1466         port->port.count = 0;
1467         port->port.flags &= ~ASYNC_NORMAL_ACTIVE;
1468         port->port.tty = NULL;
1469         wake_up_interruptible(&port->port.open_wait);
1470 }
1471
1472 static void rc_set_termios(struct tty_struct *tty,
1473                                         struct ktermios *old_termios)
1474 {
1475         struct riscom_port *port = (struct riscom_port *)tty->driver_data;
1476         unsigned long flags;
1477
1478         if (rc_paranoia_check(port, tty->name, "rc_set_termios"))
1479                 return;
1480
1481         spin_lock_irqsave(&riscom_lock, flags);
1482         rc_change_speed(port_Board(port), port);
1483         spin_unlock_irqrestore(&riscom_lock, flags);
1484
1485         if ((old_termios->c_cflag & CRTSCTS) &&
1486             !(tty->termios->c_cflag & CRTSCTS)) {
1487                 tty->hw_stopped = 0;
1488                 rc_start(tty);
1489         }
1490 }
1491
1492 static const struct tty_operations riscom_ops = {
1493         .open  = rc_open,
1494         .close = rc_close,
1495         .write = rc_write,
1496         .put_char = rc_put_char,
1497         .flush_chars = rc_flush_chars,
1498         .write_room = rc_write_room,
1499         .chars_in_buffer = rc_chars_in_buffer,
1500         .flush_buffer = rc_flush_buffer,
1501         .ioctl = rc_ioctl,
1502         .throttle = rc_throttle,
1503         .unthrottle = rc_unthrottle,
1504         .set_termios = rc_set_termios,
1505         .stop = rc_stop,
1506         .start = rc_start,
1507         .hangup = rc_hangup,
1508         .tiocmget = rc_tiocmget,
1509         .tiocmset = rc_tiocmset,
1510         .break_ctl = rc_send_break,
1511 };
1512
1513 static int __init rc_init_drivers(void)
1514 {
1515         int error;
1516         int i;
1517
1518         riscom_driver = alloc_tty_driver(RC_NBOARD * RC_NPORT);
1519         if (!riscom_driver)
1520                 return -ENOMEM;
1521
1522         riscom_driver->owner = THIS_MODULE;
1523         riscom_driver->name = "ttyL";
1524         riscom_driver->major = RISCOM8_NORMAL_MAJOR;
1525         riscom_driver->type = TTY_DRIVER_TYPE_SERIAL;
1526         riscom_driver->subtype = SERIAL_TYPE_NORMAL;
1527         riscom_driver->init_termios = tty_std_termios;
1528         riscom_driver->init_termios.c_cflag =
1529                 B9600 | CS8 | CREAD | HUPCL | CLOCAL;
1530         riscom_driver->init_termios.c_ispeed = 9600;
1531         riscom_driver->init_termios.c_ospeed = 9600;
1532         riscom_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_HARDWARE_BREAK;
1533         tty_set_operations(riscom_driver, &riscom_ops);
1534         error = tty_register_driver(riscom_driver);
1535         if (error != 0) {
1536                 put_tty_driver(riscom_driver);
1537                 printk(KERN_ERR "rc: Couldn't register RISCom/8 driver, "
1538                                 "error = %d\n", error);
1539                 return 1;
1540         }
1541         memset(rc_port, 0, sizeof(rc_port));
1542         for (i = 0; i < RC_NPORT * RC_NBOARD; i++)  {
1543                 tty_port_init(&rc_port[i].port);
1544                 rc_port[i].magic = RISCOM8_MAGIC;
1545         }
1546         return 0;
1547 }
1548
1549 static void rc_release_drivers(void)
1550 {
1551         tty_unregister_driver(riscom_driver);
1552         put_tty_driver(riscom_driver);
1553 }
1554
1555 #ifndef MODULE
1556 /*
1557  * Called at boot time.
1558  *
1559  * You can specify IO base for up to RC_NBOARD cards,
1560  * using line "riscom8=0xiobase1,0xiobase2,.." at LILO prompt.
1561  * Note that there will be no probing at default
1562  * addresses in this case.
1563  *
1564  */
1565 static int __init riscom8_setup(char *str)
1566 {
1567         int ints[RC_NBOARD];
1568         int i;
1569
1570         str = get_options(str, ARRAY_SIZE(ints), ints);
1571
1572         for (i = 0; i < RC_NBOARD; i++) {
1573                 if (i < ints[0])
1574                         rc_board[i].base = ints[i+1];
1575                 else
1576                         rc_board[i].base = 0;
1577         }
1578         return 1;
1579 }
1580
1581 __setup("riscom8=", riscom8_setup);
1582 #endif
1583
1584 static char banner[] __initdata =
1585         KERN_INFO "rc: SDL RISCom/8 card driver v1.1, (c) D.Gorodchanin "
1586                   "1994-1996.\n";
1587 static char no_boards_msg[] __initdata =
1588         KERN_INFO "rc: No RISCom/8 boards detected.\n";
1589
1590 /*
1591  * This routine must be called by kernel at boot time
1592  */
1593 static int __init riscom8_init(void)
1594 {
1595         int i;
1596         int found = 0;
1597
1598         printk(banner);
1599
1600         if (rc_init_drivers())
1601                 return -EIO;
1602
1603         for (i = 0; i < RC_NBOARD; i++)
1604                 if (rc_board[i].base && !rc_probe(&rc_board[i]))
1605                         found++;
1606         if (!found)  {
1607                 rc_release_drivers();
1608                 printk(no_boards_msg);
1609                 return -EIO;
1610         }
1611         return 0;
1612 }
1613
1614 #ifdef MODULE
1615 static int iobase;
1616 static int iobase1;
1617 static int iobase2;
1618 static int iobase3;
1619 module_param(iobase, int, 0);
1620 module_param(iobase1, int, 0);
1621 module_param(iobase2, int, 0);
1622 module_param(iobase3, int, 0);
1623
1624 MODULE_LICENSE("GPL");
1625 #endif /* MODULE */
1626
1627 /*
1628  * You can setup up to 4 boards (current value of RC_NBOARD)
1629  * by specifying "iobase=0xXXX iobase1=0xXXX ..." as insmod parameter.
1630  *
1631  */
1632 static int __init riscom8_init_module(void)
1633 {
1634 #ifdef MODULE
1635         int i;
1636
1637         if (iobase || iobase1 || iobase2 || iobase3) {
1638                 for (i = 0; i < RC_NBOARD; i++)
1639                         rc_board[i].base = 0;
1640         }
1641
1642         if (iobase)
1643                 rc_board[0].base = iobase;
1644         if (iobase1)
1645                 rc_board[1].base = iobase1;
1646         if (iobase2)
1647                 rc_board[2].base = iobase2;
1648         if (iobase3)
1649                 rc_board[3].base = iobase3;
1650 #endif /* MODULE */
1651
1652         return riscom8_init();
1653 }
1654
1655 static void __exit riscom8_exit_module(void)
1656 {
1657         int i;
1658
1659         rc_release_drivers();
1660         for (i = 0; i < RC_NBOARD; i++)
1661                 if (rc_board[i].flags & RC_BOARD_PRESENT)
1662                         rc_release_io_range(&rc_board[i]);
1663
1664 }
1665
1666 module_init(riscom8_init_module);
1667 module_exit(riscom8_exit_module);