atari_NCR5380.c 77.0 KB
Newer Older
1
/*
L
Linus Torvalds 已提交
2
 * NCR 5380 generic driver routines.  These should make it *trivial*
3
 *	to implement 5380 SCSI drivers under Linux with a non-trantor
L
Linus Torvalds 已提交
4 5 6 7 8
 *	architecture.
 *
 *	Note that these routines also work with NR53c400 family chips.
 *
 * Copyright 1993, Drew Eckhardt
9
 *	Visionary Computing
L
Linus Torvalds 已提交
10
 *	(Unix and Linux consulting and custom programming)
11
 *	drew@colorado.edu
L
Linus Torvalds 已提交
12 13
 *	+1 (303) 666-5836
 *
14
 * For more information, please consult
L
Linus Torvalds 已提交
15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57
 *
 * NCR 5380 Family
 * SCSI Protocol Controller
 * Databook
 *
 * NCR Microelectronics
 * 1635 Aeroplaza Drive
 * Colorado Springs, CO 80916
 * 1+ (719) 578-3400
 * 1+ (800) 334-5454
 */

/*
 * ++roman: To port the 5380 driver to the Atari, I had to do some changes in
 * this file, too:
 *
 *  - Some of the debug statements were incorrect (undefined variables and the
 *    like). I fixed that.
 *
 *  - In information_transfer(), I think a #ifdef was wrong. Looking at the
 *    possible DMA transfer size should also happen for REAL_DMA. I added this
 *    in the #if statement.
 *
 *  - When using real DMA, information_transfer() should return in a DATAOUT
 *    phase after starting the DMA. It has nothing more to do.
 *
 *  - The interrupt service routine should run main after end of DMA, too (not
 *    only after RESELECTION interrupts). Additionally, it should _not_ test
 *    for more interrupts after running main, since a DMA process may have
 *    been started and interrupts are turned on now. The new int could happen
 *    inside the execution of NCR5380_intr(), leading to recursive
 *    calls.
 *
 *  - I've added a function merge_contiguous_buffers() that tries to
 *    merge scatter-gather buffers that are located at contiguous
 *    physical addresses and can be processed with the same DMA setup.
 *    Since most scatter-gather operations work on a page (4K) of
 *    4 buffers (1K), in more than 90% of all cases three interrupts and
 *    DMA setup actions are saved.
 *
 * - I've deleted all the stuff for AUTOPROBE_IRQ, REAL_DMA_POLL, PSEUDO_DMA
 *    and USLEEP, because these were messing up readability and will never be
 *    needed for Atari SCSI.
58
 *
L
Linus Torvalds 已提交
59 60 61 62 63 64 65 66 67 68
 * - I've revised the NCR5380_main() calling scheme (relax the 'main_running'
 *   stuff), and 'main' is executed in a bottom half if awoken by an
 *   interrupt.
 *
 * - The code was quite cluttered up by "#if (NDEBUG & NDEBUG_*) printk..."
 *   constructs. In my eyes, this made the source rather unreadable, so I
 *   finally replaced that by the *_PRINTK() macros.
 *
 */

69 70
/* Adapted for the sun3 by Sam Creasey. */

L
Linus Torvalds 已提交
71 72 73
/*
 * Design
 *
74
 * This is a generic 5380 driver.  To use it on a different platform,
L
Linus Torvalds 已提交
75
 * one simply writes appropriate system specific macros (ie, data
76
 * transfer - some PC's will use the I/O bus, 68K's must use
L
Linus Torvalds 已提交
77 78
 * memory mapped) and drops this file in their 'C' wrapper.
 *
79
 * As far as command queueing, two queues are maintained for
L
Linus Torvalds 已提交
80
 * each 5380 in the system - commands that haven't been issued yet,
81 82 83 84 85
 * 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 已提交
86 87 88
 * while a command is already executing.
 *
 *
89
 * Issues specific to the NCR5380 :
L
Linus Torvalds 已提交
90
 *
91 92 93 94
 * 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
95
 * while doing long seek operations. [...] These
L
Linus Torvalds 已提交
96 97 98 99 100 101
 * 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 已提交
102 103 104 105
 * 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 已提交
106 107 108 109 110
 *
 * 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 已提交
111 112
 * 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 已提交
113 114 115 116 117
 *
 * 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.
 *
118
 * On command termination, the done function will be called as
L
Linus Torvalds 已提交
119 120
 * appropriate.
 *
121
 * SCSI pointers are maintained in the SCp field of SCSI command
L
Linus Torvalds 已提交
122 123 124 125 126 127 128 129 130
 * 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
131
 * of chips.  To use it, you write an architecture specific functions
L
Linus Torvalds 已提交
132 133
 * and macros and include this file in your driver.
 *
134
 * These macros control options :
L
Linus Torvalds 已提交
135
 * AUTOSENSE - if defined, REQUEST SENSE will be performed automatically
136
 *	for commands that return with a CHECK CONDITION status.
L
Linus Torvalds 已提交
137
 *
F
Finn Thain 已提交
138 139 140
 * DIFFERENTIAL - if defined, NCR53c81 chips will use external differential
 *	transceivers.
 *
L
Linus Torvalds 已提交
141 142 143 144 145
 * 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 :
146
 *
L
Linus Torvalds 已提交
147 148
 * NCR5380_read(register)  - read from the specified register
 *
149
 * NCR5380_write(register, value) - write to the specific register
L
Linus Torvalds 已提交
150
 *
F
Finn Thain 已提交
151 152 153
 * NCR5380_implementation_fields  - additional fields needed for this
 *      specific implementation of the NCR5380
 *
L
Linus Torvalds 已提交
154
 * Either real DMA *or* pseudo DMA may be implemented
155
 * REAL functions :
L
Linus Torvalds 已提交
156
 * NCR5380_REAL_DMA should be defined if real DMA is to be used.
157
 * Note that the DMA setup functions should return the number of bytes
L
Linus Torvalds 已提交
158 159
 *	that they were able to program the controller for.
 *
160
 * Also note that generic i386/PC versions of these macros are
L
Linus Torvalds 已提交
161 162 163 164 165 166 167 168 169 170 171 172
 *	available as NCR5380_i386_dma_write_setup,
 *	NCR5380_i386_dma_read_setup, and NCR5380_i386_dma_residual.
 *
 * NCR5380_dma_write_setup(instance, src, count) - initialize
 * NCR5380_dma_read_setup(instance, dst, count) - initialize
 * NCR5380_dma_residual(instance); - residual count
 *
 * PSEUDO functions :
 * NCR5380_pwrite(instance, src, count)
 * NCR5380_pread(instance, dst, count);
 *
 * The generic driver is initialized by calling NCR5380_init(instance),
173
 * after setting the appropriate host specific fields and ID.  If the
L
Linus Torvalds 已提交
174
 * driver wishes to autoprobe for an IRQ line, the NCR5380_probe_irq(instance,
F
Finn Thain 已提交
175
 * possible) function may be used.
L
Linus Torvalds 已提交
176 177 178 179
 */

#define	HOSTNO		instance->host_no

180 181 182
static int do_abort(struct Scsi_Host *);
static void do_reset(struct Scsi_Host *);

L
Linus Torvalds 已提交
183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199
#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 已提交
200
 * target.
L
Linus Torvalds 已提交
201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217
 *
 * 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.
 */

218
static void __init init_tags(struct NCR5380_hostdata *hostdata)
L
Linus Torvalds 已提交
219
{
220
	int target, lun;
221
	struct tag_alloc *ta;
222

223
	if (!(hostdata->flags & FLAG_TAGGED_QUEUING))
224 225 226 227
		return;

	for (target = 0; target < 8; ++target) {
		for (lun = 0; lun < 8; ++lun) {
228
			ta = &hostdata->TagAlloc[target][lun];
229 230 231 232 233 234 235 236
			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 已提交
237 238 239 240 241 242 243 244 245
	}
}


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

F
Finn Thain 已提交
248
static int is_lun_busy(struct scsi_cmnd *cmd, int should_be_tagged)
L
Linus Torvalds 已提交
249
{
H
Hannes Reinecke 已提交
250
	u8 lun = cmd->device->lun;
251 252
	struct Scsi_Host *instance = cmd->device->host;
	struct NCR5380_hostdata *hostdata = shost_priv(instance);
253

H
Hannes Reinecke 已提交
254
	if (hostdata->busy[cmd->device->id] & (1 << lun))
255 256
		return 1;
	if (!should_be_tagged ||
257 258
	    !(hostdata->flags & FLAG_TAGGED_QUEUING) ||
	    !cmd->device->tagged_supported)
259
		return 0;
260 261
	if (hostdata->TagAlloc[scmd_id(cmd)][lun].nr_allocated >=
	    hostdata->TagAlloc[scmd_id(cmd)][lun].queue_size) {
262 263
		dsprintk(NDEBUG_TAGS, instance, "target %d lun %d: no free tags\n",
		         scmd_id(cmd), lun);
264 265 266
		return 1;
	}
	return 0;
L
Linus Torvalds 已提交
267 268 269 270 271 272 273 274
}


/* 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 已提交
275
static void cmd_get_tag(struct scsi_cmnd *cmd, int should_be_tagged)
L
Linus Torvalds 已提交
276
{
H
Hannes Reinecke 已提交
277
	u8 lun = cmd->device->lun;
278 279
	struct Scsi_Host *instance = cmd->device->host;
	struct NCR5380_hostdata *hostdata = shost_priv(instance);
280 281 282 283 284

	/* If we or the target don't support tagged queuing, allocate the LUN for
	 * an untagged command.
	 */
	if (!should_be_tagged ||
285 286
	    !(hostdata->flags & FLAG_TAGGED_QUEUING) ||
	    !cmd->device->tagged_supported) {
287
		cmd->tag = TAG_NONE;
H
Hannes Reinecke 已提交
288
		hostdata->busy[cmd->device->id] |= (1 << lun);
289 290
		dsprintk(NDEBUG_TAGS, instance, "target %d lun %d now allocated by untagged command\n",
		         scmd_id(cmd), lun);
291
	} else {
292
		struct tag_alloc *ta = &hostdata->TagAlloc[scmd_id(cmd)][lun];
293 294 295 296

		cmd->tag = find_first_zero_bit(ta->allocated, MAX_TAGS);
		set_bit(cmd->tag, ta->allocated);
		ta->nr_allocated++;
297 298
		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);
299
	}
