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 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 void rio_udelay (int usecs)
 358 {
 359   udelay (usecs);
 360 }
 361
 362 static int rio_set_real_termios (void *ptr)
 363 {
 364   int rv, modem;
 365   struct tty_struct *tty;
 366   func_enter();
 367
 368   tty = ((struct Port *)ptr)->gs.tty;
 369
 370   modem = rio_ismodem(tty);
 371
 372   rv = RIOParam( (struct Port *) ptr, CONFIG, modem, 1);
 373
 374   func_exit ();
 375
 376   return rv;
 377 }
 378
 379
 380 static void rio_reset_interrupt (struct Host *HostP)
 381 {
 382   func_enter();
 383
 384   switch( HostP->Type ) {
 385   case RIO_AT:
 386   case RIO_MCA:
 387   case RIO_PCI:
 388     WBYTE(HostP->ResetInt , 0xff);
 389   }
 390
 391   func_exit();
 392 }
 393
 394
 395 static irqreturn_t rio_interrupt (int irq, void *ptr, struct pt_regs *regs)
 396 {
 397   struct Host *HostP;
 398   func_enter ();
 399
 400   HostP = (struct Host*)ptr; /* &p->RIOHosts[(long)ptr]; */
 401   rio_dprintk (RIO_DEBUG_IFLOW, "rio: enter rio_interrupt (%d/%d)\n",
 402                irq, HostP->Ivec);
 403
 404   /* AAargh! The order in which to do these things is essential and
 405      not trivial.
 406
 407      - Rate limit goes before "recursive". Otherwise a series of
 408        recursive calls will hang the machine in the interrupt routine.
 409
 410      - hardware twiddling goes before "recursive". Otherwise when we
 411        poll the card, and a recursive interrupt happens, we won't
 412        ack the card, so it might keep on interrupting us. (especially
 413        level sensitive interrupt systems like PCI).
 414
 415      - Rate limit goes before hardware twiddling. Otherwise we won't
 416        catch a card that has gone bonkers.
 417
 418      - The "initialized" test goes after the hardware twiddling. Otherwise
 419        the card will stick us in the interrupt routine again.
 420
 421      - The initialized test goes before recursive.
 422   */
 423
 424
 425
 426 #ifdef IRQ_RATE_LIMIT
 427   /* Aaargh! I'm ashamed. This costs more lines-of-code than the
 428      actual interrupt routine!. (Well, used to when I wrote that comment) */
 429   {
 430     static int lastjif;
 431     static int nintr=0;
 432
 433     if (lastjif == jiffies) {
 434       if (++nintr > IRQ_RATE_LIMIT) {
 435         free_irq (HostP->Ivec, ptr);
 436         printk (KERN_ERR "rio: Too many interrupts. Turning off interrupt %d.\n",
 437                 HostP->Ivec);
 438       }
 439     } else {
 440       lastjif = jiffies;
 441       nintr = 0;
 442     }
 443   }
 444 #endif
 445   rio_dprintk (RIO_DEBUG_IFLOW, "rio: We've have noticed the interrupt\n");
 446   if (HostP->Ivec == irq) {
 447     /* Tell the card we've noticed the interrupt. */
 448     rio_reset_interrupt (HostP);
 449   }
 450
 451   if ((HostP->Flags & RUN_STATE) != RC_RUNNING)
 452         return IRQ_HANDLED;
 453
 454   if (test_and_set_bit (RIO_BOARD_INTR_LOCK, &HostP->locks)) {
 455     printk (KERN_ERR "Recursive interrupt! (host %d/irq%d)\n",
 456             (int) ptr, HostP->Ivec);
 457     return IRQ_HANDLED;
 458   }
 459
 460   RIOServiceHost(p, HostP, irq);
 461
 462   rio_dprintk ( RIO_DEBUG_IFLOW, "riointr() doing host %d type %d\n",
 463                 (int) ptr, HostP->Type);
 464
 465   clear_bit (RIO_BOARD_INTR_LOCK, &HostP->locks);
 466   rio_dprintk (RIO_DEBUG_IFLOW, "rio: exit rio_interrupt (%d/%d)\n",
 467                irq, HostP->Ivec);
 468   func_exit ();
 469   return IRQ_HANDLED;
 470 }
 471
 472
 473 static void rio_pollfunc (unsigned long data)
 474 {
 475   func_enter ();
 476
 477   rio_interrupt (0, &p->RIOHosts[data], NULL);
 478   p->RIOHosts[data].timer.expires = jiffies + rio_poll;
 479   add_timer (&p->RIOHosts[data].timer);
 480
 481   func_exit ();
 482 }
 483
 484
 485 /* ********************************************************************** *
 486  *                Here are the routines that actually                     *
 487  *              interface with the generic_serial driver                  *
 488  * ********************************************************************** */
 489
 490 /* Ehhm. I don't know how to fiddle with interrupts on the Specialix
 491    cards. ....   Hmm. Ok I figured it out. You don't.  -- REW */
 492
 493 static void rio_disable_tx_interrupts (void * ptr)
 494 {
 495   func_enter();
 496
 497   /*  port->gs.flags &= ~GS_TX_INTEN; */
 498
 499   func_exit();
 500 }
 501
 502
 503 static void rio_enable_tx_interrupts (void * ptr)
 504 {
 505   struct Port *PortP = ptr;
 506   /* int hn; */
 507
 508   func_enter();
 509
 510   /* hn = PortP->HostP - p->RIOHosts;
 511
 512      rio_dprintk (RIO_DEBUG_TTY, "Pushing host %d\n", hn);
 513      rio_interrupt (-1,(void *) hn, NULL); */
 514
 515   RIOTxEnable((char *) PortP);
 516
 517   /*
 518    * In general we cannot count on "tx empty" interrupts, although
 519    * the interrupt routine seems to be able to tell the difference.
 520    */
 521   PortP->gs.flags &= ~GS_TX_INTEN;
 522
 523   func_exit();
 524 }
 525
 526
 527 static void rio_disable_rx_interrupts (void * ptr)
 528 {
 529   func_enter();
 530   func_exit();
 531 }
 532
 533 static void rio_enable_rx_interrupts (void * ptr)
 534 {
 535   /*  struct rio_port *port = ptr; */
 536   func_enter();
 537   func_exit();
 538 }
 539
 540
 541 /* Jeez. Isn't this simple?  */
 542 static int rio_get_CD (void * ptr)
 543 {
 544   struct Port *PortP = ptr;
 545   int rv;
 546
 547   func_enter();
 548   rv = (PortP->ModemState & MSVR1_CD) != 0;
 549
 550   rio_dprintk (RIO_DEBUG_INIT, "Getting CD status: %d\n", rv);
 551
 552   func_exit();
 553   return rv;
 554 }
 555
 556
 557 /* Jeez. Isn't this simple? Actually, we can sync with the actual port
 558    by just pushing stuff into the queue going to the port... */
 559 static int rio_chars_in_buffer (void * ptr)
 560 {
 561   func_enter();
 562
 563   func_exit();
 564   return 0;
 565 }
 566
 567
 568 /* Nothing special here... */
 569 static void rio_shutdown_port (void * ptr)
 570 {
 571   struct Port *PortP;
 572
 573   func_enter();
 574
 575   PortP = (struct Port *)ptr;
 576   PortP->gs.tty = NULL;
 577 #if 0
 578   port->gs.flags &= ~ GS_ACTIVE;
 579   if (!port->gs.tty) {
 580     rio_dprintk (RIO_DBUG_TTY, "No tty.\n");
 581     return;
 582   }
 583   if (!port->gs.tty->termios) {
 584     rio_dprintk (RIO_DEBUG_TTY, "No termios.\n");
 585     return;
 586   }
 587   if (port->gs.tty->termios->c_cflag & HUPCL) {
 588     rio_setsignals (port, 0, 0);
 589   }
 590 #endif
 591
 592   func_exit();
 593 }
 594
 595
 596 /* I haven't the foggiest why the decrement use count has to happen
 597    here. The whole linux serial drivers stuff needs to be redesigned.
 598    My guess is that this is a hack to minimize the impact of a bug
 599    elsewhere. Thinking about it some more. (try it sometime) Try
 600    running minicom on a serial port that is driven by a modularized
 601    driver. Have the modem hangup. Then remove the driver module. Then
 602    exit minicom.  I expect an "oops".  -- REW */
 603 static void rio_hungup (void *ptr)
 604 {
 605   struct Port *PortP;
 606
 607   func_enter();
 608
 609   PortP = (struct Port *)ptr;
 610   PortP->gs.tty = NULL;
 611
 612   func_exit ();
 613 }
 614
 615
 616 /* The standard serial_close would become shorter if you'd wrap it like
 617    this.
 618    rs_close (...){save_flags;cli;real_close();dec_use_count;restore_flags;}
 619  */
 620 static void rio_close (void *ptr)
 621 {
 622   struct Port *PortP;
 623
 624   func_enter ();
 625
 626   PortP = (struct Port *)ptr;
 627
 628   riotclose (ptr);
 629
 630   if(PortP->gs.count) {
 631     printk (KERN_ERR "WARNING port count:%d\n", PortP->gs.count);
 632     PortP->gs.count = 0;
 633   }
 634
 635   PortP->gs.tty = NULL;
 636   func_exit ();
 637 }
 638
 639
 640
 641 static int rio_fw_ioctl (struct inode *inode, struct file *filp,
 642                          unsigned int cmd, unsigned long arg)
 643 {
 644   int rc = 0;
 645   func_enter();
 646
 647   /* The "dev" argument isn't used. */
 648   rc = riocontrol (p, 0, cmd, (void *)arg, capable(CAP_SYS_ADMIN));
 649
 650   func_exit ();
 651   return rc;
 652 }
 653
 654 extern int RIOShortCommand(struct rio_info *p, struct Port *PortP,
 655                int command, int len, int arg);
 656
 657 static int rio_ioctl (struct tty_struct * tty, struct file * filp,
 658                      unsigned int cmd, unsigned long arg)
 659 {
 660   int rc;
 661   struct Port *PortP;
 662   int ival;
 663
 664   func_enter();
 665
 666   PortP = (struct Port *)tty->driver_data;
 667
 668   rc  = 0;
 669   switch (cmd) {
 670 #if 0
 671   case TIOCGSOFTCAR:
 672     rc = put_user(((tty->termios->c_cflag & CLOCAL) ? 1 : 0),
 673                   (unsigned int *) arg);
 674     break;
 675 #endif
 676   case TIOCSSOFTCAR:
 677     if ((rc = get_user(ival, (unsigned int *) arg)) == 0) {
 678       tty->termios->c_cflag =
 679         (tty->termios->c_cflag & ~CLOCAL) |
 680         (ival ? CLOCAL : 0);
 681     }
 682     break;
 683   case TIOCGSERIAL:
 684     if ((rc = verify_area(VERIFY_WRITE, (void *) arg,
 685                           sizeof(struct serial_struct))) == 0)
 686       rc = gs_getserial(&PortP->gs, (struct serial_struct *) arg);
 687     break;
 688   case TCSBRK:
 689     if ( PortP->State & RIO_DELETED ) {
 690       rio_dprintk (RIO_DEBUG_TTY, "BREAK on deleted RTA\n");
 691       rc = -EIO;
 692     } else {
 693       if (RIOShortCommand(p, PortP, SBREAK, 2, 250) == RIO_FAIL) {
 694          rio_dprintk (RIO_DEBUG_INTR, "SBREAK RIOShortCommand failed\n");
 695          rc = -EIO;
 696       }
 697     }
 698     break;
 699   case TCSBRKP:
 700     if ( PortP->State & RIO_DELETED ) {
 701       rio_dprintk (RIO_DEBUG_TTY, "BREAK on deleted RTA\n");
 702       rc = -EIO;
 703     } else {
 704       int l;
 705       l = arg?arg*100:250;
 706       if (l > 255) l = 255;
 707       if (RIOShortCommand(p, PortP, SBREAK, 2, arg?arg*100:250) == RIO_FAIL) {
 708          rio_dprintk (RIO_DEBUG_INTR, "SBREAK RIOShortCommand failed\n");
 709          rc = -EIO;
 710       }
 711     }
 712     break;
 713   case TIOCSSERIAL:
 714     if ((rc = verify_area(VERIFY_READ, (void *) arg,
 715                           sizeof(struct serial_struct))) == 0)
 716       rc = gs_setserial(&PortP->gs, (struct serial_struct *) arg);
 717     break;
 718 #if 0
 719   /*
 720    * note: these IOCTLs no longer reach here.  Use
 721    * tiocmset/tiocmget driver methods instead.  The
 722    * #if 0 disablement predates this comment.
 723    */
 724   case TIOCMGET:
 725     if ((rc = verify_area(VERIFY_WRITE, (void *) arg,
 726                           sizeof(unsigned int))) == 0) {
 727       ival = rio_getsignals(port);
 728       put_user(ival, (unsigned int *) arg);
 729     }
 730     break;
 731   case TIOCMBIS:
 732     if ((rc = get_user(ival, (unsigned int *) arg)) == 0) {
 733       rio_setsignals(port, ((ival & TIOCM_DTR) ? 1 : -1),
 734                            ((ival & TIOCM_RTS) ? 1 : -1));
 735     }
 736     break;
 737   case TIOCMBIC:
 738     if ((rc = get_user(ival, (unsigned int *) arg)) == 0) {
 739       rio_setsignals(port, ((ival & TIOCM_DTR) ? 0 : -1),
 740                            ((ival & TIOCM_RTS) ? 0 : -1));
 741     }
 742     break;
 743   case TIOCMSET:
 744     if ((rc = get_user(ival, (unsigned int *) arg)) == 0) {
 745       rio_setsignals(port, ((ival & TIOCM_DTR) ? 1 : 0),
 746                            ((ival & TIOCM_RTS) ? 1 : 0));
 747     }
 748     break;
 749 #endif
 750   default:
 751     rc = -ENOIOCTLCMD;
 752     break;
 753   }
 754   func_exit();
 755   return rc;
 756 }
 757
 758
 759 /* The throttle/unthrottle scheme for the Specialix card is different
 760  * from other drivers and deserves some explanation.
 761  * The Specialix hardware takes care of XON/XOFF
 762  * and CTS/RTS flow control itself.  This means that all we have to
 763  * do when signalled by the upper tty layer to throttle/unthrottle is
 764  * to make a note of it here.  When we come to read characters from the
 765  * rx buffers on the card (rio_receive_chars()) we look to see if the
 766  * upper layer can accept more (as noted here in rio_rx_throt[]).
 767  * If it can't we simply don't remove chars from the cards buffer.
 768  * When the tty layer can accept chars, we again note that here and when
 769  * rio_receive_chars() is called it will remove them from the cards buffer.
 770  * The card will notice that a ports buffer has drained below some low
 771  * water mark and will unflow control the line itself, using whatever
 772  * flow control scheme is in use for that port. -- Simon Allen
 773  */
 774
 775 static void rio_throttle (struct tty_struct * tty)
 776 {
 777   struct Port *port = (struct Port *)tty->driver_data;
 778
 779   func_enter();
 780   /* If the port is using any type of input flow
 781    * control then throttle the port.
 782    */
 783
 784   if((tty->termios->c_cflag & CRTSCTS) || (I_IXOFF(tty)) ) {
 785     port->State |= RIO_THROTTLE_RX;
 786   }
 787
 788   func_exit();
 789 }
 790
 791
 792 static void rio_unthrottle (struct tty_struct * tty)
 793 {
 794   struct Port *port = (struct Port *)tty->driver_data;
 795
 796   func_enter();
 797   /* Always unthrottle even if flow control is not enabled on
 798    * this port in case we disabled flow control while the port
 799    * was throttled
 800    */
 801
 802   port->State &= ~RIO_THROTTLE_RX;
 803
 804   func_exit();
 805   return;
 806 }
 807
 808
 809
 810
 811
 812 /* ********************************************************************** *
 813  *                    Here are the initialization routines.               *
 814  * ********************************************************************** */
 815
 816
 817 static struct vpd_prom *get_VPD_PROM (struct Host *hp)
 818 {
 819   static struct vpd_prom vpdp;
 820   char *p;
 821   int i;
 822
 823   func_enter();
 824   rio_dprintk (RIO_DEBUG_PROBE, "Going to verify vpd prom at %p.\n",
 825               hp->Caddr + RIO_VPD_ROM);
 826
 827   p = (char *) &vpdp;
 828   for (i=0;i< sizeof (struct vpd_prom);i++)
 829     *p++ = readb (hp->Caddr+RIO_VPD_ROM + i*2);
 830       /* read_rio_byte (hp, RIO_VPD_ROM + i*2); */
 831
 832   /* Terminate the identifier string.
 833      *** requires one extra byte in struct vpd_prom *** */
 834   *p++=0;
 835
 836   if (rio_debug & RIO_DEBUG_PROBE)
 837     my_hd ((char *)&vpdp, 0x20);
 838
 839   func_exit();
 840
 841   return &vpdp;
 842 }
 843
 844 static struct tty_operations rio_ops = {
 845         .open  = riotopen,
 846         .close = gs_close,
 847         .write = gs_write,
 848         .put_char = gs_put_char,
 849         .flush_chars = gs_flush_chars,
 850         .write_room = gs_write_room,
 851         .chars_in_buffer = gs_chars_in_buffer,
 852         .flush_buffer = gs_flush_buffer,
 853         .ioctl = rio_ioctl,
 854         .throttle = rio_throttle,
 855         .unthrottle = rio_unthrottle,
 856         .set_termios = gs_set_termios,
 857         .stop = gs_stop,
 858         .start = gs_start,
 859         .hangup = gs_hangup,
 860 };
 861
 862 static int rio_init_drivers(void)
 863 {
 864         int error = -ENOMEM;
 865
 866         rio_driver = alloc_tty_driver(256);
 867         if (!rio_driver)
 868                 goto out;
 869         rio_driver2 = alloc_tty_driver(256);
 870         if (!rio_driver2)
 871                 goto out1;
 872
 873         func_enter();
 874
 875         rio_driver->owner = THIS_MODULE;
 876         rio_driver->driver_name = "specialix_rio";
 877         rio_driver->name = "ttySR";
 878         rio_driver->major = RIO_NORMAL_MAJOR0;
 879         rio_driver->type = TTY_DRIVER_TYPE_SERIAL;
 880         rio_driver->subtype = SERIAL_TYPE_NORMAL;
 881         rio_driver->init_termios = tty_std_termios;
 882         rio_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
 883         rio_driver->flags = TTY_DRIVER_REAL_RAW;
 884         tty_set_operations(rio_driver, &rio_ops);
 885
 886         rio_driver2->owner = THIS_MODULE;
 887         rio_driver2->driver_name = "specialix_rio";
 888         rio_driver2->name = "ttySR";
 889         rio_driver2->major = RIO_NORMAL_MAJOR1;
 890         rio_driver2->type = TTY_DRIVER_TYPE_SERIAL;
 891         rio_driver2->subtype = SERIAL_TYPE_NORMAL;
 892         rio_driver2->init_termios = tty_std_termios;
 893         rio_driver2->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
 894         rio_driver2->flags = TTY_DRIVER_REAL_RAW;
 895         tty_set_operations(rio_driver2, &rio_ops);
 896
 897         rio_dprintk (RIO_DEBUG_INIT, "set_termios = %p\n", gs_set_termios);
 898
 899         if ((error = tty_register_driver(rio_driver)))
 900                 goto out2;
 901         if ((error = tty_register_driver(rio_driver2)))
 902                 goto out3;
 903         func_exit();
 904         return 0;
 905 out3:
 906         tty_unregister_driver(rio_driver);
 907 out2:
 908         put_tty_driver(rio_driver2);
 909 out1:
 910         put_tty_driver(rio_driver);
 911 out:
 912         printk(KERN_ERR "rio: Couldn't register a rio driver, error = %d\n",
 913              error);
 914         return 1;
 915 }
 916
 917
 918 static void * ckmalloc (int size)
 919 {
 920   void *p;
 921
 922   p = kmalloc(size, GFP_KERNEL);
 923   if (p)
 924     memset(p, 0, size);
 925   return p;
 926 }
 927
 928
 929
 930 static int rio_init_datastructures (void)
 931 {
 932   int i;
 933   struct Port *port;
 934   func_enter();
 935
 936   /* Many drivers statically allocate the maximum number of ports
 937      There is no reason not to allocate them dynamically. Is there? -- REW */
 938   /* However, the RIO driver allows users to configure their first
 939      RTA as the ports numbered 504-511. We therefore need to allocate
 940      the whole range. :-(   -- REW */
 941
 942 #define RI_SZ   sizeof(struct rio_info)
 943 #define HOST_SZ sizeof(struct Host)
 944 #define PORT_SZ sizeof(struct Port *)
 945 #define TMIO_SZ sizeof(struct termios *)
 946   rio_dprintk (RIO_DEBUG_INIT, "getting : %d %d %d %d %d bytes\n",
 947                RI_SZ,
 948                RIO_HOSTS * HOST_SZ,
 949                RIO_PORTS * PORT_SZ,
 950                RIO_PORTS * TMIO_SZ,
 951                RIO_PORTS * TMIO_SZ);
 952
 953   if (!(p                  = ckmalloc (              RI_SZ))) goto free0;
 954   if (!(p->RIOHosts        = ckmalloc (RIO_HOSTS * HOST_SZ))) goto free1;
 955   if (!(p->RIOPortp        = ckmalloc (RIO_PORTS * PORT_SZ))) goto free2;
 956   p->RIOConf = RIOConf;
 957   rio_dprintk (RIO_DEBUG_INIT, "Got : %p %p %p\n",
 958                p, p->RIOHosts, p->RIOPortp);
 959
 960 #if 1
 961   for (i = 0; i < RIO_PORTS; i++) {
 962     port = p->RIOPortp[i] = ckmalloc (sizeof (struct Port));
 963     if (!port) {
 964       goto free6;
 965     }
 966     rio_dprintk (RIO_DEBUG_INIT, "initing port %d (%d)\n", i, port->Mapped);
 967     port->PortNum = i;
 968     port->gs.magic = RIO_MAGIC;
 969     port->gs.close_delay = HZ/2;
 970     port->gs.closing_wait = 30 * HZ;
 971     port->gs.rd = &rio_real_driver;
 972     spin_lock_init(&port->portSem);
 973     /*
 974      * Initializing wait queue
 975      */
 976     init_waitqueue_head(&port->gs.open_wait);
 977     init_waitqueue_head(&port->gs.close_wait);
 978   }
 979 #else
 980   /* We could postpone initializing them to when they are configured. */
 981 #endif
 982
 983
 984
 985   if (rio_debug & RIO_DEBUG_INIT) {
 986     my_hd (&rio_real_driver, sizeof (rio_real_driver));
 987   }
 988
 989
 990   func_exit();
 991   return 0;
 992
 993  free6:for (i--;i>=0;i--)
 994         kfree (p->RIOPortp[i]);
 995 /*free5:
 996  free4:
 997  free3:*/kfree (p->RIOPortp);
 998  free2:kfree (p->RIOHosts);
 999  free1:
1000   rio_dprintk (RIO_DEBUG_INIT, "Not enough memory! %p %p %p\n",
1001                        p, p->RIOHosts, p->RIOPortp);
1002   kfree(p);
1003  free0:
1004   return -ENOMEM;
1005 }
1006
1007 static void  __exit rio_release_drivers(void)
1008 {
1009   func_enter();
1010   tty_unregister_driver(rio_driver2);
1011   tty_unregister_driver(rio_driver);
1012   put_tty_driver(rio_driver2);
1013   put_tty_driver(rio_driver);
1014   func_exit();
1015 }
1016
1017
1018 #ifdef CONFIG_PCI
1019  /* This was written for SX, but applies to RIO too...
1020     (including bugs....)
1021
1022     There is another bit besides Bit 17. Turning that bit off
1023     (on boards shipped with the fix in the eeprom) results in a
1024     hang on the next access to the card.
1025  */
1026
1027  /********************************************************
1028  * Setting bit 17 in the CNTRL register of the PLX 9050  *
1029  * chip forces a retry on writes while a read is pending.*
1030  * This is to prevent the card locking up on Intel Xeon  *
1031  * multiprocessor systems with the NX chipset.    -- NV  *
1032  ********************************************************/
1033
1034 /* Newer cards are produced with this bit set from the configuration
1035    EEprom.  As the bit is read/write for the CPU, we can fix it here,
1036    if we detect that it isn't set correctly. -- REW */
1037
1038 static void fix_rio_pci (struct pci_dev *pdev)
1039 {
1040   unsigned int hwbase;
1041   unsigned long rebase;
1042   unsigned int t;
1043
1044 #define CNTRL_REG_OFFSET        0x50
1045 #define CNTRL_REG_GOODVALUE     0x18260000
1046
1047   pci_read_config_dword(pdev, PCI_BASE_ADDRESS_0, &hwbase);
1048   hwbase &= PCI_BASE_ADDRESS_MEM_MASK;
1049   rebase =  (ulong) ioremap(hwbase, 0x80);
1050   t = readl (rebase + CNTRL_REG_OFFSET);
1051   if (t != CNTRL_REG_GOODVALUE) {
1052     printk (KERN_DEBUG "rio: performing cntrl reg fix: %08x -> %08x\n",
1053             t, CNTRL_REG_GOODVALUE);
1054     writel (CNTRL_REG_GOODVALUE, rebase + CNTRL_REG_OFFSET);
1055   }
1056   iounmap((char*) rebase);
1057 }
1058 #endif
1059
1060
1061 static int __init rio_init(void)
1062 {
1063   int found = 0;
1064   int i;
1065   struct Host *hp;
1066   int retval;
1067   struct vpd_prom *vpdp;
1068   int okboard;
1069
1070 #ifdef CONFIG_PCI
1071   struct pci_dev *pdev = NULL;
1072   unsigned int tint;
1073   unsigned short tshort;
1074 #endif
1075
1076   func_enter();
1077   rio_dprintk (RIO_DEBUG_INIT, "Initing rio module... (rio_debug=%d)\n",
1078                rio_debug);
1079
1080   if (abs ((long) (&rio_debug) - rio_debug) < 0x10000) {
1081     printk (KERN_WARNING "rio: rio_debug is an address, instead of a value. "
1082             "Assuming -1. Was %x/%p.\n", rio_debug, &rio_debug);
1083     rio_debug=-1;
1084   }
1085
1086   if (misc_register(&rio_fw_device) < 0) {
1087     printk(KERN_ERR "RIO: Unable to register firmware loader driver.\n");
1088     return -EIO;
1089   }
1090
1091   retval = rio_init_datastructures ();
1092   if (retval < 0) {
1093     misc_deregister(&rio_fw_device);
1094     return retval;
1095   }
1096
1097 #ifdef CONFIG_PCI
1098     /* First look for the JET devices: */
1099     while ((pdev = pci_find_device (PCI_VENDOR_ID_SPECIALIX,
1100                                     PCI_DEVICE_ID_SPECIALIX_SX_XIO_IO8,
1101                                     pdev))) {
1102        if (pci_enable_device(pdev)) continue;
1103
1104       /* Specialix has a whole bunch of cards with
1105          0x2000 as the device ID. They say its because
1106          the standard requires it. Stupid standard. */
1107       /* It seems that reading a word doesn't work reliably on 2.0.
1108          Also, reading a non-aligned dword doesn't work. So we read the
1109          whole dword at 0x2c and extract the word at 0x2e (SUBSYSTEM_ID)
1110          ourselves */
1111       /* I don't know why the define doesn't work, constant 0x2c does --REW */
1112       pci_read_config_dword (pdev, 0x2c, &tint);
1113       tshort = (tint >> 16) & 0xffff;
1114       rio_dprintk (RIO_DEBUG_PROBE, "Got a specialix card: %x.\n", tint);
1115       if (tshort != 0x0100) {
1116         rio_dprintk (RIO_DEBUG_PROBE, "But it's not a RIO card (%d)...\n",
1117                     tshort);
1118         continue;
1119       }
1120       rio_dprintk (RIO_DEBUG_PROBE, "cp1\n");
1121
1122       pci_read_config_dword(pdev, PCI_BASE_ADDRESS_2, &tint);
1123
1124       hp = &p->RIOHosts[p->RIONumHosts];
1125       hp->PaddrP =  tint & PCI_BASE_ADDRESS_MEM_MASK;
1126       hp->Ivec = pdev->irq;
1127       if (((1 << hp->Ivec) & rio_irqmask) == 0)
1128               hp->Ivec = 0;
1129       hp->Caddr = ioremap(p->RIOHosts[p->RIONumHosts].PaddrP, RIO_WINDOW_LEN);
1130       hp->CardP = (struct DpRam *) hp->Caddr;
1131       hp->Type  = RIO_PCI;
1132       hp->Copy  = rio_pcicopy;
1133       hp->Mode  = RIO_PCI_BOOT_FROM_RAM;
1134       spin_lock_init(&hp->HostLock);
1135       rio_reset_interrupt (hp);
1136       rio_start_card_running (hp);
1137
1138       rio_dprintk (RIO_DEBUG_PROBE, "Going to test it (%p/%p).\n",
1139                    (void *)p->RIOHosts[p->RIONumHosts].PaddrP,
1140                    p->RIOHosts[p->RIONumHosts].Caddr);
1141       if (RIOBoardTest( p->RIOHosts[p->RIONumHosts].PaddrP,
1142                         p->RIOHosts[p->RIONumHosts].Caddr,
1143                         RIO_PCI, 0 ) == RIO_SUCCESS) {
1144               rio_dprintk (RIO_DEBUG_INIT, "Done RIOBoardTest\n");
1145               WBYTE(p->RIOHosts[p->RIONumHosts].ResetInt, 0xff);
1146               p->RIOHosts[p->RIONumHosts].UniqueNum  =
1147                       ((RBYTE(p->RIOHosts[p->RIONumHosts].Unique[0]) &0xFF)<< 0)|
1148                       ((RBYTE(p->RIOHosts[p->RIONumHosts].Unique[1]) &0xFF)<< 8)|
1149                       ((RBYTE(p->RIOHosts[p->RIONumHosts].Unique[2]) &0xFF)<<16)|
1150                       ((RBYTE(p->RIOHosts[p->RIONumHosts].Unique[3]) &0xFF)<<24);
1151               rio_dprintk (RIO_DEBUG_PROBE, "Hmm Tested ok, uniqid = %x.\n",
1152                            p->RIOHosts[p->RIONumHosts].UniqueNum);
1153
1154               fix_rio_pci (pdev);
1155               p->RIOLastPCISearch = RIO_SUCCESS;
1156               p->RIONumHosts++;
1157               found++;
1158       } else {
1159               iounmap((char*) (p->RIOHosts[p->RIONumHosts].Caddr));
1160       }
1161     }
1162
1163     /* Then look for the older PCI card.... : */
1164
1165   /* These older PCI cards have problems (only byte-mode access is
1166      supported), which makes them a bit awkward to support.
1167      They also have problems sharing interrupts. Be careful.
1168      (The driver now refuses to share interrupts for these
1169      cards. This should be sufficient).
1170   */
1171
1172     /* Then look for the older RIO/PCI devices: */
1173     while ((pdev = pci_find_device (PCI_VENDOR_ID_SPECIALIX,
1174                                     PCI_DEVICE_ID_SPECIALIX_RIO,
1175                                     pdev))) {
1176        if (pci_enable_device(pdev)) continue;
1177
1178 #ifdef CONFIG_RIO_OLDPCI
1179       pci_read_config_dword(pdev, PCI_BASE_ADDRESS_0, &tint);
1180
1181       hp = &p->RIOHosts[p->RIONumHosts];
1182       hp->PaddrP =  tint & PCI_BASE_ADDRESS_MEM_MASK;
1183       hp->Ivec = pdev->irq;
1184       if (((1 << hp->Ivec) & rio_irqmask) == 0)
1185         hp->Ivec = 0;
1186       hp->Ivec |= 0x8000; /* Mark as non-sharable */
1187       hp->Caddr = ioremap(p->RIOHosts[p->RIONumHosts].PaddrP, RIO_WINDOW_LEN);
1188       hp->CardP = (struct DpRam *) hp->Caddr;
1189       hp->Type  = RIO_PCI;
1190       hp->Copy  = rio_pcicopy;
1191       hp->Mode  = RIO_PCI_BOOT_FROM_RAM;
1192       spin_lock_init(&hp->HostLock);
1193
1194       rio_dprintk (RIO_DEBUG_PROBE, "Ivec: %x\n", hp->Ivec);
1195       rio_dprintk (RIO_DEBUG_PROBE, "Mode: %x\n", hp->Mode);
1196
1197       rio_reset_interrupt (hp);
1198       rio_start_card_running (hp);
1199        rio_dprintk (RIO_DEBUG_PROBE, "Going to test it (%p/%p).\n",
1200                    (void *)p->RIOHosts[p->RIONumHosts].PaddrP,
1201                    p->RIOHosts[p->RIONumHosts].Caddr);
1202       if (RIOBoardTest( p->RIOHosts[p->RIONumHosts].PaddrP,
1203                         p->RIOHosts[p->RIONumHosts].Caddr,
1204                         RIO_PCI, 0 ) == RIO_SUCCESS) {
1205         WBYTE(p->RIOHosts[p->RIONumHosts].ResetInt, 0xff);
1206         p->RIOHosts[p->RIONumHosts].UniqueNum  =
1207           ((RBYTE(p->RIOHosts[p->RIONumHosts].Unique[0]) &0xFF)<< 0)|
1208           ((RBYTE(p->RIOHosts[p->RIONumHosts].Unique[1]) &0xFF)<< 8)|
1209           ((RBYTE(p->RIOHosts[p->RIONumHosts].Unique[2]) &0xFF)<<16)|
1210           ((RBYTE(p->RIOHosts[p->RIONumHosts].Unique[3]) &0xFF)<<24);
1211         rio_dprintk (RIO_DEBUG_PROBE, "Hmm Tested ok, uniqid = %x.\n",
1212                    p->RIOHosts[p->RIONumHosts].UniqueNum);
1213
1214         p->RIOLastPCISearch = RIO_SUCCESS;
1215         p->RIONumHosts++;
1216         found++;
1217       } else {
1218         iounmap((char*) (p->RIOHosts[p->RIONumHosts].Caddr));
1219       }
1220 #else
1221       printk (KERN_ERR "Found an older RIO PCI card, but the driver is not "
1222               "compiled to support it.\n");
1223 #endif
1224     }
1225 #endif /* PCI */
1226
1227   /* Now probe for ISA cards... */
1228   for (i=0;i<NR_RIO_ADDRS;i++) {
1229     hp = &p->RIOHosts[p->RIONumHosts];
1230     hp->PaddrP = rio_probe_addrs[i];
1231     /* There was something about the IRQs of these cards. 'Forget what.--REW */
1232     hp->Ivec = 0;
1233     hp->Caddr = ioremap(p->RIOHosts[p->RIONumHosts].PaddrP, RIO_WINDOW_LEN);
1234     hp->CardP = (struct DpRam *) hp->Caddr;
1235     hp->Type = RIO_AT;
1236     hp->Copy = rio_pcicopy; /* AT card PCI???? - PVDL
1237                              * -- YES! this is now a normal copy. Only the
1238                              * old PCI card uses the special PCI copy.
1239                              * Moreover, the ISA card will work with the
1240                              * special PCI copy anyway. -- REW */
1241     hp->Mode = 0;
1242     spin_lock_init(&hp->HostLock);
1243
1244     vpdp = get_VPD_PROM (hp);
1245     rio_dprintk (RIO_DEBUG_PROBE, "Got VPD ROM\n");
1246     okboard = 0;
1247     if ((strncmp (vpdp->identifier, RIO_ISA_IDENT, 16) == 0) ||
1248         (strncmp (vpdp->identifier, RIO_ISA2_IDENT, 16) == 0) ||
1249         (strncmp (vpdp->identifier, RIO_ISA3_IDENT, 16) == 0)) {
1250       /* Board is present... */
1251       if (RIOBoardTest (hp->PaddrP,
1252                         hp->Caddr, RIO_AT, 0) == RIO_SUCCESS) {
1253         /* ... and feeling fine!!!! */
1254         rio_dprintk (RIO_DEBUG_PROBE, "Hmm Tested ok, uniqid = %x.\n",
1255                    p->RIOHosts[p->RIONumHosts].UniqueNum);
1256         if (RIOAssignAT(p, hp->PaddrP, hp->Caddr, 0)) {
1257           rio_dprintk (RIO_DEBUG_PROBE, "Hmm Tested ok, host%d uniqid = %x.\n",
1258                        p->RIONumHosts,
1259                        p->RIOHosts[p->RIONumHosts-1].UniqueNum);
1260           okboard++;
1261           found++;
1262         }
1263       }
1264
1265     if (!okboard)
1266       iounmap ((char*) (hp->Caddr));
1267     }
1268   }
1269
1270
1271   for (i=0;i<p->RIONumHosts;i++) {
1272     hp = &p->RIOHosts[i];
1273     if (hp->Ivec) {
1274       int mode = SA_SHIRQ;
1275       if (hp->Ivec & 0x8000) {mode = 0; hp->Ivec &= 0x7fff;}
1276       rio_dprintk (RIO_DEBUG_INIT, "Requesting interrupt hp: %p rio_interrupt: %d Mode: %x\n", hp,hp->Ivec, hp->Mode);
1277       retval = request_irq (hp->Ivec, rio_interrupt, mode, "rio", hp);
1278       rio_dprintk (RIO_DEBUG_INIT, "Return value from request_irq: %d\n", retval);
1279       if (retval) {
1280               printk(KERN_ERR "rio: Cannot allocate irq %d.\n", hp->Ivec);
1281               hp->Ivec = 0;
1282       }
1283       rio_dprintk (RIO_DEBUG_INIT, "Got irq %d.\n", hp->Ivec);
1284       if (hp->Ivec != 0){
1285               rio_dprintk (RIO_DEBUG_INIT, "Enabling interrupts on rio card.\n");
1286               hp->Mode |= RIO_PCI_INT_ENABLE;
1287       } else
1288               hp->Mode &= !RIO_PCI_INT_ENABLE;
1289       rio_dprintk (RIO_DEBUG_INIT, "New Mode: %x\n", hp->Mode);
1290       rio_start_card_running (hp);
1291     }
1292     /* Init the timer "always" to make sure that it can safely be
1293        deleted when we unload... */
1294
1295     init_timer (&hp->timer);
1296     if (!hp->Ivec) {
1297       rio_dprintk (RIO_DEBUG_INIT, "Starting polling at %dj intervals.\n",
1298                    rio_poll);
1299       hp->timer.data = i;
1300       hp->timer.function = rio_pollfunc;
1301       hp->timer.expires = jiffies + rio_poll;
1302       add_timer (&hp->timer);
1303     }
1304   }
1305
1306   if (found) {
1307     rio_dprintk (RIO_DEBUG_INIT, "rio: total of %d boards detected.\n", found);
1308     rio_init_drivers ();
1309   } else {
1310     /* deregister the misc device we created earlier */
1311     misc_deregister(&rio_fw_device);
1312   }
1313
1314   func_exit();
1315   return found?0:-EIO;
1316 }
1317
1318
1319 static void __exit rio_exit (void)
1320 {
1321   int i;
1322   struct Host *hp;
1323
1324   func_enter();
1325
1326   for (i=0,hp=p->RIOHosts;i<p->RIONumHosts;i++, hp++) {
1327     RIOHostReset (hp->Type, hp->CardP, hp->Slot);
1328     if (hp->Ivec) {
1329       free_irq (hp->Ivec, hp);
1330       rio_dprintk (RIO_DEBUG_INIT, "freed irq %d.\n", hp->Ivec);
1331     }
1332     /* It is safe/allowed to del_timer a non-active timer */
1333     del_timer (&hp->timer);
1334   }
1335
1336   if (misc_deregister(&rio_fw_device) < 0) {
1337     printk (KERN_INFO "rio: couldn't deregister control-device\n");
1338   }
1339
1340
1341   rio_dprintk (RIO_DEBUG_CLEANUP, "Cleaning up drivers\n");
1342
1343   rio_release_drivers ();
1344
1345   /* Release dynamically allocated memory */
1346   kfree (p->RIOPortp);
1347   kfree (p->RIOHosts);
1348   kfree (p);
1349
1350   func_exit();
1351 }
1352
1353 module_init(rio_init);
1354 module_exit(rio_exit);
1355
1356 /*
1357  * Anybody who knows why this doesn't work for me, please tell me -- REW.
1358  * Snatched from scsi.c (fixed one spelling error):
1359  * Overrides for Emacs so that we follow Linus' tabbing style.
1360  * Emacs will notice this stuff at the end of the file and automatically
1361  * adjust the settings for this buffer only.  This must remain at the end
1362  * of the file.
1363  * ---------------------------------------------------------------------------
1364  * Local Variables:
1365  * c-indent-level: 4
1366  * c-brace-imaginary-offset: 0
1367  * c-brace-offset: -4
1368  * c-argdecl-indent: 4
1369  * c-label-offset: -4
1370  * c-continued-statement-offset: 4
1371  * c-continued-brace-offset: 0
1372  * indent-tabs-mode: nil
1373  * tab-width: 8
1374  * End:
1375  */
1376