atari_NCR5380.c 78.9 KB
Newer Older
1
/*
L
Linus Torvalds 已提交
2
 * NCR 5380 generic driver routines.  These should make it *trivial*
3 4
 * to implement 5380 SCSI drivers under Linux with a non-trantor
 * architecture.
L
Linus Torvalds 已提交
5
 *
6
 * Note that these routines also work with NR53c400 family chips.
L
Linus Torvalds 已提交
7 8
 *
 * Copyright 1993, Drew Eckhardt
9 10 11 12
 * Visionary Computing
 * (Unix and Linux consulting and custom programming)
 * drew@colorado.edu
 * +1 (303) 666-5836
L
Linus Torvalds 已提交
13
 *
14
 * For more information, please consult
L
Linus Torvalds 已提交
15 16 17 18 19 20 21 22 23 24 25 26
 *
 * NCR 5380 Family
 * SCSI Protocol Controller
 * Databook
 *
 * NCR Microelectronics
 * 1635 Aeroplaza Drive
 * Colorado Springs, CO 80916
 * 1+ (719) 578-3400
 * 1+ (800) 334-5454
 */

F
Finn Thain 已提交
27
/* Ported to Atari by Roman Hodek and others. */
L
Linus Torvalds 已提交
28

29 30
/* Adapted for the sun3 by Sam Creasey. */

L
Linus Torvalds 已提交
31 32 33
/*
 * Design
 *
34
 * This is a generic 5380 driver.  To use it on a different platform,
L
Linus Torvalds 已提交
35
 * one simply writes appropriate system specific macros (ie, data
36
 * transfer - some PC's will use the I/O bus, 68K's must use
L
Linus Torvalds 已提交
37 38
 * memory mapped) and drops this file in their 'C' wrapper.
 *
39
 * As far as command queueing, two queues are maintained for
L
Linus Torvalds 已提交
40
 * each 5380 in the system - commands that haven't been issued yet,
41 42 43 44 45
 * 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
L
Linus Torvalds 已提交
46 47 48
 * while a command is already executing.
 *
 *
49
 * Issues specific to the NCR5380 :
L
Linus Torvalds 已提交
50
 *
51 52 53 54
 * 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
55
 * while doing long seek operations. [...] These
L
Linus Torvalds 已提交
56 57 58 59 60 61
 * 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,
F
Finn Thain 已提交
62 63 64 65
 * 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.
L
Linus Torvalds 已提交
66 67 68 69 70
 *
 * 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
F
Finn Thain 已提交
71 72
 * queue, and NCR5380_main tries to find more work.  If the target is
 * idle for too long, the system will try to sleep.
L
Linus Torvalds 已提交
73 74 75 76 77
 *
 * 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.
 *
78
 * On command termination, the done function will be called as
L
Linus Torvalds 已提交
79 80
 * appropriate.
 *
81
 * SCSI pointers are maintained in the SCp field of SCSI command
L
Linus Torvalds 已提交
82 83 84 85 86 87 88 89 90
 * 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
91
 * of chips.  To use it, you write an architecture specific functions
L
Linus Torvalds 已提交
92 93
 * and macros and include this file in your driver.
 *
94
 * These macros control options :
L
Linus Torvalds 已提交
95
 * AUTOSENSE - if defined, REQUEST SENSE will be performed automatically
96
 * for commands that return with a CHECK CONDITION status.
L
Linus Torvalds 已提交
97
 *
F
Finn Thain 已提交
98
 * DIFFERENTIAL - if defined, NCR53c81 chips will use external differential
99
 * transceivers.
F
Finn Thain 已提交
100
 *
L
Linus Torvalds 已提交
101 102 103 104 105
 * 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 :
106
 *
L
Linus Torvalds 已提交
107 108
 * NCR5380_read(register)  - read from the specified register
 *
109
 * NCR5380_write(register, value) - write to the specific register
L
Linus Torvalds 已提交
110
 *
F
Finn Thain 已提交
111
 * NCR5380_implementation_fields  - additional fields needed for this
112
 * specific implementation of the NCR5380
F
Finn Thain 已提交
113
 *
L
Linus Torvalds 已提交
114
 * Either real DMA *or* pseudo DMA may be implemented
115
 * REAL functions :
L
Linus Torvalds 已提交
116
 * NCR5380_REAL_DMA should be defined if real DMA is to be used.
117
 * Note that the DMA setup functions should return the number of bytes
118
 * that they were able to program the controller for.
L
Linus Torvalds 已提交
119
 *
120
 * Also note that generic i386/PC versions of these macros are
121 122
 * available as NCR5380_i386_dma_write_setup,
 * NCR5380_i386_dma_read_setup, and NCR5380_i386_dma_residual.
L
Linus Torvalds 已提交
123 124 125 126 127 128 129 130 131 132
 *
 * 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),
133
 * after setting the appropriate host specific fields and ID.  If the
L
Linus Torvalds 已提交
134
 * driver wishes to autoprobe for an IRQ line, the NCR5380_probe_irq(instance,
F
Finn Thain 已提交
135
 * possible) function may be used.
L
Linus Torvalds 已提交
136 137
 */

138 139 140
static int do_abort(struct Scsi_Host *);
static void do_reset(struct Scsi_Host *);

L
Linus Torvalds 已提交
141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157
#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
F
Finn Thain 已提交
158
 * target.
L
Linus Torvalds 已提交
159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175
 *
 * 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.
 */

176
static void __init init_tags(struct NCR5380_hostdata *hostdata)
L
Linus Torvalds 已提交
177
{
178
	int target, lun;
179
	struct tag_alloc *ta;
180

181
	if (!(hostdata->flags & FLAG_TAGGED_QUEUING))
182 183 184 185
		return;

	for (target = 0; target < 8; ++target) {
		for (lun = 0; lun < 8; ++lun) {
186
			ta = &hostdata->TagAlloc[target][lun];
187 188 189 190 191 192 193 194
			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;
		}
L
Linus Torvalds 已提交
195 196 197 198 199 200 201 202 203
	}
}


/* 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.
204
 */
L
Linus Torvalds 已提交
205

F
Finn Thain 已提交
206
static int is_lun_busy(struct scsi_cmnd *cmd, int should_be_tagged)
L
Linus Torvalds 已提交
207
{
H
Hannes Reinecke 已提交
208
	u8 lun = cmd->device->lun;
209 210
	struct Scsi_Host *instance = cmd->device->host;
	struct NCR5380_hostdata *hostdata = shost_priv(instance);
211

H
Hannes Reinecke 已提交
212
	if (hostdata->busy[cmd->device->id] & (1 << lun))
213 214
		return 1;
	if (!should_be_tagged ||
215 216
	    !(hostdata->flags & FLAG_TAGGED_QUEUING) ||
	    !cmd->device->tagged_supported)
217
		return 0;
218 219
	if (hostdata->TagAlloc[scmd_id(cmd)][lun].nr_allocated >=
	    hostdata->TagAlloc[scmd_id(cmd)][lun].queue_size) {
220 221
		dsprintk(NDEBUG_TAGS, instance, "target %d lun %d: no free tags\n",
		         scmd_id(cmd), lun);
222 223 224
		return 1;
	}
	return 0;
L
Linus Torvalds 已提交
225 226 227 228 229 230 231 232
}


/* 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.
 */

F
Finn Thain 已提交
233
static void cmd_get_tag(struct scsi_cmnd *cmd, int should_be_tagged)
L
Linus Torvalds 已提交
234
{
H
Hannes Reinecke 已提交
235
	u8 lun = cmd->device->lun;
236 237
	struct Scsi_Host *instance = cmd->device->host;
	struct NCR5380_hostdata *hostdata = shost_priv(instance);
238 239 240 241 242

	/* If we or the target don't support tagged queuing, allocate the LUN for
	 * an untagged command.
	 */
	if (!should_be_tagged ||
243 244
	    !(hostdata->flags & FLAG_TAGGED_QUEUING) ||
	    !cmd->device->tagged_supported) {
245
		cmd->tag = TAG_NONE;
H
Hannes Reinecke 已提交
246
		hostdata->busy[cmd->device->id] |= (1 << lun);
247 248
		dsprintk(NDEBUG_TAGS, instance, "target %d lun %d now allocated by untagged command\n",
		         scmd_id(cmd), lun);
249
	} else {
250
		struct tag_alloc *ta = &hostdata->TagAlloc[scmd_id(cmd)][lun];
251 252 253 254

		cmd->tag = find_first_zero_bit(ta->allocated, MAX_TAGS);
		set_bit(cmd->tag, ta->allocated);
		ta->nr_allocated++;
255 256
		dsprintk(NDEBUG_TAGS, instance, "using tag %d for target %d lun %d (%d tags allocated)\n",
		         cmd->tag, scmd_id(cmd), lun, ta->nr_allocated);
257
	}
L
Linus Torvalds 已提交
258 259 260 261 262 263 264
}


/* Mark the tag of command 'cmd' as free, or in case of an untagged command,
 * unlock the LUN.
 */

F
Finn Thain 已提交
265
static void cmd_free_tag(struct scsi_cmnd *cmd)
L
Linus Torvalds 已提交
266
{
H
Hannes Reinecke 已提交
267
	u8 lun = cmd->device->lun;
268 269
	struct Scsi_Host *instance = cmd->device->host;
	struct NCR5380_hostdata *hostdata = shost_priv(instance);
270 271

	if (cmd->tag == TAG_NONE) {
H
Hannes Reinecke 已提交
272
		hostdata->busy[cmd->device->id] &= ~(1 << lun);
273 274
		dsprintk(NDEBUG_TAGS, instance, "target %d lun %d untagged cmd freed\n",
		         scmd_id(cmd), lun);
275
	} else if (cmd->tag >= MAX_TAGS) {
276 277
		shost_printk(KERN_NOTICE, instance,
		             "trying to free bad tag %d!\n", cmd->tag);
278
	} else {
279
		struct tag_alloc *ta = &hostdata->TagAlloc[scmd_id(cmd)][lun];
280 281
		clear_bit(cmd->tag, ta->allocated);
		ta->nr_allocated--;
282 283
		dsprintk(NDEBUG_TAGS, instance, "freed tag %d for target %d lun %d\n",
		         cmd->tag, scmd_id(cmd), lun);
284
	}
L
Linus Torvalds 已提交
285 286 287
}


288
static void free_all_tags(struct NCR5380_hostdata *hostdata)
L
Linus Torvalds 已提交
289
{
290
	int target, lun;
291
	struct tag_alloc *ta;
292

293
	if (!(hostdata->flags & FLAG_TAGGED_QUEUING))
294 295 296 297
		return;

	for (target = 0; target < 8; ++target) {
		for (lun = 0; lun < 8; ++lun) {
298
			ta = &hostdata->TagAlloc[target][lun];
299 300 301
			bitmap_zero(ta->allocated, MAX_TAGS);
			ta->nr_allocated = 0;
		}
L
Linus Torvalds 已提交
302 303 304 305 306
	}
}

#endif /* SUPPORT_TAGS */

F
Finn Thain 已提交
307 308 309 310 311 312 313 314 315
/**
 * merge_contiguous_buffers - coalesce scatter-gather list entries
 * @cmd: command requesting IO
 *
 * Try to merge several scatter-gather buffers into one DMA transfer.
 * This is possible if the scatter buffers lie on physically
 * contiguous addresses. The first scatter-gather buffer's data are
 * assumed to be already transferred into cmd->SCp.this_residual.
 * Every buffer merged avoids an interrupt and a DMA setup operation.
L
Linus Torvalds 已提交
316 317
 */