L
Linus Torvalds 已提交
300 301 302 303 304 305 306
}


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

F
Finn Thain 已提交
307
static void cmd_free_tag(struct scsi_cmnd *cmd)
L
Linus Torvalds 已提交
308
{
H
Hannes Reinecke 已提交
309
	u8 lun = cmd->device->lun;
310 311
	struct Scsi_Host *instance = cmd->device->host;
	struct NCR5380_hostdata *hostdata = shost_priv(instance);
312 313

	if (cmd->tag == TAG_NONE) {
H
Hannes Reinecke 已提交
314
		hostdata->busy[cmd->device->id] &= ~(1 << lun);
315 316
		dsprintk(NDEBUG_TAGS, instance, "target %d lun %d untagged cmd freed\n",
		         scmd_id(cmd), lun);
317
	} else if (cmd->tag >= MAX_TAGS) {
318 319
		shost_printk(KERN_NOTICE, instance,
		             "trying to free bad tag %d!\n", cmd->tag);
320
	} else {
321
		struct tag_alloc *ta = &hostdata->TagAlloc[scmd_id(cmd)][lun];
322 323
		clear_bit(cmd->tag, ta->allocated);
		ta->nr_allocated--;
324 325
		dsprintk(NDEBUG_TAGS, instance, "freed tag %d for target %d lun %d\n",
		         cmd->tag, scmd_id(cmd), lun);
326
	}
L
Linus Torvalds 已提交
327 328 329
}


330
static void free_all_tags(struct NCR5380_hostdata *hostdata)
L
Linus Torvalds 已提交
331
{
332
	int target, lun;
333
	struct tag_alloc *ta;
334

335
	if (!(hostdata->flags & FLAG_TAGGED_QUEUING))
336 337 338 339
		return;

	for (target = 0; target < 8; ++target) {
		for (lun = 0; lun < 8; ++lun) {
340
			ta = &hostdata->TagAlloc[target][lun];
341 342 343
			bitmap_zero(ta->allocated, MAX_TAGS);
			ta->nr_allocated = 0;
		}
L
Linus Torvalds 已提交
344 345 346 347 348 349 350
	}
}

#endif /* SUPPORT_TAGS */


/*
F
Finn Thain 已提交
351
 * Function: void merge_contiguous_buffers( struct scsi_cmnd *cmd )
L
Linus Torvalds 已提交
352 353 354 355 356
 *
 * Purpose: Try to merge several scatter-gather requests into one DMA
 *    transfer. This is possible if the scatter buffers lie on
 *    physical contiguous addresses.
 *
F
Finn Thain 已提交
357
 * Parameters: struct scsi_cmnd *cmd
L
Linus Torvalds 已提交
358
 *    The command to work on. The first scatter buffer's data are
L
Lucas De Marchi 已提交
359
 *    assumed to be already transferred into ptr/this_residual.
L
Linus Torvalds 已提交
360 361
 */

F
Finn Thain 已提交
362
static void merge_contiguous_buffers(struct scsi_cmnd *cmd)
L
Linus Torvalds 已提交
363
{
364
#if !defined(CONFIG_SUN3)
365
	unsigned long endaddr;
L
Linus Torvalds 已提交
366
#if (NDEBUG & NDEBUG_MERGING)
367 368
	unsigned long oldlen = cmd->SCp.this_residual;
	int cnt = 1;
L
Linus Torvalds 已提交
369 370
#endif

371 372
	for (endaddr = virt_to_phys(cmd->SCp.ptr + cmd->SCp.this_residual - 1) + 1;
	     cmd->SCp.buffers_residual &&
G
Geert Uytterhoeven 已提交
373
	     virt_to_phys(sg_virt(&cmd->SCp.buffer[1])) == endaddr;) {
F
Finn Thain 已提交
374
		dprintk(NDEBUG_MERGING, "VTOP(%p) == %08lx -> merging\n",
G
Geert Uytterhoeven 已提交
375
			   page_address(sg_page(&cmd->SCp.buffer[1])), endaddr);
L
Linus Torvalds 已提交
376
#if (NDEBUG & NDEBUG_MERGING)
377
		++cnt;
L
Linus Torvalds 已提交
378
#endif
379 380 381 382 383
		++cmd->SCp.buffer;
		--cmd->SCp.buffers_residual;
		cmd->SCp.this_residual += cmd->SCp.buffer->length;
		endaddr += cmd->SCp.buffer->length;
	}
L
Linus Torvalds 已提交
384
#if (NDEBUG & NDEBUG_MERGING)
385
	if (oldlen != cmd->SCp.this_residual)
F
Finn Thain 已提交
386
		dprintk(NDEBUG_MERGING, "merged %d buffers from %p, new length %08x\n",
387
			   cnt, cmd->SCp.ptr, cmd->SCp.this_residual);
L
Linus Torvalds 已提交
388
#endif
389
#endif /* !defined(CONFIG_SUN3) */
L
Linus Torvalds 已提交
390 391
}

F
Finn Thain 已提交
392 393 394
/**
 * initialize_SCp - init the scsi pointer field
 * @cmd: command block to set up
L
Linus Torvalds 已提交
395
 *
F
Finn Thain 已提交
396
 * Set up the internal fields in the SCSI command.
L
Linus Torvalds 已提交
397 398
 */

F
Finn Thain 已提交
399
static inline void initialize_SCp(struct scsi_cmnd *cmd)
L
Linus Torvalds 已提交
400
{
401 402 403
	/*
	 * Initialize the Scsi Pointer field so that all of the commands in the
	 * various queues are valid.
L
Linus Torvalds 已提交
404
	 */
405

406 407 408
	if (scsi_bufflen(cmd)) {
		cmd->SCp.buffer = scsi_sglist(cmd);
		cmd->SCp.buffers_residual = scsi_sg_count(cmd) - 1;
J
Jens Axboe 已提交
409
		cmd->SCp.ptr = sg_virt(cmd->SCp.buffer);
410 411 412 413 414 415 416 417
		cmd->SCp.this_residual = cmd->SCp.buffer->length;
		/* ++roman: Try to merge some scatter-buffers if they are at
		 * contiguous physical addresses.
		 */
		merge_contiguous_buffers(cmd);
	} else {
		cmd->SCp.buffer = NULL;
		cmd->SCp.buffers_residual = 0;
418 419
		cmd->SCp.ptr = NULL;
		cmd->SCp.this_residual = 0;
420
	}
L
Linus Torvalds 已提交
421 422
}

423
/**
424
 * NCR5380_poll_politely2 - wait for two chip register values
425
 * @instance: controller to poll
426 427 428 429 430 431
 * @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
432
 * @wait: Time-out in jiffies
433
 *
434 435 436 437
 * 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.
438
 *
439
 * Returns 0 if either or both event(s) occurred otherwise -ETIMEDOUT.
440 441
 */

442 443 444
static int NCR5380_poll_politely2(struct Scsi_Host *instance,
                                  int reg1, int bit1, int val1,
                                  int reg2, int bit2, int val2, int wait)
445
{
446 447 448 449 450 451 452
	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;
453
	n /= 2000;
454
	do {
455 456 457
		if ((NCR5380_read(reg1) & bit1) == val1)
			return 0;
		if ((NCR5380_read(reg2) & bit2) == val2)
458 459
			return 0;
		cpu_relax();
460 461 462 463
	} while (n--);

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

465 466 467
	/* Repeatedly sleep for 1 ms until deadline */
	while (time_is_after_jiffies(deadline)) {
		schedule_timeout_uninterruptible(1);
468 469 470
		if ((NCR5380_read(reg1) & bit1) == val1)
			return 0;
		if ((NCR5380_read(reg2) & bit2) == val2)
471 472
			return 0;
	}
473

474 475 476
	return -ETIMEDOUT;
}

477 478 479 480 481 482 483
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 已提交
484 485
#if NDEBUG
static struct {
486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506
	unsigned char mask;
	const char *name;
} signals[] = {
	{ SR_DBP, "PARITY"}, { SR_RST, "RST" }, { SR_BSY, "BSY" },
	{ SR_REQ, "REQ" }, { SR_MSG, "MSG" }, { SR_CD,  "CD" }, { SR_IO, "IO" },
	{ SR_SEL, "SEL" }, {0, NULL}
}, basrs[] = {
	{BASR_ATN, "ATN"}, {BASR_ACK, "ACK"}, {0, NULL}
}, icrs[] = {
	{ICR_ASSERT_RST, "ASSERT RST"},{ICR_ASSERT_ACK, "ASSERT ACK"},
	{ICR_ASSERT_BSY, "ASSERT BSY"}, {ICR_ASSERT_SEL, "ASSERT SEL"},
	{ICR_ASSERT_ATN, "ASSERT ATN"}, {ICR_ASSERT_DATA, "ASSERT DATA"},
	{0, NULL}
}, mrs[] = {
	{MR_BLOCK_DMA_MODE, "MODE BLOCK DMA"}, {MR_TARGET, "MODE TARGET"},
	{MR_ENABLE_PAR_CHECK, "MODE PARITY CHECK"}, {MR_ENABLE_PAR_INTR,
	"MODE PARITY INTR"}, {MR_ENABLE_EOP_INTR,"MODE EOP INTR"},
	{MR_MONITOR_BSY, "MODE MONITOR BSY"},
	{MR_DMA_MODE, "MODE DMA"}, {MR_ARBITRATE, "MODE ARBITRATION"},
	{0, NULL}
};
L
Linus Torvalds 已提交
507

F
Finn Thain 已提交
508 509 510
/**
 * NCR5380_print - print scsi bus signals
 * @instance: adapter state to dump
L
Linus Torvalds 已提交
511
 *
F
Finn Thain 已提交
512
 * Print the SCSI bus signals for debugging purposes
L
Linus Torvalds 已提交
513 514
 */

515 516 517 518 519 520 521 522 523
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);
524

525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541
	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 已提交
542 543 544
}

static struct {
545 546
	unsigned char value;
	const char *name;
L
Linus Torvalds 已提交
547
} phases[] = {
548 549 550 551
	{PHASE_DATAOUT, "DATAOUT"}, {PHASE_DATAIN, "DATAIN"}, {PHASE_CMDOUT, "CMDOUT"},
	{PHASE_STATIN, "STATIN"}, {PHASE_MSGOUT, "MSGOUT"}, {PHASE_MSGIN, "MSGIN"},
	{PHASE_UNKNOWN, "UNKNOWN"}
};
L
Linus Torvalds 已提交
552

