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