drivers/scsi/buslogic.c

/* */
This source file includes following definitions.
wait
buslogic_prefix
buslogic_stat
buslogic_out
buslogic_in
makecode
buslogic_info
buslogic_interrupt
buslogic_queuecommand
internal_done
buslogic_command
setup_mailboxes
getconfig
buslogic_query
buslogic_detect
restart
buslogic_abort
buslogic_reset
buslogic_biosparam
buslogic_setup
   1 /*
   2  *      buslogic.c      Copyright (C) 1993, 1994 David B. Gentzel
   3  *      Low-level scsi driver for BusLogic adapters
   4  *      by David B. Gentzel, Whitfield Software Services, Carnegie, PA
   5  *          (gentzel@nova.enet.dec.com)
   6  *      Thanks to BusLogic for providing the necessary documentation
   7  *
   8  *      The original version of this driver was derived from aha1542.[ch],
   9  *      which is Copyright (C) 1992 Tommy Thorn.  Much has been reworked, but
  10  *      most of basic structure and substantial chunks of code still remain.
  11  *
  12  *      Furthermore, many subsequent fixes and improvements to the aha1542
  13  *      driver have been folded back into this driver.  These changes to
  14  *      aha1542.[ch] are Copyright (C) 1993, 1994 Eric Youngdale.
  15  *
  16  *      Thanks to the following individuals who have made contributions (of
  17  *      (code, information, support, or testing) to this driver:
  18  *              Eric Youngdale          Leonard Zubkoff
  19  *              Tomas Hurka             Andrew Walker
  20  */
  21 
  22 /*
  23  * TODO:
  24  *      1. Clean up error handling & reporting.
  25  *      2. Find out why scatter/gather is limited to 16 requests per command.
  26  *      3. Test/improve/fix abort & reset functions.
  27  *      4. Look at command linking.
  28  *      5. Allow multiple boards to share an IRQ if the bus allows (EISA, MCA,
  29  *         and PCI).
  30  *      6. Avoid using the 445S workaround for board revs >= D.
  31  */
  32 
  33 /*
  34  * NOTES:
  35  *    BusLogic (formerly BusTek) manufactures an extensive family of
  36  *    intelligent, high performance SCSI-2 host adapters.  They all support
  37  *    command queueing and scatter/gather I/O.  Most importantly, they all
  38  *    support identical programming interfaces, so a single driver can be used
  39  *    for all boards.
  40  *
  41  *    Actually, they all support TWO identical programming interfaces!  They
  42  *    have an Adaptec 154x compatible interface (complete with 24 bit
  43  *    addresses) as well as a "native" 32 bit interface.  As such, the Linux
  44  *    aha1542 driver can be used to drive them, but with less than optimal
  45  *    performance (at least for the EISA, VESA, and MCA boards).
  46  *
  47  *    Here is the scoop on the various models:
  48  *      BT-542B - ISA first-party DMA with floppy support.
  49  *      BT-545S - 542B + FAST SCSI and active termination.
  50  *      BT-545D - 545S + differential termination.
  51  *      BT-640A - MCA bus-master with floppy support.
  52  *      BT-646S - 640A + FAST SCSI and active termination.
  53  *      BT-646D - 646S + differential termination.
  54  *      BT-742A - EISA bus-master with floppy support.
  55  *      BT-747S - 742A + FAST SCSI, active termination, and 2.88M floppy.
  56  *      BT-747D - 747S + differential termination.
  57  *      BT-757S - 747S + WIDE SCSI.
  58  *      BT-757D - 747D + WIDE SCSI.
  59  *      BT-445S - VESA bus-master FAST SCSI with active termination and floppy
  60  *                support.
  61  *      BT-445C - 445S + enhanced BIOS & firmware options.
  62  *      BT-946C - PCI bus-master FAST SCSI. (??? Nothing else known.)
  63  *
  64  *    ??? I believe other boards besides the 445 now have a "C" model, but I
  65  *    have no facts on them.
  66  *
  67  *    This driver SHOULD support all of these boards.  It has only been tested
  68  *    with a 747S and 445S.
  69  *
  70  *    Should you require further information on any of these boards, BusLogic
  71  *    can be reached at (408)492-9090.  Their BBS # is (408)492-1984 (maybe BBS
  72  *    stands for "Big Brother System"?).
  73  *
  74  *    Places flagged with a triple question-mark are things which are either
  75  *    unfinished, questionable, or wrong.
  76  */
  77 
  78 #ifdef MODULE
  79 #include <linux/module.h>
  80 #endif
  81 
  82 #include <linux/string.h>
  83 #include <linux/sched.h>
  84 #include <linux/kernel.h>
  85 #include <linux/head.h>
  86 #include <linux/types.h>
  87 #include <linux/ioport.h>
  88 #include <linux/delay.h>
  89 #include <linux/config.h>
  90 
  91 #include <asm/io.h>
  92 #include <asm/system.h>
  93 #include <asm/dma.h>
  94 
  95 #include "../block/blk.h"
  96 #include "scsi.h"
  97 #include "hosts.h"
  98 #include "sd.h"
  99 #define BUSLOGIC_PRIVATE_H      /* Get the "private" stuff */
 100 #include "buslogic.h"
 101 
 102 #ifndef BUSLOGIC_DEBUG
 103 # define BUSLOGIC_DEBUG 0
 104 #endif
 105 
 106 /* ??? Until kmalloc actually implements GFP_DMA, we can't depend on it... */
 107 #undef GFP_DMA
 108 
 109 /* If different port addresses are needed (e.g. to install more than two
 110    cards), you must define BUSLOGIC_PORT_OVERRIDE to be a comma-separated list
 111    of the addresses which will be checked.  This can also be used to resolve a
 112    conflict if the port-probing at a standard port causes problems with
 113    another board. */
 114 /* #define BUSLOGIC_PORT_OVERRIDE 0x330, 0x334, 0x130, 0x134, 0x230, 0x234 */
 115 
 116 /* Define this to be either BIOS_TRANSLATION_DEFAULT or BIOS_TRANSLATION_BIG
 117    if you wish to bypass the test for this, which uses an undocumented port.
 118    The test is believed to fail on at least some AMI BusLogic clones. */
 119 /* #define BIOS_TRANSLATION_OVERRIDE BIOS_TRANSLATION_BIG */
 120 
 121 #define BUSLOGIC_VERSION "1.14"
 122 
 123 /* Not a random value - if this is too large, the system hangs for a long time
 124    waiting for something to happen if a board is not installed. */
 125 /* ??? I don't really like this as it will wait longer on slow machines.
 126    Perhaps we should base this on the loops_per_second "Bogomips" value? */
 127 #define WAITNEXTTIMEOUT 3000000
 128 
 129 /* This is for the scsi_malloc call in buslogic_queuecommand. */
 130 /* ??? I'd up this to 4096, but would we be in danger of using up the
 131    scsi_malloc memory pool? */
 132 /* This could be a concern, I guess.  It may be possible to fix things so that
 133    the table generated in sd.c is compatible with the low-level code, but
 134    don't hold your breath.  -ERY */
 135 #define BUSLOGIC_SG_MALLOC 512
 136 
 137 /* Since the SG list is malloced, we have to limit the length. */
 138 #define BUSLOGIC_MAX_SG (BUSLOGIC_SG_MALLOC / sizeof (struct chain))
 139 
 140 /* ??? Arbitrary.  If we can dynamically allocate the mailbox arrays, I may
 141    bump up this number. */
 142 #define BUSLOGIC_MAILBOXES 16
 143 
 144 #define BUSLOGIC_CMDLUN 4               /* ??? Arbitrary */
 145 
 146 /* BusLogic boards can be configured for quite a number of port addresses (six
 147    to be exact), but I generally do not want the driver poking around at
 148    random.  We allow two port addresses - this allows people to use a BusLogic
 149    with a MIDI card, which frequently also uses 0x330.
 150 
 151    This can also be overridden on the command line to the kernel, via LILO or
 152    LOADLIN. */
 153 static unsigned short bases[7] = {
 154 #ifdef BUSLOGIC_PORT_OVERRIDE
 155     BUSLOGIC_PORT_OVERRIDE,
 156 #else
 157     0x330, 0x334, /* 0x130, 0x134, 0x230, 0x234, */
 158 #endif
 159     0
 160 };
 161 
 162 #define BIOS_TRANSLATION_DEFAULT 0      /* Default case */
 163 #define BIOS_TRANSLATION_BIG 1          /* Big disk (> 1G) case */
 164 
 165 struct hostdata {
 166     unsigned int bus_type;
 167     unsigned int bios_translation: 1;   /* BIOS mapping (for compatibility) */
 168     size_t last_mbi_used;
 169     size_t last_mbo_used;
 170     char model[7];
 171     char firmware_rev[6];
 172     Scsi_Cmnd *sc[BUSLOGIC_MAILBOXES];
 173     struct mailbox mb[2 * BUSLOGIC_MAILBOXES];
 174     struct ccb ccbs[BUSLOGIC_MAILBOXES];
 175 };
 176 
 177 #define HOSTDATA(host) ((struct hostdata *)&(host)->hostdata)
 178 
 179 /* One for each IRQ level (9-15), although 13 will never be used. */
 180 static struct Scsi_Host *host[7] = { NULL, };
 181 
 182 static int setup_mailboxes(unsigned int base, struct Scsi_Host *shpnt);
 183 static int restart(struct Scsi_Host *shpnt);
 184 
 185 #define INTR_RESET(base) outb(RINT, CONTROL(base))
 186 
 187 #define buslogic_printk buslogic_prefix(__PRETTY_FUNCTION__),printk
 188 
 189 #if defined(MODULE) && !defined(GFP_DMA)
 190 # define CHECK_DMA_ADDR(isa, addr, badstmt) \
 191     do { if ((isa) && (addr) > (void *)ISA_DMA_THRESHOLD) badstmt; } while (0)
 192 #else
 193 # define CHECK_DMA_ADDR(isa, addr, badstmt)
 194 #endif
 195 
 196 #define CHECK(cond) if (cond) ; else goto fail
 197 
 198 #define WAIT(port, allof, noneof) \
 199     CHECK(wait(port, allof, noneof, WAITNEXTTIMEOUT, FALSE))
 200 #define WAIT_WHILE(port, mask) WAIT(port, 0, mask)
 201 #define WAIT_UNTIL(port, mask) WAIT(port, mask, 0)
 202 #define WAIT_FAST(port, allof, noneof) \
 203     CHECK(wait(port, allof, noneof, 100, TRUE))
 204 #define WAIT_WHILE_FAST(port, mask) WAIT_FAST(port, 0, mask)
 205 #define WAIT_UNTIL_FAST(port, mask) WAIT_FAST(port, mask, 0)
 206 
 207 /* If delay != 0, we use the udelay call to regulate the amount of time we
 208    wait.
 209 
 210    This is inline as it is always called with constant arguments and hence
 211    will be very well optimized. */
 212 static __inline__ int wait(unsigned short port,
     /*  */
 213                            unsigned char allof, unsigned char noneof,
 214                            unsigned int timeout, int delay)
 215 {
 216     int bits;
 217 
 218     for (;;) {
 219         bits = inb(port);
 220         if ((bits & allof) == allof && (bits & noneof) == 0)
 221             return TRUE;
 222         if (delay)
 223             udelay(1000);
 224         if (--timeout == 0)
 225             return FALSE;
 226     }
 227 }
 228 
 229 static void buslogic_prefix(const char *func)
     /*  */
 230 {
 231     printk("BusLogic SCSI: %s: ", func);
 232 }
 233 
 234 static void buslogic_stat(unsigned int base)
     /*  */
 235 {
 236     int s = inb(STATUS(base)), i = inb(INTERRUPT(base));
 237 
 238     buslogic_printk("status=%02X intrflags=%02X\n", s, i);
 239 }
 240 
 241 /* This is a bit complicated, but we need to make sure that an interrupt
 242    routine does not send something out while we are in the middle of this.
 243    Fortunately, it is only at boot time that multi-byte messages are ever
 244    sent. */
 245 static int buslogic_out(unsigned int base, const unsigned char *cmdp,
     /*  */
 246                         size_t len)
 247 {
 248     unsigned long flags = 0;
 249     
 250     if (len == 1) {
 251         for (;;) {
 252             WAIT_WHILE(STATUS(base), CPRBSY);
 253             save_flags(flags);
 254             cli();
 255             if (!(inb(STATUS(base)) & CPRBSY)) {
 256                 outb(*cmdp, COMMAND_PARAMETER(base));
 257                 restore_flags(flags);
 258                 return FALSE;
 259             }
 260             restore_flags(flags);
 261         }
 262     } else {
 263         save_flags(flags);
 264         cli();
 265         while (len--) {
 266             WAIT_WHILE(STATUS(base), CPRBSY);
 267             outb(*cmdp++, COMMAND_PARAMETER(base));
 268         }
 269         restore_flags(flags);
 270     }
 271     return FALSE;
 272   fail:
 273     restore_flags(flags);
 274     buslogic_printk("failed(%u): ", len + 1);
 275     buslogic_stat(base);
 276     return TRUE;
 277 }
 278 
 279 /* Only used at boot time, so we do not need to worry about latency as much
 280    here.  This waits a very short period of time.  We use this if we are not
 281    sure whether the board will respond to the command we just sent. */
 282 static int buslogic_in(unsigned int base, unsigned char *cmdp, size_t len)
     /*  */
 283 {
 284     unsigned long flags;
 285     
 286     save_flags(flags);
 287     cli();
 288     while (len--) {
 289         WAIT_UNTIL_FAST(STATUS(base), DIRRDY);
 290         *cmdp++ = inb(DATA_IN(base));
 291     }
 292     restore_flags(flags);
 293     return FALSE;
 294   fail:
 295     restore_flags(flags);
 296 #if (BUSLOGIC_DEBUG & BD_IO)
 297     buslogic_printk("failed(%u): ", len + 1);
 298     buslogic_stat(base);
 299 #endif
 300     return TRUE;
 301 }
 302 
 303 static unsigned int makecode(unsigned int haerr, unsigned int scsierr)
     /*  */
 304 {
 305     unsigned int hosterr;
 306     const char *errstr = NULL;
 307 #if (BUSLOGIC_DEBUG & BD_ERRORS) && defined(CONFIG_SCSI_CONSTANTS)
 308     static const char *const buslogic_status[] = {
 309     /* 00 */    "Command completed normally",
 310     /* 01-07 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL,
 311     /* 08-09 */ NULL, NULL,
 312     /* 0A */    "Linked command completed normally",
 313     /* 0B */    "Linked command completed normally, interrupt generated",
 314     /* 0C-0F */ NULL, NULL, NULL, NULL,
 315     /* 10 */    NULL,
 316     /* 11 */    "Selection timed out",
 317     /* 12 */    "Data overrun/underrun",
 318     /* 13 */    "Unexpected bus free",
 319     /* 14 */    "Target bus phase sequence failure",
 320     /* 15 */    "First byte of outgoing MB was invalid",
 321     /* 16 */    "Invalid CCB Operation Code",
 322     /* 17 */    "Linked CCB does not have the same LUN",
 323     /* 18 */    "Invalid Target Direction received from Host",
 324     /* 19 */    "Duplicate CCB Received in Target Mode",
 325     /* 1A */    "Invalid CCB or Segment List Parameter",
 326     /* 1B */    "Auto request sense failed",
 327     /* 1C */    "SCSI-2 tagged queueing message was rejected by the target",
 328     /* 1D-1F */ NULL, NULL, NULL,
 329     /* 20 */    "Host adapter hardware failure",
 330     /* 21 */    "Target did not respond to SCSI ATN and the HA SCSI bus reset",
 331     /* 22 */    "Host adapter asserted a SCSI bus reset",
 332     /* 23 */    "Other SCSI devices asserted a SCSI bus reset",
 333     };
 334 #endif
 335 
 336     switch (haerr) {
 337       case 0x00:        /* Normal completion. */
 338       case 0x0A:        /* Linked command complete without error and linked
 339                            normally. */
 340       case 0x0B:        /* Linked command complete without error, interrupt
 341                            generated. */
 342         hosterr = DID_OK;
 343         break;
 344 
 345       case 0x11:        /* Selection time out: the initiator selection or
 346                            target reselection was not complete within the SCSI
 347                            time out period. */
 348         hosterr = DID_TIME_OUT;
 349         break;
 350 
 351       case 0x14:        /* Target bus phase sequence failure - An invalid bus
 352                            phase or bus phase sequence was requested by the
 353                            target.  The host adapter will generate a SCSI
 354                            Reset Condition, notifying the host with a RSTS
 355                            interrupt. */
 356       case 0x21:        /* The target did not respond to SCSI ATN and the host
 357                            adapter consequently issued a SCSI bus reset to
 358                            clear up the failure. */
 359       case 0x22:        /* The host adapter asserted a SCSI bus reset. */
 360         hosterr = DID_RESET;
 361         break;
 362 
 363       case 0x12:        /* Data overrun/underrun: the target attempted to
 364                            transfer more data than was allocated by the Data
 365                            Length field or the sum of the Scatter/Gather Data
 366                            Length fields. */
 367       case 0x13:        /* Unexpected bus free - The target dropped the SCSI
 368                            BSY at an unexpected time. */
 369       case 0x15:        /* MBO command was not 00, 01, or 02 - The first byte
 370                            of the MB was invalid.  This usually indicates a
 371                            software failure. */
 372       case 0x16:        /* Invalid CCB Operation Code - The first byte of the
 373                            CCB was invalid.  This usually indicates a software
 374                            failure. */
 375       case 0x17:        /* Linked CCB does not have the same LUN - A
 376                            subsequent CCB of a set of linked CCB's does not
 377                            specify the same logical unit number as the
 378                            first. */
 379       case 0x18:        /* Invalid Target Direction received from Host - The
 380                            direction of a Target Mode CCB was invalid. */
 381       case 0x19:        /* Duplicate CCB Received in Target Mode - More than
 382                            once CCB was received to service data transfer
 383                            between the same target LUN and initiator SCSI ID
 384                            in the same direction. */
 385       case 0x1A:        /* Invalid CCB or Segment List Parameter - A segment
 386                            list with a zero length segment or invalid segment
 387                            list boundaries was received.  A CCB parameter was
 388                            invalid. */
 389       case 0x1B:        /* Auto request sense failed. */
 390       case 0x1C:        /* SCSI-2 tagged queueing message was rejected by the
 391                            target. */
 392       case 0x20:        /* The host adapter hardware failed. */
 393       case 0x23:        /* Other SCSI devices asserted a SCSI bus reset. */
 394         hosterr = DID_ERROR;    /* ??? Couldn't find any better. */
 395         break;
 396 
 397       default:
 398 #ifndef CONFIG_SCSI_CONSTANTS
 399         errstr = "unknown hoststatus";
 400 #endif
 401         hosterr = DID_ERROR;
 402         break;
 403     }
 404 #if (BUSLOGIC_DEBUG & BD_ERRORS)
 405 # ifdef CONFIG_SCSI_CONSTANTS
 406     if (hosterr != DID_OK) {
 407         if (haerr < ARRAY_SIZE(buslogic_status))
 408             errstr = buslogic_status[haerr];
 409         if (errstr == NULL)
 410             errstr = "unknown hoststatus";
 411     }
 412 # else
 413     if (hosterr == DID_ERROR)
 414         errstr = "";
 415 # endif
 416 #endif
 417     if (errstr != NULL)
 418         buslogic_printk("%s (%02X)\n", errstr, haerr);
 419     return (hosterr << 16) | scsierr;
 420 }
 421 
 422 /* ??? this should really be "const struct Scsi_Host *" */
 423 const char *buslogic_info(struct Scsi_Host *shpnt)
     /*  */
 424 {
 425     return "BusLogic SCSI driver " BUSLOGIC_VERSION;
 426 }
 427 
 428 /* A "high" level interrupt handler. */
 429 static void buslogic_interrupt(int irq, struct pt_regs * regs)
     /*  */
 430 {
 431     void (*my_done)(Scsi_Cmnd *) = NULL;
 432     int errstatus, mbistatus = MBX_NOT_IN_USE, number_serviced, found;
 433     size_t mbi, mbo = 0;
 434     struct Scsi_Host *shpnt;
 435     Scsi_Cmnd *sctmp;
 436     unsigned long flags;
 437     int base, flag;
 438     int needs_restart;
 439     struct mailbox *mb;
 440     struct ccb *ccb;
 441 
 442     shpnt = host[irq - 9];
 443     if (!shpnt)
 444         panic("buslogic_interrupt: NULL SCSI host entry");
 445 
 446     mb = HOSTDATA(shpnt)->mb;
 447     ccb = HOSTDATA(shpnt)->ccbs;
 448     base = shpnt->io_port;
 449 
 450 #if (BUSLOGIC_DEBUG & BD_INTERRUPT)
 451     flag = inb(INTERRUPT(base));
 452 
 453     buslogic_printk("");
 454     if (!(flag & INTV))
 455         printk("no interrupt? ");
 456     if (flag & IMBL)
 457         printk("IMBL ");
 458     if (flag & MBOR)
 459         printk("MBOR ");
 460     if (flag & CMDC)
 461         printk("CMDC ");
 462     if (flag & RSTS)
 463         printk("RSTS ");
 464     printk("status %02X\n", inb(STATUS(base)));
 465 #endif
 466 
 467     number_serviced = 0;
 468     needs_restart = 0;
 469 
 470     for (;;) {
 471         flag = inb(INTERRUPT(base));
 472 
 473         /* Check for unusual interrupts.  If any of these happen, we should
 474            probably do something special, but for now just printing a message
 475            is sufficient.  A SCSI reset detected is something that we really
 476            need to deal with in some way. */
 477         if (flag & (MBOR | CMDC | RSTS)) {
 478             buslogic_printk("unusual flag:");
 479             if (flag & MBOR)
 480                 printk(" MBOR");
 481             if (flag & CMDC)
 482                 printk(" CMDC");
 483             if (flag & RSTS) {
 484                 needs_restart = 1;
 485                 printk(" RSTS");
 486             }
 487             printk("\n");
 488         }
 489 
 490         INTR_RESET(base);
 491 
 492         save_flags(flags);
 493         cli();
 494 
 495         mbi = HOSTDATA(shpnt)->last_mbi_used + 1;
 496         if (mbi >= 2 * BUSLOGIC_MAILBOXES)
 497             mbi = BUSLOGIC_MAILBOXES;
 498 
 499         /* I use the "found" variable as I like to keep cli/sti pairs at the
 500            same block level.  Debugging dropped sti's is no fun... */
 501 
 502         found = FALSE;
 503         do {
 504             if (mb[mbi].status != MBX_NOT_IN_USE) {
 505                 found = TRUE;
 506                 break;
 507             }
 508             mbi++;
 509             if (mbi >= 2 * BUSLOGIC_MAILBOXES)
 510                 mbi = BUSLOGIC_MAILBOXES;
 511         } while (mbi != HOSTDATA(shpnt)->last_mbi_used);
 512 
 513         if (found) {
 514             mbo = (struct ccb *)mb[mbi].ccbptr - ccb;
 515             mbistatus = mb[mbi].status;
 516             mb[mbi].status = MBX_NOT_IN_USE;
 517             HOSTDATA(shpnt)->last_mbi_used = mbi;
 518         }
 519 
 520         restore_flags(flags);
 521 
 522         if (!found) {
 523             /* Hmm, no mail.  Must have read it the last time around. */
 524             if (!number_serviced && !needs_restart)
 525                 buslogic_printk("interrupt received, but no mail.\n");
 526             /* We detected a reset.  Restart all pending commands for devices
 527                that use the hard reset option. */
 528             if (needs_restart)
 529                 restart(shpnt);
 530             return;
 531         }
 532 
 533 #if (BUSLOGIC_DEBUG & BD_INTERRUPT)
 534         if (ccb[mbo].tarstat || ccb[mbo].hastat)
 535             buslogic_printk("returning %08X (status %d).\n",
 536                             ((int)ccb[mbo].hastat << 16) | ccb[mbo].tarstat,
 537                             mb[mbi].status);
 538 #endif
 539 
 540         if (mbistatus == MBX_COMPLETION_NOT_FOUND)
 541             continue;
 542 
 543 #if (BUSLOGIC_DEBUG & BD_INTERRUPT)
 544         buslogic_printk("...done %u %u\n", mbo, mbi);
 545 #endif
 546 
 547         sctmp = HOSTDATA(shpnt)->sc[mbo];
 548 
 549         if (!sctmp || !sctmp->scsi_done) {
 550             buslogic_printk("unexpected interrupt.\n");
 551             buslogic_printk("tarstat=%02X, hastat=%02X id=%d lun=%d ccb#=%u\n",
 552                             ccb[mbo].tarstat, ccb[mbo].hastat,
 553                             ccb[mbo].id, ccb[mbo].lun, mbo);
 554             return;
 555         }
 556 
 557         my_done = sctmp->scsi_done;
 558         if (sctmp->host_scribble)
 559             scsi_free(sctmp->host_scribble, BUSLOGIC_SG_MALLOC);
 560 
 561         /* ??? more error checking left out here */
 562         if (mbistatus != MBX_COMPLETION_OK) {
 563             /* ??? This is surely wrong, but I don't know what's right. */
 564             errstatus = makecode(ccb[mbo].hastat, ccb[mbo].tarstat);
 565         } else
 566             errstatus = 0;
 567 
 568 #if (BUSLOGIC_DEBUG & BD_INTERRUPT)
 569         if (errstatus)
 570             buslogic_printk("error: %04X %04X\n",
 571                             ccb[mbo].hastat, ccb[mbo].tarstat);
 572 
 573         if (status_byte(ccb[mbo].tarstat) == CHECK_CONDITION) {
 574             size_t i;
 575 
 576             buslogic_printk("sense:");
 577             for (i = 0; i < sizeof sctmp->sense_buffer; i++)
 578                 printk(" %02X", sctmp->sense_buffer[i]);
 579             printk("\n");
 580         }
 581 
 582         if (errstatus)
 583             buslogic_printk("returning %08X.\n", errstatus);
 584 #endif
 585 
 586         sctmp->result = errstatus;
 587         HOSTDATA(shpnt)->sc[mbo] = NULL;        /* This effectively frees up
 588                                                    the mailbox slot, as far as
 589                                                    queuecommand is
 590                                                    concerned. */
 591         my_done(sctmp);
 592         number_serviced++;
 593     }
 594 }
 595 
 596 /* ??? Why does queuecommand return a value?  scsi.c never looks at it... */
 597 int buslogic_queuecommand(Scsi_Cmnd *scpnt, void (*done)(Scsi_Cmnd *))
     /*  */
 598 {
 599     static const unsigned char buscmd[] = { CMD_START_SCSI };
 600     unsigned char direction;
 601     unsigned char *cmd = (unsigned char *)scpnt->cmnd;
 602     unsigned char target = scpnt->target;
 603     unsigned char lun = scpnt->lun;
 604     void *buff = scpnt->request_buffer;
 605     int bufflen = scpnt->request_bufflen;
 606     int mbo;
 607     unsigned long flags;
 608     struct mailbox *mb;
 609     struct ccb *ccb;
 610     struct Scsi_Host *shpnt = scpnt->host;
 611 
 612 #if (BUSLOGIC_DEBUG & BD_COMMAND)
 613     if (target > 1) {
 614         scpnt->result = DID_TIME_OUT << 16;
 615         done(scpnt);
 616         return 0;
 617     }
 618 #endif
 619 
 620     if (*cmd == REQUEST_SENSE) {
 621 #if (BUSLOGIC_DEBUG & (BD_COMMAND | BD_ERRORS))
 622         if (bufflen != sizeof scpnt->sense_buffer) {
 623             buslogic_printk("wrong buffer length supplied for request sense"
 624                             " (%d).\n",
 625                             bufflen);
 626         }
 627 #endif
 628         scpnt->result = 0;
 629         done(scpnt);
 630         return 0;
 631     }
 632 
 633 #if (BUSLOGIC_DEBUG & BD_COMMAND)
 634     {
 635         int i;
 636 
 637         if (*cmd == READ_10 || *cmd == WRITE_10
 638             || *cmd == READ_6 || *cmd == WRITE_6)
 639             i = *(int *)(cmd + 2);
 640         else
 641             i = -1;
 642         buslogic_printk("dev %d cmd %02X pos %d len %d ",
 643                         target, *cmd, i, bufflen);
 644         buslogic_stat(shpnt->io_port);
 645         buslogic_printk("dumping scsi cmd:");
 646         for (i = 0; i < scpnt->cmd_len; i++)
 647             printk(" %02X", cmd[i]);
 648         printk("\n");
 649         if (*cmd == WRITE_10 || *cmd == WRITE_6)
 650             return 0;   /* we are still testing, so *don't* write */
 651     }
 652 #endif
 653 
 654     mb = HOSTDATA(shpnt)->mb;
 655     ccb = HOSTDATA(shpnt)->ccbs;
 656 
 657     /* Use the outgoing mailboxes in a round-robin fashion, because this
 658        is how the host adapter will scan for them. */
 659 
 660     save_flags(flags);
 661     cli();
 662 
 663     mbo = HOSTDATA(shpnt)->last_mbo_used + 1;
 664     if (mbo >= BUSLOGIC_MAILBOXES)
 665         mbo = 0;
 666 
 667     do {
 668         if (mb[mbo].status == MBX_NOT_IN_USE
 669             && HOSTDATA(shpnt)->sc[mbo] == NULL)
 670             break;
 671         mbo++;
 672         if (mbo >= BUSLOGIC_MAILBOXES)
 673             mbo = 0;
 674     } while (mbo != HOSTDATA(shpnt)->last_mbo_used);
 675 
 676     if (mb[mbo].status != MBX_NOT_IN_USE || HOSTDATA(shpnt)->sc[mbo]) {
 677         /* ??? Instead of failing, should we enable OMBR interrupts and sleep
 678            until we get one? */
 679         restore_flags(flags);
 680         buslogic_printk("unable to find empty mailbox.\n");
 681         goto fail;
 682     }
 683 
 684     HOSTDATA(shpnt)->sc[mbo] = scpnt;           /* This will effectively
 685                                                    prevent someone else from
 686                                                    screwing with this cdb. */
 687 
 688     HOSTDATA(shpnt)->last_mbo_used = mbo;
 689 
 690     restore_flags(flags);
 691 
 692 #if (BUSLOGIC_DEBUG & BD_COMMAND)
 693     buslogic_printk("sending command (%d %08X)...", mbo, done);
 694 #endif
 695 
 696     /* This gets trashed for some reason */
 697     mb[mbo].ccbptr = &ccb[mbo];
 698 
 699     memset(&ccb[mbo], 0, sizeof (struct ccb));
 700 
 701     ccb[mbo].cdblen = scpnt->cmd_len;           /* SCSI Command Descriptor
 702                                                    Block Length */
 703 
 704     direction = 0;
 705     if (*cmd == READ_10 || *cmd == READ_6)
 706         direction = 8;
 707     else if (*cmd == WRITE_10 || *cmd == WRITE_6)
 708         direction = 16;
 709 
 710     memcpy(ccb[mbo].cdb, cmd, ccb[mbo].cdblen);
 711 
 712     if (scpnt->use_sg) {
 713         struct scatterlist *sgpnt;
 714         struct chain *cptr;
 715         size_t i;
 716 
 717         ccb[mbo].op = CCB_OP_INIT_SG;   /* SCSI Initiator Command
 718                                            w/scatter-gather */
 719         scpnt->host_scribble
 720             = (unsigned char *)scsi_malloc(BUSLOGIC_SG_MALLOC);
 721         if (scpnt->host_scribble == NULL) {
 722             buslogic_printk("unable to allocate DMA memory.\n");
 723             goto fail;
 724         }
 725         sgpnt = (struct scatterlist *)scpnt->request_buffer;
 726         cptr = (struct chain *)scpnt->host_scribble;
 727         if (scpnt->use_sg > shpnt->sg_tablesize) {
 728             buslogic_printk("bad segment list, %d > %d.\n",
 729                             scpnt->use_sg, shpnt->sg_tablesize);
 730             goto fail;
 731         }
 732         for (i = 0; i < scpnt->use_sg; i++) {
 733             CHECK_DMA_ADDR(shpnt->unchecked_isa_dma, sgpnt[i].address,
 734                            goto baddma);
 735             cptr[i].dataptr = sgpnt[i].address;
 736             cptr[i].datalen = sgpnt[i].length;
 737         }
 738         ccb[mbo].datalen = scpnt->use_sg * sizeof (struct chain);
 739         ccb[mbo].dataptr = cptr;
 740 #if (BUSLOGIC_DEBUG & BD_COMMAND)
 741         {
 742             unsigned char *ptr;
 743 
 744             buslogic_printk("cptr %08X:", cptr);
 745             ptr = (unsigned char *)cptr;
 746             for (i = 0; i < 18; i++)
 747                 printk(" %02X", ptr[i]);
 748             printk("\n");
 749         }
 750 #endif
 751     } else {
 752         ccb[mbo].op = CCB_OP_INIT;      /* SCSI Initiator Command */
 753         scpnt->host_scribble = NULL;
 754         CHECK_DMA_ADDR(shpnt->unchecked_isa_dma, buff, goto baddma);
 755         ccb[mbo].datalen = bufflen;
 756         ccb[mbo].dataptr = buff;
 757     }
 758     ccb[mbo].id = target;
 759     ccb[mbo].lun = lun;
 760     ccb[mbo].dir = direction;
 761     ccb[mbo].rsalen = sizeof scpnt->sense_buffer;
 762     ccb[mbo].senseptr = scpnt->sense_buffer;
 763     ccb[mbo].linkptr = NULL;
 764     ccb[mbo].commlinkid = 0;
 765 
 766 #if (BUSLOGIC_DEBUG & BD_COMMAND)
 767     {
 768         size_t i;
 769 
 770         buslogic_printk("sending...");
 771         for (i = 0; i < sizeof ccb[mbo] - 10; i++)
 772             printk(" %02X", ((unsigned char *)&ccb[mbo])[i]);
 773         printk("\n");
 774     }
 775 #endif
 776 
 777     if (done) {
 778 #if (BUSLOGIC_DEBUG & BD_COMMAND)
 779         buslogic_printk("now waiting for interrupt: ");
 780         buslogic_stat(shpnt->io_port);
 781 #endif
 782         scpnt->scsi_done = done;
 783         mb[mbo].status = MBX_ACTION_START;
 784         /* start scsi command */
 785         buslogic_out(shpnt->io_port, buscmd, sizeof buscmd);
 786 #if (BUSLOGIC_DEBUG & BD_COMMAND)
 787         buslogic_stat(shpnt->io_port);
 788 #endif
 789     } else
 790         buslogic_printk("done can't be NULL.\n");
 791 
 792     while (0) {
 793 #if defined(MODULE) && !defined(GFP_DMA)
 794       baddma:
 795         buslogic_printk("address > 16MB used for ISA HA.\n");
 796 #endif
 797       fail:
 798         scpnt->result = DID_ERROR << 16;
 799         done(scpnt);
 800     }
 801 
 802     return 0;
 803 }
 804 
 805 #if 0
 806 static void internal_done(Scsi_Cmnd *scpnt)
     /*  */
 807 {
 808     scpnt->SCp.Status++;
 809 }
 810 
 811 int buslogic_command(Scsi_Cmnd *scpnt)
     /*  */
 812 {
 813 #if (BUSLOGIC_DEBUG & BD_COMMAND)
 814     buslogic_printk("calling buslogic_queuecommand.\n");
 815 #endif
 816 
 817     buslogic_queuecommand(scpnt, internal_done);
 818 
 819     scpnt->SCp.Status = 0;
 820     while (!scpnt->SCp.Status)
 821         continue;
 822     return scpnt->result;
 823 }
 824 #endif
 825 
 826 /* Initialize mailboxes. */
 827 static int setup_mailboxes(unsigned int base, struct Scsi_Host *shpnt)
     /*  */
 828 {
 829     size_t i;
 830     int ok = FALSE;             /* Innocent until proven guilty... */
 831     struct mailbox *mb = HOSTDATA(shpnt)->mb;
 832     struct ccb *ccb = HOSTDATA(shpnt)->ccbs;
 833     struct {
 834         unsigned char cmd, count;
 835         void *base PACKED;
 836     } cmd = { CMD_INITEXTMB, BUSLOGIC_MAILBOXES, mb };
 837 
 838     for (i = 0; i < BUSLOGIC_MAILBOXES; i++) {
 839         mb[i].status = mb[BUSLOGIC_MAILBOXES + i].status = MBX_NOT_IN_USE;
 840         mb[i].ccbptr = &ccb[i];
 841     }
 842     INTR_RESET(base);   /* reset interrupts, so they don't block */
 843 
 844     if (buslogic_out(base, (unsigned char *)&cmd, sizeof cmd))
 845         goto fail;
 846     WAIT_UNTIL(INTERRUPT(base), CMDC);
 847 
 848     ok = TRUE;
 849 
 850     while (0) {
 851       fail:
 852         buslogic_printk("failed setting up mailboxes.\n");
 853     }
 854 
 855     INTR_RESET(base);
 856 
 857     return !ok;
 858 }
 859 
 860 static int getconfig(unsigned int base, unsigned char *irq,
     /*  */
 861                      unsigned char *dma, unsigned char *id,
 862                      char *bus_type, unsigned short *max_sg,
 863                      const unsigned char **bios)
 864 {
 865     unsigned char inquiry_cmd[2];
 866     unsigned char inquiry_result[4];
 867     int i;
 868 
 869 #if (BUSLOGIC_DEBUG & BD_DETECT)
 870     buslogic_printk("called\n");
 871 #endif
 872 
 873     i = inb(STATUS(base));
 874     if (i & DIRRDY)
 875         i = inb(DATA_IN(base));
 876     inquiry_cmd[0] = CMD_RETCONF;
 877     buslogic_out(base, inquiry_cmd, 1);
 878     if (buslogic_in(base, inquiry_result, 3))
 879         goto fail;
 880     WAIT_UNTIL_FAST(INTERRUPT(base), CMDC);
 881     INTR_RESET(base);
 882     /* Defer using the DMA value until we know the bus type. */
 883     *dma = inquiry_result[0];
 884     switch (inquiry_result[1]) {
 885       case 0x01:
 886         *irq = 9;
 887         break;
 888       case 0x02:
 889         *irq = 10;
 890         break;
 891       case 0x04:
 892         *irq = 11;
 893         break;
 894       case 0x08:
 895         *irq = 12;
 896         break;
 897       case 0x20:
 898         *irq = 14;
 899         break;
 900       case 0x40:
 901         *irq = 15;
 902         break;
 903       default:
 904         buslogic_printk("unable to determine BusLogic IRQ level, "
 905                         " disabling board.\n");
 906         goto fail;
 907     }
 908     *id = inquiry_result[2] & 0x7;
 909 
 910     /* I expected Adaptec boards to fail on this, but it doesn't happen... */
 911     inquiry_cmd[0] = CMD_INQEXTSETUP;
 912     inquiry_cmd[1] = 4;
 913     if (buslogic_out(base, inquiry_cmd, 2))
 914         goto fail;
 915     if (buslogic_in(base, inquiry_result, inquiry_cmd[1]))
 916         goto fail;
 917     WAIT_UNTIL_FAST(INTERRUPT(base), CMDC);
 918     if (inb(STATUS(base)) & CMDINV)
 919         goto fail;
 920     INTR_RESET(base);
 921 
 922     *bus_type = inquiry_result[0];
 923     CHECK(*bus_type == 'A' || *bus_type == 'E' || *bus_type == 'M');
 924 
 925     *bios = (const unsigned char *)((unsigned int)inquiry_result[1] << 12);
 926 
 927     *max_sg = (inquiry_result[3] << 8) | inquiry_result[2];
 928 
 929     /* We only need a DMA channel for ISA boards.  Some other types of boards
 930        (such as the 747S) have an option to report a DMA channel even though
 931        none is used (for compatibility with Adaptec drivers which require a
 932        DMA channel).  We ignore this. */
 933     if (*bus_type == 'A')
 934         switch (*dma) {
 935           case 0:       /* This indicates that no DMA channel is used. */
 936             *dma = 0;
 937             break;
 938           case 0x20:
 939             *dma = 5;
 940             break;
 941           case 0x40:
 942             *dma = 6;
 943             break;
 944           case 0x80:
 945             *dma = 7;
 946             break;
 947           default:
 948             buslogic_printk("unable to determine BusLogic DMA channel,"
 949                             " disabling board.\n");
 950             goto fail;
 951         }
 952     else
 953         *dma = 0;
 954 
 955     while (0) {
 956       fail:
 957 #if (BUSLOGIC_DEBUG & BD_DETECT)
 958         buslogic_printk("query board settings\n");
 959 #endif
 960         return TRUE;
 961     }
 962 
 963     return FALSE;
 964 }
 965 
 966 /* Query the board.  This acts both as part of the detection sequence and as a
 967    means to get necessary configuration information. */
 968 static int buslogic_query(unsigned int base, unsigned char *trans,
     /*  */
 969                           unsigned char *irq, unsigned char *dma,
 970                           unsigned char *id, char *bus_type,
 971                           unsigned short *max_sg, const unsigned char **bios,
 972                           char *model, char *firmware_rev)
 973 {
 974     unsigned char inquiry_cmd[2];
 975     unsigned char inquiry_result[6];
 976     unsigned char geo;
 977     unsigned int i;
 978 
 979 #if (BUSLOGIC_DEBUG & BD_DETECT)
 980     buslogic_printk("called\n");
 981 #endif
 982 
 983     /* Quick and dirty test for presence of the card. */
 984     if (inb(STATUS(base)) == 0xFF)
 985         goto fail;
 986 
 987     /* Check the GEOMETRY port early for quick bailout on Adaptec boards. */
 988     geo = inb(GEOMETRY(base));
 989 #if (BUSLOGIC_DEBUG & BD_DETECT)
 990     buslogic_printk("geometry bits: %02X\n", geo);
 991 #endif
 992     /* Here is where we tell the men from the boys (i.e. Adaptec's don't
 993        support the GEOMETRY port, the men do :-) */
 994     if (geo == 0xFF)
 995         goto fail;
 996 
 997     /* In case some other card was probing here, reset interrupts. */
 998     INTR_RESET(base);
 999 
1000     /* Reset the adapter.  I ought to make a hard reset, but it's not really
1001        necessary. */
1002     outb(RSOFT | RINT/* | RSBUS*/, CONTROL(base));
1003 
1004     /* Wait a little bit for things to settle down. */
1005     i = jiffies + 2;
1006     while (i > jiffies);
1007 
1008     /* Expect INREQ and HARDY, any of the others are bad. */
1009     WAIT(STATUS(base), INREQ | HARDY, DACT | DFAIL | CMDINV | DIRRDY | CPRBSY);
1010 
1011     /* Shouldn't have generated any interrupts during reset. */
1012     if (inb(INTERRUPT(base)) & INTRMASK)
1013         goto fail;
1014 
1015     /* Getting the BusLogic firmware revision level is a bit tricky.  We get
1016        the first two digits (d.d) from CMD_INQUIRY and then use two undocumented
1017        commands to get the remaining digit and letter (d.ddl as in 3.31C). */
1018 
1019     inquiry_cmd[0] = CMD_INQUIRY;
1020     buslogic_out(base, inquiry_cmd, 1);
1021     if (buslogic_in(base, inquiry_result, 4))
1022         goto fail;
1023     /* Reading port should reset DIRRDY. */
1024     if (inb(STATUS(base)) & DIRRDY)
1025         goto fail;
1026     WAIT_UNTIL_FAST(INTERRUPT(base), CMDC);
1027     INTR_RESET(base);
1028     firmware_rev[0] = inquiry_result[2];
1029     firmware_rev[1] = '.';
1030     firmware_rev[2] = inquiry_result[3];
1031     firmware_rev[3] = '\0';
1032 #if 0
1033     buslogic_printk("inquiry bytes: %02X(%c) %02X(%c)\n",
1034                     inquiry_result[0], inquiry_result[0],
1035                     inquiry_result[1], inquiry_result[1]);
1036 #endif
1037 
1038     if (getconfig(base, irq, dma, id, bus_type, max_sg, bios))
1039         goto fail;
1040 
1041     /* Set up defaults */
1042 #ifdef BIOS_TRANSLATION_OVERRIDE
1043     *trans = BIOS_TRANSLATION_OVERRIDE;
1044 #else
1045     *trans = BIOS_TRANSLATION_DEFAULT;
1046 #endif
1047     model[0] = '\0';
1048     model[6] = 0;
1049 
1050     /* ??? Begin undocumented command use.
1051        These may not be supported by clones. */
1052 
1053     do {
1054         /* ??? It appears as though AMI BusLogic clones don't implement this
1055            feature.  As an experiment, if we read a 00 we ignore the GEO_GT_1GB
1056            bit and skip all further undocumented commands. */
1057         if (geo == 0x00)
1058             break;
1059 #ifndef BIOS_TRANSLATION_OVERRIDE
1060         *trans = ((geo & GEO_GT_1GB)
1061                   ? BIOS_TRANSLATION_BIG : BIOS_TRANSLATION_DEFAULT);
1062 #endif
1063 
1064         inquiry_cmd[0] = CMD_VER_NO_LAST;
1065         buslogic_out(base, inquiry_cmd, 1);
1066         if (buslogic_in(base, inquiry_result, 1))
1067             break;
1068         WAIT_UNTIL_FAST(INTERRUPT(base), CMDC);
1069         INTR_RESET(base);
1070         firmware_rev[3] = inquiry_result[0];
1071         firmware_rev[4] = '\0';
1072 
1073         inquiry_cmd[0] = CMD_VER_NO_LETTER;
1074         buslogic_out(base, inquiry_cmd, 1);
1075         if (buslogic_in(base, inquiry_result, 1))
1076             break;
1077         WAIT_UNTIL_FAST(INTERRUPT(base), CMDC);
1078         INTR_RESET(base);
1079         firmware_rev[4] = inquiry_result[0];
1080         firmware_rev[5] = '\0';
1081 
1082         /* Use undocumented command to get model number and revision. */
1083 
1084         inquiry_cmd[0] = CMD_RET_MODEL_NO;
1085         inquiry_cmd[1] = 6;
1086         buslogic_out(base, inquiry_cmd, 2);
1087         if (buslogic_in(base, inquiry_result, inquiry_cmd[1]))
1088             break;
1089         WAIT_UNTIL_FAST(INTERRUPT(base), CMDC);
1090         INTR_RESET(base);
1091         memcpy(model, inquiry_result, 5);
1092         model[5] = '\0';
1093         model[6] = inquiry_result[5];
1094     } while (0);
1095 
1096     /* ??? End undocumented command use. */
1097 
1098     /* bus_type from getconfig doesn't differentiate between EISA/VESA.  We
1099        override using the model number here. */
1100     switch (*bus_type) {
1101       case 'E':
1102         switch (model[0]) {
1103           case '4':
1104             *bus_type = 'V';
1105             break;
1106           case '9':
1107             *bus_type = 'P';
1108             break;
1109           case '7':
1110             break;
1111           default:
1112             *bus_type = 'X';
1113             break;
1114         }
1115         break;
1116       default:
1117         break;
1118     }
1119 
1120     while (0) {
1121       fail:
1122 #if (BUSLOGIC_DEBUG & BD_DETECT)
1123         buslogic_printk("query board settings\n");
1124 #endif
1125         return TRUE;
1126     }
1127 
1128     return FALSE;
1129 }
1130 
1131 /* return non-zero on detection */
1132 int buslogic_detect(Scsi_Host_Template *tpnt)
     /*  */