F
Finn Thain 已提交
553 554 555
/**
 * NCR5380_print_phase - show SCSI phase
 * @instance: adapter to dump
L
Linus Torvalds 已提交
556
 *
F
Finn Thain 已提交
557
 * Print the current SCSI phase for debugging purposes
L
Linus Torvalds 已提交
558
 *
F
Finn Thain 已提交
559
 * Locks: none
L
Linus Torvalds 已提交
560 561 562 563
 */

static void NCR5380_print_phase(struct Scsi_Host *instance)
{
564 565 566 567 568 569 570 571 572 573 574 575
	unsigned char status;
	int i;

	status = NCR5380_read(STATUS_REG);
	if (!(status & SR_REQ))
		printk(KERN_DEBUG "scsi%d: REQ not asserted, phase unknown.\n", HOSTNO);
	else {
		for (i = 0; (phases[i].value != PHASE_UNKNOWN) &&
		     (phases[i].value != (status & PHASE_MASK)); ++i)
			;
		printk(KERN_DEBUG "scsi%d: phase %s\n", HOSTNO, phases[i].name);
	}
L
Linus Torvalds 已提交
576 577 578 579
}

#endif

F
Finn Thain 已提交
580 581 582
/**
 * NCR58380_info - report driver and host information
 * @instance: relevant scsi host instance
L
Linus Torvalds 已提交
583
 *
F
Finn Thain 已提交
584
 * For use as the host template info() handler.
L
Linus Torvalds 已提交
585
 *
F
Finn Thain 已提交
586
 * Locks: none
L
Linus Torvalds 已提交
587 588
 */

F
Finn Thain 已提交
589
static const char *NCR5380_info(struct Scsi_Host *instance)
L
Linus Torvalds 已提交
590
{
F
Finn Thain 已提交
591 592 593 594 595 596 597 598 599 600 601 602 603 604
	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, "
605
	         "flags { %s%s}, "
F
Finn Thain 已提交
606 607 608 609 610
	         "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,
611
	         hostdata->flags & FLAG_TAGGED_QUEUING ? "TAGGED_QUEUING " : "",
612
	         hostdata->flags & FLAG_TOSHIBA_DELAY  ? "TOSHIBA_DELAY "  : "",
F
Finn Thain 已提交
613 614 615
#ifdef DIFFERENTIAL
	         "DIFFERENTIAL "
#endif
L
Linus Torvalds 已提交
616
#ifdef REAL_DMA
F
Finn Thain 已提交
617
	         "REAL_DMA "
L
Linus Torvalds 已提交
618 619
#endif
#ifdef PARITY
F
Finn Thain 已提交
620
	         "PARITY "
L
Linus Torvalds 已提交
621 622
#endif
#ifdef SUPPORT_TAGS
F
Finn Thain 已提交
623
	         "SUPPORT_TAGS "
L
Linus Torvalds 已提交
624
#endif
F
Finn Thain 已提交
625
	         "");
L
Linus Torvalds 已提交
626 627
}

F
Finn Thain 已提交
628 629 630 631
/**
 * NCR5380_init - initialise an NCR5380
 * @instance: adapter to configure
 * @flags: control flags
L
Linus Torvalds 已提交
632
 *
F
Finn Thain 已提交
633 634
 * Initializes *instance and corresponding 5380 chip,
 * with flags OR'd into the initial flags value.
L
Linus Torvalds 已提交
635 636
 *
 * Notes : I assume that the host, hostno, and id bits have been
F
Finn Thain 已提交
637
 * set correctly. I don't care about the irq and other fields.
638
 *
F
Finn Thain 已提交
639
 * Returns 0 for success
L
Linus Torvalds 已提交
640 641
 */

642
static int __init NCR5380_init(struct Scsi_Host *instance, int flags)
L
Linus Torvalds 已提交
643
{
F
Finn Thain 已提交
644
	struct NCR5380_hostdata *hostdata = shost_priv(instance);
645
	int i;
646
	unsigned long deadline;
647

648
	hostdata->host = instance;
649 650 651 652 653 654 655
	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 已提交
656
#ifdef SUPPORT_TAGS
657
	init_tags(hostdata);
L
Linus Torvalds 已提交
658 659
#endif
#if defined (REAL_DMA)
660
	hostdata->dma_len = 0;
L
Linus Torvalds 已提交
661
#endif
662
	spin_lock_init(&hostdata->lock);
663
	hostdata->connected = NULL;
664 665 666
	INIT_LIST_HEAD(&hostdata->unissued);
	INIT_LIST_HEAD(&hostdata->disconnected);

667
	hostdata->flags = flags;
668

669
	INIT_WORK(&hostdata->main_task, NCR5380_main);
670 671 672 673 674
	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 已提交
675

F
Finn Thain 已提交
676 677
	prepare_info(instance);

678 679 680 681
	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 已提交
682

683 684 685 686 687 688 689 690 691 692 693 694 695 696
	/* 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;

697
	return 0;
L
Linus Torvalds 已提交
698 699
}

700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715
/**
 * 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)
{
716
	struct NCR5380_hostdata *hostdata = shost_priv(instance);
717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734
	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);
735 736 737 738 739 740 741 742
			/* 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);
743 744 745 746 747 748 749 750 751
			break;
		case 6:
			shost_printk(KERN_ERR, instance, "bus locked solid\n");
			return -ENXIO;
		}
	}
	return 0;
}

F
Finn Thain 已提交
752 753 754 755 756 757 758
/**
 * NCR5380_exit - remove an NCR5380
 * @instance: adapter to remove
 *
 * Assumes that no more work can be queued (e.g. by NCR5380_intr).
 */

759 760
static void NCR5380_exit(struct Scsi_Host *instance)
{
761 762 763
	struct NCR5380_hostdata *hostdata = shost_priv(instance);

	cancel_work_sync(&hostdata->main_task);
764
	destroy_workqueue(hostdata->work_q);
765 766
}

767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787
/**
 * 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);

#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 已提交
788 789 790 791
/**
 * NCR5380_queue_command - queue a command
 * @instance: the relevant SCSI adapter
 * @cmd: SCSI command
L
Linus Torvalds 已提交
792
 *
F
Finn Thain 已提交
793
 * cmd is added to the per-instance issue queue, with minor
F
Finn Thain 已提交
794 795
 * twiddling done to the host specific fields of cmd.  If the
 * main coroutine is not running, it is restarted.
L
Linus Torvalds 已提交
796 797
 */

798 799
static int NCR5380_queue_command(struct Scsi_Host *instance,
                                 struct scsi_cmnd *cmd)
L
Linus Torvalds 已提交
800
{
801
	struct NCR5380_hostdata *hostdata = shost_priv(instance);
802
	struct NCR5380_cmd *ncmd = scsi_cmd_priv(cmd);
803
	unsigned long flags;
L
Linus Torvalds 已提交
804 805

#if (NDEBUG & NDEBUG_NO_WRITE)
806 807 808
	switch (cmd->cmnd[0]) {
	case WRITE_6:
	case WRITE_10:
809
		shost_printk(KERN_DEBUG, instance, "WRITE attempted with NDEBUG_NO_WRITE set\n");
810
		cmd->result = (DID_ERROR << 16);
811
		cmd->scsi_done(cmd);
812 813
		return 0;
	}
L
Linus Torvalds 已提交
814 815
#endif /* (NDEBUG & NDEBUG_NO_WRITE) */

816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836
	cmd->result = 0;

	/*
	 * Insert the cmd into the issue queue. Note that REQUEST SENSE
	 * commands are added to the head of the queue since any command will
	 * clear the contingent allegiance condition that exists and the
	 * sense data is only guaranteed to be valid while the condition exists.
	 */

	/* ++guenther: now that the issue queue is being set up, we can lock ST-DMA.
	 * Otherwise a running NCR5380_main may steal the lock.
	 * Lock before actually inserting due to fairness reasons explained in
	 * atari_scsi.c. If we insert first, then it's impossible for this driver
	 * to release the lock.
	 * Stop timer for this command while waiting for the lock, or timeouts
	 * may happen (and they really do), and it's no good if the command doesn't
	 * appear in any of the queues.
	 * ++roman: Just disabling the NCR interrupt isn't sufficient here,
	 * because also a timer int can trigger an abort or reset, which would
	 * alter queues and touch the lock.
	 */
837
	if (!NCR5380_acquire_dma_irq(instance))
838 839
		return SCSI_MLQUEUE_HOST_BUSY;

840
	spin_lock_irqsave(&hostdata->lock, flags);
841

F
Finn Thain 已提交
842 843 844 845 846 847 848
	/*
	 * 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.
	 */

849 850 851 852 853
	if (cmd->cmnd[0] == REQUEST_SENSE)
		list_add(&ncmd->list, &hostdata->unissued);
	else
		list_add_tail(&ncmd->list, &hostdata->unissued);

854
	spin_unlock_irqrestore(&hostdata->lock, flags);
855

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

859 860
	/* Kick off command processing */
	queue_work(hostdata->work_q, &hostdata->main_task);
861
	return 0;
L
Linus Torvalds 已提交
862 863
}

864 865 866 867 868
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 */
869 870
	if (list_empty(&hostdata->disconnected) &&
	    list_empty(&hostdata->unissued) &&
871 872 873 874 875
	    !hostdata->connected &&
	    !hostdata->retain_dma_intr)
		NCR5380_release_dma_irq(instance);
}

F
Finn Thain 已提交
876 877
/**
 * NCR5380_main - NCR state machines
L
Linus Torvalds 已提交
878
 *
F
Finn Thain 已提交
879 880 881 882
 * 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.
883
 *
F
Finn Thain 已提交
884
 * Locks: called as its own thread with no locks held.
885 886
 */

