iv/linux
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

ncr5380: Use standard list data structure

Browse Source 
The NCR5380 drivers have a home-spun linked list implementation for
scsi_cmnd structs that uses cmd->host_scribble as a 'next' pointer. Adopt
the standard list_head data structure and list operations instead. Remove
the eh_abort_handler rather than convert it. Doing the conversion would
only be churn because the existing EH handlers don't work and get replaced
in a subsequent patch.

Signed-off-by: Finn Thain <fthain@telegraphics.com.au>
Reviewed-by: Hannes Reinecke <hare@suse.com>
Tested-by: Ondrej Zary <linux@rainbow-software.org>
Tested-by: Michael Schmitz <schmitzmic@gmail.com>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
This commit is contained in:
Finn Thain 2016-01-03 16:05:58 +11:00 committed by Martin K. Petersen
parent 5299b3caf5
commit 32b26a1042
13 changed files with 106 additions and 421 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

214
drivers/scsi/NCR5380.c
View File

@ -622,8 +622,9 @@ static int NCR5380_init(struct Scsi_Host *instance, int flags)
#endif #endif
spin_lock_init(&hostdata->lock); spin_lock_init(&hostdata->lock);
hostdata->connected = NULL; hostdata->connected = NULL;
hostdata->issue_queue = NULL; INIT_LIST_HEAD(&hostdata->unissued);
hostdata->disconnected_queue = NULL; INIT_LIST_HEAD(&hostdata->disconnected);
hostdata->flags = flags; hostdata->flags = flags;
INIT_WORK(&hostdata->main_task, NCR5380_main); INIT_WORK(&hostdata->main_task, NCR5380_main);
@ -738,7 +739,7 @@ static int NCR5380_queue_command(struct Scsi_Host *instance,
struct scsi_cmnd *cmd) struct scsi_cmnd *cmd)
{ {
struct NCR5380_hostdata *hostdata = shost_priv(instance); struct NCR5380_hostdata *hostdata = shost_priv(instance);
struct scsi_cmnd *tmp; struct NCR5380_cmd *ncmd = scsi_cmd_priv(cmd);
unsigned long flags; unsigned long flags;
#if (NDEBUG & NDEBUG_NO_WRITE) #if (NDEBUG & NDEBUG_NO_WRITE)
@ -752,12 +753,6 @@ static int NCR5380_queue_command(struct Scsi_Host *instance,
} }
#endif /* (NDEBUG & NDEBUG_NO_WRITE) */ #endif /* (NDEBUG & NDEBUG_NO_WRITE) */
/*
* We use the host_scribble field as a pointer to the next command
* in a queue
*/
cmd->host_scribble = NULL;
cmd->result = 0; cmd->result = 0;
spin_lock_irqsave(&hostdata->lock, flags); spin_lock_irqsave(&hostdata->lock, flags);
@ -769,13 +764,11 @@ static int NCR5380_queue_command(struct Scsi_Host *instance,
* sense data is only guaranteed to be valid while the condition exists. * sense data is only guaranteed to be valid while the condition exists.
*/ */
if (!(hostdata->issue_queue) || (cmd->cmnd[0] == REQUEST_SENSE)) { if (cmd->cmnd[0] == REQUEST_SENSE)
cmd->host_scribble = (unsigned char *) hostdata->issue_queue; list_add(&ncmd->list, &hostdata->unissued);
hostdata->issue_queue = cmd; else
} else { list_add_tail(&ncmd->list, &hostdata->unissued);
for (tmp = (struct scsi_cmnd *) hostdata->issue_queue; tmp->host_scribble; tmp = (struct scsi_cmnd *) tmp->host_scribble);
tmp->host_scribble = (unsigned char *) cmd;
}
spin_unlock_irqrestore(&hostdata->lock, flags); spin_unlock_irqrestore(&hostdata->lock, flags);
dsprintk(NDEBUG_QUEUES, instance, "command %p added to %s of queue\n", dsprintk(NDEBUG_QUEUES, instance, "command %p added to %s of queue\n",
@ -803,7 +796,7 @@ static void NCR5380_main(struct work_struct *work)
struct NCR5380_hostdata *hostdata = struct NCR5380_hostdata *hostdata =
container_of(work, struct NCR5380_hostdata, main_task); container_of(work, struct NCR5380_hostdata, main_task);
struct Scsi_Host *instance = hostdata->host; struct Scsi_Host *instance = hostdata->host;
struct scsi_cmnd *tmp, *prev; struct NCR5380_cmd *ncmd, *n;
int done; int done;
spin_lock_irq(&hostdata->lock); spin_lock_irq(&hostdata->lock);
@ -816,23 +809,20 @@ static void NCR5380_main(struct work_struct *work)
* Search through the issue_queue for a command destined * Search through the issue_queue for a command destined
* for a target that's not busy. * for a target that's not busy.
*/ */
for (tmp = (struct scsi_cmnd *) hostdata->issue_queue, prev = NULL; tmp; prev = tmp, tmp = (struct scsi_cmnd *) tmp->host_scribble) list_for_each_entry_safe(ncmd, n, &hostdata->unissued,
{ list) {
struct scsi_cmnd *tmp = NCR5380_to_scmd(ncmd);
dsprintk(NDEBUG_QUEUES, instance, "main: tmp=%p target=%d busy=%d lun=%llu\n", dsprintk(NDEBUG_QUEUES, instance, "main: tmp=%p target=%d busy=%d lun=%llu\n",
tmp, scmd_id(tmp), hostdata->busy[scmd_id(tmp)], tmp, scmd_id(tmp), hostdata->busy[scmd_id(tmp)],
tmp->device->lun); tmp->device->lun);
/* When we find one, remove it from the issue queue. */ /* When we find one, remove it from the issue queue. */
if (!(hostdata->busy[tmp->device->id] & if (!(hostdata->busy[tmp->device->id] &
(1 << (u8)(tmp->device->lun & 0xff)))) { (1 << (u8)(tmp->device->lun & 0xff)))) {
if (prev) { list_del(&ncmd->list);
prev->host_scribble = tmp->host_scribble;
} else {
hostdata->issue_queue = (struct scsi_cmnd *) tmp->host_scribble;
}
tmp->host_scribble = NULL;
dsprintk(NDEBUG_MAIN | NDEBUG_QUEUES, dsprintk(NDEBUG_MAIN | NDEBUG_QUEUES,
instance, "main: removed %p from issue queue %p\n", instance, "main: removed %p from issue queue\n",
tmp, prev); tmp);
/* /*
* Attempt to establish an I_T_L nexus here. * Attempt to establish an I_T_L nexus here.
@ -851,8 +841,7 @@ static void NCR5380_main(struct work_struct *work)
/* OK or bad target */ /* OK or bad target */
} else { } else {
/* Need to retry */ /* Need to retry */
tmp->host_scribble = (unsigned char *) hostdata->issue_queue; list_add(&ncmd->list, &hostdata->unissued);
hostdata->issue_queue = tmp;
dsprintk(NDEBUG_MAIN | NDEBUG_QUEUES, dsprintk(NDEBUG_MAIN | NDEBUG_QUEUES,
instance, "main: select() failed, %p returned to issue queue\n", instance, "main: select() failed, %p returned to issue queue\n",
tmp); tmp);
@ -1744,6 +1733,8 @@ static void NCR5380_information_transfer(struct Scsi_Host *instance) {
struct scsi_cmnd *cmd; struct scsi_cmnd *cmd;
while ((cmd = hostdata->connected)) { while ((cmd = hostdata->connected)) {
struct NCR5380_cmd *ncmd = scsi_cmd_priv(cmd);
tmp = NCR5380_read(STATUS_REG); tmp = NCR5380_read(STATUS_REG);
/* We only have a valid SCSI phase when REQ is asserted */ /* We only have a valid SCSI phase when REQ is asserted */
if (tmp & SR_REQ) { if (tmp & SR_REQ) {
@ -1875,9 +1866,7 @@ static void NCR5380_information_transfer(struct Scsi_Host *instance) {
if ((cmd->cmnd[0] != REQUEST_SENSE) && (status_byte(cmd->SCp.Status) == CHECK_CONDITION)) { if ((cmd->cmnd[0] != REQUEST_SENSE) && (status_byte(cmd->SCp.Status) == CHECK_CONDITION)) {
scsi_eh_prep_cmnd(cmd, &hostdata->ses, NULL, 0, ~0); scsi_eh_prep_cmnd(cmd, &hostdata->ses, NULL, 0, ~0);
cmd->host_scribble = (unsigned char *) list_add(&ncmd->list, &hostdata->unissued);
hostdata->issue_queue;
hostdata->issue_queue = (struct scsi_cmnd *) cmd;
dsprintk(NDEBUG_AUTOSENSE | NDEBUG_QUEUES, dsprintk(NDEBUG_AUTOSENSE | NDEBUG_QUEUES,
instance, "REQUEST SENSE cmd %p added to head of issue queue\n", instance, "REQUEST SENSE cmd %p added to head of issue queue\n",
cmd); cmd);
@ -1911,10 +1900,8 @@ static void NCR5380_information_transfer(struct Scsi_Host *instance) {
case DISCONNECT:{ case DISCONNECT:{
/* Accept message by clearing ACK */ /* Accept message by clearing ACK */
NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
cmd->host_scribble = (unsigned char *)
hostdata->disconnected_queue;
hostdata->connected = NULL; hostdata->connected = NULL;
hostdata->disconnected_queue = cmd; list_add(&ncmd->list, &hostdata->disconnected);
dsprintk(NDEBUG_INFORMATION | NDEBUG_QUEUES, dsprintk(NDEBUG_INFORMATION | NDEBUG_QUEUES,
instance, "connected command %p for target %d lun %llu moved to disconnected queue\n", instance, "connected command %p for target %d lun %llu moved to disconnected queue\n",
cmd, scmd_id(cmd), cmd->device->lun); cmd, scmd_id(cmd), cmd->device->lun);
@ -2087,7 +2074,8 @@ static void NCR5380_reselect(struct Scsi_Host *instance) {
int len; int len;
unsigned char msg[3]; unsigned char msg[3];
unsigned char *data; unsigned char *data;
struct scsi_cmnd *tmp = NULL, *prev; struct NCR5380_cmd *ncmd;
struct scsi_cmnd *tmp;
/* /*
* Disable arbitration, etc. since the host adapter obviously * Disable arbitration, etc. since the host adapter obviously
@ -2156,16 +2144,14 @@ static void NCR5380_reselect(struct Scsi_Host *instance) {
* just reestablished, and remove it from the disconnected queue. * just reestablished, and remove it from the disconnected queue.
*/ */
for (tmp = (struct scsi_cmnd *) hostdata->disconnected_queue, prev = NULL; tmp = NULL;
tmp; prev = tmp, tmp = (struct scsi_cmnd *) tmp->host_scribble) { list_for_each_entry(ncmd, &hostdata->disconnected, list) {
if ((target_mask == (1 << tmp->device->id)) && (lun == (u8)tmp->device->lun)) { struct scsi_cmnd *cmd = NCR5380_to_scmd(ncmd);
if (prev) {
prev->host_scribble = tmp->host_scribble; if (target_mask == (1 << scmd_id(cmd)) &&
} else { lun == (u8)cmd->device->lun) {
hostdata->disconnected_queue = list_del(&ncmd->list);
(struct scsi_cmnd *) tmp->host_scribble; tmp = cmd;
}
tmp->host_scribble = NULL;
break; break;
} }
} }
@ -2261,146 +2247,18 @@ static int NCR5380_abort(struct scsi_cmnd *cmd)
{ {
struct Scsi_Host *instance = cmd->device->host; struct Scsi_Host *instance = cmd->device->host;
struct NCR5380_hostdata *hostdata = shost_priv(instance); struct NCR5380_hostdata *hostdata = shost_priv(instance);
struct scsi_cmnd *tmp, **prev;
unsigned long flags; unsigned long flags;
scmd_printk(KERN_WARNING, cmd, "aborting command\n");
spin_lock_irqsave(&hostdata->lock, flags); spin_lock_irqsave(&hostdata->lock, flags);
#if (NDEBUG & NDEBUG_ANY)
scmd_printk(KERN_INFO, cmd, "aborting command\n");
#endif
NCR5380_dprint(NDEBUG_ANY, instance); NCR5380_dprint(NDEBUG_ANY, instance);
NCR5380_dprint_phase(NDEBUG_ANY, instance); NCR5380_dprint_phase(NDEBUG_ANY, instance);
dprintk(NDEBUG_ABORT, "scsi%d : abort called\n", instance->host_no);
dprintk(NDEBUG_ABORT, " basr 0x%X, sr 0x%X\n", NCR5380_read(BUS_AND_STATUS_REG), NCR5380_read(STATUS_REG));
#if 0
/*
* Case 1 : If the command is the currently executing command,
* we'll set the aborted flag and return control so that
* information transfer routine can exit cleanly.
*/
if (hostdata->connected == cmd) {
dprintk(NDEBUG_ABORT, "scsi%d : aborting connected command\n", instance->host_no);
/*
* We should perform BSY checking, and make sure we haven't slipped
* into BUS FREE.
*/
NCR5380_write(INITIATOR_COMMAND_REG, ICR_ASSERT_ATN);
/*
* Since we can't change phases until we've completed the current
* handshake, we have to source or sink a byte of data if the current
* phase is not MSGOUT.
*/
/*
* Return control to the executing NCR drive so we can clear the
* aborted flag and get back into our main loop.
*/
return SUCCESS;
}
#endif
/*
* Case 2 : If the command hasn't been issued yet, we simply remove it
* from the issue queue.
*/
dprintk(NDEBUG_ABORT, "scsi%d : abort going into loop.\n", instance->host_no);
for (prev = (struct scsi_cmnd **) &(hostdata->issue_queue), tmp = (struct scsi_cmnd *) hostdata->issue_queue; tmp; prev = (struct scsi_cmnd **) &(tmp->host_scribble), tmp = (struct scsi_cmnd *) tmp->host_scribble)
if (cmd == tmp) {
(*prev) = (struct scsi_cmnd *) tmp->host_scribble;
tmp->host_scribble = NULL;
spin_unlock_irqrestore(&hostdata->lock, flags);
tmp->result = DID_ABORT << 16;
dprintk(NDEBUG_ABORT, "scsi%d : abort removed command from issue queue.\n", instance->host_no);
tmp->scsi_done(tmp);
return SUCCESS;
}
#if (NDEBUG & NDEBUG_ABORT)
/* KLL */
else if (prev == tmp)
printk(KERN_ERR "scsi%d : LOOP\n", instance->host_no);
#endif
/*
* Case 3 : If any commands are 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) {
spin_unlock_irqrestore(&hostdata->lock, flags);
dprintk(NDEBUG_ABORT, "scsi%d : abort failed, command connected.\n", instance->host_no);
return FAILED;
}
/*
* Case 4: If the command is currently disconnected from the bus, and
* there are no connected commands, we reconnect the I_T_L or
* I_T_L_Q nexus associated with it, go into message out, and send
* an abort message.
*
* This case is especially ugly. In order to reestablish the nexus, we
* need to call NCR5380_select(). The easiest way to implement this
* function was to abort if the bus was busy, and let the interrupt
* handler triggered on the SEL for reselect take care of lost arbitrations
* where necessary, meaning interrupts need to be enabled.
*
* When interrupts are enabled, the queues may change - so we
* can't remove it from the disconnected queue before selecting it
* because that could cause a failure in hashing the nexus if that
* device reselected.
*
* Since the queues may change, we can't use the pointers from when we
* first locate it.
*
* So, we must first locate the command, and if NCR5380_select()
* succeeds, then issue the abort, relocate the command and remove
* it from the disconnected queue.
*/
for (tmp = (struct scsi_cmnd *) hostdata->disconnected_queue; tmp; tmp = (struct scsi_cmnd *) tmp->host_scribble)
if (cmd == tmp) {
dprintk(NDEBUG_ABORT, "scsi%d : aborting disconnected command.\n", instance->host_no);
if (NCR5380_select(instance, cmd)) {
spin_unlock_irq(&hostdata->lock);
return FAILED;
}
dprintk(NDEBUG_ABORT, "scsi%d : nexus reestablished.\n", instance->host_no);
do_abort(instance);
for (prev = (struct scsi_cmnd **) &(hostdata->disconnected_queue), tmp = (struct scsi_cmnd *) hostdata->disconnected_queue; tmp; prev = (struct scsi_cmnd **) &(tmp->host_scribble), tmp = (struct scsi_cmnd *) tmp->host_scribble)
if (cmd == tmp) {
*prev = (struct scsi_cmnd *) tmp->host_scribble;
tmp->host_scribble = NULL;
spin_unlock_irqrestore(&hostdata->lock, flags);
tmp->result = DID_ABORT << 16;
tmp->scsi_done(tmp);
return SUCCESS;
}
}
/*
* Case 5 : 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.
*/
spin_unlock_irqrestore(&hostdata->lock, flags); spin_unlock_irqrestore(&hostdata->lock, flags);
printk(KERN_WARNING "scsi%d : warning : SCSI command probably completed successfully\n"
" before abortion\n", instance->host_no);
return FAILED; return FAILED;
} }

16
drivers/scsi/NCR5380.h
View File

@ -24,6 +24,7 @@
#include <linux/delay.h> #include <linux/delay.h>
#include <linux/interrupt.h> #include <linux/interrupt.h>
#include <linux/list.h>
#include <linux/workqueue.h> #include <linux/workqueue.h>
#include <scsi/scsi_dbg.h> #include <scsi/scsi_dbg.h>
#include <scsi/scsi_eh.h> #include <scsi/scsi_eh.h>
@ -254,8 +255,8 @@ struct NCR5380_hostdata {
#endif #endif
unsigned char last_message; /* last message OUT */ unsigned char last_message; /* last message OUT */
struct scsi_cmnd *connected; /* currently connected cmnd */ struct scsi_cmnd *connected; /* currently connected cmnd */
struct scsi_cmnd *issue_queue; /* waiting to be issued */ struct list_head unissued; /* waiting to be issued */
struct scsi_cmnd *disconnected_queue; /* waiting for reconnect */ struct list_head disconnected; /* waiting for reconnect */
spinlock_t lock; /* protects this struct */ spinlock_t lock; /* protects this struct */
int flags; int flags;
struct scsi_eh_save ses; struct scsi_eh_save ses;
@ -277,6 +278,17 @@ struct NCR5380_hostdata {
#ifdef __KERNEL__ #ifdef __KERNEL__
struct NCR5380_cmd {
struct list_head list;
};
#define NCR5380_CMD_SIZE (sizeof(struct NCR5380_cmd))
static inline struct scsi_cmnd *NCR5380_to_scmd(struct NCR5380_cmd *ncmd_ptr)
{
return ((struct scsi_cmnd *)ncmd_ptr) - 1;
}
#ifndef NDEBUG #ifndef NDEBUG
#define NDEBUG (0) #define NDEBUG (0)
#endif #endif

1
drivers/scsi/arm/cumana_1.c
View File

@ -208,6 +208,7 @@ static struct scsi_host_template cumanascsi_template = {
.cmd_per_lun = 2, .cmd_per_lun = 2,
.use_clustering = DISABLE_CLUSTERING, .use_clustering = DISABLE_CLUSTERING,
.proc_name = "CumanaSCSI-1", .proc_name = "CumanaSCSI-1",
.cmd_size = NCR5380_CMD_SIZE,
}; };
static int cumanascsi1_probe(struct expansion_card *ec, static int cumanascsi1_probe(struct expansion_card *ec,

1
drivers/scsi/arm/oak.c
View File

@ -114,6 +114,7 @@ static struct scsi_host_template oakscsi_template = {
.cmd_per_lun = 2, .cmd_per_lun = 2,
.use_clustering = DISABLE_CLUSTERING, .use_clustering = DISABLE_CLUSTERING,
.proc_name = "oakscsi", .proc_name = "oakscsi",
.cmd_size = NCR5380_CMD_SIZE,
}; };
static int oakscsi_probe(struct expansion_card *ec, const struct ecard_id *id) static int oakscsi_probe(struct expansion_card *ec, const struct ecard_id *id)

287
drivers/scsi/atari_NCR5380.c
View File

@ -175,10 +175,6 @@
* possible) function may be used. * possible) function may be used.
*/ */
#define NEXT(cmd) ((struct scsi_cmnd *)(cmd)->host_scribble)
#define SET_NEXT(cmd,next) ((cmd)->host_scribble = (void *)(next))
#define NEXTADDR(cmd) ((struct scsi_cmnd **)&(cmd)->host_scribble)
#define HOSTNO instance->host_no #define HOSTNO instance->host_no
static int do_abort(struct Scsi_Host *); static int do_abort(struct Scsi_Host *);
@ -665,8 +661,9 @@ static int __init NCR5380_init(struct Scsi_Host *instance, int flags)
#endif #endif
spin_lock_init(&hostdata->lock); spin_lock_init(&hostdata->lock);
hostdata->connected = NULL; hostdata->connected = NULL;
hostdata->issue_queue = NULL; INIT_LIST_HEAD(&hostdata->unissued);
hostdata->disconnected_queue = NULL; INIT_LIST_HEAD(&hostdata->disconnected);
hostdata->flags = flags; hostdata->flags = flags;
INIT_WORK(&hostdata->main_task, NCR5380_main); INIT_WORK(&hostdata->main_task, NCR5380_main);
@ -781,7 +778,7 @@ static int NCR5380_queue_command(struct Scsi_Host *instance,
struct scsi_cmnd *cmd) struct scsi_cmnd *cmd)
{ {
struct NCR5380_hostdata *hostdata = shost_priv(instance); struct NCR5380_hostdata *hostdata = shost_priv(instance);
struct scsi_cmnd *tmp; struct NCR5380_cmd *ncmd = scsi_cmd_priv(cmd);
unsigned long flags; unsigned long flags;
#if (NDEBUG & NDEBUG_NO_WRITE) #if (NDEBUG & NDEBUG_NO_WRITE)
@ -795,12 +792,6 @@ static int NCR5380_queue_command(struct Scsi_Host *instance,
} }
#endif /* (NDEBUG & NDEBUG_NO_WRITE) */ #endif /* (NDEBUG & NDEBUG_NO_WRITE) */
/*
* We use the host_scribble field as a pointer to the next command
* in a queue
*/
SET_NEXT(cmd, NULL);
cmd->result = 0; cmd->result = 0;
/* /*
@ -834,15 +825,11 @@ static int NCR5380_queue_command(struct Scsi_Host *instance,
* sense data is only guaranteed to be valid while the condition exists. * sense data is only guaranteed to be valid while the condition exists.
*/ */
if (!(hostdata->issue_queue) || (cmd->cmnd[0] == REQUEST_SENSE)) { if (cmd->cmnd[0] == REQUEST_SENSE)
SET_NEXT(cmd, hostdata->issue_queue); list_add(&ncmd->list, &hostdata->unissued);
hostdata->issue_queue = cmd; else
} else { list_add_tail(&ncmd->list, &hostdata->unissued);
for (tmp = (struct scsi_cmnd *)hostdata->issue_queue;
NEXT(tmp); tmp = NEXT(tmp))
;
SET_NEXT(tmp, cmd);
}
spin_unlock_irqrestore(&hostdata->lock, flags); spin_unlock_irqrestore(&hostdata->lock, flags);
dsprintk(NDEBUG_QUEUES, instance, "command %p added to %s of queue\n", dsprintk(NDEBUG_QUEUES, instance, "command %p added to %s of queue\n",
@ -858,8 +845,8 @@ static inline void maybe_release_dma_irq(struct Scsi_Host *instance)
struct NCR5380_hostdata *hostdata = shost_priv(instance); struct NCR5380_hostdata *hostdata = shost_priv(instance);
/* Caller does the locking needed to set & test these data atomically */ /* Caller does the locking needed to set & test these data atomically */
if (!hostdata->disconnected_queue && if (list_empty(&hostdata->disconnected) &&
!hostdata->issue_queue && list_empty(&hostdata->unissued) &&
!hostdata->connected && !hostdata->connected &&
!hostdata->retain_dma_intr) !hostdata->retain_dma_intr)
NCR5380_release_dma_irq(instance); NCR5380_release_dma_irq(instance);
@ -881,7 +868,7 @@ static void NCR5380_main(struct work_struct *work)
struct NCR5380_hostdata *hostdata = struct NCR5380_hostdata *hostdata =
container_of(work, struct NCR5380_hostdata, main_task); container_of(work, struct NCR5380_hostdata, main_task);
struct Scsi_Host *instance = hostdata->host; struct Scsi_Host *instance = hostdata->host;
struct scsi_cmnd *tmp, *prev; struct NCR5380_cmd *ncmd, *n;
int done; int done;
/* /*
@ -900,17 +887,9 @@ static void NCR5380_main(struct work_struct *work)
* Search through the issue_queue for a command destined * Search through the issue_queue for a command destined
* for a target that's not busy. * for a target that's not busy.
*/ */
#if (NDEBUG & NDEBUG_LISTS) list_for_each_entry_safe(ncmd, n, &hostdata->unissued,
for (tmp = (struct scsi_cmnd *) hostdata->issue_queue, prev = NULL; list) {
tmp && (tmp != prev); prev = tmp, tmp = NEXT(tmp)) struct scsi_cmnd *tmp = NCR5380_to_scmd(ncmd);
;
/*printk("%p ", tmp);*/
if ((tmp == prev) && tmp)
printk(" LOOP\n");
/* else printk("\n"); */
#endif
for (tmp = (struct scsi_cmnd *) hostdata->issue_queue,
prev = NULL; tmp; prev = tmp, tmp = NEXT(tmp)) {
u8 lun = tmp->device->lun; u8 lun = tmp->device->lun;
dsprintk(NDEBUG_QUEUES, instance, "main: tmp=%p target=%d busy=%d lun=%d\n", dsprintk(NDEBUG_QUEUES, instance, "main: tmp=%p target=%d busy=%d lun=%d\n",
@ -923,15 +902,10 @@ static void NCR5380_main(struct work_struct *work)
!(hostdata->busy[tmp->device->id] & (1 << lun)) !(hostdata->busy[tmp->device->id] & (1 << lun))
#endif #endif
) { ) {
if (prev) { list_del(&ncmd->list);
SET_NEXT(prev, NEXT(tmp));
} else {
hostdata->issue_queue = NEXT(tmp);
}
SET_NEXT(tmp, NULL);
dsprintk(NDEBUG_MAIN | NDEBUG_QUEUES, dsprintk(NDEBUG_MAIN | NDEBUG_QUEUES,
instance, "main: removed %p from issue queue %p\n", instance, "main: removed %p from issue queue\n",
tmp, prev); tmp);
hostdata->retain_dma_intr++; hostdata->retain_dma_intr++;
@ -960,8 +934,7 @@ static void NCR5380_main(struct work_struct *work)
maybe_release_dma_irq(instance); maybe_release_dma_irq(instance);
} else { } else {
/* Need to retry */ /* Need to retry */
SET_NEXT(tmp, hostdata->issue_queue); list_add(&ncmd->list, &hostdata->unissued);
hostdata->issue_queue = tmp;
dsprintk(NDEBUG_MAIN | NDEBUG_QUEUES, dsprintk(NDEBUG_MAIN | NDEBUG_QUEUES,
instance, "main: select() failed, %p returned to issue queue\n", instance, "main: select() failed, %p returned to issue queue\n",
tmp); tmp);
@ -1834,6 +1807,8 @@ static void NCR5380_information_transfer(struct Scsi_Host *instance)
#endif #endif
while ((cmd = hostdata->connected)) { while ((cmd = hostdata->connected)) {
struct NCR5380_cmd *ncmd = scsi_cmd_priv(cmd);
tmp = NCR5380_read(STATUS_REG); tmp = NCR5380_read(STATUS_REG);
/* We only have a valid SCSI phase when REQ is asserted */ /* We only have a valid SCSI phase when REQ is asserted */
if (tmp & SR_REQ) { if (tmp & SR_REQ) {
@ -2042,8 +2017,7 @@ static void NCR5380_information_transfer(struct Scsi_Host *instance)
(status_byte(cmd->SCp.Status) == CHECK_CONDITION)) { (status_byte(cmd->SCp.Status) == CHECK_CONDITION)) {
scsi_eh_prep_cmnd(cmd, &hostdata->ses, NULL, 0, ~0); scsi_eh_prep_cmnd(cmd, &hostdata->ses, NULL, 0, ~0);
SET_NEXT(cmd, hostdata->issue_queue); list_add(&ncmd->list, &hostdata->unissued);
hostdata->issue_queue = (struct scsi_cmnd *) cmd;
dsprintk(NDEBUG_AUTOSENSE | NDEBUG_QUEUES, dsprintk(NDEBUG_AUTOSENSE | NDEBUG_QUEUES,
instance, "REQUEST SENSE cmd %p added to head of issue queue\n", instance, "REQUEST SENSE cmd %p added to head of issue queue\n",
cmd); cmd);
@ -2092,9 +2066,8 @@ static void NCR5380_information_transfer(struct Scsi_Host *instance)
case DISCONNECT: case DISCONNECT:
/* Accept message by clearing ACK */ /* Accept message by clearing ACK */
NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE); NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
SET_NEXT(cmd, hostdata->disconnected_queue);
hostdata->connected = NULL; hostdata->connected = NULL;
hostdata->disconnected_queue = cmd; list_add(&ncmd->list, &hostdata->disconnected);
dsprintk(NDEBUG_INFORMATION | NDEBUG_QUEUES, dsprintk(NDEBUG_INFORMATION | NDEBUG_QUEUES,
instance, "connected command %p for target %d lun %llu moved to disconnected queue\n", instance, "connected command %p for target %d lun %llu moved to disconnected queue\n",
cmd, scmd_id(cmd), cmd->device->lun); cmd, scmd_id(cmd), cmd->device->lun);
@ -2288,7 +2261,8 @@ static void NCR5380_reselect(struct Scsi_Host *instance)
unsigned char msg[3]; unsigned char msg[3];
int __maybe_unused len; int __maybe_unused len;
unsigned char __maybe_unused *data, __maybe_unused phase; unsigned char __maybe_unused *data, __maybe_unused phase;
struct scsi_cmnd *tmp = NULL, *prev; struct NCR5380_cmd *ncmd;
struct scsi_cmnd *tmp;
/* /*
* Disable arbitration, etc. since the host adapter obviously * Disable arbitration, etc. since the host adapter obviously
@ -2379,19 +2353,18 @@ static void NCR5380_reselect(struct Scsi_Host *instance)
* just reestablished, and remove it from the disconnected queue. * just reestablished, and remove it from the disconnected queue.
*/ */
for (tmp = (struct scsi_cmnd *) hostdata->disconnected_queue, prev = NULL; tmp = NULL;
tmp; prev = tmp, tmp = NEXT(tmp)) { list_for_each_entry(ncmd, &hostdata->disconnected, list) {
if ((target_mask == (1 << tmp->device->id)) && (lun == (u8)tmp->device->lun) struct scsi_cmnd *cmd = NCR5380_to_scmd(ncmd);
if (target_mask == (1 << scmd_id(cmd)) &&
lun == (u8)cmd->device->lun
#ifdef SUPPORT_TAGS #ifdef SUPPORT_TAGS
&& (tag == tmp->tag) && (tag == cmd->tag)
#endif #endif
) { ) {
if (prev) { list_del(&ncmd->list);
SET_NEXT(prev, NEXT(tmp)); tmp = cmd;
} else {
hostdata->disconnected_queue = NEXT(tmp);
}
SET_NEXT(tmp, NULL);
break; break;
} }
} }
@ -2489,188 +2462,18 @@ int NCR5380_abort(struct scsi_cmnd *cmd)
{ {
struct Scsi_Host *instance = cmd->device->host; struct Scsi_Host *instance = cmd->device->host;
struct NCR5380_hostdata *hostdata = shost_priv(instance); struct NCR5380_hostdata *hostdata = shost_priv(instance);
struct scsi_cmnd *tmp, **prev;
unsigned long flags; unsigned long flags;
scmd_printk(KERN_NOTICE, cmd, "aborting command\n");
spin_lock_irqsave(&hostdata->lock, flags); spin_lock_irqsave(&hostdata->lock, flags);
#if (NDEBUG & NDEBUG_ANY)
scmd_printk(KERN_INFO, cmd, "aborting command\n");
#endif
NCR5380_dprint(NDEBUG_ANY, instance); NCR5380_dprint(NDEBUG_ANY, instance);
NCR5380_dprint_phase(NDEBUG_ANY, instance); NCR5380_dprint_phase(NDEBUG_ANY, instance);
dprintk(NDEBUG_ABORT, "scsi%d: abort called basr 0x%02x, sr 0x%02x\n", HOSTNO,
NCR5380_read(BUS_AND_STATUS_REG),
NCR5380_read(STATUS_REG));
#if 1
/*
* Case 1 : If the command is the currently executing command,
* we'll set the aborted flag and return control so that
* information transfer routine can exit cleanly.
*/
if (hostdata->connected == cmd) {
dprintk(NDEBUG_ABORT, "scsi%d: aborting connected command\n", HOSTNO);
/*
* We should perform BSY checking, and make sure we haven't slipped
* into BUS FREE.
*/
/* NCR5380_write(INITIATOR_COMMAND_REG, ICR_ASSERT_ATN); */
/*
* Since we can't change phases until we've completed the current
* handshake, we have to source or sink a byte of data if the current
* phase is not MSGOUT.
*/
/*
* Return control to the executing NCR drive so we can clear the
* aborted flag and get back into our main loop.
*/
if (do_abort(instance) == 0) {
hostdata->connected = NULL;
cmd->result = DID_ABORT << 16;
#ifdef SUPPORT_TAGS
cmd_free_tag(cmd);
#else
hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun);
#endif
maybe_release_dma_irq(instance);
spin_unlock_irqrestore(&hostdata->lock, flags);
cmd->scsi_done(cmd);
return SUCCESS;
} else {
spin_unlock_irqrestore(&hostdata->lock, flags);
printk("scsi%d: abort of connected command failed!\n", HOSTNO);
return FAILED;
}
}
#endif
/*
* Case 2 : If the command hasn't been issued yet, we simply remove it
* from the issue queue.
*/
for (prev = (struct scsi_cmnd **)&(hostdata->issue_queue),
tmp = (struct scsi_cmnd *)hostdata->issue_queue;
tmp; prev = NEXTADDR(tmp), tmp = NEXT(tmp)) {
if (cmd == tmp) {
(*prev) = NEXT(tmp);
SET_NEXT(tmp, NULL);
tmp->result = DID_ABORT << 16;
maybe_release_dma_irq(instance);
spin_unlock_irqrestore(&hostdata->lock, flags);
dprintk(NDEBUG_ABORT, "scsi%d: abort removed command from issue queue.\n",
HOSTNO);
/* Tagged queuing note: no tag to free here, hasn't been assigned
* yet... */
tmp->scsi_done(tmp);
return SUCCESS;
}
}
/*
* Case 3 : If any commands are 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) {
spin_unlock_irqrestore(&hostdata->lock, flags);
dprintk(NDEBUG_ABORT, "scsi%d: abort failed, command connected.\n", HOSTNO);
return FAILED;
}
/*
* Case 4: If the command is currently disconnected from the bus, and
* there are no connected commands, we reconnect the I_T_L or
* I_T_L_Q nexus associated with it, go into message out, and send
* an abort message.
*
* This case is especially ugly. In order to reestablish the nexus, we
* need to call NCR5380_select(). The easiest way to implement this
* function was to abort if the bus was busy, and let the interrupt
* handler triggered on the SEL for reselect take care of lost arbitrations
* where necessary, meaning interrupts need to be enabled.
*
* When interrupts are enabled, the queues may change - so we
* can't remove it from the disconnected queue before selecting it
* because that could cause a failure in hashing the nexus if that
* device reselected.
*
* Since the queues may change, we can't use the pointers from when we
* first locate it.
*
* So, we must first locate the command, and if NCR5380_select()
* succeeds, then issue the abort, relocate the command and remove
* it from the disconnected queue.
*/
for (tmp = (struct scsi_cmnd *) hostdata->disconnected_queue; tmp;
tmp = NEXT(tmp)) {
if (cmd == tmp) {
dprintk(NDEBUG_ABORT, "scsi%d: aborting disconnected command.\n", HOSTNO);
if (NCR5380_select(instance, cmd)) {
spin_unlock_irq(&hostdata->lock);
return FAILED;
}
dprintk(NDEBUG_ABORT, "scsi%d: nexus reestablished.\n", HOSTNO);
do_abort(instance);
for (prev = (struct scsi_cmnd **)&(hostdata->disconnected_queue),
tmp = (struct scsi_cmnd *)hostdata->disconnected_queue;
tmp; prev = NEXTADDR(tmp), tmp = NEXT(tmp)) {
if (cmd == tmp) {
*prev = NEXT(tmp);
SET_NEXT(tmp, NULL);
tmp->result = DID_ABORT << 16;
/* We must unlock the tag/LUN immediately here, since the
* target goes to BUS FREE and doesn't send us another
* message (COMMAND_COMPLETE or the like)
*/
#ifdef SUPPORT_TAGS
cmd_free_tag(tmp);
#else
hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun);
#endif
maybe_release_dma_irq(instance);
spin_unlock_irqrestore(&hostdata->lock, flags);
tmp->scsi_done(tmp);
return SUCCESS;
}
}
}
}
/* Maybe it is sufficient just to release the ST-DMA lock... (if
* possible at all) At least, we should check if the lock could be
* released after the abort, in case it is kept due to some bug.
*/
maybe_release_dma_irq(instance);
spin_unlock_irqrestore(&hostdata->lock, flags); spin_unlock_irqrestore(&hostdata->lock, flags);
/*
* Case 5 : 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.
*/
printk(KERN_INFO "scsi%d: warning : SCSI command probably completed successfully before abortion\n", HOSTNO);
return FAILED; return FAILED;
} }
@ -2710,16 +2513,18 @@ static int NCR5380_bus_reset(struct scsi_cmnd *cmd)
* commands! * commands!
*/ */
if (hostdata->issue_queue)
dsprintk(NDEBUG_ABORT, instance, "reset aborted issued command(s)\n");
if (hostdata->connected) if (hostdata->connected)
dsprintk(NDEBUG_ABORT, instance, "reset aborted a connected command\n"); dsprintk(NDEBUG_ABORT, instance, "reset aborted a connected command\n");
if (hostdata->disconnected_queue)
dsprintk(NDEBUG_ABORT, instance, "reset aborted disconnected command(s)\n");
hostdata->issue_queue = NULL;
hostdata->connected = NULL; hostdata->connected = NULL;
hostdata->disconnected_queue = NULL;
if (!list_empty(&hostdata->unissued))
dsprintk(NDEBUG_ABORT, instance, "reset aborted unissued list\n");
INIT_LIST_HEAD(&hostdata->unissued);
if (!list_empty(&hostdata->disconnected))
dsprintk(NDEBUG_ABORT, instance, "reset aborted disconnected list\n");
INIT_LIST_HEAD(&hostdata->disconnected);
#ifdef SUPPORT_TAGS #ifdef SUPPORT_TAGS
free_all_tags(hostdata); free_all_tags(hostdata);
#endif #endif

1
drivers/scsi/atari_scsi.c
View File

@ -780,6 +780,7 @@ static struct scsi_host_template atari_scsi_template = {
.eh_bus_reset_handler = atari_scsi_bus_reset, .eh_bus_reset_handler = atari_scsi_bus_reset,
.this_id = 7, .this_id = 7,
.use_clustering = DISABLE_CLUSTERING, .use_clustering = DISABLE_CLUSTERING,
.cmd_size = NCR5380_CMD_SIZE,
}; };
static int __init atari_scsi_probe(struct platform_device *pdev) static int __init atari_scsi_probe(struct platform_device *pdev)

1
drivers/scsi/dmx3191d.c
View File

@ -61,6 +61,7 @@ static struct scsi_host_template dmx3191d_driver_template = {
.sg_tablesize = SG_ALL, .sg_tablesize = SG_ALL,
.cmd_per_lun = 2, .cmd_per_lun = 2,
.use_clustering = DISABLE_CLUSTERING, .use_clustering = DISABLE_CLUSTERING,
.cmd_size = NCR5380_CMD_SIZE,
}; };
static int dmx3191d_probe_one(struct pci_dev *pdev, static int dmx3191d_probe_one(struct pci_dev *pdev,

1
drivers/scsi/dtc.c
View File

@ -452,5 +452,6 @@ static struct scsi_host_template driver_template = {
.sg_tablesize = SG_ALL, .sg_tablesize = SG_ALL,
.cmd_per_lun = 2, .cmd_per_lun = 2,
.use_clustering = DISABLE_CLUSTERING, .use_clustering = DISABLE_CLUSTERING,
.cmd_size = NCR5380_CMD_SIZE,
}; };
#include "scsi_module.c" #include "scsi_module.c"

1
drivers/scsi/g_NCR5380.c
View File

@ -728,6 +728,7 @@ static struct scsi_host_template driver_template = {
.sg_tablesize = SG_ALL, .sg_tablesize = SG_ALL,
.cmd_per_lun = 2, .cmd_per_lun = 2,
.use_clustering = DISABLE_CLUSTERING, .use_clustering = DISABLE_CLUSTERING,
.cmd_size = NCR5380_CMD_SIZE,
}; };
#include "scsi_module.c" #include "scsi_module.c"

1
drivers/scsi/mac_scsi.c
View File

@ -323,6 +323,7 @@ static struct scsi_host_template mac_scsi_template = {
.sg_tablesize = SG_ALL, .sg_tablesize = SG_ALL,
.cmd_per_lun = 2, .cmd_per_lun = 2,
.use_clustering = DISABLE_CLUSTERING, .use_clustering = DISABLE_CLUSTERING,
.cmd_size = NCR5380_CMD_SIZE,
}; };
static int __init mac_scsi_probe(struct platform_device *pdev) static int __init mac_scsi_probe(struct platform_device *pdev)

1
drivers/scsi/pas16.c
View File

@ -562,6 +562,7 @@ static struct scsi_host_template driver_template = {
.sg_tablesize = SG_ALL, .sg_tablesize = SG_ALL,
.cmd_per_lun = 2, .cmd_per_lun = 2,
.use_clustering = DISABLE_CLUSTERING, .use_clustering = DISABLE_CLUSTERING,
.cmd_size = NCR5380_CMD_SIZE,
}; };
#include "scsi_module.c" #include "scsi_module.c"

1
drivers/scsi/sun3_scsi.c
View File

@ -468,6 +468,7 @@ static struct scsi_host_template sun3_scsi_template = {
.sg_tablesize = SG_NONE, .sg_tablesize = SG_NONE,
.cmd_per_lun = 2, .cmd_per_lun = 2,
.use_clustering = DISABLE_CLUSTERING, .use_clustering = DISABLE_CLUSTERING,
.cmd_size = NCR5380_CMD_SIZE,
}; };
static int __init sun3_scsi_probe(struct platform_device *pdev) static int __init sun3_scsi_probe(struct platform_device *pdev)

1
drivers/scsi/t128.c
View File

@ -406,5 +406,6 @@ static struct scsi_host_template driver_template = {
.sg_tablesize = SG_ALL, .sg_tablesize = SG_ALL,
.cmd_per_lun = 2, .cmd_per_lun = 2,
.use_clustering = DISABLE_CLUSTERING, .use_clustering = DISABLE_CLUSTERING,
.cmd_size = NCR5380_CMD_SIZE,
}; };
#include "scsi_module.c" #include "scsi_module.c"