version from Linus tree

2 files changed, 1822 insertions, 1720 deletions

diff --git a/drivers/scsi/wd33c93.c b/drivers/scsi/wd33c93.c
index 5fbd4ba71..851ca7639 100644
--- a/drivers/scsi/wd33c93.c
+++ b/drivers/scsi/wd33c93.c
@@ -55,20 +55,22 @@
  *          almost as fast while being much easier to define, track,
  *          and debug.
  *
+ *
  * TODO:
  *       more speed. linked commands.
  *
+ *
  * People with bug reports, wish-lists, complaints, comments,
  * or improvements are asked to pah-leeez email me (John Shifflett)
  * at john@geolog.com or jshiffle@netcom.com! I'm anxious to get
  * this thing into as good a shape as possible, and I'm positive
  * there are lots of lurking bugs and "Stupid Places".
+ *
  */
 
 #include <linux/module.h>
 
 #include <asm/system.h>
-#include <linux/config.h>
 #include <linux/sched.h>
 #include <linux/string.h>
 #include <linux/delay.h>
@@ -84,6 +86,7 @@
 #include "scsi.h"
 #include "hosts.h"
 
+
 #define WD33C93_VERSION    "1.25"
 #define WD33C93_DATE       "09/Jul/1997"
 /* NOTE: 1.25 for m68k is related to in2000-1.31 for x86 */
@@ -169,60 +172,68 @@ MODULE_PARM(setup_strings, "s");
 #endif
 
 
+
 static inline uchar read_wd33c93(wd33c93_regs *regp,uchar reg_num)
 {
-	regp->SASR = reg_num;
-	return regp->SCMD;
+   regp->SASR = reg_num;
+   return(regp->SCMD);
 }
 
+
 #define READ_AUX_STAT() (regp->SASR)
 
-static inline void write_wd33c93(wd33c93_regs *regp, uchar reg_num, uchar value)
+
+static inline void write_wd33c93(wd33c93_regs *regp,uchar reg_num, uchar value)
 {
-	regp->SASR = reg_num;
-	regp->SCMD = value;
+   regp->SASR = reg_num;
+   regp->SCMD = value;
 }
 
+
 static inline void write_wd33c93_cmd(wd33c93_regs *regp, uchar cmd)
 {
-	regp->SASR = WD_COMMAND;
-	regp->SCMD = cmd;
+   regp->SASR = WD_COMMAND;
+   regp->SCMD = cmd;
 }
 
+
 static inline uchar read_1_byte(wd33c93_regs *regp)
 {
-	uchar asr;
-	uchar x = 0;
-
-	write_wd33c93(regp, WD_CONTROL, (CTRL_IDI | CTRL_EDI | CTRL_POLLED));
-	write_wd33c93_cmd(regp, (WD_CMD_TRANS_INFO | 0x80));
-	do {
-		asr = READ_AUX_STAT();
-		if (asr & ASR_DBR)
-			x = read_wd33c93(regp, WD_DATA);
-	} while (!(asr & ASR_INT));
-	return x;
+uchar asr;
+uchar x = 0;
+
+   write_wd33c93(regp, WD_CONTROL, CTRL_IDI | CTRL_EDI | CTRL_POLLED);
+   write_wd33c93_cmd(regp, WD_CMD_TRANS_INFO|0x80);
+   do {
+      asr = READ_AUX_STAT();
+      if (asr & ASR_DBR)
+         x = read_wd33c93(regp, WD_DATA);
+      } while (!(asr & ASR_INT));
+   return x;
 }
 
-static inline void write_wd33c93_count(wd33c93_regs *regp, unsigned long value)
+
+static void write_wd33c93_count(wd33c93_regs *regp,unsigned long value)
 {
-	regp->SASR = WD_TRANSFER_COUNT_MSB;
-	regp->SCMD = ((value >> 16) & 0xff);
-	regp->SCMD = ((value >>  8) & 0xff);
-	regp->SCMD = ((value >>  0) & 0xff);
+   regp->SASR = WD_TRANSFER_COUNT_MSB;
+   regp->SCMD = value >> 16;
+   regp->SCMD = value >> 8;
+   regp->SCMD = value;
 }
 
-static inline unsigned long read_wd33c93_count(wd33c93_regs *regp)
+
+static unsigned long read_wd33c93_count(wd33c93_regs *regp)
 {
-	unsigned long value;
+unsigned long value;
 
-	regp->SASR = WD_TRANSFER_COUNT_MSB;
-	value =  ((regp->SCMD & 0xff) << 16);
-	value |= ((regp->SCMD & 0xff) <<  8);
-	value |= ((regp->SCMD & 0xff) <<  0);
-	return value;
+   regp->SASR = WD_TRANSFER_COUNT_MSB;
+   value = regp->SCMD << 16;
+   value |= regp->SCMD << 8;
+   value |= regp->SCMD;
+   return value;
 }
 
+
 /* The 33c93 needs to be told which direction a command transfers its
  * data; we use this function to figure it out. Returns true if there
  * will be a DATA_OUT phase with this command, false otherwise.
@@ -230,156 +241,167 @@ static inline unsigned long read_wd33c93_count(wd33c93_regs *regp)
  */
 static int is_dir_out(Scsi_Cmnd *cmd)
 {
-	switch (cmd->cmnd[0]) {
-		case WRITE_6:		case WRITE_10:		case WRITE_12:
-		case WRITE_LONG:	case WRITE_SAME:	case WRITE_BUFFER:
-		case WRITE_VERIFY:	case WRITE_VERIFY_12:      
-		case COMPARE:		case COPY:		case COPY_VERIFY:
-		case SEARCH_EQUAL:	case SEARCH_HIGH:	case SEARCH_LOW:
-		case SEARCH_EQUAL_12:	case SEARCH_HIGH_12:	case SEARCH_LOW_12:      
-		case FORMAT_UNIT:	case REASSIGN_BLOCKS:	case RESERVE:
-		case MODE_SELECT:	case MODE_SELECT_10:	case LOG_SELECT:
-		case SEND_DIAGNOSTIC:	case CHANGE_DEFINITION:	case UPDATE_BLOCK:
-		case SET_WINDOW:	case MEDIUM_SCAN:	case SEND_VOLUME_TAG:
-		case 0xea:
-			return 1;
-		default:
-			return 0;
+   switch (cmd->cmnd[0]) {
+      case WRITE_6:           case WRITE_10:          case WRITE_12:
+      case WRITE_LONG:        case WRITE_SAME:        case WRITE_BUFFER:
+      case WRITE_VERIFY:      case WRITE_VERIFY_12:      
+      case COMPARE:           case COPY:              case COPY_VERIFY:
+      case SEARCH_EQUAL:      case SEARCH_HIGH:       case SEARCH_LOW:
+      case SEARCH_EQUAL_12:   case SEARCH_HIGH_12:    case SEARCH_LOW_12:      
+      case FORMAT_UNIT:       case REASSIGN_BLOCKS:   case RESERVE:
+      case MODE_SELECT:       case MODE_SELECT_10:    case LOG_SELECT:
+      case SEND_DIAGNOSTIC:   case CHANGE_DEFINITION: case UPDATE_BLOCK:
+      case SET_WINDOW:        case MEDIUM_SCAN:       case SEND_VOLUME_TAG:
+      case 0xea:
+         return 1;
+      default:
+         return 0;
       }
 }
 
+
+
 static struct sx_period sx_table[] = {
-	{  1, 0x20},
-	{252, 0x20},
-	{376, 0x30},
-	{500, 0x40},
-	{624, 0x50},
-	{752, 0x60},
-	{876, 0x70},
-	{1000,0x00},
-	{0,   0}
-};
-
-static inline int round_period(unsigned int period)
+   {  1, 0x20},
+   {252, 0x20},
+   {376, 0x30},
+   {500, 0x40},
+   {624, 0x50},
+   {752, 0x60},
+   {876, 0x70},
+   {1000,0x00},
+   {0,   0} };
+
+static int round_period(unsigned int period)
 {
-	int x;
-
-	for (x = 1; sx_table[x].period_ns; x++) {
-		if ((period <= sx_table[x-0].period_ns) &&
-		    (period >  sx_table[x-1].period_ns)) {
-			return x;
-		}
-	}
-	return 7;
+int x;
+
+   for (x=1; sx_table[x].period_ns; x++) {
+      if ((period <= sx_table[x-0].period_ns) &&
+          (period >  sx_table[x-1].period_ns)) {
+         return x;
+         }
+      }
+   return 7;
 }
 
-static inline uchar calc_sync_xfer(unsigned int period, unsigned int offset)
+static uchar calc_sync_xfer(unsigned int period, unsigned int offset)
 {
-	uchar result;
+uchar result;
 
-	/* convert SDTR code to ns */
-	period *= 4;
-	result  = sx_table[round_period(period)].reg_value;
-	result |= (offset < OPTIMUM_SX_OFF) ? offset : OPTIMUM_SX_OFF;
-	return result;
+   period *= 4;   /* convert SDTR code to ns */
+   result = sx_table[round_period(period)].reg_value;
+   result |= (offset < OPTIMUM_SX_OFF)?offset:OPTIMUM_SX_OFF;
+   return result;
 }
 
+
+
 static void wd33c93_execute(struct Scsi_Host *instance);
 
 int wd33c93_queuecommand (Scsi_Cmnd *cmd, void (*done)(Scsi_Cmnd *))
 {
-	struct WD33C93_hostdata *hostdata = CMDHOSTDATA(cmd);
-	Scsi_Cmnd *tmp;
-	unsigned long flags;
-
-	disable_irq(cmd->host->irq);
-	DB(DB_QCMD,printk("Q-%d-%02x-%ld( ",cmd->target,cmd->cmnd[0],cmd->pid));
-
-	/* Set up a few fields in the Scsi_Cmnd structure for our own use:
-	 *  - host_scribble is the pointer to the next cmd in the input queue
-	 *  - scsi_done points to the routine we call when a cmd is finished
-	 *  - result is what you'd expect
-	 */
-	cmd->host_scribble = NULL;
-	cmd->scsi_done = done;
-	cmd->result = 0;
-
-	/* We use the Scsi_Pointer structure that's included with each command
-	 * as a scratchpad (as it's intended to be used!). The handy thing about
-	 * the SCp.xxx fields is that they're always associated with a given
-	 * cmd, and are preserved across disconnect-reselect. This means we
-	 * can pretty much ignore SAVE_POINTERS and RESTORE_POINTERS messages
-	 * if we keep all the critical pointers and counters in SCp:
-	 *  - SCp.ptr is the pointer into the RAM buffer
-	 *  - SCp.this_residual is the size of that buffer
-	 *  - SCp.buffer points to the current scatter-gather buffer
-	 *  - SCp.buffers_residual tells us how many S.G. buffers there are
-	 *  - SCp.have_data_in is not used
-	 *  - SCp.sent_command is not used
-	 *  - SCp.phase records this command's SRCID_ER bit setting
-	 */
-	if (cmd->use_sg) {
-		cmd->SCp.buffer = (struct scatterlist *) cmd->buffer;
-		cmd->SCp.buffers_residual = cmd->use_sg - 1;
-		cmd->SCp.ptr = (char *) cmd->SCp.buffer->address;
-		cmd->SCp.this_residual = cmd->SCp.buffer->length;
-	} else {
-		cmd->SCp.buffer = NULL;
-		cmd->SCp.buffers_residual = 0;
-		cmd->SCp.ptr = (char *) cmd->request_buffer;
-		cmd->SCp.this_residual = cmd->request_bufflen;
-	}
-
-	/* WD docs state that at the conclusion of a "LEVEL2" command, the
-	 * status byte can be retrieved from the LUN register. Apparently,
-	 * this is the case only for *uninterrupted* LEVEL2 commands! If
-	 * there are any unexpected phases entered, even if they are 100%
-	 * legal (different devices may choose to do things differently),
-	 * the LEVEL2 command sequence is exited. This often occurs prior
-	 * to receiving the status byte, in which case the driver does a
-	 * status phase interrupt and gets the status byte on its own.
-	 * While such a command can then be "resumed" (ie restarted to
-	 * finish up as a LEVEL2 command), the LUN register will NOT be
-	 * a valid status byte at the command's conclusion, and we must
-	 * use the byte obtained during the earlier interrupt. Here, we
-	 * preset SCp.Status to an illegal value (0xff) so that when
-	 * this command finally completes, we can tell where the actual
-	 * status byte is stored.
-	 */
-
-	cmd->SCp.Status = ILLEGAL_STATUS_BYTE;
-
-	/* Add the cmd to the end of 'input_Q'. Note that REQUEST SENSE
-	 * commands are added to the head of the queue so that the desired
-	 * sense data is not lost before REQUEST_SENSE executes.
-	 */
-
-	save_flags(flags);
-	cli();
-
-	if (!(hostdata->input_Q) || (cmd->cmnd[0] == REQUEST_SENSE)) {
-		cmd->host_scribble = (uchar *) hostdata->input_Q;
-		hostdata->input_Q = cmd;
-	} else {
-		/* find the end of the queue */
-		for (tmp = (Scsi_Cmnd *) hostdata->input_Q;
-		     tmp->host_scribble;
-		     tmp = (Scsi_Cmnd *) tmp->host_scribble)
-			;
-		tmp->host_scribble = (uchar *) cmd;
-	}
-
-	/* We know that there's at least one command in 'input_Q' now.
-	 * Go see if any of them are runnable!
-	 */
-	wd33c93_execute(cmd->host);
-
-	DB(DB_QCMD,printk(")Q-%ld ",cmd->pid));
-	restore_flags(flags);
-	return 0;
+   struct WD33C93_hostdata *hostdata;
+   Scsi_Cmnd *tmp;
+   unsigned long flags;
+
+   hostdata = (struct WD33C93_hostdata *)cmd->host->hostdata;
+
+DB(DB_QUEUE_COMMAND,printk("Q-%d-%02x-%ld( ",cmd->target,cmd->cmnd[0],cmd->pid))
+
+/* Set up a few fields in the Scsi_Cmnd structure for our own use:
+ *  - host_scribble is the pointer to the next cmd in the input queue
+ *  - scsi_done points to the routine we call when a cmd is finished
+ *  - result is what you'd expect
+ */
+
+   cmd->host_scribble = NULL;
+   cmd->scsi_done = done;
+   cmd->result = 0;
+
+/* We use the Scsi_Pointer structure that's included with each command
+ * as a scratchpad (as it's intended to be used!). The handy thing about
+ * the SCp.xxx fields is that they're always associated with a given
+ * cmd, and are preserved across disconnect-reselect. This means we
+ * can pretty much ignore SAVE_POINTERS and RESTORE_POINTERS messages
+ * if we keep all the critical pointers and counters in SCp:
+ *  - SCp.ptr is the pointer into the RAM buffer
+ *  - SCp.this_residual is the size of that buffer
+ *  - SCp.buffer points to the current scatter-gather buffer
+ *  - SCp.buffers_residual tells us how many S.G. buffers there are
+ *  - SCp.have_data_in is not used
+ *  - SCp.sent_command is not used
+ *  - SCp.phase records this command's SRCID_ER bit setting
+ */
+
+   if (cmd->use_sg) {
+      cmd->SCp.buffer = (struct scatterlist *)cmd->buffer;
+      cmd->SCp.buffers_residual = cmd->use_sg - 1;
+      cmd->SCp.ptr = (char *)cmd->SCp.buffer->address;
+      cmd->SCp.this_residual = cmd->SCp.buffer->length;
+      }
+   else {
+      cmd->SCp.buffer = NULL;
+      cmd->SCp.buffers_residual = 0;
+      cmd->SCp.ptr = (char *)cmd->request_buffer;
+      cmd->SCp.this_residual = cmd->request_bufflen;
+      }
+
+/* WD docs state that at the conclusion of a "LEVEL2" command, the
+ * status byte can be retrieved from the LUN register. Apparently,
+ * this is the case only for *uninterrupted* LEVEL2 commands! If
+ * there are any unexpected phases entered, even if they are 100%
+ * legal (different devices may choose to do things differently),
+ * the LEVEL2 command sequence is exited. This often occurs prior
+ * to receiving the status byte, in which case the driver does a
+ * status phase interrupt and gets the status byte on its own.
+ * While such a command can then be "resumed" (ie restarted to
+ * finish up as a LEVEL2 command), the LUN register will NOT be
+ * a valid status byte at the command's conclusion, and we must
+ * use the byte obtained during the earlier interrupt. Here, we
+ * preset SCp.Status to an illegal value (0xff) so that when
+ * this command finally completes, we can tell where the actual
+ * status byte is stored.
+ */
+
+   cmd->SCp.Status = ILLEGAL_STATUS_BYTE;
+
+   /*
+    * Add the cmd to the end of 'input_Q'. Note that REQUEST SENSE
+    * commands are added to the head of the queue so that the desired
+    * sense data is not lost before REQUEST_SENSE executes.
+    */
+
+   save_flags(flags);
+   cli();
+
+   if (!(hostdata->input_Q) || (cmd->cmnd[0] == REQUEST_SENSE)) {
+      cmd->host_scribble = (uchar *)hostdata->input_Q;
+      hostdata->input_Q = cmd;
+      }
+   else {   /* find the end of the queue */
+      for (tmp=(Scsi_Cmnd *)hostdata->input_Q; tmp->host_scribble;
+            tmp=(Scsi_Cmnd *)tmp->host_scribble)
+         ;
+      tmp->host_scribble = (uchar *)cmd;
+      }
+
+/* We know that there's at least one command in 'input_Q' now.
+ * Go see if any of them are runnable!
+ */
+
+   wd33c93_execute(cmd->host);
+
+DB(DB_QUEUE_COMMAND,printk(")Q-%ld ",cmd->pid))
+
+   restore_flags(flags);
+   return 0;
 }
 
-/* This routine attempts to start a scsi command. If the host_card is
+
+
+/*
+ * This routine attempts to start a scsi command. If the host_card is
  * already connected, we give up immediately. Otherwise, look through
  * the input_Q, using the first command we find that's intended
  * for a currently non-busy target/lun.
@@ -388,1107 +410,1172 @@ int wd33c93_queuecommand (Scsi_Cmnd *cmd, void (*done)(Scsi_Cmnd *))
  * the wd33c93_intr itself, which means that a wd33c93 interrupt
  * cannot occur while we are in here.
  */