887
static void NCR5380_main(struct work_struct *work)
L
Linus Torvalds 已提交
888
{
889 890 891
	struct NCR5380_hostdata *hostdata =
		container_of(work, struct NCR5380_hostdata, main_task);
	struct Scsi_Host *instance = hostdata->host;
892
	struct NCR5380_cmd *ncmd, *n;
893 894 895 896 897 898 899 900
	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.
	 */

901
	spin_lock_irq(&hostdata->lock);
902 903 904 905
	do {
		done = 1;

		if (!hostdata->connected) {
F
Finn Thain 已提交
906
			dprintk(NDEBUG_MAIN, "scsi%d: not connected\n", HOSTNO);
907 908 909 910
			/*
			 * Search through the issue_queue for a command destined
			 * for a target that's not busy.
			 */
911 912 913
			list_for_each_entry_safe(ncmd, n, &hostdata->unissued,
			                         list) {
				struct scsi_cmnd *tmp = NCR5380_to_scmd(ncmd);
H
Hannes Reinecke 已提交
914
				u8 lun = tmp->device->lun;
L
Linus Torvalds 已提交
915

916 917
				dsprintk(NDEBUG_QUEUES, instance, "main: tmp=%p target=%d busy=%d lun=%d\n",
				         tmp, scmd_id(tmp), hostdata->busy[scmd_id(tmp)], lun);
918 919
				/*  When we find one, remove it from the issue queue. */
				if (
L
Linus Torvalds 已提交
920
#ifdef SUPPORT_TAGS
921
				    !is_lun_busy( tmp, tmp->cmnd[0] != REQUEST_SENSE)
L
Linus Torvalds 已提交
922
#else
H
Hannes Reinecke 已提交
923
				    !(hostdata->busy[tmp->device->id] & (1 << lun))
L
Linus Torvalds 已提交
924
#endif
925
				    ) {
926
					list_del(&ncmd->list);
927
					dsprintk(NDEBUG_MAIN | NDEBUG_QUEUES,
928 929
					         instance, "main: removed %p from issue queue\n",
					         tmp);
930

931
					hostdata->retain_dma_intr++;
932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948

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

L
Linus Torvalds 已提交
949
#ifdef SUPPORT_TAGS
950
					cmd_get_tag(tmp, tmp->cmnd[0] != REQUEST_SENSE);
L
Linus Torvalds 已提交
951
#endif
952
					if (!NCR5380_select(instance, tmp)) {
953
						/* OK or bad target */
954
						hostdata->retain_dma_intr--;
955
						maybe_release_dma_irq(instance);
956
					} else {
957
						/* Need to retry */
958
						list_add(&ncmd->list, &hostdata->unissued);
959 960 961
						dsprintk(NDEBUG_MAIN | NDEBUG_QUEUES,
						         instance, "main: select() failed, %p returned to issue queue\n",
						         tmp);
L
Linus Torvalds 已提交
962
#ifdef SUPPORT_TAGS
963
						cmd_free_tag(tmp);
L
Linus Torvalds 已提交
964
#endif
965
						hostdata->retain_dma_intr--;
966
						done = 0;
967
					}
968 969
					if (hostdata->connected)
						break;
970 971 972 973 974
				} /* if target/lun/target queue is not busy */
			} /* for issue_queue */
		} /* if (!hostdata->connected) */

		if (hostdata->connected
L
Linus Torvalds 已提交
975
#ifdef REAL_DMA
976
		    && !hostdata->dma_len
L
Linus Torvalds 已提交
977
#endif
978
		    ) {
F
Finn Thain 已提交
979
			dprintk(NDEBUG_MAIN, "scsi%d: main: performing information transfer\n",
980 981
				    HOSTNO);
			NCR5380_information_transfer(instance);
F
Finn Thain 已提交
982
			dprintk(NDEBUG_MAIN, "scsi%d: main: done set false\n", HOSTNO);
983 984 985
			done = 0;
		}
	} while (!done);
986
	spin_unlock_irq(&hostdata->lock);
L
Linus Torvalds 已提交
987 988 989 990 991 992 993 994
}


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

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

1010
	if (hostdata->read_overruns) {
1011 1012 1013 1014 1015 1016 1017 1018
		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;
F
Finn Thain 已提交
1019
				dprintk(NDEBUG_DMA, "scsi%d: read overrun handled\n", HOSTNO);
1020 1021 1022 1023
			}
		}
	}

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

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

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

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

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

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


F
Finn Thain 已提交
1075 1076 1077 1078
/**
 * NCR5380_intr - generic NCR5380 irq handler
 * @irq: interrupt number
 * @dev_id: device info
L
Linus Torvalds 已提交
1079
 *
F
Finn Thain 已提交
1080 1081 1082
 * Handle interrupts, reestablishing I_T_L or I_T_L_Q nexuses
 * from the disconnected queue, and restarting NCR5380_main()
 * as required.
1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106
 *
 * 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 已提交
1107 1108
 */

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

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

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

		dprintk(NDEBUG_INTR, "scsi%d: IRQ %d, BASR 0x%02x, SR 0x%02x, MR 0x%02x\n",
		        HOSTNO, irq, basr, sr, mr);
L
Linus Torvalds 已提交
1126 1127

#if defined(REAL_DMA)
1128 1129 1130 1131
		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.
1132 1133
			 */

1134
			dprintk(NDEBUG_INTR, "scsi%d: interrupt in DMA mode\n", HOSTNO);
1135

1136 1137 1138 1139 1140 1141 1142 1143
			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 已提交
1144
#endif /* REAL_DMA */
1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164
		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);

			dprintk(NDEBUG_INTR, "scsi%d: interrupt with SEL and IO\n",
			        HOSTNO);

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

			dprintk(NDEBUG_INTR, "scsi%d: unknown interrupt\n", HOSTNO);
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 1184
 * Function : int NCR5380_select(struct Scsi_Host *instance,
 *                               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 : -1 if selection failed but should be retried.
 *      0 if selection failed and should not be retried.
 *      0 if selection succeeded completely (hostdata->connected == cmd).
L
Linus Torvalds 已提交
1196
 *
1197 1198
 * Side effects :
 *	If bus busy, arbitration failed, etc, NCR5380_select() will exit
L
Linus Torvalds 已提交
1199 1200 1201 1202
 *		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.
 *
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
 *	If failed (no target) : cmd->scsi_done() will be called, and the
L
Linus Torvalds 已提交
1208 1209 1210
 *		cmd->result host byte set to DID_BAD_TARGET.
 */

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

1219
	NCR5380_dprint(NDEBUG_ARBITRATION, instance);
F
Finn Thain 已提交
1220
	dprintk(NDEBUG_ARBITRATION, "scsi%d: starting arbitration, id = %d\n", HOSTNO,
1221 1222 1223 1224 1225 1226 1227 1228
		   instance->this_id);

	/*
	 * 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 已提交
1229

1230 1231 1232
	/*
	 * Start arbitration.
	 */
L
Linus Torvalds 已提交
1233

1234 1235
	NCR5380_write(OUTPUT_DATA_REG, hostdata->id_mask);
	NCR5380_write(MODE_REG, MR_ARBITRATE);
L
Linus Torvalds 已提交
1236

1237 1238 1239
	/* The chip now waits for BUS FREE phase. Then after the 800 ns
	 * Bus Free Delay, arbitration will begin.
	 */
1240

1241
	spin_unlock_irq(&hostdata->lock);
1242 1243 1244
	err = NCR5380_poll_politely2(instance, MODE_REG, MR_ARBITRATE, 0,
	                INITIATOR_COMMAND_REG, ICR_ARBITRATION_PROGRESS,
	                                       ICR_ARBITRATION_PROGRESS, HZ);
1245
	spin_lock_irq(&hostdata->lock);
1246 1247 1248 1249 1250 1251 1252 1253 1254
	if (!(NCR5380_read(MODE_REG) & MR_ARBITRATE)) {
		/* Reselection interrupt */
		return -1;
	}
	if (err < 0) {
		NCR5380_write(MODE_REG, MR_BASE);
		shost_printk(KERN_ERR, instance,
		             "select: arbitration timeout\n");
		return -1;
1255
	}
1256
	spin_unlock_irq(&hostdata->lock);
1257

1258
	/* The SCSI-2 arbitration delay is 2.4 us */
1259 1260 1261 1262 1263
	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) ||
1264
	    (NCR5380_read(INITIATOR_COMMAND_REG) & ICR_ARBITRATION_LOST)) {
1265
		NCR5380_write(MODE_REG, MR_BASE);
F
Finn Thain 已提交
1266
		dprintk(NDEBUG_ARBITRATION, "scsi%d: lost arbitration, deasserting MR_ARBITRATE\n",
1267
			   HOSTNO);
1268
		spin_lock_irq(&hostdata->lock);
1269 1270
		return -1;
	}
L
Linus Torvalds 已提交
1271

1272 1273 1274 1275
	/* 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)
	 */
1276 1277 1278 1279 1280 1281 1282
	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 已提交
1283

1284 1285 1286 1287
	if (hostdata->flags & FLAG_TOSHIBA_DELAY)
		udelay(15);
	else
		udelay(2);
1288

1289 1290
	spin_lock_irq(&hostdata->lock);

1291 1292
	/* NCR5380_reselect() clears MODE_REG after a reselection interrupt */
	if (!(NCR5380_read(MODE_REG) & MR_ARBITRATE))
1293 1294
		return -1;

F
Finn Thain 已提交
1295
	dprintk(NDEBUG_ARBITRATION, "scsi%d: won arbitration\n", HOSTNO);
1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311

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

	NCR5380_write(OUTPUT_DATA_REG, (hostdata->id_mask | (1 << cmd->device->id)));

	/*
	 * Raise ATN while SEL is true before BSY goes false from arbitration,
	 * since this is the only way to guarantee that we'll get a MESSAGE OUT
	 * phase immediately after selection.
	 */

	NCR5380_write(INITIATOR_COMMAND_REG, (ICR_BASE | ICR_ASSERT_BSY |
		      ICR_ASSERT_DATA | ICR_ASSERT_ATN | ICR_ASSERT_SEL ));
L
Linus Torvalds 已提交
1312 1313
	NCR5380_write(MODE_REG, MR_BASE);

