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