[PATCH] next NCR5380 updates

Fix more locking, do a major rethink on the bh handling (now workqueue)

drivers/scsi/Config.in

@@ -92,12 +92,10 @@ if [ "$CONFIG_MCA" = "y" ]; then
    dep_tristate 'Future Domain MCS-600/700 SCSI support' CONFIG_SCSI_FD_MCS $CONFIG_SCSI
 fi
 dep_tristate 'Intel/ICP (former GDT SCSI Disk Array) RAID Controller support' CONFIG_SCSI_GDTH $CONFIG_SCSI
-dep_tristate 'Generic NCR5380/53c400 SCSI support' CONFIG_SCSI_GENERIC_NCR5380 $CONFIG_SCSI
+dep_tristate 'Generic NCR5380/53c400 SCSI PIO support' CONFIG_SCSI_GENERIC_NCR5380 $CONFIG_SCSI
+dep_tristate 'Generic NCR5380/53c400 SCSI MMIO support' CONFIG_SCSI_GENERIC_NCR5380_MMIO $CONFIG_SCSI
 if [ "$CONFIG_SCSI_GENERIC_NCR5380" != "n" ]; then
    bool '  Enable NCR53c400 extensions' CONFIG_SCSI_GENERIC_NCR53C400
-   choice 'NCR5380/53c400 mapping method (use Port for T130B)' \
-		"Port CONFIG_SCSI_G_NCR5380_PORT \
-		 Memory CONFIG_SCSI_G_NCR5380_MEM" Port
 fi
 if [ "$CONFIG_MCA" = "y" ]; then
    dep_tristate 'IBMMCA SCSI support' CONFIG_SCSI_IBMMCA $CONFIG_SCSI

drivers/scsi/Makefile

@@ -65,6 +65,7 @@ obj-$(CONFIG_SCSI_FD_MCS)	+= fd_mcs.o
 obj-$(CONFIG_SCSI_FUTURE_DOMAIN)+= fdomain.o
 obj-$(CONFIG_SCSI_IN2000)	+= in2000.o
 obj-$(CONFIG_SCSI_GENERIC_NCR5380) += g_NCR5380.o
+obj-$(CONFIG_SCSI_GENERIC_NCR5380_MMIO) += g_NCR5380_mmio.o
 obj-$(CONFIG_SCSI_NCR53C406A)	+= NCR53c406a.o
 obj-$(CONFIG_SCSI_NCR_D700)	+= NCR_D700.o 53c700.o
 obj-$(CONFIG_SCSI_SYM53C416)	+= sym53c416.o

drivers/scsi/NCR5380.c

-#ifndef NDEBUG
-#define NDEBUG (NDEBUG_RESTART_SELECT | NDEBUG_ABORT)
-#endif
 /* 
  * NCR 5380 generic driver routines.  These should make it *trivial*
  *      to implement 5380 SCSI drivers under Linux with a non-trantor
@@ -316,8 +313,8 @@
 
 static int do_abort(struct Scsi_Host *host);
 static void do_reset(struct Scsi_Host *host);
-static struct Scsi_Host *first_instance = NULL;
-static Scsi_Host_Template *the_template = NULL;
+static struct NCR5380_hostdata *first_host = NULL;
+static struct NCR5380_hostdata *last_host = NULL;
 static struct timer_list usleep_timer;
 
 /*
@@ -348,7 +345,18 @@ static __inline__ void initialize_SCp(Scsi_Cmnd * cmd)
 	}
 }
 
-#include <linux/delay.h>
+static struct {
+	unsigned char value;
+	const char *name;
+} phases[] = {
+	{PHASE_DATAOUT, "DATAOUT"}, 
+	{PHASE_DATAIN, "DATAIN"}, 
+	{PHASE_CMDOUT, "CMDOUT"}, 
+	{PHASE_STATIN, "STATIN"}, 
+	{PHASE_MSGOUT, "MSGOUT"}, 
+	{PHASE_MSGIN, "MSGIN"}, 
+	{PHASE_UNKNOWN, "UNKNOWN"}
+};
 
 #ifdef NDEBUG
 static struct {
@@ -430,18 +438,6 @@ static void NCR5380_print(struct Scsi_Host *instance)
 	printk("\n");
 }
 
-static struct {
-	unsigned char value;
-	const char *name;
-} phases[] = {
-	{PHASE_DATAOUT, "DATAOUT"}, 
-	{PHASE_DATAIN, "DATAIN"}, 
-	{PHASE_CMDOUT, "CMDOUT"}, 
-	{PHASE_STATIN, "STATIN"}, 
-	{PHASE_MSGOUT, "MSGOUT"}, 
-	{PHASE_MSGIN, "MSGIN"}, 
-	{PHASE_UNKNOWN, "UNKNOWN"}
-};
 
 /* 
  *	NCR5380_print_phase	-	show SCSI phase
@@ -469,44 +465,6 @@ static void NCR5380_print_phase(struct Scsi_Host *instance)
 }
 #endif
 
-/*
- * We need to have our coroutine active given these constraints : 
- * 1.  The mutex flag, main_running, can only be set when the main 
- *     routine can actually process data, otherwise SCSI commands
- *     will never get issued.
- *
- * 2.  NCR5380_main() shouldn't be called before it has exited, because
- *     other drivers have had kernel stack overflows in similar
- *     situations.
- *
- * 3.  We don't want to inline NCR5380_main() because of space concerns,
- *     even though it is only called in two places.
- *
- * So, the solution is to set the mutex in an inline wrapper for the 
- * main coroutine, and have the main coroutine exit with interrupts 
- * disabled after the final search through the queues so that no race 
- * conditions are possible.
- */
-
-static unsigned long main_running = 0;
-
-/* 
- * Function : run_main(void)
- * 
- * Purpose : insure that the coroutine is running and will process our 
- *      request.  main_running is checked/set here (in an inline function)
- *      rather than in NCR5380_main itself to reduce the chances of stack
- *      overflow.
- * FIXME: NCR5380_main should probably be run with schedule_task or be a
- * thread.
- */
-
-static __inline__ void run_main(void)
-{
-	if (!test_and_set_bit(0, &main_running))
-		NCR5380_main();
-}
-
 /*
  * These need tweaking, and would probably work best as per-device 
  * flags initialized differently for disk, tape, cd, etc devices.
@@ -621,13 +579,17 @@ static int NCR5380_set_timer(struct Scsi_Host *instance)
 static void NCR5380_timer_fn(unsigned long unused)
 {
 	struct Scsi_Host *instance;
+	struct NCR5380_hostdata *hostdata;
 	unsigned long flags;
 
 	spin_lock_irqsave(&timer_lock, flags);
-	for (; expires_first && time_before_eq(((struct NCR5380_hostdata *) expires_first->hostdata)->time_expires, jiffies);) {
-		instance = ((struct NCR5380_hostdata *) expires_first->hostdata)->next_timer;
-		((struct NCR5380_hostdata *) expires_first->hostdata)->next_timer = NULL;
-		((struct NCR5380_hostdata *) expires_first->hostdata)->time_expires = 0;
+	for (; expires_first && time_before_eq(((struct NCR5380_hostdata *) expires_first->hostdata)->time_expires, jiffies);) 
+	{
+		hostdata = (struct NCR5380_hostdata *) expires_first->hostdata;
+		schedule_work(&hostdata->coroutine);
+		instance = hostdata->next_timer;
+		hostdata->next_timer = NULL;
+		hostdata->time_expires = 0;
 		expires_first = instance;
 	}
 
@@ -636,10 +598,7 @@ static void NCR5380_timer_fn(unsigned long unused)
 		usleep_timer.expires = ((struct NCR5380_hostdata *) expires_first->hostdata)->time_expires;
 		add_timer(&usleep_timer);
 	}
-
 	spin_unlock_irqrestore(&timer_lock, flags);
-	
-	run_main();
 }
 
 /**
@@ -778,6 +737,22 @@ static void __init NCR5380_print_options(struct Scsi_Host *instance)
 	}
 }
 
+/**
+ *	NCR5380_coroutine_running	-	coroutine status
+ *	@instance: controller to check
+ *
+ *	Return true if the co-routine for this controller is running
+ *	or scheduled to run
+ *
+ *	FIXME: this test function belongs in the workqueue code!
+ */
+ 
+static int NCR5380_coroutine_running(struct Scsi_Host *instance)
+{
+	struct NCR5380_hostdata *hostdata = (struct NCR5380_hostdata *)instance->hostdata;
+	return test_bit(0, &hostdata->coroutine.pending);
+}
+
 /**
  *	NCR5380_print_status 	-	dump controller info
  *	@instance: controller to dump
@@ -794,7 +769,7 @@ static void NCR5380_print_status(struct Scsi_Host *instance)
 	char *start;
 	int len;
 
-	printk("NCR5380 : coroutine is%s running.\n", main_running ? "" : "n't");
+	printk("NCR5380 : coroutine is%s running.\n",  NCR5380_coroutine_running(instance)? "" : "n't");
 
 	NCR5380_dprint(NDEBUG_ANY, instance);
 	NCR5380_dprint_phase(NDEBUG_ANY, instance);
@@ -837,7 +812,7 @@ int NCR5380_proc_info(char *buffer, char **start, off_t offset, int length, int
 	struct NCR5380_hostdata *hostdata;
 	Scsi_Cmnd *ptr;
 
-	for (instance = first_instance; instance && instance->host_no != hostno; instance = instance->next);
+	instance = scsi_host_hn_get(hostno);
 	if (!instance)
 		return (-ESRCH);
 	hostdata = (struct NCR5380_hostdata *) instance->hostdata;
@@ -881,7 +856,7 @@ int NCR5380_proc_info(char *buffer, char **start, off_t offset, int length, int
 	SPRINTF("Highwater I/O busy_spin_counts -- write: %d  read: %d\n", pas_wmaxi, pas_maxi);
 #endif
 	spin_lock_irq(instance->host_lock);
-	SPRINTF("NCR5380 : coroutine is%s running.\n", main_running ? "" : "n't");
+	SPRINTF("NCR5380 : coroutine is%s running.\n", NCR5380_coroutine_running(instance) ? "" : "n't");
 	if (!hostdata->connected)
 		SPRINTF("scsi%d: no currently connected command\n", instance->host_no);
 	else
@@ -904,8 +879,7 @@ int NCR5380_proc_info(char *buffer, char **start, off_t offset, int length, int
 	return length;
 }
 
-static
-char *lprint_Scsi_Cmnd(Scsi_Cmnd * cmd, char *pos, char *buffer, int length)
+static char *lprint_Scsi_Cmnd(Scsi_Cmnd * cmd, char *pos, char *buffer, int length)
 {
 	SPRINTF("scsi%d : destination target %d, lun %d\n", cmd->host->host_no, cmd->target, cmd->lun);
 	SPRINTF("        command = ");
@@ -913,8 +887,7 @@ char *lprint_Scsi_Cmnd(Scsi_Cmnd * cmd, char *pos, char *buffer, int length)
 	return (pos);
 }
 
-static
-char *lprint_command(unsigned char *command, char *pos, char *buffer, int length)
+static char *lprint_command(unsigned char *command, char *pos, char *buffer, int length)
 {
 	int i, s;
 	pos = lprint_opcode(command[0], pos, buffer, length);
@@ -924,8 +897,7 @@ char *lprint_command(unsigned char *command, char *pos, char *buffer, int length
 	return (pos);
 }
 
-static
-char *lprint_opcode(int opcode, char *pos, char *buffer, int length)
+static char *lprint_opcode(int opcode, char *pos, char *buffer, int length)
 {
 	SPRINTF("%2d (0x%02x)", opcode, opcode);
 	return (pos);
@@ -943,10 +915,12 @@ char *lprint_opcode(int opcode, char *pos, char *buffer, int length)
  *	Notes : I assume that the host, hostno, and id bits have been
  *      set correctly.  I don't care about the irq and other fields. 
  *
+ *	Returns 0 for success
+ *
  *	Locks: interrupts must be enabled when we are called 
  */
 
