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