-static void wd33c93_execute(struct Scsi_Host *instance)
+static void wd33c93_execute (struct Scsi_Host *instance)
 {
-	struct WD33C93_hostdata *hostdata = INSTHOSTDATA(instance);
-	wd33c93_regs *regp = hostdata->regp;
-	Scsi_Cmnd *cmd = (Scsi_Cmnd *) hostdata->input_Q;
-	Scsi_Cmnd *prev = 0;
-	int i;
-
-	DB(DB_EXECUTE, printk("EX("));
-
-	if (hostdata->selecting || hostdata->connected) {
-		DB(DB_EXECUTE, printk(")EX-0 "));
-		goto execute_out;
-	}
-
-	/* Search through the input_Q for a command destined
-	 * for an idle target/lun.
-	 */
-	while (cmd) {
-		if (!(hostdata->busy[cmd->target] & (1 << cmd->lun)))
-			break;
-		prev = cmd;
-		cmd =  (Scsi_Cmnd *) cmd->host_scribble;
-	}
-
-	/* Quit if queue empty or all possible targets are busy. */
-	if (!cmd) {
-		DB(DB_EXECUTE, printk(")EX-1 "));
-		goto execute_out;
-	}
-
-	/* Remove command from queue. */
-	if (prev)
-		prev->host_scribble = cmd->host_scribble;
-	else
-		hostdata->input_Q = (Scsi_Cmnd *) cmd->host_scribble;
+struct WD33C93_hostdata *hostdata;
+wd33c93_regs *regp;
+Scsi_Cmnd *cmd, *prev;
+int i;
+
+   hostdata = (struct WD33C93_hostdata *)instance->hostdata;
+   regp = hostdata->regp;
+
+DB(DB_EXECUTE,printk("EX("))
+
+   if (hostdata->selecting || hostdata->connected) {
+
+DB(DB_EXECUTE,printk(")EX-0 "))
+
+      return;
+      }
+
+    /*
+     * Search through the input_Q for a command destined
+     * for an idle target/lun.
+     */
+
+   cmd = (Scsi_Cmnd *)hostdata->input_Q;
+   prev = 0;
+   while (cmd) {
+      if (!(hostdata->busy[cmd->target] & (1 << cmd->lun)))
+         break;
+      prev = cmd;
+      cmd = (Scsi_Cmnd *)cmd->host_scribble;
+      }
+
+   /* quit if queue empty or all possible targets are busy */
+
+   if (!cmd) {
+
+DB(DB_EXECUTE,printk(")EX-1 "))
+
+      return;
+      }
+
+   /*  remove command from queue */
+   
+   if (prev)
+      prev->host_scribble = cmd->host_scribble;
+   else
+      hostdata->input_Q = (Scsi_Cmnd *)cmd->host_scribble;
 
 #ifdef PROC_STATISTICS
-	hostdata->cmd_cnt[cmd->target]++;
+   hostdata->cmd_cnt[cmd->target]++;
 #endif
 
-	/* Start the selection process. */
-	if (is_dir_out(cmd))
-		write_wd33c93(regp, WD_DESTINATION_ID, cmd->target);
-	else
-		write_wd33c93(regp, WD_DESTINATION_ID, (cmd->target | DSTID_DPD));
-
-	/* Now we need to figure out whether or not this command is a good
-	 * candidate for disconnect/reselect. We guess to the best of our
-	 * ability, based on a set of hierarchical rules. When several
-	 * devices are operating simultaneously, disconnects are usually
-	 * an advantage. In a single device system, or if only 1 device
-	 * is being accessed, transfers usually go faster if disconnects
-	 * are not allowed:
-	 *
-	 * + Commands should NEVER disconnect if hostdata->disconnect =
-	 *   DIS_NEVER (this holds for tape drives also), and ALWAYS
-	 *   disconnect if hostdata->disconnect = DIS_ALWAYS.
-	 * + Tape drive commands should always be allowed to disconnect.
-	 * + Disconnect should be allowed if disconnected_Q isn't empty.
-	 * + Commands should NOT disconnect if input_Q is empty.
-	 * + Disconnect should be allowed if there are commands in input_Q
-	 *   for a different target/lun. In this case, the other commands
-	 *   should be made disconnect-able, if not already.
-	 *
-	 * I know, I know - this code would flunk me out of any
-	 * "C Programming 101" class ever offered. But it's easy
-	 * to change around and experiment with for now.
-	 */
-	cmd->SCp.phase = 0;  /* assume no disconnect */
-	if (hostdata->disconnect == DIS_NEVER)
-		goto no;
-	if ((hostdata->disconnect == DIS_ALWAYS) || (cmd->device->type == 1) ||
-	    (hostdata->disconnected_Q))
-		goto yes;
-	if (!(hostdata->input_Q))     /* input_Q empty? */
-		goto no;
-	for (prev=(Scsi_Cmnd *)hostdata->input_Q; prev;
-	     prev=(Scsi_Cmnd *)prev->host_scribble) {
-		if ((prev->target != cmd->target) || (prev->lun != cmd->lun)) {
-			for (prev=(Scsi_Cmnd *)hostdata->input_Q; prev;
-			     prev=(Scsi_Cmnd *)prev->host_scribble)
-				prev->SCp.phase = 1;
-			goto yes;
-		}
-	}
-	goto no;
+   /*
+    * Start the selection process
+    */
+
+   if (is_dir_out(cmd))
+      write_wd33c93(regp, WD_DESTINATION_ID, cmd->target);
+   else
+      write_wd33c93(regp, WD_DESTINATION_ID, cmd->target | DSTID_DPD);
+
+/* Now we need to figure out whether or not this command is a good
+ * candidate for disconnect/reselect. We guess to the best of our
+ * ability, based on a set of hierarchical rules. When several
+ * devices are operating simultaneously, disconnects are usually
+ * an advantage. In a single device system, or if only 1 device
+ * is being accessed, transfers usually go faster if disconnects
+ * are not allowed:
+ *
+ * + Commands should NEVER disconnect if hostdata->disconnect =
+ *   DIS_NEVER (this holds for tape drives also), and ALWAYS
+ *   disconnect if hostdata->disconnect = DIS_ALWAYS.
+ * + Tape drive commands should always be allowed to disconnect.
+ * + Disconnect should be allowed if disconnected_Q isn't empty.
+ * + Commands should NOT disconnect if input_Q is empty.
+ * + Disconnect should be allowed if there are commands in input_Q
+ *   for a different target/lun. In this case, the other commands
+ *   should be made disconnect-able, if not already.
+ *
+ * I know, I know - this code would flunk me out of any
+ * "C Programming 101" class ever offered. But it's easy
+ * to change around and experiment with for now.
+ */
+
+   cmd->SCp.phase = 0;  /* assume no disconnect */
+   if (hostdata->disconnect == DIS_NEVER)
+      goto no;
+   if (hostdata->disconnect == DIS_ALWAYS)
+      goto yes;
+   if (cmd->device->type == 1)   /* tape drive? */
+      goto yes;
+   if (hostdata->disconnected_Q) /* other commands disconnected? */
+      goto yes;
+   if (!(hostdata->input_Q))     /* input_Q empty? */
+      goto no;
+   for (prev=(Scsi_Cmnd *)hostdata->input_Q; prev;
+         prev=(Scsi_Cmnd *)prev->host_scribble) {
+      if ((prev->target != cmd->target) || (prev->lun != cmd->lun)) {
+         for (prev=(Scsi_Cmnd *)hostdata->input_Q; prev;
+               prev=(Scsi_Cmnd *)prev->host_scribble)
+            prev->SCp.phase = 1;
+         goto yes;
+         }
+      }
+   goto no;
 
 yes:
-	cmd->SCp.phase = 1;
+   cmd->SCp.phase = 1;
 
 #ifdef PROC_STATISTICS
-	hostdata->disc_allowed_cnt[cmd->target]++;
+   hostdata->disc_allowed_cnt[cmd->target]++;
 #endif
 
 no:
-	write_wd33c93(regp, WD_SOURCE_ID, ((cmd->SCp.phase) ? SRCID_ER : 0));
-	write_wd33c93(regp, WD_TARGET_LUN, cmd->lun);
-	write_wd33c93(regp, WD_SYNCHRONOUS_TRANSFER,
-		      hostdata->sync_xfer[cmd->target]);
-
-	hostdata->busy[cmd->target] |= (1 << cmd->lun);
-	if ((hostdata->level2 == L2_NONE) ||
-	    (hostdata->sync_stat[cmd->target] == SS_UNSET)) {
-		/* Do a 'Select-With-ATN' command. This will end with
-		 * one of the following interrupts:
-		 *    CSR_RESEL_AM:  failure - can try again later.
-		 *    CSR_TIMEOUT:   failure - give up.
-		 *    CSR_SELECT:    success - proceed.
-		 */
-		hostdata->selecting = cmd;
-
-		/* Every target has its own synchronous transfer
-		 * setting, kept in the sync_xfer array, and a
-		 * corresponding status byte in sync_stat[].  Each
-		 * target's sync_stat[] entry is initialized to
-		 * SX_UNSET, and its sync_xfer[] entry is initialized
-		 * to the default/safe value. SS_UNSET means that the
-		 * parameters are undetermined as yet, and that we
-		 * need to send an SDTR message to this device after
-		 * selection is complete: We set SS_FIRST to tell the
-		 * interrupt routine to do so.  If we've been asked not to
-		 * try synchronous transfers on this target (and _all_ luns
-		 * within it), we'll still send the SDTR message later, but
-		 * at that time we'll negotiate for async by specifying a
-		 * sync fifo depth of 0.
-		 */
-
-		if (hostdata->sync_stat[cmd->target] == SS_UNSET)
-			hostdata->sync_stat[cmd->target] = SS_FIRST;
-		hostdata->state = S_SELECTING;
-
-		/* guarantee a DATA_PHASE interrupt */
-		write_wd33c93_count(regp, 0);
-		write_wd33c93_cmd(regp, WD_CMD_SEL_ATN);
-	} else {
-		/* Do a 'Select-With-ATN-Xfer' command. This will end with
-		 * one of the following interrupts:
-		 *    CSR_RESEL_AM:  failure - can try again later.
-		 *    CSR_TIMEOUT:   failure - give up.
-		 *    anything else: success - proceed.
-		 */
-		hostdata->connected = cmd;
-		write_wd33c93(regp, WD_COMMAND_PHASE, 0);
-
-		/* copy command_descriptor_block into WD chip
-		 * (take advantage of auto-incrementing)
-		 */
-		regp->SASR = WD_CDB_1;
-		for (i = 0; i < cmd->cmd_len; i++)
-			regp->SCMD = cmd->cmnd[i];
-
-		/* The wd33c93 only knows about Group 0, 1, and 5 commands when
-		 * it's doing a 'select-and-transfer'. To be safe, we write the
-		 * size of the CDB into the OWN_ID register for every case. This
-		 * way there won't be problems with vendor-unique, audio, etc.
-		 */
-		write_wd33c93(regp, WD_OWN_ID, cmd->cmd_len);
-
-		/* When doing a non-disconnect command with DMA, we can save
-		 * ourselves a DATA phase interrupt later by setting everything
-		 * up ahead of time.
-		 */
-		if ((cmd->SCp.phase == 0) && (hostdata->no_dma == 0)) {
-			if (hostdata->dma_setup(cmd, (is_dir_out(cmd)) ?
-						DATA_OUT_DIR : DATA_IN_DIR)) {
-				/* guarantee a DATA_PHASE interrupt */
-				write_wd33c93_count(regp, 0);
-			} else {
-				/* write_wd33c93_count(regp, cmd->SCp.this_residual); */
-				write_wd33c93(regp, WD_CONTROL,
-					      (CTRL_IDI | CTRL_EDI | CTRL_DMA));
-				hostdata->dma = D_DMA_RUNNING;
-			}
-		} else {
-			/* guarantee a DATA_PHASE interrupt */
-			write_wd33c93_count(regp, 0);
-		}
-
-		hostdata->state = S_RUNNING_LEVEL2;
-		write_wd33c93_cmd(regp, WD_CMD_SEL_ATN_XFER);
-	}
-
-	/* Since the SCSI bus can handle only 1 connection at a time,
-	 * we get out of here now. If the selection fails, or when
-	 * the command disconnects, we'll come back to this routine
-	 * to search the input_Q again...
-	 */
-	DB(DB_EXECUTE, printk("%s%ld)EX-2 ", (cmd->SCp.phase) ? "d:":"", cmd->pid));
-execute_out:
+
+   write_wd33c93(regp, WD_SOURCE_ID, ((cmd->SCp.phase)?SRCID_ER:0));
+
+   write_wd33c93(regp, WD_TARGET_LUN, cmd->lun);
+   write_wd33c93(regp,WD_SYNCHRONOUS_TRANSFER,hostdata->sync_xfer[cmd->target]);
+   hostdata->busy[cmd->target] |= (1 << cmd->lun);
+
+   if ((hostdata->level2 == L2_NONE) ||
+       (hostdata->sync_stat[cmd->target] == SS_UNSET)) {
+
+         /*
+          * Do a 'Select-With-ATN' command. This will end with
+          * one of the following interrupts:
+          *    CSR_RESEL_AM:  failure - can try again later.
+          *    CSR_TIMEOUT:   failure - give up.
+          *    CSR_SELECT:    success - proceed.
+          */
+
+      hostdata->selecting = cmd;
+
+/* Every target has its own synchronous transfer setting, kept in the
+ * sync_xfer array, and a corresponding status byte in sync_stat[].
+ * Each target's sync_stat[] entry is initialized to SX_UNSET, and its
+ * sync_xfer[] entry is initialized to the default/safe value. SS_UNSET
+ * means that the parameters are undetermined as yet, and that we
+ * need to send an SDTR message to this device after selection is
+ * complete: We set SS_FIRST to tell the interrupt routine to do so.
+ * If we've been asked not to try synchronous transfers on this
+ * target (and _all_ luns within it), we'll still send the SDTR message
+ * later, but at that time we'll negotiate for async by specifying a
+ * sync fifo depth of 0.
+ */
+      if (hostdata->sync_stat[cmd->target] == SS_UNSET)
+            hostdata->sync_stat[cmd->target] = SS_FIRST;
+      hostdata->state = S_SELECTING;
+      write_wd33c93_count(regp,0); /* guarantee a DATA_PHASE interrupt */
+      write_wd33c93_cmd(regp, WD_CMD_SEL_ATN);
+      }
+
+   else {
+
+         /*
+          * Do a 'Select-With-ATN-Xfer' command. This will end with
+          * one of the following interrupts:
+          *    CSR_RESEL_AM:  failure - can try again later.
+          *    CSR_TIMEOUT:   failure - give up.
+          *    anything else: success - proceed.
+          */
+
+      hostdata->connected = cmd;
+      write_wd33c93(regp, WD_COMMAND_PHASE, 0);
+
+   /* copy command_descriptor_block into WD chip
+    * (take advantage of auto-incrementing)
+    */
+
+      regp->SASR = WD_CDB_1;
+      for (i=0; i<cmd->cmd_len; i++)
+         regp->SCMD = cmd->cmnd[i];
+
+   /* The wd33c93 only knows about Group 0, 1, and 5 commands when
+    * it's doing a 'select-and-transfer'. To be safe, we write the
+    * size of the CDB into the OWN_ID register for every case. This
+    * way there won't be problems with vendor-unique, audio, etc.
+    */
+
+      write_wd33c93(regp, WD_OWN_ID, cmd->cmd_len);
+
+   /* When doing a non-disconnect command with DMA, we can save
+    * ourselves a DATA phase interrupt later by setting everything
+    * up ahead of time.
+    */
+
+      if ((cmd->SCp.phase == 0) && (hostdata->no_dma == 0)) {
+         if (hostdata->dma_setup(cmd,
+                     (is_dir_out(cmd))?DATA_OUT_DIR:DATA_IN_DIR))
+            write_wd33c93_count(regp,0); /* guarantee a DATA_PHASE interrupt */
+         else {
+            write_wd33c93(regp,WD_CONTROL, CTRL_IDI | CTRL_EDI | CTRL_DMA);
+            hostdata->dma = D_DMA_RUNNING;
+            }
+         }
+      else
+         write_wd33c93_count(regp,0); /* guarantee a DATA_PHASE interrupt */
+
+      hostdata->state = S_RUNNING_LEVEL2;
+      write_wd33c93_cmd(regp, WD_CMD_SEL_ATN_XFER);
+      }
+
+   /*
+    * Since the SCSI bus can handle only 1 connection at a time,
+    * we get out of here now. If the selection fails, or when
+    * the command disconnects, we'll come back to this routine
+    * to search the input_Q again...
+    */
+      
+DB(DB_EXECUTE,printk("%s%ld)EX-2 ",(cmd->SCp.phase)?"d:":"",cmd->pid))
 }
 
+
+
 static void transfer_pio(wd33c93_regs *regp, uchar *buf, int cnt,
-                         int data_in_dir, struct WD33C93_hostdata *hostdata)
+                  int data_in_dir, struct WD33C93_hostdata *hostdata)
 {
-	uchar asr;
-
-	DB(DB_TRANSFER,printk("(%p,%d,%s:",buf,cnt,data_in_dir?"in":"out"));
-	write_wd33c93(regp, WD_CONTROL, (CTRL_IDI | CTRL_EDI | CTRL_POLLED));
-	write_wd33c93_count(regp, cnt);
-	write_wd33c93_cmd(regp, WD_CMD_TRANS_INFO);
-	if (data_in_dir) {
-		do {
-			asr = READ_AUX_STAT();
-			if (asr & ASR_DBR)
-				*buf++ = read_wd33c93(regp, WD_DATA);
-		} while (!(asr & ASR_INT));
-	} else {
-		do {
-			asr = READ_AUX_STAT();
-			if (asr & ASR_DBR)
-				write_wd33c93(regp, WD_DATA, *buf++);
-		} while (!(asr & ASR_INT));
-	}
-	/* Note: we are returning with the interrupt UN-cleared.
-	 * Since (presumably) an entire I/O operation has
-	 * completed, the bus phase is probably different, and
-	 * the interrupt routine will discover this when it
-	 * responds to the uncleared int.
-	 */
+uchar asr;
+
+DB(DB_TRANSFER,printk("(%p,%d,%s:",buf,cnt,data_in_dir?"in":"out"))
+
+   write_wd33c93(regp, WD_CONTROL, CTRL_IDI | CTRL_EDI | CTRL_POLLED);
+   write_wd33c93_count(regp,cnt);
+   write_wd33c93_cmd(regp, WD_CMD_TRANS_INFO);
+   if (data_in_dir) {
+      do {
+         asr = READ_AUX_STAT();
+         if (asr & ASR_DBR)
+            *buf++ = read_wd33c93(regp, WD_DATA);
+         } while (!(asr & ASR_INT));
+      }
+   else {
+      do {
+         asr = READ_AUX_STAT();
+         if (asr & ASR_DBR)
+            write_wd33c93(regp, WD_DATA, *buf++);
+         } while (!(asr & ASR_INT));
+      }
+
+   /* Note: we are returning with the interrupt UN-cleared.
+   * Since (presumably) an entire I/O operation has
+   * completed, the bus phase is probably different, and
+   * the interrupt routine will discover this when it
+   * responds to the uncleared int.
+   */
+
 }
 
+
+
 static void transfer_bytes(wd33c93_regs *regp, Scsi_Cmnd *cmd, int data_in_dir)
 {
-	struct WD33C93_hostdata *hostdata = CMDHOSTDATA(cmd);
-	unsigned long length;
-
-	/* Normally, you'd expect 'this_residual' to be non-zero here.
-	 * In a series of scatter-gather transfers, however, this
-	 * routine will usually be called with 'this_residual' equal
-	 * to 0 and 'buffers_residual' non-zero. This means that a
-	 * previous transfer completed, clearing 'this_residual', and
-	 * now we need to setup the next scatter-gather buffer as the
-	 * source or destination for THIS transfer.
-	 */
-	if (!cmd->SCp.this_residual && cmd->SCp.buffers_residual) {
-		++cmd->SCp.buffer;
-		--cmd->SCp.buffers_residual;
-		cmd->SCp.this_residual = cmd->SCp.buffer->length;
-		cmd->SCp.ptr = cmd->SCp.buffer->address;
-	}
-
-	write_wd33c93(regp, WD_SYNCHRONOUS_TRANSFER,
-		      hostdata->sync_xfer[cmd->target]);
-
-	/* 'hostdata->no_dma' is TRUE if we don't even want to try DMA.
-	 * Update 'this_residual' and 'ptr' after 'transfer_pio()' returns.
-	 */
-	if (hostdata->no_dma)
-		goto use_transfer_pio;
-
-	/* 'dma_setup()' will return TRUE if we can't do DMA.
-	 * Update 'this_residual' and 'ptr' after 'transfer_pio()' returns.
-	 */
-
-	else if (hostdata->dma_setup(cmd, data_in_dir)) {
+struct WD33C93_hostdata *hostdata;
+unsigned long length;
+
+   hostdata = (struct WD33C93_hostdata *)cmd->host->hostdata;
+
+/* Normally, you'd expect 'this_residual' to be non-zero here.
+ * In a series of scatter-gather transfers, however, this
+ * routine will usually be called with 'this_residual' equal
+ * to 0 and 'buffers_residual' non-zero. This means that a
+ * previous transfer completed, clearing 'this_residual', and
+ * now we need to setup the next scatter-gather buffer as the
+ * source or destination for THIS transfer.
+ */
+   if (!cmd->SCp.this_residual && cmd->SCp.buffers_residual) {
+      ++cmd->SCp.buffer;
+      --cmd->SCp.buffers_residual;
+      cmd->SCp.this_residual = cmd->SCp.buffer->length;
+      cmd->SCp.ptr = cmd->SCp.buffer->address;
+      }
+
+   write_wd33c93(regp,WD_SYNCHRONOUS_TRANSFER,hostdata->sync_xfer[cmd->target]);
+
+/* 'hostdata->no_dma' is TRUE if we don't even want to try DMA.
+ * Update 'this_residual' and 'ptr' after 'transfer_pio()' returns.
+ */
+
+   if (hostdata->no_dma)
+      goto use_transfer_pio;
+
+/* 'dma_setup()' will return TRUE if we can't do DMA.
+ * Update 'this_residual' and 'ptr' after 'transfer_pio()' returns.
+ */
+
+   else if (hostdata->dma_setup(cmd, data_in_dir)) {
 use_transfer_pio:
 #ifdef PROC_STATISTICS
-		hostdata->pio_cnt++;
+      hostdata->pio_cnt++;
 #endif
-		transfer_pio(regp, (uchar *)cmd->SCp.ptr,
-		             cmd->SCp.this_residual, data_in_dir, hostdata);
-		length = cmd->SCp.this_residual;
-		cmd->SCp.this_residual = read_wd33c93_count(regp);
-		cmd->SCp.ptr += (length - cmd->SCp.this_residual);
-	} else {
-		/* We are able to do DMA (in fact, the Amiga hardware is
-		 * already going!), so start up the wd33c93 in DMA mode.
-		 * We set 'hostdata->dma' = D_DMA_RUNNING so that when the
-		 * transfer completes and causes an interrupt, we're
-		 * reminded to tell the Amiga to shut down its end. We'll
-		 * postpone the updating of 'this_residual' and 'ptr'
-		 * until then.
-		 */
+      transfer_pio(regp, (uchar *)cmd->SCp.ptr, cmd->SCp.this_residual,
+                         data_in_dir, hostdata);
+      length = cmd->SCp.this_residual;
+      cmd->SCp.this_residual = read_wd33c93_count(regp);
+      cmd->SCp.ptr += (length - cmd->SCp.this_residual);
+      }
+
+/* We are able to do DMA (in fact, the Amiga hardware is
+ * already going!), so start up the wd33c93 in DMA mode.
+ * We set 'hostdata->dma' = D_DMA_RUNNING so that when the
+ * transfer completes and causes an interrupt, we're
+ * reminded to tell the Amiga to shut down its end. We'll
+ * postpone the updating of 'this_residual' and 'ptr'
+ * until then.
+ */
+
+   else {
 #ifdef PROC_STATISTICS
-		hostdata->dma_cnt++;
+      hostdata->dma_cnt++;
 #endif
-		write_wd33c93(regp, WD_CONTROL, (CTRL_IDI | CTRL_EDI | CTRL_DMA));
-		/* write_wd33c93_count(regp, cmd->SCp.this_residual); */
-
-		if ((hostdata->level2 >= L2_DATA) ||
-		    (hostdata->level2 == L2_BASIC && cmd->SCp.phase == 0)) {
-			write_wd33c93(regp, WD_COMMAND_PHASE, 0x45);
-			write_wd33c93_cmd(regp, WD_CMD_SEL_ATN_XFER);
-			hostdata->state = S_RUNNING_LEVEL2;
-		} else {
-			write_wd33c93_cmd(regp, WD_CMD_TRANS_INFO);
-		}
-		hostdata->dma = D_DMA_RUNNING;
-	}
+      write_wd33c93(regp, WD_CONTROL, CTRL_IDI | CTRL_EDI | CTRL_DMA);
+
+      if ((hostdata->level2 >= L2_DATA) ||
+          (hostdata->level2 == L2_BASIC && cmd->SCp.phase == 0)) {
+         write_wd33c93(regp, WD_COMMAND_PHASE, 0x45);
+         write_wd33c93_cmd(regp, WD_CMD_SEL_ATN_XFER);
+         hostdata->state = S_RUNNING_LEVEL2;
+         }
+      else
+         write_wd33c93_cmd(regp, WD_CMD_TRANS_INFO);
+
+      hostdata->dma = D_DMA_RUNNING;
+      }
 }
 
