1/*
   2 * Copyright (c) 1996 John Shifflett, GeoLog Consulting
   3 *    john@geolog.com
   4 *    jshiffle@netcom.com
   5 *
   6 * This program is free software; you can redistribute it and/or modify
   7 * it under the terms of the GNU General Public License as published by
   8 * the Free Software Foundation; either version 2, or (at your option)
   9 * any later version.
  10 *
  11 * This program is distributed in the hope that it will be useful,
  12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 * GNU General Public License for more details.
  15 */
  16
  17/*
  18 * Drew Eckhardt's excellent 'Generic NCR5380' sources from Linux-PC
  19 * provided much of the inspiration and some of the code for this
  20 * driver. Everything I know about Amiga DMA was gleaned from careful
  21 * reading of Hamish Mcdonald's original wd33c93 driver; in fact, I
  22 * borrowed shamelessly from all over that source. Thanks Hamish!
  23 *
  24 * _This_ driver is (I feel) an improvement over the old one in
  25 * several respects:
  26 *
  27 *    -  Target Disconnection/Reconnection  is now supported. Any
  28 *          system with more than one device active on the SCSI bus
  29 *          will benefit from this. The driver defaults to what I
  30 *          call 'adaptive disconnect' - meaning that each command
  31 *          is evaluated individually as to whether or not it should
  32 *          be run with the option to disconnect/reselect (if the
  33 *          device chooses), or as a "SCSI-bus-hog".
  34 *
  35 *    -  Synchronous data transfers are now supported. Because of
  36 *          a few devices that choke after telling the driver that
  37 *          they can do sync transfers, we don't automatically use
  38 *          this faster protocol - it can be enabled via the command-
  39 *          line on a device-by-device basis.
  40 *
  41 *    -  Runtime operating parameters can now be specified through
  42 *       the 'amiboot' or the 'insmod' command line. For amiboot do:
  43 *          "amiboot [usual stuff] wd33c93=blah,blah,blah"
  44 *       The defaults should be good for most people. See the comment
  45 *       for 'setup_strings' below for more details.
  46 *
  47 *    -  The old driver relied exclusively on what the Western Digital
  48 *          docs call "Combination Level 2 Commands", which are a great
  49 *          idea in that the CPU is relieved of a lot of interrupt
  50 *          overhead. However, by accepting a certain (user-settable)
  51 *          amount of additional interrupts, this driver achieves
  52 *          better control over the SCSI bus, and data transfers are
  53 *          almost as fast while being much easier to define, track,
  54 *          and debug.
  55 *
  56 *
  57 * TODO:
  58 *       more speed. linked commands.
  59 *
  60 *
  61 * People with bug reports, wish-lists, complaints, comments,
  62 * or improvements are asked to pah-leeez email me (John Shifflett)
  63 * at john@geolog.com or jshiffle@netcom.com! I'm anxious to get
  64 * this thing into as good a shape as possible, and I'm positive
  65 * there are lots of lurking bugs and "Stupid Places".
  66 *
  67 * Updates:
  68 *
  69 * Added support for pre -A chips, which don't have advanced features
  70 * and will generate CSR_RESEL rather than CSR_RESEL_AM.
  71 *	Richard Hirst <richard@sleepie.demon.co.uk>  August 2000
  72 *
  73 * Added support for Burst Mode DMA and Fast SCSI. Enabled the use of
  74 * default_sx_per for asynchronous data transfers. Added adjustment
  75 * of transfer periods in sx_table to the actual input-clock.
  76 *  peter fuerst <post@pfrst.de>  February 2007
  77 */
  78
  79#include <linux/module.h>
  80
  81#include <linux/string.h>
  82#include <linux/delay.h>
  83#include <linux/init.h>
  84#include <linux/interrupt.h>
  85#include <linux/blkdev.h>
  86
  87#include <scsi/scsi.h>
  88#include <scsi/scsi_cmnd.h>
  89#include <scsi/scsi_device.h>
  90#include <scsi/scsi_host.h>
  91
  92#include <asm/irq.h>
  93
  94#include "wd33c93.h"
  95
  96#define optimum_sx_per(hostdata) (hostdata)->sx_table[1].period_ns
  97
  98
  99#define WD33C93_VERSION    "1.26++"
 100#define WD33C93_DATE       "10/Feb/2007"
 101
 102MODULE_AUTHOR("John Shifflett");
 103MODULE_DESCRIPTION("Generic WD33C93 SCSI driver");
 104MODULE_LICENSE("GPL");
 105
 106/*
 107 * 'setup_strings' is a single string used to pass operating parameters and
 108 * settings from the kernel/module command-line to the driver. 'setup_args[]'
 109 * is an array of strings that define the compile-time default values for
 110 * these settings. If Linux boots with an amiboot or insmod command-line,
 111 * those settings are combined with 'setup_args[]'. Note that amiboot
 112 * command-lines are prefixed with "wd33c93=" while insmod uses a
 113 * "setup_strings=" prefix. The driver recognizes the following keywords
 114 * (lower case required) and arguments:
 115 *
 116 * -  nosync:bitmask -bitmask is a byte where the 1st 7 bits correspond with
 117 *                    the 7 possible SCSI devices. Set a bit to negotiate for
 118 *                    asynchronous transfers on that device. To maintain
 119 *                    backwards compatibility, a command-line such as
 120 *                    "wd33c93=255" will be automatically translated to
 121 *                    "wd33c93=nosync:0xff".
 122 * -  nodma:x        -x = 1 to disable DMA, x = 0 to enable it. Argument is
 123 *                    optional - if not present, same as "nodma:1".
 124 * -  period:ns      -ns is the minimum # of nanoseconds in a SCSI data transfer
 125 *                    period. Default is 500; acceptable values are 250 - 1000.
 126 * -  disconnect:x   -x = 0 to never allow disconnects, 2 to always allow them.
 127 *                    x = 1 does 'adaptive' disconnects, which is the default
 128 *                    and generally the best choice.
 129 * -  debug:x        -If 'DEBUGGING_ON' is defined, x is a bit mask that causes
 130 *                    various types of debug output to printed - see the DB_xxx
 131 *                    defines in wd33c93.h
 132 * -  clock:x        -x = clock input in MHz for WD33c93 chip. Normal values
 133 *                    would be from 8 through 20. Default is 8.
 134 * -  burst:x        -x = 1 to use Burst Mode (or Demand-Mode) DMA, x = 0 to use
 135 *                    Single Byte DMA, which is the default. Argument is
 136 *                    optional - if not present, same as "burst:1".
 137 * -  fast:x         -x = 1 to enable Fast SCSI, which is only effective with
 138 *                    input-clock divisor 4 (WD33C93_FS_16_20), x = 0 to disable
 139 *                    it, which is the default.  Argument is optional - if not
 140 *                    present, same as "fast:1".
 141 * -  next           -No argument. Used to separate blocks of keywords when
 142 *                    there's more than one host adapter in the system.
 143 *
 144 * Syntax Notes:
 145 * -  Numeric arguments can be decimal or the '0x' form of hex notation. There
 146 *    _must_ be a colon between a keyword and its numeric argument, with no
 147 *    spaces.
 148 * -  Keywords are separated by commas, no spaces, in the standard kernel
 149 *    command-line manner.
 150 * -  A keyword in the 'nth' comma-separated command-line member will overwrite
 151 *    the 'nth' element of setup_args[]. A blank command-line member (in
 152 *    other words, a comma with no preceding keyword) will _not_ overwrite
 153 *    the corresponding setup_args[] element.
 154 * -  If a keyword is used more than once, the first one applies to the first
 155 *    SCSI host found, the second to the second card, etc, unless the 'next'
 156 *    keyword is used to change the order.
 157 *
 158 * Some amiboot examples (for insmod, use 'setup_strings' instead of 'wd33c93'):
 159 * -  wd33c93=nosync:255
 160 * -  wd33c93=nodma
 161 * -  wd33c93=nodma:1
 162 * -  wd33c93=disconnect:2,nosync:0x08,period:250
 163 * -  wd33c93=debug:0x1c
 164 */
 165
 166/* Normally, no defaults are specified */
 167static char *setup_args[] = { "", "", "", "", "", "", "", "", "", "" };
 168
 169static char *setup_strings;
 170module_param(setup_strings, charp, 0);
 171
 172static void wd33c93_execute(struct Scsi_Host *instance);
 173
 174#ifdef CONFIG_WD33C93_PIO
 175static inline uchar
 176read_wd33c93(const wd33c93_regs regs, uchar reg_num)
 177{
 178	uchar data;
 179
 180	outb(reg_num, regs.SASR);
 181	data = inb(regs.SCMD);
 182	return data;
 183}
 184
 185static inline unsigned long
 186read_wd33c93_count(const wd33c93_regs regs)
 187{
 188	unsigned long value;
 189
 190	outb(WD_TRANSFER_COUNT_MSB, regs.SASR);
 191	value = inb(regs.SCMD) << 16;
 192	value |= inb(regs.SCMD) << 8;
 193	value |= inb(regs.SCMD);
 194	return value;
 195}
 196
 197static inline uchar
 198read_aux_stat(const wd33c93_regs regs)
 199{
 200	return inb(regs.SASR);
 201}
 202
 203static inline void
 204write_wd33c93(const wd33c93_regs regs, uchar reg_num, uchar value)
 205{
 206      outb(reg_num, regs.SASR);
 207      outb(value, regs.SCMD);
 208}
 209
 210static inline void
 211write_wd33c93_count(const wd33c93_regs regs, unsigned long value)
 212{
 213	outb(WD_TRANSFER_COUNT_MSB, regs.SASR);
 214	outb((value >> 16) & 0xff, regs.SCMD);
 215	outb((value >> 8) & 0xff, regs.SCMD);
 216	outb( value & 0xff, regs.SCMD);
 217}
 218
 219#define write_wd33c93_cmd(regs, cmd) \
 220	write_wd33c93((regs), WD_COMMAND, (cmd))
 221
 222static inline void
 223write_wd33c93_cdb(const wd33c93_regs regs, uint len, uchar cmnd[])
 224{
 225	int i;
 226
 227	outb(WD_CDB_1, regs.SASR);
 228	for (i=0; i<len; i++)
 229		outb(cmnd[i], regs.SCMD);
 230}
 231
 232#else /* CONFIG_WD33C93_PIO */
 233static inline uchar
 234read_wd33c93(const wd33c93_regs regs, uchar reg_num)
 235{
 236	*regs.SASR = reg_num;
 237	mb();
 238	return (*regs.SCMD);
 239}
 240
 241static unsigned long
 242read_wd33c93_count(const wd33c93_regs regs)
 243{
 244	unsigned long value;
 245
 246	*regs.SASR = WD_TRANSFER_COUNT_MSB;
 247	mb();
 248	value = *regs.SCMD << 16;
 249	value |= *regs.SCMD << 8;
 250	value |= *regs.SCMD;
 251	mb();
 252	return value;
 253}
 254
 255static inline uchar
 256read_aux_stat(const wd33c93_regs regs)
 257{
 258	return *regs.SASR;
 259}
 260
 261static inline void
 262write_wd33c93(const wd33c93_regs regs, uchar reg_num, uchar value)
 263{
 264	*regs.SASR = reg_num;
 265	mb();
 266	*regs.SCMD = value;
 267	mb();
 268}
 269
 270static void
 271write_wd33c93_count(const wd33c93_regs regs, unsigned long value)
 272{
 273	*regs.SASR = WD_TRANSFER_COUNT_MSB;
 274	mb();
 275	*regs.SCMD = value >> 16;
 276	*regs.SCMD = value >> 8;
 277	*regs.SCMD = value;
 278	mb();
 279}
 280
 281static inline void
 282write_wd33c93_cmd(const wd33c93_regs regs, uchar cmd)
 283{
 284	*regs.SASR = WD_COMMAND;
 285	mb();
 286	*regs.SCMD = cmd;
 287	mb();
 288}
 289
 290static inline void
 291write_wd33c93_cdb(const wd33c93_regs regs, uint len, uchar cmnd[])
 292{
 293	int i;
 294
 295	*regs.SASR = WD_CDB_1;
 296	for (i = 0; i < len; i++)
 297		*regs.SCMD = cmnd[i];
 298}
 299#endif /* CONFIG_WD33C93_PIO */
 300
 301static inline uchar
 302read_1_byte(const wd33c93_regs regs)
 303{
 304	uchar asr;
 305	uchar x = 0;
 306
 307	write_wd33c93(regs, WD_CONTROL, CTRL_IDI | CTRL_EDI | CTRL_POLLED);
 308	write_wd33c93_cmd(regs, WD_CMD_TRANS_INFO | 0x80);
 309	do {
 310		asr = read_aux_stat(regs);
 311		if (asr & ASR_DBR)
 312			x = read_wd33c93(regs, WD_DATA);
 313	} while (!(asr & ASR_INT));
 314	return x;
 315}
 316
 317static int
 318round_period(unsigned int period, const struct sx_period *sx_table)
 319{
 320	int x;
 321
 322	for (x = 1; sx_table[x].period_ns; x++) {
 323		if ((period <= sx_table[x - 0].period_ns) &&
 324		    (period > sx_table[x - 1].period_ns)) {
 325			return x;
 326		}
 327	}
 328	return 7;
 329}
 330
 331/*
 332 * Calculate Synchronous Transfer Register value from SDTR code.
 333 */
 334static uchar
 335calc_sync_xfer(unsigned int period, unsigned int offset, unsigned int fast,
 336               const struct sx_period *sx_table)
 337{
 338	/* When doing Fast SCSI synchronous data transfers, the corresponding
 339	 * value in 'sx_table' is two times the actually used transfer period.
 340	 */
 341	uchar result;
 342
 343	if (offset && fast) {
 344		fast = STR_FSS;
 345		period *= 2;
 346	} else {
 347		fast = 0;
 348	}
 349	period *= 4;		/* convert SDTR code to ns */
 350	result = sx_table[round_period(period,sx_table)].reg_value;
 351	result |= (offset < OPTIMUM_SX_OFF) ? offset : OPTIMUM_SX_OFF;
 352	result |= fast;
 353	return result;
 354}
 355
 356/*
 357 * Calculate SDTR code bytes [3],[4] from period and offset.
 358 */
 359static inline void
 360calc_sync_msg(unsigned int period, unsigned int offset, unsigned int fast,
 361                uchar  msg[2])
 362{
 363	/* 'period' is a "normal"-mode value, like the ones in 'sx_table'. The
 364	 * actually used transfer period for Fast SCSI synchronous data
 365	 * transfers is half that value.
 366	 */
 367	period /= 4;
 368	if (offset && fast)
 369		period /= 2;
 370	msg[0] = period;
 371	msg[1] = offset;
 372}
 373
 374static int
 375wd33c93_queuecommand_lck(struct scsi_cmnd *cmd,
 376		void (*done)(struct scsi_cmnd *))
 377{
 
 378	struct WD33C93_hostdata *hostdata;
 379	struct scsi_cmnd *tmp;
 380
 381	hostdata = (struct WD33C93_hostdata *) cmd->device->host->hostdata;
 382
 383	DB(DB_QUEUE_COMMAND,
 384	   printk("Q-%d-%02x( ", cmd->device->id, cmd->cmnd[0]))
 385
 386/* Set up a few fields in the scsi_cmnd structure for our own use:
 387 *  - host_scribble is the pointer to the next cmd in the input queue
 388 *  - scsi_done points to the routine we call when a cmd is finished
 389 *  - result is what you'd expect
 390 */
 391	cmd->host_scribble = NULL;
 392	cmd->scsi_done = done;
 393	cmd->result = 0;
 394
 395/* We use the Scsi_Pointer structure that's included with each command
 396 * as a scratchpad (as it's intended to be used!). The handy thing about
 397 * the SCp.xxx fields is that they're always associated with a given
 398 * cmd, and are preserved across disconnect-reselect. This means we
 399 * can pretty much ignore SAVE_POINTERS and RESTORE_POINTERS messages
 400 * if we keep all the critical pointers and counters in SCp:
 401 *  - SCp.ptr is the pointer into the RAM buffer
 402 *  - SCp.this_residual is the size of that buffer
 403 *  - SCp.buffer points to the current scatter-gather buffer
 404 *  - SCp.buffers_residual tells us how many S.G. buffers there are
 405 *  - SCp.have_data_in is not used
 406 *  - SCp.sent_command is not used
 407 *  - SCp.phase records this command's SRCID_ER bit setting
 408 */
 409
 410	if (scsi_bufflen(cmd)) {
 411		cmd->SCp.buffer = scsi_sglist(cmd);
 412		cmd->SCp.buffers_residual = scsi_sg_count(cmd) - 1;
 413		cmd->SCp.ptr = sg_virt(cmd->SCp.buffer);
 414		cmd->SCp.this_residual = cmd->SCp.buffer->length;
 415	} else {
 416		cmd->SCp.buffer = NULL;
 417		cmd->SCp.buffers_residual = 0;
 418		cmd->SCp.ptr = NULL;
 419		cmd->SCp.this_residual = 0;
 420	}
 421
 422/* WD docs state that at the conclusion of a "LEVEL2" command, the
 423 * status byte can be retrieved from the LUN register. Apparently,
 424 * this is the case only for *uninterrupted* LEVEL2 commands! If
 425 * there are any unexpected phases entered, even if they are 100%
 426 * legal (different devices may choose to do things differently),
 427 * the LEVEL2 command sequence is exited. This often occurs prior
 428 * to receiving the status byte, in which case the driver does a
 429 * status phase interrupt and gets the status byte on its own.
 430 * While such a command can then be "resumed" (ie restarted to
 431 * finish up as a LEVEL2 command), the LUN register will NOT be
 432 * a valid status byte at the command's conclusion, and we must
 433 * use the byte obtained during the earlier interrupt. Here, we
 434 * preset SCp.Status to an illegal value (0xff) so that when
 435 * this command finally completes, we can tell where the actual
 436 * status byte is stored.
 437 */
 438
 439	cmd->SCp.Status = ILLEGAL_STATUS_BYTE;
 440
 441	/*
 442	 * Add the cmd to the end of 'input_Q'. Note that REQUEST SENSE
 443	 * commands are added to the head of the queue so that the desired
 444	 * sense data is not lost before REQUEST_SENSE executes.
 445	 */
 446
 447	spin_lock_irq(&hostdata->lock);
 448
 449	if (!(hostdata->input_Q) || (cmd->cmnd[0] == REQUEST_SENSE)) {
 450		cmd->host_scribble = (uchar *) hostdata->input_Q;
 451		hostdata->input_Q = cmd;
 452	} else {		/* find the end of the queue */
 453		for (tmp = (struct scsi_cmnd *) hostdata->input_Q;
 454		     tmp->host_scribble;
 455		     tmp = (struct scsi_cmnd *) tmp->host_scribble) ;
 456		tmp->host_scribble = (uchar *) cmd;
 457	}
 458
 459/* We know that there's at least one command in 'input_Q' now.
 460 * Go see if any of them are runnable!
 461 */
 462
 463	wd33c93_execute(cmd->device->host);
 464
 465	DB(DB_QUEUE_COMMAND, printk(")Q "))
 466
 467	spin_unlock_irq(&hostdata->lock);
 468	return 0;
 469}
 470
 471DEF_SCSI_QCMD(wd33c93_queuecommand)
 472
 473/*
 474 * This routine attempts to start a scsi command. If the host_card is
 475 * already connected, we give up immediately. Otherwise, look through
 476 * the input_Q, using the first command we find that's intended
 477 * for a currently non-busy target/lun.
 478 *
 479 * wd33c93_execute() is always called with interrupts disabled or from
 480 * the wd33c93_intr itself, which means that a wd33c93 interrupt
 481 * cannot occur while we are in here.
 482 */
 483static void
 484wd33c93_execute(struct Scsi_Host *instance)
 485{
 
 486	struct WD33C93_hostdata *hostdata =
 487	    (struct WD33C93_hostdata *) instance->hostdata;
 488	const wd33c93_regs regs = hostdata->regs;
 489	struct scsi_cmnd *cmd, *prev;
 490
 491	DB(DB_EXECUTE, printk("EX("))
 492	if (hostdata->selecting || hostdata->connected) {
 493		DB(DB_EXECUTE, printk(")EX-0 "))
 494		return;
 495	}
 496
 497	/*
 498	 * Search through the input_Q for a command destined
 499	 * for an idle target/lun.
 500	 */
 501
 502	cmd = (struct scsi_cmnd *) hostdata->input_Q;
 503	prev = NULL;
 504	while (cmd) {
 505		if (!(hostdata->busy[cmd->device->id] & (1 << cmd->device->lun)))
 
 506			break;
 507		prev = cmd;
 508		cmd = (struct scsi_cmnd *) cmd->host_scribble;
 509	}
 510
 511	/* quit if queue empty or all possible targets are busy */
 512
 513	if (!cmd) {
 514		DB(DB_EXECUTE, printk(")EX-1 "))
 515		return;
 516	}
 517
 518	/*  remove command from queue */
 519
 520	if (prev)
 521		prev->host_scribble = cmd->host_scribble;
 522	else
 523		hostdata->input_Q = (struct scsi_cmnd *) cmd->host_scribble;
 524
 525#ifdef PROC_STATISTICS
 526	hostdata->cmd_cnt[cmd->device->id]++;
 527#endif
 528
 529	/*
 530	 * Start the selection process
 531	 */
 532
 533	if (cmd->sc_data_direction == DMA_TO_DEVICE)
 534		write_wd33c93(regs, WD_DESTINATION_ID, cmd->device->id);
 535	else
 536		write_wd33c93(regs, WD_DESTINATION_ID, cmd->device->id | DSTID_DPD);
 537
 538/* Now we need to figure out whether or not this command is a good
 539 * candidate for disconnect/reselect. We guess to the best of our
 540 * ability, based on a set of hierarchical rules. When several
 541 * devices are operating simultaneously, disconnects are usually
 542 * an advantage. In a single device system, or if only 1 device
 543 * is being accessed, transfers usually go faster if disconnects
 544 * are not allowed:
 545 *
 546 * + Commands should NEVER disconnect if hostdata->disconnect =
 547 *   DIS_NEVER (this holds for tape drives also), and ALWAYS
 548 *   disconnect if hostdata->disconnect = DIS_ALWAYS.
 549 * + Tape drive commands should always be allowed to disconnect.
 550 * + Disconnect should be allowed if disconnected_Q isn't empty.
 551 * + Commands should NOT disconnect if input_Q is empty.
 552 * + Disconnect should be allowed if there are commands in input_Q
 553 *   for a different target/lun. In this case, the other commands
 554 *   should be made disconnect-able, if not already.
 555 *
 556 * I know, I know - this code would flunk me out of any
 557 * "C Programming 101" class ever offered. But it's easy
 558 * to change around and experiment with for now.
 559 */
 560
 561	cmd->SCp.phase = 0;	/* assume no disconnect */
 
 562	if (hostdata->disconnect == DIS_NEVER)
 563		goto no;
 564	if (hostdata->disconnect == DIS_ALWAYS)
 565		goto yes;
 566	if (cmd->device->type == 1)	/* tape drive? */
 567		goto yes;
 568	if (hostdata->disconnected_Q)	/* other commands disconnected? */
 569		goto yes;
 570	if (!(hostdata->input_Q))	/* input_Q empty? */
 571		goto no;
 572	for (prev = (struct scsi_cmnd *) hostdata->input_Q; prev;
 573	     prev = (struct scsi_cmnd *) prev->host_scribble) {
 574		if ((prev->device->id != cmd->device->id) ||
 575		    (prev->device->lun != cmd->device->lun)) {
 576			for (prev = (struct scsi_cmnd *) hostdata->input_Q; prev;
 577			     prev = (struct scsi_cmnd *) prev->host_scribble)
 578				prev->SCp.phase = 1;
 579			goto yes;
 580		}
 581	}
 582
 583	goto no;
 584
 585 yes:
 586	cmd->SCp.phase = 1;
 587
 588#ifdef PROC_STATISTICS
 589	hostdata->disc_allowed_cnt[cmd->device->id]++;
 590#endif
 591
 592 no:
 593
 594	write_wd33c93(regs, WD_SOURCE_ID, ((cmd->SCp.phase) ? SRCID_ER : 0));
 595
 596	write_wd33c93(regs, WD_TARGET_LUN, cmd->device->lun);
 597	write_wd33c93(regs, WD_SYNCHRONOUS_TRANSFER,
 598		      hostdata->sync_xfer[cmd->device->id]);
 599	hostdata->busy[cmd->device->id] |= (1 << cmd->device->lun);
 600
 601	if ((hostdata->level2 == L2_NONE) ||
 602	    (hostdata->sync_stat[cmd->device->id] == SS_UNSET)) {
 603
 604		/*
 605		 * Do a 'Select-With-ATN' command. This will end with
 606		 * one of the following interrupts:
 607		 *    CSR_RESEL_AM:  failure - can try again later.
 608		 *    CSR_TIMEOUT:   failure - give up.
 609		 *    CSR_SELECT:    success - proceed.
 610		 */
 611
 612		hostdata->selecting = cmd;
 613
 614/* Every target has its own synchronous transfer setting, kept in the
 615 * sync_xfer array, and a corresponding status byte in sync_stat[].
 616 * Each target's sync_stat[] entry is initialized to SX_UNSET, and its
 617 * sync_xfer[] entry is initialized to the default/safe value. SS_UNSET
 618 * means that the parameters are undetermined as yet, and that we
 619 * need to send an SDTR message to this device after selection is
 620 * complete: We set SS_FIRST to tell the interrupt routine to do so.
 621 * If we've been asked not to try synchronous transfers on this
 622 * target (and _all_ luns within it), we'll still send the SDTR message
 623 * later, but at that time we'll negotiate for async by specifying a
 624 * sync fifo depth of 0.
 625 */
 626		if (hostdata->sync_stat[cmd->device->id] == SS_UNSET)
 627			hostdata->sync_stat[cmd->device->id] = SS_FIRST;
 628		hostdata->state = S_SELECTING;
 629		write_wd33c93_count(regs, 0);	/* guarantee a DATA_PHASE interrupt */
 630		write_wd33c93_cmd(regs, WD_CMD_SEL_ATN);
 631	} else {
 632
 633		/*
 634		 * Do a 'Select-With-ATN-Xfer' command. This will end with
 635		 * one of the following interrupts:
 636		 *    CSR_RESEL_AM:  failure - can try again later.
 637		 *    CSR_TIMEOUT:   failure - give up.
 638		 *    anything else: success - proceed.
 639		 */
 640
 641		hostdata->connected = cmd;
 642		write_wd33c93(regs, WD_COMMAND_PHASE, 0);
 643
 644		/* copy command_descriptor_block into WD chip
 645		 * (take advantage of auto-incrementing)
 646		 */
 647
 648		write_wd33c93_cdb(regs, cmd->cmd_len, cmd->cmnd);
 649
 650		/* The wd33c93 only knows about Group 0, 1, and 5 commands when
 651		 * it's doing a 'select-and-transfer'. To be safe, we write the
 652		 * size of the CDB into the OWN_ID register for every case. This
 653		 * way there won't be problems with vendor-unique, audio, etc.
 654		 */
 655
 656		write_wd33c93(regs, WD_OWN_ID, cmd->cmd_len);
 657
 658		/* When doing a non-disconnect command with DMA, we can save
 659		 * ourselves a DATA phase interrupt later by setting everything
 660		 * up ahead of time.
 661		 */
 662
 663		if ((cmd->SCp.phase == 0) && (hostdata->no_dma == 0)) {
 664			if (hostdata->dma_setup(cmd,
 665			    (cmd->sc_data_direction == DMA_TO_DEVICE) ?
 666			     DATA_OUT_DIR : DATA_IN_DIR))
 667				write_wd33c93_count(regs, 0);	/* guarantee a DATA_PHASE interrupt */
 668			else {
 669				write_wd33c93_count(regs,
 670						    cmd->SCp.this_residual);
 671				write_wd33c93(regs, WD_CONTROL,
 672					      CTRL_IDI | CTRL_EDI | hostdata->dma_mode);
 673				hostdata->dma = D_DMA_RUNNING;
 674			}
 675		} else
 676			write_wd33c93_count(regs, 0);	/* guarantee a DATA_PHASE interrupt */
 677
 678		hostdata->state = S_RUNNING_LEVEL2;
 679		write_wd33c93_cmd(regs, WD_CMD_SEL_ATN_XFER);
 680	}
 681
 682	/*
 683	 * Since the SCSI bus can handle only 1 connection at a time,
 684	 * we get out of here now. If the selection fails, or when
 685	 * the command disconnects, we'll come back to this routine
 686	 * to search the input_Q again...
 687	 */
 688
 689	DB(DB_EXECUTE,
 690	   printk("%s)EX-2 ", (cmd->SCp.phase) ? "d:" : ""))
 691}
 692
 693static void
 694transfer_pio(const wd33c93_regs regs, uchar * buf, int cnt,
 695	     int data_in_dir, struct WD33C93_hostdata *hostdata)
 696{
 697	uchar asr;
 698
 699	DB(DB_TRANSFER,
 700	   printk("(%p,%d,%s:", buf, cnt, data_in_dir ? "in" : "out"))
 701
 702	write_wd33c93(regs, WD_CONTROL, CTRL_IDI | CTRL_EDI | CTRL_POLLED);
 703	write_wd33c93_count(regs, cnt);
 704	write_wd33c93_cmd(regs, WD_CMD_TRANS_INFO);
 705	if (data_in_dir) {
 706		do {
 707			asr = read_aux_stat(regs);
 708			if (asr & ASR_DBR)
 709				*buf++ = read_wd33c93(regs, WD_DATA);
 710		} while (!(asr & ASR_INT));
 711	} else {
 712		do {
 713			asr = read_aux_stat(regs);
 714			if (asr & ASR_DBR)
 715				write_wd33c93(regs, WD_DATA, *buf++);
 716		} while (!(asr & ASR_INT));
 717	}
 718
 719	/* Note: we are returning with the interrupt UN-cleared.
 720	 * Since (presumably) an entire I/O operation has
 721	 * completed, the bus phase is probably different, and
 722	 * the interrupt routine will discover this when it
 723	 * responds to the uncleared int.
 724	 */
 725
 726}
 727
 728static void
 729transfer_bytes(const wd33c93_regs regs, struct scsi_cmnd *cmd,
 730		int data_in_dir)
 731{
 
 732	struct WD33C93_hostdata *hostdata;
 733	unsigned long length;
 734
 735	hostdata = (struct WD33C93_hostdata *) cmd->device->host->hostdata;
 736
 737/* Normally, you'd expect 'this_residual' to be non-zero here.
 738 * In a series of scatter-gather transfers, however, this
 739 * routine will usually be called with 'this_residual' equal
 740 * to 0 and 'buffers_residual' non-zero. This means that a
 741 * previous transfer completed, clearing 'this_residual', and
 742 * now we need to setup the next scatter-gather buffer as the
 743 * source or destination for THIS transfer.
 744 */
 745	if (!cmd->SCp.this_residual && cmd->SCp.buffers_residual) {
 746		++cmd->SCp.buffer;
 747		--cmd->SCp.buffers_residual;
 748		cmd->SCp.this_residual = cmd->SCp.buffer->length;
 749		cmd->SCp.ptr = sg_virt(cmd->SCp.buffer);
 750	}
 751	if (!cmd->SCp.this_residual) /* avoid bogus setups */
 752		return;
 753
 754	write_wd33c93(regs, WD_SYNCHRONOUS_TRANSFER,
 755		      hostdata->sync_xfer[cmd->device->id]);
 756
 757/* 'hostdata->no_dma' is TRUE if we don't even want to try DMA.
 758 * Update 'this_residual' and 'ptr' after 'transfer_pio()' returns.
 759 */
 760
 761	if (hostdata->no_dma || hostdata->dma_setup(cmd, data_in_dir)) {
 762#ifdef PROC_STATISTICS
 763		hostdata->pio_cnt++;
 764#endif
 765		transfer_pio(regs, (uchar *) cmd->SCp.ptr,
 766			     cmd->SCp.this_residual, data_in_dir, hostdata);
 767		length = cmd->SCp.this_residual;
 768		cmd->SCp.this_residual = read_wd33c93_count(regs);
 769		cmd->SCp.ptr += (length - cmd->SCp.this_residual);
 
 770	}
 771
 772/* We are able to do DMA (in fact, the Amiga hardware is
 773 * already going!), so start up the wd33c93 in DMA mode.
 774 * We set 'hostdata->dma' = D_DMA_RUNNING so that when the
 775 * transfer completes and causes an interrupt, we're
 776 * reminded to tell the Amiga to shut down its end. We'll
 777 * postpone the updating of 'this_residual' and 'ptr'
 778 * until then.
 779 */
 780
 781	else {
 782#ifdef PROC_STATISTICS
 783		hostdata->dma_cnt++;
 784#endif
 785		write_wd33c93(regs, WD_CONTROL, CTRL_IDI | CTRL_EDI | hostdata->dma_mode);
 786		write_wd33c93_count(regs, cmd->SCp.this_residual);
 787
 788		if ((hostdata->level2 >= L2_DATA) ||
 789		    (hostdata->level2 == L2_BASIC && cmd->SCp.phase == 0)) {
 790			write_wd33c93(regs, WD_COMMAND_PHASE, 0x45);
 791			write_wd33c93_cmd(regs, WD_CMD_SEL_ATN_XFER);
 792			hostdata->state = S_RUNNING_LEVEL2;
 793		} else
 794			write_wd33c93_cmd(regs, WD_CMD_TRANS_INFO);
 795
 796		hostdata->dma = D_DMA_RUNNING;
 797	}
 798}
 799
 800void
 801wd33c93_intr(struct Scsi_Host *instance)
 802{
 
 803	struct WD33C93_hostdata *hostdata =
 804	    (struct WD33C93_hostdata *) instance->hostdata;
 805	const wd33c93_regs regs = hostdata->regs;
 806	struct scsi_cmnd *patch, *cmd;
 807	uchar asr, sr, phs, id, lun, *ucp, msg;
 808	unsigned long length, flags;
 809
 810	asr = read_aux_stat(regs);
 811	if (!(asr & ASR_INT) || (asr & ASR_BSY))
 812		return;
 813
 814	spin_lock_irqsave(&hostdata->lock, flags);
 815
 816#ifdef PROC_STATISTICS
 817	hostdata->int_cnt++;
 818#endif
 819
 820	cmd = (struct scsi_cmnd *) hostdata->connected;	/* assume we're connected */
 
 821	sr = read_wd33c93(regs, WD_SCSI_STATUS);	/* clear the interrupt */
 822	phs = read_wd33c93(regs, WD_COMMAND_PHASE);
 823
 824	DB(DB_INTR, printk("{%02x:%02x-", asr, sr))
 825
 826/* After starting a DMA transfer, the next interrupt
 827 * is guaranteed to be in response to completion of
 828 * the transfer. Since the Amiga DMA hardware runs in
 829 * in an open-ended fashion, it needs to be told when
 830 * to stop; do that here if D_DMA_RUNNING is true.
 831 * Also, we have to update 'this_residual' and 'ptr'
 832 * based on the contents of the TRANSFER_COUNT register,
 833 * in case the device decided to do an intermediate
 834 * disconnect (a device may do this if it has to do a
 835 * seek, or just to be nice and let other devices have
 836 * some bus time during long transfers). After doing
 837 * whatever is needed, we go on and service the WD3393
 838 * interrupt normally.
 839 */
 840	    if (hostdata->dma == D_DMA_RUNNING) {
 841		DB(DB_TRANSFER,
 842		   printk("[%p/%d:", cmd->SCp.ptr, cmd->SCp.this_residual))
 843		    hostdata->dma_stop(cmd->device->host, cmd, 1);
 844		hostdata->dma = D_DMA_OFF;
 845		length = cmd->SCp.this_residual;
 846		cmd->SCp.this_residual = read_wd33c93_count(regs);
 847		cmd->SCp.ptr += (length - cmd->SCp.this_residual);
 848		DB(DB_TRANSFER,
 849		   printk("%p/%d]", cmd->SCp.ptr, cmd->SCp.this_residual))
 850	}
 851
 852/* Respond to the specific WD3393 interrupt - there are quite a few! */
 853	switch (sr) {
 854	case CSR_TIMEOUT:
 855		DB(DB_INTR, printk("TIMEOUT"))
 856
 857		    if (hostdata->state == S_RUNNING_LEVEL2)
 858			hostdata->connected = NULL;
 859		else {
 860			cmd = (struct scsi_cmnd *) hostdata->selecting;	/* get a valid cmd */
 861			hostdata->selecting = NULL;
 862		}
 863
 864		cmd->result = DID_NO_CONNECT << 16;
 865		hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun);
 866		hostdata->state = S_UNCONNECTED;
 867		cmd->scsi_done(cmd);
 868
 869		/* From esp.c:
 870		 * There is a window of time within the scsi_done() path
 871		 * of execution where interrupts are turned back on full
 872		 * blast and left that way.  During that time we could
 873		 * reconnect to a disconnected command, then we'd bomb
 874		 * out below.  We could also end up executing two commands
 875		 * at _once_.  ...just so you know why the restore_flags()
 876		 * is here...
 877		 */
 878
 879		spin_unlock_irqrestore(&hostdata->lock, flags);
 880
 881/* We are not connected to a target - check to see if there
 882 * are commands waiting to be executed.
 883 */
 884
 885		wd33c93_execute(instance);
 886		break;
 887
 888/* Note: this interrupt should not occur in a LEVEL2 command */
 889
 890	case CSR_SELECT:
 891		DB(DB_INTR, printk("SELECT"))
 892		    hostdata->connected = cmd =
 893		    (struct scsi_cmnd *) hostdata->selecting;
 894		hostdata->selecting = NULL;
 895
 896		/* construct an IDENTIFY message with correct disconnect bit */
 897
 898		hostdata->outgoing_msg[0] = (0x80 | 0x00 | cmd->device->lun);
 899		if (cmd->SCp.phase)
 900			hostdata->outgoing_msg[0] |= 0x40;
 901
 902		if (hostdata->sync_stat[cmd->device->id] == SS_FIRST) {
 903
 904			hostdata->sync_stat[cmd->device->id] = SS_WAITING;
 905
 906/* Tack on a 2nd message to ask about synchronous transfers. If we've
 907 * been asked to do only asynchronous transfers on this device, we
 908 * request a fifo depth of 0, which is equivalent to async - should
 909 * solve the problems some people have had with GVP's Guru ROM.
 910 */
 911
 912			hostdata->outgoing_msg[1] = EXTENDED_MESSAGE;
 913			hostdata->outgoing_msg[2] = 3;
 914			hostdata->outgoing_msg[3] = EXTENDED_SDTR;
 915			if (hostdata->no_sync & (1 << cmd->device->id)) {
 916				calc_sync_msg(hostdata->default_sx_per, 0,
 917						0, hostdata->outgoing_msg + 4);
 918			} else {
 919				calc_sync_msg(optimum_sx_per(hostdata),
 920						OPTIMUM_SX_OFF,
 921						hostdata->fast,
 922						hostdata->outgoing_msg + 4);
 923			}
 924			hostdata->outgoing_len = 6;
 925#ifdef SYNC_DEBUG
 926			ucp = hostdata->outgoing_msg + 1;
 927			printk(" sending SDTR %02x03%02x%02x%02x ",
 928				ucp[0], ucp[2], ucp[3], ucp[4]);
 929#endif
 930		} else
 931			hostdata->outgoing_len = 1;
 932
 933		hostdata->state = S_CONNECTED;
 934		spin_unlock_irqrestore(&hostdata->lock, flags);
 935		break;
 936
 937	case CSR_XFER_DONE | PHS_DATA_IN:
 938	case CSR_UNEXP | PHS_DATA_IN:
 939	case CSR_SRV_REQ | PHS_DATA_IN:
 940		DB(DB_INTR,
 941		   printk("IN-%d.%d", cmd->SCp.this_residual,
 942			  cmd->SCp.buffers_residual))
 943		    transfer_bytes(regs, cmd, DATA_IN_DIR);
 944		if (hostdata->state != S_RUNNING_LEVEL2)
 945			hostdata->state = S_CONNECTED;
 946		spin_unlock_irqrestore(&hostdata->lock, flags);
 947		break;
 948
 949	case CSR_XFER_DONE | PHS_DATA_OUT:
 950	case CSR_UNEXP | PHS_DATA_OUT:
 951	case CSR_SRV_REQ | PHS_DATA_OUT:
 952		DB(DB_INTR,
 953		   printk("OUT-%d.%d", cmd->SCp.this_residual,
 954			  cmd->SCp.buffers_residual))
 955		    transfer_bytes(regs, cmd, DATA_OUT_DIR);
 956		if (hostdata->state != S_RUNNING_LEVEL2)
 957			hostdata->state = S_CONNECTED;
 958		spin_unlock_irqrestore(&hostdata->lock, flags);
 959		break;
 960
 961/* Note: this interrupt should not occur in a LEVEL2 command */
 962
 963	case CSR_XFER_DONE | PHS_COMMAND:
 964	case CSR_UNEXP | PHS_COMMAND:
 965	case CSR_SRV_REQ | PHS_COMMAND:
 966		DB(DB_INTR, printk("CMND-%02x", cmd->cmnd[0]))
 967		    transfer_pio(regs, cmd->cmnd, cmd->cmd_len, DATA_OUT_DIR,
 968				 hostdata);
 969		hostdata->state = S_CONNECTED;
 970		spin_unlock_irqrestore(&hostdata->lock, flags);
 971		break;
 972
 973	case CSR_XFER_DONE | PHS_STATUS:
 974	case CSR_UNEXP | PHS_STATUS:
 975	case CSR_SRV_REQ | PHS_STATUS:
 976		DB(DB_INTR, printk("STATUS="))
 977		cmd->SCp.Status = read_1_byte(regs);
 978		DB(DB_INTR, printk("%02x", cmd->SCp.Status))
 979		    if (hostdata->level2 >= L2_BASIC) {
 980			sr = read_wd33c93(regs, WD_SCSI_STATUS);	/* clear interrupt */
 981			udelay(7);
 982			hostdata->state = S_RUNNING_LEVEL2;
 983			write_wd33c93(regs, WD_COMMAND_PHASE, 0x50);
 984			write_wd33c93_cmd(regs, WD_CMD_SEL_ATN_XFER);
 985		} else {
 986			hostdata->state = S_CONNECTED;
 987		}
 988		spin_unlock_irqrestore(&hostdata->lock, flags);
 989		break;
 990
 991	case CSR_XFER_DONE | PHS_MESS_IN:
 992	case CSR_UNEXP | PHS_MESS_IN:
 993	case CSR_SRV_REQ | PHS_MESS_IN:
 994		DB(DB_INTR, printk("MSG_IN="))
 995
 996		msg = read_1_byte(regs);
 997		sr = read_wd33c93(regs, WD_SCSI_STATUS);	/* clear interrupt */
 998		udelay(7);
 999
1000		hostdata->incoming_msg[hostdata->incoming_ptr] = msg;
1001		if (hostdata->incoming_msg[0] == EXTENDED_MESSAGE)
1002			msg = EXTENDED_MESSAGE;
1003		else
1004			hostdata->incoming_ptr = 0;
1005
1006		cmd->SCp.Message = msg;
1007		switch (msg) {
1008
1009		case COMMAND_COMPLETE:
1010			DB(DB_INTR, printk("CCMP"))
1011			    write_wd33c93_cmd(regs, WD_CMD_NEGATE_ACK);
1012			hostdata->state = S_PRE_CMP_DISC;
1013			break;
1014
1015		case SAVE_POINTERS:
1016			DB(DB_INTR, printk("SDP"))
1017			    write_wd33c93_cmd(regs, WD_CMD_NEGATE_ACK);
1018			hostdata->state = S_CONNECTED;
1019			break;
1020
1021		case RESTORE_POINTERS:
1022			DB(DB_INTR, printk("RDP"))
1023			    if (hostdata->level2 >= L2_BASIC) {
1024				write_wd33c93(regs, WD_COMMAND_PHASE, 0x45);
1025				write_wd33c93_cmd(regs, WD_CMD_SEL_ATN_XFER);
1026				hostdata->state = S_RUNNING_LEVEL2;
1027			} else {
1028				write_wd33c93_cmd(regs, WD_CMD_NEGATE_ACK);
1029				hostdata->state = S_CONNECTED;
1030			}
1031			break;
1032
1033		case DISCONNECT:
1034			DB(DB_INTR, printk("DIS"))
1035			    cmd->device->disconnect = 1;
1036			write_wd33c93_cmd(regs, WD_CMD_NEGATE_ACK);
1037			hostdata->state = S_PRE_TMP_DISC;
1038			break;
1039
1040		case MESSAGE_REJECT:
1041			DB(DB_INTR, printk("REJ"))
1042#ifdef SYNC_DEBUG
1043			    printk("-REJ-");
1044#endif
1045			if (hostdata->sync_stat[cmd->device->id] == SS_WAITING) {
1046				hostdata->sync_stat[cmd->device->id] = SS_SET;
1047				/* we want default_sx_per, not DEFAULT_SX_PER */
1048				hostdata->sync_xfer[cmd->device->id] =
1049					calc_sync_xfer(hostdata->default_sx_per
1050						/ 4, 0, 0, hostdata->sx_table);
1051			}
1052			write_wd33c93_cmd(regs, WD_CMD_NEGATE_ACK);
1053			hostdata->state = S_CONNECTED;
1054			break;
1055
1056		case EXTENDED_MESSAGE:
1057			DB(DB_INTR, printk("EXT"))
1058
1059			    ucp = hostdata->incoming_msg;
1060
1061#ifdef SYNC_DEBUG
1062			printk("%02x", ucp[hostdata->incoming_ptr]);
1063#endif
1064			/* Is this the last byte of the extended message? */
1065
1066			if ((hostdata->incoming_ptr >= 2) &&
1067			    (hostdata->incoming_ptr == (ucp[1] + 1))) {
1068
1069				switch (ucp[2]) {	/* what's the EXTENDED code? */
1070				case EXTENDED_SDTR:
1071					/* default to default async period */
1072					id = calc_sync_xfer(hostdata->
1073							default_sx_per / 4, 0,
1074							0, hostdata->sx_table);
1075					if (hostdata->sync_stat[cmd->device->id] !=
1076					    SS_WAITING) {
1077
1078/* A device has sent an unsolicited SDTR message; rather than go
1079 * through the effort of decoding it and then figuring out what
1080 * our reply should be, we're just gonna say that we have a
1081 * synchronous fifo depth of 0. This will result in asynchronous
1082 * transfers - not ideal but so much easier.
1083 * Actually, this is OK because it assures us that if we don't
1084 * specifically ask for sync transfers, we won't do any.
1085 */
1086
1087						write_wd33c93_cmd(regs, WD_CMD_ASSERT_ATN);	/* want MESS_OUT */
1088						hostdata->outgoing_msg[0] =
1089						    EXTENDED_MESSAGE;
1090						hostdata->outgoing_msg[1] = 3;
1091						hostdata->outgoing_msg[2] =
1092						    EXTENDED_SDTR;
1093						calc_sync_msg(hostdata->
1094							default_sx_per, 0,
1095							0, hostdata->outgoing_msg + 3);
1096						hostdata->outgoing_len = 5;
1097					} else {
1098						if (ucp[4]) /* well, sync transfer */
1099							id = calc_sync_xfer(ucp[3], ucp[4],
1100									hostdata->fast,
1101									hostdata->sx_table);
1102						else if (ucp[3]) /* very unlikely... */
1103							id = calc_sync_xfer(ucp[3], ucp[4],
1104									0, hostdata->sx_table);
1105					}
1106					hostdata->sync_xfer[cmd->device->id] = id;
1107#ifdef SYNC_DEBUG
1108					printk(" sync_xfer=%02x\n",
1109					       hostdata->sync_xfer[cmd->device->id]);
1110#endif
1111					hostdata->sync_stat[cmd->device->id] =
1112					    SS_SET;
1113					write_wd33c93_cmd(regs,
1114							  WD_CMD_NEGATE_ACK);
1115					hostdata->state = S_CONNECTED;
1116					break;
1117				case EXTENDED_WDTR:
1118					write_wd33c93_cmd(regs, WD_CMD_ASSERT_ATN);	/* want MESS_OUT */
1119					printk("sending WDTR ");
1120					hostdata->outgoing_msg[0] =
1121					    EXTENDED_MESSAGE;
1122					hostdata->outgoing_msg[1] = 2;
1123					hostdata->outgoing_msg[2] =
1124					    EXTENDED_WDTR;
1125					hostdata->outgoing_msg[3] = 0;	/* 8 bit transfer width */
1126					hostdata->outgoing_len = 4;
1127					write_wd33c93_cmd(regs,
1128							  WD_CMD_NEGATE_ACK);
1129					hostdata->state = S_CONNECTED;
1130					break;
1131				default:
1132					write_wd33c93_cmd(regs, WD_CMD_ASSERT_ATN);	/* want MESS_OUT */
1133					printk
1134					    ("Rejecting Unknown Extended Message(%02x). ",
1135					     ucp[2]);
1136					hostdata->outgoing_msg[0] =
1137					    MESSAGE_REJECT;
1138					hostdata->outgoing_len = 1;
1139					write_wd33c93_cmd(regs,
1140							  WD_CMD_NEGATE_ACK);
1141					hostdata->state = S_CONNECTED;
1142					break;
1143				}
1144				hostdata->incoming_ptr = 0;
1145			}
1146
1147			/* We need to read more MESS_IN bytes for the extended message */
1148
1149			else {
1150				hostdata->incoming_ptr++;
1151				write_wd33c93_cmd(regs, WD_CMD_NEGATE_ACK);
1152				hostdata->state = S_CONNECTED;
1153			}
1154			break;
1155
1156		default:
1157			printk("Rejecting Unknown Message(%02x) ", msg);
1158			write_wd33c93_cmd(regs, WD_CMD_ASSERT_ATN);	/* want MESS_OUT */
1159			hostdata->outgoing_msg[0] = MESSAGE_REJECT;
1160			hostdata->outgoing_len = 1;
1161			write_wd33c93_cmd(regs, WD_CMD_NEGATE_ACK);
1162			hostdata->state = S_CONNECTED;
1163		}
1164		spin_unlock_irqrestore(&hostdata->lock, flags);
1165		break;
1166
1167/* Note: this interrupt will occur only after a LEVEL2 command */
1168
1169	case CSR_SEL_XFER_DONE:
1170
1171/* Make sure that reselection is enabled at this point - it may
1172 * have been turned off for the command that just completed.
1173 */
1174
1175		write_wd33c93(regs, WD_SOURCE_ID, SRCID_ER);
1176		if (phs == 0x60) {
1177			DB(DB_INTR, printk("SX-DONE"))
1178			    cmd->SCp.Message = COMMAND_COMPLETE;
1179			lun = read_wd33c93(regs, WD_TARGET_LUN);
1180			DB(DB_INTR, printk(":%d.%d", cmd->SCp.Status, lun))
1181			    hostdata->connected = NULL;
1182			hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun);
1183			hostdata->state = S_UNCONNECTED;
1184			if (cmd->SCp.Status == ILLEGAL_STATUS_BYTE)
1185				cmd->SCp.Status = lun;
1186			if (cmd->cmnd[0] == REQUEST_SENSE
1187			    && cmd->SCp.Status != GOOD)
1188				cmd->result =
1189				    (cmd->
1190				     result & 0x00ffff) | (DID_ERROR << 16);
1191			else
1192				cmd->result =
1193				    cmd->SCp.Status | (cmd->SCp.Message << 8);
1194			cmd->scsi_done(cmd);
1195
1196/* We are no longer  connected to a target - check to see if
1197 * there are commands waiting to be executed.
1198 */
1199			spin_unlock_irqrestore(&hostdata->lock, flags);
1200			wd33c93_execute(instance);
1201		} else {
1202			printk
1203			    ("%02x:%02x:%02x: Unknown SEL_XFER_DONE phase!!---",
1204			     asr, sr, phs);
1205			spin_unlock_irqrestore(&hostdata->lock, flags);
1206		}
1207		break;
1208
1209/* Note: this interrupt will occur only after a LEVEL2 command */
1210
1211	case CSR_SDP:
1212		DB(DB_INTR, printk("SDP"))
1213		    hostdata->state = S_RUNNING_LEVEL2;
1214		write_wd33c93(regs, WD_COMMAND_PHASE, 0x41);
1215		write_wd33c93_cmd(regs, WD_CMD_SEL_ATN_XFER);
1216		spin_unlock_irqrestore(&hostdata->lock, flags);
1217		break;
1218
1219	case CSR_XFER_DONE | PHS_MESS_OUT:
1220	case CSR_UNEXP | PHS_MESS_OUT:
1221	case CSR_SRV_REQ | PHS_MESS_OUT:
1222		DB(DB_INTR, printk("MSG_OUT="))
1223
1224/* To get here, we've probably requested MESSAGE_OUT and have
1225 * already put the correct bytes in outgoing_msg[] and filled
1226 * in outgoing_len. We simply send them out to the SCSI bus.
1227 * Sometimes we get MESSAGE_OUT phase when we're not expecting
1228 * it - like when our SDTR message is rejected by a target. Some
1229 * targets send the REJECT before receiving all of the extended
1230 * message, and then seem to go back to MESSAGE_OUT for a byte
1231 * or two. Not sure why, or if I'm doing something wrong to
1232 * cause this to happen. Regardless, it seems that sending
1233 * NOP messages in these situations results in no harm and
1234 * makes everyone happy.
1235 */
1236		    if (hostdata->outgoing_len == 0) {
1237			hostdata->outgoing_len = 1;
1238			hostdata->outgoing_msg[0] = NOP;
1239		}
1240		transfer_pio(regs, hostdata->outgoing_msg,
1241			     hostdata->outgoing_len, DATA_OUT_DIR, hostdata);
1242		DB(DB_INTR, printk("%02x", hostdata->outgoing_msg[0]))
1243		    hostdata->outgoing_len = 0;
1244		hostdata->state = S_CONNECTED;
1245		spin_unlock_irqrestore(&hostdata->lock, flags);
1246		break;
1247
1248	case CSR_UNEXP_DISC:
1249
1250/* I think I've seen this after a request-sense that was in response
1251 * to an error condition, but not sure. We certainly need to do
1252 * something when we get this interrupt - the question is 'what?'.
1253 * Let's think positively, and assume some command has finished
1254 * in a legal manner (like a command that provokes a request-sense),
1255 * so we treat it as a normal command-complete-disconnect.
1256 */
1257
1258/* Make sure that reselection is enabled at this point - it may
1259 * have been turned off for the command that just completed.
1260 */
1261
1262		write_wd33c93(regs, WD_SOURCE_ID, SRCID_ER);
1263		if (cmd == NULL) {
1264			printk(" - Already disconnected! ");
1265			hostdata->state = S_UNCONNECTED;
1266			spin_unlock_irqrestore(&hostdata->lock, flags);
1267			return;
1268		}
1269		DB(DB_INTR, printk("UNEXP_DISC"))
1270		    hostdata->connected = NULL;
1271		hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun);
1272		hostdata->state = S_UNCONNECTED;
1273		if (cmd->cmnd[0] == REQUEST_SENSE && cmd->SCp.Status != GOOD)
1274			cmd->result =
1275			    (cmd->result & 0x00ffff) | (DID_ERROR << 16);
1276		else
1277			cmd->result = cmd->SCp.Status | (cmd->SCp.Message << 8);
1278		cmd->scsi_done(cmd);
 
 
 
