1
2 /* rio_linux.c -- Linux driver for the Specialix RIO series cards.
3 *
4 *
5 * (C) 1999 R.E.Wolff@BitWizard.nl
6 *
7 * Specialix pays for the development and support of this driver.
8 * Please DO contact support@specialix.co.uk if you require
9 * support. But please read the documentation (rio.txt) first.
10 *
11 *
12 *
13 * This program is free software; you can redistribute it and/or
14 * modify it under the terms of the GNU General Public License as
15 * published by the Free Software Foundation; either version 2 of
16 * the License, or (at your option) any later version.
17 *
18 * This program is distributed in the hope that it will be
19 * useful, but WITHOUT ANY WARRANTY; without even the implied
20 * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
21 * PURPOSE. See the GNU General Public License for more details.
22 *
23 * You should have received a copy of the GNU General Public
24 * License along with this program; if not, write to the Free
25 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139,
26 * USA.
27 *
28 * Revision history:
29 * $Log: rio.c,v $
30 * Revision 1.1 1999/07/11 10:13:54 wolff
31 * Initial revision
32 *
33 * */
34
35 #include <linux/module.h>
36 #include <linux/config.h>
37 #include <linux/kdev_t.h>
38 #include <asm/io.h>
39 #include <linux/kernel.h>
40 #include <linux/sched.h>
41 #include <linux/ioport.h>
42 #include <linux/interrupt.h>
43 #include <linux/errno.h>
44 #include <linux/tty.h>
45 #include <linux/tty_flip.h>
46 #include <linux/mm.h>
47 #include <linux/serial.h>
48 #include <linux/fcntl.h>
49 #include <linux/major.h>
50 #include <linux/delay.h>
51 #include <linux/pci.h>
52 #include <linux/slab.h>
53 #include <linux/miscdevice.h>
54 #include <linux/init.h>
55
56 #include <linux/generic_serial.h>
57 #include <asm/uaccess.h>
58
59 #if BITS_PER_LONG != 32
60 # error FIXME: this driver only works on 32-bit platforms
61 #endif
62
63 #include "linux_compat.h"
64 #include "typdef.h"
65 #include "pkt.h"
66 #include "daemon.h"
67 #include "rio.h"
68 #include "riospace.h"
69 #include "top.h"
70 #include "cmdpkt.h"
71 #include "map.h"
72 #include "riotypes.h"
73 #include "rup.h"
74 #include "port.h"
75 #include "riodrvr.h"
76 #include "rioinfo.h"
77 #include "func.h"
78 #include "errors.h"
79 #include "pci.h"
80
81 #include "parmmap.h"
82 #include "unixrup.h"
83 #include "board.h"
84 #include "host.h"
85 #include "error.h"
86 #include "phb.h"
87 #include "link.h"
88 #include "cmdblk.h"
89 #include "route.h"
90 #include "control.h"
91 #include "cirrus.h"
92 #include "rioioctl.h"
93 #include "param.h"
94 #include "list.h"
95 #include "sam.h"
96 #include "protsts.h"
97 #include "rioboard.h"
98
99
100 #include "rio_linux.h"
101
102 /* I don't think that this driver can handle more than 512 ports on
103 one machine. Specialix specifies max 4 boards in one machine. I don't
104 know why. If you want to try anyway you'll have to increase the number
105 of boards in rio.h. You'll have to allocate more majors if you need
106 more than 512 ports.... */
107
108 #ifndef RIO_NORMAL_MAJOR0
109 /* This allows overriding on the compiler commandline, or in a "major.h"
110 include or something like that */
111 #define RIO_NORMAL_MAJOR0 154
112 #define RIO_NORMAL_MAJOR1 156
113 #endif
114
115 #ifndef PCI_DEVICE_ID_SPECIALIX_SX_XIO_IO8
116 #define PCI_DEVICE_ID_SPECIALIX_SX_XIO_IO8 0x2000
117 #endif
118
119 #ifndef RIO_WINDOW_LEN
120 #define RIO_WINDOW_LEN 0x10000
121 #endif
122
123
124 /* Configurable options:
125 (Don't be too sure that it'll work if you toggle them) */
126
127 /* Am I paranoid or not ? ;-) */
128 #undef RIO_PARANOIA_CHECK
129
130
131 /* 20 -> 2000 per second. The card should rate-limit interrupts at 1000
132 Hz, but it is user configurable. I don't recommend going above 1000
133 Hz. The interrupt ratelimit might trigger if the interrupt is
134 shared with a very active other device.
135 undef this if you want to disable the check....
136 */
137 #define IRQ_RATE_LIMIT 200
138
139 #if 0
140 /* Not implemented */
141 /*
142 * The following defines are mostly for testing purposes. But if you need
143 * some nice reporting in your syslog, you can define them also.
144 */
145 #define RIO_REPORT_FIFO
146 #define RIO_REPORT_OVERRUN
147 #endif
148
149
150 /* These constants are derived from SCO Source */
151 static struct Conf
152 RIOConf =
153 {
154 /* locator */ "RIO Config here",
155 /* startuptime */ HZ*2, /* how long to wait for card to run */
156 /* slowcook */ 0, /* TRUE -> always use line disc. */
157 /* intrpolltime */ 1, /* The frequency of OUR polls */
158 /* breakinterval */ 25, /* x10 mS XXX: units seem to be 1ms not 10! -- REW*/
159 /* timer */ 10, /* mS */
160 /* RtaLoadBase */ 0x7000,
161 /* HostLoadBase */ 0x7C00,
162 /* XpHz */ 5, /* number of Xprint hits per second */
163 /* XpCps */ 120, /* Xprint characters per second */
164 /* XpOn */ "\033d#", /* start Xprint for a wyse 60 */
165 /* XpOff */ "\024", /* end Xprint for a wyse 60 */
166 /* MaxXpCps */ 2000, /* highest Xprint speed */
167 /* MinXpCps */ 10, /* slowest Xprint speed */
168 /* SpinCmds */ 1, /* non-zero for mega fast boots */
169 /* First Addr */ 0x0A0000, /* First address to look at */
170 /* Last Addr */ 0xFF0000, /* Last address looked at */
171 /* BufferSize */ 1024, /* Bytes per port of buffering */
172 /* LowWater */ 256, /* how much data left before wakeup */
173 /* LineLength */ 80, /* how wide is the console? */
174 /* CmdTimeout */ HZ, /* how long a close command may take */
175 };
176
177
178
179
180 /* Function prototypes */
181
182 static void rio_disable_tx_interrupts (void * ptr);
183 static void rio_enable_tx_interrupts (void * ptr);
184 static void rio_disable_rx_interrupts (void * ptr);
185 static void rio_enable_rx_interrupts (void * ptr);
186 static int rio_get_CD (void * ptr);
187 static void rio_shutdown_port (void * ptr);
188 static int rio_set_real_termios (void *ptr);
189 static void rio_hungup (void *ptr);
190 static void rio_close (void *ptr);
191 static int rio_chars_in_buffer (void * ptr);
192 static int rio_fw_ioctl (struct inode *inode, struct file *filp,
193 unsigned int cmd, unsigned long arg);
194 static int rio_init_drivers(void);
195
196 static void my_hd (void *addr, int len);
197
198 static struct tty_driver *rio_driver, *rio_driver2;
199
200 /* The name "p" is a bit non-descript. But that's what the rio-lynxos
201 sources use all over the place. */
202 struct rio_info *p;
203
204 int rio_debug;
205
206
207 /* You can have the driver poll your card.
208 - Set rio_poll to 1 to poll every timer tick (10ms on Intel).
209 This is used when the card cannot use an interrupt for some reason.
210 */
211 static int rio_poll = 1;
212
213
214 /* These are the only open spaces in my computer. Yours may have more
215 or less.... */
216 static int rio_probe_addrs[]= {0xc0000, 0xd0000, 0xe0000};
217
218 #define NR_RIO_ADDRS (sizeof(rio_probe_addrs)/sizeof (int))
219
220
221 /* Set the mask to all-ones. This alas, only supports 32 interrupts.
222 Some architectures may need more. -- Changed to LONG to
223 support up to 64 bits on 64bit architectures. -- REW 20/06/99 */
224 long rio_irqmask = -1;
225
226 MODULE_AUTHOR("Rogier Wolff <R.E.Wolff@bitwizard.nl>, Patrick van de Lageweg <patrick@bitwizard.nl>");
227 MODULE_DESCRIPTION("RIO driver");
228 MODULE_LICENSE("GPL");
229 module_param(rio_poll, int, 0);
230 module_param(rio_debug, int, 0644);
231 module_param(rio_irqmask, long, 0);
232
233 static struct real_driver rio_real_driver = {
234 rio_disable_tx_interrupts,
235 rio_enable_tx_interrupts,
236 rio_disable_rx_interrupts,
237 rio_enable_rx_interrupts,
238 rio_get_CD,
239 rio_shutdown_port,
240 rio_set_real_termios,
241 rio_chars_in_buffer,
242 rio_close,
243 rio_hungup,
244 NULL
245 };
246
247 /*
248 * Firmware loader driver specific routines
249 *
250 */
251
252 static struct file_operations rio_fw_fops = {
253 .owner = THIS_MODULE,
254 .ioctl = rio_fw_ioctl,
255 };
256
257 static struct miscdevice rio_fw_device = {
258 RIOCTL_MISC_MINOR, "rioctl", &rio_fw_fops
259 };
260
261
262
263
264
265 #ifdef RIO_PARANOIA_CHECK
266
267 /* This doesn't work. Who's paranoid around here? Not me! */
268
269 static inline int rio_paranoia_check(struct rio_port const * port,
270 char *name, const char *routine)
271 {
272
273 static const char *badmagic =
274 KERN_ERR "rio: Warning: bad rio port magic number for device %s in %s\n";
275 static const char *badinfo =
276 KERN_ERR "rio: Warning: null rio port for device %s in %s\n";
277
278 if (!port) {
279 printk (badinfo, name, routine);
280 return 1;
281 }
282 if (port->magic != RIO_MAGIC) {
283 printk (badmagic, name, routine);
284 return 1;
285 }
286
287 return 0;
288 }
289 #else
290 #define rio_paranoia_check(a,b,c) 0
291 #endif
292
293
294 #ifdef DEBUG
295 static void my_hd (void *ad, int len)
296 {
297 int i, j, ch;
298 unsigned char *addr = ad;
299
300 for (i=0;i<len;i+=16) {
301 rio_dprintk (RIO_DEBUG_PARAM, "%08x ", (int) addr+i);
302 for (j=0;j<16;j++) {
303 rio_dprintk (RIO_DEBUG_PARAM, "%02x %s", addr[j+i], (j==7)?" ":"");
304 }
305 for (j=0;j<16;j++) {
306 ch = addr[j+i];
307 rio_dprintk (RIO_DEBUG_PARAM, "%c", (ch < 0x20)?'.':((ch > 0x7f)?'.':ch));
308 }
309 rio_dprintk (RIO_DEBUG_PARAM, "\n");
310 }
311 }
312 #else
313 #define my_hd(ad,len) do{/* nothing*/ } while (0)
314 #endif
315
316
317 /* Delay a number of jiffies, allowing a signal to interrupt */
318 int RIODelay (struct Port *PortP, int njiffies)
319 {
320 func_enter ();
321
322 rio_dprintk (RIO_DEBUG_DELAY, "delaying %d jiffies\n", njiffies);
323 msleep_interruptible(jiffies_to_msecs(njiffies));
324 func_exit();
325
326 if (signal_pending(current))
327 return RIO_FAIL;
328 else
329 return !RIO_FAIL;
330 }
331
332
333 /* Delay a number of jiffies, disallowing a signal to interrupt */
334 int RIODelay_ni (struct Port *PortP, int njiffies)
335 {
336 func_enter ();
337
338 rio_dprintk (RIO_DEBUG_DELAY, "delaying %d jiffies (ni)\n", njiffies);
339 msleep(jiffies_to_msecs(njiffies));
340 func_exit();
341 return !RIO_FAIL;
342 }
343
344
345 int rio_minor(struct tty_struct *tty)
346 {
347 return tty->index + (tty->driver == rio_driver) ? 0 : 256;
348 }
349
350
351 int rio_ismodem(struct tty_struct *tty)
352 {
353 return 1;
354 }
355
356
357 void rio_udelay (int usecs)
358 {
359 udelay (usecs);
360 }
361
362 static int rio_set_real_termios (void *ptr)
363 {
364 int rv, modem;
365 struct tty_struct *tty;
366 func_enter();
367
368 tty = ((struct Port *)ptr)->gs.tty;
369
370 modem = rio_ismodem(tty);
371
372 rv = RIOParam( (struct Port *) ptr, CONFIG, modem, 1);
373
374 func_exit ();
375
376 return rv;
377 }
378
379
380 static void rio_reset_interrupt (struct Host *HostP)
381 {
382 func_enter();
383
384 switch( HostP->Type ) {
385 case RIO_AT:
386 case RIO_MCA:
387 case RIO_PCI:
388 WBYTE(HostP->ResetInt , 0xff);
389 }
390
391 func_exit();
392 }
393
394
395 static irqreturn_t rio_interrupt (int irq, void *ptr, struct pt_regs *regs)
396 {
397 struct Host *HostP;
398 func_enter ();
399
400 HostP = (struct Host*)ptr; /* &p->RIOHosts[(long)ptr]; */
401 rio_dprintk (RIO_DEBUG_IFLOW, "rio: enter rio_interrupt (%d/%d)\n",
402 irq, HostP->Ivec);
403
404 /* AAargh! The order in which to do these things is essential and
405 not trivial.
406
407 - Rate limit goes before "recursive". Otherwise a series of
408 recursive calls will hang the machine in the interrupt routine.
409
410 - hardware twiddling goes before "recursive". Otherwise when we
411 poll the card, and a recursive interrupt happens, we won't
412 ack the card, so it might keep on interrupting us. (especially
413 level sensitive interrupt systems like PCI).
414
415 - Rate limit goes before hardware twiddling. Otherwise we won't
416 catch a card that has gone bonkers.
417
418 - The "initialized" test goes after the hardware twiddling. Otherwise
419 the card will stick us in the interrupt routine again.
420
421 - The initialized test goes before recursive.
422 */
423
424
425
426 #ifdef IRQ_RATE_LIMIT
427 /* Aaargh! I'm ashamed. This costs more lines-of-code than the
428 actual interrupt routine!. (Well, used to when I wrote that comment) */
429 {
430 static int lastjif;
431 static int nintr=0;
432
433 if (lastjif == jiffies) {
434 if (++nintr > IRQ_RATE_LIMIT) {
435 free_irq (HostP->Ivec, ptr);
436 printk (KERN_ERR "rio: Too many interrupts. Turning off interrupt %d.\n",
437 HostP->Ivec);
438 }
439 } else {
440 lastjif = jiffies;
441 nintr = 0;
442 }
443 }
444 #endif
445 rio_dprintk (RIO_DEBUG_IFLOW, "rio: We've have noticed the interrupt\n");
446 if (HostP->Ivec == irq) {
447 /* Tell the card we've noticed the interrupt. */
448 rio_reset_interrupt (HostP);
449 }
450
451 if ((HostP->Flags & RUN_STATE) != RC_RUNNING)
452 return IRQ_HANDLED;
453
454 if (test_and_set_bit (RIO_BOARD_INTR_LOCK, &HostP->locks)) {
455 printk (KERN_ERR "Recursive interrupt! (host %d/irq%d)\n",
456 (int) ptr, HostP->Ivec);
457 return IRQ_HANDLED;
458 }
459
460 RIOServiceHost(p, HostP, irq);
461
462 rio_dprintk ( RIO_DEBUG_IFLOW, "riointr() doing host %d type %d\n",
463 (int) ptr, HostP->Type);
464
465 clear_bit (RIO_BOARD_INTR_LOCK, &HostP->locks);
466 rio_dprintk (RIO_DEBUG_IFLOW, "rio: exit rio_interrupt (%d/%d)\n",
467 irq, HostP->Ivec);
468 func_exit ();
469 return IRQ_HANDLED;
470 }
471
472
473 static void rio_pollfunc (unsigned long data)
474 {
475 func_enter ();
476
477 rio_interrupt (0, &p->RIOHosts[data], NULL);
478 p->RIOHosts[data].timer.expires = jiffies + rio_poll;
479 add_timer (&p->RIOHosts[data].timer);
480
481 func_exit ();
482 }
483
484
485 /* ********************************************************************** *
486 * Here are the routines that actually *
487 * interface with the generic_serial driver *
488 * ********************************************************************** */
489
490 /* Ehhm. I don't know how to fiddle with interrupts on the Specialix
491 cards. .... Hmm. Ok I figured it out. You don't. -- REW */
492
493 static void rio_disable_tx_interrupts (void * ptr)
494 {
495 func_enter();
496
497 /* port->gs.flags &= ~GS_TX_INTEN; */
498
499 func_exit();
500 }
501
502
503 static void rio_enable_tx_interrupts (void * ptr)
504 {
505 struct Port *PortP = ptr;
506 /* int hn; */
507
508 func_enter();
509
510 /* hn = PortP->HostP - p->RIOHosts;
511
512 rio_dprintk (RIO_DEBUG_TTY, "Pushing host %d\n", hn);
513 rio_interrupt (-1,(void *) hn, NULL); */
514
515 RIOTxEnable((char *) PortP);
516
517 /*
518 * In general we cannot count on "tx empty" interrupts, although
519 * the interrupt routine seems to be able to tell the difference.
520 */
521 PortP->gs.flags &= ~GS_TX_INTEN;
522
523 func_exit();
524 }
525
526
527 static void rio_disable_rx_interrupts (void * ptr)
528 {
529 func_enter();
530 func_exit();
531 }
532
533 static void rio_enable_rx_interrupts (void * ptr)
534 {
535 /* struct rio_port *port = ptr; */
536 func_enter();
537 func_exit();
538 }
539
540
541 /* Jeez. Isn't this simple? */
542 static int rio_get_CD (void * ptr)
543 {
544 struct Port *PortP = ptr;
545 int rv;
546
547 func_enter();
548 rv = (PortP->ModemState & MSVR1_CD) != 0;
549
550 rio_dprintk (RIO_DEBUG_INIT, "Getting CD status: %d\n", rv);
551
552 func_exit();
553 return rv;
554 }
555
556
557 /* Jeez. Isn't this simple? Actually, we can sync with the actual port
558 by just pushing stuff into the queue going to the port... */
559 static int rio_chars_in_buffer (void * ptr)
560 {
561 func_enter();
562
563 func_exit();
564 return 0;
565 }
566
567
568 /* Nothing special here... */
569 static void rio_shutdown_port (void * ptr)
570 {
571 struct Port *PortP;
572
573 func_enter();
574
575 PortP = (struct Port *)ptr;
576 PortP->gs.tty = NULL;
577 #if 0
578 port->gs.flags &= ~ GS_ACTIVE;
579 if (!port->gs.tty) {
580 rio_dprintk (RIO_DBUG_TTY, "No tty.\n");
581 return;
582 }
583 if (!port->gs.tty->termios) {
584 rio_dprintk (RIO_DEBUG_TTY, "No termios.\n");
585 return;
586 }
587 if (port->gs.tty->termios->c_cflag & HUPCL) {
588 rio_setsignals (port, 0, 0);
589 }
590 #endif
591
592 func_exit();
593 }
594
595
596 /* I haven't the foggiest why the decrement use count has to happen
597 here. The whole linux serial drivers stuff needs to be redesigned.
598 My guess is that this is a hack to minimize the impact of a bug
599 elsewhere. Thinking about it some more. (try it sometime) Try
600 running minicom on a serial port that is driven by a modularized
601 driver. Have the modem hangup. Then remove the driver module. Then
602 exit minicom. I expect an "oops". -- REW */
603 static void rio_hungup (void *ptr)
604 {
605 struct Port *PortP;
606
607 func_enter();
608
609 PortP = (struct Port *)ptr;
610 PortP->gs.tty = NULL;
611
612 func_exit ();
613 }
614
615
616 /* The standard serial_close would become shorter if you'd wrap it like
617 this.
618 rs_close (...){save_flags;cli;real_close();dec_use_count;restore_flags;}
619 */
620 static void rio_close (void *ptr)
621 {
622 struct Port *PortP;
623
624 func_enter ();
625
626 PortP = (struct Port *)ptr;
627
628 riotclose (ptr);
629
630 if(PortP->gs.count) {
631 printk (KERN_ERR "WARNING port count:%d\n", PortP->gs.count);
632 PortP->gs.count = 0;
633 }
634
635 PortP->gs.tty = NULL;
636 func_exit ();
637 }
638
639
640
641 static int rio_fw_ioctl (struct inode *inode, struct file *filp,
642 unsigned int cmd, unsigned long arg)
643 {
644 int rc = 0;
645 func_enter();
646
647 /* The "dev" argument isn't used. */
648 rc = riocontrol (p, 0, cmd, (void *)arg, capable(CAP_SYS_ADMIN));
649
650 func_exit ();
651 return rc;
652 }
653
654 extern int RIOShortCommand(struct rio_info *p, struct Port *PortP,
655 int command, int len, int arg);
656
657 static int rio_ioctl (struct tty_struct * tty, struct file * filp,
658 unsigned int cmd, unsigned long arg)
659 {
660 int rc;
661 struct Port *PortP;
662 int ival;
663
664 func_enter();
665
666 PortP = (struct Port *)tty->driver_data;
667
668 rc = 0;
669 switch (cmd) {
670 #if 0
671 case TIOCGSOFTCAR:
672 rc = put_user(((tty->termios->c_cflag & CLOCAL) ? 1 : 0),
673 (unsigned int *) arg);
674 break;
675 #endif
676 case TIOCSSOFTCAR:
677 if ((rc = get_user(ival, (unsigned int *) arg)) == 0) {
678 tty->termios->c_cflag =
679 (tty->termios->c_cflag & ~CLOCAL) |
680 (ival ? CLOCAL : 0);
681 }
682 break;
683 case TIOCGSERIAL:
684 if ((rc = verify_area(VERIFY_WRITE, (void *) arg,
685 sizeof(struct serial_struct))) == 0)
686 rc = gs_getserial(&PortP->gs, (struct serial_struct *) arg);
687 break;
688 case TCSBRK:
689 if ( PortP->State & RIO_DELETED ) {
690 rio_dprintk (RIO_DEBUG_TTY, "BREAK on deleted RTA\n");
691 rc = -EIO;
692 } else {
693 if (RIOShortCommand(p, PortP, SBREAK, 2, 250) == RIO_FAIL) {
694 rio_dprintk (RIO_DEBUG_INTR, "SBREAK RIOShortCommand failed\n");
695 rc = -EIO;
696 }
697 }
698 break;
699 case TCSBRKP:
700 if ( PortP->State & RIO_DELETED ) {
701 rio_dprintk (RIO_DEBUG_TTY, "BREAK on deleted RTA\n");
702 rc = -EIO;
703 } else {
704 int l;
705 l = arg?arg*100:250;
706 if (l > 255) l = 255;
707 if (RIOShortCommand(p, PortP, SBREAK, 2, arg?arg*100:250) == RIO_FAIL) {
708 rio_dprintk (RIO_DEBUG_INTR, "SBREAK RIOShortCommand failed\n");
709 rc = -EIO;
710 }
711 }
712 break;
713 case TIOCSSERIAL:
714 if ((rc = verify_area(VERIFY_READ, (void *) arg,
715 sizeof(struct serial_struct))) == 0)
716 rc = gs_setserial(&PortP->gs, (struct serial_struct *) arg);
717 break;
718 #if 0
719 /*
720 * note: these IOCTLs no longer reach here. Use
721 * tiocmset/tiocmget driver methods instead. The
722 * #if 0 disablement predates this comment.
723 */
724 case TIOCMGET:
725 if ((rc = verify_area(VERIFY_WRITE, (void *) arg,
726 sizeof(unsigned int))) == 0) {
727 ival = rio_getsignals(port);
728 put_user(ival, (unsigned int *) arg);
729 }
730 break;
731 case TIOCMBIS:
732 if ((rc = get_user(ival, (unsigned int *) arg)) == 0) {
733 rio_setsignals(port, ((ival & TIOCM_DTR) ? 1 : -1),
734 ((ival & TIOCM_RTS) ? 1 : -1));
735 }
736 break;
737 case TIOCMBIC:
738 if ((rc = get_user(ival, (unsigned int *) arg)) == 0) {
739 rio_setsignals(port, ((ival & TIOCM_DTR) ? 0 : -1),
740 ((ival & TIOCM_RTS) ? 0 : -1));
741 }
742 break;
743 case TIOCMSET:
744 if ((rc = get_user(ival, (unsigned int *) arg)) == 0) {
745 rio_setsignals(port, ((ival & TIOCM_DTR) ? 1 : 0),
746 ((ival & TIOCM_RTS) ? 1 : 0));
747 }
748 break;
749 #endif
750 default:
751 rc = -ENOIOCTLCMD;
752 break;
753 }
754 func_exit();
755 return rc;
756 }
757
758
759 /* The throttle/unthrottle scheme for the Specialix card is different
760 * from other drivers and deserves some explanation.
761 * The Specialix hardware takes care of XON/XOFF
762 * and CTS/RTS flow control itself. This means that all we have to
763 * do when signalled by the upper tty layer to throttle/unthrottle is
764 * to make a note of it here. When we come to read characters from the
765 * rx buffers on the card (rio_receive_chars()) we look to see if the
766 * upper layer can accept more (as noted here in rio_rx_throt[]).
767 * If it can't we simply don't remove chars from the cards buffer.
768 * When the tty layer can accept chars, we again note that here and when
769 * rio_receive_chars() is called it will remove them from the cards buffer.
770 * The card will notice that a ports buffer has drained below some low
771 * water mark and will unflow control the line itself, using whatever
772 * flow control scheme is in use for that port. -- Simon Allen
773 */
774
775 static void rio_throttle (struct tty_struct * tty)
776 {
777 struct Port *port = (struct Port *)tty->driver_data;
778
779 func_enter();
780 /* If the port is using any type of input flow
781 * control then throttle the port.
782 */
783
784 if((tty->termios->c_cflag & CRTSCTS) || (I_IXOFF(tty)) ) {
785 port->State |= RIO_THROTTLE_RX;
786 }
787
788 func_exit();
789 }
790
791
792 static void rio_unthrottle (struct tty_struct * tty)
793 {
794 struct Port *port = (struct Port *)tty->driver_data;
795
796 func_enter();
797 /* Always unthrottle even if flow control is not enabled on
798 * this port in case we disabled flow control while the port
799 * was throttled
800 */
801
802 port->State &= ~RIO_THROTTLE_RX;
803
804 func_exit();
805 return;
806 }
807
808
809
810
811
812 /* ********************************************************************** *
813 * Here are the initialization routines. *
814 * ********************************************************************** */
815
816
817 static struct vpd_prom *get_VPD_PROM (struct Host *hp)
818 {
819 static struct vpd_prom vpdp;
820 char *p;
821 int i;
822
823 func_enter();
824 rio_dprintk (RIO_DEBUG_PROBE, "Going to verify vpd prom at %p.\n",
825 hp->Caddr + RIO_VPD_ROM);
826
827 p = (char *) &vpdp;
828 for (i=0;i< sizeof (struct vpd_prom);i++)
829 *p++ = readb (hp->Caddr+RIO_VPD_ROM + i*2);
830 /* read_rio_byte (hp, RIO_VPD_ROM + i*2); */
831
832 /* Terminate the identifier string.
833 *** requires one extra byte in struct vpd_prom *** */
834 *p++=0;
835
836 if (rio_debug & RIO_DEBUG_PROBE)
837 my_hd ((char *)&vpdp, 0x20);
838
839 func_exit();
840
841 return &vpdp;
842 }
843
844 static struct tty_operations rio_ops = {
845 .open = riotopen,
846 .close = gs_close,
847 .write = gs_write,
848 .put_char = gs_put_char,
849 .flush_chars = gs_flush_chars,
850 .write_room = gs_write_room,
851 .chars_in_buffer = gs_chars_in_buffer,
852 .flush_buffer = gs_flush_buffer,
853 .ioctl = rio_ioctl,
854 .throttle = rio_throttle,
855 .unthrottle = rio_unthrottle,
856 .set_termios = gs_set_termios,
857 .stop = gs_stop,
858 .start = gs_start,
859 .hangup = gs_hangup,
860 };
861
862 static int rio_init_drivers(void)
863 {
864 int error = -ENOMEM;
865
866 rio_driver = alloc_tty_driver(256);
867 if (!rio_driver)
868 goto out;
869 rio_driver2 = alloc_tty_driver(256);
870 if (!rio_driver2)
871 goto out1;
872
873 func_enter();
874
875 rio_driver->owner = THIS_MODULE;
876 rio_driver->driver_name = "specialix_rio";
877 rio_driver->name = "ttySR";
878 rio_driver->major = RIO_NORMAL_MAJOR0;
879 rio_driver->type = TTY_DRIVER_TYPE_SERIAL;
880 rio_driver->subtype = SERIAL_TYPE_NORMAL;
881 rio_driver->init_termios = tty_std_termios;
882 rio_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
883 rio_driver->flags = TTY_DRIVER_REAL_RAW;
884 tty_set_operations(rio_driver, &rio_ops);
885
886 rio_driver2->owner = THIS_MODULE;
887 rio_driver2->driver_name = "specialix_rio";
888 rio_driver2->name = "ttySR";
889 rio_driver2->major = RIO_NORMAL_MAJOR1;
890 rio_driver2->type = TTY_DRIVER_TYPE_SERIAL;
891 rio_driver2->subtype = SERIAL_TYPE_NORMAL;
892 rio_driver2->init_termios = tty_std_termios;
893 rio_driver2->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
894 rio_driver2->flags = TTY_DRIVER_REAL_RAW;
895 tty_set_operations(rio_driver2, &rio_ops);
896
897 rio_dprintk (RIO_DEBUG_INIT, "set_termios = %p\n", gs_set_termios);
898
899 if ((error = tty_register_driver(rio_driver)))
900 goto out2;
901 if ((error = tty_register_driver(rio_driver2)))
902 goto out3;
903 func_exit();
904 return 0;
905 out3:
906 tty_unregister_driver(rio_driver);
907 out2:
908 put_tty_driver(rio_driver2);
909 out1:
910 put_tty_driver(rio_driver);
911 out:
912 printk(KERN_ERR "rio: Couldn't register a rio driver, error = %d\n",
913 error);
914 return 1;
915 }
916
917
918 static void * ckmalloc (int size)
919 {
920 void *p;
921
922 p = kmalloc(size, GFP_KERNEL);
923 if (p)
924 memset(p, 0, size);
925 return p;
926 }
927
928
929
930 static int rio_init_datastructures (void)
931 {
932 int i;
933 struct Port *port;
934 func_enter();
935
936 /* Many drivers statically allocate the maximum number of ports
937 There is no reason not to allocate them dynamically. Is there? -- REW */
938 /* However, the RIO driver allows users to configure their first
939 RTA as the ports numbered 504-511. We therefore need to allocate
940 the whole range. :-( -- REW */
941
942 #define RI_SZ sizeof(struct rio_info)
943 #define HOST_SZ sizeof(struct Host)
944 #define PORT_SZ sizeof(struct Port *)
945 #define TMIO_SZ sizeof(struct termios *)
946 rio_dprintk (RIO_DEBUG_INIT, "getting : %d %d %d %d %d bytes\n",
947 RI_SZ,
948 RIO_HOSTS * HOST_SZ,
949 RIO_PORTS * PORT_SZ,
950 RIO_PORTS * TMIO_SZ,
951 RIO_PORTS * TMIO_SZ);
952
953 if (!(p = ckmalloc ( RI_SZ))) goto free0;
954 if (!(p->RIOHosts = ckmalloc (RIO_HOSTS * HOST_SZ))) goto free1;
955 if (!(p->RIOPortp = ckmalloc (RIO_PORTS * PORT_SZ))) goto free2;
956 p->RIOConf = RIOConf;
957 rio_dprintk (RIO_DEBUG_INIT, "Got : %p %p %p\n",
958 p, p->RIOHosts, p->RIOPortp);
959
960 #if 1
961 for (i = 0; i < RIO_PORTS; i++) {
962 port = p->RIOPortp[i] = ckmalloc (sizeof (struct Port));
963 if (!port) {
964 goto free6;
965 }
966 rio_dprintk (RIO_DEBUG_INIT, "initing port %d (%d)\n", i, port->Mapped);
967 port->PortNum = i;
968 port->gs.magic = RIO_MAGIC;
969 port->gs.close_delay = HZ/2;
970 port->gs.closing_wait = 30 * HZ;
971 port->gs.rd = &rio_real_driver;
972 spin_lock_init(&port->portSem);
973 /*
974 * Initializing wait queue
975 */
976 init_waitqueue_head(&port->gs.open_wait);
977 init_waitqueue_head(&port->gs.close_wait);
978 }
979 #else
980 /* We could postpone initializing them to when they are configured. */
981 #endif
982
983
984
985 if (rio_debug & RIO_DEBUG_INIT) {
986 my_hd (&rio_real_driver, sizeof (rio_real_driver));
987 }
988
989
990 func_exit();
991 return 0;
992
993 free6:for (i--;i>=0;i--)
994 kfree (p->RIOPortp[i]);
995 /*free5:
996 free4:
997 free3:*/kfree (p->RIOPortp);
998 free2:kfree (p->RIOHosts);
999 free1:
1000 rio_dprintk (RIO_DEBUG_INIT, "Not enough memory! %p %p %p\n",
1001 p, p->RIOHosts, p->RIOPortp);
1002 kfree(p);
1003 free0:
1004 return -ENOMEM;
1005 }
1006
1007 static void __exit rio_release_drivers(void)
1008 {
1009 func_enter();
1010 tty_unregister_driver(rio_driver2);
1011 tty_unregister_driver(rio_driver);
1012 put_tty_driver(rio_driver2);
1013 put_tty_driver(rio_driver);
1014 func_exit();
1015 }
1016
1017
1018 #ifdef CONFIG_PCI
1019 /* This was written for SX, but applies to RIO too...
1020 (including bugs....)
1021
1022 There is another bit besides Bit 17. Turning that bit off
1023 (on boards shipped with the fix in the eeprom) results in a
1024 hang on the next access to the card.
1025 */
1026
1027 /********************************************************
1028 * Setting bit 17 in the CNTRL register of the PLX 9050 *
1029 * chip forces a retry on writes while a read is pending.*
1030 * This is to prevent the card locking up on Intel Xeon *
1031 * multiprocessor systems with the NX chipset. -- NV *
1032 ********************************************************/
1033
1034 /* Newer cards are produced with this bit set from the configuration
1035 EEprom. As the bit is read/write for the CPU, we can fix it here,
1036 if we detect that it isn't set correctly. -- REW */
1037
1038 static void fix_rio_pci (struct pci_dev *pdev)
1039 {
1040 unsigned int hwbase;
1041 unsigned long rebase;
1042 unsigned int t;
1043
1044 #define CNTRL_REG_OFFSET 0x50
1045 #define CNTRL_REG_GOODVALUE 0x18260000
1046
1047 pci_read_config_dword(pdev, PCI_BASE_ADDRESS_0, &hwbase);
1048 hwbase &= PCI_BASE_ADDRESS_MEM_MASK;
1049 rebase = (ulong) ioremap(hwbase, 0x80);
1050 t = readl (rebase + CNTRL_REG_OFFSET);
1051 if (t != CNTRL_REG_GOODVALUE) {
1052 printk (KERN_DEBUG "rio: performing cntrl reg fix: %08x -> %08x\n",
1053 t, CNTRL_REG_GOODVALUE);
1054 writel (CNTRL_REG_GOODVALUE, rebase + CNTRL_REG_OFFSET);
1055 }
1056 iounmap((char*) rebase);
1057 }
1058 #endif
1059
1060
1061 static int __init rio_init(void)
1062 {
1063 int found = 0;
1064 int i;
1065 struct Host *hp;
1066 int retval;
1067 struct vpd_prom *vpdp;
1068 int okboard;
1069
1070 #ifdef CONFIG_PCI
1071 struct pci_dev *pdev = NULL;
1072 unsigned int tint;
1073 unsigned short tshort;
1074 #endif
1075
1076 func_enter();
1077 rio_dprintk (RIO_DEBUG_INIT, "Initing rio module... (rio_debug=%d)\n",
1078 rio_debug);
1079
1080 if (abs ((long) (&rio_debug) - rio_debug) < 0x10000) {
1081 printk (KERN_WARNING "rio: rio_debug is an address, instead of a value. "
1082 "Assuming -1. Was %x/%p.\n", rio_debug, &rio_debug);
1083 rio_debug=-1;
1084 }
1085
1086 if (misc_register(&rio_fw_device) < 0) {
1087 printk(KERN_ERR "RIO: Unable to register firmware loader driver.\n");
1088 return -EIO;
1089 }
1090
1091 retval = rio_init_datastructures ();
1092 if (retval < 0) {
1093 misc_deregister(&rio_fw_device);
1094 return retval;
1095 }
1096
1097 #ifdef CONFIG_PCI
1098 /* First look for the JET devices: */
1099 while ((pdev = pci_find_device (PCI_VENDOR_ID_SPECIALIX,
1100 PCI_DEVICE_ID_SPECIALIX_SX_XIO_IO8,
1101 pdev))) {
1102 if (pci_enable_device(pdev)) continue;
1103
1104 /* Specialix has a whole bunch of cards with
1105 0x2000 as the device ID. They say its because
1106 the standard requires it. Stupid standard. */
1107 /* It seems that reading a word doesn't work reliably on 2.0.
1108 Also, reading a non-aligned dword doesn't work. So we read the
1109 whole dword at 0x2c and extract the word at 0x2e (SUBSYSTEM_ID)
1110 ourselves */
1111 /* I don't know why the define doesn't work, constant 0x2c does --REW */
1112 pci_read_config_dword (pdev, 0x2c, &tint);
1113 tshort = (tint >> 16) & 0xffff;
1114 rio_dprintk (RIO_DEBUG_PROBE, "Got a specialix card: %x.\n", tint);
1115 if (tshort != 0x0100) {
1116 rio_dprintk (RIO_DEBUG_PROBE, "But it's not a RIO card (%d)...\n",
1117 tshort);
1118 continue;
1119 }
1120 rio_dprintk (RIO_DEBUG_PROBE, "cp1\n");
1121
1122 pci_read_config_dword(pdev, PCI_BASE_ADDRESS_2, &tint);
1123
1124 hp = &p->RIOHosts[p->RIONumHosts];
1125 hp->PaddrP = tint & PCI_BASE_ADDRESS_MEM_MASK;
1126 hp->Ivec = pdev->irq;
1127 if (((1 << hp->Ivec) & rio_irqmask) == 0)
1128 hp->Ivec = 0;
1129 hp->Caddr = ioremap(p->RIOHosts[p->RIONumHosts].PaddrP, RIO_WINDOW_LEN);
1130 hp->CardP = (struct DpRam *) hp->Caddr;
1131 hp->Type = RIO_PCI;
1132 hp->Copy = rio_pcicopy;
1133 hp->Mode = RIO_PCI_BOOT_FROM_RAM;
1134 spin_lock_init(&hp->HostLock);
1135 rio_reset_interrupt (hp);
1136 rio_start_card_running (hp);
1137
1138 rio_dprintk (RIO_DEBUG_PROBE, "Going to test it (%p/%p).\n",
1139 (void *)p->RIOHosts[p->RIONumHosts].PaddrP,
1140 p->RIOHosts[p->RIONumHosts].Caddr);
1141 if (RIOBoardTest( p->RIOHosts[p->RIONumHosts].PaddrP,
1142 p->RIOHosts[p->RIONumHosts].Caddr,
1143 RIO_PCI, 0 ) == RIO_SUCCESS) {
1144 rio_dprintk (RIO_DEBUG_INIT, "Done RIOBoardTest\n");
1145 WBYTE(p->RIOHosts[p->RIONumHosts].ResetInt, 0xff);
1146 p->RIOHosts[p->RIONumHosts].UniqueNum =
1147 ((RBYTE(p->RIOHosts[p->RIONumHosts].Unique[0]) &0xFF)<< 0)|
1148 ((RBYTE(p->RIOHosts[p->RIONumHosts].Unique[1]) &0xFF)<< 8)|
1149 ((RBYTE(p->RIOHosts[p->RIONumHosts].Unique[2]) &0xFF)<<16)|
1150 ((RBYTE(p->RIOHosts[p->RIONumHosts].Unique[3]) &0xFF)<<24);
1151 rio_dprintk (RIO_DEBUG_PROBE, "Hmm Tested ok, uniqid = %x.\n",
1152 p->RIOHosts[p->RIONumHosts].UniqueNum);
1153
1154 fix_rio_pci (pdev);
1155 p->RIOLastPCISearch = RIO_SUCCESS;
1156 p->RIONumHosts++;
1157 found++;
1158 } else {
1159 iounmap((char*) (p->RIOHosts[p->RIONumHosts].Caddr));
1160 }
1161 }
1162
1163 /* Then look for the older PCI card.... : */
1164
1165 /* These older PCI cards have problems (only byte-mode access is
1166 supported), which makes them a bit awkward to support.
1167 They also have problems sharing interrupts. Be careful.
1168 (The driver now refuses to share interrupts for these
1169 cards. This should be sufficient).
1170 */
1171
1172 /* Then look for the older RIO/PCI devices: */
1173 while ((pdev = pci_find_device (PCI_VENDOR_ID_SPECIALIX,
1174 PCI_DEVICE_ID_SPECIALIX_RIO,
1175 pdev))) {
1176 if (pci_enable_device(pdev)) continue;
1177
1178 #ifdef CONFIG_RIO_OLDPCI
1179 pci_read_config_dword(pdev, PCI_BASE_ADDRESS_0, &tint);
1180
1181 hp = &p->RIOHosts[p->RIONumHosts];
1182 hp->PaddrP = tint & PCI_BASE_ADDRESS_MEM_MASK;
1183 hp->Ivec = pdev->irq;
1184 if (((1 << hp->Ivec) & rio_irqmask) == 0)
1185 hp->Ivec = 0;
1186 hp->Ivec |= 0x8000; /* Mark as non-sharable */
1187 hp->Caddr = ioremap(p->RIOHosts[p->RIONumHosts].PaddrP, RIO_WINDOW_LEN);
1188 hp->CardP = (struct DpRam *) hp->Caddr;
1189 hp->Type = RIO_PCI;
1190 hp->Copy = rio_pcicopy;
1191 hp->Mode = RIO_PCI_BOOT_FROM_RAM;
1192 spin_lock_init(&hp->HostLock);
1193
1194 rio_dprintk (RIO_DEBUG_PROBE, "Ivec: %x\n", hp->Ivec);
1195 rio_dprintk (RIO_DEBUG_PROBE, "Mode: %x\n", hp->Mode);
1196
1197 rio_reset_interrupt (hp);
1198 rio_start_card_running (hp);
1199 rio_dprintk (RIO_DEBUG_PROBE, "Going to test it (%p/%p).\n",
1200 (void *)p->RIOHosts[p->RIONumHosts].PaddrP,
1201 p->RIOHosts[p->RIONumHosts].Caddr);
1202 if (RIOBoardTest( p->RIOHosts[p->RIONumHosts].PaddrP,
1203 p->RIOHosts[p->RIONumHosts].Caddr,
1204 RIO_PCI, 0 ) == RIO_SUCCESS) {
1205 WBYTE(p->RIOHosts[p->RIONumHosts].ResetInt, 0xff);
1206 p->RIOHosts[p->RIONumHosts].UniqueNum =
1207 ((RBYTE(p->RIOHosts[p->RIONumHosts].Unique[0]) &0xFF)<< 0)|
1208 ((RBYTE(p->RIOHosts[p->RIONumHosts].Unique[1]) &0xFF)<< 8)|
1209 ((RBYTE(p->RIOHosts[p->RIONumHosts].Unique[2]) &0xFF)<<16)|
1210 ((RBYTE(p->RIOHosts[p->RIONumHosts].Unique[3]) &0xFF)<<24);
1211 rio_dprintk (RIO_DEBUG_PROBE, "Hmm Tested ok, uniqid = %x.\n",
1212 p->RIOHosts[p->RIONumHosts].UniqueNum);
1213
1214 p->RIOLastPCISearch = RIO_SUCCESS;
1215 p->RIONumHosts++;
1216 found++;
1217 } else {
1218 iounmap((char*) (p->RIOHosts[p->RIONumHosts].Caddr));
1219 }
1220 #else
1221 printk (KERN_ERR "Found an older RIO PCI card, but the driver is not "
1222 "compiled to support it.\n");
1223 #endif
1224 }
1225 #endif /* PCI */
1226
1227 /* Now probe for ISA cards... */
1228 for (i=0;i<NR_RIO_ADDRS;i++) {
1229 hp = &p->RIOHosts[p->RIONumHosts];
1230 hp->PaddrP = rio_probe_addrs[i];
1231 /* There was something about the IRQs of these cards. 'Forget what.--REW */
1232 hp->Ivec = 0;
1233 hp->Caddr = ioremap(p->RIOHosts[p->RIONumHosts].PaddrP, RIO_WINDOW_LEN);
1234 hp->CardP = (struct DpRam *) hp->Caddr;
1235 hp->Type = RIO_AT;
1236 hp->Copy = rio_pcicopy; /* AT card PCI???? - PVDL
1237 * -- YES! this is now a normal copy. Only the
1238 * old PCI card uses the special PCI copy.
1239 * Moreover, the ISA card will work with the
1240 * special PCI copy anyway. -- REW */
1241 hp->Mode = 0;
1242 spin_lock_init(&hp->HostLock);
1243
1244 vpdp = get_VPD_PROM (hp);
1245 rio_dprintk (RIO_DEBUG_PROBE, "Got VPD ROM\n");
1246 okboard = 0;
1247 if ((strncmp (vpdp->identifier, RIO_ISA_IDENT, 16) == 0) ||
1248 (strncmp (vpdp->identifier, RIO_ISA2_IDENT, 16) == 0) ||
1249 (strncmp (vpdp->identifier, RIO_ISA3_IDENT, 16) == 0)) {
1250 /* Board is present... */
1251 if (RIOBoardTest (hp->PaddrP,
1252 hp->Caddr, RIO_AT, 0) == RIO_SUCCESS) {
1253 /* ... and feeling fine!!!! */
1254 rio_dprintk (RIO_DEBUG_PROBE, "Hmm Tested ok, uniqid = %x.\n",
1255 p->RIOHosts[p->RIONumHosts].UniqueNum);
1256 if (RIOAssignAT(p, hp->PaddrP, hp->Caddr, 0)) {
1257 rio_dprintk (RIO_DEBUG_PROBE, "Hmm Tested ok, host%d uniqid = %x.\n",
1258 p->RIONumHosts,
1259 p->RIOHosts[p->RIONumHosts-1].UniqueNum);
1260 okboard++;
1261 found++;
1262 }
1263 }
1264
1265 if (!okboard)
1266 iounmap ((char*) (hp->Caddr));
1267 }
1268 }
1269
1270
1271 for (i=0;i<p->RIONumHosts;i++) {
1272 hp = &p->RIOHosts[i];
1273 if (hp->Ivec) {
1274 int mode = SA_SHIRQ;
1275 if (hp->Ivec & 0x8000) {mode = 0; hp->Ivec &= 0x7fff;}
1276 rio_dprintk (RIO_DEBUG_INIT, "Requesting interrupt hp: %p rio_interrupt: %d Mode: %x\n", hp,hp->Ivec, hp->Mode);
1277 retval = request_irq (hp->Ivec, rio_interrupt, mode, "rio", hp);
1278 rio_dprintk (RIO_DEBUG_INIT, "Return value from request_irq: %d\n", retval);
1279 if (retval) {
1280 printk(KERN_ERR "rio: Cannot allocate irq %d.\n", hp->Ivec);
1281 hp->Ivec = 0;
1282 }
1283 rio_dprintk (RIO_DEBUG_INIT, "Got irq %d.\n", hp->Ivec);
1284 if (hp->Ivec != 0){
1285 rio_dprintk (RIO_DEBUG_INIT, "Enabling interrupts on rio card.\n");
1286 hp->Mode |= RIO_PCI_INT_ENABLE;
1287 } else
1288 hp->Mode &= !RIO_PCI_INT_ENABLE;
1289 rio_dprintk (RIO_DEBUG_INIT, "New Mode: %x\n", hp->Mode);
1290 rio_start_card_running (hp);
1291 }
1292 /* Init the timer "always" to make sure that it can safely be
1293 deleted when we unload... */
1294
1295 init_timer (&hp->timer);
1296 if (!hp->Ivec) {
1297 rio_dprintk (RIO_DEBUG_INIT, "Starting polling at %dj intervals.\n",
1298 rio_poll);
1299 hp->timer.data = i;
1300 hp->timer.function = rio_pollfunc;
1301 hp->timer.expires = jiffies + rio_poll;
1302 add_timer (&hp->timer);
1303 }
1304 }
1305
1306 if (found) {
1307 rio_dprintk (RIO_DEBUG_INIT, "rio: total of %d boards detected.\n", found);
1308 rio_init_drivers ();
1309 } else {
1310 /* deregister the misc device we created earlier */
1311 misc_deregister(&rio_fw_device);
1312 }
1313
1314 func_exit();
1315 return found?0:-EIO;
1316 }
1317
1318
1319 static void __exit rio_exit (void)
1320 {
1321 int i;
1322 struct Host *hp;
1323
1324 func_enter();
1325
1326 for (i=0,hp=p->RIOHosts;i<p->RIONumHosts;i++, hp++) {
1327 RIOHostReset (hp->Type, hp->CardP, hp->Slot);
1328 if (hp->Ivec) {
1329 free_irq (hp->Ivec, hp);
1330 rio_dprintk (RIO_DEBUG_INIT, "freed irq %d.\n", hp->Ivec);
1331 }
1332 /* It is safe/allowed to del_timer a non-active timer */
1333 del_timer (&hp->timer);
1334 }
1335
1336 if (misc_deregister(&rio_fw_device) < 0) {
1337 printk (KERN_INFO "rio: couldn't deregister control-device\n");
1338 }
1339
1340
1341 rio_dprintk (RIO_DEBUG_CLEANUP, "Cleaning up drivers\n");
1342
1343 rio_release_drivers ();
1344
1345 /* Release dynamically allocated memory */
1346 kfree (p->RIOPortp);
1347 kfree (p->RIOHosts);
1348 kfree (p);
1349
1350 func_exit();
1351 }
1352
1353 module_init(rio_init);
1354 module_exit(rio_exit);
1355
1356 /*
1357 * Anybody who knows why this doesn't work for me, please tell me -- REW.
1358 * Snatched from scsi.c (fixed one spelling error):
1359 * Overrides for Emacs so that we follow Linus' tabbing style.
1360 * Emacs will notice this stuff at the end of the file and automatically
1361 * adjust the settings for this buffer only. This must remain at the end
1362 * of the file.
1363 * ---------------------------------------------------------------------------
1364 * Local Variables:
1365 * c-indent-level: 4
1366 * c-brace-imaginary-offset: 0
1367 * c-brace-offset: -4
1368 * c-argdecl-indent: 4
1369 * c-label-offset: -4
1370 * c-continued-statement-offset: 4
1371 * c-continued-brace-offset: 0
1372 * indent-tabs-mode: nil
1373 * tab-width: 8
1374 * End:
1375 */
1376
1377
|
This page was automatically generated by the
LXR engine.
|