1314 1315 1316 1317 1318
	/*
	 * 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 已提交
1319

1320 1321
	spin_unlock_irq(&hostdata->lock);

1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347
	/*
	 * The initiator shall then wait at least two deskew delays and release
	 * the BSY signal.
	 */
	udelay(1);        /* wingel -- wait two bus deskew delay >2*45ns */

	/* Reset BSY */
	NCR5380_write(INITIATOR_COMMAND_REG, (ICR_BASE | ICR_ASSERT_DATA |
		      ICR_ASSERT_ATN | ICR_ASSERT_SEL));

	/*
	 * Something weird happens when we cease to drive BSY - looks
	 * like the board/chip is letting us do another read before the
	 * appropriate propagation delay has expired, and we're confusing
	 * a BSY signal from ourselves as the target's response to SELECTION.
	 *
	 * A small delay (the 'C++' frontend breaks the pipeline with an
	 * unnecessary jump, making it work on my 386-33/Trantor T128, the
	 * tighter 'C' code breaks and requires this) solves the problem -
	 * the 1 us delay is arbitrary, and only used because this delay will
	 * be the same on other platforms and since it works here, it should
	 * work there.
	 *
	 * wingel suggests that this could be due to failing to wait
	 * one deskew delay.
	 */
L
Linus Torvalds 已提交
1348

1349
	udelay(1);
L
Linus Torvalds 已提交
1350

F
Finn Thain 已提交
1351
	dprintk(NDEBUG_SELECTION, "scsi%d: selecting target %d\n", HOSTNO, cmd->device->id);
L
Linus Torvalds 已提交
1352

1353 1354 1355 1356
	/*
	 * The SCSI specification calls for a 250 ms timeout for the actual
	 * selection.
	 */
L
Linus Torvalds 已提交
1357

F
Finn Thain 已提交
1358 1359
	err = NCR5380_poll_politely(instance, STATUS_REG, SR_BSY, SR_BSY,
	                            msecs_to_jiffies(250));
1360 1361

	if ((NCR5380_read(STATUS_REG) & (SR_SEL | SR_IO)) == (SR_SEL | SR_IO)) {
1362
		spin_lock_irq(&hostdata->lock);
1363 1364
		NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
		NCR5380_reselect(instance);
1365 1366
		if (!hostdata->connected)
			NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
1367 1368 1369 1370
		printk(KERN_ERR "scsi%d: reselection after won arbitration?\n",
		       HOSTNO);
		return -1;
	}
L
Linus Torvalds 已提交
1371

F
Finn Thain 已提交
1372
	if (err < 0) {
1373
		spin_lock_irq(&hostdata->lock);
1374 1375
		NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
		cmd->result = DID_BAD_TARGET << 16;
1376
		complete_cmd(instance, cmd);
1377
		NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
F
Finn Thain 已提交
1378
		dprintk(NDEBUG_SELECTION, "scsi%d: target did not respond within 250ms\n", HOSTNO);
1379 1380 1381
		return 0;
	}

F
Finn Thain 已提交
1382 1383 1384 1385 1386 1387 1388 1389 1390 1391
	/*
	 * 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);

1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407
	/*
	 * Since we followed the SCSI spec, and raised ATN while SEL
	 * was true but before BSY was false during selection, the information
	 * transfer phase should be a MESSAGE OUT phase so that we can send the
	 * IDENTIFY message.
	 *
	 * If SCSI-II tagged queuing is enabled, we also send a SIMPLE_QUEUE_TAG
	 * message (2 bytes) with a tag ID that we increment with every command
	 * until it wraps back to 0.
	 *
	 * XXX - it turns out that there are some broken SCSI-II devices,
	 *	     which claim to support tagged queuing but fail when more than
	 *	     some number of commands are issued at once.
	 */

	/* Wait for start of REQ/ACK handshake */
1408 1409

	err = NCR5380_poll_politely(instance, STATUS_REG, SR_REQ, SR_REQ, HZ);
1410
	spin_lock_irq(&hostdata->lock);
1411 1412 1413 1414 1415 1416
	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);
		return -1;
	}
1417

F
Finn Thain 已提交
1418
	dprintk(NDEBUG_SELECTION, "scsi%d: target %d selected, going into MESSAGE OUT phase.\n",
1419 1420
		   HOSTNO, cmd->device->id);
	tmp[0] = IDENTIFY(1, cmd->device->lun);
L
Linus Torvalds 已提交
1421 1422

#ifdef SUPPORT_TAGS
1423 1424 1425 1426 1427 1428
	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 已提交
1429
#else
1430 1431
	len = 1;
	cmd->tag = 0;
L
Linus Torvalds 已提交
1432 1433
#endif /* SUPPORT_TAGS */

1434 1435 1436 1437
	/* Send message(s) */
	data = tmp;
	phase = PHASE_MSGOUT;
	NCR5380_transfer_pio(instance, &phase, &len, &data);
F
Finn Thain 已提交
1438
	dprintk(NDEBUG_SELECTION, "scsi%d: nexus established.\n", HOSTNO);
1439
	/* XXX need to handle errors here */
1440

1441
	hostdata->connected = cmd;
L
Linus Torvalds 已提交
1442
#ifndef SUPPORT_TAGS
1443 1444
	hostdata->busy[cmd->device->id] |= (1 << cmd->device->lun);
#endif
1445 1446 1447
#ifdef SUN3_SCSI_VME
	dregs->csr |= CSR_INTR;
#endif
L
Linus Torvalds 已提交
1448

1449
	initialize_SCp(cmd);
L
Linus Torvalds 已提交
1450

1451
	return 0;
L
Linus Torvalds 已提交
1452 1453
}

1454 1455
/*
 * Function : int NCR5380_transfer_pio (struct Scsi_Host *instance,
L
Linus Torvalds 已提交
1456 1457 1458 1459
 *      unsigned char *phase, int *count, unsigned char **data)
 *
 * Purpose : transfers data in given phase using polled I/O
 *
1460 1461
 * Inputs : instance - instance of driver, *phase - pointer to
 *	what phase is expected, *count - pointer to number of
L
Linus Torvalds 已提交
1462
 *	bytes to transfer, **data - pointer to data pointer.
1463
 *
L
Linus Torvalds 已提交
1464
 * Returns : -1 when different phase is entered without transferring
L
Lucas De Marchi 已提交
1465
 *	maximum number of bytes, 0 if all bytes are transferred or exit
L
Linus Torvalds 已提交
1466 1467
 *	is in same phase.
 *
1468
 *	Also, *phase, *count, *data are modified in place.
L
Linus Torvalds 已提交
1469 1470 1471 1472 1473
 *
 * XXX Note : handling for bus free may be useful.
 */

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

1479 1480 1481
static int NCR5380_transfer_pio(struct Scsi_Host *instance,
				unsigned char *phase, int *count,
				unsigned char **data)
L
Linus Torvalds 已提交
1482
{
1483 1484 1485 1486 1487 1488 1489 1490
	register unsigned char p = *phase, tmp;
	register int c = *count;
	register unsigned char *d = *data;

	/*
	 * The NCR5380 chip will only drive the SCSI bus when the
	 * phase specified in the appropriate bits of the TARGET COMMAND
	 * REGISTER match the STATUS REGISTER
L
Linus Torvalds 已提交
1491 1492
	 */

1493
	NCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(p));
L
Linus Torvalds 已提交
1494

1495 1496 1497 1498 1499
	do {
		/*
		 * Wait for assertion of REQ, after which the phase bits will be
		 * valid
		 */
1500 1501 1502

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

F
Finn Thain 已提交
1504
		dprintk(NDEBUG_HANDSHAKE, "scsi%d: REQ detected\n", HOSTNO);
L
Linus Torvalds 已提交
1505

1506
		/* Check for phase mismatch */
1507
		if ((NCR5380_read(STATUS_REG) & PHASE_MASK) != p) {
F
Finn Thain 已提交
1508
			dprintk(NDEBUG_PIO, "scsi%d: phase mismatch\n", HOSTNO);
1509
			NCR5380_dprint_phase(NDEBUG_PIO, instance);
1510 1511
			break;
		}
L
Linus Torvalds 已提交
1512

1513 1514 1515 1516 1517
		/* 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 已提交
1518

1519
		++d;
L
Linus Torvalds 已提交
1520

1521 1522 1523 1524 1525 1526
		/*
		 * 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 已提交
1527

1528 1529 1530
		if (!(p & SR_IO)) {
			if (!((p & SR_MSG) && c > 1)) {
				NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_DATA);
1531
				NCR5380_dprint(NDEBUG_PIO, instance);
1532 1533 1534 1535 1536
				NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE |
					      ICR_ASSERT_DATA | ICR_ASSERT_ACK);
			} else {
				NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE |
					      ICR_ASSERT_DATA | ICR_ASSERT_ATN);
1537
				NCR5380_dprint(NDEBUG_PIO, instance);
1538 1539 1540 1541
				NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE |
					      ICR_ASSERT_DATA | ICR_ASSERT_ATN | ICR_ASSERT_ACK);
			}
		} else {
1542
			NCR5380_dprint(NDEBUG_PIO, instance);
1543 1544
			NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ACK);
		}
L
Linus Torvalds 已提交
1545

1546 1547 1548
		if (NCR5380_poll_politely(instance,
		                          STATUS_REG, SR_REQ, 0, 5 * HZ) < 0)
			break;
1549

F
Finn Thain 已提交
1550
		dprintk(NDEBUG_HANDSHAKE, "scsi%d: req false, handshake complete\n", HOSTNO);
1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570

		/*
		 * We have several special cases to consider during REQ/ACK handshaking :
		 * 1.  We were in MSGOUT phase, and we are on the last byte of the
		 *	message.  ATN must be dropped as ACK is dropped.
		 *
		 * 2.  We are in a MSGIN phase, and we are on the last byte of the
		 *	message.  We must exit with ACK asserted, so that the calling
		 *	code may raise ATN before dropping ACK to reject the message.
		 *
		 * 3.  ACK and ATN are clear and the target may proceed as normal.
		 */
		if (!(p == PHASE_MSGIN && c == 1)) {
			if (p == PHASE_MSGOUT && c > 1)
				NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN);
			else
				NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
		}
	} while (--c);

F
Finn Thain 已提交
1571
	dprintk(NDEBUG_PIO, "scsi%d: residual %d\n", HOSTNO, c);
1572 1573 1574 1575 1576

	*count = c;
	*data = d;
	tmp = NCR5380_read(STATUS_REG);
	/* The phase read from the bus is valid if either REQ is (already)
1577 1578
	 * 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.
1579
	 */
1580
	if ((tmp & SR_REQ) || ((tmp & SR_IO) && c == 0))
