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 #if 0
 588                 /* scsi_request_sense() provides a buffer of size 256,
 589                    so there is no reason to expect equality */
 590                 if (bufflen != SCSI_SENSE_BUFFERSIZE)
 591                         printk(KERN_CRIT "aha1542: Wrong buffer length supplied "
 592                                "for request sense (%d)\n", bufflen);
 593 #endif
 594                 SCpnt->result = 0;
 595                 done(SCpnt);
 596                 return 0;
 597         }
 598 #ifdef DEBUG
 599         if (*cmd == READ_10 || *cmd == WRITE_10)
 600                 i = xscsi2int(cmd + 2);
 601         else if (*cmd == READ_6 || *cmd == WRITE_6)
 602                 i = scsi2int(cmd + 2);
 603         else
 604                 i = -1;
 605         if (done)
 606                 printk(KERN_DEBUG "aha1542_queuecommand: dev %d cmd %02x pos %d len %d ", target, *cmd, i, bufflen);
 607         else
 608                 printk(KERN_DEBUG "aha1542_command: dev %d cmd %02x pos %d len %d ", target, *cmd, i, bufflen);
 609         aha1542_stat();
 610         printk(KERN_DEBUG "aha1542_queuecommand: dumping scsi cmd:");
 611         for (i = 0; i < SCpnt->cmd_len; i++)
 612                 printk("%02x ", cmd[i]);
 613         printk("\n");
 614         if (*cmd == WRITE_10 || *cmd == WRITE_6)
 615                 return 0;       /* we are still testing, so *don't* write */
 616 #endif
 617         /* Use the outgoing mailboxes in a round-robin fashion, because this
 618            is how the host adapter will scan for them */
 619
 620         spin_lock_irqsave(&aha1542_lock, flags);
 621         mbo = HOSTDATA(SCpnt->device->host)->aha1542_last_mbo_used + 1;
 622         if (mbo >= AHA1542_MAILBOXES)
 623                 mbo = 0;
 624
 625         do {
 626                 if (mb[mbo].status == 0 && HOSTDATA(SCpnt->device->host)->SCint[mbo] == NULL)
 627                         break;
 628                 mbo++;
 629                 if (mbo >= AHA1542_MAILBOXES)
 630                         mbo = 0;
 631         } while (mbo != HOSTDATA(SCpnt->device->host)->aha1542_last_mbo_used);
 632
 633         if (mb[mbo].status || HOSTDATA(SCpnt->device->host)->SCint[mbo])
 634                 panic("Unable to find empty mailbox for aha1542.\n");
 635
 636         HOSTDATA(SCpnt->device->host)->SCint[mbo] = SCpnt;      /* This will effectively prevent someone else from
 637                                                            screwing with this cdb. */
 638
 639         HOSTDATA(SCpnt->device->host)->aha1542_last_mbo_used = mbo;
 640         spin_unlock_irqrestore(&aha1542_lock, flags);
 641
 642 #ifdef DEBUG
 643         printk(KERN_DEBUG "Sending command (%d %x)...", mbo, done);
 644 #endif
 645
 646         any2scsi(mb[mbo].ccbptr, SCSI_BUF_PA(&ccb[mbo]));       /* This gets trashed for some reason */
 647
 648         memset(&ccb[mbo], 0, sizeof(struct ccb));
 649
 650         ccb[mbo].cdblen = SCpnt->cmd_len;
 651
 652         direction = 0;
 653         if (*cmd == READ_10 || *cmd == READ_6)
 654                 direction = 8;
 655         else if (*cmd == WRITE_10 || *cmd == WRITE_6)
 656                 direction = 16;
 657
 658         memcpy(ccb[mbo].cdb, cmd, ccb[mbo].cdblen);
 659
 660         if (bufflen) {
 661                 struct scatterlist *sg;
 662                 struct chain *cptr;
 663 #ifdef DEBUG
 664                 unsigned char *ptr;
 665 #endif
 666                 int i, sg_count = scsi_sg_count(SCpnt);
 667                 ccb[mbo].op = 2;        /* SCSI Initiator Command  w/scatter-gather */
 668                 SCpnt->host_scribble = kmalloc(sizeof(*cptr)*sg_count,
 669                                                          GFP_KERNEL | GFP_DMA);
 670                 cptr = (struct chain *) SCpnt->host_scribble;
 671                 if (cptr == NULL) {
 672                         /* free the claimed mailbox slot */
 673                         HOSTDATA(SCpnt->device->host)->SCint[mbo] = NULL;
 674                         return SCSI_MLQUEUE_HOST_BUSY;
 675                 }
 676                 scsi_for_each_sg(SCpnt, sg, sg_count, i) {
 677                         any2scsi(cptr[i].dataptr, SCSI_SG_PA(sg));
 678                         any2scsi(cptr[i].datalen, sg->length);
 679                 };
 680                 any2scsi(ccb[mbo].datalen, sg_count * sizeof(struct chain));
 681                 any2scsi(ccb[mbo].dataptr, SCSI_BUF_PA(cptr));
 682 #ifdef DEBUG
 683                 printk("cptr %x: ", cptr);
 684                 ptr = (unsigned char *) cptr;
 685                 for (i = 0; i < 18; i++)
 686                         printk("%02x ", ptr[i]);
 687 #endif
 688         } else {
 689                 ccb[mbo].op = 0;        /* SCSI Initiator Command */
 690                 SCpnt->host_scribble = NULL;
 691                 any2scsi(ccb[mbo].datalen, 0);
 692                 any2scsi(ccb[mbo].dataptr, 0);
 693         };
 694         ccb[mbo].idlun = (target & 7) << 5 | direction | (lun & 7);     /*SCSI Target Id */
 695         ccb[mbo].rsalen = 16;
 696         ccb[mbo].linkptr[0] = ccb[mbo].linkptr[1] = ccb[mbo].linkptr[2] = 0;
 697         ccb[mbo].commlinkid = 0;
 698
 699 #ifdef DEBUG
 700         {
 701                 int i;
 702                 printk(KERN_DEBUG "aha1542_command: sending.. ");
 703                 for (i = 0; i < sizeof(ccb[mbo]) - 10; i++)
 704                         printk("%02x ", ((unchar *) & ccb[mbo])[i]);
 705         };
 706 #endif
 707
 708         if (done) {
 709                 DEB(printk("aha1542_queuecommand: now waiting for interrupt ");
 710                     aha1542_stat());
 711                 SCpnt->scsi_done = done;
 712                 mb[mbo].status = 1;
 713                 aha1542_out(SCpnt->device->host->io_port, &ahacmd, 1);  /* start scsi command */
 714                 DEB(aha1542_stat());
 715         } else
 716                 printk("aha1542_queuecommand: done can't be NULL\n");
 717
 718         return 0;
 719 }
 720
 721 /* Initialize mailboxes */
 722 static void setup_mailboxes(int bse, struct Scsi_Host *shpnt)
 723 {
 724         int i;
 725         struct mailbox *mb;
 726         struct ccb *ccb;
 727
 728         unchar cmd[5] = { CMD_MBINIT, AHA1542_MAILBOXES, 0, 0, 0};
 729
 730         mb = HOSTDATA(shpnt)->mb;
 731         ccb = HOSTDATA(shpnt)->ccb;
 732
 733         for (i = 0; i < AHA1542_MAILBOXES; i++) {
 734                 mb[i].status = mb[AHA1542_MAILBOXES + i].status = 0;
 735                 any2scsi(mb[i].ccbptr, SCSI_BUF_PA(&ccb[i]));
 736         };
 737         aha1542_intr_reset(bse);        /* reset interrupts, so they don't block */
 738         any2scsi((cmd + 2), SCSI_BUF_PA(mb));
 739         aha1542_out(bse, cmd, 5);
 740         WAIT(INTRFLAGS(bse), INTRMASK, HACC, 0);
 741         while (0) {
 742 fail:
 743                 printk(KERN_ERR "aha1542_detect: failed setting up mailboxes\n");
 744         }
 745         aha1542_intr_reset(bse);
 746 }
 747
 748 static int __init aha1542_getconfig(int base_io, unsigned char *irq_level, unsigned char *dma_chan, unsigned char *scsi_id)
 749 {
 750         unchar inquiry_cmd[] = {CMD_RETCONF};
 751         unchar inquiry_result[3];
 752         int i;
 753         i = inb(STATUS(base_io));
 754         if (i & DF) {
 755                 i = inb(DATA(base_io));
 756         };
 757         aha1542_out(base_io, inquiry_cmd, 1);
 758         aha1542_in(base_io, inquiry_result, 3);
 759         WAIT(INTRFLAGS(base_io), INTRMASK, HACC, 0);
 760         while (0) {
 761 fail:
 762                 printk(KERN_ERR "aha1542_detect: query board settings\n");
 763         }
 764         aha1542_intr_reset(base_io);
 765         switch (inquiry_result[0]) {
 766         case 0x80:
 767                 *dma_chan = 7;
 768                 break;
 769         case 0x40:
 770                 *dma_chan = 6;
 771                 break;
 772         case 0x20:
 773                 *dma_chan = 5;
 774                 break;
 775         case 0x01:
 776                 *dma_chan = 0;
 777                 break;
 778         case 0:
 779                 /* This means that the adapter, although Adaptec 1542 compatible, doesn't use a DMA channel.
 780                    Currently only aware of the BusLogic BT-445S VL-Bus adapter which needs this. */
 781                 *dma_chan = 0xFF;
 782                 break;
 783         default:
 784                 printk(KERN_ERR "Unable to determine Adaptec DMA priority.  Disabling board\n");
 785                 return -1;
 786         };
 787         switch (inquiry_result[1]) {
 788         case 0x40:
 789                 *irq_level = 15;
 790                 break;
 791         case 0x20:
 792                 *irq_level = 14;
 793                 break;
 794         case 0x8:
 795                 *irq_level = 12;
 796                 break;
 797         case 0x4:
 798                 *irq_level = 11;
 799                 break;
 800         case 0x2:
 801                 *irq_level = 10;
 802                 break;
 803         case 0x1:
 804                 *irq_level = 9;
 805                 break;
 806         default:
 807                 printk(KERN_ERR "Unable to determine Adaptec IRQ level.  Disabling board\n");
 808                 return -1;
 809         };
 810         *scsi_id = inquiry_result[2] & 7;
 811         return 0;
 812 }
 813
 814 /* This function should only be called for 1542C boards - we can detect
 815    the special firmware settings and unlock the board */
 816
 817 static int __init aha1542_mbenable(int base)
 818 {
 819         static unchar mbenable_cmd[3];
 820         static unchar mbenable_result[2];
 821         int retval;
 822
 823         retval = BIOS_TRANSLATION_6432;
 824
 825         mbenable_cmd[0] = CMD_EXTBIOS;
 826         aha1542_out(base, mbenable_cmd, 1);
 827         if (aha1542_in1(base, mbenable_result, 2))
 828                 return retval;
 829         WAITd(INTRFLAGS(base), INTRMASK, HACC, 0, 100);
 830         aha1542_intr_reset(base);
 831
 832         if ((mbenable_result[0] & 0x08) || mbenable_result[1]) {
 833                 mbenable_cmd[0] = CMD_MBENABLE;
 834                 mbenable_cmd[1] = 0;
 835                 mbenable_cmd[2] = mbenable_result[1];
 836
 837                 if ((mbenable_result[0] & 0x08) && (mbenable_result[1] & 0x03))
 838                         retval = BIOS_TRANSLATION_25563;
 839
 840                 aha1542_out(base, mbenable_cmd, 3);
 841                 WAIT(INTRFLAGS(base), INTRMASK, HACC, 0);
 842         };
 843         while (0) {
 844 fail:
 845                 printk(KERN_ERR "aha1542_mbenable: Mailbox init failed\n");
 846         }
 847         aha1542_intr_reset(base);
 848         return retval;
 849 }
 850
 851 /* Query the board to find out if it is a 1542 or a 1740, or whatever. */
 852 static int __init aha1542_query(int base_io, int *transl)
 853 {
 854         unchar inquiry_cmd[] = {CMD_INQUIRY};
 855         unchar inquiry_result[4];
 856         int i;
 857         i = inb(STATUS(base_io));
 858         if (i & DF) {
 859                 i = inb(DATA(base_io));
 860         };
 861         aha1542_out(base_io, inquiry_cmd, 1);
 862         aha1542_in(base_io, inquiry_result, 4);
 863         WAIT(INTRFLAGS(base_io), INTRMASK, HACC, 0);
 864         while (0) {
 865 fail:
 866                 printk(KERN_ERR "aha1542_detect: query card type\n");
 867         }
 868         aha1542_intr_reset(base_io);
 869
 870         *transl = BIOS_TRANSLATION_6432;        /* Default case */
 871
 872         /* For an AHA1740 series board, we ignore the board since there is a
 873            hardware bug which can lead to wrong blocks being returned if the board
 874            is operating in the 1542 emulation mode.  Since there is an extended mode
 875            driver, we simply ignore the board and let the 1740 driver pick it up.
 876          */
 877
 878         if (inquiry_result[0] == 0x43) {
 879                 printk(KERN_INFO "aha1542.c: Emulation mode not supported for AHA 174N hardware.\n");
 880                 return 1;
 881         };
 882
 883         /* Always call this - boards that do not support extended bios translation
 884            will ignore the command, and we will set the proper default */
 885
 886         *transl = aha1542_mbenable(base_io);
 887
 888         return 0;
 889 }
 890
 891 #ifndef MODULE
 892 static char *setup_str[MAXBOARDS] __initdata;
 893 static int setup_idx = 0;
 894
 895 static void __init aha1542_setup(char *str, int *ints)
 896 {
 897         const char *ahausage = "aha1542: usage: aha1542=<PORTBASE>[,<BUSON>,<BUSOFF>[,<DMASPEED>]]\n";
 898         int setup_portbase;
 899
 900         if (setup_idx >= MAXBOARDS) {
 901                 printk(KERN_ERR "aha1542: aha1542_setup called too many times! Bad LILO params ?\n");
 902                 printk(KERN_ERR "   Entryline 1: %s\n", setup_str[0]);
 903                 printk(KERN_ERR "   Entryline 2: %s\n", setup_str[1]);
 904                 printk(KERN_ERR "   This line:   %s\n", str);
 905                 return;
 906         }
 907         if (ints[0] < 1 || ints[0] > 4) {
 908                 printk(KERN_ERR "aha1542: %s\n", str);
 909                 printk(ahausage);
 910                 printk(KERN_ERR "aha1542: Wrong parameters may cause system malfunction.. We try anyway..\n");
 911         }
 912         setup_called[setup_idx] = ints[0];
 913         setup_str[setup_idx] = str;
 914
 915         setup_portbase = ints[0] >= 1 ? ints[1] : 0;    /* Preserve the default value.. */
 916         setup_buson[setup_idx] = ints[0] >= 2 ? ints[2] : 7;
 917         setup_busoff[setup_idx] = ints[0] >= 3 ? ints[3] : 5;
 918         if (ints[0] >= 4)
 919         {
 920                 int atbt = -1;
 921                 switch (ints[4]) {
 922                 case 5:
 923                         atbt = 0x00;
 924                         break;
 925                 case 6:
 926                         atbt = 0x04;
 927                         break;
 928                 case 7:
 929                         atbt = 0x01;
 930                         break;
 931                 case 8:
 932                         atbt = 0x02;
 933                         break;
 934                 case 10:
 935                         atbt = 0x03;
 936                         break;
 937                 default:
 938                         printk(KERN_ERR "aha1542: %s\n", str);
 939                         printk(ahausage);
 940                         printk(KERN_ERR "aha1542: Valid values for DMASPEED are 5-8, 10 MB/s.  Using jumper defaults.\n");
 941                         break;
 942                 }
 943                 setup_dmaspeed[setup_idx] = atbt;
 944         }
 945         if (setup_portbase != 0)
 946                 bases[setup_idx] = setup_portbase;
 947
 948         ++setup_idx;
 949 }
 950
 951 static int __init do_setup(char *str)
 952 {
 953         int ints[5];
 954
 955         int count=setup_idx;
 956
 957         get_options(str, ARRAY_SIZE(ints), ints);
 958         aha1542_setup(str,ints);
 959
 960         return count<setup_idx;
 961 }
 962
 963 __setup("aha1542=",do_setup);
 964 #endif
 965
 966 /* return non-zero on detection */
 967 static int __init aha1542_detect(struct scsi_host_template * tpnt)
 968 {
 969         unsigned char dma_chan;
 970         unsigned char irq_level;
 971         unsigned char scsi_id;
 972         unsigned long flags;
 973         unsigned int base_io;
 974         int trans;
 975         struct Scsi_Host *shpnt = NULL;
 976         int count = 0;
 977         int indx;
 978
 979         DEB(printk("aha1542_detect: \n"));
 980
 981         tpnt->proc_name = "aha1542";
 982
 983 #ifdef MODULE
 984         bases[0] = aha1542[0];
 985         setup_buson[0] = aha1542[1];
 986         setup_busoff[0] = aha1542[2];
 987         {
 988                 int atbt = -1;
 989                 switch (aha1542[3]) {
 990                 case 5:
 991                         atbt = 0x00;
 992                         break;
 993                 case 6:
 994                         atbt = 0x04;
 995                         break;
 996                 case 7:
 997                         atbt = 0x01;
 998                         break;
 999                 case 8:
1000                         atbt = 0x02;
1001                         break;
1002                 case 10:
1003                         atbt = 0x03;
1004                         break;
1005                 };
1006                 setup_dmaspeed[0] = atbt;
1007         }
1008 #endif
1009
1010         /*
1011          *      Find MicroChannel cards (AHA1640)
1012          */
1013 #ifdef CONFIG_MCA_LEGACY
1014         if(MCA_bus) {
1015                 int slot = 0;
1016                 int pos = 0;
1017
1018                 for (indx = 0; (slot != MCA_NOTFOUND) && (indx < ARRAY_SIZE(bases)); indx++) {
1019
1020                         if (bases[indx])
1021                                 continue;
1022
1023                         /* Detect only AHA-1640 cards -- MCA ID 0F1F */
1024                         slot = mca_find_unused_adapter(0x0f1f, slot);
1025                         if (slot == MCA_NOTFOUND)
1026                                 break;
1027
1028                         /* Found one */
1029                         pos = mca_read_stored_pos(slot, 3);
1030
1031                         /* Decode address */
1032                         if (pos & 0x80) {
1033                                 if (pos & 0x02) {
1034                                         if (pos & 0x01)
1035                                                 bases[indx] = 0x334;
1036                                         else
1037                                                 bases[indx] = 0x234;
1038                                 } else {
1039                                         if (pos & 0x01)
1040                                                 bases[indx] = 0x134;
1041                                 }
1042                         } else {
1043                                 if (pos & 0x02) {
1044                                         if (pos & 0x01)
1045                                                 bases[indx] = 0x330;
1046                                         else
1047                                                 bases[indx] = 0x230;
1048                                 } else {
1049                                         if (pos & 0x01)
1050                                                 bases[indx] = 0x130;
1051                                 }
1052                         }
1053
1054                         /* No need to decode IRQ and Arb level -- those are
1055                          * read off the card later.
1056                          */
1057                         printk(KERN_INFO "Found an AHA-1640 in MCA slot %d, I/O 0x%04x\n", slot, bases[indx]);
1058
1059                         mca_set_adapter_name(slot, "Adapter AHA-1640");
1060                         mca_set_adapter_procfn(slot, NULL, NULL);
1061                         mca_mark_as_used(slot);
1062
1063                         /* Go on */
1064                         slot++;
1065                 }
1066
1067         }
1068 #endif
1069
1070         /*
1071          *      Hunt for ISA Plug'n'Pray Adaptecs (AHA1535)
1072          */
1073
1074         if(isapnp)
1075         {
1076                 struct pnp_dev *pdev = NULL;
1077                 for(indx = 0; indx < ARRAY_SIZE(bases); indx++) {
1078                         if(bases[indx])
1079                                 continue;
1080                         pdev = pnp_find_dev(NULL, ISAPNP_VENDOR('A', 'D', 'P'),
1081                                 ISAPNP_FUNCTION(0x1542), pdev);
1082                         if(pdev==NULL)
1083                                 break;
1084                         /*
1085                          *      Activate the PnP card
1086                          */
1087
1088                         if(pnp_device_attach(pdev)<0)
1089                                 continue;
1090
1091                         if(pnp_activate_dev(pdev)<0) {
1092                                 pnp_device_detach(pdev);
1093                                 continue;
1094                         }
1095
1096                         if(!pnp_port_valid(pdev, 0)) {
1097                                 pnp_device_detach(pdev);
1098                                 continue;
1099                         }
1100
1101                         bases[indx] = pnp_port_start(pdev, 0);
1102
1103                         /* The card can be queried for its DMA, we have
1104                            the DMA set up that is enough */
1105
1106                         printk(KERN_INFO "ISAPnP found an AHA1535 at I/O 0x%03X\n", bases[indx]);
1107                 }
1108         }
1109         for (indx = 0; indx < ARRAY_SIZE(bases); indx++)
1110                 if (bases[indx] != 0 && request_region(bases[indx], 4, "aha1542")) {
1111                         shpnt = scsi_register(tpnt,
1112                                         sizeof(struct aha1542_hostdata));
1113
1114                         if(shpnt==NULL) {
1115                                 release_region(bases[indx], 4);
1116                                 continue;
1117                         }
1118                         if (!aha1542_test_port(bases[indx], shpnt))
1119                                 goto unregister;
1120
1121                         base_io = bases[indx];
1122
1123                         /* Set the Bus on/off-times as not to ruin floppy performance */
1124                         {
1125                                 unchar oncmd[] = {CMD_BUSON_TIME, 7};
1126                                 unchar offcmd[] = {CMD_BUSOFF_TIME, 5};
1127
1128                                 if (setup_called[indx]) {
1129                                         oncmd[1] = setup_buson[indx];
1130                                         offcmd[1] = setup_busoff[indx];
1131                                 }
1132                                 aha1542_intr_reset(base_io);
1133                                 aha1542_out(base_io, oncmd, 2);
1134                                 WAIT(INTRFLAGS(base_io), INTRMASK, HACC, 0);
1135                                 aha1542_intr_reset(base_io);
1136                                 aha1542_out(base_io, offcmd, 2);
1137                                 WAIT(INTRFLAGS(base_io), INTRMASK, HACC, 0);
1138                                 if (setup_dmaspeed[indx] >= 0) {
1139                                         unchar dmacmd[] = {CMD_DMASPEED, 0};
1140                                         dmacmd[1] = setup_dmaspeed[indx];
1141                                         aha1542_intr_reset(base_io);
1142                                         aha1542_out(base_io, dmacmd, 2);
1143                                         WAIT(INTRFLAGS(base_io), INTRMASK, HACC, 0);
1144                                 }
1145                                 while (0) {
1146 fail:
1147                                         printk(KERN_ERR "aha1542_detect: setting bus on/off-time failed\n");
1148                                 }
1149                                 aha1542_intr_reset(base_io);
1150                         }
1151                         if (aha1542_query(base_io, &trans))
1152                                 goto unregister;
1153
1154                         if (aha1542_getconfig(base_io, &irq_level, &dma_chan, &scsi_id) == -1)
1155                                 goto unregister;
1156
1157                         printk(KERN_INFO "Configuring Adaptec (SCSI-ID %d) at IO:%x, IRQ %d", scsi_id, base_io, irq_level);
1158                         if (dma_chan != 0xFF)
1159                                 printk(", DMA priority %d", dma_chan);
1160                         printk("\n");
1161
1162                         DEB(aha1542_stat());
1163                         setup_mailboxes(base_io, shpnt);
1164
1165                         DEB(aha1542_stat());
1166
1167                         DEB(printk("aha1542_detect: enable interrupt channel %d\n", irq_level));
1168                         spin_lock_irqsave(&aha1542_lock, flags);
1169                         if (request_irq(irq_level, do_aha1542_intr_handle, 0,
1170                                         "aha1542", shpnt)) {
1171                                 printk(KERN_ERR "Unable to allocate IRQ for adaptec controller.\n");
1172                                 spin_unlock_irqrestore(&aha1542_lock, flags);
1173                                 goto unregister;
1174                         }
1175                         if (dma_chan != 0xFF) {
1176                                 if (request_dma(dma_chan, "aha1542")) {
1177                                         printk(KERN_ERR "Unable to allocate DMA channel for Adaptec.\n");
1178                                         free_irq(irq_level, shpnt);
1179                                         spin_unlock_irqrestore(&aha1542_lock, flags);
1180                                         goto unregister;
1181                                 }
1182                                 if (dma_chan == 0 || dma_chan >= 5) {
1183                                         set_dma_mode(dma_chan, DMA_MODE_CASCADE);
1184                                         enable_dma(dma_chan);
1185                                 }
1186                         }
1187
1188                         shpnt->this_id = scsi_id;
1189                         shpnt->unique_id = base_io;
1190                         shpnt->io_port = base_io;
1191                         shpnt->n_io_port = 4;   /* Number of bytes of I/O space used */
1192                         shpnt->dma_channel = dma_chan;
1193                         shpnt->irq = irq_level;
1194                         HOSTDATA(shpnt)->bios_translation = trans;
1195                         if (trans == BIOS_TRANSLATION_25563)
1196                                 printk(KERN_INFO "aha1542.c: Using extended bios translation\n");
1197                         HOSTDATA(shpnt)->aha1542_last_mbi_used = (2 * AHA1542_MAILBOXES - 1);
1198                         HOSTDATA(shpnt)->aha1542_last_mbo_used = (AHA1542_MAILBOXES - 1);
1199                         memset(HOSTDATA(shpnt)->SCint, 0, sizeof(HOSTDATA(shpnt)->SCint));
1200                         spin_unlock_irqrestore(&aha1542_lock, flags);
1201 #if 0
1202                         DEB(printk(" *** READ CAPACITY ***\n"));
1203
1204                         {
1205                                 unchar buf[8];
1206                                 static unchar cmd[] = { READ_CAPACITY, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
1207                                 int i;
1208
1209                                 for (i = 0; i < sizeof(buf); ++i)
1210                                         buf[i] = 0x87;
1211                                 for (i = 0; i < 2; ++i)
1212                                         if (!aha1542_command(i, cmd, buf, sizeof(buf))) {
1213                                                 printk(KERN_DEBUG "aha_detect: LU %d sector_size %d device_size %d\n",
1214                                                        i, xscsi2int(buf + 4), xscsi2int(buf));
1215                                         }
1216                         }
1217
1218                         DEB(printk(" *** NOW RUNNING MY OWN TEST *** \n"));
1219
1220                         for (i = 0; i < 4; ++i) {
1221                                 unsigned char cmd[10];
1222                                 static buffer[512];
1223
1224                                 cmd[0] = READ_10;
1225                                 cmd[1] = 0;
1226                                 xany2scsi(cmd + 2, i);
1227                                 cmd[6] = 0;
1228                                 cmd[7] = 0;
1229                                 cmd[8] = 1;
1230                                 cmd[9] = 0;
1231                                 aha1542_command(0, cmd, buffer, 512);
1232                         }
1233 #endif
1234                         count++;
1235                         continue;
1236 unregister:
1237                         release_region(bases[indx], 4);
1238                         scsi_unregister(shpnt);
1239                         continue;
1240
1241                 };
1242
1243         return count;
1244 }
1245
1246 static int aha1542_release(struct Scsi_Host *shost)
1247 {
1248         if (shost->irq)
1249                 free_irq(shost->irq, shost);
1250         if (shost->dma_channel != 0xff)
1251                 free_dma(shost->dma_channel);
1252         if (shost->io_port && shost->n_io_port)
1253                 release_region(shost->io_port, shost->n_io_port);
1254         scsi_unregister(shost);
1255         return 0;
1256 }
1257
1258 static int aha1542_restart(struct Scsi_Host *shost)
1259 {
1260         int i;
1261         int count = 0;
1262 #if 0
1263         unchar ahacmd = CMD_START_SCSI;
1264 #endif
1265
1266         for (i = 0; i < AHA1542_MAILBOXES; i++)
1267                 if (HOSTDATA(shost)->SCint[i] &&
1268                     !(HOSTDATA(shost)->SCint[i]->device->soft_reset)) {
1269 #if 0
1270                         HOSTDATA(shost)->mb[i].status = 1;      /* Indicate ready to restart... */
1271 #endif
1272                         count++;
1273                 }
1274         printk(KERN_DEBUG "Potential to restart %d stalled commands...\n", count);
1275 #if 0
1276         /* start scsi command */
1277         if (count)
1278                 aha1542_out(shost->io_port, &ahacmd, 1);
1279 #endif
1280         return 0;
1281 }
1282
1283 /*
1284  * This is a device reset.  This is handled by sending a special command
1285  * to the device.
1286  */
1287 static int aha1542_dev_reset(Scsi_Cmnd * SCpnt)
1288 {
1289         unsigned long flags;
1290         struct mailbox *mb;
1291         unchar target = SCpnt->device->id;
1292         unchar lun = SCpnt->device->lun;
1293         int mbo;
1294         struct ccb *ccb;
1295         unchar ahacmd = CMD_START_SCSI;
1296
1297         ccb = HOSTDATA(SCpnt->device->host)->ccb;
1298         mb = HOSTDATA(SCpnt->device->host)->mb;
1299
1300         spin_lock_irqsave(&aha1542_lock, flags);
1301         mbo = HOSTDATA(SCpnt->device->host)->aha1542_last_mbo_used + 1;
1302         if (mbo >= AHA1542_MAILBOXES)
1303                 mbo = 0;
1304
1305         do {
1306                 if (mb[mbo].status == 0 && HOSTDATA(SCpnt->device->host)->SCint[mbo] == NULL)
1307                         break;
1308                 mbo++;
1309                 if (mbo >= AHA1542_MAILBOXES)
1310                         mbo = 0;
1311         } while (mbo != HOSTDATA(SCpnt->device->host)->aha1542_last_mbo_used);
1312
1313         if (mb[mbo].status || HOSTDATA(SCpnt->device->host)->SCint[mbo])
1314                 panic("Unable to find empty mailbox for aha1542.\n");
1315
1316         HOSTDATA(SCpnt->device->host)->SCint[mbo] = SCpnt;      /* This will effectively
1317                                                            prevent someone else from
1318                                                            screwing with this cdb. */
1319
1320         HOSTDATA(SCpnt->device->host)->aha1542_last_mbo_used = mbo;
1321         spin_unlock_irqrestore(&aha1542_lock, flags);
1322
1323         any2scsi(mb[mbo].ccbptr, SCSI_BUF_PA(&ccb[mbo]));       /* This gets trashed for some reason */
1324
1325         memset(&ccb[mbo], 0, sizeof(struct ccb));
1326
1327         ccb[mbo].op = 0x81;     /* BUS DEVICE RESET */
1328
1329         ccb[mbo].idlun = (target & 7) << 5 | (lun & 7);         /*SCSI Target Id */
1330
1331         ccb[mbo].linkptr[0] = ccb[mbo].linkptr[1] = ccb[mbo].linkptr[2] = 0;
1332         ccb[mbo].commlinkid = 0;
1333
1334         /*
1335          * Now tell the 1542 to flush all pending commands for this
1336          * target
1337          */
1338         aha1542_out(SCpnt->device->host->io_port, &ahacmd, 1);
1339
1340         scmd_printk(KERN_WARNING, SCpnt,
1341                 "Trying device reset for target\n");
1342
1343         return SUCCESS;
1344
1345
1346 #ifdef ERIC_neverdef
1347         /*
1348          * With the 1542 we apparently never get an interrupt to
1349          * acknowledge a device reset being sent.  Then again, Leonard
1350          * says we are doing this wrong in the first place...
1351          *
1352          * Take a wait and see attitude.  If we get spurious interrupts,
1353          * then the device reset is doing something sane and useful, and
1354          * we will wait for the interrupt to post completion.
1355          */
1356         printk(KERN_WARNING "Sent BUS DEVICE RESET to target %d\n", SCpnt->target);
1357
1358         /*
1359          * Free the command block for all commands running on this
1360          * target...
1361          */
1362         for (i = 0; i < AHA1542_MAILBOXES; i++) {
1363                 if (HOSTDATA(SCpnt->host)->SCint[i] &&
1364                     HOSTDATA(SCpnt->host)->SCint[i]->target == SCpnt->target) {
1365                         Scsi_Cmnd *SCtmp;
1366                         SCtmp = HOSTDATA(SCpnt->host)->SCint[i];
1367                         kfree(SCtmp->host_scribble);
1368                         SCtmp->host_scribble = NULL;
1369                         HOSTDATA(SCpnt->host)->SCint[i] = NULL;
1370                         HOSTDATA(SCpnt->host)->mb[i].status = 0;
1371                 }
1372         }
1373         return SUCCESS;
1374
1375         return FAILED;
1376 #endif                          /* ERIC_neverdef */
1377 }
1378
1379 static int aha1542_bus_reset(Scsi_Cmnd * SCpnt)
1380 {
1381         int i;
1382
1383         /*
1384          * This does a scsi reset for all devices on the bus.
1385          * In principle, we could also reset the 1542 - should
1386          * we do this?  Try this first, and we can add that later
1387          * if it turns out to be useful.
1388          */
1389         outb(SCRST, CONTROL(SCpnt->device->host->io_port));
1390
1391         /*
1392          * Wait for the thing to settle down a bit.  Unfortunately
1393          * this is going to basically lock up the machine while we
1394          * wait for this to complete.  To be 100% correct, we need to
1395          * check for timeout, and if we are doing something like this
1396          * we are pretty desperate anyways.
1397          */
1398         ssleep(4);
1399
1400         spin_lock_irq(SCpnt->device->host->host_lock);
1401
1402         WAIT(STATUS(SCpnt->device->host->io_port),
1403              STATMASK, INIT | IDLE, STST | DIAGF | INVDCMD | DF | CDF);
1404
1405         /*
1406          * Now try to pick up the pieces.  For all pending commands,
1407          * free any internal data structures, and basically clear things
1408          * out.  We do not try and restart any commands or anything -
1409          * the strategy handler takes care of that crap.
1410          */
1411         printk(KERN_WARNING "Sent BUS RESET to scsi host %d\n", SCpnt->device->host->host_no);
1412
1413         for (i = 0; i < AHA1542_MAILBOXES; i++) {
1414                 if (HOSTDATA(SCpnt->device->host)->SCint[i] != NULL) {
1415                         Scsi_Cmnd *SCtmp;
1416                         SCtmp = HOSTDATA(SCpnt->device->host)->SCint[i];
1417
1418
1419                         if (SCtmp->device->soft_reset) {
1420                                 /*
1421                                  * If this device implements the soft reset option,
1422                                  * then it is still holding onto the command, and
1423                                  * may yet complete it.  In this case, we don't
1424                                  * flush the data.
1425                                  */
1426                                 continue;
1427                         }
1428                         kfree(SCtmp->host_scribble);
1429                         SCtmp->host_scribble = NULL;
1430                         HOSTDATA(SCpnt->device->host)->SCint[i] = NULL;
1431                         HOSTDATA(SCpnt->device->host)->mb[i].status = 0;
1432                 }
1433         }
1434
1435         spin_unlock_irq(SCpnt->device->host->host_lock);
1436         return SUCCESS;
1437
1438 fail:
1439         spin_unlock_irq(SCpnt->device->host->host_lock);
1440         return FAILED;
1441 }
1442
1443 static int aha1542_host_reset(Scsi_Cmnd * SCpnt)
1444 {
1445         int i;
1446
1447         /*
1448          * This does a scsi reset for all devices on the bus.
1449          * In principle, we could also reset the 1542 - should
1450          * we do this?  Try this first, and we can add that later
1451          * if it turns out to be useful.
1452          */
1453         outb(HRST | SCRST, CONTROL(SCpnt->device->host->io_port));
1454
1455         /*
1456          * Wait for the thing to settle down a bit.  Unfortunately
1457          * this is going to basically lock up the machine while we
1458          * wait for this to complete.  To be 100% correct, we need to
1459          * check for timeout, and if we are doing something like this
1460          * we are pretty desperate anyways.
1461          */
1462         ssleep(4);
1463         spin_lock_irq(SCpnt->device->host->host_lock);
1464
1465         WAIT(STATUS(SCpnt->device->host->io_port),
1466              STATMASK, INIT | IDLE, STST | DIAGF | INVDCMD | DF | CDF);
1467
1468         /*
1469          * We need to do this too before the 1542 can interact with
1470          * us again.
1471          */
1472         setup_mailboxes(SCpnt->device->host->io_port, SCpnt->device->host);
1473
1474         /*
1475          * Now try to pick up the pieces.  For all pending commands,
1476          * free any internal data structures, and basically clear things
1477          * out.  We do not try and restart any commands or anything -
1478          * the strategy handler takes care of that crap.
1479          */
1480         printk(KERN_WARNING "Sent BUS RESET to scsi host %d\n", SCpnt->device->host->host_no);
1481
1482         for (i = 0; i < AHA1542_MAILBOXES; i++) {
1483                 if (HOSTDATA(SCpnt->device->host)->SCint[i] != NULL) {
1484                         Scsi_Cmnd *SCtmp;
1485                         SCtmp = HOSTDATA(SCpnt->device->host)->SCint[i];
1486
1487                         if (SCtmp->device->soft_reset) {
1488                                 /*
1489                                  * If this device implements the soft reset option,
1490                                  * then it is still holding onto the command, and
1491                                  * may yet complete it.  In this case, we don't
1492                                  * flush the data.
1493                                  */
1494                                 continue;
1495                         }
1496                         kfree(SCtmp->host_scribble);
1497                         SCtmp->host_scribble = NULL;
1498                         HOSTDATA(SCpnt->device->host)->SCint[i] = NULL;
1499                         HOSTDATA(SCpnt->device->host)->mb[i].status = 0;
1500                 }
1501         }
1502
1503         spin_unlock_irq(SCpnt->device->host->host_lock);
1504         return SUCCESS;
1505
1506 fail:
1507         spin_unlock_irq(SCpnt->device->host->host_lock);
1508         return FAILED;
1509 }
1510
1511 #if 0
1512 /*
1513  * These are the old error handling routines.  They are only temporarily
1514  * here while we play with the new error handling code.
1515  */
1516 static int aha1542_old_abort(Scsi_Cmnd * SCpnt)
1517 {
1518 #if 0
1519         unchar ahacmd = CMD_START_SCSI;
1520         unsigned long flags;
1521         struct mailbox *mb;
1522         int mbi, mbo, i;
1523
1524         printk(KERN_DEBUG "In aha1542_abort: %x %x\n",
1525                inb(STATUS(SCpnt->host->io_port)),
1526                inb(INTRFLAGS(SCpnt->host->io_port)));
1527
1528         spin_lock_irqsave(&aha1542_lock, flags);
1529         mb = HOSTDATA(SCpnt->host)->mb;
1530         mbi = HOSTDATA(SCpnt->host)->aha1542_last_mbi_used + 1;
1531         if (mbi >= 2 * AHA1542_MAILBOXES)
1532                 mbi = AHA1542_MAILBOXES;
1533
1534         do {
1535                 if (mb[mbi].status != 0)
1536                         break;
1537                 mbi++;
1538                 if (mbi >= 2 * AHA1542_MAILBOXES)
1539                         mbi = AHA1542_MAILBOXES;
1540         } while (mbi != HOSTDATA(SCpnt->host)->aha1542_last_mbi_used);
1541         spin_unlock_irqrestore(&aha1542_lock, flags);
1542
1543         if (mb[mbi].status) {
1544                 printk(KERN_ERR "Lost interrupt discovered on irq %d - attempting to recover\n",
1545                        SCpnt->host->irq);
1546                 aha1542_intr_handle(SCpnt->host, NULL);
1547                 return 0;
1548         }
1549         /* OK, no lost interrupt.  Try looking to see how many pending commands
1550            we think we have. */
1551
1552         for (i = 0; i < AHA1542_MAILBOXES; i++)
1553                 if (HOSTDATA(SCpnt->host)->SCint[i]) {
1554                         if (HOSTDATA(SCpnt->host)->SCint[i] == SCpnt) {
1555                                 printk(KERN_ERR "Timed out command pending for %s\n",
1556                                        SCpnt->request->rq_disk ?
1557                                        SCpnt->request->rq_disk->disk_name : "?"
1558                                        );
1559                                 if (HOSTDATA(SCpnt->host)->mb[i].status) {
1560                                         printk(KERN_ERR "OGMB still full - restarting\n");
1561                                         aha1542_out(SCpnt->host->io_port, &ahacmd, 1);
1562                                 };
1563                         } else
1564                                 printk(KERN_ERR "Other pending command %s\n",
1565                                        SCpnt->request->rq_disk ?
1566                                        SCpnt->request->rq_disk->disk_name : "?"
1567                                        );
1568                 }
1569 #endif
1570
1571         DEB(printk("aha1542_abort\n"));
1572 #if 0
1573         spin_lock_irqsave(&aha1542_lock, flags);
1574         for (mbo = 0; mbo < AHA1542_MAILBOXES; mbo++) {
1575                 if (SCpnt == HOSTDATA(SCpnt->host)->SCint[mbo]) {
1576                         mb[mbo].status = 2;     /* Abort command */
1577                         aha1542_out(SCpnt->host->io_port, &ahacmd, 1);  /* start scsi command */
1578                         spin_unlock_irqrestore(&aha1542_lock, flags);
1579                         break;
1580                 }
1581         }
1582         if (AHA1542_MAILBOXES == mbo)
1583                 spin_unlock_irqrestore(&aha1542_lock, flags);
1584 #endif
1585         return SCSI_ABORT_SNOOZE;
1586 }
1587
1588 /* We do not implement a reset function here, but the upper level code
1589    assumes that it will get some kind of response for the command in
1590    SCpnt.  We must oblige, or the command will hang the scsi system.
1591    For a first go, we assume that the 1542 notifies us with all of the
1592    pending commands (it does implement soft reset, after all). */
1593
1594 static int aha1542_old_reset(Scsi_Cmnd * SCpnt, unsigned int reset_flags)
1595 {
1596         unchar ahacmd = CMD_START_SCSI;
1597         int i;
1598
1599         /*
1600          * See if a bus reset was suggested.
1601          */
1602         if (reset_flags & SCSI_RESET_SUGGEST_BUS_RESET) {
1603                 /*
1604                  * This does a scsi reset for all devices on the bus.
1605                  * In principle, we could also reset the 1542 - should
1606                  * we do this?  Try this first, and we can add that later
1607                  * if it turns out to be useful.
1608                  */
1609                 outb(HRST | SCRST, CONTROL(SCpnt->host->io_port));
1610
1611                 /*
1612                  * Wait for the thing to settle down a bit.  Unfortunately
1613                  * this is going to basically lock up the machine while we
1614                  * wait for this to complete.  To be 100% correct, we need to
1615                  * check for timeout, and if we are doing something like this
1616                  * we are pretty desperate anyways.
1617                  */
1618                 WAIT(STATUS(SCpnt->host->io_port),
1619                 STATMASK, INIT | IDLE, STST | DIAGF | INVDCMD | DF | CDF);
1620
1621                 /*
1622                  * We need to do this too before the 1542 can interact with
1623                  * us again.
1624                  */
1625                 setup_mailboxes(SCpnt->host->io_port, SCpnt->host);
1626
1627                 /*
1628                  * Now try to pick up the pieces.  Restart all commands
1629                  * that are currently active on the bus, and reset all of
1630                  * the datastructures.  We have some time to kill while
1631                  * things settle down, so print a nice message.
1632                  */
1633                 printk(KERN_WARNING "Sent BUS RESET to scsi host %d\n", SCpnt->host->host_no);
1634
1635                 for (i = 0; i < AHA1542_MAILBOXES; i++)
1636                         if (HOSTDATA(SCpnt->host)->SCint[i] != NULL) {
1637                                 Scsi_Cmnd *SCtmp;
1638                                 SCtmp = HOSTDATA(SCpnt->host)->SCint[i];
1639                                 SCtmp->result = DID_RESET << 16;
1640                                 kfree(SCtmp->host_scribble);
1641                                 SCtmp->host_scribble = NULL;
1642                                 printk(KERN_WARNING "Sending DID_RESET for target %d\n", SCpnt->target);
1643                                 SCtmp->scsi_done(SCpnt);
1644
1645                                 HOSTDATA(SCpnt->host)->SCint[i] = NULL;
1646                                 HOSTDATA(SCpnt->host)->mb[i].status = 0;
1647                         }
1648                 /*
1649                  * Now tell the mid-level code what we did here.  Since
1650                  * we have restarted all of the outstanding commands,
1651                  * then report SUCCESS.
1652                  */
1653                 return (SCSI_RESET_SUCCESS | SCSI_RESET_BUS_RESET);
1654 fail:
1655                 printk(KERN_CRIT "aha1542.c: Unable to perform hard reset.\n");
1656                 printk(KERN_CRIT "Power cycle machine to reset\n");
1657                 return (SCSI_RESET_ERROR | SCSI_RESET_BUS_RESET);
1658
1659
1660         } else {
1661                 /* This does a selective reset of just the one device */
1662                 /* First locate the ccb for this command */
1663                 for (i = 0; i < AHA1542_MAILBOXES; i++)
1664                         if (HOSTDATA(SCpnt->host)->SCint[i] == SCpnt) {
1665                                 HOSTDATA(SCpnt->host)->ccb[i].op = 0x81;        /* BUS DEVICE RESET */
1666                                 /* Now tell the 1542 to flush all pending commands for this target */
1667                                 aha1542_out(SCpnt->host->io_port, &ahacmd, 1);
1668
1669                                 /* Here is the tricky part.  What to do next.  Do we get an interrupt
1670                                    for the commands that we aborted with the specified target, or
1671                                    do we generate this on our own?  Try it without first and see
1672                                    what happens */
1673                                 printk(KERN_WARNING "Sent BUS DEVICE RESET to target %d\n", SCpnt->target);
1674
1675                                 /* If the first does not work, then try the second.  I think the
1676                                    first option is more likely to be correct. Free the command
1677                                    block for all commands running on this target... */
1678                                 for (i = 0; i < AHA1542_MAILBOXES; i++)
1679                                         if (HOSTDATA(SCpnt->host)->SCint[i] &&
1680                                             HOSTDATA(SCpnt->host)->SCint[i]->target == SCpnt->target) {
1681                                                 Scsi_Cmnd *SCtmp;
1682                                                 SCtmp = HOSTDATA(SCpnt->host)->SCint[i];
1683                                                 SCtmp->result = DID_RESET << 16;
1684                                                 kfree(SCtmp->host_scribble);
1685                                                 SCtmp->host_scribble = NULL;
1686                                                 printk(KERN_WARNING "Sending DID_RESET for target %d\n", SCpnt->target);
1687                                                 SCtmp->scsi_done(SCpnt);
1688
1689                                                 HOSTDATA(SCpnt->host)->SCint[i] = NULL;
1690                                                 HOSTDATA(SCpnt->host)->mb[i].status = 0;
1691                                         }
1692                                 return SCSI_RESET_SUCCESS;
1693                         }
1694         }
1695         /* No active command at this time, so this means that each time we got
1696            some kind of response the last time through.  Tell the mid-level code
1697            to request sense information in order to decide what to do next. */
1698         return SCSI_RESET_PUNT;
1699 }
1700 #endif    /* end of big comment block around old_abort + old_reset */
1701
1702 static int aha1542_biosparam(struct scsi_device *sdev,
1703                 struct block_device *bdev, sector_t capacity, int *ip)
1704 {
1705         int translation_algorithm;
1706         int size = capacity;
1707
1708         translation_algorithm = HOSTDATA(sdev->host)->bios_translation;
1709
1710         if ((size >> 11) > 1024 && translation_algorithm == BIOS_TRANSLATION_25563) {
1711                 /* Please verify that this is the same as what DOS returns */
1712                 ip[0] = 255;
1713                 ip[1] = 63;
1714                 ip[2] = size / 255 / 63;
1715         } else {
1716                 ip[0] = 64;
1717                 ip[1] = 32;
1718                 ip[2] = size >> 11;
1719         }
1720
1721         return 0;
1722 }
1723 MODULE_LICENSE("GPL");
1724
1725
1726 static struct scsi_host_template driver_template = {
1727         .proc_name              = "aha1542",
1728         .name                   = "Adaptec 1542",
1729         .detect                 = aha1542_detect,
1730         .release                = aha1542_release,
1731         .queuecommand           = aha1542_queuecommand,
1732         .eh_device_reset_handler= aha1542_dev_reset,
1733         .eh_bus_reset_handler   = aha1542_bus_reset,
1734         .eh_host_reset_handler  = aha1542_host_reset,
1735         .bios_param             = aha1542_biosparam,
1736         .can_queue              = AHA1542_MAILBOXES,
1737         .this_id                = 7,
1738         .sg_tablesize           = AHA1542_SCATTER,
1739         .cmd_per_lun            = AHA1542_CMDLUN,
1740         .unchecked_isa_dma      = 1,
1741         .use_clustering         = ENABLE_CLUSTERING,
1742 };
1743 #include "scsi_module.c"