开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
in2000.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：77k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

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