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