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