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