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