-static void __init NCR5380_init(struct Scsi_Host *instance, int flags)
+static int __init NCR5380_init(struct Scsi_Host *instance, int flags)
 {
 	NCR5380_local_declare();
 	int i, pass;
@@ -982,6 +956,9 @@ static void __init NCR5380_init(struct Scsi_Host *instance, int flags)
 	hostdata->connected = NULL;
 	hostdata->issue_queue = NULL;
 	hostdata->disconnected_queue = NULL;
+	
+	INIT_WORK(&hostdata->coroutine, NCR5380_main, hostdata);
+	
 #ifdef NCR5380_STATS
 	for (i = 0; i < 8; ++i) {
 		hostdata->time_read[i] = 0;
@@ -1000,10 +977,16 @@ static void __init NCR5380_init(struct Scsi_Host *instance, int flags)
 	else
 		hostdata->flags = FLAG_CHECK_LAST_BYTE_SENT | flags;
 
-	if (!the_template) {
-		the_template = instance->hostt;
-		first_instance = instance;
-	}
+	hostdata->next = NULL;
+	
+	if (!first_host)
+		first_host = hostdata;
+	else
+		last_host->next = hostdata;
+
+	last_host = hostdata;
+	
+	hostdata->host = instance;
 	hostdata->time_expires = 0;
 	hostdata->next_timer = NULL;
 
@@ -1041,22 +1024,28 @@ static void __init NCR5380_init(struct Scsi_Host *instance, int flags)
 		case 1:
 		case 3:
 		case 5:
-			printk("scsi%d: SCSI bus busy, waiting up to five seconds\n", instance->host_no);
+			printk(KERN_INFO "scsi%d: SCSI bus busy, waiting up to five seconds\n", instance->host_no);
 			timeout = jiffies + 5 * HZ;
-			while (time_before(jiffies, timeout) && (NCR5380_read(STATUS_REG) & SR_BSY));
+			while (time_before(jiffies, timeout) && (NCR5380_read(STATUS_REG) & SR_BSY))
+			{
+				set_current_state(TASK_UNINTERRUPTIBLE);
+				schedule_timeout(1);
+			}
 			break;
 		case 2:
-			printk("scsi%d: bus busy, attempting abort\n", instance->host_no);
+			printk(KERN_WARNING "scsi%d: bus busy, attempting abort\n", instance->host_no);
 			do_abort(instance);
 			break;
 		case 4:
-			printk("scsi%d: bus busy, attempting reset\n", instance->host_no);
+			printk(KERN_WARNING "scsi%d: bus busy, attempting reset\n", instance->host_no);
 			do_reset(instance);
 			break;
 		case 6:
-			printk("scsi%d: bus locked solid or invalid override\n", instance->host_no);
+			printk(KERN_ERR "scsi%d: bus locked solid or invalid override\n", instance->host_no);
+			return -ENXIO;
 		}
 	}
+	return 0;
 }
 
 /**
@@ -1072,15 +1061,11 @@ static void __init NCR5380_init(struct Scsi_Host *instance, int flags)
  *	retake this lock. Called functions take dma lock.
  */
 