F
Finn Thain 已提交
318
static void merge_contiguous_buffers(struct scsi_cmnd *cmd)
L
Linus Torvalds 已提交
319
{
320
#if !defined(CONFIG_SUN3)
321
	unsigned long endaddr;
L
Linus Torvalds 已提交
322
#if (NDEBUG & NDEBUG_MERGING)
323 324
	unsigned long oldlen = cmd->SCp.this_residual;
	int cnt = 1;
L
Linus Torvalds 已提交
325 326
#endif

327 328
	for (endaddr = virt_to_phys(cmd->SCp.ptr + cmd->SCp.this_residual - 1) + 1;
	     cmd->SCp.buffers_residual &&
G
Geert Uytterhoeven 已提交
329
	     virt_to_phys(sg_virt(&cmd->SCp.buffer[1])) == endaddr;) {
F
Finn Thain 已提交
330
		dprintk(NDEBUG_MERGING, "VTOP(%p) == %08lx -> merging\n",
G
Geert Uytterhoeven 已提交
331
			   page_address(sg_page(&cmd->SCp.buffer[1])), endaddr);
L
Linus Torvalds 已提交
332
#if (NDEBUG & NDEBUG_MERGING)
333
		++cnt;
L
Linus Torvalds 已提交
334
#endif
335 336 337 338 339
		++cmd->SCp.buffer;
		--cmd->SCp.buffers_residual;
		cmd->SCp.this_residual += cmd->SCp.buffer->length;
		endaddr += cmd->SCp.buffer->length;
	}
L
Linus Torvalds 已提交
340
#if (NDEBUG & NDEBUG_MERGING)
341
	if (oldlen != cmd->SCp.this_residual)
F
Finn Thain 已提交
342
		dprintk(NDEBUG_MERGING, "merged %d buffers from %p, new length %08x\n",
343
			   cnt, cmd->SCp.ptr, cmd->SCp.this_residual);
L
Linus Torvalds 已提交
344
#endif
345
#endif /* !defined(CONFIG_SUN3) */
L
Linus Torvalds 已提交
346 347
}

F
Finn Thain 已提交
348 349 350
/**
 * initialize_SCp - init the scsi pointer field
 * @cmd: command block to set up
L
Linus Torvalds 已提交
351
 *
F
Finn Thain 已提交
352
 * Set up the internal fields in the SCSI command.
L
Linus Torvalds 已提交
353 354
 */

F
Finn Thain 已提交
355
static inline void initialize_SCp(struct scsi_cmnd *cmd)
L
Linus Torvalds 已提交
356
{
357 358 359
	/*
	 * Initialize the Scsi Pointer field so that all of the commands in the
	 * various queues are valid.
L
Linus Torvalds 已提交
360
	 */
361

362 363 364
	if (scsi_bufflen(cmd)) {
		cmd->SCp.buffer = scsi_sglist(cmd);
		cmd->SCp.buffers_residual = scsi_sg_count(cmd) - 1;
J
Jens Axboe 已提交
365
		cmd->SCp.ptr = sg_virt(cmd->SCp.buffer);
366
		cmd->SCp.this_residual = cmd->SCp.buffer->length;
F
Finn Thain 已提交
367

368 369 370 371
		merge_contiguous_buffers(cmd);
	} else {
		cmd->SCp.buffer = NULL;
		cmd->SCp.buffers_residual = 0;
372 373
		cmd->SCp.ptr = NULL;
		cmd->SCp.this_residual = 0;
374
	}
F
Finn Thain 已提交
375 376 377

	cmd->SCp.Status = 0;
	cmd->SCp.Message = 0;
L
Linus Torvalds 已提交
378 379
}

380
/**
381
 * NCR5380_poll_politely2 - wait for two chip register values
382
 * @instance: controller to poll
383 384 385 386 387 388
 * @reg1: 5380 register to poll
 * @bit1: Bitmask to check
 * @val1: Expected value
 * @reg2: Second 5380 register to poll
 * @bit2: Second bitmask to check
 * @val2: Second expected value
389
 * @wait: Time-out in jiffies
390
 *
391 392 393 394
 * Polls the chip in a reasonably efficient manner waiting for an
 * event to occur. After a short quick poll we begin to yield the CPU
 * (if possible). In irq contexts the time-out is arbitrarily limited.
 * Callers may hold locks as long as they are held in irq mode.
395
 *
396
 * Returns 0 if either or both event(s) occurred otherwise -ETIMEDOUT.
397 398
 */

399 400 401
static int NCR5380_poll_politely2(struct Scsi_Host *instance,
                                  int reg1, int bit1, int val1,
                                  int reg2, int bit2, int val2, int wait)
402
{
403 404 405 406 407 408 409
	struct NCR5380_hostdata *hostdata = shost_priv(instance);
	unsigned long deadline = jiffies + wait;
	unsigned long n;

	/* Busy-wait for up to 10 ms */
	n = min(10000U, jiffies_to_usecs(wait));
	n *= hostdata->accesses_per_ms;
410
	n /= 2000;
411
	do {
412 413 414
		if ((NCR5380_read(reg1) & bit1) == val1)
			return 0;
		if ((NCR5380_read(reg2) & bit2) == val2)
415 416
			return 0;
		cpu_relax();
417 418 419 420
	} while (n--);

	if (irqs_disabled() || in_interrupt())
		return -ETIMEDOUT;
421

422 423 424
	/* Repeatedly sleep for 1 ms until deadline */
	while (time_is_after_jiffies(deadline)) {
		schedule_timeout_uninterruptible(1);
425 426 427
		if ((NCR5380_read(reg1) & bit1) == val1)
			return 0;
		if ((NCR5380_read(reg2) & bit2) == val2)
428 429
			return 0;
	}
430

431 432 433
	return -ETIMEDOUT;
}

434 435 436 437 438 439 440
static inline int NCR5380_poll_politely(struct Scsi_Host *instance,
                                        int reg, int bit, int val, int wait)
{
	return NCR5380_poll_politely2(instance, reg, bit, val,
	                                        reg, bit, val, wait);
}

L
Linus Torvalds 已提交
441 442
#if NDEBUG
static struct {
443 444 445
	unsigned char mask;
	const char *name;
} signals[] = {
446 447 448 449 450 451 452 453
	{SR_DBP, "PARITY"},
	{SR_RST, "RST"},
	{SR_BSY, "BSY"},
	{SR_REQ, "REQ"},
	{SR_MSG, "MSG"},
	{SR_CD, "CD"},
	{SR_IO, "IO"},
	{SR_SEL, "SEL"},
454
	{0, NULL}
455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475
},
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"},
476
	{MR_MONITOR_BSY, "MODE MONITOR BSY"},
477 478
	{MR_DMA_MODE, "MODE DMA"},
	{MR_ARBITRATE, "MODE ARBITRATION"},
479 480
	{0, NULL}
};
L
Linus Torvalds 已提交
481

F
Finn Thain 已提交
482 483 484
/**
 * NCR5380_print - print scsi bus signals
 * @instance: adapter state to dump
L
Linus Torvalds 已提交
485
 *
F
Finn Thain 已提交
486
 * Print the SCSI bus signals for debugging purposes
L
Linus Torvalds 已提交
487 488
 */

489 490 491 492 493 494 495 496 497
static void NCR5380_print(struct Scsi_Host *instance)
{
	unsigned char status, data, basr, mr, icr, i;

	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);
498

499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515
	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");
L
Linus Torvalds 已提交
516 517 518
}

static struct {
519 520
	unsigned char value;
	const char *name;
L
Linus Torvalds 已提交
521
} phases[] = {
522 523 524 525 526 527
	{PHASE_DATAOUT, "DATAOUT"},
	{PHASE_DATAIN, "DATAIN"},
	{PHASE_CMDOUT, "CMDOUT"},
	{PHASE_STATIN, "STATIN"},
	{PHASE_MSGOUT, "MSGOUT"},
	{PHASE_MSGIN, "MSGIN"},
528 529
	{PHASE_UNKNOWN, "UNKNOWN"}
};
L
Linus Torvalds 已提交
530

F
Finn Thain 已提交
531 532 533
/**
 * NCR5380_print_phase - show SCSI phase
 * @instance: adapter to dump
L
Linus Torvalds 已提交
534
 *
F
Finn Thain 已提交
535
 * Print the current SCSI phase for debugging purposes
L
Linus Torvalds 已提交
536 537 538 539
 */

static void NCR5380_print_phase(struct Scsi_Host *instance)
{
540 541 542 543 544
	unsigned char status;
	int i;

	status = NCR5380_read(STATUS_REG);
	if (!(status & SR_REQ))
545
		shost_printk(KERN_DEBUG, instance, "REQ not asserted, phase unknown.\n");
546 547 548 549
	else {
		for (i = 0; (phases[i].value != PHASE_UNKNOWN) &&
		     (phases[i].value != (status & PHASE_MASK)); ++i)
			;
550
		shost_printk(KERN_DEBUG, instance, "phase %s\n", phases[i].name);
551
	}
L
Linus Torvalds 已提交
552 553 554
}
#endif

F
Finn Thain 已提交
555 556 557
/**
 * NCR58380_info - report driver and host information
 * @instance: relevant scsi host instance
L
Linus Torvalds 已提交
558
 *
F
Finn Thain 已提交
559
 * For use as the host template info() handler.
L
Linus Torvalds 已提交
560 561
 */

F
Finn Thain 已提交
562
static const char *NCR5380_info(struct Scsi_Host *instance)
L
Linus Torvalds 已提交
563
{
F
Finn Thain 已提交
564 565 566 567 568 569 570 571 572 573 574 575 576 577
	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, "
578
	         "flags { %s%s}, "
F
Finn Thain 已提交
579 580 581 582 583
	         "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,
584
	         hostdata->flags & FLAG_TAGGED_QUEUING ? "TAGGED_QUEUING " : "",
585
	         hostdata->flags & FLAG_TOSHIBA_DELAY  ? "TOSHIBA_DELAY "  : "",
F
Finn Thain 已提交
586 587 588
#ifdef DIFFERENTIAL
	         "DIFFERENTIAL "
#endif
L
Linus Torvalds 已提交
589
#ifdef REAL_DMA
F
Finn Thain 已提交
590
	         "REAL_DMA "
L
Linus Torvalds 已提交
591 592
#endif
#ifdef PARITY
F
Finn Thain 已提交
593
	         "PARITY "
L
Linus Torvalds 已提交
594 595
#endif
#ifdef SUPPORT_TAGS
F
Finn Thain 已提交
596
	         "SUPPORT_TAGS "
L
Linus Torvalds 已提交
597
#endif
F
Finn Thain 已提交
598
	         "");
L
Linus Torvalds 已提交
599 600
}

F
Finn Thain 已提交
601 602 603 604
/**
 * NCR5380_init - initialise an NCR5380
 * @instance: adapter to configure
 * @flags: control flags
L
Linus Torvalds 已提交
605
 *
F
Finn Thain 已提交
606 607
 * Initializes *instance and corresponding 5380 chip,
 * with flags OR'd into the initial flags value.
L
Linus Torvalds 已提交
608 609
 *
 * Notes : I assume that the host, hostno, and id bits have been
F
Finn Thain 已提交
610
 * set correctly. I don't care about the irq and other fields.
611
 *
F
Finn Thain 已提交
612
 * Returns 0 for success
L
Linus Torvalds 已提交
613 614
 */

615
static int __init NCR5380_init(struct Scsi_Host *instance, int flags)
L
Linus Torvalds 已提交
616
{
F
Finn Thain 已提交
617
	struct NCR5380_hostdata *hostdata = shost_priv(instance);
618
	int i;
619
	unsigned long deadline;
620

621
	hostdata->host = instance;
622 623 624 625 626 627 628
	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;
L
Linus Torvalds 已提交
629
#ifdef SUPPORT_TAGS
630
	init_tags(hostdata);
L
Linus Torvalds 已提交
631 632
#endif
#if defined (REAL_DMA)
633
	hostdata->dma_len = 0;
L
Linus Torvalds 已提交
634
#endif
635
	spin_lock_init(&hostdata->lock);
636
	hostdata->connected = NULL;
F
Finn Thain 已提交
637 638
	hostdata->sensing = NULL;
	INIT_LIST_HEAD(&hostdata->autosense);
639 640 641
	INIT_LIST_HEAD(&hostdata->unissued);
	INIT_LIST_HEAD(&hostdata->disconnected);

642
	hostdata->flags = flags;
643

644
	INIT_WORK(&hostdata->main_task, NCR5380_main);
645 646 647 648 649
	hostdata->work_q = alloc_workqueue("ncr5380_%d",
	                        WQ_UNBOUND | WQ_MEM_RECLAIM,
	                        1, instance->host_no);
	if (!hostdata->work_q)
		return -ENOMEM;
L
Linus Torvalds 已提交
650

F
Finn Thain 已提交
651 652
	prepare_info(instance);

653 654 655 656
	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);
L
Linus Torvalds 已提交
657