-#ifdef CONFIG_SGI
-#define NOINTS_IN_WDINTR
-#endif
+
 
 void wd33c93_intr (struct Scsi_Host *instance)
 {
-	struct WD33C93_hostdata *hostdata = INSTHOSTDATA(instance);
-	wd33c93_regs *regp = hostdata->regp;
-	Scsi_Cmnd *patch, *cmd;
-	uchar asr, sr, phs, id, lun, *ucp, msg;
-	unsigned long length, flags;
+struct WD33C93_hostdata *hostdata;
+Scsi_Cmnd *patch, *cmd;
+wd33c93_regs *regp;
+uchar asr, sr, phs, id, lun, *ucp, msg;
+unsigned long length, flags;
 
-	asr = READ_AUX_STAT();
-	if (!(asr & ASR_INT) || (asr & ASR_BSY))
-		return;
+   hostdata = (struct WD33C93_hostdata *)instance->hostdata;
+   regp = hostdata->regp;
 
-	save_flags(flags);
+   asr = READ_AUX_STAT();
+   if (!(asr & ASR_INT) || (asr & ASR_BSY))
+      return;
+
+   save_flags(flags);
 
 #ifdef PROC_STATISTICS
-	hostdata->int_cnt++;
+   hostdata->int_cnt++;
 #endif
 
-	cmd = (Scsi_Cmnd *) hostdata->connected;   /* assume we're connected */
-	sr = read_wd33c93(regp, WD_SCSI_STATUS);  /* clear the interrupt */
-	phs = read_wd33c93(regp, WD_COMMAND_PHASE);
-	DB(DB_INTR,printk("{%02x:%02x-", asr, sr));
-
-	/* After starting a DMA transfer, the next interrupt
-	 * is guaranteed to be in response to completion of
-	 * the transfer. Since the Amiga DMA hardware runs in
-	 * in an open-ended fashion, it needs to be told when
-	 * to stop; do that here if D_DMA_RUNNING is true.
-	 * Also, we have to update 'this_residual' and 'ptr'
-	 * based on the contents of the TRANSFER_COUNT register,
-	 * in case the device decided to do an intermediate
-	 * disconnect (a device may do this if it has to do a
-	 * seek, or just to be nice and let other devices have
-	 * some bus time during long transfers). After doing
-	 * whatever is needed, we go on and service the WD3393
-	 * interrupt normally.
-	 */
-	if (hostdata->dma == D_DMA_RUNNING) {
-		DB(DB_TRANSFER,printk("[%p/%d:",cmd->SCp.ptr,cmd->SCp.this_residual));
-		hostdata->dma_stop(cmd->host, cmd, 1);
-		hostdata->dma = D_DMA_OFF;
-		length = cmd->SCp.this_residual;
-		cmd->SCp.this_residual = read_wd33c93_count(regp);
-		cmd->SCp.ptr += (length - cmd->SCp.this_residual);
-		DB(DB_TRANSFER,printk("%p/%d]",cmd->SCp.ptr,cmd->SCp.this_residual));
-	}
-
-	/* Respond to the specific WD3393 interrupt - there are quite a few! */
-	switch (sr) {
-	case CSR_TIMEOUT:
-		DB(DB_INTR, printk("TIMEOUT"));
-
-		if (hostdata->state == S_RUNNING_LEVEL2) {
-			hostdata->connected = NULL;
-		} else {
-			/* get a valid cmd */
-			cmd = (Scsi_Cmnd *) hostdata->selecting;
-			hostdata->selecting = NULL;
-		}
-		cmd->result = (DID_NO_CONNECT << 16);
-		hostdata->busy[cmd->target] &= ~(1 << cmd->lun);
-		hostdata->state = S_UNCONNECTED;
-		cmd->scsi_done(cmd);
-
-		/* From esp.c:
-		 * There is a window of time within the scsi_done() path
-		 * of execution where interrupts are turned back on full
-		 * blast and left that way.  During that time we could
-		 * reconnect to a disconnected command, then we'd bomb
-		 * out below.  We could also end up executing two commands
-		 * at _once_.  ...just so you know why the restore_flags()
-		 * is here...
-		 */
-		restore_flags(flags);
-
-		/* We are not connected to a target - check to see if there
-		 * are commands waiting to be executed.
-		 */
-		wd33c93_execute(instance);
-		break;
-
-	case CSR_SELECT:
-		/* Note: this interrupt should not occur in a LEVEL2 command */
-		DB(DB_INTR, printk("SELECT"));
-		hostdata->connected = cmd = (Scsi_Cmnd *) hostdata->selecting;
-		hostdata->selecting = NULL;
-
-		/* construct an IDENTIFY message with correct disconnect bit */
-		hostdata->outgoing_msg[0] = (0x80 | 0x00 | cmd->lun);
-		if (cmd->SCp.phase)
-			hostdata->outgoing_msg[0] |= 0x40;
-		if (hostdata->sync_stat[cmd->target] == SS_FIRST) {
+   cmd = (Scsi_Cmnd *)hostdata->connected;   /* assume we're connected */
+   sr = read_wd33c93(regp, WD_SCSI_STATUS);  /* clear the interrupt */
+   phs = read_wd33c93(regp, WD_COMMAND_PHASE);
+
+DB(DB_INTR,printk("{%02x:%02x-",asr,sr))
+
+/* After starting a DMA transfer, the next interrupt
+ * is guaranteed to be in response to completion of
+ * the transfer. Since the Amiga DMA hardware runs in
+ * in an open-ended fashion, it needs to be told when
+ * to stop; do that here if D_DMA_RUNNING is true.
+ * Also, we have to update 'this_residual' and 'ptr'
+ * based on the contents of the TRANSFER_COUNT register,
+ * in case the device decided to do an intermediate
+ * disconnect (a device may do this if it has to do a
+ * seek, or just to be nice and let other devices have
+ * some bus time during long transfers). After doing
+ * whatever is needed, we go on and service the WD3393
+ * interrupt normally.
+ */
+
+   if (hostdata->dma == D_DMA_RUNNING) {
+DB(DB_TRANSFER,printk("[%p/%d:",cmd->SCp.ptr,cmd->SCp.this_residual))
+      hostdata->dma_stop(cmd->host, cmd, 1);
+      hostdata->dma = D_DMA_OFF;
+      length = cmd->SCp.this_residual;
+      cmd->SCp.this_residual = read_wd33c93_count(regp);
+      cmd->SCp.ptr += (length - cmd->SCp.this_residual);
+DB(DB_TRANSFER,printk("%p/%d]",cmd->SCp.ptr,cmd->SCp.this_residual))
+      }
+
+/* Respond to the specific WD3393 interrupt - there are quite a few! */
+
+   switch (sr) {
+
+      case CSR_TIMEOUT:
+DB(DB_INTR,printk("TIMEOUT"))
+
+         if (hostdata->state == S_RUNNING_LEVEL2)
+            hostdata->connected = NULL;
+         else {
+            cmd = (Scsi_Cmnd *)hostdata->selecting;   /* get a valid cmd */
+            hostdata->selecting = NULL;
+            }
+
+         cmd->result = DID_NO_CONNECT << 16;
+         hostdata->busy[cmd->target] &= ~(1 << cmd->lun);
+         hostdata->state = S_UNCONNECTED;
+         cmd->scsi_done(cmd);
+
+    /* From esp.c:
+     * There is a window of time within the scsi_done() path
+     * of execution where interrupts are turned back on full
+     * blast and left that way.  During that time we could
+     * reconnect to a disconnected command, then we'd bomb
+     * out below.  We could also end up executing two commands
+     * at _once_.  ...just so you know why the restore_flags()
+     * is here...
+     */
+
+    restore_flags(flags);
+
+/* We are not connected to a target - check to see if there
+ * are commands waiting to be executed.
+ */
+
+         wd33c93_execute(instance);
+         break;
+
+
+/* Note: this interrupt should not occur in a LEVEL2 command */
+
+      case CSR_SELECT:
+
+DB(DB_INTR,printk("SELECT"))
+         hostdata->connected = cmd = (Scsi_Cmnd *)hostdata->selecting;
+         hostdata->selecting = NULL;
+
+      /* construct an IDENTIFY message with correct disconnect bit */
+
+         hostdata->outgoing_msg[0] = (0x80 | 0x00 | cmd->lun);
+         if (cmd->SCp.phase)
+            hostdata->outgoing_msg[0] |= 0x40;
+
+         if (hostdata->sync_stat[cmd->target] == SS_FIRST) {
 #ifdef SYNC_DEBUG
-			printk(" sending SDTR ");
+printk(" sending SDTR ");
 #endif
-			hostdata->sync_stat[cmd->target] = SS_WAITING;
-
-			/* Tack on a 2nd message to ask about synchronous
-			   transfers. If we've been asked to do only
-			   asynchronous transfers on this device, we request a
-			   fifo depth of 0, which is equivalent to async -
-			   should solve the problems some people have had with
-			   GVP's Guru ROM.  */
-
-			hostdata->outgoing_msg[1] = EXTENDED_MESSAGE;
-			hostdata->outgoing_msg[2] = 3;
-			hostdata->outgoing_msg[3] = EXTENDED_SDTR;
-			if (hostdata->no_sync & (1 << cmd->target)) {
-				hostdata->outgoing_msg[4] = hostdata->default_sx_per/4;
-				hostdata->outgoing_msg[5] = 0;
-			}
-			else {
-				hostdata->outgoing_msg[4] = OPTIMUM_SX_PER/4;
-				hostdata->outgoing_msg[5] = OPTIMUM_SX_OFF;
-			}
-			hostdata->outgoing_len = 6;
-		} else {
-			hostdata->outgoing_len = 1;
-		}
-		hostdata->state = S_CONNECTED;
-		break;
-
-	case CSR_XFER_DONE|PHS_DATA_IN:
-	case CSR_UNEXP    |PHS_DATA_IN:
-	case CSR_SRV_REQ  |PHS_DATA_IN:
-		DB(DB_INTR,printk("IN-%d.%d",cmd->SCp.this_residual,cmd->SCp.buffers_residual));
-		transfer_bytes(regp, cmd, DATA_IN_DIR);
-		if (hostdata->state != S_RUNNING_LEVEL2)
-			hostdata->state = S_CONNECTED;
-		break;
-
-	case CSR_XFER_DONE|PHS_DATA_OUT:
-	case CSR_UNEXP    |PHS_DATA_OUT:
-	case CSR_SRV_REQ  |PHS_DATA_OUT:
-		DB(DB_INTR,printk("OUT-%d.%d",cmd->SCp.this_residual,cmd->SCp.buffers_residual));
-		transfer_bytes(regp, cmd, DATA_OUT_DIR);
-		if (hostdata->state != S_RUNNING_LEVEL2)
-			hostdata->state = S_CONNECTED;
-		break;
-
-	case CSR_XFER_DONE|PHS_COMMAND:
-	case CSR_UNEXP    |PHS_COMMAND:
-	case CSR_SRV_REQ  |PHS_COMMAND:
-		/* Note: this interrupt should not occur in a LEVEL2 command */
-		DB(DB_INTR,printk("CMND-%02x,%ld", cmd->cmnd[0], cmd->pid));
-		transfer_pio(regp, cmd->cmnd, cmd->cmd_len, DATA_OUT_DIR, hostdata);
-		hostdata->state = S_CONNECTED;
-		break;
-
-	case CSR_XFER_DONE|PHS_STATUS:
-	case CSR_UNEXP    |PHS_STATUS:
-	case CSR_SRV_REQ  |PHS_STATUS:
-		DB(DB_INTR,printk("STATUS="));
-
-		cmd->SCp.Status = read_1_byte(regp);
-		DB(DB_INTR,printk("%02x",cmd->SCp.Status));
-		if (hostdata->level2 >= L2_BASIC) {
-			/* clear interrupt */
-			sr = read_wd33c93(regp, WD_SCSI_STATUS);
-			hostdata->state = S_RUNNING_LEVEL2;
-			write_wd33c93(regp, WD_COMMAND_PHASE, 0x50);
-			write_wd33c93_cmd(regp, WD_CMD_SEL_ATN_XFER);
-		} else {
-			hostdata->state = S_CONNECTED;
-		}
-		break;
-
-	case CSR_XFER_DONE|PHS_MESS_IN:
-	case CSR_UNEXP    |PHS_MESS_IN:
-	case CSR_SRV_REQ  |PHS_MESS_IN:
-		DB(DB_INTR, printk("MSG_IN="));
-
-		msg = read_1_byte(regp);
-		sr = read_wd33c93(regp, WD_SCSI_STATUS); /* clear interrupt */
-
-		hostdata->incoming_msg[hostdata->incoming_ptr] = msg;
-		if (hostdata->incoming_msg[0] == EXTENDED_MESSAGE)
-			msg = EXTENDED_MESSAGE;
-		else
-			hostdata->incoming_ptr = 0;
-
-		cmd->SCp.Message = msg;
-		switch (msg) {
-		case COMMAND_COMPLETE:
-			DB(DB_INTR,printk("CCMP-%ld", cmd->pid));
-			write_wd33c93_cmd(regp, WD_CMD_NEGATE_ACK);
-			hostdata->state = S_PRE_CMP_DISC;
-			break;
-
-		case SAVE_POINTERS:
-			DB(DB_INTR,printk("SDP"));
-			write_wd33c93_cmd(regp, WD_CMD_NEGATE_ACK);
-			hostdata->state = S_CONNECTED;
-			break;
-
-		case RESTORE_POINTERS:
-			DB(DB_INTR,printk("RDP"));
-			if (hostdata->level2 >= L2_BASIC) {
-				write_wd33c93(regp, WD_COMMAND_PHASE, 0x45);
-				write_wd33c93_cmd(regp, WD_CMD_SEL_ATN_XFER);
-				hostdata->state = S_RUNNING_LEVEL2;
-			} else {
-				write_wd33c93_cmd(regp, WD_CMD_NEGATE_ACK);
-				hostdata->state = S_CONNECTED;
-			}
-			break;
-
-		case DISCONNECT:
-			DB(DB_INTR,printk("DIS"));
-			cmd->device->disconnect = 1;
-			write_wd33c93_cmd(regp, WD_CMD_NEGATE_ACK);
-			hostdata->state = S_PRE_TMP_DISC;
-			break;
-
-		case MESSAGE_REJECT:
-			DB(DB_INTR,printk("REJ"));
+
+            hostdata->sync_stat[cmd->target] = SS_WAITING;
+
+/* Tack on a 2nd message to ask about synchronous transfers. If we've
+ * been asked to do only asynchronous transfers on this device, we
+ * request a fifo depth of 0, which is equivalent to async - should
+ * solve the problems some people have had with GVP's Guru ROM.
+ */
+
+            hostdata->outgoing_msg[1] = EXTENDED_MESSAGE;
+            hostdata->outgoing_msg[2] = 3;
+            hostdata->outgoing_msg[3] = EXTENDED_SDTR;
+            if (hostdata->no_sync & (1 << cmd->target)) {
+               hostdata->outgoing_msg[4] = hostdata->default_sx_per/4;
+               hostdata->outgoing_msg[5] = 0;
+               }
+            else {
+            hostdata->outgoing_msg[4] = OPTIMUM_SX_PER/4;
+            hostdata->outgoing_msg[5] = OPTIMUM_SX_OFF;
+               }
+            hostdata->outgoing_len = 6;
+            }
+         else
+            hostdata->outgoing_len = 1;
+
+         hostdata->state = S_CONNECTED;
+         break;
+
+
+      case CSR_XFER_DONE|PHS_DATA_IN:
+      case CSR_UNEXP    |PHS_DATA_IN:
+      case CSR_SRV_REQ  |PHS_DATA_IN:
+DB(DB_INTR,printk("IN-%d.%d",cmd->SCp.this_residual,cmd->SCp.buffers_residual))
+         transfer_bytes(regp, cmd, DATA_IN_DIR);
+         if (hostdata->state != S_RUNNING_LEVEL2)
+            hostdata->state = S_CONNECTED;
+         break;
+
+
+      case CSR_XFER_DONE|PHS_DATA_OUT:
+      case CSR_UNEXP    |PHS_DATA_OUT:
+      case CSR_SRV_REQ  |PHS_DATA_OUT:
+DB(DB_INTR,printk("OUT-%d.%d",cmd->SCp.this_residual,cmd->SCp.buffers_residual))
+         transfer_bytes(regp, cmd, DATA_OUT_DIR);
+         if (hostdata->state != S_RUNNING_LEVEL2)
+            hostdata->state = S_CONNECTED;
+         break;
+
+
+/* Note: this interrupt should not occur in a LEVEL2 command */
+
+      case CSR_XFER_DONE|PHS_COMMAND:
+      case CSR_UNEXP    |PHS_COMMAND:
+      case CSR_SRV_REQ  |PHS_COMMAND:
+DB(DB_INTR,printk("CMND-%02x,%ld",cmd->cmnd[0],cmd->pid))
+         transfer_pio(regp, cmd->cmnd, cmd->cmd_len, DATA_OUT_DIR, hostdata);
+         hostdata->state = S_CONNECTED;
+         break;
+
+
+      case CSR_XFER_DONE|PHS_STATUS:
+      case CSR_UNEXP    |PHS_STATUS:
+      case CSR_SRV_REQ  |PHS_STATUS:
+DB(DB_INTR,printk("STATUS="))
+
+         cmd->SCp.Status = read_1_byte(regp);
+DB(DB_INTR,printk("%02x",cmd->SCp.Status))
+         if (hostdata->level2 >= L2_BASIC) {
+            sr = read_wd33c93(regp, WD_SCSI_STATUS);  /* clear interrupt */
+            hostdata->state = S_RUNNING_LEVEL2;
+            write_wd33c93(regp, WD_COMMAND_PHASE, 0x50);
+            write_wd33c93_cmd(regp, WD_CMD_SEL_ATN_XFER);
+            }
+         else {
+            hostdata->state = S_CONNECTED;
+            }
+         break;
+
+
+      case CSR_XFER_DONE|PHS_MESS_IN:
+      case CSR_UNEXP    |PHS_MESS_IN:
+      case CSR_SRV_REQ  |PHS_MESS_IN:
+DB(DB_INTR,printk("MSG_IN="))
+
+         msg = read_1_byte(regp);
+         sr = read_wd33c93(regp, WD_SCSI_STATUS);  /* clear interrupt */
+
+         hostdata->incoming_msg[hostdata->incoming_ptr] = msg;
+         if (hostdata->incoming_msg[0] == EXTENDED_MESSAGE)
+            msg = EXTENDED_MESSAGE;
+         else
+            hostdata->incoming_ptr = 0;
+
+         cmd->SCp.Message = msg;
+         switch (msg) {
+
+            case COMMAND_COMPLETE:
+DB(DB_INTR,printk("CCMP-%ld",cmd->pid))
+               write_wd33c93_cmd(regp,WD_CMD_NEGATE_ACK);
+               hostdata->state = S_PRE_CMP_DISC;
+               break;
+
+            case SAVE_POINTERS:
+DB(DB_INTR,printk("SDP"))
+               write_wd33c93_cmd(regp,WD_CMD_NEGATE_ACK);
+               hostdata->state = S_CONNECTED;
+               break;
+
+            case RESTORE_POINTERS:
+DB(DB_INTR,printk("RDP"))
+               if (hostdata->level2 >= L2_BASIC) {
+                  write_wd33c93(regp, WD_COMMAND_PHASE, 0x45);
+                  write_wd33c93_cmd(regp, WD_CMD_SEL_ATN_XFER);
+                  hostdata->state = S_RUNNING_LEVEL2;
+                  }
+               else {
+                  write_wd33c93_cmd(regp, WD_CMD_NEGATE_ACK);
+                  hostdata->state = S_CONNECTED;
+                  }
+               break;
+
+            case DISCONNECT:
+DB(DB_INTR,printk("DIS"))
+               cmd->device->disconnect = 1;
+               write_wd33c93_cmd(regp,WD_CMD_NEGATE_ACK);
+               hostdata->state = S_PRE_TMP_DISC;
+               break;
+
+            case MESSAGE_REJECT:
+DB(DB_INTR,printk("REJ"))
 #ifdef SYNC_DEBUG
-			printk("-REJ-");
+printk("-REJ-");
 #endif
-			if (hostdata->sync_stat[cmd->target] == SS_WAITING)
-				hostdata->sync_stat[cmd->target] = SS_SET;
-			write_wd33c93_cmd(regp, WD_CMD_NEGATE_ACK);
-			hostdata->state = S_CONNECTED;
-			break;
-
-		case EXTENDED_MESSAGE:
-			DB(DB_INTR,printk("EXT"));
-			ucp = hostdata->incoming_msg;
+               if (hostdata->sync_stat[cmd->target] == SS_WAITING)
+                  hostdata->sync_stat[cmd->target] = SS_SET;
+               write_wd33c93_cmd(regp,WD_CMD_NEGATE_ACK);
+               hostdata->state = S_CONNECTED;
+               break;
+
+            case EXTENDED_MESSAGE:
+DB(DB_INTR,printk("EXT"))
+
+               ucp = hostdata->incoming_msg;
+
 #ifdef SYNC_DEBUG
-			printk("%02x",ucp[hostdata->incoming_ptr]);
+printk("%02x",ucp[hostdata->incoming_ptr]);
 #endif
-			/* Is this the last byte of the extended message? */
-			if ((hostdata->incoming_ptr >= 2) &&
-			    (hostdata->incoming_ptr == (ucp[1] + 1))) {
-				switch (ucp[2]) {   /* what's the EXTENDED code? */
-				case EXTENDED_SDTR:
-					id = calc_sync_xfer(ucp[3],ucp[4]);
-					if (hostdata->sync_stat[cmd->target] !=
-					    SS_WAITING) {
-						/* A device has sent
-						 * an unsolicited SDTR
-						 * message; rather
-						 * than go through the
-						 * effort of decoding
-						 * it and then
-						 * figuring out what
-						 * our reply should
-						 * be, we're just
-						 * gonna say that we
-						 * have a synchronous
-						 * fifo depth of
-						 * 0. This will result
-						 * in asynchronous
-						 * transfers - not
-						 * ideal but so much
-						 * easier.  Actually,
-						 * this is OK because
-						 * it assures us that
-						 * if we don't
-						 * specifically ask
-						 * for sync transfers,
-						 * we won't do any.  */
-
-						/* want MESS_OUT */
-						write_wd33c93_cmd(regp,
-								  WD_CMD_ASSERT_ATN);
-						hostdata->outgoing_msg[0] = EXTENDED_MESSAGE;
-						hostdata->outgoing_msg[1] = 3;
-						hostdata->outgoing_msg[2] = EXTENDED_SDTR;
-						hostdata->outgoing_msg[3] = hostdata->default_sx_per/4;
-						hostdata->outgoing_msg[4] = 0;
-						hostdata->outgoing_len = 5;
-						hostdata->sync_xfer[cmd->target] =
-							calc_sync_xfer(hostdata->default_sx_per/4,0);
-					} else {
-						hostdata->sync_xfer[cmd->target] = id;
-					}
+         /* Is this the last byte of the extended message? */
+
+               if ((hostdata->incoming_ptr >= 2) &&
+                   (hostdata->incoming_ptr == (ucp[1] + 1))) {
+
+                  switch (ucp[2]) {   /* what's the EXTENDED code? */
+                     case EXTENDED_SDTR:
+                        id = calc_sync_xfer(ucp[3],ucp[4]);
+                        if (hostdata->sync_stat[cmd->target] != SS_WAITING) {
+
+/* A device has sent an unsolicited SDTR message; rather than go
+ * through the effort of decoding it and then figuring out what
+ * our reply should be, we're just gonna say that we have a
+ * synchronous fifo depth of 0. This will result in asynchronous
+ * transfers - not ideal but so much easier.
+ * Actually, this is OK because it assures us that if we don't
+ * specifically ask for sync transfers, we won't do any.
+ */
+
+                           write_wd33c93_cmd(regp,WD_CMD_ASSERT_ATN); /* want MESS_OUT */
+                           hostdata->outgoing_msg[0] = EXTENDED_MESSAGE;
+                           hostdata->outgoing_msg[1] = 3;
+                           hostdata->outgoing_msg[2] = EXTENDED_SDTR;
+                           hostdata->outgoing_msg[3] = hostdata->default_sx_per/4;
+                           hostdata->outgoing_msg[4] = 0;
+                           hostdata->outgoing_len = 5;
+                           hostdata->sync_xfer[cmd->target] =
+                                       calc_sync_xfer(hostdata->default_sx_per/4,0);
+                           }
+                        else {
+                           hostdata->sync_xfer[cmd->target] = id;
+                           }
 #ifdef SYNC_DEBUG
-					printk("sync_xfer=%02x",hostdata->sync_xfer[cmd->target]);
+printk("sync_xfer=%02x",hostdata->sync_xfer[cmd->target]);
 #endif
-					hostdata->sync_stat[cmd->target] = SS_SET;
-					write_wd33c93_cmd(regp, WD_CMD_NEGATE_ACK);
-					hostdata->state = S_CONNECTED;
-					break;
-
-				case EXTENDED_WDTR:
-					/* want MESS_OUT */
-					write_wd33c93_cmd(regp, WD_CMD_ASSERT_ATN);
-					printk("sending WDTR ");
-					hostdata->outgoing_msg[0] = EXTENDED_MESSAGE;
-					hostdata->outgoing_msg[1] = 2;
-					hostdata->outgoing_msg[2] = EXTENDED_WDTR;
-					/* 8 bit transfer width */
-					hostdata->outgoing_msg[3] = 0;
-					hostdata->outgoing_len = 4;
-					write_wd33c93_cmd(regp, WD_CMD_NEGATE_ACK);
-					hostdata->state = S_CONNECTED;
-					break;
-
-				default:
-					/* want MESS_OUT */
-					write_wd33c93_cmd(regp, WD_CMD_ASSERT_ATN);
-					printk("Rejecting Unknown Extended "
-					       "Message(%02x). ",ucp[2]);
-					hostdata->outgoing_msg[0] = MESSAGE_REJECT;
-					hostdata->outgoing_len = 1;
-					write_wd33c93_cmd(regp, WD_CMD_NEGATE_ACK);
-					hostdata->state = S_CONNECTED;
-					break;
-				}
-				hostdata->incoming_ptr = 0;
-			} else {
-				/* We need to read more MESS_IN bytes for the
-				 * extended message
-				 */
-				hostdata->incoming_ptr++;
-				write_wd33c93_cmd(regp, WD_CMD_NEGATE_ACK);
-				hostdata->state = S_CONNECTED;
-			}
-			break;
-
-		default:
-			printk("Rejecting Unknown Message(%02x) ",msg);
-			/* want MESS_OUT */
-			write_wd33c93_cmd(regp, WD_CMD_ASSERT_ATN);
-			hostdata->outgoing_msg[0] = MESSAGE_REJECT;
-			hostdata->outgoing_len = 1;
-			write_wd33c93_cmd(regp, WD_CMD_NEGATE_ACK);
-			hostdata->state = S_CONNECTED;
-		}
-		restore_flags(flags);
-		break;
-
-	case CSR_SEL_XFER_DONE:
-		/* Note: this interrupt will occur only after a LEVEL2 command */
-
-		/* Make sure that reselection is enabled at this point - it may
-		 * have been turned off for the command that just completed.
-		 */
-		write_wd33c93(regp, WD_SOURCE_ID, SRCID_ER);
-		if (phs == 0x60) {
-			DB(DB_INTR, printk("SX-DONE-%ld", cmd->pid));
-			cmd->SCp.Message = COMMAND_COMPLETE;
-			lun = read_wd33c93(regp, WD_TARGET_LUN);
-			DB(DB_INTR,printk(":%d.%d",cmd->SCp.Status,lun));
-			hostdata->connected = NULL;
-			hostdata->busy[cmd->target] &= ~(1 << cmd->lun);
-			hostdata->state = S_UNCONNECTED;
-			if (cmd->SCp.Status == ILLEGAL_STATUS_BYTE)
-				cmd->SCp.Status = lun;
-			if (cmd->cmnd[0] == REQUEST_SENSE
-			    && cmd->SCp.Status != GOOD)
-				cmd->result = (cmd->result & 0x00ffff) |				                      (DID_ERROR << 16);
-			else
-				cmd->result = cmd->SCp.Status |
-				              (cmd->SCp.Message << 8);
-			cmd->scsi_done(cmd);
-
-			/* We are no longer  connected to a target - check to
-			 * see if there are commands waiting to be executed.
-			 */
-			restore_flags(flags);
-			wd33c93_execute(instance);
-		} else {
-			printk("%02x:%02x:%02x-%ld: Unknown SEL_XFER_DONE "
-			       "phase!!---", asr, sr, phs, cmd->pid);
-		}
-		break;
-
-	case CSR_SDP:
-		/* Note: this interrupt will occur only after a LEVEL2 command */
-		DB(DB_INTR, printk("SDP"));
-		hostdata->state = S_RUNNING_LEVEL2;
-		write_wd33c93(regp, WD_COMMAND_PHASE, 0x41);
-		write_wd33c93_cmd(regp, WD_CMD_SEL_ATN_XFER);
-		break;
-
-	case CSR_XFER_DONE|PHS_MESS_OUT:
-	case CSR_UNEXP    |PHS_MESS_OUT:
-	case CSR_SRV_REQ  |PHS_MESS_OUT:
-		DB(DB_INTR, printk("MSG_OUT="));
-
-		/* To get here, we've probably requested MESSAGE_OUT and have
-		 * already put the correct bytes in outgoing_msg[] and filled
-		 * in outgoing_len. We simply send them out to the SCSI bus.
-		 * Sometimes we get MESSAGE_OUT phase when we're not expecting
-		 * it - like when our SDTR message is rejected by a target. Some
-		 * targets send the REJECT before receiving all of the extended
-		 * message, and then seem to go back to MESSAGE_OUT for a byte
-		 * or two. Not sure why, or if I'm doing something wrong to
-		 * cause this to happen. Regardless, it seems that sending
-		 * NOP messages in these situations results in no harm and
-		 * makes everyone happy.
-		 */
-		if (hostdata->outgoing_len == 0) {
-			hostdata->outgoing_len = 1;
-			hostdata->outgoing_msg[0] = NOP;
-		}
-		transfer_pio(regp, hostdata->outgoing_msg, hostdata->outgoing_len,
-			     DATA_OUT_DIR, hostdata);
-		DB(DB_INTR,printk("%02x", hostdata->outgoing_msg[0]));
-		hostdata->outgoing_len = 0;
-		hostdata->state = S_CONNECTED;
-		break;
-
-	case CSR_UNEXP_DISC:
-		/* I think I've seen this after a request-sense that was in response
-		 * to an error condition, but not sure. We certainly need to do
-		 * something when we get this interrupt - the question is 'what?'.
-		 * Let's think positively, and assume some command has finished
-		 * in a legal manner (like a command that provokes a request-sense),
-		 * so we treat it as a normal command-complete-disconnect.
-		 */
-
-		/* Make sure that reselection is enabled at this point - it may
-		 * have been turned off for the command that just completed.
-		 */
-		write_wd33c93(regp, WD_SOURCE_ID, SRCID_ER);
-		if (cmd == NULL) {
-			printk(" - Already disconnected! ");
-			hostdata->state = S_UNCONNECTED;
-			return;
-		}
-		DB(DB_INTR,printk("UNEXP_DISC-%ld", cmd->pid));
-		hostdata->connected = NULL;
-		hostdata->busy[cmd->target] &= ~(1 << cmd->lun);
-		hostdata->state = S_UNCONNECTED;
-		if (cmd->cmnd[0] == REQUEST_SENSE && cmd->SCp.Status != GOOD)
-			cmd->result = (cmd->result & 0x00ffff) |
-			              (DID_ERROR << 16);
-		else
-			cmd->result = cmd->SCp.Status |
-			              (cmd->SCp.Message << 8);
-
-		cmd->scsi_done(cmd);
-
-		/* We are no longer connected to a target - check to see if
-		 * there are commands waiting to be executed.
-		 */
-		wd33c93_execute(instance);
-		/* look above for comments on scsi_done() */
-		restore_flags(flags);
-		break;
-
-	case CSR_DISC:
-		/* Make sure that reselection is enabled at this point - it may
-		 * have been turned off for the command that just completed.
-		 */
-		write_wd33c93(regp, WD_SOURCE_ID, SRCID_ER);
-		DB(DB_INTR, printk("DISC-%ld", cmd->pid));
-		if (cmd == NULL) {
-			printk(" - Already disconnected! ");
-			hostdata->state = S_UNCONNECTED;
-		}
-		switch (hostdata->state) {
-		case S_PRE_CMP_DISC:
-			hostdata->connected = NULL;
-			hostdata->busy[cmd->target] &= ~(1 << cmd->lun);
-			hostdata->state = S_UNCONNECTED;
-			DB(DB_INTR,printk(":%d",cmd->SCp.Status))
-			if (cmd->cmnd[0] == REQUEST_SENSE &&
-			    cmd->SCp.Status != GOOD)
-				cmd->result = (cmd->result & 0x00ffff) |
-				              (DID_ERROR << 16);
-			else
-				cmd->result = cmd->SCp.Status |
-				              (cmd->SCp.Message << 8);
-			cmd->scsi_done(cmd);
-			restore_flags(flags);
-			break;
-		case S_PRE_TMP_DISC:
-		case S_RUNNING_LEVEL2:
-			cmd->host_scribble = (uchar *) hostdata->disconnected_Q;
-			hostdata->disconnected_Q = cmd;
-			hostdata->connected = NULL;
-			hostdata->state = S_UNCONNECTED;
+                        hostdata->sync_stat[cmd->target] = SS_SET;
+                        write_wd33c93_cmd(regp,WD_CMD_NEGATE_ACK);
+                        hostdata->state = S_CONNECTED;
+                        break;
+                     case EXTENDED_WDTR:
+                        write_wd33c93_cmd(regp,WD_CMD_ASSERT_ATN); /* want MESS_OUT */
+                        printk("sending WDTR ");
+                        hostdata->outgoing_msg[0] = EXTENDED_MESSAGE;
+                        hostdata->outgoing_msg[1] = 2;
+                        hostdata->outgoing_msg[2] = EXTENDED_WDTR;
+                        hostdata->outgoing_msg[3] = 0;   /* 8 bit transfer width */
+                        hostdata->outgoing_len = 4;
+                        write_wd33c93_cmd(regp,WD_CMD_NEGATE_ACK);
+                        hostdata->state = S_CONNECTED;
+                        break;
+                     default:
+                        write_wd33c93_cmd(regp,WD_CMD_ASSERT_ATN); /* want MESS_OUT */
+                        printk("Rejecting Unknown Extended Message(%02x). ",ucp[2]);
+                        hostdata->outgoing_msg[0] = MESSAGE_REJECT;
+                        hostdata->outgoing_len = 1;
+                        write_wd33c93_cmd(regp,WD_CMD_NEGATE_ACK);
+                        hostdata->state = S_CONNECTED;
+                        break;
+                     }
+                  hostdata->incoming_ptr = 0;
+                  }
+
+         /* We need to read more MESS_IN bytes for the extended message */
+
+               else {
+                  hostdata->incoming_ptr++;
+                  write_wd33c93_cmd(regp,WD_CMD_NEGATE_ACK);
+                  hostdata->state = S_CONNECTED;
+                  }
+               break;
+
+            default:
+               printk("Rejecting Unknown Message(%02x) ",msg);
+               write_wd33c93_cmd(regp,WD_CMD_ASSERT_ATN); /* want MESS_OUT */
+               hostdata->outgoing_msg[0] = MESSAGE_REJECT;
+               hostdata->outgoing_len = 1;
+               write_wd33c93_cmd(regp,WD_CMD_NEGATE_ACK);
+               hostdata->state = S_CONNECTED;
+            }
+         restore_flags(flags);
+         break;
+
+
+/* Note: this interrupt will occur only after a LEVEL2 command */
+
+      case CSR_SEL_XFER_DONE:
+
+/* Make sure that reselection is enabled at this point - it may
+ * have been turned off for the command that just completed.
+ */
+
+         write_wd33c93(regp,WD_SOURCE_ID, SRCID_ER);
+         if (phs == 0x60) {
+DB(DB_INTR,printk("SX-DONE-%ld",cmd->pid))
+            cmd->SCp.Message = COMMAND_COMPLETE;
+            lun = read_wd33c93(regp, WD_TARGET_LUN);
+DB(DB_INTR,printk(":%d.%d",cmd->SCp.Status,lun))
+            hostdata->connected = NULL;
+            hostdata->busy[cmd->target] &= ~(1 << cmd->lun);
+            hostdata->state = S_UNCONNECTED;
+            if (cmd->SCp.Status == ILLEGAL_STATUS_BYTE)
+               cmd->SCp.Status = lun;
+            if (cmd->cmnd[0] == REQUEST_SENSE && cmd->SCp.Status != GOOD)
+               cmd->result = (cmd->result & 0x00ffff) | (DID_ERROR << 16);
+            else
+               cmd->result = cmd->SCp.Status | (cmd->SCp.Message << 8);
+            cmd->scsi_done(cmd);
+
+/* We are no longer  connected to a target - check to see if
+ * there are commands waiting to be executed.
+ */
+       restore_flags(flags);
+            wd33c93_execute(instance);
+            }
+         else {
+            printk("%02x:%02x:%02x-%ld: Unknown SEL_XFER_DONE phase!!---",asr,sr,phs,cmd->pid);
+            }
+         break;
+
+
+/* Note: this interrupt will occur only after a LEVEL2 command */
+
+      case CSR_SDP:
+DB(DB_INTR,printk("SDP"))
+            hostdata->state = S_RUNNING_LEVEL2;
+            write_wd33c93(regp, WD_COMMAND_PHASE, 0x41);
+            write_wd33c93_cmd(regp, WD_CMD_SEL_ATN_XFER);
+         break;
+
+
+      case CSR_XFER_DONE|PHS_MESS_OUT:
+      case CSR_UNEXP    |PHS_MESS_OUT:
+      case CSR_SRV_REQ  |PHS_MESS_OUT:
+DB(DB_INTR,printk("MSG_OUT="))
+
+/* To get here, we've probably requested MESSAGE_OUT and have
+ * already put the correct bytes in outgoing_msg[] and filled
+ * in outgoing_len. We simply send them out to the SCSI bus.
+ * Sometimes we get MESSAGE_OUT phase when we're not expecting
+ * it - like when our SDTR message is rejected by a target. Some
+ * targets send the REJECT before receiving all of the extended
+ * message, and then seem to go back to MESSAGE_OUT for a byte
+ * or two. Not sure why, or if I'm doing something wrong to
+ * cause this to happen. Regardless, it seems that sending
+ * NOP messages in these situations results in no harm and
+ * makes everyone happy.
+ */
+
+         if (hostdata->outgoing_len == 0) {
+            hostdata->outgoing_len = 1;
+            hostdata->outgoing_msg[0] = NOP;
+            }
+         transfer_pio(regp, hostdata->outgoing_msg, hostdata->outgoing_len,
+                            DATA_OUT_DIR, hostdata);
+DB(DB_INTR,printk("%02x",hostdata->outgoing_msg[0]))
+         hostdata->outgoing_len = 0;
+         hostdata->state = S_CONNECTED;
+         break;
+
+
+      case CSR_UNEXP_DISC:
+
+/* I think I've seen this after a request-sense that was in response
+ * to an error condition, but not sure. We certainly need to do
+ * something when we get this interrupt - the question is 'what?'.
+ * Let's think positively, and assume some command has finished
+ * in a legal manner (like a command that provokes a request-sense),
+ * so we treat it as a normal command-complete-disconnect.
+ */
+
+/* Make sure that reselection is enabled at this point - it may
+ * have been turned off for the command that just completed.
+ */
+
+         write_wd33c93(regp,WD_SOURCE_ID, SRCID_ER);
+         if (cmd == NULL) {
+            printk(" - Already disconnected! ");
+            hostdata->state = S_UNCONNECTED;
+            return;
+            }
+DB(DB_INTR,printk("UNEXP_DISC-%ld",cmd->pid))
+         hostdata->connected = NULL;
+         hostdata->busy[cmd->target] &= ~(1 << cmd->lun);
+         hostdata->state = S_UNCONNECTED;
+         if (cmd->cmnd[0] == REQUEST_SENSE && cmd->SCp.Status != GOOD)
+            cmd->result = (cmd->result & 0x00ffff) | (DID_ERROR << 16);
+         else
+            cmd->result = cmd->SCp.Status | (cmd->SCp.Message << 8);
+         cmd->scsi_done(cmd);
+
+/* We are no longer connected to a target - check to see if
+ * there are commands waiting to be executed.
+ */
+    /* look above for comments on scsi_done() */
+    restore_flags(flags);
+         wd33c93_execute(instance);
+         break;
+
+
+      case CSR_DISC:
+
+/* Make sure that reselection is enabled at this point - it may
+ * have been turned off for the command that just completed.
+ */
+
+         write_wd33c93(regp,WD_SOURCE_ID, SRCID_ER);
+DB(DB_INTR,printk("DISC-%ld",cmd->pid))
+         if (cmd == NULL) {
+            printk(" - Already disconnected! ");
+            hostdata->state = S_UNCONNECTED;
+            }
+         switch (hostdata->state) {
+            case S_PRE_CMP_DISC:
+               hostdata->connected = NULL;
+               hostdata->busy[cmd->target] &= ~(1 << cmd->lun);
+               hostdata->state = S_UNCONNECTED;
+DB(DB_INTR,printk(":%d",cmd->SCp.Status))
+               if (cmd->cmnd[0] == REQUEST_SENSE && cmd->SCp.Status != GOOD)
+                  cmd->result = (cmd->result & 0x00ffff) | (DID_ERROR << 16);
+               else
+                  cmd->result = cmd->SCp.Status | (cmd->SCp.Message << 8);
+               cmd->scsi_done(cmd);
+          restore_flags(flags);
+               break;
+            case S_PRE_TMP_DISC:
+            case S_RUNNING_LEVEL2:
+               cmd->host_scribble = (uchar *)hostdata->disconnected_Q;
+               hostdata->disconnected_Q = cmd;
+               hostdata->connected = NULL;
+               hostdata->state = S_UNCONNECTED;
+
 #ifdef PROC_STATISTICS
-			hostdata->disc_done_cnt[cmd->target]++;
+               hostdata->disc_done_cnt[cmd->target]++;
 #endif
-			break;
-
-		default:
-			printk("*** Unexpected DISCONNECT interrupt! ***");
-			hostdata->state = S_UNCONNECTED;
-		}
-		/* We are no longer connected to a target - check to see if
-		 * there are commands waiting to be executed.
-		 */
-		wd33c93_execute(instance);
-		break;
-
-	case CSR_RESEL_AM:
-		DB(DB_INTR,printk("RESEL"));
-
-		/* First we have to make sure this reselection didn't
-		 * happen during Arbitration/Selection of some other device.
-		 * If yes, put losing command back on top of input_Q.
-		 */
-		if (hostdata->level2 <= L2_NONE) {
-			if (hostdata->selecting) {
-				cmd = (Scsi_Cmnd *) hostdata->selecting;
-				hostdata->selecting = NULL;
-				hostdata->busy[cmd->target] &= ~(1 << cmd->lun);
-				cmd->host_scribble = (uchar *) hostdata->input_Q;
-				hostdata->input_Q = cmd;
-			}
-		} else {
-			if (cmd) {
-				if (phs == 0x00) {
-					hostdata->busy[cmd->target] &=
-						~(1 << cmd->lun);
-					cmd->host_scribble =
-						(uchar *) hostdata->input_Q;
-					hostdata->input_Q = cmd;
-				} else {
-					printk("---%02x:%02x:%02x-TROUBLE: "
-					       "Intrusive ReSelect!---",
-					       asr, sr, phs);
-					while (1)
-						printk("\r");
-				}
-			}
-		}
-
-		/* OK - find out which device reselected us. */
-		id = read_wd33c93(regp, WD_SOURCE_ID);
-		id &= SRCID_MASK;
-
-		/* and extract the lun from the ID message. (Note that we don't
-		 * bother to check for a valid message here - I guess this is
-		 * not the right way to go, but...)
-		 */
-		lun = read_wd33c93(regp, WD_DATA);
-		if (hostdata->level2 < L2_RESELECT)
-			write_wd33c93_cmd(regp, WD_CMD_NEGATE_ACK);
-		lun &= 7;
-
-		/* Now we look for the command that's reconnecting. */
-		cmd = (Scsi_Cmnd *) hostdata->disconnected_Q;
-		patch = NULL;
-		while (cmd) {
-			if ((id == cmd->target) && (lun == cmd->lun))
-				break;
-			patch = cmd;
-			cmd = (Scsi_Cmnd *) cmd->host_scribble;
-		}
-
-		/* Hmm. Couldn't find a valid command.... What to do? */
-		if (!cmd) {
-			printk("---TROUBLE: target %d.%d not in disconnect "
-			       "queue---", id, lun);
-			return;
-		}
-
-		/* Ok, found the command - now start it up again. */
-		if (patch)
-			patch->host_scribble = cmd->host_scribble;
-		else
-			hostdata->disconnected_Q = (Scsi_Cmnd *) cmd->host_scribble;
-		hostdata->connected = cmd;
-
-		/* We don't need to worry about 'initialize_SCp()' or
-		 * 'hostdata->busy[]' because these things are preserved
-		 * over a disconnect.  But we DO need to fix the DPD bit so
-		 * it's correct for this command.
-		 */
-		if (is_dir_out(cmd))
-			write_wd33c93(regp, WD_DESTINATION_ID, cmd->target);
-		else
-			write_wd33c93(regp, WD_DESTINATION_ID,
-				      (cmd->target | DSTID_DPD));
-		if (hostdata->level2 >= L2_RESELECT) {
-			/* we want a DATA_PHASE interrupt */
-			write_wd33c93_count(regp, 0);
-			write_wd33c93(regp, WD_COMMAND_PHASE, 0x45);
-			write_wd33c93_cmd(regp, WD_CMD_SEL_ATN_XFER);
-			hostdata->state = S_RUNNING_LEVEL2;
-		} else {
-			hostdata->state = S_CONNECTED;
-		}
-
-		DB(DB_INTR,printk("-%ld", cmd->pid));
-		break;
+
+               break;
+            default:
+               printk("*** Unexpected DISCONNECT interrupt! ***");
+               hostdata->state = S_UNCONNECTED;
+            }
+
+/* We are no longer connected to a target - check to see if
+ * there are commands waiting to be executed.
+ */
+         wd33c93_execute(instance);
+         break;
+
+
+      case CSR_RESEL_AM:
+DB(DB_INTR,printk("RESEL"))
+
+   /* First we have to make sure this reselection didn't */
+   /* happen during Arbitration/Selection of some other device. */
+   /* If yes, put losing command back on top of input_Q. */
+
+         if (hostdata->level2 <= L2_NONE) {
+
+            if (hostdata->selecting) {
+               cmd = (Scsi_Cmnd *)hostdata->selecting;
+               hostdata->selecting = NULL;
+               hostdata->busy[cmd->target] &= ~(1 << cmd->lun);
+               cmd->host_scribble = (uchar *)hostdata->input_Q;
+               hostdata->input_Q = cmd;
+               }
+            }
+
+         else {
+
+            if (cmd) {
+               if (phs == 0x00) {
+                  hostdata->busy[cmd->target] &= ~(1 << cmd->lun);
+                  cmd->host_scribble = (uchar *)hostdata->input_Q;
+                  hostdata->input_Q = cmd;
+                  }
+               else {
+                  printk("---%02x:%02x:%02x-TROUBLE: Intrusive ReSelect!---",asr,sr,phs);
+                  while (1)
+                     printk("\r");
+                  }
+               }
+
+            }
+
+   /* OK - find out which device reselected us. */
+
+         id = read_wd33c93(regp, WD_SOURCE_ID);
+         id &= SRCID_MASK;
+
+   /* and extract the lun from the ID message. (Note that we don't
+    * bother to check for a valid message here - I guess this is
+    * not the right way to go, but...)
+    */
+
+         lun = read_wd33c93(regp, WD_DATA);
+         if (hostdata->level2 < L2_RESELECT)
+            write_wd33c93_cmd(regp,WD_CMD_NEGATE_ACK);
+         lun &= 7;
+
+   /* Now we look for the command that's reconnecting. */
+
+         cmd = (Scsi_Cmnd *)hostdata->disconnected_Q;
+         patch = NULL;
+         while (cmd) {
+            if (id == cmd->target && lun == cmd->lun)
+               break;
+            patch = cmd;
+            cmd = (Scsi_Cmnd *)cmd->host_scribble;
+            }
+
+   /* Hmm. Couldn't find a valid command.... What to do? */
+
+         if (!cmd) {
+            printk("---TROUBLE: target %d.%d not in disconnect queue---",id,lun);
+            return;
+            }
+
+   /* Ok, found the command - now start it up again. */
+
+         if (patch)
+            patch->host_scribble = cmd->host_scribble;
+         else
+            hostdata->disconnected_Q = (Scsi_Cmnd *)cmd->host_scribble;
+         hostdata->connected = cmd;
+
+   /* We don't need to worry about 'initialize_SCp()' or 'hostdata->busy[]'
+    * because these things are preserved over a disconnect.
+    * But we DO need to fix the DPD bit so it's correct for this command.
+    */
+
+         if (is_dir_out(cmd))
+            write_wd33c93(regp, WD_DESTINATION_ID, cmd->target);
+         else
+            write_wd33c93(regp, WD_DESTINATION_ID, cmd->target | DSTID_DPD);
+         if (hostdata->level2 >= L2_RESELECT) {
+            write_wd33c93_count(regp, 0);  /* we want a DATA_PHASE interrupt */
+            write_wd33c93(regp, WD_COMMAND_PHASE, 0x45);
+            write_wd33c93_cmd(regp, WD_CMD_SEL_ATN_XFER);
+            hostdata->state = S_RUNNING_LEVEL2;
+            }
+         else
+            hostdata->state = S_CONNECTED;
+
+DB(DB_INTR,printk("-%ld",cmd->pid))
+         break;
          
-	default:
-		printk("--UNKNOWN INTERRUPT:%02x:%02x:%02x--", asr, sr, phs);
-	}
+      default:
+         printk("--UNKNOWN INTERRUPT:%02x:%02x:%02x--",asr,sr,phs);
+      }
+
+DB(DB_INTR,printk("} "))
 
-	DB(DB_INTR,printk("} "));
 }
 
