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