658 659 660 661 662 663 664 665 666 667 668 669 670 671
	/* Calibrate register polling loop */
	i = 0;
	deadline = jiffies + 1;
	do {
		cpu_relax();
	} while (time_is_after_jiffies(deadline));
	deadline += msecs_to_jiffies(256);
	do {
		NCR5380_read(STATUS_REG);
		++i;
		cpu_relax();
	} while (time_is_after_jiffies(deadline));
	hostdata->accesses_per_ms = i / 256;

672
	return 0;
L
Linus Torvalds 已提交
673 674
}

675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690
/**
 * NCR5380_maybe_reset_bus - Detect and correct bus wedge problems.
 * @instance: adapter to check
 *
 * If the system crashed, it may have crashed with a connected target and
 * the SCSI bus busy. Check for BUS FREE phase. If not, try to abort the
 * currently established nexus, which we know nothing about. Failing that
 * do a bus reset.
 *
 * Note that a bus reset will cause the chip to assert IRQ.
 *
 * Returns 0 if successful, otherwise -ENXIO.
 */

static int NCR5380_maybe_reset_bus(struct Scsi_Host *instance)
{
691
	struct NCR5380_hostdata *hostdata = shost_priv(instance);
692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709
	int pass;

	for (pass = 1; (NCR5380_read(STATUS_REG) & SR_BSY) && pass <= 6; ++pass) {
		switch (pass) {
		case 1:
		case 3:
		case 5:
			shost_printk(KERN_ERR, instance, "SCSI bus busy, waiting up to five seconds\n");
			NCR5380_poll_politely(instance,
			                      STATUS_REG, SR_BSY, 0, 5 * HZ);
			break;
		case 2:
			shost_printk(KERN_ERR, instance, "bus busy, attempting abort\n");
			do_abort(instance);
			break;
		case 4:
			shost_printk(KERN_ERR, instance, "bus busy, attempting reset\n");
			do_reset(instance);
710 711 712 713 714 715 716 717
			/* Wait after a reset; the SCSI standard calls for
			 * 250ms, we wait 500ms to be on the safe side.
			 * But some Toshiba CD-ROMs need ten times that.
			 */
			if (hostdata->flags & FLAG_TOSHIBA_DELAY)
				msleep(2500);
			else
				msleep(500);
718 719 720 721 722 723 724 725 726
			break;
		case 6:
			shost_printk(KERN_ERR, instance, "bus locked solid\n");
			return -ENXIO;
		}
	}
	return 0;
}

F
Finn Thain 已提交
727 728 729 730 731 732 733
/**
 * NCR5380_exit - remove an NCR5380
 * @instance: adapter to remove
 *
 * Assumes that no more work can be queued (e.g. by NCR5380_intr).
 */

734 735
static void NCR5380_exit(struct Scsi_Host *instance)
{
736 737 738
	struct NCR5380_hostdata *hostdata = shost_priv(instance);

	cancel_work_sync(&hostdata->main_task);
739
	destroy_workqueue(hostdata->work_q);
740 741
}

742 743 744 745 746 747 748 749 750 751 752 753 754
/**
 * complete_cmd - finish processing a command and return it to the SCSI ML
 * @instance: the host instance
 * @cmd: command to complete
 */

static void complete_cmd(struct Scsi_Host *instance,
                         struct scsi_cmnd *cmd)
{
	struct NCR5380_hostdata *hostdata = shost_priv(instance);

	dsprintk(NDEBUG_QUEUES, instance, "complete_cmd: cmd %p\n", cmd);

F
Finn Thain 已提交
755 756 757 758 759 760 761 762 763 764
	if (hostdata->sensing == cmd) {
		/* Autosense processing ends here */
		if ((cmd->result & 0xff) != SAM_STAT_GOOD) {
			scsi_eh_restore_cmnd(cmd, &hostdata->ses);
			set_host_byte(cmd, DID_ERROR);
		} else
			scsi_eh_restore_cmnd(cmd, &hostdata->ses);
		hostdata->sensing = NULL;
	}

765 766 767 768 769 770 771 772
#ifdef SUPPORT_TAGS
	cmd_free_tag(cmd);
#else
	hostdata->busy[scmd_id(cmd)] &= ~(1 << cmd->device->lun);
#endif
	cmd->scsi_done(cmd);
}

F
Finn Thain 已提交
773 774 775 776
/**
 * NCR5380_queue_command - queue a command
 * @instance: the relevant SCSI adapter
 * @cmd: SCSI command
L
Linus Torvalds 已提交
777
 *
F
Finn Thain 已提交
778
 * cmd is added to the per-instance issue queue, with minor
F
Finn Thain 已提交
779 780
 * twiddling done to the host specific fields of cmd.  If the
 * main coroutine is not running, it is restarted.
L
Linus Torvalds 已提交
781 782
 */

783 784
static int NCR5380_queue_command(struct Scsi_Host *instance,
                                 struct scsi_cmnd *cmd)
L
Linus Torvalds 已提交
785
{
786
	struct NCR5380_hostdata *hostdata = shost_priv(instance);
787
	struct NCR5380_cmd *ncmd = scsi_cmd_priv(cmd);
788
	unsigned long flags;
L
Linus Torvalds 已提交
789 790

#if (NDEBUG & NDEBUG_NO_WRITE)
791 792 793
	switch (cmd->cmnd[0]) {
	case WRITE_6:
	case WRITE_10:
794
		shost_printk(KERN_DEBUG, instance, "WRITE attempted with NDEBUG_NO_WRITE set\n");
795
		cmd->result = (DID_ERROR << 16);
796
		cmd->scsi_done(cmd);
797 798
		return 0;
	}
L
Linus Torvalds 已提交
799 800
#endif /* (NDEBUG & NDEBUG_NO_WRITE) */

801 802 803 804 805 806 807
	cmd->result = 0;

	/*
	 * ++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.
	 */
808
	if (!NCR5380_acquire_dma_irq(instance))
809 810
		return SCSI_MLQUEUE_HOST_BUSY;

811
	spin_lock_irqsave(&hostdata->lock, flags);
812

F
Finn Thain 已提交
813 814 815 816 817 818 819
	/*
	 * 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.
	 */

820 821 822 823 824
	if (cmd->cmnd[0] == REQUEST_SENSE)
		list_add(&ncmd->list, &hostdata->unissued);
	else
		list_add_tail(&ncmd->list, &hostdata->unissued);

825
	spin_unlock_irqrestore(&hostdata->lock, flags);
826

827 828
	dsprintk(NDEBUG_QUEUES, instance, "command %p added to %s of queue\n",
	         cmd, (cmd->cmnd[0] == REQUEST_SENSE) ? "head" : "tail");
829

830 831
	/* Kick off command processing */
	queue_work(hostdata->work_q, &hostdata->main_task);
832
	return 0;
L
Linus Torvalds 已提交
833 834
}

835 836 837 838 839
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 */
840 841
	if (list_empty(&hostdata->disconnected) &&
	    list_empty(&hostdata->unissued) &&
F
Finn Thain 已提交
842
	    list_empty(&hostdata->autosense) &&
843
	    !hostdata->connected &&
844
	    !hostdata->selecting)
845 846 847
		NCR5380_release_dma_irq(instance);
}

F
Finn Thain 已提交
848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911
/**
 * dequeue_next_cmd - dequeue a command for processing
 * @instance: the scsi host instance
 *
 * Priority is given to commands on the autosense queue. These commands
 * need autosense because of a CHECK CONDITION result.
 *
 * Returns a command pointer if a command is found for a target that is
 * not already busy. Otherwise returns NULL.
 */

static struct scsi_cmnd *dequeue_next_cmd(struct Scsi_Host *instance)
{
	struct NCR5380_hostdata *hostdata = shost_priv(instance);
	struct NCR5380_cmd *ncmd;
	struct scsi_cmnd *cmd;

	if (list_empty(&hostdata->autosense)) {
		list_for_each_entry(ncmd, &hostdata->unissued, list) {
			cmd = NCR5380_to_scmd(ncmd);
			dsprintk(NDEBUG_QUEUES, instance, "dequeue: cmd=%p target=%d busy=0x%02x lun=%llu\n",
			         cmd, scmd_id(cmd), hostdata->busy[scmd_id(cmd)], cmd->device->lun);

			if (
#ifdef SUPPORT_TAGS
			    !is_lun_busy(cmd, 1)
#else
			    !(hostdata->busy[scmd_id(cmd)] & (1 << cmd->device->lun))
#endif
			) {
				list_del(&ncmd->list);
				dsprintk(NDEBUG_QUEUES, instance,
				         "dequeue: removed %p from issue queue\n", cmd);
				return cmd;
			}
		}
	} else {
		/* Autosense processing begins here */
		ncmd = list_first_entry(&hostdata->autosense,
		                        struct NCR5380_cmd, list);
		list_del(&ncmd->list);
		cmd = NCR5380_to_scmd(ncmd);
		dsprintk(NDEBUG_QUEUES, instance,
		         "dequeue: removed %p from autosense queue\n", cmd);
		scsi_eh_prep_cmnd(cmd, &hostdata->ses, NULL, 0, ~0);
		hostdata->sensing = cmd;
		return cmd;
	}
	return NULL;
}

static void requeue_cmd(struct Scsi_Host *instance, struct scsi_cmnd *cmd)
{
	struct NCR5380_hostdata *hostdata = shost_priv(instance);
	struct NCR5380_cmd *ncmd = scsi_cmd_priv(cmd);

	if (hostdata->sensing) {
		scsi_eh_restore_cmnd(cmd, &hostdata->ses);
		list_add(&ncmd->list, &hostdata->autosense);
		hostdata->sensing = NULL;
	} else
		list_add(&ncmd->list, &hostdata->unissued);
}

F
Finn Thain 已提交
912 913
/**
 * NCR5380_main - NCR state machines
L
Linus Torvalds 已提交
914
 *
F
Finn Thain 已提交
915 916 917 918
 * 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.
919 920
 */

921
static void NCR5380_main(struct work_struct *work)
L
Linus Torvalds 已提交
922
{
923 924 925
	struct NCR5380_hostdata *hostdata =
		container_of(work, struct NCR5380_hostdata, main_task);
	struct Scsi_Host *instance = hostdata->host;
F
Finn Thain 已提交
926
	struct scsi_cmnd *cmd;
927 928 929 930 931 932 933 934 935 936 937
	int done;

	/*
	 * ++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.
	 */

	do {
		done = 1;

F
Finn Thain 已提交
938
		spin_lock_irq(&hostdata->lock);
F
Finn Thain 已提交
939 940
		while (!hostdata->connected &&
		       (cmd = dequeue_next_cmd(instance))) {
941

F
Finn Thain 已提交
942
			dsprintk(NDEBUG_MAIN, instance, "main: dequeued %p\n", cmd);
943

F
Finn Thain 已提交
944 945 946 947 948 949 950 951 952 953 954 955 956 957 958
			/*
			 * 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.
			 */
			/*
			 * 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.
			 */
959

L
Linus Torvalds 已提交
960
#ifdef SUPPORT_TAGS
F
Finn Thain 已提交
961
			cmd_get_tag(cmd, cmd->cmnd[0] != REQUEST_SENSE);
L
Linus Torvalds 已提交
962
#endif
963 964 965
			cmd = NCR5380_select(instance, cmd);
			if (!cmd) {
				dsprintk(NDEBUG_MAIN, instance, "main: select complete\n");
F
Finn Thain 已提交
966 967 968 969 970
				maybe_release_dma_irq(instance);
			} else {
				dsprintk(NDEBUG_MAIN | NDEBUG_QUEUES, instance,
				         "main: select failed, returning %p to queue\n", cmd);
				requeue_cmd(instance, cmd);
L
Linus Torvalds 已提交
971
#ifdef SUPPORT_TAGS
F
Finn Thain 已提交
972
				cmd_free_tag(cmd);
L
Linus Torvalds 已提交
973
#endif
F
Finn Thain 已提交
974 975
			}
		}
976
		if (hostdata->connected
L
Linus Torvalds 已提交
977
#ifdef REAL_DMA
978
		    && !hostdata->dma_len
L
Linus Torvalds 已提交
979
#endif
980
		    ) {
981
			dsprintk(NDEBUG_MAIN, instance, "main: performing information transfer\n");
982 983 984
			NCR5380_information_transfer(instance);
			done = 0;
		}
F
Finn Thain 已提交
985 986 987
		spin_unlock_irq(&hostdata->lock);
		if (!done)
			cond_resched();
988
	} while (!done);
L
Linus Torvalds 已提交
989 990 991 992 993 994 995 996
}


