/home/lenb/src/to-linus-stable branch 'acpi-2.6.12'
[linux-2.6] / drivers / sbus / char / aurora.c
1 /*      $Id: aurora.c,v 1.19 2002/01/08 16:00:16 davem Exp $
2  *      linux/drivers/sbus/char/aurora.c -- Aurora multiport driver
3  *
4  *      Copyright (c) 1999 by Oliver Aldulea (oli at bv dot ro)
5  *
6  *      This code is based on the RISCom/8 multiport serial driver written
7  *      by Dmitry Gorodchanin (pgmdsg@ibi.com), based on the Linux serial
8  *      driver, written by Linus Torvalds, Theodore T'so and others.
9  *      The Aurora multiport programming info was obtained mainly from the
10  *      Cirrus Logic CD180 documentation (available on the web), and by
11  *      doing heavy tests on the board. Many thanks to Eddie C. Dost for the
12  *      help on the sbus interface.
13  *
14  *      This program is free software; you can redistribute it and/or modify
15  *      it under the terms of the GNU General Public License as published by
16  *      the Free Software Foundation; either version 2 of the License, or
17  *      (at your option) any later version.
18  *
19  *      This program is distributed in the hope that it will be useful,
20  *      but WITHOUT ANY WARRANTY; without even the implied warranty of
21  *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
22  *      GNU General Public License for more details.
23  *
24  *      You should have received a copy of the GNU General Public License
25  *      along with this program; if not, write to the Free Software
26  *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
27  *
28  *      Revision 1.0
29  *
30  *      This is the first public release.
31  *
32  *      Most of the information you need is in the aurora.h file. Please
33  *      read that file before reading this one.
34  *
35  *      Several parts of the code do not have comments yet.
36  * 
37  * n.b.  The board can support 115.2 bit rates, but only on a few
38  * ports. The total badwidth of one chip (ports 0-7 or 8-15) is equal
39  * to OSC_FREQ div 16. In case of my board, each chip can take 6
40  * channels of 115.2 kbaud.  This information is not well-tested.
41  * 
42  * Fixed to use tty_get_baud_rate().
43  *   Theodore Ts'o <tytso@mit.edu>, 2001-Oct-12
44  */
45
46 #include <linux/module.h>
47
48 #include <linux/errno.h>
49 #include <linux/sched.h>
50 #ifdef AURORA_INT_DEBUG
51 #include <linux/timer.h>
52 #endif
53 #include <linux/interrupt.h>
54 #include <linux/tty.h>
55 #include <linux/tty_flip.h>
56 #include <linux/major.h>
57 #include <linux/string.h>
58 #include <linux/fcntl.h>
59 #include <linux/mm.h>
60 #include <linux/kernel.h>
61 #include <linux/init.h>
62 #include <linux/delay.h>
63 #include <linux/bitops.h>
64
65 #include <asm/io.h>
66 #include <asm/irq.h>
67 #include <asm/oplib.h>
68 #include <asm/system.h>
69 #include <asm/kdebug.h>
70 #include <asm/sbus.h>
71 #include <asm/uaccess.h>
72
73 #include "aurora.h"
74 #include "cd180.h"
75
76 unsigned char irqs[4] = {
77         0, 0, 0, 0
78 };
79
80 #ifdef AURORA_INT_DEBUG
81 int irqhit=0;
82 #endif
83
84 static struct tty_driver *aurora_driver;
85 static struct Aurora_board aurora_board[AURORA_NBOARD] = {
86         {0,},
87 };
88
89 static struct Aurora_port aurora_port[AURORA_TNPORTS] =  {
90         { 0, },
91 };
92
93 /* no longer used. static struct Aurora_board * IRQ_to_board[16] = { NULL, } ;*/
94 static unsigned char * tmp_buf = NULL;
95 static DECLARE_MUTEX(tmp_buf_sem);
96
97 DECLARE_TASK_QUEUE(tq_aurora);
98
99 static inline int aurora_paranoia_check(struct Aurora_port const * port,
100                                     char *name, const char *routine)
101 {
102 #ifdef AURORA_PARANOIA_CHECK
103         static const char *badmagic =
104                 KERN_DEBUG "aurora: Warning: bad aurora port magic number for device %s in %s\n";
105         static const char *badinfo =
106                 KERN_DEBUG "aurora: Warning: null aurora port for device %s in %s\n";
107
108         if (!port) {
109                 printk(badinfo, name, routine);
110                 return 1;
111         }
112         if (port->magic != AURORA_MAGIC) {
113                 printk(badmagic, name, routine);
114                 return 1;
115         }
116 #endif
117         return 0;
118 }
119
120 /*
121  * 
122  *  Service functions for aurora driver.
123  * 
124  */
125
126 /* Get board number from pointer */
127 extern inline int board_No (struct Aurora_board const * bp)
128 {
129         return bp - aurora_board;
130 }
131
132 /* Get port number from pointer */
133 extern inline int port_No (struct Aurora_port const * port)
134 {
135         return AURORA_PORT(port - aurora_port); 
136 }
137
138 /* Get pointer to board from pointer to port */
139 extern inline struct Aurora_board * port_Board(struct Aurora_port const * port)
140 {
141         return &aurora_board[AURORA_BOARD(port - aurora_port)];
142 }
143
144 /* Wait for Channel Command Register ready */
145 extern inline void aurora_wait_CCR(struct aurora_reg128 * r)
146 {
147         unsigned long delay;
148
149 #ifdef AURORA_DEBUG
150 printk("aurora_wait_CCR\n");
151 #endif
152         /* FIXME: need something more descriptive than 100000 :) */
153         for (delay = 100000; delay; delay--) 
154                 if (!sbus_readb(&r->r[CD180_CCR]))
155                         return;
156         printk(KERN_DEBUG "aurora: Timeout waiting for CCR.\n");
157 }
158
159 /*
160  *  aurora probe functions.
161  */
162
163 /* Must be called with enabled interrupts */
164 extern inline void aurora_long_delay(unsigned long delay)
165 {
166         unsigned long i;
167
168 #ifdef AURORA_DEBUG
169         printk("aurora_long_delay: start\n");
170 #endif
171         for (i = jiffies + delay; time_before(jiffies, i); ) ;
172 #ifdef AURORA_DEBUG
173         printk("aurora_long_delay: end\n");
174 #endif
175 }
176
177 /* Reset and setup CD180 chip */
178 static int aurora_init_CD180(struct Aurora_board * bp, int chip)
179 {
180         unsigned long flags;
181         int id;
182         
183 #ifdef AURORA_DEBUG
184         printk("aurora_init_CD180: start %d:%d\n",
185                board_No(bp), chip);
186 #endif
187         save_flags(flags); cli();
188         sbus_writeb(0, &bp->r[chip]->r[CD180_CAR]);
189         sbus_writeb(0, &bp->r[chip]->r[CD180_GSVR]);
190
191         /* Wait for CCR ready        */
192         aurora_wait_CCR(bp->r[chip]);
193
194         /* Reset CD180 chip          */
195         sbus_writeb(CCR_HARDRESET, &bp->r[chip]->r[CD180_CCR]);
196         udelay(1);
197         sti();
198         id=1000;
199         while((--id) &&
200               (sbus_readb(&bp->r[chip]->r[CD180_GSVR])!=0xff))udelay(100);
201         if(!id) {
202                 printk(KERN_ERR "aurora%d: Chip %d failed init.\n",
203                        board_No(bp), chip);
204                 restore_flags(flags);
205                 return(-1);
206         }
207         cli();
208         sbus_writeb((board_No(bp)<<5)|((chip+1)<<3),
209                     &bp->r[chip]->r[CD180_GSVR]); /* Set ID for this chip      */
210         sbus_writeb(0x80|bp->ACK_MINT,
211                     &bp->r[chip]->r[CD180_MSMR]); /* Prio for modem intr       */
212         sbus_writeb(0x80|bp->ACK_TINT,
213                     &bp->r[chip]->r[CD180_TSMR]); /* Prio for transmitter intr */
214         sbus_writeb(0x80|bp->ACK_RINT,
215                     &bp->r[chip]->r[CD180_RSMR]); /* Prio for receiver intr    */
216         /* Setting up prescaler. We need 4 tick per 1 ms */
217         sbus_writeb((bp->oscfreq/(1000000/AURORA_TPS)) >> 8,
218                     &bp->r[chip]->r[CD180_PPRH]);
219         sbus_writeb((bp->oscfreq/(1000000/AURORA_TPS)) & 0xff,
220                     &bp->r[chip]->r[CD180_PPRL]);
221
222         sbus_writeb(SRCR_AUTOPRI|SRCR_GLOBPRI,
223                     &bp->r[chip]->r[CD180_SRCR]);
224
225         id = sbus_readb(&bp->r[chip]->r[CD180_GFRCR]);
226         printk(KERN_INFO "aurora%d: Chip %d id %02x: ",
227                board_No(bp), chip,id);
228         if(sbus_readb(&bp->r[chip]->r[CD180_SRCR]) & 128) {
229                 switch (id) {
230                         case 0x82:printk("CL-CD1864 rev A\n");break;
231                         case 0x83:printk("CL-CD1865 rev A\n");break;
232                         case 0x84:printk("CL-CD1865 rev B\n");break;
233                         case 0x85:printk("CL-CD1865 rev C\n");break;
234                         default:printk("Unknown.\n");
235                 };
236         } else {
237                 switch (id) {
238                         case 0x81:printk("CL-CD180 rev B\n");break;
239                         case 0x82:printk("CL-CD180 rev C\n");break;
240                         default:printk("Unknown.\n");
241                 };
242         }
243         restore_flags(flags);
244 #ifdef AURORA_DEBUG
245         printk("aurora_init_CD180: end\n");
246 #endif
247         return 0;
248 }
249
250 static int valid_irq(unsigned char irq)
251 {
252 int i;
253 for(i=0;i<TYPE_1_IRQS;i++)
254         if (type_1_irq[i]==irq) return 1;
255 return 0;
256 }
257
258 static irqreturn_t aurora_interrupt(int irq, void * dev_id, struct pt_regs * regs);
259
260 /* Main probing routine, also sets irq. */
261 static int aurora_probe(void)
262 {
263         struct sbus_bus *sbus;
264         struct sbus_dev *sdev;
265         int grrr;
266         char buf[30];
267         int bn = 0;
268         struct Aurora_board *bp;
269
270         for_each_sbus(sbus) {
271                 for_each_sbusdev(sdev, sbus) {
272 /*                      printk("Try: %x %s\n",sdev,sdev->prom_name);*/
273                         if (!strcmp(sdev->prom_name, "sio16")) {
274 #ifdef AURORA_DEBUG
275                                 printk(KERN_INFO "aurora: sio16 at %p\n",sdev);
276 #endif
277                                 if((sdev->reg_addrs[0].reg_size!=1) &&
278                                    (sdev->reg_addrs[1].reg_size!=128) &&
279                                    (sdev->reg_addrs[2].reg_size!=128) &&
280                                    (sdev->reg_addrs[3].reg_size!=4)) {
281                                         printk(KERN_ERR "aurora%d: registers' sizes "
282                                                "do not match.\n", bn);
283                                         break;
284                                 }
285                                 bp = &aurora_board[bn];
286                                 bp->r0 = (struct aurora_reg1 *)
287                                         sbus_ioremap(&sdev->resource[0], 0,
288                                                      sdev->reg_addrs[0].reg_size,
289                                                      "sio16");
290                                 if (bp->r0 == NULL) {
291                                         printk(KERN_ERR "aurora%d: can't map "
292                                                "reg_addrs[0]\n", bn);
293                                         break;
294                                 }
295 #ifdef AURORA_DEBUG
296                                 printk("Map reg 0: %p\n", bp->r0);
297 #endif
298                                 bp->r[0] = (struct aurora_reg128 *)
299                                         sbus_ioremap(&sdev->resource[1], 0,
300                                                      sdev->reg_addrs[1].reg_size,
301                                                      "sio16");
302                                 if (bp->r[0] == NULL) {
303                                         printk(KERN_ERR "aurora%d: can't map "
304                                                "reg_addrs[1]\n", bn);
305                                         break;
306                                 }
307 #ifdef AURORA_DEBUG
308                                 printk("Map reg 1: %p\n", bp->r[0]);
309 #endif
310                                 bp->r[1] = (struct aurora_reg128 *)
311                                         sbus_ioremap(&sdev->resource[2], 0,
312                                                      sdev->reg_addrs[2].reg_size,
313                                                      "sio16");
314                                 if (bp->r[1] == NULL) {
315                                         printk(KERN_ERR "aurora%d: can't map "
316                                                "reg_addrs[2]\n", bn);
317                                         break;
318                                 }
319 #ifdef AURORA_DEBUG
320                                 printk("Map reg 2: %p\n", bp->r[1]);
321 #endif
322                                 bp->r3 = (struct aurora_reg4 *)
323                                         sbus_ioremap(&sdev->resource[3], 0,
324                                                      sdev->reg_addrs[3].reg_size,
325                                                      "sio16");
326                                 if (bp->r3 == NULL) {
327                                         printk(KERN_ERR "aurora%d: can't map "
328                                                "reg_addrs[3]\n", bn);
329                                         break;
330                                 }
331 #ifdef AURORA_DEBUG
332                                 printk("Map reg 3: %p\n", bp->r3);
333 #endif
334                                 /* Variables setup */
335                                 bp->flags = 0;
336 #ifdef AURORA_DEBUG
337                                 grrr=prom_getint(sdev->prom_node,"intr");
338                                 printk("intr pri %d\n", grrr);
339 #endif
340                                 if ((bp->irq=irqs[bn]) && valid_irq(bp->irq) &&
341                                     !request_irq(bp->irq|0x30, aurora_interrupt, SA_SHIRQ, "sio16", bp)) {
342                                         free_irq(bp->irq|0x30, bp);
343                                 } else
344                                 if ((bp->irq=prom_getint(sdev->prom_node, "bintr")) && valid_irq(bp->irq) &&
345                                     !request_irq(bp->irq|0x30, aurora_interrupt, SA_SHIRQ, "sio16", bp)) {
346                                         free_irq(bp->irq|0x30, bp);
347                                 } else
348                                 if ((bp->irq=prom_getint(sdev->prom_node, "intr")) && valid_irq(bp->irq) &&
349                                     !request_irq(bp->irq|0x30, aurora_interrupt, SA_SHIRQ, "sio16", bp)) {
350                                         free_irq(bp->irq|0x30, bp);
351                                 } else
352                                 for(grrr=0;grrr<TYPE_1_IRQS;grrr++) {
353                                         if ((bp->irq=type_1_irq[grrr])&&!request_irq(bp->irq|0x30, aurora_interrupt, SA_SHIRQ, "sio16", bp)) {
354                                                 free_irq(bp->irq|0x30, bp);
355                                                 break;
356                                         } else {
357                                         printk(KERN_ERR "aurora%d: Could not get an irq for this board !!!\n",bn);
358                                         bp->flags=0xff;
359                                         }
360                                 }
361                                 if(bp->flags==0xff)break;
362                                 printk(KERN_INFO "aurora%d: irq %d\n",bn,bp->irq&0x0f);
363                                 buf[0]=0;
364                                 grrr=prom_getproperty(sdev->prom_node,"dtr_rts",buf,sizeof(buf));
365                                 if(!strcmp(buf,"swapped")){
366                                         printk(KERN_INFO "aurora%d: Swapped DTR and RTS\n",bn);
367                                         bp->DTR=MSVR_RTS;
368                                         bp->RTS=MSVR_DTR;
369                                         bp->MSVDTR=CD180_MSVRTS;
370                                         bp->MSVRTS=CD180_MSVDTR;
371                                         bp->flags|=AURORA_BOARD_DTR_FLOW_OK;
372                                         }else{
373                                         #ifdef AURORA_FORCE_DTR_FLOW
374                                         printk(KERN_INFO "aurora%d: Forcing swapped DTR-RTS\n",bn);
375                                         bp->DTR=MSVR_RTS;
376                                         bp->RTS=MSVR_DTR;
377                                         bp->MSVDTR=CD180_MSVRTS;
378                                         bp->MSVRTS=CD180_MSVDTR;
379                                         bp->flags|=AURORA_BOARD_DTR_FLOW_OK;
380                                         #else
381                                         printk(KERN_INFO "aurora%d: Normal DTR and RTS\n",bn);
382                                         bp->DTR=MSVR_DTR;
383                                         bp->RTS=MSVR_RTS;
384                                         bp->MSVDTR=CD180_MSVDTR;
385                                         bp->MSVRTS=CD180_MSVRTS;
386                                         #endif
387                                 }
388                                 bp->oscfreq=prom_getint(sdev->prom_node,"clk")*100;
389                                 printk(KERN_INFO "aurora%d: Oscillator: %d Hz\n",bn,bp->oscfreq);
390                                 grrr=prom_getproperty(sdev->prom_node,"chip",buf,sizeof(buf));
391                                 printk(KERN_INFO "aurora%d: Chips: %s\n",bn,buf);
392                                 grrr=prom_getproperty(sdev->prom_node,"manu",buf,sizeof(buf));
393                                 printk(KERN_INFO "aurora%d: Manufacturer: %s\n",bn,buf);
394                                 grrr=prom_getproperty(sdev->prom_node,"model",buf,sizeof(buf));
395                                 printk(KERN_INFO "aurora%d: Model: %s\n",bn,buf);
396                                 grrr=prom_getproperty(sdev->prom_node,"rev",buf,sizeof(buf));
397                                 printk(KERN_INFO "aurora%d: Revision: %s\n",bn,buf);
398                                 grrr=prom_getproperty(sdev->prom_node,"mode",buf,sizeof(buf));
399                                 printk(KERN_INFO "aurora%d: Mode: %s\n",bn,buf);
400                                 #ifdef MODULE
401                                 bp->count=0;
402                                 #endif
403                                 bp->flags = AURORA_BOARD_PRESENT;
404                                 /* hardware ack */
405                                 bp->ACK_MINT=1;
406                                 bp->ACK_TINT=2;
407                                 bp->ACK_RINT=3;
408                                 bn++;
409                         }
410                 }
411         }
412         return bn;
413 }
414
415 static void aurora_release_io_range(struct Aurora_board *bp)
416 {
417         sbus_iounmap((unsigned long)bp->r0, 1);
418         sbus_iounmap((unsigned long)bp->r[0], 128);
419         sbus_iounmap((unsigned long)bp->r[1], 128);
420         sbus_iounmap((unsigned long)bp->r3, 4);
421 }
422
423 extern inline void aurora_mark_event(struct Aurora_port * port, int event)
424 {
425 #ifdef AURORA_DEBUG
426         printk("aurora_mark_event: start\n");
427 #endif
428         set_bit(event, &port->event);
429         queue_task(&port->tqueue, &tq_aurora);
430         mark_bh(AURORA_BH);
431 #ifdef AURORA_DEBUG
432         printk("aurora_mark_event: end\n");
433 #endif
434 }
435
436 static __inline__ struct Aurora_port * aurora_get_port(struct Aurora_board const * bp,
437                                                        int chip,
438                                                        unsigned char const *what)
439 {
440         unsigned char channel;
441         struct Aurora_port * port;
442
443         channel = ((chip << 3) |
444                    ((sbus_readb(&bp->r[chip]->r[CD180_GSCR]) & GSCR_CHAN) >> GSCR_CHAN_OFF));
445         port = &aurora_port[board_No(bp) * AURORA_NPORT * AURORA_NCD180 + channel];
446         if (port->flags & ASYNC_INITIALIZED)
447                 return port;
448
449         printk(KERN_DEBUG "aurora%d: %s interrupt from invalid port %d\n",
450                board_No(bp), what, channel);
451         return NULL;
452 }
453
454 static void aurora_receive_exc(struct Aurora_board const * bp, int chip)
455 {
456         struct Aurora_port *port;
457         struct tty_struct *tty;
458         unsigned char status;
459         unsigned char ch;
460         
461         if (!(port = aurora_get_port(bp, chip, "Receive_x")))
462                 return;
463
464         tty = port->tty;
465         if (tty->flip.count >= TTY_FLIPBUF_SIZE)  {
466 #ifdef AURORA_INTNORM
467                 printk("aurora%d: port %d: Working around flip buffer overflow.\n",
468                        board_No(bp), port_No(port));
469 #endif
470                 return;
471         }
472         
473 #ifdef AURORA_REPORT_OVERRUN    
474         status = sbus_readb(&bp->r[chip]->r[CD180_RCSR]);
475         if (status & RCSR_OE)  {
476                 port->overrun++;
477 #if 1
478                 printk("aurora%d: port %d: Overrun. Total %ld overruns.\n",
479                        board_No(bp), port_No(port), port->overrun);
480 #endif          
481         }
482         status &= port->mark_mask;
483 #else   
484         status = sbus_readb(&bp->r[chip]->r[CD180_RCSR]) & port->mark_mask;
485 #endif  
486         ch = sbus_readb(&bp->r[chip]->r[CD180_RDR]);
487         if (!status)
488                 return;
489
490         if (status & RCSR_TOUT)  {
491 /*              printk("aurora%d: port %d: Receiver timeout. Hardware problems ?\n",
492                        board_No(bp), port_No(port));*/
493                 return;
494                 
495         } else if (status & RCSR_BREAK)  {
496                 printk(KERN_DEBUG "aurora%d: port %d: Handling break...\n",
497                        board_No(bp), port_No(port));
498                 *tty->flip.flag_buf_ptr++ = TTY_BREAK;
499                 if (port->flags & ASYNC_SAK)
500                         do_SAK(tty);
501                 
502         } else if (status & RCSR_PE) 
503                 *tty->flip.flag_buf_ptr++ = TTY_PARITY;
504         
505         else if (status & RCSR_FE) 
506                 *tty->flip.flag_buf_ptr++ = TTY_FRAME;
507         
508         else if (status & RCSR_OE)
509                 *tty->flip.flag_buf_ptr++ = TTY_OVERRUN;
510         
511         else
512                 *tty->flip.flag_buf_ptr++ = 0;
513         
514         *tty->flip.char_buf_ptr++ = ch;
515         tty->flip.count++;
516         queue_task(&tty->flip.tqueue, &tq_timer);
517 }
518
519 static void aurora_receive(struct Aurora_board const * bp, int chip)
520 {
521         struct Aurora_port *port;
522         struct tty_struct *tty;
523         unsigned char count,cnt;
524
525         if (!(port = aurora_get_port(bp, chip, "Receive")))
526                 return;
527         
528         tty = port->tty;
529         
530         count = sbus_readb(&bp->r[chip]->r[CD180_RDCR]);
531
532 #ifdef AURORA_REPORT_FIFO
533         port->hits[count > 8 ? 9 : count]++;
534 #endif
535
536         while (count--)  {
537                 if (tty->flip.count >= TTY_FLIPBUF_SIZE)  {
538 #ifdef AURORA_INTNORM
539                         printk("aurora%d: port %d: Working around flip buffer overflow.\n",
540                                board_No(bp), port_No(port));
541 #endif
542                         break;
543                 }
544                 cnt = sbus_readb(&bp->r[chip]->r[CD180_RDR]);
545                 *tty->flip.char_buf_ptr++ = cnt;
546                 *tty->flip.flag_buf_ptr++ = 0;
547                 tty->flip.count++;
548         }
549         queue_task(&tty->flip.tqueue, &tq_timer);
550 }
551
552 static void aurora_transmit(struct Aurora_board const * bp, int chip)
553 {
554         struct Aurora_port *port;
555         struct tty_struct *tty;
556         unsigned char count;
557         
558         if (!(port = aurora_get_port(bp, chip, "Transmit")))
559                 return;
560                 
561         tty = port->tty;
562         
563         if (port->SRER & SRER_TXEMPTY)  {
564                 /* FIFO drained */
565                 sbus_writeb(port_No(port) & 7,
566                             &bp->r[chip]->r[CD180_CAR]);
567                 udelay(1);
568                 port->SRER &= ~SRER_TXEMPTY;
569                 sbus_writeb(port->SRER, &bp->r[chip]->r[CD180_SRER]);
570                 return;
571         }
572         
573         if ((port->xmit_cnt <= 0 && !port->break_length)
574             || tty->stopped || tty->hw_stopped)  {
575                 sbus_writeb(port_No(port) & 7,
576                             &bp->r[chip]->r[CD180_CAR]);
577                 udelay(1);
578                 port->SRER &= ~SRER_TXRDY;
579                 sbus_writeb(port->SRER,
580                             &bp->r[chip]->r[CD180_SRER]);
581                 return;
582         }
583         
584         if (port->break_length)  {
585                 if (port->break_length > 0)  {
586                         if (port->COR2 & COR2_ETC)  {
587                                 sbus_writeb(CD180_C_ESC,
588                                             &bp->r[chip]->r[CD180_TDR]);
589                                 sbus_writeb(CD180_C_SBRK,
590                                             &bp->r[chip]->r[CD180_TDR]);
591                                 port->COR2 &= ~COR2_ETC;
592                         }
593                         count = min(port->break_length, 0xff);
594                         sbus_writeb(CD180_C_ESC,
595                                     &bp->r[chip]->r[CD180_TDR]);
596                         sbus_writeb(CD180_C_DELAY,
597                                     &bp->r[chip]->r[CD180_TDR]);
598                         sbus_writeb(count,
599                                     &bp->r[chip]->r[CD180_TDR]);
600                         if (!(port->break_length -= count))
601                                 port->break_length--;
602                 } else  {
603                         sbus_writeb(CD180_C_ESC,
604                                     &bp->r[chip]->r[CD180_TDR]);
605                         sbus_writeb(CD180_C_EBRK,
606                                     &bp->r[chip]->r[CD180_TDR]);
607                         sbus_writeb(port->COR2,
608                                     &bp->r[chip]->r[CD180_COR2]);
609                         aurora_wait_CCR(bp->r[chip]);
610                         sbus_writeb(CCR_CORCHG2,
611                                     &bp->r[chip]->r[CD180_CCR]);
612                         port->break_length = 0;
613                 }
614                 return;
615         }
616         
617         count = CD180_NFIFO;
618         do {
619                 u8 byte = port->xmit_buf[port->xmit_tail++];
620
621                 sbus_writeb(byte, &bp->r[chip]->r[CD180_TDR]);
622                 port->xmit_tail = port->xmit_tail & (SERIAL_XMIT_SIZE-1);
623                 if (--port->xmit_cnt <= 0)
624                         break;
625         } while (--count > 0);
626         
627         if (port->xmit_cnt <= 0)  {
628                 sbus_writeb(port_No(port) & 7,
629                             &bp->r[chip]->r[CD180_CAR]);
630                 udelay(1);
631                 port->SRER &= ~SRER_TXRDY;
632                 sbus_writeb(port->SRER,
633                             &bp->r[chip]->r[CD180_SRER]);
634         }
635         if (port->xmit_cnt <= port->wakeup_chars)
636                 aurora_mark_event(port, RS_EVENT_WRITE_WAKEUP);
637 }
638
639 static void aurora_check_modem(struct Aurora_board const * bp, int chip)
640 {
641         struct Aurora_port *port;
642         struct tty_struct *tty;
643         unsigned char mcr;
644         
645         if (!(port = aurora_get_port(bp, chip, "Modem")))
646                 return;
647                 
648         tty = port->tty;
649         
650         mcr = sbus_readb(&bp->r[chip]->r[CD180_MCR]);
651         if (mcr & MCR_CDCHG)  {
652                 if (sbus_readb(&bp->r[chip]->r[CD180_MSVR]) & MSVR_CD) 
653                         wake_up_interruptible(&port->open_wait);
654                 else
655                         schedule_task(&port->tqueue_hangup);
656         }
657         
658 /* We don't have such things yet. My aurora board has DTR and RTS swapped, but that doesn't count in this driver. Let's hope
659  * Aurora didn't made any boards with CTS or DSR broken...
660  */
661 /* #ifdef AURORA_BRAIN_DAMAGED_CTS
662         if (mcr & MCR_CTSCHG)  {
663                 if (aurora_in(bp, CD180_MSVR) & MSVR_CTS)  {
664                         tty->hw_stopped = 0;
665                         port->SRER |= SRER_TXRDY;
666                         if (port->xmit_cnt <= port->wakeup_chars)
667                                 aurora_mark_event(port, RS_EVENT_WRITE_WAKEUP);
668                 } else  {
669                         tty->hw_stopped = 1;
670                         port->SRER &= ~SRER_TXRDY;
671                 }
672                 sbus_writeb(port->SRER, &bp->r[chip]->r[CD180_SRER]);
673         }
674         if (mcr & MCR_DSRCHG)  {
675                 if (aurora_in(bp, CD180_MSVR) & MSVR_DSR)  {
676                         tty->hw_stopped = 0;
677                         port->SRER |= SRER_TXRDY;
678                         if (port->xmit_cnt <= port->wakeup_chars)
679                                 aurora_mark_event(port, RS_EVENT_WRITE_WAKEUP);
680                 } else  {
681                         tty->hw_stopped = 1;
682                         port->SRER &= ~SRER_TXRDY;
683                 }
684                 sbus_writeb(port->SRER, &bp->r[chip]->r[CD180_SRER]);
685         }
686 #endif AURORA_BRAIN_DAMAGED_CTS */
687         
688         /* Clear change bits */
689         sbus_writeb(0, &bp->r[chip]->r[CD180_MCR]);
690 }
691
692 /* The main interrupt processing routine */
693 static irqreturn_t aurora_interrupt(int irq, void * dev_id, struct pt_regs * regs)
694 {
695         unsigned char status;
696         unsigned char ack,chip/*,chip_id*/;
697         struct Aurora_board * bp = (struct Aurora_board *) dev_id;
698         unsigned long loop = 0;
699
700 #ifdef AURORA_INT_DEBUG
701         printk("IRQ%d %d\n",irq,++irqhit);
702 #ifdef AURORA_FLOODPRO
703         if (irqhit>=AURORA_FLOODPRO)
704                 sbus_writeb(8, &bp->r0->r);
705 #endif
706 #endif
707         
708 /* old  bp = IRQ_to_board[irq&0x0f];*/
709         
710         if (!bp || !(bp->flags & AURORA_BOARD_ACTIVE))
711                 return IRQ_NONE;
712
713 /*      The while() below takes care of this.
714         status = sbus_readb(&bp->r[0]->r[CD180_SRSR]);
715 #ifdef AURORA_INT_DEBUG
716         printk("mumu: %02x\n", status);
717 #endif
718         if (!(status&SRSR_ANYINT))
719                 return IRQ_NONE; * Nobody has anything to say, so exit *
720 */
721         while ((loop++ < 48) &&
722                (status = sbus_readb(&bp->r[0]->r[CD180_SRSR]) & SRSR_ANYINT)){
723 #ifdef AURORA_INT_DEBUG
724                 printk("SRSR: %02x\n", status);
725 #endif
726                 if (status & SRSR_REXT) {
727                         ack = sbus_readb(&bp->r3->r[bp->ACK_RINT]);
728 #ifdef AURORA_INT_DEBUG
729                         printk("R-ACK %02x\n", ack);
730 #endif
731                         if ((ack >> 5) == board_No(bp)) {
732                                 if ((chip=((ack>>3)&3)-1) < AURORA_NCD180) {
733                                         if ((ack&GSVR_ITMASK)==GSVR_IT_RGD) {
734                                                 aurora_receive(bp,chip);
735                                                 sbus_writeb(0,
736                                                          &bp->r[chip]->r[CD180_EOSRR]);
737                                         } else if ((ack & GSVR_ITMASK) == GSVR_IT_REXC) {
738                                                 aurora_receive_exc(bp,chip);
739                                                 sbus_writeb(0,
740                                                          &bp->r[chip]->r[CD180_EOSRR]);
741                                         }
742                                 }
743                         }
744                 } else if (status & SRSR_TEXT) {
745                         ack = sbus_readb(&bp->r3->r[bp->ACK_TINT]);
746 #ifdef AURORA_INT_DEBUG
747                         printk("T-ACK %02x\n", ack);
748 #endif
749                         if ((ack >> 5) == board_No(bp)) {
750                                 if ((chip=((ack>>3)&3)-1) < AURORA_NCD180) {
751                                         if ((ack&GSVR_ITMASK)==GSVR_IT_TX) {
752                                                 aurora_transmit(bp,chip);
753                                                 sbus_writeb(0,
754                                                          &bp->r[chip]->r[CD180_EOSRR]);
755                                         }
756                                 }
757                         }
758                 } else if (status & SRSR_MEXT) {
759                         ack = sbus_readb(&bp->r3->r[bp->ACK_MINT]);
760 #ifdef AURORA_INT_DEBUG
761                         printk("M-ACK %02x\n", ack);
762 #endif
763                         if ((ack >> 5) == board_No(bp)) {
764                                 if ((chip = ((ack>>3)&3)-1) < AURORA_NCD180) {
765                                         if ((ack&GSVR_ITMASK)==GSVR_IT_MDM) {
766                                                 aurora_check_modem(bp,chip);
767                                                 sbus_writeb(0,
768                                                          &bp->r[chip]->r[CD180_EOSRR]);
769                                         }
770                                 }
771                         }
772                 }
773         }
774 /* I guess this faster code can be used with CD1865, using AUROPRI and GLOBPRI. */
775 #if 0
776         while ((loop++ < 48)&&(status=bp->r[0]->r[CD180_SRSR]&SRSR_ANYINT)){
777 #ifdef AURORA_INT_DEBUG
778                 printk("SRSR: %02x\n",status);
779 #endif
780                 ack = sbus_readb(&bp->r3->r[0]);
781 #ifdef AURORA_INT_DEBUG
782                 printk("ACK: %02x\n",ack);
783 #endif
784                 if ((ack>>5)==board_No(bp)) {
785                         if ((chip=((ack>>3)&3)-1) < AURORA_NCD180) {
786                                 ack&=GSVR_ITMASK;
787                                 if (ack==GSVR_IT_RGD) {
788                                         aurora_receive(bp,chip);
789                                         sbus_writeb(0,
790                                                     &bp->r[chip]->r[CD180_EOSRR]);
791                                 } else if (ack==GSVR_IT_REXC) {
792                                         aurora_receive_exc(bp,chip);
793                                         sbus_writeb(0,
794                                                     &bp->r[chip]->r[CD180_EOSRR]);
795                                 } else if (ack==GSVR_IT_TX) {
796                                         aurora_transmit(bp,chip);
797                                         sbus_writeb(0,
798                                                     &bp->r[chip]->r[CD180_EOSRR]);
799                                 } else if (ack==GSVR_IT_MDM) {
800                                         aurora_check_modem(bp,chip);
801                                         sbus_writeb(0,
802                                                     &bp->r[chip]->r[CD180_EOSRR]);
803                                 }
804                         }
805                 }
806         }
807 #endif
808
809 /* This is the old handling routine, used in riscom8 for only one CD180. I keep it here for reference. */
810 #if 0
811         for(chip=0;chip<AURORA_NCD180;chip++){
812                 chip_id=(board_No(bp)<<5)|((chip+1)<<3);
813                 loop=0;
814                 while ((loop++ < 1) &&
815                        ((status = sbus_readb(&bp->r[chip]->r[CD180_SRSR])) &
816                         (SRSR_TEXT | SRSR_MEXT | SRSR_REXT))) {
817
818                         if (status & SRSR_REXT) {
819                                 ack = sbus_readb(&bp->r3->r[bp->ACK_RINT]);
820                                 if (ack == (chip_id | GSVR_IT_RGD)) {
821 #ifdef AURORA_INTMSG
822                                         printk("RX ACK\n");
823 #endif
824                                         aurora_receive(bp,chip);
825                                 } else if (ack == (chip_id | GSVR_IT_REXC)) {
826 #ifdef AURORA_INTMSG
827                                         printk("RXC ACK\n");
828 #endif
829                                         aurora_receive_exc(bp,chip);
830                                 } else {
831 #ifdef AURORA_INTNORM
832                                         printk("aurora%d-%d: Bad receive ack 0x%02x.\n",
833                                                board_No(bp), chip, ack);
834 #endif
835                                 }
836                         } else if (status & SRSR_TEXT) {
837                                 ack = sbus_readb(&bp->r3->r[bp->ACK_TINT]);
838                                 if (ack == (chip_id | GSVR_IT_TX)){
839 #ifdef AURORA_INTMSG
840                                         printk("TX ACK\n");
841 #endif
842                                         aurora_transmit(bp,chip);
843                                 } else {
844 #ifdef AURORA_INTNORM
845                                         printk("aurora%d-%d: Bad transmit ack 0x%02x.\n",
846                                                board_No(bp), chip, ack);
847 #endif
848                                 }
849                         } else  if (status & SRSR_MEXT)  {
850                                 ack = sbus_readb(&bp->r3->r[bp->ACK_MINT]);
851                                 if (ack == (chip_id | GSVR_IT_MDM)){
852 #ifdef AURORA_INTMSG
853                                         printk("MDM ACK\n");
854 #endif
855                                         aurora_check_modem(bp,chip);
856                                 } else {
857 #ifdef AURORA_INTNORM
858                                         printk("aurora%d-%d: Bad modem ack 0x%02x.\n",
859                                                board_No(bp), chip, ack);
860 #endif
861                                 }
862                         }
863                         sbus_writeb(0, &bp->r[chip]->r[CD180_EOSRR]);
864                 }
865         }
866 #endif
867
868         return IRQ_HANDLED;
869 }
870
871 #ifdef AURORA_INT_DEBUG
872 static void aurora_timer (unsigned long ignored);
873
874 static struct timer_list aurora_poll_timer =
875                         TIMER_INITIALIZER(aurora_timer, 0, 0);
876
877 static void
878 aurora_timer (unsigned long ignored)
879 {
880         unsigned long flags;
881         int i;
882
883         save_flags(flags); cli();
884
885         printk("SRSR: %02x,%02x - ",
886                sbus_readb(&aurora_board[0].r[0]->r[CD180_SRSR]),
887                sbus_readb(&aurora_board[0].r[1]->r[CD180_SRSR]));
888         for (i = 0; i < 4; i++) {
889                 udelay(1);
890                 printk("%02x ",
891                        sbus_readb(&aurora_board[0].r3->r[i]));
892         }
893         printk("\n");
894
895         aurora_poll_timer.expires = jiffies + 300;
896         add_timer (&aurora_poll_timer);
897
898         restore_flags(flags);
899 }
900 #endif
901
902 /*
903  *  Routines for open & close processing.
904  */
905
906 /* Called with disabled interrupts */
907 static int aurora_setup_board(struct Aurora_board * bp)
908 {
909         int error;
910         
911 #ifdef AURORA_ALLIRQ
912         int i;
913         for (i = 0; i < AURORA_ALLIRQ; i++) {
914                 error = request_irq(allirq[i]|0x30, aurora_interrupt, SA_SHIRQ,
915                                     "sio16", bp);
916                 if (error)
917                         printk(KERN_ERR "IRQ%d request error %d\n",
918                                allirq[i], error);
919         }
920 #else
921         error = request_irq(bp->irq|0x30, aurora_interrupt, SA_SHIRQ,
922                             "sio16", bp);
923         if (error) {
924                 printk(KERN_ERR "IRQ request error %d\n", error);
925                 return error;
926         }
927 #endif
928         /* Board reset */
929         sbus_writeb(0, &bp->r0->r);
930         udelay(1);
931         if (bp->flags & AURORA_BOARD_TYPE_2) {
932                 /* unknown yet */
933         } else {
934                 sbus_writeb((AURORA_CFG_ENABLE_IO | AURORA_CFG_ENABLE_IRQ |
935                              (((bp->irq)&0x0f)>>2)),
936                             &bp->r0->r);
937         }
938         udelay(10000);
939
940         if (aurora_init_CD180(bp,0))error=1;error=0;
941         if (aurora_init_CD180(bp,1))error++;
942         if (error == AURORA_NCD180) {
943                 printk(KERN_ERR "Both chips failed initialisation.\n");
944                 return -EIO;
945         }
946
947 #ifdef AURORA_INT_DEBUG
948         aurora_poll_timer.expires= jiffies + 1;
949         add_timer(&aurora_poll_timer);
950 #endif
951 #ifdef AURORA_DEBUG
952         printk("aurora_setup_board: end\n");
953 #endif
954         return 0;
955 }
956
957 /* Called with disabled interrupts */
958 static void aurora_shutdown_board(struct Aurora_board *bp)
959 {
960         int i;
961
962 #ifdef AURORA_DEBUG
963         printk("aurora_shutdown_board: start\n");
964 #endif
965
966 #ifdef AURORA_INT_DEBUG
967         del_timer(&aurora_poll_timer);
968 #endif
969
970 #ifdef AURORA_ALLIRQ
971         for(i=0;i<AURORA_ALLIRQ;i++){
972                 free_irq(allirq[i]|0x30, bp);
973 /*              IRQ_to_board[allirq[i]&0xf] = NULL;*/
974         }
975 #else
976         free_irq(bp->irq|0x30, bp);
977 /*      IRQ_to_board[bp->irq&0xf] = NULL;*/
978 #endif  
979         /* Drop all DTR's */
980         for(i=0;i<16;i++){
981                 sbus_writeb(i & 7, &bp->r[i>>3]->r[CD180_CAR]);
982                 udelay(1);
983                 sbus_writeb(0, &bp->r[i>>3]->r[CD180_MSVR]);
984                 udelay(1);
985         }
986         /* Board shutdown */
987         sbus_writeb(0, &bp->r0->r);
988
989 #ifdef AURORA_DEBUG
990         printk("aurora_shutdown_board: end\n");
991 #endif
992 }
993
994 /* Setting up port characteristics. 
995  * Must be called with disabled interrupts
996  */
997 static void aurora_change_speed(struct Aurora_board *bp, struct Aurora_port *port)
998 {
999         struct tty_struct *tty;
1000         unsigned long baud;
1001         long tmp;
1002         unsigned char cor1 = 0, cor3 = 0;
1003         unsigned char mcor1 = 0, mcor2 = 0,chip;
1004         
1005 #ifdef AURORA_DEBUG
1006         printk("aurora_change_speed: start\n");
1007 #endif
1008         if (!(tty = port->tty) || !tty->termios)
1009                 return;
1010                 
1011         chip = AURORA_CD180(port_No(port));
1012
1013         port->SRER  = 0;
1014         port->COR2 = 0;
1015         port->MSVR = MSVR_RTS|MSVR_DTR;
1016         
1017         baud = tty_get_baud_rate(tty);
1018         
1019         /* Select port on the board */
1020         sbus_writeb(port_No(port) & 7,
1021                     &bp->r[chip]->r[CD180_CAR]);
1022         udelay(1);
1023         
1024         if (!baud)  {
1025                 /* Drop DTR & exit */
1026                 port->MSVR &= ~(bp->DTR|bp->RTS);
1027                 sbus_writeb(port->MSVR,
1028                             &bp->r[chip]->r[CD180_MSVR]);
1029                 return;
1030         } else  {
1031                 /* Set DTR on */
1032                 port->MSVR |= bp->DTR;
1033                 sbus_writeb(port->MSVR,
1034                             &bp->r[chip]->r[CD180_MSVR]);
1035         }
1036         
1037         /* Now we must calculate some speed dependent things. */
1038         
1039         /* Set baud rate for port. */
1040         tmp = (((bp->oscfreq + baud/2) / baud +
1041                 CD180_TPC/2) / CD180_TPC);
1042
1043 /*      tmp = (bp->oscfreq/7)/baud;
1044         if((tmp%10)>4)tmp=tmp/10+1;else tmp=tmp/10;*/
1045 /*      printk("Prescaler period: %d\n",tmp);*/
1046
1047         sbus_writeb((tmp >> 8) & 0xff,
1048                     &bp->r[chip]->r[CD180_RBPRH]);
1049         sbus_writeb((tmp >> 8) & 0xff,
1050                     &bp->r[chip]->r[CD180_TBPRH]);
1051         sbus_writeb(tmp & 0xff, &bp->r[chip]->r[CD180_RBPRL]);
1052         sbus_writeb(tmp & 0xff, &bp->r[chip]->r[CD180_TBPRL]);
1053         
1054         baud = (baud + 5) / 10;   /* Estimated CPS */
1055         
1056         /* Two timer ticks seems enough to wakeup something like SLIP driver */
1057         tmp = ((baud + HZ/2) / HZ) * 2 - CD180_NFIFO;           
1058         port->wakeup_chars = (tmp < 0) ? 0 : ((tmp >= SERIAL_XMIT_SIZE) ?
1059                                               SERIAL_XMIT_SIZE - 1 : tmp);
1060         
1061         /* Receiver timeout will be transmission time for 1.5 chars */
1062         tmp = (AURORA_TPS + AURORA_TPS/2 + baud/2) / baud;
1063         tmp = (tmp > 0xff) ? 0xff : tmp;
1064         sbus_writeb(tmp, &bp->r[chip]->r[CD180_RTPR]);
1065         
1066         switch (C_CSIZE(tty))  {
1067          case CS5:
1068                 cor1 |= COR1_5BITS;
1069                 break;
1070          case CS6:
1071                 cor1 |= COR1_6BITS;
1072                 break;
1073          case CS7:
1074                 cor1 |= COR1_7BITS;
1075                 break;
1076          case CS8:
1077                 cor1 |= COR1_8BITS;
1078                 break;
1079         }
1080         
1081         if (C_CSTOPB(tty)) 
1082                 cor1 |= COR1_2SB;
1083         
1084         cor1 |= COR1_IGNORE;
1085         if (C_PARENB(tty))  {
1086                 cor1 |= COR1_NORMPAR;
1087                 if (C_PARODD(tty)) 
1088                         cor1 |= COR1_ODDP;
1089                 if (I_INPCK(tty)) 
1090                         cor1 &= ~COR1_IGNORE;
1091         }
1092         /* Set marking of some errors */
1093         port->mark_mask = RCSR_OE | RCSR_TOUT;
1094         if (I_INPCK(tty)) 
1095                 port->mark_mask |= RCSR_FE | RCSR_PE;
1096         if (I_BRKINT(tty) || I_PARMRK(tty)) 
1097                 port->mark_mask |= RCSR_BREAK;
1098         if (I_IGNPAR(tty)) 
1099                 port->mark_mask &= ~(RCSR_FE | RCSR_PE);
1100         if (I_IGNBRK(tty))  {
1101                 port->mark_mask &= ~RCSR_BREAK;
1102                 if (I_IGNPAR(tty)) 
1103                         /* Real raw mode. Ignore all */
1104                         port->mark_mask &= ~RCSR_OE;
1105         }
1106         /* Enable Hardware Flow Control */
1107         if (C_CRTSCTS(tty))  {
1108 /*#ifdef AURORA_BRAIN_DAMAGED_CTS
1109                 port->SRER |= SRER_DSR | SRER_CTS;
1110                 mcor1 |= MCOR1_DSRZD | MCOR1_CTSZD;
1111                 mcor2 |= MCOR2_DSROD | MCOR2_CTSOD;
1112                 tty->hw_stopped = !(aurora_in(bp, CD180_MSVR) & (MSVR_CTS|MSVR_DSR));
1113 #else*/
1114                 port->COR2 |= COR2_CTSAE;
1115 /*#endif*/
1116                 if (bp->flags&AURORA_BOARD_DTR_FLOW_OK) {
1117                         mcor1 |= AURORA_RXTH;
1118                 }
1119         }
1120         /* Enable Software Flow Control. FIXME: I'm not sure about this */
1121         /* Some people reported that it works, but I still doubt */
1122         if (I_IXON(tty))  {
1123                 port->COR2 |= COR2_TXIBE;
1124                 cor3 |= (COR3_FCT | COR3_SCDE);
1125                 if (I_IXANY(tty))
1126                         port->COR2 |= COR2_IXM;
1127                 sbus_writeb(START_CHAR(tty),
1128                             &bp->r[chip]->r[CD180_SCHR1]);
1129                 sbus_writeb(STOP_CHAR(tty),
1130                             &bp->r[chip]->r[CD180_SCHR2]);
1131                 sbus_writeb(START_CHAR(tty),
1132                             &bp->r[chip]->r[CD180_SCHR3]);
1133                 sbus_writeb(STOP_CHAR(tty),
1134                             &bp->r[chip]->r[CD180_SCHR4]);
1135         }
1136         if (!C_CLOCAL(tty))  {
1137                 /* Enable CD check */
1138                 port->SRER |= SRER_CD;
1139                 mcor1 |= MCOR1_CDZD;
1140                 mcor2 |= MCOR2_CDOD;
1141         }
1142         
1143         if (C_CREAD(tty)) 
1144                 /* Enable receiver */
1145                 port->SRER |= SRER_RXD;
1146         
1147         /* Set input FIFO size (1-8 bytes) */
1148         cor3 |= AURORA_RXFIFO; 
1149         /* Setting up CD180 channel registers */
1150         sbus_writeb(cor1, &bp->r[chip]->r[CD180_COR1]);
1151         sbus_writeb(port->COR2, &bp->r[chip]->r[CD180_COR2]);
1152         sbus_writeb(cor3, &bp->r[chip]->r[CD180_COR3]);
1153         /* Make CD180 know about registers change */
1154         aurora_wait_CCR(bp->r[chip]);
1155         sbus_writeb(CCR_CORCHG1 | CCR_CORCHG2 | CCR_CORCHG3,
1156                     &bp->r[chip]->r[CD180_CCR]);
1157         /* Setting up modem option registers */
1158         sbus_writeb(mcor1, &bp->r[chip]->r[CD180_MCOR1]);
1159         sbus_writeb(mcor2, &bp->r[chip]->r[CD180_MCOR2]);
1160         /* Enable CD180 transmitter & receiver */
1161         aurora_wait_CCR(bp->r[chip]);
1162         sbus_writeb(CCR_TXEN | CCR_RXEN, &bp->r[chip]->r[CD180_CCR]);
1163         /* Enable interrupts */
1164         sbus_writeb(port->SRER, &bp->r[chip]->r[CD180_SRER]);
1165         /* And finally set RTS on */
1166         sbus_writeb(port->MSVR, &bp->r[chip]->r[CD180_MSVR]);
1167 #ifdef AURORA_DEBUG
1168         printk("aurora_change_speed: end\n");
1169 #endif
1170 }
1171
1172 /* Must be called with interrupts enabled */
1173 static int aurora_setup_port(struct Aurora_board *bp, struct Aurora_port *port)
1174 {
1175         unsigned long flags;
1176         
1177 #ifdef AURORA_DEBUG
1178         printk("aurora_setup_port: start %d\n",port_No(port));
1179 #endif
1180         if (port->flags & ASYNC_INITIALIZED)
1181                 return 0;
1182                 
1183         if (!port->xmit_buf) {
1184                 /* We may sleep in get_zeroed_page() */
1185                 unsigned long tmp;
1186                 
1187                 if (!(tmp = get_zeroed_page(GFP_KERNEL)))
1188                         return -ENOMEM;
1189                     
1190                 if (port->xmit_buf) {
1191                         free_page(tmp);
1192                         return -ERESTARTSYS;
1193                 }
1194                 port->xmit_buf = (unsigned char *) tmp;
1195         }
1196                 
1197         save_flags(flags); cli();
1198                 
1199         if (port->tty) 
1200                 clear_bit(TTY_IO_ERROR, &port->tty->flags);
1201                 
1202 #ifdef MODULE
1203         if ((port->count == 1) && ((++bp->count) == 1))
1204                         bp->flags |= AURORA_BOARD_ACTIVE;
1205 #endif
1206
1207         port->xmit_cnt = port->xmit_head = port->xmit_tail = 0;
1208         aurora_change_speed(bp, port);
1209         port->flags |= ASYNC_INITIALIZED;
1210                 
1211         restore_flags(flags);
1212 #ifdef AURORA_DEBUG
1213         printk("aurora_setup_port: end\n");
1214 #endif
1215         return 0;
1216 }
1217
1218 /* Must be called with interrupts disabled */
1219 static void aurora_shutdown_port(struct Aurora_board *bp, struct Aurora_port *port)
1220 {
1221         struct tty_struct *tty;
1222         unsigned char chip;
1223
1224 #ifdef AURORA_DEBUG
1225         printk("aurora_shutdown_port: start\n");
1226 #endif
1227         if (!(port->flags & ASYNC_INITIALIZED)) 
1228                 return;
1229         
1230         chip = AURORA_CD180(port_No(port));
1231         
1232 #ifdef AURORA_REPORT_OVERRUN
1233         printk("aurora%d: port %d: Total %ld overruns were detected.\n",
1234                board_No(bp), port_No(port), port->overrun);
1235 #endif  
1236 #ifdef AURORA_REPORT_FIFO
1237         {
1238                 int i;
1239                 
1240                 printk("aurora%d: port %d: FIFO hits [ ",
1241                        board_No(bp), port_No(port));
1242                 for (i = 0; i < 10; i++)  {
1243                         printk("%ld ", port->hits[i]);
1244                 }
1245                 printk("].\n");
1246         }
1247 #endif  
1248         if (port->xmit_buf)  {
1249                 free_page((unsigned long) port->xmit_buf);
1250                 port->xmit_buf = NULL;
1251         }
1252
1253         if (!(tty = port->tty) || C_HUPCL(tty))  {
1254                 /* Drop DTR */
1255                 port->MSVR &= ~(bp->DTR|bp->RTS);
1256                 sbus_writeb(port->MSVR,
1257                             &bp->r[chip]->r[CD180_MSVR]);
1258         }
1259         
1260         /* Select port */
1261         sbus_writeb(port_No(port) & 7,
1262                     &bp->r[chip]->r[CD180_CAR]);
1263         udelay(1);
1264
1265         /* Reset port */
1266         aurora_wait_CCR(bp->r[chip]);
1267         sbus_writeb(CCR_SOFTRESET, &bp->r[chip]->r[CD180_CCR]);
1268
1269         /* Disable all interrupts from this port */
1270         port->SRER = 0;
1271         sbus_writeb(port->SRER, &bp->r[chip]->r[CD180_SRER]);
1272         
1273         if (tty)  
1274                 set_bit(TTY_IO_ERROR, &tty->flags);
1275         port->flags &= ~ASYNC_INITIALIZED;
1276
1277 #ifdef MODULE
1278         if (--bp->count < 0)  {
1279                 printk(KERN_DEBUG "aurora%d: aurora_shutdown_port: "
1280                        "bad board count: %d\n",
1281                        board_No(bp), bp->count);
1282                 bp->count = 0;
1283         }
1284         
1285         if (!bp->count)
1286                 bp->flags &= ~AURORA_BOARD_ACTIVE;
1287 #endif
1288
1289 #ifdef AURORA_DEBUG
1290         printk("aurora_shutdown_port: end\n");
1291 #endif
1292 }
1293
1294         
1295 static int block_til_ready(struct tty_struct *tty, struct file * filp,
1296                            struct Aurora_port *port)
1297 {
1298         DECLARE_WAITQUEUE(wait, current);
1299         struct Aurora_board *bp = port_Board(port);
1300         int    retval;
1301         int    do_clocal = 0;
1302         int    CD;
1303         unsigned char chip;
1304         
1305 #ifdef AURORA_DEBUG
1306         printk("block_til_ready: start\n");
1307 #endif
1308         chip = AURORA_CD180(port_No(port));
1309
1310         /* If the device is in the middle of being closed, then block
1311          * until it's done, and then try again.
1312          */
1313         if (tty_hung_up_p(filp) || port->flags & ASYNC_CLOSING) {
1314                 interruptible_sleep_on(&port->close_wait);
1315                 if (port->flags & ASYNC_HUP_NOTIFY)
1316                         return -EAGAIN;
1317                 else
1318                         return -ERESTARTSYS;
1319         }
1320
1321         /* If non-blocking mode is set, or the port is not enabled,
1322          * then make the check up front and then exit.
1323          */
1324         if ((filp->f_flags & O_NONBLOCK) ||
1325             (tty->flags & (1 << TTY_IO_ERROR))) {
1326                 port->flags |= ASYNC_NORMAL_ACTIVE;
1327                 return 0;
1328         }
1329
1330         if (C_CLOCAL(tty))  
1331                 do_clocal = 1;
1332
1333         /* Block waiting for the carrier detect and the line to become
1334          * free (i.e., not in use by the callout).  While we are in
1335          * this loop, info->count is dropped by one, so that
1336          * rs_close() knows when to free things.  We restore it upon
1337          * exit, either normal or abnormal.
1338          */
1339         retval = 0;
1340         add_wait_queue(&port->open_wait, &wait);
1341         cli();
1342         if (!tty_hung_up_p(filp))
1343                 port->count--;
1344         sti();
1345         port->blocked_open++;
1346         while (1) {
1347                 cli();
1348                 sbus_writeb(port_No(port) & 7,
1349                             &bp->r[chip]->r[CD180_CAR]);
1350                 udelay(1);
1351                 CD = sbus_readb(&bp->r[chip]->r[CD180_MSVR]) & MSVR_CD;
1352                 port->MSVR=bp->RTS;
1353
1354                 /* auto drops DTR */
1355                 sbus_writeb(port->MSVR, &bp->r[chip]->r[CD180_MSVR]);
1356                 sti();
1357                 set_current_state(TASK_INTERRUPTIBLE);
1358                 if (tty_hung_up_p(filp) ||
1359                     !(port->flags & ASYNC_INITIALIZED)) {
1360                         if (port->flags & ASYNC_HUP_NOTIFY)
1361                                 retval = -EAGAIN;
1362                         else
1363                                 retval = -ERESTARTSYS;  
1364                         break;
1365                 }
1366                 if (!(port->flags & ASYNC_CLOSING) &&
1367                     (do_clocal || CD))
1368                         break;
1369                 if (signal_pending(current)) {
1370                         retval = -ERESTARTSYS;
1371                         break;
1372                 }
1373                 schedule();
1374         }
1375         current->state = TASK_RUNNING;
1376         remove_wait_queue(&port->open_wait, &wait);
1377         if (!tty_hung_up_p(filp))
1378                 port->count++;
1379         port->blocked_open--;
1380         if (retval)
1381                 return retval;
1382         
1383         port->flags |= ASYNC_NORMAL_ACTIVE;
1384 #ifdef AURORA_DEBUG
1385         printk("block_til_ready: end\n");
1386 #endif
1387         return 0;
1388 }       
1389
1390 static int aurora_open(struct tty_struct * tty, struct file * filp)
1391 {
1392         int board;
1393         int error;
1394         struct Aurora_port * port;
1395         struct Aurora_board * bp;
1396         unsigned long flags;
1397         
1398 #ifdef AURORA_DEBUG
1399         printk("aurora_open: start\n");
1400 #endif
1401         
1402         board = AURORA_BOARD(tty->index);
1403         if (board > AURORA_NBOARD ||
1404             !(aurora_board[board].flags & AURORA_BOARD_PRESENT)) {
1405 #ifdef AURORA_DEBUG
1406                 printk("aurora_open: error board %d present %d\n",
1407                        board, aurora_board[board].flags & AURORA_BOARD_PRESENT);
1408 #endif
1409                 return -ENODEV;
1410         }
1411         
1412         bp = &aurora_board[board];
1413         port = aurora_port + board * AURORA_NPORT * AURORA_NCD180 + AURORA_PORT(tty->index);
1414         if ((aurora_paranoia_check(port, tty->name, "aurora_open")) {
1415 #ifdef AURORA_DEBUG
1416                 printk("aurora_open: error paranoia check\n");
1417 #endif
1418                 return -ENODEV;
1419         }
1420         
1421         port->count++;
1422         tty->driver_data = port;
1423         port->tty = tty;
1424         
1425         if ((error = aurora_setup_port(bp, port))) {
1426 #ifdef AURORA_DEBUG
1427                 printk("aurora_open: error aurora_setup_port ret %d\n",error);
1428 #endif
1429                 return error;
1430         }
1431
1432         if ((error = block_til_ready(tty, filp, port))) {
1433 #ifdef AURORA_DEBUG
1434                 printk("aurora_open: error block_til_ready ret %d\n",error);
1435 #endif
1436                 return error;
1437         }
1438         
1439 #ifdef AURORA_DEBUG
1440         printk("aurora_open: end\n");
1441 #endif
1442         return 0;
1443 }
1444
1445 static void aurora_close(struct tty_struct * tty, struct file * filp)
1446 {
1447         struct Aurora_port *port = (struct Aurora_port *) tty->driver_data;
1448         struct Aurora_board *bp;
1449         unsigned long flags;
1450         unsigned long timeout;
1451         unsigned char chip;
1452         
1453 #ifdef AURORA_DEBUG
1454         printk("aurora_close: start\n");
1455 #endif
1456         
1457         if (!port || (aurora_paranoia_check(port, tty->name, "close"))
1458                 return;
1459         
1460         chip = AURORA_CD180(port_No(port));
1461
1462         save_flags(flags); cli();
1463         if (tty_hung_up_p(filp))  {
1464                 restore_flags(flags);
1465                 return;
1466         }
1467         
1468         bp = port_Board(port);
1469         if ((tty->count == 1) && (port->count != 1))  {
1470                 printk(KERN_DEBUG "aurora%d: aurora_close: bad port count; "
1471                        "tty->count is 1, port count is %d\n",
1472                        board_No(bp), port->count);
1473                 port->count = 1;
1474         }
1475         if (--port->count < 0)  {
1476                 printk(KERN_DEBUG "aurora%d: aurora_close: bad port "
1477                        "count for tty%d: %d\n",
1478                        board_No(bp), port_No(port), port->count);
1479                 port->count = 0;
1480         }
1481         if (port->count)  {
1482                 restore_flags(flags);
1483                 return;
1484         }
1485         port->flags |= ASYNC_CLOSING;
1486
1487         /* Now we wait for the transmit buffer to clear; and we notify 
1488          * the line discipline to only process XON/XOFF characters.
1489          */
1490         tty->closing = 1;
1491         if (port->closing_wait != ASYNC_CLOSING_WAIT_NONE){
1492 #ifdef AURORA_DEBUG
1493                 printk("aurora_close: waiting to flush...\n");
1494 #endif
1495                 tty_wait_until_sent(tty, port->closing_wait);
1496         }
1497
1498         /* At this point we stop accepting input.  To do this, we
1499          * disable the receive line status interrupts, and tell the
1500          * interrupt driver to stop checking the data ready bit in the
1501          * line status register.
1502          */
1503         port->SRER &= ~SRER_RXD;
1504         if (port->flags & ASYNC_INITIALIZED) {
1505                 port->SRER &= ~SRER_TXRDY;
1506                 port->SRER |= SRER_TXEMPTY;
1507                 sbus_writeb(port_No(port) & 7,
1508                             &bp->r[chip]->r[CD180_CAR]);
1509                 udelay(1);
1510                 sbus_writeb(port->SRER, &bp->r[chip]->r[CD180_SRER]);
1511                 /*
1512                  * Before we drop DTR, make sure the UART transmitter
1513                  * has completely drained; this is especially
1514                  * important if there is a transmit FIFO!
1515                  */
1516                 timeout = jiffies+HZ;
1517                 while(port->SRER & SRER_TXEMPTY)  {
1518                         msleep_interruptible(jiffies_to_msecs(port->timeout));
1519                         if (time_after(jiffies, timeout))
1520                                 break;
1521                 }
1522         }
1523 #ifdef AURORA_DEBUG
1524         printk("aurora_close: shutdown_port\n");
1525 #endif
1526         aurora_shutdown_port(bp, port);
1527         if (tty->driver->flush_buffer)
1528                 tty->driver->flush_buffer(tty);
1529         tty_ldisc_flush(tty);
1530         tty->closing = 0;
1531         port->event = 0;
1532         port->tty = 0;
1533         if (port->blocked_open) {
1534                 if (port->close_delay) {
1535                         msleep_interruptible(jiffies_to_msecs(port->close_delay));
1536                 }
1537                 wake_up_interruptible(&port->open_wait);
1538         }
1539         port->flags &= ~(ASYNC_NORMAL_ACTIVE|ASYNC_CLOSING);
1540         wake_up_interruptible(&port->close_wait);
1541         restore_flags(flags);
1542 #ifdef AURORA_DEBUG
1543         printk("aurora_close: end\n");
1544 #endif
1545 }
1546
1547 static int aurora_write(struct tty_struct * tty, 
1548                         const unsigned char *buf, int count)
1549 {
1550         struct Aurora_port *port = (struct Aurora_port *) tty->driver_data;
1551         struct Aurora_board *bp;
1552         int c, total = 0;
1553         unsigned long flags;
1554         unsigned char chip;
1555
1556 #ifdef AURORA_DEBUG
1557         printk("aurora_write: start %d\n",count);
1558 #endif
1559         if ((aurora_paranoia_check(port, tty->name, "aurora_write"))
1560                 return 0;
1561                 
1562         chip = AURORA_CD180(port_No(port));
1563         
1564         bp = port_Board(port);
1565
1566         if (!tty || !port->xmit_buf || !tmp_buf)
1567                 return 0;
1568
1569         save_flags(flags);
1570         while (1) {
1571                 cli();
1572                 c = min(count, min(SERIAL_XMIT_SIZE - port->xmit_cnt - 1,
1573                                    SERIAL_XMIT_SIZE - port->xmit_head));
1574                 if (c <= 0) {
1575                         restore_flags(flags);
1576                         break;
1577                 }
1578                 memcpy(port->xmit_buf + port->xmit_head, buf, c);
1579                 port->xmit_head = (port->xmit_head + c) & (SERIAL_XMIT_SIZE-1);
1580                 port->xmit_cnt += c;
1581                 restore_flags(flags);
1582
1583                 buf += c;
1584                 count -= c;
1585                 total += c;
1586         }
1587
1588         cli();
1589         if (port->xmit_cnt && !tty->stopped && !tty->hw_stopped &&
1590             !(port->SRER & SRER_TXRDY)) {
1591                 port->SRER |= SRER_TXRDY;
1592                 sbus_writeb(port_No(port) & 7,
1593                             &bp->r[chip]->r[CD180_CAR]);
1594                 udelay(1);
1595                 sbus_writeb(port->SRER, &bp->r[chip]->r[CD180_SRER]);
1596         }
1597         restore_flags(flags);
1598 #ifdef AURORA_DEBUG
1599         printk("aurora_write: end %d\n",total);
1600 #endif
1601         return total;
1602 }
1603
1604 static void aurora_put_char(struct tty_struct * tty, unsigned char ch)
1605 {
1606         struct Aurora_port *port = (struct Aurora_port *) tty->driver_data;
1607         unsigned long flags;
1608
1609 #ifdef AURORA_DEBUG
1610         printk("aurora_put_char: start %c\n",ch);
1611 #endif
1612         if ((aurora_paranoia_check(port, tty->name, "aurora_put_char"))
1613                 return;
1614
1615         if (!tty || !port->xmit_buf)
1616                 return;
1617
1618         save_flags(flags); cli();
1619         
1620         if (port->xmit_cnt >= SERIAL_XMIT_SIZE - 1) {
1621                 restore_flags(flags);
1622                 return;
1623         }
1624
1625         port->xmit_buf[port->xmit_head++] = ch;
1626         port->xmit_head &= SERIAL_XMIT_SIZE - 1;
1627         port->xmit_cnt++;
1628         restore_flags(flags);
1629 #ifdef AURORA_DEBUG
1630         printk("aurora_put_char: end\n");
1631 #endif
1632 }
1633
1634 static void aurora_flush_chars(struct tty_struct * tty)
1635 {
1636         struct Aurora_port *port = (struct Aurora_port *) tty->driver_data;
1637         unsigned long flags;
1638         unsigned char chip;
1639
1640 /*#ifdef AURORA_DEBUG
1641         printk("aurora_flush_chars: start\n");
1642 #endif*/
1643         if ((aurora_paranoia_check(port, tty->name, "aurora_flush_chars"))
1644                 return;
1645                 
1646         chip = AURORA_CD180(port_No(port));
1647         
1648         if (port->xmit_cnt <= 0 || tty->stopped || tty->hw_stopped ||
1649             !port->xmit_buf)
1650                 return;
1651
1652         save_flags(flags); cli();
1653         port->SRER |= SRER_TXRDY;
1654         sbus_writeb(port_No(port) & 7,
1655                     &port_Board(port)->r[chip]->r[CD180_CAR]);
1656         udelay(1);
1657         sbus_writeb(port->SRER,
1658                     &port_Board(port)->r[chip]->r[CD180_SRER]);
1659         restore_flags(flags);
1660 /*#ifdef AURORA_DEBUG
1661         printk("aurora_flush_chars: end\n");
1662 #endif*/
1663 }
1664
1665 static int aurora_write_room(struct tty_struct * tty)
1666 {
1667         struct Aurora_port *port = (struct Aurora_port *) tty->driver_data;
1668         int     ret;
1669
1670 #ifdef AURORA_DEBUG
1671         printk("aurora_write_room: start\n");
1672 #endif
1673         if ((aurora_paranoia_check(port, tty->name, "aurora_write_room"))
1674                 return 0;
1675
1676         ret = SERIAL_XMIT_SIZE - port->xmit_cnt - 1;
1677         if (ret < 0)
1678                 ret = 0;
1679 #ifdef AURORA_DEBUG
1680         printk("aurora_write_room: end\n");
1681 #endif
1682         return ret;
1683 }
1684
1685 static int aurora_chars_in_buffer(struct tty_struct *tty)
1686 {
1687         struct Aurora_port *port = (struct Aurora_port *) tty->driver_data;
1688                                 
1689         if ((aurora_paranoia_check(port, tty->name, "aurora_chars_in_buffer"))
1690                 return 0;
1691         
1692         return port->xmit_cnt;
1693 }
1694
1695 static void aurora_flush_buffer(struct tty_struct *tty)
1696 {
1697         struct Aurora_port *port = (struct Aurora_port *) tty->driver_data;
1698         unsigned long flags;
1699
1700 #ifdef AURORA_DEBUG
1701         printk("aurora_flush_buffer: start\n");
1702 #endif
1703         if ((aurora_paranoia_check(port, tty->name, "aurora_flush_buffer"))
1704                 return;
1705
1706         save_flags(flags); cli();
1707         port->xmit_cnt = port->xmit_head = port->xmit_tail = 0;
1708         restore_flags(flags);
1709         
1710         tty_wakeup(tty);
1711 #ifdef AURORA_DEBUG
1712         printk("aurora_flush_buffer: end\n");
1713 #endif
1714 }
1715
1716 static int aurora_tiocmget(struct tty_struct *tty, struct file *file)
1717 {
1718         struct Aurora_port *port = (struct Aurora_port *) tty->driver_data;
1719         struct Aurora_board * bp;
1720         unsigned char status,chip;
1721         unsigned int result;
1722         unsigned long flags;
1723
1724 #ifdef AURORA_DEBUG
1725         printk("aurora_get_modem_info: start\n");
1726 #endif
1727         if ((aurora_paranoia_check(port, tty->name, __FUNCTION__))
1728                 return -ENODEV;
1729
1730         chip = AURORA_CD180(port_No(port));
1731
1732         bp = port_Board(port);
1733
1734         save_flags(flags); cli();
1735
1736         sbus_writeb(port_No(port) & 7, &bp->r[chip]->r[CD180_CAR]);
1737         udelay(1);
1738
1739         status = sbus_readb(&bp->r[chip]->r[CD180_MSVR]);
1740         result = 0/*bp->r[chip]->r[AURORA_RI] & (1u << port_No(port)) ? 0 : TIOCM_RNG*/;
1741
1742         restore_flags(flags);
1743
1744         result |= ((status & bp->RTS) ? TIOCM_RTS : 0)
1745                 | ((status & bp->DTR) ? TIOCM_DTR : 0)
1746                 | ((status & MSVR_CD)  ? TIOCM_CAR : 0)
1747                 | ((status & MSVR_DSR) ? TIOCM_DSR : 0)
1748                 | ((status & MSVR_CTS) ? TIOCM_CTS : 0);
1749
1750 #ifdef AURORA_DEBUG
1751         printk("aurora_get_modem_info: end\n");
1752 #endif
1753         return result;
1754 }
1755
1756 static int aurora_tiocmset(struct tty_struct *tty, struct file *file,
1757                            unsigned int set, unsigned int clear)
1758 {
1759         struct Aurora_port *port = (struct Aurora_port *) tty->driver_data;
1760         unsigned int arg;
1761         unsigned long flags;
1762         struct Aurora_board *bp = port_Board(port);
1763         unsigned char chip;
1764
1765 #ifdef AURORA_DEBUG
1766         printk("aurora_set_modem_info: start\n");
1767 #endif
1768         if ((aurora_paranoia_check(port, tty->name, __FUNCTION__))
1769                 return -ENODEV;
1770
1771         chip = AURORA_CD180(port_No(port));
1772
1773         save_flags(flags); cli();
1774         if (set & TIOCM_RTS)
1775                 port->MSVR |= bp->RTS;
1776         if (set & TIOCM_DTR)
1777                 port->MSVR |= bp->DTR;
1778         if (clear & TIOCM_RTS)
1779                 port->MSVR &= ~bp->RTS;
1780         if (clear & TIOCM_DTR)
1781                 port->MSVR &= ~bp->DTR;
1782
1783         sbus_writeb(port_No(port) & 7, &bp->r[chip]->r[CD180_CAR]);
1784         udelay(1);
1785
1786         sbus_writeb(port->MSVR, &bp->r[chip]->r[CD180_MSVR]);
1787
1788         restore_flags(flags);
1789 #ifdef AURORA_DEBUG
1790         printk("aurora_set_modem_info: end\n");
1791 #endif
1792         return 0;
1793 }
1794
1795 static void aurora_send_break(struct Aurora_port * port, unsigned long length)
1796 {
1797         struct Aurora_board *bp = port_Board(port);
1798         unsigned long flags;
1799         unsigned char chip;
1800         
1801 #ifdef AURORA_DEBUG
1802         printk("aurora_send_break: start\n");
1803 #endif
1804         chip = AURORA_CD180(port_No(port));
1805         
1806         save_flags(flags); cli();
1807
1808         port->break_length = AURORA_TPS / HZ * length;
1809         port->COR2 |= COR2_ETC;
1810         port->SRER  |= SRER_TXRDY;
1811         sbus_writeb(port_No(port) & 7, &bp->r[chip]->r[CD180_CAR]);
1812         udelay(1);
1813
1814         sbus_writeb(port->COR2, &bp->r[chip]->r[CD180_COR2]);
1815         sbus_writeb(port->SRER, &bp->r[chip]->r[CD180_SRER]);
1816         aurora_wait_CCR(bp->r[chip]);
1817
1818         sbus_writeb(CCR_CORCHG2, &bp->r[chip]->r[CD180_CCR]);
1819         aurora_wait_CCR(bp->r[chip]);
1820
1821         restore_flags(flags);
1822 #ifdef AURORA_DEBUG
1823         printk("aurora_send_break: end\n");
1824 #endif
1825 }
1826
1827 static int aurora_set_serial_info(struct Aurora_port * port,
1828                                   struct serial_struct * newinfo)
1829 {
1830         struct serial_struct tmp;
1831         struct Aurora_board *bp = port_Board(port);
1832         int change_speed;
1833         unsigned long flags;
1834
1835 #ifdef AURORA_DEBUG
1836         printk("aurora_set_serial_info: start\n");
1837 #endif
1838         if (copy_from_user(&tmp, newinfo, sizeof(tmp)))
1839                 return -EFAULT;
1840 #if 0   
1841         if ((tmp.irq != bp->irq) ||
1842             (tmp.port != bp->base) ||
1843             (tmp.type != PORT_CIRRUS) ||
1844             (tmp.baud_base != (bp->oscfreq + CD180_TPC/2) / CD180_TPC) ||
1845             (tmp.custom_divisor != 0) ||
1846             (tmp.xmit_fifo_size != CD180_NFIFO) ||
1847             (tmp.flags & ~AURORA_LEGAL_FLAGS))
1848                 return -EINVAL;
1849 #endif  
1850         
1851         change_speed = ((port->flags & ASYNC_SPD_MASK) !=
1852                         (tmp.flags & ASYNC_SPD_MASK));
1853         
1854         if (!capable(CAP_SYS_ADMIN)) {
1855                 if ((tmp.close_delay != port->close_delay) ||
1856                     (tmp.closing_wait != port->closing_wait) ||
1857                     ((tmp.flags & ~ASYNC_USR_MASK) !=
1858                      (port->flags & ~ASYNC_USR_MASK)))  
1859                         return -EPERM;
1860                 port->flags = ((port->flags & ~ASYNC_USR_MASK) |
1861                                (tmp.flags & ASYNC_USR_MASK));
1862         } else  {
1863                 port->flags = ((port->flags & ~ASYNC_FLAGS) |
1864                                (tmp.flags & ASYNC_FLAGS));
1865                 port->close_delay = tmp.close_delay;
1866                 port->closing_wait = tmp.closing_wait;
1867         }
1868         if (change_speed)  {
1869                 save_flags(flags); cli();
1870                 aurora_change_speed(bp, port);
1871                 restore_flags(flags);
1872         }
1873 #ifdef AURORA_DEBUG
1874         printk("aurora_set_serial_info: end\n");
1875 #endif
1876         return 0;
1877 }
1878
1879 extern int aurora_get_serial_info(struct Aurora_port * port,
1880                                   struct serial_struct * retinfo)
1881 {
1882         struct serial_struct tmp;
1883         struct Aurora_board *bp = port_Board(port);
1884         
1885 #ifdef AURORA_DEBUG
1886         printk("aurora_get_serial_info: start\n");
1887 #endif
1888         if (!access_ok(VERIFY_WRITE, (void *) retinfo, sizeof(tmp)))
1889                 return -EFAULT;
1890         
1891         memset(&tmp, 0, sizeof(tmp));
1892         tmp.type = PORT_CIRRUS;
1893         tmp.line = port - aurora_port;
1894         tmp.port = 0;
1895         tmp.irq  = bp->irq;
1896         tmp.flags = port->flags;
1897         tmp.baud_base = (bp->oscfreq + CD180_TPC/2) / CD180_TPC;
1898         tmp.close_delay = port->close_delay * HZ/100;
1899         tmp.closing_wait = port->closing_wait * HZ/100;
1900         tmp.xmit_fifo_size = CD180_NFIFO;
1901         copy_to_user(retinfo, &tmp, sizeof(tmp));
1902 #ifdef AURORA_DEBUG
1903 printk("aurora_get_serial_info: end\n");
1904 #endif
1905         return 0;
1906 }
1907
1908 static int aurora_ioctl(struct tty_struct * tty, struct file * filp, 
1909                     unsigned int cmd, unsigned long arg)
1910                     
1911 {
1912         struct Aurora_port *port = (struct Aurora_port *) tty->driver_data;
1913         int retval;
1914
1915 #ifdef AURORA_DEBUG
1916         printk("aurora_ioctl: start\n");
1917 #endif
1918         if ((aurora_paranoia_check(port, tty->name, "aurora_ioctl"))
1919                 return -ENODEV;
1920         
1921         switch (cmd) {
1922         case TCSBRK:    /* SVID version: non-zero arg --> no break */
1923                 retval = tty_check_change(tty);
1924                 if (retval)
1925                         return retval;
1926                 tty_wait_until_sent(tty, 0);
1927                 if (!arg)
1928                         aurora_send_break(port, HZ/4);  /* 1/4 second */
1929                 return 0;
1930         case TCSBRKP:   /* support for POSIX tcsendbreak() */
1931                 retval = tty_check_change(tty);
1932                 if (retval)
1933                         return retval;
1934                 tty_wait_until_sent(tty, 0);
1935                 aurora_send_break(port, arg ? arg*(HZ/10) : HZ/4);
1936                 return 0;
1937         case TIOCGSOFTCAR:
1938                 return put_user(C_CLOCAL(tty) ? 1 : 0, (unsigned long *)arg);
1939         case TIOCSSOFTCAR:
1940                 if (get_user(arg,(unsigned long *)arg))
1941                         return -EFAULT;
1942                 tty->termios->c_cflag =
1943                         ((tty->termios->c_cflag & ~CLOCAL) |
1944                          (arg ? CLOCAL : 0));
1945                 return 0;
1946         case TIOCGSERIAL:       
1947                 return aurora_get_serial_info(port, (struct serial_struct *) arg);
1948         case TIOCSSERIAL:       
1949                 return aurora_set_serial_info(port, (struct serial_struct *) arg);
1950         default:
1951                 return -ENOIOCTLCMD;
1952         };
1953 #ifdef AURORA_DEBUG
1954         printk("aurora_ioctl: end\n");
1955 #endif
1956         return 0;
1957 }
1958
1959 static void aurora_throttle(struct tty_struct * tty)
1960 {
1961         struct Aurora_port *port = (struct Aurora_port *) tty->driver_data;
1962         struct Aurora_board *bp;
1963         unsigned long flags;
1964         unsigned char chip;
1965
1966 #ifdef AURORA_DEBUG
1967         printk("aurora_throttle: start\n");
1968 #endif
1969         if ((aurora_paranoia_check(port, tty->name, "aurora_throttle"))
1970                 return;
1971         
1972         bp = port_Board(port);
1973         chip = AURORA_CD180(port_No(port));
1974         
1975         save_flags(flags); cli();
1976         port->MSVR &= ~bp->RTS;
1977         sbus_writeb(port_No(port) & 7, &bp->r[chip]->r[CD180_CAR]);
1978         udelay(1);
1979         if (I_IXOFF(tty))  {
1980                 aurora_wait_CCR(bp->r[chip]);
1981                 sbus_writeb(CCR_SSCH2, &bp->r[chip]->r[CD180_CCR]);
1982                 aurora_wait_CCR(bp->r[chip]);
1983         }
1984         sbus_writeb(port->MSVR, &bp->r[chip]->r[CD180_MSVR]);
1985         restore_flags(flags);
1986 #ifdef AURORA_DEBUG
1987         printk("aurora_throttle: end\n");
1988 #endif
1989 }
1990
1991 static void aurora_unthrottle(struct tty_struct * tty)
1992 {
1993         struct Aurora_port *port = (struct Aurora_port *) tty->driver_data;
1994         struct Aurora_board *bp;
1995         unsigned long flags;
1996         unsigned char chip;
1997
1998 #ifdef AURORA_DEBUG
1999         printk("aurora_unthrottle: start\n");
2000 #endif
2001         if ((aurora_paranoia_check(port, tty->name, "aurora_unthrottle"))
2002                 return;
2003         
2004         bp = port_Board(port);
2005         
2006         chip = AURORA_CD180(port_No(port));
2007         
2008         save_flags(flags); cli();
2009         port->MSVR |= bp->RTS;
2010         sbus_writeb(port_No(port) & 7,
2011                     &bp->r[chip]->r[CD180_CAR]);
2012         udelay(1);
2013         if (I_IXOFF(tty))  {
2014                 aurora_wait_CCR(bp->r[chip]);
2015                 sbus_writeb(CCR_SSCH1,
2016                             &bp->r[chip]->r[CD180_CCR]);
2017                 aurora_wait_CCR(bp->r[chip]);
2018         }
2019         sbus_writeb(port->MSVR, &bp->r[chip]->r[CD180_MSVR]);
2020         restore_flags(flags);
2021 #ifdef AURORA_DEBUG
2022         printk("aurora_unthrottle: end\n");
2023 #endif
2024 }
2025
2026 static void aurora_stop(struct tty_struct * tty)
2027 {
2028         struct Aurora_port *port = (struct Aurora_port *) tty->driver_data;
2029         struct Aurora_board *bp;
2030         unsigned long flags;
2031         unsigned char chip;
2032
2033 #ifdef AURORA_DEBUG
2034         printk("aurora_stop: start\n");
2035 #endif
2036         if ((aurora_paranoia_check(port, tty->name, "aurora_stop"))
2037                 return;
2038         
2039         bp = port_Board(port);
2040         
2041         chip = AURORA_CD180(port_No(port));
2042         
2043         save_flags(flags); cli();
2044         port->SRER &= ~SRER_TXRDY;
2045         sbus_writeb(port_No(port) & 7,
2046                     &bp->r[chip]->r[CD180_CAR]);
2047         udelay(1);
2048         sbus_writeb(port->SRER,
2049                     &bp->r[chip]->r[CD180_SRER]);
2050         restore_flags(flags);
2051 #ifdef AURORA_DEBUG
2052         printk("aurora_stop: end\n");
2053 #endif
2054 }
2055
2056 static void aurora_start(struct tty_struct * tty)
2057 {
2058         struct Aurora_port *port = (struct Aurora_port *) tty->driver_data;
2059         struct Aurora_board *bp;
2060         unsigned long flags;
2061         unsigned char chip;
2062
2063 #ifdef AURORA_DEBUG
2064         printk("aurora_start: start\n");
2065 #endif
2066         if ((aurora_paranoia_check(port, tty->name, "aurora_start"))
2067                 return;
2068         
2069         bp = port_Board(port);
2070         
2071         chip = AURORA_CD180(port_No(port));
2072         
2073         save_flags(flags); cli();
2074         if (port->xmit_cnt && port->xmit_buf && !(port->SRER & SRER_TXRDY))  {
2075                 port->SRER |= SRER_TXRDY;
2076                 sbus_writeb(port_No(port) & 7,
2077                             &bp->r[chip]->r[CD180_CAR]);
2078                 udelay(1);
2079                 sbus_writeb(port->SRER,
2080                             &bp->r[chip]->r[CD180_SRER]);
2081         }
2082         restore_flags(flags);
2083 #ifdef AURORA_DEBUG
2084         printk("aurora_start: end\n");
2085 #endif
2086 }
2087
2088 /*
2089  * This routine is called from the scheduler tqueue when the interrupt
2090  * routine has signalled that a hangup has occurred.  The path of
2091  * hangup processing is:
2092  *
2093  *      serial interrupt routine -> (scheduler tqueue) ->
2094  *      do_aurora_hangup() -> tty->hangup() -> aurora_hangup()
2095  * 
2096  */
2097 static void do_aurora_hangup(void *private_)
2098 {
2099         struct Aurora_port      *port = (struct Aurora_port *) private_;
2100         struct tty_struct       *tty;
2101
2102 #ifdef AURORA_DEBUG
2103         printk("do_aurora_hangup: start\n");
2104 #endif
2105         tty = port->tty;
2106         if (tty != NULL) {
2107                 tty_hangup(tty);        /* FIXME: module removal race - AKPM */
2108 #ifdef AURORA_DEBUG
2109                 printk("do_aurora_hangup: end\n");
2110 #endif
2111         }
2112 }
2113
2114 static void aurora_hangup(struct tty_struct * tty)
2115 {
2116         struct Aurora_port *port = (struct Aurora_port *) tty->driver_data;
2117         struct Aurora_board *bp;
2118                                 
2119 #ifdef AURORA_DEBUG
2120         printk("aurora_hangup: start\n");
2121 #endif
2122         if ((aurora_paranoia_check(port, tty->name, "aurora_hangup"))
2123                 return;
2124         
2125         bp = port_Board(port);
2126         
2127         aurora_shutdown_port(bp, port);
2128         port->event = 0;
2129         port->count = 0;
2130         port->flags &= ~ASYNC_NORMAL_ACTIVE;
2131         port->tty = 0;
2132         wake_up_interruptible(&port->open_wait);
2133 #ifdef AURORA_DEBUG
2134         printk("aurora_hangup: end\n");
2135 #endif
2136 }
2137
2138 static void aurora_set_termios(struct tty_struct * tty, struct termios * old_termios)
2139 {
2140         struct Aurora_port *port = (struct Aurora_port *) tty->driver_data;
2141         unsigned long flags;
2142
2143 #ifdef AURORA_DEBUG
2144         printk("aurora_set_termios: start\n");
2145 #endif
2146         if ((aurora_paranoia_check(port, tty->name, "aurora_set_termios"))
2147                 return;
2148         
2149         if (tty->termios->c_cflag == old_termios->c_cflag &&
2150             tty->termios->c_iflag == old_termios->c_iflag)
2151                 return;
2152
2153         save_flags(flags); cli();
2154         aurora_change_speed(port_Board(port), port);
2155         restore_flags(flags);
2156
2157         if ((old_termios->c_cflag & CRTSCTS) &&
2158             !(tty->termios->c_cflag & CRTSCTS)) {
2159                 tty->hw_stopped = 0;
2160                 aurora_start(tty);
2161         }
2162 #ifdef AURORA_DEBUG
2163         printk("aurora_set_termios: end\n");
2164 #endif
2165 }
2166
2167 static void do_aurora_bh(void)
2168 {
2169          run_task_queue(&tq_aurora);
2170 }
2171
2172 static void do_softint(void *private_)
2173 {
2174         struct Aurora_port      *port = (struct Aurora_port *) private_;
2175         struct tty_struct       *tty;
2176
2177 #ifdef AURORA_DEBUG
2178         printk("do_softint: start\n");
2179 #endif
2180         tty = port->tty;
2181         if (tty == NULL)
2182                 return;
2183
2184         if (test_and_clear_bit(RS_EVENT_WRITE_WAKEUP, &port->event)) {
2185                 tty_wakeup(tty);
2186         }
2187 #ifdef AURORA_DEBUG
2188         printk("do_softint: end\n");
2189 #endif
2190 }
2191
2192 static struct tty_operations aurora_ops = {
2193         .open  = aurora_open,
2194         .close = aurora_close,
2195         .write = aurora_write,
2196         .put_char = aurora_put_char,
2197         .flush_chars = aurora_flush_chars,
2198         .write_room = aurora_write_room,
2199         .chars_in_buffer = aurora_chars_in_buffer,
2200         .flush_buffer = aurora_flush_buffer,
2201         .ioctl = aurora_ioctl,
2202         .throttle = aurora_throttle,
2203         .unthrottle = aurora_unthrottle,
2204         .set_termios = aurora_set_termios,
2205         .stop = aurora_stop,
2206         .start = aurora_start,
2207         .hangup = aurora_hangup,
2208         .tiocmget = aurora_tiocmget,
2209         .tiocmset = aurora_tiocmset,
2210 };
2211
2212 static int aurora_init_drivers(void)
2213 {
2214         int error;
2215         int i;
2216
2217 #ifdef AURORA_DEBUG
2218         printk("aurora_init_drivers: start\n");
2219 #endif
2220         tmp_buf = (unsigned char *) get_zeroed_page(GFP_KERNEL);
2221         if (tmp_buf == NULL) {
2222                 printk(KERN_ERR "aurora: Couldn't get free page.\n");
2223                 return 1;
2224         }
2225         init_bh(AURORA_BH, do_aurora_bh);
2226         aurora_driver = alloc_tty_driver(AURORA_INPORTS);
2227         if (!aurora_driver) {
2228                 printk(KERN_ERR "aurora: Couldn't allocate tty driver.\n");
2229                 free_page((unsigned long) tmp_buf);
2230                 return 1;
2231         }
2232         aurora_driver->owner = THIS_MODULE;
2233         aurora_driver->name = "ttyA";
2234         aurora_driver->major = AURORA_MAJOR;
2235         aurora_driver->type = TTY_DRIVER_TYPE_SERIAL;
2236         aurora_driver->subtype = SERIAL_TYPE_NORMAL;
2237         aurora_driver->init_termios = tty_std_termios;
2238         aurora_driver->init_termios.c_cflag =
2239                 B9600 | CS8 | CREAD | HUPCL | CLOCAL;
2240         aurora_driver->flags = TTY_DRIVER_REAL_RAW;
2241         tty_set_operations(aurora_driver, &aurora_ops);
2242         error = tty_register_driver(aurora_driver);
2243         if (error) {
2244                 put_tty_driver(aurora_driver);
2245                 free_page((unsigned long) tmp_buf);
2246                 printk(KERN_ERR "aurora: Couldn't register aurora driver, error = %d\n",
2247                        error);
2248                 return 1;
2249         }
2250         
2251         memset(aurora_port, 0, sizeof(aurora_port));
2252         for (i = 0; i < AURORA_TNPORTS; i++)  {
2253                 aurora_port[i].magic = AURORA_MAGIC;
2254                 aurora_port[i].tqueue.routine = do_softint;
2255                 aurora_port[i].tqueue.data = &aurora_port[i];
2256                 aurora_port[i].tqueue_hangup.routine = do_aurora_hangup;
2257                 aurora_port[i].tqueue_hangup.data = &aurora_port[i];
2258                 aurora_port[i].close_delay = 50 * HZ/100;
2259                 aurora_port[i].closing_wait = 3000 * HZ/100;
2260                 init_waitqueue_head(&aurora_port[i].open_wait);
2261                 init_waitqueue_head(&aurora_port[i].close_wait);
2262         }
2263 #ifdef AURORA_DEBUG
2264         printk("aurora_init_drivers: end\n");
2265 #endif
2266         return 0;
2267 }
2268
2269 static void aurora_release_drivers(void)
2270 {
2271 #ifdef AURORA_DEBUG
2272         printk("aurora_release_drivers: start\n");
2273 #endif
2274         free_page((unsigned long)tmp_buf);
2275         tty_unregister_driver(aurora_driver);
2276         put_tty_driver(aurora_driver);
2277 #ifdef AURORA_DEBUG
2278         printk("aurora_release_drivers: end\n");
2279 #endif
2280 }
2281
2282 /*
2283  * Called at boot time.
2284  *
2285  * You can specify IO base for up to RC_NBOARD cards,
2286  * using line "riscom8=0xiobase1,0xiobase2,.." at LILO prompt.
2287  * Note that there will be no probing at default
2288  * addresses in this case.
2289  *
2290  */
2291 void __init aurora_setup(char *str, int *ints)
2292 {
2293         int i;
2294
2295         for(i=0;(i<ints[0])&&(i<4);i++) {
2296                 if (ints[i+1]) irqs[i]=ints[i+1];
2297                 }
2298 }
2299
2300 static int __init aurora_real_init(void)
2301 {
2302         int found;
2303         int i;
2304
2305         printk(KERN_INFO "aurora: Driver starting.\n");
2306         if(aurora_init_drivers())
2307                 return -EIO;
2308         found = aurora_probe();
2309         if(!found) {
2310                 aurora_release_drivers();
2311                 printk(KERN_INFO "aurora: No Aurora Multiport boards detected.\n");
2312                 return -EIO;
2313         } else {
2314                 printk(KERN_INFO "aurora: %d boards found.\n", found);
2315         }
2316         for (i = 0; i < found; i++) {
2317                 int ret = aurora_setup_board(&aurora_board[i]);
2318
2319                 if (ret) {
2320 #ifdef AURORA_DEBUG
2321                         printk(KERN_ERR "aurora_init: error aurora_setup_board ret %d\n",
2322                                ret);
2323 #endif
2324                         return ret;
2325                 }
2326         }
2327         return 0;
2328 }
2329
2330 int irq  = 0;
2331 int irq1 = 0;
2332 int irq2 = 0;
2333 int irq3 = 0;
2334 module_param(irq , int, 0);
2335 module_param(irq1, int, 0);
2336 module_param(irq2, int, 0);
2337 module_param(irq3, int, 0);
2338
2339 static int __init aurora_init(void) 
2340 {
2341         if (irq ) irqs[0]=irq ;
2342         if (irq1) irqs[1]=irq1;
2343         if (irq2) irqs[2]=irq2;
2344         if (irq3) irqs[3]=irq3;
2345         return aurora_real_init();
2346 }
2347         
2348 static void __exit aurora_cleanup(void)
2349 {
2350         int i;
2351         
2352 #ifdef AURORA_DEBUG
2353 printk("cleanup_module: aurora_release_drivers\n");
2354 #endif
2355
2356         aurora_release_drivers();
2357         for (i = 0; i < AURORA_NBOARD; i++)
2358                 if (aurora_board[i].flags & AURORA_BOARD_PRESENT) {
2359                         aurora_shutdown_board(&aurora_board[i]);
2360                         aurora_release_io_range(&aurora_board[i]);
2361                 }
2362 }
2363
2364 module_init(aurora_init);
2365 module_exit(aurora_cleanup);
2366 MODULE_LICENSE("GPL");