1581 1582 1583 1584 1585 1586 1587 1588
		*phase = tmp & PHASE_MASK;
	else
		*phase = PHASE_UNKNOWN;

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

1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616
/**
 * 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);
}

1617 1618 1619 1620
/**
 * do_abort - abort the currently established nexus by going to
 * MESSAGE OUT phase and sending an ABORT message.
 * @instance: relevant scsi host instance
1621
 *
1622
 * Returns 0 on success, -1 on failure.
L
Linus Torvalds 已提交
1623 1624
 */

1625
static int do_abort(struct Scsi_Host *instance)
L
Linus Torvalds 已提交
1626
{
1627 1628
	unsigned char tmp, *msgptr, phase;
	int len;
1629
	int rc;
1630 1631

	/* Request message out phase */
L
Linus Torvalds 已提交
1632
	NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN);
1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643

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

1644 1645 1646 1647 1648
	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;
1649 1650 1651

	NCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(tmp));

1652 1653 1654 1655 1656 1657
	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;
1658 1659 1660 1661 1662 1663 1664
		NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN);
	}

	tmp = ABORT;
	msgptr = &tmp;
	len = 1;
	phase = PHASE_MSGOUT;
1665
	NCR5380_transfer_pio(instance, &phase, &len, &msgptr);
1666 1667 1668 1669 1670 1671 1672

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

	return len ? -1 : 0;
1673 1674 1675 1676

timeout:
	NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
	return -1;
L
Linus Torvalds 已提交
1677 1678 1679
}

#if defined(REAL_DMA)
1680 1681
/*
 * Function : int NCR5380_transfer_dma (struct Scsi_Host *instance,
L
Linus Torvalds 已提交
1682 1683 1684 1685 1686
 *      unsigned char *phase, int *count, unsigned char **data)
 *
 * Purpose : transfers data in given phase using either real
 *	or pseudo DMA.
 *
1687 1688
 * Inputs : instance - instance of driver, *phase - pointer to
 *	what phase is expected, *count - pointer to number of
L
Linus Torvalds 已提交
1689
 *	bytes to transfer, **data - pointer to data pointer.
1690
 *
L
Linus Torvalds 已提交
1691
 * Returns : -1 when different phase is entered without transferring
L
Lucas De Marchi 已提交
1692
 *	maximum number of bytes, 0 if all bytes or transferred or exit
L
Linus Torvalds 已提交
1693 1694
 *	is in same phase.
 *
1695
 *	Also, *phase, *count, *data are modified in place.
L
Linus Torvalds 已提交
1696 1697 1698 1699
 *
 */


1700 1701 1702
static int NCR5380_transfer_dma(struct Scsi_Host *instance,
				unsigned char *phase, int *count,
				unsigned char **data)
L
Linus Torvalds 已提交
1703
{
F
Finn Thain 已提交
1704
	struct NCR5380_hostdata *hostdata = shost_priv(instance);
1705 1706
	register int c = *count;
	register unsigned char p = *phase;
1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725

#if defined(CONFIG_SUN3)
	/* sanity check */
	if (!sun3_dma_setup_done) {
		pr_err("scsi%d: transfer_dma without setup!\n",
		       instance->host_no);
		BUG();
	}
	hostdata->dma_len = c;

	dprintk(NDEBUG_DMA, "scsi%d: initializing DMA for %s, %d bytes %s %p\n",
		instance->host_no, (p & SR_IO) ? "reading" : "writing",
		c, (p & SR_IO) ? "to" : "from", *data);

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

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

1726 1727 1728
	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);
1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743
	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) */
1744 1745 1746 1747 1748 1749 1750
	register unsigned char *d = *data;
	unsigned char tmp;

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

1752 1753
	if (hostdata->read_overruns && (p & SR_IO))
		c -= hostdata->read_overruns;
L
Linus Torvalds 已提交
1754

F
Finn Thain 已提交
1755
	dprintk(NDEBUG_DMA, "scsi%d: initializing DMA for %s, %d bytes %s %p\n",
1756 1757
		   HOSTNO, (p & SR_IO) ? "reading" : "writing",
		   c, (p & SR_IO) ? "to" : "from", d);
L
Linus Torvalds 已提交
1758

1759
	NCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(p));
1760 1761
	NCR5380_write(MODE_REG, MR_BASE | MR_DMA_MODE | MR_MONITOR_BSY |
	                        MR_ENABLE_EOP_INTR);
L
Linus Torvalds 已提交
1762

1763
	if (!(hostdata->flags & FLAG_LATE_DMA_SETUP)) {
1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778
		/* 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);
	}

1779
	if (hostdata->flags & FLAG_LATE_DMA_SETUP) {
1780 1781 1782 1783 1784 1785 1786
		/* 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);
	}
1787 1788
#endif /* !defined(CONFIG_SUN3) */

1789
	return 0;
L
Linus Torvalds 已提交
1790 1791 1792 1793 1794 1795
}
#endif /* defined(REAL_DMA) */

/*
 * Function : NCR5380_information_transfer (struct Scsi_Host *instance)
 *
1796 1797
 * Purpose : run through the various SCSI phases and do as the target
 *	directs us to.  Operates on the currently connected command,
L
Linus Torvalds 已提交
1798 1799 1800 1801
 *	instance->connected.
 *
 * Inputs : instance, instance for which we are doing commands
 *
1802
 * Side effects : SCSI things happen, the disconnected queue will be
L
Linus Torvalds 已提交
1803 1804 1805
 *	modified if a command disconnects, *instance->connected will
 *	change.
 *
1806 1807
 * XXX Note : we need to watch for bus free or a reset condition here
 *	to recover from an unexpected bus free condition.
L
Linus Torvalds 已提交
1808
 */
1809 1810

static void NCR5380_information_transfer(struct Scsi_Host *instance)
L
Linus Torvalds 已提交
1811
{
F
Finn Thain 已提交
1812
	struct NCR5380_hostdata *hostdata = shost_priv(instance);
1813 1814 1815
	unsigned char msgout = NOP;
	int sink = 0;
	int len;
L
Linus Torvalds 已提交
1816
#if defined(REAL_DMA)
1817
	int transfersize;
L
Linus Torvalds 已提交
1818
#endif
1819 1820
	unsigned char *data;
	unsigned char phase, tmp, extended_msg[10], old_phase = 0xff;
1821
	struct scsi_cmnd *cmd;
1822

1823 1824 1825 1826
#ifdef SUN3_SCSI_VME
	dregs->csr |= CSR_INTR;
#endif

1827
	while ((cmd = hostdata->connected)) {
1828 1829
		struct NCR5380_cmd *ncmd = scsi_cmd_priv(cmd);

1830 1831 1832 1833 1834 1835
		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;
1836
				NCR5380_dprint_phase(NDEBUG_INFORMATION, instance);
1837
			}
1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864
#if defined(CONFIG_SUN3)
			if (phase == PHASE_CMDOUT) {
#if defined(REAL_DMA)
				void *d;
				unsigned long count;

				if (!cmd->SCp.this_residual && cmd->SCp.buffers_residual) {
					count = cmd->SCp.buffer->length;
					d = sg_virt(cmd->SCp.buffer);
				} else {
					count = cmd->SCp.this_residual;
					d = cmd->SCp.ptr;
				}
				/* this command setup for dma yet? */
				if ((count >= DMA_MIN_SIZE) && (sun3_dma_setup_done != cmd)) {
					if (cmd->request->cmd_type == REQ_TYPE_FS) {
						sun3scsi_dma_setup(d, count,
						                   rq_data_dir(cmd->request));
						sun3_dma_setup_done = cmd;
					}
				}
#endif
#ifdef SUN3_SCSI_VME
				dregs->csr |= CSR_INTR;
#endif
			}
#endif /* CONFIG_SUN3 */
L
Linus Torvalds 已提交
1865

1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880
			if (sink && (phase != PHASE_MSGOUT)) {
				NCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(tmp));

				NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN |
					      ICR_ASSERT_ACK);
				while (NCR5380_read(STATUS_REG) & SR_REQ)
					;
				NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE |
					      ICR_ASSERT_ATN);
				sink = 0;
				continue;
			}

			switch (phase) {
			case PHASE_DATAOUT:
L
Linus Torvalds 已提交
1881
#if (NDEBUG & NDEBUG_NO_DATAOUT)
1882 1883 1884 1885 1886
				printk("scsi%d: NDEBUG_NO_DATAOUT set, attempted DATAOUT "
				       "aborted\n", HOSTNO);
				sink = 1;
				do_abort(instance);
				cmd->result = DID_ERROR << 16;
1887
				complete_cmd(instance, cmd);
1888
				return;
L
Linus Torvalds 已提交
1889
#endif
1890 1891 1892 1893 1894 1895 1896 1897 1898 1899
			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 已提交
1900
					cmd->SCp.ptr = sg_virt(cmd->SCp.buffer);
1901 1902 1903 1904
					/* ++roman: Try to merge some scatter-buffers if
					 * they are at contiguous physical addresses.
					 */
					merge_contiguous_buffers(cmd);
F
Finn Thain 已提交
1905
					dprintk(NDEBUG_INFORMATION, "scsi%d: %d bytes and %d buffers left\n",
1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923
						   HOSTNO, cmd->SCp.this_residual,
						   cmd->SCp.buffers_residual);
				}

				/*
				 * The preferred transfer method is going to be
				 * PSEUDO-DMA for systems that are strictly PIO,
				 * since we can let the hardware do the handshaking.
				 *
				 * For this to work, we need to know the transfersize
				 * ahead of time, since the pseudo-DMA code will sit
				 * in an unconditional loop.
				 */

				/* ++roman: I suggest, this should be
				 *   #if def(REAL_DMA)
				 * instead of leaving REAL_DMA out.
				 */
L
Linus Torvalds 已提交
1924 1925

#if defined(REAL_DMA)
1926
#if !defined(CONFIG_SUN3)
1927 1928
				transfersize = 0;
				if (!cmd->device->borken)