#ifdef REAL_DMA
/*
 * Function : void NCR5380_dma_complete (struct Scsi_Host *instance)
 *
 * Purpose : Called by interrupt handler when DMA finishes or a phase
997
 * mismatch occurs (which would finish the DMA transfer).
L
Linus Torvalds 已提交
998 999 1000 1001
 *
 * Inputs : instance - this instance of the NCR5380.
 */

1002
static void NCR5380_dma_complete(struct Scsi_Host *instance)
L
Linus Torvalds 已提交
1003
{
F
Finn Thain 已提交
1004
	struct NCR5380_hostdata *hostdata = shost_priv(instance);
F
Finn Thain 已提交
1005
	int transferred;
1006
	unsigned char **data;
1007
	int *count;
1008 1009
	int saved_data = 0, overrun = 0;
	unsigned char p;
1010

1011
	if (hostdata->read_overruns) {
1012 1013 1014 1015 1016 1017 1018 1019
		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;
1020
				dsprintk(NDEBUG_DMA, instance, "read overrun handled\n");
1021 1022 1023 1024
			}
		}
	}

1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042
#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

1043 1044
	NCR5380_write(MODE_REG, MR_BASE);
	NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
1045
	NCR5380_read(RESET_PARITY_INTERRUPT_REG);
1046

F
Finn Thain 已提交
1047
	transferred = hostdata->dma_len - NCR5380_dma_residual(instance);
1048 1049 1050 1051
	hostdata->dma_len = 0;

	data = (unsigned char **)&hostdata->connected->SCp.ptr;
	count = &hostdata->connected->SCp.this_residual;
F
Finn Thain 已提交
1052 1053
	*data += transferred;
	*count -= transferred;
1054

1055
	if (hostdata->read_overruns) {
1056 1057
		int cnt, toPIO;

1058
		if ((NCR5380_read(STATUS_REG) & PHASE_MASK) == p && (p & SR_IO)) {
1059
			cnt = toPIO = hostdata->read_overruns;
1060
			if (overrun) {
F
Finn Thain 已提交
1061
				dprintk(NDEBUG_DMA, "Got an input overrun, using saved byte\n");
1062 1063 1064 1065 1066
				*(*data)++ = saved_data;
				(*count)--;
				cnt--;
				toPIO--;
			}
F
Finn Thain 已提交
1067
			dprintk(NDEBUG_DMA, "Doing %d-byte PIO to 0x%08lx\n", cnt, (long)*data);
1068 1069 1070
			NCR5380_transfer_pio(instance, &p, &cnt, data);
			*count -= toPIO - cnt;
		}
L
Linus Torvalds 已提交
1071 1072 1073 1074 1075
	}
}
#endif /* REAL_DMA */


F
Finn Thain 已提交
1076 1077 1078 1079
/**
 * NCR5380_intr - generic NCR5380 irq handler
 * @irq: interrupt number
 * @dev_id: device info
L
Linus Torvalds 已提交
1080
 *
F
Finn Thain 已提交
1081 1082 1083
 * Handle interrupts, reestablishing I_T_L or I_T_L_Q nexuses
 * from the disconnected queue, and restarting NCR5380_main()
 * as required.
1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107
 *
 * The chip can assert IRQ in any of six different conditions. The IRQ flag
 * is then cleared by reading the Reset Parity/Interrupt Register (RPIR).
 * Three of these six conditions are latched in the Bus and Status Register:
 * - End of DMA (cleared by ending DMA Mode)
 * - Parity error (cleared by reading RPIR)
 * - Loss of BSY (cleared by reading RPIR)
 * Two conditions have flag bits that are not latched:
 * - Bus phase mismatch (non-maskable in DMA Mode, cleared by ending DMA Mode)
 * - Bus reset (non-maskable)
 * The remaining condition has no flag bit at all:
 * - Selection/reselection
 *
 * Hence, establishing the cause(s) of any interrupt is partly guesswork.
 * In "The DP8490 and DP5380 Comparison Guide", National Semiconductor
 * claimed that "the design of the [DP8490] interrupt logic ensures
 * interrupts will not be lost (they can be on the DP5380)."
 * The L5380/53C80 datasheet from LOGIC Devices has more details.
 *
 * Checking for bus reset by reading RST is futile because of interrupt
 * latency, but a bus reset will reset chip logic. Checking for parity error
 * is unnecessary because that interrupt is never enabled. A Loss of BSY
 * condition will clear DMA Mode. We can tell when this occurs because the
 * the Busy Monitor interrupt is enabled together with DMA Mode.
L
Linus Torvalds 已提交
1108 1109
 */

1110
static irqreturn_t NCR5380_intr(int irq, void *dev_id)
L
Linus Torvalds 已提交
1111
{
1112
	struct Scsi_Host *instance = dev_id;
1113
	struct NCR5380_hostdata *hostdata = shost_priv(instance);
1114
	int handled = 0;
1115
	unsigned char basr;
1116 1117 1118
	unsigned long flags;

	spin_lock_irqsave(&hostdata->lock, flags);
1119 1120 1121

	basr = NCR5380_read(BUS_AND_STATUS_REG);
	if (basr & BASR_IRQ) {
1122 1123 1124
		unsigned char mr = NCR5380_read(MODE_REG);
		unsigned char sr = NCR5380_read(STATUS_REG);

1125 1126
		dsprintk(NDEBUG_INTR, instance, "IRQ %d, BASR 0x%02x, SR 0x%02x, MR 0x%02x\n",
		         irq, basr, sr, mr);
L
Linus Torvalds 已提交
1127 1128

#if defined(REAL_DMA)
1129 1130 1131 1132
		if ((mr & MR_DMA_MODE) || (mr & MR_MONITOR_BSY)) {
			/* Probably End of DMA, Phase Mismatch or Loss of BSY.
			 * We ack IRQ after clearing Mode Register. Workarounds
			 * for End of DMA errata need to happen in DMA Mode.
1133 1134
			 */

1135
			dsprintk(NDEBUG_INTR, instance, "interrupt in DMA mode\n");
1136

1137 1138 1139 1140 1141 1142 1143 1144
			if (hostdata->connected) {
				NCR5380_dma_complete(instance);
				queue_work(hostdata->work_q, &hostdata->main_task);
			} else {
				NCR5380_write(MODE_REG, MR_BASE);
				NCR5380_read(RESET_PARITY_INTERRUPT_REG);
			}
		} else
L
Linus Torvalds 已提交
1145
#endif /* REAL_DMA */
1146 1147 1148 1149 1150 1151
		if ((NCR5380_read(CURRENT_SCSI_DATA_REG) & hostdata->id_mask) &&
		    (sr & (SR_SEL | SR_IO | SR_BSY | SR_RST)) == (SR_SEL | SR_IO)) {
			/* Probably reselected */
			NCR5380_write(SELECT_ENABLE_REG, 0);
			NCR5380_read(RESET_PARITY_INTERRUPT_REG);

1152
			dsprintk(NDEBUG_INTR, instance, "interrupt with SEL and IO\n");
1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163

			if (!hostdata->connected) {
				NCR5380_reselect(instance);
				queue_work(hostdata->work_q, &hostdata->main_task);
			}
			if (!hostdata->connected)
				NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
		} else {
			/* Probably Bus Reset */
			NCR5380_read(RESET_PARITY_INTERRUPT_REG);

1164
			dsprintk(NDEBUG_INTR, instance, "unknown interrupt\n");
1165
#ifdef SUN3_SCSI_VME
1166
			dregs->csr |= CSR_DMA_ENABLE;
1167
#endif
1168
		}
1169
		handled = 1;
1170 1171
	} else {
		shost_printk(KERN_NOTICE, instance, "interrupt without IRQ bit\n");
1172 1173 1174
#ifdef SUN3_SCSI_VME
		dregs->csr |= CSR_DMA_ENABLE;
#endif
1175 1176
	}

1177 1178
	spin_unlock_irqrestore(&hostdata->lock, flags);

1179
	return IRQ_RETVAL(handled);
L
Linus Torvalds 已提交
1180 1181
}

1182
/*
F
Finn Thain 已提交
1183
 * Function : int NCR5380_select(struct Scsi_Host *instance,
1184
 * struct scsi_cmnd *cmd)
L
Linus Torvalds 已提交
1185 1186
 *
 * Purpose : establishes I_T_L or I_T_L_Q nexus for new or existing command,
1187 1188
 * including ARBITRATION, SELECTION, and initial message out for
 * IDENTIFY and queue messages.
L
Linus Torvalds 已提交
1189
 *
1190
 * Inputs : instance - instantiation of the 5380 driver on which this
1191
 * target lives, cmd - SCSI command to execute.
1192
 *
1193 1194 1195
 * Returns cmd if selection failed but should be retried,
 * NULL if selection failed and should not be retried, or
 * NULL if selection succeeded (hostdata->connected == cmd).
L
Linus Torvalds 已提交
1196
 *
1197
 * Side effects :
1198 1199 1200 1201
 * If bus busy, arbitration failed, etc, NCR5380_select() will exit
 * 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.
L
Linus Torvalds 已提交
1202
 *
1203 1204 1205
 * 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.
L
Linus Torvalds 已提交
1206
 *
1207 1208
 * If failed (no target) : cmd->scsi_done() will be called, and the
 * cmd->result host byte set to DID_BAD_TARGET.
L
Linus Torvalds 已提交
1209 1210
 */

1211 1212
static struct scsi_cmnd *NCR5380_select(struct Scsi_Host *instance,
                                        struct scsi_cmnd *cmd)
L
Linus Torvalds 已提交
1213
{
F
Finn Thain 已提交
1214
	struct NCR5380_hostdata *hostdata = shost_priv(instance);
1215 1216 1217
	unsigned char tmp[3], phase;
	unsigned char *data;
	int len;
F
Finn Thain 已提交
1218
	int err;
1219

1220
	NCR5380_dprint(NDEBUG_ARBITRATION, instance);
1221 1222
	dsprintk(NDEBUG_ARBITRATION, instance, "starting arbitration, id = %d\n",
	         instance->this_id);
1223

1224 1225 1226 1227 1228 1229 1230 1231 1232
	/*
	 * Arbitration and selection phases are slow and involve dropping the
	 * lock, so we have to watch out for EH. An exception handler may
	 * change 'selecting' to NULL. This function will then return NULL
	 * so that the caller will forget about 'cmd'. (During information
	 * transfer phases, EH may change 'connected' to NULL.)
	 */
	hostdata->selecting = cmd;

1233 1234 1235 1236 1237 1238
	/*
	 * Set the phase bits to 0, otherwise the NCR5380 won't drive the
	 * data bus during SELECTION.
	 */

	NCR5380_write(TARGET_COMMAND_REG, 0);
L
Linus Torvalds 已提交
1239

1240 1241 1242
	/*
	 * Start arbitration.
	 */
L
Linus Torvalds 已提交
1243

1244 1245
	NCR5380_write(OUTPUT_DATA_REG, hostdata->id_mask);
	NCR5380_write(MODE_REG, MR_ARBITRATE);
L
Linus Torvalds 已提交
1246

1247 1248 1249
	/* The chip now waits for BUS FREE phase. Then after the 800 ns
	 * Bus Free Delay, arbitration will begin.
	 */
1250

1251
	spin_unlock_irq(&hostdata->lock);
1252 1253 1254
	err = NCR5380_poll_politely2(instance, MODE_REG, MR_ARBITRATE, 0,
	                INITIATOR_COMMAND_REG, ICR_ARBITRATION_PROGRESS,
	                                       ICR_ARBITRATION_PROGRESS, HZ);
1255
	spin_lock_irq(&hostdata->lock);
1256 1257
	if (!(NCR5380_read(MODE_REG) & MR_ARBITRATE)) {
		/* Reselection interrupt */
1258
		goto out;
1259 1260 1261 1262 1263
	}
	if (err < 0) {
		NCR5380_write(MODE_REG, MR_BASE);
		shost_printk(KERN_ERR, instance,
		             "select: arbitration timeout\n");
1264
		goto out;
1265
	}
1266
	spin_unlock_irq(&hostdata->lock);
1267

1268
	/* The SCSI-2 arbitration delay is 2.4 us */
1269 1270 1271 1272 1273
	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) ||
