drivers/char/rio/rio_linux.c

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