release/src-rt-6.x.4708/linux/linux-2.6.36/drivers/scsi/aha1542.c

   1 /* $Id: aha1542.c,v 1.1 1992/07/24 06:27:38 root Exp root $
   2  *  linux/kernel/aha1542.c
   3  *
   4  *  Copyright (C) 1992  Tommy Thorn
   5  *  Copyright (C) 1993, 1994, 1995 Eric Youngdale
   6  *
   7  *  Modified by Eric Youngdale
   8  *        Use request_irq and request_dma to help prevent unexpected conflicts
   9  *        Set up on-board DMA controller, such that we do not have to
  10  *        have the bios enabled to use the aha1542.
  11  *  Modified by David Gentzel
  12  *        Don't call request_dma if dma mask is 0 (for BusLogic BT-445S VL-Bus
  13  *        controller).
  14  *  Modified by Matti Aarnio
  15  *        Accept parameters from LILO cmd-line. -- 1-Oct-94
  16  *  Modified by Mike McLagan <mike.mclagan@linux.org>
  17  *        Recognise extended mode on AHA1542CP, different bit than 1542CF
  18  *        1-Jan-97
  19  *  Modified by Bjorn L. Thordarson and Einar Thor Einarsson
  20  *        Recognize that DMA0 is valid DMA channel -- 13-Jul-98
  21  *  Modified by Chris Faulhaber <jedgar@fxp.org>
  22  *        Added module command-line options
  23  *        19-Jul-99
  24  *  Modified by Adam Fritzler
  25  *        Added proper detection of the AHA-1640 (MCA version of AHA-1540)
  26  */
  27
  28 #include <linux/module.h>
  29 #include <linux/interrupt.h>
  30 #include <linux/kernel.h>
  31 #include <linux/types.h>
  32 #include <linux/string.h>
  33 #include <linux/ioport.h>
  34 #include <linux/delay.h>
  35 #include <linux/proc_fs.h>
  36 #include <linux/init.h>
  37 #include <linux/spinlock.h>
  38 #include <linux/isapnp.h>
  39 #include <linux/blkdev.h>
  40 #include <linux/mca.h>
  41 #include <linux/mca-legacy.h>
  42 #include <linux/slab.h>
  43
  44 #include <asm/dma.h>
  45 #include <asm/system.h>
  46 #include <asm/io.h>
  47
  48 #include "scsi.h"
  49 #include <scsi/scsi_host.h>
  50 #include "aha1542.h"
  51
  52 #define SCSI_BUF_PA(address)    isa_virt_to_bus(address)
  53 #define SCSI_SG_PA(sgent)       (isa_page_to_bus(sg_page((sgent))) + (sgent)->offset)
  54
  55 #include<linux/stat.h>
  56
  57 #ifdef DEBUG
  58 #define DEB(x) x
  59 #else
  60 #define DEB(x)
  61 #endif
  62
  63 /*
  64    static const char RCSid[] = "$Header: /usr/src/linux/kernel/blk_drv/scsi/RCS/aha1542.c,v 1.1 1992/07/24 06:27:38 root Exp root $";
  65  */
  66
  67 /* The adaptec can be configured for quite a number of addresses, but
  68    I generally do not want the card poking around at random.  We allow
  69    two addresses - this allows people to use the Adaptec with a Midi
  70    card, which also used 0x330 -- can be overridden with LILO! */
  71
  72 #define MAXBOARDS 4             /* Increase this and the sizes of the
  73                                    arrays below, if you need more.. */
  74
  75 /* Boards 3,4 slots are reserved for ISAPnP/MCA scans */
  76
  77 static unsigned int bases[MAXBOARDS] __initdata = {0x330, 0x334, 0, 0};
  78
  79 /* set by aha1542_setup according to the command line; they also may
  80    be marked __initdata, but require zero initializers then */
  81
  82 static int setup_called[MAXBOARDS];
  83 static int setup_buson[MAXBOARDS];
  84 static int setup_busoff[MAXBOARDS];
  85 static int setup_dmaspeed[MAXBOARDS] __initdata = { -1, -1, -1, -1 };
  86
  87 /*
  88  * LILO/Module params:  aha1542=<PORTBASE>[,<BUSON>,<BUSOFF>[,<DMASPEED>]]
  89  *
  90  * Where:  <PORTBASE> is any of the valid AHA addresses:
  91  *                      0x130, 0x134, 0x230, 0x234, 0x330, 0x334
  92  *         <BUSON>  is the time (in microsecs) that AHA spends on the AT-bus
  93  *                  when transferring data.  1542A power-on default is 11us,
  94  *                  valid values are in range: 2..15 (decimal)
  95  *         <BUSOFF> is the time that AHA spends OFF THE BUS after while
  96  *                  it is transferring data (not to monopolize the bus).
  97  *                  Power-on default is 4us, valid range: 1..64 microseconds.
  98  *         <DMASPEED> Default is jumper selected (1542A: on the J1),
  99  *                  but experimenter can alter it with this.
 100  *                  Valid values: 5, 6, 7, 8, 10 (MB/s)
 101  *                  Factory default is 5 MB/s.
 102  */
 103
 104 #if defined(MODULE)
 105 static int isapnp = 0;
 106 static int aha1542[] = {0x330, 11, 4, -1};
 107 module_param_array(aha1542, int, NULL, 0);
 108 module_param(isapnp, bool, 0);
 109
 110 static struct isapnp_device_id id_table[] __initdata = {
 111         {
 112                 ISAPNP_ANY_ID, ISAPNP_ANY_ID,
 113                 ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1542),
 114                 0
 115         },
 116         {0}
 117 };
 118
 119 MODULE_DEVICE_TABLE(isapnp, id_table);
 120
 121 #else
 122 static int isapnp = 1;
 123 #endif
 124
 125 #define BIOS_TRANSLATION_1632 0 /* Used by some old 1542A boards */
 126 #define BIOS_TRANSLATION_6432 1 /* Default case these days */
 127 #define BIOS_TRANSLATION_25563 2        /* Big disk case */
 128
 129 struct aha1542_hostdata {
 130         /* This will effectively start both of them at the first mailbox */
 131         int bios_translation;   /* Mapping bios uses - for compatibility */
 132         int aha1542_last_mbi_used;
 133         int aha1542_last_mbo_used;
 134         Scsi_Cmnd *SCint[AHA1542_MAILBOXES];
 135         struct mailbox mb[2 * AHA1542_MAILBOXES];
 136         struct ccb ccb[AHA1542_MAILBOXES];
 137 };
 138
 139 #define HOSTDATA(host) ((struct aha1542_hostdata *) &host->hostdata)
 140
 141 static DEFINE_SPINLOCK(aha1542_lock);
 142
 143
 144
 145 #define WAITnexttimeout 3000000
 146
 147 static void setup_mailboxes(int base_io, struct Scsi_Host *shpnt);
 148 static int aha1542_restart(struct Scsi_Host *shost);
 149 static void aha1542_intr_handle(struct Scsi_Host *shost);
 150
 151 #define aha1542_intr_reset(base)  outb(IRST, CONTROL(base))
 152
 153 #define WAIT(port, mask, allof, noneof)                                 \
 154  { register int WAITbits;                                               \
 155    register int WAITtimeout = WAITnexttimeout;                          \
 156    while (1) {                                                          \
 157      WAITbits = inb(port) & (mask);                                     \
 158      if ((WAITbits & (allof)) == (allof) && ((WAITbits & (noneof)) == 0)) \
 159        break;                                                           \
 160      if (--WAITtimeout == 0) goto fail;                                 \
 161    }                                                                    \
 162  }
 163
 164 /* Similar to WAIT, except we use the udelay call to regulate the
 165    amount of time we wait.  */
 166 #define WAITd(port, mask, allof, noneof, timeout)                       \
 167  { register int WAITbits;                                               \
 168    register int WAITtimeout = timeout;                                  \
 169    while (1) {                                                          \
 170      WAITbits = inb(port) & (mask);                                     \
 171      if ((WAITbits & (allof)) == (allof) && ((WAITbits & (noneof)) == 0)) \
 172        break;                                                           \
 173      mdelay(1);                                                 \
 174      if (--WAITtimeout == 0) goto fail;                                 \
 175    }                                                                    \
 176  }
 177
 178 static void aha1542_stat(void)
 179 {
 180 /*      int s = inb(STATUS), i = inb(INTRFLAGS);
 181         printk("status=%x intrflags=%x\n", s, i, WAITnexttimeout-WAITtimeout); */
 182 }
 183
 184 /* This is a bit complicated, but we need to make sure that an interrupt
 185    routine does not send something out while we are in the middle of this.
 186    Fortunately, it is only at boot time that multi-byte messages
 187    are ever sent. */
 188 static int aha1542_out(unsigned int base, unchar * cmdp, int len)
 189 {
 190         unsigned long flags = 0;
 191         int got_lock;
 192
 193         if (len == 1) {
 194                 got_lock = 0;
 195                 while (1 == 1) {
 196                         WAIT(STATUS(base), CDF, 0, CDF);
 197                         spin_lock_irqsave(&aha1542_lock, flags);
 198                         if (inb(STATUS(base)) & CDF) {
 199                                 spin_unlock_irqrestore(&aha1542_lock, flags);
 200                                 continue;
 201                         }
 202                         outb(*cmdp, DATA(base));
 203                         spin_unlock_irqrestore(&aha1542_lock, flags);
 204                         return 0;
 205                 }
 206         } else {
 207                 spin_lock_irqsave(&aha1542_lock, flags);
 208                 got_lock = 1;
 209                 while (len--) {
 210                         WAIT(STATUS(base), CDF, 0, CDF);
 211                         outb(*cmdp++, DATA(base));
 212                 }
 213                 spin_unlock_irqrestore(&aha1542_lock, flags);
 214         }
 215         return 0;
 216 fail:
 217         if (got_lock)
 218                 spin_unlock_irqrestore(&aha1542_lock, flags);
 219         printk(KERN_ERR "aha1542_out failed(%d): ", len + 1);
 220         aha1542_stat();
 221         return 1;
 222 }
 223
 224 /* Only used at boot time, so we do not need to worry about latency as much
 225    here */
 226
 227 static int __init aha1542_in(unsigned int base, unchar * cmdp, int len)
 228 {
 229         unsigned long flags;
 230
 231         spin_lock_irqsave(&aha1542_lock, flags);
 232         while (len--) {
 233                 WAIT(STATUS(base), DF, DF, 0);
 234                 *cmdp++ = inb(DATA(base));
 235         }
 236         spin_unlock_irqrestore(&aha1542_lock, flags);
 237         return 0;
 238 fail:
 239         spin_unlock_irqrestore(&aha1542_lock, flags);
 240         printk(KERN_ERR "aha1542_in failed(%d): ", len + 1);
 241         aha1542_stat();
 242         return 1;
 243 }
 244
 245 /* Similar to aha1542_in, except that we wait a very short period of time.
 246    We use this if we know the board is alive and awake, but we are not sure
 247    if the board will respond to the command we are about to send or not */
 248 static int __init aha1542_in1(unsigned int base, unchar * cmdp, int len)
 249 {
 250         unsigned long flags;
 251
 252         spin_lock_irqsave(&aha1542_lock, flags);
 253         while (len--) {
 254                 WAITd(STATUS(base), DF, DF, 0, 100);
 255                 *cmdp++ = inb(DATA(base));
 256         }
 257         spin_unlock_irqrestore(&aha1542_lock, flags);
 258         return 0;
 259 fail:
 260         spin_unlock_irqrestore(&aha1542_lock, flags);
 261         return 1;
 262 }
 263
 264 static int makecode(unsigned hosterr, unsigned scsierr)
 265 {
 266         switch (hosterr) {
 267         case 0x0:
 268         case 0xa:               /* Linked command complete without error and linked normally */
 269         case 0xb:               /* Linked command complete without error, interrupt generated */
 270                 hosterr = 0;
 271                 break;
 272
 273         case 0x11:              /* Selection time out-The initiator selection or target
 274                                    reselection was not complete within the SCSI Time out period */
 275                 hosterr = DID_TIME_OUT;
 276                 break;
 277
 278         case 0x12:              /* Data overrun/underrun-The target attempted to transfer more data
 279                                    than was allocated by the Data Length field or the sum of the
 280                                    Scatter / Gather Data Length fields. */
 281
 282         case 0x13:              /* Unexpected bus free-The target dropped the SCSI BSY at an unexpected time. */
 283
 284         case 0x15:              /* MBO command was not 00, 01 or 02-The first byte of the CB was
 285                                    invalid. This usually indicates a software failure. */
 286
 287         case 0x16:              /* Invalid CCB Operation Code-The first byte of the CCB was invalid.
 288                                    This usually indicates a software failure. */
 289
 290         case 0x17:              /* Linked CCB does not have the same LUN-A subsequent CCB of a set
 291                                    of linked CCB's does not specify the same logical unit number as
 292                                    the first. */
 293         case 0x18:              /* Invalid Target Direction received from Host-The direction of a
 294                                    Target Mode CCB was invalid. */
 295
 296         case 0x19:              /* Duplicate CCB Received in Target Mode-More than once CCB was
 297                                    received to service data transfer between the same target LUN
 298                                    and initiator SCSI ID in the same direction. */
 299
 300         case 0x1a:              /* Invalid CCB or Segment List Parameter-A segment list with a zero
 301                                    length segment or invalid segment list boundaries was received.
 302                                    A CCB parameter was invalid. */
 303                 DEB(printk("Aha1542: %x %x\n", hosterr, scsierr));
 304                 hosterr = DID_ERROR;    /* Couldn't find any better */
 305                 break;
 306
 307         case 0x14:              /* Target bus phase sequence failure-An invalid bus phase or bus
 308                                    phase sequence was requested by the target. The host adapter
 309                                    will generate a SCSI Reset Condition, notifying the host with
 310                                    a SCRD interrupt */
 311                 hosterr = DID_RESET;
 312                 break;
 313         default:
 314                 printk(KERN_ERR "aha1542: makecode: unknown hoststatus %x\n", hosterr);
 315                 break;
 316         }
 317         return scsierr | (hosterr << 16);
 318 }
 319
 320 static int __init aha1542_test_port(int bse, struct Scsi_Host *shpnt)
 321 {
 322         unchar inquiry_cmd[] = {CMD_INQUIRY};
 323         unchar inquiry_result[4];
 324         unchar *cmdp;
 325         int len;
 326         volatile int debug = 0;
 327
 328         /* Quick and dirty test for presence of the card. */
 329         if (inb(STATUS(bse)) == 0xff)
 330                 return 0;
 331
 332         /* Reset the adapter. I ought to make a hard reset, but it's not really necessary */
 333
 334         /*  DEB(printk("aha1542_test_port called \n")); */
 335
 336         /* In case some other card was probing here, reset interrupts */
 337         aha1542_intr_reset(bse);        /* reset interrupts, so they don't block */
 338
 339         outb(SRST | IRST /*|SCRST */ , CONTROL(bse));
 340
 341         mdelay(20);             /* Wait a little bit for things to settle down. */
 342
 343         debug = 1;
 344         /* Expect INIT and IDLE, any of the others are bad */
 345         WAIT(STATUS(bse), STATMASK, INIT | IDLE, STST | DIAGF | INVDCMD | DF | CDF);
 346
 347         debug = 2;
 348         /* Shouldn't have generated any interrupts during reset */
 349         if (inb(INTRFLAGS(bse)) & INTRMASK)
 350                 goto fail;
 351
 352
 353         /* Perform a host adapter inquiry instead so we do not need to set
 354            up the mailboxes ahead of time */
 355
 356         aha1542_out(bse, inquiry_cmd, 1);
 357
 358         debug = 3;
 359         len = 4;
 360         cmdp = &inquiry_result[0];
 361
 362         while (len--) {
 363                 WAIT(STATUS(bse), DF, DF, 0);
 364                 *cmdp++ = inb(DATA(bse));
 365         }
 366
 367         debug = 8;
 368         /* Reading port should reset DF */
 369         if (inb(STATUS(bse)) & DF)
 370                 goto fail;
 371
 372         debug = 9;
 373         /* When HACC, command is completed, and we're though testing */
 374         WAIT(INTRFLAGS(bse), HACC, HACC, 0);
 375         /* now initialize adapter */
 376
 377         debug = 10;
 378         /* Clear interrupts */
 379         outb(IRST, CONTROL(bse));
 380
 381         debug = 11;
 382
 383         return debug;           /* 1 = ok */
 384 fail:
 385         return 0;               /* 0 = not ok */
 386 }
 387
 388 /* A quick wrapper for do_aha1542_intr_handle to grab the spin lock */
 389 static irqreturn_t do_aha1542_intr_handle(int dummy, void *dev_id)
 390 {
 391         unsigned long flags;
 392         struct Scsi_Host *shost = dev_id;
 393
 394         spin_lock_irqsave(shost->host_lock, flags);
 395         aha1542_intr_handle(shost);
 396         spin_unlock_irqrestore(shost->host_lock, flags);
 397         return IRQ_HANDLED;
 398 }
 399
 400 /* A "high" level interrupt handler */
 401 static void aha1542_intr_handle(struct Scsi_Host *shost)
 402 {
 403         void (*my_done) (Scsi_Cmnd *) = NULL;
 404         int errstatus, mbi, mbo, mbistatus;
 405         int number_serviced;
 406         unsigned long flags;
 407         Scsi_Cmnd *SCtmp;
 408         int flag;
 409         int needs_restart;
 410         struct mailbox *mb;
 411         struct ccb *ccb;
 412
 413         mb = HOSTDATA(shost)->mb;
 414         ccb = HOSTDATA(shost)->ccb;
 415
 416 #ifdef DEBUG
 417         {
 418                 flag = inb(INTRFLAGS(shost->io_port));
 419                 printk(KERN_DEBUG "aha1542_intr_handle: ");
 420                 if (!(flag & ANYINTR))
 421                         printk("no interrupt?");
 422                 if (flag & MBIF)
 423                         printk("MBIF ");
 424                 if (flag & MBOA)
 425                         printk("MBOF ");
 426                 if (flag & HACC)
 427                         printk("HACC ");
 428                 if (flag & SCRD)
 429                         printk("SCRD ");
 430                 printk("status %02x\n", inb(STATUS(shost->io_port)));
 431         };
 432 #endif
 433         number_serviced = 0;
 434         needs_restart = 0;
 435
 436         while (1 == 1) {
 437                 flag = inb(INTRFLAGS(shost->io_port));
 438
 439                 /* Check for unusual interrupts.  If any of these happen, we should
 440                    probably do something special, but for now just printing a message
 441                    is sufficient.  A SCSI reset detected is something that we really
 442                    need to deal with in some way. */
 443                 if (flag & ~MBIF) {
 444                         if (flag & MBOA)
 445                                 printk("MBOF ");
 446                         if (flag & HACC)
 447                                 printk("HACC ");
 448                         if (flag & SCRD) {
 449                                 needs_restart = 1;
 450                                 printk("SCRD ");
 451                         }
 452                 }
 453                 aha1542_intr_reset(shost->io_port);
 454
 455                 spin_lock_irqsave(&aha1542_lock, flags);
 456                 mbi = HOSTDATA(shost)->aha1542_last_mbi_used + 1;
 457                 if (mbi >= 2 * AHA1542_MAILBOXES)
 458                         mbi = AHA1542_MAILBOXES;
 459
 460                 do {
 461                         if (mb[mbi].status != 0)
 462                                 break;
 463                         mbi++;
 464                         if (mbi >= 2 * AHA1542_MAILBOXES)
 465                                 mbi = AHA1542_MAILBOXES;
 466                 } while (mbi != HOSTDATA(shost)->aha1542_last_mbi_used);
 467
 468                 if (mb[mbi].status == 0) {
 469                         spin_unlock_irqrestore(&aha1542_lock, flags);
 470                         /* Hmm, no mail.  Must have read it the last time around */
 471                         if (!number_serviced && !needs_restart)
 472                                 printk(KERN_WARNING "aha1542.c: interrupt received, but no mail.\n");
 473                         /* We detected a reset.  Restart all pending commands for
 474                            devices that use the hard reset option */
 475                         if (needs_restart)
 476                                 aha1542_restart(shost);
 477                         return;
 478                 };
 479
 480                 mbo = (scsi2int(mb[mbi].ccbptr) - (SCSI_BUF_PA(&ccb[0]))) / sizeof(struct ccb);
 481                 mbistatus = mb[mbi].status;
 482                 mb[mbi].status = 0;
 483                 HOSTDATA(shost)->aha1542_last_mbi_used = mbi;
 484                 spin_unlock_irqrestore(&aha1542_lock, flags);
 485
 486 #ifdef DEBUG
 487                 {
 488                         if (ccb[mbo].tarstat | ccb[mbo].hastat)
 489                                 printk(KERN_DEBUG "aha1542_command: returning %x (status %d)\n",
 490                                        ccb[mbo].tarstat + ((int) ccb[mbo].hastat << 16), mb[mbi].status);
 491                 };
 492 #endif
 493
 494                 if (mbistatus == 3)
 495                         continue;       /* Aborted command not found */
 496
 497 #ifdef DEBUG
 498                 printk(KERN_DEBUG "...done %d %d\n", mbo, mbi);
 499 #endif
 500
 501                 SCtmp = HOSTDATA(shost)->SCint[mbo];
 502
 503                 if (!SCtmp || !SCtmp->scsi_done) {
 504                         printk(KERN_WARNING "aha1542_intr_handle: Unexpected interrupt\n");
 505                         printk(KERN_WARNING "tarstat=%x, hastat=%x idlun=%x ccb#=%d \n", ccb[mbo].tarstat,
 506                                ccb[mbo].hastat, ccb[mbo].idlun, mbo);
 507                         return;
 508                 }
 509                 my_done = SCtmp->scsi_done;
 510                 kfree(SCtmp->host_scribble);
 511                 SCtmp->host_scribble = NULL;
 512                 /* Fetch the sense data, and tuck it away, in the required slot.  The
 513                    Adaptec automatically fetches it, and there is no guarantee that
 514                    we will still have it in the cdb when we come back */
 515                 if (ccb[mbo].tarstat == 2)
 516                         memcpy(SCtmp->sense_buffer, &ccb[mbo].cdb[ccb[mbo].cdblen],
 517                                SCSI_SENSE_BUFFERSIZE);
 518
 519
 520                 /* is there mail :-) */
 521
 522                 /* more error checking left out here */
 523                 if (mbistatus != 1)
 524                         /* This is surely wrong, but I don't know what's right */
 525                         errstatus = makecode(ccb[mbo].hastat, ccb[mbo].tarstat);
 526                 else
 527                         errstatus = 0;
 528
 529 #ifdef DEBUG
 530                 if (errstatus)
 531                         printk(KERN_DEBUG "(aha1542 error:%x %x %x) ", errstatus,
 532                                ccb[mbo].hastat, ccb[mbo].tarstat);
 533 #endif
 534
 535                 if (ccb[mbo].tarstat == 2) {
 536 #ifdef DEBUG
 537                         int i;
 538 #endif
 539                         DEB(printk("aha1542_intr_handle: sense:"));
 540 #ifdef DEBUG
 541                         for (i = 0; i < 12; i++)
 542                                 printk("%02x ", ccb[mbo].cdb[ccb[mbo].cdblen + i]);
 543                         printk("\n");
 544 #endif
 545                         /*
 546                            DEB(printk("aha1542_intr_handle: buf:"));
 547                            for (i = 0; i < bufflen; i++)
 548                            printk("%02x ", ((unchar *)buff)[i]);
 549                            printk("\n");
 550                          */
 551                 }
 552                 DEB(if (errstatus) printk("aha1542_intr_handle: returning %6x\n", errstatus));
 553                 SCtmp->result = errstatus;
 554                 HOSTDATA(shost)->SCint[mbo] = NULL;     /* This effectively frees up the mailbox slot, as
 555                                                            far as queuecommand is concerned */
 556                 my_done(SCtmp);
 557                 number_serviced++;
 558         };
 559 }
 560
 561 static int aha1542_queuecommand(Scsi_Cmnd * SCpnt, void (*done) (Scsi_Cmnd *))
 562 {
 563         unchar ahacmd = CMD_START_SCSI;
 564         unchar direction;
 565         unchar *cmd = (unchar *) SCpnt->cmnd;
 566         unchar target = SCpnt->device->id;
 567         unchar lun = SCpnt->device->lun;
 568         unsigned long flags;
 569         int bufflen = scsi_bufflen(SCpnt);
 570         int mbo;
 571         struct mailbox *mb;
 572         struct ccb *ccb;
 573
 574         DEB(int i);
 575
 576         mb = HOSTDATA(SCpnt->device->host)->mb;
 577         ccb = HOSTDATA(SCpnt->device->host)->ccb;
 578
 579         DEB(if (target > 1) {
 580             SCpnt->result = DID_TIME_OUT << 16;
 581             done(SCpnt); return 0;
 582             }
 583         );
 584
 585         if (*cmd == REQUEST_SENSE) {
 586                 /* Don't do the command - we have the sense data already */
 587                 SCpnt->result = 0;
 588                 done(SCpnt);
 589                 return 0;
 590         }
 591 #ifdef DEBUG
 592         if (*cmd == READ_10 || *cmd == WRITE_10)
 593                 i = xscsi2int(cmd + 2);
 594         else if (*cmd == READ_6 || *cmd == WRITE_6)
 595                 i = scsi2int(cmd + 2);
 596         else
 597                 i = -1;
 598         if (done)
 599                 printk(KERN_DEBUG "aha1542_queuecommand: dev %d cmd %02x pos %d len %d ", target, *cmd, i, bufflen);
 600         else
 601                 printk(KERN_DEBUG "aha1542_command: dev %d cmd %02x pos %d len %d ", target, *cmd, i, bufflen);
 602         aha1542_stat();
 603         printk(KERN_DEBUG "aha1542_queuecommand: dumping scsi cmd:");
 604         for (i = 0; i < SCpnt->cmd_len; i++)
 605                 printk("%02x ", cmd[i]);
 606         printk("\n");
 607         if (*cmd == WRITE_10 || *cmd == WRITE_6)
 608                 return 0;       /* we are still testing, so *don't* write */
 609 #endif
 610         /* Use the outgoing mailboxes in a round-robin fashion, because this
 611            is how the host adapter will scan for them */
 612
 613         spin_lock_irqsave(&aha1542_lock, flags);
 614         mbo = HOSTDATA(SCpnt->device->host)->aha1542_last_mbo_used + 1;
 615         if (mbo >= AHA1542_MAILBOXES)
 616                 mbo = 0;
 617
 618         do {
 619                 if (mb[mbo].status == 0 && HOSTDATA(SCpnt->device->host)->SCint[mbo] == NULL)
 620                         break;
 621                 mbo++;
 622                 if (mbo >= AHA1542_MAILBOXES)
 623                         mbo = 0;
 624         } while (mbo != HOSTDATA(SCpnt->device->host)->aha1542_last_mbo_used);
 625
 626         if (mb[mbo].status || HOSTDATA(SCpnt->device->host)->SCint[mbo])
 627                 panic("Unable to find empty mailbox for aha1542.\n");
 628
 629         HOSTDATA(SCpnt->device->host)->SCint[mbo] = SCpnt;      /* This will effectively prevent someone else from
 630                                                            screwing with this cdb. */
 631
 632         HOSTDATA(SCpnt->device->host)->aha1542_last_mbo_used = mbo;
 633         spin_unlock_irqrestore(&aha1542_lock, flags);
 634
 635 #ifdef DEBUG
 636         printk(KERN_DEBUG "Sending command (%d %x)...", mbo, done);
 637 #endif
 638
 639         any2scsi(mb[mbo].ccbptr, SCSI_BUF_PA(&ccb[mbo]));       /* This gets trashed for some reason */
 640
 641         memset(&ccb[mbo], 0, sizeof(struct ccb));
 642
 643         ccb[mbo].cdblen = SCpnt->cmd_len;
 644
 645         direction = 0;
 646         if (*cmd == READ_10 || *cmd == READ_6)
 647                 direction = 8;
 648         else if (*cmd == WRITE_10 || *cmd == WRITE_6)
 649                 direction = 16;
 650
 651         memcpy(ccb[mbo].cdb, cmd, ccb[mbo].cdblen);
 652
 653         if (bufflen) {
 654                 struct scatterlist *sg;
 655                 struct chain *cptr;
 656 #ifdef DEBUG
 657                 unsigned char *ptr;
 658 #endif
 659                 int i, sg_count = scsi_sg_count(SCpnt);
 660                 ccb[mbo].op = 2;        /* SCSI Initiator Command  w/scatter-gather */
 661                 SCpnt->host_scribble = kmalloc(sizeof(*cptr)*sg_count,
 662                                                          GFP_KERNEL | GFP_DMA);
 663                 cptr = (struct chain *) SCpnt->host_scribble;
 664                 if (cptr == NULL) {
 665                         /* free the claimed mailbox slot */
 666                         HOSTDATA(SCpnt->device->host)->SCint[mbo] = NULL;
 667                         return SCSI_MLQUEUE_HOST_BUSY;
 668                 }
 669                 scsi_for_each_sg(SCpnt, sg, sg_count, i) {
 670                         any2scsi(cptr[i].dataptr, SCSI_SG_PA(sg));
 671                         any2scsi(cptr[i].datalen, sg->length);
 672                 };
 673                 any2scsi(ccb[mbo].datalen, sg_count * sizeof(struct chain));
 674                 any2scsi(ccb[mbo].dataptr, SCSI_BUF_PA(cptr));
 675 #ifdef DEBUG
 676                 printk("cptr %x: ", cptr);
 677                 ptr = (unsigned char *) cptr;
 678                 for (i = 0; i < 18; i++)
 679                         printk("%02x ", ptr[i]);
 680 #endif
 681         } else {
 682                 ccb[mbo].op = 0;        /* SCSI Initiator Command */
 683                 SCpnt->host_scribble = NULL;
 684                 any2scsi(ccb[mbo].datalen, 0);
 685                 any2scsi(ccb[mbo].dataptr, 0);
 686         };
 687         ccb[mbo].idlun = (target & 7) << 5 | direction | (lun & 7);     /*SCSI Target Id */
 688         ccb[mbo].rsalen = 16;
 689         ccb[mbo].linkptr[0] = ccb[mbo].linkptr[1] = ccb[mbo].linkptr[2] = 0;
 690         ccb[mbo].commlinkid = 0;
 691
 692 #ifdef DEBUG
 693         {
 694                 int i;
 695                 printk(KERN_DEBUG "aha1542_command: sending.. ");
 696                 for (i = 0; i < sizeof(ccb[mbo]) - 10; i++)
 697                         printk("%02x ", ((unchar *) & ccb[mbo])[i]);
 698         };
 699 #endif
 700
 701         if (done) {
 702                 DEB(printk("aha1542_queuecommand: now waiting for interrupt ");
 703                     aha1542_stat());
 704                 SCpnt->scsi_done = done;
 705                 mb[mbo].status = 1;
 706                 aha1542_out(SCpnt->device->host->io_port, &ahacmd, 1);  /* start scsi command */
 707                 DEB(aha1542_stat());
 708         } else
 709                 printk("aha1542_queuecommand: done can't be NULL\n");
 710
 711         return 0;
 712 }
 713
 714 /* Initialize mailboxes */
 715 static void setup_mailboxes(int bse, struct Scsi_Host *shpnt)
 716 {
 717         int i;
 718         struct mailbox *mb;
 719         struct ccb *ccb;
 720
 721         unchar cmd[5] = { CMD_MBINIT, AHA1542_MAILBOXES, 0, 0, 0};
 722
 723         mb = HOSTDATA(shpnt)->mb;
 724         ccb = HOSTDATA(shpnt)->ccb;
 725
 726         for (i = 0; i < AHA1542_MAILBOXES; i++) {
 727                 mb[i].status = mb[AHA1542_MAILBOXES + i].status = 0;
 728                 any2scsi(mb[i].ccbptr, SCSI_BUF_PA(&ccb[i]));
 729         };
 730         aha1542_intr_reset(bse);        /* reset interrupts, so they don't block */
 731         any2scsi((cmd + 2), SCSI_BUF_PA(mb));
 732         aha1542_out(bse, cmd, 5);
 733         WAIT(INTRFLAGS(bse), INTRMASK, HACC, 0);
 734         while (0) {
 735 fail:
 736                 printk(KERN_ERR "aha1542_detect: failed setting up mailboxes\n");
 737         }
 738         aha1542_intr_reset(bse);
 739 }
 740
 741 static int __init aha1542_getconfig(int base_io, unsigned char *irq_level, unsigned char *dma_chan, unsigned char *scsi_id)
 742 {
 743         unchar inquiry_cmd[] = {CMD_RETCONF};
 744         unchar inquiry_result[3];
 745         int i;
 746         i = inb(STATUS(base_io));
 747         if (i & DF) {
 748                 i = inb(DATA(base_io));
 749         };
 750         aha1542_out(base_io, inquiry_cmd, 1);
 751         aha1542_in(base_io, inquiry_result, 3);
 752         WAIT(INTRFLAGS(base_io), INTRMASK, HACC, 0);
 753         while (0) {
 754 fail:
 755                 printk(KERN_ERR "aha1542_detect: query board settings\n");
 756         }
 757         aha1542_intr_reset(base_io);
 758         switch (inquiry_result[0]) {
 759         case 0x80:
 760                 *dma_chan = 7;
 761                 break;
 762         case 0x40:
 763                 *dma_chan = 6;
 764                 break;
 765         case 0x20:
 766                 *dma_chan = 5;
 767                 break;
 768         case 0x01:
 769                 *dma_chan = 0;
 770                 break;
 771         case 0:
 772                 /* This means that the adapter, although Adaptec 1542 compatible, doesn't use a DMA channel.
 773                    Currently only aware of the BusLogic BT-445S VL-Bus adapter which needs this. */
 774                 *dma_chan = 0xFF;
 775                 break;
 776         default:
 777                 printk(KERN_ERR "Unable to determine Adaptec DMA priority.  Disabling board\n");
 778                 return -1;
 779         };
 780         switch (inquiry_result[1]) {
 781         case 0x40:
 782                 *irq_level = 15;
 783                 break;
 784         case 0x20:
 785                 *irq_level = 14;
 786                 break;
 787         case 0x8:
 788                 *irq_level = 12;
 789                 break;
 790         case 0x4:
 791                 *irq_level = 11;
 792                 break;
 793         case 0x2:
 794                 *irq_level = 10;
 795                 break;
 796         case 0x1:
 797                 *irq_level = 9;
 798                 break;
 799         default:
 800                 printk(KERN_ERR "Unable to determine Adaptec IRQ level.  Disabling board\n");
 801                 return -1;
 802         };
 803         *scsi_id = inquiry_result[2] & 7;
 804         return 0;
 805 }
 806
 807 /* This function should only be called for 1542C boards - we can detect
 808    the special firmware settings and unlock the board */
 809
 810 static int __init aha1542_mbenable(int base)
 811 {
 812         static unchar mbenable_cmd[3];
 813         static unchar mbenable_result[2];
 814         int retval;
 815
 816         retval = BIOS_TRANSLATION_6432;
 817
 818         mbenable_cmd[0] = CMD_EXTBIOS;
 819         aha1542_out(base, mbenable_cmd, 1);
 820         if (aha1542_in1(base, mbenable_result, 2))
 821                 return retval;
 822         WAITd(INTRFLAGS(base), INTRMASK, HACC, 0, 100);
 823         aha1542_intr_reset(base);
 824
 825         if ((mbenable_result[0] & 0x08) || mbenable_result[1]) {
 826                 mbenable_cmd[0] = CMD_MBENABLE;
 827                 mbenable_cmd[1] = 0;
 828                 mbenable_cmd[2] = mbenable_result[1];
 829
 830                 if ((mbenable_result[0] & 0x08) && (mbenable_result[1] & 0x03))
 831                         retval = BIOS_TRANSLATION_25563;
 832
 833                 aha1542_out(base, mbenable_cmd, 3);
 834                 WAIT(INTRFLAGS(base), INTRMASK, HACC, 0);
 835         };
 836         while (0) {
 837 fail:
 838                 printk(KERN_ERR "aha1542_mbenable: Mailbox init failed\n");
 839         }
 840         aha1542_intr_reset(base);
 841         return retval;
 842 }
 843
 844 /* Query the board to find out if it is a 1542 or a 1740, or whatever. */
 845 static int __init aha1542_query(int base_io, int *transl)
 846 {
 847         unchar inquiry_cmd[] = {CMD_INQUIRY};
 848         unchar inquiry_result[4];
 849         int i;
 850         i = inb(STATUS(base_io));
 851         if (i & DF) {
 852                 i = inb(DATA(base_io));
 853         };
 854         aha1542_out(base_io, inquiry_cmd, 1);
 855         aha1542_in(base_io, inquiry_result, 4);
 856         WAIT(INTRFLAGS(base_io), INTRMASK, HACC, 0);
 857         while (0) {
 858 fail:
 859                 printk(KERN_ERR "aha1542_detect: query card type\n");
 860         }
 861         aha1542_intr_reset(base_io);
 862
 863         *transl = BIOS_TRANSLATION_6432;        /* Default case */
 864
 865         /* For an AHA1740 series board, we ignore the board since there is a
 866            hardware bug which can lead to wrong blocks being returned if the board
 867            is operating in the 1542 emulation mode.  Since there is an extended mode
 868            driver, we simply ignore the board and let the 1740 driver pick it up.
 869          */
 870
 871         if (inquiry_result[0] == 0x43) {
 872                 printk(KERN_INFO "aha1542.c: Emulation mode not supported for AHA 174N hardware.\n");
 873                 return 1;
 874         };
 875
 876         /* Always call this - boards that do not support extended bios translation
 877            will ignore the command, and we will set the proper default */
 878
 879         *transl = aha1542_mbenable(base_io);
 880
 881         return 0;
 882 }
 883
 884 #ifndef MODULE
 885 static char *setup_str[MAXBOARDS] __initdata;
 886 static int setup_idx = 0;
 887
 888 static void __init aha1542_setup(char *str, int *ints)
 889 {
 890         const char *ahausage = "aha1542: usage: aha1542=<PORTBASE>[,<BUSON>,<BUSOFF>[,<DMASPEED>]]\n";
 891         int setup_portbase;
 892
 893         if (setup_idx >= MAXBOARDS) {
 894                 printk(KERN_ERR "aha1542: aha1542_setup called too many times! Bad LILO params ?\n");
 895                 printk(KERN_ERR "   Entryline 1: %s\n", setup_str[0]);
 896                 printk(KERN_ERR "   Entryline 2: %s\n", setup_str[1]);
 897                 printk(KERN_ERR "   This line:   %s\n", str);
 898                 return;
 899         }
 900         if (ints[0] < 1 || ints[0] > 4) {
 901                 printk(KERN_ERR "aha1542: %s\n", str);
 902                 printk(ahausage);
 903                 printk(KERN_ERR "aha1542: Wrong parameters may cause system malfunction.. We try anyway..\n");
 904         }
 905         setup_called[setup_idx] = ints[0];
 906         setup_str[setup_idx] = str;
 907
 908         setup_portbase = ints[0] >= 1 ? ints[1] : 0;    /* Preserve the default value.. */
 909         setup_buson[setup_idx] = ints[0] >= 2 ? ints[2] : 7;
 910         setup_busoff[setup_idx] = ints[0] >= 3 ? ints[3] : 5;
 911         if (ints[0] >= 4)
 912         {
 913                 int atbt = -1;
 914                 switch (ints[4]) {
 915                 case 5:
 916                         atbt = 0x00;
 917                         break;
 918                 case 6:
 919                         atbt = 0x04;
 920                         break;
 921                 case 7:
 922                         atbt = 0x01;
 923                         break;
 924                 case 8:
 925                         atbt = 0x02;
 926                         break;
 927                 case 10:
 928                         atbt = 0x03;
 929                         break;
 930                 default:
 931                         printk(KERN_ERR "aha1542: %s\n", str);
 932                         printk(ahausage);
 933                         printk(KERN_ERR "aha1542: Valid values for DMASPEED are 5-8, 10 MB/s.  Using jumper defaults.\n");
 934                         break;
 935                 }
 936                 setup_dmaspeed[setup_idx] = atbt;
 937         }
 938         if (setup_portbase != 0)
 939                 bases[setup_idx] = setup_portbase;
 940
 941         ++setup_idx;
 942 }
 943
 944 static int __init do_setup(char *str)
 945 {
 946         int ints[5];
 947
 948         int count=setup_idx;
 949
 950         get_options(str, ARRAY_SIZE(ints), ints);
 951         aha1542_setup(str,ints);
 952
 953         return count<setup_idx;
 954 }
 955
 956 __setup("aha1542=",do_setup);
 957 #endif
 958
 959 /* return non-zero on detection */
 960 static int __init aha1542_detect(struct scsi_host_template * tpnt)
 961 {
 962         unsigned char dma_chan;
 963         unsigned char irq_level;
 964         unsigned char scsi_id;
 965         unsigned long flags;
 966         unsigned int base_io;
 967         int trans;
 968         struct Scsi_Host *shpnt = NULL;
 969         int count = 0;
 970         int indx;
 971
 972         DEB(printk("aha1542_detect: \n"));
 973
 974         tpnt->proc_name = "aha1542";
 975
 976 #ifdef MODULE
 977         bases[0] = aha1542[0];
 978         setup_buson[0] = aha1542[1];
 979         setup_busoff[0] = aha1542[2];
 980         {
 981                 int atbt = -1;
 982                 switch (aha1542[3]) {
 983                 case 5:
 984                         atbt = 0x00;
 985                         break;
 986                 case 6:
 987                         atbt = 0x04;
 988                         break;
 989                 case 7:
 990                         atbt = 0x01;
 991                         break;
 992                 case 8:
 993                         atbt = 0x02;
 994                         break;
 995                 case 10:
 996                         atbt = 0x03;
 997                         break;
 998                 };
 999                 setup_dmaspeed[0] = atbt;
1000         }
1001 #endif
1002
1003         /*
1004          *      Find MicroChannel cards (AHA1640)
1005          */
1006 #ifdef CONFIG_MCA_LEGACY
1007         if(MCA_bus) {
1008                 int slot = 0;
1009                 int pos = 0;
1010
1011                 for (indx = 0; (slot != MCA_NOTFOUND) && (indx < ARRAY_SIZE(bases)); indx++) {
1012
1013                         if (bases[indx])
1014                                 continue;
1015
1016                         /* Detect only AHA-1640 cards -- MCA ID 0F1F */
1017                         slot = mca_find_unused_adapter(0x0f1f, slot);
1018                         if (slot == MCA_NOTFOUND)
1019                                 break;
1020
1021                         /* Found one */
1022                         pos = mca_read_stored_pos(slot, 3);
1023
1024                         /* Decode address */
1025                         if (pos & 0x80) {
1026                                 if (pos & 0x02) {
1027                                         if (pos & 0x01)
1028                                                 bases[indx] = 0x334;
1029                                         else
1030                                                 bases[indx] = 0x234;
1031                                 } else {
1032                                         if (pos & 0x01)
1033                                                 bases[indx] = 0x134;
1034                                 }
1035                         } else {
1036                                 if (pos & 0x02) {
1037                                         if (pos & 0x01)
1038                                                 bases[indx] = 0x330;
1039                                         else
1040                                                 bases[indx] = 0x230;
1041                                 } else {
1042                                         if (pos & 0x01)
1043                                                 bases[indx] = 0x130;
1044                                 }
1045                         }
1046
1047                         /* No need to decode IRQ and Arb level -- those are
1048                          * read off the card later.
1049                          */
1050                         printk(KERN_INFO "Found an AHA-1640 in MCA slot %d, I/O 0x%04x\n", slot, bases[indx]);
1051
1052                         mca_set_adapter_name(slot, "Adapter AHA-1640");
1053                         mca_set_adapter_procfn(slot, NULL, NULL);
1054                         mca_mark_as_used(slot);
1055
1056                         /* Go on */
1057                         slot++;
1058                 }
1059
1060         }
1061 #endif
1062
1063         /*
1064          *      Hunt for ISA Plug'n'Pray Adaptecs (AHA1535)
1065          */
1066
1067         if(isapnp)
1068         {
1069                 struct pnp_dev *pdev = NULL;
1070                 for(indx = 0; indx < ARRAY_SIZE(bases); indx++) {
1071                         if(bases[indx])
1072                                 continue;
1073                         pdev = pnp_find_dev(NULL, ISAPNP_VENDOR('A', 'D', 'P'),
1074                                 ISAPNP_FUNCTION(0x1542), pdev);
1075                         if(pdev==NULL)
1076                                 break;
1077                         /*
1078                          *      Activate the PnP card
1079                          */
1080
1081                         if(pnp_device_attach(pdev)<0)
1082                                 continue;
1083
1084                         if(pnp_activate_dev(pdev)<0) {
1085                                 pnp_device_detach(pdev);
1086                                 continue;
1087                         }
1088
1089                         if(!pnp_port_valid(pdev, 0)) {
1090                                 pnp_device_detach(pdev);
1091                                 continue;
1092                         }
1093
1094                         bases[indx] = pnp_port_start(pdev, 0);
1095
1096                         /* The card can be queried for its DMA, we have
1097                            the DMA set up that is enough */
1098
1099                         printk(KERN_INFO "ISAPnP found an AHA1535 at I/O 0x%03X\n", bases[indx]);
1100                 }
1101         }
1102         for (indx = 0; indx < ARRAY_SIZE(bases); indx++)
1103                 if (bases[indx] != 0 && request_region(bases[indx], 4, "aha1542")) {
1104                         shpnt = scsi_register(tpnt,
1105                                         sizeof(struct aha1542_hostdata));
1106
1107                         if(shpnt==NULL) {
1108                                 release_region(bases[indx], 4);
1109                                 continue;
1110                         }
1111                         if (!aha1542_test_port(bases[indx], shpnt))
1112                                 goto unregister;
1113
1114                         base_io = bases[indx];
1115
1116                         /* Set the Bus on/off-times as not to ruin floppy performance */
1117                         {
1118                                 unchar oncmd[] = {CMD_BUSON_TIME, 7};
1119                                 unchar offcmd[] = {CMD_BUSOFF_TIME, 5};
1120
1121                                 if (setup_called[indx]) {
1122                                         oncmd[1] = setup_buson[indx];
1123                                         offcmd[1] = setup_busoff[indx];
1124                                 }
1125                                 aha1542_intr_reset(base_io);
1126                                 aha1542_out(base_io, oncmd, 2);
1127                                 WAIT(INTRFLAGS(base_io), INTRMASK, HACC, 0);
1128                                 aha1542_intr_reset(base_io);
1129                                 aha1542_out(base_io, offcmd, 2);
1130                                 WAIT(INTRFLAGS(base_io), INTRMASK, HACC, 0);
1131                                 if (setup_dmaspeed[indx] >= 0) {
1132                                         unchar dmacmd[] = {CMD_DMASPEED, 0};
1133                                         dmacmd[1] = setup_dmaspeed[indx];
1134                                         aha1542_intr_reset(base_io);
1135                                         aha1542_out(base_io, dmacmd, 2);
1136                                         WAIT(INTRFLAGS(base_io), INTRMASK, HACC, 0);
1137                                 }
1138                                 while (0) {
1139 fail:
1140                                         printk(KERN_ERR "aha1542_detect: setting bus on/off-time failed\n");
1141                                 }
1142                                 aha1542_intr_reset(base_io);
1143                         }
1144                         if (aha1542_query(base_io, &trans))
1145                                 goto unregister;
1146
1147                         if (aha1542_getconfig(base_io, &irq_level, &dma_chan, &scsi_id) == -1)
1148                                 goto unregister;
1149
1150                         printk(KERN_INFO "Configuring Adaptec (SCSI-ID %d) at IO:%x, IRQ %d", scsi_id, base_io, irq_level);
1151                         if (dma_chan != 0xFF)
1152                                 printk(", DMA priority %d", dma_chan);
1153                         printk("\n");
1154
1155                         DEB(aha1542_stat());
1156                         setup_mailboxes(base_io, shpnt);
1157
1158                         DEB(aha1542_stat());
1159
1160                         DEB(printk("aha1542_detect: enable interrupt channel %d\n", irq_level));
1161                         spin_lock_irqsave(&aha1542_lock, flags);
1162                         if (request_irq(irq_level, do_aha1542_intr_handle, 0,
1163                                         "aha1542", shpnt)) {
1164                                 printk(KERN_ERR "Unable to allocate IRQ for adaptec controller.\n");
1165                                 spin_unlock_irqrestore(&aha1542_lock, flags);
1166                                 goto unregister;
1167                         }
1168                         if (dma_chan != 0xFF) {
1169                                 if (request_dma(dma_chan, "aha1542")) {
1170                                         printk(KERN_ERR "Unable to allocate DMA channel for Adaptec.\n");
1171                                         free_irq(irq_level, shpnt);
1172                                         spin_unlock_irqrestore(&aha1542_lock, flags);
1173                                         goto unregister;
1174                                 }
1175                                 if (dma_chan == 0 || dma_chan >= 5) {
1176                                         set_dma_mode(dma_chan, DMA_MODE_CASCADE);
1177                                         enable_dma(dma_chan);
1178                                 }
1179                         }
1180
1181                         shpnt->this_id = scsi_id;
1182                         shpnt->unique_id = base_io;
1183                         shpnt->io_port = base_io;
1184                         shpnt->n_io_port = 4;   /* Number of bytes of I/O space used */
1185                         shpnt->dma_channel = dma_chan;
1186                         shpnt->irq = irq_level;
1187                         HOSTDATA(shpnt)->bios_translation = trans;
1188                         if (trans == BIOS_TRANSLATION_25563)
1189                                 printk(KERN_INFO "aha1542.c: Using extended bios translation\n");
1190                         HOSTDATA(shpnt)->aha1542_last_mbi_used = (2 * AHA1542_MAILBOXES - 1);
1191                         HOSTDATA(shpnt)->aha1542_last_mbo_used = (AHA1542_MAILBOXES - 1);
1192                         memset(HOSTDATA(shpnt)->SCint, 0, sizeof(HOSTDATA(shpnt)->SCint));
1193                         spin_unlock_irqrestore(&aha1542_lock, flags);
1194                         count++;
1195                         continue;
1196 unregister:
1197                         release_region(bases[indx], 4);
1198                         scsi_unregister(shpnt);
1199                         continue;
1200
1201                 };
1202
1203         return count;
1204 }
1205
1206 static int aha1542_release(struct Scsi_Host *shost)
1207 {
1208         if (shost->irq)
1209                 free_irq(shost->irq, shost);
1210         if (shost->dma_channel != 0xff)
1211                 free_dma(shost->dma_channel);
1212         if (shost->io_port && shost->n_io_port)
1213                 release_region(shost->io_port, shost->n_io_port);
1214         scsi_unregister(shost);
1215         return 0;
1216 }
1217
1218 static int aha1542_restart(struct Scsi_Host *shost)
1219 {
1220         int i;
1221         int count = 0;
1222
1223         for (i = 0; i < AHA1542_MAILBOXES; i++)
1224                 if (HOSTDATA(shost)->SCint[i] &&
1225                     !(HOSTDATA(shost)->SCint[i]->device->soft_reset)) {
1226                         count++;
1227                 }
1228         printk(KERN_DEBUG "Potential to restart %d stalled commands...\n", count);
1229         return 0;
1230 }
1231
1232 /*
1233  * This is a device reset.  This is handled by sending a special command
1234  * to the device.
1235  */
1236 static int aha1542_dev_reset(Scsi_Cmnd * SCpnt)
1237 {
1238         unsigned long flags;
1239         struct mailbox *mb;
1240         unchar target = SCpnt->device->id;
1241         unchar lun = SCpnt->device->lun;
1242         int mbo;
1243         struct ccb *ccb;
1244         unchar ahacmd = CMD_START_SCSI;
1245
1246         ccb = HOSTDATA(SCpnt->device->host)->ccb;
1247         mb = HOSTDATA(SCpnt->device->host)->mb;
1248
1249         spin_lock_irqsave(&aha1542_lock, flags);
1250         mbo = HOSTDATA(SCpnt->device->host)->aha1542_last_mbo_used + 1;
1251         if (mbo >= AHA1542_MAILBOXES)
1252                 mbo = 0;
1253
1254         do {
1255                 if (mb[mbo].status == 0 && HOSTDATA(SCpnt->device->host)->SCint[mbo] == NULL)
1256                         break;
1257                 mbo++;
1258                 if (mbo >= AHA1542_MAILBOXES)
1259                         mbo = 0;
1260         } while (mbo != HOSTDATA(SCpnt->device->host)->aha1542_last_mbo_used);
1261
1262         if (mb[mbo].status || HOSTDATA(SCpnt->device->host)->SCint[mbo])
1263                 panic("Unable to find empty mailbox for aha1542.\n");
1264
1265         HOSTDATA(SCpnt->device->host)->SCint[mbo] = SCpnt;      /* This will effectively
1266                                                            prevent someone else from
1267                                                            screwing with this cdb. */
1268
1269         HOSTDATA(SCpnt->device->host)->aha1542_last_mbo_used = mbo;
1270         spin_unlock_irqrestore(&aha1542_lock, flags);
1271
1272         any2scsi(mb[mbo].ccbptr, SCSI_BUF_PA(&ccb[mbo]));       /* This gets trashed for some reason */
1273
1274         memset(&ccb[mbo], 0, sizeof(struct ccb));
1275
1276         ccb[mbo].op = 0x81;     /* BUS DEVICE RESET */
1277
1278         ccb[mbo].idlun = (target & 7) << 5 | (lun & 7);         /*SCSI Target Id */
1279
1280         ccb[mbo].linkptr[0] = ccb[mbo].linkptr[1] = ccb[mbo].linkptr[2] = 0;
1281         ccb[mbo].commlinkid = 0;
1282
1283         /*
1284          * Now tell the 1542 to flush all pending commands for this
1285          * target
1286          */
1287         aha1542_out(SCpnt->device->host->io_port, &ahacmd, 1);
1288
1289         scmd_printk(KERN_WARNING, SCpnt,
1290                 "Trying device reset for target\n");
1291
1292         return SUCCESS;
1293
1294
1295 #ifdef ERIC_neverdef
1296         /*
1297          * With the 1542 we apparently never get an interrupt to
1298          * acknowledge a device reset being sent.  Then again, Leonard
1299          * says we are doing this wrong in the first place...
1300          *
1301          * Take a wait and see attitude.  If we get spurious interrupts,
1302          * then the device reset is doing something sane and useful, and
1303          * we will wait for the interrupt to post completion.
1304          */
1305         printk(KERN_WARNING "Sent BUS DEVICE RESET to target %d\n", SCpnt->target);
1306
1307         /*
1308          * Free the command block for all commands running on this
1309          * target...
1310          */
1311         for (i = 0; i < AHA1542_MAILBOXES; i++) {
1312                 if (HOSTDATA(SCpnt->host)->SCint[i] &&
1313                     HOSTDATA(SCpnt->host)->SCint[i]->target == SCpnt->target) {
1314                         Scsi_Cmnd *SCtmp;
1315                         SCtmp = HOSTDATA(SCpnt->host)->SCint[i];
1316                         kfree(SCtmp->host_scribble);
1317                         SCtmp->host_scribble = NULL;
1318                         HOSTDATA(SCpnt->host)->SCint[i] = NULL;
1319                         HOSTDATA(SCpnt->host)->mb[i].status = 0;
1320                 }
1321         }
1322         return SUCCESS;
1323
1324         return FAILED;
1325 #endif                          /* ERIC_neverdef */
1326 }
1327
1328 static int aha1542_bus_reset(Scsi_Cmnd * SCpnt)
1329 {
1330         int i;
1331
1332         /*
1333          * This does a scsi reset for all devices on the bus.
1334          * In principle, we could also reset the 1542 - should
1335          * we do this?  Try this first, and we can add that later
1336          * if it turns out to be useful.
1337          */
1338         outb(SCRST, CONTROL(SCpnt->device->host->io_port));
1339
1340         /*
1341          * Wait for the thing to settle down a bit.  Unfortunately
1342          * this is going to basically lock up the machine while we
1343          * wait for this to complete.  To be 100% correct, we need to
1344          * check for timeout, and if we are doing something like this
1345          * we are pretty desperate anyways.
1346          */
1347         ssleep(4);
1348
1349         spin_lock_irq(SCpnt->device->host->host_lock);
1350
1351         WAIT(STATUS(SCpnt->device->host->io_port),
1352              STATMASK, INIT | IDLE, STST | DIAGF | INVDCMD | DF | CDF);
1353
1354         /*
1355          * Now try to pick up the pieces.  For all pending commands,
1356          * free any internal data structures, and basically clear things
1357          * out.  We do not try and restart any commands or anything -
1358          * the strategy handler takes care of that crap.
1359          */
1360         printk(KERN_WARNING "Sent BUS RESET to scsi host %d\n", SCpnt->device->host->host_no);
1361
1362         for (i = 0; i < AHA1542_MAILBOXES; i++) {
1363                 if (HOSTDATA(SCpnt->device->host)->SCint[i] != NULL) {
1364                         Scsi_Cmnd *SCtmp;
1365                         SCtmp = HOSTDATA(SCpnt->device->host)->SCint[i];
1366
1367
1368                         if (SCtmp->device->soft_reset) {
1369                                 /*
1370                                  * If this device implements the soft reset option,
1371                                  * then it is still holding onto the command, and
1372                                  * may yet complete it.  In this case, we don't
1373                                  * flush the data.
1374                                  */
1375                                 continue;
1376                         }
1377                         kfree(SCtmp->host_scribble);
1378                         SCtmp->host_scribble = NULL;
1379                         HOSTDATA(SCpnt->device->host)->SCint[i] = NULL;
1380                         HOSTDATA(SCpnt->device->host)->mb[i].status = 0;
1381                 }
1382         }
1383
1384         spin_unlock_irq(SCpnt->device->host->host_lock);
1385         return SUCCESS;
1386
1387 fail:
1388         spin_unlock_irq(SCpnt->device->host->host_lock);
1389         return FAILED;
1390 }
1391
1392 static int aha1542_host_reset(Scsi_Cmnd * SCpnt)
1393 {
1394         int i;
1395
1396         /*
1397          * This does a scsi reset for all devices on the bus.
1398          * In principle, we could also reset the 1542 - should
1399          * we do this?  Try this first, and we can add that later
1400          * if it turns out to be useful.
1401          */
1402         outb(HRST | SCRST, CONTROL(SCpnt->device->host->io_port));
1403
1404         /*
1405          * Wait for the thing to settle down a bit.  Unfortunately
1406          * this is going to basically lock up the machine while we
1407          * wait for this to complete.  To be 100% correct, we need to
1408          * check for timeout, and if we are doing something like this
1409          * we are pretty desperate anyways.
1410          */
1411         ssleep(4);
1412         spin_lock_irq(SCpnt->device->host->host_lock);
1413
1414         WAIT(STATUS(SCpnt->device->host->io_port),
1415              STATMASK, INIT | IDLE, STST | DIAGF | INVDCMD | DF | CDF);
1416
1417         /*
1418          * We need to do this too before the 1542 can interact with
1419          * us again.
1420          */
1421         setup_mailboxes(SCpnt->device->host->io_port, SCpnt->device->host);
1422
1423         /*
1424          * Now try to pick up the pieces.  For all pending commands,
1425          * free any internal data structures, and basically clear things
1426          * out.  We do not try and restart any commands or anything -
1427          * the strategy handler takes care of that crap.
1428          */
1429         printk(KERN_WARNING "Sent BUS RESET to scsi host %d\n", SCpnt->device->host->host_no);
1430
1431         for (i = 0; i < AHA1542_MAILBOXES; i++) {
1432                 if (HOSTDATA(SCpnt->device->host)->SCint[i] != NULL) {
1433                         Scsi_Cmnd *SCtmp;
1434                         SCtmp = HOSTDATA(SCpnt->device->host)->SCint[i];
1435
1436                         if (SCtmp->device->soft_reset) {
1437                                 /*
1438                                  * If this device implements the soft reset option,
1439                                  * then it is still holding onto the command, and
1440                                  * may yet complete it.  In this case, we don't
1441                                  * flush the data.
1442                                  */
1443                                 continue;
1444                         }
1445                         kfree(SCtmp->host_scribble);
1446                         SCtmp->host_scribble = NULL;
1447                         HOSTDATA(SCpnt->device->host)->SCint[i] = NULL;
1448                         HOSTDATA(SCpnt->device->host)->mb[i].status = 0;
1449                 }
1450         }
1451
1452         spin_unlock_irq(SCpnt->device->host->host_lock);
1453         return SUCCESS;
1454
1455 fail:
1456         spin_unlock_irq(SCpnt->device->host->host_lock);
1457         return FAILED;
1458 }
1459
1460
1461 static int aha1542_biosparam(struct scsi_device *sdev,
1462                 struct block_device *bdev, sector_t capacity, int *ip)
1463 {
1464         int translation_algorithm;
1465         int size = capacity;
1466
1467         translation_algorithm = HOSTDATA(sdev->host)->bios_translation;
1468
1469         if ((size >> 11) > 1024 && translation_algorithm == BIOS_TRANSLATION_25563) {
1470                 /* Please verify that this is the same as what DOS returns */
1471                 ip[0] = 255;
1472                 ip[1] = 63;
1473                 ip[2] = size / 255 / 63;
1474         } else {
1475                 ip[0] = 64;
1476                 ip[1] = 32;
1477                 ip[2] = size >> 11;
1478         }
1479
1480         return 0;
1481 }
1482 MODULE_LICENSE("GPL");
1483
1484
1485 static struct scsi_host_template driver_template = {
1486         .proc_name              = "aha1542",
1487         .name                   = "Adaptec 1542",
1488         .detect                 = aha1542_detect,
1489         .release                = aha1542_release,
1490         .queuecommand           = aha1542_queuecommand,
1491         .eh_device_reset_handler= aha1542_dev_reset,
1492         .eh_bus_reset_handler   = aha1542_bus_reset,
1493         .eh_host_reset_handler  = aha1542_host_reset,
1494         .bios_param             = aha1542_biosparam,
1495         .can_queue              = AHA1542_MAILBOXES,
1496         .this_id                = 7,
1497         .sg_tablesize           = AHA1542_SCATTER,
1498         .cmd_per_lun            = AHA1542_CMDLUN,
1499         .unchecked_isa_dma      = 1,
1500         .use_clustering         = ENABLE_CLUSTERING,
1501 };
1502 #include "scsi_module.c"