1274
	    (NCR5380_read(INITIATOR_COMMAND_REG) & ICR_ARBITRATION_LOST)) {
1275
		NCR5380_write(MODE_REG, MR_BASE);
1276
		dsprintk(NDEBUG_ARBITRATION, instance, "lost arbitration, deasserting MR_ARBITRATE\n");
1277
		spin_lock_irq(&hostdata->lock);
1278
		goto out;
1279
	}
L
Linus Torvalds 已提交
1280

1281 1282 1283 1284
	/* 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)
	 */
1285 1286 1287 1288 1289 1290 1291
	NCR5380_write(INITIATOR_COMMAND_REG,
		      ICR_BASE | ICR_ASSERT_SEL | ICR_ASSERT_BSY);

	/*
	 * Again, bus clear + bus settle time is 1.2us, however, this is
	 * a minimum so we'll udelay ceil(1.2)
	 */
L
Linus Torvalds 已提交
1292

1293 1294 1295 1296
	if (hostdata->flags & FLAG_TOSHIBA_DELAY)
		udelay(15);
	else
		udelay(2);
1297

1298 1299
	spin_lock_irq(&hostdata->lock);

1300 1301
	/* NCR5380_reselect() clears MODE_REG after a reselection interrupt */
	if (!(NCR5380_read(MODE_REG) & MR_ARBITRATE))
1302 1303 1304 1305 1306 1307 1308
		goto out;

	if (!hostdata->selecting) {
		NCR5380_write(MODE_REG, MR_BASE);
		NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
		goto out;
	}
1309

1310
	dsprintk(NDEBUG_ARBITRATION, instance, "won arbitration\n");
1311 1312 1313 1314 1315 1316

	/*
	 * Now that we have won arbitration, start Selection process, asserting
	 * the host and target ID's on the SCSI bus.
	 */

1317
	NCR5380_write(OUTPUT_DATA_REG, hostdata->id_mask | (1 << scmd_id(cmd)));
1318 1319 1320 1321 1322 1323 1324

	/*
	 * 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.
	 */

1325 1326
	NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_BSY |
	              ICR_ASSERT_DATA | ICR_ASSERT_ATN | ICR_ASSERT_SEL);
L
Linus Torvalds 已提交
1327 1328
	NCR5380_write(MODE_REG, MR_BASE);

1329 1330 1331 1332 1333
	/*
	 * Reselect interrupts must be turned off prior to the dropping of BSY,
	 * otherwise we will trigger an interrupt.
	 */
	NCR5380_write(SELECT_ENABLE_REG, 0);
L
Linus Torvalds 已提交
1334

1335 1336
	spin_unlock_irq(&hostdata->lock);

1337 1338 1339 1340 1341 1342 1343
	/*
	 * 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 */
1344 1345
	NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_DATA |
	              ICR_ASSERT_ATN | ICR_ASSERT_SEL);
1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362

	/*
	 * 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.
	 */
L
Linus Torvalds 已提交
1363

1364
	udelay(1);
L
Linus Torvalds 已提交
1365

1366
	dsprintk(NDEBUG_SELECTION, instance, "selecting target %d\n", scmd_id(cmd));
L
Linus Torvalds 已提交
1367

1368 1369 1370 1371
	/*
	 * The SCSI specification calls for a 250 ms timeout for the actual
	 * selection.
	 */
L
Linus Torvalds 已提交
1372

F
Finn Thain 已提交
1373 1374
	err = NCR5380_poll_politely(instance, STATUS_REG, SR_BSY, SR_BSY,
	                            msecs_to_jiffies(250));
1375 1376

	if ((NCR5380_read(STATUS_REG) & (SR_SEL | SR_IO)) == (SR_SEL | SR_IO)) {
1377
		spin_lock_irq(&hostdata->lock);
1378 1379
		NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
		NCR5380_reselect(instance);
1380 1381
		if (!hostdata->connected)
			NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
1382
		shost_printk(KERN_ERR, instance, "reselection after won arbitration?\n");
1383
		goto out;
1384
	}
L
Linus Torvalds 已提交
1385

F
Finn Thain 已提交
1386
	if (err < 0) {
1387
		spin_lock_irq(&hostdata->lock);
1388 1389
		NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
		NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
1390 1391 1392 1393 1394 1395 1396 1397
		/* Can't touch cmd if it has been reclaimed by the scsi ML */
		if (hostdata->selecting) {
			cmd->result = DID_BAD_TARGET << 16;
			complete_cmd(instance, cmd);
			dsprintk(NDEBUG_SELECTION, instance, "target did not respond within 250ms\n");
			cmd = NULL;
		}
		goto out;
1398 1399
	}

F
Finn Thain 已提交
1400 1401 1402 1403 1404 1405 1406 1407 1408 1409
	/*
	 * 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
	 */

	udelay(1);

	NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN);

1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420
	/*
	 * 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,
1421 1422
	 * which claim to support tagged queuing but fail when more than
	 * some number of commands are issued at once.
1423 1424 1425
	 */

	/* Wait for start of REQ/ACK handshake */
1426 1427

	err = NCR5380_poll_politely(instance, STATUS_REG, SR_REQ, SR_REQ, HZ);
1428
	spin_lock_irq(&hostdata->lock);
1429 1430 1431 1432
	if (err < 0) {
		shost_printk(KERN_ERR, instance, "select: REQ timeout\n");
		NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
		NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
1433 1434 1435 1436 1437
		goto out;
	}
	if (!hostdata->selecting) {
		do_abort(instance);
		goto out;
1438
	}
1439

1440 1441
	dsprintk(NDEBUG_SELECTION, instance, "target %d selected, going into MESSAGE OUT phase.\n",
	         scmd_id(cmd));
1442
	tmp[0] = IDENTIFY(1, cmd->device->lun);
L
Linus Torvalds 已提交
1443 1444

#ifdef SUPPORT_TAGS
1445 1446 1447 1448 1449 1450
	if (cmd->tag != TAG_NONE) {
		tmp[1] = hostdata->last_message = SIMPLE_QUEUE_TAG;
		tmp[2] = cmd->tag;
		len = 3;
	} else
		len = 1;
L
Linus Torvalds 已提交
1451
#else
1452 1453
	len = 1;
	cmd->tag = 0;
L
Linus Torvalds 已提交
1454 1455
#endif /* SUPPORT_TAGS */

1456 1457 1458 1459
	/* Send message(s) */
	data = tmp;
	phase = PHASE_MSGOUT;
	NCR5380_transfer_pio(instance, &phase, &len, &data);
1460
	dsprintk(NDEBUG_SELECTION, instance, "nexus established.\n");
1461
	/* XXX need to handle errors here */
1462

1463
	hostdata->connected = cmd;
L
Linus Torvalds 已提交
1464
#ifndef SUPPORT_TAGS
1465
	hostdata->busy[cmd->device->id] |= 1 << cmd->device->lun;
1466
#endif
1467 1468 1469
#ifdef SUN3_SCSI_VME
	dregs->csr |= CSR_INTR;
#endif
L
Linus Torvalds 已提交
1470

1471
	initialize_SCp(cmd);
L
Linus Torvalds 已提交
1472

1473 1474 1475 1476 1477 1478 1479
	cmd = NULL;

out:
	if (!hostdata->selecting)
		return NULL;
	hostdata->selecting = NULL;
	return cmd;
L
Linus Torvalds 已提交
1480 1481
}

1482 1483
/*
 * Function : int NCR5380_transfer_pio (struct Scsi_Host *instance,
1484
 * unsigned char *phase, int *count, unsigned char **data)
L
Linus Torvalds 已提交
1485 1486 1487
 *
 * Purpose : transfers data in given phase using polled I/O
 *
1488
 * Inputs : instance - instance of driver, *phase - pointer to
1489 1490
 * what phase is expected, *count - pointer to number of
 * bytes to transfer, **data - pointer to data pointer.
1491
 *
L
Linus Torvalds 已提交
1492
 * Returns : -1 when different phase is entered without transferring
1493 1494
 * maximum number of bytes, 0 if all bytes are transferred or exit
 * is in same phase.
L
Linus Torvalds 已提交
1495
 *
1496
 * Also, *phase, *count, *data are modified in place.
L
Linus Torvalds 已提交
1497 1498 1499 1500 1501
 *
 * XXX Note : handling for bus free may be useful.
 */

/*
1502
 * Note : this code is not as quick as it could be, however it
L
Linus Torvalds 已提交
1503 1504 1505 1506
 * IS 100% reliable, and for the actual data transfer where speed
 * counts, we will always do a pseudo DMA or DMA transfer.
 */

1507 1508 1509
static int NCR5380_transfer_pio(struct Scsi_Host *instance,
				unsigned char *phase, int *count,
				unsigned char **data)
L
Linus Torvalds 已提交
1510
{
1511 1512 1513
	unsigned char p = *phase, tmp;
	int c = *count;
	unsigned char *d = *data;
1514 1515 1516 1517 1518

	/*
	 * 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
L
Linus Torvalds 已提交
1519 1520
	 */

1521
	NCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(p));
L
Linus Torvalds 已提交
1522

1523 1524 1525 1526 1527
	do {
		/*
		 * Wait for assertion of REQ, after which the phase bits will be
		 * valid
		 */
1528 1529 1530

		if (NCR5380_poll_politely(instance, STATUS_REG, SR_REQ, SR_REQ, HZ) < 0)
			break;
L
Linus Torvalds 已提交
1531

1532
		dsprintk(NDEBUG_HANDSHAKE, instance, "REQ asserted\n");
L
Linus Torvalds 已提交
1533

1534
		/* Check for phase mismatch */
1535
		if ((NCR5380_read(STATUS_REG) & PHASE_MASK) != p) {
1536
			dsprintk(NDEBUG_PIO, instance, "phase mismatch\n");
1537
			NCR5380_dprint_phase(NDEBUG_PIO, instance);
1538 1539
			break;
		}
L
Linus Torvalds 已提交
1540

1541 1542 1543 1544 1545
		/* 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);
L
Linus Torvalds 已提交
1546

1547
		++d;
L
Linus Torvalds 已提交
1548

1549 1550 1551 1552 1553 1554
		/*
		 * 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.
		 */
L
Linus Torvalds 已提交
1555

1556 1557 1558
		if (!(p & SR_IO)) {
			if (!((p & SR_MSG) && c > 1)) {
				NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_DATA);
1559
				NCR5380_dprint(NDEBUG_PIO, instance);
1560
				NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE |
1561
				              ICR_ASSERT_DATA | ICR_ASSERT_ACK);
1562 1563
			} else {
				NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE |
1564
				              ICR_ASSERT_DATA | ICR_ASSERT_ATN);
1565
				NCR5380_dprint(NDEBUG_PIO, instance);
1566
				NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE |
1567
				              ICR_ASSERT_DATA | ICR_ASSERT_ATN | ICR_ASSERT_ACK);
1568 1569
			}
		} else {
1570
			NCR5380_dprint(NDEBUG_PIO, instance);
1571 1572
			NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ACK);
		}
L
Linus Torvalds 已提交
1573

1574 1575 1576
		if (NCR5380_poll_politely(instance,
		                          STATUS_REG, SR_REQ, 0, 5 * HZ) < 0)
			break;
1577

1578
		dsprintk(NDEBUG_HANDSHAKE, instance, "REQ negated, handshake complete\n");
1579

1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590
/*
 * 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.
 */
1591 1592 1593 1594 1595 1596 1597 1598
		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);

1599
	dsprintk(NDEBUG_PIO, instance, "residual %d\n", c);
1600 1601 1602 1603 1604

	*count = c;
	*data = d;
	tmp = NCR5380_read(STATUS_REG);
	/* The phase read from the bus is valid if either REQ is (already)
1605 1606
	 * asserted or if ACK hasn't been released yet. The latter applies if
	 * we're in MSG IN, DATA IN or STATUS and all bytes have been received.
1607
	 */
1608
	if ((tmp & SR_REQ) || ((tmp & SR_IO) && c == 0))
1609 1610 1611 1612 1613 1614 1615 1616
		*phase = tmp & PHASE_MASK;
	else
		*phase = PHASE_UNKNOWN;

	if (!c || (*phase == p))
		return 0;
	else
		return -1;