-/*
- * Not static 'cause called from outside ...
- */
+
+
 void reset_wd33c93(struct Scsi_Host *instance)
 {
-	struct WD33C93_hostdata *hostdata = INSTHOSTDATA(instance);
-	wd33c93_regs *regp = hostdata->regp;
-	uchar sr;
-
-	write_wd33c93(regp, WD_OWN_ID, (OWNID_EAF | OWNID_RAF |
-		      instance->this_id | hostdata->clock_freq));
-	write_wd33c93(regp, WD_CONTROL, (CTRL_IDI | CTRL_EDI | CTRL_POLLED));
-	write_wd33c93(regp, WD_SYNCHRONOUS_TRANSFER,
-		      calc_sync_xfer(hostdata->default_sx_per/4, DEFAULT_SX_OFF));
-	write_wd33c93(regp, WD_COMMAND, WD_CMD_RESET);
-
-	while (!(READ_AUX_STAT() & ASR_INT))
-		;
-
-	sr = read_wd33c93(regp, WD_SCSI_STATUS);
-	hostdata->microcode = read_wd33c93(regp, WD_CDB_1);
-	if (sr == 0x00)
-		hostdata->chip = C_WD33C93;
-	else if (sr == 0x01) {
-		write_wd33c93(regp, WD_QUEUE_TAG, 0xa5);  /* any random number */
-		sr = read_wd33c93(regp, WD_QUEUE_TAG);
-		if (sr == 0xa5) {
-			hostdata->chip = C_WD33C93B;
-			write_wd33c93(regp, WD_QUEUE_TAG, 0);
-		} else {
-			hostdata->chip = C_WD33C93A;
-		}
-	} else {
-		hostdata->chip = C_UNKNOWN_CHIP;
-	}
-
-	write_wd33c93(regp, WD_TIMEOUT_PERIOD, TIMEOUT_PERIOD_VALUE);
-	write_wd33c93(regp, WD_CONTROL, (CTRL_IDI | CTRL_EDI | CTRL_POLLED));
+struct WD33C93_hostdata *hostdata;
+wd33c93_regs *regp;
+uchar sr;
+
+   hostdata = (struct WD33C93_hostdata *)instance->hostdata;
+   regp = hostdata->regp;
+
+   write_wd33c93(regp, WD_OWN_ID, OWNID_EAF | OWNID_RAF |
+                 instance->this_id | hostdata->clock_freq);
+   write_wd33c93(regp, WD_CONTROL, CTRL_IDI | CTRL_EDI | CTRL_POLLED);
+   write_wd33c93(regp, WD_SYNCHRONOUS_TRANSFER,
+                 calc_sync_xfer(hostdata->default_sx_per/4,DEFAULT_SX_OFF));
+   write_wd33c93(regp, WD_COMMAND, WD_CMD_RESET);
+
+   while (!(READ_AUX_STAT() & ASR_INT))
+      ;
+   sr = read_wd33c93(regp, WD_SCSI_STATUS);
+
+   hostdata->microcode = read_wd33c93(regp, WD_CDB_1);
+   if (sr == 0x00)
+      hostdata->chip = C_WD33C93;
+   else if (sr == 0x01) {
+      write_wd33c93(regp, WD_QUEUE_TAG, 0xa5);  /* any random number */
+      sr = read_wd33c93(regp, WD_QUEUE_TAG);
+      if (sr == 0xa5) {
+         hostdata->chip = C_WD33C93B;
+         write_wd33c93(regp, WD_QUEUE_TAG, 0);
+         }
+      else
+         hostdata->chip = C_WD33C93A;
+      }
+   else
+      hostdata->chip = C_UNKNOWN_CHIP;
+
+   write_wd33c93(regp, WD_TIMEOUT_PERIOD, TIMEOUT_PERIOD_VALUE);
+   write_wd33c93(regp, WD_CONTROL, CTRL_IDI | CTRL_EDI | CTRL_POLLED);
 }
 
