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