L
Linus Torvalds 已提交
1617 1618
}

1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644
/**
 * do_reset - issue a reset command
 * @instance: adapter to reset
 *
 * Issue a reset sequence to the NCR5380 and try and get the bus
 * back into sane shape.
 *
 * This clears the reset interrupt flag because there may be no handler for
 * it. When the driver is initialized, the NCR5380_intr() handler has not yet
 * been installed. And when in EH we may have released the ST DMA interrupt.
 */

static void do_reset(struct Scsi_Host *instance)
{
	unsigned long flags;

	local_irq_save(flags);
	NCR5380_write(TARGET_COMMAND_REG,
	              PHASE_SR_TO_TCR(NCR5380_read(STATUS_REG) & PHASE_MASK));
	NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_RST);
	udelay(50);
	NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
	(void)NCR5380_read(RESET_PARITY_INTERRUPT_REG);
	local_irq_restore(flags);
}

1645 1646 1647 1648
/**
 * do_abort - abort the currently established nexus by going to
 * MESSAGE OUT phase and sending an ABORT message.
 * @instance: relevant scsi host instance
1649
 *
1650
 * Returns 0 on success, -1 on failure.
L
Linus Torvalds 已提交
1651 1652
 */

1653
static int do_abort(struct Scsi_Host *instance)
L
Linus Torvalds 已提交
1654
{
1655
	unsigned char *msgptr, phase, tmp;
1656
	int len;
1657
	int rc;
1658 1659

	/* Request message out phase */
L
Linus Torvalds 已提交
1660
	NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN);
1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671

	/*
	 * 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.
	 */

1672 1673 1674 1675 1676
	rc = NCR5380_poll_politely(instance, STATUS_REG, SR_REQ, SR_REQ, 10 * HZ);
	if (rc < 0)
		goto timeout;

	tmp = NCR5380_read(STATUS_REG) & PHASE_MASK;
1677 1678 1679

	NCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(tmp));

1680 1681 1682 1683 1684 1685
	if (tmp != PHASE_MSGOUT) {
		NCR5380_write(INITIATOR_COMMAND_REG,
		              ICR_BASE | ICR_ASSERT_ATN | ICR_ASSERT_ACK);
		rc = NCR5380_poll_politely(instance, STATUS_REG, SR_REQ, 0, 3 * HZ);
		if (rc < 0)
			goto timeout;
1686 1687 1688 1689 1690 1691 1692
		NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN);
	}

	tmp = ABORT;
	msgptr = &tmp;
	len = 1;
	phase = PHASE_MSGOUT;
1693
	NCR5380_transfer_pio(instance, &phase, &len, &msgptr);
1694 1695 1696 1697 1698 1699 1700

	/*
	 * If we got here, and the command completed successfully,
	 * we're about to go into bus free state.
	 */

	return len ? -1 : 0;
1701 1702 1703 1704

timeout:
	NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
	return -1;
L
Linus Torvalds 已提交
1705 1706 1707
}

#if defined(REAL_DMA)
1708 1709
/*
 * Function : int NCR5380_transfer_dma (struct Scsi_Host *instance,
1710
 * unsigned char *phase, int *count, unsigned char **data)
L
Linus Torvalds 已提交
1711 1712
 *
 * Purpose : transfers data in given phase using either real
1713
 * or pseudo DMA.
L
Linus Torvalds 已提交
1714
 *
1715
 * Inputs : instance - instance of driver, *phase - pointer to
1716 1717
 * what phase is expected, *count - pointer to number of
 * bytes to transfer, **data - pointer to data pointer.
1718
 *
L
Linus Torvalds 已提交
1719
 * Returns : -1 when different phase is entered without transferring
1720 1721
 * maximum number of bytes, 0 if all bytes or transferred or exit
 * is in same phase.
L
Linus Torvalds 已提交
1722
 *
1723
 * Also, *phase, *count, *data are modified in place.
L
Linus Torvalds 已提交
1724 1725 1726
 */


1727 1728 1729
static int NCR5380_transfer_dma(struct Scsi_Host *instance,
				unsigned char *phase, int *count,
				unsigned char **data)
L
Linus Torvalds 已提交
1730
{
F
Finn Thain 已提交
1731
	struct NCR5380_hostdata *hostdata = shost_priv(instance);
1732 1733
	register int c = *count;
	register unsigned char p = *phase;
1734 1735 1736 1737 1738 1739 1740 1741 1742 1743

#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;

1744 1745
	dsprintk(NDEBUG_DMA, instance, "initializing DMA %s: length %d, address %p\n",
	         (p & SR_IO) ? "receive" : "send", c, *data);
1746 1747 1748 1749 1750 1751

	/* netbsd turns off ints here, why not be safe and do it too */

	/* send start chain */
	sun3scsi_dma_start(c, *data);

1752 1753 1754
	NCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(p));
	NCR5380_write(MODE_REG, MR_BASE | MR_DMA_MODE | MR_MONITOR_BSY |
	                        MR_ENABLE_EOP_INTR);
1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769
	if (p & SR_IO) {
		NCR5380_write(INITIATOR_COMMAND_REG, 0);
		NCR5380_write(START_DMA_INITIATOR_RECEIVE_REG, 0);
	} else {
		NCR5380_write(INITIATOR_COMMAND_REG, ICR_ASSERT_DATA);
		NCR5380_write(START_DMA_SEND_REG, 0);
	}

#ifdef SUN3_SCSI_VME
	dregs->csr |= CSR_DMA_ENABLE;
#endif

	sun3_dma_active = 1;

#else /* !defined(CONFIG_SUN3) */
1770 1771 1772 1773 1774 1775 1776
	register unsigned char *d = *data;
	unsigned char tmp;

	if ((tmp = (NCR5380_read(STATUS_REG) & PHASE_MASK)) != p) {
		*phase = tmp;
		return -1;
	}
L
Linus Torvalds 已提交
1777

1778 1779
	if (hostdata->read_overruns && (p & SR_IO))
		c -= hostdata->read_overruns;
L
Linus Torvalds 已提交
1780

1781 1782
	dsprintk(NDEBUG_DMA, instance, "initializing DMA %s: length %d, address %p\n",
	         (p & SR_IO) ? "receive" : "send", c, d);
L
Linus Torvalds 已提交
1783

1784
	NCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(p));
1785 1786
	NCR5380_write(MODE_REG, MR_BASE | MR_DMA_MODE | MR_MONITOR_BSY |
	                        MR_ENABLE_EOP_INTR);
L
Linus Torvalds 已提交
1787

1788
	if (!(hostdata->flags & FLAG_LATE_DMA_SETUP)) {
1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803
		/* On the Medusa, it is a must to initialize the DMA before
		 * starting the NCR. This is also the cleaner way for the TT.
		 */
		hostdata->dma_len = (p & SR_IO) ?
			NCR5380_dma_read_setup(instance, d, c) :
			NCR5380_dma_write_setup(instance, d, c);
	}

	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);
	}

1804
	if (hostdata->flags & FLAG_LATE_DMA_SETUP) {
1805 1806 1807 1808 1809 1810 1811
		/* On the Falcon, the DMA setup must be done after the last */
		/* NCR access, else the DMA setup gets trashed!
		 */
		hostdata->dma_len = (p & SR_IO) ?
			NCR5380_dma_read_setup(instance, d, c) :
			NCR5380_dma_write_setup(instance, d, c);
	}
1812 1813
#endif /* !defined(CONFIG_SUN3) */

1814
	return 0;
L
Linus Torvalds 已提交
1815 1816 1817 1818 1819 1820
}
#endif /* defined(REAL_DMA) */

/*
 * Function : NCR5380_information_transfer (struct Scsi_Host *instance)
 *
1821
 * Purpose : run through the various SCSI phases and do as the target
1822 1823
 * directs us to.  Operates on the currently connected command,
 * instance->connected.
L
Linus Torvalds 已提交
1824 1825 1826
 *
 * Inputs : instance, instance for which we are doing commands
 *
1827
 * Side effects : SCSI things happen, the disconnected queue will be
1828 1829
 * modified if a command disconnects, *instance->connected will
 * change.
L
Linus Torvalds 已提交
1830
 *
1831
 * XXX Note : we need to watch for bus free or a reset condition here
1832
 * to recover from an unexpected bus free condition.
L
Linus Torvalds 已提交
1833
 */
1834 1835

static void NCR5380_information_transfer(struct Scsi_Host *instance)
L
Linus Torvalds 已提交
1836
{
F
Finn Thain 已提交
1837
	struct NCR5380_hostdata *hostdata = shost_priv(instance);
1838 1839 1840 1841 1842 1843
	unsigned char msgout = NOP;
	int sink = 0;
	int len;
	int transfersize;
	unsigned char *data;
	unsigned char phase, tmp, extended_msg[10], old_phase = 0xff;
1844
	struct scsi_cmnd *cmd;
1845

1846 1847 1848 1849
#ifdef SUN3_SCSI_VME
	dregs->csr |= CSR_INTR;
#endif

1850
	while ((cmd = hostdata->connected)) {
1851 1852
		struct NCR5380_cmd *ncmd = scsi_cmd_priv(cmd);

1853 1854 1855 1856 1857 1858
		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;
1859
				NCR5380_dprint_phase(NDEBUG_INFORMATION, instance);
1860
			}
1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876
#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) {
1877
						sun3scsi_dma_setup(instance, d, count,
1878 1879 1880 1881 1882 1883 1884 1885 1886 1887
						                   rq_data_dir(cmd->request));
						sun3_dma_setup_done = cmd;
					}
				}
#endif
#ifdef SUN3_SCSI_VME
				dregs->csr |= CSR_INTR;
#endif
			}
#endif /* CONFIG_SUN3 */
L
Linus Torvalds 已提交
1888

1889 1890 1891 1892
			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 |
1893
				              ICR_ASSERT_ACK);
1894 1895 1896
				while (NCR5380_read(STATUS_REG) & SR_REQ)
					;
				NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE |
1897
				              ICR_ASSERT_ATN);
1898 1899 1900 1901 1902 1903
				sink = 0;
				continue;
			}

			switch (phase) {
			case PHASE_DATAOUT:
L
Linus Torvalds 已提交
1904
#if (NDEBUG & NDEBUG_NO_DATAOUT)
1905
				shost_printk(KERN_DEBUG, instance, "NDEBUG_NO_DATAOUT set, attempted DATAOUT aborted\n");
1906 1907 1908
				sink = 1;
				do_abort(instance);
				cmd->result = DID_ERROR << 16;
1909
				complete_cmd(instance, cmd);
1910
				return;
L
Linus Torvalds 已提交
1911
#endif
1912 1913 1914 1915 1916 1917 1918 1919 1920 1921
			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;
J
Jens Axboe 已提交
1922
					cmd->SCp.ptr = sg_virt(cmd->SCp.buffer);
1923
					merge_contiguous_buffers(cmd);
1924 1925 1926
					dsprintk(NDEBUG_INFORMATION, instance, "%d bytes and %d buffers left\n",
					         cmd->SCp.this_residual,
					         cmd->SCp.buffers_residual);
1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939
				}

				/*
				 * 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
1940
				 * #if def(REAL_DMA)
1941 1942
				 * instead of leaving REAL_DMA out.
				 */
L
Linus Torvalds 已提交
1943 1944

#if defined(REAL_DMA)
1945
#if !defined(CONFIG_SUN3)
1946 1947
				transfersize = 0;
				if (!cmd->device->borken)