-/* Only make static if a wrapper function is used */
-#ifndef NCR5380_queue_command
-static
-#endif
-int NCR5380_queue_command(Scsi_Cmnd * cmd, void (*done) (Scsi_Cmnd *)) {
+static int NCR5380_queue_command(Scsi_Cmnd * cmd, void (*done) (Scsi_Cmnd *)) 
+{
 	struct Scsi_Host *instance = cmd->host;
 	struct NCR5380_hostdata *hostdata = (struct NCR5380_hostdata *) instance->hostdata;
 	Scsi_Cmnd *tmp;
-	unsigned long flags;
 
 #if (NDEBUG & NDEBUG_NO_WRITE)
 	switch (cmd->cmnd[0]) {
@@ -1093,7 +1078,6 @@ int NCR5380_queue_command(Scsi_Cmnd * cmd, void (*done) (Scsi_Cmnd *)) {
 	}
 #endif				/* (NDEBUG & NDEBUG_NO_WRITE) */
 
-	spin_lock_irqsave(instance->host_lock, flags);
 #ifdef NCR5380_STATS
 	switch (cmd->cmnd[0]) {
 		case WRITE:
@@ -1141,9 +1125,8 @@ int NCR5380_queue_command(Scsi_Cmnd * cmd, void (*done) (Scsi_Cmnd *)) {
 	dprintk(NDEBUG_QUEUES, ("scsi%d : command added to %s of queue\n", instance->host_no, (cmd->cmnd[0] == REQUEST_SENSE) ? "head" : "tail"));
 
 	/* Run the coroutine if it isn't already running. */
-	spin_unlock_irqrestore(instance->host_lock, flags);
-	
-	run_main();
+	/* Kick off command processing */
+	schedule_work(&hostdata->coroutine);
 	return 0;
 }
 
@@ -1155,21 +1138,22 @@ int NCR5380_queue_command(Scsi_Cmnd * cmd, void (*done) (Scsi_Cmnd *)) {
  *      NCR5380_queue_command() and NCR5380_intr() will try to start it 
  *      in case it is not running.
  * 
- *	Locks; The caller must hold the io_request_lock. The lock will still be
- *	held on return but may be dropped while running. Called functions take
- *	the DMA lock.
+ *	Locks: called as its own thread with no locks held. Takes the
+ *	host lock and called routines may take the isa dma lock.
  */
 
-static void NCR5380_main(void) {
+static void NCR5380_main(void *p)
+{
+	struct NCR5380_hostdata *hostdata = p;
 	Scsi_Cmnd *tmp, *prev;
 	struct Scsi_Host *instance;
-	struct NCR5380_hostdata *hostdata;
 	int done;
-
+	unsigned long flags;
+	
 	/*
 	 * We run (with interrupts disabled) until we're sure that none of 
 	 * the host adapters have anything that can be done, at which point 
-	 * we set main_running to 0 and exit.
+	 * we can exit
 	 *
 	 * Interrupts are enabled before doing various other internal 
 	 * instructions, after we've decided that we need to run through
@@ -1178,113 +1162,112 @@ static void NCR5380_main(void) {
 	 * this should prevent any race conditions.
 	 */
 
+	instance = hostdata->host;
+
+	spin_lock_irqsave(instance->host_lock, flags);
+
 	do {
 		/* Lock held here */
 		done = 1;
-		for (instance = first_instance; instance && instance->hostt == the_template; instance = instance->next) {
-			hostdata = (struct NCR5380_hostdata *) instance->hostdata;
-			/* Lock held here */
-			if (!hostdata->connected && !hostdata->selecting) {
-				dprintk(NDEBUG_MAIN, ("scsi%d : not connected\n", instance->host_no));
-				/*
-				 * Search through the issue_queue for a command destined
-				 * for a target that's not busy.
-				 */
-				for (tmp = (Scsi_Cmnd *) hostdata->issue_queue, prev = NULL; tmp; prev = tmp, tmp = (Scsi_Cmnd *) tmp->host_scribble) 
-				{
-					if (prev != tmp)
-						dprintk(NDEBUG_LISTS, ("MAIN tmp=%p   target=%d   busy=%d lun=%d\n", tmp, tmp->target, hostdata->busy[tmp->target], tmp->lun));
-					/*  When we find one, remove it from the issue queue. */
-					if (!(hostdata->busy[tmp->target] & (1 << tmp->lun))) {
-						if (prev) {
-							REMOVE(prev, prev->host_scribble, tmp, tmp->host_scribble);
-							prev->host_scribble = tmp->host_scribble;
-						} else {
-							REMOVE(-1, hostdata->issue_queue, tmp, tmp->host_scribble);
-							hostdata->issue_queue = (Scsi_Cmnd *) tmp->host_scribble;
-						}
-						tmp->host_scribble = NULL;
-
-
-						/* 
-						 * Attempt to establish an I_T_L nexus here. 
-						 * On success, instance->hostdata->connected is set.
-						 * On failure, we must add the command back to the
-						 *   issue queue so we can keep trying. 
-						 */
-						dprintk(NDEBUG_MAIN|NDEBUG_QUEUES, ("scsi%d : main() : command for target %d lun %d removed from issue_queue\n", instance->host_no, tmp->target, tmp->lun));
+		if (!hostdata->connected && !hostdata->selecting) {
+			dprintk(NDEBUG_MAIN, ("scsi%d : not connected\n", instance->host_no));
+			/*
+			 * Search through the issue_queue for a command destined
+			 * for a target that's not busy.
+			 */
+			for (tmp = (Scsi_Cmnd *) hostdata->issue_queue, prev = NULL; tmp; prev = tmp, tmp = (Scsi_Cmnd *) tmp->host_scribble) 
+			{
+				if (prev != tmp)
+					dprintk(NDEBUG_LISTS, ("MAIN tmp=%p   target=%d   busy=%d lun=%d\n", tmp, tmp->target, hostdata->busy[tmp->target], tmp->lun));
+				/*  When we find one, remove it from the issue queue. */
+				if (!(hostdata->busy[tmp->target] & (1 << tmp->lun))) {
+					if (prev) {
+						REMOVE(prev, prev->host_scribble, tmp, tmp->host_scribble);
+						prev->host_scribble = tmp->host_scribble;
+					} else {
+						REMOVE(-1, hostdata->issue_queue, tmp, tmp->host_scribble);
+						hostdata->issue_queue = (Scsi_Cmnd *) tmp->host_scribble;
+					}
+					tmp->host_scribble = NULL;
 
-						/*
-						 * A successful selection is defined as one that 
-						 * leaves us with the command connected and 
-						 * in hostdata->connected, OR has terminated the
-						 * command.
-						 *
-						 * With successful commands, we fall through
-						 * and see if we can do an information transfer,
-						 * with failures we will restart.
-						 */
-						hostdata->selecting = 0;	
-						/* RvC: have to preset this to indicate a new command is being performed */
-
-						if (!NCR5380_select(instance, tmp,
-								    /* 
-								     * REQUEST SENSE commands are issued without tagged
-								     * queueing, even on SCSI-II devices because the 
-								     * contingent allegiance condition exists for the 
-								     * entire unit.
-								     */
-								    (tmp->cmnd[0] == REQUEST_SENSE) ? TAG_NONE : TAG_NEXT)) {
-							break;
-						} else {
-							LIST(tmp, hostdata->issue_queue);
-							tmp->host_scribble = (unsigned char *) hostdata->issue_queue;
-							hostdata->issue_queue = tmp;
-							done = 0;
-							dprintk(NDEBUG_MAIN|NDEBUG_QUEUES, ("scsi%d : main(): select() failed, returned to issue_queue\n", instance->host_no));
-						}
-						/* lock held here still */
-					}	/* if target/lun is not busy */
-				}	/* for */
-				/* exited locked */
-			}	/* if (!hostdata->connected) */
-			if (hostdata->selecting) {
-				tmp = (Scsi_Cmnd *) hostdata->selecting;
-				/* Selection will drop and retake the lock */
-				if (!NCR5380_select(instance, tmp, (tmp->cmnd[0] == REQUEST_SENSE) ? TAG_NONE : TAG_NEXT)) {
-					/* Ok ?? */
-				} else {
-					/* RvC: device failed, so we wait a long time
-					   this is needed for Mustek scanners, that
-					   do not respond to commands immediately
-					   after a scan */
-					printk(KERN_DEBUG "scsi%d: device %d did not respond in time\n", instance->host_no, tmp->target);
-					//spin_lock_irq(&io_request_lock);
-					LIST(tmp, hostdata->issue_queue);
-					tmp->host_scribble = (unsigned char *) hostdata->issue_queue;
-					hostdata->issue_queue = tmp;
-					//spin_unlock_irq(&io_request_lock);
-
-					hostdata->time_expires = jiffies + USLEEP_WAITLONG;
-					NCR5380_set_timer(instance);
-				}
-			}	/* if hostdata->selecting */
-			if (hostdata->connected
+					/* 
+					 * Attempt to establish an I_T_L nexus here. 
+					 * On success, instance->hostdata->connected is set.
+					 * On failure, we must add the command back to the
+					 *   issue queue so we can keep trying. 
+					 */
+					dprintk(NDEBUG_MAIN|NDEBUG_QUEUES, ("scsi%d : main() : command for target %d lun %d removed from issue_queue\n", instance->host_no, tmp->target, tmp->lun));
+	
+					/*
+					 * A successful selection is defined as one that 
+					 * leaves us with the command connected and 
+					 * in hostdata->connected, OR has terminated the
+					 * command.
+					 *
+					 * With successful commands, we fall through
+					 * and see if we can do an information transfer,
+					 * with failures we will restart.
+					 */
+					hostdata->selecting = 0;	
+					/* RvC: have to preset this to indicate a new command is being performed */
+
+					if (!NCR5380_select(instance, tmp,
+							    /* 
+							     * REQUEST SENSE commands are issued without tagged
+							     * queueing, even on SCSI-II devices because the 
+							     * contingent allegiance condition exists for the 
+							     * entire unit.
+							     */
+							    (tmp->cmnd[0] == REQUEST_SENSE) ? TAG_NONE : TAG_NEXT)) {
+						break;
+					} else {
+						LIST(tmp, hostdata->issue_queue);
+						tmp->host_scribble = (unsigned char *) hostdata->issue_queue;
+						hostdata->issue_queue = tmp;
+						done = 0;
+						dprintk(NDEBUG_MAIN|NDEBUG_QUEUES, ("scsi%d : main(): select() failed, returned to issue_queue\n", instance->host_no));
+					}
+					/* lock held here still */
+				}	/* if target/lun is not busy */
+			}	/* for */
+			/* exited locked */
+		}	/* if (!hostdata->connected) */
+		if (hostdata->selecting) {
+			tmp = (Scsi_Cmnd *) hostdata->selecting;
+			/* Selection will drop and retake the lock */
+			if (!NCR5380_select(instance, tmp, (tmp->cmnd[0] == REQUEST_SENSE) ? TAG_NONE : TAG_NEXT)) {
+				/* Ok ?? */
+			} else {
+				/* RvC: device failed, so we wait a long time
+				   this is needed for Mustek scanners, that
+				   do not respond to commands immediately
+				   after a scan */
+				printk(KERN_DEBUG "scsi%d: device %d did not respond in time\n", instance->host_no, tmp->target);
+				//spin_lock_irq(&io_request_lock);
+				LIST(tmp, hostdata->issue_queue);
+				tmp->host_scribble = (unsigned char *) hostdata->issue_queue;
+				hostdata->issue_queue = tmp;
+				//spin_unlock_irq(&io_request_lock);
+
+				hostdata->time_expires = jiffies + USLEEP_WAITLONG;
+				NCR5380_set_timer(instance);
+			}
+		}	/* if hostdata->selecting */
+		if (hostdata->connected
 #ifdef REAL_DMA
-			    && !hostdata->dmalen
+		    && !hostdata->dmalen
 #endif
-			    && (!hostdata->time_expires || time_before_eq(hostdata->time_expires, jiffies))
-			    ) {
-				dprintk(NDEBUG_MAIN, ("scsi%d : main() : performing information transfer\n", instance->host_no));
-				NCR5380_information_transfer(instance);
-				dprintk(NDEBUG_MAIN, ("scsi%d : main() : done set false\n", instance->host_no));
-				done = 0;
-			} else
-				break;
-		}		/* for instance */
+		    && (!hostdata->time_expires || time_before_eq(hostdata->time_expires, jiffies))
+		    ) {
+			dprintk(NDEBUG_MAIN, ("scsi%d : main() : performing information transfer\n", instance->host_no));
+			NCR5380_information_transfer(instance);
+			dprintk(NDEBUG_MAIN, ("scsi%d : main() : done set false\n", instance->host_no));
+			done = 0;
+		} else
+			break;
 	} while (!done);
-	/* Exit lock held */
-	clear_bit(0, &main_running);
+	
+	spin_unlock_irqrestore(instance->host_lock, flags);
 }
 
 #ifndef DONT_USE_INTR
@@ -1308,6 +1291,7 @@ static void NCR5380_intr(int irq, void *dev_id, struct pt_regs *regs)
 	struct Scsi_Host *instance;
 	int done;
 	unsigned char basr;
+	struct NCR5380_hostdata *hostdata;
 
 	dprintk(NDEBUG_INTR, ("scsi : NCR5380 irq %d triggered\n", irq));
 
@@ -1315,8 +1299,9 @@ static void NCR5380_intr(int irq, void *dev_id, struct pt_regs *regs)
 		done = 1;
 		/* The instance list is constant while the driver is
 		   loaded */
-		for (instance = first_instance; instance && (instance->hostt == the_template); instance = instance->next)
+		for (hostdata = first_host; hostdata != NULL; hostdata = hostdata->next)
 		{
+			instance = hostdata->host;
 			if (instance->irq == irq) {
 				spin_lock_irq(instance->host_lock);
 				/* Look for pending interrupts */
@@ -1385,8 +1370,8 @@ static void NCR5380_intr(int irq, void *dev_id, struct pt_regs *regs)
 					}
 				}	/* if BASR_IRQ */
 				spin_unlock_irq(instance->host_lock);
-				if (!done)
-					run_main();
+				if(!done)
+					schedule_work(&hostdata->coroutine);
 			}	/* if (instance->irq == irq) */
 		}
 	} while (!done);

drivers/scsi/NCR5380.h

@@ -248,6 +248,8 @@
 #ifndef ASM
 struct NCR5380_hostdata {
 	NCR5380_implementation_fields;		/* implementation specific */
+	struct Scsi_Host *host;			/* Host backpointer */
+	struct NCR5380_hostdata *next;		/* Next in our hot chain */
 	unsigned char id_mask, id_higher_mask;	/* 1 << id, all bits greater */
 	unsigned char targets_present;		/* targets we have connected
 						   to, so we can call a select
@@ -269,6 +271,7 @@ struct NCR5380_hostdata {
 	struct Scsi_Host *next_timer;
 	int select_time;			/* timer in select for target response */
 	volatile Scsi_Cmnd *selecting;
+	struct work_struct coroutine;		/* our co-routine */
 #ifdef NCR5380_STATS
 	unsigned timebase;			/* Base for time calcs */
 	long time_read[8];			/* time to do reads */
@@ -281,7 +284,6 @@ struct NCR5380_hostdata {
 };
 
 #ifdef __KERNEL__
-static struct Scsi_Host *first_instance;	/* linked list of 5380's */
 
 #define dprintk(a,b)			do {} while(0)
 #define NCR5380_dprint(a,b)		do {} while(0)
@@ -290,36 +292,22 @@ static struct Scsi_Host *first_instance;	/* linked list of 5380's */
 #if defined(AUTOPROBE_IRQ)
 static int NCR5380_probe_irq(struct Scsi_Host *instance, int possible);
 #endif
-static void NCR5380_init(struct Scsi_Host *instance, int flags);
+static int NCR5380_init(struct Scsi_Host *instance, int flags);
 static void NCR5380_information_transfer(struct Scsi_Host *instance);
 #ifndef DONT_USE_INTR
 static void NCR5380_intr(int irq, void *dev_id, struct pt_regs *regs);
-static void do_NCR5380_intr(int irq, void *dev_id, struct pt_regs *regs);
 #endif
-static void NCR5380_main(void);
+static void NCR5380_main(void *ptr);
 static void NCR5380_print_options(struct Scsi_Host *instance);
+#ifdef NDEBUG
 static void NCR5380_print_phase(struct Scsi_Host *instance);
 static void NCR5380_print(struct Scsi_Host *instance);
-#ifndef NCR5380_abort
-static
 #endif
-int NCR5380_abort(Scsi_Cmnd * cmd);
-#ifndef NCR5380_bus_reset
-static
-#endif
-int NCR5380_bus_reset(Scsi_Cmnd * cmd);
-#ifndef NCR5380_host_reset
-static
-#endif
-int NCR5380_host_reset(Scsi_Cmnd * cmd);
-#ifndef NCR5380_device_reset
-static
-#endif
-int NCR5380_device_reset(Scsi_Cmnd * cmd);
-#ifndef NCR5380_queue_command
-static
-#endif
-int NCR5380_queue_command(Scsi_Cmnd * cmd, void (*done) (Scsi_Cmnd *));
+static int NCR5380_abort(Scsi_Cmnd * cmd);
+static int NCR5380_bus_reset(Scsi_Cmnd * cmd);
+static int NCR5380_host_reset(Scsi_Cmnd * cmd);
+static int NCR5380_device_reset(Scsi_Cmnd * cmd);
+static int NCR5380_queue_command(Scsi_Cmnd * cmd, void (*done) (Scsi_Cmnd *));
 
 
 static void NCR5380_reselect(struct Scsi_Host *instance);

drivers/scsi/dmx3191d.c

@@ -31,6 +31,7 @@
 #include <linux/signal.h>
 #include <linux/stat.h>
 #include <linux/version.h>
+#include <linux/delay.h>
 
 #include "scsi.h"
 #include "hosts.h"
@@ -52,7 +53,7 @@
 #include "NCR5380.c"
 
 
-int __init dmx3191d_detect(Scsi_Host_Template *tmpl) {
+static int __init dmx3191d_detect(Scsi_Host_Template *tmpl) {
 	int boards = 0;
 	struct Scsi_Host *instance = NULL;
 	struct pci_dev *pdev = NULL;
@@ -90,7 +91,7 @@ int __init dmx3191d_detect(Scsi_Host_Template *tmpl) {
 		instance->irq = pdev->irq;
 		NCR5380_init(instance, FLAG_NO_PSEUDO_DMA | FLAG_DTC3181E);
 
-		if (request_irq(pdev->irq, dmx3191d_do_intr, SA_SHIRQ,
+		if (request_irq(pdev->irq, dmx3191d_intr, SA_SHIRQ,
 				DMX3191D_DRIVER_NAME, instance)) {
 			printk(KERN_WARNING "dmx3191: IRQ %d not available - switching to polled mode.\n", pdev->irq);
 			/* Steam powered scsi controllers run without an IRQ
@@ -103,13 +104,13 @@ int __init dmx3191d_detect(Scsi_Host_Template *tmpl) {
 	return boards;
 }
 
-const char * dmx3191d_info(struct Scsi_Host *host) {
+static const char * dmx3191d_info(struct Scsi_Host *host) {
 	static const char *info ="Domex DMX3191D";
 
 	return info;
 }
 
-int dmx3191d_release_resources(struct Scsi_Host *instance)
+static int dmx3191d_release_resources(struct Scsi_Host *instance)
 {
 	release_region(instance->io_port, DMX3191D_REGION);
 	if(instance->irq!=IRQ_NONE)

drivers/scsi/dmx3191d.h

@@ -20,16 +20,15 @@
 #define PCI_DEVICE_ID_DOMEX_DMX3191D	0x0001
 #endif
 
-#ifndef ASM
-int dmx3191d_abort(Scsi_Cmnd *);
-int dmx3191d_detect(Scsi_Host_Template *);
-const char* dmx3191d_info(struct Scsi_Host *);
-int dmx3191d_proc_info(char *, char **, off_t, int, int, int);
-int dmx3191d_queue_command(Scsi_Cmnd *, void (*done)(Scsi_Cmnd *));
-int dmx3191d_release_resources(struct Scsi_Host *);
-int dmx3191d_bus_reset(Scsi_Cmnd *);
-int dmx3191d_host_reset(Scsi_Cmnd *);
-int dmx3191d_device_reset(Scsi_Cmnd *);
+static int dmx3191d_abort(Scsi_Cmnd *);
+static int dmx3191d_detect(Scsi_Host_Template *);
+static const char* dmx3191d_info(struct Scsi_Host *);
+static int dmx3191d_proc_info(char *, char **, off_t, int, int, int);
+static int dmx3191d_queue_command(Scsi_Cmnd *, void (*done)(Scsi_Cmnd *));
+static int dmx3191d_release_resources(struct Scsi_Host *);
+static int dmx3191d_bus_reset(Scsi_Cmnd *);
+static int dmx3191d_host_reset(Scsi_Cmnd *);
+static int dmx3191d_device_reset(Scsi_Cmnd *);
 
 
 #define DMX3191D {				\
@@ -64,9 +63,9 @@ int dmx3191d_device_reset(Scsi_Cmnd *);
 #define NCR5380_intr				dmx3191d_intr
 #define NCR5380_proc_info			dmx3191d_proc_info
 #define NCR5380_queue_command			dmx3191d_queue_command
-#define NCR5380_reset				dmx3191d_reset
-
-#endif	/* ASM */
+#define NCR5380_host_reset			dmx3191d_host_reset
+#define NCR5380_bus_reset			dmx3191d_bus_reset
+#define NCR5380_device_reset			dmx3191d_device_reset
 
 #endif	/* __DMX3191D_H */
 

drivers/scsi/dtc.c

@@ -2,7 +2,7 @@
 #define AUTOSENSE
 #define PSEUDO_DMA
 #define DONT_USE_INTR
-#define UNSAFE		/* Leave interrupts enabled during pseudo-dma I/O */
+#define UNSAFE			/* Leave interrupts enabled during pseudo-dma I/O */
 #define xNDEBUG (NDEBUG_INTR+NDEBUG_RESELECTION+\
 		 NDEBUG_SELECTION+NDEBUG_ARBITRATION)
 #define DMA_WORKS_RIGHT
@@ -77,6 +77,7 @@
 #include <linux/signal.h>
 #include <linux/sched.h>
 #include <linux/blk.h>
+#include <linux/delay.h>
 #include <asm/io.h>
 #include "scsi.h"
 #include "hosts.h"
@@ -101,65 +102,77 @@
  */
 
 /*
- */ 
+ */
 /* Offset from DTC_5380_OFFSET */
 #define DTC_CONTROL_REG		0x100	/* rw */
 #define D_CR_ACCESS		0x80	/* ro set=can access 3280 registers */
 #define CSR_DIR_READ		0x40	/* rw direction, 1 = read 0 = write */
 
-#define CSR_RESET              0x80    /* wo  Resets 53c400 */
-#define CSR_5380_REG           0x80    /* ro  5380 registers can be accessed */
-#define CSR_TRANS_DIR          0x40    /* rw  Data transfer direction */
-#define CSR_SCSI_BUFF_INTR     0x20    /* rw  Enable int on transfer ready */
-#define CSR_5380_INTR          0x10    /* rw  Enable 5380 interrupts */
-#define CSR_SHARED_INTR        0x08    /* rw  Interrupt sharing */
-#define CSR_HOST_BUF_NOT_RDY   0x04    /* ro  Host buffer not ready */
-#define CSR_SCSI_BUF_RDY       0x02    /* ro  SCSI buffer ready */
-#define CSR_GATED_5380_IRQ     0x01    /* ro  Last block xferred */
+#define CSR_RESET              0x80	/* wo  Resets 53c400 */
+#define CSR_5380_REG           0x80	/* ro  5380 registers can be accessed */
+#define CSR_TRANS_DIR          0x40	/* rw  Data transfer direction */
+#define CSR_SCSI_BUFF_INTR     0x20	/* rw  Enable int on transfer ready */
+#define CSR_5380_INTR          0x10	/* rw  Enable 5380 interrupts */
+#define CSR_SHARED_INTR        0x08	/* rw  Interrupt sharing */
+#define CSR_HOST_BUF_NOT_RDY   0x04	/* ro  Host buffer not ready */
+#define CSR_SCSI_BUF_RDY       0x02	/* ro  SCSI buffer ready */
+#define CSR_GATED_5380_IRQ     0x01	/* ro  Last block xferred */
 #define CSR_INT_BASE (CSR_SCSI_BUFF_INTR | CSR_5380_INTR)
 
 
-#define DTC_BLK_CNT		0x101   /* rw 
+#define DTC_BLK_CNT		0x101	/* rw 
 					 * # of 128-byte blocks to transfer */
 
 
-#define D_CR_ACCESS             0x80    /* ro set=can access 3280 registers */
+#define D_CR_ACCESS             0x80	/* ro set=can access 3280 registers */
 
 #define DTC_SWITCH_REG		0x3982	/* ro - DIP switches */
 #define DTC_RESUME_XFER		0x3982	/* wo - resume data xfer 
-					   * after disconnect/reconnect*/
+					 * after disconnect/reconnect*/
 
 #define DTC_5380_OFFSET		0x3880	/* 8 registers here, see NCR5380.h */
 
 /*!!!! for dtc, it's a 128 byte buffer at 3900 !!! */
-#define DTC_DATA_BUF		0x3900  /* rw 128 bytes long */
+#define DTC_DATA_BUF		0x3900	/* rw 128 bytes long */
 
 static struct override {
-   unsigned int address;
-   int irq;
+	unsigned int address;
+	int irq;
 } overrides
 #ifdef OVERRIDE
 [] __initdata = OVERRIDE;
 #else
-[4] __initdata = {{0, IRQ_AUTO}, {0, IRQ_AUTO}, {0, IRQ_AUTO}, {0, IRQ_AUTO}};
+[4] __initdata = { {
+0, IRQ_AUTO}, {
+0, IRQ_AUTO}, {
+0, IRQ_AUTO}, {
+0, IRQ_AUTO}};
 #endif
 
 #define NO_OVERRIDES (sizeof(overrides) / sizeof(struct override))
 
 static struct base {
-   unsigned long address;
-   int noauto;
-} bases[] __initdata = {{0xcc000, 0}, {0xc8000, 0}, {0xdc000, 0}, {0xd8000, 0}};
+	unsigned long address;
+	int noauto;
+} bases[] __initdata = { 
+	{ 0xcc000, 0 }, 
+	{ 0xc8000, 0 }, 
+	{ 0xdc000, 0 }, 
+	{ 0xd8000, 0 }
+};
 
 #define NO_BASES (sizeof (bases) / sizeof (struct base))
 
 static const struct signature {
-   const char *string;
-   int offset;
-} signatures[] = { {"DATA TECHNOLOGY CORPORATION BIOS", 0x25}, };
+	const char *string;
+	int offset;
+} signatures[] = { 
+	{"DATA TECHNOLOGY CORPORATION BIOS", 0x25},
+};
 
 #define NO_SIGNATURES (sizeof (signatures) /  sizeof (struct signature))
 
+#ifndef MODULE
 /*
  * Function : dtc_setup(char *str, int *ints)
  *
@@ -170,23 +183,24 @@ static const struct signature {
  *
 */
 
-void __init dtc_setup(char *str, int *ints){
-   static int commandline_current = 0;
-   int i;
-   if (ints[0] != 2)
-      printk("dtc_setup: usage dtc=address,irq\n");
-   else
-      if (commandline_current < NO_OVERRIDES) {
-      overrides[commandline_current].address = ints[1];
-      overrides[commandline_current].irq = ints[2];
-      for (i = 0; i < NO_BASES; ++i)
-	 if (bases[i].address == ints[1]) {
-	 bases[i].noauto = 1;
-	 break;
-      }
-      ++commandline_current;
-   }
+static void __init dtc_setup(char *str, int *ints)
+{
+	static int commandline_current = 0;
+	int i;
+	if (ints[0] != 2)
+		printk("dtc_setup: usage dtc=address,irq\n");
+	else if (commandline_current < NO_OVERRIDES) {
+		overrides[commandline_current].address = ints[1];
+		overrides[commandline_current].irq = ints[2];
+		for (i = 0; i < NO_BASES; ++i)
+			if (bases[i].address == ints[1]) {
+				bases[i].noauto = 1;
+				break;
+			}
+		++commandline_current;
+	}
 }
+#endif
 
 /* 
  * Function : int dtc_detect(Scsi_Host_Template * tpnt)
@@ -201,97 +215,92 @@ void __init dtc_setup(char *str, int *ints){
  *
 */
 
-int __init dtc_detect(Scsi_Host_Template * tpnt){
-   static int current_override = 0, current_base = 0;
-   struct Scsi_Host *instance;
-   unsigned int base;
-   int sig, count;
+static int __init dtc_detect(Scsi_Host_Template * tpnt)
+{
+	static int current_override = 0, current_base = 0;
+	struct Scsi_Host *instance;
+	unsigned int base;
+	int sig, count;
 
-   tpnt->proc_name = "dtc3x80";
-   tpnt->proc_info = &dtc_proc_info;
+	tpnt->proc_name = "dtc3x80";
+	tpnt->proc_info = &dtc_proc_info;
 
-   for (count = 0; current_override < NO_OVERRIDES; ++current_override) {
-      base = 0;
+	for (count = 0; current_override < NO_OVERRIDES; ++current_override) {
+		base = 0;
 
-      if (overrides[current_override].address)
-	 base = overrides[current_override].address;
-      else
-	 for (; !base && (current_base < NO_BASES); ++current_base) {
+		if (overrides[current_override].address)
+			base = overrides[current_override].address;
+		else
+			for (; !base && (current_base < NO_BASES); ++current_base) {
 #if (DTCDEBUG & DTCDEBUG_INIT)
-	 printk("scsi-dtc : probing address %08x\n", bases[current_base].address);
+				printk("scsi-dtc : probing address %08x\n", bases[current_base].address);
 #endif
-	 for (sig = 0; sig < NO_SIGNATURES; ++sig)
-	    if (!bases[current_base].noauto && 
-		isa_check_signature(bases[current_base].address +
-				signatures[sig].offset,
-	      signatures[sig].string, strlen(signatures[sig].string))) {
-	    base = bases[current_base].address;
+				for (sig = 0; sig < NO_SIGNATURES; ++sig)
+					if (!bases[current_base].noauto && isa_check_signature(bases[current_base].address + signatures[sig].offset, signatures[sig].string, strlen(signatures[sig].string))) {
+						base = bases[current_base].address;
 #if (DTCDEBUG & DTCDEBUG_INIT)
-	    printk("scsi-dtc : detected board.\n");
+						printk("scsi-dtc : detected board.\n");
 #endif
-	    break;
-	 }
-      }
+						break;
+					}
+			}
 
 #if defined(DTCDEBUG) && (DTCDEBUG & DTCDEBUG_INIT)
-      printk("scsi-dtc : base = %08x\n", base);
+		printk("scsi-dtc : base = %08x\n", base);
 #endif
 
-      if (!base)
-	 break;
+		if (!base)
+			break;
 
-      instance = scsi_register (tpnt, sizeof(struct NCR5380_hostdata));
-      if(instance == NULL)
-      	break;
-      	
-      instance->base = base;
+		instance = scsi_register(tpnt, sizeof(struct NCR5380_hostdata));
+		if (instance == NULL)
+			break;
 
-      NCR5380_init(instance, 0);
+		instance->base = base;
 
-      NCR5380_write(DTC_CONTROL_REG, CSR_5380_INTR); /* Enable int's */
-      if (overrides[current_override].irq != IRQ_AUTO)
-	 instance->irq = overrides[current_override].irq;
-      else
-	 instance->irq = NCR5380_probe_irq(instance, DTC_IRQS);
+		NCR5380_init(instance, 0);
+
+		NCR5380_write(DTC_CONTROL_REG, CSR_5380_INTR);	/* Enable int's */
+		if (overrides[current_override].irq != IRQ_AUTO)
+			instance->irq = overrides[current_override].irq;
+		else
+			instance->irq = NCR5380_probe_irq(instance, DTC_IRQS);
 
 #ifndef DONT_USE_INTR
-/* With interrupts enabled, it will sometimes hang when doing heavy
- * reads. So better not enable them until I finger it out. */
-      if (instance->irq != IRQ_NONE)
-	 if (request_irq(instance->irq, do_dtc_intr, SA_INTERRUPT, "dtc", instance)) {
-	 printk("scsi%d : IRQ%d not free, interrupts disabled\n",
-	      instance->host_no, instance->irq);
-	 instance->irq = IRQ_NONE;
-      }
-
-      if (instance->irq == IRQ_NONE) {
-	 printk("scsi%d : interrupts not enabled. for better interactive performance,\n", instance->host_no);
-	 printk("scsi%d : please jumper the board for a free IRQ.\n", instance->host_no);
-      }
+		/* With interrupts enabled, it will sometimes hang when doing heavy
+		 * reads. So better not enable them until I finger it out. */
+		if (instance->irq != IRQ_NONE)
+			if (request_irq(instance->irq, dtc_intr, SA_INTERRUPT, "dtc", instance)) {
+				printk(KERN_ERR "scsi%d : IRQ%d not free, interrupts disabled\n", instance->host_no, instance->irq);
+				instance->irq = IRQ_NONE;
+			}
+
+		if (instance->irq == IRQ_NONE) {
+			printk(KERN_WARNING "scsi%d : interrupts not enabled. for better interactive performance,\n", instance->host_no);
+			printk(KERN_WARNING "scsi%d : please jumper the board for a free IRQ.\n", instance->host_no);
+		}
 #else
-      if (instance->irq != IRQ_NONE)
-	 printk("scsi%d : interrupts not used. Might as well not jumper it.\n",
-		instance->host_no);
-      instance->irq = IRQ_NONE;
+		if (instance->irq != IRQ_NONE)
+			printk(KERN_WARNING "scsi%d : interrupts not used. Might as well not jumper it.\n", instance->host_no);
+		instance->irq = IRQ_NONE;
 #endif
 #if defined(DTCDEBUG) && (DTCDEBUG & DTCDEBUG_INIT)
-      printk("scsi%d : irq = %d\n", instance->host_no, instance->irq);
+		printk("scsi%d : irq = %d\n", instance->host_no, instance->irq);
 #endif
 
-      printk("scsi%d : at 0x%05X", instance->host_no, (int)instance->base);
-      if (instance->irq == IRQ_NONE)
-	 printk (" interrupts disabled");
-      else
-	 printk (" irq %d", instance->irq);
-      printk(" options CAN_QUEUE=%d  CMD_PER_LUN=%d release=%d",
-	   CAN_QUEUE, CMD_PER_LUN, DTC_PUBLIC_RELEASE);
-      NCR5380_print_options(instance);
-      printk("\n");
-
-      ++current_override;
-      ++count;
-   }
-   return count;
+		printk(KERN_INFO "scsi%d : at 0x%05X", instance->host_no, (int) instance->base);
+		if (instance->irq == IRQ_NONE)
+			printk(" interrupts disabled");
+		else
+			printk(" irq %d", instance->irq);
+		printk(" options CAN_QUEUE=%d  CMD_PER_LUN=%d release=%d", CAN_QUEUE, CMD_PER_LUN, DTC_PUBLIC_RELEASE);
+		NCR5380_print_options(instance);
+		printk("\n");
+
+		++current_override;
+		++count;
+	}
+	return count;
 }
 
 /*
@@ -314,14 +323,14 @@ int __init dtc_detect(Scsi_Host_Template * tpnt){
  * and matching the H_C_S coordinates to what DOS uses.
 */
 
-int dtc_biosparam(Disk * disk, struct block_device *dev, int * ip)
+static int dtc_biosparam(Disk * disk, struct block_device *dev, int *ip)
 {
-   int size = disk->capacity;
+	int size = disk->capacity;
 
-   ip[0] = 64;
-   ip[1] = 32;
-   ip[2] = size >> 11;
-   return 0;
+	ip[0] = 64;
+	ip[1] = 32;
+	ip[2] = size >> 11;
+	return 0;
 }
 
 
@@ -341,43 +350,43 @@ int dtc_biosparam(Disk * disk, struct block_device *dev, int * ip)
 static int dtc_maxi = 0;
 static int dtc_wmaxi = 0;
 
-static inline int NCR5380_pread (struct Scsi_Host *instance,
-     unsigned char *dst, int len)
-     {
-   unsigned char *d = dst;
-   int i;	/* For counting time spent in the poll-loop */
-   NCR5380_local_declare();
-   NCR5380_setup(instance);
-
-   i = 0;
-   NCR5380_read(RESET_PARITY_INTERRUPT_REG);
-   NCR5380_write(MODE_REG, MR_ENABLE_EOP_INTR | MR_DMA_MODE);
-   if (instance->irq == IRQ_NONE)
-      NCR5380_write(DTC_CONTROL_REG, CSR_DIR_READ);
-   else
-      NCR5380_write(DTC_CONTROL_REG, CSR_DIR_READ | CSR_INT_BASE);
-   NCR5380_write(DTC_BLK_CNT, len >> 7);        /* Block count */
-   rtrc(1);
-   while (len > 0) {
-      rtrc(2);
-      while (NCR5380_read(DTC_CONTROL_REG) & CSR_HOST_BUF_NOT_RDY)
-	 ++i;
-      rtrc(3);
-      isa_memcpy_fromio(d, base + DTC_DATA_BUF, 128);
-      d += 128;
-      len -= 128;
-      rtrc(7);	/*** with int's on, it sometimes hangs after here.
+static inline int NCR5380_pread(struct Scsi_Host *instance, unsigned char *dst, int len)
+{
+	unsigned char *d = dst;
+	int i;			/* For counting time spent in the poll-loop */
+	NCR5380_local_declare();
+	NCR5380_setup(instance);
+
+	i = 0;
+	NCR5380_read(RESET_PARITY_INTERRUPT_REG);
+	NCR5380_write(MODE_REG, MR_ENABLE_EOP_INTR | MR_DMA_MODE);
+	if (instance->irq == IRQ_NONE)
+		NCR5380_write(DTC_CONTROL_REG, CSR_DIR_READ);
+	else
+		NCR5380_write(DTC_CONTROL_REG, CSR_DIR_READ | CSR_INT_BASE);
+	NCR5380_write(DTC_BLK_CNT, len >> 7);	/* Block count */
+	rtrc(1);
+	while (len > 0) {
+		rtrc(2);
+		while (NCR5380_read(DTC_CONTROL_REG) & CSR_HOST_BUF_NOT_RDY)
+			++i;
+		rtrc(3);
+		isa_memcpy_fromio(d, base + DTC_DATA_BUF, 128);
+		d += 128;
+		len -= 128;
+		rtrc(7);
+		/*** with int's on, it sometimes hangs after here.
 		 * Looks like something makes HBNR go away. */
-   }
-   rtrc(4);
-   while ( !(NCR5380_read(DTC_CONTROL_REG) & D_CR_ACCESS))
-      ++i;
-   NCR5380_write(MODE_REG, 0); /* Clear the operating mode */
-   rtrc(0);
-   NCR5380_read(RESET_PARITY_INTERRUPT_REG);
-   if (i > dtc_maxi)
-      dtc_maxi = i;
-   return(0);
+	}
+	rtrc(4);
+	while (!(NCR5380_read(DTC_CONTROL_REG) & D_CR_ACCESS))
+		++i;
+	NCR5380_write(MODE_REG, 0);	/* Clear the operating mode */
+	rtrc(0);
+	NCR5380_read(RESET_PARITY_INTERRUPT_REG);
+	if (i > dtc_maxi)
+		dtc_maxi = i;
+	return (0);
 }
 
 /****************************************************************
@@ -393,44 +402,44 @@ static inline int NCR5380_pread (struct Scsi_Host *instance,
  * 	timeout.
 */
 
-static inline int NCR5380_pwrite (struct Scsi_Host *instance,
-     unsigned char *src, int len) {
-   int i;
-   NCR5380_local_declare();
-   NCR5380_setup(instance);
-
-   NCR5380_read(RESET_PARITY_INTERRUPT_REG);
-   NCR5380_write(MODE_REG, MR_ENABLE_EOP_INTR | MR_DMA_MODE);
-   /* set direction (write) */
-   if (instance->irq == IRQ_NONE)
-      NCR5380_write(DTC_CONTROL_REG, 0);
-   else
-      NCR5380_write(DTC_CONTROL_REG, CSR_5380_INTR);
-   NCR5380_write(DTC_BLK_CNT, len >> 7);        /* Block count */
-   for (i = 0; len > 0; ++i) {
-      rtrc(5);
-      /* Poll until the host buffer can accept data. */
-      while (NCR5380_read(DTC_CONTROL_REG) & CSR_HOST_BUF_NOT_RDY)
-	 ++i;
-      rtrc(3);
-      isa_memcpy_toio(base + DTC_DATA_BUF, src, 128);
-      src += 128;
-      len -= 128;
-   }
-   rtrc(4);
-   while ( !(NCR5380_read(DTC_CONTROL_REG) & D_CR_ACCESS))
-      ++i;
-   rtrc(6);
-   /* Wait until the last byte has been sent to the disk */
-   while (!(NCR5380_read(TARGET_COMMAND_REG) & TCR_LAST_BYTE_SENT))
-      ++i;
-   rtrc(7);
-   /* Check for parity error here. fixme. */
-   NCR5380_write(MODE_REG, 0); /* Clear the operating mode */
-   rtrc(0);
-   if (i > dtc_wmaxi)
-      dtc_wmaxi = i;
-   return (0);
+static inline int NCR5380_pwrite(struct Scsi_Host *instance, unsigned char *src, int len)
+{
+	int i;
+	NCR5380_local_declare();
+	NCR5380_setup(instance);
+
+	NCR5380_read(RESET_PARITY_INTERRUPT_REG);
+	NCR5380_write(MODE_REG, MR_ENABLE_EOP_INTR | MR_DMA_MODE);
+	/* set direction (write) */
+	if (instance->irq == IRQ_NONE)
+		NCR5380_write(DTC_CONTROL_REG, 0);
+	else
+		NCR5380_write(DTC_CONTROL_REG, CSR_5380_INTR);
+	NCR5380_write(DTC_BLK_CNT, len >> 7);	/* Block count */
+	for (i = 0; len > 0; ++i) {
+		rtrc(5);
+		/* Poll until the host buffer can accept data. */
+		while (NCR5380_read(DTC_CONTROL_REG) & CSR_HOST_BUF_NOT_RDY)
+			++i;
+		rtrc(3);
+		isa_memcpy_toio(base + DTC_DATA_BUF, src, 128);
+		src += 128;
+		len -= 128;
+	}
+	rtrc(4);
+	while (!(NCR5380_read(DTC_CONTROL_REG) & D_CR_ACCESS))
+		++i;
+	rtrc(6);
+	/* Wait until the last byte has been sent to the disk */
+	while (!(NCR5380_read(TARGET_COMMAND_REG) & TCR_LAST_BYTE_SENT))
+		++i;
+	rtrc(7);
+	/* Check for parity error here. fixme. */
+	NCR5380_write(MODE_REG, 0);	/* Clear the operating mode */
+	rtrc(0);
+	if (i > dtc_wmaxi)
+		dtc_wmaxi = i;
+	return (0);
 }
 
 MODULE_LICENSE("GPL");

drivers/scsi/dtc.h

@@ -28,19 +28,16 @@
 #ifndef DTC3280_H
 #define DTC3280_H
 
-#ifndef ASM
-int dtc_abort(Scsi_Cmnd *);
-int dtc_biosparam(Disk *, struct block_device *, int*);
-int dtc_detect(Scsi_Host_Template *);
-int dtc_queue_command(Scsi_Cmnd *, void (*done)(Scsi_Cmnd *));
-int dtc_reset(Scsi_Cmnd *, unsigned int reset_flags);
-int dtc_proc_info (char *buffer, char **start, off_t offset,
+static int dtc_abort(Scsi_Cmnd *);
+static int dtc_biosparam(Disk *, struct block_device *, int*);
+static int dtc_detect(Scsi_Host_Template *);
+static int dtc_queue_command(Scsi_Cmnd *, void (*done)(Scsi_Cmnd *));
+static int dtc_bus_reset(Scsi_Cmnd *);
+static int dtc_device_reset(Scsi_Cmnd *);
+static int dtc_host_reset(Scsi_Cmnd *);
+static int dtc_proc_info (char *buffer, char **start, off_t offset,
 		   int length, int hostno, int inout);
 
-#ifndef NULL
-#define NULL 0
-#endif
-
 #ifndef CMD_PER_LUN
 #define CMD_PER_LUN 2
 #endif
@@ -55,24 +52,26 @@ int dtc_proc_info (char *buffer, char **start, off_t offset,
  * macros when this is being used solely for the host stub.
  */
 
-#define DTC3x80 {				\
-	name:           "DTC 3180/3280 ",	\
-	detect:         dtc_detect,		\
-	queuecommand:   dtc_queue_command,	\
-	abort:          dtc_abort,		\
-	reset:          dtc_reset,		\
-	bios_param:     dtc_biosparam,		\
-	can_queue:      CAN_QUEUE,		\
-	this_id:        7,			\
-	sg_tablesize:   SG_ALL,			\
-	cmd_per_lun:    CMD_PER_LUN ,		\
+#define DTC3x80 {						\
+	name:				"DTC 3180/3280 ",	\
+	detect:				dtc_detect,		\
+	queuecommand:			dtc_queue_command,	\
+	eh_abort_handler:		dtc_abort,		\
+	eh_bus_reset_handler:		dtc_bus_reset,		\
+	eh_device_reset_handler:	dtc_device_reset,	\
+	eh_host_reset_handler:          dtc_host_reset,		\
+	bios_param:     dtc_biosparam,				\
+	can_queue:      CAN_QUEUE,				\
+	this_id:        7,					\
+	sg_tablesize:   SG_ALL,					\
+	cmd_per_lun:    CMD_PER_LUN ,				\
 	use_clustering: DISABLE_CLUSTERING}
 
 #define NCR5380_implementation_fields \
-    volatile unsigned int base
+    unsigned int base
 
 #define NCR5380_local_declare() \
-    volatile unsigned int base
+    unsigned int base
 
 #define NCR5380_setup(instance) \
     base = (unsigned int)(instance)->base
@@ -105,12 +104,13 @@ int dtc_proc_info (char *buffer, char **start, off_t offset,
     isa_writeb(value, DTC_address(reg));} while(0)
 #endif
 
-#define NCR5380_intr dtc_intr
-#define do_NCR5380_intr do_dtc_intr
-#define NCR5380_queue_command dtc_queue_command
-#define NCR5380_abort dtc_abort
-#define NCR5380_reset dtc_reset
-#define NCR5380_proc_info dtc_proc_info 
+#define NCR5380_intr			dtc_intr
+#define NCR5380_queue_command		dtc_queue_command
+#define NCR5380_abort			dtc_abort
+#define NCR5380_bus_reset		dtc_bus_reset
+#define NCR5380_device_reset		dtc_device_reset
+#define NCR5380_host_reset		dtc_host_reset
+#define NCR5380_proc_info		dtc_proc_info 
 
 /* 15 12 11 10
    1001 1100 0000 0000 */
@@ -118,5 +118,4 @@ int dtc_proc_info (char *buffer, char **start, off_t offset,
 #define DTC_IRQS 0x9c00
 
 
-#endif /* ndef ASM */
 #endif /* DTC3280_H */

drivers/scsi/g_NCR5380.c

@@ -100,12 +100,6 @@
 #define NCR5380_STATS
 #undef NCR5380_STAT_LIMIT
 #endif
-#if defined(CONFIG_SCSI_G_NCR5380_PORT) && defined(CONFIG_SCSI_G_NCR5380_MEM)
-#error You can not configure the Generic NCR 5380 SCSI Driver for memory mapped I/O and port mapped I/O at the same time (yet)
-#endif
-#if !defined(CONFIG_SCSI_G_NCR5380_PORT) && !defined(CONFIG_SCSI_G_NCR5380_MEM)
-#error You must configure the Generic NCR 5380 SCSI Driver for one of memory mapped I/O and port mapped I/O.
-#endif
 
 #include <asm/system.h>
 #include <asm/io.h>
@@ -121,6 +115,7 @@
 #include <linux/init.h>
 #include <linux/ioport.h>
 #include <linux/isapnp.h>
+#include <linux/delay.h>
 
 #define NCR_NOT_SET 0
 static int ncr_irq = NCR_NOT_SET;
@@ -143,8 +138,11 @@ static struct override {
 [1] __initdata = { { 0,},};
 #endif
 
+
 #define NO_OVERRIDES (sizeof(overrides) / sizeof(struct override))
 
+#ifndef MODULE 
+
 /**
  *	internal_setup		-	handle lilo command string override
  *	@board:	BOARD_* identifier for the board
@@ -199,6 +197,7 @@ static void __init internal_setup(int board, char *str, int *ints)
 	}
 }
 
+
 /**
  * 	do_NCR53C80_setup		-	set up entry point
  *	@str: unused
@@ -270,6 +269,8 @@ static int __init do_DTC3181E_setup(char *str)
 	return 1;
 }
 
+#endif
+
 /**
  * 	generic_NCR5380_detect	-	look for NCR5380 controllers
  *	@tpnt: the scsi template
@@ -367,7 +368,7 @@ int __init generic_NCR5380_detect(Scsi_Host_Template * tpnt)
 			break;
 		}
 
-#ifdef CONFIG_SCSI_G_NCR5380_PORT
+#ifndef CONFIG_SCSI_G_NCR5380_MEM
 		if (ports) {
 			/* wakeup sequence for the NCR53C400A and DTC3181E */
 
@@ -412,7 +413,7 @@ int __init generic_NCR5380_detect(Scsi_Host_Template * tpnt)
 #endif
 		instance = scsi_register(tpnt, sizeof(struct NCR5380_hostdata));
 		if (instance == NULL) {
-#ifdef CONFIG_SCSI_G_NCR5380_PORT
+#ifndef CONFIG_SCSI_G_NCR5380_MEM
 			release_region(overrides[current_override].NCR5380_map_name, NCR5380_region_size);
 #else
 			release_mem_region(overrides[current_override].NCR5380_map_name, NCR5380_region_size);
@@ -430,7 +431,7 @@ int __init generic_NCR5380_detect(Scsi_Host_Template * tpnt)
 			instance->irq = NCR5380_probe_irq(instance, 0xffff);
 
 		if (instance->irq != IRQ_NONE)
-			if (request_irq(instance->irq, do_generic_NCR5380_intr, SA_INTERRUPT, "NCR5380", NULL)) {
+			if (request_irq(instance->irq, generic_NCR5380_intr, SA_INTERRUPT, "NCR5380", NULL)) {
 				printk(KERN_WARNING "scsi%d : IRQ%d not free, interrupts disabled\n", instance->host_no, instance->irq);
 				instance->irq = IRQ_NONE;
 			}
@@ -482,7 +483,7 @@ int generic_NCR5380_release_resources(struct Scsi_Host *instance)
 	NCR5380_local_declare();
 	NCR5380_setup(instance);
 
-#ifdef CONFIG_SCSI_G_NCR5380_PORT
+#ifndef CONFIG_SCSI_G_NCR5380_MEM
 	release_region(instance->NCR5380_instance_name, NCR5380_region_size);
 #else
 	release_mem_region(instance->NCR5380_instance_name, NCR5380_region_size);
@@ -555,7 +556,7 @@ static inline int NCR5380_pread(struct Scsi_Host *instance, unsigned char *dst,
 		}
 		while (NCR5380_read(C400_CONTROL_STATUS_REG) & CSR_HOST_BUF_NOT_RDY);
 
-#ifdef CONFIG_SCSI_G_NCR5380_PORT
+#ifndef CONFIG_SCSI_G_NCR5380_MEM
 		{
 			int i;
 			for (i = 0; i < 128; i++)
@@ -575,7 +576,7 @@ static inline int NCR5380_pread(struct Scsi_Host *instance, unsigned char *dst,
 			// FIXME - no timeout
 		}
 
-#ifdef CONFIG_SCSI_G_NCR5380_PORT
+#ifndef CONFIG_SCSI_G_NCR5380_MEM
 		{
 			int i;	
 			for (i = 0; i < 128; i++)
@@ -641,7 +642,7 @@ static inline int NCR5380_pwrite(struct Scsi_Host *instance, unsigned char *src,
 		}
 		while (NCR5380_read(C400_CONTROL_STATUS_REG) & CSR_HOST_BUF_NOT_RDY)
 			; // FIXME - timeout
-#ifdef CONFIG_SCSI_G_NCR5380_PORT
+#ifndef CONFIG_SCSI_G_NCR5380_MEM
 		{
 			for (i = 0; i < 128; i++)
 				NCR5380_write(C400_HOST_BUFFER, src[start + i]);
@@ -657,7 +658,7 @@ static inline int NCR5380_pwrite(struct Scsi_Host *instance, unsigned char *src,
 		while (NCR5380_read(C400_CONTROL_STATUS_REG) & CSR_HOST_BUF_NOT_RDY)
 			; // FIXME - no timeout
 
-#ifdef CONFIG_SCSI_G_NCR5380_PORT
+#ifndef CONFIG_SCSI_G_NCR5380_MEM
 		{
 			for (i = 0; i < 128; i++)
 				NCR5380_write(C400_HOST_BUFFER, src[start + i]);
@@ -781,9 +782,8 @@ int generic_NCR5380_proc_info(char *buffer, char **start, off_t offset, int leng
 #endif
 
 	/* For now this is constant so we may walk it */
-	for (scsi_ptr = first_instance; scsi_ptr; scsi_ptr = scsi_ptr->next)
-		if (scsi_ptr->host_no == hostno)
-			break;
+	scsi_ptr = scsi_host_hn_get(hostno);
+	
 	NCR5380_setup(scsi_ptr);
 	hostdata = (struct NCR5380_hostdata *) scsi_ptr->hostdata;
 

drivers/scsi/g_NCR5380.h

@@ -44,25 +44,19 @@
 #endif
 
 #ifndef ASM
-int generic_NCR5380_abort(Scsi_Cmnd *);
-int generic_NCR5380_detect(Scsi_Host_Template *);
-int generic_NCR5380_release_resources(struct Scsi_Host *);
-int generic_NCR5380_queue_command(Scsi_Cmnd *, void (*done)(Scsi_Cmnd *));
-int generic_NCR5380_bus_reset(Scsi_Cmnd *);
-int generic_NCR5380_host_reset(Scsi_Cmnd *);
-int generic_NCR5380_device_reset(Scsi_Cmnd *);
-int notyet_generic_proc_info (char *buffer ,char **start, off_t offset,
+static int generic_NCR5380_abort(Scsi_Cmnd *);
+static int generic_NCR5380_detect(Scsi_Host_Template *);
+static int generic_NCR5380_release_resources(struct Scsi_Host *);
+static int generic_NCR5380_queue_command(Scsi_Cmnd *, void (*done)(Scsi_Cmnd *));
+static int generic_NCR5380_bus_reset(Scsi_Cmnd *);
+static int generic_NCR5380_host_reset(Scsi_Cmnd *);
+static int generic_NCR5380_device_reset(Scsi_Cmnd *);
+static int notyet_generic_proc_info (char *buffer ,char **start, off_t offset,
                      int length, int hostno, int inout);
-const char* generic_NCR5380_info(struct Scsi_Host *);
-#ifdef BIOSPARAM
-int generic_NCR5380_biosparam(Disk *, struct block_device *, int *);
-#endif
-
-int generic_NCR5380_proc_info(char* buffer, char** start, off_t offset, int length, int hostno, int inout);
+static const char* generic_NCR5380_info(struct Scsi_Host *);
+static int generic_NCR5380_biosparam(Disk *, struct block_device *, int *);
 
-#ifndef NULL
-#define NULL 0
-#endif
+static int generic_NCR5380_proc_info(char* buffer, char** start, off_t offset, int length, int hostno, int inout);
 
 #ifndef CMD_PER_LUN
 #define CMD_PER_LUN 2
@@ -95,18 +89,13 @@ int generic_NCR5380_proc_info(char* buffer, char** start, off_t offset, int leng
 #define __STRVAL(x) #x
 #define STRVAL(x) __STRVAL(x)
 
-#ifdef CONFIG_SCSI_G_NCR5380_PORT
+#ifndef CONFIG_SCSI_G_NCR5380_MEM
 
 #define NCR5380_map_config port
-
 #define NCR5380_map_type int
-
 #define NCR5380_map_name port
-
 #define NCR5380_instance_name io_port
-
 #define NCR53C400_register_offset 0
-
 #define NCR53C400_address_adjust 8
 
 #ifdef NCR53C400
@@ -122,27 +111,17 @@ int generic_NCR5380_proc_info(char* buffer, char** start, off_t offset, int leng
 /* therefore CONFIG_SCSI_G_NCR5380_MEM */
 
 #define NCR5380_map_config memory
-
 #define NCR5380_map_type unsigned long
-
 #define NCR5380_map_name base
-
 #define NCR5380_instance_name base
-
 #define NCR53C400_register_offset 0x108
-
 #define NCR53C400_address_adjust 0
-
 #define NCR53C400_mem_base 0x3880
-
 #define NCR53C400_host_buffer 0x3900
-
 #define NCR5380_region_size 0x3a00
 
-
 #define NCR5380_read(reg) isa_readb(NCR5380_map_name + NCR53C400_mem_base + (reg))
 #define NCR5380_write(reg, value) isa_writeb(NCR5380_map_name + NCR53C400_mem_base + (reg), value)
-
 #endif
 
 #define NCR5380_implementation_fields \
@@ -155,7 +134,6 @@ int generic_NCR5380_proc_info(char* buffer, char** start, off_t offset, int leng
     NCR5380_map_name = (NCR5380_map_type)((instance)->NCR5380_instance_name)
 
 #define NCR5380_intr generic_NCR5380_intr
-#define do_NCR5380_intr do_generic_NCR5380_intr
 #define NCR5380_queue_command generic_NCR5380_queue_command
 #define NCR5380_abort generic_NCR5380_abort
 #define NCR5380_bus_reset generic_NCR5380_bus_reset

drivers/scsi/g_NCR5380_mmio.c

+/*
+ *	There is probably a nicer way to do this but this one makes
+ *	pretty obvious what is happening. We rebuild the same file with
+ *	different options for mmio versus pio.
+ */
+
+#define SCSI_G_NCR5380_MEM
+
+#include "g_NCR5380.c"
+

drivers/scsi/pas16.c

@@ -118,6 +118,7 @@
 #include <linux/sched.h>
 #include <asm/io.h>
 #include <linux/blk.h>
+#include <linux/delay.h>
 #include "scsi.h"
 #include "hosts.h"
 #include "pas16.h"
@@ -450,7 +451,7 @@ int __init pas16_detect(Scsi_Host_Template * tpnt)
 	    instance->irq = NCR5380_probe_irq(instance, PAS16_IRQS);
 
 	if (instance->irq != IRQ_NONE) 
-	    if (request_irq(instance->irq, do_pas16_intr, SA_INTERRUPT, "pas16", instance)) {
+	    if (request_irq(instance->irq, pas16_intr, SA_INTERRUPT, "pas16", instance)) {
 		printk("scsi%d : IRQ%d not free, interrupts disabled\n", 
 		    instance->host_no, instance->irq);
 		instance->irq = IRQ_NONE;

drivers/scsi/pas16.h

@@ -114,14 +114,14 @@
 
 
 #ifndef ASM
-int pas16_abort(Scsi_Cmnd *);
-int pas16_biosparam(Disk *, struct block_device *, int*);
-int pas16_detect(Scsi_Host_Template *);
-int pas16_queue_command(Scsi_Cmnd *, void (*done)(Scsi_Cmnd *));
-int pas16_bus_reset(Scsi_Cmnd *);
-int pas16_host_reset(Scsi_Cmnd *);
-int pas16_device_reset(Scsi_Cmnd *);
-int pas16_proc_info (char *buffer ,char **start, off_t offset,
+static int pas16_abort(Scsi_Cmnd *);
+static int pas16_biosparam(Disk *, struct block_device *, int*);
+static int pas16_detect(Scsi_Host_Template *);
+static int pas16_queue_command(Scsi_Cmnd *, void (*done)(Scsi_Cmnd *));
+static int pas16_bus_reset(Scsi_Cmnd *);
+static int pas16_host_reset(Scsi_Cmnd *);
+static int pas16_device_reset(Scsi_Cmnd *);
+static int pas16_proc_info (char *buffer ,char **start, off_t offset,
 		     int length, int hostno, int inout);
 
 #ifndef NULL

drivers/scsi/t128.c

@@ -120,6 +120,7 @@
 #include <linux/stat.h>
 #include <linux/init.h>
 #include <linux/module.h>
+#include <linux/delay.h>
 
 static struct override {
     unsigned long address;
@@ -247,7 +248,7 @@ int __init t128_detect(Scsi_Host_Template * tpnt){
 	    instance->irq = NCR5380_probe_irq(instance, T128_IRQS);
 
 	if (instance->irq != IRQ_NONE) 
-	    if (request_irq(instance->irq, do_t128_intr, SA_INTERRUPT, "t128", instance)) {
+	    if (request_irq(instance->irq, t128_intr, SA_INTERRUPT, "t128", instance)) {
 		printk("scsi%d : IRQ%d not free, interrupts disabled\n", 
 		    instance->host_no, instance->irq);
 		instance->irq = IRQ_NONE;

drivers/scsi/t128.h

@@ -91,14 +91,14 @@
 #define T_DATA_REG_OFFSET	0x1e00	/* rw 512 bytes long */
 
 #ifndef ASM
-int t128_abort(Scsi_Cmnd *);
-int t128_biosparam(Disk *, struct block_device *, int*);
-int t128_detect(Scsi_Host_Template *);
-int t128_queue_command(Scsi_Cmnd *, void (*done)(Scsi_Cmnd *));
-int t128_host_reset(Scsi_Cmnd *);
-int t128_bus_reset(Scsi_Cmnd *);
-int t128_device_reset(Scsi_Cmnd *);
-int t128_proc_info (char *buffer, char **start, off_t offset,
+static int t128_abort(Scsi_Cmnd *);
+static int t128_biosparam(Disk *, struct block_device *, int*);
+static int t128_detect(Scsi_Host_Template *);
+static int t128_queue_command(Scsi_Cmnd *, void (*done)(Scsi_Cmnd *));
+static int t128_host_reset(Scsi_Cmnd *);
+static int t128_bus_reset(Scsi_Cmnd *);
+static int t128_device_reset(Scsi_Cmnd *);
+static int t128_proc_info (char *buffer, char **start, off_t offset,
 		   int length, int hostno, int inout);
 
 #ifndef NULL
@@ -166,7 +166,7 @@ int t128_proc_info (char *buffer, char **start, off_t offset,
 #define do_NCR5380_intr do_t128_intr
 #define NCR5380_queue_command t128_queue_command
 #define NCR5380_abort t128_abort
-#define NCR5380_host_reset t128_hostreset
+#define NCR5380_host_reset t128_host_reset
 #define NCR5380_device_reset t128_device_reset
 #define NCR5380_bus_reset t128_bus_reset
 #define NCR5380_proc_info t128_proc_info