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