1948
#endif
1949 1950 1951
					transfersize = NCR5380_dma_xfer_len(instance, cmd, phase);

				if (transfersize >= DMA_MIN_SIZE) {
1952 1953 1954 1955 1956 1957 1958
					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
F
Finn Thain 已提交
1959 1960
						 * polled-IO.
						 */
F
Finn Thain 已提交
1961 1962
						scmd_printk(KERN_INFO, cmd,
							"switching to slow handshake\n");
1963 1964 1965 1966
						cmd->device->borken = 1;
						sink = 1;
						do_abort(instance);
						cmd->result = DID_ERROR << 16;
1967
						complete_cmd(instance, cmd);
1968 1969
						/* XXX - need to source or sink data here, as appropriate */
					} else {
L
Linus Torvalds 已提交
1970
#ifdef REAL_DMA
1971 1972 1973 1974 1975 1976 1977 1978
						/* ++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;
L
Linus Torvalds 已提交
1979
#endif
1980 1981
					}
				} else
L
Linus Torvalds 已提交
1982
#endif /* defined(REAL_DMA) */
1983
				{
1984 1985 1986 1987 1988 1989 1990
					/* Break up transfer into 3 ms chunks,
					 * presuming 6 accesses per handshake.
					 */
					transfersize = min((unsigned long)cmd->SCp.this_residual,
					                   hostdata->accesses_per_ms / 2);
					len = transfersize;
					NCR5380_transfer_pio(instance, &phase, &len,
1991
					                     (unsigned char **)&cmd->SCp.ptr);
1992
					cmd->SCp.this_residual -= transfersize - len;
1993
				}
1994 1995 1996 1997 1998
#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
1999
				return;
2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010
			case PHASE_MSGIN:
				len = 1;
				data = &tmp;
				NCR5380_transfer_pio(instance, &phase, &len, &data);
				cmd->SCp.Message = tmp;

				switch (tmp) {
				case ABORT:
				case COMMAND_COMPLETE:
					/* Accept message by clearing ACK */
					NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
2011 2012 2013
					dsprintk(NDEBUG_QUEUES, instance,
					         "COMMAND COMPLETE %p target %d lun %llu\n",
					         cmd, scmd_id(cmd), cmd->device->lun);
2014 2015

					hostdata->connected = NULL;
L
Linus Torvalds 已提交
2016
#ifdef SUPPORT_TAGS
2017 2018
					cmd_free_tag(cmd);
					if (status_byte(cmd->SCp.Status) == QUEUE_FULL) {
2019 2020 2021 2022 2023 2024
						u8 lun = cmd->device->lun;
						struct tag_alloc *ta = &hostdata->TagAlloc[scmd_id(cmd)][lun];

						dsprintk(NDEBUG_TAGS, instance,
						         "QUEUE_FULL %p target %d lun %d nr_allocated %d\n",
						         cmd, scmd_id(cmd), lun, ta->nr_allocated);
2025
						if (ta->queue_size > ta->nr_allocated)
F
Finn Thain 已提交
2026
							ta->queue_size = ta->nr_allocated;
2027
					}
L
Linus Torvalds 已提交
2028
#endif
2029

F
Finn Thain 已提交
2030 2031 2032
					cmd->result &= ~0xffff;
					cmd->result |= cmd->SCp.Status;
					cmd->result |= cmd->SCp.Message << 8;
2033

F
Finn Thain 已提交
2034
					if (cmd->cmnd[0] == REQUEST_SENSE)
2035
						complete_cmd(instance, cmd);
F
Finn Thain 已提交
2036 2037 2038 2039 2040 2041 2042 2043 2044
					else {
						if (cmd->SCp.Status == SAM_STAT_CHECK_CONDITION ||
						    cmd->SCp.Status == SAM_STAT_COMMAND_TERMINATED) {
							dsprintk(NDEBUG_QUEUES, instance, "autosense: adding cmd %p to tail of autosense queue\n",
							         cmd);
							list_add_tail(&ncmd->list,
							              &hostdata->autosense);
						} else
							complete_cmd(instance, cmd);
2045 2046 2047 2048 2049 2050 2051 2052
					}

					/*
					 * Restore phase bits to 0 so an interrupted selection,
					 * arbitration can resume.
					 */
					NCR5380_write(TARGET_COMMAND_REG, 0);

2053 2054 2055
					/* Enable reselect interrupts */
					NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);

2056
					maybe_release_dma_irq(instance);
2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073
					return;
				case MESSAGE_REJECT:
					/* Accept message by clearing ACK */
					NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
					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;
2074 2075
						dsprintk(NDEBUG_TAGS, instance, "target %d lun %llu rejected QUEUE_TAG message; tagged queuing disabled\n",
						         scmd_id(cmd), cmd->device->lun);
2076 2077 2078 2079 2080 2081 2082
						break;
					}
					break;
				case DISCONNECT:
					/* Accept message by clearing ACK */
					NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
					hostdata->connected = NULL;
2083
					list_add(&ncmd->list, &hostdata->disconnected);
2084 2085 2086 2087
					dsprintk(NDEBUG_INFORMATION | NDEBUG_QUEUES,
					         instance, "connected command %p for target %d lun %llu moved to disconnected queue\n",
					         cmd, scmd_id(cmd), cmd->device->lun);

2088 2089 2090 2091 2092 2093 2094 2095
					/*
					 * 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);
2096 2097 2098
#ifdef SUN3_SCSI_VME
					dregs->csr |= CSR_DMA_ENABLE;
#endif
2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116
					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);
					break;
				case EXTENDED_MESSAGE:
					/*
F
Finn Thain 已提交
2117
					 * Start the message buffer with the EXTENDED_MESSAGE
2118 2119 2120 2121 2122 2123
					 * 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);

2124 2125
					spin_unlock_irq(&hostdata->lock);

2126
					dsprintk(NDEBUG_EXTENDED, instance, "receiving extended message\n");
2127 2128 2129 2130 2131

					len = 2;
					data = extended_msg + 1;
					phase = PHASE_MSGIN;
					NCR5380_transfer_pio(instance, &phase, &len, &data);
2132 2133 2134
					dsprintk(NDEBUG_EXTENDED, instance, "length %d, code 0x%02x\n",
					         (int)extended_msg[1],
					         (int)extended_msg[2]);
2135

2136 2137
					if (!len && extended_msg[1] > 0 &&
					    extended_msg[1] <= sizeof(extended_msg) - 2) {
2138 2139 2140 2141 2142 2143 2144
						/* 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);
2145 2146
						dsprintk(NDEBUG_EXTENDED, instance, "message received, residual %d\n",
						         len);
2147 2148 2149 2150 2151 2152 2153 2154 2155

						switch (extended_msg[2]) {
						case EXTENDED_SDTR:
						case EXTENDED_WDTR:
						case EXTENDED_MODIFY_DATA_POINTER:
						case EXTENDED_EXTENDED_IDENTIFY:
							tmp = 0;
						}
					} else if (len) {
2156
						shost_printk(KERN_ERR, instance, "error receiving extended message\n");
2157 2158
						tmp = 0;
					} else {
2159 2160
						shost_printk(KERN_NOTICE, instance, "extended message code %02x length %d is too long\n",
						             extended_msg[2], extended_msg[1]);
2161 2162
						tmp = 0;
					}
2163 2164 2165 2166 2167

					spin_lock_irq(&hostdata->lock);
					if (!hostdata->connected)
						return;

2168 2169 2170 2171 2172 2173 2174 2175
					/* Fall through to reject message */

					/*
					 * If we get something weird that we aren't expecting,
					 * reject it.
					 */
				default:
					if (!tmp) {
2176
						shost_printk(KERN_ERR, instance, "rejecting message ");
2177 2178 2179
						spi_print_msg(extended_msg);
						printk("\n");
					} else if (tmp != EXTENDED_MESSAGE)
F
Finn Thain 已提交
2180 2181 2182
						scmd_printk(KERN_INFO, cmd,
						            "rejecting unknown message %02x\n",
						            tmp);
2183
					else
F
Finn Thain 已提交
2184 2185 2186
						scmd_printk(KERN_INFO, cmd,
						            "rejecting unknown extended message code %02x, length %d\n",
						            extended_msg[1], extended_msg[0]);
2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200

					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) {
					hostdata->connected = NULL;
					cmd->result = DID_ERROR << 16;
2201
					complete_cmd(instance, cmd);
2202
					maybe_release_dma_irq(instance);
2203
					NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224
					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:
2225
				shost_printk(KERN_ERR, instance, "unknown phase\n");
2226
				NCR5380_dprint(NDEBUG_ANY, instance);
2227
			} /* switch(phase) */
2228
		} else {
2229
			spin_unlock_irq(&hostdata->lock);
2230
			NCR5380_poll_politely(instance, STATUS_REG, SR_REQ, SR_REQ, HZ);
2231
			spin_lock_irq(&hostdata->lock);
2232
		}
2233
	}
L
Linus Torvalds 已提交
2234 2235 2236 2237 2238
}

/*
 * Function : void NCR5380_reselect (struct Scsi_Host *instance)
 *
2239
 * Purpose : does reselection, initializing the instance->connected
2240 2241
 * field to point to the scsi_cmnd for which the I_T_L or I_T_L_Q
 * nexus has been reestablished,
2242
 *
L
Linus Torvalds 已提交
2243 2244 2245 2246
 * Inputs : instance - this instance of the NCR5380.
 */


2247 2248 2249
/* it might eventually prove necessary to do a dma setup on
   reselection, but it doesn't seem to be needed now -- sam */

2250
static void NCR5380_reselect(struct Scsi_Host *instance)
L
Linus Torvalds 已提交
2251
{
F
Finn Thain 已提交
2252
	struct NCR5380_hostdata *hostdata = shost_priv(instance);
2253
	unsigned char target_mask;
2254
	unsigned char lun;
L
Linus Torvalds 已提交
2255
#ifdef SUPPORT_TAGS
2256
	unsigned char tag;
L
Linus Torvalds 已提交
2257
#endif
2258
	unsigned char msg[3];
2259 2260
	int __maybe_unused len;
	unsigned char __maybe_unused *data, __maybe_unused phase;
2261 2262
	struct NCR5380_cmd *ncmd;
	struct scsi_cmnd *tmp;
2263 2264 2265 2266 2267 2268 2269 2270 2271 2272

	/*
	 * Disable arbitration, etc. since the host adapter obviously
	 * lost, and tell an interrupted NCR5380_select() to restart.
	 */

	NCR5380_write(MODE_REG, MR_BASE);

	target_mask = NCR5380_read(CURRENT_SCSI_DATA_REG) & ~(hostdata->id_mask);

2273
	dsprintk(NDEBUG_RESELECTION, instance, "reselect\n");
2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284

	/*
	 * 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);
2285 2286 2287 2288 2289
	if (NCR5380_poll_politely(instance,
	                          STATUS_REG, SR_SEL, 0, 2 * HZ) < 0) {
		NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
		return;
	}
2290 2291 2292 2293 2294 2295
	NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);

	/*
	 * Wait for target to go into MSGIN.
	 */

2296 2297 2298 2299 2300
	if (NCR5380_poll_politely(instance,
	                          STATUS_REG, SR_REQ, SR_REQ, 2 * HZ) < 0) {
		do_abort(instance);
		return;
	}
2301

2302 2303 2304 2305 2306 2307 2308
#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
2309 2310 2311 2312
	len = 1;
	data = msg;
	phase = PHASE_MSGIN;
	NCR5380_transfer_pio(instance, &phase, &len, &data);
2313 2314 2315 2316 2317

	if (len) {
		do_abort(instance);
		return;
	}
2318
#endif
2319 2320

	if (!(msg[0] & 0x80)) {
2321
		shost_printk(KERN_ERR, instance, "expecting IDENTIFY message, got ");
2322
		spi_print_msg(msg);
2323
		printk("\n");
2324 2325 2326
		do_abort(instance);
		return;
	}
2327
	lun = msg[0] & 0x07;
L
Linus Torvalds 已提交
2328

2329
#if defined(SUPPORT_TAGS) && !defined(CONFIG_SUN3)
2330 2331 2332 2333 2334
	/* 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;
2335
	if (phase == PHASE_MSGIN && (hostdata->flags & FLAG_TAGGED_QUEUING)) {
2336 2337 2338 2339 2340 2341 2342
		/* 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];
2343 2344
		dsprintk(NDEBUG_TAGS, instance, "reselect: target mask %02x, lun %d sent tag %d\n",
		         target_mask, lun, tag);
2345
	}
L
Linus Torvalds 已提交
2346
#endif
2347 2348 2349 2350 2351 2352

	/*
	 * 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.
	 */

2353 2354 2355 2356 2357 2358
	tmp = NULL;
	list_for_each_entry(ncmd, &hostdata->disconnected, list) {
		struct scsi_cmnd *cmd = NCR5380_to_scmd(ncmd);

		if (target_mask == (1 << scmd_id(cmd)) &&
		    lun == (u8)cmd->device->lun
L
Linus Torvalds 已提交
2359
#ifdef SUPPORT_TAGS
2360
		    && (tag == cmd->tag)
L
Linus Torvalds 已提交
2361
#endif
2362
		    ) {
2363 2364
			list_del(&ncmd->list);
			tmp = cmd;
2365 2366
			break;
		}
L
Linus Torvalds 已提交
2367
	}
2368

2369 2370 2371 2372 2373
	if (tmp) {
		dsprintk(NDEBUG_RESELECTION | NDEBUG_QUEUES, instance,
		         "reselect: removed %p from disconnected queue\n", tmp);
	} else {

L
Linus Torvalds 已提交
2374
#ifdef SUPPORT_TAGS
2375 2376 2377 2378 2379
		shost_printk(KERN_ERR, instance, "target bitmask 0x%02x lun %d tag %d not in disconnected queue.\n",
		             target_mask, lun, tag);
#else
		shost_printk(KERN_ERR, instance, "target bitmask 0x%02x lun %d not in disconnected queue.\n",
		             target_mask, lun);
L
Linus Torvalds 已提交
2380
#endif
2381 2382 2383 2384 2385 2386 2387
		/*
		 * Since we have an established nexus that we can't do anything
		 * with, we must abort it.
		 */
		do_abort(instance);
		return;
	}
L
Linus Torvalds 已提交
2388

2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403
#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)) {
2404 2405
			sun3scsi_dma_setup(instance, d, count,
			                   rq_data_dir(tmp->request));
2406 2407 2408 2409 2410 2411 2412
			sun3_dma_setup_done = tmp;
		}
	}

	NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ACK);
