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