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