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