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