linux/drivers/scsi/aha1542.c
<<
>>
Prefs
   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
  74static 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
  79static int setup_called[MAXBOARDS];
  80static int setup_buson[MAXBOARDS];
  81static int setup_busoff[MAXBOARDS];
  82static 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)
 102static bool isapnp = 0;
 103static int aha1542[] = {0x330, 11, 4, -1};
 104module_param_array(aha1542, int, NULL, 0);
 105module_param(isapnp, bool, 0);
 106
 107static 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
 116MODULE_DEVICE_TABLE(isapnp, id_table);
 117
 118#else
 119static 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
 126struct 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
 138static DEFINE_SPINLOCK(aha1542_lock);
 139
 140
 141
 142#define WAITnexttimeout 3000000
 143
 144static void setup_mailboxes(int base_io, struct Scsi_Host *shpnt);
 145static int aha1542_restart(struct Scsi_Host *shost);
 146static 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
 175static 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. */
 185static 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;
 213fail:
 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
 224static 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;
 235fail:
 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 */
 245static 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;
 256fail:
 257        spin_unlock_irqrestore(&aha1542_lock, flags);
 258        return 1;
 259}
 260
 261static 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
 317static 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 */
 381fail:
 382        return 0;               /* 0 = not ok */
 383}
 384
 385/* A quick wrapper for do_aha1542_intr_handle to grab the spin lock */
 386static 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 */
 398static 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
 558static 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
 718static DEF_SCSI_QCMD(aha1542_queuecommand)
 719
 720/* Initialize mailboxes */
 721static 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) {
 741fail:
 742                printk(KERN_ERR "aha1542_detect: failed setting up mailboxes\n");
 743        }
 744        aha1542_intr_reset(bse);
 745}
 746
 747static 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) {
 760fail:
 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
 816static 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) {
 843fail:
 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. */
 851static 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) {
 864fail:
 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
 891static char *setup_str[MAXBOARDS] __initdata;
 892static int setup_idx = 0;
 893
 894static 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
 950static 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 */
 966static 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) {
1085fail:
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;
1175unregister:
1176                        release_region(bases[indx], 4);
1177                        scsi_unregister(shpnt);
1178                        continue;
1179
1180                };
1181
1182        return count;
1183}
1184
1185static 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
1197static 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 */
1226static 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
1318static 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
1377fail:
1378        spin_unlock_irq(SCpnt->device->host->host_lock);
1379        return FAILED;
1380}
1381
1382static 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
1445fail:
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 */
1455static 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
1533static 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);
1593fail:
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
1641static 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}
1662MODULE_LICENSE("GPL");
1663
1664
1665static 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"
1683
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.