linux/drivers/scsi/in2000.c
<<
>>
Prefs
   1/*
   2 *    in2000.c -  Linux device driver for the
   3 *                Always IN2000 ISA SCSI card.
   4 *
   5 * Copyright (c) 1996 John Shifflett, GeoLog Consulting
   6 *    john@geolog.com
   7 *    jshiffle@netcom.com
   8 *
   9 * This program is free software; you can redistribute it and/or modify
  10 * it under the terms of the GNU General Public License as published by
  11 * the Free Software Foundation; either version 2, or (at your option)
  12 * any later version.
  13 *
  14 * This program is distributed in the hope that it will be useful,
  15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 * GNU General Public License for more details.
  18 *
  19 * For the avoidance of doubt the "preferred form" of this code is one which
  20 * is in an open non patent encumbered format. Where cryptographic key signing
  21 * forms part of the process of creating an executable the information
  22 * including keys needed to generate an equivalently functional executable
  23 * are deemed to be part of the source code.
  24 *
  25 * Drew Eckhardt's excellent 'Generic NCR5380' sources provided
  26 * much of the inspiration and some of the code for this driver.
  27 * The Linux IN2000 driver distributed in the Linux kernels through
  28 * version 1.2.13 was an extremely valuable reference on the arcane
  29 * (and still mysterious) workings of the IN2000's fifo. It also
  30 * is where I lifted in2000_biosparam(), the gist of the card
  31 * detection scheme, and other bits of code. Many thanks to the
  32 * talented and courageous people who wrote, contributed to, and
  33 * maintained that driver (including Brad McLean, Shaun Savage,
  34 * Bill Earnest, Larry Doolittle, Roger Sunshine, John Luckey,
  35 * Matt Postiff, Peter Lu, zerucha@shell.portal.com, and Eric
  36 * Youngdale). I should also mention the driver written by
  37 * Hamish Macdonald for the (GASP!) Amiga A2091 card, included
  38 * in the Linux-m68k distribution; it gave me a good initial
  39 * understanding of the proper way to run a WD33c93 chip, and I
  40 * ended up stealing lots of code from it.
  41 *
  42 * _This_ driver is (I feel) an improvement over the old one in
  43 * several respects:
  44 *    -  All problems relating to the data size of a SCSI request are
  45 *          gone (as far as I know). The old driver couldn't handle
  46 *          swapping to partitions because that involved 4k blocks, nor
  47 *          could it deal with the st.c tape driver unmodified, because
  48 *          that usually involved 4k - 32k blocks. The old driver never
  49 *          quite got away from a morbid dependence on 2k block sizes -
  50 *          which of course is the size of the card's fifo.
  51 *
  52 *    -  Target Disconnection/Reconnection is now supported. Any
  53 *          system with more than one device active on the SCSI bus
  54 *          will benefit from this. The driver defaults to what I'm
  55 *          calling 'adaptive disconnect' - meaning that each command
  56 *          is evaluated individually as to whether or not it should
  57 *          be run with the option to disconnect/reselect (if the
  58 *          device chooses), or as a "SCSI-bus-hog".
  59 *
  60 *    -  Synchronous data transfers are now supported. Because there
  61 *          are a few devices (and many improperly terminated systems)
  62 *          that choke when doing sync, the default is sync DISABLED
  63 *          for all devices. This faster protocol can (and should!)
  64 *          be enabled on selected devices via the command-line.
  65 *
  66 *    -  Runtime operating parameters can now be specified through
  67 *       either the LILO or the 'insmod' command line. For LILO do:
  68 *          "in2000=blah,blah,blah"
  69 *       and with insmod go like:
  70 *          "insmod /usr/src/linux/modules/in2000.o setup_strings=blah,blah"
  71 *       The defaults should be good for most people. See the comment
  72 *       for 'setup_strings' below for more details.
  73 *
  74 *    -  The old driver relied exclusively on what the Western Digital
  75 *          docs call "Combination Level 2 Commands", which are a great
  76 *          idea in that the CPU is relieved of a lot of interrupt
  77 *          overhead. However, by accepting a certain (user-settable)
  78 *          amount of additional interrupts, this driver achieves
  79 *          better control over the SCSI bus, and data transfers are
  80 *          almost as fast while being much easier to define, track,
  81 *          and debug.
  82 *
  83 *    -  You can force detection of a card whose BIOS has been disabled.
  84 *
  85 *    -  Multiple IN2000 cards might almost be supported. I've tried to
  86 *       keep it in mind, but have no way to test...
  87 *
  88 *
  89 * TODO:
  90 *       tagged queuing. multiple cards.
  91 *
  92 *
  93 * NOTE:
  94 *       When using this or any other SCSI driver as a module, you'll
  95 *       find that with the stock kernel, at most _two_ SCSI hard
  96 *       drives will be linked into the device list (ie, usable).
  97 *       If your IN2000 card has more than 2 disks on its bus, you
  98 *       might want to change the define of 'SD_EXTRA_DEVS' in the
  99 *       'hosts.h' file from 2 to whatever is appropriate. It took
 100 *       me a while to track down this surprisingly obscure and
 101 *       undocumented little "feature".
 102 *
 103 *
 104 * People with bug reports, wish-lists, complaints, comments,
 105 * or improvements are asked to pah-leeez email me (John Shifflett)
 106 * at john@geolog.com or jshiffle@netcom.com! I'm anxious to get
 107 * this thing into as good a shape as possible, and I'm positive
 108 * there are lots of lurking bugs and "Stupid Places".
 109 *
 110 * Updated for Linux 2.5 by Alan Cox <alan@lxorguk.ukuu.org.uk>
 111 *      - Using new_eh handler
 112 *      - Hopefully got all the locking right again
 113 *      See "FIXME" notes for items that could do with more work
 114 */
 115
 116#include <linux/module.h>
 117#include <linux/blkdev.h>
 118#include <linux/interrupt.h>
 119#include <linux/string.h>
 120#include <linux/delay.h>
 121#include <linux/proc_fs.h>
 122#include <linux/ioport.h>
 123#include <linux/stat.h>
 124
 125#include <asm/io.h>
 126
 127#include "scsi.h"
 128#include <scsi/scsi_host.h>
 129
 130#define IN2000_VERSION    "1.33-2.5"
 131#define IN2000_DATE       "2002/11/03"
 132
 133#include "in2000.h"
 134
 135
 136/*
 137 * 'setup_strings' is a single string used to pass operating parameters and
 138 * settings from the kernel/module command-line to the driver. 'setup_args[]'
 139 * is an array of strings that define the compile-time default values for
 140 * these settings. If Linux boots with a LILO or insmod command-line, those
 141 * settings are combined with 'setup_args[]'. Note that LILO command-lines
 142 * are prefixed with "in2000=" while insmod uses a "setup_strings=" prefix.
 143 * The driver recognizes the following keywords (lower case required) and
 144 * arguments:
 145 *
 146 * -  ioport:addr    -Where addr is IO address of a (usually ROM-less) card.
 147 * -  noreset        -No optional args. Prevents SCSI bus reset at boot time.
 148 * -  nosync:x       -x is a bitmask where the 1st 7 bits correspond with
 149 *                    the 7 possible SCSI devices (bit 0 for device #0, etc).
 150 *                    Set a bit to PREVENT sync negotiation on that device.
 151 *                    The driver default is sync DISABLED on all devices.
 152 * -  period:ns      -ns is the minimum # of nanoseconds in a SCSI data transfer
 153 *                    period. Default is 500; acceptable values are 250 - 1000.
 154 * -  disconnect:x   -x = 0 to never allow disconnects, 2 to always allow them.
 155 *                    x = 1 does 'adaptive' disconnects, which is the default
 156 *                    and generally the best choice.
 157 * -  debug:x        -If 'DEBUGGING_ON' is defined, x is a bitmask that causes
 158 *                    various types of debug output to printed - see the DB_xxx
 159 *                    defines in in2000.h
 160 * -  proc:x         -If 'PROC_INTERFACE' is defined, x is a bitmask that
 161 *                    determines how the /proc interface works and what it
 162 *                    does - see the PR_xxx defines in in2000.h
 163 *
 164 * Syntax Notes:
 165 * -  Numeric arguments can be decimal or the '0x' form of hex notation. There
 166 *    _must_ be a colon between a keyword and its numeric argument, with no
 167 *    spaces.
 168 * -  Keywords are separated by commas, no spaces, in the standard kernel
 169 *    command-line manner.
 170 * -  A keyword in the 'nth' comma-separated command-line member will overwrite
 171 *    the 'nth' element of setup_args[]. A blank command-line member (in
 172 *    other words, a comma with no preceding keyword) will _not_ overwrite
 173 *    the corresponding setup_args[] element.
 174 *
 175 * A few LILO examples (for insmod, use 'setup_strings' instead of 'in2000'):
 176 * -  in2000=ioport:0x220,noreset
 177 * -  in2000=period:250,disconnect:2,nosync:0x03
 178 * -  in2000=debug:0x1e
 179 * -  in2000=proc:3
 180 */
 181
 182/* Normally, no defaults are specified... */
 183static char *setup_args[] = { "", "", "", "", "", "", "", "", "" };
 184
 185/* filled in by 'insmod' */
 186static char *setup_strings;
 187
 188module_param(setup_strings, charp, 0);
 189
 190static inline uchar read_3393(struct IN2000_hostdata *hostdata, uchar reg_num)
 191{
 192        write1_io(reg_num, IO_WD_ADDR);
 193        return read1_io(IO_WD_DATA);
 194}
 195
 196
 197#define READ_AUX_STAT() read1_io(IO_WD_ASR)
 198
 199
 200static inline void write_3393(struct IN2000_hostdata *hostdata, uchar reg_num, uchar value)
 201{
 202        write1_io(reg_num, IO_WD_ADDR);
 203        write1_io(value, IO_WD_DATA);
 204}
 205
 206
 207static inline void write_3393_cmd(struct IN2000_hostdata *hostdata, uchar cmd)
 208{
 209/*   while (READ_AUX_STAT() & ASR_CIP)
 210      printk("|");*/
 211        write1_io(WD_COMMAND, IO_WD_ADDR);
 212        write1_io(cmd, IO_WD_DATA);
 213}
 214
 215
 216static uchar read_1_byte(struct IN2000_hostdata *hostdata)
 217{
 218        uchar asr, x = 0;
 219
 220        write_3393(hostdata, WD_CONTROL, CTRL_IDI | CTRL_EDI | CTRL_POLLED);
 221        write_3393_cmd(hostdata, WD_CMD_TRANS_INFO | 0x80);
 222        do {
 223                asr = READ_AUX_STAT();
 224                if (asr & ASR_DBR)
 225                        x = read_3393(hostdata, WD_DATA);
 226        } while (!(asr & ASR_INT));
 227        return x;
 228}
 229
 230
 231static void write_3393_count(struct IN2000_hostdata *hostdata, unsigned long value)
 232{
 233        write1_io(WD_TRANSFER_COUNT_MSB, IO_WD_ADDR);
 234        write1_io((value >> 16), IO_WD_DATA);
 235        write1_io((value >> 8), IO_WD_DATA);
 236        write1_io(value, IO_WD_DATA);
 237}
 238
 239
 240static unsigned long read_3393_count(struct IN2000_hostdata *hostdata)
 241{
 242        unsigned long value;
 243
 244        write1_io(WD_TRANSFER_COUNT_MSB, IO_WD_ADDR);
 245        value = read1_io(IO_WD_DATA) << 16;
 246        value |= read1_io(IO_WD_DATA) << 8;
 247        value |= read1_io(IO_WD_DATA);
 248        return value;
 249}
 250
 251
 252/* The 33c93 needs to be told which direction a command transfers its
 253 * data; we use this function to figure it out. Returns true if there
 254 * will be a DATA_OUT phase with this command, false otherwise.
 255 * (Thanks to Joerg Dorchain for the research and suggestion.)
 256 */
 257static int is_dir_out(Scsi_Cmnd * cmd)
 258{
 259        switch (cmd->cmnd[0]) {
 260        case WRITE_6:
 261        case WRITE_10:
 262        case WRITE_12:
 263        case WRITE_LONG:
 264        case WRITE_SAME:
 265        case WRITE_BUFFER:
 266        case WRITE_VERIFY:
 267        case WRITE_VERIFY_12:
 268        case COMPARE:
 269        case COPY:
 270        case COPY_VERIFY:
 271        case SEARCH_EQUAL:
 272        case SEARCH_HIGH:
 273        case SEARCH_LOW:
 274        case SEARCH_EQUAL_12:
 275        case SEARCH_HIGH_12:
 276        case SEARCH_LOW_12:
 277        case FORMAT_UNIT:
 278        case REASSIGN_BLOCKS:
 279        case RESERVE:
 280        case MODE_SELECT:
 281        case MODE_SELECT_10:
 282        case LOG_SELECT:
 283        case SEND_DIAGNOSTIC:
 284        case CHANGE_DEFINITION:
 285        case UPDATE_BLOCK:
 286        case SET_WINDOW:
 287        case MEDIUM_SCAN:
 288        case SEND_VOLUME_TAG:
 289        case 0xea:
 290                return 1;
 291        default:
 292                return 0;
 293        }
 294}
 295
 296
 297
 298static struct sx_period sx_table[] = {
 299        {1, 0x20},
 300        {252, 0x20},
 301        {376, 0x30},
 302        {500, 0x40},
 303        {624, 0x50},
 304        {752, 0x60},
 305        {876, 0x70},
 306        {1000, 0x00},
 307        {0, 0}
 308};
 309
 310static int round_period(unsigned int period)
 311{
 312        int x;
 313
 314        for (x = 1; sx_table[x].period_ns; x++) {
 315                if ((period <= sx_table[x - 0].period_ns) && (period > sx_table[x - 1].period_ns)) {
 316                        return x;
 317                }
 318        }
 319        return 7;
 320}
 321
 322static uchar calc_sync_xfer(unsigned int period, unsigned int offset)
 323{
 324        uchar result;
 325
 326        period *= 4;            /* convert SDTR code to ns */
 327        result = sx_table[round_period(period)].reg_value;
 328        result |= (offset < OPTIMUM_SX_OFF) ? offset : OPTIMUM_SX_OFF;
 329        return result;
 330}
 331
 332
 333
 334static void in2000_execute(struct Scsi_Host *instance);
 335
 336static int in2000_queuecommand_lck(Scsi_Cmnd * cmd, void (*done) (Scsi_Cmnd *))
 337{
 338        struct Scsi_Host *instance;
 339        struct IN2000_hostdata *hostdata;
 340        Scsi_Cmnd *tmp;
 341
 342        instance = cmd->device->host;
 343        hostdata = (struct IN2000_hostdata *) instance->hostdata;
 344
 345        DB(DB_QUEUE_COMMAND, scmd_printk(KERN_DEBUG, cmd, "Q-%02x(", cmd->cmnd[0]))
 346
 347/* Set up a few fields in the Scsi_Cmnd structure for our own use:
 348 *  - host_scribble is the pointer to the next cmd in the input queue
 349 *  - scsi_done points to the routine we call when a cmd is finished
 350 *  - result is what you'd expect
 351 */
 352            cmd->host_scribble = NULL;
 353        cmd->scsi_done = done;
 354        cmd->result = 0;
 355
 356/* We use the Scsi_Pointer structure that's included with each command
 357 * as a scratchpad (as it's intended to be used!). The handy thing about
 358 * the SCp.xxx fields is that they're always associated with a given
 359 * cmd, and are preserved across disconnect-reselect. This means we
 360 * can pretty much ignore SAVE_POINTERS and RESTORE_POINTERS messages
 361 * if we keep all the critical pointers and counters in SCp:
 362 *  - SCp.ptr is the pointer into the RAM buffer
 363 *  - SCp.this_residual is the size of that buffer
 364 *  - SCp.buffer points to the current scatter-gather buffer
 365 *  - SCp.buffers_residual tells us how many S.G. buffers there are
 366 *  - SCp.have_data_in helps keep track of >2048 byte transfers
 367 *  - SCp.sent_command is not used
 368 *  - SCp.phase records this command's SRCID_ER bit setting
 369 */
 370
 371        if (scsi_bufflen(cmd)) {
 372                cmd->SCp.buffer = scsi_sglist(cmd);
 373                cmd->SCp.buffers_residual = scsi_sg_count(cmd) - 1;
 374                cmd->SCp.ptr = sg_virt(cmd->SCp.buffer);
 375                cmd->SCp.this_residual = cmd->SCp.buffer->length;
 376        } else {
 377                cmd->SCp.buffer = NULL;
 378                cmd->SCp.buffers_residual = 0;
 379                cmd->SCp.ptr = NULL;
 380                cmd->SCp.this_residual = 0;
 381        }
 382        cmd->SCp.have_data_in = 0;
 383
 384/* We don't set SCp.phase here - that's done in in2000_execute() */
 385
 386/* WD docs state that at the conclusion of a "LEVEL2" command, the
 387 * status byte can be retrieved from the LUN register. Apparently,
 388 * this is the case only for *uninterrupted* LEVEL2 commands! If
 389 * there are any unexpected phases entered, even if they are 100%
 390 * legal (different devices may choose to do things differently),
 391 * the LEVEL2 command sequence is exited. This often occurs prior
 392 * to receiving the status byte, in which case the driver does a
 393 * status phase interrupt and gets the status byte on its own.
 394 * While such a command can then be "resumed" (ie restarted to
 395 * finish up as a LEVEL2 command), the LUN register will NOT be
 396 * a valid status byte at the command's conclusion, and we must
 397 * use the byte obtained during the earlier interrupt. Here, we
 398 * preset SCp.Status to an illegal value (0xff) so that when
 399 * this command finally completes, we can tell where the actual
 400 * status byte is stored.
 401 */
 402
 403        cmd->SCp.Status = ILLEGAL_STATUS_BYTE;
 404
 405/* We need to disable interrupts before messing with the input
 406 * queue and calling in2000_execute().
 407 */
 408
 409        /*
 410         * Add the cmd to the end of 'input_Q'. Note that REQUEST_SENSE
 411         * commands are added to the head of the queue so that the desired
 412         * sense data is not lost before REQUEST_SENSE executes.
 413         */
 414
 415        if (!(hostdata->input_Q) || (cmd->cmnd[0] == REQUEST_SENSE)) {
 416                cmd->host_scribble = (uchar *) hostdata->input_Q;
 417                hostdata->input_Q = cmd;
 418        } else {                /* find the end of the queue */
 419                for (tmp = (Scsi_Cmnd *) hostdata->input_Q; tmp->host_scribble; tmp = (Scsi_Cmnd *) tmp->host_scribble);
 420                tmp->host_scribble = (uchar *) cmd;
 421        }
 422
 423/* We know that there's at least one command in 'input_Q' now.
 424 * Go see if any of them are runnable!
 425 */
 426
 427        in2000_execute(cmd->device->host);
 428
 429        DB(DB_QUEUE_COMMAND, printk(")Q "))
 430            return 0;
 431}
 432
 433static DEF_SCSI_QCMD(in2000_queuecommand)
 434
 435
 436
 437/*
 438 * This routine attempts to start a scsi command. If the host_card is
 439 * already connected, we give up immediately. Otherwise, look through
 440 * the input_Q, using the first command we find that's intended
 441 * for a currently non-busy target/lun.
 442 * Note that this function is always called with interrupts already
 443 * disabled (either from in2000_queuecommand() or in2000_intr()).
 444 */
 445static void in2000_execute(struct Scsi_Host *instance)
 446{
 447        struct IN2000_hostdata *hostdata;
 448        Scsi_Cmnd *cmd, *prev;
 449        int i;
 450        unsigned short *sp;
 451        unsigned short f;
 452        unsigned short flushbuf[16];
 453
 454
 455        hostdata = (struct IN2000_hostdata *) instance->hostdata;
 456
 457        DB(DB_EXECUTE, printk("EX("))
 458
 459            if (hostdata->selecting || hostdata->connected) {
 460
 461                DB(DB_EXECUTE, printk(")EX-0 "))
 462
 463                    return;
 464        }
 465
 466        /*
 467         * Search through the input_Q for a command destined
 468         * for an idle target/lun.
 469         */
 470
 471        cmd = (Scsi_Cmnd *) hostdata->input_Q;
 472        prev = NULL;
 473        while (cmd) {
 474                if (!(hostdata->busy[cmd->device->id] & (1 << cmd->device->lun)))
 475                        break;
 476                prev = cmd;
 477                cmd = (Scsi_Cmnd *) cmd->host_scribble;
 478        }
 479
 480        /* quit if queue empty or all possible targets are busy */
 481
 482        if (!cmd) {
 483
 484                DB(DB_EXECUTE, printk(")EX-1 "))
 485
 486                    return;
 487        }
 488
 489        /*  remove command from queue */
 490
 491        if (prev)
 492                prev->host_scribble = cmd->host_scribble;
 493        else
 494                hostdata->input_Q = (Scsi_Cmnd *) cmd->host_scribble;
 495
 496#ifdef PROC_STATISTICS
 497        hostdata->cmd_cnt[cmd->device->id]++;
 498#endif
 499
 500/*
 501 * Start the selection process
 502 */
 503
 504        if (is_dir_out(cmd))
 505                write_3393(hostdata, WD_DESTINATION_ID, cmd->device->id);
 506        else
 507                write_3393(hostdata, WD_DESTINATION_ID, cmd->device->id | DSTID_DPD);
 508
 509/* Now we need to figure out whether or not this command is a good
 510 * candidate for disconnect/reselect. We guess to the best of our
 511 * ability, based on a set of hierarchical rules. When several
 512 * devices are operating simultaneously, disconnects are usually
 513 * an advantage. In a single device system, or if only 1 device
 514 * is being accessed, transfers usually go faster if disconnects
 515 * are not allowed:
 516 *
 517 * + Commands should NEVER disconnect if hostdata->disconnect =
 518 *   DIS_NEVER (this holds for tape drives also), and ALWAYS
 519 *   disconnect if hostdata->disconnect = DIS_ALWAYS.
 520 * + Tape drive commands should always be allowed to disconnect.
 521 * + Disconnect should be allowed if disconnected_Q isn't empty.
 522 * + Commands should NOT disconnect if input_Q is empty.
 523 * + Disconnect should be allowed if there are commands in input_Q
 524 *   for a different target/lun. In this case, the other commands
 525 *   should be made disconnect-able, if not already.
 526 *
 527 * I know, I know - this code would flunk me out of any
 528 * "C Programming 101" class ever offered. But it's easy
 529 * to change around and experiment with for now.
 530 */
 531
 532        cmd->SCp.phase = 0;     /* assume no disconnect */
 533        if (hostdata->disconnect == DIS_NEVER)
 534                goto no;
 535        if (hostdata->disconnect == DIS_ALWAYS)
 536                goto yes;
 537        if (cmd->device->type == 1)     /* tape drive? */
 538                goto yes;
 539        if (hostdata->disconnected_Q)   /* other commands disconnected? */
 540                goto yes;
 541        if (!(hostdata->input_Q))       /* input_Q empty? */
 542                goto no;
 543        for (prev = (Scsi_Cmnd *) hostdata->input_Q; prev; prev = (Scsi_Cmnd *) prev->host_scribble) {
 544                if ((prev->device->id != cmd->device->id) || (prev->device->lun != cmd->device->lun)) {
 545                        for (prev = (Scsi_Cmnd *) hostdata->input_Q; prev; prev = (Scsi_Cmnd *) prev->host_scribble)
 546                                prev->SCp.phase = 1;
 547                        goto yes;
 548                }
 549        }
 550        goto no;
 551
 552      yes:
 553        cmd->SCp.phase = 1;
 554
 555#ifdef PROC_STATISTICS
 556        hostdata->disc_allowed_cnt[cmd->device->id]++;
 557#endif
 558
 559      no:
 560        write_3393(hostdata, WD_SOURCE_ID, ((cmd->SCp.phase) ? SRCID_ER : 0));
 561
 562        write_3393(hostdata, WD_TARGET_LUN, cmd->device->lun);
 563        write_3393(hostdata, WD_SYNCHRONOUS_TRANSFER, hostdata->sync_xfer[cmd->device->id]);
 564        hostdata->busy[cmd->device->id] |= (1 << cmd->device->lun);
 565
 566        if ((hostdata->level2 <= L2_NONE) || (hostdata->sync_stat[cmd->device->id] == SS_UNSET)) {
 567
 568                /*
 569                 * Do a 'Select-With-ATN' command. This will end with
 570                 * one of the following interrupts:
 571                 *    CSR_RESEL_AM:  failure - can try again later.
 572                 *    CSR_TIMEOUT:   failure - give up.
 573                 *    CSR_SELECT:    success - proceed.
 574                 */
 575
 576                hostdata->selecting = cmd;
 577
 578/* Every target has its own synchronous transfer setting, kept in
 579 * the sync_xfer array, and a corresponding status byte in sync_stat[].
 580 * Each target's sync_stat[] entry is initialized to SS_UNSET, and its
 581 * sync_xfer[] entry is initialized to the default/safe value. SS_UNSET
 582 * means that the parameters are undetermined as yet, and that we
 583 * need to send an SDTR message to this device after selection is
 584 * complete. We set SS_FIRST to tell the interrupt routine to do so,
 585 * unless we don't want to even _try_ synchronous transfers: In this
 586 * case we set SS_SET to make the defaults final.
 587 */
 588                if (hostdata->sync_stat[cmd->device->id] == SS_UNSET) {
 589                        if (hostdata->sync_off & (1 << cmd->device->id))
 590                                hostdata->sync_stat[cmd->device->id] = SS_SET;
 591                        else
 592                                hostdata->sync_stat[cmd->device->id] = SS_FIRST;
 593                }
 594                hostdata->state = S_SELECTING;
 595                write_3393_count(hostdata, 0);  /* this guarantees a DATA_PHASE interrupt */
 596                write_3393_cmd(hostdata, WD_CMD_SEL_ATN);
 597        }
 598
 599        else {
 600
 601                /*
 602                 * Do a 'Select-With-ATN-Xfer' command. This will end with
 603                 * one of the following interrupts:
 604                 *    CSR_RESEL_AM:  failure - can try again later.
 605                 *    CSR_TIMEOUT:   failure - give up.
 606                 *    anything else: success - proceed.
 607                 */
 608
 609                hostdata->connected = cmd;
 610                write_3393(hostdata, WD_COMMAND_PHASE, 0);
 611
 612                /* copy command_descriptor_block into WD chip
 613                 * (take advantage of auto-incrementing)
 614                 */
 615
 616                write1_io(WD_CDB_1, IO_WD_ADDR);
 617                for (i = 0; i < cmd->cmd_len; i++)
 618                        write1_io(cmd->cmnd[i], IO_WD_DATA);
 619
 620                /* The wd33c93 only knows about Group 0, 1, and 5 commands when
 621                 * it's doing a 'select-and-transfer'. To be safe, we write the
 622                 * size of the CDB into the OWN_ID register for every case. This
 623                 * way there won't be problems with vendor-unique, audio, etc.
 624                 */
 625
 626                write_3393(hostdata, WD_OWN_ID, cmd->cmd_len);
 627
 628                /* When doing a non-disconnect command, we can save ourselves a DATA
 629                 * phase interrupt later by setting everything up now. With writes we
 630                 * need to pre-fill the fifo; if there's room for the 32 flush bytes,
 631                 * put them in there too - that'll avoid a fifo interrupt. Reads are
 632                 * somewhat simpler.
 633                 * KLUDGE NOTE: It seems that you can't completely fill the fifo here:
 634                 * This results in the IO_FIFO_COUNT register rolling over to zero,
 635                 * and apparently the gate array logic sees this as empty, not full,
 636                 * so the 3393 chip is never signalled to start reading from the
 637                 * fifo. Or maybe it's seen as a permanent fifo interrupt condition.
 638                 * Regardless, we fix this by temporarily pretending that the fifo
 639                 * is 16 bytes smaller. (I see now that the old driver has a comment
 640                 * about "don't fill completely" in an analogous place - must be the
 641                 * same deal.) This results in CDROM, swap partitions, and tape drives
 642                 * needing an extra interrupt per write command - I think we can live
 643                 * with that!
 644                 */
 645
 646                if (!(cmd->SCp.phase)) {
 647                        write_3393_count(hostdata, cmd->SCp.this_residual);
 648                        write_3393(hostdata, WD_CONTROL, CTRL_IDI | CTRL_EDI | CTRL_BUS);
 649                        write1_io(0, IO_FIFO_WRITE);    /* clear fifo counter, write mode */
 650
 651                        if (is_dir_out(cmd)) {
 652                                hostdata->fifo = FI_FIFO_WRITING;
 653                                if ((i = cmd->SCp.this_residual) > (IN2000_FIFO_SIZE - 16))
 654                                        i = IN2000_FIFO_SIZE - 16;
 655                                cmd->SCp.have_data_in = i;      /* this much data in fifo */
 656                                i >>= 1;        /* Gulp. Assuming modulo 2. */
 657                                sp = (unsigned short *) cmd->SCp.ptr;
 658                                f = hostdata->io_base + IO_FIFO;
 659
 660#ifdef FAST_WRITE_IO
 661
 662                                FAST_WRITE2_IO();
 663#else
 664                                while (i--)
 665                                        write2_io(*sp++, IO_FIFO);
 666
 667#endif
 668
 669                                /* Is there room for the flush bytes? */
 670
 671                                if (cmd->SCp.have_data_in <= ((IN2000_FIFO_SIZE - 16) - 32)) {
 672                                        sp = flushbuf;
 673                                        i = 16;
 674
 675#ifdef FAST_WRITE_IO
 676
 677                                        FAST_WRITE2_IO();
 678#else
 679                                        while (i--)
 680                                                write2_io(0, IO_FIFO);
 681
 682#endif
 683
 684                                }
 685                        }
 686
 687                        else {
 688                                write1_io(0, IO_FIFO_READ);     /* put fifo in read mode */
 689                                hostdata->fifo = FI_FIFO_READING;
 690                                cmd->SCp.have_data_in = 0;      /* nothing transferred yet */
 691                        }
 692
 693                } else {
 694                        write_3393_count(hostdata, 0);  /* this guarantees a DATA_PHASE interrupt */
 695                }
 696                hostdata->state = S_RUNNING_LEVEL2;
 697                write_3393_cmd(hostdata, WD_CMD_SEL_ATN_XFER);
 698        }
 699
 700        /*
 701         * Since the SCSI bus can handle only 1 connection at a time,
 702         * we get out of here now. If the selection fails, or when
 703         * the command disconnects, we'll come back to this routine
 704         * to search the input_Q again...
 705         */
 706
 707        DB(DB_EXECUTE, printk("%s)EX-2 ", (cmd->SCp.phase) ? "d:" : ""))
 708
 709}
 710
 711
 712
 713static void transfer_pio(uchar * buf, int cnt, int data_in_dir, struct IN2000_hostdata *hostdata)
 714{
 715        uchar asr;
 716
 717        DB(DB_TRANSFER, printk("(%p,%d,%s)", buf, cnt, data_in_dir ? "in" : "out"))
 718
 719            write_3393(hostdata, WD_CONTROL, CTRL_IDI | CTRL_EDI | CTRL_POLLED);
 720        write_3393_count(hostdata, cnt);
 721        write_3393_cmd(hostdata, WD_CMD_TRANS_INFO);
 722        if (data_in_dir) {
 723                do {
 724                        asr = READ_AUX_STAT();
 725                        if (asr & ASR_DBR)
 726                                *buf++ = read_3393(hostdata, WD_DATA);
 727                } while (!(asr & ASR_INT));
 728        } else {
 729                do {
 730                        asr = READ_AUX_STAT();
 731                        if (asr & ASR_DBR)
 732                                write_3393(hostdata, WD_DATA, *buf++);
 733                } while (!(asr & ASR_INT));
 734        }
 735
 736        /* Note: we are returning with the interrupt UN-cleared.
 737         * Since (presumably) an entire I/O operation has
 738         * completed, the bus phase is probably different, and
 739         * the interrupt routine will discover this when it
 740         * responds to the uncleared int.
 741         */
 742
 743}
 744
 745
 746
 747static void transfer_bytes(Scsi_Cmnd * cmd, int data_in_dir)
 748{
 749        struct IN2000_hostdata *hostdata;
 750        unsigned short *sp;
 751        unsigned short f;
 752        int i;
 753
 754        hostdata = (struct IN2000_hostdata *) cmd->device->host->hostdata;
 755
 756/* Normally, you'd expect 'this_residual' to be non-zero here.
 757 * In a series of scatter-gather transfers, however, this
 758 * routine will usually be called with 'this_residual' equal
 759 * to 0 and 'buffers_residual' non-zero. This means that a
 760 * previous transfer completed, clearing 'this_residual', and
 761 * now we need to setup the next scatter-gather buffer as the
 762 * source or destination for THIS transfer.
 763 */
 764        if (!cmd->SCp.this_residual && cmd->SCp.buffers_residual) {
 765                ++cmd->SCp.buffer;
 766                --cmd->SCp.buffers_residual;
 767                cmd->SCp.this_residual = cmd->SCp.buffer->length;
 768                cmd->SCp.ptr = sg_virt(cmd->SCp.buffer);
 769        }
 770
 771/* Set up hardware registers */
 772
 773        write_3393(hostdata, WD_SYNCHRONOUS_TRANSFER, hostdata->sync_xfer[cmd->device->id]);
 774        write_3393_count(hostdata, cmd->SCp.this_residual);
 775        write_3393(hostdata, WD_CONTROL, CTRL_IDI | CTRL_EDI | CTRL_BUS);
 776        write1_io(0, IO_FIFO_WRITE);    /* zero counter, assume write */
 777
 778/* Reading is easy. Just issue the command and return - we'll
 779 * get an interrupt later when we have actual data to worry about.
 780 */
 781
 782        if (data_in_dir) {
 783                write1_io(0, IO_FIFO_READ);
 784                if ((hostdata->level2 >= L2_DATA) || (hostdata->level2 == L2_BASIC && cmd->SCp.phase == 0)) {
 785                        write_3393(hostdata, WD_COMMAND_PHASE, 0x45);
 786                        write_3393_cmd(hostdata, WD_CMD_SEL_ATN_XFER);
 787                        hostdata->state = S_RUNNING_LEVEL2;
 788                } else
 789                        write_3393_cmd(hostdata, WD_CMD_TRANS_INFO);
 790                hostdata->fifo = FI_FIFO_READING;
 791                cmd->SCp.have_data_in = 0;
 792                return;
 793        }
 794
 795/* Writing is more involved - we'll start the WD chip and write as
 796 * much data to the fifo as we can right now. Later interrupts will
 797 * write any bytes that don't make it at this stage.
 798 */
 799
 800        if ((hostdata->level2 >= L2_DATA) || (hostdata->level2 == L2_BASIC && cmd->SCp.phase == 0)) {
 801                write_3393(hostdata, WD_COMMAND_PHASE, 0x45);
 802                write_3393_cmd(hostdata, WD_CMD_SEL_ATN_XFER);
 803                hostdata->state = S_RUNNING_LEVEL2;
 804        } else
 805                write_3393_cmd(hostdata, WD_CMD_TRANS_INFO);
 806        hostdata->fifo = FI_FIFO_WRITING;
 807        sp = (unsigned short *) cmd->SCp.ptr;
 808
 809        if ((i = cmd->SCp.this_residual) > IN2000_FIFO_SIZE)
 810                i = IN2000_FIFO_SIZE;
 811        cmd->SCp.have_data_in = i;
 812        i >>= 1;                /* Gulp. We assume this_residual is modulo 2 */
 813        f = hostdata->io_base + IO_FIFO;
 814
 815#ifdef FAST_WRITE_IO
 816
 817        FAST_WRITE2_IO();
 818#else
 819        while (i--)
 820                write2_io(*sp++, IO_FIFO);
 821
 822#endif
 823
 824}
 825
 826
 827/* We need to use spin_lock_irqsave() & spin_unlock_irqrestore() in this
 828 * function in order to work in an SMP environment. (I'd be surprised
 829 * if the driver is ever used by anyone on a real multi-CPU motherboard,
 830 * but it _does_ need to be able to compile and run in an SMP kernel.)
 831 */
 832
 833static irqreturn_t in2000_intr(int irqnum, void *dev_id)
 834{
 835        struct Scsi_Host *instance = dev_id;
 836        struct IN2000_hostdata *hostdata;
 837        Scsi_Cmnd *patch, *cmd;
 838        uchar asr, sr, phs, id, lun, *ucp, msg;
 839        int i, j;
 840        unsigned long length;
 841        unsigned short *sp;
 842        unsigned short f;
 843        unsigned long flags;
 844
 845        hostdata = (struct IN2000_hostdata *) instance->hostdata;
 846
 847/* Get the spin_lock and disable further ints, for SMP */
 848
 849        spin_lock_irqsave(instance->host_lock, flags);
 850
 851#ifdef PROC_STATISTICS
 852        hostdata->int_cnt++;
 853#endif
 854
 855/* The IN2000 card has 2 interrupt sources OR'ed onto its IRQ line - the
 856 * WD3393 chip and the 2k fifo (which is actually a dual-port RAM combined
 857 * with a big logic array, so it's a little different than what you might
 858 * expect). As far as I know, there's no reason that BOTH can't be active
 859 * at the same time, but there's a problem: while we can read the 3393
 860 * to tell if _it_ wants an interrupt, I don't know of a way to ask the
 861 * fifo the same question. The best we can do is check the 3393 and if
 862 * it _isn't_ the source of the interrupt, then we can be pretty sure
 863 * that the fifo is the culprit.
 864 *  UPDATE: I have it on good authority (Bill Earnest) that bit 0 of the
 865 *          IO_FIFO_COUNT register mirrors the fifo interrupt state. I
 866 *          assume that bit clear means interrupt active. As it turns
 867 *          out, the driver really doesn't need to check for this after
 868 *          all, so my remarks above about a 'problem' can safely be
 869 *          ignored. The way the logic is set up, there's no advantage
 870 *          (that I can see) to worrying about it.
 871 *
 872 * It seems that the fifo interrupt signal is negated when we extract
 873 * bytes during read or write bytes during write.
 874 *  - fifo will interrupt when data is moving from it to the 3393, and
 875 *    there are 31 (or less?) bytes left to go. This is sort of short-
 876 *    sighted: what if you don't WANT to do more? In any case, our
 877 *    response is to push more into the fifo - either actual data or
 878 *    dummy bytes if need be. Note that we apparently have to write at
 879 *    least 32 additional bytes to the fifo after an interrupt in order
 880 *    to get it to release the ones it was holding on to - writing fewer
 881 *    than 32 will result in another fifo int.
 882 *  UPDATE: Again, info from Bill Earnest makes this more understandable:
 883 *          32 bytes = two counts of the fifo counter register. He tells
 884 *          me that the fifo interrupt is a non-latching signal derived
 885 *          from a straightforward boolean interpretation of the 7
 886 *          highest bits of the fifo counter and the fifo-read/fifo-write
 887 *          state. Who'd a thought?
 888 */
 889
 890        write1_io(0, IO_LED_ON);
 891        asr = READ_AUX_STAT();
 892        if (!(asr & ASR_INT)) { /* no WD33c93 interrupt? */
 893
 894/* Ok. This is definitely a FIFO-only interrupt.
 895 *
 896 * If FI_FIFO_READING is set, there are up to 2048 bytes waiting to be read,
 897 * maybe more to come from the SCSI bus. Read as many as we can out of the
 898 * fifo and into memory at the location of SCp.ptr[SCp.have_data_in], and
 899 * update have_data_in afterwards.
 900 *
 901 * If we have FI_FIFO_WRITING, the FIFO has almost run out of bytes to move
 902 * into the WD3393 chip (I think the interrupt happens when there are 31
 903 * bytes left, but it may be fewer...). The 3393 is still waiting, so we
 904 * shove some more into the fifo, which gets things moving again. If the
 905 * original SCSI command specified more than 2048 bytes, there may still
 906 * be some of that data left: fine - use it (from SCp.ptr[SCp.have_data_in]).
 907 * Don't forget to update have_data_in. If we've already written out the
 908 * entire buffer, feed 32 dummy bytes to the fifo - they're needed to
 909 * push out the remaining real data.
 910 *    (Big thanks to Bill Earnest for getting me out of the mud in here.)
 911 */
 912
 913                cmd = (Scsi_Cmnd *) hostdata->connected;        /* assume we're connected */
 914                CHECK_NULL(cmd, "fifo_int")
 915
 916                    if (hostdata->fifo == FI_FIFO_READING) {
 917
 918                        DB(DB_FIFO, printk("{R:%02x} ", read1_io(IO_FIFO_COUNT)))
 919
 920                            sp = (unsigned short *) (cmd->SCp.ptr + cmd->SCp.have_data_in);
 921                        i = read1_io(IO_FIFO_COUNT) & 0xfe;
 922                        i <<= 2;        /* # of words waiting in the fifo */
 923                        f = hostdata->io_base + IO_FIFO;
 924
 925#ifdef FAST_READ_IO
 926
 927                        FAST_READ2_IO();
 928#else
 929                        while (i--)
 930                                *sp++ = read2_io(IO_FIFO);
 931
 932#endif
 933
 934                        i = sp - (unsigned short *) (cmd->SCp.ptr + cmd->SCp.have_data_in);
 935                        i <<= 1;
 936                        cmd->SCp.have_data_in += i;
 937                }
 938
 939                else if (hostdata->fifo == FI_FIFO_WRITING) {
 940
 941                        DB(DB_FIFO, printk("{W:%02x} ", read1_io(IO_FIFO_COUNT)))
 942
 943/* If all bytes have been written to the fifo, flush out the stragglers.
 944 * Note that while writing 16 dummy words seems arbitrary, we don't
 945 * have another choice that I can see. What we really want is to read
 946 * the 3393 transfer count register (that would tell us how many bytes
 947 * needed flushing), but the TRANSFER_INFO command hasn't completed
 948 * yet (not enough bytes!) and that register won't be accessible. So,
 949 * we use 16 words - a number obtained through trial and error.
 950 *  UPDATE: Bill says this is exactly what Always does, so there.
 951 *          More thanks due him for help in this section.
 952 */
 953                            if (cmd->SCp.this_residual == cmd->SCp.have_data_in) {
 954                                i = 16;
 955                                while (i--)     /* write 32 dummy bytes */
 956                                        write2_io(0, IO_FIFO);
 957                        }
 958
 959/* If there are still bytes left in the SCSI buffer, write as many as we
 960 * can out to the fifo.
 961 */
 962
 963                        else {
 964                                sp = (unsigned short *) (cmd->SCp.ptr + cmd->SCp.have_data_in);
 965                                i = cmd->SCp.this_residual - cmd->SCp.have_data_in;     /* bytes yet to go */
 966                                j = read1_io(IO_FIFO_COUNT) & 0xfe;
 967                                j <<= 2;        /* how many words the fifo has room for */
 968                                if ((j << 1) > i)
 969                                        j = (i >> 1);
 970                                while (j--)
 971                                        write2_io(*sp++, IO_FIFO);
 972
 973                                i = sp - (unsigned short *) (cmd->SCp.ptr + cmd->SCp.have_data_in);
 974                                i <<= 1;
 975                                cmd->SCp.have_data_in += i;
 976                        }
 977                }
 978
 979                else {
 980                        printk("*** Spurious FIFO interrupt ***");
 981                }
 982
 983                write1_io(0, IO_LED_OFF);
 984
 985/* release the SMP spin_lock and restore irq state */
 986                spin_unlock_irqrestore(instance->host_lock, flags);
 987                return IRQ_HANDLED;
 988        }
 989
 990/* This interrupt was triggered by the WD33c93 chip. The fifo interrupt
 991 * may also be asserted, but we don't bother to check it: we get more
 992 * detailed info from FIFO_READING and FIFO_WRITING (see below).
 993 */
 994
 995        cmd = (Scsi_Cmnd *) hostdata->connected;        /* assume we're connected */
 996        sr = read_3393(hostdata, WD_SCSI_STATUS);       /* clear the interrupt */
 997        phs = read_3393(hostdata, WD_COMMAND_PHASE);
 998
 999        if (!cmd && (sr != CSR_RESEL_AM && sr != CSR_TIMEOUT && sr != CSR_SELECT)) {
1000                printk("\nNR:wd-intr-1\n");
1001                write1_io(0, IO_LED_OFF);
1002
1003/* release the SMP spin_lock and restore irq state */
1004                spin_unlock_irqrestore(instance->host_lock, flags);
1005                return IRQ_HANDLED;
1006        }
1007
1008        DB(DB_INTR, printk("{%02x:%02x-", asr, sr))
1009
1010/* After starting a FIFO-based transfer, the next _WD3393_ interrupt is
1011 * guaranteed to be in response to the completion of the transfer.
1012 * If we were reading, there's probably data in the fifo that needs
1013 * to be copied into RAM - do that here. Also, we have to update
1014 * 'this_residual' and 'ptr' based on the contents of the
1015 * TRANSFER_COUNT register, in case the device decided to do an
1016 * intermediate disconnect (a device may do this if it has to
1017 * do a seek,  or just to be nice and let other devices have
1018 * some bus time during long transfers).
1019 * After doing whatever is necessary with the fifo, we go on and
1020 * service the WD3393 interrupt normally.
1021 */
1022            if (hostdata->fifo == FI_FIFO_READING) {
1023
1024/* buffer index = start-of-buffer + #-of-bytes-already-read */
1025
1026                sp = (unsigned short *) (cmd->SCp.ptr + cmd->SCp.have_data_in);
1027
1028/* bytes remaining in fifo = (total-wanted - #-not-got) - #-already-read */
1029
1030                i = (cmd->SCp.this_residual - read_3393_count(hostdata)) - cmd->SCp.have_data_in;
1031                i >>= 1;        /* Gulp. We assume this will always be modulo 2 */
1032                f = hostdata->io_base + IO_FIFO;
1033
1034#ifdef FAST_READ_IO
1035
1036                FAST_READ2_IO();
1037#else
1038                while (i--)
1039                        *sp++ = read2_io(IO_FIFO);
1040
1041#endif
1042
1043                hostdata->fifo = FI_FIFO_UNUSED;
1044                length = cmd->SCp.this_residual;
1045                cmd->SCp.this_residual = read_3393_count(hostdata);
1046                cmd->SCp.ptr += (length - cmd->SCp.this_residual);
1047
1048                DB(DB_TRANSFER, printk("(%p,%d)", cmd->SCp.ptr, cmd->SCp.this_residual))
1049
1050        }
1051
1052        else if (hostdata->fifo == FI_FIFO_WRITING) {
1053                hostdata->fifo = FI_FIFO_UNUSED;
1054                length = cmd->SCp.this_residual;
1055                cmd->SCp.this_residual = read_3393_count(hostdata);
1056                cmd->SCp.ptr += (length - cmd->SCp.this_residual);
1057
1058                DB(DB_TRANSFER, printk("(%p,%d)", cmd->SCp.ptr, cmd->SCp.this_residual))
1059
1060        }
1061
1062/* Respond to the specific WD3393 interrupt - there are quite a few! */
1063
1064        switch (sr) {
1065
1066        case CSR_TIMEOUT:
1067                DB(DB_INTR, printk("TIMEOUT"))
1068
1069                    if (hostdata->state == S_RUNNING_LEVEL2)
1070                        hostdata->connected = NULL;
1071                else {
1072                        cmd = (Scsi_Cmnd *) hostdata->selecting;        /* get a valid cmd */
1073                        CHECK_NULL(cmd, "csr_timeout")
1074                            hostdata->selecting = NULL;
1075                }
1076
1077                cmd->result = DID_NO_CONNECT << 16;
1078                hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun);
1079                hostdata->state = S_UNCONNECTED;
1080                cmd->scsi_done(cmd);
1081
1082/* We are not connected to a target - check to see if there
1083 * are commands waiting to be executed.
1084 */
1085
1086                in2000_execute(instance);
1087                break;
1088
1089
1090/* Note: this interrupt should not occur in a LEVEL2 command */
1091
1092        case CSR_SELECT:
1093                DB(DB_INTR, printk("SELECT"))
1094                    hostdata->connected = cmd = (Scsi_Cmnd *) hostdata->selecting;
1095                CHECK_NULL(cmd, "csr_select")
1096                    hostdata->selecting = NULL;
1097
1098                /* construct an IDENTIFY message with correct disconnect bit */
1099
1100                hostdata->outgoing_msg[0] = (0x80 | 0x00 | cmd->device->lun);
1101                if (cmd->SCp.phase)
1102                        hostdata->outgoing_msg[0] |= 0x40;
1103
1104                if (hostdata->sync_stat[cmd->device->id] == SS_FIRST) {
1105#ifdef SYNC_DEBUG
1106                        printk(" sending SDTR ");
1107#endif
1108
1109                        hostdata->sync_stat[cmd->device->id] = SS_WAITING;
1110
1111                        /* tack on a 2nd message to ask about synchronous transfers */
1112
1113                        hostdata->outgoing_msg[1] = EXTENDED_MESSAGE;
1114                        hostdata->outgoing_msg[2] = 3;
1115                        hostdata->outgoing_msg[3] = EXTENDED_SDTR;
1116                        hostdata->outgoing_msg[4] = OPTIMUM_SX_PER / 4;
1117                        hostdata->outgoing_msg[5] = OPTIMUM_SX_OFF;
1118                        hostdata->outgoing_len = 6;
1119                } else
1120                        hostdata->outgoing_len = 1;
1121
1122                hostdata->state = S_CONNECTED;
1123                break;
1124
1125
1126        case CSR_XFER_DONE | PHS_DATA_IN:
1127        case CSR_UNEXP | PHS_DATA_IN:
1128        case CSR_SRV_REQ | PHS_DATA_IN:
1129                DB(DB_INTR, printk("IN-%d.%d", cmd->SCp.this_residual, cmd->SCp.buffers_residual))
1130                    transfer_bytes(cmd, DATA_IN_DIR);
1131                if (hostdata->state != S_RUNNING_LEVEL2)
1132                        hostdata->state = S_CONNECTED;
1133                break;
1134
1135
1136        case CSR_XFER_DONE | PHS_DATA_OUT:
1137        case CSR_UNEXP | PHS_DATA_OUT:
1138        case CSR_SRV_REQ | PHS_DATA_OUT:
1139                DB(DB_INTR, printk("OUT-%d.%d", cmd->SCp.this_residual, cmd->SCp.buffers_residual))
1140                    transfer_bytes(cmd, DATA_OUT_DIR);
1141                if (hostdata->state != S_RUNNING_LEVEL2)
1142                        hostdata->state = S_CONNECTED;
1143                break;
1144
1145
1146/* Note: this interrupt should not occur in a LEVEL2 command */
1147
1148        case CSR_XFER_DONE | PHS_COMMAND:
1149        case CSR_UNEXP | PHS_COMMAND:
1150        case CSR_SRV_REQ | PHS_COMMAND:
1151                DB(DB_INTR, printk("CMND-%02x", cmd->cmnd[0]))
1152                    transfer_pio(cmd->cmnd, cmd->cmd_len, DATA_OUT_DIR, hostdata);
1153                hostdata->state = S_CONNECTED;
1154                break;
1155
1156
1157        case CSR_XFER_DONE | PHS_STATUS:
1158        case CSR_UNEXP | PHS_STATUS:
1159        case CSR_SRV_REQ | PHS_STATUS:
1160                DB(DB_INTR, printk("STATUS="))
1161
1162                    cmd->SCp.Status = read_1_byte(hostdata);
1163                DB(DB_INTR, printk("%02x", cmd->SCp.Status))
1164                    if (hostdata->level2 >= L2_BASIC) {
1165                        sr = read_3393(hostdata, WD_SCSI_STATUS);       /* clear interrupt */
1166                        hostdata->state = S_RUNNING_LEVEL2;
1167                        write_3393(hostdata, WD_COMMAND_PHASE, 0x50);
1168                        write_3393_cmd(hostdata, WD_CMD_SEL_ATN_XFER);
1169                } else {
1170                        hostdata->state = S_CONNECTED;
1171                }
1172                break;
1173
1174
1175        case CSR_XFER_DONE | PHS_MESS_IN:
1176        case CSR_UNEXP | PHS_MESS_IN:
1177        case CSR_SRV_REQ | PHS_MESS_IN:
1178                DB(DB_INTR, printk("MSG_IN="))
1179
1180                    msg = read_1_byte(hostdata);
1181                sr = read_3393(hostdata, WD_SCSI_STATUS);       /* clear interrupt */
1182
1183                hostdata->incoming_msg[hostdata->incoming_ptr] = msg;
1184                if (hostdata->incoming_msg[0] == EXTENDED_MESSAGE)
1185                        msg = EXTENDED_MESSAGE;
1186                else
1187                        hostdata->incoming_ptr = 0;
1188
1189                cmd->SCp.Message = msg;
1190                switch (msg) {
1191
1192                case COMMAND_COMPLETE:
1193                        DB(DB_INTR, printk("CCMP"))
1194                            write_3393_cmd(hostdata, WD_CMD_NEGATE_ACK);
1195                        hostdata->state = S_PRE_CMP_DISC;
1196                        break;
1197
1198                case SAVE_POINTERS:
1199                        DB(DB_INTR, printk("SDP"))
1200                            write_3393_cmd(hostdata, WD_CMD_NEGATE_ACK);
1201                        hostdata->state = S_CONNECTED;
1202                        break;
1203
1204                case RESTORE_POINTERS:
1205                        DB(DB_INTR, printk("RDP"))
1206                            if (hostdata->level2 >= L2_BASIC) {
1207                                write_3393(hostdata, WD_COMMAND_PHASE, 0x45);
1208                                write_3393_cmd(hostdata, WD_CMD_SEL_ATN_XFER);
1209                                hostdata->state = S_RUNNING_LEVEL2;
1210                        } else {
1211                                write_3393_cmd(hostdata, WD_CMD_NEGATE_ACK);
1212                                hostdata->state = S_CONNECTED;
1213                        }
1214                        break;
1215
1216                case DISCONNECT:
1217                        DB(DB_INTR, printk("DIS"))
1218                            cmd->device->disconnect = 1;
1219                        write_3393_cmd(hostdata, WD_CMD_NEGATE_ACK);
1220                        hostdata->state = S_PRE_TMP_DISC;
1221                        break;
1222
1223                case MESSAGE_REJECT:
1224                        DB(DB_INTR, printk("REJ"))
1225#ifdef SYNC_DEBUG
1226                            printk("-REJ-");
1227#endif
1228                        if (hostdata->sync_stat[cmd->device->id] == SS_WAITING)
1229                                hostdata->sync_stat[cmd->device->id] = SS_SET;
1230                        write_3393_cmd(hostdata, WD_CMD_NEGATE_ACK);
1231                        hostdata->state = S_CONNECTED;
1232                        break;
1233
1234                case EXTENDED_MESSAGE:
1235                        DB(DB_INTR, printk("EXT"))
1236
1237                            ucp = hostdata->incoming_msg;
1238
1239#ifdef SYNC_DEBUG
1240                        printk("%02x", ucp[hostdata->incoming_ptr]);
1241#endif
1242                        /* Is this the last byte of the extended message? */
1243
1244                        if ((hostdata->incoming_ptr >= 2) && (hostdata->incoming_ptr == (ucp[1] + 1))) {
1245
1246                                switch (ucp[2]) {       /* what's the EXTENDED code? */
1247                                case EXTENDED_SDTR:
1248                                        id = calc_sync_xfer(ucp[3], ucp[4]);
1249                                        if (hostdata->sync_stat[cmd->device->id] != SS_WAITING) {
1250
1251/* A device has sent an unsolicited SDTR message; rather than go
1252 * through the effort of decoding it and then figuring out what
1253 * our reply should be, we're just gonna say that we have a
1254 * synchronous fifo depth of 0. This will result in asynchronous
1255 * transfers - not ideal but so much easier.
1256 * Actually, this is OK because it assures us that if we don't
1257 * specifically ask for sync transfers, we won't do any.
1258 */
1259
1260                                                write_3393_cmd(hostdata, WD_CMD_ASSERT_ATN);    /* want MESS_OUT */
1261                                                hostdata->outgoing_msg[0] = EXTENDED_MESSAGE;
1262                                                hostdata->outgoing_msg[1] = 3;
1263                                                hostdata->outgoing_msg[2] = EXTENDED_SDTR;
1264                                                hostdata->outgoing_msg[3] = hostdata->default_sx_per / 4;
1265                                                hostdata->outgoing_msg[4] = 0;
1266                                                hostdata->outgoing_len = 5;
1267                                                hostdata->sync_xfer[cmd->device->id] = calc_sync_xfer(hostdata->default_sx_per / 4, 0);
1268                                        } else {
1269                                                hostdata->sync_xfer[cmd->device->id] = id;
1270                                        }
1271#ifdef SYNC_DEBUG
1272                                        printk("sync_xfer=%02x", hostdata->sync_xfer[cmd->device->id]);
1273#endif
1274                                        hostdata->sync_stat[cmd->device->id] = SS_SET;
1275                                        write_3393_cmd(hostdata, WD_CMD_NEGATE_ACK);
1276                                        hostdata->state = S_CONNECTED;
1277                                        break;
1278                                case EXTENDED_WDTR:
1279                                        write_3393_cmd(hostdata, WD_CMD_ASSERT_ATN);    /* want MESS_OUT */
1280                                        printk("sending WDTR ");
1281                                        hostdata->outgoing_msg[0] = EXTENDED_MESSAGE;
1282                                        hostdata->outgoing_msg[1] = 2;
1283                                        hostdata->outgoing_msg[2] = EXTENDED_WDTR;
1284                                        hostdata->outgoing_msg[3] = 0;  /* 8 bit transfer width */
1285                                        hostdata->outgoing_len = 4;
1286                                        write_3393_cmd(hostdata, WD_CMD_NEGATE_ACK);
1287                                        hostdata->state = S_CONNECTED;
1288                                        break;
1289                                default:
1290                                        write_3393_cmd(hostdata, WD_CMD_ASSERT_ATN);    /* want MESS_OUT */
1291                                        printk("Rejecting Unknown Extended Message(%02x). ", ucp[2]);
1292                                        hostdata->outgoing_msg[0] = MESSAGE_REJECT;
1293                                        hostdata->outgoing_len = 1;
1294                                        write_3393_cmd(hostdata, WD_CMD_NEGATE_ACK);
1295                                        hostdata->state = S_CONNECTED;
1296                                        break;
1297                                }
1298                                hostdata->incoming_ptr = 0;
1299                        }
1300
1301                        /* We need to read more MESS_IN bytes for the extended message */
1302
1303                        else {
1304                                hostdata->incoming_ptr++;
1305                                write_3393_cmd(hostdata, WD_CMD_NEGATE_ACK);
1306                                hostdata->state = S_CONNECTED;
1307                        }
1308                        break;
1309
1310                default:
1311                        printk("Rejecting Unknown Message(%02x) ", msg);
1312                        write_3393_cmd(hostdata, WD_CMD_ASSERT_ATN);    /* want MESS_OUT */
1313                        hostdata->outgoing_msg[0] = MESSAGE_REJECT;
1314                        hostdata->outgoing_len = 1;
1315                        write_3393_cmd(hostdata, WD_CMD_NEGATE_ACK);
1316                        hostdata->state = S_CONNECTED;
1317                }
1318                break;
1319
1320
1321/* Note: this interrupt will occur only after a LEVEL2 command */
1322
1323        case CSR_SEL_XFER_DONE:
1324
1325/* Make sure that reselection is enabled at this point - it may
1326 * have been turned off for the command that just completed.
1327 */
1328
1329                write_3393(hostdata, WD_SOURCE_ID, SRCID_ER);
1330                if (phs == 0x60) {
1331                        DB(DB_INTR, printk("SX-DONE"))
1332                            cmd->SCp.Message = COMMAND_COMPLETE;
1333                        lun = read_3393(hostdata, WD_TARGET_LUN);
1334                        DB(DB_INTR, printk(":%d.%d", cmd->SCp.Status, lun))
1335                            hostdata->connected = NULL;
1336                        hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun);
1337                        hostdata->state = S_UNCONNECTED;
1338                        if (cmd->SCp.Status == ILLEGAL_STATUS_BYTE)
1339                                cmd->SCp.Status = lun;
1340                        if (cmd->cmnd[0] == REQUEST_SENSE && cmd->SCp.Status != GOOD)
1341                                cmd->result = (cmd->result & 0x00ffff) | (DID_ERROR << 16);
1342                        else
1343                                cmd->result = cmd->SCp.Status | (cmd->SCp.Message << 8);
1344                        cmd->scsi_done(cmd);
1345
1346/* We are no longer connected to a target - check to see if
1347 * there are commands waiting to be executed.
1348 */
1349
1350                        in2000_execute(instance);
1351                } else {
1352                        printk("%02x:%02x:%02x: Unknown SEL_XFER_DONE phase!!---", asr, sr, phs);
1353                }
1354                break;
1355
1356
1357/* Note: this interrupt will occur only after a LEVEL2 command */
1358
1359        case CSR_SDP:
1360                DB(DB_INTR, printk("SDP"))
1361                    hostdata->state = S_RUNNING_LEVEL2;
1362                write_3393(hostdata, WD_COMMAND_PHASE, 0x41);
1363                write_3393_cmd(hostdata, WD_CMD_SEL_ATN_XFER);
1364                break;
1365
1366
1367        case CSR_XFER_DONE | PHS_MESS_OUT:
1368        case CSR_UNEXP | PHS_MESS_OUT:
1369        case CSR_SRV_REQ | PHS_MESS_OUT:
1370                DB(DB_INTR, printk("MSG_OUT="))
1371
1372/* To get here, we've probably requested MESSAGE_OUT and have
1373 * already put the correct bytes in outgoing_msg[] and filled
1374 * in outgoing_len. We simply send them out to the SCSI bus.
1375 * Sometimes we get MESSAGE_OUT phase when we're not expecting
1376 * it - like when our SDTR message is rejected by a target. Some
1377 * targets send the REJECT before receiving all of the extended
1378 * message, and then seem to go back to MESSAGE_OUT for a byte
1379 * or two. Not sure why, or if I'm doing something wrong to
1380 * cause this to happen. Regardless, it seems that sending
1381 * NOP messages in these situations results in no harm and
1382 * makes everyone happy.
1383 */
1384                    if (hostdata->outgoing_len == 0) {
1385                        hostdata->outgoing_len = 1;
1386                        hostdata->outgoing_msg[0] = NOP;
1387                }
1388                transfer_pio(hostdata->outgoing_msg, hostdata->outgoing_len, DATA_OUT_DIR, hostdata);
1389                DB(DB_INTR, printk("%02x", hostdata->outgoing_msg[0]))
1390                    hostdata->outgoing_len = 0;
1391                hostdata->state = S_CONNECTED;
1392                break;
1393
1394
1395        case CSR_UNEXP_DISC:
1396
1397/* I think I've seen this after a request-sense that was in response
1398 * to an error condition, but not sure. We certainly need to do
1399 * something when we get this interrupt - the question is 'what?'.
1400 * Let's think positively, and assume some command has finished
1401 * in a legal manner (like a command that provokes a request-sense),
1402 * so we treat it as a normal command-complete-disconnect.
1403 */
1404
1405
1406/* Make sure that reselection is enabled at this point - it may
1407 * have been turned off for the command that just completed.
1408 */
1409
1410                write_3393(hostdata, WD_SOURCE_ID, SRCID_ER);
1411                if (cmd == NULL) {
1412                        printk(" - Already disconnected! ");
1413                        hostdata->state = S_UNCONNECTED;
1414
1415/* release the SMP spin_lock and restore irq state */
1416                        spin_unlock_irqrestore(instance->host_lock, flags);
1417                        return IRQ_HANDLED;
1418                }
1419                DB(DB_INTR, printk("UNEXP_DISC"))
1420                    hostdata->connected = NULL;
1421                hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun);
1422                hostdata->state = S_UNCONNECTED;
1423                if (cmd->cmnd[0] == REQUEST_SENSE && cmd->SCp.Status != GOOD)
1424                        cmd->result = (cmd->result & 0x00ffff) | (DID_ERROR << 16);
1425                else
1426                        cmd->result = cmd->SCp.Status | (cmd->SCp.Message << 8);
1427                cmd->scsi_done(cmd);
1428
1429/* We are no longer connected to a target - check to see if
1430 * there are commands waiting to be executed.
1431 */
1432
1433                in2000_execute(instance);
1434                break;
1435
1436
1437        case CSR_DISC:
1438
1439/* Make sure that reselection is enabled at this point - it may
1440 * have been turned off for the command that just completed.
1441 */
1442
1443                write_3393(hostdata, WD_SOURCE_ID, SRCID_ER);
1444                DB(DB_INTR, printk("DISC"))
1445                    if (cmd == NULL) {
1446                        printk(" - Already disconnected! ");
1447                        hostdata->state = S_UNCONNECTED;
1448                }
1449                switch (hostdata->state) {
1450                case S_PRE_CMP_DISC:
1451                        hostdata->connected = NULL;
1452                        hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun);
1453                        hostdata->state = S_UNCONNECTED;
1454                        DB(DB_INTR, printk(":%d", cmd->SCp.Status))
1455                            if (cmd->cmnd[0] == REQUEST_SENSE && cmd->SCp.Status != GOOD)
1456                                cmd->result = (cmd->result & 0x00ffff) | (DID_ERROR << 16);
1457                        else
1458                                cmd->result = cmd->SCp.Status | (cmd->SCp.Message << 8);
1459                        cmd->scsi_done(cmd);
1460                        break;
1461                case S_PRE_TMP_DISC:
1462                case S_RUNNING_LEVEL2:
1463                        cmd->host_scribble = (uchar *) hostdata->disconnected_Q;
1464                        hostdata->disconnected_Q = cmd;
1465                        hostdata->connected = NULL;
1466                        hostdata->state = S_UNCONNECTED;
1467
1468#ifdef PROC_STATISTICS
1469                        hostdata->disc_done_cnt[cmd->device->id]++;
1470#endif
1471
1472                        break;
1473                default:
1474                        printk("*** Unexpected DISCONNECT interrupt! ***");
1475                        hostdata->state = S_UNCONNECTED;
1476                }
1477
1478/* We are no longer connected to a target - check to see if
1479 * there are commands waiting to be executed.
1480 */
1481
1482                in2000_execute(instance);
1483                break;
1484
1485
1486        case CSR_RESEL_AM:
1487                DB(DB_INTR, printk("RESEL"))
1488
1489                    /* First we have to make sure this reselection didn't */
1490                    /* happen during Arbitration/Selection of some other device. */
1491                    /* If yes, put losing command back on top of input_Q. */
1492                    if (hostdata->level2 <= L2_NONE) {
1493
1494                        if (hostdata->selecting) {
1495                                cmd = (Scsi_Cmnd *) hostdata->selecting;
1496                                hostdata->selecting = NULL;
1497                                hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun);
1498                                cmd->host_scribble = (uchar *) hostdata->input_Q;
1499                                hostdata->input_Q = cmd;
1500                        }
1501                }
1502
1503                else {
1504
1505                        if (cmd) {
1506                                if (phs == 0x00) {
1507                                        hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun);
1508                                        cmd->host_scribble = (uchar *) hostdata->input_Q;
1509                                        hostdata->input_Q = cmd;
1510                                } else {
1511                                        printk("---%02x:%02x:%02x-TROUBLE: Intrusive ReSelect!---", asr, sr, phs);
1512                                        while (1)
1513                                                printk("\r");
1514                                }
1515                        }
1516
1517                }
1518
1519                /* OK - find out which device reselected us. */
1520
1521                id = read_3393(hostdata, WD_SOURCE_ID);
1522                id &= SRCID_MASK;
1523
1524                /* and extract the lun from the ID message. (Note that we don't
1525                 * bother to check for a valid message here - I guess this is
1526                 * not the right way to go, but....)
1527                 */
1528
1529                lun = read_3393(hostdata, WD_DATA);
1530                if (hostdata->level2 < L2_RESELECT)
1531                        write_3393_cmd(hostdata, WD_CMD_NEGATE_ACK);
1532                lun &= 7;
1533
1534                /* Now we look for the command that's reconnecting. */
1535
1536                cmd = (Scsi_Cmnd *) hostdata->disconnected_Q;
1537                patch = NULL;
1538                while (cmd) {
1539                        if (id == cmd->device->id && lun == cmd->device->lun)
1540                                break;
1541                        patch = cmd;
1542                        cmd = (Scsi_Cmnd *) cmd->host_scribble;
1543                }
1544
1545                /* Hmm. Couldn't find a valid command.... What to do? */
1546
1547                if (!cmd) {
1548                        printk("---TROUBLE: target %d.%d not in disconnect queue---", id, lun);
1549                        break;
1550                }
1551
1552                /* Ok, found the command - now start it up again. */
1553
1554                if (patch)
1555                        patch->host_scribble = cmd->host_scribble;
1556                else
1557                        hostdata->disconnected_Q = (Scsi_Cmnd *) cmd->host_scribble;
1558                hostdata->connected = cmd;
1559
1560                /* We don't need to worry about 'initialize_SCp()' or 'hostdata->busy[]'
1561                 * because these things are preserved over a disconnect.
1562                 * But we DO need to fix the DPD bit so it's correct for this command.
1563                 */
1564
1565                if (is_dir_out(cmd))
1566                        write_3393(hostdata, WD_DESTINATION_ID, cmd->device->id);
1567                else
1568                        write_3393(hostdata, WD_DESTINATION_ID, cmd->device->id | DSTID_DPD);
1569                if (hostdata->level2 >= L2_RESELECT) {
1570                        write_3393_count(hostdata, 0);  /* we want a DATA_PHASE interrupt */
1571                        write_3393(hostdata, WD_COMMAND_PHASE, 0x45);
1572                        write_3393_cmd(hostdata, WD_CMD_SEL_ATN_XFER);
1573                        hostdata->state = S_RUNNING_LEVEL2;
1574                } else
1575                        hostdata->state = S_CONNECTED;
1576
1577                    break;
1578
1579        default:
1580                printk("--UNKNOWN INTERRUPT:%02x:%02x:%02x--", asr, sr, phs);
1581        }
1582
1583        write1_io(0, IO_LED_OFF);
1584
1585        DB(DB_INTR, printk("} "))
1586
1587/* release the SMP spin_lock and restore irq state */
1588            spin_unlock_irqrestore(instance->host_lock, flags);
1589        return IRQ_HANDLED;
1590}
1591
1592
1593
1594#define RESET_CARD         0
1595#define RESET_CARD_AND_BUS 1
1596#define B_FLAG 0x80
1597
1598/*
1599 *      Caller must hold instance lock!
1600 */
1601
1602static int reset_hardware(struct Scsi_Host *instance, int type)
1603{
1604        struct IN2000_hostdata *hostdata;
1605        int qt, x;
1606
1607        hostdata = (struct IN2000_hostdata *) instance->hostdata;
1608
1609        write1_io(0, IO_LED_ON);
1610        if (type == RESET_CARD_AND_BUS) {
1611                write1_io(0, IO_CARD_RESET);
1612                x = read1_io(IO_HARDWARE);
1613        }
1614        x = read_3393(hostdata, WD_SCSI_STATUS);        /* clear any WD intrpt */
1615        write_3393(hostdata, WD_OWN_ID, instance->this_id | OWNID_EAF | OWNID_RAF | OWNID_FS_8);
1616        write_3393(hostdata, WD_CONTROL, CTRL_IDI | CTRL_EDI | CTRL_POLLED);
1617        write_3393(hostdata, WD_SYNCHRONOUS_TRANSFER, calc_sync_xfer(hostdata->default_sx_per / 4, DEFAULT_SX_OFF));
1618
1619        write1_io(0, IO_FIFO_WRITE);    /* clear fifo counter */
1620        write1_io(0, IO_FIFO_READ);     /* start fifo out in read mode */
1621        write_3393(hostdata, WD_COMMAND, WD_CMD_RESET);
1622        /* FIXME: timeout ?? */
1623        while (!(READ_AUX_STAT() & ASR_INT))
1624                cpu_relax();    /* wait for RESET to complete */
1625
1626        x = read_3393(hostdata, WD_SCSI_STATUS);        /* clear interrupt */
1627
1628        write_3393(hostdata, WD_QUEUE_TAG, 0xa5);       /* any random number */
1629        qt = read_3393(hostdata, WD_QUEUE_TAG);
1630        if (qt == 0xa5) {
1631                x |= B_FLAG;
1632                write_3393(hostdata, WD_QUEUE_TAG, 0);
1633        }
1634        write_3393(hostdata, WD_TIMEOUT_PERIOD, TIMEOUT_PERIOD_VALUE);
1635        write_3393(hostdata, WD_CONTROL, CTRL_IDI | CTRL_EDI | CTRL_POLLED);
1636        write1_io(0, IO_LED_OFF);
1637        return x;
1638}
1639
1640
1641
1642static int in2000_bus_reset(Scsi_Cmnd * cmd)
1643{
1644        struct Scsi_Host *instance;
1645        struct IN2000_hostdata *hostdata;
1646        int x;
1647        unsigned long flags;
1648
1649        instance = cmd->device->host;
1650        hostdata = (struct IN2000_hostdata *) instance->hostdata;
1651
1652        printk(KERN_WARNING "scsi%d: Reset. ", instance->host_no);
1653
1654        spin_lock_irqsave(instance->host_lock, flags);
1655
1656        /* do scsi-reset here */
1657        reset_hardware(instance, RESET_CARD_AND_BUS);
1658        for (x = 0; x < 8; x++) {
1659                hostdata->busy[x] = 0;
1660                hostdata->sync_xfer[x] = calc_sync_xfer(DEFAULT_SX_PER / 4, DEFAULT_SX_OFF);
1661                hostdata->sync_stat[x] = SS_UNSET;      /* using default sync values */
1662        }
1663        hostdata->input_Q = NULL;
1664        hostdata->selecting = NULL;
1665        hostdata->connected = NULL;
1666        hostdata->disconnected_Q = NULL;
1667        hostdata->state = S_UNCONNECTED;
1668        hostdata->fifo = FI_FIFO_UNUSED;
1669        hostdata->incoming_ptr = 0;
1670        hostdata->outgoing_len = 0;
1671
1672        cmd->result = DID_RESET << 16;
1673
1674        spin_unlock_irqrestore(instance->host_lock, flags);
1675        return SUCCESS;
1676}
1677
1678static int __in2000_abort(Scsi_Cmnd * cmd)
1679{
1680        struct Scsi_Host *instance;
1681        struct IN2000_hostdata *hostdata;
1682        Scsi_Cmnd *tmp, *prev;
1683        uchar sr, asr;
1684        unsigned long timeout;
1685
1686        instance = cmd->device->host;
1687        hostdata = (struct IN2000_hostdata *) instance->hostdata;
1688
1689        printk(KERN_DEBUG "scsi%d: Abort-", instance->host_no);
1690        printk("(asr=%02x,count=%ld,resid=%d,buf_resid=%d,have_data=%d,FC=%02x)- ", READ_AUX_STAT(), read_3393_count(hostdata), cmd->SCp.this_residual, cmd->SCp.buffers_residual, cmd->SCp.have_data_in, read1_io(IO_FIFO_COUNT));
1691
1692/*
1693 * Case 1 : If the command hasn't been issued yet, we simply remove it
1694 *     from the inout_Q.
1695 */
1696
1697        tmp = (Scsi_Cmnd *) hostdata->input_Q;
1698        prev = NULL;
1699        while (tmp) {
1700                if (tmp == cmd) {
1701                        if (prev)
1702                                prev->host_scribble = cmd->host_scribble;
1703                        cmd->host_scribble = NULL;
1704                        cmd->result = DID_ABORT << 16;
1705                        printk(KERN_WARNING "scsi%d: Abort - removing command from input_Q. ", instance->host_no);
1706                        cmd->scsi_done(cmd);
1707                        return SUCCESS;
1708                }
1709                prev = tmp;
1710                tmp = (Scsi_Cmnd *) tmp->host_scribble;
1711        }
1712
1713/*
1714 * Case 2 : If the command is connected, we're going to fail the abort
1715 *     and let the high level SCSI driver retry at a later time or
1716 *     issue a reset.
1717 *
1718 *     Timeouts, and therefore aborted commands, will be highly unlikely
1719 *     and handling them cleanly in this situation would make the common
1720 *     case of noresets less efficient, and would pollute our code.  So,
1721 *     we fail.
1722 */
1723
1724        if (hostdata->connected == cmd) {
1725
1726                printk(KERN_WARNING "scsi%d: Aborting connected command - ", instance->host_no);
1727
1728                printk("sending wd33c93 ABORT command - ");
1729                write_3393(hostdata, WD_CONTROL, CTRL_IDI | CTRL_EDI | CTRL_POLLED);
1730                write_3393_cmd(hostdata, WD_CMD_ABORT);
1731
1732/* Now we have to attempt to flush out the FIFO... */
1733
1734                printk("flushing fifo - ");
1735                timeout = 1000000;
1736                do {
1737                        asr = READ_AUX_STAT();
1738                        if (asr & ASR_DBR)
1739                                read_3393(hostdata, WD_DATA);
1740                } while (!(asr & ASR_INT) && timeout-- > 0);
1741                sr = read_3393(hostdata, WD_SCSI_STATUS);
1742                printk("asr=%02x, sr=%02x, %ld bytes un-transferred (timeout=%ld) - ", asr, sr, read_3393_count(hostdata), timeout);
1743
1744                /*
1745                 * Abort command processed.
1746                 * Still connected.
1747                 * We must disconnect.
1748                 */
1749
1750                printk("sending wd33c93 DISCONNECT command - ");
1751                write_3393_cmd(hostdata, WD_CMD_DISCONNECT);
1752
1753                timeout = 1000000;
1754                asr = READ_AUX_STAT();
1755                while ((asr & ASR_CIP) && timeout-- > 0)
1756                        asr = READ_AUX_STAT();
1757                sr = read_3393(hostdata, WD_SCSI_STATUS);
1758                printk("asr=%02x, sr=%02x.", asr, sr);
1759
1760                hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun);
1761                hostdata->connected = NULL;
1762                hostdata->state = S_UNCONNECTED;
1763                cmd->result = DID_ABORT << 16;
1764                cmd->scsi_done(cmd);
1765
1766                in2000_execute(instance);
1767
1768                return SUCCESS;
1769        }
1770
1771/*
1772 * Case 3: If the command is currently disconnected from the bus,
1773 * we're not going to expend much effort here: Let's just return
1774 * an ABORT_SNOOZE and hope for the best...
1775 */
1776
1777        for (tmp = (Scsi_Cmnd *) hostdata->disconnected_Q; tmp; tmp = (Scsi_Cmnd *) tmp->host_scribble)
1778                if (cmd == tmp) {
1779                        printk(KERN_DEBUG "scsi%d: unable to abort disconnected command.\n", instance->host_no);
1780                        return FAILED;
1781                }
1782
1783/*
1784 * Case 4 : If we reached this point, the command was not found in any of
1785 *     the queues.
1786 *
1787 * We probably reached this point because of an unlikely race condition
1788 * between the command completing successfully and the abortion code,
1789 * so we won't panic, but we will notify the user in case something really
1790 * broke.
1791 */
1792
1793        in2000_execute(instance);
1794
1795        printk("scsi%d: warning : SCSI command probably completed successfully" "         before abortion. ", instance->host_no);
1796        return SUCCESS;
1797}
1798
1799static int in2000_abort(Scsi_Cmnd * cmd)
1800{
1801        int rc;
1802
1803        spin_lock_irq(cmd->device->host->host_lock);
1804        rc = __in2000_abort(cmd);
1805        spin_unlock_irq(cmd->device->host->host_lock);
1806
1807        return rc;
1808}
1809
1810
1811#define MAX_IN2000_HOSTS 3
1812#define MAX_SETUP_ARGS ARRAY_SIZE(setup_args)
1813#define SETUP_BUFFER_SIZE 200
1814static char setup_buffer[SETUP_BUFFER_SIZE];
1815static char setup_used[MAX_SETUP_ARGS];
1816static int done_setup = 0;
1817
1818static void __init in2000_setup(char *str, int *ints)
1819{
1820        int i;
1821        char *p1, *p2;
1822
1823        strlcpy(setup_buffer, str, SETUP_BUFFER_SIZE);
1824        p1 = setup_buffer;
1825        i = 0;
1826        while (*p1 && (i < MAX_SETUP_ARGS)) {
1827                p2 = strchr(p1, ',');
1828                if (p2) {
1829                        *p2 = '\0';
1830                        if (p1 != p2)
1831                                setup_args[i] = p1;
1832                        p1 = p2 + 1;
1833                        i++;
1834                } else {
1835                        setup_args[i] = p1;
1836                        break;
1837                }
1838        }
1839        for (i = 0; i < MAX_SETUP_ARGS; i++)
1840                setup_used[i] = 0;
1841        done_setup = 1;
1842}
1843
1844
1845/* check_setup_args() returns index if key found, 0 if not
1846 */
1847
1848static int __init check_setup_args(char *key, int *val, char *buf)
1849{
1850        int x;
1851        char *cp;
1852
1853        for (x = 0; x < MAX_SETUP_ARGS; x++) {
1854                if (setup_used[x])
1855                        continue;
1856                if (!strncmp(setup_args[x], key, strlen(key)))
1857                        break;
1858        }
1859        if (x == MAX_SETUP_ARGS)
1860                return 0;
1861        setup_used[x] = 1;
1862        cp = setup_args[x] + strlen(key);
1863        *val = -1;
1864        if (*cp != ':')
1865                return ++x;
1866        cp++;
1867        if ((*cp >= '0') && (*cp <= '9')) {
1868                *val = simple_strtoul(cp, NULL, 0);
1869        }
1870        return ++x;
1871}
1872
1873
1874
1875/* The "correct" (ie portable) way to access memory-mapped hardware
1876 * such as the IN2000 EPROM and dip switch is through the use of
1877 * special macros declared in 'asm/io.h'. We use readb() and readl()
1878 * when reading from the card's BIOS area in in2000_detect().
1879 */
1880static u32 bios_tab[] in2000__INITDATA = {
1881        0xc8000,
1882        0xd0000,
1883        0xd8000,
1884        0
1885};
1886
1887static unsigned short base_tab[] in2000__INITDATA = {
1888        0x220,
1889        0x200,
1890        0x110,
1891        0x100,
1892};
1893
1894static int int_tab[] in2000__INITDATA = {
1895        15,
1896        14,
1897        11,
1898        10
1899};
1900
1901static int probe_bios(u32 addr, u32 *s1, uchar *switches)
1902{
1903        void __iomem *p = ioremap(addr, 0x34);
1904        if (!p)
1905                return 0;
1906        *s1 = readl(p + 0x10);
1907        if (*s1 == 0x41564f4e || readl(p + 0x30) == 0x61776c41) {
1908                /* Read the switch image that's mapped into EPROM space */
1909                *switches = ~readb(p + 0x20);
1910                iounmap(p);
1911                return 1;
1912        }
1913        iounmap(p);
1914        return 0;
1915}
1916
1917static int __init in2000_detect(struct scsi_host_template * tpnt)
1918{
1919        struct Scsi_Host *instance;
1920        struct IN2000_hostdata *hostdata;
1921        int detect_count;
1922        int bios;
1923        int x;
1924        unsigned short base;
1925        uchar switches;
1926        uchar hrev;
1927        unsigned long flags;
1928        int val;
1929        char buf[32];
1930
1931/* Thanks to help from Bill Earnest, probing for IN2000 cards is a
1932 * pretty straightforward and fool-proof operation. There are 3
1933 * possible locations for the IN2000 EPROM in memory space - if we
1934 * find a BIOS signature, we can read the dip switch settings from
1935 * the byte at BIOS+32 (shadowed in by logic on the card). From 2
1936 * of the switch bits we get the card's address in IO space. There's
1937 * an image of the dip switch there, also, so we have a way to back-
1938 * check that this really is an IN2000 card. Very nifty. Use the
1939 * 'ioport:xx' command-line parameter if your BIOS EPROM is absent
1940 * or disabled.
1941 */
1942
1943        if (!done_setup && setup_strings)
1944                in2000_setup(setup_strings, NULL);
1945
1946        detect_count = 0;
1947        for (bios = 0; bios_tab[bios]; bios++) {
1948                u32 s1 = 0;
1949                if (check_setup_args("ioport", &val, buf)) {
1950                        base = val;
1951                        switches = ~inb(base + IO_SWITCHES) & 0xff;
1952                        printk("Forcing IN2000 detection at IOport 0x%x ", base);
1953                        bios = 2;
1954                }
1955/*
1956 * There have been a couple of BIOS versions with different layouts
1957 * for the obvious ID strings. We look for the 2 most common ones and
1958 * hope that they cover all the cases...
1959 */
1960                else if (probe_bios(bios_tab[bios], &s1, &switches)) {
1961                        printk("Found IN2000 BIOS at 0x%x ", (unsigned int) bios_tab[bios]);
1962
1963/* Find out where the IO space is */
1964
1965                        x = switches & (SW_ADDR0 | SW_ADDR1);
1966                        base = base_tab[x];
1967
1968/* Check for the IN2000 signature in IO space. */
1969
1970                        x = ~inb(base + IO_SWITCHES) & 0xff;
1971                        if (x != switches) {
1972                                printk("Bad IO signature: %02x vs %02x.\n", x, switches);
1973                                continue;
1974                        }
1975                } else
1976                        continue;
1977
1978/* OK. We have a base address for the IO ports - run a few safety checks */
1979
1980                if (!(switches & SW_BIT7)) {    /* I _think_ all cards do this */
1981                        printk("There is no IN-2000 SCSI card at IOport 0x%03x!\n", base);
1982                        continue;
1983                }
1984
1985/* Let's assume any hardware version will work, although the driver
1986 * has only been tested on 0x21, 0x22, 0x25, 0x26, and 0x27. We'll
1987 * print out the rev number for reference later, but accept them all.
1988 */
1989
1990                hrev = inb(base + IO_HARDWARE);
1991
1992                /* Bit 2 tells us if interrupts are disabled */
1993                if (switches & SW_DISINT) {
1994                        printk("The IN-2000 SCSI card at IOport 0x%03x ", base);
1995                        printk("is not configured for interrupt operation!\n");
1996                        printk("This driver requires an interrupt: cancelling detection.\n");
1997                        continue;
1998                }
1999
2000/* Ok. We accept that there's an IN2000 at ioaddr 'base'. Now
2001 * initialize it.
2002 */
2003
2004                tpnt->proc_name = "in2000";
2005                instance = scsi_register(tpnt, sizeof(struct IN2000_hostdata));
2006                if (instance == NULL)
2007                        continue;
2008                detect_count++;
2009                hostdata = (struct IN2000_hostdata *) instance->hostdata;
2010                instance->io_port = hostdata->io_base = base;
2011                hostdata->dip_switch = switches;
2012                hostdata->hrev = hrev;
2013
2014                write1_io(0, IO_FIFO_WRITE);    /* clear fifo counter */
2015                write1_io(0, IO_FIFO_READ);     /* start fifo out in read mode */
2016                write1_io(0, IO_INTR_MASK);     /* allow all ints */
2017                x = int_tab[(switches & (SW_INT0 | SW_INT1)) >> SW_INT_SHIFT];
2018                if (request_irq(x, in2000_intr, IRQF_DISABLED, "in2000", instance)) {
2019                        printk("in2000_detect: Unable to allocate IRQ.\n");
2020                        detect_count--;
2021                        continue;
2022                }
2023                instance->irq = x;
2024                instance->n_io_port = 13;
2025                request_region(base, 13, "in2000");     /* lock in this IO space for our use */
2026
2027                for (x = 0; x < 8; x++) {
2028                        hostdata->busy[x] = 0;
2029                        hostdata->sync_xfer[x] = calc_sync_xfer(DEFAULT_SX_PER / 4, DEFAULT_SX_OFF);
2030                        hostdata->sync_stat[x] = SS_UNSET;      /* using default sync values */
2031#ifdef PROC_STATISTICS
2032                        hostdata->cmd_cnt[x] = 0;
2033                        hostdata->disc_allowed_cnt[x] = 0;
2034                        hostdata->disc_done_cnt[x] = 0;
2035#endif
2036                }
2037                hostdata->input_Q = NULL;
2038                hostdata->selecting = NULL;
2039                hostdata->connected = NULL;
2040                hostdata->disconnected_Q = NULL;
2041                hostdata->state = S_UNCONNECTED;
2042                hostdata->fifo = FI_FIFO_UNUSED;
2043                hostdata->level2 = L2_BASIC;
2044                hostdata->disconnect = DIS_ADAPTIVE;
2045                hostdata->args = DEBUG_DEFAULTS;
2046                hostdata->incoming_ptr = 0;
2047                hostdata->outgoing_len = 0;
2048                hostdata->default_sx_per = DEFAULT_SX_PER;
2049
2050/* Older BIOS's had a 'sync on/off' switch - use its setting */
2051
2052                if (s1 == 0x41564f4e && (switches & SW_SYNC_DOS5))
2053                        hostdata->sync_off = 0x00;      /* sync defaults to on */
2054                else
2055                        hostdata->sync_off = 0xff;      /* sync defaults to off */
2056
2057#ifdef PROC_INTERFACE
2058                hostdata->proc = PR_VERSION | PR_INFO | PR_STATISTICS | PR_CONNECTED | PR_INPUTQ | PR_DISCQ | PR_STOP;
2059#ifdef PROC_STATISTICS
2060                hostdata->int_cnt = 0;
2061#endif
2062#endif
2063
2064                if (check_setup_args("nosync", &val, buf))
2065                        hostdata->sync_off = val;
2066
2067                if (check_setup_args("period", &val, buf))
2068                        hostdata->default_sx_per = sx_table[round_period((unsigned int) val)].period_ns;
2069
2070                if (check_setup_args("disconnect", &val, buf)) {
2071                        if ((val >= DIS_NEVER) && (val <= DIS_ALWAYS))
2072                                hostdata->disconnect = val;
2073                        else
2074                                hostdata->disconnect = DIS_ADAPTIVE;
2075                }
2076
2077                if (check_setup_args("noreset", &val, buf))
2078                        hostdata->args ^= A_NO_SCSI_RESET;
2079
2080                if (check_setup_args("level2", &val, buf))
2081                        hostdata->level2 = val;
2082
2083                if (check_setup_args("debug", &val, buf))
2084                        hostdata->args = (val & DB_MASK);
2085
2086#ifdef PROC_INTERFACE
2087                if (check_setup_args("proc", &val, buf))
2088                        hostdata->proc = val;
2089#endif
2090
2091
2092                /* FIXME: not strictly needed I think but the called code expects
2093                   to be locked */
2094                spin_lock_irqsave(instance->host_lock, flags);
2095                x = reset_hardware(instance, (hostdata->args & A_NO_SCSI_RESET) ? RESET_CARD : RESET_CARD_AND_BUS);
2096                spin_unlock_irqrestore(instance->host_lock, flags);
2097
2098                hostdata->microcode = read_3393(hostdata, WD_CDB_1);
2099                if (x & 0x01) {
2100                        if (x & B_FLAG)
2101                                hostdata->chip = C_WD33C93B;
2102                        else
2103                                hostdata->chip = C_WD33C93A;
2104                } else
2105                        hostdata->chip = C_WD33C93;
2106
2107                printk("dip_switch=%02x irq=%d ioport=%02x floppy=%s sync/DOS5=%s ", (switches & 0x7f), instance->irq, hostdata->io_base, (switches & SW_FLOPPY) ? "Yes" : "No", (switches & SW_SYNC_DOS5) ? "Yes" : "No");
2108                printk("hardware_ver=%02x chip=%s microcode=%02x\n", hrev, (hostdata->chip == C_WD33C93) ? "WD33c93" : (hostdata->chip == C_WD33C93A) ? "WD33c93A" : (hostdata->chip == C_WD33C93B) ? "WD33c93B" : "unknown", hostdata->microcode);
2109#ifdef DEBUGGING_ON
2110                printk("setup_args = ");
2111                for (x = 0; x < MAX_SETUP_ARGS; x++)
2112                        printk("%s,", setup_args[x]);
2113                printk("\n");
2114#endif
2115                if (hostdata->sync_off == 0xff)
2116                        printk("Sync-transfer DISABLED on all devices: ENABLE from command-line\n");
2117                printk("IN2000 driver version %s - %s\n", IN2000_VERSION, IN2000_DATE);
2118        }
2119
2120        return detect_count;
2121}
2122
2123static int in2000_release(struct Scsi_Host *shost)
2124{
2125        if (shost->irq)
2126                free_irq(shost->irq, shost);
2127        if (shost->io_port && shost->n_io_port)
2128                release_region(shost->io_port, shost->n_io_port);
2129        return 0;
2130}
2131
2132/* NOTE: I lifted this function straight out of the old driver,
2133 *       and have not tested it. Presumably it does what it's
2134 *       supposed to do...
2135 */
2136
2137static int in2000_biosparam(struct scsi_device *sdev, struct block_device *bdev, sector_t capacity, int *iinfo)
2138{
2139        int size;
2140
2141        size = capacity;
2142        iinfo[0] = 64;
2143        iinfo[1] = 32;
2144        iinfo[2] = size >> 11;
2145
2146/* This should approximate the large drive handling that the DOS ASPI manager
2147   uses.  Drives very near the boundaries may not be handled correctly (i.e.
2148   near 2.0 Gb and 4.0 Gb) */
2149
2150        if (iinfo[2] > 1024) {
2151                iinfo[0] = 64;
2152                iinfo[1] = 63;
2153                iinfo[2] = (unsigned long) capacity / (iinfo[0] * iinfo[1]);
2154        }
2155        if (iinfo[2] > 1024) {
2156                iinfo[0] = 128;
2157                iinfo[1] = 63;
2158                iinfo[2] = (unsigned long) capacity / (iinfo[0] * iinfo[1]);
2159        }
2160        if (iinfo[2] > 1024) {
2161                iinfo[0] = 255;
2162                iinfo[1] = 63;
2163                iinfo[2] = (unsigned long) capacity / (iinfo[0] * iinfo[1]);
2164        }
2165        return 0;
2166}
2167
2168
2169static int in2000_proc_info(struct Scsi_Host *instance, char *buf, char **start, off_t off, int len, int in)
2170{
2171
2172#ifdef PROC_INTERFACE
2173
2174        char *bp;
2175        char tbuf[128];
2176        unsigned long flags;
2177        struct IN2000_hostdata *hd;
2178        Scsi_Cmnd *cmd;
2179        int x, i;
2180        static int stop = 0;
2181
2182        hd = (struct IN2000_hostdata *) instance->hostdata;
2183
2184/* If 'in' is TRUE we need to _read_ the proc file. We accept the following
2185 * keywords (same format as command-line, but only ONE per read):
2186 *    debug
2187 *    disconnect
2188 *    period
2189 *    resync
2190 *    proc
2191 */
2192
2193        if (in) {
2194                buf[len] = '\0';
2195                bp = buf;
2196                if (!strncmp(bp, "debug:", 6)) {
2197                        bp += 6;
2198                        hd->args = simple_strtoul(bp, NULL, 0) & DB_MASK;
2199                } else if (!strncmp(bp, "disconnect:", 11)) {
2200                        bp += 11;
2201                        x = simple_strtoul(bp, NULL, 0);
2202                        if (x < DIS_NEVER || x > DIS_ALWAYS)
2203                                x = DIS_ADAPTIVE;
2204                        hd->disconnect = x;
2205                } else if (!strncmp(bp, "period:", 7)) {
2206                        bp += 7;
2207                        x = simple_strtoul(bp, NULL, 0);
2208                        hd->default_sx_per = sx_table[round_period((unsigned int) x)].period_ns;
2209                } else if (!strncmp(bp, "resync:", 7)) {
2210                        bp += 7;
2211                        x = simple_strtoul(bp, NULL, 0);
2212                        for (i = 0; i < 7; i++)
2213                                if (x & (1 << i))
2214                                        hd->sync_stat[i] = SS_UNSET;
2215                } else if (!strncmp(bp, "proc:", 5)) {
2216                        bp += 5;
2217                        hd->proc = simple_strtoul(bp, NULL, 0);
2218                } else if (!strncmp(bp, "level2:", 7)) {
2219                        bp += 7;
2220                        hd->level2 = simple_strtoul(bp, NULL, 0);
2221                }
2222                return len;
2223        }
2224
2225        spin_lock_irqsave(instance->host_lock, flags);
2226        bp = buf;
2227        *bp = '\0';
2228        if (hd->proc & PR_VERSION) {
2229                sprintf(tbuf, "\nVersion %s - %s.", IN2000_VERSION, IN2000_DATE);
2230                strcat(bp, tbuf);
2231        }
2232        if (hd->proc & PR_INFO) {
2233                sprintf(tbuf, "\ndip_switch=%02x: irq=%d io=%02x floppy=%s sync/DOS5=%s", (hd->dip_switch & 0x7f), instance->irq, hd->io_base, (hd->dip_switch & 0x40) ? "Yes" : "No", (hd->dip_switch & 0x20) ? "Yes" : "No");
2234                strcat(bp, tbuf);
2235                strcat(bp, "\nsync_xfer[] =       ");
2236                for (x = 0; x < 7; x++) {
2237                        sprintf(tbuf, "\t%02x", hd->sync_xfer[x]);
2238                        strcat(bp, tbuf);
2239                }
2240                strcat(bp, "\nsync_stat[] =       ");
2241                for (x = 0; x < 7; x++) {
2242                        sprintf(tbuf, "\t%02x", hd->sync_stat[x]);
2243                        strcat(bp, tbuf);
2244                }
2245        }
2246#ifdef PROC_STATISTICS
2247        if (hd->proc & PR_STATISTICS) {
2248                strcat(bp, "\ncommands issued:    ");
2249                for (x = 0; x < 7; x++) {
2250                        sprintf(tbuf, "\t%ld", hd->cmd_cnt[x]);
2251                        strcat(bp, tbuf);
2252                }
2253                strcat(bp, "\ndisconnects allowed:");
2254                for (x = 0; x < 7; x++) {
2255                        sprintf(tbuf, "\t%ld", hd->disc_allowed_cnt[x]);
2256                        strcat(bp, tbuf);
2257                }
2258                strcat(bp, "\ndisconnects done:   ");
2259                for (x = 0; x < 7; x++) {
2260                        sprintf(tbuf, "\t%ld", hd->disc_done_cnt[x]);
2261                        strcat(bp, tbuf);
2262                }
2263                sprintf(tbuf, "\ninterrupts:      \t%ld", hd->int_cnt);
2264                strcat(bp, tbuf);
2265        }
2266#endif
2267        if (hd->proc & PR_CONNECTED) {
2268                strcat(bp, "\nconnected:     ");
2269                if (hd->connected) {
2270                        cmd = (Scsi_Cmnd *) hd->connected;
2271                        sprintf(tbuf, " %d:%d(%02x)", cmd->device->id, cmd->device->lun, cmd->cmnd[0]);
2272                        strcat(bp, tbuf);
2273                }
2274        }
2275        if (hd->proc & PR_INPUTQ) {
2276                strcat(bp, "\ninput_Q:       ");
2277                cmd = (Scsi_Cmnd *) hd->input_Q;
2278                while (cmd) {
2279                        sprintf(tbuf, " %d:%d(%02x)", cmd->device->id, cmd->device->lun, cmd->cmnd[0]);
2280                        strcat(bp, tbuf);
2281                        cmd = (Scsi_Cmnd *) cmd->host_scribble;
2282                }
2283        }
2284        if (hd->proc & PR_DISCQ) {
2285                strcat(bp, "\ndisconnected_Q:");
2286                cmd = (Scsi_Cmnd *) hd->disconnected_Q;
2287                while (cmd) {
2288                        sprintf(tbuf, " %d:%d(%02x)", cmd->device->id, cmd->device->lun, cmd->cmnd[0]);
2289                        strcat(bp, tbuf);
2290                        cmd = (Scsi_Cmnd *) cmd->host_scribble;
2291                }
2292        }
2293        if (hd->proc & PR_TEST) {
2294                ;               /* insert your own custom function here */
2295        }
2296        strcat(bp, "\n");
2297        spin_unlock_irqrestore(instance->host_lock, flags);
2298        *start = buf;
2299        if (stop) {
2300                stop = 0;
2301                return 0;       /* return 0 to signal end-of-file */
2302        }
2303        if (off > 0x40000)      /* ALWAYS stop after 256k bytes have been read */
2304                stop = 1;
2305        if (hd->proc & PR_STOP) /* stop every other time */
2306                stop = 1;
2307        return strlen(bp);
2308
2309#else                           /* PROC_INTERFACE */
2310
2311        return 0;
2312
2313#endif                          /* PROC_INTERFACE */
2314
2315}
2316
2317MODULE_LICENSE("GPL");
2318
2319
2320static struct scsi_host_template driver_template = {
2321        .proc_name                      = "in2000",
2322        .proc_info                      = in2000_proc_info,
2323        .name                           = "Always IN2000",
2324        .detect                         = in2000_detect, 
2325        .release                        = in2000_release,
2326        .queuecommand                   = in2000_queuecommand,
2327        .eh_abort_handler               = in2000_abort,
2328        .eh_bus_reset_handler           = in2000_bus_reset,
2329        .bios_param                     = in2000_biosparam, 
2330        .can_queue                      = IN2000_CAN_Q,
2331        .this_id                        = IN2000_HOST_ID,
2332        .sg_tablesize                   = IN2000_SG,
2333        .cmd_per_lun                    = IN2000_CPL,
2334        .use_clustering                 = DISABLE_CLUSTERING,
2335};
2336#include "scsi_module.c"
2337
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.