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 *sgp,
  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(sgp->page) + sgp->offset,
  71                (unsigned long long)SCSI_SG_PA(sgp),
  72                sgp->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 *sg;
 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                 cptr = (struct chain *) SCpnt->host_scribble;
 703                 if (cptr == NULL) {
 704                         /* free the claimed mailbox slot */
 705                         HOSTDATA(SCpnt->device->host)->SCint[mbo] = NULL;
 706                         return SCSI_MLQUEUE_HOST_BUSY;
 707                 }
 708                 scsi_for_each_sg(SCpnt, sg, SCpnt->use_sg, i) {
 709                         if (sg->length == 0 || SCpnt->use_sg > 16 ||
 710                             (((int) sg->offset) & 1) || (sg->length & 1)) {
 711                                 unsigned char *ptr;
 712                                 printk(KERN_CRIT "Bad segment list supplied to aha1542.c (%d, %d)\n", SCpnt->use_sg, i);
 713                                 scsi_for_each_sg(SCpnt, sg, SCpnt->use_sg, i) {
 714                                         printk(KERN_CRIT "%d: %p %d\n", i,
 715                                                (page_address(sg->page) +
 716                                                 sg->offset), sg->length);
 717                                 };
 718                                 printk(KERN_CRIT "cptr %x: ", (unsigned int) cptr);
 719                                 ptr = (unsigned char *) &cptr[i];
 720                                 for (i = 0; i < 18; i++)
 721                                         printk("%02x ", ptr[i]);
 722                                 panic("Foooooooood fight!");
 723                         };
 724                         any2scsi(cptr[i].dataptr, SCSI_SG_PA(sg));
 725                         if (SCSI_SG_PA(sg) + sg->length - 1 > ISA_DMA_THRESHOLD)
 726                                 BAD_SG_DMA(SCpnt, sg, SCpnt->use_sg, i);
 727                         any2scsi(cptr[i].datalen, sg->length);
 728                 };
 729                 any2scsi(ccb[mbo].datalen, SCpnt->use_sg * sizeof(struct chain));
 730                 any2scsi(ccb[mbo].dataptr, SCSI_BUF_PA(cptr));
 731 #ifdef DEBUG
 732                 printk("cptr %x: ", cptr);
 733                 ptr = (unsigned char *) cptr;
 734                 for (i = 0; i < 18; i++)
 735                         printk("%02x ", ptr[i]);
 736 #endif
 737         } else {
 738                 ccb[mbo].op = 0;        /* SCSI Initiator Command */
 739                 SCpnt->host_scribble = NULL;
 740                 any2scsi(ccb[mbo].datalen, bufflen);
 741                 if (buff && SCSI_BUF_PA(buff + bufflen - 1) > ISA_DMA_THRESHOLD)
 742                         BAD_DMA(buff, bufflen);
 743                 any2scsi(ccb[mbo].dataptr, SCSI_BUF_PA(buff));
 744         };
 745         ccb[mbo].idlun = (target & 7) << 5 | direction | (lun & 7);     /*SCSI Target Id */
 746         ccb[mbo].rsalen = 16;
 747         ccb[mbo].linkptr[0] = ccb[mbo].linkptr[1] = ccb[mbo].linkptr[2] = 0;
 748         ccb[mbo].commlinkid = 0;
 749
 750 #ifdef DEBUG
 751         {
 752                 int i;
 753                 printk(KERN_DEBUG "aha1542_command: sending.. ");
 754                 for (i = 0; i < sizeof(ccb[mbo]) - 10; i++)
 755                         printk("%02x ", ((unchar *) & ccb[mbo])[i]);
 756         };
 757 #endif
 758
 759         if (done) {
 760                 DEB(printk("aha1542_queuecommand: now waiting for interrupt ");
 761                     aha1542_stat());
 762                 SCpnt->scsi_done = done;
 763                 mb[mbo].status = 1;
 764                 aha1542_out(SCpnt->device->host->io_port, &ahacmd, 1);  /* start scsi command */
 765                 DEB(aha1542_stat());
 766         } else
 767                 printk("aha1542_queuecommand: done can't be NULL\n");
 768
 769         return 0;
 770 }
 771
 772 /* Initialize mailboxes */
 773 static void setup_mailboxes(int bse, struct Scsi_Host *shpnt)
 774 {
 775         int i;
 776         struct mailbox *mb;
 777         struct ccb *ccb;
 778
 779         unchar cmd[5] = { CMD_MBINIT, AHA1542_MAILBOXES, 0, 0, 0};
 780
 781         mb = HOSTDATA(shpnt)->mb;
 782         ccb = HOSTDATA(shpnt)->ccb;
 783
 784         for (i = 0; i < AHA1542_MAILBOXES; i++) {
 785                 mb[i].status = mb[AHA1542_MAILBOXES + i].status = 0;
 786                 any2scsi(mb[i].ccbptr, SCSI_BUF_PA(&ccb[i]));
 787         };
 788         aha1542_intr_reset(bse);        /* reset interrupts, so they don't block */
 789         any2scsi((cmd + 2), SCSI_BUF_PA(mb));
 790         aha1542_out(bse, cmd, 5);
 791         WAIT(INTRFLAGS(bse), INTRMASK, HACC, 0);
 792         while (0) {
 793 fail:
 794                 printk(KERN_ERR "aha1542_detect: failed setting up mailboxes\n");
 795         }
 796         aha1542_intr_reset(bse);
 797 }
 798
 799 static int __init aha1542_getconfig(int base_io, unsigned char *irq_level, unsigned char *dma_chan, unsigned char *scsi_id)
 800 {
 801         unchar inquiry_cmd[] = {CMD_RETCONF};
 802         unchar inquiry_result[3];
 803         int i;
 804         i = inb(STATUS(base_io));
 805         if (i & DF) {
 806                 i = inb(DATA(base_io));
 807         };
 808         aha1542_out(base_io, inquiry_cmd, 1);
 809         aha1542_in(base_io, inquiry_result, 3);
 810         WAIT(INTRFLAGS(base_io), INTRMASK, HACC, 0);
 811         while (0) {
 812 fail:
 813                 printk(KERN_ERR "aha1542_detect: query board settings\n");
 814         }
 815         aha1542_intr_reset(base_io);
 816         switch (inquiry_result[0]) {
 817         case 0x80:
 818                 *dma_chan = 7;
 819                 break;
 820         case 0x40:
 821                 *dma_chan = 6;
 822                 break;
 823         case 0x20:
 824                 *dma_chan = 5;
 825                 break;
 826         case 0x01:
 827                 *dma_chan = 0;
 828                 break;
 829         case 0:
 830                 /* This means that the adapter, although Adaptec 1542 compatible, doesn't use a DMA channel.
 831                    Currently only aware of the BusLogic BT-445S VL-Bus adapter which needs this. */
 832                 *dma_chan = 0xFF;
 833                 break;
 834         default:
 835                 printk(KERN_ERR "Unable to determine Adaptec DMA priority.  Disabling board\n");
 836                 return -1;
 837         };
 838         switch (inquiry_result[1]) {
 839         case 0x40:
 840                 *irq_level = 15;
 841                 break;
 842         case 0x20:
 843                 *irq_level = 14;
 844                 break;
 845         case 0x8:
 846                 *irq_level = 12;
 847                 break;
 848         case 0x4:
 849                 *irq_level = 11;
 850                 break;
 851         case 0x2:
 852                 *irq_level = 10;
 853                 break;
 854         case 0x1:
 855                 *irq_level = 9;
 856                 break;
 857         default:
 858                 printk(KERN_ERR "Unable to determine Adaptec IRQ level.  Disabling board\n");
 859                 return -1;
 860         };
 861         *scsi_id = inquiry_result[2] & 7;
 862         return 0;
 863 }
 864
 865 /* This function should only be called for 1542C boards - we can detect
 866    the special firmware settings and unlock the board */
 867
 868 static int __init aha1542_mbenable(int base)
 869 {
 870         static unchar mbenable_cmd[3];
 871         static unchar mbenable_result[2];
 872         int retval;
 873
 874         retval = BIOS_TRANSLATION_6432;
 875
 876         mbenable_cmd[0] = CMD_EXTBIOS;
 877         aha1542_out(base, mbenable_cmd, 1);
 878         if (aha1542_in1(base, mbenable_result, 2))
 879                 return retval;
 880         WAITd(INTRFLAGS(base), INTRMASK, HACC, 0, 100);
 881         aha1542_intr_reset(base);
 882
 883         if ((mbenable_result[0] & 0x08) || mbenable_result[1]) {
 884                 mbenable_cmd[0] = CMD_MBENABLE;
 885                 mbenable_cmd[1] = 0;
 886                 mbenable_cmd[2] = mbenable_result[1];
 887
 888                 if ((mbenable_result[0] & 0x08) && (mbenable_result[1] & 0x03))
 889                         retval = BIOS_TRANSLATION_25563;
 890
 891                 aha1542_out(base, mbenable_cmd, 3);
 892                 WAIT(INTRFLAGS(base), INTRMASK, HACC, 0);
 893         };
 894         while (0) {
 895 fail:
 896                 printk(KERN_ERR "aha1542_mbenable: Mailbox init failed\n");
 897         }
 898         aha1542_intr_reset(base);
 899         return retval;
 900 }
 901
 902 /* Query the board to find out if it is a 1542 or a 1740, or whatever. */
 903 static int __init aha1542_query(int base_io, int *transl)
 904 {
 905         unchar inquiry_cmd[] = {CMD_INQUIRY};
 906         unchar inquiry_result[4];
 907         int i;
 908         i = inb(STATUS(base_io));
 909         if (i & DF) {
 910                 i = inb(DATA(base_io));
 911         };
 912         aha1542_out(base_io, inquiry_cmd, 1);
 913         aha1542_in(base_io, inquiry_result, 4);
 914         WAIT(INTRFLAGS(base_io), INTRMASK, HACC, 0);
 915         while (0) {
 916 fail:
 917                 printk(KERN_ERR "aha1542_detect: query card type\n");
 918         }
 919         aha1542_intr_reset(base_io);
 920
 921         *transl = BIOS_TRANSLATION_6432;        /* Default case */
 922
 923         /* For an AHA1740 series board, we ignore the board since there is a
 924            hardware bug which can lead to wrong blocks being returned if the board
 925            is operating in the 1542 emulation mode.  Since there is an extended mode
 926            driver, we simply ignore the board and let the 1740 driver pick it up.
 927          */
 928
 929         if (inquiry_result[0] == 0x43) {
 930                 printk(KERN_INFO "aha1542.c: Emulation mode not supported for AHA 174N hardware.\n");
 931                 return 1;
 932         };
 933
 934         /* Always call this - boards that do not support extended bios translation
 935            will ignore the command, and we will set the proper default */
 936
 937         *transl = aha1542_mbenable(base_io);
 938
 939         return 0;
 940 }
 941
 942 #ifndef MODULE
 943 static char *setup_str[MAXBOARDS] __initdata;
 944 static int setup_idx = 0;
 945
 946 static void __init aha1542_setup(char *str, int *ints)
 947 {
 948         const char *ahausage = "aha1542: usage: aha1542=<PORTBASE>[,<BUSON>,<BUSOFF>[,<DMASPEED>]]\n";
 949         int setup_portbase;
 950
 951         if (setup_idx >= MAXBOARDS) {
 952                 printk(KERN_ERR "aha1542: aha1542_setup called too many times! Bad LILO params ?\n");
 953                 printk(KERN_ERR "   Entryline 1: %s\n", setup_str[0]);
 954                 printk(KERN_ERR "   Entryline 2: %s\n", setup_str[1]);
 955                 printk(KERN_ERR "   This line:   %s\n", str);
 956                 return;
 957         }
 958         if (ints[0] < 1 || ints[0] > 4) {
 959                 printk(KERN_ERR "aha1542: %s\n", str);
 960                 printk(ahausage);
 961                 printk(KERN_ERR "aha1542: Wrong parameters may cause system malfunction.. We try anyway..\n");
 962         }
 963         setup_called[setup_idx] = ints[0];
 964         setup_str[setup_idx] = str;
 965
 966         setup_portbase = ints[0] >= 1 ? ints[1] : 0;    /* Preserve the default value.. */
 967         setup_buson[setup_idx] = ints[0] >= 2 ? ints[2] : 7;
 968         setup_busoff[setup_idx] = ints[0] >= 3 ? ints[3] : 5;
 969         if (ints[0] >= 4)
 970         {
 971                 int atbt = -1;
 972                 switch (ints[4]) {
 973                 case 5:
 974                         atbt = 0x00;
 975                         break;
 976                 case 6:
 977                         atbt = 0x04;
 978                         break;
 979                 case 7:
 980                         atbt = 0x01;
 981                         break;
 982                 case 8:
 983                         atbt = 0x02;
 984                         break;
 985                 case 10:
 986                         atbt = 0x03;
 987                         break;
 988                 default:
 989                         printk(KERN_ERR "aha1542: %s\n", str);
 990                         printk(ahausage);
 991                         printk(KERN_ERR "aha1542: Valid values for DMASPEED are 5-8, 10 MB/s.  Using jumper defaults.\n");
 992                         break;
 993                 }
 994                 setup_dmaspeed[setup_idx] = atbt;
 995         }
 996         if (setup_portbase != 0)
 997                 bases[setup_idx] = setup_portbase;
 998
 999         ++setup_idx;
1000 }
1001
1002 static int __init do_setup(char *str)
1003 {
1004         int ints[5];
1005
1006         int count=setup_idx;
1007
1008         get_options(str, ARRAY_SIZE(ints), ints);
1009         aha1542_setup(str,ints);
1010
1011         return count<setup_idx;
1012 }
1013
1014 __setup("aha1542=",do_setup);
1015 #endif
1016
1017 /* return non-zero on detection */
1018 static int __init aha1542_detect(struct scsi_host_template * tpnt)
1019 {
1020         unsigned char dma_chan;
1021         unsigned char irq_level;
1022         unsigned char scsi_id;
1023         unsigned long flags;
1024         unsigned int base_io;
1025         int trans;
1026         struct Scsi_Host *shpnt = NULL;
1027         int count = 0;
1028         int indx;
1029
1030         DEB(printk("aha1542_detect: \n"));
1031
1032         tpnt->proc_name = "aha1542";
1033
1034 #ifdef MODULE
1035         bases[0] = aha1542[0];
1036         setup_buson[0] = aha1542[1];
1037         setup_busoff[0] = aha1542[2];
1038         {
1039                 int atbt = -1;
1040                 switch (aha1542[3]) {
1041                 case 5:
1042                         atbt = 0x00;
1043                         break;
1044                 case 6:
1045                         atbt = 0x04;
1046                         break;
1047                 case 7:
1048                         atbt = 0x01;
1049                         break;
1050                 case 8:
1051                         atbt = 0x02;
1052                         break;
1053                 case 10:
1054                         atbt = 0x03;
1055                         break;
1056                 };
1057                 setup_dmaspeed[0] = atbt;
1058         }
1059 #endif
1060
1061         /*
1062          *      Find MicroChannel cards (AHA1640)
1063          */
1064 #ifdef CONFIG_MCA_LEGACY
1065         if(MCA_bus) {
1066                 int slot = 0;
1067                 int pos = 0;
1068
1069                 for (indx = 0; (slot != MCA_NOTFOUND) && (indx < ARRAY_SIZE(bases)); indx++) {
1070
1071                         if (bases[indx])
1072                                 continue;
1073
1074                         /* Detect only AHA-1640 cards -- MCA ID 0F1F */
1075                         slot = mca_find_unused_adapter(0x0f1f, slot);
1076                         if (slot == MCA_NOTFOUND)
1077                                 break;
1078
1079                         /* Found one */
1080                         pos = mca_read_stored_pos(slot, 3);
1081
1082                         /* Decode address */
1083                         if (pos & 0x80) {
1084                                 if (pos & 0x02) {
1085                                         if (pos & 0x01)
1086                                                 bases[indx] = 0x334;
1087                                         else
1088                                                 bases[indx] = 0x234;
1089                                 } else {
1090                                         if (pos & 0x01)
1091                                                 bases[indx] = 0x134;
1092                                 }
1093                         } else {
1094                                 if (pos & 0x02) {
1095                                         if (pos & 0x01)
1096                                                 bases[indx] = 0x330;
1097                                         else
1098                                                 bases[indx] = 0x230;
1099                                 } else {
1100                                         if (pos & 0x01)
1101                                                 bases[indx] = 0x130;
1102                                 }
1103                         }
1104
1105                         /* No need to decode IRQ and Arb level -- those are
1106                          * read off the card later.
1107                          */
1108                         printk(KERN_INFO "Found an AHA-1640 in MCA slot %d, I/O 0x%04x\n", slot, bases[indx]);
1109
1110                         mca_set_adapter_name(slot, "Adapter AHA-1640");
1111                         mca_set_adapter_procfn(slot, NULL, NULL);
1112                         mca_mark_as_used(slot);
1113
1114                         /* Go on */
1115                         slot++;
1116                 }
1117
1118         }
1119 #endif
1120
1121         /*
1122          *      Hunt for ISA Plug'n'Pray Adaptecs (AHA1535)
1123          */
1124
1125         if(isapnp)
1126         {
1127                 struct pnp_dev *pdev = NULL;
1128                 for(indx = 0; indx < ARRAY_SIZE(bases); indx++) {
1129                         if(bases[indx])
1130                                 continue;
1131                         pdev = pnp_find_dev(NULL, ISAPNP_VENDOR('A', 'D', 'P'),
1132                                 ISAPNP_FUNCTION(0x1542), pdev);
1133                         if(pdev==NULL)
1134                                 break;
1135                         /*
1136                          *      Activate the PnP card
1137                          */
1138
1139                         if(pnp_device_attach(pdev)<0)
1140                                 continue;
1141
1142                         if(pnp_activate_dev(pdev)<0) {
1143                                 pnp_device_detach(pdev);
1144                                 continue;
1145                         }
1146
1147                         if(!pnp_port_valid(pdev, 0)) {
1148                                 pnp_device_detach(pdev);
1149                                 continue;
1150                         }
1151
1152                         bases[indx] = pnp_port_start(pdev, 0);
1153
1154                         /* The card can be queried for its DMA, we have
1155                            the DMA set up that is enough */
1156
1157                         printk(KERN_INFO "ISAPnP found an AHA1535 at I/O 0x%03X\n", bases[indx]);
1158                 }
1159         }
1160         for (indx = 0; indx < ARRAY_SIZE(bases); indx++)
1161                 if (bases[indx] != 0 && request_region(bases[indx], 4, "aha1542")) {
1162                         shpnt = scsi_register(tpnt,
1163                                         sizeof(struct aha1542_hostdata));
1164
1165                         if(shpnt==NULL) {
1166                                 release_region(bases[indx], 4);
1167                                 continue;
1168                         }
1169                         /* For now we do this - until kmalloc is more intelligent
1170                            we are resigned to stupid hacks like this */
1171                         if (SCSI_BUF_PA(shpnt) >= ISA_DMA_THRESHOLD) {
1172                                 printk(KERN_ERR "Invalid address for shpnt with 1542.\n");
1173                                 goto unregister;
1174                         }
1175                         if (!aha1542_test_port(bases[indx], shpnt))
1176                                 goto unregister;
1177
1178
1179                         base_io = bases[indx];
1180
1181                         /* Set the Bus on/off-times as not to ruin floppy performance */
1182                         {
1183                                 unchar oncmd[] = {CMD_BUSON_TIME, 7};
1184                                 unchar offcmd[] = {CMD_BUSOFF_TIME, 5};
1185
1186                                 if (setup_called[indx]) {
1187                                         oncmd[1] = setup_buson[indx];
1188                                         offcmd[1] = setup_busoff[indx];
1189                                 }
1190                                 aha1542_intr_reset(base_io);
1191                                 aha1542_out(base_io, oncmd, 2);
1192                                 WAIT(INTRFLAGS(base_io), INTRMASK, HACC, 0);
1193                                 aha1542_intr_reset(base_io);
1194                                 aha1542_out(base_io, offcmd, 2);
1195                                 WAIT(INTRFLAGS(base_io), INTRMASK, HACC, 0);
1196                                 if (setup_dmaspeed[indx] >= 0) {
1197                                         unchar dmacmd[] = {CMD_DMASPEED, 0};
1198                                         dmacmd[1] = setup_dmaspeed[indx];
1199                                         aha1542_intr_reset(base_io);
1200                                         aha1542_out(base_io, dmacmd, 2);
1201                                         WAIT(INTRFLAGS(base_io), INTRMASK, HACC, 0);
1202                                 }
1203                                 while (0) {
1204 fail:
1205                                         printk(KERN_ERR "aha1542_detect: setting bus on/off-time failed\n");
1206                                 }
1207                                 aha1542_intr_reset(base_io);
1208                         }
1209                         if (aha1542_query(base_io, &trans))
1210                                 goto unregister;
1211
1212                         if (aha1542_getconfig(base_io, &irq_level, &dma_chan, &scsi_id) == -1)
1213                                 goto unregister;
1214
1215                         printk(KERN_INFO "Configuring Adaptec (SCSI-ID %d) at IO:%x, IRQ %d", scsi_id, base_io, irq_level);
1216                         if (dma_chan != 0xFF)
1217                                 printk(", DMA priority %d", dma_chan);
1218                         printk("\n");
1219
1220                         DEB(aha1542_stat());
1221                         setup_mailboxes(base_io, shpnt);
1222
1223                         DEB(aha1542_stat());
1224
1225                         DEB(printk("aha1542_detect: enable interrupt channel %d\n", irq_level));
1226                         spin_lock_irqsave(&aha1542_lock, flags);
1227                         if (request_irq(irq_level, do_aha1542_intr_handle, 0, "aha1542", NULL)) {
1228                                 printk(KERN_ERR "Unable to allocate IRQ for adaptec controller.\n");
1229                                 spin_unlock_irqrestore(&aha1542_lock, flags);
1230                                 goto unregister;
1231                         }
1232                         if (dma_chan != 0xFF) {
1233                                 if (request_dma(dma_chan, "aha1542")) {
1234                                         printk(KERN_ERR "Unable to allocate DMA channel for Adaptec.\n");
1235                                         free_irq(irq_level, NULL);
1236                                         spin_unlock_irqrestore(&aha1542_lock, flags);
1237                                         goto unregister;
1238                                 }
1239                                 if (dma_chan == 0 || dma_chan >= 5) {
1240                                         set_dma_mode(dma_chan, DMA_MODE_CASCADE);
1241                                         enable_dma(dma_chan);
1242                                 }
1243                         }
1244                         aha_host[irq_level - 9] = shpnt;
1245                         shpnt->this_id = scsi_id;
1246                         shpnt->unique_id = base_io;
1247                         shpnt->io_port = base_io;
1248                         shpnt->n_io_port = 4;   /* Number of bytes of I/O space used */
1249                         shpnt->dma_channel = dma_chan;
1250                         shpnt->irq = irq_level;
1251                         HOSTDATA(shpnt)->bios_translation = trans;
1252                         if (trans == BIOS_TRANSLATION_25563)
1253                                 printk(KERN_INFO "aha1542.c: Using extended bios translation\n");
1254                         HOSTDATA(shpnt)->aha1542_last_mbi_used = (2 * AHA1542_MAILBOXES - 1);
1255                         HOSTDATA(shpnt)->aha1542_last_mbo_used = (AHA1542_MAILBOXES - 1);
1256                         memset(HOSTDATA(shpnt)->SCint, 0, sizeof(HOSTDATA(shpnt)->SCint));
1257                         spin_unlock_irqrestore(&aha1542_lock, flags);
1258 #if 0
1259                         DEB(printk(" *** READ CAPACITY ***\n"));
1260
1261                         {
1262                                 unchar buf[8];
1263                                 static unchar cmd[] = { READ_CAPACITY, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
1264                                 int i;
1265
1266                                 for (i = 0; i < sizeof(buf); ++i)
1267                                         buf[i] = 0x87;
1268                                 for (i = 0; i < 2; ++i)
1269                                         if (!aha1542_command(i, cmd, buf, sizeof(buf))) {
1270                                                 printk(KERN_DEBUG "aha_detect: LU %d sector_size %d device_size %d\n",
1271                                                        i, xscsi2int(buf + 4), xscsi2int(buf));
1272                                         }
1273                         }
1274
1275                         DEB(printk(" *** NOW RUNNING MY OWN TEST *** \n"));
1276
1277                         for (i = 0; i < 4; ++i) {
1278                                 unsigned char cmd[10];
1279                                 static buffer[512];
1280
1281                                 cmd[0] = READ_10;
1282                                 cmd[1] = 0;
1283                                 xany2scsi(cmd + 2, i);
1284                                 cmd[6] = 0;
1285                                 cmd[7] = 0;
1286                                 cmd[8] = 1;
1287                                 cmd[9] = 0;
1288                                 aha1542_command(0, cmd, buffer, 512);
1289                         }
1290 #endif
1291                         count++;
1292                         continue;
1293 unregister:
1294                         release_region(bases[indx], 4);
1295                         scsi_unregister(shpnt);
1296                         continue;
1297
1298                 };
1299
1300         return count;
1301 }
1302
1303 static int aha1542_release(struct Scsi_Host *shost)
1304 {
1305         if (shost->irq)
1306                 free_irq(shost->irq, NULL);
1307         if (shost->dma_channel != 0xff)
1308                 free_dma(shost->dma_channel);
1309         if (shost->io_port && shost->n_io_port)
1310                 release_region(shost->io_port, shost->n_io_port);
1311         scsi_unregister(shost);
1312         return 0;
1313 }
1314
1315 static int aha1542_restart(struct Scsi_Host *shost)
1316 {
1317         int i;
1318         int count = 0;
1319 #if 0
1320         unchar ahacmd = CMD_START_SCSI;
1321 #endif
1322
1323         for (i = 0; i < AHA1542_MAILBOXES; i++)
1324                 if (HOSTDATA(shost)->SCint[i] &&
1325                     !(HOSTDATA(shost)->SCint[i]->device->soft_reset)) {
1326 #if 0
1327                         HOSTDATA(shost)->mb[i].status = 1;      /* Indicate ready to restart... */
1328 #endif
1329                         count++;
1330                 }
1331         printk(KERN_DEBUG "Potential to restart %d stalled commands...\n", count);
1332 #if 0
1333         /* start scsi command */
1334         if (count)
1335                 aha1542_out(shost->io_port, &ahacmd, 1);
1336 #endif
1337         return 0;
1338 }
1339
1340 /*
1341  * This is a device reset.  This is handled by sending a special command
1342  * to the device.
1343  */
1344 static int aha1542_dev_reset(Scsi_Cmnd * SCpnt)
1345 {
1346         unsigned long flags;
1347         struct mailbox *mb;
1348         unchar target = SCpnt->device->id;
1349         unchar lun = SCpnt->device->lun;
1350         int mbo;
1351         struct ccb *ccb;
1352         unchar ahacmd = CMD_START_SCSI;
1353
1354         ccb = HOSTDATA(SCpnt->device->host)->ccb;
1355         mb = HOSTDATA(SCpnt->device->host)->mb;
1356
1357         spin_lock_irqsave(&aha1542_lock, flags);
1358         mbo = HOSTDATA(SCpnt->device->host)->aha1542_last_mbo_used + 1;
1359         if (mbo >= AHA1542_MAILBOXES)
1360                 mbo = 0;
1361
1362         do {
1363                 if (mb[mbo].status == 0 && HOSTDATA(SCpnt->device->host)->SCint[mbo] == NULL)
1364                         break;
1365                 mbo++;
1366                 if (mbo >= AHA1542_MAILBOXES)
1367                         mbo = 0;
1368         } while (mbo != HOSTDATA(SCpnt->device->host)->aha1542_last_mbo_used);
1369
1370         if (mb[mbo].status || HOSTDATA(SCpnt->device->host)->SCint[mbo])
1371                 panic("Unable to find empty mailbox for aha1542.\n");
1372
1373         HOSTDATA(SCpnt->device->host)->SCint[mbo] = SCpnt;      /* This will effectively
1374                                                            prevent someone else from
1375                                                            screwing with this cdb. */
1376
1377         HOSTDATA(SCpnt->device->host)->aha1542_last_mbo_used = mbo;
1378         spin_unlock_irqrestore(&aha1542_lock, flags);
1379
1380         any2scsi(mb[mbo].ccbptr, SCSI_BUF_PA(&ccb[mbo]));       /* This gets trashed for some reason */
1381
1382         memset(&ccb[mbo], 0, sizeof(struct ccb));
1383
1384         ccb[mbo].op = 0x81;     /* BUS DEVICE RESET */
1385
1386         ccb[mbo].idlun = (target & 7) << 5 | (lun & 7);         /*SCSI Target Id */
1387
1388         ccb[mbo].linkptr[0] = ccb[mbo].linkptr[1] = ccb[mbo].linkptr[2] = 0;
1389         ccb[mbo].commlinkid = 0;
1390
1391         /*
1392          * Now tell the 1542 to flush all pending commands for this
1393          * target
1394          */
1395         aha1542_out(SCpnt->device->host->io_port, &ahacmd, 1);
1396
1397         scmd_printk(KERN_WARNING, SCpnt,
1398                 "Trying device reset for target\n");
1399
1400         return SUCCESS;
1401
1402
1403 #ifdef ERIC_neverdef
1404         /*
1405          * With the 1542 we apparently never get an interrupt to
1406          * acknowledge a device reset being sent.  Then again, Leonard
1407          * says we are doing this wrong in the first place...
1408          *
1409          * Take a wait and see attitude.  If we get spurious interrupts,
1410          * then the device reset is doing something sane and useful, and
1411          * we will wait for the interrupt to post completion.
1412          */
1413         printk(KERN_WARNING "Sent BUS DEVICE RESET to target %d\n", SCpnt->target);
1414
1415         /*
1416          * Free the command block for all commands running on this
1417          * target...
1418          */
1419         for (i = 0; i < AHA1542_MAILBOXES; i++) {
1420                 if (HOSTDATA(SCpnt->host)->SCint[i] &&
1421                     HOSTDATA(SCpnt->host)->SCint[i]->target == SCpnt->target) {
1422                         Scsi_Cmnd *SCtmp;
1423                         SCtmp = HOSTDATA(SCpnt->host)->SCint[i];
1424                         kfree(SCtmp->host_scribble);
1425                         SCtmp->host_scribble = NULL;
1426                         HOSTDATA(SCpnt->host)->SCint[i] = NULL;
1427                         HOSTDATA(SCpnt->host)->mb[i].status = 0;
1428                 }
1429         }
1430         return SUCCESS;
1431
1432         return FAILED;
1433 #endif                          /* ERIC_neverdef */
1434 }
1435
1436 static int aha1542_bus_reset(Scsi_Cmnd * SCpnt)
1437 {
1438         int i;
1439
1440         /*
1441          * This does a scsi reset for all devices on the bus.
1442          * In principle, we could also reset the 1542 - should
1443          * we do this?  Try this first, and we can add that later
1444          * if it turns out to be useful.
1445          */
1446         outb(SCRST, CONTROL(SCpnt->device->host->io_port));
1447
1448         /*
1449          * Wait for the thing to settle down a bit.  Unfortunately
1450          * this is going to basically lock up the machine while we
1451          * wait for this to complete.  To be 100% correct, we need to
1452          * check for timeout, and if we are doing something like this
1453          * we are pretty desperate anyways.
1454          */
1455         ssleep(4);
1456
1457         spin_lock_irq(SCpnt->device->host->host_lock);
1458
1459         WAIT(STATUS(SCpnt->device->host->io_port),
1460              STATMASK, INIT | IDLE, STST | DIAGF | INVDCMD | DF | CDF);
1461
1462         /*
1463          * Now try to pick up the pieces.  For all pending commands,
1464          * free any internal data structures, and basically clear things
1465          * out.  We do not try and restart any commands or anything -
1466          * the strategy handler takes care of that crap.
1467          */
1468         printk(KERN_WARNING "Sent BUS RESET to scsi host %d\n", SCpnt->device->host->host_no);
1469
1470         for (i = 0; i < AHA1542_MAILBOXES; i++) {
1471                 if (HOSTDATA(SCpnt->device->host)->SCint[i] != NULL) {
1472                         Scsi_Cmnd *SCtmp;
1473                         SCtmp = HOSTDATA(SCpnt->device->host)->SCint[i];
1474
1475
1476                         if (SCtmp->device->soft_reset) {
1477                                 /*
1478                                  * If this device implements the soft reset option,
1479                                  * then it is still holding onto the command, and
1480                                  * may yet complete it.  In this case, we don't
1481                                  * flush the data.
1482                                  */
1483                                 continue;
1484                         }
1485                         kfree(SCtmp->host_scribble);
1486                         SCtmp->host_scribble = NULL;
1487                         HOSTDATA(SCpnt->device->host)->SCint[i] = NULL;
1488                         HOSTDATA(SCpnt->device->host)->mb[i].status = 0;
1489                 }
1490         }
1491
1492         spin_unlock_irq(SCpnt->device->host->host_lock);
1493         return SUCCESS;
1494
1495 fail:
1496         spin_unlock_irq(SCpnt->device->host->host_lock);
1497         return FAILED;
1498 }
1499
1500 static int aha1542_host_reset(Scsi_Cmnd * SCpnt)
1501 {
1502         int i;
1503
1504         /*
1505          * This does a scsi reset for all devices on the bus.
1506          * In principle, we could also reset the 1542 - should
1507          * we do this?  Try this first, and we can add that later
1508          * if it turns out to be useful.
1509          */
1510         outb(HRST | SCRST, CONTROL(SCpnt->device->host->io_port));
1511
1512         /*
1513          * Wait for the thing to settle down a bit.  Unfortunately
1514          * this is going to basically lock up the machine while we
1515          * wait for this to complete.  To be 100% correct, we need to
1516          * check for timeout, and if we are doing something like this
1517          * we are pretty desperate anyways.
1518          */
1519         ssleep(4);
1520         spin_lock_irq(SCpnt->device->host->host_lock);
1521
1522         WAIT(STATUS(SCpnt->device->host->io_port),
1523              STATMASK, INIT | IDLE, STST | DIAGF | INVDCMD | DF | CDF);
1524
1525         /*
1526          * We need to do this too before the 1542 can interact with
1527          * us again.
1528          */
1529         setup_mailboxes(SCpnt->device->host->io_port, SCpnt->device->host);
1530
1531         /*
1532          * Now try to pick up the pieces.  For all pending commands,
1533          * free any internal data structures, and basically clear things
1534          * out.  We do not try and restart any commands or anything -
1535          * the strategy handler takes care of that crap.
1536          */
1537         printk(KERN_WARNING "Sent BUS RESET to scsi host %d\n", SCpnt->device->host->host_no);
1538
1539         for (i = 0; i < AHA1542_MAILBOXES; i++) {
1540                 if (HOSTDATA(SCpnt->device->host)->SCint[i] != NULL) {
1541                         Scsi_Cmnd *SCtmp;
1542                         SCtmp = HOSTDATA(SCpnt->device->host)->SCint[i];
1543
1544                         if (SCtmp->device->soft_reset) {
1545                                 /*
1546                                  * If this device implements the soft reset option,
1547                                  * then it is still holding onto the command, and
1548                                  * may yet complete it.  In this case, we don't
1549                                  * flush the data.
1550                                  */
1551                                 continue;
1552                         }
1553                         kfree(SCtmp->host_scribble);
1554                         SCtmp->host_scribble = NULL;
1555                         HOSTDATA(SCpnt->device->host)->SCint[i] = NULL;
1556                         HOSTDATA(SCpnt->device->host)->mb[i].status = 0;
1557                 }
1558         }
1559
1560         spin_unlock_irq(SCpnt->device->host->host_lock);
1561         return SUCCESS;
1562
1563 fail:
1564         spin_unlock_irq(SCpnt->device->host->host_lock);
1565         return FAILED;
1566 }
1567
1568 #if 0
1569 /*
1570  * These are the old error handling routines.  They are only temporarily
1571  * here while we play with the new error handling code.
1572  */
1573 static int aha1542_old_abort(Scsi_Cmnd * SCpnt)
1574 {
1575 #if 0
1576         unchar ahacmd = CMD_START_SCSI;
1577         unsigned long flags;
1578         struct mailbox *mb;
1579         int mbi, mbo, i;
1580
1581         printk(KERN_DEBUG "In aha1542_abort: %x %x\n",
1582                inb(STATUS(SCpnt->host->io_port)),
1583                inb(INTRFLAGS(SCpnt->host->io_port)));
1584
1585         spin_lock_irqsave(&aha1542_lock, flags);
1586         mb = HOSTDATA(SCpnt->host)->mb;
1587         mbi = HOSTDATA(SCpnt->host)->aha1542_last_mbi_used + 1;
1588         if (mbi >= 2 * AHA1542_MAILBOXES)
1589                 mbi = AHA1542_MAILBOXES;
1590
1591         do {
1592                 if (mb[mbi].status != 0)
1593                         break;
1594                 mbi++;
1595                 if (mbi >= 2 * AHA1542_MAILBOXES)
1596                         mbi = AHA1542_MAILBOXES;
1597         } while (mbi != HOSTDATA(SCpnt->host)->aha1542_last_mbi_used);
1598         spin_unlock_irqrestore(&aha1542_lock, flags);
1599
1600         if (mb[mbi].status) {
1601                 printk(KERN_ERR "Lost interrupt discovered on irq %d - attempting to recover\n",
1602                        SCpnt->host->irq);
1603                 aha1542_intr_handle(SCpnt->host, NULL);
1604                 return 0;
1605         }
1606         /* OK, no lost interrupt.  Try looking to see how many pending commands
1607            we think we have. */
1608
1609         for (i = 0; i < AHA1542_MAILBOXES; i++)
1610                 if (HOSTDATA(SCpnt->host)->SCint[i]) {
1611                         if (HOSTDATA(SCpnt->host)->SCint[i] == SCpnt) {
1612                                 printk(KERN_ERR "Timed out command pending for %s\n",
1613                                        SCpnt->request->rq_disk ?
1614                                        SCpnt->request->rq_disk->disk_name : "?"
1615                                        );
1616                                 if (HOSTDATA(SCpnt->host)->mb[i].status) {
1617                                         printk(KERN_ERR "OGMB still full - restarting\n");
1618                                         aha1542_out(SCpnt->host->io_port, &ahacmd, 1);
1619                                 };
1620                         } else
1621                                 printk(KERN_ERR "Other pending command %s\n",
1622                                        SCpnt->request->rq_disk ?
1623                                        SCpnt->request->rq_disk->disk_name : "?"
1624                                        );
1625                 }
1626 #endif
1627
1628         DEB(printk("aha1542_abort\n"));
1629 #if 0
1630         spin_lock_irqsave(&aha1542_lock, flags);
1631         for (mbo = 0; mbo < AHA1542_MAILBOXES; mbo++) {
1632                 if (SCpnt == HOSTDATA(SCpnt->host)->SCint[mbo]) {
1633                         mb[mbo].status = 2;     /* Abort command */
1634                         aha1542_out(SCpnt->host->io_port, &ahacmd, 1);  /* start scsi command */
1635                         spin_unlock_irqrestore(&aha1542_lock, flags);
1636                         break;
1637                 }
1638         }
1639         if (AHA1542_MAILBOXES == mbo)
1640                 spin_unlock_irqrestore(&aha1542_lock, flags);
1641 #endif
1642         return SCSI_ABORT_SNOOZE;
1643 }
1644
1645 /* We do not implement a reset function here, but the upper level code
1646    assumes that it will get some kind of response for the command in
1647    SCpnt.  We must oblige, or the command will hang the scsi system.
1648    For a first go, we assume that the 1542 notifies us with all of the
1649    pending commands (it does implement soft reset, after all). */
1650
1651 static int aha1542_old_reset(Scsi_Cmnd * SCpnt, unsigned int reset_flags)
1652 {
1653         unchar ahacmd = CMD_START_SCSI;
1654         int i;
1655
1656         /*
1657          * See if a bus reset was suggested.
1658          */
1659         if (reset_flags & SCSI_RESET_SUGGEST_BUS_RESET) {
1660                 /*
1661                  * This does a scsi reset for all devices on the bus.
1662                  * In principle, we could also reset the 1542 - should
1663                  * we do this?  Try this first, and we can add that later
1664                  * if it turns out to be useful.
1665                  */
1666                 outb(HRST | SCRST, CONTROL(SCpnt->host->io_port));
1667
1668                 /*
1669                  * Wait for the thing to settle down a bit.  Unfortunately
1670                  * this is going to basically lock up the machine while we
1671                  * wait for this to complete.  To be 100% correct, we need to
1672                  * check for timeout, and if we are doing something like this
1673                  * we are pretty desperate anyways.
1674                  */
1675                 WAIT(STATUS(SCpnt->host->io_port),
1676                 STATMASK, INIT | IDLE, STST | DIAGF | INVDCMD | DF | CDF);
1677
1678                 /*
1679                  * We need to do this too before the 1542 can interact with
1680                  * us again.
1681                  */
1682                 setup_mailboxes(SCpnt->host->io_port, SCpnt->host);
1683
1684                 /*
1685                  * Now try to pick up the pieces.  Restart all commands
1686                  * that are currently active on the bus, and reset all of
1687                  * the datastructures.  We have some time to kill while
1688                  * things settle down, so print a nice message.
1689                  */
1690                 printk(KERN_WARNING "Sent BUS RESET to scsi host %d\n", SCpnt->host->host_no);
1691
1692                 for (i = 0; i < AHA1542_MAILBOXES; i++)
1693                         if (HOSTDATA(SCpnt->host)->SCint[i] != NULL) {
1694                                 Scsi_Cmnd *SCtmp;
1695                                 SCtmp = HOSTDATA(SCpnt->host)->SCint[i];
1696                                 SCtmp->result = DID_RESET << 16;
1697                                 kfree(SCtmp->host_scribble);
1698                                 SCtmp->host_scribble = NULL;
1699                                 printk(KERN_WARNING "Sending DID_RESET for target %d\n", SCpnt->target);
1700                                 SCtmp->scsi_done(SCpnt);
1701
1702                                 HOSTDATA(SCpnt->host)->SCint[i] = NULL;
1703                                 HOSTDATA(SCpnt->host)->mb[i].status = 0;
1704                         }
1705                 /*
1706                  * Now tell the mid-level code what we did here.  Since
1707                  * we have restarted all of the outstanding commands,
1708                  * then report SUCCESS.
1709                  */
1710                 return (SCSI_RESET_SUCCESS | SCSI_RESET_BUS_RESET);
1711 fail:
1712                 printk(KERN_CRIT "aha1542.c: Unable to perform hard reset.\n");
1713                 printk(KERN_CRIT "Power cycle machine to reset\n");
1714                 return (SCSI_RESET_ERROR | SCSI_RESET_BUS_RESET);
1715
1716
1717         } else {
1718                 /* This does a selective reset of just the one device */
1719                 /* First locate the ccb for this command */
1720                 for (i = 0; i < AHA1542_MAILBOXES; i++)
1721                         if (HOSTDATA(SCpnt->host)->SCint[i] == SCpnt) {
1722                                 HOSTDATA(SCpnt->host)->ccb[i].op = 0x81;        /* BUS DEVICE RESET */
1723                                 /* Now tell the 1542 to flush all pending commands for this target */
1724                                 aha1542_out(SCpnt->host->io_port, &ahacmd, 1);
1725
1726                                 /* Here is the tricky part.  What to do next.  Do we get an interrupt
1727                                    for the commands that we aborted with the specified target, or
1728                                    do we generate this on our own?  Try it without first and see
1729                                    what happens */
1730                                 printk(KERN_WARNING "Sent BUS DEVICE RESET to target %d\n", SCpnt->target);
1731
1732                                 /* If the first does not work, then try the second.  I think the
1733                                    first option is more likely to be correct. Free the command
1734                                    block for all commands running on this target... */
1735                                 for (i = 0; i < AHA1542_MAILBOXES; i++)
1736                                         if (HOSTDATA(SCpnt->host)->SCint[i] &&
1737                                             HOSTDATA(SCpnt->host)->SCint[i]->target == SCpnt->target) {
1738                                                 Scsi_Cmnd *SCtmp;
1739                                                 SCtmp = HOSTDATA(SCpnt->host)->SCint[i];
1740                                                 SCtmp->result = DID_RESET << 16;
1741                                                 kfree(SCtmp->host_scribble);
1742                                                 SCtmp->host_scribble = NULL;
1743                                                 printk(KERN_WARNING "Sending DID_RESET for target %d\n", SCpnt->target);
1744                                                 SCtmp->scsi_done(SCpnt);
1745
1746                                                 HOSTDATA(SCpnt->host)->SCint[i] = NULL;
1747                                                 HOSTDATA(SCpnt->host)->mb[i].status = 0;
1748                                         }
1749                                 return SCSI_RESET_SUCCESS;
1750                         }
1751         }
1752         /* No active command at this time, so this means that each time we got
1753            some kind of response the last time through.  Tell the mid-level code
1754            to request sense information in order to decide what to do next. */
1755         return SCSI_RESET_PUNT;
1756 }
1757 #endif    /* end of big comment block around old_abort + old_reset */
1758
1759 static int aha1542_biosparam(struct scsi_device *sdev,
1760                 struct block_device *bdev, sector_t capacity, int *ip)
1761 {
1762         int translation_algorithm;
1763         int size = capacity;
1764
1765         translation_algorithm = HOSTDATA(sdev->host)->bios_translation;
1766
1767         if ((size >> 11) > 1024 && translation_algorithm == BIOS_TRANSLATION_25563) {
1768                 /* Please verify that this is the same as what DOS returns */
1769                 ip[0] = 255;
1770                 ip[1] = 63;
1771                 ip[2] = size / 255 / 63;
1772         } else {
1773                 ip[0] = 64;
1774                 ip[1] = 32;
1775                 ip[2] = size >> 11;
1776         }
1777
1778         return 0;
1779 }
1780 MODULE_LICENSE("GPL");
1781
1782
1783 static struct scsi_host_template driver_template = {
1784         .proc_name              = "aha1542",
1785         .name                   = "Adaptec 1542",
1786         .detect                 = aha1542_detect,
1787         .release                = aha1542_release,
1788         .queuecommand           = aha1542_queuecommand,
1789         .eh_device_reset_handler= aha1542_dev_reset,
1790         .eh_bus_reset_handler   = aha1542_bus_reset,
1791         .eh_host_reset_handler  = aha1542_host_reset,
1792         .bios_param             = aha1542_biosparam,
1793         .can_queue              = AHA1542_MAILBOXES,
1794         .this_id                = 7,
1795         .sg_tablesize           = AHA1542_SCATTER,
1796         .cmd_per_lun            = AHA1542_CMDLUN,
1797         .unchecked_isa_dma      = 1,
1798         .use_clustering         = ENABLE_CLUSTERING,
1799 };
1800 #include "scsi_module.c"