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