+
+
 #if LINUX_VERSION_CODE >= 0x010300
 int wd33c93_reset(Scsi_Cmnd *SCpnt, unsigned int reset_flags)
 #else
 int wd33c93_reset(Scsi_Cmnd *SCpnt)
 #endif
 {
-	struct Scsi_Host *instance = SCpnt->host;
-	struct WD33C93_hostdata *hostdata = INSTHOSTDATA(instance);
-	int i;
-
-	printk("scsi%d: reset. ", instance->host_no);
-	disable_irq(instance->irq);
-
-	((struct WD33C93_hostdata *)instance->hostdata)->dma_stop(instance,NULL,0);
-	for (i = 0; i < 8; i++) {
-		hostdata->busy[i] = 0;
-		hostdata->sync_xfer[i] =
-			calc_sync_xfer(DEFAULT_SX_PER/4, DEFAULT_SX_OFF);
-		hostdata->sync_stat[i] = SS_UNSET;  /* using default sync values */
-	}
-#ifdef PROC_STATISTICS
-	hostdata->cmd_cnt[i] = 0;
-	hostdata->disc_allowed_cnt[i] = 0;
-	hostdata->disc_done_cnt[i] = 0;
-#endif
-	hostdata->input_Q = NULL;
-	hostdata->selecting = NULL;
-	hostdata->connected = NULL;
-	hostdata->disconnected_Q = NULL;
-	hostdata->state = S_UNCONNECTED;
-	hostdata->dma = D_DMA_OFF;
-	hostdata->incoming_ptr = 0;
-	hostdata->outgoing_len = 0;
-
-	reset_wd33c93(instance);
-	SCpnt->result = (DID_RESET << 16);
-	enable_irq(instance->irq);
-	return 0;
+struct Scsi_Host *instance;
+struct WD33C93_hostdata *hostdata;
+int i;
+
+   instance = SCpnt->host;
+   hostdata = (struct WD33C93_hostdata *)instance->hostdata;
+
+   printk("scsi%d: reset. ", instance->host_no);
+   disable_irq(instance->irq);
+
+   ((struct WD33C93_hostdata *)instance->hostdata)->dma_stop(instance,NULL,0);
+   for (i = 0; i < 8; i++) {
+      hostdata->busy[i] = 0;
+      hostdata->sync_xfer[i] = calc_sync_xfer(DEFAULT_SX_PER/4,DEFAULT_SX_OFF);
+      hostdata->sync_stat[i] = SS_UNSET;  /* using default sync values */
+      }
+   hostdata->input_Q = NULL;
+   hostdata->selecting = NULL;
+   hostdata->connected = NULL;
+   hostdata->disconnected_Q = NULL;
+   hostdata->state = S_UNCONNECTED;
+   hostdata->dma = D_DMA_OFF;
+   hostdata->incoming_ptr = 0;
+   hostdata->outgoing_len = 0;
+
+   reset_wd33c93(instance);
+   SCpnt->result = DID_RESET << 16;
+   enable_irq(instance->irq);
+   return 0;
 }
 
