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