]> git.karo-electronics.de Git - karo-tx-linux.git/blob - drivers/char/rio/rio_linux.c
[PATCH] pci: remove deprecates
[karo-tx-linux.git] / drivers / char / rio / rio_linux.c
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 static 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 static 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
375 static 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
390 static 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
468 static 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
488 static 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
498 static 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
522 static void rio_disable_rx_interrupts (void * ptr) 
523 {
524   func_enter();
525   func_exit();
526 }
527
528 static 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?  */
537 static 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... */
554 static 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... */
564 static 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 */
598 static 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  */
615 static 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
636 static 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
649 extern int RIOShortCommand(struct rio_info *p, struct Port *PortP,
650                int command, int len, int arg);
651
652 static 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
774 static 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
791 static 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
816 static 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
843 static 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
861 static 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;
904 out3:
905         tty_unregister_driver(rio_driver);
906 out2:
907         put_tty_driver(rio_driver2);
908 out1:
909         put_tty_driver(rio_driver);
910 out:
911         printk(KERN_ERR "rio: Couldn't register a rio driver, error = %d\n",
912              error);
913         return 1;
914 }
915
916
917 static 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
929 static 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
1006 static 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
1037 static 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
1060 static 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
1318 static 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
1352 module_init(rio_init);
1353 module_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