1929
#endif
1930 1931 1932
					transfersize = NCR5380_dma_xfer_len(instance, cmd, phase);

				if (transfersize >= DMA_MIN_SIZE) {
1933 1934 1935 1936 1937 1938 1939 1940
					len = transfersize;
					cmd->SCp.phase = phase;
					if (NCR5380_transfer_dma(instance, &phase,
					    &len, (unsigned char **)&cmd->SCp.ptr)) {
						/*
						 * If the watchdog timer fires, all future
						 * accesses to this device will use the
						 * polled-IO. */
F
Finn Thain 已提交
1941 1942
						scmd_printk(KERN_INFO, cmd,
							"switching to slow handshake\n");
1943 1944 1945 1946
						cmd->device->borken = 1;
						sink = 1;
						do_abort(instance);
						cmd->result = DID_ERROR << 16;
1947
						complete_cmd(instance, cmd);
1948 1949
						/* XXX - need to source or sink data here, as appropriate */
					} else {
L
Linus Torvalds 已提交
1950
#ifdef REAL_DMA
1951 1952 1953 1954 1955 1956 1957 1958
						/* ++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 已提交
1959
#endif
1960 1961
					}
				} else
L
Linus Torvalds 已提交
1962
#endif /* defined(REAL_DMA) */
1963 1964
				{
					spin_unlock_irq(&hostdata->lock);
1965 1966 1967
					NCR5380_transfer_pio(instance, &phase,
							     (int *)&cmd->SCp.this_residual,
							     (unsigned char **)&cmd->SCp.ptr);
1968 1969
					spin_lock_irq(&hostdata->lock);
				}
1970 1971 1972 1973 1974
#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
1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986
				break;
			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);
1987 1988 1989
					dsprintk(NDEBUG_QUEUES, instance,
					         "COMMAND COMPLETE %p target %d lun %llu\n",
					         cmd, scmd_id(cmd), cmd->device->lun);
1990 1991

					hostdata->connected = NULL;
L
Linus Torvalds 已提交
1992
#ifdef SUPPORT_TAGS
1993 1994
					cmd_free_tag(cmd);
					if (status_byte(cmd->SCp.Status) == QUEUE_FULL) {
1995
						struct tag_alloc *ta = &hostdata->TagAlloc[scmd_id(cmd)][cmd->device->lun];
H
Hannes Reinecke 已提交
1996
						dprintk(NDEBUG_TAGS, "scsi%d: target %d lun %llu returned "
1997 1998 1999 2000
							   "QUEUE_FULL after %d commands\n",
							   HOSTNO, cmd->device->id, cmd->device->lun,
							   ta->nr_allocated);
						if (ta->queue_size > ta->nr_allocated)
F
Finn Thain 已提交
2001
							ta->queue_size = ta->nr_allocated;
2002
					}
L
Linus Torvalds 已提交
2003
#endif
2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024

					/*
					 * I'm not sure what the correct thing to do here is :
					 *
					 * If the command that just executed is NOT a request
					 * sense, the obvious thing to do is to set the result
					 * code to the values of the stored parameters.
					 *
					 * If it was a REQUEST SENSE command, we need some way to
					 * differentiate between the failure code of the original
					 * and the failure code of the REQUEST sense - the obvious
					 * case is success, where we fall through and leave the
					 * result code unchanged.
					 *
					 * The non-obvious place is where the REQUEST SENSE failed
					 */

					if (cmd->cmnd[0] != REQUEST_SENSE)
						cmd->result = cmd->SCp.Status | (cmd->SCp.Message << 8);
					else if (status_byte(cmd->SCp.Status) != GOOD)
						cmd->result = (cmd->result & 0x00ffff) | (DID_ERROR << 16);
L
Linus Torvalds 已提交
2025

2026 2027 2028 2029 2030 2031
					if ((cmd->cmnd[0] == REQUEST_SENSE) &&
						hostdata->ses.cmd_len) {
						scsi_eh_restore_cmnd(cmd, &hostdata->ses);
						hostdata->ses.cmd_len = 0 ;
					}

2032 2033
					if ((cmd->cmnd[0] != REQUEST_SENSE) &&
					    (status_byte(cmd->SCp.Status) == CHECK_CONDITION)) {
2034 2035
						scsi_eh_prep_cmnd(cmd, &hostdata->ses, NULL, 0, ~0);

2036
						list_add(&ncmd->list, &hostdata->unissued);
2037 2038
						dsprintk(NDEBUG_AUTOSENSE | NDEBUG_QUEUES,
						         instance, "REQUEST SENSE cmd %p added to head of issue queue\n",
2039
						         cmd);
2040 2041 2042 2043 2044
#ifdef SUPPORT_TAGS
						cmd_free_tag(cmd);
#else
						hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun);
#endif
2045
					} else {
2046
						complete_cmd(instance, cmd);
2047 2048 2049 2050 2051 2052 2053 2054
					}

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

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

2058 2059 2060 2061
					/* ++roman: For Falcon SCSI, release the lock on the
					 * ST-DMA here if no other commands are waiting on the
					 * disconnected queue.
					 */
2062
					maybe_release_dma_irq(instance);
2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079
					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;
H
Hannes Reinecke 已提交
2080
						dprintk(NDEBUG_TAGS, "scsi%d: target %d lun %llu rejected "
2081 2082 2083 2084 2085 2086 2087 2088 2089 2090
							   "QUEUE_TAG message; tagged queuing "
							   "disabled\n",
							   HOSTNO, cmd->device->id, cmd->device->lun);
						break;
					}
					break;
				case DISCONNECT:
					/* Accept message by clearing ACK */
					NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
					hostdata->connected = NULL;
2091
					list_add(&ncmd->list, &hostdata->disconnected);
2092 2093 2094 2095
					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);

2096 2097 2098 2099 2100 2101 2102 2103
					/*
					 * 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);
2104 2105 2106
#ifdef SUN3_SCSI_VME
					dregs->csr |= CSR_DMA_ENABLE;
#endif
2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139
					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:
					/*
					 * Extended messages are sent in the following format :
					 * Byte
					 * 0		EXTENDED_MESSAGE == 1
					 * 1		length (includes one byte for code, doesn't
					 *		include first two bytes)
					 * 2		code
					 * 3..length+1	arguments
					 *
					 * Start the extended message buffer with the EXTENDED_MESSAGE
					 * byte, since spi_print_msg() wants the whole thing.
					 */
					extended_msg[0] = EXTENDED_MESSAGE;
					/* Accept first byte by clearing ACK */
					NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);

2140 2141
					spin_unlock_irq(&hostdata->lock);

F
Finn Thain 已提交
2142
					dprintk(NDEBUG_EXTENDED, "scsi%d: receiving extended message\n", HOSTNO);
2143 2144 2145 2146 2147

					len = 2;
					data = extended_msg + 1;
					phase = PHASE_MSGIN;
					NCR5380_transfer_pio(instance, &phase, &len, &data);
F
Finn Thain 已提交
2148
					dprintk(NDEBUG_EXTENDED, "scsi%d: length=%d, code=0x%02x\n", HOSTNO,
2149 2150
						   (int)extended_msg[1], (int)extended_msg[2]);

2151 2152
					if (!len && extended_msg[1] > 0 &&
					    extended_msg[1] <= sizeof(extended_msg) - 2) {
2153 2154 2155 2156 2157 2158 2159
						/* 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);
F
Finn Thain 已提交
2160
						dprintk(NDEBUG_EXTENDED, "scsi%d: message received, residual %d\n",
2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179
							   HOSTNO, len);

						switch (extended_msg[2]) {
						case EXTENDED_SDTR:
						case EXTENDED_WDTR:
						case EXTENDED_MODIFY_DATA_POINTER:
						case EXTENDED_EXTENDED_IDENTIFY:
							tmp = 0;
						}
					} else if (len) {
						printk(KERN_NOTICE "scsi%d: error receiving "
						       "extended message\n", HOSTNO);
						tmp = 0;
					} else {
						printk(KERN_NOTICE "scsi%d: extended message "
							   "code %02x length %d is too long\n",
							   HOSTNO, extended_msg[2], extended_msg[1]);
						tmp = 0;
					}
2180 2181 2182 2183 2184

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

2185 2186 2187 2188 2189 2190 2191 2192
					/* Fall through to reject message */

					/*
					 * If we get something weird that we aren't expecting,
					 * reject it.
					 */
				default:
					if (!tmp) {
F
Finn Thain 已提交
2193 2194
						printk(KERN_INFO "scsi%d: rejecting message ",
						       instance->host_no);
2195 2196 2197
						spi_print_msg(extended_msg);
						printk("\n");
					} else if (tmp != EXTENDED_MESSAGE)
F
Finn Thain 已提交
2198 2199 2200
						scmd_printk(KERN_INFO, cmd,
						            "rejecting unknown message %02x\n",
						            tmp);
2201
					else
F
Finn Thain 已提交
2202 2203 2204
						scmd_printk(KERN_INFO, cmd,
						            "rejecting unknown extended message code %02x, length %d\n",
						            extended_msg[1], extended_msg[0]);
2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218

					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;
2219
					complete_cmd(instance, cmd);
2220
					maybe_release_dma_irq(instance);
2221
					NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243
					return;
				}
				msgout = NOP;
				break;
			case PHASE_CMDOUT:
				len = cmd->cmd_len;
				data = cmd->cmnd;
				/*
				 * XXX for performance reasons, on machines with a
				 * PSEUDO-DMA architecture we should probably
				 * use the dma transfer function.
				 */
				NCR5380_transfer_pio(instance, &phase, &len, &data);
				break;
			case PHASE_STATIN:
				len = 1;
				data = &tmp;
				NCR5380_transfer_pio(instance, &phase, &len, &data);
				cmd->SCp.Status = tmp;
				break;
			default:
				printk("scsi%d: unknown phase\n", HOSTNO);
2244
				NCR5380_dprint(NDEBUG_ANY, instance);
2245
			} /* switch(phase) */
2246
		} else {
2247
			spin_unlock_irq(&hostdata->lock);
2248
			NCR5380_poll_politely(instance, STATUS_REG, SR_REQ, SR_REQ, HZ);
2249
			spin_lock_irq(&hostdata->lock);
2250
		}
2251
	}
L
Linus Torvalds 已提交
2252 2253 2254 2255 2256
}

/*
 * Function : void NCR5380_reselect (struct Scsi_Host *instance)
 *
2257
 * Purpose : does reselection, initializing the instance->connected
F
Finn Thain 已提交
2258
 *	field to point to the scsi_cmnd for which the I_T_L or I_T_L_Q
L
Linus Torvalds 已提交
2259
 *	nexus has been reestablished,
2260
 *
L
Linus Torvalds 已提交
2261 2262 2263 2264 2265
 * Inputs : instance - this instance of the NCR5380.
 *
 */


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