1279
1280/* We are no longer connected to a target - check to see if
1281 * there are commands waiting to be executed.
1282 */
1283		/* look above for comments on scsi_done() */
1284		spin_unlock_irqrestore(&hostdata->lock, flags);
1285		wd33c93_execute(instance);
1286		break;
1287
1288	case CSR_DISC:
1289
1290/* Make sure that reselection is enabled at this point - it may
1291 * have been turned off for the command that just completed.
1292 */
1293
1294		write_wd33c93(regs, WD_SOURCE_ID, SRCID_ER);
1295		DB(DB_INTR, printk("DISC"))
1296		    if (cmd == NULL) {
1297			printk(" - Already disconnected! ");
1298			hostdata->state = S_UNCONNECTED;
1299		}
1300		switch (hostdata->state) {
1301		case S_PRE_CMP_DISC:
1302			hostdata->connected = NULL;
1303			hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun);
1304			hostdata->state = S_UNCONNECTED;
1305			DB(DB_INTR, printk(":%d", cmd->SCp.Status))
1306			    if (cmd->cmnd[0] == REQUEST_SENSE
1307				&& cmd->SCp.Status != GOOD)
1308				cmd->result =
1309				    (cmd->
1310				     result & 0x00ffff) | (DID_ERROR << 16);
1311			else
1312				cmd->result =
1313				    cmd->SCp.Status | (cmd->SCp.Message << 8);
1314			cmd->scsi_done(cmd);
1315			break;
1316		case S_PRE_TMP_DISC:
1317		case S_RUNNING_LEVEL2:
1318			cmd->host_scribble = (uchar *) hostdata->disconnected_Q;
1319			hostdata->disconnected_Q = cmd;
1320			hostdata->connected = NULL;
1321			hostdata->state = S_UNCONNECTED;
1322
1323#ifdef PROC_STATISTICS
1324			hostdata->disc_done_cnt[cmd->device->id]++;
1325#endif
1326
1327			break;
1328		default:
1329			printk("*** Unexpected DISCONNECT interrupt! ***");
1330			hostdata->state = S_UNCONNECTED;
1331		}
1332
1333/* We are no longer connected to a target - check to see if
1334 * there are commands waiting to be executed.
1335 */
1336		spin_unlock_irqrestore(&hostdata->lock, flags);
1337		wd33c93_execute(instance);
1338		break;
1339
1340	case CSR_RESEL_AM:
1341	case CSR_RESEL:
1342		DB(DB_INTR, printk("RESEL%s", sr == CSR_RESEL_AM ? "_AM" : ""))
1343
1344		    /* Old chips (pre -A ???) don't have advanced features and will
1345		     * generate CSR_RESEL.  In that case we have to extract the LUN the
1346		     * hard way (see below).
1347		     * First we have to make sure this reselection didn't
1348		     * happen during Arbitration/Selection of some other device.
1349		     * If yes, put losing command back on top of input_Q.
1350		     */
1351		    if (hostdata->level2 <= L2_NONE) {
1352
1353			if (hostdata->selecting) {
1354				cmd = (struct scsi_cmnd *) hostdata->selecting;
1355				hostdata->selecting = NULL;
1356				hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun);
1357				cmd->host_scribble =
1358				    (uchar *) hostdata->input_Q;
1359				hostdata->input_Q = cmd;
1360			}
1361		}
1362
1363		else {
1364
1365			if (cmd) {
1366				if (phs == 0x00) {
1367					hostdata->busy[cmd->device->id] &=
1368					    ~(1 << cmd->device->lun);
1369					cmd->host_scribble =
1370					    (uchar *) hostdata->input_Q;
1371					hostdata->input_Q = cmd;
1372				} else {
1373					printk
1374					    ("---%02x:%02x:%02x-TROUBLE: Intrusive ReSelect!---",
1375					     asr, sr, phs);
1376					while (1)
1377						printk("\r");
1378				}
1379			}
1380
1381		}
1382
1383		/* OK - find out which device reselected us. */
1384
1385		id = read_wd33c93(regs, WD_SOURCE_ID);
1386		id &= SRCID_MASK;
1387
1388		/* and extract the lun from the ID message. (Note that we don't
1389		 * bother to check for a valid message here - I guess this is
1390		 * not the right way to go, but...)
1391		 */
1392
1393		if (sr == CSR_RESEL_AM) {
1394			lun = read_wd33c93(regs, WD_DATA);
1395			if (hostdata->level2 < L2_RESELECT)
1396				write_wd33c93_cmd(regs, WD_CMD_NEGATE_ACK);
1397			lun &= 7;
1398		} else {
1399			/* Old chip; wait for msgin phase to pick up the LUN. */
1400			for (lun = 255; lun; lun--) {
1401				if ((asr = read_aux_stat(regs)) & ASR_INT)
1402					break;
1403				udelay(10);
1404			}
1405			if (!(asr & ASR_INT)) {
1406				printk
1407				    ("wd33c93: Reselected without IDENTIFY\n");
1408				lun = 0;
1409			} else {
1410				/* Verify this is a change to MSG_IN and read the message */
1411				sr = read_wd33c93(regs, WD_SCSI_STATUS);
1412				udelay(7);
1413				if (sr == (CSR_ABORT | PHS_MESS_IN) ||
1414				    sr == (CSR_UNEXP | PHS_MESS_IN) ||
1415				    sr == (CSR_SRV_REQ | PHS_MESS_IN)) {
1416					/* Got MSG_IN, grab target LUN */
1417					lun = read_1_byte(regs);
1418					/* Now we expect a 'paused with ACK asserted' int.. */
1419					asr = read_aux_stat(regs);
1420					if (!(asr & ASR_INT)) {
1421						udelay(10);
1422						asr = read_aux_stat(regs);
1423						if (!(asr & ASR_INT))
1424							printk
1425							    ("wd33c93: No int after LUN on RESEL (%02x)\n",
1426							     asr);
1427					}
1428					sr = read_wd33c93(regs, WD_SCSI_STATUS);
1429					udelay(7);
1430					if (sr != CSR_MSGIN)
1431						printk
1432						    ("wd33c93: Not paused with ACK on RESEL (%02x)\n",
1433						     sr);
1434					lun &= 7;
1435					write_wd33c93_cmd(regs,
1436							  WD_CMD_NEGATE_ACK);
1437				} else {
1438					printk
1439					    ("wd33c93: Not MSG_IN on reselect (%02x)\n",
1440					     sr);
1441					lun = 0;
1442				}
1443			}
1444		}
1445
1446		/* Now we look for the command that's reconnecting. */
1447
1448		cmd = (struct scsi_cmnd *) hostdata->disconnected_Q;
1449		patch = NULL;
1450		while (cmd) {
1451			if (id == cmd->device->id && lun == cmd->device->lun)
1452				break;
1453			patch = cmd;
1454			cmd = (struct scsi_cmnd *) cmd->host_scribble;
1455		}
1456
1457		/* Hmm. Couldn't find a valid command.... What to do? */
1458
1459		if (!cmd) {
1460			printk
1461			    ("---TROUBLE: target %d.%d not in disconnect queue---",
1462			     id, lun);
1463			spin_unlock_irqrestore(&hostdata->lock, flags);
1464			return;
1465		}
1466
1467		/* Ok, found the command - now start it up again. */
1468
1469		if (patch)
1470			patch->host_scribble = cmd->host_scribble;
1471		else
1472			hostdata->disconnected_Q =
1473			    (struct scsi_cmnd *) cmd->host_scribble;
1474		hostdata->connected = cmd;
1475
1476		/* We don't need to worry about 'initialize_SCp()' or 'hostdata->busy[]'
1477		 * because these things are preserved over a disconnect.
1478		 * But we DO need to fix the DPD bit so it's correct for this command.
1479		 */
1480
1481		if (cmd->sc_data_direction == DMA_TO_DEVICE)
1482			write_wd33c93(regs, WD_DESTINATION_ID, cmd->device->id);
1483		else
1484			write_wd33c93(regs, WD_DESTINATION_ID,
1485				      cmd->device->id | DSTID_DPD);
1486		if (hostdata->level2 >= L2_RESELECT) {
1487			write_wd33c93_count(regs, 0);	/* we want a DATA_PHASE interrupt */
1488			write_wd33c93(regs, WD_COMMAND_PHASE, 0x45);
1489			write_wd33c93_cmd(regs, WD_CMD_SEL_ATN_XFER);
1490			hostdata->state = S_RUNNING_LEVEL2;
1491		} else
1492			hostdata->state = S_CONNECTED;
1493
1494		    spin_unlock_irqrestore(&hostdata->lock, flags);
1495		break;
1496
1497	default:
1498		printk("--UNKNOWN INTERRUPT:%02x:%02x:%02x--", asr, sr, phs);
1499		spin_unlock_irqrestore(&hostdata->lock, flags);
1500	}
1501
1502	DB(DB_INTR, printk("} "))
1503
1504}
1505
1506static void
1507reset_wd33c93(struct Scsi_Host *instance)
1508{
1509	struct WD33C93_hostdata *hostdata =
1510	    (struct WD33C93_hostdata *) instance->hostdata;
1511	const wd33c93_regs regs = hostdata->regs;
1512	uchar sr;
1513
1514#ifdef CONFIG_SGI_IP22
1515	{
1516		int busycount = 0;
1517		extern void sgiwd93_reset(unsigned long);
1518		/* wait 'til the chip gets some time for us */
1519		while ((read_aux_stat(regs) & ASR_BSY) && busycount++ < 100)
1520			udelay (10);
1521	/*
1522 	 * there are scsi devices out there, which manage to lock up
1523	 * the wd33c93 in a busy condition. In this state it won't
1524	 * accept the reset command. The only way to solve this is to
1525 	 * give the chip a hardware reset (if possible). The code below
1526	 * does this for the SGI Indy, where this is possible
1527	 */
1528	/* still busy ? */
1529	if (read_aux_stat(regs) & ASR_BSY)
1530		sgiwd93_reset(instance->base); /* yeah, give it the hard one */
1531	}
1532#endif
1533
1534	write_wd33c93(regs, WD_OWN_ID, OWNID_EAF | OWNID_RAF |
1535		      instance->this_id | hostdata->clock_freq);
1536	write_wd33c93(regs, WD_CONTROL, CTRL_IDI | CTRL_EDI | CTRL_POLLED);
1537	write_wd33c93(regs, WD_SYNCHRONOUS_TRANSFER,
1538		      calc_sync_xfer(hostdata->default_sx_per / 4,
1539				     DEFAULT_SX_OFF, 0, hostdata->sx_table));
1540	write_wd33c93(regs, WD_COMMAND, WD_CMD_RESET);
1541
1542
1543#ifdef CONFIG_MVME147_SCSI
1544	udelay(25);		/* The old wd33c93 on MVME147 needs this, at least */
1545#endif
1546
1547	while (!(read_aux_stat(regs) & ASR_INT))
1548		;
1549	sr = read_wd33c93(regs, WD_SCSI_STATUS);
1550
1551	hostdata->microcode = read_wd33c93(regs, WD_CDB_1);
1552	if (sr == 0x00)
1553		hostdata->chip = C_WD33C93;
1554	else if (sr == 0x01) {
1555		write_wd33c93(regs, WD_QUEUE_TAG, 0xa5);	/* any random number */
1556		sr = read_wd33c93(regs, WD_QUEUE_TAG);
1557		if (sr == 0xa5) {
1558			hostdata->chip = C_WD33C93B;
1559			write_wd33c93(regs, WD_QUEUE_TAG, 0);
1560		} else
1561			hostdata->chip = C_WD33C93A;
1562	} else
1563		hostdata->chip = C_UNKNOWN_CHIP;
1564
1565	if (hostdata->chip != C_WD33C93B)	/* Fast SCSI unavailable */
1566		hostdata->fast = 0;
1567
1568	write_wd33c93(regs, WD_TIMEOUT_PERIOD, TIMEOUT_PERIOD_VALUE);
1569	write_wd33c93(regs, WD_CONTROL, CTRL_IDI | CTRL_EDI | CTRL_POLLED);
1570}
1571
1572int
1573wd33c93_host_reset(struct scsi_cmnd * SCpnt)
1574{
1575	struct Scsi_Host *instance;
1576	struct WD33C93_hostdata *hostdata;
1577	int i;
1578
1579	instance = SCpnt->device->host;
 
1580	hostdata = (struct WD33C93_hostdata *) instance->hostdata;
1581
1582	printk("scsi%d: reset. ", instance->host_no);
1583	disable_irq(instance->irq);
1584
1585	hostdata->dma_stop(instance, NULL, 0);
1586	for (i = 0; i < 8; i++) {
1587		hostdata->busy[i] = 0;
1588		hostdata->sync_xfer[i] =
1589			calc_sync_xfer(DEFAULT_SX_PER / 4, DEFAULT_SX_OFF,
1590					0, hostdata->sx_table);
1591		hostdata->sync_stat[i] = SS_UNSET;	/* using default sync values */
1592	}
1593	hostdata->input_Q = NULL;
1594	hostdata->selecting = NULL;
1595	hostdata->connected = NULL;
1596	hostdata->disconnected_Q = NULL;
1597	hostdata->state = S_UNCONNECTED;
1598	hostdata->dma = D_DMA_OFF;
1599	hostdata->incoming_ptr = 0;
1600	hostdata->outgoing_len = 0;
1601
1602	reset_wd33c93(instance);
1603	SCpnt->result = DID_RESET << 16;
1604	enable_irq(instance->irq);
 
1605	return SUCCESS;
1606}
1607
1608int
1609wd33c93_abort(struct scsi_cmnd * cmd)
1610{
1611	struct Scsi_Host *instance;
1612	struct WD33C93_hostdata *hostdata;
1613	wd33c93_regs regs;
1614	struct scsi_cmnd *tmp, *prev;
1615
1616	disable_irq(cmd->device->host->irq);
1617
1618	instance = cmd->device->host;
1619	hostdata = (struct WD33C93_hostdata *) instance->hostdata;
1620	regs = hostdata->regs;
1621
1622/*
1623 * Case 1 : If the command hasn't been issued yet, we simply remove it
1624 *     from the input_Q.
1625 */
1626
1627	tmp = (struct scsi_cmnd *) hostdata->input_Q;
1628	prev = NULL;
1629	while (tmp) {
1630		if (tmp == cmd) {
1631			if (prev)
1632				prev->host_scribble = cmd->host_scribble;
1633			else
1634				hostdata->input_Q =
1635				    (struct scsi_cmnd *) cmd->host_scribble;
1636			cmd->host_scribble = NULL;
1637			cmd->result = DID_ABORT << 16;
1638			printk
1639			    ("scsi%d: Abort - removing command from input_Q. ",
1640			     instance->host_no);
1641			enable_irq(cmd->device->host->irq);
1642			cmd->scsi_done(cmd);
1643			return SUCCESS;
1644		}
1645		prev = tmp;
1646		tmp = (struct scsi_cmnd *) tmp->host_scribble;
1647	}
1648
1649/*
1650 * Case 2 : If the command is connected, we're going to fail the abort
1651 *     and let the high level SCSI driver retry at a later time or
1652 *     issue a reset.
1653 *
1654 *     Timeouts, and therefore aborted commands, will be highly unlikely
1655 *     and handling them cleanly in this situation would make the common
1656 *     case of noresets less efficient, and would pollute our code.  So,
1657 *     we fail.
1658 */
1659
1660	if (hostdata->connected == cmd) {
1661		uchar sr, asr;
1662		unsigned long timeout;
1663
1664		printk("scsi%d: Aborting connected command - ",
1665		       instance->host_no);
1666
1667		printk("stopping DMA - ");
1668		if (hostdata->dma == D_DMA_RUNNING) {
1669			hostdata->dma_stop(instance, cmd, 0);
1670			hostdata->dma = D_DMA_OFF;
1671		}
1672
1673		printk("sending wd33c93 ABORT command - ");
1674		write_wd33c93(regs, WD_CONTROL,
1675			      CTRL_IDI | CTRL_EDI | CTRL_POLLED);
1676		write_wd33c93_cmd(regs, WD_CMD_ABORT);
1677
1678/* Now we have to attempt to flush out the FIFO... */
1679
1680		printk("flushing fifo - ");
1681		timeout = 1000000;
1682		do {
1683			asr = read_aux_stat(regs);
1684			if (asr & ASR_DBR)
1685				read_wd33c93(regs, WD_DATA);
1686		} while (!(asr & ASR_INT) && timeout-- > 0);
1687		sr = read_wd33c93(regs, WD_SCSI_STATUS);
1688		printk
1689		    ("asr=%02x, sr=%02x, %ld bytes un-transferred (timeout=%ld) - ",
1690		     asr, sr, read_wd33c93_count(regs), timeout);
1691
1692		/*
1693		 * Abort command processed.
1694		 * Still connected.
1695		 * We must disconnect.
1696		 */
1697
1698		printk("sending wd33c93 DISCONNECT command - ");
1699		write_wd33c93_cmd(regs, WD_CMD_DISCONNECT);
1700
1701		timeout = 1000000;
1702		asr = read_aux_stat(regs);
1703		while ((asr & ASR_CIP) && timeout-- > 0)
1704			asr = read_aux_stat(regs);
1705		sr = read_wd33c93(regs, WD_SCSI_STATUS);
1706		printk("asr=%02x, sr=%02x.", asr, sr);
1707
1708		hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun);
1709		hostdata->connected = NULL;
1710		hostdata->state = S_UNCONNECTED;
1711		cmd->result = DID_ABORT << 16;
1712
1713/*      sti();*/
1714		wd33c93_execute(instance);
1715
1716		enable_irq(cmd->device->host->irq);
1717		cmd->scsi_done(cmd);
1718		return SUCCESS;
1719	}
1720
1721/*
1722 * Case 3: If the command is currently disconnected from the bus,
1723 * we're not going to expend much effort here: Let's just return
1724 * an ABORT_SNOOZE and hope for the best...
1725 */
1726
1727	tmp = (struct scsi_cmnd *) hostdata->disconnected_Q;
1728	while (tmp) {
1729		if (tmp == cmd) {
1730			printk
1731			    ("scsi%d: Abort - command found on disconnected_Q - ",
1732			     instance->host_no);
1733			printk("Abort SNOOZE. ");
1734			enable_irq(cmd->device->host->irq);
1735			return FAILED;
1736		}
1737		tmp = (struct scsi_cmnd *) tmp->host_scribble;
1738	}
1739
1740/*
1741 * Case 4 : If we reached this point, the command was not found in any of
1742 *     the queues.
1743 *
1744 * We probably reached this point because of an unlikely race condition
1745 * between the command completing successfully and the abortion code,
1746 * so we won't panic, but we will notify the user in case something really
1747 * broke.
1748 */
1749
1750/*   sti();*/
1751	wd33c93_execute(instance);
1752
1753	enable_irq(cmd->device->host->irq);
1754	printk("scsi%d: warning : SCSI command probably completed successfully"
1755	       "         before abortion. ", instance->host_no);
1756	return FAILED;
1757}
1758
1759#define MAX_WD33C93_HOSTS 4
1760#define MAX_SETUP_ARGS ARRAY_SIZE(setup_args)
1761#define SETUP_BUFFER_SIZE 200
1762static char setup_buffer[SETUP_BUFFER_SIZE];
1763static char setup_used[MAX_SETUP_ARGS];
1764static int done_setup = 0;
1765
1766static int
1767wd33c93_setup(char *str)
1768{
1769	int i;
1770	char *p1, *p2;
1771
1772	/* The kernel does some processing of the command-line before calling
1773	 * this function: If it begins with any decimal or hex number arguments,
1774	 * ints[0] = how many numbers found and ints[1] through [n] are the values
1775	 * themselves. str points to where the non-numeric arguments (if any)
1776	 * start: We do our own parsing of those. We construct synthetic 'nosync'
1777	 * keywords out of numeric args (to maintain compatibility with older
1778	 * versions) and then add the rest of the arguments.
1779	 */
1780
1781	p1 = setup_buffer;
1782	*p1 = '\0';
1783	if (str)
1784		strncpy(p1, str, SETUP_BUFFER_SIZE - strlen(setup_buffer));
1785	setup_buffer[SETUP_BUFFER_SIZE - 1] = '\0';
1786	p1 = setup_buffer;
1787	i = 0;
1788	while (*p1 && (i < MAX_SETUP_ARGS)) {
1789		p2 = strchr(p1, ',');
1790		if (p2) {
1791			*p2 = '\0';
1792			if (p1 != p2)
1793				setup_args[i] = p1;
1794			p1 = p2 + 1;
1795			i++;
1796		} else {
1797			setup_args[i] = p1;
1798			break;
1799		}
1800	}
1801	for (i = 0; i < MAX_SETUP_ARGS; i++)
1802		setup_used[i] = 0;
1803	done_setup = 1;
1804
1805	return 1;
1806}
1807__setup("wd33c93=", wd33c93_setup);
1808
1809/* check_setup_args() returns index if key found, 0 if not
1810 */
1811static int
1812check_setup_args(char *key, int *flags, int *val, char *buf)
1813{
1814	int x;
1815	char *cp;
1816
1817	for (x = 0; x < MAX_SETUP_ARGS; x++) {
1818		if (setup_used[x])
1819			continue;
1820		if (!strncmp(setup_args[x], key, strlen(key)))
1821			break;
1822		if (!strncmp(setup_args[x], "next", strlen("next")))
1823			return 0;
1824	}
1825	if (x == MAX_SETUP_ARGS)
1826		return 0;
1827	setup_used[x] = 1;
1828	cp = setup_args[x] + strlen(key);
1829	*val = -1;
1830	if (*cp != ':')
1831		return ++x;
1832	cp++;
1833	if ((*cp >= '0') && (*cp <= '9')) {
1834		*val = simple_strtoul(cp, NULL, 0);
1835	}
1836	return ++x;
1837}
1838
1839/*
1840 * Calculate internal data-transfer-clock cycle from input-clock
1841 * frequency (/MHz) and fill 'sx_table'.
1842 *
1843 * The original driver used to rely on a fixed sx_table, containing periods
1844 * for (only) the lower limits of the respective input-clock-frequency ranges
1845 * (8-10/12-15/16-20 MHz). Although it seems, that no problems occurred with
1846 * this setting so far, it might be desirable to adjust the transfer periods
1847 * closer to the really attached, possibly 25% higher, input-clock, since
1848 * - the wd33c93 may really use a significant shorter period, than it has
1849 *   negotiated (eg. thrashing the target, which expects 4/8MHz, with 5/10MHz
1850 *   instead).
1851 * - the wd33c93 may ask the target for a lower transfer rate, than the target
1852 *   is capable of (eg. negotiating for an assumed minimum of 252ns instead of
1853 *   possible 200ns, which indeed shows up in tests as an approx. 10% lower
1854 *   transfer rate).
1855 */
1856static inline unsigned int
1857round_4(unsigned int x)
1858{
1859	switch (x & 3) {
1860		case 1: --x;
1861			break;
1862		case 2: ++x;
 
1863		case 3: ++x;
1864	}
1865	return x;
1866}
1867
1868static void
1869calc_sx_table(unsigned int mhz, struct sx_period sx_table[9])
1870{
1871	unsigned int d, i;
1872	if (mhz < 11)
1873		d = 2;	/* divisor for  8-10 MHz input-clock */
1874	else if (mhz < 16)
1875		d = 3;	/* divisor for 12-15 MHz input-clock */
1876	else
1877		d = 4;	/* divisor for 16-20 MHz input-clock */
1878
1879	d = (100000 * d) / 2 / mhz; /* 100 x DTCC / nanosec */
1880
1881	sx_table[0].period_ns = 1;
1882	sx_table[0].reg_value = 0x20;
1883	for (i = 1; i < 8; i++) {
1884		sx_table[i].period_ns = round_4((i+1)*d / 100);
1885		sx_table[i].reg_value = (i+1)*0x10;
1886	}
1887	sx_table[7].reg_value = 0;
1888	sx_table[8].period_ns = 0;
1889	sx_table[8].reg_value = 0;
1890}
1891
1892/*
1893 * check and, maybe, map an init- or "clock:"- argument.
1894 */
1895static uchar
1896set_clk_freq(int freq, int *mhz)
1897{
1898	int x = freq;
1899	if (WD33C93_FS_8_10 == freq)
1900		freq = 8;
1901	else if (WD33C93_FS_12_15 == freq)
1902		freq = 12;
1903	else if (WD33C93_FS_16_20 == freq)
1904		freq = 16;
1905	else if (freq > 7 && freq < 11)
1906		x = WD33C93_FS_8_10;
1907		else if (freq > 11 && freq < 16)
1908		x = WD33C93_FS_12_15;
1909		else if (freq > 15 && freq < 21)
1910		x = WD33C93_FS_16_20;
1911	else {
1912			/* Hmm, wouldn't it be safer to assume highest freq here? */
1913		x = WD33C93_FS_8_10;
1914		freq = 8;
1915	}
1916	*mhz = freq;
1917	return x;
1918}
1919
1920/*
1921 * to be used with the resync: fast: ... options
1922 */
1923static inline void set_resync ( struct WD33C93_hostdata *hd, int mask )
1924{
1925	int i;
1926	for (i = 0; i < 8; i++)
1927		if (mask & (1 << i))
1928			hd->sync_stat[i] = SS_UNSET;
1929}
1930
1931void
1932wd33c93_init(struct Scsi_Host *instance, const wd33c93_regs regs,
1933	     dma_setup_t setup, dma_stop_t stop, int clock_freq)
1934{
1935	struct WD33C93_hostdata *hostdata;
1936	int i;
1937	int flags;
1938	int val;
1939	char buf[32];
1940
1941	if (!done_setup && setup_strings)
1942		wd33c93_setup(setup_strings);
1943
1944	hostdata = (struct WD33C93_hostdata *) instance->hostdata;
1945
1946	hostdata->regs = regs;
1947	hostdata->clock_freq = set_clk_freq(clock_freq, &i);
1948	calc_sx_table(i, hostdata->sx_table);
1949	hostdata->dma_setup = setup;
1950	hostdata->dma_stop = stop;
1951	hostdata->dma_bounce_buffer = NULL;
1952	hostdata->dma_bounce_len = 0;
1953	for (i = 0; i < 8; i++) {
1954		hostdata->busy[i] = 0;
1955		hostdata->sync_xfer[i] =
1956			calc_sync_xfer(DEFAULT_SX_PER / 4, DEFAULT_SX_OFF,
1957					0, hostdata->sx_table);
1958		hostdata->sync_stat[i] = SS_UNSET;	/* using default sync values */
1959#ifdef PROC_STATISTICS
1960		hostdata->cmd_cnt[i] = 0;
1961		hostdata->disc_allowed_cnt[i] = 0;
1962		hostdata->disc_done_cnt[i] = 0;
1963#endif
1964	}
1965	hostdata->input_Q = NULL;
1966	hostdata->selecting = NULL;
1967	hostdata->connected = NULL;
1968	hostdata->disconnected_Q = NULL;
1969	hostdata->state = S_UNCONNECTED;
1970	hostdata->dma = D_DMA_OFF;
1971	hostdata->level2 = L2_BASIC;
1972	hostdata->disconnect = DIS_ADAPTIVE;
1973	hostdata->args = DEBUG_DEFAULTS;
1974	hostdata->incoming_ptr = 0;
1975	hostdata->outgoing_len = 0;
1976	hostdata->default_sx_per = DEFAULT_SX_PER;
1977	hostdata->no_dma = 0;	/* default is DMA enabled */
1978
1979#ifdef PROC_INTERFACE
1980	hostdata->proc = PR_VERSION | PR_INFO | PR_STATISTICS |
1981	    PR_CONNECTED | PR_INPUTQ | PR_DISCQ | PR_STOP;
1982#ifdef PROC_STATISTICS
1983	hostdata->dma_cnt = 0;
1984	hostdata->pio_cnt = 0;
1985	hostdata->int_cnt = 0;
1986#endif
1987#endif
1988
1989	if (check_setup_args("clock", &flags, &val, buf)) {
1990		hostdata->clock_freq = set_clk_freq(val, &val);
1991		calc_sx_table(val, hostdata->sx_table);
1992	}
1993
1994	if (check_setup_args("nosync", &flags, &val, buf))
1995		hostdata->no_sync = val;
1996
1997	if (check_setup_args("nodma", &flags, &val, buf))
1998		hostdata->no_dma = (val == -1) ? 1 : val;
1999
2000	if (check_setup_args("period", &flags, &val, buf))
2001		hostdata->default_sx_per =
2002		    hostdata->sx_table[round_period((unsigned int) val,
2003		                                    hostdata->sx_table)].period_ns;
2004
2005	if (check_setup_args("disconnect", &flags, &val, buf)) {
2006		if ((val >= DIS_NEVER) && (val <= DIS_ALWAYS))
2007			hostdata->disconnect = val;
2008		else
2009			hostdata->disconnect = DIS_ADAPTIVE;
2010	}
2011
2012	if (check_setup_args("level2", &flags, &val, buf))
2013		hostdata->level2 = val;
2014
2015	if (check_setup_args("debug", &flags, &val, buf))
2016		hostdata->args = val & DB_MASK;
2017
2018	if (check_setup_args("burst", &flags, &val, buf))
2019		hostdata->dma_mode = val ? CTRL_BURST:CTRL_DMA;
2020
2021	if (WD33C93_FS_16_20 == hostdata->clock_freq /* divisor 4 */
2022		&& check_setup_args("fast", &flags, &val, buf))
2023		hostdata->fast = !!val;
2024
2025	if ((i = check_setup_args("next", &flags, &val, buf))) {
2026		while (i)
2027			setup_used[--i] = 1;
2028	}
2029#ifdef PROC_INTERFACE
2030	if (check_setup_args("proc", &flags, &val, buf))
2031		hostdata->proc = val;
2032#endif
2033
2034	spin_lock_irq(&hostdata->lock);
2035	reset_wd33c93(instance);
2036	spin_unlock_irq(&hostdata->lock);
2037
2038	printk("wd33c93-%d: chip=%s/%d no_sync=0x%x no_dma=%d",
2039	       instance->host_no,
2040	       (hostdata->chip == C_WD33C93) ? "WD33c93" : (hostdata->chip ==
2041							    C_WD33C93A) ?
2042	       "WD33c93A" : (hostdata->chip ==
2043			     C_WD33C93B) ? "WD33c93B" : "unknown",
2044	       hostdata->microcode, hostdata->no_sync, hostdata->no_dma);
2045#ifdef DEBUGGING_ON
2046	printk(" debug_flags=0x%02x\n", hostdata->args);
2047#else
2048	printk(" debugging=OFF\n");
2049#endif
2050	printk("           setup_args=");
2051	for (i = 0; i < MAX_SETUP_ARGS; i++)
2052		printk("%s,", setup_args[i]);
2053	printk("\n");
2054	printk("           Version %s - %s\n", WD33C93_VERSION, WD33C93_DATE);
2055}
2056
2057int wd33c93_write_info(struct Scsi_Host *instance, char *buf, int len)
2058{
2059#ifdef PROC_INTERFACE
2060	char *bp;
2061	struct WD33C93_hostdata *hd;
2062	int x;
2063
2064	hd = (struct WD33C93_hostdata *) instance->hostdata;
2065
2066/* We accept the following
2067 * keywords (same format as command-line, but arguments are not optional):
2068 *    debug
2069 *    disconnect
2070 *    period
2071 *    resync
2072 *    proc
2073 *    nodma
2074 *    level2
2075 *    burst
2076 *    fast
2077 *    nosync
2078 */
2079
2080	buf[len] = '\0';
2081	for (bp = buf; *bp; ) {
2082		while (',' == *bp || ' ' == *bp)
2083			++bp;
2084	if (!strncmp(bp, "debug:", 6)) {
2085			hd->args = simple_strtoul(bp+6, &bp, 0) & DB_MASK;
2086	} else if (!strncmp(bp, "disconnect:", 11)) {
2087			x = simple_strtoul(bp+11, &bp, 0);
2088		if (x < DIS_NEVER || x > DIS_ALWAYS)
2089			x = DIS_ADAPTIVE;
2090		hd->disconnect = x;
2091	} else if (!strncmp(bp, "period:", 7)) {
2092		x = simple_strtoul(bp+7, &bp, 0);
2093		hd->default_sx_per =
2094			hd->sx_table[round_period((unsigned int) x,
2095						  hd->sx_table)].period_ns;
2096	} else if (!strncmp(bp, "resync:", 7)) {
2097			set_resync(hd, (int)simple_strtoul(bp+7, &bp, 0));
2098	} else if (!strncmp(bp, "proc:", 5)) {
2099			hd->proc = simple_strtoul(bp+5, &bp, 0);
2100	} else if (!strncmp(bp, "nodma:", 6)) {
2101			hd->no_dma = simple_strtoul(bp+6, &bp, 0);
2102	} else if (!strncmp(bp, "level2:", 7)) {
2103			hd->level2 = simple_strtoul(bp+7, &bp, 0);
2104		} else if (!strncmp(bp, "burst:", 6)) {
2105			hd->dma_mode =
2106				simple_strtol(bp+6, &bp, 0) ? CTRL_BURST:CTRL_DMA;
2107		} else if (!strncmp(bp, "fast:", 5)) {
2108			x = !!simple_strtol(bp+5, &bp, 0);
2109			if (x != hd->fast)
2110				set_resync(hd, 0xff);
2111			hd->fast = x;
2112		} else if (!strncmp(bp, "nosync:", 7)) {
2113			x = simple_strtoul(bp+7, &bp, 0);
2114			set_resync(hd, x ^ hd->no_sync);
2115			hd->no_sync = x;
2116		} else {
2117			break; /* unknown keyword,syntax-error,... */
2118		}
2119	}
2120	return len;
2121#else
2122	return 0;
2123#endif
2124}
2125
2126int
2127wd33c93_show_info(struct seq_file *m, struct Scsi_Host *instance)
2128{
2129#ifdef PROC_INTERFACE
2130	struct WD33C93_hostdata *hd;
2131	struct scsi_cmnd *cmd;
2132	int x;
2133
2134	hd = (struct WD33C93_hostdata *) instance->hostdata;
2135
2136	spin_lock_irq(&hd->lock);
2137	if (hd->proc & PR_VERSION)
2138		seq_printf(m, "\nVersion %s - %s.",
2139			WD33C93_VERSION, WD33C93_DATE);
2140
2141	if (hd->proc & PR_INFO) {
2142		seq_printf(m, "\nclock_freq=%02x no_sync=%02x no_dma=%d"
2143			" dma_mode=%02x fast=%d",
2144			hd->clock_freq, hd->no_sync, hd->no_dma, hd->dma_mode, hd->fast);
2145		seq_printf(m, "\nsync_xfer[] =       ");
2146		for (x = 0; x < 7; x++)
2147			seq_printf(m, "\t%02x", hd->sync_xfer[x]);
2148		seq_printf(m, "\nsync_stat[] =       ");
2149		for (x = 0; x < 7; x++)
2150			seq_printf(m, "\t%02x", hd->sync_stat[x]);
2151	}
2152#ifdef PROC_STATISTICS
2153	if (hd->proc & PR_STATISTICS) {
2154		seq_printf(m, "\ncommands issued:    ");
2155		for (x = 0; x < 7; x++)
2156			seq_printf(m, "\t%ld", hd->cmd_cnt[x]);
2157		seq_printf(m, "\ndisconnects allowed:");
2158		for (x = 0; x < 7; x++)
2159			seq_printf(m, "\t%ld", hd->disc_allowed_cnt[x]);
2160		seq_printf(m, "\ndisconnects done:   ");
2161		for (x = 0; x < 7; x++)
2162			seq_printf(m, "\t%ld", hd->disc_done_cnt[x]);
2163		seq_printf(m,
2164			"\ninterrupts: %ld, DATA_PHASE ints: %ld DMA, %ld PIO",
2165			hd->int_cnt, hd->dma_cnt, hd->pio_cnt);
2166	}
2167#endif
2168	if (hd->proc & PR_CONNECTED) {
2169		seq_printf(m, "\nconnected:     ");
2170		if (hd->connected) {
2171			cmd = (struct scsi_cmnd *) hd->connected;
2172			seq_printf(m, " %d:%d(%02x)",
2173				cmd->device->id, cmd->device->lun, cmd->cmnd[0]);
2174		}
2175	}
2176	if (hd->proc & PR_INPUTQ) {
2177		seq_printf(m, "\ninput_Q:       ");
2178		cmd = (struct scsi_cmnd *) hd->input_Q;
2179		while (cmd) {
2180			seq_printf(m, " %d:%d(%02x)",
2181				cmd->device->id, cmd->device->lun, cmd->cmnd[0]);
2182			cmd = (struct scsi_cmnd *) cmd->host_scribble;
2183		}
2184	}
2185	if (hd->proc & PR_DISCQ) {
2186		seq_printf(m, "\ndisconnected_Q:");
2187		cmd = (struct scsi_cmnd *) hd->disconnected_Q;
2188		while (cmd) {
2189			seq_printf(m, " %d:%d(%02x)",
2190				cmd->device->id, cmd->device->lun, cmd->cmnd[0]);
2191			cmd = (struct scsi_cmnd *) cmd->host_scribble;
2192		}
2193	}
2194	seq_printf(m, "\n");
2195	spin_unlock_irq(&hd->lock);
2196#endif				/* PROC_INTERFACE */
2197	return 0;
2198}
2199
2200EXPORT_SYMBOL(wd33c93_host_reset);
2201EXPORT_SYMBOL(wd33c93_init);
2202EXPORT_SYMBOL(wd33c93_abort);
2203EXPORT_SYMBOL(wd33c93_queuecommand);
2204EXPORT_SYMBOL(wd33c93_intr);
2205EXPORT_SYMBOL(wd33c93_show_info);
2206EXPORT_SYMBOL(wd33c93_write_info);