+
+
 int wd33c93_abort (Scsi_Cmnd *cmd)
 {
-	struct Scsi_Host *instance = cmd->host;
-	struct WD33C93_hostdata *hostdata = INSTHOSTDATA(instance);
-	wd33c93_regs *regp = hostdata->regp;
-	Scsi_Cmnd *tmp, *prev;
-
-	disable_irq(cmd->host->irq);
-
-	/* Case 1 : If the command hasn't been issued yet, we simply remove it
-	 *     from the input_Q.
-	 */
-	tmp = (Scsi_Cmnd *) hostdata->input_Q;
-	prev = 0;
-	while (tmp) {
-		if (tmp == cmd) {
-			if (prev)
-				prev->host_scribble = cmd->host_scribble;
-			cmd->host_scribble = NULL;
-			cmd->result = (DID_ABORT << 16);
-			printk("scsi%d: Abort - removing command %ld from "
-			       "input_Q. ", instance->host_no, cmd->pid);
-			cmd->scsi_done(cmd);
-			enable_irq(cmd->host->irq);
-			return SCSI_ABORT_SUCCESS;
-		}
-		prev = tmp;
-		tmp = (Scsi_Cmnd *) tmp->host_scribble;
-	}
-
-	/* Case 2 : If the command is connected, we're going to fail the abort
-	 *     and let the high level SCSI driver retry at a later time or
-	 *     issue a reset.
-	 *
-	 *     Timeouts, and therefore aborted commands, will be highly unlikely
-	 *     and handling them cleanly in this situation would make the common
-	 *     case of noresets less efficient, and would pollute our code.  So,
-	 *     we fail.
-	 */
-	if (hostdata->connected == cmd) {
-		uchar sr, asr;
-		unsigned long timeout;
-
-		printk("scsi%d: Aborting connected command %ld - ",
-		       instance->host_no, cmd->pid);
-
-		printk("stopping DMA - ");
-		if (hostdata->dma == D_DMA_RUNNING) {
-			hostdata->dma_stop(instance, cmd, 0);
-			hostdata->dma = D_DMA_OFF;
-		}
-
-		printk("sending wd33c93 ABORT command - ");
-		write_wd33c93(regp, WD_CONTROL,
-			      (CTRL_IDI | CTRL_EDI | CTRL_POLLED));
-		write_wd33c93_cmd(regp, WD_CMD_ABORT);
-
-		/* Now we have to attempt to flush out the FIFO... */
-		printk("flushing fifo - ");
-		timeout = 1000000;
-		do {
-			asr = READ_AUX_STAT();
-			if (asr & ASR_DBR)
-				read_wd33c93(regp, WD_DATA);
-		} while (!(asr & ASR_INT) && timeout-- > 0);
-
-		sr = read_wd33c93(regp, WD_SCSI_STATUS);
-		printk("asr=%02x, sr=%02x, %ld bytes un-transferred "
-		       "(timeout=%ld) - ", asr, sr, read_wd33c93_count(regp),
-		       timeout);
-
-		/* Abort command processed.
-		 * Still connected.
-		 * We must disconnect.
-		 */
-		printk("sending wd33c93 DISCONNECT command - ");
-		write_wd33c93_cmd(regp, WD_CMD_DISCONNECT);
-
-		timeout = 1000000;
-		asr = READ_AUX_STAT();
-		while ((asr & ASR_CIP) && timeout-- > 0)
-			asr = READ_AUX_STAT();
-		sr = read_wd33c93(regp, WD_SCSI_STATUS);
-		printk("asr=%02x, sr=%02x.", asr, sr);
-
-		hostdata->busy[cmd->target] &= ~(1 << cmd->lun);
-		hostdata->connected = NULL;
-		hostdata->state = S_UNCONNECTED;
-		cmd->result = (DID_ABORT << 16);
-		cmd->scsi_done(cmd);
-
-		/*      sti();*/
-		enable_irq(cmd->host->irq);
-		cmd->scsi_done(cmd);
-		wd33c93_execute (instance);
-
-		return SCSI_ABORT_SUCCESS;
-	}
-
-	/* Case 3: If the command is currently disconnected from the bus,
-	 * we're not going to expend much effort here: Let's just return
-	 * an ABORT_SNOOZE and hope for the best...
-	 */
-
-	tmp = (Scsi_Cmnd *) hostdata->disconnected_Q;
-	while (tmp) {
-		if (tmp == cmd) {
-			printk("scsi%d: Abort - command %ld found on "
-			       "disconnected_Q - ", instance->host_no, cmd->pid);
-			printk("returning ABORT_SNOOZE. ");
-			enable_irq(cmd->host->irq);
-			return SCSI_ABORT_SNOOZE;
-		}
-		tmp = (Scsi_Cmnd *) tmp->host_scribble;
-	}
-
-	/* Case 4 : If we reached this point, the command was not found in any of
-	 *     the queues.
-	 *
-	 * We probably reached this point because of an unlikely race condition
-	 * between the command completing successfully and the abortion code,
-	 * so we won't panic, but we will notify the user in case something really
-	 * broke.
-	 */
-
-	/*   sti();*/
-	wd33c93_execute (instance);
-
-	enable_irq(cmd->host->irq);
-	printk("scsi%d: warning : SCSI command probably completed successfully"
-	       "         before abortion. ", instance->host_no);
-	return SCSI_ABORT_NOT_RUNNING;
+struct Scsi_Host *instance;
+struct WD33C93_hostdata *hostdata;
+wd33c93_regs *regp;
+Scsi_Cmnd *tmp, *prev;
+
+   disable_irq(cmd->host->irq);
+
+   instance = cmd->host;
+   hostdata = (struct WD33C93_hostdata *)instance->hostdata;
+   regp = hostdata->regp;
+
+/*
+ * Case 1 : If the command hasn't been issued yet, we simply remove it
+ *     from the input_Q.
+ */
+
+   tmp = (Scsi_Cmnd *)hostdata->input_Q;
+   prev = 0;
+   while (tmp) {
+      if (tmp == cmd) {
+         if (prev)
+            prev->host_scribble = cmd->host_scribble;
+         cmd->host_scribble = NULL;
+         cmd->result = DID_ABORT << 16;
+         printk("scsi%d: Abort - removing command %ld from input_Q. ",
+           instance->host_no, cmd->pid);
+    enable_irq(cmd->host->irq);
+         cmd->scsi_done(cmd);
+         return SCSI_ABORT_SUCCESS;
+         }
+      prev = tmp;
+      tmp = (Scsi_Cmnd *)tmp->host_scribble;
+      }
+
+/*
+ * Case 2 : If the command is connected, we're going to fail the abort
+ *     and let the high level SCSI driver retry at a later time or
+ *     issue a reset.
+ *
+ *     Timeouts, and therefore aborted commands, will be highly unlikely
+ *     and handling them cleanly in this situation would make the common
+ *     case of noresets less efficient, and would pollute our code.  So,
+ *     we fail.
+ */
+
+   if (hostdata->connected == cmd) {
+      uchar sr, asr;
+      unsigned long timeout;
+
+      printk("scsi%d: Aborting connected command %ld - ",
+              instance->host_no, cmd->pid);
+
+      printk("stopping DMA - ");
+      if (hostdata->dma == D_DMA_RUNNING) {
+         hostdata->dma_stop(instance, cmd, 0);
+         hostdata->dma = D_DMA_OFF;
+         }
+
+      printk("sending wd33c93 ABORT command - ");
+      write_wd33c93(regp, WD_CONTROL, CTRL_IDI | CTRL_EDI | CTRL_POLLED);
+      write_wd33c93_cmd(regp, WD_CMD_ABORT);
+
+/* Now we have to attempt to flush out the FIFO... */
+
+      printk("flushing fifo - ");
+      timeout = 1000000;
+      do {
+         asr = READ_AUX_STAT();
+         if (asr & ASR_DBR)
+            read_wd33c93(regp, WD_DATA);
+         } while (!(asr & ASR_INT) && timeout-- > 0);
+      sr = read_wd33c93(regp, WD_SCSI_STATUS);
+      printk("asr=%02x, sr=%02x, %ld bytes un-transferred (timeout=%ld) - ",
+             asr, sr, read_wd33c93_count(regp), timeout);
+
+   /*
+    * Abort command processed.
+    * Still connected.
+    * We must disconnect.
+    */
+
+      printk("sending wd33c93 DISCONNECT command - ");
+      write_wd33c93_cmd(regp, WD_CMD_DISCONNECT);
+
+      timeout = 1000000;
+      asr = READ_AUX_STAT();
+      while ((asr & ASR_CIP) && timeout-- > 0)
+         asr = READ_AUX_STAT();
+      sr = read_wd33c93(regp, WD_SCSI_STATUS);
+      printk("asr=%02x, sr=%02x.",asr,sr);
+
+      hostdata->busy[cmd->target] &= ~(1 << cmd->lun);
+      hostdata->connected = NULL;
+      hostdata->state = S_UNCONNECTED;
+      cmd->result = DID_ABORT << 16;
+
+/*      sti();*/
+      wd33c93_execute (instance);
+
+      enable_irq(cmd->host->irq);
+      cmd->scsi_done(cmd);
+      return SCSI_ABORT_SUCCESS;
+      }
+
+/*
+ * Case 3: If the command is currently disconnected from the bus,
+ * we're not going to expend much effort here: Let's just return
+ * an ABORT_SNOOZE and hope for the best...
+ */
+
+   tmp = (Scsi_Cmnd *)hostdata->disconnected_Q;
+   while (tmp) {
+      if (tmp == cmd) {
+         printk("scsi%d: Abort - command %ld found on disconnected_Q - ",
+                 instance->host_no, cmd->pid);
+         printk("returning ABORT_SNOOZE. ");
+    enable_irq(cmd->host->irq);
+         return SCSI_ABORT_SNOOZE;
+         }
+      tmp = (Scsi_Cmnd *)tmp->host_scribble;
+      }
+
+/*
+ * Case 4 : If we reached this point, the command was not found in any of
+ *     the queues.
+ *
+ * We probably reached this point because of an unlikely race condition
+ * between the command completing successfully and the abortion code,
+ * so we won't panic, but we will notify the user in case something really
+ * broke.
+ */
+
+/*   sti();*/
+   wd33c93_execute (instance);
+
+   enable_irq(cmd->host->irq);
+   printk("scsi%d: warning : SCSI command probably completed successfully"
+      "         before abortion. ", instance->host_no);
+   return SCSI_ABORT_NOT_RUNNING;
 }
 
+
+
 #define MAX_WD33C93_HOSTS 4
 #define MAX_SETUP_ARGS ((int)(sizeof(setup_args) / sizeof(char *)))
 #define SETUP_BUFFER_SIZE 200
@@ -1498,372 +1585,381 @@ static int done_setup = 0;
 
 void wd33c93_setup (char *str, int *ints)
 {
-	int i, x;
-	char *p1, *p2;
-
-	/* The kernel does some processing of the command-line before calling
-	 * this function: If it begins with any decimal or hex number arguments,
-	 * ints[0] = how many numbers found and ints[1] through [n] are the
-	 * values themselves. str points to where the non-numeric arguments
-	 * (if any)
-	 * start: We do our own parsing of those. We construct synthetic
-	 * 'nosync' keywords out of numeric args (to maintain compatibility
-	 * with older versions) and then add the rest of the arguments.
-	 */
-	p1 = setup_buffer;
-	*p1 = '\0';
-	if (ints[0]) {
-		for (i = 0; i < ints[0]; i++) {
-			x = vsprintf(p1, "nosync:0x%02x,", ints[i+1]);
-			p1 += x;
-		}
-	}
-	if (str)
-		strncpy(p1, str, SETUP_BUFFER_SIZE - strlen(setup_buffer));
-	setup_buffer[SETUP_BUFFER_SIZE - 1] = '\0';
-	p1 = setup_buffer;
-	i = 0;
-	while (*p1 && (i < MAX_SETUP_ARGS)) {
-		p2 = strchr(p1, ',');
-		if (p2) {
-			*p2 = '\0';
-			if (p1 != p2)
-				setup_args[i] = p1;
-			p1 = p2 + 1;
-			i++;
-		} else {
-			setup_args[i] = p1;
-			break;
-		}
-	}
-	for (i = 0; i < MAX_SETUP_ARGS; i++)
-		setup_used[i] = 0;
-	done_setup = 1;
+int i,x;
+char *p1,*p2;
+
+   /* The kernel does some processing of the command-line before calling
+    * this function: If it begins with any decimal or hex number arguments,
+    * ints[0] = how many numbers found and ints[1] through [n] are the values
+    * themselves. str points to where the non-numeric arguments (if any)
+    * start: We do our own parsing of those. We construct synthetic 'nosync'
+    * keywords out of numeric args (to maintain compatibility with older
+    * versions) and then add the rest of the arguments.
+    */
+
+   p1 = setup_buffer;
+   *p1 = '\0';
+   if (ints[0]) {
+      for (i=0; i<ints[0]; i++) {
+         x = vsprintf(p1,"nosync:0x%02x,",&(ints[i+1]));
+         p1 += x;
+         }
+      }
+   if (str)
+      strncpy(p1, str, SETUP_BUFFER_SIZE - strlen(setup_buffer));
+   setup_buffer[SETUP_BUFFER_SIZE - 1] = '\0';
+   p1 = setup_buffer;
+   i = 0;
+   while (*p1 && (i < MAX_SETUP_ARGS)) {
+      p2 = strchr(p1, ',');
+      if (p2) {
+         *p2 = '\0';
+         if (p1 != p2)
+            setup_args[i] = p1;
+         p1 = p2 + 1;
+         i++;
+         }
+      else {
+         setup_args[i] = p1;
+         break;
+         }
+      }
+   for (i=0; i<MAX_SETUP_ARGS; i++)
+      setup_used[i] = 0;
+   done_setup = 1;
 }
 
-/* check_setup_args() returns index if key found, 0 if not */
+
+/* check_setup_args() returns index if key found, 0 if not
+ */
+
 static int check_setup_args(char *key, int *flags, int *val, char *buf)
 {
-	int x;
-	char *cp;
-
-	for  (x = 0; x < MAX_SETUP_ARGS; x++) {
-		if (setup_used[x])
-			continue;
-		if (!strncmp(setup_args[x], key, strlen(key)))
-			break;
-		if (!strncmp(setup_args[x], "next", strlen("next")))
-			return 0;
-	}
-	if (x == MAX_SETUP_ARGS)
-		return 0;
-	setup_used[x] = 1;
-	cp = setup_args[x] + strlen(key);
-	*val = -1;
-	if (*cp != ':')
-		return ++x;
-	cp++;
-	if ((*cp >= '0') && (*cp <= '9'))
-		*val = simple_strtoul(cp, NULL, 0);
-
-	return ++x;
+int x;
+char *cp;
+
+   for  (x=0; x<MAX_SETUP_ARGS; x++) {
+      if (setup_used[x])
+         continue;
+      if (!strncmp(setup_args[x], key, strlen(key)))
+         break;
+      if (!strncmp(setup_args[x], "next", strlen("next")))
+         return 0;
+      }
+   if (x == MAX_SETUP_ARGS)
+      return 0;
+   setup_used[x] = 1;
+   cp = setup_args[x] + strlen(key);
+   *val = -1;
+   if (*cp != ':')
+      return ++x;
+   cp++;
+   if ((*cp >= '0') && (*cp <= '9')) {
+      *val = simple_strtoul(cp,NULL,0);
+      }
+   return ++x;
 }
 
+
+
 void wd33c93_init (struct Scsi_Host *instance, wd33c93_regs *regs,
-		   dma_setup_t setup, dma_stop_t stop, int clock_freq)
+         dma_setup_t setup, dma_stop_t stop, int clock_freq)
 {
-	static int shown = 0;
-	struct WD33C93_hostdata *hostdata;
-	int i;
-	int flags;
-	int val;
-	char buf[32];
-
-	if (!done_setup && setup_strings)
-		wd33c93_setup(setup_strings,0);
-	hostdata = INSTHOSTDATA(instance);
-
-	hostdata->regp = regs;
-	hostdata->clock_freq = clock_freq;
-	hostdata->dma_setup = setup;
-	hostdata->dma_stop = stop;
-	hostdata->dma_bounce_buffer = NULL;
-	hostdata->dma_bounce_len = 0;
-	for (i = 0; i < 8; i++) {
-		hostdata->busy[i] = 0;
-		hostdata->sync_xfer[i] =
-			calc_sync_xfer(DEFAULT_SX_PER/4, DEFAULT_SX_OFF);
-		hostdata->sync_stat[i] = SS_UNSET;  /* using default sync values */
-	}
-	hostdata->input_Q = NULL;
-	hostdata->selecting = NULL;
-	hostdata->connected = NULL;
-	hostdata->disconnected_Q = NULL;
-	hostdata->state = S_UNCONNECTED;
-	hostdata->dma = D_DMA_OFF;
-	hostdata->level2 = L2_BASIC;
-	hostdata->disconnect = DIS_ADAPTIVE;
-	hostdata->args = DEBUG_DEFAULTS;
-	hostdata->incoming_ptr = 0;
-	hostdata->outgoing_len = 0;
-	hostdata->default_sx_per = DEFAULT_SX_PER;
-	hostdata->no_sync = 0xff;     /* sync defaults to off */
-	hostdata->no_dma = 0;         /* default is DMA enabled */
+struct WD33C93_hostdata *hostdata;
+int i;
+int flags;
+int val;
+char buf[32];
+
+   if (!done_setup && setup_strings)
+      wd33c93_setup(setup_strings,0);
+
+   hostdata = (struct WD33C93_hostdata *)instance->hostdata;
+
+   hostdata->regp = regs;
+   hostdata->clock_freq = clock_freq;
+   hostdata->dma_setup = setup;
+   hostdata->dma_stop = stop;
+   hostdata->dma_bounce_buffer = NULL;
+   hostdata->dma_bounce_len = 0;
+   for (i = 0; i < 8; i++) {
+      hostdata->busy[i] = 0;
+      hostdata->sync_xfer[i] = calc_sync_xfer(DEFAULT_SX_PER/4,DEFAULT_SX_OFF);
+      hostdata->sync_stat[i] = SS_UNSET;  /* using default sync values */
+#ifdef PROC_STATISTICS
+      hostdata->cmd_cnt[i] = 0;
+      hostdata->disc_allowed_cnt[i] = 0;
+      hostdata->disc_done_cnt[i] = 0;
+#endif
+      }
+   hostdata->input_Q = NULL;
+   hostdata->selecting = NULL;
+   hostdata->connected = NULL;
+   hostdata->disconnected_Q = NULL;
+   hostdata->state = S_UNCONNECTED;
+   hostdata->dma = D_DMA_OFF;
+   hostdata->level2 = L2_BASIC;
+   hostdata->disconnect = DIS_ADAPTIVE;
+   hostdata->args = DEBUG_DEFAULTS;
+   hostdata->incoming_ptr = 0;
+   hostdata->outgoing_len = 0;
+   hostdata->default_sx_per = DEFAULT_SX_PER;
+   hostdata->no_sync = 0xff;     /* sync defaults to off */
+   hostdata->no_dma = 0;         /* default is DMA enabled */
 
 #ifdef PROC_INTERFACE
-	hostdata->proc = PR_VERSION|PR_INFO|PR_STATISTICS|
-	                 PR_CONNECTED|PR_INPUTQ|PR_DISCQ|
-	                 PR_STOP;
+   hostdata->proc = PR_VERSION|PR_INFO|PR_STATISTICS|
+                    PR_CONNECTED|PR_INPUTQ|PR_DISCQ|
+                    PR_STOP;
 #ifdef PROC_STATISTICS
-	hostdata->dma_cnt = 0;
-	hostdata->pio_cnt = 0;
-	hostdata->int_cnt = 0;
+   hostdata->dma_cnt = 0;
+   hostdata->pio_cnt = 0;
+   hostdata->int_cnt = 0;
 #endif
 #endif
 
 
-	if (check_setup_args("nosync",&flags,&val,buf))
-		hostdata->no_sync = val;
-
-	if (check_setup_args("nodma",&flags,&val,buf))
-		hostdata->no_dma = (val == -1) ? 1 : val;
+   if (check_setup_args("nosync",&flags,&val,buf))
+      hostdata->no_sync = val;
 
-	if (check_setup_args("period",&flags,&val,buf))
-		hostdata->default_sx_per =
-			sx_table[round_period((unsigned int)val)].period_ns;
+   if (check_setup_args("nodma",&flags,&val,buf))
+      hostdata->no_dma = (val == -1) ? 1 : val;
 
-	if (check_setup_args("disconnect",&flags,&val,buf)) {
-		if ((val >= DIS_NEVER) && (val <= DIS_ALWAYS))
-			hostdata->disconnect = val;
-		else
-			hostdata->disconnect = DIS_ADAPTIVE;
-	}
+   if (check_setup_args("period",&flags,&val,buf))
+      hostdata->default_sx_per = sx_table[round_period((unsigned int)val)].period_ns;
 
-	if (check_setup_args("level2",&flags,&val,buf))
-		hostdata->level2 = val;
-
-	if (check_setup_args("debug",&flags,&val,buf))
-		hostdata->args = val & DB_MASK;
+   if (check_setup_args("disconnect",&flags,&val,buf)) {
+      if ((val >= DIS_NEVER) && (val <= DIS_ALWAYS))
+         hostdata->disconnect = val;
+      else
+         hostdata->disconnect = DIS_ADAPTIVE;
+      }
 
-	if (check_setup_args("clock",&flags,&val,buf)) {
-		if ((val > 7) && (val < 11))
-			val = WD33C93_FS_8_10;
-		else if ((val > 11) && (val < 16))
-			val = WD33C93_FS_12_15;
-		else if ((val > 15) && (val < 21))
-			val = WD33C93_FS_16_20;
-		else
-			val = WD33C93_FS_8_10;
-		hostdata->clock_freq = val;
-	}
+   if (check_setup_args("level2",&flags,&val,buf))
+      hostdata->level2 = val;
+
+   if (check_setup_args("debug",&flags,&val,buf))
+      hostdata->args = val & DB_MASK;
+
+   if (check_setup_args("clock",&flags,&val,buf)) {
+      if (val>7 && val<11)
+         val = WD33C93_FS_8_10;
+      else if (val>11 && val<16)
+         val = WD33C93_FS_12_15;
+      else if (val>15 && val<21)
+         val = WD33C93_FS_16_20;
+      else
+         val = WD33C93_FS_8_10;
+      hostdata->clock_freq = val;
+      }
 
-	if ((i = check_setup_args("next",&flags,&val,buf))) {
-		while (i)
-			setup_used[--i] = 1;
-	}
+   if ((i = check_setup_args("next",&flags,&val,buf))) {
+      while (i)
+         setup_used[--i] = 1;
+      }
 
 #ifdef PROC_INTERFACE
-	if (check_setup_args("proc",&flags,&val,buf))
-		hostdata->proc = val;
+   if (check_setup_args("proc",&flags,&val,buf))
+      hostdata->proc = val;
 #endif
 
-	{
-		unsigned long flags;
-		save_flags(flags);
-		cli();
-		reset_wd33c93(instance);
-		restore_flags(flags);
-	}
-
-	if(!shown++) {
-		printk("WD93: Driver version %s ", WD33C93_VERSION);
-		printk("compiled on %s at %s\n", __DATE__, __TIME__);
+
+   { unsigned long flags;
+     save_flags(flags);
+     cli();
+     reset_wd33c93(instance);
+     restore_flags(flags);
+   }
+
+   printk("wd33c93-%d: chip=%s/%d no_sync=0x%x no_dma=%d",instance->host_no,
+         (hostdata->chip==C_WD33C93)?"WD33c93":
+         (hostdata->chip==C_WD33C93A)?"WD33c93A":
+         (hostdata->chip==C_WD33C93B)?"WD33c93B":"unknown",
+         hostdata->microcode,hostdata->no_sync,hostdata->no_dma);
 #ifdef DEBUGGING_ON
-		printk(" debug_flags=0x%02x\n",hostdata->args);
+   printk(" debug_flags=0x%02x\n",hostdata->args);
 #else
-		printk(" debugging=OFF\n");
-#endif
-#if 0
-		printk("wd33c93-%d: setup_args=", instance->host_no);
-		for (i = 0; i < MAX_SETUP_ARGS; i++)
-			printk("%s,", setup_args[i]);
-		printk("\n");
-		printk("wd33c93-%d: debug_flags = %04x\n",
-		       instance->host_no, hostdata->args);
+   printk(" debugging=OFF\n");
 #endif
-	}
-
-	printk("wd33c93-%d: chip=%s/%d no_sync=0x%x no_dma=%d",
-	       instance->host_no,
-	       (hostdata->chip==C_WD33C93)?"WD33c93":
-	       (hostdata->chip==C_WD33C93A)?"WD33c93A":
-	       (hostdata->chip==C_WD33C93B)?"WD33c93B":"unknown",
-	       hostdata->microcode,hostdata->no_sync,hostdata->no_dma);
-
-	MOD_INC_USE_COUNT;
+   printk("           setup_args=");
+   for (i=0; i<MAX_SETUP_ARGS; i++)
+      printk("%s,",setup_args[i]);
+   printk("\n");
+   printk("           Version %s - %s, Compiled %s at %s\n",
+               WD33C93_VERSION,WD33C93_DATE,__DATE__,__TIME__);
+   MOD_INC_USE_COUNT;
 }
 