#endif

2413 2414
	/* Accept message by clearing ACK */
	NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
L
Linus Torvalds 已提交
2415

2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429
#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];
2430 2431
		dsprintk(NDEBUG_TAGS, instance, "reselect: target mask %02x, lun %d sent tag %d\n"
		         target_mask, lun, tag);
2432 2433 2434
	}
#endif

2435
	hostdata->connected = tmp;
2436 2437
	dsprintk(NDEBUG_RESELECTION, instance, "nexus established, target %d, lun %llu, tag %d\n",
	         scmd_id(tmp), tmp->device->lun, tmp->tag);
L
Linus Torvalds 已提交
2438 2439 2440
}


2441 2442 2443 2444
/**
 * list_find_cmd - test for presence of a command in a linked list
 * @haystack: list of commands
 * @needle: command to search for
L
Linus Torvalds 已提交
2445 2446
 */

2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502
static bool list_find_cmd(struct list_head *haystack,
                          struct scsi_cmnd *needle)
{
	struct NCR5380_cmd *ncmd;

	list_for_each_entry(ncmd, haystack, list)
		if (NCR5380_to_scmd(ncmd) == needle)
			return true;
	return false;
}

/**
 * list_remove_cmd - remove a command from linked list
 * @haystack: list of commands
 * @needle: command to remove
 */

static bool list_del_cmd(struct list_head *haystack,
                         struct scsi_cmnd *needle)
{
	if (list_find_cmd(haystack, needle)) {
		struct NCR5380_cmd *ncmd = scsi_cmd_priv(needle);

		list_del(&ncmd->list);
		return true;
	}
	return false;
}

/**
 * NCR5380_abort - scsi host eh_abort_handler() method
 * @cmd: the command to be aborted
 *
 * Try to abort a given command by removing it from queues and/or sending
 * the target an abort message. This may not succeed in causing a target
 * to abort the command. Nonetheless, the low-level driver must forget about
 * the command because the mid-layer reclaims it and it may be re-issued.
 *
 * The normal path taken by a command is as follows. For EH we trace this
 * same path to locate and abort the command.
 *
 * unissued -> selecting -> [unissued -> selecting ->]... connected ->
 * [disconnected -> connected ->]...
 * [autosense -> connected ->] done
 *
 * If cmd is unissued then just remove it.
 * If cmd is disconnected, try to select the target.
 * If cmd is connected, try to send an abort message.
 * If cmd is waiting for autosense, give it a chance to complete but check
 * that it isn't left connected.
 * If cmd was not found at all then presumably it has already been completed,
 * in which case return SUCCESS to try to avoid further EH measures.
 * If the command has not completed yet, we must not fail to find it.
 */

static int NCR5380_abort(struct scsi_cmnd *cmd)
L
Linus Torvalds 已提交
2503
{
2504
	struct Scsi_Host *instance = cmd->device->host;
F
Finn Thain 已提交
2505
	struct NCR5380_hostdata *hostdata = shost_priv(instance);
2506
	unsigned long flags;
2507
	int result = SUCCESS;
L
Linus Torvalds 已提交
2508

2509
	spin_lock_irqsave(&hostdata->lock, flags);
2510

2511
#if (NDEBUG & NDEBUG_ANY)
2512
	scmd_printk(KERN_INFO, cmd, __func__);
2513
#endif
2514 2515
	NCR5380_dprint(NDEBUG_ANY, instance);
	NCR5380_dprint_phase(NDEBUG_ANY, instance);
L
Linus Torvalds 已提交
2516

2517 2518 2519 2520 2521 2522 2523
	if (list_del_cmd(&hostdata->unissued, cmd)) {
		dsprintk(NDEBUG_ABORT, instance,
		         "abort: removed %p from issue queue\n", cmd);
		cmd->result = DID_ABORT << 16;
		cmd->scsi_done(cmd); /* No tag or busy flag to worry about */
	}

2524 2525 2526 2527 2528 2529 2530 2531 2532
	if (hostdata->selecting == cmd) {
		dsprintk(NDEBUG_ABORT, instance,
		         "abort: cmd %p == selecting\n", cmd);
		hostdata->selecting = NULL;
		cmd->result = DID_ABORT << 16;
		complete_cmd(instance, cmd);
		goto out;
	}

2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598 2599 2600 2601 2602 2603 2604 2605 2606 2607 2608
	if (list_del_cmd(&hostdata->disconnected, cmd)) {
		dsprintk(NDEBUG_ABORT, instance,
		         "abort: removed %p from disconnected list\n", cmd);
		cmd->result = DID_ERROR << 16;
		if (!hostdata->connected)
			NCR5380_select(instance, cmd);
		if (hostdata->connected != cmd) {
			complete_cmd(instance, cmd);
			result = FAILED;
			goto out;
		}
	}

	if (hostdata->connected == cmd) {
		dsprintk(NDEBUG_ABORT, instance, "abort: cmd %p is connected\n", cmd);
		hostdata->connected = NULL;
		if (do_abort(instance)) {
			set_host_byte(cmd, DID_ERROR);
			complete_cmd(instance, cmd);
			result = FAILED;
			goto out;
		}
		set_host_byte(cmd, DID_ABORT);
#ifdef REAL_DMA
		hostdata->dma_len = 0;
#endif
		if (cmd->cmnd[0] == REQUEST_SENSE)
			complete_cmd(instance, cmd);
		else {
			struct NCR5380_cmd *ncmd = scsi_cmd_priv(cmd);

			/* Perform autosense for this command */
			list_add(&ncmd->list, &hostdata->autosense);
		}
	}

	if (list_find_cmd(&hostdata->autosense, cmd)) {
		dsprintk(NDEBUG_ABORT, instance,
		         "abort: found %p on sense queue\n", cmd);
		spin_unlock_irqrestore(&hostdata->lock, flags);
		queue_work(hostdata->work_q, &hostdata->main_task);
		msleep(1000);
		spin_lock_irqsave(&hostdata->lock, flags);
		if (list_del_cmd(&hostdata->autosense, cmd)) {
			dsprintk(NDEBUG_ABORT, instance,
			         "abort: removed %p from sense queue\n", cmd);
			set_host_byte(cmd, DID_ABORT);
			complete_cmd(instance, cmd);
			goto out;
		}
	}

	if (hostdata->connected == cmd) {
		dsprintk(NDEBUG_ABORT, instance, "abort: cmd %p is connected\n", cmd);
		hostdata->connected = NULL;
		if (do_abort(instance)) {
			set_host_byte(cmd, DID_ERROR);
			complete_cmd(instance, cmd);
			result = FAILED;
			goto out;
		}
		set_host_byte(cmd, DID_ABORT);
#ifdef REAL_DMA
		hostdata->dma_len = 0;
#endif
		complete_cmd(instance, cmd);
	}

out:
	if (result == FAILED)
		dsprintk(NDEBUG_ABORT, instance, "abort: failed to abort %p\n", cmd);
	else
		dsprintk(NDEBUG_ABORT, instance, "abort: successfully aborted %p\n", cmd);

	queue_work(hostdata->work_q, &hostdata->main_task);
	maybe_release_dma_irq(instance);
2609
	spin_unlock_irqrestore(&hostdata->lock, flags);
2610

2611
	return result;
L
Linus Torvalds 已提交
2612 2613 2614
}


2615 2616 2617
/**
 * NCR5380_bus_reset - reset the SCSI bus
 * @cmd: SCSI command undergoing EH
L
Linus Torvalds 已提交
2618
 *
2619
 * Returns SUCCESS
2620
 */
L
Linus Torvalds 已提交
2621

F
Finn Thain 已提交
2622
static int NCR5380_bus_reset(struct scsi_cmnd *cmd)
L
Linus Torvalds 已提交
2623
{
2624 2625
	struct Scsi_Host *instance = cmd->device->host;
	struct NCR5380_hostdata *hostdata = shost_priv(instance);
2626 2627
	int i;
	unsigned long flags;
2628
	struct NCR5380_cmd *ncmd;
L
Linus Torvalds 已提交
2629

2630
	spin_lock_irqsave(&hostdata->lock, flags);
2631 2632

#if (NDEBUG & NDEBUG_ANY)
2633
	scmd_printk(KERN_INFO, cmd, __func__);
2634
#endif
2635 2636
	NCR5380_dprint(NDEBUG_ANY, instance);
	NCR5380_dprint_phase(NDEBUG_ANY, instance);
2637 2638

	do_reset(instance);
2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649 2650

	/* reset NCR registers */
	NCR5380_write(MODE_REG, MR_BASE);
	NCR5380_write(TARGET_COMMAND_REG, 0);
	NCR5380_write(SELECT_ENABLE_REG, 0);

	/* 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!
	 */

2651 2652 2653 2654 2655 2656 2657 2658 2659 2660
	if (list_del_cmd(&hostdata->unissued, cmd)) {
		cmd->result = DID_RESET << 16;
		cmd->scsi_done(cmd);
	}

	if (hostdata->selecting) {
		hostdata->selecting->result = DID_RESET << 16;
		complete_cmd(instance, hostdata->selecting);
		hostdata->selecting = NULL;
	}
2661

2662 2663
	list_for_each_entry(ncmd, &hostdata->disconnected, list) {
		struct scsi_cmnd *cmd = NCR5380_to_scmd(ncmd);
2664

2665 2666
		set_host_byte(cmd, DID_RESET);
		cmd->scsi_done(cmd);
F
Finn Thain 已提交
2667
	}
2668
	INIT_LIST_HEAD(&hostdata->disconnected);
F
Finn Thain 已提交
2669

2670 2671
	list_for_each_entry(ncmd, &hostdata->autosense, list) {
		struct scsi_cmnd *cmd = NCR5380_to_scmd(ncmd);
F
Finn Thain 已提交
2672

2673 2674 2675
		set_host_byte(cmd, DID_RESET);
		cmd->scsi_done(cmd);
	}
2676
	INIT_LIST_HEAD(&hostdata->autosense);
2677

2678 2679 2680 2681 2682 2683
	if (hostdata->connected) {
		set_host_byte(hostdata->connected, DID_RESET);
		complete_cmd(instance, hostdata->connected);
		hostdata->connected = NULL;
	}

L
Linus Torvalds 已提交
2684
#ifdef SUPPORT_TAGS
2685
	free_all_tags(hostdata);
L
Linus Torvalds 已提交
2686
#endif
2687 2688
	for (i = 0; i < 8; ++i)
		hostdata->busy[i] = 0;
L
Linus Torvalds 已提交
2689
#ifdef REAL_DMA
2690
	hostdata->dma_len = 0;
L
Linus Torvalds 已提交
2691
#endif
2692

2693
	queue_work(hostdata->work_q, &hostdata->main_task);
2694
	maybe_release_dma_irq(instance);
2695
	spin_unlock_irqrestore(&hostdata->lock, flags);
L
Linus Torvalds 已提交
2696

2697
	return SUCCESS;
L
Linus Torvalds 已提交
2698
}