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