2 /* rio_linux.c -- Linux driver for the Specialix RIO series cards.
5 * (C) 1999 R.E.Wolff@BitWizard.nl
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.
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.
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.
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,
30 #include <linux/module.h>
31 #include <linux/kdev_t.h>
33 #include <linux/kernel.h>
34 #include <linux/sched.h>
35 #include <linux/ioport.h>
36 #include <linux/interrupt.h>
37 #include <linux/errno.h>
38 #include <linux/tty.h>
39 #include <linux/tty_flip.h>
41 #include <linux/serial.h>
42 #include <linux/fcntl.h>
43 #include <linux/major.h>
44 #include <linux/delay.h>
45 #include <linux/pci.h>
46 #include <linux/slab.h>
47 #include <linux/miscdevice.h>
48 #include <linux/init.h>
50 #include <linux/generic_serial.h>
51 #include <asm/uaccess.h>
53 #include "linux_compat.h"
83 #include "rio_linux.h"
85 /* I don't think that this driver can handle more than 512 ports on
86 one machine. Specialix specifies max 4 boards in one machine. I don't
87 know why. If you want to try anyway you'll have to increase the number
88 of boards in rio.h. You'll have to allocate more majors if you need
89 more than 512 ports.... */
91 #ifndef RIO_NORMAL_MAJOR0
92 /* This allows overriding on the compiler commandline, or in a "major.h"
93 include or something like that */
94 #define RIO_NORMAL_MAJOR0 154
95 #define RIO_NORMAL_MAJOR1 156
98 #ifndef PCI_DEVICE_ID_SPECIALIX_SX_XIO_IO8
99 #define PCI_DEVICE_ID_SPECIALIX_SX_XIO_IO8 0x2000
102 #ifndef RIO_WINDOW_LEN
103 #define RIO_WINDOW_LEN 0x10000
107 /* Configurable options:
108 (Don't be too sure that it'll work if you toggle them) */
110 /* Am I paranoid or not ? ;-) */
111 #undef RIO_PARANOIA_CHECK
114 /* 20 -> 2000 per second. The card should rate-limit interrupts at 1000
115 Hz, but it is user configurable. I don't recommend going above 1000
116 Hz. The interrupt ratelimit might trigger if the interrupt is
117 shared with a very active other device.
118 undef this if you want to disable the check....
120 #define IRQ_RATE_LIMIT 200
123 /* These constants are derived from SCO Source */
126 /* locator */ "RIO Config here",
127 /* startuptime */ HZ * 2,
128 /* how long to wait for card to run */
130 /* TRUE -> always use line disc. */
131 /* intrpolltime */ 1,
132 /* The frequency of OUR polls */
133 /* breakinterval */ 25,
134 /* x10 mS XXX: units seem to be 1ms not 10! -- REW */
137 /* RtaLoadBase */ 0x7000,
138 /* HostLoadBase */ 0x7C00,
140 /* number of Xprint hits per second */
142 /* Xprint characters per second */
144 /* start Xprint for a wyse 60 */
146 /* end Xprint for a wyse 60 */
148 /* highest Xprint speed */
150 /* slowest Xprint speed */
152 /* non-zero for mega fast boots */
153 /* First Addr */ 0x0A0000,
154 /* First address to look at */
155 /* Last Addr */ 0xFF0000,
156 /* Last address looked at */
157 /* BufferSize */ 1024,
158 /* Bytes per port of buffering */
160 /* how much data left before wakeup */
162 /* how wide is the console? */
164 /* how long a close command may take */
170 /* Function prototypes */
172 static void rio_disable_tx_interrupts(void *ptr);
173 static void rio_enable_tx_interrupts(void *ptr);
174 static void rio_disable_rx_interrupts(void *ptr);
175 static void rio_enable_rx_interrupts(void *ptr);
176 static int rio_get_CD(void *ptr);
177 static void rio_shutdown_port(void *ptr);
178 static int rio_set_real_termios(void *ptr);
179 static void rio_hungup(void *ptr);
180 static void rio_close(void *ptr);
181 static int rio_chars_in_buffer(void *ptr);
182 static int rio_fw_ioctl(struct inode *inode, struct file *filp, unsigned int cmd, unsigned long arg);
183 static int rio_init_drivers(void);
185 static void my_hd(void *addr, int len);
187 static struct tty_driver *rio_driver, *rio_driver2;
189 /* The name "p" is a bit non-descript. But that's what the rio-lynxos
190 sources use all over the place. */
196 /* You can have the driver poll your card.
197 - Set rio_poll to 1 to poll every timer tick (10ms on Intel).
198 This is used when the card cannot use an interrupt for some reason.
200 static int rio_poll = 1;
203 /* These are the only open spaces in my computer. Yours may have more
205 static int rio_probe_addrs[] = { 0xc0000, 0xd0000, 0xe0000 };
207 #define NR_RIO_ADDRS ARRAY_SIZE(rio_probe_addrs)
210 /* Set the mask to all-ones. This alas, only supports 32 interrupts.
211 Some architectures may need more. -- Changed to LONG to
212 support up to 64 bits on 64bit architectures. -- REW 20/06/99 */
213 static long rio_irqmask = -1;
215 MODULE_AUTHOR("Rogier Wolff <R.E.Wolff@bitwizard.nl>, Patrick van de Lageweg <patrick@bitwizard.nl>");
216 MODULE_DESCRIPTION("RIO driver");
217 MODULE_LICENSE("GPL");
218 module_param(rio_poll, int, 0);
219 module_param(rio_debug, int, 0644);
220 module_param(rio_irqmask, long, 0);
222 static struct real_driver rio_real_driver = {
223 rio_disable_tx_interrupts,
224 rio_enable_tx_interrupts,
225 rio_disable_rx_interrupts,
226 rio_enable_rx_interrupts,
229 rio_set_real_termios,
237 * Firmware loader driver specific routines
241 static const struct file_operations rio_fw_fops = {
242 .owner = THIS_MODULE,
243 .ioctl = rio_fw_ioctl,
246 static struct miscdevice rio_fw_device = {
247 RIOCTL_MISC_MINOR, "rioctl", &rio_fw_fops
254 #ifdef RIO_PARANOIA_CHECK
256 /* This doesn't work. Who's paranoid around here? Not me! */
258 static inline int rio_paranoia_check(struct rio_port const *port, char *name, const char *routine)
261 static const char *badmagic = KERN_ERR "rio: Warning: bad rio port magic number for device %s in %s\n";
262 static const char *badinfo = KERN_ERR "rio: Warning: null rio port for device %s in %s\n";
265 printk(badinfo, name, routine);
268 if (port->magic != RIO_MAGIC) {
269 printk(badmagic, name, routine);
276 #define rio_paranoia_check(a,b,c) 0
281 static void my_hd(void *ad, int len)
284 unsigned char *addr = ad;
286 for (i = 0; i < len; i += 16) {
287 rio_dprintk(RIO_DEBUG_PARAM, "%08lx ", (unsigned long) addr + i);
288 for (j = 0; j < 16; j++) {
289 rio_dprintk(RIO_DEBUG_PARAM, "%02x %s", addr[j + i], (j == 7) ? " " : "");
291 for (j = 0; j < 16; j++) {
293 rio_dprintk(RIO_DEBUG_PARAM, "%c", (ch < 0x20) ? '.' : ((ch > 0x7f) ? '.' : ch));
295 rio_dprintk(RIO_DEBUG_PARAM, "\n");
299 #define my_hd(ad,len) do{/* nothing*/ } while (0)
303 /* Delay a number of jiffies, allowing a signal to interrupt */
304 int RIODelay(struct Port *PortP, int njiffies)
308 rio_dprintk(RIO_DEBUG_DELAY, "delaying %d jiffies\n", njiffies);
309 msleep_interruptible(jiffies_to_msecs(njiffies));
312 if (signal_pending(current))
319 /* Delay a number of jiffies, disallowing a signal to interrupt */
320 int RIODelay_ni(struct Port *PortP, int njiffies)
324 rio_dprintk(RIO_DEBUG_DELAY, "delaying %d jiffies (ni)\n", njiffies);
325 msleep(jiffies_to_msecs(njiffies));
330 void rio_copy_to_card(void *from, void __iomem *to, int len)
332 rio_copy_toio(to, from, len);
335 int rio_minor(struct tty_struct *tty)
337 return tty->index + (tty->driver == rio_driver) ? 0 : 256;
340 static int rio_set_real_termios(void *ptr)
342 return RIOParam((struct Port *) ptr, RIOC_CONFIG, 1, 1);
346 static void rio_reset_interrupt(struct Host *HostP)
350 switch (HostP->Type) {
354 writeb(0xFF, &HostP->ResetInt);
361 static irqreturn_t rio_interrupt(int irq, void *ptr)
366 HostP = ptr; /* &p->RIOHosts[(long)ptr]; */
367 rio_dprintk(RIO_DEBUG_IFLOW, "rio: enter rio_interrupt (%d/%d)\n", irq, HostP->Ivec);
369 /* AAargh! The order in which to do these things is essential and
372 - hardware twiddling goes before "recursive". Otherwise when we
373 poll the card, and a recursive interrupt happens, we won't
374 ack the card, so it might keep on interrupting us. (especially
375 level sensitive interrupt systems like PCI).
377 - Rate limit goes before hardware twiddling. Otherwise we won't
378 catch a card that has gone bonkers.
380 - The "initialized" test goes after the hardware twiddling. Otherwise
381 the card will stick us in the interrupt routine again.
383 - The initialized test goes before recursive.
386 rio_dprintk(RIO_DEBUG_IFLOW, "rio: We've have noticed the interrupt\n");
387 if (HostP->Ivec == irq) {
388 /* Tell the card we've noticed the interrupt. */
389 rio_reset_interrupt(HostP);
392 if ((HostP->Flags & RUN_STATE) != RC_RUNNING)
395 if (test_and_set_bit(RIO_BOARD_INTR_LOCK, &HostP->locks)) {
396 printk(KERN_ERR "Recursive interrupt! (host %p/irq%d)\n", ptr, HostP->Ivec);
400 RIOServiceHost(p, HostP);
402 rio_dprintk(RIO_DEBUG_IFLOW, "riointr() doing host %p type %d\n", ptr, HostP->Type);
404 clear_bit(RIO_BOARD_INTR_LOCK, &HostP->locks);
405 rio_dprintk(RIO_DEBUG_IFLOW, "rio: exit rio_interrupt (%d/%d)\n", irq, HostP->Ivec);
411 static void rio_pollfunc(unsigned long data)
415 rio_interrupt(0, &p->RIOHosts[data]);
416 mod_timer(&p->RIOHosts[data].timer, jiffies + rio_poll);
422 /* ********************************************************************** *
423 * Here are the routines that actually *
424 * interface with the generic_serial driver *
425 * ********************************************************************** */
427 /* Ehhm. I don't know how to fiddle with interrupts on the Specialix
428 cards. .... Hmm. Ok I figured it out. You don't. -- REW */
430 static void rio_disable_tx_interrupts(void *ptr)
434 /* port->gs.port.flags &= ~GS_TX_INTEN; */
440 static void rio_enable_tx_interrupts(void *ptr)
442 struct Port *PortP = ptr;
447 /* hn = PortP->HostP - p->RIOHosts;
449 rio_dprintk (RIO_DEBUG_TTY, "Pushing host %d\n", hn);
450 rio_interrupt (-1,(void *) hn, NULL); */
452 RIOTxEnable((char *) PortP);
455 * In general we cannot count on "tx empty" interrupts, although
456 * the interrupt routine seems to be able to tell the difference.
458 PortP->gs.port.flags &= ~GS_TX_INTEN;
464 static void rio_disable_rx_interrupts(void *ptr)
470 static void rio_enable_rx_interrupts(void *ptr)
472 /* struct rio_port *port = ptr; */
478 /* Jeez. Isn't this simple? */
479 static int rio_get_CD(void *ptr)
481 struct Port *PortP = ptr;
485 rv = (PortP->ModemState & RIOC_MSVR1_CD) != 0;
487 rio_dprintk(RIO_DEBUG_INIT, "Getting CD status: %d\n", rv);
494 /* Jeez. Isn't this simple? Actually, we can sync with the actual port
495 by just pushing stuff into the queue going to the port... */
496 static int rio_chars_in_buffer(void *ptr)
505 /* Nothing special here... */
506 static void rio_shutdown_port(void *ptr)
512 PortP = (struct Port *) ptr;
513 PortP->gs.port.tty = NULL;
518 /* I haven't the foggiest why the decrement use count has to happen
519 here. The whole linux serial drivers stuff needs to be redesigned.
520 My guess is that this is a hack to minimize the impact of a bug
521 elsewhere. Thinking about it some more. (try it sometime) Try
522 running minicom on a serial port that is driven by a modularized
523 driver. Have the modem hangup. Then remove the driver module. Then
524 exit minicom. I expect an "oops". -- REW */
525 static void rio_hungup(void *ptr)
531 PortP = (struct Port *) ptr;
532 PortP->gs.port.tty = NULL;
538 /* The standard serial_close would become shorter if you'd wrap it like
540 rs_close (...){save_flags;cli;real_close();dec_use_count;restore_flags;}
542 static void rio_close(void *ptr)
548 PortP = (struct Port *) ptr;
552 if (PortP->gs.port.count) {
553 printk(KERN_ERR "WARNING port count:%d\n", PortP->gs.port.count);
554 PortP->gs.port.count = 0;
557 PortP->gs.port.tty = NULL;
563 static int rio_fw_ioctl(struct inode *inode, struct file *filp, unsigned int cmd, unsigned long arg)
568 /* The "dev" argument isn't used. */
569 rc = riocontrol(p, 0, cmd, arg, capable(CAP_SYS_ADMIN));
575 extern int RIOShortCommand(struct rio_info *p, struct Port *PortP, int command, int len, int arg);
577 static int rio_ioctl(struct tty_struct *tty, struct file *filp, unsigned int cmd, unsigned long arg)
579 void __user *argp = (void __user *)arg;
586 PortP = (struct Port *) tty->driver_data;
591 if ((rc = get_user(ival, (unsigned __user *) argp)) == 0) {
592 tty->termios->c_cflag = (tty->termios->c_cflag & ~CLOCAL) | (ival ? CLOCAL : 0);
597 if (access_ok(VERIFY_WRITE, argp, sizeof(struct serial_struct)))
598 rc = gs_getserial(&PortP->gs, argp);
601 if (PortP->State & RIO_DELETED) {
602 rio_dprintk(RIO_DEBUG_TTY, "BREAK on deleted RTA\n");
605 if (RIOShortCommand(p, PortP, RIOC_SBREAK, 2, 250) ==
607 rio_dprintk(RIO_DEBUG_INTR, "SBREAK RIOShortCommand failed\n");
613 if (PortP->State & RIO_DELETED) {
614 rio_dprintk(RIO_DEBUG_TTY, "BREAK on deleted RTA\n");
618 l = arg ? arg * 100 : 250;
621 if (RIOShortCommand(p, PortP, RIOC_SBREAK, 2,
622 arg ? arg * 100 : 250) == RIO_FAIL) {
623 rio_dprintk(RIO_DEBUG_INTR, "SBREAK RIOShortCommand failed\n");
630 if (access_ok(VERIFY_READ, argp, sizeof(struct serial_struct)))
631 rc = gs_setserial(&PortP->gs, argp);
642 /* The throttle/unthrottle scheme for the Specialix card is different
643 * from other drivers and deserves some explanation.
644 * The Specialix hardware takes care of XON/XOFF
645 * and CTS/RTS flow control itself. This means that all we have to
646 * do when signalled by the upper tty layer to throttle/unthrottle is
647 * to make a note of it here. When we come to read characters from the
648 * rx buffers on the card (rio_receive_chars()) we look to see if the
649 * upper layer can accept more (as noted here in rio_rx_throt[]).
650 * If it can't we simply don't remove chars from the cards buffer.
651 * When the tty layer can accept chars, we again note that here and when
652 * rio_receive_chars() is called it will remove them from the cards buffer.
653 * The card will notice that a ports buffer has drained below some low
654 * water mark and will unflow control the line itself, using whatever
655 * flow control scheme is in use for that port. -- Simon Allen
658 static void rio_throttle(struct tty_struct *tty)
660 struct Port *port = (struct Port *) tty->driver_data;
663 /* If the port is using any type of input flow
664 * control then throttle the port.
667 if ((tty->termios->c_cflag & CRTSCTS) || (I_IXOFF(tty))) {
668 port->State |= RIO_THROTTLE_RX;
675 static void rio_unthrottle(struct tty_struct *tty)
677 struct Port *port = (struct Port *) tty->driver_data;
680 /* Always unthrottle even if flow control is not enabled on
681 * this port in case we disabled flow control while the port
685 port->State &= ~RIO_THROTTLE_RX;
695 /* ********************************************************************** *
696 * Here are the initialization routines. *
697 * ********************************************************************** */
700 static struct vpd_prom *get_VPD_PROM(struct Host *hp)
702 static struct vpd_prom vpdp;
707 rio_dprintk(RIO_DEBUG_PROBE, "Going to verify vpd prom at %p.\n", hp->Caddr + RIO_VPD_ROM);
710 for (i = 0; i < sizeof(struct vpd_prom); i++)
711 *p++ = readb(hp->Caddr + RIO_VPD_ROM + i * 2);
712 /* read_rio_byte (hp, RIO_VPD_ROM + i*2); */
714 /* Terminate the identifier string.
715 *** requires one extra byte in struct vpd_prom *** */
718 if (rio_debug & RIO_DEBUG_PROBE)
719 my_hd((char *) &vpdp, 0x20);
726 static const struct tty_operations rio_ops = {
730 .put_char = gs_put_char,
731 .flush_chars = gs_flush_chars,
732 .write_room = gs_write_room,
733 .chars_in_buffer = gs_chars_in_buffer,
734 .flush_buffer = gs_flush_buffer,
736 .throttle = rio_throttle,
737 .unthrottle = rio_unthrottle,
738 .set_termios = gs_set_termios,
744 static int rio_init_drivers(void)
748 rio_driver = alloc_tty_driver(256);
751 rio_driver2 = alloc_tty_driver(256);
757 rio_driver->owner = THIS_MODULE;
758 rio_driver->driver_name = "specialix_rio";
759 rio_driver->name = "ttySR";
760 rio_driver->major = RIO_NORMAL_MAJOR0;
761 rio_driver->type = TTY_DRIVER_TYPE_SERIAL;
762 rio_driver->subtype = SERIAL_TYPE_NORMAL;
763 rio_driver->init_termios = tty_std_termios;
764 rio_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
765 rio_driver->flags = TTY_DRIVER_REAL_RAW;
766 tty_set_operations(rio_driver, &rio_ops);
768 rio_driver2->owner = THIS_MODULE;
769 rio_driver2->driver_name = "specialix_rio";
770 rio_driver2->name = "ttySR";
771 rio_driver2->major = RIO_NORMAL_MAJOR1;
772 rio_driver2->type = TTY_DRIVER_TYPE_SERIAL;
773 rio_driver2->subtype = SERIAL_TYPE_NORMAL;
774 rio_driver2->init_termios = tty_std_termios;
775 rio_driver2->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
776 rio_driver2->flags = TTY_DRIVER_REAL_RAW;
777 tty_set_operations(rio_driver2, &rio_ops);
779 rio_dprintk(RIO_DEBUG_INIT, "set_termios = %p\n", gs_set_termios);
781 if ((error = tty_register_driver(rio_driver)))
783 if ((error = tty_register_driver(rio_driver2)))
788 tty_unregister_driver(rio_driver);
790 put_tty_driver(rio_driver2);
792 put_tty_driver(rio_driver);
794 printk(KERN_ERR "rio: Couldn't register a rio driver, error = %d\n", error);
799 static void *ckmalloc(int size)
803 p = kzalloc(size, GFP_KERNEL);
809 static int rio_init_datastructures(void)
815 /* Many drivers statically allocate the maximum number of ports
816 There is no reason not to allocate them dynamically. Is there? -- REW */
817 /* However, the RIO driver allows users to configure their first
818 RTA as the ports numbered 504-511. We therefore need to allocate
819 the whole range. :-( -- REW */
821 #define RI_SZ sizeof(struct rio_info)
822 #define HOST_SZ sizeof(struct Host)
823 #define PORT_SZ sizeof(struct Port *)
824 #define TMIO_SZ sizeof(struct termios *)
825 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);
827 if (!(p = ckmalloc(RI_SZ)))
829 if (!(p->RIOHosts = ckmalloc(RIO_HOSTS * HOST_SZ)))
831 if (!(p->RIOPortp = ckmalloc(RIO_PORTS * PORT_SZ)))
833 p->RIOConf = RIOConf;
834 rio_dprintk(RIO_DEBUG_INIT, "Got : %p %p %p\n", p, p->RIOHosts, p->RIOPortp);
837 for (i = 0; i < RIO_PORTS; i++) {
838 port = p->RIOPortp[i] = ckmalloc(sizeof(struct Port));
842 rio_dprintk(RIO_DEBUG_INIT, "initing port %d (%d)\n", i, port->Mapped);
844 port->gs.magic = RIO_MAGIC;
845 port->gs.close_delay = HZ / 2;
846 port->gs.closing_wait = 30 * HZ;
847 port->gs.rd = &rio_real_driver;
848 spin_lock_init(&port->portSem);
850 * Initializing wait queue
852 init_waitqueue_head(&port->gs.port.open_wait);
853 init_waitqueue_head(&port->gs.port.close_wait);
856 /* We could postpone initializing them to when they are configured. */
861 if (rio_debug & RIO_DEBUG_INIT) {
862 my_hd(&rio_real_driver, sizeof(rio_real_driver));
869 free6:for (i--; i >= 0; i--)
870 kfree(p->RIOPortp[i]);
873 free3:*/ kfree(p->RIOPortp);
874 free2:kfree(p->RIOHosts);
876 rio_dprintk(RIO_DEBUG_INIT, "Not enough memory! %p %p %p\n", p, p->RIOHosts, p->RIOPortp);
882 static void __exit rio_release_drivers(void)
885 tty_unregister_driver(rio_driver2);
886 tty_unregister_driver(rio_driver);
887 put_tty_driver(rio_driver2);
888 put_tty_driver(rio_driver);
894 /* This was written for SX, but applies to RIO too...
897 There is another bit besides Bit 17. Turning that bit off
898 (on boards shipped with the fix in the eeprom) results in a
899 hang on the next access to the card.
902 /********************************************************
903 * Setting bit 17 in the CNTRL register of the PLX 9050 *
904 * chip forces a retry on writes while a read is pending.*
905 * This is to prevent the card locking up on Intel Xeon *
906 * multiprocessor systems with the NX chipset. -- NV *
907 ********************************************************/
909 /* Newer cards are produced with this bit set from the configuration
910 EEprom. As the bit is read/write for the CPU, we can fix it here,
911 if we detect that it isn't set correctly. -- REW */
913 static void fix_rio_pci(struct pci_dev *pdev)
915 unsigned long hwbase;
916 unsigned char __iomem *rebase;
919 #define CNTRL_REG_OFFSET 0x50
920 #define CNTRL_REG_GOODVALUE 0x18260000
922 hwbase = pci_resource_start(pdev, 0);
923 rebase = ioremap(hwbase, 0x80);
924 t = readl(rebase + CNTRL_REG_OFFSET);
925 if (t != CNTRL_REG_GOODVALUE) {
926 printk(KERN_DEBUG "rio: performing cntrl reg fix: %08x -> %08x\n", t, CNTRL_REG_GOODVALUE);
927 writel(CNTRL_REG_GOODVALUE, rebase + CNTRL_REG_OFFSET);
934 static int __init rio_init(void)
940 struct vpd_prom *vpdp;
944 struct pci_dev *pdev = NULL;
945 unsigned short tshort;
949 rio_dprintk(RIO_DEBUG_INIT, "Initing rio module... (rio_debug=%d)\n", rio_debug);
951 if (abs((long) (&rio_debug) - rio_debug) < 0x10000) {
952 printk(KERN_WARNING "rio: rio_debug is an address, instead of a value. " "Assuming -1. Was %x/%p.\n", rio_debug, &rio_debug);
956 if (misc_register(&rio_fw_device) < 0) {
957 printk(KERN_ERR "RIO: Unable to register firmware loader driver.\n");
961 retval = rio_init_datastructures();
963 misc_deregister(&rio_fw_device);
967 /* First look for the JET devices: */
968 while ((pdev = pci_get_device(PCI_VENDOR_ID_SPECIALIX, PCI_DEVICE_ID_SPECIALIX_SX_XIO_IO8, pdev))) {
971 if (pci_enable_device(pdev))
974 /* Specialix has a whole bunch of cards with
975 0x2000 as the device ID. They say its because
976 the standard requires it. Stupid standard. */
977 /* It seems that reading a word doesn't work reliably on 2.0.
978 Also, reading a non-aligned dword doesn't work. So we read the
979 whole dword at 0x2c and extract the word at 0x2e (SUBSYSTEM_ID)
981 pci_read_config_dword(pdev, 0x2c, &tint);
982 tshort = (tint >> 16) & 0xffff;
983 rio_dprintk(RIO_DEBUG_PROBE, "Got a specialix card: %x.\n", tint);
984 if (tshort != 0x0100) {
985 rio_dprintk(RIO_DEBUG_PROBE, "But it's not a RIO card (%d)...\n", tshort);
988 rio_dprintk(RIO_DEBUG_PROBE, "cp1\n");
990 hp = &p->RIOHosts[p->RIONumHosts];
991 hp->PaddrP = pci_resource_start(pdev, 2);
992 hp->Ivec = pdev->irq;
993 if (((1 << hp->Ivec) & rio_irqmask) == 0)
995 hp->Caddr = ioremap(p->RIOHosts[p->RIONumHosts].PaddrP, RIO_WINDOW_LEN);
996 hp->CardP = (struct DpRam __iomem *) hp->Caddr;
998 hp->Copy = rio_copy_to_card;
999 hp->Mode = RIO_PCI_BOOT_FROM_RAM;
1000 spin_lock_init(&hp->HostLock);
1001 rio_reset_interrupt(hp);
1002 rio_start_card_running(hp);
1004 rio_dprintk(RIO_DEBUG_PROBE, "Going to test it (%p/%p).\n", (void *) p->RIOHosts[p->RIONumHosts].PaddrP, p->RIOHosts[p->RIONumHosts].Caddr);
1005 if (RIOBoardTest(p->RIOHosts[p->RIONumHosts].PaddrP, p->RIOHosts[p->RIONumHosts].Caddr, RIO_PCI, 0) == 0) {
1006 rio_dprintk(RIO_DEBUG_INIT, "Done RIOBoardTest\n");
1007 writeb(0xFF, &p->RIOHosts[p->RIONumHosts].ResetInt);
1008 p->RIOHosts[p->RIONumHosts].UniqueNum =
1009 ((readb(&p->RIOHosts[p->RIONumHosts].Unique[0]) & 0xFF) << 0) |
1010 ((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);
1011 rio_dprintk(RIO_DEBUG_PROBE, "Hmm Tested ok, uniqid = %x.\n", p->RIOHosts[p->RIONumHosts].UniqueNum);
1015 p->RIOHosts[p->RIONumHosts].pdev = pdev;
1018 p->RIOLastPCISearch = 0;
1022 iounmap(p->RIOHosts[p->RIONumHosts].Caddr);
1023 p->RIOHosts[p->RIONumHosts].Caddr = NULL;
1027 /* Then look for the older PCI card.... : */
1029 /* These older PCI cards have problems (only byte-mode access is
1030 supported), which makes them a bit awkward to support.
1031 They also have problems sharing interrupts. Be careful.
1032 (The driver now refuses to share interrupts for these
1033 cards. This should be sufficient).
1036 /* Then look for the older RIO/PCI devices: */
1037 while ((pdev = pci_get_device(PCI_VENDOR_ID_SPECIALIX, PCI_DEVICE_ID_SPECIALIX_RIO, pdev))) {
1038 if (pci_enable_device(pdev))
1041 #ifdef CONFIG_RIO_OLDPCI
1042 hp = &p->RIOHosts[p->RIONumHosts];
1043 hp->PaddrP = pci_resource_start(pdev, 0);
1044 hp->Ivec = pdev->irq;
1045 if (((1 << hp->Ivec) & rio_irqmask) == 0)
1047 hp->Ivec |= 0x8000; /* Mark as non-sharable */
1048 hp->Caddr = ioremap(p->RIOHosts[p->RIONumHosts].PaddrP, RIO_WINDOW_LEN);
1049 hp->CardP = (struct DpRam __iomem *) hp->Caddr;
1051 hp->Copy = rio_copy_to_card;
1052 hp->Mode = RIO_PCI_BOOT_FROM_RAM;
1053 spin_lock_init(&hp->HostLock);
1055 rio_dprintk(RIO_DEBUG_PROBE, "Ivec: %x\n", hp->Ivec);
1056 rio_dprintk(RIO_DEBUG_PROBE, "Mode: %x\n", hp->Mode);
1058 rio_reset_interrupt(hp);
1059 rio_start_card_running(hp);
1060 rio_dprintk(RIO_DEBUG_PROBE, "Going to test it (%p/%p).\n", (void *) p->RIOHosts[p->RIONumHosts].PaddrP, p->RIOHosts[p->RIONumHosts].Caddr);
1061 if (RIOBoardTest(p->RIOHosts[p->RIONumHosts].PaddrP, p->RIOHosts[p->RIONumHosts].Caddr, RIO_PCI, 0) == 0) {
1062 writeb(0xFF, &p->RIOHosts[p->RIONumHosts].ResetInt);
1063 p->RIOHosts[p->RIONumHosts].UniqueNum =
1064 ((readb(&p->RIOHosts[p->RIONumHosts].Unique[0]) & 0xFF) << 0) |
1065 ((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);
1066 rio_dprintk(RIO_DEBUG_PROBE, "Hmm Tested ok, uniqid = %x.\n", p->RIOHosts[p->RIONumHosts].UniqueNum);
1068 p->RIOHosts[p->RIONumHosts].pdev = pdev;
1071 p->RIOLastPCISearch = 0;
1075 iounmap(p->RIOHosts[p->RIONumHosts].Caddr);
1076 p->RIOHosts[p->RIONumHosts].Caddr = NULL;
1079 printk(KERN_ERR "Found an older RIO PCI card, but the driver is not " "compiled to support it.\n");
1084 /* Now probe for ISA cards... */
1085 for (i = 0; i < NR_RIO_ADDRS; i++) {
1086 hp = &p->RIOHosts[p->RIONumHosts];
1087 hp->PaddrP = rio_probe_addrs[i];
1088 /* There was something about the IRQs of these cards. 'Forget what.--REW */
1090 hp->Caddr = ioremap(p->RIOHosts[p->RIONumHosts].PaddrP, RIO_WINDOW_LEN);
1091 hp->CardP = (struct DpRam __iomem *) hp->Caddr;
1093 hp->Copy = rio_copy_to_card; /* AT card PCI???? - PVDL
1094 * -- YES! this is now a normal copy. Only the
1095 * old PCI card uses the special PCI copy.
1096 * Moreover, the ISA card will work with the
1097 * special PCI copy anyway. -- REW */
1099 spin_lock_init(&hp->HostLock);
1101 vpdp = get_VPD_PROM(hp);
1102 rio_dprintk(RIO_DEBUG_PROBE, "Got VPD ROM\n");
1104 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)) {
1105 /* Board is present... */
1106 if (RIOBoardTest(hp->PaddrP, hp->Caddr, RIO_AT, 0) == 0) {
1107 /* ... and feeling fine!!!! */
1108 rio_dprintk(RIO_DEBUG_PROBE, "Hmm Tested ok, uniqid = %x.\n", p->RIOHosts[p->RIONumHosts].UniqueNum);
1109 if (RIOAssignAT(p, hp->PaddrP, hp->Caddr, 0)) {
1110 rio_dprintk(RIO_DEBUG_PROBE, "Hmm Tested ok, host%d uniqid = %x.\n", p->RIONumHosts, p->RIOHosts[p->RIONumHosts - 1].UniqueNum);
1124 for (i = 0; i < p->RIONumHosts; i++) {
1125 hp = &p->RIOHosts[i];
1127 int mode = IRQF_SHARED;
1128 if (hp->Ivec & 0x8000) {
1132 rio_dprintk(RIO_DEBUG_INIT, "Requesting interrupt hp: %p rio_interrupt: %d Mode: %x\n", hp, hp->Ivec, hp->Mode);
1133 retval = request_irq(hp->Ivec, rio_interrupt, mode, "rio", hp);
1134 rio_dprintk(RIO_DEBUG_INIT, "Return value from request_irq: %d\n", retval);
1136 printk(KERN_ERR "rio: Cannot allocate irq %d.\n", hp->Ivec);
1139 rio_dprintk(RIO_DEBUG_INIT, "Got irq %d.\n", hp->Ivec);
1140 if (hp->Ivec != 0) {
1141 rio_dprintk(RIO_DEBUG_INIT, "Enabling interrupts on rio card.\n");
1142 hp->Mode |= RIO_PCI_INT_ENABLE;
1144 hp->Mode &= ~RIO_PCI_INT_ENABLE;
1145 rio_dprintk(RIO_DEBUG_INIT, "New Mode: %x\n", hp->Mode);
1146 rio_start_card_running(hp);
1148 /* Init the timer "always" to make sure that it can safely be
1149 deleted when we unload... */
1151 setup_timer(&hp->timer, rio_pollfunc, i);
1153 rio_dprintk(RIO_DEBUG_INIT, "Starting polling at %dj intervals.\n", rio_poll);
1154 mod_timer(&hp->timer, jiffies + rio_poll);
1159 rio_dprintk(RIO_DEBUG_INIT, "rio: total of %d boards detected.\n", found);
1162 /* deregister the misc device we created earlier */
1163 misc_deregister(&rio_fw_device);
1167 return found ? 0 : -EIO;
1171 static void __exit rio_exit(void)
1178 for (i = 0, hp = p->RIOHosts; i < p->RIONumHosts; i++, hp++) {
1179 RIOHostReset(hp->Type, hp->CardP, hp->Slot);
1181 free_irq(hp->Ivec, hp);
1182 rio_dprintk(RIO_DEBUG_INIT, "freed irq %d.\n", hp->Ivec);
1184 /* It is safe/allowed to del_timer a non-active timer */
1185 del_timer_sync(&hp->timer);
1188 if (hp->Type == RIO_PCI)
1189 pci_dev_put(hp->pdev);
1192 if (misc_deregister(&rio_fw_device) < 0) {
1193 printk(KERN_INFO "rio: couldn't deregister control-device\n");
1197 rio_dprintk(RIO_DEBUG_CLEANUP, "Cleaning up drivers\n");
1199 rio_release_drivers();
1201 /* Release dynamically allocated memory */
1209 module_init(rio_init);
1210 module_exit(rio_exit);