Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
tjh.dev
kernel
os
linux
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
103one machine. Specialix specifies max 4 boards in one machine. I don't
104know why. If you want to try anyway you'll have to increase the number
105of boards in rio.h. You'll have to allocate more majors if you need
106more 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 */
151static struct Conf
152RIOConf =
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
182static void rio_disable_tx_interrupts (void * ptr);
183static void rio_enable_tx_interrupts (void * ptr);
184static void rio_disable_rx_interrupts (void * ptr);
185static void rio_enable_rx_interrupts (void * ptr);
186static int rio_get_CD (void * ptr);
187static void rio_shutdown_port (void * ptr);
188static int rio_set_real_termios (void *ptr);
189static void rio_hungup (void *ptr);
190static void rio_close (void *ptr);
191static int rio_chars_in_buffer (void * ptr);
192static int rio_fw_ioctl (struct inode *inode, struct file *filp,
193 unsigned int cmd, unsigned long arg);
194static int rio_init_drivers(void);
195
196static void my_hd (void *addr, int len);
197
198static struct tty_driver *rio_driver, *rio_driver2;
199
200/* The name "p" is a bit non-descript. But that's what the rio-lynxos
201sources use all over the place. */
202struct rio_info *p;
203
204int 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*/
211static int rio_poll = 1;
212
213
214/* These are the only open spaces in my computer. Yours may have more
215 or less.... */
216static 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 */
224static long rio_irqmask = -1;
225
226MODULE_AUTHOR("Rogier Wolff <R.E.Wolff@bitwizard.nl>, Patrick van de Lageweg <patrick@bitwizard.nl>");
227MODULE_DESCRIPTION("RIO driver");
228MODULE_LICENSE("GPL");
229module_param(rio_poll, int, 0);
230module_param(rio_debug, int, 0644);
231module_param(rio_irqmask, long, 0);
232
233static 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
252static struct file_operations rio_fw_fops = {
253 .owner = THIS_MODULE,
254 .ioctl = rio_fw_ioctl,
255};
256
257static 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
269static 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
295static 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 */
318int 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 */
334int 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
345int rio_minor(struct tty_struct *tty)
346{
347 return tty->index + (tty->driver == rio_driver) ? 0 : 256;
348}
349
350
351int rio_ismodem(struct tty_struct *tty)
352{
353 return 1;
354}
355
356
357static int rio_set_real_termios (void *ptr)
358{
359 int rv, modem;
360 struct tty_struct *tty;
361 func_enter();
362
363 tty = ((struct Port *)ptr)->gs.tty;
364
365 modem = rio_ismodem(tty);
366
367 rv = RIOParam( (struct Port *) ptr, CONFIG, modem, 1);
368
369 func_exit ();
370
371 return rv;
372}
373
374
375static void rio_reset_interrupt (struct Host *HostP)
376{
377 func_enter();
378
379 switch( HostP->Type ) {
380 case RIO_AT:
381 case RIO_MCA:
382 case RIO_PCI:
383 WBYTE(HostP->ResetInt , 0xff);
384 }
385
386 func_exit();
387}
388
389
390static irqreturn_t rio_interrupt (int irq, void *ptr, struct pt_regs *regs)
391{
392 struct Host *HostP;
393 func_enter ();
394
395 HostP = (struct Host*)ptr; /* &p->RIOHosts[(long)ptr]; */
396 rio_dprintk (RIO_DEBUG_IFLOW, "rio: enter rio_interrupt (%d/%d)\n",
397 irq, HostP->Ivec);
398
399 /* AAargh! The order in which to do these things is essential and
400 not trivial.
401
402 - Rate limit goes before "recursive". Otherwise a series of
403 recursive calls will hang the machine in the interrupt routine.
404
405 - hardware twiddling goes before "recursive". Otherwise when we
406 poll the card, and a recursive interrupt happens, we won't
407 ack the card, so it might keep on interrupting us. (especially
408 level sensitive interrupt systems like PCI).
409
410 - Rate limit goes before hardware twiddling. Otherwise we won't
411 catch a card that has gone bonkers.
412
413 - The "initialized" test goes after the hardware twiddling. Otherwise
414 the card will stick us in the interrupt routine again.
415
416 - The initialized test goes before recursive.
417 */
418
419
420
421#ifdef IRQ_RATE_LIMIT
422 /* Aaargh! I'm ashamed. This costs more lines-of-code than the
423 actual interrupt routine!. (Well, used to when I wrote that comment) */
424 {
425 static int lastjif;
426 static int nintr=0;
427
428 if (lastjif == jiffies) {
429 if (++nintr > IRQ_RATE_LIMIT) {
430 free_irq (HostP->Ivec, ptr);
431 printk (KERN_ERR "rio: Too many interrupts. Turning off interrupt %d.\n",
432 HostP->Ivec);
433 }
434 } else {
435 lastjif = jiffies;
436 nintr = 0;
437 }
438 }
439#endif
440 rio_dprintk (RIO_DEBUG_IFLOW, "rio: We've have noticed the interrupt\n");
441 if (HostP->Ivec == irq) {
442 /* Tell the card we've noticed the interrupt. */
443 rio_reset_interrupt (HostP);
444 }
445
446 if ((HostP->Flags & RUN_STATE) != RC_RUNNING)
447 return IRQ_HANDLED;
448
449 if (test_and_set_bit (RIO_BOARD_INTR_LOCK, &HostP->locks)) {
450 printk (KERN_ERR "Recursive interrupt! (host %d/irq%d)\n",
451 (int) ptr, HostP->Ivec);
452 return IRQ_HANDLED;
453 }
454
455 RIOServiceHost(p, HostP, irq);
456
457 rio_dprintk ( RIO_DEBUG_IFLOW, "riointr() doing host %d type %d\n",
458 (int) ptr, HostP->Type);
459
460 clear_bit (RIO_BOARD_INTR_LOCK, &HostP->locks);
461 rio_dprintk (RIO_DEBUG_IFLOW, "rio: exit rio_interrupt (%d/%d)\n",
462 irq, HostP->Ivec);
463 func_exit ();
464 return IRQ_HANDLED;
465}
466
467
468static void rio_pollfunc (unsigned long data)
469{
470 func_enter ();
471
472 rio_interrupt (0, &p->RIOHosts[data], NULL);
473 p->RIOHosts[data].timer.expires = jiffies + rio_poll;
474 add_timer (&p->RIOHosts[data].timer);
475
476 func_exit ();
477}
478
479
480/* ********************************************************************** *
481 * Here are the routines that actually *
482 * interface with the generic_serial driver *
483 * ********************************************************************** */
484
485/* Ehhm. I don't know how to fiddle with interrupts on the Specialix
486 cards. .... Hmm. Ok I figured it out. You don't. -- REW */
487
488static void rio_disable_tx_interrupts (void * ptr)
489{
490 func_enter();
491
492 /* port->gs.flags &= ~GS_TX_INTEN; */
493
494 func_exit();
495}
496
497
498static void rio_enable_tx_interrupts (void * ptr)
499{
500 struct Port *PortP = ptr;
501 /* int hn; */
502
503 func_enter();
504
505 /* hn = PortP->HostP - p->RIOHosts;
506
507 rio_dprintk (RIO_DEBUG_TTY, "Pushing host %d\n", hn);
508 rio_interrupt (-1,(void *) hn, NULL); */
509
510 RIOTxEnable((char *) PortP);
511
512 /*
513 * In general we cannot count on "tx empty" interrupts, although
514 * the interrupt routine seems to be able to tell the difference.
515 */
516 PortP->gs.flags &= ~GS_TX_INTEN;
517
518 func_exit();
519}
520
521
522static void rio_disable_rx_interrupts (void * ptr)
523{
524 func_enter();
525 func_exit();
526}
527
528static void rio_enable_rx_interrupts (void * ptr)
529{
530 /* struct rio_port *port = ptr; */
531 func_enter();
532 func_exit();
533}
534
535
536/* Jeez. Isn't this simple? */
537static int rio_get_CD (void * ptr)
538{
539 struct Port *PortP = ptr;
540 int rv;
541
542 func_enter();
543 rv = (PortP->ModemState & MSVR1_CD) != 0;
544
545 rio_dprintk (RIO_DEBUG_INIT, "Getting CD status: %d\n", rv);
546
547 func_exit();
548 return rv;
549}
550
551
552/* Jeez. Isn't this simple? Actually, we can sync with the actual port
553 by just pushing stuff into the queue going to the port... */
554static int rio_chars_in_buffer (void * ptr)
555{
556 func_enter();
557
558 func_exit();
559 return 0;
560}
561
562
563/* Nothing special here... */
564static void rio_shutdown_port (void * ptr)
565{
566 struct Port *PortP;
567
568 func_enter();
569
570 PortP = (struct Port *)ptr;
571 PortP->gs.tty = NULL;
572#if 0
573 port->gs.flags &= ~ GS_ACTIVE;
574 if (!port->gs.tty) {
575 rio_dprintk (RIO_DBUG_TTY, "No tty.\n");
576 return;
577 }
578 if (!port->gs.tty->termios) {
579 rio_dprintk (RIO_DEBUG_TTY, "No termios.\n");
580 return;
581 }
582 if (port->gs.tty->termios->c_cflag & HUPCL) {
583 rio_setsignals (port, 0, 0);
584 }
585#endif
586
587 func_exit();
588}
589
590
591/* I haven't the foggiest why the decrement use count has to happen
592 here. The whole linux serial drivers stuff needs to be redesigned.
593 My guess is that this is a hack to minimize the impact of a bug
594 elsewhere. Thinking about it some more. (try it sometime) Try
595 running minicom on a serial port that is driven by a modularized
596 driver. Have the modem hangup. Then remove the driver module. Then
597 exit minicom. I expect an "oops". -- REW */
598static void rio_hungup (void *ptr)
599{
600 struct Port *PortP;
601
602 func_enter();
603
604 PortP = (struct Port *)ptr;
605 PortP->gs.tty = NULL;
606
607 func_exit ();
608}
609
610
611/* The standard serial_close would become shorter if you'd wrap it like
612 this.
613 rs_close (...){save_flags;cli;real_close();dec_use_count;restore_flags;}
614 */
615static void rio_close (void *ptr)
616{
617 struct Port *PortP;
618
619 func_enter ();
620
621 PortP = (struct Port *)ptr;
622
623 riotclose (ptr);
624
625 if(PortP->gs.count) {
626 printk (KERN_ERR "WARNING port count:%d\n", PortP->gs.count);
627 PortP->gs.count = 0;
628 }
629
630 PortP->gs.tty = NULL;
631 func_exit ();
632}
633
634
635
636static int rio_fw_ioctl (struct inode *inode, struct file *filp,
637 unsigned int cmd, unsigned long arg)
638{
639 int rc = 0;
640 func_enter();
641
642 /* The "dev" argument isn't used. */
643 rc = riocontrol (p, 0, cmd, (void *)arg, capable(CAP_SYS_ADMIN));
644
645 func_exit ();
646 return rc;
647}
648
649extern int RIOShortCommand(struct rio_info *p, struct Port *PortP,
650 int command, int len, int arg);
651
652static int rio_ioctl (struct tty_struct * tty, struct file * filp,
653 unsigned int cmd, unsigned long arg)
654{
655 int rc;
656 struct Port *PortP;
657 int ival;
658
659 func_enter();
660
661 PortP = (struct Port *)tty->driver_data;
662
663 rc = 0;
664 switch (cmd) {
665#if 0
666 case TIOCGSOFTCAR:
667 rc = put_user(((tty->termios->c_cflag & CLOCAL) ? 1 : 0),
668 (unsigned int *) arg);
669 break;
670#endif
671 case TIOCSSOFTCAR:
672 if ((rc = get_user(ival, (unsigned int *) arg)) == 0) {
673 tty->termios->c_cflag =
674 (tty->termios->c_cflag & ~CLOCAL) |
675 (ival ? CLOCAL : 0);
676 }
677 break;
678 case TIOCGSERIAL:
679 rc = -EFAULT;
680 if (access_ok(VERIFY_WRITE, (void *) arg,
681 sizeof(struct serial_struct)))
682 rc = gs_getserial(&PortP->gs, (struct serial_struct *) arg);
683 break;
684 case TCSBRK:
685 if ( PortP->State & RIO_DELETED ) {
686 rio_dprintk (RIO_DEBUG_TTY, "BREAK on deleted RTA\n");
687 rc = -EIO;
688 } else {
689 if (RIOShortCommand(p, PortP, SBREAK, 2, 250) == RIO_FAIL) {
690 rio_dprintk (RIO_DEBUG_INTR, "SBREAK RIOShortCommand failed\n");
691 rc = -EIO;
692 }
693 }
694 break;
695 case TCSBRKP:
696 if ( PortP->State & RIO_DELETED ) {
697 rio_dprintk (RIO_DEBUG_TTY, "BREAK on deleted RTA\n");
698 rc = -EIO;
699 } else {
700 int l;
701 l = arg?arg*100:250;
702 if (l > 255) l = 255;
703 if (RIOShortCommand(p, PortP, SBREAK, 2, arg?arg*100:250) == RIO_FAIL) {
704 rio_dprintk (RIO_DEBUG_INTR, "SBREAK RIOShortCommand failed\n");
705 rc = -EIO;
706 }
707 }
708 break;
709 case TIOCSSERIAL:
710 rc = -EFAULT;
711 if (access_ok(VERIFY_READ, (void *) arg,
712 sizeof(struct serial_struct)))
713 rc = gs_setserial(&PortP->gs, (struct serial_struct *) arg);
714 break;
715#if 0
716 /*
717 * note: these IOCTLs no longer reach here. Use
718 * tiocmset/tiocmget driver methods instead. The
719 * #if 0 disablement predates this comment.
720 */
721 case TIOCMGET:
722 rc = -EFAULT;
723 if (access_ok(VERIFY_WRITE, (void *) arg,
724 sizeof(unsigned int))) {
725 rc = 0;
726 ival = rio_getsignals(port);
727 put_user(ival, (unsigned int *) arg);
728 }
729 break;
730 case TIOCMBIS:
731 if ((rc = get_user(ival, (unsigned int *) arg)) == 0) {
732 rio_setsignals(port, ((ival & TIOCM_DTR) ? 1 : -1),
733 ((ival & TIOCM_RTS) ? 1 : -1));
734 }
735 break;
736 case TIOCMBIC:
737 if ((rc = get_user(ival, (unsigned int *) arg)) == 0) {
738 rio_setsignals(port, ((ival & TIOCM_DTR) ? 0 : -1),
739 ((ival & TIOCM_RTS) ? 0 : -1));
740 }
741 break;
742 case TIOCMSET:
743 if ((rc = get_user(ival, (unsigned int *) arg)) == 0) {
744 rio_setsignals(port, ((ival & TIOCM_DTR) ? 1 : 0),
745 ((ival & TIOCM_RTS) ? 1 : 0));
746 }
747 break;
748#endif
749 default:
750 rc = -ENOIOCTLCMD;
751 break;
752 }
753 func_exit();
754 return rc;
755}
756
757
758/* The throttle/unthrottle scheme for the Specialix card is different
759 * from other drivers and deserves some explanation.
760 * The Specialix hardware takes care of XON/XOFF
761 * and CTS/RTS flow control itself. This means that all we have to
762 * do when signalled by the upper tty layer to throttle/unthrottle is
763 * to make a note of it here. When we come to read characters from the
764 * rx buffers on the card (rio_receive_chars()) we look to see if the
765 * upper layer can accept more (as noted here in rio_rx_throt[]).
766 * If it can't we simply don't remove chars from the cards buffer.
767 * When the tty layer can accept chars, we again note that here and when
768 * rio_receive_chars() is called it will remove them from the cards buffer.
769 * The card will notice that a ports buffer has drained below some low
770 * water mark and will unflow control the line itself, using whatever
771 * flow control scheme is in use for that port. -- Simon Allen
772 */
773
774static void rio_throttle (struct tty_struct * tty)
775{
776 struct Port *port = (struct Port *)tty->driver_data;
777
778 func_enter();
779 /* If the port is using any type of input flow
780 * control then throttle the port.
781 */
782
783 if((tty->termios->c_cflag & CRTSCTS) || (I_IXOFF(tty)) ) {
784 port->State |= RIO_THROTTLE_RX;
785 }
786
787 func_exit();
788}
789
790
791static void rio_unthrottle (struct tty_struct * tty)
792{
793 struct Port *port = (struct Port *)tty->driver_data;
794
795 func_enter();
796 /* Always unthrottle even if flow control is not enabled on
797 * this port in case we disabled flow control while the port
798 * was throttled
799 */
800
801 port->State &= ~RIO_THROTTLE_RX;
802
803 func_exit();
804 return;
805}
806
807
808
809
810
811/* ********************************************************************** *
812 * Here are the initialization routines. *
813 * ********************************************************************** */
814
815
816static struct vpd_prom *get_VPD_PROM (struct Host *hp)
817{
818 static struct vpd_prom vpdp;
819 char *p;
820 int i;
821
822 func_enter();
823 rio_dprintk (RIO_DEBUG_PROBE, "Going to verify vpd prom at %p.\n",
824 hp->Caddr + RIO_VPD_ROM);
825
826 p = (char *) &vpdp;
827 for (i=0;i< sizeof (struct vpd_prom);i++)
828 *p++ = readb (hp->Caddr+RIO_VPD_ROM + i*2);
829 /* read_rio_byte (hp, RIO_VPD_ROM + i*2); */
830
831 /* Terminate the identifier string.
832 *** requires one extra byte in struct vpd_prom *** */
833 *p++=0;
834
835 if (rio_debug & RIO_DEBUG_PROBE)
836 my_hd ((char *)&vpdp, 0x20);
837
838 func_exit();
839
840 return &vpdp;
841}
842
843static struct tty_operations rio_ops = {
844 .open = riotopen,
845 .close = gs_close,
846 .write = gs_write,
847 .put_char = gs_put_char,
848 .flush_chars = gs_flush_chars,
849 .write_room = gs_write_room,
850 .chars_in_buffer = gs_chars_in_buffer,
851 .flush_buffer = gs_flush_buffer,
852 .ioctl = rio_ioctl,
853 .throttle = rio_throttle,
854 .unthrottle = rio_unthrottle,
855 .set_termios = gs_set_termios,
856 .stop = gs_stop,
857 .start = gs_start,
858 .hangup = gs_hangup,
859};
860
861static int rio_init_drivers(void)
862{
863 int error = -ENOMEM;
864
865 rio_driver = alloc_tty_driver(256);
866 if (!rio_driver)
867 goto out;
868 rio_driver2 = alloc_tty_driver(256);
869 if (!rio_driver2)
870 goto out1;
871
872 func_enter();
873
874 rio_driver->owner = THIS_MODULE;
875 rio_driver->driver_name = "specialix_rio";
876 rio_driver->name = "ttySR";
877 rio_driver->major = RIO_NORMAL_MAJOR0;
878 rio_driver->type = TTY_DRIVER_TYPE_SERIAL;
879 rio_driver->subtype = SERIAL_TYPE_NORMAL;
880 rio_driver->init_termios = tty_std_termios;
881 rio_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
882 rio_driver->flags = TTY_DRIVER_REAL_RAW;
883 tty_set_operations(rio_driver, &rio_ops);
884
885 rio_driver2->owner = THIS_MODULE;
886 rio_driver2->driver_name = "specialix_rio";
887 rio_driver2->name = "ttySR";
888 rio_driver2->major = RIO_NORMAL_MAJOR1;
889 rio_driver2->type = TTY_DRIVER_TYPE_SERIAL;
890 rio_driver2->subtype = SERIAL_TYPE_NORMAL;
891 rio_driver2->init_termios = tty_std_termios;
892 rio_driver2->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
893 rio_driver2->flags = TTY_DRIVER_REAL_RAW;
894 tty_set_operations(rio_driver2, &rio_ops);
895
896 rio_dprintk (RIO_DEBUG_INIT, "set_termios = %p\n", gs_set_termios);
897
898 if ((error = tty_register_driver(rio_driver)))
899 goto out2;
900 if ((error = tty_register_driver(rio_driver2)))
901 goto out3;
902 func_exit();
903 return 0;
904out3:
905 tty_unregister_driver(rio_driver);
906out2:
907 put_tty_driver(rio_driver2);
908out1:
909 put_tty_driver(rio_driver);
910out:
911 printk(KERN_ERR "rio: Couldn't register a rio driver, error = %d\n",
912 error);
913 return 1;
914}
915
916
917static void * ckmalloc (int size)
918{
919 void *p;
920
921 p = kmalloc(size, GFP_KERNEL);
922 if (p)
923 memset(p, 0, size);
924 return p;
925}
926
927
928
929static int rio_init_datastructures (void)
930{
931 int i;
932 struct Port *port;
933 func_enter();
934
935 /* Many drivers statically allocate the maximum number of ports
936 There is no reason not to allocate them dynamically. Is there? -- REW */
937 /* However, the RIO driver allows users to configure their first
938 RTA as the ports numbered 504-511. We therefore need to allocate
939 the whole range. :-( -- REW */
940
941#define RI_SZ sizeof(struct rio_info)
942#define HOST_SZ sizeof(struct Host)
943#define PORT_SZ sizeof(struct Port *)
944#define TMIO_SZ sizeof(struct termios *)
945 rio_dprintk (RIO_DEBUG_INIT, "getting : %d %d %d %d %d bytes\n",
946 RI_SZ,
947 RIO_HOSTS * HOST_SZ,
948 RIO_PORTS * PORT_SZ,
949 RIO_PORTS * TMIO_SZ,
950 RIO_PORTS * TMIO_SZ);
951
952 if (!(p = ckmalloc ( RI_SZ))) goto free0;
953 if (!(p->RIOHosts = ckmalloc (RIO_HOSTS * HOST_SZ))) goto free1;
954 if (!(p->RIOPortp = ckmalloc (RIO_PORTS * PORT_SZ))) goto free2;
955 p->RIOConf = RIOConf;
956 rio_dprintk (RIO_DEBUG_INIT, "Got : %p %p %p\n",
957 p, p->RIOHosts, p->RIOPortp);
958
959#if 1
960 for (i = 0; i < RIO_PORTS; i++) {
961 port = p->RIOPortp[i] = ckmalloc (sizeof (struct Port));
962 if (!port) {
963 goto free6;
964 }
965 rio_dprintk (RIO_DEBUG_INIT, "initing port %d (%d)\n", i, port->Mapped);
966 port->PortNum = i;
967 port->gs.magic = RIO_MAGIC;
968 port->gs.close_delay = HZ/2;
969 port->gs.closing_wait = 30 * HZ;
970 port->gs.rd = &rio_real_driver;
971 spin_lock_init(&port->portSem);
972 /*
973 * Initializing wait queue
974 */
975 init_waitqueue_head(&port->gs.open_wait);
976 init_waitqueue_head(&port->gs.close_wait);
977 }
978#else
979 /* We could postpone initializing them to when they are configured. */
980#endif
981
982
983
984 if (rio_debug & RIO_DEBUG_INIT) {
985 my_hd (&rio_real_driver, sizeof (rio_real_driver));
986 }
987
988
989 func_exit();
990 return 0;
991
992 free6:for (i--;i>=0;i--)
993 kfree (p->RIOPortp[i]);
994/*free5:
995 free4:
996 free3:*/kfree (p->RIOPortp);
997 free2:kfree (p->RIOHosts);
998 free1:
999 rio_dprintk (RIO_DEBUG_INIT, "Not enough memory! %p %p %p\n",
1000 p, p->RIOHosts, p->RIOPortp);
1001 kfree(p);
1002 free0:
1003 return -ENOMEM;
1004}
1005
1006static void __exit rio_release_drivers(void)
1007{
1008 func_enter();
1009 tty_unregister_driver(rio_driver2);
1010 tty_unregister_driver(rio_driver);
1011 put_tty_driver(rio_driver2);
1012 put_tty_driver(rio_driver);
1013 func_exit();
1014}
1015
1016
1017#ifdef CONFIG_PCI
1018 /* This was written for SX, but applies to RIO too...
1019 (including bugs....)
1020
1021 There is another bit besides Bit 17. Turning that bit off
1022 (on boards shipped with the fix in the eeprom) results in a
1023 hang on the next access to the card.
1024 */
1025
1026 /********************************************************
1027 * Setting bit 17 in the CNTRL register of the PLX 9050 *
1028 * chip forces a retry on writes while a read is pending.*
1029 * This is to prevent the card locking up on Intel Xeon *
1030 * multiprocessor systems with the NX chipset. -- NV *
1031 ********************************************************/
1032
1033/* Newer cards are produced with this bit set from the configuration
1034 EEprom. As the bit is read/write for the CPU, we can fix it here,
1035 if we detect that it isn't set correctly. -- REW */
1036
1037static void fix_rio_pci (struct pci_dev *pdev)
1038{
1039 unsigned int hwbase;
1040 unsigned long rebase;
1041 unsigned int t;
1042
1043#define CNTRL_REG_OFFSET 0x50
1044#define CNTRL_REG_GOODVALUE 0x18260000
1045
1046 pci_read_config_dword(pdev, PCI_BASE_ADDRESS_0, &hwbase);
1047 hwbase &= PCI_BASE_ADDRESS_MEM_MASK;
1048 rebase = (ulong) ioremap(hwbase, 0x80);
1049 t = readl (rebase + CNTRL_REG_OFFSET);
1050 if (t != CNTRL_REG_GOODVALUE) {
1051 printk (KERN_DEBUG "rio: performing cntrl reg fix: %08x -> %08x\n",
1052 t, CNTRL_REG_GOODVALUE);
1053 writel (CNTRL_REG_GOODVALUE, rebase + CNTRL_REG_OFFSET);
1054 }
1055 iounmap((char*) rebase);
1056}
1057#endif
1058
1059
1060static int __init rio_init(void)
1061{
1062 int found = 0;
1063 int i;
1064 struct Host *hp;
1065 int retval;
1066 struct vpd_prom *vpdp;
1067 int okboard;
1068
1069#ifdef CONFIG_PCI
1070 struct pci_dev *pdev = NULL;
1071 unsigned int tint;
1072 unsigned short tshort;
1073#endif
1074
1075 func_enter();
1076 rio_dprintk (RIO_DEBUG_INIT, "Initing rio module... (rio_debug=%d)\n",
1077 rio_debug);
1078
1079 if (abs ((long) (&rio_debug) - rio_debug) < 0x10000) {
1080 printk (KERN_WARNING "rio: rio_debug is an address, instead of a value. "
1081 "Assuming -1. Was %x/%p.\n", rio_debug, &rio_debug);
1082 rio_debug=-1;
1083 }
1084
1085 if (misc_register(&rio_fw_device) < 0) {
1086 printk(KERN_ERR "RIO: Unable to register firmware loader driver.\n");
1087 return -EIO;
1088 }
1089
1090 retval = rio_init_datastructures ();
1091 if (retval < 0) {
1092 misc_deregister(&rio_fw_device);
1093 return retval;
1094 }
1095
1096#ifdef CONFIG_PCI
1097 /* First look for the JET devices: */
1098 while ((pdev = pci_get_device (PCI_VENDOR_ID_SPECIALIX,
1099 PCI_DEVICE_ID_SPECIALIX_SX_XIO_IO8,
1100 pdev))) {
1101 if (pci_enable_device(pdev)) continue;
1102
1103 /* Specialix has a whole bunch of cards with
1104 0x2000 as the device ID. They say its because
1105 the standard requires it. Stupid standard. */
1106 /* It seems that reading a word doesn't work reliably on 2.0.
1107 Also, reading a non-aligned dword doesn't work. So we read the
1108 whole dword at 0x2c and extract the word at 0x2e (SUBSYSTEM_ID)
1109 ourselves */
1110 /* I don't know why the define doesn't work, constant 0x2c does --REW */
1111 pci_read_config_dword (pdev, 0x2c, &tint);
1112 tshort = (tint >> 16) & 0xffff;
1113 rio_dprintk (RIO_DEBUG_PROBE, "Got a specialix card: %x.\n", tint);
1114 if (tshort != 0x0100) {
1115 rio_dprintk (RIO_DEBUG_PROBE, "But it's not a RIO card (%d)...\n",
1116 tshort);
1117 continue;
1118 }
1119 rio_dprintk (RIO_DEBUG_PROBE, "cp1\n");
1120
1121 pci_read_config_dword(pdev, PCI_BASE_ADDRESS_2, &tint);
1122
1123 hp = &p->RIOHosts[p->RIONumHosts];
1124 hp->PaddrP = tint & PCI_BASE_ADDRESS_MEM_MASK;
1125 hp->Ivec = pdev->irq;
1126 if (((1 << hp->Ivec) & rio_irqmask) == 0)
1127 hp->Ivec = 0;
1128 hp->Caddr = ioremap(p->RIOHosts[p->RIONumHosts].PaddrP, RIO_WINDOW_LEN);
1129 hp->CardP = (struct DpRam *) hp->Caddr;
1130 hp->Type = RIO_PCI;
1131 hp->Copy = rio_pcicopy;
1132 hp->Mode = RIO_PCI_BOOT_FROM_RAM;
1133 spin_lock_init(&hp->HostLock);
1134 rio_reset_interrupt (hp);
1135 rio_start_card_running (hp);
1136
1137 rio_dprintk (RIO_DEBUG_PROBE, "Going to test it (%p/%p).\n",
1138 (void *)p->RIOHosts[p->RIONumHosts].PaddrP,
1139 p->RIOHosts[p->RIONumHosts].Caddr);
1140 if (RIOBoardTest( p->RIOHosts[p->RIONumHosts].PaddrP,
1141 p->RIOHosts[p->RIONumHosts].Caddr,
1142 RIO_PCI, 0 ) == RIO_SUCCESS) {
1143 rio_dprintk (RIO_DEBUG_INIT, "Done RIOBoardTest\n");
1144 WBYTE(p->RIOHosts[p->RIONumHosts].ResetInt, 0xff);
1145 p->RIOHosts[p->RIONumHosts].UniqueNum =
1146 ((RBYTE(p->RIOHosts[p->RIONumHosts].Unique[0]) &0xFF)<< 0)|
1147 ((RBYTE(p->RIOHosts[p->RIONumHosts].Unique[1]) &0xFF)<< 8)|
1148 ((RBYTE(p->RIOHosts[p->RIONumHosts].Unique[2]) &0xFF)<<16)|
1149 ((RBYTE(p->RIOHosts[p->RIONumHosts].Unique[3]) &0xFF)<<24);
1150 rio_dprintk (RIO_DEBUG_PROBE, "Hmm Tested ok, uniqid = %x.\n",
1151 p->RIOHosts[p->RIONumHosts].UniqueNum);
1152
1153 fix_rio_pci (pdev);
1154 p->RIOLastPCISearch = RIO_SUCCESS;
1155 p->RIONumHosts++;
1156 found++;
1157 } else {
1158 iounmap((char*) (p->RIOHosts[p->RIONumHosts].Caddr));
1159 }
1160 }
1161
1162 /* Then look for the older PCI card.... : */
1163
1164 /* These older PCI cards have problems (only byte-mode access is
1165 supported), which makes them a bit awkward to support.
1166 They also have problems sharing interrupts. Be careful.
1167 (The driver now refuses to share interrupts for these
1168 cards. This should be sufficient).
1169 */
1170
1171 /* Then look for the older RIO/PCI devices: */
1172 while ((pdev = pci_get_device (PCI_VENDOR_ID_SPECIALIX,
1173 PCI_DEVICE_ID_SPECIALIX_RIO,
1174 pdev))) {
1175 if (pci_enable_device(pdev)) continue;
1176
1177#ifdef CONFIG_RIO_OLDPCI
1178 pci_read_config_dword(pdev, PCI_BASE_ADDRESS_0, &tint);
1179
1180 hp = &p->RIOHosts[p->RIONumHosts];
1181 hp->PaddrP = tint & PCI_BASE_ADDRESS_MEM_MASK;
1182 hp->Ivec = pdev->irq;
1183 if (((1 << hp->Ivec) & rio_irqmask) == 0)
1184 hp->Ivec = 0;
1185 hp->Ivec |= 0x8000; /* Mark as non-sharable */
1186 hp->Caddr = ioremap(p->RIOHosts[p->RIONumHosts].PaddrP, RIO_WINDOW_LEN);
1187 hp->CardP = (struct DpRam *) hp->Caddr;
1188 hp->Type = RIO_PCI;
1189 hp->Copy = rio_pcicopy;
1190 hp->Mode = RIO_PCI_BOOT_FROM_RAM;
1191 spin_lock_init(&hp->HostLock);
1192
1193 rio_dprintk (RIO_DEBUG_PROBE, "Ivec: %x\n", hp->Ivec);
1194 rio_dprintk (RIO_DEBUG_PROBE, "Mode: %x\n", hp->Mode);
1195
1196 rio_reset_interrupt (hp);
1197 rio_start_card_running (hp);
1198 rio_dprintk (RIO_DEBUG_PROBE, "Going to test it (%p/%p).\n",
1199 (void *)p->RIOHosts[p->RIONumHosts].PaddrP,
1200 p->RIOHosts[p->RIONumHosts].Caddr);
1201 if (RIOBoardTest( p->RIOHosts[p->RIONumHosts].PaddrP,
1202 p->RIOHosts[p->RIONumHosts].Caddr,
1203 RIO_PCI, 0 ) == RIO_SUCCESS) {
1204 WBYTE(p->RIOHosts[p->RIONumHosts].ResetInt, 0xff);
1205 p->RIOHosts[p->RIONumHosts].UniqueNum =
1206 ((RBYTE(p->RIOHosts[p->RIONumHosts].Unique[0]) &0xFF)<< 0)|
1207 ((RBYTE(p->RIOHosts[p->RIONumHosts].Unique[1]) &0xFF)<< 8)|
1208 ((RBYTE(p->RIOHosts[p->RIONumHosts].Unique[2]) &0xFF)<<16)|
1209 ((RBYTE(p->RIOHosts[p->RIONumHosts].Unique[3]) &0xFF)<<24);
1210 rio_dprintk (RIO_DEBUG_PROBE, "Hmm Tested ok, uniqid = %x.\n",
1211 p->RIOHosts[p->RIONumHosts].UniqueNum);
1212
1213 p->RIOLastPCISearch = RIO_SUCCESS;
1214 p->RIONumHosts++;
1215 found++;
1216 } else {
1217 iounmap((char*) (p->RIOHosts[p->RIONumHosts].Caddr));
1218 }
1219#else
1220 printk (KERN_ERR "Found an older RIO PCI card, but the driver is not "
1221 "compiled to support it.\n");
1222#endif
1223 }
1224#endif /* PCI */
1225
1226 /* Now probe for ISA cards... */
1227 for (i=0;i<NR_RIO_ADDRS;i++) {
1228 hp = &p->RIOHosts[p->RIONumHosts];
1229 hp->PaddrP = rio_probe_addrs[i];
1230 /* There was something about the IRQs of these cards. 'Forget what.--REW */
1231 hp->Ivec = 0;
1232 hp->Caddr = ioremap(p->RIOHosts[p->RIONumHosts].PaddrP, RIO_WINDOW_LEN);
1233 hp->CardP = (struct DpRam *) hp->Caddr;
1234 hp->Type = RIO_AT;
1235 hp->Copy = rio_pcicopy; /* AT card PCI???? - PVDL
1236 * -- YES! this is now a normal copy. Only the
1237 * old PCI card uses the special PCI copy.
1238 * Moreover, the ISA card will work with the
1239 * special PCI copy anyway. -- REW */
1240 hp->Mode = 0;
1241 spin_lock_init(&hp->HostLock);
1242
1243 vpdp = get_VPD_PROM (hp);
1244 rio_dprintk (RIO_DEBUG_PROBE, "Got VPD ROM\n");
1245 okboard = 0;
1246 if ((strncmp (vpdp->identifier, RIO_ISA_IDENT, 16) == 0) ||
1247 (strncmp (vpdp->identifier, RIO_ISA2_IDENT, 16) == 0) ||
1248 (strncmp (vpdp->identifier, RIO_ISA3_IDENT, 16) == 0)) {
1249 /* Board is present... */
1250 if (RIOBoardTest (hp->PaddrP,
1251 hp->Caddr, RIO_AT, 0) == RIO_SUCCESS) {
1252 /* ... and feeling fine!!!! */
1253 rio_dprintk (RIO_DEBUG_PROBE, "Hmm Tested ok, uniqid = %x.\n",
1254 p->RIOHosts[p->RIONumHosts].UniqueNum);
1255 if (RIOAssignAT(p, hp->PaddrP, hp->Caddr, 0)) {
1256 rio_dprintk (RIO_DEBUG_PROBE, "Hmm Tested ok, host%d uniqid = %x.\n",
1257 p->RIONumHosts,
1258 p->RIOHosts[p->RIONumHosts-1].UniqueNum);
1259 okboard++;
1260 found++;
1261 }
1262 }
1263
1264 if (!okboard)
1265 iounmap ((char*) (hp->Caddr));
1266 }
1267 }
1268
1269
1270 for (i=0;i<p->RIONumHosts;i++) {
1271 hp = &p->RIOHosts[i];
1272 if (hp->Ivec) {
1273 int mode = SA_SHIRQ;
1274 if (hp->Ivec & 0x8000) {mode = 0; hp->Ivec &= 0x7fff;}
1275 rio_dprintk (RIO_DEBUG_INIT, "Requesting interrupt hp: %p rio_interrupt: %d Mode: %x\n", hp,hp->Ivec, hp->Mode);
1276 retval = request_irq (hp->Ivec, rio_interrupt, mode, "rio", hp);
1277 rio_dprintk (RIO_DEBUG_INIT, "Return value from request_irq: %d\n", retval);
1278 if (retval) {
1279 printk(KERN_ERR "rio: Cannot allocate irq %d.\n", hp->Ivec);
1280 hp->Ivec = 0;
1281 }
1282 rio_dprintk (RIO_DEBUG_INIT, "Got irq %d.\n", hp->Ivec);
1283 if (hp->Ivec != 0){
1284 rio_dprintk (RIO_DEBUG_INIT, "Enabling interrupts on rio card.\n");
1285 hp->Mode |= RIO_PCI_INT_ENABLE;
1286 } else
1287 hp->Mode &= !RIO_PCI_INT_ENABLE;
1288 rio_dprintk (RIO_DEBUG_INIT, "New Mode: %x\n", hp->Mode);
1289 rio_start_card_running (hp);
1290 }
1291 /* Init the timer "always" to make sure that it can safely be
1292 deleted when we unload... */
1293
1294 init_timer (&hp->timer);
1295 if (!hp->Ivec) {
1296 rio_dprintk (RIO_DEBUG_INIT, "Starting polling at %dj intervals.\n",
1297 rio_poll);
1298 hp->timer.data = i;
1299 hp->timer.function = rio_pollfunc;
1300 hp->timer.expires = jiffies + rio_poll;
1301 add_timer (&hp->timer);
1302 }
1303 }
1304
1305 if (found) {
1306 rio_dprintk (RIO_DEBUG_INIT, "rio: total of %d boards detected.\n", found);
1307 rio_init_drivers ();
1308 } else {
1309 /* deregister the misc device we created earlier */
1310 misc_deregister(&rio_fw_device);
1311 }
1312
1313 func_exit();
1314 return found?0:-EIO;
1315}
1316
1317
1318static void __exit rio_exit (void)
1319{
1320 int i;
1321 struct Host *hp;
1322
1323 func_enter();
1324
1325 for (i=0,hp=p->RIOHosts;i<p->RIONumHosts;i++, hp++) {
1326 RIOHostReset (hp->Type, hp->CardP, hp->Slot);
1327 if (hp->Ivec) {
1328 free_irq (hp->Ivec, hp);
1329 rio_dprintk (RIO_DEBUG_INIT, "freed irq %d.\n", hp->Ivec);
1330 }
1331 /* It is safe/allowed to del_timer a non-active timer */
1332 del_timer (&hp->timer);
1333 }
1334
1335 if (misc_deregister(&rio_fw_device) < 0) {
1336 printk (KERN_INFO "rio: couldn't deregister control-device\n");
1337 }
1338
1339
1340 rio_dprintk (RIO_DEBUG_CLEANUP, "Cleaning up drivers\n");
1341
1342 rio_release_drivers ();
1343
1344 /* Release dynamically allocated memory */
1345 kfree (p->RIOPortp);
1346 kfree (p->RIOHosts);
1347 kfree (p);
1348
1349 func_exit();
1350}
1351
1352module_init(rio_init);
1353module_exit(rio_exit);
1354
1355/*
1356 * Anybody who knows why this doesn't work for me, please tell me -- REW.
1357 * Snatched from scsi.c (fixed one spelling error):
1358 * Overrides for Emacs so that we follow Linus' tabbing style.
1359 * Emacs will notice this stuff at the end of the file and automatically
1360 * adjust the settings for this buffer only. This must remain at the end
1361 * of the file.
1362 * ---------------------------------------------------------------------------
1363 * Local Variables:
1364 * c-indent-level: 4
1365 * c-brace-imaginary-offset: 0
1366 * c-brace-offset: -4
1367 * c-argdecl-indent: 4
1368 * c-label-offset: -4
1369 * c-continued-statement-offset: 4
1370 * c-continued-brace-offset: 0
1371 * indent-tabs-mode: nil
1372 * tab-width: 8
1373 * End:
1374 */
1375