1133 {
1134     unsigned char dma;
1135     unsigned char irq;
1136     unsigned int base;
1137     unsigned char id;
1138     char bus_type;
1139     unsigned short max_sg;
1140     unsigned char bios_translation;
1141     unsigned long flags;
1142     const unsigned char *bios;
1143     char *model;
1144     char *firmware_rev;
1145     struct Scsi_Host *shpnt;
1146     size_t indx;
1147     int unchecked_isa_dma;
1148     int count = 0;
1149 
1150 #if (BUSLOGIC_DEBUG & BD_DETECT)
1151     buslogic_printk("called\n");
1152 #endif
1153 
1154     tpnt->can_queue = BUSLOGIC_MAILBOXES;
1155     for (indx = 0; bases[indx] != 0; indx++)
1156         if (!check_region(bases[indx], 4)) {
1157             shpnt = scsi_register(tpnt, sizeof (struct hostdata));
1158 
1159             base = bases[indx];
1160 
1161             model = HOSTDATA(shpnt)->model;
1162             firmware_rev = HOSTDATA(shpnt)->firmware_rev;
1163             if (buslogic_query(base, &bios_translation, &irq, &dma, &id,
1164                                &bus_type, &max_sg, &bios, model, firmware_rev))
1165                 goto unregister;
1166 
1167 #if (BUSLOGIC_DEBUG & BD_DETECT)
1168             buslogic_stat(base);
1169 #endif
1170 
1171             /* Only type 'A' (AT/ISA) bus adapters use unchecked DMA. */
1172             unchecked_isa_dma = (bus_type == 'A');
1173 #ifndef CONFIG_NO_BUGGY_BUSLOGIC
1174             /* There is a hardware bug in the BT-445S prior to revision D.
1175                When the BIOS is enabled and you have more than 16MB of memory,
1176                the card mishandles memory transfers over 16MB which (if viewed
1177                as a 24-bit address) overlap with the BIOS address space.  For
1178                example if you have the BIOS located at physical address
1179                0xDC000 and a DMA transfer from the card to RAM starts at
1180                physical address 0x10DC000 then the transfer is messed up.  To
1181                be more precise every fourth byte of the transfer is messed up.
1182                (This analysis courtesy of Tomas Hurka, author of the NeXTSTEP
1183                BusLogic driver.) */
1184 
1185             if (bus_type == 'V'                             /* 445 */
1186                 && firmware_rev[0] <= '3'                   /* S */
1187                 && bios != NULL) {                          /* BIOS enabled */
1188 #if 1
1189                 /* Now that LNZ's forbidden_addr stuff is in the higher level
1190                    scsi code, we can use this instead. */
1191                 /* Avoid addresses which "mirror" the BIOS for DMA. */
1192                 shpnt->forbidden_addr = (unsigned long)bios;
1193                 shpnt->forbidden_size = 16 * 1024;
1194 #else
1195                 /* Use double-buffering. */
1196                 unchecked_isa_dma = TRUE;
1197 #endif
1198             }
1199 #endif
1200 
1201             CHECK_DMA_ADDR(unchecked_isa_dma, shpnt, goto unregister);
1202 
1203             if (setup_mailboxes(base, shpnt))
1204                 goto unregister;
1205 
1206             /* Set the Bus on/off-times as not to ruin floppy performance.
1207                CMD_BUSOFF_TIME is a noop for EISA boards (and possibly
1208                others???). */
1209             if (bus_type != 'E' && bus_type != 'P') {
1210                 /* The default ON/OFF times for BusLogic adapters is 7/4. */
1211                 static const unsigned char oncmd[] = { CMD_BUSON_TIME, 7 };
1212                 static const unsigned char offcmd[] = { CMD_BUSOFF_TIME, 5 };
1213 
1214                 INTR_RESET(base);
1215                 buslogic_out(base, oncmd, sizeof oncmd);
1216                 WAIT_UNTIL(INTERRUPT(base), CMDC);
1217                 INTR_RESET(base);
1218                 buslogic_out(base, offcmd, sizeof offcmd);
1219                 WAIT_UNTIL(INTERRUPT(base), CMDC);
1220                 while (0) {
1221                   fail:
1222                     buslogic_printk("setting bus on/off-time failed.\n");
1223                 }
1224                 INTR_RESET(base);
1225             }
1226 
1227             buslogic_printk("configuring %s HA at port 0x%03X, IRQ %u",
1228                             (bus_type == 'A' ? "ISA"
1229                              : (bus_type == 'E' ? "EISA"
1230                                 : (bus_type == 'M' ? "MCA"
1231                                    : (bus_type == 'P' ? "PCI"
1232                                       : (bus_type == 'V' ? "VESA"
1233                                          : (bus_type == 'X' ? "EISA/VESA/PCI"
1234                                             : "Unknown")))))),
1235                             base, irq);
1236             if (bios != NULL)
1237                 printk(", BIOS 0x%05X", (unsigned int)bios);
1238             if (dma != 0)
1239                 printk(", DMA %u", dma);
1240             printk(", ID %u\n", id);
1241             buslogic_printk("Model Number: %s",
1242                             (model[0] ? model : "Unknown"));
1243             if (model[0])
1244                 printk(" (revision %d)", model[6]);
1245             printk("\n");
1246             buslogic_printk("firmware revision: %s\n", firmware_rev);
1247 
1248 #if (BUSLOGIC_DEBUG & BD_DETECT)
1249             buslogic_stat(base);
1250 #endif
1251 
1252 #if (BUSLOGIC_DEBUG & BD_DETECT)
1253             buslogic_printk("enable interrupt channel %d.\n", irq);
1254 #endif
1255 
1256             save_flags(flags);
1257             cli();
1258             if (request_irq(irq, buslogic_interrupt, 0, "buslogic")) {
1259                 buslogic_printk("unable to allocate IRQ for "
1260                                 "BusLogic controller.\n");
1261                 restore_flags(flags);
1262                 goto unregister;
1263             }
1264 
1265             if (dma) {
1266                 if (request_dma(dma, "buslogic")) {
1267                     buslogic_printk("unable to allocate DMA channel for "
1268                                     "BusLogic controller.\n");
1269                     free_irq(irq);
1270                     restore_flags(flags);
1271                     goto unregister;
1272                 }
1273 
1274                 /* The DMA-Controller.  We need to fool with this because we
1275                    want to be able to use an ISA BusLogic without having to
1276                    have the BIOS enabled. */
1277                 set_dma_mode(dma, DMA_MODE_CASCADE);
1278                 enable_dma(dma);
1279             }
1280 
1281             host[irq - 9] = shpnt;
1282             shpnt->this_id = id;
1283             shpnt->unchecked_isa_dma = unchecked_isa_dma;
1284             /* Have to keep cmd_per_lun at 1 for ISA machines otherwise lots
1285                of memory gets sucked up for bounce buffers.  */
1286             shpnt->cmd_per_lun = (unchecked_isa_dma ? 1 : BUSLOGIC_CMDLUN);
1287             shpnt->sg_tablesize = max_sg;
1288             if (shpnt->sg_tablesize > BUSLOGIC_MAX_SG)
1289                 shpnt->sg_tablesize = BUSLOGIC_MAX_SG;
1290             /* ??? shpnt->base should really be "const unsigned char *"... */
1291             shpnt->base = (unsigned char *)bios;
1292             shpnt->io_port = base;
1293             shpnt->n_io_port = 4;       /* Number of bytes of I/O space used */
1294             shpnt->dma_channel = dma;
1295             shpnt->irq = irq;
1296             HOSTDATA(shpnt)->bios_translation = bios_translation;
1297             if (bios_translation == BIOS_TRANSLATION_BIG)
1298                 buslogic_printk("using extended bios translation.\n");
1299             HOSTDATA(shpnt)->last_mbi_used = 2 * BUSLOGIC_MAILBOXES - 1;
1300             HOSTDATA(shpnt)->last_mbo_used = BUSLOGIC_MAILBOXES - 1;
1301             memset(HOSTDATA(shpnt)->sc, 0, sizeof HOSTDATA(shpnt)->sc);
1302             restore_flags(flags);
1303 
1304 #if 0
1305             {
1306                 unsigned char buf[8];
1307                 unsigned char cmd[]
1308                     = { READ_CAPACITY, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
1309                 size_t i;
1310 
1311 #if (BUSLOGIC_DEBUG & BD_DETECT)
1312                 buslogic_printk("*** READ CAPACITY ***\n");
1313 #endif
1314                 for (i = 0; i < sizeof buf; i++)
1315                     buf[i] = 0x87;
1316                 for (i = 0; i < 2; i++)
1317                     if (!buslogic_command(i, cmd, buf, sizeof buf)) {
1318                         buslogic_printk("LU %u sector_size %d device_size %d\n",
1319                                         i, *(int *)(buf + 4), *(int *)buf);
1320                     }
1321 
1322 #if (BUSLOGIC_DEBUG & BD_DETECT)
1323                 buslogic_printk("*** NOW RUNNING MY OWN TEST ***\n");
1324 #endif
1325                 for (i = 0; i < 4; i++) {
1326                     static buffer[512];
1327 
1328                     cmd[0] = READ_10;
1329                     cmd[1] = 0;
1330                     xany2scsi(cmd + 2, i);
1331                     cmd[6] = 0;
1332                     cmd[7] = 0;
1333                     cmd[8] = 1;
1334                     cmd[9] = 0;
1335                     buslogic_command(0, cmd, buffer, sizeof buffer);
1336                 }
1337             }
1338 #endif
1339 
1340             request_region(bases[indx], 4,"buslogic");
1341             /* Register the IO ports that we use */
1342             count++;
1343             continue;
1344           unregister:
1345             scsi_unregister(shpnt);
1346         }
1347     return count;
1348 }
1349 
1350 static int restart(struct Scsi_Host *shpnt)
     /*  */
1351 {
1352     unsigned int i;
1353     unsigned int count = 0;
1354 #if 0
1355     static const unsigned char buscmd[] = { CMD_START_SCSI };
1356 #endif
1357 
1358     for (i = 0; i < BUSLOGIC_MAILBOXES; i++)
1359         if (HOSTDATA(shpnt)->sc[i]
1360             && !HOSTDATA(shpnt)->sc[i]->device->soft_reset) {
1361 #if 0
1362             HOSTDATA(shpnt)->mb[i].status
1363                 = MBX_ACTION_START;     /* Indicate ready to restart... */
1364 #endif
1365             count++;
1366         }
1367 
1368     buslogic_printk("potential to restart %d stalled commands...\n", count);
1369 #if 0
1370     /* start scsi command */
1371     if (count)
1372         buslogic_out(shpnt->host->io_port, buscmd, sizeof buscmd);
1373 #endif
1374     return 0;
1375 }
1376 
1377 /* ??? The abort command for the aha1542 does not leave the device in a clean
1378    state where it is available to be used again.  As it is not clear whether
1379    the same problem exists with BusLogic boards, we will enable this and see
1380    if it works. */
1381 int buslogic_abort(Scsi_Cmnd *scpnt)
     /*  */
1382 {
1383 #if 1
1384     static const unsigned char buscmd[] = { CMD_START_SCSI };
1385     struct mailbox *mb;
1386     size_t mbi, mbo;
1387     unsigned long flags;
1388     unsigned int i;
1389 
1390     buslogic_printk("%X %X\n",
1391                     inb(STATUS(scpnt->host->io_port)),
1392                     inb(INTERRUPT(scpnt->host->io_port)));
1393 
1394     save_flags(flags);
1395     cli();
1396     mb = HOSTDATA(scpnt->host)->mb;
1397     mbi = HOSTDATA(scpnt->host)->last_mbi_used + 1;
1398     if (mbi >= 2 * BUSLOGIC_MAILBOXES)
1399         mbi = BUSLOGIC_MAILBOXES;
1400 
1401     do {
1402         if (mb[mbi].status != MBX_NOT_IN_USE)
1403             break;
1404         mbi++;
1405         if (mbi >= 2 * BUSLOGIC_MAILBOXES)
1406             mbi = BUSLOGIC_MAILBOXES;
1407     } while (mbi != HOSTDATA(scpnt->host)->last_mbi_used);
1408     restore_flags(flags);
1409 
1410     if (mb[mbi].status != MBX_NOT_IN_USE) {
1411         buslogic_printk("lost interrupt discovered on irq %d"
1412                         " - attempting to recover...\n",
1413                         scpnt->host->irq);
1414         {
1415             buslogic_interrupt(scpnt->host->irq, NULL);
1416             return SCSI_ABORT_SUCCESS;
1417         }
1418     }
1419 
1420     /* OK, no lost interrupt.  Try looking to see how many pending commands we
1421        think we have. */
1422     for (i = 0; i < BUSLOGIC_MAILBOXES; i++)
1423         if (HOSTDATA(scpnt->host)->sc[i]) {
1424             if (HOSTDATA(scpnt->host)->sc[i] == scpnt) {
1425                 buslogic_printk("timed out command pending for %4.4X.\n",
1426                                 scpnt->request.dev);
1427                 if (HOSTDATA(scpnt->host)->mb[i].status != MBX_NOT_IN_USE) {
1428                     buslogic_printk("OGMB still full - restarting...\n");
1429                     buslogic_out(scpnt->host->io_port, buscmd, sizeof buscmd);
1430                 }
1431             } else
1432                 buslogic_printk("other pending command: %4.4X\n",
1433                                 scpnt->request.dev);
1434         }
1435 #endif
1436 
1437 #if (BUSLOGIC_DEBUG & BD_ABORT)
1438     buslogic_printk("called\n");
1439 #endif
1440 
1441 #if 1
1442     /* This section of code should be used carefully - some devices cannot
1443        abort a command, and this merely makes it worse. */
1444     save_flags(flags);
1445     cli();
1446     for (mbo = 0; mbo < BUSLOGIC_MAILBOXES; mbo++)
1447         if (scpnt == HOSTDATA(scpnt->host)->sc[mbo]) {
1448             mb[mbo].status = MBX_ACTION_ABORT;
1449             buslogic_out(scpnt->host->io_port, buscmd, sizeof buscmd);
1450             break;
1451         }
1452     restore_flags(flags);
1453 #endif
1454 
1455     return SCSI_ABORT_SNOOZE;
1456 }
1457 
1458 /* We do not implement a reset function here, but the upper level code assumes
1459    that it will get some kind of response for the command in scpnt.  We must
1460    oblige, or the command will hang the SCSI system.  For a first go, we assume
1461    that the BusLogic notifies us with all of the pending commands (it does
1462    implement soft reset, after all). */
1463 int buslogic_reset(Scsi_Cmnd *scpnt)
     /*  */
1464 {
1465     static const unsigned char buscmd[] = { CMD_START_SCSI };
1466     unsigned int i;
1467 
1468 #if (BUSLOGIC_DEBUG & BD_RESET)
1469     buslogic_printk("called\n");
1470 #endif
1471 #if 0
1472     /* This does a scsi reset for all devices on the bus. */
1473     outb(RSBUS, CONTROL(scpnt->host->io_port));
1474 #else
1475     /* This does a selective reset of just the one device. */
1476     /* First locate the ccb for this command. */
1477     for (i = 0; i < BUSLOGIC_MAILBOXES; i++)
1478         if (HOSTDATA(scpnt->host)->sc[i] == scpnt) {
1479             HOSTDATA(scpnt->host)->ccbs[i].op = CCB_OP_BUS_RESET;
1480 
1481             /* Now tell the BusLogic to flush all pending commands for this
1482                target. */
1483             buslogic_out(scpnt->host->io_port, buscmd, sizeof buscmd);
1484 
1485             /* Here is the tricky part.  What to do next.  Do we get an
1486                interrupt for the commands that we aborted with the specified
1487                target, or do we generate this on our own?  Try it without first
1488                and see what happens. */
1489             buslogic_printk("sent BUS DEVICE RESET to target %d.\n",
1490                             scpnt->target);
1491 
1492             /* If the first does not work, then try the second.  I think the
1493                first option is more likely to be correct.  Free the command
1494                block for all commands running on this target... */
1495 #if 1
1496             for (i = 0; i < BUSLOGIC_MAILBOXES; i++)
1497                 if (HOSTDATA(scpnt->host)->sc[i]
1498                     && HOSTDATA(scpnt->host)->sc[i]->target == scpnt->target) {
1499                     Scsi_Cmnd *sctmp = HOSTDATA(scpnt->host)->sc[i];
1500 
1501                     sctmp->result = DID_RESET << 16;
1502                     if (sctmp->host_scribble)
1503                         scsi_free(sctmp->host_scribble, BUSLOGIC_SG_MALLOC);
1504                     buslogic_printk("sending DID_RESET for target %d.\n",
1505                                     scpnt->target);
1506                     sctmp->scsi_done(scpnt);
1507 
1508                     HOSTDATA(scpnt->host)->sc[i] = NULL;
1509                     HOSTDATA(scpnt->host)->mb[i].status = MBX_NOT_IN_USE;
1510                 }
1511             return SCSI_RESET_SUCCESS;
1512 #else
1513             return SCSI_RESET_PENDING;
1514 #endif
1515         }
1516 #endif
1517     /* No active command at this time, so this means that each time we got some
1518        kind of response the last time through.  Tell the mid-level code to
1519        request sense information in order to decide what to do next. */
1520     return SCSI_RESET_PUNT;
1521 }
1522 
1523 /* ??? This is probably not correct for series "C" boards.  I believe these
1524    support separate mappings for each disk.  We would need to issue a
1525    CMD_READ_FW_LOCAL_RAM command to check for the particular drive being
1526    queried.  Note that series "C" boards can be differentiated by having
1527    HOSTDATA(disk->device->host)->firmware_rev[0] >= '4'. */
1528 int buslogic_biosparam(Disk *disk, int dev, int *ip)
     /*  */
1529 {
1530     unsigned int size = disk->capacity;
1531 
1532     /* ip[0] == heads, ip[1] == sectors, ip[2] == cylinders */
1533     if (HOSTDATA(disk->device->host)->bios_translation == BIOS_TRANSLATION_BIG
1534         && size >= 0x200000) {          /* 1GB */
1535         if (size >= 0x400000) {         /* 2GB */
1536 #if 0   /* ??? Used in earlier kernels, but disagrees with BusLogic info. */
1537             if (mb >= 0x800000) {       /* 4GB */
1538                 ip[0] = 256;
1539                 ip[1] = 64;
1540             } else {
1541                 ip[0] = 256;
1542                 ip[1] = 32;
1543             }
1544 #else
1545             ip[0] = 256;
1546             ip[1] = 64;
1547 #endif
1548         } else {
1549             ip[0] = 128;
1550             ip[1] = 32;
1551         }
1552     } else {
1553         ip[0] = 64;
1554         ip[1] = 32;
1555     }
1556     ip[2] = size / (ip[0] * ip[1]);
1557 /*    if (ip[2] > 1024)
1558         ip[2] = 1024; */
1559     return 0;
1560 }
1561 
1562 /* called from init/main.c */
1563 void buslogic_setup(char *str, int *ints)
     /*  */
1564 {
1565     static const unsigned short valid_bases[]
1566         = { 0x130, 0x134, 0x230, 0x234, 0x330, 0x334 };
1567     static size_t setup_idx = 0;
1568     size_t i;
1569 
1570     if (setup_idx >= ARRAY_SIZE(bases) - 1) {
1571         buslogic_printk("called too many times.  Bad LILO params?\n");
1572         return;
1573     }
1574     if (ints[0] != 1) {
1575         buslogic_printk("malformed command line.\n");
1576         buslogic_printk("usage: buslogic=<portbase>\n");
1577         return;
1578     }
1579     for (i = 0; i < ARRAY_SIZE(valid_bases); i++)
1580         if (valid_bases[i] == ints[1]) {
1581             bases[setup_idx++] = ints[1];
1582             bases[setup_idx] = 0;
1583             return;
1584         }
1585     buslogic_printk("invalid base 0x%X specified.\n", ints[i]);
1586 }
1587 
1588 #ifdef MODULE
1589 /* Eventually this will go into an include file, but that's later... */
1590 Scsi_Host_Template driver_template = BUSLOGIC;
1591 
1592 # include "scsi_module.c"
1593 #endif
/* */
root/drivers/scsi/buslogic.c

DEFINITIONS