+
 int wd33c93_proc_info(char *buf, char **start, off_t off, int len, int hn, int in)
 {
+
 #ifdef PROC_INTERFACE
-	char *bp;
-	char tbuf[128];
-	unsigned long flags;
-	struct Scsi_Host *instance;
-	struct WD33C93_hostdata *hd;
-	Scsi_Cmnd *cmd;
-	int x,i;
-	static int stop = 0;
-
-	for (instance = scsi_hostlist; instance; instance = instance->next) {
-		if (instance->host_no == hn)
-			break;
-	}
-	if (!instance) {
-		printk("*** Hmm... Can't find host #%d!\n",hn);
-		return (-ESRCH);
-	}
-	hd = (struct WD33C93_hostdata *) instance->hostdata;
-
-	/* If 'in' is TRUE we need to _read_ the proc file. We accept the following
-	 * keywords (same format as command-line, but only ONE per read):
-	 *    debug
-	 *    disconnect
-	 *    period
-	 *    resync
-	 *    proc
-	 *    nodma
-	 */
-	if (in) {
-		buf[len] = '\0';
-		bp = buf;
-		if (!strncmp(bp, "debug:", 6)) {
-			bp += 6;
-			hd->args = simple_strtoul(bp, NULL, 0) & DB_MASK;
-		} else if (!strncmp(bp, "disconnect:", 11)) {
-			bp += 11;
-			x = simple_strtoul(bp, NULL, 0);
-			if ((x < DIS_NEVER) || (x > DIS_ALWAYS))
-				x = DIS_ADAPTIVE;
-			hd->disconnect = x;
-		} else if (!strncmp(bp, "period:", 7)) {
-			bp += 7;
-			x = simple_strtoul(bp, NULL, 0);
-			hd->default_sx_per =
-				sx_table[round_period((unsigned int)x)].period_ns;
-		} else if (!strncmp(bp, "resync:", 7)) {
-			bp += 7;
-			x = simple_strtoul(bp, NULL, 0);
-			for (i = 0; i < 7; i++)
-				if (x & (1<<i))
-					hd->sync_stat[i] = SS_UNSET;
-		} else if (!strncmp(bp, "proc:", 5)) {
-			bp += 5;
-			hd->proc = simple_strtoul(bp, NULL, 0);
-		} else if (!strncmp(bp,"nodma:",6)) {
-			bp += 6;
-			hd->no_dma = simple_strtoul(bp,NULL,0);
-		}
-		else if (!strncmp(bp,"level2:",7)) {
-			bp += 7;
-			hd->level2 = simple_strtoul(bp,NULL,0);
-		}
-
-		return len;
-	}
-
-	save_flags(flags); cli();
-
-	bp = buf;
-	*bp = '\0';
-	if (hd->proc & PR_VERSION) {
-		sprintf(tbuf,"\nVersion %s - %s. Compiled %s %s",
-			WD33C93_VERSION, WD33C93_DATE, __DATE__, __TIME__);
-		strcat(bp, tbuf);
-	}
-	if (hd->proc & PR_INFO) {
-		sprintf(tbuf,"\nclock_freq=%02x no_sync=%02x no_dma=%d",
-		        hd->clock_freq,hd->no_sync,hd->no_dma);
-		strcat(bp,tbuf);
-		strcat(bp,"\nsync_xfer[] =       ");
-		for (x=0; x<7; x++) {
-			sprintf(tbuf,"\t%02x",hd->sync_xfer[x]);
-			strcat(bp,tbuf);
-		}
-		strcat(bp,"\nsync_stat[] =       ");
-		for (x=0; x<7; x++) {
-			sprintf(tbuf,"\t%02x",hd->sync_stat[x]);
-			strcat(bp,tbuf);
-		}
-	}
+
+char *bp;
+char tbuf[128];
+unsigned long flags;
+struct Scsi_Host *instance;
+struct WD33C93_hostdata *hd;
+Scsi_Cmnd *cmd;
+int x,i;
+static int stop = 0;
+
+   for (instance=scsi_hostlist; instance; instance=instance->next) {
+      if (instance->host_no == hn)
+         break;
+      }
+   if (!instance) {
+      printk("*** Hmm... Can't find host #%d!\n",hn);
+      return (-ESRCH);
+      }
+   hd = (struct WD33C93_hostdata *)instance->hostdata;
+
+/* If 'in' is TRUE we need to _read_ the proc file. We accept the following
+ * keywords (same format as command-line, but only ONE per read):
+ *    debug
+ *    disconnect
+ *    period
+ *    resync
+ *    proc
+ *    nodma
+ */
+
+   if (in) {
+      buf[len] = '\0';
+      bp = buf;
+      if (!strncmp(bp,"debug:",6)) {
+         bp += 6;
+         hd->args = simple_strtoul(bp,NULL,0) & DB_MASK;
+         }
+      else if (!strncmp(bp,"disconnect:",11)) {
+         bp += 11;
+         x = simple_strtoul(bp,NULL,0);
+         if (x < DIS_NEVER || x > DIS_ALWAYS)
+            x = DIS_ADAPTIVE;
+         hd->disconnect = x;
+         }
+      else if (!strncmp(bp,"period:",7)) {
+         bp += 7;
+         x = simple_strtoul(bp,NULL,0);
+         hd->default_sx_per = sx_table[round_period((unsigned int)x)].period_ns;
+         }
+      else if (!strncmp(bp,"resync:",7)) {
+         bp += 7;
+         x = simple_strtoul(bp,NULL,0);
+         for (i=0; i<7; i++)
+            if (x & (1<<i))
+               hd->sync_stat[i] = SS_UNSET;
+         }
+      else if (!strncmp(bp,"proc:",5)) {
+         bp += 5;
+         hd->proc = simple_strtoul(bp,NULL,0);
+         }
+      else if (!strncmp(bp,"nodma:",6)) {
+         bp += 6;
+         hd->no_dma = simple_strtoul(bp,NULL,0);
+         }
+      else if (!strncmp(bp,"level2:",7)) {
+         bp += 7;
+         hd->level2 = simple_strtoul(bp,NULL,0);
+         }
+      return len;
+      }
+
+   save_flags(flags);
+   cli();
+   bp = buf;
+   *bp = '\0';
+   if (hd->proc & PR_VERSION) {
+      sprintf(tbuf,"\nVersion %s - %s. Compiled %s %s",
+            WD33C93_VERSION,WD33C93_DATE,__DATE__,__TIME__);
+      strcat(bp,tbuf);
+      }
+   if (hd->proc & PR_INFO) {
+      sprintf(tbuf,"\nclock_freq=%02x no_sync=%02x no_dma=%d",
+            hd->clock_freq,hd->no_sync,hd->no_dma);
+      strcat(bp,tbuf);
+      strcat(bp,"\nsync_xfer[] =       ");
+      for (x=0; x<7; x++) {
+         sprintf(tbuf,"\t%02x",hd->sync_xfer[x]);
+         strcat(bp,tbuf);
+         }
+      strcat(bp,"\nsync_stat[] =       ");
+      for (x=0; x<7; x++) {
+         sprintf(tbuf,"\t%02x",hd->sync_stat[x]);
+         strcat(bp,tbuf);
+         }
+      }
 #ifdef PROC_STATISTICS
-	if (hd->proc & PR_STATISTICS) {
-		strcat(bp,"\ncommands issued:    ");
-		for (x=0; x<7; x++) {
-			sprintf(tbuf,"\t%ld",hd->cmd_cnt[x]);
-			strcat(bp,tbuf);
-		}
-		strcat(bp,"\ndisconnects allowed:");
-		for (x=0; x<7; x++) {
-			sprintf(tbuf,"\t%ld",hd->disc_allowed_cnt[x]);
-			strcat(bp,tbuf);
-		}
-		strcat(bp,"\ndisconnects done:   ");
-		for (x=0; x<7; x++) {
-			sprintf(tbuf,"\t%ld",hd->disc_done_cnt[x]);
-			strcat(bp,tbuf);
-		}
-		sprintf(tbuf,
-		        "\ninterrupts: %ld, DATA_PHASE ints: %ld DMA, %ld PIO",
-		        hd->int_cnt,hd->dma_cnt,hd->pio_cnt);
-		strcat(bp,tbuf);
-	}
+   if (hd->proc & PR_STATISTICS) {
+      strcat(bp,"\ncommands issued:    ");
+      for (x=0; x<7; x++) {
+         sprintf(tbuf,"\t%ld",hd->cmd_cnt[x]);
+         strcat(bp,tbuf);
+         }
+      strcat(bp,"\ndisconnects allowed:");
+      for (x=0; x<7; x++) {
+         sprintf(tbuf,"\t%ld",hd->disc_allowed_cnt[x]);
+         strcat(bp,tbuf);
+         }
+      strcat(bp,"\ndisconnects done:   ");
+      for (x=0; x<7; x++) {
+         sprintf(tbuf,"\t%ld",hd->disc_done_cnt[x]);
+         strcat(bp,tbuf);
+         }
+      sprintf(tbuf,"\ninterrupts: %ld, DATA_PHASE ints: %ld DMA, %ld PIO",
+            hd->int_cnt,hd->dma_cnt,hd->pio_cnt);
+      strcat(bp,tbuf);
+      }
 #endif
-	if (hd->proc & PR_CONNECTED) {
-		strcat(bp, "\nconnected:     ");
-		if (hd->connected) {
-			cmd = (Scsi_Cmnd *) hd->connected;
-			sprintf(tbuf," %ld-%d:%d(%02x)",
-				cmd->pid, cmd->target, cmd->lun, cmd->cmnd[0]);
-			strcat(bp, tbuf);
-		}
-	}
-	if (hd->proc & PR_INPUTQ) {
-		strcat(bp, "\ninput_Q:       ");
-		cmd = (Scsi_Cmnd *) hd->input_Q;
-		while (cmd) {
-			sprintf(tbuf," %ld-%d:%d(%02x)",
-				cmd->pid, cmd->target, cmd->lun, cmd->cmnd[0]);
-			strcat(bp, tbuf);
-			cmd = (Scsi_Cmnd *) cmd->host_scribble;
-		}
-	}
-	if (hd->proc & PR_DISCQ) {
-		strcat(bp, "\ndisconnected_Q:");
-		cmd = (Scsi_Cmnd *) hd->disconnected_Q;
-		while (cmd) {
-			sprintf(tbuf," %ld-%d:%d(%02x)",
-				cmd->pid, cmd->target, cmd->lun, cmd->cmnd[0]);
-			strcat(bp, tbuf);
-			cmd = (Scsi_Cmnd *) cmd->host_scribble;
-		}
-	}
-	strcat(bp, "\n");
-	restore_flags(flags);
-	*start = buf;
-	if (stop) {
-		stop = 0;
-		return 0;
-	}
-	if (off > 0x40000)   /* ALWAYS stop after 256k bytes have been read */
-		stop = 1;;
-	if (hd->proc & PR_STOP)    /* stop every other time */
-		stop = 1;
-	return strlen(bp);
+   if (hd->proc & PR_CONNECTED) {
+      strcat(bp,"\nconnected:     ");
+      if (hd->connected) {
+         cmd = (Scsi_Cmnd *)hd->connected;
+         sprintf(tbuf," %ld-%d:%d(%02x)",
+               cmd->pid, cmd->target, cmd->lun, cmd->cmnd[0]);
+         strcat(bp,tbuf);
+         }
+      }
+   if (hd->proc & PR_INPUTQ) {
+      strcat(bp,"\ninput_Q:       ");
+      cmd = (Scsi_Cmnd *)hd->input_Q;
+      while (cmd) {
+         sprintf(tbuf," %ld-%d:%d(%02x)",
+               cmd->pid, cmd->target, cmd->lun, cmd->cmnd[0]);
+         strcat(bp,tbuf);
+         cmd = (Scsi_Cmnd *)cmd->host_scribble;
+         }
+      }
+   if (hd->proc & PR_DISCQ) {
+      strcat(bp,"\ndisconnected_Q:");
+      cmd = (Scsi_Cmnd *)hd->disconnected_Q;
+      while (cmd) {
+         sprintf(tbuf," %ld-%d:%d(%02x)",
+               cmd->pid, cmd->target, cmd->lun, cmd->cmnd[0]);
+         strcat(bp,tbuf);
+         cmd = (Scsi_Cmnd *)cmd->host_scribble;
+         }
+      }
+   strcat(bp,"\n");
+   restore_flags(flags);
+   *start = buf;
+   if (stop) {
+      stop = 0;
+      return 0;
+      }
+   if (off > 0x40000)   /* ALWAYS stop after 256k bytes have been read */
+      stop = 1;;
+   if (hd->proc & PR_STOP)    /* stop every other time */
+      stop = 1;
+   return strlen(bp);
 
 #else    /* PROC_INTERFACE */
-	return 0;
+
+   return 0;
+
 #endif   /* PROC_INTERFACE */
+
 }
 
 #ifdef MODULE
diff --git a/drivers/scsi/wd33c93.h b/drivers/scsi/wd33c93.h
index c0584037b..0a49ce982 100644
--- a/drivers/scsi/wd33c93.h
+++ b/drivers/scsi/wd33c93.h
@@ -17,12 +17,12 @@
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
+ *
  */
 
 #ifndef WD33C93_H
 #define WD33C93_H
 
-#include <linux/config.h>
 
 #define PROC_INTERFACE     /* add code for /proc/scsi/wd33c93/xxx interface */
 #ifdef  PROC_INTERFACE
@@ -34,8 +34,6 @@
 #define DEBUG_DEFAULTS 0   /* default debugging bitmask */
 
 
-#define ILLEGAL_STATUS_BYTE   0xff
-
 #ifdef DEBUGGING_ON
 #define DB(f,a) if (hostdata->args & (f)) a;
 #else
@@ -44,137 +42,138 @@
 
 #define uchar unsigned char
 