2269
static void NCR5380_reselect(struct Scsi_Host *instance)
L
Linus Torvalds 已提交
2270
{
F
Finn Thain 已提交
2271
	struct NCR5380_hostdata *hostdata = shost_priv(instance);
2272
	unsigned char target_mask;
2273
	unsigned char lun;
L
Linus Torvalds 已提交
2274
#ifdef SUPPORT_TAGS
2275
	unsigned char tag;
L
Linus Torvalds 已提交
2276
#endif
2277
	unsigned char msg[3];
2278 2279
	int __maybe_unused len;
	unsigned char __maybe_unused *data, __maybe_unused phase;
2280 2281
	struct NCR5380_cmd *ncmd;
	struct scsi_cmnd *tmp;
2282 2283 2284 2285 2286 2287 2288 2289 2290 2291

	/*
	 * 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);

F
Finn Thain 已提交
2292
	dprintk(NDEBUG_RESELECTION, "scsi%d: reselect\n", HOSTNO);
2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303

	/*
	 * 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);
2304 2305 2306 2307 2308
	if (NCR5380_poll_politely(instance,
	                          STATUS_REG, SR_SEL, 0, 2 * HZ) < 0) {
		NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
		return;
	}
2309 2310 2311 2312 2313 2314
	NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);

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

2315 2316 2317 2318 2319
	if (NCR5380_poll_politely(instance,
	                          STATUS_REG, SR_REQ, SR_REQ, 2 * HZ) < 0) {
		do_abort(instance);
		return;
	}
2320

2321 2322 2323 2324 2325 2326 2327
#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
2328 2329 2330 2331
	len = 1;
	data = msg;
	phase = PHASE_MSGIN;
	NCR5380_transfer_pio(instance, &phase, &len, &data);
2332 2333 2334 2335 2336

	if (len) {
		do_abort(instance);
		return;
	}
2337
#endif
2338 2339

	if (!(msg[0] & 0x80)) {
2340
		shost_printk(KERN_ERR, instance, "expecting IDENTIFY message, got ");
2341
		spi_print_msg(msg);
2342
		printk("\n");
2343 2344 2345
		do_abort(instance);
		return;
	}
2346
	lun = msg[0] & 0x07;
L
Linus Torvalds 已提交
2347

2348
#if defined(SUPPORT_TAGS) && !defined(CONFIG_SUN3)
2349 2350 2351 2352 2353
	/* 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;
2354
	if (phase == PHASE_MSGIN && (hostdata->flags & FLAG_TAGGED_QUEUING)) {
2355 2356 2357 2358 2359 2360 2361
		/* 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];
F
Finn Thain 已提交
2362
		dprintk(NDEBUG_TAGS, "scsi%d: target mask %02x, lun %d sent tag %d at "
2363 2364
			   "reselection\n", HOSTNO, target_mask, lun, tag);
	}
L
Linus Torvalds 已提交
2365
#endif
2366 2367 2368 2369 2370 2371

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

2372 2373 2374 2375 2376 2377
	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 已提交
2378
#ifdef SUPPORT_TAGS
2379
		    && (tag == cmd->tag)
L
Linus Torvalds 已提交
2380
#endif
2381
		    ) {
2382 2383
			list_del(&ncmd->list);
			tmp = cmd;
2384 2385
			break;
		}
L
Linus Torvalds 已提交
2386
	}
2387

2388 2389 2390 2391 2392
	if (tmp) {
		dsprintk(NDEBUG_RESELECTION | NDEBUG_QUEUES, instance,
		         "reselect: removed %p from disconnected queue\n", tmp);
	} else {

L
Linus Torvalds 已提交
2393
#ifdef SUPPORT_TAGS
2394 2395 2396 2397 2398
		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 已提交
2399
#endif
2400 2401 2402 2403 2404 2405 2406
		/*
		 * Since we have an established nexus that we can't do anything
		 * with, we must abort it.
		 */
		do_abort(instance);
		return;
	}
L
Linus Torvalds 已提交
2407

2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430
#if defined(CONFIG_SUN3) && defined(REAL_DMA)
	/* engage dma setup for the command we just saw */
	{
		void *d;
		unsigned long count;

		if (!tmp->SCp.this_residual && tmp->SCp.buffers_residual) {
			count = tmp->SCp.buffer->length;
			d = sg_virt(tmp->SCp.buffer);
		} else {
			count = tmp->SCp.this_residual;
			d = tmp->SCp.ptr;
		}
		/* setup this command for dma if not already */
		if ((count >= DMA_MIN_SIZE) && (sun3_dma_setup_done != tmp)) {
			sun3scsi_dma_setup(d, count, rq_data_dir(tmp->request));
			sun3_dma_setup_done = tmp;
		}
	}

	NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ACK);
#endif

2431 2432
	/* Accept message by clearing ACK */
	NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
L
Linus Torvalds 已提交
2433

2434 2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452
#if defined(SUPPORT_TAGS) && defined(CONFIG_SUN3)
	/* If the phase is still MSGIN, the target wants to send some more
	 * messages. In case it supports tagged queuing, this is probably a
	 * SIMPLE_QUEUE_TAG for the I_T_L_Q nexus.
	 */
	tag = TAG_NONE;
	if (phase == PHASE_MSGIN && setup_use_tagged_queuing) {
		/* Accept previous IDENTIFY message by clearing ACK */
		NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
		len = 2;
		data = msg + 1;
		if (!NCR5380_transfer_pio(instance, &phase, &len, &data) &&
		    msg[1] == SIMPLE_QUEUE_TAG)
			tag = msg[2];
		dprintk(NDEBUG_TAGS, "scsi%d: target mask %02x, lun %d sent tag %d at reselection\n"
			HOSTNO, target_mask, lun, tag);
	}
#endif

2453
	hostdata->connected = tmp;
H
Hannes Reinecke 已提交
2454
	dprintk(NDEBUG_RESELECTION, "scsi%d: nexus established, target = %d, lun = %llu, tag = %d\n",
2455
		   HOSTNO, tmp->device->id, tmp->device->lun, tmp->tag);
L
Linus Torvalds 已提交
2456 2457 2458 2459
}


/*
F
Finn Thain 已提交
2460
 * Function : int NCR5380_abort (struct scsi_cmnd *cmd)
L
Linus Torvalds 已提交
2461 2462 2463
 *
 * Purpose : abort a command
 *
F
Finn Thain 已提交
2464
 * Inputs : cmd - the scsi_cmnd to abort, code - code to set the
2465
 *	host byte of the result field to, if zero DID_ABORTED is
L
Linus Torvalds 已提交
2466 2467
 *	used.
 *
2468
 * Returns : SUCCESS - success, FAILED on failure.
L
Linus Torvalds 已提交
2469
 *
2470 2471
 * XXX - there is no way to abort the command that is currently
 *	 connected, you have to wait for it to complete.  If this is
L
Linus Torvalds 已提交
2472
 *	 a problem, we could implement longjmp() / setjmp(), setjmp()
2473
 *	 called where the loop started in NCR5380_main().
L
Linus Torvalds 已提交
2474 2475 2476
 */

static
F
Finn Thain 已提交
2477
int NCR5380_abort(struct scsi_cmnd *cmd)
L
Linus Torvalds 已提交
2478
{
2479
	struct Scsi_Host *instance = cmd->device->host;
F
Finn Thain 已提交
2480
	struct NCR5380_hostdata *hostdata = shost_priv(instance);
2481
	unsigned long flags;
L
Linus Torvalds 已提交
2482

2483
	spin_lock_irqsave(&hostdata->lock, flags);
2484

2485 2486 2487
#if (NDEBUG & NDEBUG_ANY)
	scmd_printk(KERN_INFO, cmd, "aborting command\n");
#endif
2488 2489
	NCR5380_dprint(NDEBUG_ANY, instance);
	NCR5380_dprint_phase(NDEBUG_ANY, instance);
L
Linus Torvalds 已提交
2490

2491
	spin_unlock_irqrestore(&hostdata->lock, flags);
2492

2493
	return FAILED;
L
Linus Torvalds 已提交
2494 2495 2496
}


2497 2498 2499
/**
 * NCR5380_bus_reset - reset the SCSI bus
 * @cmd: SCSI command undergoing EH
L
Linus Torvalds 已提交
2500
 *
2501
 * Returns SUCCESS
2502
 */
L
Linus Torvalds 已提交
2503

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

2511
	spin_lock_irqsave(&hostdata->lock, flags);
2512 2513 2514 2515

#if (NDEBUG & NDEBUG_ANY)
	scmd_printk(KERN_INFO, cmd, "performing bus reset\n");
#endif
2516 2517
	NCR5380_dprint(NDEBUG_ANY, instance);
	NCR5380_dprint_phase(NDEBUG_ANY, instance);
2518 2519

	do_reset(instance);
2520 2521 2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532

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

	if (hostdata->connected)
2533
		dsprintk(NDEBUG_ABORT, instance, "reset aborted a connected command\n");
2534
	hostdata->connected = NULL;
2535 2536 2537 2538 2539 2540 2541 2542 2543

	if (!list_empty(&hostdata->unissued))
		dsprintk(NDEBUG_ABORT, instance, "reset aborted unissued list\n");
	INIT_LIST_HEAD(&hostdata->unissued);

	if (!list_empty(&hostdata->disconnected))
		dsprintk(NDEBUG_ABORT, instance, "reset aborted disconnected list\n");
	INIT_LIST_HEAD(&hostdata->disconnected);

L
Linus Torvalds 已提交
2544
#ifdef SUPPORT_TAGS
2545
	free_all_tags(hostdata);
L
Linus Torvalds 已提交
2546
#endif
2547 2548
	for (i = 0; i < 8; ++i)
		hostdata->busy[i] = 0;
L
Linus Torvalds 已提交
2549
#ifdef REAL_DMA
2550
	hostdata->dma_len = 0;
L
Linus Torvalds 已提交
2551
#endif
2552 2553

	maybe_release_dma_irq(instance);
2554
	spin_unlock_irqrestore(&hostdata->lock, flags);
L
Linus Torvalds 已提交
2555

2556
	return SUCCESS;
L
Linus Torvalds 已提交
2557
}