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