2007-05-01 14:32:36 -06:00
|
|
|
/*
|
2005-04-16 16:20:36 -06:00
|
|
|
* NCR 5380 generic driver routines. These should make it *trivial*
|
2007-05-01 14:32:36 -06:00
|
|
|
* to implement 5380 SCSI drivers under Linux with a non-trantor
|
2005-04-16 16:20:36 -06:00
|
|
|
* architecture.
|
|
|
|
*
|
|
|
|
* Note that these routines also work with NR53c400 family chips.
|
|
|
|
*
|
|
|
|
* Copyright 1993, Drew Eckhardt
|
2007-05-01 14:32:36 -06:00
|
|
|
* Visionary Computing
|
2005-04-16 16:20:36 -06:00
|
|
|
* (Unix and Linux consulting and custom programming)
|
2007-05-01 14:32:36 -06:00
|
|
|
* drew@colorado.edu
|
2005-04-16 16:20:36 -06:00
|
|
|
* +1 (303) 666-5836
|
|
|
|
*
|
2007-05-01 14:32:36 -06:00
|
|
|
* For more information, please consult
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* NCR 5380 Family
|
|
|
|
* SCSI Protocol Controller
|
|
|
|
* Databook
|
|
|
|
*
|
|
|
|
* NCR Microelectronics
|
|
|
|
* 1635 Aeroplaza Drive
|
|
|
|
* Colorado Springs, CO 80916
|
|
|
|
* 1+ (719) 578-3400
|
|
|
|
* 1+ (800) 334-5454
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* ++roman: To port the 5380 driver to the Atari, I had to do some changes in
|
|
|
|
* this file, too:
|
|
|
|
*
|
|
|
|
* - Some of the debug statements were incorrect (undefined variables and the
|
|
|
|
* like). I fixed that.
|
|
|
|
*
|
|
|
|
* - In information_transfer(), I think a #ifdef was wrong. Looking at the
|
|
|
|
* possible DMA transfer size should also happen for REAL_DMA. I added this
|
|
|
|
* in the #if statement.
|
|
|
|
*
|
|
|
|
* - When using real DMA, information_transfer() should return in a DATAOUT
|
|
|
|
* phase after starting the DMA. It has nothing more to do.
|
|
|
|
*
|
|
|
|
* - The interrupt service routine should run main after end of DMA, too (not
|
|
|
|
* only after RESELECTION interrupts). Additionally, it should _not_ test
|
|
|
|
* for more interrupts after running main, since a DMA process may have
|
|
|
|
* been started and interrupts are turned on now. The new int could happen
|
|
|
|
* inside the execution of NCR5380_intr(), leading to recursive
|
|
|
|
* calls.
|
|
|
|
*
|
|
|
|
* - I've added a function merge_contiguous_buffers() that tries to
|
|
|
|
* merge scatter-gather buffers that are located at contiguous
|
|
|
|
* physical addresses and can be processed with the same DMA setup.
|
|
|
|
* Since most scatter-gather operations work on a page (4K) of
|
|
|
|
* 4 buffers (1K), in more than 90% of all cases three interrupts and
|
|
|
|
* DMA setup actions are saved.
|
|
|
|
*
|
|
|
|
* - I've deleted all the stuff for AUTOPROBE_IRQ, REAL_DMA_POLL, PSEUDO_DMA
|
|
|
|
* and USLEEP, because these were messing up readability and will never be
|
|
|
|
* needed for Atari SCSI.
|
2007-05-01 14:32:36 -06:00
|
|
|
*
|
2005-04-16 16:20:36 -06:00
|
|
|
* - I've revised the NCR5380_main() calling scheme (relax the 'main_running'
|
|
|
|
* stuff), and 'main' is executed in a bottom half if awoken by an
|
|
|
|
* interrupt.
|
|
|
|
*
|
|
|
|
* - The code was quite cluttered up by "#if (NDEBUG & NDEBUG_*) printk..."
|
|
|
|
* constructs. In my eyes, this made the source rather unreadable, so I
|
|
|
|
* finally replaced that by the *_PRINTK() macros.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
2007-05-01 14:32:36 -06:00
|
|
|
* Further development / testing that should be done :
|
|
|
|
* 1. Test linked command handling code after Eric is ready with
|
2005-04-16 16:20:36 -06:00
|
|
|
* the high level code.
|
|
|
|
*/
|
2014-11-11 22:12:16 -07:00
|
|
|
|
|
|
|
/* Adapted for the sun3 by Sam Creasey. */
|
|
|
|
|
2005-04-03 13:53:59 -06:00
|
|
|
#include <scsi/scsi_dbg.h>
|
2005-12-15 14:22:01 -07:00
|
|
|
#include <scsi/scsi_transport_spi.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
#if (NDEBUG & NDEBUG_LISTS)
|
2007-05-01 14:32:36 -06:00
|
|
|
#define LIST(x, y) \
|
|
|
|
do { \
|
|
|
|
printk("LINE:%d Adding %p to %p\n", \
|
|
|
|
__LINE__, (void*)(x), (void*)(y)); \
|
|
|
|
if ((x) == (y)) \
|
|
|
|
udelay(5); \
|
|
|
|
} while (0)
|
|
|
|
#define REMOVE(w, x, y, z) \
|
|
|
|
do { \
|
|
|
|
printk("LINE:%d Removing: %p->%p %p->%p \n", \
|
|
|
|
__LINE__, (void*)(w), (void*)(x), \
|
|
|
|
(void*)(y), (void*)(z)); \
|
|
|
|
if ((x) == (y)) \
|
|
|
|
udelay(5); \
|
|
|
|
} while (0)
|
2005-04-16 16:20:36 -06:00
|
|
|
#else
|
|
|
|
#define LIST(x,y)
|
|
|
|
#define REMOVE(w,x,y,z)
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifndef notyet
|
|
|
|
#undef LINKED
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Design
|
|
|
|
*
|
2007-05-01 14:32:36 -06:00
|
|
|
* This is a generic 5380 driver. To use it on a different platform,
|
2005-04-16 16:20:36 -06:00
|
|
|
* one simply writes appropriate system specific macros (ie, data
|
2007-05-01 14:32:36 -06:00
|
|
|
* transfer - some PC's will use the I/O bus, 68K's must use
|
2005-04-16 16:20:36 -06:00
|
|
|
* memory mapped) and drops this file in their 'C' wrapper.
|
|
|
|
*
|
2007-05-01 14:32:36 -06:00
|
|
|
* As far as command queueing, two queues are maintained for
|
2005-04-16 16:20:36 -06:00
|
|
|
* each 5380 in the system - commands that haven't been issued yet,
|
2007-05-01 14:32:36 -06:00
|
|
|
* and commands that are currently executing. This means that an
|
|
|
|
* unlimited number of commands may be queued, letting
|
|
|
|
* more commands propagate from the higher driver levels giving higher
|
|
|
|
* throughput. Note that both I_T_L and I_T_L_Q nexuses are supported,
|
|
|
|
* allowing multiple commands to propagate all the way to a SCSI-II device
|
2005-04-16 16:20:36 -06:00
|
|
|
* while a command is already executing.
|
|
|
|
*
|
|
|
|
*
|
2007-05-01 14:32:36 -06:00
|
|
|
* Issues specific to the NCR5380 :
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2007-05-01 14:32:36 -06:00
|
|
|
* When used in a PIO or pseudo-dma mode, the NCR5380 is a braindead
|
|
|
|
* piece of hardware that requires you to sit in a loop polling for
|
|
|
|
* the REQ signal as long as you are connected. Some devices are
|
|
|
|
* brain dead (ie, many TEXEL CD ROM drives) and won't disconnect
|
2005-04-16 16:20:36 -06:00
|
|
|
* while doing long seek operations.
|
2007-05-01 14:32:36 -06:00
|
|
|
*
|
2005-04-16 16:20:36 -06:00
|
|
|
* The workaround for this is to keep track of devices that have
|
|
|
|
* disconnected. If the device hasn't disconnected, for commands that
|
2007-05-01 14:32:36 -06:00
|
|
|
* should disconnect, we do something like
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* while (!REQ is asserted) { sleep for N usecs; poll for M usecs }
|
2007-05-01 14:32:36 -06:00
|
|
|
*
|
|
|
|
* Some tweaking of N and M needs to be done. An algorithm based
|
2005-04-16 16:20:36 -06:00
|
|
|
* on "time to data" would give the best results as long as short time
|
2007-05-01 14:32:36 -06:00
|
|
|
* to datas (ie, on the same track) were considered, however these
|
2005-04-16 16:20:36 -06:00
|
|
|
* broken devices are the exception rather than the rule and I'd rather
|
|
|
|
* spend my time optimizing for the normal case.
|
|
|
|
*
|
|
|
|
* Architecture :
|
|
|
|
*
|
|
|
|
* At the heart of the design is a coroutine, NCR5380_main,
|
2014-11-11 22:12:18 -07:00
|
|
|
* which is started from a workqueue for each NCR5380 host in the
|
|
|
|
* system. It attempts to establish I_T_L or I_T_L_Q nexuses by
|
|
|
|
* removing the commands from the issue queue and calling
|
|
|
|
* NCR5380_select() if a nexus is not established.
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* Once a nexus is established, the NCR5380_information_transfer()
|
|
|
|
* phase goes through the various phases as instructed by the target.
|
|
|
|
* if the target goes into MSG IN and sends a DISCONNECT message,
|
|
|
|
* the command structure is placed into the per instance disconnected
|
2014-11-11 22:12:18 -07:00
|
|
|
* queue, and NCR5380_main tries to find more work. If the target is
|
|
|
|
* idle for too long, the system will try to sleep.
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* If a command has disconnected, eventually an interrupt will trigger,
|
|
|
|
* calling NCR5380_intr() which will in turn call NCR5380_reselect
|
|
|
|
* to reestablish a nexus. This will run main if necessary.
|
|
|
|
*
|
2007-05-01 14:32:36 -06:00
|
|
|
* On command termination, the done function will be called as
|
2005-04-16 16:20:36 -06:00
|
|
|
* appropriate.
|
|
|
|
*
|
2007-05-01 14:32:36 -06:00
|
|
|
* SCSI pointers are maintained in the SCp field of SCSI command
|
2005-04-16 16:20:36 -06:00
|
|
|
* structures, being initialized after the command is connected
|
|
|
|
* in NCR5380_select, and set as appropriate in NCR5380_information_transfer.
|
|
|
|
* Note that in violation of the standard, an implicit SAVE POINTERS operation
|
|
|
|
* is done, since some BROKEN disks fail to issue an explicit SAVE POINTERS.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Using this file :
|
|
|
|
* This file a skeleton Linux SCSI driver for the NCR 5380 series
|
2007-05-01 14:32:36 -06:00
|
|
|
* of chips. To use it, you write an architecture specific functions
|
2005-04-16 16:20:36 -06:00
|
|
|
* and macros and include this file in your driver.
|
|
|
|
*
|
2007-05-01 14:32:36 -06:00
|
|
|
* These macros control options :
|
2005-04-16 16:20:36 -06:00
|
|
|
* AUTOSENSE - if defined, REQUEST SENSE will be performed automatically
|
2007-05-01 14:32:36 -06:00
|
|
|
* for commands that return with a CHECK CONDITION status.
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2014-11-11 22:12:18 -07:00
|
|
|
* DIFFERENTIAL - if defined, NCR53c81 chips will use external differential
|
|
|
|
* transceivers.
|
|
|
|
*
|
2005-04-16 16:20:36 -06:00
|
|
|
* LINKED - if defined, linked commands are supported.
|
|
|
|
*
|
|
|
|
* REAL_DMA - if defined, REAL DMA is used during the data transfer phases.
|
|
|
|
*
|
|
|
|
* SUPPORT_TAGS - if defined, SCSI-2 tagged queuing is used where possible
|
|
|
|
*
|
|
|
|
* These macros MUST be defined :
|
2007-05-01 14:32:36 -06:00
|
|
|
*
|
2005-04-16 16:20:36 -06:00
|
|
|
* NCR5380_read(register) - read from the specified register
|
|
|
|
*
|
2007-05-01 14:32:36 -06:00
|
|
|
* NCR5380_write(register, value) - write to the specific register
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2014-11-11 22:12:18 -07:00
|
|
|
* NCR5380_implementation_fields - additional fields needed for this
|
|
|
|
* specific implementation of the NCR5380
|
|
|
|
*
|
2005-04-16 16:20:36 -06:00
|
|
|
* Either real DMA *or* pseudo DMA may be implemented
|
2007-05-01 14:32:36 -06:00
|
|
|
* REAL functions :
|
2005-04-16 16:20:36 -06:00
|
|
|
* NCR5380_REAL_DMA should be defined if real DMA is to be used.
|
2007-05-01 14:32:36 -06:00
|
|
|
* Note that the DMA setup functions should return the number of bytes
|
2005-04-16 16:20:36 -06:00
|
|
|
* that they were able to program the controller for.
|
|
|
|
*
|
2007-05-01 14:32:36 -06:00
|
|
|
* Also note that generic i386/PC versions of these macros are
|
2005-04-16 16:20:36 -06:00
|
|
|
* available as NCR5380_i386_dma_write_setup,
|
|
|
|
* NCR5380_i386_dma_read_setup, and NCR5380_i386_dma_residual.
|
|
|
|
*
|
|
|
|
* NCR5380_dma_write_setup(instance, src, count) - initialize
|
|
|
|
* NCR5380_dma_read_setup(instance, dst, count) - initialize
|
|
|
|
* NCR5380_dma_residual(instance); - residual count
|
|
|
|
*
|
|
|
|
* PSEUDO functions :
|
|
|
|
* NCR5380_pwrite(instance, src, count)
|
|
|
|
* NCR5380_pread(instance, dst, count);
|
|
|
|
*
|
|
|
|
* The generic driver is initialized by calling NCR5380_init(instance),
|
2007-05-01 14:32:36 -06:00
|
|
|
* after setting the appropriate host specific fields and ID. If the
|
2005-04-16 16:20:36 -06:00
|
|
|
* driver wishes to autoprobe for an IRQ line, the NCR5380_probe_irq(instance,
|
2014-11-11 22:11:58 -07:00
|
|
|
* possible) function may be used.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
|
|
|
|
/* Macros ease life... :-) */
|
|
|
|
#define SETUP_HOSTDATA(in) \
|
|
|
|
struct NCR5380_hostdata *hostdata = \
|
|
|
|
(struct NCR5380_hostdata *)(in)->hostdata
|
|
|
|
#define HOSTDATA(in) ((struct NCR5380_hostdata *)(in)->hostdata)
|
|
|
|
|
2014-11-11 22:12:02 -07:00
|
|
|
#define NEXT(cmd) ((struct scsi_cmnd *)(cmd)->host_scribble)
|
2007-05-01 14:32:37 -06:00
|
|
|
#define SET_NEXT(cmd,next) ((cmd)->host_scribble = (void *)(next))
|
2014-11-11 22:12:02 -07:00
|
|
|
#define NEXTADDR(cmd) ((struct scsi_cmnd **)&(cmd)->host_scribble)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
#define HOSTNO instance->host_no
|
|
|
|
#define H_NO(cmd) (cmd)->device->host->host_no
|
|
|
|
|
|
|
|
#ifdef SUPPORT_TAGS
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Functions for handling tagged queuing
|
|
|
|
* =====================================
|
|
|
|
*
|
|
|
|
* ++roman (01/96): Now I've implemented SCSI-2 tagged queuing. Some notes:
|
|
|
|
*
|
|
|
|
* Using consecutive numbers for the tags is no good idea in my eyes. There
|
|
|
|
* could be wrong re-usings if the counter (8 bit!) wraps and some early
|
|
|
|
* command has been preempted for a long time. My solution: a bitfield for
|
|
|
|
* remembering used tags.
|
|
|
|
*
|
|
|
|
* There's also the problem that each target has a certain queue size, but we
|
|
|
|
* cannot know it in advance :-( We just see a QUEUE_FULL status being
|
|
|
|
* returned. So, in this case, the driver internal queue size assumption is
|
|
|
|
* reduced to the number of active tags if QUEUE_FULL is returned by the
|
|
|
|
* target. The command is returned to the mid-level, but with status changed
|
|
|
|
* to BUSY, since --as I've seen-- the mid-level can't handle QUEUE_FULL
|
|
|
|
* correctly.
|
|
|
|
*
|
|
|
|
* We're also not allowed running tagged commands as long as an untagged
|
|
|
|
* command is active. And REQUEST SENSE commands after a contingent allegiance
|
|
|
|
* condition _must_ be untagged. To keep track whether an untagged command has
|
|
|
|
* been issued, the host->busy array is still employed, as it is without
|
|
|
|
* support for tagged queuing.
|
|
|
|
*
|
|
|
|
* One could suspect that there are possible race conditions between
|
|
|
|
* is_lun_busy(), cmd_get_tag() and cmd_free_tag(). But I think this isn't the
|
|
|
|
* case: is_lun_busy() and cmd_get_tag() are both called from NCR5380_main(),
|
|
|
|
* which already guaranteed to be running at most once. It is also the only
|
|
|
|
* place where tags/LUNs are allocated. So no other allocation can slip
|
|
|
|
* between that pair, there could only happen a reselection, which can free a
|
|
|
|
* tag, but that doesn't hurt. Only the sequence in cmd_free_tag() becomes
|
|
|
|
* important: the tag bit must be cleared before 'nr_allocated' is decreased.
|
|
|
|
*/
|
|
|
|
|
2014-11-11 22:12:19 -07:00
|
|
|
static void __init init_tags(struct NCR5380_hostdata *hostdata)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-05-01 14:32:36 -06:00
|
|
|
int target, lun;
|
2014-11-11 22:12:20 -07:00
|
|
|
struct tag_alloc *ta;
|
2007-05-01 14:32:36 -06:00
|
|
|
|
2014-11-11 22:12:19 -07:00
|
|
|
if (!(hostdata->flags & FLAG_TAGGED_QUEUING))
|
2007-05-01 14:32:36 -06:00
|
|
|
return;
|
|
|
|
|
|
|
|
for (target = 0; target < 8; ++target) {
|
|
|
|
for (lun = 0; lun < 8; ++lun) {
|
2014-11-11 22:12:20 -07:00
|
|
|
ta = &hostdata->TagAlloc[target][lun];
|
2007-05-01 14:32:36 -06:00
|
|
|
bitmap_zero(ta->allocated, MAX_TAGS);
|
|
|
|
ta->nr_allocated = 0;
|
|
|
|
/* At the beginning, assume the maximum queue size we could
|
|
|
|
* support (MAX_TAGS). This value will be decreased if the target
|
|
|
|
* returns QUEUE_FULL status.
|
|
|
|
*/
|
|
|
|
ta->queue_size = MAX_TAGS;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* Check if we can issue a command to this LUN: First see if the LUN is marked
|
|
|
|
* busy by an untagged command. If the command should use tagged queuing, also
|
|
|
|
* check that there is a free tag and the target's queue won't overflow. This
|
|
|
|
* function should be called with interrupts disabled to avoid race
|
|
|
|
* conditions.
|
2007-05-01 14:32:36 -06:00
|
|
|
*/
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2014-11-11 22:12:02 -07:00
|
|
|
static int is_lun_busy(struct scsi_cmnd *cmd, int should_be_tagged)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2014-06-25 07:27:36 -06:00
|
|
|
u8 lun = cmd->device->lun;
|
2007-05-01 14:32:36 -06:00
|
|
|
SETUP_HOSTDATA(cmd->device->host);
|
|
|
|
|
2014-06-25 07:27:36 -06:00
|
|
|
if (hostdata->busy[cmd->device->id] & (1 << lun))
|
2007-05-01 14:32:36 -06:00
|
|
|
return 1;
|
|
|
|
if (!should_be_tagged ||
|
2014-11-11 22:12:19 -07:00
|
|
|
!(hostdata->flags & FLAG_TAGGED_QUEUING) ||
|
|
|
|
!cmd->device->tagged_supported)
|
2007-05-01 14:32:36 -06:00
|
|
|
return 0;
|
2014-11-11 22:12:20 -07:00
|
|
|
if (hostdata->TagAlloc[scmd_id(cmd)][lun].nr_allocated >=
|
|
|
|
hostdata->TagAlloc[scmd_id(cmd)][lun].queue_size) {
|
2014-03-17 18:42:20 -06:00
|
|
|
dprintk(NDEBUG_TAGS, "scsi%d: target %d lun %d: no free tags\n",
|
2014-06-25 07:27:36 -06:00
|
|
|
H_NO(cmd), cmd->device->id, lun);
|
2007-05-01 14:32:36 -06:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* Allocate a tag for a command (there are no checks anymore, check_lun_busy()
|
|
|
|
* must be called before!), or reserve the LUN in 'busy' if the command is
|
|
|
|
* untagged.
|
|
|
|
*/
|
|
|
|
|
2014-11-11 22:12:02 -07:00
|
|
|
static void cmd_get_tag(struct scsi_cmnd *cmd, int should_be_tagged)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2014-06-25 07:27:36 -06:00
|
|
|
u8 lun = cmd->device->lun;
|
2007-05-01 14:32:36 -06:00
|
|
|
SETUP_HOSTDATA(cmd->device->host);
|
|
|
|
|
|
|
|
/* If we or the target don't support tagged queuing, allocate the LUN for
|
|
|
|
* an untagged command.
|
|
|
|
*/
|
|
|
|
if (!should_be_tagged ||
|
2014-11-11 22:12:19 -07:00
|
|
|
!(hostdata->flags & FLAG_TAGGED_QUEUING) ||
|
|
|
|
!cmd->device->tagged_supported) {
|
2007-05-01 14:32:36 -06:00
|
|
|
cmd->tag = TAG_NONE;
|
2014-06-25 07:27:36 -06:00
|
|
|
hostdata->busy[cmd->device->id] |= (1 << lun);
|
2014-03-17 18:42:20 -06:00
|
|
|
dprintk(NDEBUG_TAGS, "scsi%d: target %d lun %d now allocated by untagged "
|
2014-06-25 07:27:36 -06:00
|
|
|
"command\n", H_NO(cmd), cmd->device->id, lun);
|
2007-05-01 14:32:36 -06:00
|
|
|
} else {
|
2014-11-11 22:12:20 -07:00
|
|
|
struct tag_alloc *ta = &hostdata->TagAlloc[scmd_id(cmd)][lun];
|
2007-05-01 14:32:36 -06:00
|
|
|
|
|
|
|
cmd->tag = find_first_zero_bit(ta->allocated, MAX_TAGS);
|
|
|
|
set_bit(cmd->tag, ta->allocated);
|
|
|
|
ta->nr_allocated++;
|
2014-03-17 18:42:20 -06:00
|
|
|
dprintk(NDEBUG_TAGS, "scsi%d: using tag %d for target %d lun %d "
|
2007-05-01 14:32:36 -06:00
|
|
|
"(now %d tags in use)\n",
|
|
|
|
H_NO(cmd), cmd->tag, cmd->device->id,
|
2014-06-25 07:27:36 -06:00
|
|
|
lun, ta->nr_allocated);
|
2007-05-01 14:32:36 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* Mark the tag of command 'cmd' as free, or in case of an untagged command,
|
|
|
|
* unlock the LUN.
|
|
|
|
*/
|
|
|
|
|
2014-11-11 22:12:02 -07:00
|
|
|
static void cmd_free_tag(struct scsi_cmnd *cmd)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2014-06-25 07:27:36 -06:00
|
|
|
u8 lun = cmd->device->lun;
|
2007-05-01 14:32:36 -06:00
|
|
|
SETUP_HOSTDATA(cmd->device->host);
|
|
|
|
|
|
|
|
if (cmd->tag == TAG_NONE) {
|
2014-06-25 07:27:36 -06:00
|
|
|
hostdata->busy[cmd->device->id] &= ~(1 << lun);
|
2014-03-17 18:42:20 -06:00
|
|
|
dprintk(NDEBUG_TAGS, "scsi%d: target %d lun %d untagged cmd finished\n",
|
2014-06-25 07:27:36 -06:00
|
|
|
H_NO(cmd), cmd->device->id, lun);
|
2007-05-01 14:32:36 -06:00
|
|
|
} else if (cmd->tag >= MAX_TAGS) {
|
|
|
|
printk(KERN_NOTICE "scsi%d: trying to free bad tag %d!\n",
|
|
|
|
H_NO(cmd), cmd->tag);
|
|
|
|
} else {
|
2014-11-11 22:12:20 -07:00
|
|
|
struct tag_alloc *ta = &hostdata->TagAlloc[scmd_id(cmd)][lun];
|
2007-05-01 14:32:36 -06:00
|
|
|
clear_bit(cmd->tag, ta->allocated);
|
|
|
|
ta->nr_allocated--;
|
2014-03-17 18:42:20 -06:00
|
|
|
dprintk(NDEBUG_TAGS, "scsi%d: freed tag %d for target %d lun %d\n",
|
2014-06-25 07:27:36 -06:00
|
|
|
H_NO(cmd), cmd->tag, cmd->device->id, lun);
|
2007-05-01 14:32:36 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2014-11-11 22:12:19 -07:00
|
|
|
static void free_all_tags(struct NCR5380_hostdata *hostdata)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-05-01 14:32:36 -06:00
|
|
|
int target, lun;
|
2014-11-11 22:12:20 -07:00
|
|
|
struct tag_alloc *ta;
|
2007-05-01 14:32:36 -06:00
|
|
|
|
2014-11-11 22:12:19 -07:00
|
|
|
if (!(hostdata->flags & FLAG_TAGGED_QUEUING))
|
2007-05-01 14:32:36 -06:00
|
|
|
return;
|
|
|
|
|
|
|
|
for (target = 0; target < 8; ++target) {
|
|
|
|
for (lun = 0; lun < 8; ++lun) {
|
2014-11-11 22:12:20 -07:00
|
|
|
ta = &hostdata->TagAlloc[target][lun];
|
2007-05-01 14:32:36 -06:00
|
|
|
bitmap_zero(ta->allocated, MAX_TAGS);
|
|
|
|
ta->nr_allocated = 0;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif /* SUPPORT_TAGS */
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
2014-11-11 22:12:02 -07:00
|
|
|
* Function: void merge_contiguous_buffers( struct scsi_cmnd *cmd )
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* Purpose: Try to merge several scatter-gather requests into one DMA
|
|
|
|
* transfer. This is possible if the scatter buffers lie on
|
|
|
|
* physical contiguous addresses.
|
|
|
|
*
|
2014-11-11 22:12:02 -07:00
|
|
|
* Parameters: struct scsi_cmnd *cmd
|
2005-04-16 16:20:36 -06:00
|
|
|
* The command to work on. The first scatter buffer's data are
|
2011-03-30 19:57:33 -06:00
|
|
|
* assumed to be already transferred into ptr/this_residual.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
|
2014-11-11 22:12:02 -07:00
|
|
|
static void merge_contiguous_buffers(struct scsi_cmnd *cmd)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2014-11-11 22:12:16 -07:00
|
|
|
#if !defined(CONFIG_SUN3)
|
2007-05-01 14:32:36 -06:00
|
|
|
unsigned long endaddr;
|
2005-04-16 16:20:36 -06:00
|
|
|
#if (NDEBUG & NDEBUG_MERGING)
|
2007-05-01 14:32:36 -06:00
|
|
|
unsigned long oldlen = cmd->SCp.this_residual;
|
|
|
|
int cnt = 1;
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
|
|
|
|
2007-05-01 14:32:36 -06:00
|
|
|
for (endaddr = virt_to_phys(cmd->SCp.ptr + cmd->SCp.this_residual - 1) + 1;
|
|
|
|
cmd->SCp.buffers_residual &&
|
2007-10-24 00:55:40 -06:00
|
|
|
virt_to_phys(sg_virt(&cmd->SCp.buffer[1])) == endaddr;) {
|
2014-03-17 18:42:20 -06:00
|
|
|
dprintk(NDEBUG_MERGING, "VTOP(%p) == %08lx -> merging\n",
|
2007-10-24 00:55:40 -06:00
|
|
|
page_address(sg_page(&cmd->SCp.buffer[1])), endaddr);
|
2005-04-16 16:20:36 -06:00
|
|
|
#if (NDEBUG & NDEBUG_MERGING)
|
2007-05-01 14:32:36 -06:00
|
|
|
++cnt;
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
2007-05-01 14:32:36 -06:00
|
|
|
++cmd->SCp.buffer;
|
|
|
|
--cmd->SCp.buffers_residual;
|
|
|
|
cmd->SCp.this_residual += cmd->SCp.buffer->length;
|
|
|
|
endaddr += cmd->SCp.buffer->length;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
#if (NDEBUG & NDEBUG_MERGING)
|
2007-05-01 14:32:36 -06:00
|
|
|
if (oldlen != cmd->SCp.this_residual)
|
2014-03-17 18:42:20 -06:00
|
|
|
dprintk(NDEBUG_MERGING, "merged %d buffers from %p, new length %08x\n",
|
2007-05-01 14:32:36 -06:00
|
|
|
cnt, cmd->SCp.ptr, cmd->SCp.this_residual);
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
2014-11-11 22:12:16 -07:00
|
|
|
#endif /* !defined(CONFIG_SUN3) */
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2014-11-11 22:12:18 -07:00
|
|
|
/**
|
|
|
|
* initialize_SCp - init the scsi pointer field
|
|
|
|
* @cmd: command block to set up
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2014-11-11 22:12:18 -07:00
|
|
|
* Set up the internal fields in the SCSI command.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
|
2014-11-11 22:12:02 -07:00
|
|
|
static inline void initialize_SCp(struct scsi_cmnd *cmd)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-05-01 14:32:36 -06:00
|
|
|
/*
|
|
|
|
* Initialize the Scsi Pointer field so that all of the commands in the
|
|
|
|
* various queues are valid.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2007-05-01 14:32:36 -06:00
|
|
|
|
2007-11-05 02:23:35 -07:00
|
|
|
if (scsi_bufflen(cmd)) {
|
|
|
|
cmd->SCp.buffer = scsi_sglist(cmd);
|
|
|
|
cmd->SCp.buffers_residual = scsi_sg_count(cmd) - 1;
|
2007-10-22 13:19:53 -06:00
|
|
|
cmd->SCp.ptr = sg_virt(cmd->SCp.buffer);
|
2007-05-01 14:32:36 -06:00
|
|
|
cmd->SCp.this_residual = cmd->SCp.buffer->length;
|
|
|
|
/* ++roman: Try to merge some scatter-buffers if they are at
|
|
|
|
* contiguous physical addresses.
|
|
|
|
*/
|
|
|
|
merge_contiguous_buffers(cmd);
|
|
|
|
} else {
|
|
|
|
cmd->SCp.buffer = NULL;
|
|
|
|
cmd->SCp.buffers_residual = 0;
|
2007-11-05 02:23:35 -07:00
|
|
|
cmd->SCp.ptr = NULL;
|
|
|
|
cmd->SCp.this_residual = 0;
|
2007-05-01 14:32:36 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
#include <linux/delay.h>
|
|
|
|
|
|
|
|
#if NDEBUG
|
|
|
|
static struct {
|
2007-05-01 14:32:36 -06:00
|
|
|
unsigned char mask;
|
|
|
|
const char *name;
|
|
|
|
} signals[] = {
|
|
|
|
{ SR_DBP, "PARITY"}, { SR_RST, "RST" }, { SR_BSY, "BSY" },
|
|
|
|
{ SR_REQ, "REQ" }, { SR_MSG, "MSG" }, { SR_CD, "CD" }, { SR_IO, "IO" },
|
|
|
|
{ SR_SEL, "SEL" }, {0, NULL}
|
|
|
|
}, basrs[] = {
|
|
|
|
{BASR_ATN, "ATN"}, {BASR_ACK, "ACK"}, {0, NULL}
|
|
|
|
}, icrs[] = {
|
|
|
|
{ICR_ASSERT_RST, "ASSERT RST"},{ICR_ASSERT_ACK, "ASSERT ACK"},
|
|
|
|
{ICR_ASSERT_BSY, "ASSERT BSY"}, {ICR_ASSERT_SEL, "ASSERT SEL"},
|
|
|
|
{ICR_ASSERT_ATN, "ASSERT ATN"}, {ICR_ASSERT_DATA, "ASSERT DATA"},
|
|
|
|
{0, NULL}
|
|
|
|
}, mrs[] = {
|
|
|
|
{MR_BLOCK_DMA_MODE, "MODE BLOCK DMA"}, {MR_TARGET, "MODE TARGET"},
|
|
|
|
{MR_ENABLE_PAR_CHECK, "MODE PARITY CHECK"}, {MR_ENABLE_PAR_INTR,
|
|
|
|
"MODE PARITY INTR"}, {MR_ENABLE_EOP_INTR,"MODE EOP INTR"},
|
|
|
|
{MR_MONITOR_BSY, "MODE MONITOR BSY"},
|
|
|
|
{MR_DMA_MODE, "MODE DMA"}, {MR_ARBITRATE, "MODE ARBITRATION"},
|
|
|
|
{0, NULL}
|
|
|
|
};
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2014-11-11 22:12:18 -07:00
|
|
|
/**
|
|
|
|
* NCR5380_print - print scsi bus signals
|
|
|
|
* @instance: adapter state to dump
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2014-11-11 22:12:18 -07:00
|
|
|
* Print the SCSI bus signals for debugging purposes
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
|
2007-05-01 14:32:36 -06:00
|
|
|
static void NCR5380_print(struct Scsi_Host *instance)
|
|
|
|
{
|
|
|
|
unsigned char status, data, basr, mr, icr, i;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
local_irq_save(flags);
|
|
|
|
data = NCR5380_read(CURRENT_SCSI_DATA_REG);
|
|
|
|
status = NCR5380_read(STATUS_REG);
|
|
|
|
mr = NCR5380_read(MODE_REG);
|
|
|
|
icr = NCR5380_read(INITIATOR_COMMAND_REG);
|
|
|
|
basr = NCR5380_read(BUS_AND_STATUS_REG);
|
|
|
|
local_irq_restore(flags);
|
|
|
|
printk("STATUS_REG: %02x ", status);
|
|
|
|
for (i = 0; signals[i].mask; ++i)
|
|
|
|
if (status & signals[i].mask)
|
|
|
|
printk(",%s", signals[i].name);
|
|
|
|
printk("\nBASR: %02x ", basr);
|
|
|
|
for (i = 0; basrs[i].mask; ++i)
|
|
|
|
if (basr & basrs[i].mask)
|
|
|
|
printk(",%s", basrs[i].name);
|
|
|
|
printk("\nICR: %02x ", icr);
|
|
|
|
for (i = 0; icrs[i].mask; ++i)
|
|
|
|
if (icr & icrs[i].mask)
|
|
|
|
printk(",%s", icrs[i].name);
|
|
|
|
printk("\nMODE: %02x ", mr);
|
|
|
|
for (i = 0; mrs[i].mask; ++i)
|
|
|
|
if (mr & mrs[i].mask)
|
|
|
|
printk(",%s", mrs[i].name);
|
|
|
|
printk("\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static struct {
|
2007-05-01 14:32:36 -06:00
|
|
|
unsigned char value;
|
|
|
|
const char *name;
|
2005-04-16 16:20:36 -06:00
|
|
|
} phases[] = {
|
2007-05-01 14:32:36 -06:00
|
|
|
{PHASE_DATAOUT, "DATAOUT"}, {PHASE_DATAIN, "DATAIN"}, {PHASE_CMDOUT, "CMDOUT"},
|
|
|
|
{PHASE_STATIN, "STATIN"}, {PHASE_MSGOUT, "MSGOUT"}, {PHASE_MSGIN, "MSGIN"},
|
|
|
|
{PHASE_UNKNOWN, "UNKNOWN"}
|
|
|
|
};
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2014-11-11 22:12:18 -07:00
|
|
|
/**
|
|
|
|
* NCR5380_print_phase - show SCSI phase
|
|
|
|
* @instance: adapter to dump
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2014-11-11 22:12:18 -07:00
|
|
|
* Print the current SCSI phase for debugging purposes
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2014-11-11 22:12:18 -07:00
|
|
|
* Locks: none
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
|
|
|
|
static void NCR5380_print_phase(struct Scsi_Host *instance)
|
|
|
|
{
|
2007-05-01 14:32:36 -06:00
|
|
|
unsigned char status;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
status = NCR5380_read(STATUS_REG);
|
|
|
|
if (!(status & SR_REQ))
|
|
|
|
printk(KERN_DEBUG "scsi%d: REQ not asserted, phase unknown.\n", HOSTNO);
|
|
|
|
else {
|
|
|
|
for (i = 0; (phases[i].value != PHASE_UNKNOWN) &&
|
|
|
|
(phases[i].value != (status & PHASE_MASK)); ++i)
|
|
|
|
;
|
|
|
|
printk(KERN_DEBUG "scsi%d: phase %s\n", HOSTNO, phases[i].name);
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/*
|
|
|
|
* ++roman: New scheme of calling NCR5380_main()
|
2007-05-01 14:32:36 -06:00
|
|
|
*
|
2005-04-16 16:20:36 -06:00
|
|
|
* If we're not in an interrupt, we can call our main directly, it cannot be
|
|
|
|
* already running. Else, we queue it on a task queue, if not 'main_running'
|
|
|
|
* tells us that a lower level is already executing it. This way,
|
|
|
|
* 'main_running' needs not be protected in a special way.
|
|
|
|
*
|
|
|
|
* queue_main() is a utility function for putting our main onto the task
|
|
|
|
* queue, if main_running is false. It should be called only from a
|
|
|
|
* interrupt or bottom half.
|
|
|
|
*/
|
|
|
|
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 02:04:11 -06:00
|
|
|
#include <linux/gfp.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/workqueue.h>
|
|
|
|
#include <linux/interrupt.h>
|
|
|
|
|
2014-11-11 22:12:21 -07:00
|
|
|
static inline void queue_main(struct NCR5380_hostdata *hostdata)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2014-11-11 22:12:21 -07:00
|
|
|
if (!hostdata->main_running) {
|
2007-05-01 14:32:36 -06:00
|
|
|
/* If in interrupt and NCR5380_main() not already running,
|
|
|
|
queue it on the 'immediate' task queue, to be processed
|
|
|
|
immediately after the current interrupt processing has
|
|
|
|
finished. */
|
2014-11-11 22:12:21 -07:00
|
|
|
schedule_work(&hostdata->main_task);
|
2007-05-01 14:32:36 -06:00
|
|
|
}
|
|
|
|
/* else: nothing to do: the running NCR5380_main() will pick up
|
|
|
|
any newly queued command. */
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2014-11-11 22:11:58 -07:00
|
|
|
/**
|
|
|
|
* NCR58380_info - report driver and host information
|
|
|
|
* @instance: relevant scsi host instance
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2014-11-11 22:11:58 -07:00
|
|
|
* For use as the host template info() handler.
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2014-11-11 22:11:58 -07:00
|
|
|
* Locks: none
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
|
2014-11-11 22:11:58 -07:00
|
|
|
static const char *NCR5380_info(struct Scsi_Host *instance)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2014-11-11 22:11:58 -07:00
|
|
|
struct NCR5380_hostdata *hostdata = shost_priv(instance);
|
|
|
|
|
|
|
|
return hostdata->info;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void prepare_info(struct Scsi_Host *instance)
|
|
|
|
{
|
|
|
|
struct NCR5380_hostdata *hostdata = shost_priv(instance);
|
|
|
|
|
|
|
|
snprintf(hostdata->info, sizeof(hostdata->info),
|
|
|
|
"%s, io_port 0x%lx, n_io_port %d, "
|
|
|
|
"base 0x%lx, irq %d, "
|
|
|
|
"can_queue %d, cmd_per_lun %d, "
|
|
|
|
"sg_tablesize %d, this_id %d, "
|
2014-11-11 22:12:19 -07:00
|
|
|
"flags { %s}, "
|
2014-11-11 22:11:58 -07:00
|
|
|
"options { %s} ",
|
|
|
|
instance->hostt->name, instance->io_port, instance->n_io_port,
|
|
|
|
instance->base, instance->irq,
|
|
|
|
instance->can_queue, instance->cmd_per_lun,
|
|
|
|
instance->sg_tablesize, instance->this_id,
|
2014-11-11 22:12:19 -07:00
|
|
|
hostdata->flags & FLAG_TAGGED_QUEUING ? "TAGGED_QUEUING " : "",
|
2014-11-11 22:11:58 -07:00
|
|
|
#ifdef DIFFERENTIAL
|
|
|
|
"DIFFERENTIAL "
|
|
|
|
#endif
|
2005-04-16 16:20:36 -06:00
|
|
|
#ifdef REAL_DMA
|
2014-11-11 22:11:58 -07:00
|
|
|
"REAL_DMA "
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
|
|
|
#ifdef PARITY
|
2014-11-11 22:11:58 -07:00
|
|
|
"PARITY "
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
|
|
|
#ifdef SUPPORT_TAGS
|
2014-11-11 22:11:58 -07:00
|
|
|
"SUPPORT_TAGS "
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
2014-11-11 22:11:58 -07:00
|
|
|
"");
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2014-11-11 22:12:18 -07:00
|
|
|
/**
|
|
|
|
* NCR5380_print_status - dump controller info
|
|
|
|
* @instance: controller to dump
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2014-11-11 22:12:18 -07:00
|
|
|
* Print commands in the various queues, called from NCR5380_abort
|
|
|
|
* to aid debugging.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
|
2014-11-11 22:12:02 -07:00
|
|
|
static void lprint_Scsi_Cmnd(struct scsi_cmnd *cmd)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2013-03-31 11:24:44 -06:00
|
|
|
int i, s;
|
|
|
|
unsigned char *command;
|
2014-06-25 07:27:36 -06:00
|
|
|
printk("scsi%d: destination target %d, lun %llu\n",
|
2013-03-31 11:24:44 -06:00
|
|
|
H_NO(cmd), cmd->device->id, cmd->device->lun);
|
|
|
|
printk(KERN_CONT " command = ");
|
|
|
|
command = cmd->cmnd;
|
|
|
|
printk(KERN_CONT "%2d (0x%02x)", command[0], command[0]);
|
|
|
|
for (i = 1, s = COMMAND_SIZE(command[0]); i < s; ++i)
|
|
|
|
printk(KERN_CONT " %02x", command[i]);
|
|
|
|
printk("\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2013-03-31 11:24:44 -06:00
|
|
|
static void NCR5380_print_status(struct Scsi_Host *instance)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-05-01 14:32:36 -06:00
|
|
|
struct NCR5380_hostdata *hostdata;
|
2014-11-11 22:12:02 -07:00
|
|
|
struct scsi_cmnd *ptr;
|
2007-05-01 14:32:36 -06:00
|
|
|
unsigned long flags;
|
2013-03-31 11:24:44 -06:00
|
|
|
|
2014-03-17 18:42:19 -06:00
|
|
|
NCR5380_dprint(NDEBUG_ANY, instance);
|
|
|
|
NCR5380_dprint_phase(NDEBUG_ANY, instance);
|
2007-05-01 14:32:36 -06:00
|
|
|
|
|
|
|
hostdata = (struct NCR5380_hostdata *)instance->hostdata;
|
|
|
|
|
|
|
|
local_irq_save(flags);
|
2013-03-31 11:24:44 -06:00
|
|
|
printk("NCR5380: coroutine is%s running.\n",
|
2014-11-11 22:12:21 -07:00
|
|
|
hostdata->main_running ? "" : "n't");
|
2007-05-01 14:32:36 -06:00
|
|
|
if (!hostdata->connected)
|
2013-03-31 11:24:44 -06:00
|
|
|
printk("scsi%d: no currently connected command\n", HOSTNO);
|
2007-05-01 14:32:36 -06:00
|
|
|
else
|
2014-11-11 22:12:02 -07:00
|
|
|
lprint_Scsi_Cmnd((struct scsi_cmnd *) hostdata->connected);
|
2013-03-31 11:24:44 -06:00
|
|
|
printk("scsi%d: issue_queue\n", HOSTNO);
|
2014-11-11 22:12:02 -07:00
|
|
|
for (ptr = (struct scsi_cmnd *)hostdata->issue_queue; ptr; ptr = NEXT(ptr))
|
2013-03-31 11:24:44 -06:00
|
|
|
lprint_Scsi_Cmnd(ptr);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2013-03-31 11:24:44 -06:00
|
|
|
printk("scsi%d: disconnected_queue\n", HOSTNO);
|
2014-11-11 22:12:02 -07:00
|
|
|
for (ptr = (struct scsi_cmnd *) hostdata->disconnected_queue; ptr;
|
2013-03-31 11:24:44 -06:00
|
|
|
ptr = NEXT(ptr))
|
|
|
|
lprint_Scsi_Cmnd(ptr);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-05-01 14:32:36 -06:00
|
|
|
local_irq_restore(flags);
|
2013-03-31 11:24:44 -06:00
|
|
|
printk("\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2014-11-11 22:12:02 -07:00
|
|
|
static void show_Scsi_Cmnd(struct scsi_cmnd *cmd, struct seq_file *m)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-05-01 14:32:36 -06:00
|
|
|
int i, s;
|
|
|
|
unsigned char *command;
|
2014-06-25 07:27:36 -06:00
|
|
|
seq_printf(m, "scsi%d: destination target %d, lun %llu\n",
|
2007-05-01 14:32:36 -06:00
|
|
|
H_NO(cmd), cmd->device->id, cmd->device->lun);
|
2014-12-02 16:10:52 -07:00
|
|
|
seq_puts(m, " command = ");
|
2007-05-01 14:32:36 -06:00
|
|
|
command = cmd->cmnd;
|
2013-03-31 11:24:44 -06:00
|
|
|
seq_printf(m, "%2d (0x%02x)", command[0], command[0]);
|
2007-05-01 14:32:36 -06:00
|
|
|
for (i = 1, s = COMMAND_SIZE(command[0]); i < s; ++i)
|
2013-03-31 11:24:44 -06:00
|
|
|
seq_printf(m, " %02x", command[i]);
|
2014-12-02 16:10:54 -07:00
|
|
|
seq_putc(m, '\n');
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2014-11-11 22:11:52 -07:00
|
|
|
static int __maybe_unused NCR5380_show_info(struct seq_file *m,
|
|
|
|
struct Scsi_Host *instance)
|
2013-03-31 11:24:44 -06:00
|
|
|
{
|
|
|
|
struct NCR5380_hostdata *hostdata;
|
2014-11-11 22:12:02 -07:00
|
|
|
struct scsi_cmnd *ptr;
|
2013-03-31 11:24:44 -06:00
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
hostdata = (struct NCR5380_hostdata *)instance->hostdata;
|
|
|
|
|
|
|
|
local_irq_save(flags);
|
|
|
|
seq_printf(m, "NCR5380: coroutine is%s running.\n",
|
2014-11-11 22:12:21 -07:00
|
|
|
hostdata->main_running ? "" : "n't");
|
2013-03-31 11:24:44 -06:00
|
|
|
if (!hostdata->connected)
|
|
|
|
seq_printf(m, "scsi%d: no currently connected command\n", HOSTNO);
|
|
|
|
else
|
2014-11-11 22:12:02 -07:00
|
|
|
show_Scsi_Cmnd((struct scsi_cmnd *) hostdata->connected, m);
|
2013-03-31 11:24:44 -06:00
|
|
|
seq_printf(m, "scsi%d: issue_queue\n", HOSTNO);
|
2014-11-11 22:12:02 -07:00
|
|
|
for (ptr = (struct scsi_cmnd *)hostdata->issue_queue; ptr; ptr = NEXT(ptr))
|
2013-03-31 11:24:44 -06:00
|
|
|
show_Scsi_Cmnd(ptr, m);
|
|
|
|
|
|
|
|
seq_printf(m, "scsi%d: disconnected_queue\n", HOSTNO);
|
2014-11-11 22:12:02 -07:00
|
|
|
for (ptr = (struct scsi_cmnd *) hostdata->disconnected_queue; ptr;
|
2013-03-31 11:24:44 -06:00
|
|
|
ptr = NEXT(ptr))
|
|
|
|
show_Scsi_Cmnd(ptr, m);
|
|
|
|
|
|
|
|
local_irq_restore(flags);
|
|
|
|
return 0;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2014-11-11 22:12:18 -07:00
|
|
|
/**
|
|
|
|
* NCR5380_init - initialise an NCR5380
|
|
|
|
* @instance: adapter to configure
|
|
|
|
* @flags: control flags
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2014-11-11 22:12:18 -07:00
|
|
|
* Initializes *instance and corresponding 5380 chip,
|
|
|
|
* with flags OR'd into the initial flags value.
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* Notes : I assume that the host, hostno, and id bits have been
|
2014-11-11 22:12:18 -07:00
|
|
|
* set correctly. I don't care about the irq and other fields.
|
2007-05-01 14:32:36 -06:00
|
|
|
*
|
2014-11-11 22:12:18 -07:00
|
|
|
* Returns 0 for success
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
|
2009-01-17 19:22:15 -07:00
|
|
|
static int __init NCR5380_init(struct Scsi_Host *instance, int flags)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-05-01 14:32:36 -06:00
|
|
|
int i;
|
|
|
|
SETUP_HOSTDATA(instance);
|
|
|
|
|
2014-11-11 22:12:21 -07:00
|
|
|
hostdata->host = instance;
|
2007-05-01 14:32:36 -06:00
|
|
|
hostdata->aborted = 0;
|
|
|
|
hostdata->id_mask = 1 << instance->this_id;
|
|
|
|
hostdata->id_higher_mask = 0;
|
|
|
|
for (i = hostdata->id_mask; i <= 0x80; i <<= 1)
|
|
|
|
if (i > hostdata->id_mask)
|
|
|
|
hostdata->id_higher_mask |= i;
|
|
|
|
for (i = 0; i < 8; ++i)
|
|
|
|
hostdata->busy[i] = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
#ifdef SUPPORT_TAGS
|
2014-11-11 22:12:19 -07:00
|
|
|
init_tags(hostdata);
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
|
|
|
#if defined (REAL_DMA)
|
2007-05-01 14:32:36 -06:00
|
|
|
hostdata->dma_len = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
2007-05-01 14:32:36 -06:00
|
|
|
hostdata->targets_present = 0;
|
|
|
|
hostdata->connected = NULL;
|
|
|
|
hostdata->issue_queue = NULL;
|
|
|
|
hostdata->disconnected_queue = NULL;
|
2014-11-11 22:12:14 -07:00
|
|
|
hostdata->flags = flags;
|
2007-05-01 14:32:36 -06:00
|
|
|
|
2014-11-11 22:12:21 -07:00
|
|
|
INIT_WORK(&hostdata->main_task, NCR5380_main);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2014-11-11 22:11:58 -07:00
|
|
|
prepare_info(instance);
|
|
|
|
|
2007-05-01 14:32:36 -06:00
|
|
|
NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
|
|
|
|
NCR5380_write(MODE_REG, MR_BASE);
|
|
|
|
NCR5380_write(TARGET_COMMAND_REG, 0);
|
|
|
|
NCR5380_write(SELECT_ENABLE_REG, 0);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-05-01 14:32:36 -06:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2014-11-11 22:12:18 -07:00
|
|
|
/**
|
|
|
|
* NCR5380_exit - remove an NCR5380
|
|
|
|
* @instance: adapter to remove
|
|
|
|
*
|
|
|
|
* Assumes that no more work can be queued (e.g. by NCR5380_intr).
|
|
|
|
*/
|
|
|
|
|
2011-06-13 12:39:15 -06:00
|
|
|
static void NCR5380_exit(struct Scsi_Host *instance)
|
|
|
|
{
|
2014-11-11 22:12:21 -07:00
|
|
|
struct NCR5380_hostdata *hostdata = shost_priv(instance);
|
|
|
|
|
|
|
|
cancel_work_sync(&hostdata->main_task);
|
2011-06-13 12:39:15 -06:00
|
|
|
}
|
|
|
|
|
2014-11-11 22:12:18 -07:00
|
|
|
/**
|
|
|
|
* NCR5380_queue_command - queue a command
|
|
|
|
* @instance: the relevant SCSI adapter
|
|
|
|
* @cmd: SCSI command
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2014-11-11 22:12:18 -07:00
|
|
|
* cmd is added to the per instance issue_queue, with minor
|
|
|
|
* twiddling done to the host specific fields of cmd. If the
|
|
|
|
* main coroutine is not running, it is restarted.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
|
2014-11-11 22:12:08 -07:00
|
|
|
static int NCR5380_queue_command(struct Scsi_Host *instance,
|
|
|
|
struct scsi_cmnd *cmd)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2014-11-11 22:12:08 -07:00
|
|
|
struct NCR5380_hostdata *hostdata = shost_priv(instance);
|
2014-11-11 22:12:02 -07:00
|
|
|
struct scsi_cmnd *tmp;
|
2007-05-01 14:32:36 -06:00
|
|
|
unsigned long flags;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
#if (NDEBUG & NDEBUG_NO_WRITE)
|
2007-05-01 14:32:36 -06:00
|
|
|
switch (cmd->cmnd[0]) {
|
|
|
|
case WRITE_6:
|
|
|
|
case WRITE_10:
|
|
|
|
printk(KERN_NOTICE "scsi%d: WRITE attempted with NO_WRITE debugging flag set\n",
|
|
|
|
H_NO(cmd));
|
|
|
|
cmd->result = (DID_ERROR << 16);
|
2014-11-11 22:12:08 -07:00
|
|
|
cmd->scsi_done(cmd);
|
2007-05-01 14:32:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif /* (NDEBUG & NDEBUG_NO_WRITE) */
|
|
|
|
|
2007-05-01 14:32:36 -06:00
|
|
|
/*
|
|
|
|
* We use the host_scribble field as a pointer to the next command
|
|
|
|
* in a queue
|
|
|
|
*/
|
|
|
|
|
2007-05-01 14:32:37 -06:00
|
|
|
SET_NEXT(cmd, NULL);
|
2007-05-01 14:32:36 -06:00
|
|
|
cmd->result = 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Insert the cmd into the issue queue. Note that REQUEST SENSE
|
|
|
|
* commands are added to the head of the queue since any command will
|
|
|
|
* clear the contingent allegiance condition that exists and the
|
|
|
|
* sense data is only guaranteed to be valid while the condition exists.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* ++guenther: now that the issue queue is being set up, we can lock ST-DMA.
|
|
|
|
* Otherwise a running NCR5380_main may steal the lock.
|
|
|
|
* Lock before actually inserting due to fairness reasons explained in
|
|
|
|
* atari_scsi.c. If we insert first, then it's impossible for this driver
|
|
|
|
* to release the lock.
|
|
|
|
* Stop timer for this command while waiting for the lock, or timeouts
|
|
|
|
* may happen (and they really do), and it's no good if the command doesn't
|
|
|
|
* appear in any of the queues.
|
|
|
|
* ++roman: Just disabling the NCR interrupt isn't sufficient here,
|
|
|
|
* because also a timer int can trigger an abort or reset, which would
|
|
|
|
* alter queues and touch the lock.
|
|
|
|
*/
|
2014-11-11 22:12:15 -07:00
|
|
|
if (!NCR5380_acquire_dma_irq(instance))
|
2014-11-11 22:12:08 -07:00
|
|
|
return SCSI_MLQUEUE_HOST_BUSY;
|
|
|
|
|
|
|
|
local_irq_save(flags);
|
|
|
|
|
2014-11-11 22:12:18 -07:00
|
|
|
/*
|
|
|
|
* Insert the cmd into the issue queue. Note that REQUEST SENSE
|
|
|
|
* commands are added to the head of the queue since any command will
|
|
|
|
* clear the contingent allegiance condition that exists and the
|
|
|
|
* sense data is only guaranteed to be valid while the condition exists.
|
|
|
|
*/
|
|
|
|
|
2007-05-01 14:32:36 -06:00
|
|
|
if (!(hostdata->issue_queue) || (cmd->cmnd[0] == REQUEST_SENSE)) {
|
|
|
|
LIST(cmd, hostdata->issue_queue);
|
2007-05-01 14:32:37 -06:00
|
|
|
SET_NEXT(cmd, hostdata->issue_queue);
|
2007-05-01 14:32:36 -06:00
|
|
|
hostdata->issue_queue = cmd;
|
|
|
|
} else {
|
2014-11-11 22:12:02 -07:00
|
|
|
for (tmp = (struct scsi_cmnd *)hostdata->issue_queue;
|
2007-05-01 14:32:36 -06:00
|
|
|
NEXT(tmp); tmp = NEXT(tmp))
|
|
|
|
;
|
|
|
|
LIST(cmd, tmp);
|
2007-05-01 14:32:37 -06:00
|
|
|
SET_NEXT(tmp, cmd);
|
2007-05-01 14:32:36 -06:00
|
|
|
}
|
|
|
|
local_irq_restore(flags);
|
|
|
|
|
2014-03-17 18:42:20 -06:00
|
|
|
dprintk(NDEBUG_QUEUES, "scsi%d: command added to %s of queue\n", H_NO(cmd),
|
2007-05-01 14:32:36 -06:00
|
|
|
(cmd->cmnd[0] == REQUEST_SENSE) ? "head" : "tail");
|
|
|
|
|
|
|
|
/* If queue_command() is called from an interrupt (real one or bottom
|
|
|
|
* half), we let queue_main() do the job of taking care about main. If it
|
|
|
|
* is already running, this is a no-op, else main will be queued.
|
|
|
|
*
|
|
|
|
* If we're not in an interrupt, we can call NCR5380_main()
|
|
|
|
* unconditionally, because it cannot be already running.
|
|
|
|
*/
|
2014-11-11 22:12:08 -07:00
|
|
|
if (in_interrupt() || irqs_disabled())
|
2014-11-11 22:12:21 -07:00
|
|
|
queue_main(hostdata);
|
2007-05-01 14:32:36 -06:00
|
|
|
else
|
2014-11-11 22:12:21 -07:00
|
|
|
NCR5380_main(&hostdata->main_task);
|
2007-05-01 14:32:36 -06:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2014-11-11 22:12:15 -07:00
|
|
|
static inline void maybe_release_dma_irq(struct Scsi_Host *instance)
|
|
|
|
{
|
|
|
|
struct NCR5380_hostdata *hostdata = shost_priv(instance);
|
|
|
|
|
|
|
|
/* Caller does the locking needed to set & test these data atomically */
|
|
|
|
if (!hostdata->disconnected_queue &&
|
|
|
|
!hostdata->issue_queue &&
|
|
|
|
!hostdata->connected &&
|
|
|
|
!hostdata->retain_dma_intr)
|
|
|
|
NCR5380_release_dma_irq(instance);
|
|
|
|
}
|
|
|
|
|
2014-11-11 22:12:18 -07:00
|
|
|
/**
|
|
|
|
* NCR5380_main - NCR state machines
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2014-11-11 22:12:18 -07:00
|
|
|
* NCR5380_main is a coroutine that runs as long as more work can
|
|
|
|
* be done on the NCR5380 host adapters in a system. Both
|
|
|
|
* NCR5380_queue_command() and NCR5380_intr() will try to start it
|
|
|
|
* in case it is not running.
|
2007-05-01 14:32:36 -06:00
|
|
|
*
|
2014-11-11 22:12:18 -07:00
|
|
|
* Locks: called as its own thread with no locks held.
|
2007-05-01 14:32:36 -06:00
|
|
|
*/
|
|
|
|
|
2007-05-01 14:32:48 -06:00
|
|
|
static void NCR5380_main(struct work_struct *work)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2014-11-11 22:12:21 -07:00
|
|
|
struct NCR5380_hostdata *hostdata =
|
|
|
|
container_of(work, struct NCR5380_hostdata, main_task);
|
|
|
|
struct Scsi_Host *instance = hostdata->host;
|
2014-11-11 22:12:02 -07:00
|
|
|
struct scsi_cmnd *tmp, *prev;
|
2007-05-01 14:32:36 -06:00
|
|
|
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.
|
|
|
|
*
|
|
|
|
* Interrupts are enabled before doing various other internal
|
|
|
|
* instructions, after we've decided that we need to run through
|
|
|
|
* the loop again.
|
|
|
|
*
|
|
|
|
* this should prevent any race conditions.
|
|
|
|
*
|
|
|
|
* ++roman: Just disabling the NCR interrupt isn't sufficient here,
|
|
|
|
* because also a timer int can trigger an abort or reset, which can
|
|
|
|
* alter queues and touch the Falcon lock.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* Tell int handlers main() is now already executing. Note that
|
|
|
|
no races are possible here. If an int comes in before
|
|
|
|
'main_running' is set here, and queues/executes main via the
|
|
|
|
task queue, it doesn't do any harm, just this instance of main
|
|
|
|
won't find any work left to do. */
|
2014-11-11 22:12:21 -07:00
|
|
|
if (hostdata->main_running)
|
2007-05-01 14:32:36 -06:00
|
|
|
return;
|
2014-11-11 22:12:21 -07:00
|
|
|
hostdata->main_running = 1;
|
2007-05-01 14:32:36 -06:00
|
|
|
|
|
|
|
local_save_flags(flags);
|
|
|
|
do {
|
|
|
|
local_irq_disable(); /* Freeze request queues */
|
|
|
|
done = 1;
|
|
|
|
|
|
|
|
if (!hostdata->connected) {
|
2014-03-17 18:42:20 -06:00
|
|
|
dprintk(NDEBUG_MAIN, "scsi%d: not connected\n", HOSTNO);
|
2007-05-01 14:32:36 -06:00
|
|
|
/*
|
|
|
|
* Search through the issue_queue for a command destined
|
|
|
|
* for a target that's not busy.
|
|
|
|
*/
|
2005-04-16 16:20:36 -06:00
|
|
|
#if (NDEBUG & NDEBUG_LISTS)
|
2014-11-11 22:12:02 -07:00
|
|
|
for (tmp = (struct scsi_cmnd *) hostdata->issue_queue, prev = NULL;
|
2007-05-01 14:32:36 -06:00
|
|
|
tmp && (tmp != prev); prev = tmp, tmp = NEXT(tmp))
|
|
|
|
;
|
|
|
|
/*printk("%p ", tmp);*/
|
|
|
|
if ((tmp == prev) && tmp)
|
|
|
|
printk(" LOOP\n");
|
|
|
|
/* else printk("\n"); */
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
2014-11-11 22:12:02 -07:00
|
|
|
for (tmp = (struct scsi_cmnd *) hostdata->issue_queue,
|
2007-05-01 14:32:36 -06:00
|
|
|
prev = NULL; tmp; prev = tmp, tmp = NEXT(tmp)) {
|
2014-06-25 07:27:36 -06:00
|
|
|
u8 lun = tmp->device->lun;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2014-11-11 22:12:16 -07:00
|
|
|
dprintk(NDEBUG_LISTS,
|
|
|
|
"MAIN tmp=%p target=%d busy=%d lun=%d\n",
|
|
|
|
tmp, scmd_id(tmp), hostdata->busy[scmd_id(tmp)],
|
|
|
|
lun);
|
2007-05-01 14:32:36 -06:00
|
|
|
/* When we find one, remove it from the issue queue. */
|
|
|
|
/* ++guenther: possible race with Falcon locking */
|
|
|
|
if (
|
2005-04-16 16:20:36 -06:00
|
|
|
#ifdef SUPPORT_TAGS
|
2007-05-01 14:32:36 -06:00
|
|
|
!is_lun_busy( tmp, tmp->cmnd[0] != REQUEST_SENSE)
|
2005-04-16 16:20:36 -06:00
|
|
|
#else
|
2014-06-25 07:27:36 -06:00
|
|
|
!(hostdata->busy[tmp->device->id] & (1 << lun))
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
2007-05-01 14:32:36 -06:00
|
|
|
) {
|
|
|
|
/* ++guenther: just to be sure, this must be atomic */
|
|
|
|
local_irq_disable();
|
|
|
|
if (prev) {
|
|
|
|
REMOVE(prev, NEXT(prev), tmp, NEXT(tmp));
|
2007-05-01 14:32:37 -06:00
|
|
|
SET_NEXT(prev, NEXT(tmp));
|
2007-05-01 14:32:36 -06:00
|
|
|
} else {
|
|
|
|
REMOVE(-1, hostdata->issue_queue, tmp, NEXT(tmp));
|
|
|
|
hostdata->issue_queue = NEXT(tmp);
|
|
|
|
}
|
2007-05-01 14:32:37 -06:00
|
|
|
SET_NEXT(tmp, NULL);
|
2014-11-11 22:12:14 -07:00
|
|
|
hostdata->retain_dma_intr++;
|
2007-05-01 14:32:36 -06:00
|
|
|
|
|
|
|
/* reenable interrupts after finding one */
|
|
|
|
local_irq_restore(flags);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
2014-03-17 18:42:20 -06:00
|
|
|
dprintk(NDEBUG_MAIN, "scsi%d: main(): command for target %d "
|
2007-05-01 14:32:36 -06:00
|
|
|
"lun %d removed from issue_queue\n",
|
2014-06-25 07:27:36 -06:00
|
|
|
HOSTNO, tmp->device->id, lun);
|
2007-05-01 14:32:36 -06:00
|
|
|
/*
|
|
|
|
* REQUEST SENSE commands are issued without tagged
|
|
|
|
* queueing, even on SCSI-II devices because the
|
|
|
|
* contingent allegiance condition exists for the
|
|
|
|
* entire unit.
|
|
|
|
*/
|
|
|
|
/* ++roman: ...and the standard also requires that
|
|
|
|
* REQUEST SENSE command are untagged.
|
|
|
|
*/
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
#ifdef SUPPORT_TAGS
|
2007-05-01 14:32:36 -06:00
|
|
|
cmd_get_tag(tmp, tmp->cmnd[0] != REQUEST_SENSE);
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
2014-11-11 22:11:53 -07:00
|
|
|
if (!NCR5380_select(instance, tmp)) {
|
2014-11-11 22:12:15 -07:00
|
|
|
local_irq_disable();
|
2014-11-11 22:12:14 -07:00
|
|
|
hostdata->retain_dma_intr--;
|
2007-05-01 14:32:36 -06:00
|
|
|
/* release if target did not response! */
|
2014-11-11 22:12:15 -07:00
|
|
|
maybe_release_dma_irq(instance);
|
|
|
|
local_irq_restore(flags);
|
2007-05-01 14:32:36 -06:00
|
|
|
break;
|
|
|
|
} else {
|
|
|
|
local_irq_disable();
|
|
|
|
LIST(tmp, hostdata->issue_queue);
|
2007-05-01 14:32:37 -06:00
|
|
|
SET_NEXT(tmp, hostdata->issue_queue);
|
2007-05-01 14:32:36 -06:00
|
|
|
hostdata->issue_queue = tmp;
|
2005-04-16 16:20:36 -06:00
|
|
|
#ifdef SUPPORT_TAGS
|
2007-05-01 14:32:36 -06:00
|
|
|
cmd_free_tag(tmp);
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
2014-11-11 22:12:14 -07:00
|
|
|
hostdata->retain_dma_intr--;
|
2007-05-01 14:32:36 -06:00
|
|
|
local_irq_restore(flags);
|
2014-03-17 18:42:20 -06:00
|
|
|
dprintk(NDEBUG_MAIN, "scsi%d: main(): select() failed, "
|
2007-05-01 14:32:36 -06:00
|
|
|
"returned to issue_queue\n", HOSTNO);
|
|
|
|
if (hostdata->connected)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} /* if target/lun/target queue is not busy */
|
|
|
|
} /* for issue_queue */
|
|
|
|
} /* if (!hostdata->connected) */
|
|
|
|
|
|
|
|
if (hostdata->connected
|
2005-04-16 16:20:36 -06:00
|
|
|
#ifdef REAL_DMA
|
2007-05-01 14:32:36 -06:00
|
|
|
&& !hostdata->dma_len
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
2007-05-01 14:32:36 -06:00
|
|
|
) {
|
|
|
|
local_irq_restore(flags);
|
2014-03-17 18:42:20 -06:00
|
|
|
dprintk(NDEBUG_MAIN, "scsi%d: main: performing information transfer\n",
|
2007-05-01 14:32:36 -06:00
|
|
|
HOSTNO);
|
|
|
|
NCR5380_information_transfer(instance);
|
2014-03-17 18:42:20 -06:00
|
|
|
dprintk(NDEBUG_MAIN, "scsi%d: main: done set false\n", HOSTNO);
|
2007-05-01 14:32:36 -06:00
|
|
|
done = 0;
|
|
|
|
}
|
|
|
|
} while (!done);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-05-01 14:32:36 -06:00
|
|
|
/* Better allow ints _after_ 'main_running' has been cleared, else
|
|
|
|
an interrupt could believe we'll pick up the work it left for
|
|
|
|
us, but we won't see it anymore here... */
|
2014-11-11 22:12:21 -07:00
|
|
|
hostdata->main_running = 0;
|
2007-05-01 14:32:36 -06:00
|
|
|
local_irq_restore(flags);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#ifdef REAL_DMA
|
|
|
|
/*
|
|
|
|
* Function : void NCR5380_dma_complete (struct Scsi_Host *instance)
|
|
|
|
*
|
|
|
|
* Purpose : Called by interrupt handler when DMA finishes or a phase
|
2007-05-01 14:32:36 -06:00
|
|
|
* mismatch occurs (which would finish the DMA transfer).
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* Inputs : instance - this instance of the NCR5380.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2007-05-01 14:32:36 -06:00
|
|
|
static void NCR5380_dma_complete(struct Scsi_Host *instance)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-05-01 14:32:36 -06:00
|
|
|
SETUP_HOSTDATA(instance);
|
2014-11-11 22:12:23 -07:00
|
|
|
int transferred;
|
2014-11-11 22:12:16 -07:00
|
|
|
unsigned char **data;
|
2007-05-01 14:32:36 -06:00
|
|
|
volatile int *count;
|
2014-11-11 22:12:16 -07:00
|
|
|
int saved_data = 0, overrun = 0;
|
|
|
|
unsigned char p;
|
2007-05-01 14:32:36 -06:00
|
|
|
|
|
|
|
if (!hostdata->connected) {
|
|
|
|
printk(KERN_WARNING "scsi%d: received end of DMA interrupt with "
|
|
|
|
"no connected cmd\n", HOSTNO);
|
|
|
|
return;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2007-05-01 14:32:36 -06:00
|
|
|
|
2014-11-11 22:12:14 -07:00
|
|
|
if (hostdata->read_overruns) {
|
2007-05-01 14:32:36 -06:00
|
|
|
p = hostdata->connected->SCp.phase;
|
|
|
|
if (p & SR_IO) {
|
|
|
|
udelay(10);
|
|
|
|
if ((NCR5380_read(BUS_AND_STATUS_REG) &
|
|
|
|
(BASR_PHASE_MATCH|BASR_ACK)) ==
|
|
|
|
(BASR_PHASE_MATCH|BASR_ACK)) {
|
|
|
|
saved_data = NCR5380_read(INPUT_DATA_REG);
|
|
|
|
overrun = 1;
|
2014-03-17 18:42:20 -06:00
|
|
|
dprintk(NDEBUG_DMA, "scsi%d: read overrun handled\n", HOSTNO);
|
2007-05-01 14:32:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-03-17 18:42:20 -06:00
|
|
|
dprintk(NDEBUG_DMA, "scsi%d: real DMA transfer complete, basr 0x%X, sr 0x%X\n",
|
2007-05-01 14:32:36 -06:00
|
|
|
HOSTNO, NCR5380_read(BUS_AND_STATUS_REG),
|
|
|
|
NCR5380_read(STATUS_REG));
|
|
|
|
|
2014-11-11 22:12:16 -07:00
|
|
|
#if defined(CONFIG_SUN3)
|
|
|
|
if ((sun3scsi_dma_finish(rq_data_dir(hostdata->connected->request)))) {
|
|
|
|
pr_err("scsi%d: overrun in UDC counter -- not prepared to deal with this!\n",
|
|
|
|
instance->host_no);
|
|
|
|
BUG();
|
|
|
|
}
|
|
|
|
|
|
|
|
/* make sure we're not stuck in a data phase */
|
|
|
|
if ((NCR5380_read(BUS_AND_STATUS_REG) & (BASR_PHASE_MATCH | BASR_ACK)) ==
|
|
|
|
(BASR_PHASE_MATCH | BASR_ACK)) {
|
|
|
|
pr_err("scsi%d: BASR %02x\n", instance->host_no,
|
|
|
|
NCR5380_read(BUS_AND_STATUS_REG));
|
|
|
|
pr_err("scsi%d: bus stuck in data phase -- probably a single byte overrun!\n",
|
|
|
|
instance->host_no);
|
|
|
|
BUG();
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2007-05-01 14:32:36 -06:00
|
|
|
(void)NCR5380_read(RESET_PARITY_INTERRUPT_REG);
|
|
|
|
NCR5380_write(MODE_REG, MR_BASE);
|
|
|
|
NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
|
|
|
|
|
2014-11-11 22:12:23 -07:00
|
|
|
transferred = hostdata->dma_len - NCR5380_dma_residual(instance);
|
2007-05-01 14:32:36 -06:00
|
|
|
hostdata->dma_len = 0;
|
|
|
|
|
|
|
|
data = (unsigned char **)&hostdata->connected->SCp.ptr;
|
|
|
|
count = &hostdata->connected->SCp.this_residual;
|
2014-11-11 22:12:23 -07:00
|
|
|
*data += transferred;
|
|
|
|
*count -= transferred;
|
2007-05-01 14:32:36 -06:00
|
|
|
|
2014-11-11 22:12:14 -07:00
|
|
|
if (hostdata->read_overruns) {
|
2014-11-11 22:12:16 -07:00
|
|
|
int cnt, toPIO;
|
|
|
|
|
2007-05-01 14:32:36 -06:00
|
|
|
if ((NCR5380_read(STATUS_REG) & PHASE_MASK) == p && (p & SR_IO)) {
|
2014-11-11 22:12:14 -07:00
|
|
|
cnt = toPIO = hostdata->read_overruns;
|
2007-05-01 14:32:36 -06:00
|
|
|
if (overrun) {
|
2014-03-17 18:42:20 -06:00
|
|
|
dprintk(NDEBUG_DMA, "Got an input overrun, using saved byte\n");
|
2007-05-01 14:32:36 -06:00
|
|
|
*(*data)++ = saved_data;
|
|
|
|
(*count)--;
|
|
|
|
cnt--;
|
|
|
|
toPIO--;
|
|
|
|
}
|
2014-03-17 18:42:20 -06:00
|
|
|
dprintk(NDEBUG_DMA, "Doing %d-byte PIO to 0x%08lx\n", cnt, (long)*data);
|
2007-05-01 14:32:36 -06:00
|
|
|
NCR5380_transfer_pio(instance, &p, &cnt, data);
|
|
|
|
*count -= toPIO - cnt;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif /* REAL_DMA */
|
|
|
|
|
|
|
|
|
2014-11-11 22:12:18 -07:00
|
|
|
/**
|
|
|
|
* NCR5380_intr - generic NCR5380 irq handler
|
|
|
|
* @irq: interrupt number
|
|
|
|
* @dev_id: device info
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2014-11-11 22:12:18 -07:00
|
|
|
* Handle interrupts, reestablishing I_T_L or I_T_L_Q nexuses
|
|
|
|
* from the disconnected queue, and restarting NCR5380_main()
|
|
|
|
* as required.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
|
2007-05-01 14:32:36 -06:00
|
|
|
static irqreturn_t NCR5380_intr(int irq, void *dev_id)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2014-11-11 22:12:21 -07:00
|
|
|
struct Scsi_Host *instance = dev_id;
|
2007-05-01 14:32:36 -06:00
|
|
|
int done = 1, handled = 0;
|
|
|
|
unsigned char basr;
|
|
|
|
|
2014-03-17 18:42:20 -06:00
|
|
|
dprintk(NDEBUG_INTR, "scsi%d: NCR5380 irq triggered\n", HOSTNO);
|
2007-05-01 14:32:36 -06:00
|
|
|
|
|
|
|
/* Look for pending interrupts */
|
|
|
|
basr = NCR5380_read(BUS_AND_STATUS_REG);
|
2014-03-17 18:42:20 -06:00
|
|
|
dprintk(NDEBUG_INTR, "scsi%d: BASR=%02x\n", HOSTNO, basr);
|
2007-05-01 14:32:36 -06:00
|
|
|
/* dispatch to appropriate routine if found and done=0 */
|
|
|
|
if (basr & BASR_IRQ) {
|
2014-03-17 18:42:19 -06:00
|
|
|
NCR5380_dprint(NDEBUG_INTR, instance);
|
2007-05-01 14:32:36 -06:00
|
|
|
if ((NCR5380_read(STATUS_REG) & (SR_SEL|SR_IO)) == (SR_SEL|SR_IO)) {
|
|
|
|
done = 0;
|
2014-03-17 18:42:20 -06:00
|
|
|
dprintk(NDEBUG_INTR, "scsi%d: SEL interrupt\n", HOSTNO);
|
2007-05-01 14:32:36 -06:00
|
|
|
NCR5380_reselect(instance);
|
|
|
|
(void)NCR5380_read(RESET_PARITY_INTERRUPT_REG);
|
|
|
|
} else if (basr & BASR_PARITY_ERROR) {
|
2014-03-17 18:42:20 -06:00
|
|
|
dprintk(NDEBUG_INTR, "scsi%d: PARITY interrupt\n", HOSTNO);
|
2007-05-01 14:32:36 -06:00
|
|
|
(void)NCR5380_read(RESET_PARITY_INTERRUPT_REG);
|
|
|
|
} else if ((NCR5380_read(STATUS_REG) & SR_RST) == SR_RST) {
|
2014-03-17 18:42:20 -06:00
|
|
|
dprintk(NDEBUG_INTR, "scsi%d: RESET interrupt\n", HOSTNO);
|
2007-05-01 14:32:36 -06:00
|
|
|
(void)NCR5380_read(RESET_PARITY_INTERRUPT_REG);
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* The rest of the interrupt conditions can occur only during a
|
|
|
|
* DMA transfer
|
|
|
|
*/
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
#if defined(REAL_DMA)
|
2007-05-01 14:32:36 -06:00
|
|
|
/*
|
|
|
|
* We should only get PHASE MISMATCH and EOP interrupts if we have
|
|
|
|
* DMA enabled, so do a sanity check based on the current setting
|
|
|
|
* of the MODE register.
|
|
|
|
*/
|
|
|
|
|
|
|
|
if ((NCR5380_read(MODE_REG) & MR_DMA_MODE) &&
|
|
|
|
((basr & BASR_END_DMA_TRANSFER) ||
|
|
|
|
!(basr & BASR_PHASE_MATCH))) {
|
|
|
|
|
2014-03-17 18:42:20 -06:00
|
|
|
dprintk(NDEBUG_INTR, "scsi%d: PHASE MISM or EOP interrupt\n", HOSTNO);
|
2007-05-01 14:32:36 -06:00
|
|
|
NCR5380_dma_complete( instance );
|
|
|
|
done = 0;
|
|
|
|
} else
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif /* REAL_DMA */
|
2007-05-01 14:32:36 -06:00
|
|
|
{
|
2005-04-16 16:20:36 -06:00
|
|
|
/* MS: Ignore unknown phase mismatch interrupts (caused by EOP interrupt) */
|
2007-05-01 14:32:36 -06:00
|
|
|
if (basr & BASR_PHASE_MATCH)
|
2014-11-11 22:12:16 -07:00
|
|
|
dprintk(NDEBUG_INTR, "scsi%d: unknown interrupt, "
|
2007-05-01 14:32:36 -06:00
|
|
|
"BASR 0x%x, MR 0x%x, SR 0x%x\n",
|
|
|
|
HOSTNO, basr, NCR5380_read(MODE_REG),
|
|
|
|
NCR5380_read(STATUS_REG));
|
|
|
|
(void)NCR5380_read(RESET_PARITY_INTERRUPT_REG);
|
2014-11-11 22:12:16 -07:00
|
|
|
#ifdef SUN3_SCSI_VME
|
|
|
|
dregs->csr |= CSR_DMA_ENABLE;
|
|
|
|
#endif
|
2007-05-01 14:32:36 -06:00
|
|
|
}
|
|
|
|
} /* if !(SELECTION || PARITY) */
|
|
|
|
handled = 1;
|
|
|
|
} /* BASR & IRQ */ else {
|
|
|
|
printk(KERN_NOTICE "scsi%d: interrupt without IRQ bit set in BASR, "
|
|
|
|
"BASR 0x%X, MR 0x%X, SR 0x%x\n", HOSTNO, basr,
|
|
|
|
NCR5380_read(MODE_REG), NCR5380_read(STATUS_REG));
|
|
|
|
(void)NCR5380_read(RESET_PARITY_INTERRUPT_REG);
|
2014-11-11 22:12:16 -07:00
|
|
|
#ifdef SUN3_SCSI_VME
|
|
|
|
dregs->csr |= CSR_DMA_ENABLE;
|
|
|
|
#endif
|
2007-05-01 14:32:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!done) {
|
2014-03-17 18:42:20 -06:00
|
|
|
dprintk(NDEBUG_INTR, "scsi%d: in int routine, calling main\n", HOSTNO);
|
2007-05-01 14:32:36 -06:00
|
|
|
/* Put a call to NCR5380_main() on the queue... */
|
2014-11-11 22:12:21 -07:00
|
|
|
queue_main(shost_priv(instance));
|
2007-05-01 14:32:36 -06:00
|
|
|
}
|
|
|
|
return IRQ_RETVAL(handled);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2007-05-01 14:32:36 -06:00
|
|
|
/*
|
2014-11-11 22:12:02 -07:00
|
|
|
* Function : int NCR5380_select(struct Scsi_Host *instance,
|
|
|
|
* struct scsi_cmnd *cmd)
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* Purpose : establishes I_T_L or I_T_L_Q nexus for new or existing command,
|
2007-05-01 14:32:36 -06:00
|
|
|
* including ARBITRATION, SELECTION, and initial message out for
|
|
|
|
* IDENTIFY and queue messages.
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2007-05-01 14:32:36 -06:00
|
|
|
* Inputs : instance - instantiation of the 5380 driver on which this
|
2014-11-11 22:11:53 -07:00
|
|
|
* target lives, cmd - SCSI command to execute.
|
2007-05-01 14:32:36 -06:00
|
|
|
*
|
2005-04-16 16:20:36 -06:00
|
|
|
* Returns : -1 if selection could not execute for some reason,
|
2007-05-01 14:32:36 -06:00
|
|
|
* 0 if selection succeeded or failed because the target
|
|
|
|
* did not respond.
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2007-05-01 14:32:36 -06:00
|
|
|
* Side effects :
|
|
|
|
* If bus busy, arbitration failed, etc, NCR5380_select() will exit
|
2005-04-16 16:20:36 -06:00
|
|
|
* with registers as they should have been on entry - ie
|
|
|
|
* SELECT_ENABLE will be set appropriately, the NCR5380
|
|
|
|
* will cease to drive any SCSI bus signals.
|
|
|
|
*
|
2007-05-01 14:32:36 -06:00
|
|
|
* If successful : I_T_L or I_T_L_Q nexus will be established,
|
|
|
|
* instance->connected will be set to cmd.
|
|
|
|
* SELECT interrupt will be disabled.
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2007-05-01 14:32:36 -06:00
|
|
|
* If failed (no target) : cmd->scsi_done() will be called, and the
|
2005-04-16 16:20:36 -06:00
|
|
|
* cmd->result host byte set to DID_BAD_TARGET.
|
|
|
|
*/
|
|
|
|
|
2014-11-11 22:12:02 -07:00
|
|
|
static int NCR5380_select(struct Scsi_Host *instance, struct scsi_cmnd *cmd)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-05-01 14:32:36 -06:00
|
|
|
SETUP_HOSTDATA(instance);
|
|
|
|
unsigned char tmp[3], phase;
|
|
|
|
unsigned char *data;
|
|
|
|
int len;
|
|
|
|
unsigned long timeout;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
hostdata->restart_select = 0;
|
2014-03-17 18:42:19 -06:00
|
|
|
NCR5380_dprint(NDEBUG_ARBITRATION, instance);
|
2014-03-17 18:42:20 -06:00
|
|
|
dprintk(NDEBUG_ARBITRATION, "scsi%d: starting arbitration, id = %d\n", HOSTNO,
|
2007-05-01 14:32:36 -06:00
|
|
|
instance->this_id);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set the phase bits to 0, otherwise the NCR5380 won't drive the
|
|
|
|
* data bus during SELECTION.
|
|
|
|
*/
|
|
|
|
|
|
|
|
local_irq_save(flags);
|
|
|
|
if (hostdata->connected) {
|
|
|
|
local_irq_restore(flags);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
NCR5380_write(TARGET_COMMAND_REG, 0);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-05-01 14:32:36 -06:00
|
|
|
/*
|
|
|
|
* Start arbitration.
|
|
|
|
*/
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-05-01 14:32:36 -06:00
|
|
|
NCR5380_write(OUTPUT_DATA_REG, hostdata->id_mask);
|
|
|
|
NCR5380_write(MODE_REG, MR_ARBITRATE);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-05-01 14:32:36 -06:00
|
|
|
local_irq_restore(flags);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-05-01 14:32:36 -06:00
|
|
|
/* Wait for arbitration logic to complete */
|
2007-05-01 14:32:35 -06:00
|
|
|
#if defined(NCR_TIMEOUT)
|
2007-05-01 14:32:36 -06:00
|
|
|
{
|
|
|
|
unsigned long timeout = jiffies + 2*NCR_TIMEOUT;
|
|
|
|
|
|
|
|
while (!(NCR5380_read(INITIATOR_COMMAND_REG) & ICR_ARBITRATION_PROGRESS) &&
|
|
|
|
time_before(jiffies, timeout) && !hostdata->connected)
|
|
|
|
;
|
|
|
|
if (time_after_eq(jiffies, timeout)) {
|
|
|
|
printk("scsi : arbitration timeout at %d\n", __LINE__);
|
|
|
|
NCR5380_write(MODE_REG, MR_BASE);
|
|
|
|
NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
#else /* NCR_TIMEOUT */
|
2007-05-01 14:32:36 -06:00
|
|
|
while (!(NCR5380_read(INITIATOR_COMMAND_REG) & ICR_ARBITRATION_PROGRESS) &&
|
|
|
|
!hostdata->connected)
|
|
|
|
;
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
|
|
|
|
2014-03-17 18:42:20 -06:00
|
|
|
dprintk(NDEBUG_ARBITRATION, "scsi%d: arbitration complete\n", HOSTNO);
|
2007-05-01 14:32:36 -06:00
|
|
|
|
|
|
|
if (hostdata->connected) {
|
|
|
|
NCR5380_write(MODE_REG, MR_BASE);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* The arbitration delay is 2.2us, but this is a minimum and there is
|
|
|
|
* no maximum so we can safely sleep for ceil(2.2) usecs to accommodate
|
|
|
|
* the integral nature of udelay().
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
udelay(3);
|
|
|
|
|
|
|
|
/* Check for lost arbitration */
|
|
|
|
if ((NCR5380_read(INITIATOR_COMMAND_REG) & ICR_ARBITRATION_LOST) ||
|
|
|
|
(NCR5380_read(CURRENT_SCSI_DATA_REG) & hostdata->id_higher_mask) ||
|
|
|
|
(NCR5380_read(INITIATOR_COMMAND_REG) & ICR_ARBITRATION_LOST) ||
|
|
|
|
hostdata->connected) {
|
|
|
|
NCR5380_write(MODE_REG, MR_BASE);
|
2014-03-17 18:42:20 -06:00
|
|
|
dprintk(NDEBUG_ARBITRATION, "scsi%d: lost arbitration, deasserting MR_ARBITRATE\n",
|
2007-05-01 14:32:36 -06:00
|
|
|
HOSTNO);
|
|
|
|
return -1;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-05-01 14:32:36 -06:00
|
|
|
/* after/during arbitration, BSY should be asserted.
|
|
|
|
IBM DPES-31080 Version S31Q works now */
|
|
|
|
/* Tnx to Thomas_Roesch@m2.maus.de for finding this! (Roman) */
|
|
|
|
NCR5380_write(INITIATOR_COMMAND_REG,
|
|
|
|
ICR_BASE | ICR_ASSERT_SEL | ICR_ASSERT_BSY);
|
|
|
|
|
|
|
|
if ((NCR5380_read(INITIATOR_COMMAND_REG) & ICR_ARBITRATION_LOST) ||
|
|
|
|
hostdata->connected) {
|
|
|
|
NCR5380_write(MODE_REG, MR_BASE);
|
|
|
|
NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
|
2014-03-17 18:42:20 -06:00
|
|
|
dprintk(NDEBUG_ARBITRATION, "scsi%d: lost arbitration, deasserting ICR_ASSERT_SEL\n",
|
2007-05-01 14:32:36 -06:00
|
|
|
HOSTNO);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Again, bus clear + bus settle time is 1.2us, however, this is
|
|
|
|
* a minimum so we'll udelay ceil(1.2)
|
|
|
|
*/
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
#ifdef CONFIG_ATARI_SCSI_TOSHIBA_DELAY
|
2007-05-01 14:32:36 -06:00
|
|
|
/* ++roman: But some targets (see above :-) seem to need a bit more... */
|
|
|
|
udelay(15);
|
2005-04-16 16:20:36 -06:00
|
|
|
#else
|
2007-05-01 14:32:36 -06:00
|
|
|
udelay(2);
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
2007-05-01 14:32:36 -06:00
|
|
|
|
|
|
|
if (hostdata->connected) {
|
|
|
|
NCR5380_write(MODE_REG, MR_BASE);
|
|
|
|
NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2014-03-17 18:42:20 -06:00
|
|
|
dprintk(NDEBUG_ARBITRATION, "scsi%d: won arbitration\n", HOSTNO);
|
2007-05-01 14:32:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Now that we have won arbitration, start Selection process, asserting
|
|
|
|
* the host and target ID's on the SCSI bus.
|
|
|
|
*/
|
|
|
|
|
|
|
|
NCR5380_write(OUTPUT_DATA_REG, (hostdata->id_mask | (1 << cmd->device->id)));
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Raise ATN while SEL is true before BSY goes false from arbitration,
|
|
|
|
* since this is the only way to guarantee that we'll get a MESSAGE OUT
|
|
|
|
* phase immediately after selection.
|
|
|
|
*/
|
|
|
|
|
|
|
|
NCR5380_write(INITIATOR_COMMAND_REG, (ICR_BASE | ICR_ASSERT_BSY |
|
|
|
|
ICR_ASSERT_DATA | ICR_ASSERT_ATN | ICR_ASSERT_SEL ));
|
2005-04-16 16:20:36 -06:00
|
|
|
NCR5380_write(MODE_REG, MR_BASE);
|
|
|
|
|
2007-05-01 14:32:36 -06:00
|
|
|
/*
|
|
|
|
* Reselect interrupts must be turned off prior to the dropping of BSY,
|
|
|
|
* otherwise we will trigger an interrupt.
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (hostdata->connected) {
|
|
|
|
NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
NCR5380_write(SELECT_ENABLE_REG, 0);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-05-01 14:32:36 -06:00
|
|
|
/*
|
|
|
|
* The initiator shall then wait at least two deskew delays and release
|
|
|
|
* the BSY signal.
|
|
|
|
*/
|
|
|
|
udelay(1); /* wingel -- wait two bus deskew delay >2*45ns */
|
|
|
|
|
|
|
|
/* Reset BSY */
|
|
|
|
NCR5380_write(INITIATOR_COMMAND_REG, (ICR_BASE | ICR_ASSERT_DATA |
|
|
|
|
ICR_ASSERT_ATN | ICR_ASSERT_SEL));
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Something weird happens when we cease to drive BSY - looks
|
|
|
|
* like the board/chip is letting us do another read before the
|
|
|
|
* appropriate propagation delay has expired, and we're confusing
|
|
|
|
* a BSY signal from ourselves as the target's response to SELECTION.
|
|
|
|
*
|
|
|
|
* A small delay (the 'C++' frontend breaks the pipeline with an
|
|
|
|
* unnecessary jump, making it work on my 386-33/Trantor T128, the
|
|
|
|
* tighter 'C' code breaks and requires this) solves the problem -
|
|
|
|
* the 1 us delay is arbitrary, and only used because this delay will
|
|
|
|
* be the same on other platforms and since it works here, it should
|
|
|
|
* work there.
|
|
|
|
*
|
|
|
|
* wingel suggests that this could be due to failing to wait
|
|
|
|
* one deskew delay.
|
|
|
|
*/
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-05-01 14:32:36 -06:00
|
|
|
udelay(1);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2014-03-17 18:42:20 -06:00
|
|
|
dprintk(NDEBUG_SELECTION, "scsi%d: selecting target %d\n", HOSTNO, cmd->device->id);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-05-01 14:32:36 -06:00
|
|
|
/*
|
|
|
|
* The SCSI specification calls for a 250 ms timeout for the actual
|
|
|
|
* selection.
|
|
|
|
*/
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2015-02-04 11:30:20 -07:00
|
|
|
timeout = jiffies + msecs_to_jiffies(250);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-05-01 14:32:36 -06:00
|
|
|
/*
|
|
|
|
* XXX very interesting - we're seeing a bounce where the BSY we
|
|
|
|
* asserted is being reflected / still asserted (propagation delay?)
|
|
|
|
* and it's detecting as true. Sigh.
|
|
|
|
*/
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
#if 0
|
2007-05-01 14:32:36 -06:00
|
|
|
/* ++roman: If a target conformed to the SCSI standard, it wouldn't assert
|
|
|
|
* IO while SEL is true. But again, there are some disks out the in the
|
|
|
|
* world that do that nevertheless. (Somebody claimed that this announces
|
|
|
|
* reselection capability of the target.) So we better skip that test and
|
|
|
|
* only wait for BSY... (Famous german words: Der Klügere gibt nach :-)
|
|
|
|
*/
|
|
|
|
|
|
|
|
while (time_before(jiffies, timeout) &&
|
|
|
|
!(NCR5380_read(STATUS_REG) & (SR_BSY | SR_IO)))
|
|
|
|
;
|
|
|
|
|
|
|
|
if ((NCR5380_read(STATUS_REG) & (SR_SEL | SR_IO)) == (SR_SEL | SR_IO)) {
|
|
|
|
NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
|
|
|
|
NCR5380_reselect(instance);
|
|
|
|
printk(KERN_ERR "scsi%d: reselection after won arbitration?\n",
|
|
|
|
HOSTNO);
|
|
|
|
NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
|
|
|
|
return -1;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
#else
|
2007-05-01 14:32:36 -06:00
|
|
|
while (time_before(jiffies, timeout) && !(NCR5380_read(STATUS_REG) & SR_BSY))
|
|
|
|
;
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
|
|
|
|
2007-05-01 14:32:36 -06:00
|
|
|
/*
|
|
|
|
* No less than two deskew delays after the initiator detects the
|
|
|
|
* BSY signal is true, it shall release the SEL signal and may
|
|
|
|
* change the DATA BUS. -wingel
|
|
|
|
*/
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-05-01 14:32:36 -06:00
|
|
|
udelay(1);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-05-01 14:32:36 -06:00
|
|
|
NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-05-01 14:32:36 -06:00
|
|
|
if (!(NCR5380_read(STATUS_REG) & SR_BSY)) {
|
|
|
|
NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
|
|
|
|
if (hostdata->targets_present & (1 << cmd->device->id)) {
|
|
|
|
printk(KERN_ERR "scsi%d: weirdness\n", HOSTNO);
|
|
|
|
if (hostdata->restart_select)
|
|
|
|
printk(KERN_NOTICE "\trestart select\n");
|
2014-03-17 18:42:19 -06:00
|
|
|
NCR5380_dprint(NDEBUG_ANY, instance);
|
2007-05-01 14:32:36 -06:00
|
|
|
NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
cmd->result = DID_BAD_TARGET << 16;
|
2005-04-16 16:20:36 -06:00
|
|
|
#ifdef SUPPORT_TAGS
|
2007-05-01 14:32:36 -06:00
|
|
|
cmd_free_tag(cmd);
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
2007-05-01 14:32:36 -06:00
|
|
|
cmd->scsi_done(cmd);
|
|
|
|
NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
|
2014-03-17 18:42:20 -06:00
|
|
|
dprintk(NDEBUG_SELECTION, "scsi%d: target did not respond within 250ms\n", HOSTNO);
|
2007-05-01 14:32:36 -06:00
|
|
|
NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
hostdata->targets_present |= (1 << cmd->device->id);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Since we followed the SCSI spec, and raised ATN while SEL
|
|
|
|
* was true but before BSY was false during selection, the information
|
|
|
|
* transfer phase should be a MESSAGE OUT phase so that we can send the
|
|
|
|
* IDENTIFY message.
|
|
|
|
*
|
|
|
|
* If SCSI-II tagged queuing is enabled, we also send a SIMPLE_QUEUE_TAG
|
|
|
|
* message (2 bytes) with a tag ID that we increment with every command
|
|
|
|
* until it wraps back to 0.
|
|
|
|
*
|
|
|
|
* XXX - it turns out that there are some broken SCSI-II devices,
|
|
|
|
* which claim to support tagged queuing but fail when more than
|
|
|
|
* some number of commands are issued at once.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* Wait for start of REQ/ACK handshake */
|
|
|
|
while (!(NCR5380_read(STATUS_REG) & SR_REQ))
|
|
|
|
;
|
|
|
|
|
2014-03-17 18:42:20 -06:00
|
|
|
dprintk(NDEBUG_SELECTION, "scsi%d: target %d selected, going into MESSAGE OUT phase.\n",
|
2007-05-01 14:32:36 -06:00
|
|
|
HOSTNO, cmd->device->id);
|
|
|
|
tmp[0] = IDENTIFY(1, cmd->device->lun);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
#ifdef SUPPORT_TAGS
|
2007-05-01 14:32:36 -06:00
|
|
|
if (cmd->tag != TAG_NONE) {
|
|
|
|
tmp[1] = hostdata->last_message = SIMPLE_QUEUE_TAG;
|
|
|
|
tmp[2] = cmd->tag;
|
|
|
|
len = 3;
|
|
|
|
} else
|
|
|
|
len = 1;
|
2005-04-16 16:20:36 -06:00
|
|
|
#else
|
2007-05-01 14:32:36 -06:00
|
|
|
len = 1;
|
|
|
|
cmd->tag = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif /* SUPPORT_TAGS */
|
|
|
|
|
2007-05-01 14:32:36 -06:00
|
|
|
/* Send message(s) */
|
|
|
|
data = tmp;
|
|
|
|
phase = PHASE_MSGOUT;
|
|
|
|
NCR5380_transfer_pio(instance, &phase, &len, &data);
|
2014-03-17 18:42:20 -06:00
|
|
|
dprintk(NDEBUG_SELECTION, "scsi%d: nexus established.\n", HOSTNO);
|
2007-05-01 14:32:36 -06:00
|
|
|
/* XXX need to handle errors here */
|
|
|
|
hostdata->connected = cmd;
|
2005-04-16 16:20:36 -06:00
|
|
|
#ifndef SUPPORT_TAGS
|
2007-05-01 14:32:36 -06:00
|
|
|
hostdata->busy[cmd->device->id] |= (1 << cmd->device->lun);
|
|
|
|
#endif
|
2014-11-11 22:12:16 -07:00
|
|
|
#ifdef SUN3_SCSI_VME
|
|
|
|
dregs->csr |= CSR_INTR;
|
|
|
|
#endif
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-05-01 14:32:36 -06:00
|
|
|
initialize_SCp(cmd);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-05-01 14:32:36 -06:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2007-05-01 14:32:36 -06:00
|
|
|
/*
|
|
|
|
* Function : int NCR5380_transfer_pio (struct Scsi_Host *instance,
|
2005-04-16 16:20:36 -06:00
|
|
|
* unsigned char *phase, int *count, unsigned char **data)
|
|
|
|
*
|
|
|
|
* Purpose : transfers data in given phase using polled I/O
|
|
|
|
*
|
2007-05-01 14:32:36 -06:00
|
|
|
* Inputs : instance - instance of driver, *phase - pointer to
|
|
|
|
* what phase is expected, *count - pointer to number of
|
2005-04-16 16:20:36 -06:00
|
|
|
* bytes to transfer, **data - pointer to data pointer.
|
2007-05-01 14:32:36 -06:00
|
|
|
*
|
2005-04-16 16:20:36 -06:00
|
|
|
* Returns : -1 when different phase is entered without transferring
|
2011-03-30 19:57:33 -06:00
|
|
|
* maximum number of bytes, 0 if all bytes are transferred or exit
|
2005-04-16 16:20:36 -06:00
|
|
|
* is in same phase.
|
|
|
|
*
|
2007-05-01 14:32:36 -06:00
|
|
|
* Also, *phase, *count, *data are modified in place.
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* XXX Note : handling for bus free may be useful.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
2007-05-01 14:32:36 -06:00
|
|
|
* Note : this code is not as quick as it could be, however it
|
2005-04-16 16:20:36 -06:00
|
|
|
* IS 100% reliable, and for the actual data transfer where speed
|
|
|
|
* counts, we will always do a pseudo DMA or DMA transfer.
|
|
|
|
*/
|
|
|
|
|
2007-05-01 14:32:36 -06:00
|
|
|
static int NCR5380_transfer_pio(struct Scsi_Host *instance,
|
|
|
|
unsigned char *phase, int *count,
|
|
|
|
unsigned char **data)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-05-01 14:32:36 -06:00
|
|
|
register unsigned char p = *phase, tmp;
|
|
|
|
register int c = *count;
|
|
|
|
register unsigned char *d = *data;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The NCR5380 chip will only drive the SCSI bus when the
|
|
|
|
* phase specified in the appropriate bits of the TARGET COMMAND
|
|
|
|
* REGISTER match the STATUS REGISTER
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
|
2007-05-01 14:32:36 -06:00
|
|
|
NCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(p));
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-05-01 14:32:36 -06:00
|
|
|
do {
|
|
|
|
/*
|
|
|
|
* Wait for assertion of REQ, after which the phase bits will be
|
|
|
|
* valid
|
|
|
|
*/
|
|
|
|
while (!((tmp = NCR5380_read(STATUS_REG)) & SR_REQ))
|
|
|
|
;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2014-03-17 18:42:20 -06:00
|
|
|
dprintk(NDEBUG_HANDSHAKE, "scsi%d: REQ detected\n", HOSTNO);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-05-01 14:32:36 -06:00
|
|
|
/* Check for phase mismatch */
|
|
|
|
if ((tmp & PHASE_MASK) != p) {
|
2014-03-17 18:42:20 -06:00
|
|
|
dprintk(NDEBUG_PIO, "scsi%d: phase mismatch\n", HOSTNO);
|
2014-03-17 18:42:19 -06:00
|
|
|
NCR5380_dprint_phase(NDEBUG_PIO, instance);
|
2007-05-01 14:32:36 -06:00
|
|
|
break;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-05-01 14:32:36 -06:00
|
|
|
/* Do actual transfer from SCSI bus to / from memory */
|
|
|
|
if (!(p & SR_IO))
|
|
|
|
NCR5380_write(OUTPUT_DATA_REG, *d);
|
|
|
|
else
|
|
|
|
*d = NCR5380_read(CURRENT_SCSI_DATA_REG);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-05-01 14:32:36 -06:00
|
|
|
++d;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-05-01 14:32:36 -06:00
|
|
|
/*
|
|
|
|
* The SCSI standard suggests that in MSGOUT phase, the initiator
|
|
|
|
* should drop ATN on the last byte of the message phase
|
|
|
|
* after REQ has been asserted for the handshake but before
|
|
|
|
* the initiator raises ACK.
|
|
|
|
*/
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-05-01 14:32:36 -06:00
|
|
|
if (!(p & SR_IO)) {
|
|
|
|
if (!((p & SR_MSG) && c > 1)) {
|
|
|
|
NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_DATA);
|
2014-03-17 18:42:19 -06:00
|
|
|
NCR5380_dprint(NDEBUG_PIO, instance);
|
2007-05-01 14:32:36 -06:00
|
|
|
NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE |
|
|
|
|
ICR_ASSERT_DATA | ICR_ASSERT_ACK);
|
|
|
|
} else {
|
|
|
|
NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE |
|
|
|
|
ICR_ASSERT_DATA | ICR_ASSERT_ATN);
|
2014-03-17 18:42:19 -06:00
|
|
|
NCR5380_dprint(NDEBUG_PIO, instance);
|
2007-05-01 14:32:36 -06:00
|
|
|
NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE |
|
|
|
|
ICR_ASSERT_DATA | ICR_ASSERT_ATN | ICR_ASSERT_ACK);
|
|
|
|
}
|
|
|
|
} else {
|
2014-03-17 18:42:19 -06:00
|
|
|
NCR5380_dprint(NDEBUG_PIO, instance);
|
2007-05-01 14:32:36 -06:00
|
|
|
NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ACK);
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-05-01 14:32:36 -06:00
|
|
|
while (NCR5380_read(STATUS_REG) & SR_REQ)
|
|
|
|
;
|
|
|
|
|
2014-03-17 18:42:20 -06:00
|
|
|
dprintk(NDEBUG_HANDSHAKE, "scsi%d: req false, handshake complete\n", HOSTNO);
|
2007-05-01 14:32:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* We have several special cases to consider during REQ/ACK handshaking :
|
|
|
|
* 1. We were in MSGOUT phase, and we are on the last byte of the
|
|
|
|
* message. ATN must be dropped as ACK is dropped.
|
|
|
|
*
|
|
|
|
* 2. We are in a MSGIN phase, and we are on the last byte of the
|
|
|
|
* message. We must exit with ACK asserted, so that the calling
|
|
|
|
* code may raise ATN before dropping ACK to reject the message.
|
|
|
|
*
|
|
|
|
* 3. ACK and ATN are clear and the target may proceed as normal.
|
|
|
|
*/
|
|
|
|
if (!(p == PHASE_MSGIN && c == 1)) {
|
|
|
|
if (p == PHASE_MSGOUT && c > 1)
|
|
|
|
NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN);
|
|
|
|
else
|
|
|
|
NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
|
|
|
|
}
|
|
|
|
} while (--c);
|
|
|
|
|
2014-03-17 18:42:20 -06:00
|
|
|
dprintk(NDEBUG_PIO, "scsi%d: residual %d\n", HOSTNO, c);
|
2007-05-01 14:32:36 -06:00
|
|
|
|
|
|
|
*count = c;
|
|
|
|
*data = d;
|
|
|
|
tmp = NCR5380_read(STATUS_REG);
|
|
|
|
/* The phase read from the bus is valid if either REQ is (already)
|
|
|
|
* asserted or if ACK hasn't been released yet. The latter is the case if
|
|
|
|
* we're in MSGIN and all wanted bytes have been received.
|
|
|
|
*/
|
|
|
|
if ((tmp & SR_REQ) || (p == PHASE_MSGIN && c == 0))
|
|
|
|
*phase = tmp & PHASE_MASK;
|
|
|
|
else
|
|
|
|
*phase = PHASE_UNKNOWN;
|
|
|
|
|
|
|
|
if (!c || (*phase == p))
|
|
|
|
return 0;
|
|
|
|
else
|
|
|
|
return -1;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Function : do_abort (Scsi_Host *host)
|
2007-05-01 14:32:36 -06:00
|
|
|
*
|
|
|
|
* Purpose : abort the currently established nexus. Should only be
|
|
|
|
* called from a routine which can drop into a
|
|
|
|
*
|
2005-04-16 16:20:36 -06:00
|
|
|
* Returns : 0 on success, -1 on failure.
|
|
|
|
*/
|
|
|
|
|
2014-11-11 22:12:21 -07:00
|
|
|
static int do_abort(struct Scsi_Host *instance)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-05-01 14:32:36 -06:00
|
|
|
unsigned char tmp, *msgptr, phase;
|
|
|
|
int len;
|
|
|
|
|
|
|
|
/* Request message out phase */
|
2005-04-16 16:20:36 -06:00
|
|
|
NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN);
|
2007-05-01 14:32:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Wait for the target to indicate a valid phase by asserting
|
|
|
|
* REQ. Once this happens, we'll have either a MSGOUT phase
|
|
|
|
* and can immediately send the ABORT message, or we'll have some
|
|
|
|
* other phase and will have to source/sink data.
|
|
|
|
*
|
|
|
|
* We really don't care what value was on the bus or what value
|
|
|
|
* the target sees, so we just handshake.
|
|
|
|
*/
|
|
|
|
|
2007-11-15 13:13:46 -07:00
|
|
|
while (!((tmp = NCR5380_read(STATUS_REG)) & SR_REQ))
|
2007-05-01 14:32:36 -06:00
|
|
|
;
|
|
|
|
|
|
|
|
NCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(tmp));
|
|
|
|
|
|
|
|
if ((tmp & PHASE_MASK) != PHASE_MSGOUT) {
|
|
|
|
NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN |
|
|
|
|
ICR_ASSERT_ACK);
|
|
|
|
while (NCR5380_read(STATUS_REG) & SR_REQ)
|
|
|
|
;
|
|
|
|
NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN);
|
|
|
|
}
|
|
|
|
|
|
|
|
tmp = ABORT;
|
|
|
|
msgptr = &tmp;
|
|
|
|
len = 1;
|
|
|
|
phase = PHASE_MSGOUT;
|
2014-11-11 22:12:21 -07:00
|
|
|
NCR5380_transfer_pio(instance, &phase, &len, &msgptr);
|
2007-05-01 14:32:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If we got here, and the command completed successfully,
|
|
|
|
* we're about to go into bus free state.
|
|
|
|
*/
|
|
|
|
|
|
|
|
return len ? -1 : 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
#if defined(REAL_DMA)
|
2007-05-01 14:32:36 -06:00
|
|
|
/*
|
|
|
|
* Function : int NCR5380_transfer_dma (struct Scsi_Host *instance,
|
2005-04-16 16:20:36 -06:00
|
|
|
* unsigned char *phase, int *count, unsigned char **data)
|
|
|
|
*
|
|
|
|
* Purpose : transfers data in given phase using either real
|
|
|
|
* or pseudo DMA.
|
|
|
|
*
|
2007-05-01 14:32:36 -06:00
|
|
|
* Inputs : instance - instance of driver, *phase - pointer to
|
|
|
|
* what phase is expected, *count - pointer to number of
|
2005-04-16 16:20:36 -06:00
|
|
|
* bytes to transfer, **data - pointer to data pointer.
|
2007-05-01 14:32:36 -06:00
|
|
|
*
|
2005-04-16 16:20:36 -06:00
|
|
|
* Returns : -1 when different phase is entered without transferring
|
2011-03-30 19:57:33 -06:00
|
|
|
* maximum number of bytes, 0 if all bytes or transferred or exit
|
2005-04-16 16:20:36 -06:00
|
|
|
* is in same phase.
|
|
|
|
*
|
2007-05-01 14:32:36 -06:00
|
|
|
* Also, *phase, *count, *data are modified in place.
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
2007-05-01 14:32:36 -06:00
|
|
|
static int NCR5380_transfer_dma(struct Scsi_Host *instance,
|
|
|
|
unsigned char *phase, int *count,
|
|
|
|
unsigned char **data)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-05-01 14:32:36 -06:00
|
|
|
SETUP_HOSTDATA(instance);
|
|
|
|
register int c = *count;
|
|
|
|
register unsigned char p = *phase;
|
2014-11-11 22:12:16 -07:00
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
#if defined(CONFIG_SUN3)
|
|
|
|
/* sanity check */
|
|
|
|
if (!sun3_dma_setup_done) {
|
|
|
|
pr_err("scsi%d: transfer_dma without setup!\n",
|
|
|
|
instance->host_no);
|
|
|
|
BUG();
|
|
|
|
}
|
|
|
|
hostdata->dma_len = c;
|
|
|
|
|
|
|
|
dprintk(NDEBUG_DMA, "scsi%d: initializing DMA for %s, %d bytes %s %p\n",
|
|
|
|
instance->host_no, (p & SR_IO) ? "reading" : "writing",
|
|
|
|
c, (p & SR_IO) ? "to" : "from", *data);
|
|
|
|
|
|
|
|
/* netbsd turns off ints here, why not be safe and do it too */
|
|
|
|
local_irq_save(flags);
|
|
|
|
|
|
|
|
/* send start chain */
|
|
|
|
sun3scsi_dma_start(c, *data);
|
|
|
|
|
|
|
|
if (p & SR_IO) {
|
|
|
|
NCR5380_write(TARGET_COMMAND_REG, 1);
|
|
|
|
NCR5380_read(RESET_PARITY_INTERRUPT_REG);
|
|
|
|
NCR5380_write(INITIATOR_COMMAND_REG, 0);
|
|
|
|
NCR5380_write(MODE_REG,
|
|
|
|
(NCR5380_read(MODE_REG) | MR_DMA_MODE | MR_ENABLE_EOP_INTR));
|
|
|
|
NCR5380_write(START_DMA_INITIATOR_RECEIVE_REG, 0);
|
|
|
|
} else {
|
|
|
|
NCR5380_write(TARGET_COMMAND_REG, 0);
|
|
|
|
NCR5380_read(RESET_PARITY_INTERRUPT_REG);
|
|
|
|
NCR5380_write(INITIATOR_COMMAND_REG, ICR_ASSERT_DATA);
|
|
|
|
NCR5380_write(MODE_REG,
|
|
|
|
(NCR5380_read(MODE_REG) | MR_DMA_MODE | MR_ENABLE_EOP_INTR));
|
|
|
|
NCR5380_write(START_DMA_SEND_REG, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef SUN3_SCSI_VME
|
|
|
|
dregs->csr |= CSR_DMA_ENABLE;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
local_irq_restore(flags);
|
|
|
|
|
|
|
|
sun3_dma_active = 1;
|
|
|
|
|
|
|
|
#else /* !defined(CONFIG_SUN3) */
|
2007-05-01 14:32:36 -06:00
|
|
|
register unsigned char *d = *data;
|
|
|
|
unsigned char tmp;
|
|
|
|
|
|
|
|
if ((tmp = (NCR5380_read(STATUS_REG) & PHASE_MASK)) != p) {
|
|
|
|
*phase = tmp;
|
|
|
|
return -1;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2014-11-11 22:12:14 -07:00
|
|
|
if (hostdata->read_overruns && (p & SR_IO))
|
|
|
|
c -= hostdata->read_overruns;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2014-03-17 18:42:20 -06:00
|
|
|
dprintk(NDEBUG_DMA, "scsi%d: initializing DMA for %s, %d bytes %s %p\n",
|
2007-05-01 14:32:36 -06:00
|
|
|
HOSTNO, (p & SR_IO) ? "reading" : "writing",
|
|
|
|
c, (p & SR_IO) ? "to" : "from", d);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-05-01 14:32:36 -06:00
|
|
|
NCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(p));
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
#ifdef REAL_DMA
|
2007-05-01 14:32:36 -06:00
|
|
|
NCR5380_write(MODE_REG, MR_BASE | MR_DMA_MODE | MR_ENABLE_EOP_INTR | MR_MONITOR_BSY);
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif /* def REAL_DMA */
|
|
|
|
|
2014-11-11 22:12:14 -07:00
|
|
|
if (!(hostdata->flags & FLAG_LATE_DMA_SETUP)) {
|
2007-05-01 14:32:36 -06:00
|
|
|
/* On the Medusa, it is a must to initialize the DMA before
|
|
|
|
* starting the NCR. This is also the cleaner way for the TT.
|
|
|
|
*/
|
|
|
|
local_irq_save(flags);
|
|
|
|
hostdata->dma_len = (p & SR_IO) ?
|
|
|
|
NCR5380_dma_read_setup(instance, d, c) :
|
|
|
|
NCR5380_dma_write_setup(instance, d, c);
|
|
|
|
local_irq_restore(flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (p & SR_IO)
|
|
|
|
NCR5380_write(START_DMA_INITIATOR_RECEIVE_REG, 0);
|
|
|
|
else {
|
|
|
|
NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_DATA);
|
|
|
|
NCR5380_write(START_DMA_SEND_REG, 0);
|
|
|
|
}
|
|
|
|
|
2014-11-11 22:12:14 -07:00
|
|
|
if (hostdata->flags & FLAG_LATE_DMA_SETUP) {
|
2007-05-01 14:32:36 -06:00
|
|
|
/* On the Falcon, the DMA setup must be done after the last */
|
|
|
|
/* NCR access, else the DMA setup gets trashed!
|
|
|
|
*/
|
|
|
|
local_irq_save(flags);
|
|
|
|
hostdata->dma_len = (p & SR_IO) ?
|
|
|
|
NCR5380_dma_read_setup(instance, d, c) :
|
|
|
|
NCR5380_dma_write_setup(instance, d, c);
|
|
|
|
local_irq_restore(flags);
|
|
|
|
}
|
2014-11-11 22:12:16 -07:00
|
|
|
#endif /* !defined(CONFIG_SUN3) */
|
|
|
|
|
2007-05-01 14:32:36 -06:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
#endif /* defined(REAL_DMA) */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Function : NCR5380_information_transfer (struct Scsi_Host *instance)
|
|
|
|
*
|
2007-05-01 14:32:36 -06:00
|
|
|
* Purpose : run through the various SCSI phases and do as the target
|
|
|
|
* directs us to. Operates on the currently connected command,
|
2005-04-16 16:20:36 -06:00
|
|
|
* instance->connected.
|
|
|
|
*
|
|
|
|
* Inputs : instance, instance for which we are doing commands
|
|
|
|
*
|
2007-05-01 14:32:36 -06:00
|
|
|
* Side effects : SCSI things happen, the disconnected queue will be
|
2005-04-16 16:20:36 -06:00
|
|
|
* modified if a command disconnects, *instance->connected will
|
|
|
|
* change.
|
|
|
|
*
|
2007-05-01 14:32:36 -06:00
|
|
|
* XXX Note : we need to watch for bus free or a reset condition here
|
|
|
|
* to recover from an unexpected bus free condition.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2007-05-01 14:32:36 -06:00
|
|
|
|
|
|
|
static void NCR5380_information_transfer(struct Scsi_Host *instance)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-05-01 14:32:36 -06:00
|
|
|
SETUP_HOSTDATA(instance);
|
|
|
|
unsigned long flags;
|
|
|
|
unsigned char msgout = NOP;
|
|
|
|
int sink = 0;
|
|
|
|
int len;
|
2005-04-16 16:20:36 -06:00
|
|
|
#if defined(REAL_DMA)
|
2007-05-01 14:32:36 -06:00
|
|
|
int transfersize;
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
2007-05-01 14:32:36 -06:00
|
|
|
unsigned char *data;
|
|
|
|
unsigned char phase, tmp, extended_msg[10], old_phase = 0xff;
|
2014-11-11 22:12:02 -07:00
|
|
|
struct scsi_cmnd *cmd = (struct scsi_cmnd *) hostdata->connected;
|
2007-05-01 14:32:36 -06:00
|
|
|
|
2014-11-11 22:12:16 -07:00
|
|
|
#ifdef SUN3_SCSI_VME
|
|
|
|
dregs->csr |= CSR_INTR;
|
|
|
|
#endif
|
|
|
|
|
2007-05-01 14:32:36 -06:00
|
|
|
while (1) {
|
|
|
|
tmp = NCR5380_read(STATUS_REG);
|
|
|
|
/* We only have a valid SCSI phase when REQ is asserted */
|
|
|
|
if (tmp & SR_REQ) {
|
|
|
|
phase = (tmp & PHASE_MASK);
|
|
|
|
if (phase != old_phase) {
|
|
|
|
old_phase = phase;
|
2014-03-17 18:42:19 -06:00
|
|
|
NCR5380_dprint_phase(NDEBUG_INFORMATION, instance);
|
2007-05-01 14:32:36 -06:00
|
|
|
}
|
2014-11-11 22:12:16 -07:00
|
|
|
#if defined(CONFIG_SUN3)
|
|
|
|
if (phase == PHASE_CMDOUT) {
|
|
|
|
#if defined(REAL_DMA)
|
|
|
|
void *d;
|
|
|
|
unsigned long count;
|
|
|
|
|
|
|
|
if (!cmd->SCp.this_residual && cmd->SCp.buffers_residual) {
|
|
|
|
count = cmd->SCp.buffer->length;
|
|
|
|
d = sg_virt(cmd->SCp.buffer);
|
|
|
|
} else {
|
|
|
|
count = cmd->SCp.this_residual;
|
|
|
|
d = cmd->SCp.ptr;
|
|
|
|
}
|
|
|
|
/* this command setup for dma yet? */
|
|
|
|
if ((count >= DMA_MIN_SIZE) && (sun3_dma_setup_done != cmd)) {
|
|
|
|
if (cmd->request->cmd_type == REQ_TYPE_FS) {
|
|
|
|
sun3scsi_dma_setup(d, count,
|
|
|
|
rq_data_dir(cmd->request));
|
|
|
|
sun3_dma_setup_done = cmd;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
#ifdef SUN3_SCSI_VME
|
|
|
|
dregs->csr |= CSR_INTR;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_SUN3 */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-05-01 14:32:36 -06:00
|
|
|
if (sink && (phase != PHASE_MSGOUT)) {
|
|
|
|
NCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(tmp));
|
|
|
|
|
|
|
|
NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN |
|
|
|
|
ICR_ASSERT_ACK);
|
|
|
|
while (NCR5380_read(STATUS_REG) & SR_REQ)
|
|
|
|
;
|
|
|
|
NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE |
|
|
|
|
ICR_ASSERT_ATN);
|
|
|
|
sink = 0;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (phase) {
|
|
|
|
case PHASE_DATAOUT:
|
2005-04-16 16:20:36 -06:00
|
|
|
#if (NDEBUG & NDEBUG_NO_DATAOUT)
|
2007-05-01 14:32:36 -06:00
|
|
|
printk("scsi%d: NDEBUG_NO_DATAOUT set, attempted DATAOUT "
|
|
|
|
"aborted\n", HOSTNO);
|
|
|
|
sink = 1;
|
|
|
|
do_abort(instance);
|
|
|
|
cmd->result = DID_ERROR << 16;
|
2007-09-25 10:42:01 -06:00
|
|
|
cmd->scsi_done(cmd);
|
2007-05-01 14:32:36 -06:00
|
|
|
return;
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
2007-05-01 14:32:36 -06:00
|
|
|
case PHASE_DATAIN:
|
|
|
|
/*
|
|
|
|
* If there is no room left in the current buffer in the
|
|
|
|
* scatter-gather list, move onto the next one.
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (!cmd->SCp.this_residual && cmd->SCp.buffers_residual) {
|
|
|
|
++cmd->SCp.buffer;
|
|
|
|
--cmd->SCp.buffers_residual;
|
|
|
|
cmd->SCp.this_residual = cmd->SCp.buffer->length;
|
2007-10-22 13:19:53 -06:00
|
|
|
cmd->SCp.ptr = sg_virt(cmd->SCp.buffer);
|
2007-05-01 14:32:36 -06:00
|
|
|
/* ++roman: Try to merge some scatter-buffers if
|
|
|
|
* they are at contiguous physical addresses.
|
|
|
|
*/
|
|
|
|
merge_contiguous_buffers(cmd);
|
2014-03-17 18:42:20 -06:00
|
|
|
dprintk(NDEBUG_INFORMATION, "scsi%d: %d bytes and %d buffers left\n",
|
2007-05-01 14:32:36 -06:00
|
|
|
HOSTNO, cmd->SCp.this_residual,
|
|
|
|
cmd->SCp.buffers_residual);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The preferred transfer method is going to be
|
|
|
|
* PSEUDO-DMA for systems that are strictly PIO,
|
|
|
|
* since we can let the hardware do the handshaking.
|
|
|
|
*
|
|
|
|
* For this to work, we need to know the transfersize
|
|
|
|
* ahead of time, since the pseudo-DMA code will sit
|
|
|
|
* in an unconditional loop.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* ++roman: I suggest, this should be
|
|
|
|
* #if def(REAL_DMA)
|
|
|
|
* instead of leaving REAL_DMA out.
|
|
|
|
*/
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
#if defined(REAL_DMA)
|
2014-11-11 22:12:16 -07:00
|
|
|
if (
|
|
|
|
#if !defined(CONFIG_SUN3)
|
|
|
|
!cmd->device->borken &&
|
|
|
|
#endif
|
|
|
|
(transfersize = NCR5380_dma_xfer_len(instance, cmd, phase)) >= DMA_MIN_SIZE) {
|
2007-05-01 14:32:36 -06:00
|
|
|
len = transfersize;
|
|
|
|
cmd->SCp.phase = phase;
|
|
|
|
if (NCR5380_transfer_dma(instance, &phase,
|
|
|
|
&len, (unsigned char **)&cmd->SCp.ptr)) {
|
|
|
|
/*
|
|
|
|
* If the watchdog timer fires, all future
|
|
|
|
* accesses to this device will use the
|
|
|
|
* polled-IO. */
|
2014-11-11 22:12:18 -07:00
|
|
|
scmd_printk(KERN_INFO, cmd,
|
|
|
|
"switching to slow handshake\n");
|
2007-05-01 14:32:36 -06:00
|
|
|
cmd->device->borken = 1;
|
|
|
|
NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE |
|
|
|
|
ICR_ASSERT_ATN);
|
|
|
|
sink = 1;
|
|
|
|
do_abort(instance);
|
|
|
|
cmd->result = DID_ERROR << 16;
|
2007-09-25 10:42:01 -06:00
|
|
|
cmd->scsi_done(cmd);
|
2007-05-01 14:32:36 -06:00
|
|
|
/* XXX - need to source or sink data here, as appropriate */
|
|
|
|
} else {
|
2005-04-16 16:20:36 -06:00
|
|
|
#ifdef REAL_DMA
|
2007-05-01 14:32:36 -06:00
|
|
|
/* ++roman: When using real DMA,
|
|
|
|
* information_transfer() should return after
|
|
|
|
* starting DMA since it has nothing more to
|
|
|
|
* do.
|
|
|
|
*/
|
|
|
|
return;
|
|
|
|
#else
|
|
|
|
cmd->SCp.this_residual -= transfersize - len;
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
2007-05-01 14:32:36 -06:00
|
|
|
}
|
|
|
|
} else
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif /* defined(REAL_DMA) */
|
2007-05-01 14:32:36 -06:00
|
|
|
NCR5380_transfer_pio(instance, &phase,
|
|
|
|
(int *)&cmd->SCp.this_residual,
|
|
|
|
(unsigned char **)&cmd->SCp.ptr);
|
2014-11-11 22:12:16 -07:00
|
|
|
#if defined(CONFIG_SUN3) && defined(REAL_DMA)
|
|
|
|
/* if we had intended to dma that command clear it */
|
|
|
|
if (sun3_dma_setup_done == cmd)
|
|
|
|
sun3_dma_setup_done = NULL;
|
|
|
|
#endif
|
2007-05-01 14:32:36 -06:00
|
|
|
break;
|
|
|
|
case PHASE_MSGIN:
|
|
|
|
len = 1;
|
|
|
|
data = &tmp;
|
|
|
|
NCR5380_write(SELECT_ENABLE_REG, 0); /* disable reselects */
|
|
|
|
NCR5380_transfer_pio(instance, &phase, &len, &data);
|
|
|
|
cmd->SCp.Message = tmp;
|
|
|
|
|
|
|
|
switch (tmp) {
|
|
|
|
/*
|
|
|
|
* Linking lets us reduce the time required to get the
|
|
|
|
* next command out to the device, hopefully this will
|
|
|
|
* mean we don't waste another revolution due to the delays
|
|
|
|
* required by ARBITRATION and another SELECTION.
|
|
|
|
*
|
|
|
|
* In the current implementation proposal, low level drivers
|
|
|
|
* merely have to start the next command, pointed to by
|
|
|
|
* next_link, done() is called as with unlinked commands.
|
|
|
|
*/
|
2005-04-16 16:20:36 -06:00
|
|
|
#ifdef LINKED
|
2007-05-01 14:32:36 -06:00
|
|
|
case LINKED_CMD_COMPLETE:
|
|
|
|
case LINKED_FLG_CMD_COMPLETE:
|
|
|
|
/* Accept message by clearing ACK */
|
|
|
|
NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
|
|
|
|
|
2014-06-25 07:27:36 -06:00
|
|
|
dprintk(NDEBUG_LINKED, "scsi%d: target %d lun %llu linked command "
|
2007-05-01 14:32:36 -06:00
|
|
|
"complete.\n", HOSTNO, cmd->device->id, cmd->device->lun);
|
|
|
|
|
|
|
|
/* Enable reselect interrupts */
|
|
|
|
NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
|
|
|
|
/*
|
|
|
|
* Sanity check : A linked command should only terminate
|
|
|
|
* with one of these messages if there are more linked
|
|
|
|
* commands available.
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (!cmd->next_link) {
|
2014-06-25 07:27:36 -06:00
|
|
|
printk(KERN_NOTICE "scsi%d: target %d lun %llu "
|
2007-05-01 14:32:36 -06:00
|
|
|
"linked command complete, no next_link\n",
|
|
|
|
HOSTNO, cmd->device->id, cmd->device->lun);
|
|
|
|
sink = 1;
|
|
|
|
do_abort(instance);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
initialize_SCp(cmd->next_link);
|
|
|
|
/* The next command is still part of this process; copy it
|
|
|
|
* and don't free it! */
|
|
|
|
cmd->next_link->tag = cmd->tag;
|
|
|
|
cmd->result = cmd->SCp.Status | (cmd->SCp.Message << 8);
|
2014-06-25 07:27:36 -06:00
|
|
|
dprintk(NDEBUG_LINKED, "scsi%d: target %d lun %llu linked request "
|
2007-05-01 14:32:36 -06:00
|
|
|
"done, calling scsi_done().\n",
|
|
|
|
HOSTNO, cmd->device->id, cmd->device->lun);
|
|
|
|
cmd->scsi_done(cmd);
|
|
|
|
cmd = hostdata->connected;
|
|
|
|
break;
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif /* def LINKED */
|
2007-05-01 14:32:36 -06:00
|
|
|
case ABORT:
|
|
|
|
case COMMAND_COMPLETE:
|
|
|
|
/* Accept message by clearing ACK */
|
|
|
|
NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
|
2014-06-25 07:27:36 -06:00
|
|
|
dprintk(NDEBUG_QUEUES, "scsi%d: command for target %d, lun %llu "
|
2007-05-01 14:32:36 -06:00
|
|
|
"completed\n", HOSTNO, cmd->device->id, cmd->device->lun);
|
2014-11-11 22:12:15 -07:00
|
|
|
|
|
|
|
local_irq_save(flags);
|
|
|
|
hostdata->retain_dma_intr++;
|
|
|
|
hostdata->connected = NULL;
|
2005-04-16 16:20:36 -06:00
|
|
|
#ifdef SUPPORT_TAGS
|
2007-05-01 14:32:36 -06:00
|
|
|
cmd_free_tag(cmd);
|
|
|
|
if (status_byte(cmd->SCp.Status) == QUEUE_FULL) {
|
|
|
|
/* Turn a QUEUE FULL status into BUSY, I think the
|
|
|
|
* mid level cannot handle QUEUE FULL :-( (The
|
|
|
|
* command is retried after BUSY). Also update our
|
|
|
|
* queue size to the number of currently issued
|
|
|
|
* commands now.
|
|
|
|
*/
|
|
|
|
/* ++Andreas: the mid level code knows about
|
|
|
|
QUEUE_FULL now. */
|
2014-11-11 22:12:20 -07:00
|
|
|
struct tag_alloc *ta = &hostdata->TagAlloc[scmd_id(cmd)][cmd->device->lun];
|
2014-06-25 07:27:36 -06:00
|
|
|
dprintk(NDEBUG_TAGS, "scsi%d: target %d lun %llu returned "
|
2007-05-01 14:32:36 -06:00
|
|
|
"QUEUE_FULL after %d commands\n",
|
|
|
|
HOSTNO, cmd->device->id, cmd->device->lun,
|
|
|
|
ta->nr_allocated);
|
|
|
|
if (ta->queue_size > ta->nr_allocated)
|
|
|
|
ta->nr_allocated = ta->queue_size;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
#else
|
2007-05-01 14:32:36 -06:00
|
|
|
hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun);
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
2007-05-01 14:32:36 -06:00
|
|
|
/* Enable reselect interrupts */
|
|
|
|
NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* I'm not sure what the correct thing to do here is :
|
|
|
|
*
|
|
|
|
* If the command that just executed is NOT a request
|
|
|
|
* sense, the obvious thing to do is to set the result
|
|
|
|
* code to the values of the stored parameters.
|
|
|
|
*
|
|
|
|
* If it was a REQUEST SENSE command, we need some way to
|
|
|
|
* differentiate between the failure code of the original
|
|
|
|
* and the failure code of the REQUEST sense - the obvious
|
|
|
|
* case is success, where we fall through and leave the
|
|
|
|
* result code unchanged.
|
|
|
|
*
|
|
|
|
* The non-obvious place is where the REQUEST SENSE failed
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (cmd->cmnd[0] != REQUEST_SENSE)
|
|
|
|
cmd->result = cmd->SCp.Status | (cmd->SCp.Message << 8);
|
|
|
|
else if (status_byte(cmd->SCp.Status) != GOOD)
|
|
|
|
cmd->result = (cmd->result & 0x00ffff) | (DID_ERROR << 16);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-09-10 13:37:45 -06:00
|
|
|
if ((cmd->cmnd[0] == REQUEST_SENSE) &&
|
|
|
|
hostdata->ses.cmd_len) {
|
|
|
|
scsi_eh_restore_cmnd(cmd, &hostdata->ses);
|
|
|
|
hostdata->ses.cmd_len = 0 ;
|
|
|
|
}
|
|
|
|
|
2007-05-01 14:32:36 -06:00
|
|
|
if ((cmd->cmnd[0] != REQUEST_SENSE) &&
|
|
|
|
(status_byte(cmd->SCp.Status) == CHECK_CONDITION)) {
|
2007-09-10 13:37:45 -06:00
|
|
|
scsi_eh_prep_cmnd(cmd, &hostdata->ses, NULL, 0, ~0);
|
|
|
|
|
2014-03-17 18:42:20 -06:00
|
|
|
dprintk(NDEBUG_AUTOSENSE, "scsi%d: performing request sense\n", HOSTNO);
|
2007-05-01 14:32:36 -06:00
|
|
|
|
|
|
|
LIST(cmd,hostdata->issue_queue);
|
2007-05-01 14:32:37 -06:00
|
|
|
SET_NEXT(cmd, hostdata->issue_queue);
|
2014-11-11 22:12:02 -07:00
|
|
|
hostdata->issue_queue = (struct scsi_cmnd *) cmd;
|
2014-03-17 18:42:20 -06:00
|
|
|
dprintk(NDEBUG_QUEUES, "scsi%d: REQUEST SENSE added to head of "
|
2007-05-01 14:32:36 -06:00
|
|
|
"issue queue\n", H_NO(cmd));
|
2014-11-11 22:11:54 -07:00
|
|
|
} else {
|
2007-05-01 14:32:36 -06:00
|
|
|
cmd->scsi_done(cmd);
|
|
|
|
}
|
|
|
|
|
2014-11-11 22:12:15 -07:00
|
|
|
local_irq_restore(flags);
|
|
|
|
|
2007-05-01 14:32:36 -06:00
|
|
|
NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
|
|
|
|
/*
|
|
|
|
* Restore phase bits to 0 so an interrupted selection,
|
|
|
|
* arbitration can resume.
|
|
|
|
*/
|
|
|
|
NCR5380_write(TARGET_COMMAND_REG, 0);
|
|
|
|
|
|
|
|
while ((NCR5380_read(STATUS_REG) & SR_BSY) && !hostdata->connected)
|
|
|
|
barrier();
|
|
|
|
|
2014-11-11 22:12:15 -07:00
|
|
|
local_irq_save(flags);
|
2014-11-11 22:12:14 -07:00
|
|
|
hostdata->retain_dma_intr--;
|
2007-05-01 14:32:36 -06:00
|
|
|
/* ++roman: For Falcon SCSI, release the lock on the
|
|
|
|
* ST-DMA here if no other commands are waiting on the
|
|
|
|
* disconnected queue.
|
|
|
|
*/
|
2014-11-11 22:12:15 -07:00
|
|
|
maybe_release_dma_irq(instance);
|
|
|
|
local_irq_restore(flags);
|
2007-05-01 14:32:36 -06:00
|
|
|
return;
|
|
|
|
case MESSAGE_REJECT:
|
|
|
|
/* Accept message by clearing ACK */
|
|
|
|
NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
|
|
|
|
/* Enable reselect interrupts */
|
|
|
|
NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
|
|
|
|
switch (hostdata->last_message) {
|
|
|
|
case HEAD_OF_QUEUE_TAG:
|
|
|
|
case ORDERED_QUEUE_TAG:
|
|
|
|
case SIMPLE_QUEUE_TAG:
|
|
|
|
/* The target obviously doesn't support tagged
|
|
|
|
* queuing, even though it announced this ability in
|
|
|
|
* its INQUIRY data ?!? (maybe only this LUN?) Ok,
|
|
|
|
* clear 'tagged_supported' and lock the LUN, since
|
|
|
|
* the command is treated as untagged further on.
|
|
|
|
*/
|
|
|
|
cmd->device->tagged_supported = 0;
|
|
|
|
hostdata->busy[cmd->device->id] |= (1 << cmd->device->lun);
|
|
|
|
cmd->tag = TAG_NONE;
|
2014-06-25 07:27:36 -06:00
|
|
|
dprintk(NDEBUG_TAGS, "scsi%d: target %d lun %llu rejected "
|
2007-05-01 14:32:36 -06:00
|
|
|
"QUEUE_TAG message; tagged queuing "
|
|
|
|
"disabled\n",
|
|
|
|
HOSTNO, cmd->device->id, cmd->device->lun);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case DISCONNECT:
|
|
|
|
/* Accept message by clearing ACK */
|
|
|
|
NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
|
|
|
|
local_irq_save(flags);
|
|
|
|
cmd->device->disconnect = 1;
|
|
|
|
LIST(cmd,hostdata->disconnected_queue);
|
2007-05-01 14:32:37 -06:00
|
|
|
SET_NEXT(cmd, hostdata->disconnected_queue);
|
2007-05-01 14:32:36 -06:00
|
|
|
hostdata->connected = NULL;
|
|
|
|
hostdata->disconnected_queue = cmd;
|
|
|
|
local_irq_restore(flags);
|
2014-06-25 07:27:36 -06:00
|
|
|
dprintk(NDEBUG_QUEUES, "scsi%d: command for target %d lun %llu was "
|
2007-05-01 14:32:36 -06:00
|
|
|
"moved from connected to the "
|
|
|
|
"disconnected_queue\n", HOSTNO,
|
|
|
|
cmd->device->id, cmd->device->lun);
|
|
|
|
/*
|
|
|
|
* Restore phase bits to 0 so an interrupted selection,
|
|
|
|
* arbitration can resume.
|
|
|
|
*/
|
|
|
|
NCR5380_write(TARGET_COMMAND_REG, 0);
|
|
|
|
|
|
|
|
/* Enable reselect interrupts */
|
|
|
|
NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
|
|
|
|
/* Wait for bus free to avoid nasty timeouts */
|
|
|
|
while ((NCR5380_read(STATUS_REG) & SR_BSY) && !hostdata->connected)
|
|
|
|
barrier();
|
2014-11-11 22:12:16 -07:00
|
|
|
#ifdef SUN3_SCSI_VME
|
|
|
|
dregs->csr |= CSR_DMA_ENABLE;
|
|
|
|
#endif
|
2007-05-01 14:32:36 -06:00
|
|
|
return;
|
|
|
|
/*
|
|
|
|
* The SCSI data pointer is *IMPLICITLY* saved on a disconnect
|
|
|
|
* operation, in violation of the SCSI spec so we can safely
|
|
|
|
* ignore SAVE/RESTORE pointers calls.
|
|
|
|
*
|
|
|
|
* Unfortunately, some disks violate the SCSI spec and
|
|
|
|
* don't issue the required SAVE_POINTERS message before
|
|
|
|
* disconnecting, and we have to break spec to remain
|
|
|
|
* compatible.
|
|
|
|
*/
|
|
|
|
case SAVE_POINTERS:
|
|
|
|
case RESTORE_POINTERS:
|
|
|
|
/* Accept message by clearing ACK */
|
|
|
|
NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
|
|
|
|
/* Enable reselect interrupts */
|
|
|
|
NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
|
|
|
|
break;
|
|
|
|
case EXTENDED_MESSAGE:
|
|
|
|
/*
|
|
|
|
* Extended messages are sent in the following format :
|
|
|
|
* Byte
|
|
|
|
* 0 EXTENDED_MESSAGE == 1
|
|
|
|
* 1 length (includes one byte for code, doesn't
|
|
|
|
* include first two bytes)
|
|
|
|
* 2 code
|
|
|
|
* 3..length+1 arguments
|
|
|
|
*
|
|
|
|
* Start the extended message buffer with the EXTENDED_MESSAGE
|
|
|
|
* byte, since spi_print_msg() wants the whole thing.
|
|
|
|
*/
|
|
|
|
extended_msg[0] = EXTENDED_MESSAGE;
|
|
|
|
/* Accept first byte by clearing ACK */
|
|
|
|
NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
|
|
|
|
|
2014-03-17 18:42:20 -06:00
|
|
|
dprintk(NDEBUG_EXTENDED, "scsi%d: receiving extended message\n", HOSTNO);
|
2007-05-01 14:32:36 -06:00
|
|
|
|
|
|
|
len = 2;
|
|
|
|
data = extended_msg + 1;
|
|
|
|
phase = PHASE_MSGIN;
|
|
|
|
NCR5380_transfer_pio(instance, &phase, &len, &data);
|
2014-03-17 18:42:20 -06:00
|
|
|
dprintk(NDEBUG_EXTENDED, "scsi%d: length=%d, code=0x%02x\n", HOSTNO,
|
2007-05-01 14:32:36 -06:00
|
|
|
(int)extended_msg[1], (int)extended_msg[2]);
|
|
|
|
|
|
|
|
if (!len && extended_msg[1] <=
|
|
|
|
(sizeof(extended_msg) - 1)) {
|
|
|
|
/* Accept third byte by clearing ACK */
|
|
|
|
NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
|
|
|
|
len = extended_msg[1] - 1;
|
|
|
|
data = extended_msg + 3;
|
|
|
|
phase = PHASE_MSGIN;
|
|
|
|
|
|
|
|
NCR5380_transfer_pio(instance, &phase, &len, &data);
|
2014-03-17 18:42:20 -06:00
|
|
|
dprintk(NDEBUG_EXTENDED, "scsi%d: message received, residual %d\n",
|
2007-05-01 14:32:36 -06:00
|
|
|
HOSTNO, len);
|
|
|
|
|
|
|
|
switch (extended_msg[2]) {
|
|
|
|
case EXTENDED_SDTR:
|
|
|
|
case EXTENDED_WDTR:
|
|
|
|
case EXTENDED_MODIFY_DATA_POINTER:
|
|
|
|
case EXTENDED_EXTENDED_IDENTIFY:
|
|
|
|
tmp = 0;
|
|
|
|
}
|
|
|
|
} else if (len) {
|
|
|
|
printk(KERN_NOTICE "scsi%d: error receiving "
|
|
|
|
"extended message\n", HOSTNO);
|
|
|
|
tmp = 0;
|
|
|
|
} else {
|
|
|
|
printk(KERN_NOTICE "scsi%d: extended message "
|
|
|
|
"code %02x length %d is too long\n",
|
|
|
|
HOSTNO, extended_msg[2], extended_msg[1]);
|
|
|
|
tmp = 0;
|
|
|
|
}
|
|
|
|
/* Fall through to reject message */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we get something weird that we aren't expecting,
|
|
|
|
* reject it.
|
|
|
|
*/
|
|
|
|
default:
|
|
|
|
if (!tmp) {
|
2014-11-11 22:12:18 -07:00
|
|
|
printk(KERN_INFO "scsi%d: rejecting message ",
|
|
|
|
instance->host_no);
|
2007-05-01 14:32:36 -06:00
|
|
|
spi_print_msg(extended_msg);
|
|
|
|
printk("\n");
|
|
|
|
} else if (tmp != EXTENDED_MESSAGE)
|
2014-11-11 22:12:18 -07:00
|
|
|
scmd_printk(KERN_INFO, cmd,
|
|
|
|
"rejecting unknown message %02x\n",
|
|
|
|
tmp);
|
2007-05-01 14:32:36 -06:00
|
|
|
else
|
2014-11-11 22:12:18 -07:00
|
|
|
scmd_printk(KERN_INFO, cmd,
|
|
|
|
"rejecting unknown extended message code %02x, length %d\n",
|
|
|
|
extended_msg[1], extended_msg[0]);
|
2007-05-01 14:32:36 -06:00
|
|
|
|
|
|
|
msgout = MESSAGE_REJECT;
|
|
|
|
NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN);
|
|
|
|
break;
|
|
|
|
} /* switch (tmp) */
|
|
|
|
break;
|
|
|
|
case PHASE_MSGOUT:
|
|
|
|
len = 1;
|
|
|
|
data = &msgout;
|
|
|
|
hostdata->last_message = msgout;
|
|
|
|
NCR5380_transfer_pio(instance, &phase, &len, &data);
|
|
|
|
if (msgout == ABORT) {
|
2014-11-11 22:12:15 -07:00
|
|
|
local_irq_save(flags);
|
2005-04-16 16:20:36 -06:00
|
|
|
#ifdef SUPPORT_TAGS
|
2007-05-01 14:32:36 -06:00
|
|
|
cmd_free_tag(cmd);
|
2005-04-16 16:20:36 -06:00
|
|
|
#else
|
2007-05-01 14:32:36 -06:00
|
|
|
hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun);
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
2007-05-01 14:32:36 -06:00
|
|
|
hostdata->connected = NULL;
|
|
|
|
cmd->result = DID_ERROR << 16;
|
|
|
|
NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
|
2014-11-11 22:12:15 -07:00
|
|
|
maybe_release_dma_irq(instance);
|
|
|
|
local_irq_restore(flags);
|
|
|
|
cmd->scsi_done(cmd);
|
2007-05-01 14:32:36 -06:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
msgout = NOP;
|
|
|
|
break;
|
|
|
|
case PHASE_CMDOUT:
|
|
|
|
len = cmd->cmd_len;
|
|
|
|
data = cmd->cmnd;
|
|
|
|
/*
|
|
|
|
* XXX for performance reasons, on machines with a
|
|
|
|
* PSEUDO-DMA architecture we should probably
|
|
|
|
* use the dma transfer function.
|
|
|
|
*/
|
|
|
|
NCR5380_transfer_pio(instance, &phase, &len, &data);
|
|
|
|
break;
|
|
|
|
case PHASE_STATIN:
|
|
|
|
len = 1;
|
|
|
|
data = &tmp;
|
|
|
|
NCR5380_transfer_pio(instance, &phase, &len, &data);
|
|
|
|
cmd->SCp.Status = tmp;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
printk("scsi%d: unknown phase\n", HOSTNO);
|
2014-03-17 18:42:19 -06:00
|
|
|
NCR5380_dprint(NDEBUG_ANY, instance);
|
2007-05-01 14:32:36 -06:00
|
|
|
} /* switch(phase) */
|
|
|
|
} /* if (tmp * SR_REQ) */
|
|
|
|
} /* while (1) */
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Function : void NCR5380_reselect (struct Scsi_Host *instance)
|
|
|
|
*
|
2007-05-01 14:32:36 -06:00
|
|
|
* Purpose : does reselection, initializing the instance->connected
|
2014-11-11 22:12:02 -07:00
|
|
|
* field to point to the scsi_cmnd for which the I_T_L or I_T_L_Q
|
2005-04-16 16:20:36 -06:00
|
|
|
* nexus has been reestablished,
|
2007-05-01 14:32:36 -06:00
|
|
|
*
|
2005-04-16 16:20:36 -06:00
|
|
|
* Inputs : instance - this instance of the NCR5380.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
2014-11-11 22:12:16 -07:00
|
|
|
/* it might eventually prove necessary to do a dma setup on
|
|
|
|
reselection, but it doesn't seem to be needed now -- sam */
|
|
|
|
|
2007-05-01 14:32:36 -06:00
|
|
|
static void NCR5380_reselect(struct Scsi_Host *instance)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-05-01 14:32:36 -06:00
|
|
|
SETUP_HOSTDATA(instance);
|
|
|
|
unsigned char target_mask;
|
2014-11-11 22:12:16 -07:00
|
|
|
unsigned char lun;
|
2005-04-16 16:20:36 -06:00
|
|
|
#ifdef SUPPORT_TAGS
|
2007-05-01 14:32:36 -06:00
|
|
|
unsigned char tag;
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
2007-05-01 14:32:36 -06:00
|
|
|
unsigned char msg[3];
|
2014-11-11 22:12:16 -07:00
|
|
|
int __maybe_unused len;
|
|
|
|
unsigned char __maybe_unused *data, __maybe_unused phase;
|
2014-11-11 22:12:02 -07:00
|
|
|
struct scsi_cmnd *tmp = NULL, *prev;
|
2007-05-01 14:32:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Disable arbitration, etc. since the host adapter obviously
|
|
|
|
* lost, and tell an interrupted NCR5380_select() to restart.
|
|
|
|
*/
|
|
|
|
|
|
|
|
NCR5380_write(MODE_REG, MR_BASE);
|
|
|
|
hostdata->restart_select = 1;
|
|
|
|
|
|
|
|
target_mask = NCR5380_read(CURRENT_SCSI_DATA_REG) & ~(hostdata->id_mask);
|
|
|
|
|
2014-03-17 18:42:20 -06:00
|
|
|
dprintk(NDEBUG_RESELECTION, "scsi%d: reselect\n", HOSTNO);
|
2007-05-01 14:32:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* At this point, we have detected that our SCSI ID is on the bus,
|
|
|
|
* SEL is true and BSY was false for at least one bus settle delay
|
|
|
|
* (400 ns).
|
|
|
|
*
|
|
|
|
* We must assert BSY ourselves, until the target drops the SEL
|
|
|
|
* signal.
|
|
|
|
*/
|
|
|
|
|
|
|
|
NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_BSY);
|
|
|
|
|
|
|
|
while (NCR5380_read(STATUS_REG) & SR_SEL)
|
|
|
|
;
|
|
|
|
NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Wait for target to go into MSGIN.
|
|
|
|
*/
|
|
|
|
|
|
|
|
while (!(NCR5380_read(STATUS_REG) & SR_REQ))
|
|
|
|
;
|
|
|
|
|
2014-11-11 22:12:16 -07:00
|
|
|
#if defined(CONFIG_SUN3) && defined(REAL_DMA)
|
|
|
|
/* acknowledge toggle to MSGIN */
|
|
|
|
NCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(PHASE_MSGIN));
|
|
|
|
|
|
|
|
/* peek at the byte without really hitting the bus */
|
|
|
|
msg[0] = NCR5380_read(CURRENT_SCSI_DATA_REG);
|
|
|
|
#else
|
2007-05-01 14:32:36 -06:00
|
|
|
len = 1;
|
|
|
|
data = msg;
|
|
|
|
phase = PHASE_MSGIN;
|
|
|
|
NCR5380_transfer_pio(instance, &phase, &len, &data);
|
2014-11-11 22:12:16 -07:00
|
|
|
#endif
|
2007-05-01 14:32:36 -06:00
|
|
|
|
|
|
|
if (!(msg[0] & 0x80)) {
|
|
|
|
printk(KERN_DEBUG "scsi%d: expecting IDENTIFY message, got ", HOSTNO);
|
|
|
|
spi_print_msg(msg);
|
|
|
|
do_abort(instance);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
lun = (msg[0] & 0x07);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2014-11-11 22:12:16 -07:00
|
|
|
#if defined(SUPPORT_TAGS) && !defined(CONFIG_SUN3)
|
2007-05-01 14:32:36 -06:00
|
|
|
/* If the phase is still MSGIN, the target wants to send some more
|
|
|
|
* messages. In case it supports tagged queuing, this is probably a
|
|
|
|
* SIMPLE_QUEUE_TAG for the I_T_L_Q nexus.
|
|
|
|
*/
|
|
|
|
tag = TAG_NONE;
|
2014-11-11 22:12:19 -07:00
|
|
|
if (phase == PHASE_MSGIN && (hostdata->flags & FLAG_TAGGED_QUEUING)) {
|
2007-05-01 14:32:36 -06:00
|
|
|
/* Accept previous IDENTIFY message by clearing ACK */
|
|
|
|
NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
|
|
|
|
len = 2;
|
|
|
|
data = msg + 1;
|
|
|
|
if (!NCR5380_transfer_pio(instance, &phase, &len, &data) &&
|
|
|
|
msg[1] == SIMPLE_QUEUE_TAG)
|
|
|
|
tag = msg[2];
|
2014-03-17 18:42:20 -06:00
|
|
|
dprintk(NDEBUG_TAGS, "scsi%d: target mask %02x, lun %d sent tag %d at "
|
2007-05-01 14:32:36 -06:00
|
|
|
"reselection\n", HOSTNO, target_mask, lun, tag);
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
2007-05-01 14:32:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Find the command corresponding to the I_T_L or I_T_L_Q nexus we
|
|
|
|
* just reestablished, and remove it from the disconnected queue.
|
|
|
|
*/
|
|
|
|
|
2014-11-11 22:12:02 -07:00
|
|
|
for (tmp = (struct scsi_cmnd *) hostdata->disconnected_queue, prev = NULL;
|
2007-05-01 14:32:36 -06:00
|
|
|
tmp; prev = tmp, tmp = NEXT(tmp)) {
|
|
|
|
if ((target_mask == (1 << tmp->device->id)) && (lun == tmp->device->lun)
|
2005-04-16 16:20:36 -06:00
|
|
|
#ifdef SUPPORT_TAGS
|
2007-05-01 14:32:36 -06:00
|
|
|
&& (tag == tmp->tag)
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
2007-05-01 14:32:36 -06:00
|
|
|
) {
|
|
|
|
if (prev) {
|
|
|
|
REMOVE(prev, NEXT(prev), tmp, NEXT(tmp));
|
2007-05-01 14:32:37 -06:00
|
|
|
SET_NEXT(prev, NEXT(tmp));
|
2007-05-01 14:32:36 -06:00
|
|
|
} else {
|
|
|
|
REMOVE(-1, hostdata->disconnected_queue, tmp, NEXT(tmp));
|
|
|
|
hostdata->disconnected_queue = NEXT(tmp);
|
|
|
|
}
|
2007-05-01 14:32:37 -06:00
|
|
|
SET_NEXT(tmp, NULL);
|
2007-05-01 14:32:36 -06:00
|
|
|
break;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2007-05-01 14:32:36 -06:00
|
|
|
|
|
|
|
if (!tmp) {
|
|
|
|
printk(KERN_WARNING "scsi%d: warning: target bitmask %02x lun %d "
|
2005-04-16 16:20:36 -06:00
|
|
|
#ifdef SUPPORT_TAGS
|
2007-05-01 14:32:36 -06:00
|
|
|
"tag %d "
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
2007-05-01 14:32:36 -06:00
|
|
|
"not in disconnected_queue.\n",
|
|
|
|
HOSTNO, target_mask, lun
|
2005-04-16 16:20:36 -06:00
|
|
|
#ifdef SUPPORT_TAGS
|
2007-05-01 14:32:36 -06:00
|
|
|
, tag
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
2007-05-01 14:32:36 -06:00
|
|
|
);
|
|
|
|
/*
|
|
|
|
* Since we have an established nexus that we can't do anything
|
|
|
|
* with, we must abort it.
|
|
|
|
*/
|
|
|
|
do_abort(instance);
|
|
|
|
return;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2014-11-11 22:12:16 -07:00
|
|
|
#if defined(CONFIG_SUN3) && defined(REAL_DMA)
|
|
|
|
/* engage dma setup for the command we just saw */
|
|
|
|
{
|
|
|
|
void *d;
|
|
|
|
unsigned long count;
|
|
|
|
|
|
|
|
if (!tmp->SCp.this_residual && tmp->SCp.buffers_residual) {
|
|
|
|
count = tmp->SCp.buffer->length;
|
|
|
|
d = sg_virt(tmp->SCp.buffer);
|
|
|
|
} else {
|
|
|
|
count = tmp->SCp.this_residual;
|
|
|
|
d = tmp->SCp.ptr;
|
|
|
|
}
|
|
|
|
/* setup this command for dma if not already */
|
|
|
|
if ((count >= DMA_MIN_SIZE) && (sun3_dma_setup_done != tmp)) {
|
|
|
|
sun3scsi_dma_setup(d, count, rq_data_dir(tmp->request));
|
|
|
|
sun3_dma_setup_done = tmp;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ACK);
|
|
|
|
#endif
|
|
|
|
|
2007-05-01 14:32:36 -06:00
|
|
|
/* Accept message by clearing ACK */
|
|
|
|
NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2014-11-11 22:12:16 -07:00
|
|
|
#if defined(SUPPORT_TAGS) && defined(CONFIG_SUN3)
|
|
|
|
/* If the phase is still MSGIN, the target wants to send some more
|
|
|
|
* messages. In case it supports tagged queuing, this is probably a
|
|
|
|
* SIMPLE_QUEUE_TAG for the I_T_L_Q nexus.
|
|
|
|
*/
|
|
|
|
tag = TAG_NONE;
|
|
|
|
if (phase == PHASE_MSGIN && setup_use_tagged_queuing) {
|
|
|
|
/* Accept previous IDENTIFY message by clearing ACK */
|
|
|
|
NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
|
|
|
|
len = 2;
|
|
|
|
data = msg + 1;
|
|
|
|
if (!NCR5380_transfer_pio(instance, &phase, &len, &data) &&
|
|
|
|
msg[1] == SIMPLE_QUEUE_TAG)
|
|
|
|
tag = msg[2];
|
|
|
|
dprintk(NDEBUG_TAGS, "scsi%d: target mask %02x, lun %d sent tag %d at reselection\n"
|
|
|
|
HOSTNO, target_mask, lun, tag);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2007-05-01 14:32:36 -06:00
|
|
|
hostdata->connected = tmp;
|
2014-06-25 07:27:36 -06:00
|
|
|
dprintk(NDEBUG_RESELECTION, "scsi%d: nexus established, target = %d, lun = %llu, tag = %d\n",
|
2007-05-01 14:32:36 -06:00
|
|
|
HOSTNO, tmp->device->id, tmp->device->lun, tmp->tag);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
2014-11-11 22:12:02 -07:00
|
|
|
* Function : int NCR5380_abort (struct scsi_cmnd *cmd)
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* Purpose : abort a command
|
|
|
|
*
|
2014-11-11 22:12:02 -07:00
|
|
|
* Inputs : cmd - the scsi_cmnd to abort, code - code to set the
|
2007-05-01 14:32:36 -06:00
|
|
|
* host byte of the result field to, if zero DID_ABORTED is
|
2005-04-16 16:20:36 -06:00
|
|
|
* used.
|
|
|
|
*
|
2014-10-30 02:44:36 -06:00
|
|
|
* Returns : SUCCESS - success, FAILED on failure.
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2007-05-01 14:32:36 -06:00
|
|
|
* XXX - there is no way to abort the command that is currently
|
|
|
|
* connected, you have to wait for it to complete. If this is
|
2005-04-16 16:20:36 -06:00
|
|
|
* a problem, we could implement longjmp() / setjmp(), setjmp()
|
2007-05-01 14:32:36 -06:00
|
|
|
* called where the loop started in NCR5380_main().
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
|
|
|
|
static
|
2014-11-11 22:12:02 -07:00
|
|
|
int NCR5380_abort(struct scsi_cmnd *cmd)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-05-01 14:32:36 -06:00
|
|
|
struct Scsi_Host *instance = cmd->device->host;
|
|
|
|
SETUP_HOSTDATA(instance);
|
2014-11-11 22:12:02 -07:00
|
|
|
struct scsi_cmnd *tmp, **prev;
|
2007-05-01 14:32:36 -06:00
|
|
|
unsigned long flags;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2014-10-24 06:26:58 -06:00
|
|
|
scmd_printk(KERN_NOTICE, cmd, "aborting command\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-05-01 14:32:36 -06:00
|
|
|
NCR5380_print_status(instance);
|
|
|
|
|
|
|
|
local_irq_save(flags);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2014-03-17 18:42:20 -06:00
|
|
|
dprintk(NDEBUG_ABORT, "scsi%d: abort called basr 0x%02x, sr 0x%02x\n", HOSTNO,
|
2007-05-01 14:32:36 -06:00
|
|
|
NCR5380_read(BUS_AND_STATUS_REG),
|
|
|
|
NCR5380_read(STATUS_REG));
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
#if 1
|
2007-05-01 14:32:36 -06:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-05-01 14:32:36 -06:00
|
|
|
if (hostdata->connected == cmd) {
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2014-03-17 18:42:20 -06:00
|
|
|
dprintk(NDEBUG_ABORT, "scsi%d: aborting connected command\n", HOSTNO);
|
2007-05-01 14:32:36 -06:00
|
|
|
/*
|
|
|
|
* We should perform BSY checking, and make sure we haven't slipped
|
|
|
|
* into BUS FREE.
|
|
|
|
*/
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-05-01 14:32:36 -06:00
|
|
|
/* 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.
|
|
|
|
*/
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-05-01 14:32:36 -06:00
|
|
|
/*
|
|
|
|
* Return control to the executing NCR drive so we can clear the
|
|
|
|
* aborted flag and get back into our main loop.
|
|
|
|
*/
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-05-01 14:32:36 -06:00
|
|
|
if (do_abort(instance) == 0) {
|
|
|
|
hostdata->aborted = 1;
|
|
|
|
hostdata->connected = NULL;
|
|
|
|
cmd->result = DID_ABORT << 16;
|
2005-04-16 16:20:36 -06:00
|
|
|
#ifdef SUPPORT_TAGS
|
2007-05-01 14:32:36 -06:00
|
|
|
cmd_free_tag(cmd);
|
2005-04-16 16:20:36 -06:00
|
|
|
#else
|
2007-05-01 14:32:36 -06:00
|
|
|
hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun);
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
2014-11-11 22:12:15 -07:00
|
|
|
maybe_release_dma_irq(instance);
|
2007-05-01 14:32:36 -06:00
|
|
|
local_irq_restore(flags);
|
|
|
|
cmd->scsi_done(cmd);
|
2014-05-02 02:43:01 -06:00
|
|
|
return SUCCESS;
|
2007-05-01 14:32:36 -06:00
|
|
|
} else {
|
2014-11-11 22:12:15 -07:00
|
|
|
local_irq_restore(flags);
|
2007-05-01 14:32:36 -06:00
|
|
|
printk("scsi%d: abort of connected command failed!\n", HOSTNO);
|
2014-05-02 02:43:01 -06:00
|
|
|
return FAILED;
|
2007-05-01 14:32:36 -06:00
|
|
|
}
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
|
|
|
|
2007-05-01 14:32:36 -06:00
|
|
|
/*
|
|
|
|
* Case 2 : If the command hasn't been issued yet, we simply remove it
|
|
|
|
* from the issue queue.
|
|
|
|
*/
|
2014-11-11 22:12:02 -07:00
|
|
|
for (prev = (struct scsi_cmnd **)&(hostdata->issue_queue),
|
|
|
|
tmp = (struct scsi_cmnd *)hostdata->issue_queue;
|
2007-05-01 14:32:36 -06:00
|
|
|
tmp; prev = NEXTADDR(tmp), tmp = NEXT(tmp)) {
|
|
|
|
if (cmd == tmp) {
|
|
|
|
REMOVE(5, *prev, tmp, NEXT(tmp));
|
|
|
|
(*prev) = NEXT(tmp);
|
2007-05-01 14:32:37 -06:00
|
|
|
SET_NEXT(tmp, NULL);
|
2007-05-01 14:32:36 -06:00
|
|
|
tmp->result = DID_ABORT << 16;
|
2014-11-11 22:12:15 -07:00
|
|
|
maybe_release_dma_irq(instance);
|
2007-05-01 14:32:36 -06:00
|
|
|
local_irq_restore(flags);
|
2014-03-17 18:42:20 -06:00
|
|
|
dprintk(NDEBUG_ABORT, "scsi%d: abort removed command from issue queue.\n",
|
2007-05-01 14:32:36 -06:00
|
|
|
HOSTNO);
|
|
|
|
/* Tagged queuing note: no tag to free here, hasn't been assigned
|
|
|
|
* yet... */
|
|
|
|
tmp->scsi_done(tmp);
|
2014-05-02 02:43:01 -06:00
|
|
|
return SUCCESS;
|
2007-05-01 14:32:36 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2007-05-01 14:32:36 -06:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-05-01 14:32:36 -06:00
|
|
|
if (hostdata->connected) {
|
|
|
|
local_irq_restore(flags);
|
2014-03-17 18:42:20 -06:00
|
|
|
dprintk(NDEBUG_ABORT, "scsi%d: abort failed, command connected.\n", HOSTNO);
|
2014-05-02 02:43:01 -06:00
|
|
|
return FAILED;
|
2007-05-01 14:32:36 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-05-01 14:32:36 -06:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
|
2014-11-11 22:12:02 -07:00
|
|
|
for (tmp = (struct scsi_cmnd *) hostdata->disconnected_queue; tmp;
|
2007-05-01 14:32:36 -06:00
|
|
|
tmp = NEXT(tmp)) {
|
|
|
|
if (cmd == tmp) {
|
|
|
|
local_irq_restore(flags);
|
2014-03-17 18:42:20 -06:00
|
|
|
dprintk(NDEBUG_ABORT, "scsi%d: aborting disconnected command.\n", HOSTNO);
|
2007-05-01 14:32:36 -06:00
|
|
|
|
2014-11-11 22:11:53 -07:00
|
|
|
if (NCR5380_select(instance, cmd))
|
2014-05-02 02:43:01 -06:00
|
|
|
return FAILED;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2014-03-17 18:42:20 -06:00
|
|
|
dprintk(NDEBUG_ABORT, "scsi%d: nexus reestablished.\n", HOSTNO);
|
2007-05-01 14:32:36 -06:00
|
|
|
|
|
|
|
do_abort(instance);
|
|
|
|
|
|
|
|
local_irq_save(flags);
|
2014-11-11 22:12:02 -07:00
|
|
|
for (prev = (struct scsi_cmnd **)&(hostdata->disconnected_queue),
|
|
|
|
tmp = (struct scsi_cmnd *)hostdata->disconnected_queue;
|
2007-05-01 14:32:36 -06:00
|
|
|
tmp; prev = NEXTADDR(tmp), tmp = NEXT(tmp)) {
|
|
|
|
if (cmd == tmp) {
|
|
|
|
REMOVE(5, *prev, tmp, NEXT(tmp));
|
|
|
|
*prev = NEXT(tmp);
|
2007-05-01 14:32:37 -06:00
|
|
|
SET_NEXT(tmp, NULL);
|
2007-05-01 14:32:36 -06:00
|
|
|
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)
|
|
|
|
*/
|
2005-04-16 16:20:36 -06:00
|
|
|
#ifdef SUPPORT_TAGS
|
2007-05-01 14:32:36 -06:00
|
|
|
cmd_free_tag(tmp);
|
2005-04-16 16:20:36 -06:00
|
|
|
#else
|
2007-05-01 14:32:36 -06:00
|
|
|
hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun);
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
2014-11-11 22:12:15 -07:00
|
|
|
maybe_release_dma_irq(instance);
|
2007-05-01 14:32:36 -06:00
|
|
|
local_irq_restore(flags);
|
|
|
|
tmp->scsi_done(tmp);
|
2014-05-02 02:43:01 -06:00
|
|
|
return SUCCESS;
|
2007-05-01 14:32:36 -06:00
|
|
|
}
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-11-11 22:12:15 -07:00
|
|
|
/* 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);
|
|
|
|
local_irq_restore(flags);
|
|
|
|
|
2007-05-01 14:32:36 -06:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-07-06 14:05:40 -06:00
|
|
|
printk(KERN_INFO "scsi%d: warning : SCSI command probably completed successfully before abortion\n", HOSTNO);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2014-05-02 02:43:01 -06:00
|
|
|
return FAILED;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-05-01 14:32:36 -06:00
|
|
|
/*
|
2014-11-11 22:12:02 -07:00
|
|
|
* Function : int NCR5380_reset (struct scsi_cmnd *cmd)
|
2007-05-01 14:32:36 -06:00
|
|
|
*
|
2005-04-16 16:20:36 -06:00
|
|
|
* Purpose : reset the SCSI bus.
|
|
|
|
*
|
2014-05-02 02:43:01 -06:00
|
|
|
* Returns : SUCCESS or FAILURE
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2007-05-01 14:32:36 -06:00
|
|
|
*/
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2014-11-11 22:12:02 -07:00
|
|
|
static int NCR5380_bus_reset(struct scsi_cmnd *cmd)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2014-11-11 22:12:15 -07:00
|
|
|
struct Scsi_Host *instance = cmd->device->host;
|
|
|
|
struct NCR5380_hostdata *hostdata = shost_priv(instance);
|
2007-05-01 14:32:36 -06:00
|
|
|
int i;
|
|
|
|
unsigned long flags;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2014-11-11 22:12:15 -07:00
|
|
|
NCR5380_print_status(instance);
|
2007-05-01 14:32:36 -06:00
|
|
|
|
|
|
|
/* get in phase */
|
|
|
|
NCR5380_write(TARGET_COMMAND_REG,
|
|
|
|
PHASE_SR_TO_TCR(NCR5380_read(STATUS_REG)));
|
|
|
|
/* assert RST */
|
|
|
|
NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_RST);
|
|
|
|
udelay(40);
|
|
|
|
/* reset NCR registers */
|
|
|
|
NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
|
|
|
|
NCR5380_write(MODE_REG, MR_BASE);
|
|
|
|
NCR5380_write(TARGET_COMMAND_REG, 0);
|
|
|
|
NCR5380_write(SELECT_ENABLE_REG, 0);
|
|
|
|
/* ++roman: reset interrupt condition! otherwise no interrupts don't get
|
|
|
|
* through anymore ... */
|
|
|
|
(void)NCR5380_read(RESET_PARITY_INTERRUPT_REG);
|
|
|
|
|
|
|
|
/* After the reset, there are no more connected or disconnected commands
|
|
|
|
* and no busy units; so clear the low-level status here to avoid
|
|
|
|
* conflicts when the mid-level code tries to wake up the affected
|
|
|
|
* commands!
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (hostdata->issue_queue)
|
2014-03-17 18:42:20 -06:00
|
|
|
dprintk(NDEBUG_ABORT, "scsi%d: reset aborted issued command(s)\n", H_NO(cmd));
|
2007-05-01 14:32:36 -06:00
|
|
|
if (hostdata->connected)
|
2014-03-17 18:42:20 -06:00
|
|
|
dprintk(NDEBUG_ABORT, "scsi%d: reset aborted a connected command\n", H_NO(cmd));
|
2007-05-01 14:32:36 -06:00
|
|
|
if (hostdata->disconnected_queue)
|
2014-03-17 18:42:20 -06:00
|
|
|
dprintk(NDEBUG_ABORT, "scsi%d: reset aborted disconnected command(s)\n", H_NO(cmd));
|
2007-05-01 14:32:36 -06:00
|
|
|
|
|
|
|
local_irq_save(flags);
|
|
|
|
hostdata->issue_queue = NULL;
|
|
|
|
hostdata->connected = NULL;
|
|
|
|
hostdata->disconnected_queue = NULL;
|
2005-04-16 16:20:36 -06:00
|
|
|
#ifdef SUPPORT_TAGS
|
2014-11-11 22:12:19 -07:00
|
|
|
free_all_tags(hostdata);
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
2007-05-01 14:32:36 -06:00
|
|
|
for (i = 0; i < 8; ++i)
|
|
|
|
hostdata->busy[i] = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
#ifdef REAL_DMA
|
2007-05-01 14:32:36 -06:00
|
|
|
hostdata->dma_len = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
2014-11-11 22:12:15 -07:00
|
|
|
|
|
|
|
maybe_release_dma_irq(instance);
|
2007-05-01 14:32:36 -06:00
|
|
|
local_irq_restore(flags);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2014-05-02 02:43:01 -06:00
|
|
|
return SUCCESS;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|