-/* WD register names. */
-#define WD_OWN_ID                0x00 /* Own ID register        */
-#define WD_CONTROL               0x01 /* Control bits           */
-#define WD_TIMEOUT_PERIOD        0x02 /* SCSI timeout period    */
-#define WD_CDB_1                 0x03 /* SCSI command byte 1    */
-#define WD_CDB_2                 0x04 /* SCSI command byte 2    */
-#define WD_CDB_3                 0x05 /* SCSI command byte 3    */
-#define WD_CDB_4                 0x06 /* SCSI command byte 4    */
-#define WD_CDB_5                 0x07 /* SCSI command byte 5    */
-#define WD_CDB_6                 0x08 /* SCSI command byte 6    */
-#define WD_CDB_7                 0x09 /* SCSI command byte 7    */
-#define WD_CDB_8                 0x0a /* SCSI command byte 8    */
-#define WD_CDB_9                 0x0b /* SCSI command byte 9    */
-#define WD_CDB_10                0x0c /* SCSI command byte 10   */
-#define WD_CDB_11                0x0d /* SCSI command byte 11   */
-#define WD_CDB_12                0x0e /* SCSI command byte 12   */
-#define WD_TARGET_LUN            0x0f /* Target | Lun           */
-#define WD_COMMAND_PHASE         0x10 /* Phase register         */
-#define WD_SYNCHRONOUS_TRANSFER  0x11 /* Synchronous indicator  */
-#define WD_TRANSFER_COUNT_MSB    0x12 /* Trans cnt, bits<23:16> */
-#define WD_TRANSFER_COUNT        0x13 /* Trans cnt, bits<15:8>  */
-#define WD_TRANSFER_COUNT_LSB    0x14 /* Trans cnt, bits<7:0>   */
-#define WD_DESTINATION_ID        0x15 /* Dest ID register       */
-#define WD_SOURCE_ID             0x16 /* Src ID register        */
-#define WD_SCSI_STATUS           0x17 /* Status register        */
-#define WD_COMMAND               0x18 /* Command reg            */
-#define WD_DATA                  0x19 /* Data bus bit reg       */
-#define WD_QUEUE_TAG             0x1a /* Queue TAG reg (wd93b)  */
-#define WD_AUXILIARY_STATUS      0x1f /* Aux status reg         */
-
-/* WD commands. */
-#define WD_CMD_RESET             0x00 /* Reset SCSI bus and wd93x chip       */
-#define WD_CMD_ABORT             0x01 /* Stop and abort current action       */
-#define WD_CMD_ASSERT_ATN        0x02 /* Assert ATN on SCSI bus              */
-#define WD_CMD_NEGATE_ACK        0x03 /* De-assert ACK on SCSI bus           */
-#define WD_CMD_DISCONNECT        0x04 /* Causes wd93x to force disconnect    */
-#define WD_CMD_RESELECT          0x05 /* Causes wd93x to reselect as targ    */
-#define WD_CMD_SEL_ATN           0x06 /* Tells wd93x to select w/ATN assrt   */
-#define WD_CMD_SEL               0x07 /* Tells wd93x to select w/o ATN assrt */
-#define WD_CMD_SEL_ATN_XFER      0x08 /* Select w/ATN and transfer data      */
-#define WD_CMD_SEL_XFER          0x09 /* Select w/o ATN and transfer data    */
-#define WD_CMD_RESEL_RECEIVE     0x0a /* Reselect and into receive mode      */
-#define WD_CMD_RESEL_SEND        0x0b /* Reselect and into send mode         */
-#define WD_CMD_WAIT_SEL_RECEIVE  0x0c /* Await selection, into receive mode  */
-#define WD_CMD_TRANS_ADDR        0x18 /* Address translate                   */
-#define WD_CMD_TRANS_INFO        0x20 /* Information transfer                */
-#define WD_CMD_TRANSFER_PAD      0x21 /* Information pad                     */
-#define WD_CMD_SBT_MODE          0x80 /* XXX investigate for this comment    */
-
-/* ASR (Auxiliary Status) register values. */
-#define ASR_INT         (0x80) /* Showing an interrupt                           */
-#define ASR_LCI         (0x40) /* Ignored most recent command                    */
-#define ASR_BSY         (0x20) /* A level II command in progress, therefore busy */
-#define ASR_CIP         (0x10) /* A command is in progress                       */
-#define ASR_PE          (0x02) /* Detected a parity error                        */
-#define ASR_DBR         (0x01) /* The data buffer is ready                       */
-
-/* SCSI Bus Phases. */
-#define PHS_DATA_OUT    (0x00)
-#define PHS_DATA_IN     (0x01)
-#define PHS_COMMAND     (0x02)
-#define PHS_STATUS      (0x03)
-#define PHS_MESS_OUT    (0x06)
-#define PHS_MESS_IN     (0x07)
+
+/* wd register names */
+#define WD_OWN_ID    0x00
+#define WD_CONTROL      0x01
+#define WD_TIMEOUT_PERIOD  0x02
+#define WD_CDB_1     0x03
+#define WD_CDB_2     0x04
+#define WD_CDB_3     0x05
+#define WD_CDB_4     0x06
+#define WD_CDB_5     0x07
+#define WD_CDB_6     0x08
+#define WD_CDB_7     0x09
+#define WD_CDB_8     0x0a
+#define WD_CDB_9     0x0b
+#define WD_CDB_10    0x0c
+#define WD_CDB_11    0x0d
+#define WD_CDB_12    0x0e
+#define WD_TARGET_LUN      0x0f
+#define WD_COMMAND_PHASE   0x10
+#define WD_SYNCHRONOUS_TRANSFER 0x11
+#define WD_TRANSFER_COUNT_MSB 0x12
+#define WD_TRANSFER_COUNT  0x13
+#define WD_TRANSFER_COUNT_LSB 0x14
+#define WD_DESTINATION_ID  0x15
+#define WD_SOURCE_ID    0x16
+#define WD_SCSI_STATUS     0x17
+#define WD_COMMAND      0x18
+#define WD_DATA      0x19
+#define WD_QUEUE_TAG    0x1a
+#define WD_AUXILIARY_STATUS   0x1f
+
+/* WD commands */
+#define WD_CMD_RESET    0x00
+#define WD_CMD_ABORT    0x01
+#define WD_CMD_ASSERT_ATN  0x02
+#define WD_CMD_NEGATE_ACK  0x03
+#define WD_CMD_DISCONNECT  0x04
+#define WD_CMD_RESELECT    0x05
+#define WD_CMD_SEL_ATN     0x06
+#define WD_CMD_SEL      0x07
+#define WD_CMD_SEL_ATN_XFER   0x08
+#define WD_CMD_SEL_XFER    0x09
+#define WD_CMD_RESEL_RECEIVE  0x0a
+#define WD_CMD_RESEL_SEND  0x0b
+#define WD_CMD_WAIT_SEL_RECEIVE 0x0c
+#define WD_CMD_TRANS_ADDR  0x18
+#define WD_CMD_TRANS_INFO  0x20
+#define WD_CMD_TRANSFER_PAD   0x21
+#define WD_CMD_SBT_MODE    0x80
+
+/* ASR register */
+#define ASR_INT         (0x80)
+#define ASR_LCI         (0x40)
+#define ASR_BSY         (0x20)
+#define ASR_CIP         (0x10)
+#define ASR_PE          (0x02)
+#define ASR_DBR         (0x01)
+
+/* SCSI Bus Phases */
+#define PHS_DATA_OUT    0x00
+#define PHS_DATA_IN     0x01
+#define PHS_COMMAND     0x02
+#define PHS_STATUS      0x03
+#define PHS_MESS_OUT    0x06
+#define PHS_MESS_IN     0x07
 
 /* Command Status Register definitions */
 
-/* reset state interrupts */
-#define CSR_RESET          0x00
-#define CSR_RESET_AF       0x01
+  /* reset state interrupts */
+#define CSR_RESET    0x00
+#define CSR_RESET_AF    0x01
 
-/* successful completion interrupts */
-#define CSR_RESELECT       0x10
-#define CSR_SELECT         0x11
+  /* successful completion interrupts */
+#define CSR_RESELECT    0x10
+#define CSR_SELECT      0x11
 #define CSR_SEL_XFER_DONE  0x16
 #define CSR_XFER_DONE      0x18
 
-/* paused or aborted interrupts */
-#define CSR_MSGIN          0x20
-#define CSR_SDP            0x21
+  /* paused or aborted interrupts */
+#define CSR_MSGIN    0x20
+#define CSR_SDP         0x21
 #define CSR_SEL_ABORT      0x22
 #define CSR_RESEL_ABORT    0x25
 #define CSR_RESEL_ABORT_AM 0x27
-#define CSR_ABORT          0x28
+#define CSR_ABORT    0x28
 
-/* terminated interrupts */
-#define CSR_INVALID        0x40
+  /* terminated interrupts */
+#define CSR_INVALID     0x40
 #define CSR_UNEXP_DISC     0x41
-#define CSR_TIMEOUT        0x42
-#define CSR_PARITY         0x43
+#define CSR_TIMEOUT     0x42
+#define CSR_PARITY      0x43
 #define CSR_PARITY_ATN     0x44
 #define CSR_BAD_STATUS     0x45
-#define CSR_UNEXP          0x48
-
-/* service required interrupts */
-#define CSR_RESEL          0x80
-#define CSR_RESEL_AM       0x81
-#define CSR_DISC           0x85
-#define CSR_SRV_REQ        0x88
-
-/* Own ID/CDB Size register */
-#define OWNID_EAF          0x08
-#define OWNID_EHP          0x10
-#define OWNID_RAF          0x20
-#define OWNID_FS_8         0x00
-#define OWNID_FS_12        0x40
-#define OWNID_FS_16        0x80
-
-/* define these so we don't have to change a2091.c, etc. */
-#define WD33C93_FS_8_10    OWNID_FS_8
-#define WD33C93_FS_12_15   OWNID_FS_12
-#define WD33C93_FS_16_20   OWNID_FS_16
-
-/* Control register */
-#define CTRL_HSP           0x01
-#define CTRL_HA            0x02
-#define CTRL_IDI           0x04
-#define CTRL_EDI           0x08
-#define CTRL_HHP           0x10
-#define CTRL_POLLED        0x00
-#define CTRL_BURST         0x20
-#define CTRL_BUS           0x40
-#define CTRL_DMA           0x80
-
-/* Timeout Period register */
+#define CSR_UNEXP    0x48
+
+  /* service required interrupts */
+#define CSR_RESEL    0x80
+#define CSR_RESEL_AM    0x81
+#define CSR_DISC     0x85
+#define CSR_SRV_REQ     0x88
+
+   /* Own ID/CDB Size register */
+#define OWNID_EAF    0x08
+#define OWNID_EHP    0x10
+#define OWNID_RAF    0x20
+#define OWNID_FS_8   0x00
+#define OWNID_FS_12  0x40
+#define OWNID_FS_16  0x80
+
+   /* define these so we don't have to change a2091.c, etc. */
+#define WD33C93_FS_8_10  OWNID_FS_8
+#define WD33C93_FS_12_15 OWNID_FS_12
+#define WD33C93_FS_16_20 OWNID_FS_16
+
+   /* Control register */
+#define CTRL_HSP     0x01
+#define CTRL_HA      0x02
+#define CTRL_IDI     0x04
+#define CTRL_EDI     0x08
+#define CTRL_HHP     0x10
+#define CTRL_POLLED  0x00
+#define CTRL_BURST   0x20
+#define CTRL_BUS     0x40
+#define CTRL_DMA     0x80
+
+   /* Timeout Period register */
 #define TIMEOUT_PERIOD_VALUE  20    /* 20 = 200 ms */
 
-/* Synchronous Transfer Register */
+   /* Synchronous Transfer Register */
 #define STR_FSS      0x80
 
-/* Destination ID register */
+   /* Destination ID register */
 #define DSTID_DPD    0x40
 #define DATA_OUT_DIR 0
 #define DATA_IN_DIR  1
@@ -189,17 +188,21 @@
 
    /* This is what the 3393 chip looks like to us */
 typedef struct {
-	volatile unsigned char   SASR;
-	char                     pad;
+   volatile unsigned char   SASR;
+   char                     pad;
 #ifdef CONFIG_SGI
-	char                     pad2, pad3; /* HPC is funny like this... */
+   char                     pad2,pad3;
 #endif
-	volatile unsigned char   SCMD;
+   volatile unsigned char   SCMD;
 } wd33c93_regs;
 
+
 typedef int (*dma_setup_t) (Scsi_Cmnd *SCpnt, int dir_in);
 typedef void (*dma_stop_t) (struct Scsi_Host *instance, Scsi_Cmnd *SCpnt,
-			    int status);
+             int status);
+
+
+#define ILLEGAL_STATUS_BYTE   0xff
 
 #define DEFAULT_SX_PER   376     /* (ns) fairly safe */
 #define DEFAULT_SX_OFF   0       /* aka async */
@@ -208,69 +211,70 @@ typedef void (*dma_stop_t) (struct Scsi_Host *instance, Scsi_Cmnd *SCpnt,
 #define OPTIMUM_SX_OFF   12      /* size of wd3393 fifo */
 
 struct sx_period {
-	unsigned int   period_ns;
-	uchar          reg_value;
-};
+   unsigned int   period_ns;
+   uchar          reg_value;
+   };
 
 /* FEF: defines for hostdata->dma_buffer_pool */
+
 #define BUF_CHIP_ALLOCED 0
 #define BUF_SCSI_ALLOCED 1
 
 struct WD33C93_hostdata {
-	struct Scsi_Host *next;
-	wd33c93_regs     *regp;
-	uchar            clock_freq;
-	uchar            chip;             /* what kind of wd33c93? */
-	uchar            microcode;        /* microcode rev */
-	int              dma_dir;          /* data transfer dir. */
-	dma_setup_t      dma_setup;
-	dma_stop_t       dma_stop;
-	unsigned int     dma_xfer_mask;
-	uchar            *dma_bounce_buffer;
-	unsigned int     dma_bounce_len;
-	uchar            dma_buffer_pool;  /* FEF: buffer from chip_ram? */
-	volatile uchar   busy[8];          /* index = target, bit = lun */
-	volatile Scsi_Cmnd *input_Q;       /* commands waiting to be started */
-	volatile Scsi_Cmnd *selecting;     /* trying to select this command */
-	volatile Scsi_Cmnd *connected;     /* currently connected command */
-	volatile Scsi_Cmnd *disconnected_Q;/* commands waiting for reconnect */
-	uchar            state;            /* what we are currently doing */
-	uchar            dma;              /* current state of DMA (on/off) */
-	uchar            level2;           /* extent to which Level-2 commands are used */
-	uchar            disconnect;       /* disconnect/reselect policy */
-	unsigned int     args;             /* set from command-line argument */
-	uchar            incoming_msg[8];  /* filled during message_in phase */
-	int              incoming_ptr;     /* mainly used with EXTENDED messages */
-	uchar            outgoing_msg[8];  /* send this during next message_out */
-	int              outgoing_len;     /* length of outgoing message */
-	unsigned int     default_sx_per;   /* default transfer period for SCSI bus */
-	uchar            sync_xfer[8];     /* sync_xfer reg settings per target */
-	uchar            sync_stat[8];     /* status of sync negotiation per target */
-	uchar            no_sync;          /* bitmask: don't do sync on these targets */
-	uchar            no_dma;           /* set this flag to disable DMA */
+    struct Scsi_Host *next;
+    wd33c93_regs     *regp;
+    uchar            clock_freq;
+    uchar            chip;             /* what kind of wd33c93? */
+    uchar            microcode;        /* microcode rev */
+    int              dma_dir;          /* data transfer dir. */
+    dma_setup_t      dma_setup;
+    dma_stop_t       dma_stop;
+    unsigned int     dma_xfer_mask;
+    uchar            *dma_bounce_buffer;
+    unsigned int     dma_bounce_len;
+    uchar            dma_buffer_pool;  /* FEF: buffer from chip_ram? */
+    volatile uchar   busy[8];          /* index = target, bit = lun */
+    volatile Scsi_Cmnd *input_Q;       /* commands waiting to be started */
+    volatile Scsi_Cmnd *selecting;     /* trying to select this command */
+    volatile Scsi_Cmnd *connected;     /* currently connected command */
+    volatile Scsi_Cmnd *disconnected_Q;/* commands waiting for reconnect */
+    uchar            state;            /* what we are currently doing */
+    uchar            dma;              /* current state of DMA (on/off) */
+    uchar            level2;           /* extent to which Level-2 commands are used */
+    uchar            disconnect;       /* disconnect/reselect policy */
+    unsigned int     args;             /* set from command-line argument */
+    uchar            incoming_msg[8];  /* filled during message_in phase */
+    int              incoming_ptr;     /* mainly used with EXTENDED messages */
+    uchar            outgoing_msg[8];  /* send this during next message_out */
+    int              outgoing_len;     /* length of outgoing message */
+    unsigned int     default_sx_per;   /* default transfer period for SCSI bus */
+    uchar            sync_xfer[8];     /* sync_xfer reg settings per target */
+    uchar            sync_stat[8];     /* status of sync negotiation per target */
+    uchar            no_sync;          /* bitmask: don't do sync on these targets */
+    uchar            no_dma;           /* set this flag to disable DMA */
 #ifdef PROC_INTERFACE
-	uchar            proc;             /* bitmask: what's in proc output */
+    uchar            proc;             /* bitmask: what's in proc output */
 #ifdef PROC_STATISTICS
-	unsigned long    cmd_cnt[8];       /* # of commands issued per target */
-	unsigned long    int_cnt;          /* # of interrupts serviced */
-	unsigned long    pio_cnt;          /* # of pio data transfers */
-	unsigned long    dma_cnt;          /* # of DMA data transfers */
-	unsigned long    disc_allowed_cnt[8]; /* # of disconnects allowed per target */
-	unsigned long    disc_done_cnt[8]; /* # of disconnects done per target*/
+    unsigned long    cmd_cnt[8];       /* # of commands issued per target */
+    unsigned long    int_cnt;          /* # of interrupts serviced */
+    unsigned long    pio_cnt;          /* # of pio data transfers */
+    unsigned long    dma_cnt;          /* # of DMA data transfers */
+    unsigned long    disc_allowed_cnt[8]; /* # of disconnects allowed per target */
+    unsigned long    disc_done_cnt[8]; /* # of disconnects done per target*/
 #endif
 #endif
-};
+    };
 
-#define CMDHOSTDATA(cmd)   ((struct WD33C93_hostdata *) (cmd)->host->hostdata)
-#define INSTHOSTDATA(inst) ((struct WD33C93_hostdata *) (inst)->hostdata)
 
 /* defines for hostdata->chip */
-#define C_WD33C93             0
-#define C_WD33C93A            1
-#define C_WD33C93B            2
-#define C_UNKNOWN_CHIP        100
+
+#define C_WD33C93       0
+#define C_WD33C93A      1
+#define C_WD33C93B      2
+#define C_UNKNOWN_CHIP  100
 
 /* defines for hostdata->state */
+
 #define S_UNCONNECTED         0
 #define S_SELECTING           1
 #define S_RUNNING_LEVEL2      2
@@ -279,18 +283,15 @@ struct WD33C93_hostdata {
 #define S_PRE_CMP_DISC        5
 
 /* defines for hostdata->dma */
-#define D_DMA_OFF             0
-#define D_DMA_RUNNING         1
+
+#define D_DMA_OFF          0
+#define D_DMA_RUNNING      1
 
 /* defines for hostdata->level2 */
 /* NOTE: only the first 3 are implemented so far */
 
-/*  (The first 8 bits are reserved for compatibility. They function */
-#if 0
+#define L2_NONE      1  /* no combination commands - we get lots of ints */
 #define L2_SELECT    2  /* start with SEL_ATN_XFER, but never resume it */
-#endif
-
-#define L2_NONE      0
 #define L2_BASIC     3  /* resume after STATUS ints & RDP messages */
 #define L2_DATA      4  /* resume after DATA_IN/OUT ints */
 #define L2_MOST      5  /* resume after anything except a RESELECT int */
@@ -298,37 +299,42 @@ struct WD33C93_hostdata {
 #define L2_ALL       7  /* always resume */
 
 /* defines for hostdata->disconnect */
+
 #define DIS_NEVER    0
 #define DIS_ADAPTIVE 1
 #define DIS_ALWAYS   2
 
 /* defines for hostdata->args */
-#define DB_TEST1              (1<<0)
-#define DB_TEST2              (1<<1)
-#define DB_QCMD               (1<<2)
-#define DB_EXECUTE            (1<<3)
-#define DB_INTR               (1<<4)
-#define DB_TRANSFER           (1<<5)
-#define DB_MASK               (0x3f)
+
+#define DB_TEST1              1<<0
+#define DB_TEST2              1<<1
+#define DB_QUEUE_COMMAND      1<<2
+#define DB_EXECUTE            1<<3
+#define DB_INTR               1<<4
+#define DB_TRANSFER           1<<5
+#define DB_MASK               0x3f
 
 /* defines for hostdata->sync_stat[] */
+
 #define SS_UNSET     0
 #define SS_FIRST     1
 #define SS_WAITING   2
 #define SS_SET       3
 
 /* defines for hostdata->proc */
-#define PR_VERSION   (1<<0)
-#define PR_INFO      (1<<1)
-#define PR_STATISTICS (1<<2)
-#define PR_CONNECTED (1<<3)
-#define PR_INPUTQ    (1<<4)
-#define PR_DISCQ     (1<<5)
-#define PR_TEST      (1<<6)
-#define PR_STOP      (1<<7)
+
+#define PR_VERSION   1<<0
+#define PR_INFO      1<<1
+#define PR_STATISTICS 1<<2
+#define PR_CONNECTED 1<<3
+#define PR_INPUTQ    1<<4
+#define PR_DISCQ     1<<5
+#define PR_TEST      1<<6
+#define PR_STOP      1<<7
+
 
 void wd33c93_init (struct Scsi_Host *instance, wd33c93_regs *regs,
-		   dma_setup_t setup, dma_stop_t stop, int clock_freq);
+         dma_setup_t setup, dma_stop_t stop, int clock_freq);
 int wd33c93_abort (Scsi_Cmnd *cmd);
 int wd33c93_queuecommand (Scsi_Cmnd *cmd, void (*done)(Scsi_Cmnd *));
 void wd33c93_intr (struct Scsi_Host *instance);