• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * NCR 5380 generic driver routines.  These should make it *trivial*
3  * to implement 5380 SCSI drivers under Linux with a non-trantor
4  * architecture.
5  *
6  * Note that these routines also work with NR53c400 family chips.
7  *
8  * Copyright 1993, Drew Eckhardt
9  * Visionary Computing
10  * (Unix and Linux consulting and custom programming)
11  * drew@colorado.edu
12  * +1 (303) 666-5836
13  *
14  * For more information, please consult
15  *
16  * NCR 5380 Family
17  * SCSI Protocol Controller
18  * Databook
19  *
20  * NCR Microelectronics
21  * 1635 Aeroplaza Drive
22  * Colorado Springs, CO 80916
23  * 1+ (719) 578-3400
24  * 1+ (800) 334-5454
25  */
26 
27 /*
28  * With contributions from Ray Van Tassle, Ingmar Baumgart,
29  * Ronald van Cuijlenborg, Alan Cox and others.
30  */
31 
32 /* Ported to Atari by Roman Hodek and others. */
33 
34 /* Adapted for the Sun 3 by Sam Creasey. */
35 
36 /*
37  * Design
38  *
39  * This is a generic 5380 driver.  To use it on a different platform,
40  * one simply writes appropriate system specific macros (ie, data
41  * transfer - some PC's will use the I/O bus, 68K's must use
42  * memory mapped) and drops this file in their 'C' wrapper.
43  *
44  * As far as command queueing, two queues are maintained for
45  * each 5380 in the system - commands that haven't been issued yet,
46  * and commands that are currently executing.  This means that an
47  * unlimited number of commands may be queued, letting
48  * more commands propagate from the higher driver levels giving higher
49  * throughput.  Note that both I_T_L and I_T_L_Q nexuses are supported,
50  * allowing multiple commands to propagate all the way to a SCSI-II device
51  * while a command is already executing.
52  *
53  *
54  * Issues specific to the NCR5380 :
55  *
56  * When used in a PIO or pseudo-dma mode, the NCR5380 is a braindead
57  * piece of hardware that requires you to sit in a loop polling for
58  * the REQ signal as long as you are connected.  Some devices are
59  * brain dead (ie, many TEXEL CD ROM drives) and won't disconnect
60  * while doing long seek operations. [...] These
61  * broken devices are the exception rather than the rule and I'd rather
62  * spend my time optimizing for the normal case.
63  *
64  * Architecture :
65  *
66  * At the heart of the design is a coroutine, NCR5380_main,
67  * which is started from a workqueue for each NCR5380 host in the
68  * system.  It attempts to establish I_T_L or I_T_L_Q nexuses by
69  * removing the commands from the issue queue and calling
70  * NCR5380_select() if a nexus is not established.
71  *
72  * Once a nexus is established, the NCR5380_information_transfer()
73  * phase goes through the various phases as instructed by the target.
74  * if the target goes into MSG IN and sends a DISCONNECT message,
75  * the command structure is placed into the per instance disconnected
76  * queue, and NCR5380_main tries to find more work.  If the target is
77  * idle for too long, the system will try to sleep.
78  *
79  * If a command has disconnected, eventually an interrupt will trigger,
80  * calling NCR5380_intr()  which will in turn call NCR5380_reselect
81  * to reestablish a nexus.  This will run main if necessary.
82  *
83  * On command termination, the done function will be called as
84  * appropriate.
85  *
86  * SCSI pointers are maintained in the SCp field of SCSI command
87  * structures, being initialized after the command is connected
88  * in NCR5380_select, and set as appropriate in NCR5380_information_transfer.
89  * Note that in violation of the standard, an implicit SAVE POINTERS operation
90  * is done, since some BROKEN disks fail to issue an explicit SAVE POINTERS.
91  */
92 
93 /*
94  * Using this file :
95  * This file a skeleton Linux SCSI driver for the NCR 5380 series
96  * of chips.  To use it, you write an architecture specific functions
97  * and macros and include this file in your driver.
98  *
99  * These macros control options :
100  * AUTOPROBE_IRQ - if defined, the NCR5380_probe_irq() function will be
101  * defined.
102  *
103  * AUTOSENSE - if defined, REQUEST SENSE will be performed automatically
104  * for commands that return with a CHECK CONDITION status.
105  *
106  * DIFFERENTIAL - if defined, NCR53c81 chips will use external differential
107  * transceivers.
108  *
109  * PSEUDO_DMA - if defined, PSEUDO DMA is used during the data transfer phases.
110  *
111  * REAL_DMA - if defined, REAL DMA is used during the data transfer phases.
112  *
113  * These macros MUST be defined :
114  *
115  * NCR5380_read(register)  - read from the specified register
116  *
117  * NCR5380_write(register, value) - write to the specific register
118  *
119  * NCR5380_implementation_fields  - additional fields needed for this
120  * specific implementation of the NCR5380
121  *
122  * Either real DMA *or* pseudo DMA may be implemented
123  *
124  * NCR5380_dma_write_setup(instance, src, count) - initialize
125  * NCR5380_dma_read_setup(instance, dst, count) - initialize
126  * NCR5380_dma_residual(instance); - residual count
127  *
128  * The generic driver is initialized by calling NCR5380_init(instance),
129  * after setting the appropriate host specific fields and ID.  If the
130  * driver wishes to autoprobe for an IRQ line, the NCR5380_probe_irq(instance,
131  * possible) function may be used.
132  */
133 
134 #ifndef NCR5380_io_delay
135 #define NCR5380_io_delay(x)
136 #endif
137 
138 #ifndef NCR5380_acquire_dma_irq
139 #define NCR5380_acquire_dma_irq(x)	(1)
140 #endif
141 
142 #ifndef NCR5380_release_dma_irq
143 #define NCR5380_release_dma_irq(x)
144 #endif
145 
146 static int do_abort(struct Scsi_Host *);
147 static void do_reset(struct Scsi_Host *);
148 
149 /**
150  * initialize_SCp - init the scsi pointer field
151  * @cmd: command block to set up
152  *
153  * Set up the internal fields in the SCSI command.
154  */
155 
initialize_SCp(struct scsi_cmnd * cmd)156 static inline void initialize_SCp(struct scsi_cmnd *cmd)
157 {
158 	/*
159 	 * Initialize the Scsi Pointer field so that all of the commands in the
160 	 * various queues are valid.
161 	 */
162 
163 	if (scsi_bufflen(cmd)) {
164 		cmd->SCp.buffer = scsi_sglist(cmd);
165 		cmd->SCp.buffers_residual = scsi_sg_count(cmd) - 1;
166 		cmd->SCp.ptr = sg_virt(cmd->SCp.buffer);
167 		cmd->SCp.this_residual = cmd->SCp.buffer->length;
168 	} else {
169 		cmd->SCp.buffer = NULL;
170 		cmd->SCp.buffers_residual = 0;
171 		cmd->SCp.ptr = NULL;
172 		cmd->SCp.this_residual = 0;
173 	}
174 
175 	cmd->SCp.Status = 0;
176 	cmd->SCp.Message = 0;
177 }
178 
179 /**
180  * NCR5380_poll_politely2 - wait for two chip register values
181  * @instance: controller to poll
182  * @reg1: 5380 register to poll
183  * @bit1: Bitmask to check
184  * @val1: Expected value
185  * @reg2: Second 5380 register to poll
186  * @bit2: Second bitmask to check
187  * @val2: Second expected value
188  * @wait: Time-out in jiffies
189  *
190  * Polls the chip in a reasonably efficient manner waiting for an
191  * event to occur. After a short quick poll we begin to yield the CPU
192  * (if possible). In irq contexts the time-out is arbitrarily limited.
193  * Callers may hold locks as long as they are held in irq mode.
194  *
195  * Returns 0 if either or both event(s) occurred otherwise -ETIMEDOUT.
196  */
197 
NCR5380_poll_politely2(struct Scsi_Host * instance,int reg1,int bit1,int val1,int reg2,int bit2,int val2,int wait)198 static int NCR5380_poll_politely2(struct Scsi_Host *instance,
199                                   int reg1, int bit1, int val1,
200                                   int reg2, int bit2, int val2, int wait)
201 {
202 	struct NCR5380_hostdata *hostdata = shost_priv(instance);
203 	unsigned long deadline = jiffies + wait;
204 	unsigned long n;
205 
206 	/* Busy-wait for up to 10 ms */
207 	n = min(10000U, jiffies_to_usecs(wait));
208 	n *= hostdata->accesses_per_ms;
209 	n /= 2000;
210 	do {
211 		if ((NCR5380_read(reg1) & bit1) == val1)
212 			return 0;
213 		if ((NCR5380_read(reg2) & bit2) == val2)
214 			return 0;
215 		cpu_relax();
216 	} while (n--);
217 
218 	if (irqs_disabled() || in_interrupt())
219 		return -ETIMEDOUT;
220 
221 	/* Repeatedly sleep for 1 ms until deadline */
222 	while (time_is_after_jiffies(deadline)) {
223 		schedule_timeout_uninterruptible(1);
224 		if ((NCR5380_read(reg1) & bit1) == val1)
225 			return 0;
226 		if ((NCR5380_read(reg2) & bit2) == val2)
227 			return 0;
228 	}
229 
230 	return -ETIMEDOUT;
231 }
232 
233 #if NDEBUG
234 static struct {
235 	unsigned char mask;
236 	const char *name;
237 } signals[] = {
238 	{SR_DBP, "PARITY"},
239 	{SR_RST, "RST"},
240 	{SR_BSY, "BSY"},
241 	{SR_REQ, "REQ"},
242 	{SR_MSG, "MSG"},
243 	{SR_CD, "CD"},
244 	{SR_IO, "IO"},
245 	{SR_SEL, "SEL"},
246 	{0, NULL}
247 },
248 basrs[] = {
249 	{BASR_END_DMA_TRANSFER, "END OF DMA"},
250 	{BASR_DRQ, "DRQ"},
251 	{BASR_PARITY_ERROR, "PARITY ERROR"},
252 	{BASR_IRQ, "IRQ"},
253 	{BASR_PHASE_MATCH, "PHASE MATCH"},
254 	{BASR_BUSY_ERROR, "BUSY ERROR"},
255 	{BASR_ATN, "ATN"},
256 	{BASR_ACK, "ACK"},
257 	{0, NULL}
258 },
259 icrs[] = {
260 	{ICR_ASSERT_RST, "ASSERT RST"},
261 	{ICR_ARBITRATION_PROGRESS, "ARB. IN PROGRESS"},
262 	{ICR_ARBITRATION_LOST, "LOST ARB."},
263 	{ICR_ASSERT_ACK, "ASSERT ACK"},
264 	{ICR_ASSERT_BSY, "ASSERT BSY"},
265 	{ICR_ASSERT_SEL, "ASSERT SEL"},
266 	{ICR_ASSERT_ATN, "ASSERT ATN"},
267 	{ICR_ASSERT_DATA, "ASSERT DATA"},
268 	{0, NULL}
269 },
270 mrs[] = {
271 	{MR_BLOCK_DMA_MODE, "BLOCK DMA MODE"},
272 	{MR_TARGET, "TARGET"},
273 	{MR_ENABLE_PAR_CHECK, "PARITY CHECK"},
274 	{MR_ENABLE_PAR_INTR, "PARITY INTR"},
275 	{MR_ENABLE_EOP_INTR, "EOP INTR"},
276 	{MR_MONITOR_BSY, "MONITOR BSY"},
277 	{MR_DMA_MODE, "DMA MODE"},
278 	{MR_ARBITRATE, "ARBITRATE"},
279 	{0, NULL}
280 };
281 
282 /**
283  * NCR5380_print - print scsi bus signals
284  * @instance: adapter state to dump
285  *
286  * Print the SCSI bus signals for debugging purposes
287  */
288 
NCR5380_print(struct Scsi_Host * instance)289 static void NCR5380_print(struct Scsi_Host *instance)
290 {
291 	unsigned char status, data, basr, mr, icr, i;
292 
293 	data = NCR5380_read(CURRENT_SCSI_DATA_REG);
294 	status = NCR5380_read(STATUS_REG);
295 	mr = NCR5380_read(MODE_REG);
296 	icr = NCR5380_read(INITIATOR_COMMAND_REG);
297 	basr = NCR5380_read(BUS_AND_STATUS_REG);
298 
299 	printk(KERN_DEBUG "SR =   0x%02x : ", status);
300 	for (i = 0; signals[i].mask; ++i)
301 		if (status & signals[i].mask)
302 			printk(KERN_CONT "%s, ", signals[i].name);
303 	printk(KERN_CONT "\nBASR = 0x%02x : ", basr);
304 	for (i = 0; basrs[i].mask; ++i)
305 		if (basr & basrs[i].mask)
306 			printk(KERN_CONT "%s, ", basrs[i].name);
307 	printk(KERN_CONT "\nICR =  0x%02x : ", icr);
308 	for (i = 0; icrs[i].mask; ++i)
309 		if (icr & icrs[i].mask)
310 			printk(KERN_CONT "%s, ", icrs[i].name);
311 	printk(KERN_CONT "\nMR =   0x%02x : ", mr);
312 	for (i = 0; mrs[i].mask; ++i)
313 		if (mr & mrs[i].mask)
314 			printk(KERN_CONT "%s, ", mrs[i].name);
315 	printk(KERN_CONT "\n");
316 }
317 
318 static struct {
319 	unsigned char value;
320 	const char *name;
321 } phases[] = {
322 	{PHASE_DATAOUT, "DATAOUT"},
323 	{PHASE_DATAIN, "DATAIN"},
324 	{PHASE_CMDOUT, "CMDOUT"},
325 	{PHASE_STATIN, "STATIN"},
326 	{PHASE_MSGOUT, "MSGOUT"},
327 	{PHASE_MSGIN, "MSGIN"},
328 	{PHASE_UNKNOWN, "UNKNOWN"}
329 };
330 
331 /**
332  * NCR5380_print_phase - show SCSI phase
333  * @instance: adapter to dump
334  *
335  * Print the current SCSI phase for debugging purposes
336  */
337 
NCR5380_print_phase(struct Scsi_Host * instance)338 static void NCR5380_print_phase(struct Scsi_Host *instance)
339 {
340 	unsigned char status;
341 	int i;
342 
343 	status = NCR5380_read(STATUS_REG);
344 	if (!(status & SR_REQ))
345 		shost_printk(KERN_DEBUG, instance, "REQ not asserted, phase unknown.\n");
346 	else {
347 		for (i = 0; (phases[i].value != PHASE_UNKNOWN) &&
348 		     (phases[i].value != (status & PHASE_MASK)); ++i)
349 			;
350 		shost_printk(KERN_DEBUG, instance, "phase %s\n", phases[i].name);
351 	}
352 }
353 #endif
354 
355 
356 static int probe_irq;
357 
358 /**
359  * probe_intr	-	helper for IRQ autoprobe
360  * @irq: interrupt number
361  * @dev_id: unused
362  * @regs: unused
363  *
364  * Set a flag to indicate the IRQ in question was received. This is
365  * used by the IRQ probe code.
366  */
367 
probe_intr(int irq,void * dev_id)368 static irqreturn_t probe_intr(int irq, void *dev_id)
369 {
370 	probe_irq = irq;
371 	return IRQ_HANDLED;
372 }
373 
374 /**
375  * NCR5380_probe_irq	-	find the IRQ of an NCR5380
376  * @instance: NCR5380 controller
377  * @possible: bitmask of ISA IRQ lines
378  *
379  * Autoprobe for the IRQ line used by the NCR5380 by triggering an IRQ
380  * and then looking to see what interrupt actually turned up.
381  */
382 
NCR5380_probe_irq(struct Scsi_Host * instance,int possible)383 static int __maybe_unused NCR5380_probe_irq(struct Scsi_Host *instance,
384 						int possible)
385 {
386 	struct NCR5380_hostdata *hostdata = shost_priv(instance);
387 	unsigned long timeout;
388 	int trying_irqs, i, mask;
389 
390 	for (trying_irqs = 0, i = 1, mask = 2; i < 16; ++i, mask <<= 1)
391 		if ((mask & possible) && (request_irq(i, &probe_intr, 0, "NCR-probe", NULL) == 0))
392 			trying_irqs |= mask;
393 
394 	timeout = jiffies + msecs_to_jiffies(250);
395 	probe_irq = NO_IRQ;
396 
397 	/*
398 	 * A interrupt is triggered whenever BSY = false, SEL = true
399 	 * and a bit set in the SELECT_ENABLE_REG is asserted on the
400 	 * SCSI bus.
401 	 *
402 	 * Note that the bus is only driven when the phase control signals
403 	 * (I/O, C/D, and MSG) match those in the TCR, so we must reset that
404 	 * to zero.
405 	 */
406 
407 	NCR5380_write(TARGET_COMMAND_REG, 0);
408 	NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
409 	NCR5380_write(OUTPUT_DATA_REG, hostdata->id_mask);
410 	NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_DATA | ICR_ASSERT_SEL);
411 
412 	while (probe_irq == NO_IRQ && time_before(jiffies, timeout))
413 		schedule_timeout_uninterruptible(1);
414 
415 	NCR5380_write(SELECT_ENABLE_REG, 0);
416 	NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
417 
418 	for (i = 1, mask = 2; i < 16; ++i, mask <<= 1)
419 		if (trying_irqs & mask)
420 			free_irq(i, NULL);
421 
422 	return probe_irq;
423 }
424 
425 /**
426  * NCR58380_info - report driver and host information
427  * @instance: relevant scsi host instance
428  *
429  * For use as the host template info() handler.
430  */
431 
NCR5380_info(struct Scsi_Host * instance)432 static const char *NCR5380_info(struct Scsi_Host *instance)
433 {
434 	struct NCR5380_hostdata *hostdata = shost_priv(instance);
435 
436 	return hostdata->info;
437 }
438 
prepare_info(struct Scsi_Host * instance)439 static void prepare_info(struct Scsi_Host *instance)
440 {
441 	struct NCR5380_hostdata *hostdata = shost_priv(instance);
442 
443 	snprintf(hostdata->info, sizeof(hostdata->info),
444 	         "%s, io_port 0x%lx, n_io_port %d, "
445 	         "base 0x%lx, irq %d, "
446 	         "can_queue %d, cmd_per_lun %d, "
447 	         "sg_tablesize %d, this_id %d, "
448 	         "flags { %s%s%s}, "
449 	         "options { %s} ",
450 	         instance->hostt->name, instance->io_port, instance->n_io_port,
451 	         instance->base, instance->irq,
452 	         instance->can_queue, instance->cmd_per_lun,
453 	         instance->sg_tablesize, instance->this_id,
454 	         hostdata->flags & FLAG_DMA_FIXUP     ? "DMA_FIXUP "     : "",
455 	         hostdata->flags & FLAG_NO_PSEUDO_DMA ? "NO_PSEUDO_DMA " : "",
456 	         hostdata->flags & FLAG_TOSHIBA_DELAY ? "TOSHIBA_DELAY "  : "",
457 #ifdef DIFFERENTIAL
458 	         "DIFFERENTIAL "
459 #endif
460 #ifdef PARITY
461 	         "PARITY "
462 #endif
463 	         "");
464 }
465 
466 /**
467  * NCR5380_init - initialise an NCR5380
468  * @instance: adapter to configure
469  * @flags: control flags
470  *
471  * Initializes *instance and corresponding 5380 chip,
472  * with flags OR'd into the initial flags value.
473  *
474  * Notes : I assume that the host, hostno, and id bits have been
475  * set correctly. I don't care about the irq and other fields.
476  *
477  * Returns 0 for success
478  */
479 
NCR5380_init(struct Scsi_Host * instance,int flags)480 static int NCR5380_init(struct Scsi_Host *instance, int flags)
481 {
482 	struct NCR5380_hostdata *hostdata = shost_priv(instance);
483 	int i;
484 	unsigned long deadline;
485 
486 	instance->max_lun = 7;
487 
488 	hostdata->host = instance;
489 	hostdata->id_mask = 1 << instance->this_id;
490 	hostdata->id_higher_mask = 0;
491 	for (i = hostdata->id_mask; i <= 0x80; i <<= 1)
492 		if (i > hostdata->id_mask)
493 			hostdata->id_higher_mask |= i;
494 	for (i = 0; i < 8; ++i)
495 		hostdata->busy[i] = 0;
496 	hostdata->dma_len = 0;
497 
498 	spin_lock_init(&hostdata->lock);
499 	hostdata->connected = NULL;
500 	hostdata->sensing = NULL;
501 	INIT_LIST_HEAD(&hostdata->autosense);
502 	INIT_LIST_HEAD(&hostdata->unissued);
503 	INIT_LIST_HEAD(&hostdata->disconnected);
504 
505 	hostdata->flags = flags;
506 
507 	INIT_WORK(&hostdata->main_task, NCR5380_main);
508 	hostdata->work_q = alloc_workqueue("ncr5380_%d",
509 	                        WQ_UNBOUND | WQ_MEM_RECLAIM,
510 	                        1, instance->host_no);
511 	if (!hostdata->work_q)
512 		return -ENOMEM;
513 
514 	prepare_info(instance);
515 
516 	NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
517 	NCR5380_write(MODE_REG, MR_BASE);
518 	NCR5380_write(TARGET_COMMAND_REG, 0);
519 	NCR5380_write(SELECT_ENABLE_REG, 0);
520 
521 	/* Calibrate register polling loop */
522 	i = 0;
523 	deadline = jiffies + 1;
524 	do {
525 		cpu_relax();
526 	} while (time_is_after_jiffies(deadline));
527 	deadline += msecs_to_jiffies(256);
528 	do {
529 		NCR5380_read(STATUS_REG);
530 		++i;
531 		cpu_relax();
532 	} while (time_is_after_jiffies(deadline));
533 	hostdata->accesses_per_ms = i / 256;
534 
535 	return 0;
536 }
537 
538 /**
539  * NCR5380_maybe_reset_bus - Detect and correct bus wedge problems.
540  * @instance: adapter to check
541  *
542  * If the system crashed, it may have crashed with a connected target and
543  * the SCSI bus busy. Check for BUS FREE phase. If not, try to abort the
544  * currently established nexus, which we know nothing about. Failing that
545  * do a bus reset.
546  *
547  * Note that a bus reset will cause the chip to assert IRQ.
548  *
549  * Returns 0 if successful, otherwise -ENXIO.
550  */
551 
NCR5380_maybe_reset_bus(struct Scsi_Host * instance)552 static int NCR5380_maybe_reset_bus(struct Scsi_Host *instance)
553 {
554 	struct NCR5380_hostdata *hostdata = shost_priv(instance);
555 	int pass;
556 
557 	for (pass = 1; (NCR5380_read(STATUS_REG) & SR_BSY) && pass <= 6; ++pass) {
558 		switch (pass) {
559 		case 1:
560 		case 3:
561 		case 5:
562 			shost_printk(KERN_ERR, instance, "SCSI bus busy, waiting up to five seconds\n");
563 			NCR5380_poll_politely(instance,
564 			                      STATUS_REG, SR_BSY, 0, 5 * HZ);
565 			break;
566 		case 2:
567 			shost_printk(KERN_ERR, instance, "bus busy, attempting abort\n");
568 			do_abort(instance);
569 			break;
570 		case 4:
571 			shost_printk(KERN_ERR, instance, "bus busy, attempting reset\n");
572 			do_reset(instance);
573 			/* Wait after a reset; the SCSI standard calls for
574 			 * 250ms, we wait 500ms to be on the safe side.
575 			 * But some Toshiba CD-ROMs need ten times that.
576 			 */
577 			if (hostdata->flags & FLAG_TOSHIBA_DELAY)
578 				msleep(2500);
579 			else
580 				msleep(500);
581 			break;
582 		case 6:
583 			shost_printk(KERN_ERR, instance, "bus locked solid\n");
584 			return -ENXIO;
585 		}
586 	}
587 	return 0;
588 }
589 
590 /**
591  * NCR5380_exit - remove an NCR5380
592  * @instance: adapter to remove
593  *
594  * Assumes that no more work can be queued (e.g. by NCR5380_intr).
595  */
596 
NCR5380_exit(struct Scsi_Host * instance)597 static void NCR5380_exit(struct Scsi_Host *instance)
598 {
599 	struct NCR5380_hostdata *hostdata = shost_priv(instance);
600 
601 	cancel_work_sync(&hostdata->main_task);
602 	destroy_workqueue(hostdata->work_q);
603 }
604 
605 /**
606  * complete_cmd - finish processing a command and return it to the SCSI ML
607  * @instance: the host instance
608  * @cmd: command to complete
609  */
610 
complete_cmd(struct Scsi_Host * instance,struct scsi_cmnd * cmd)611 static void complete_cmd(struct Scsi_Host *instance,
612                          struct scsi_cmnd *cmd)
613 {
614 	struct NCR5380_hostdata *hostdata = shost_priv(instance);
615 
616 	dsprintk(NDEBUG_QUEUES, instance, "complete_cmd: cmd %p\n", cmd);
617 
618 	if (hostdata->sensing == cmd) {
619 		/* Autosense processing ends here */
620 		if ((cmd->result & 0xff) != SAM_STAT_GOOD) {
621 			scsi_eh_restore_cmnd(cmd, &hostdata->ses);
622 			set_host_byte(cmd, DID_ERROR);
623 		} else
624 			scsi_eh_restore_cmnd(cmd, &hostdata->ses);
625 		hostdata->sensing = NULL;
626 	}
627 
628 	hostdata->busy[scmd_id(cmd)] &= ~(1 << cmd->device->lun);
629 
630 	cmd->scsi_done(cmd);
631 }
632 
633 /**
634  * NCR5380_queue_command - queue a command
635  * @instance: the relevant SCSI adapter
636  * @cmd: SCSI command
637  *
638  * cmd is added to the per-instance issue queue, with minor
639  * twiddling done to the host specific fields of cmd.  If the
640  * main coroutine is not running, it is restarted.
641  */
642 
NCR5380_queue_command(struct Scsi_Host * instance,struct scsi_cmnd * cmd)643 static int NCR5380_queue_command(struct Scsi_Host *instance,
644                                  struct scsi_cmnd *cmd)
645 {
646 	struct NCR5380_hostdata *hostdata = shost_priv(instance);
647 	struct NCR5380_cmd *ncmd = scsi_cmd_priv(cmd);
648 	unsigned long flags;
649 
650 #if (NDEBUG & NDEBUG_NO_WRITE)
651 	switch (cmd->cmnd[0]) {
652 	case WRITE_6:
653 	case WRITE_10:
654 		shost_printk(KERN_DEBUG, instance, "WRITE attempted with NDEBUG_NO_WRITE set\n");
655 		cmd->result = (DID_ERROR << 16);
656 		cmd->scsi_done(cmd);
657 		return 0;
658 	}
659 #endif /* (NDEBUG & NDEBUG_NO_WRITE) */
660 
661 	cmd->result = 0;
662 
663 	if (!NCR5380_acquire_dma_irq(instance))
664 		return SCSI_MLQUEUE_HOST_BUSY;
665 
666 	spin_lock_irqsave(&hostdata->lock, flags);
667 
668 	/*
669 	 * Insert the cmd into the issue queue. Note that REQUEST SENSE
670 	 * commands are added to the head of the queue since any command will
671 	 * clear the contingent allegiance condition that exists and the
672 	 * sense data is only guaranteed to be valid while the condition exists.
673 	 */
674 
675 	if (cmd->cmnd[0] == REQUEST_SENSE)
676 		list_add(&ncmd->list, &hostdata->unissued);
677 	else
678 		list_add_tail(&ncmd->list, &hostdata->unissued);
679 
680 	spin_unlock_irqrestore(&hostdata->lock, flags);
681 
682 	dsprintk(NDEBUG_QUEUES, instance, "command %p added to %s of queue\n",
683 	         cmd, (cmd->cmnd[0] == REQUEST_SENSE) ? "head" : "tail");
684 
685 	/* Kick off command processing */
686 	queue_work(hostdata->work_q, &hostdata->main_task);
687 	return 0;
688 }
689 
maybe_release_dma_irq(struct Scsi_Host * instance)690 static inline void maybe_release_dma_irq(struct Scsi_Host *instance)
691 {
692 	struct NCR5380_hostdata *hostdata = shost_priv(instance);
693 
694 	/* Caller does the locking needed to set & test these data atomically */
695 	if (list_empty(&hostdata->disconnected) &&
696 	    list_empty(&hostdata->unissued) &&
697 	    list_empty(&hostdata->autosense) &&
698 	    !hostdata->connected &&
699 	    !hostdata->selecting)
700 		NCR5380_release_dma_irq(instance);
701 }
702 
703 /**
704  * dequeue_next_cmd - dequeue a command for processing
705  * @instance: the scsi host instance
706  *
707  * Priority is given to commands on the autosense queue. These commands
708  * need autosense because of a CHECK CONDITION result.
709  *
710  * Returns a command pointer if a command is found for a target that is
711  * not already busy. Otherwise returns NULL.
712  */
713 
dequeue_next_cmd(struct Scsi_Host * instance)714 static struct scsi_cmnd *dequeue_next_cmd(struct Scsi_Host *instance)
715 {
716 	struct NCR5380_hostdata *hostdata = shost_priv(instance);
717 	struct NCR5380_cmd *ncmd;
718 	struct scsi_cmnd *cmd;
719 
720 	if (hostdata->sensing || list_empty(&hostdata->autosense)) {
721 		list_for_each_entry(ncmd, &hostdata->unissued, list) {
722 			cmd = NCR5380_to_scmd(ncmd);
723 			dsprintk(NDEBUG_QUEUES, instance, "dequeue: cmd=%p target=%d busy=0x%02x lun=%llu\n",
724 			         cmd, scmd_id(cmd), hostdata->busy[scmd_id(cmd)], cmd->device->lun);
725 
726 			if (!(hostdata->busy[scmd_id(cmd)] & (1 << cmd->device->lun))) {
727 				list_del(&ncmd->list);
728 				dsprintk(NDEBUG_QUEUES, instance,
729 				         "dequeue: removed %p from issue queue\n", cmd);
730 				return cmd;
731 			}
732 		}
733 	} else {
734 		/* Autosense processing begins here */
735 		ncmd = list_first_entry(&hostdata->autosense,
736 		                        struct NCR5380_cmd, list);
737 		list_del(&ncmd->list);
738 		cmd = NCR5380_to_scmd(ncmd);
739 		dsprintk(NDEBUG_QUEUES, instance,
740 		         "dequeue: removed %p from autosense queue\n", cmd);
741 		scsi_eh_prep_cmnd(cmd, &hostdata->ses, NULL, 0, ~0);
742 		hostdata->sensing = cmd;
743 		return cmd;
744 	}
745 	return NULL;
746 }
747 
requeue_cmd(struct Scsi_Host * instance,struct scsi_cmnd * cmd)748 static void requeue_cmd(struct Scsi_Host *instance, struct scsi_cmnd *cmd)
749 {
750 	struct NCR5380_hostdata *hostdata = shost_priv(instance);
751 	struct NCR5380_cmd *ncmd = scsi_cmd_priv(cmd);
752 
753 	if (hostdata->sensing == cmd) {
754 		scsi_eh_restore_cmnd(cmd, &hostdata->ses);
755 		list_add(&ncmd->list, &hostdata->autosense);
756 		hostdata->sensing = NULL;
757 	} else
758 		list_add(&ncmd->list, &hostdata->unissued);
759 }
760 
761 /**
762  * NCR5380_main - NCR state machines
763  *
764  * NCR5380_main is a coroutine that runs as long as more work can
765  * be done on the NCR5380 host adapters in a system.  Both
766  * NCR5380_queue_command() and NCR5380_intr() will try to start it
767  * in case it is not running.
768  */
769 
NCR5380_main(struct work_struct * work)770 static void NCR5380_main(struct work_struct *work)
771 {
772 	struct NCR5380_hostdata *hostdata =
773 		container_of(work, struct NCR5380_hostdata, main_task);
774 	struct Scsi_Host *instance = hostdata->host;
775 	int done;
776 
777 	do {
778 		done = 1;
779 
780 		spin_lock_irq(&hostdata->lock);
781 		while (!hostdata->connected && !hostdata->selecting) {
782 			struct scsi_cmnd *cmd = dequeue_next_cmd(instance);
783 
784 			if (!cmd)
785 				break;
786 
787 			dsprintk(NDEBUG_MAIN, instance, "main: dequeued %p\n", cmd);
788 
789 			/*
790 			 * Attempt to establish an I_T_L nexus here.
791 			 * On success, instance->hostdata->connected is set.
792 			 * On failure, we must add the command back to the
793 			 * issue queue so we can keep trying.
794 			 */
795 			/*
796 			 * REQUEST SENSE commands are issued without tagged
797 			 * queueing, even on SCSI-II devices because the
798 			 * contingent allegiance condition exists for the
799 			 * entire unit.
800 			 */
801 
802 			if (!NCR5380_select(instance, cmd)) {
803 				dsprintk(NDEBUG_MAIN, instance, "main: select complete\n");
804 				maybe_release_dma_irq(instance);
805 			} else {
806 				dsprintk(NDEBUG_MAIN | NDEBUG_QUEUES, instance,
807 				         "main: select failed, returning %p to queue\n", cmd);
808 				requeue_cmd(instance, cmd);
809 			}
810 		}
811 		if (hostdata->connected && !hostdata->dma_len) {
812 			dsprintk(NDEBUG_MAIN, instance, "main: performing information transfer\n");
813 			NCR5380_information_transfer(instance);
814 			done = 0;
815 		}
816 		spin_unlock_irq(&hostdata->lock);
817 		if (!done)
818 			cond_resched();
819 	} while (!done);
820 }
821 
822 /*
823  * NCR5380_dma_complete - finish DMA transfer
824  * @instance: the scsi host instance
825  *
826  * Called by the interrupt handler when DMA finishes or a phase
827  * mismatch occurs (which would end the DMA transfer).
828  */
829 
NCR5380_dma_complete(struct Scsi_Host * instance)830 static void NCR5380_dma_complete(struct Scsi_Host *instance)
831 {
832 	struct NCR5380_hostdata *hostdata = shost_priv(instance);
833 	int transferred;
834 	unsigned char **data;
835 	int *count;
836 	int saved_data = 0, overrun = 0;
837 	unsigned char p;
838 
839 	if (hostdata->read_overruns) {
840 		p = hostdata->connected->SCp.phase;
841 		if (p & SR_IO) {
842 			udelay(10);
843 			if ((NCR5380_read(BUS_AND_STATUS_REG) &
844 			     (BASR_PHASE_MATCH | BASR_ACK)) ==
845 			    (BASR_PHASE_MATCH | BASR_ACK)) {
846 				saved_data = NCR5380_read(INPUT_DATA_REG);
847 				overrun = 1;
848 				dsprintk(NDEBUG_DMA, instance, "read overrun handled\n");
849 			}
850 		}
851 	}
852 
853 #ifdef CONFIG_SUN3
854 	if ((sun3scsi_dma_finish(rq_data_dir(hostdata->connected->request)))) {
855 		pr_err("scsi%d: overrun in UDC counter -- not prepared to deal with this!\n",
856 		       instance->host_no);
857 		BUG();
858 	}
859 
860 	if ((NCR5380_read(BUS_AND_STATUS_REG) & (BASR_PHASE_MATCH | BASR_ACK)) ==
861 	    (BASR_PHASE_MATCH | BASR_ACK)) {
862 		pr_err("scsi%d: BASR %02x\n", instance->host_no,
863 		       NCR5380_read(BUS_AND_STATUS_REG));
864 		pr_err("scsi%d: bus stuck in data phase -- probably a single byte overrun!\n",
865 		       instance->host_no);
866 		BUG();
867 	}
868 #endif
869 
870 	NCR5380_write(MODE_REG, MR_BASE);
871 	NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
872 	NCR5380_read(RESET_PARITY_INTERRUPT_REG);
873 
874 	transferred = hostdata->dma_len - NCR5380_dma_residual(instance);
875 	hostdata->dma_len = 0;
876 
877 	data = (unsigned char **)&hostdata->connected->SCp.ptr;
878 	count = &hostdata->connected->SCp.this_residual;
879 	*data += transferred;
880 	*count -= transferred;
881 
882 	if (hostdata->read_overruns) {
883 		int cnt, toPIO;
884 
885 		if ((NCR5380_read(STATUS_REG) & PHASE_MASK) == p && (p & SR_IO)) {
886 			cnt = toPIO = hostdata->read_overruns;
887 			if (overrun) {
888 				dsprintk(NDEBUG_DMA, instance,
889 				         "Got an input overrun, using saved byte\n");
890 				*(*data)++ = saved_data;
891 				(*count)--;
892 				cnt--;
893 				toPIO--;
894 			}
895 			if (toPIO > 0) {
896 				dsprintk(NDEBUG_DMA, instance,
897 				         "Doing %d byte PIO to 0x%p\n", cnt, *data);
898 				NCR5380_transfer_pio(instance, &p, &cnt, data);
899 				*count -= toPIO - cnt;
900 			}
901 		}
902 	}
903 }
904 
905 /**
906  * NCR5380_intr - generic NCR5380 irq handler
907  * @irq: interrupt number
908  * @dev_id: device info
909  *
910  * Handle interrupts, reestablishing I_T_L or I_T_L_Q nexuses
911  * from the disconnected queue, and restarting NCR5380_main()
912  * as required.
913  *
914  * The chip can assert IRQ in any of six different conditions. The IRQ flag
915  * is then cleared by reading the Reset Parity/Interrupt Register (RPIR).
916  * Three of these six conditions are latched in the Bus and Status Register:
917  * - End of DMA (cleared by ending DMA Mode)
918  * - Parity error (cleared by reading RPIR)
919  * - Loss of BSY (cleared by reading RPIR)
920  * Two conditions have flag bits that are not latched:
921  * - Bus phase mismatch (non-maskable in DMA Mode, cleared by ending DMA Mode)
922  * - Bus reset (non-maskable)
923  * The remaining condition has no flag bit at all:
924  * - Selection/reselection
925  *
926  * Hence, establishing the cause(s) of any interrupt is partly guesswork.
927  * In "The DP8490 and DP5380 Comparison Guide", National Semiconductor
928  * claimed that "the design of the [DP8490] interrupt logic ensures
929  * interrupts will not be lost (they can be on the DP5380)."
930  * The L5380/53C80 datasheet from LOGIC Devices has more details.
931  *
932  * Checking for bus reset by reading RST is futile because of interrupt
933  * latency, but a bus reset will reset chip logic. Checking for parity error
934  * is unnecessary because that interrupt is never enabled. A Loss of BSY
935  * condition will clear DMA Mode. We can tell when this occurs because the
936  * the Busy Monitor interrupt is enabled together with DMA Mode.
937  */
938 
NCR5380_intr(int irq,void * dev_id)939 static irqreturn_t __maybe_unused NCR5380_intr(int irq, void *dev_id)
940 {
941 	struct Scsi_Host *instance = dev_id;
942 	struct NCR5380_hostdata *hostdata = shost_priv(instance);
943 	int handled = 0;
944 	unsigned char basr;
945 	unsigned long flags;
946 
947 	spin_lock_irqsave(&hostdata->lock, flags);
948 
949 	basr = NCR5380_read(BUS_AND_STATUS_REG);
950 	if (basr & BASR_IRQ) {
951 		unsigned char mr = NCR5380_read(MODE_REG);
952 		unsigned char sr = NCR5380_read(STATUS_REG);
953 
954 		dsprintk(NDEBUG_INTR, instance, "IRQ %d, BASR 0x%02x, SR 0x%02x, MR 0x%02x\n",
955 		         irq, basr, sr, mr);
956 
957 		if ((mr & MR_DMA_MODE) || (mr & MR_MONITOR_BSY)) {
958 			/* Probably End of DMA, Phase Mismatch or Loss of BSY.
959 			 * We ack IRQ after clearing Mode Register. Workarounds
960 			 * for End of DMA errata need to happen in DMA Mode.
961 			 */
962 
963 			dsprintk(NDEBUG_INTR, instance, "interrupt in DMA mode\n");
964 
965 			if (hostdata->connected) {
966 				NCR5380_dma_complete(instance);
967 				queue_work(hostdata->work_q, &hostdata->main_task);
968 			} else {
969 				NCR5380_write(MODE_REG, MR_BASE);
970 				NCR5380_read(RESET_PARITY_INTERRUPT_REG);
971 			}
972 		} else if ((NCR5380_read(CURRENT_SCSI_DATA_REG) & hostdata->id_mask) &&
973 		    (sr & (SR_SEL | SR_IO | SR_BSY | SR_RST)) == (SR_SEL | SR_IO)) {
974 			/* Probably reselected */
975 			NCR5380_write(SELECT_ENABLE_REG, 0);
976 			NCR5380_read(RESET_PARITY_INTERRUPT_REG);
977 
978 			dsprintk(NDEBUG_INTR, instance, "interrupt with SEL and IO\n");
979 
980 			if (!hostdata->connected) {
981 				NCR5380_reselect(instance);
982 				queue_work(hostdata->work_q, &hostdata->main_task);
983 			}
984 			if (!hostdata->connected)
985 				NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
986 		} else {
987 			/* Probably Bus Reset */
988 			NCR5380_read(RESET_PARITY_INTERRUPT_REG);
989 
990 			dsprintk(NDEBUG_INTR, instance, "unknown interrupt\n");
991 #ifdef SUN3_SCSI_VME
992 			dregs->csr |= CSR_DMA_ENABLE;
993 #endif
994 		}
995 		handled = 1;
996 	} else {
997 		shost_printk(KERN_NOTICE, instance, "interrupt without IRQ bit\n");
998 #ifdef SUN3_SCSI_VME
999 		dregs->csr |= CSR_DMA_ENABLE;
1000 #endif
1001 	}
1002 
1003 	spin_unlock_irqrestore(&hostdata->lock, flags);
1004 
1005 	return IRQ_RETVAL(handled);
1006 }
1007 
1008 /*
1009  * Function : int NCR5380_select(struct Scsi_Host *instance,
1010  * struct scsi_cmnd *cmd)
1011  *
1012  * Purpose : establishes I_T_L or I_T_L_Q nexus for new or existing command,
1013  * including ARBITRATION, SELECTION, and initial message out for
1014  * IDENTIFY and queue messages.
1015  *
1016  * Inputs : instance - instantiation of the 5380 driver on which this
1017  * target lives, cmd - SCSI command to execute.
1018  *
1019  * Returns cmd if selection failed but should be retried,
1020  * NULL if selection failed and should not be retried, or
1021  * NULL if selection succeeded (hostdata->connected == cmd).
1022  *
1023  * Side effects :
1024  * If bus busy, arbitration failed, etc, NCR5380_select() will exit
1025  * with registers as they should have been on entry - ie
1026  * SELECT_ENABLE will be set appropriately, the NCR5380
1027  * will cease to drive any SCSI bus signals.
1028  *
1029  * If successful : I_T_L or I_T_L_Q nexus will be established,
1030  * instance->connected will be set to cmd.
1031  * SELECT interrupt will be disabled.
1032  *
1033  * If failed (no target) : cmd->scsi_done() will be called, and the
1034  * cmd->result host byte set to DID_BAD_TARGET.
1035  */
1036 
NCR5380_select(struct Scsi_Host * instance,struct scsi_cmnd * cmd)1037 static struct scsi_cmnd *NCR5380_select(struct Scsi_Host *instance,
1038                                         struct scsi_cmnd *cmd)
1039 {
1040 	struct NCR5380_hostdata *hostdata = shost_priv(instance);
1041 	unsigned char tmp[3], phase;
1042 	unsigned char *data;
1043 	int len;
1044 	int err;
1045 
1046 	NCR5380_dprint(NDEBUG_ARBITRATION, instance);
1047 	dsprintk(NDEBUG_ARBITRATION, instance, "starting arbitration, id = %d\n",
1048 	         instance->this_id);
1049 
1050 	/*
1051 	 * Arbitration and selection phases are slow and involve dropping the
1052 	 * lock, so we have to watch out for EH. An exception handler may
1053 	 * change 'selecting' to NULL. This function will then return NULL
1054 	 * so that the caller will forget about 'cmd'. (During information
1055 	 * transfer phases, EH may change 'connected' to NULL.)
1056 	 */
1057 	hostdata->selecting = cmd;
1058 
1059 	/*
1060 	 * Set the phase bits to 0, otherwise the NCR5380 won't drive the
1061 	 * data bus during SELECTION.
1062 	 */
1063 
1064 	NCR5380_write(TARGET_COMMAND_REG, 0);
1065 
1066 	/*
1067 	 * Start arbitration.
1068 	 */
1069 
1070 	NCR5380_write(OUTPUT_DATA_REG, hostdata->id_mask);
1071 	NCR5380_write(MODE_REG, MR_ARBITRATE);
1072 
1073 	/* The chip now waits for BUS FREE phase. Then after the 800 ns
1074 	 * Bus Free Delay, arbitration will begin.
1075 	 */
1076 
1077 	spin_unlock_irq(&hostdata->lock);
1078 	err = NCR5380_poll_politely2(instance, MODE_REG, MR_ARBITRATE, 0,
1079 	                INITIATOR_COMMAND_REG, ICR_ARBITRATION_PROGRESS,
1080 	                                       ICR_ARBITRATION_PROGRESS, HZ);
1081 	spin_lock_irq(&hostdata->lock);
1082 	if (!(NCR5380_read(MODE_REG) & MR_ARBITRATE)) {
1083 		/* Reselection interrupt */
1084 		goto out;
1085 	}
1086 	if (!hostdata->selecting) {
1087 		/* Command was aborted */
1088 		NCR5380_write(MODE_REG, MR_BASE);
1089 		goto out;
1090 	}
1091 	if (err < 0) {
1092 		NCR5380_write(MODE_REG, MR_BASE);
1093 		shost_printk(KERN_ERR, instance,
1094 		             "select: arbitration timeout\n");
1095 		goto out;
1096 	}
1097 	spin_unlock_irq(&hostdata->lock);
1098 
1099 	/* The SCSI-2 arbitration delay is 2.4 us */
1100 	udelay(3);
1101 
1102 	/* Check for lost arbitration */
1103 	if ((NCR5380_read(INITIATOR_COMMAND_REG) & ICR_ARBITRATION_LOST) ||
1104 	    (NCR5380_read(CURRENT_SCSI_DATA_REG) & hostdata->id_higher_mask) ||
1105 	    (NCR5380_read(INITIATOR_COMMAND_REG) & ICR_ARBITRATION_LOST)) {
1106 		NCR5380_write(MODE_REG, MR_BASE);
1107 		dsprintk(NDEBUG_ARBITRATION, instance, "lost arbitration, deasserting MR_ARBITRATE\n");
1108 		spin_lock_irq(&hostdata->lock);
1109 		goto out;
1110 	}
1111 
1112 	/* After/during arbitration, BSY should be asserted.
1113 	 * IBM DPES-31080 Version S31Q works now
1114 	 * Tnx to Thomas_Roesch@m2.maus.de for finding this! (Roman)
1115 	 */
1116 	NCR5380_write(INITIATOR_COMMAND_REG,
1117 		      ICR_BASE | ICR_ASSERT_SEL | ICR_ASSERT_BSY);
1118 
1119 	/*
1120 	 * Again, bus clear + bus settle time is 1.2us, however, this is
1121 	 * a minimum so we'll udelay ceil(1.2)
1122 	 */
1123 
1124 	if (hostdata->flags & FLAG_TOSHIBA_DELAY)
1125 		udelay(15);
1126 	else
1127 		udelay(2);
1128 
1129 	spin_lock_irq(&hostdata->lock);
1130 
1131 	/* NCR5380_reselect() clears MODE_REG after a reselection interrupt */
1132 	if (!(NCR5380_read(MODE_REG) & MR_ARBITRATE))
1133 		goto out;
1134 
1135 	if (!hostdata->selecting) {
1136 		NCR5380_write(MODE_REG, MR_BASE);
1137 		NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
1138 		goto out;
1139 	}
1140 
1141 	dsprintk(NDEBUG_ARBITRATION, instance, "won arbitration\n");
1142 
1143 	/*
1144 	 * Now that we have won arbitration, start Selection process, asserting
1145 	 * the host and target ID's on the SCSI bus.
1146 	 */
1147 
1148 	NCR5380_write(OUTPUT_DATA_REG, hostdata->id_mask | (1 << scmd_id(cmd)));
1149 
1150 	/*
1151 	 * Raise ATN while SEL is true before BSY goes false from arbitration,
1152 	 * since this is the only way to guarantee that we'll get a MESSAGE OUT
1153 	 * phase immediately after selection.
1154 	 */
1155 
1156 	NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_BSY |
1157 	              ICR_ASSERT_DATA | ICR_ASSERT_ATN | ICR_ASSERT_SEL);
1158 	NCR5380_write(MODE_REG, MR_BASE);
1159 
1160 	/*
1161 	 * Reselect interrupts must be turned off prior to the dropping of BSY,
1162 	 * otherwise we will trigger an interrupt.
1163 	 */
1164 	NCR5380_write(SELECT_ENABLE_REG, 0);
1165 
1166 	spin_unlock_irq(&hostdata->lock);
1167 
1168 	/*
1169 	 * The initiator shall then wait at least two deskew delays and release
1170 	 * the BSY signal.
1171 	 */
1172 	udelay(1);        /* wingel -- wait two bus deskew delay >2*45ns */
1173 
1174 	/* Reset BSY */
1175 	NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_DATA |
1176 	              ICR_ASSERT_ATN | ICR_ASSERT_SEL);
1177 
1178 	/*
1179 	 * Something weird happens when we cease to drive BSY - looks
1180 	 * like the board/chip is letting us do another read before the
1181 	 * appropriate propagation delay has expired, and we're confusing
1182 	 * a BSY signal from ourselves as the target's response to SELECTION.
1183 	 *
1184 	 * A small delay (the 'C++' frontend breaks the pipeline with an
1185 	 * unnecessary jump, making it work on my 386-33/Trantor T128, the
1186 	 * tighter 'C' code breaks and requires this) solves the problem -
1187 	 * the 1 us delay is arbitrary, and only used because this delay will
1188 	 * be the same on other platforms and since it works here, it should
1189 	 * work there.
1190 	 *
1191 	 * wingel suggests that this could be due to failing to wait
1192 	 * one deskew delay.
1193 	 */
1194 
1195 	udelay(1);
1196 
1197 	dsprintk(NDEBUG_SELECTION, instance, "selecting target %d\n", scmd_id(cmd));
1198 
1199 	/*
1200 	 * The SCSI specification calls for a 250 ms timeout for the actual
1201 	 * selection.
1202 	 */
1203 
1204 	err = NCR5380_poll_politely(instance, STATUS_REG, SR_BSY, SR_BSY,
1205 	                            msecs_to_jiffies(250));
1206 
1207 	if ((NCR5380_read(STATUS_REG) & (SR_SEL | SR_IO)) == (SR_SEL | SR_IO)) {
1208 		spin_lock_irq(&hostdata->lock);
1209 		NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
1210 		NCR5380_reselect(instance);
1211 		if (!hostdata->connected)
1212 			NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
1213 		shost_printk(KERN_ERR, instance, "reselection after won arbitration?\n");
1214 		goto out;
1215 	}
1216 
1217 	if (err < 0) {
1218 		spin_lock_irq(&hostdata->lock);
1219 		NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
1220 		NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
1221 		/* Can't touch cmd if it has been reclaimed by the scsi ML */
1222 		if (hostdata->selecting) {
1223 			cmd->result = DID_BAD_TARGET << 16;
1224 			complete_cmd(instance, cmd);
1225 			dsprintk(NDEBUG_SELECTION, instance, "target did not respond within 250ms\n");
1226 			cmd = NULL;
1227 		}
1228 		goto out;
1229 	}
1230 
1231 	/*
1232 	 * No less than two deskew delays after the initiator detects the
1233 	 * BSY signal is true, it shall release the SEL signal and may
1234 	 * change the DATA BUS.                                     -wingel
1235 	 */
1236 
1237 	udelay(1);
1238 
1239 	NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN);
1240 
1241 	/*
1242 	 * Since we followed the SCSI spec, and raised ATN while SEL
1243 	 * was true but before BSY was false during selection, the information
1244 	 * transfer phase should be a MESSAGE OUT phase so that we can send the
1245 	 * IDENTIFY message.
1246 	 */
1247 
1248 	/* Wait for start of REQ/ACK handshake */
1249 
1250 	err = NCR5380_poll_politely(instance, STATUS_REG, SR_REQ, SR_REQ, HZ);
1251 	spin_lock_irq(&hostdata->lock);
1252 	if (err < 0) {
1253 		shost_printk(KERN_ERR, instance, "select: REQ timeout\n");
1254 		NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
1255 		NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
1256 		goto out;
1257 	}
1258 	if (!hostdata->selecting) {
1259 		do_abort(instance);
1260 		goto out;
1261 	}
1262 
1263 	dsprintk(NDEBUG_SELECTION, instance, "target %d selected, going into MESSAGE OUT phase.\n",
1264 	         scmd_id(cmd));
1265 	tmp[0] = IDENTIFY(((instance->irq == NO_IRQ) ? 0 : 1), cmd->device->lun);
1266 
1267 	len = 1;
1268 	data = tmp;
1269 	phase = PHASE_MSGOUT;
1270 	NCR5380_transfer_pio(instance, &phase, &len, &data);
1271 	dsprintk(NDEBUG_SELECTION, instance, "nexus established.\n");
1272 	/* XXX need to handle errors here */
1273 
1274 	hostdata->connected = cmd;
1275 	hostdata->busy[cmd->device->id] |= 1 << cmd->device->lun;
1276 
1277 #ifdef SUN3_SCSI_VME
1278 	dregs->csr |= CSR_INTR;
1279 #endif
1280 
1281 	initialize_SCp(cmd);
1282 
1283 	cmd = NULL;
1284 
1285 out:
1286 	if (!hostdata->selecting)
1287 		return NULL;
1288 	hostdata->selecting = NULL;
1289 	return cmd;
1290 }
1291 
1292 /*
1293  * Function : int NCR5380_transfer_pio (struct Scsi_Host *instance,
1294  * unsigned char *phase, int *count, unsigned char **data)
1295  *
1296  * Purpose : transfers data in given phase using polled I/O
1297  *
1298  * Inputs : instance - instance of driver, *phase - pointer to
1299  * what phase is expected, *count - pointer to number of
1300  * bytes to transfer, **data - pointer to data pointer.
1301  *
1302  * Returns : -1 when different phase is entered without transferring
1303  * maximum number of bytes, 0 if all bytes are transferred or exit
1304  * is in same phase.
1305  *
1306  * Also, *phase, *count, *data are modified in place.
1307  *
1308  * XXX Note : handling for bus free may be useful.
1309  */
1310 
1311 /*
1312  * Note : this code is not as quick as it could be, however it
1313  * IS 100% reliable, and for the actual data transfer where speed
1314  * counts, we will always do a pseudo DMA or DMA transfer.
1315  */
1316 
NCR5380_transfer_pio(struct Scsi_Host * instance,unsigned char * phase,int * count,unsigned char ** data)1317 static int NCR5380_transfer_pio(struct Scsi_Host *instance,
1318 				unsigned char *phase, int *count,
1319 				unsigned char **data)
1320 {
1321 	unsigned char p = *phase, tmp;
1322 	int c = *count;
1323 	unsigned char *d = *data;
1324 
1325 	/*
1326 	 * The NCR5380 chip will only drive the SCSI bus when the
1327 	 * phase specified in the appropriate bits of the TARGET COMMAND
1328 	 * REGISTER match the STATUS REGISTER
1329 	 */
1330 
1331 	NCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(p));
1332 
1333 	do {
1334 		/*
1335 		 * Wait for assertion of REQ, after which the phase bits will be
1336 		 * valid
1337 		 */
1338 
1339 		if (NCR5380_poll_politely(instance, STATUS_REG, SR_REQ, SR_REQ, HZ) < 0)
1340 			break;
1341 
1342 		dsprintk(NDEBUG_HANDSHAKE, instance, "REQ asserted\n");
1343 
1344 		/* Check for phase mismatch */
1345 		if ((NCR5380_read(STATUS_REG) & PHASE_MASK) != p) {
1346 			dsprintk(NDEBUG_PIO, instance, "phase mismatch\n");
1347 			NCR5380_dprint_phase(NDEBUG_PIO, instance);
1348 			break;
1349 		}
1350 
1351 		/* Do actual transfer from SCSI bus to / from memory */
1352 		if (!(p & SR_IO))
1353 			NCR5380_write(OUTPUT_DATA_REG, *d);
1354 		else
1355 			*d = NCR5380_read(CURRENT_SCSI_DATA_REG);
1356 
1357 		++d;
1358 
1359 		/*
1360 		 * The SCSI standard suggests that in MSGOUT phase, the initiator
1361 		 * should drop ATN on the last byte of the message phase
1362 		 * after REQ has been asserted for the handshake but before
1363 		 * the initiator raises ACK.
1364 		 */
1365 
1366 		if (!(p & SR_IO)) {
1367 			if (!((p & SR_MSG) && c > 1)) {
1368 				NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_DATA);
1369 				NCR5380_dprint(NDEBUG_PIO, instance);
1370 				NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE |
1371 				              ICR_ASSERT_DATA | ICR_ASSERT_ACK);
1372 			} else {
1373 				NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE |
1374 				              ICR_ASSERT_DATA | ICR_ASSERT_ATN);
1375 				NCR5380_dprint(NDEBUG_PIO, instance);
1376 				NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE |
1377 				              ICR_ASSERT_DATA | ICR_ASSERT_ATN | ICR_ASSERT_ACK);
1378 			}
1379 		} else {
1380 			NCR5380_dprint(NDEBUG_PIO, instance);
1381 			NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ACK);
1382 		}
1383 
1384 		if (NCR5380_poll_politely(instance,
1385 		                          STATUS_REG, SR_REQ, 0, 5 * HZ) < 0)
1386 			break;
1387 
1388 		dsprintk(NDEBUG_HANDSHAKE, instance, "REQ negated, handshake complete\n");
1389 
1390 /*
1391  * We have several special cases to consider during REQ/ACK handshaking :
1392  * 1.  We were in MSGOUT phase, and we are on the last byte of the
1393  * message.  ATN must be dropped as ACK is dropped.
1394  *
1395  * 2.  We are in a MSGIN phase, and we are on the last byte of the
1396  * message.  We must exit with ACK asserted, so that the calling
1397  * code may raise ATN before dropping ACK to reject the message.
1398  *
1399  * 3.  ACK and ATN are clear and the target may proceed as normal.
1400  */
1401 		if (!(p == PHASE_MSGIN && c == 1)) {
1402 			if (p == PHASE_MSGOUT && c > 1)
1403 				NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN);
1404 			else
1405 				NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
1406 		}
1407 	} while (--c);
1408 
1409 	dsprintk(NDEBUG_PIO, instance, "residual %d\n", c);
1410 
1411 	*count = c;
1412 	*data = d;
1413 	tmp = NCR5380_read(STATUS_REG);
1414 	/* The phase read from the bus is valid if either REQ is (already)
1415 	 * asserted or if ACK hasn't been released yet. The latter applies if
1416 	 * we're in MSG IN, DATA IN or STATUS and all bytes have been received.
1417 	 */
1418 	if ((tmp & SR_REQ) || ((tmp & SR_IO) && c == 0))
1419 		*phase = tmp & PHASE_MASK;
1420 	else
1421 		*phase = PHASE_UNKNOWN;
1422 
1423 	if (!c || (*phase == p))
1424 		return 0;
1425 	else
1426 		return -1;
1427 }
1428 
1429 /**
1430  * do_reset - issue a reset command
1431  * @instance: adapter to reset
1432  *
1433  * Issue a reset sequence to the NCR5380 and try and get the bus
1434  * back into sane shape.
1435  *
1436  * This clears the reset interrupt flag because there may be no handler for
1437  * it. When the driver is initialized, the NCR5380_intr() handler has not yet
1438  * been installed. And when in EH we may have released the ST DMA interrupt.
1439  */
1440 
do_reset(struct Scsi_Host * instance)1441 static void do_reset(struct Scsi_Host *instance)
1442 {
1443 	unsigned long flags;
1444 
1445 	local_irq_save(flags);
1446 	NCR5380_write(TARGET_COMMAND_REG,
1447 	              PHASE_SR_TO_TCR(NCR5380_read(STATUS_REG) & PHASE_MASK));
1448 	NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_RST);
1449 	udelay(50);
1450 	NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
1451 	(void)NCR5380_read(RESET_PARITY_INTERRUPT_REG);
1452 	local_irq_restore(flags);
1453 }
1454 
1455 /**
1456  * do_abort - abort the currently established nexus by going to
1457  * MESSAGE OUT phase and sending an ABORT message.
1458  * @instance: relevant scsi host instance
1459  *
1460  * Returns 0 on success, -1 on failure.
1461  */
1462 
do_abort(struct Scsi_Host * instance)1463 static int do_abort(struct Scsi_Host *instance)
1464 {
1465 	unsigned char *msgptr, phase, tmp;
1466 	int len;
1467 	int rc;
1468 
1469 	/* Request message out phase */
1470 	NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN);
1471 
1472 	/*
1473 	 * Wait for the target to indicate a valid phase by asserting
1474 	 * REQ.  Once this happens, we'll have either a MSGOUT phase
1475 	 * and can immediately send the ABORT message, or we'll have some
1476 	 * other phase and will have to source/sink data.
1477 	 *
1478 	 * We really don't care what value was on the bus or what value
1479 	 * the target sees, so we just handshake.
1480 	 */
1481 
1482 	rc = NCR5380_poll_politely(instance, STATUS_REG, SR_REQ, SR_REQ, 10 * HZ);
1483 	if (rc < 0)
1484 		goto timeout;
1485 
1486 	tmp = NCR5380_read(STATUS_REG) & PHASE_MASK;
1487 
1488 	NCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(tmp));
1489 
1490 	if (tmp != PHASE_MSGOUT) {
1491 		NCR5380_write(INITIATOR_COMMAND_REG,
1492 		              ICR_BASE | ICR_ASSERT_ATN | ICR_ASSERT_ACK);
1493 		rc = NCR5380_poll_politely(instance, STATUS_REG, SR_REQ, 0, 3 * HZ);
1494 		if (rc < 0)
1495 			goto timeout;
1496 		NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN);
1497 	}
1498 
1499 	tmp = ABORT;
1500 	msgptr = &tmp;
1501 	len = 1;
1502 	phase = PHASE_MSGOUT;
1503 	NCR5380_transfer_pio(instance, &phase, &len, &msgptr);
1504 
1505 	/*
1506 	 * If we got here, and the command completed successfully,
1507 	 * we're about to go into bus free state.
1508 	 */
1509 
1510 	return len ? -1 : 0;
1511 
1512 timeout:
1513 	NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
1514 	return -1;
1515 }
1516 
1517 /*
1518  * Function : int NCR5380_transfer_dma (struct Scsi_Host *instance,
1519  * unsigned char *phase, int *count, unsigned char **data)
1520  *
1521  * Purpose : transfers data in given phase using either real
1522  * or pseudo DMA.
1523  *
1524  * Inputs : instance - instance of driver, *phase - pointer to
1525  * what phase is expected, *count - pointer to number of
1526  * bytes to transfer, **data - pointer to data pointer.
1527  *
1528  * Returns : -1 when different phase is entered without transferring
1529  * maximum number of bytes, 0 if all bytes or transferred or exit
1530  * is in same phase.
1531  *
1532  * Also, *phase, *count, *data are modified in place.
1533  */
1534 
1535 
NCR5380_transfer_dma(struct Scsi_Host * instance,unsigned char * phase,int * count,unsigned char ** data)1536 static int NCR5380_transfer_dma(struct Scsi_Host *instance,
1537 				unsigned char *phase, int *count,
1538 				unsigned char **data)
1539 {
1540 	struct NCR5380_hostdata *hostdata = shost_priv(instance);
1541 	int c = *count;
1542 	unsigned char p = *phase;
1543 	unsigned char *d = *data;
1544 	unsigned char tmp;
1545 	int result = 0;
1546 
1547 	if ((tmp = (NCR5380_read(STATUS_REG) & PHASE_MASK)) != p) {
1548 		*phase = tmp;
1549 		return -1;
1550 	}
1551 
1552 	hostdata->connected->SCp.phase = p;
1553 
1554 	if (p & SR_IO) {
1555 		if (hostdata->read_overruns)
1556 			c -= hostdata->read_overruns;
1557 		else if (hostdata->flags & FLAG_DMA_FIXUP)
1558 			--c;
1559 	}
1560 
1561 	dsprintk(NDEBUG_DMA, instance, "initializing DMA %s: length %d, address %p\n",
1562 	         (p & SR_IO) ? "receive" : "send", c, d);
1563 
1564 #ifdef CONFIG_SUN3
1565 	/* send start chain */
1566 	sun3scsi_dma_start(c, *data);
1567 #endif
1568 
1569 	NCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(p));
1570 	NCR5380_write(MODE_REG, MR_BASE | MR_DMA_MODE | MR_MONITOR_BSY |
1571 	                        MR_ENABLE_EOP_INTR);
1572 
1573 	if (!(hostdata->flags & FLAG_LATE_DMA_SETUP)) {
1574 		/* On the Medusa, it is a must to initialize the DMA before
1575 		 * starting the NCR. This is also the cleaner way for the TT.
1576 		 */
1577 		if (p & SR_IO)
1578 			result = NCR5380_dma_recv_setup(instance, d, c);
1579 		else
1580 			result = NCR5380_dma_send_setup(instance, d, c);
1581 	}
1582 
1583 	/*
1584 	 * On the PAS16 at least I/O recovery delays are not needed here.
1585 	 * Everyone else seems to want them.
1586 	 */
1587 
1588 	if (p & SR_IO) {
1589 		NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
1590 		NCR5380_io_delay(1);
1591 		NCR5380_write(START_DMA_INITIATOR_RECEIVE_REG, 0);
1592 	} else {
1593 		NCR5380_io_delay(1);
1594 		NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_DATA);
1595 		NCR5380_io_delay(1);
1596 		NCR5380_write(START_DMA_SEND_REG, 0);
1597 		NCR5380_io_delay(1);
1598 	}
1599 
1600 #ifdef CONFIG_SUN3
1601 #ifdef SUN3_SCSI_VME
1602 	dregs->csr |= CSR_DMA_ENABLE;
1603 #endif
1604 	sun3_dma_active = 1;
1605 #endif
1606 
1607 	if (hostdata->flags & FLAG_LATE_DMA_SETUP) {
1608 		/* On the Falcon, the DMA setup must be done after the last
1609 		 * NCR access, else the DMA setup gets trashed!
1610 		 */
1611 		if (p & SR_IO)
1612 			result = NCR5380_dma_recv_setup(instance, d, c);
1613 		else
1614 			result = NCR5380_dma_send_setup(instance, d, c);
1615 	}
1616 
1617 	/* On failure, NCR5380_dma_xxxx_setup() returns a negative int. */
1618 	if (result < 0)
1619 		return result;
1620 
1621 	/* For real DMA, result is the byte count. DMA interrupt is expected. */
1622 	if (result > 0) {
1623 		hostdata->dma_len = result;
1624 		return 0;
1625 	}
1626 
1627 	/* The result is zero iff pseudo DMA send/receive was completed. */
1628 	hostdata->dma_len = c;
1629 
1630 /*
1631  * A note regarding the DMA errata workarounds for early NMOS silicon.
1632  *
1633  * For DMA sends, we want to wait until the last byte has been
1634  * transferred out over the bus before we turn off DMA mode.  Alas, there
1635  * seems to be no terribly good way of doing this on a 5380 under all
1636  * conditions.  For non-scatter-gather operations, we can wait until REQ
1637  * and ACK both go false, or until a phase mismatch occurs.  Gather-sends
1638  * are nastier, since the device will be expecting more data than we
1639  * are prepared to send it, and REQ will remain asserted.  On a 53C8[01] we
1640  * could test Last Byte Sent to assure transfer (I imagine this is precisely
1641  * why this signal was added to the newer chips) but on the older 538[01]
1642  * this signal does not exist.  The workaround for this lack is a watchdog;
1643  * we bail out of the wait-loop after a modest amount of wait-time if
1644  * the usual exit conditions are not met.  Not a terribly clean or
1645  * correct solution :-%
1646  *
1647  * DMA receive is equally tricky due to a nasty characteristic of the NCR5380.
1648  * If the chip is in DMA receive mode, it will respond to a target's
1649  * REQ by latching the SCSI data into the INPUT DATA register and asserting
1650  * ACK, even if it has _already_ been notified by the DMA controller that
1651  * the current DMA transfer has completed!  If the NCR5380 is then taken
1652  * out of DMA mode, this already-acknowledged byte is lost. This is
1653  * not a problem for "one DMA transfer per READ command", because
1654  * the situation will never arise... either all of the data is DMA'ed
1655  * properly, or the target switches to MESSAGE IN phase to signal a
1656  * disconnection (either operation bringing the DMA to a clean halt).
1657  * However, in order to handle scatter-receive, we must work around the
1658  * problem.  The chosen fix is to DMA fewer bytes, then check for the
1659  * condition before taking the NCR5380 out of DMA mode.  One or two extra
1660  * bytes are transferred via PIO as necessary to fill out the original
1661  * request.
1662  */
1663 
1664 	if (hostdata->flags & FLAG_DMA_FIXUP) {
1665 		if (p & SR_IO) {
1666 			/*
1667 			 * The workaround was to transfer fewer bytes than we
1668 			 * intended to with the pseudo-DMA read function, wait for
1669 			 * the chip to latch the last byte, read it, and then disable
1670 			 * pseudo-DMA mode.
1671 			 *
1672 			 * After REQ is asserted, the NCR5380 asserts DRQ and ACK.
1673 			 * REQ is deasserted when ACK is asserted, and not reasserted
1674 			 * until ACK goes false.  Since the NCR5380 won't lower ACK
1675 			 * until DACK is asserted, which won't happen unless we twiddle
1676 			 * the DMA port or we take the NCR5380 out of DMA mode, we
1677 			 * can guarantee that we won't handshake another extra
1678 			 * byte.
1679 			 */
1680 
1681 			if (NCR5380_poll_politely(instance, BUS_AND_STATUS_REG,
1682 			                          BASR_DRQ, BASR_DRQ, HZ) < 0) {
1683 				result = -1;
1684 				shost_printk(KERN_ERR, instance, "PDMA read: DRQ timeout\n");
1685 			}
1686 			if (NCR5380_poll_politely(instance, STATUS_REG,
1687 			                          SR_REQ, 0, HZ) < 0) {
1688 				result = -1;
1689 				shost_printk(KERN_ERR, instance, "PDMA read: !REQ timeout\n");
1690 			}
1691 			d[*count - 1] = NCR5380_read(INPUT_DATA_REG);
1692 		} else {
1693 			/*
1694 			 * Wait for the last byte to be sent.  If REQ is being asserted for
1695 			 * the byte we're interested, we'll ACK it and it will go false.
1696 			 */
1697 			if (NCR5380_poll_politely2(instance,
1698 			     BUS_AND_STATUS_REG, BASR_DRQ, BASR_DRQ,
1699 			     BUS_AND_STATUS_REG, BASR_PHASE_MATCH, 0, HZ) < 0) {
1700 				result = -1;
1701 				shost_printk(KERN_ERR, instance, "PDMA write: DRQ and phase timeout\n");
1702 			}
1703 		}
1704 	}
1705 
1706 	NCR5380_dma_complete(instance);
1707 	return result;
1708 }
1709 
1710 /*
1711  * Function : NCR5380_information_transfer (struct Scsi_Host *instance)
1712  *
1713  * Purpose : run through the various SCSI phases and do as the target
1714  * directs us to.  Operates on the currently connected command,
1715  * instance->connected.
1716  *
1717  * Inputs : instance, instance for which we are doing commands
1718  *
1719  * Side effects : SCSI things happen, the disconnected queue will be
1720  * modified if a command disconnects, *instance->connected will
1721  * change.
1722  *
1723  * XXX Note : we need to watch for bus free or a reset condition here
1724  * to recover from an unexpected bus free condition.
1725  */
1726 
NCR5380_information_transfer(struct Scsi_Host * instance)1727 static void NCR5380_information_transfer(struct Scsi_Host *instance)
1728 {
1729 	struct NCR5380_hostdata *hostdata = shost_priv(instance);
1730 	unsigned char msgout = NOP;
1731 	int sink = 0;
1732 	int len;
1733 	int transfersize;
1734 	unsigned char *data;
1735 	unsigned char phase, tmp, extended_msg[10], old_phase = 0xff;
1736 	struct scsi_cmnd *cmd;
1737 
1738 #ifdef SUN3_SCSI_VME
1739 	dregs->csr |= CSR_INTR;
1740 #endif
1741 
1742 	while ((cmd = hostdata->connected)) {
1743 		struct NCR5380_cmd *ncmd = scsi_cmd_priv(cmd);
1744 
1745 		tmp = NCR5380_read(STATUS_REG);
1746 		/* We only have a valid SCSI phase when REQ is asserted */
1747 		if (tmp & SR_REQ) {
1748 			phase = (tmp & PHASE_MASK);
1749 			if (phase != old_phase) {
1750 				old_phase = phase;
1751 				NCR5380_dprint_phase(NDEBUG_INFORMATION, instance);
1752 			}
1753 #ifdef CONFIG_SUN3
1754 			if (phase == PHASE_CMDOUT) {
1755 				void *d;
1756 				unsigned long count;
1757 
1758 				if (!cmd->SCp.this_residual && cmd->SCp.buffers_residual) {
1759 					count = cmd->SCp.buffer->length;
1760 					d = sg_virt(cmd->SCp.buffer);
1761 				} else {
1762 					count = cmd->SCp.this_residual;
1763 					d = cmd->SCp.ptr;
1764 				}
1765 
1766 				if (sun3_dma_setup_done != cmd &&
1767 				    sun3scsi_dma_xfer_len(count, cmd) > 0) {
1768 					sun3scsi_dma_setup(instance, d, count,
1769 					                   rq_data_dir(cmd->request));
1770 					sun3_dma_setup_done = cmd;
1771 				}
1772 #ifdef SUN3_SCSI_VME
1773 				dregs->csr |= CSR_INTR;
1774 #endif
1775 			}
1776 #endif /* CONFIG_SUN3 */
1777 
1778 			if (sink && (phase != PHASE_MSGOUT)) {
1779 				NCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(tmp));
1780 
1781 				NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN |
1782 				              ICR_ASSERT_ACK);
1783 				while (NCR5380_read(STATUS_REG) & SR_REQ)
1784 					;
1785 				NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE |
1786 				              ICR_ASSERT_ATN);
1787 				sink = 0;
1788 				continue;
1789 			}
1790 
1791 			switch (phase) {
1792 			case PHASE_DATAOUT:
1793 #if (NDEBUG & NDEBUG_NO_DATAOUT)
1794 				shost_printk(KERN_DEBUG, instance, "NDEBUG_NO_DATAOUT set, attempted DATAOUT aborted\n");
1795 				sink = 1;
1796 				do_abort(instance);
1797 				cmd->result = DID_ERROR << 16;
1798 				complete_cmd(instance, cmd);
1799 				hostdata->connected = NULL;
1800 				return;
1801 #endif
1802 			case PHASE_DATAIN:
1803 				/*
1804 				 * If there is no room left in the current buffer in the
1805 				 * scatter-gather list, move onto the next one.
1806 				 */
1807 
1808 				if (!cmd->SCp.this_residual && cmd->SCp.buffers_residual) {
1809 					++cmd->SCp.buffer;
1810 					--cmd->SCp.buffers_residual;
1811 					cmd->SCp.this_residual = cmd->SCp.buffer->length;
1812 					cmd->SCp.ptr = sg_virt(cmd->SCp.buffer);
1813 					dsprintk(NDEBUG_INFORMATION, instance, "%d bytes and %d buffers left\n",
1814 					         cmd->SCp.this_residual,
1815 					         cmd->SCp.buffers_residual);
1816 				}
1817 
1818 				/*
1819 				 * The preferred transfer method is going to be
1820 				 * PSEUDO-DMA for systems that are strictly PIO,
1821 				 * since we can let the hardware do the handshaking.
1822 				 *
1823 				 * For this to work, we need to know the transfersize
1824 				 * ahead of time, since the pseudo-DMA code will sit
1825 				 * in an unconditional loop.
1826 				 */
1827 
1828 				transfersize = 0;
1829 				if (!cmd->device->borken)
1830 					transfersize = NCR5380_dma_xfer_len(instance, cmd, phase);
1831 
1832 				if (transfersize > 0) {
1833 					len = transfersize;
1834 					if (NCR5380_transfer_dma(instance, &phase,
1835 					    &len, (unsigned char **)&cmd->SCp.ptr)) {
1836 						/*
1837 						 * If the watchdog timer fires, all future
1838 						 * accesses to this device will use the
1839 						 * polled-IO.
1840 						 */
1841 						scmd_printk(KERN_INFO, cmd,
1842 							"switching to slow handshake\n");
1843 						cmd->device->borken = 1;
1844 						sink = 1;
1845 						do_abort(instance);
1846 						cmd->result = DID_ERROR << 16;
1847 						/* XXX - need to source or sink data here, as appropriate */
1848 					}
1849 				} else {
1850 					/* Transfer a small chunk so that the
1851 					 * irq mode lock is not held too long.
1852 					 */
1853 					transfersize = min(cmd->SCp.this_residual,
1854 							   NCR5380_PIO_CHUNK_SIZE);
1855 					len = transfersize;
1856 					NCR5380_transfer_pio(instance, &phase, &len,
1857 					                     (unsigned char **)&cmd->SCp.ptr);
1858 					cmd->SCp.this_residual -= transfersize - len;
1859 				}
1860 #ifdef CONFIG_SUN3
1861 				if (sun3_dma_setup_done == cmd)
1862 					sun3_dma_setup_done = NULL;
1863 #endif
1864 				return;
1865 			case PHASE_MSGIN:
1866 				len = 1;
1867 				data = &tmp;
1868 				NCR5380_transfer_pio(instance, &phase, &len, &data);
1869 				cmd->SCp.Message = tmp;
1870 
1871 				switch (tmp) {
1872 				case ABORT:
1873 				case COMMAND_COMPLETE:
1874 					/* Accept message by clearing ACK */
1875 					sink = 1;
1876 					NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
1877 					dsprintk(NDEBUG_QUEUES, instance,
1878 					         "COMMAND COMPLETE %p target %d lun %llu\n",
1879 					         cmd, scmd_id(cmd), cmd->device->lun);
1880 
1881 					hostdata->connected = NULL;
1882 
1883 					cmd->result &= ~0xffff;
1884 					cmd->result |= cmd->SCp.Status;
1885 					cmd->result |= cmd->SCp.Message << 8;
1886 
1887 					if (cmd->cmnd[0] == REQUEST_SENSE)
1888 						complete_cmd(instance, cmd);
1889 					else {
1890 						if (cmd->SCp.Status == SAM_STAT_CHECK_CONDITION ||
1891 						    cmd->SCp.Status == SAM_STAT_COMMAND_TERMINATED) {
1892 							dsprintk(NDEBUG_QUEUES, instance, "autosense: adding cmd %p to tail of autosense queue\n",
1893 							         cmd);
1894 							list_add_tail(&ncmd->list,
1895 							              &hostdata->autosense);
1896 						} else
1897 							complete_cmd(instance, cmd);
1898 					}
1899 
1900 					/*
1901 					 * Restore phase bits to 0 so an interrupted selection,
1902 					 * arbitration can resume.
1903 					 */
1904 					NCR5380_write(TARGET_COMMAND_REG, 0);
1905 
1906 					/* Enable reselect interrupts */
1907 					NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
1908 
1909 					maybe_release_dma_irq(instance);
1910 					return;
1911 				case MESSAGE_REJECT:
1912 					/* Accept message by clearing ACK */
1913 					NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
1914 					switch (hostdata->last_message) {
1915 					case HEAD_OF_QUEUE_TAG:
1916 					case ORDERED_QUEUE_TAG:
1917 					case SIMPLE_QUEUE_TAG:
1918 						cmd->device->simple_tags = 0;
1919 						hostdata->busy[cmd->device->id] |= (1 << (cmd->device->lun & 0xFF));
1920 						break;
1921 					default:
1922 						break;
1923 					}
1924 					break;
1925 				case DISCONNECT:
1926 					/* Accept message by clearing ACK */
1927 					NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
1928 					hostdata->connected = NULL;
1929 					list_add(&ncmd->list, &hostdata->disconnected);
1930 					dsprintk(NDEBUG_INFORMATION | NDEBUG_QUEUES,
1931 					         instance, "connected command %p for target %d lun %llu moved to disconnected queue\n",
1932 					         cmd, scmd_id(cmd), cmd->device->lun);
1933 
1934 					/*
1935 					 * Restore phase bits to 0 so an interrupted selection,
1936 					 * arbitration can resume.
1937 					 */
1938 					NCR5380_write(TARGET_COMMAND_REG, 0);
1939 
1940 					/* Enable reselect interrupts */
1941 					NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
1942 #ifdef SUN3_SCSI_VME
1943 					dregs->csr |= CSR_DMA_ENABLE;
1944 #endif
1945 					return;
1946 					/*
1947 					 * The SCSI data pointer is *IMPLICITLY* saved on a disconnect
1948 					 * operation, in violation of the SCSI spec so we can safely
1949 					 * ignore SAVE/RESTORE pointers calls.
1950 					 *
1951 					 * Unfortunately, some disks violate the SCSI spec and
1952 					 * don't issue the required SAVE_POINTERS message before
1953 					 * disconnecting, and we have to break spec to remain
1954 					 * compatible.
1955 					 */
1956 				case SAVE_POINTERS:
1957 				case RESTORE_POINTERS:
1958 					/* Accept message by clearing ACK */
1959 					NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
1960 					break;
1961 				case EXTENDED_MESSAGE:
1962 					/*
1963 					 * Start the message buffer with the EXTENDED_MESSAGE
1964 					 * byte, since spi_print_msg() wants the whole thing.
1965 					 */
1966 					extended_msg[0] = EXTENDED_MESSAGE;
1967 					/* Accept first byte by clearing ACK */
1968 					NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
1969 
1970 					spin_unlock_irq(&hostdata->lock);
1971 
1972 					dsprintk(NDEBUG_EXTENDED, instance, "receiving extended message\n");
1973 
1974 					len = 2;
1975 					data = extended_msg + 1;
1976 					phase = PHASE_MSGIN;
1977 					NCR5380_transfer_pio(instance, &phase, &len, &data);
1978 					dsprintk(NDEBUG_EXTENDED, instance, "length %d, code 0x%02x\n",
1979 					         (int)extended_msg[1],
1980 					         (int)extended_msg[2]);
1981 
1982 					if (!len && extended_msg[1] > 0 &&
1983 					    extended_msg[1] <= sizeof(extended_msg) - 2) {
1984 						/* Accept third byte by clearing ACK */
1985 						NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
1986 						len = extended_msg[1] - 1;
1987 						data = extended_msg + 3;
1988 						phase = PHASE_MSGIN;
1989 
1990 						NCR5380_transfer_pio(instance, &phase, &len, &data);
1991 						dsprintk(NDEBUG_EXTENDED, instance, "message received, residual %d\n",
1992 						         len);
1993 
1994 						switch (extended_msg[2]) {
1995 						case EXTENDED_SDTR:
1996 						case EXTENDED_WDTR:
1997 						case EXTENDED_MODIFY_DATA_POINTER:
1998 						case EXTENDED_EXTENDED_IDENTIFY:
1999 							tmp = 0;
2000 						}
2001 					} else if (len) {
2002 						shost_printk(KERN_ERR, instance, "error receiving extended message\n");
2003 						tmp = 0;
2004 					} else {
2005 						shost_printk(KERN_NOTICE, instance, "extended message code %02x length %d is too long\n",
2006 						             extended_msg[2], extended_msg[1]);
2007 						tmp = 0;
2008 					}
2009 
2010 					spin_lock_irq(&hostdata->lock);
2011 					if (!hostdata->connected)
2012 						return;
2013 
2014 					/* Fall through to reject message */
2015 
2016 					/*
2017 					 * If we get something weird that we aren't expecting,
2018 					 * reject it.
2019 					 */
2020 				default:
2021 					if (!tmp) {
2022 						shost_printk(KERN_ERR, instance, "rejecting message ");
2023 						spi_print_msg(extended_msg);
2024 						printk("\n");
2025 					} else if (tmp != EXTENDED_MESSAGE)
2026 						scmd_printk(KERN_INFO, cmd,
2027 						            "rejecting unknown message %02x\n",
2028 						            tmp);
2029 					else
2030 						scmd_printk(KERN_INFO, cmd,
2031 						            "rejecting unknown extended message code %02x, length %d\n",
2032 						            extended_msg[1], extended_msg[0]);
2033 
2034 					msgout = MESSAGE_REJECT;
2035 					NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN);
2036 					break;
2037 				} /* switch (tmp) */
2038 				break;
2039 			case PHASE_MSGOUT:
2040 				len = 1;
2041 				data = &msgout;
2042 				hostdata->last_message = msgout;
2043 				NCR5380_transfer_pio(instance, &phase, &len, &data);
2044 				if (msgout == ABORT) {
2045 					hostdata->connected = NULL;
2046 					cmd->result = DID_ERROR << 16;
2047 					complete_cmd(instance, cmd);
2048 					maybe_release_dma_irq(instance);
2049 					NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
2050 					return;
2051 				}
2052 				msgout = NOP;
2053 				break;
2054 			case PHASE_CMDOUT:
2055 				len = cmd->cmd_len;
2056 				data = cmd->cmnd;
2057 				/*
2058 				 * XXX for performance reasons, on machines with a
2059 				 * PSEUDO-DMA architecture we should probably
2060 				 * use the dma transfer function.
2061 				 */
2062 				NCR5380_transfer_pio(instance, &phase, &len, &data);
2063 				break;
2064 			case PHASE_STATIN:
2065 				len = 1;
2066 				data = &tmp;
2067 				NCR5380_transfer_pio(instance, &phase, &len, &data);
2068 				cmd->SCp.Status = tmp;
2069 				break;
2070 			default:
2071 				shost_printk(KERN_ERR, instance, "unknown phase\n");
2072 				NCR5380_dprint(NDEBUG_ANY, instance);
2073 			} /* switch(phase) */
2074 		} else {
2075 			spin_unlock_irq(&hostdata->lock);
2076 			NCR5380_poll_politely(instance, STATUS_REG, SR_REQ, SR_REQ, HZ);
2077 			spin_lock_irq(&hostdata->lock);
2078 		}
2079 	}
2080 }
2081 
2082 /*
2083  * Function : void NCR5380_reselect (struct Scsi_Host *instance)
2084  *
2085  * Purpose : does reselection, initializing the instance->connected
2086  * field to point to the scsi_cmnd for which the I_T_L or I_T_L_Q
2087  * nexus has been reestablished,
2088  *
2089  * Inputs : instance - this instance of the NCR5380.
2090  */
2091 
NCR5380_reselect(struct Scsi_Host * instance)2092 static void NCR5380_reselect(struct Scsi_Host *instance)
2093 {
2094 	struct NCR5380_hostdata *hostdata = shost_priv(instance);
2095 	unsigned char target_mask;
2096 	unsigned char lun;
2097 	unsigned char msg[3];
2098 	struct NCR5380_cmd *ncmd;
2099 	struct scsi_cmnd *tmp;
2100 
2101 	/*
2102 	 * Disable arbitration, etc. since the host adapter obviously
2103 	 * lost, and tell an interrupted NCR5380_select() to restart.
2104 	 */
2105 
2106 	NCR5380_write(MODE_REG, MR_BASE);
2107 
2108 	target_mask = NCR5380_read(CURRENT_SCSI_DATA_REG) & ~(hostdata->id_mask);
2109 
2110 	dsprintk(NDEBUG_RESELECTION, instance, "reselect\n");
2111 
2112 	/*
2113 	 * At this point, we have detected that our SCSI ID is on the bus,
2114 	 * SEL is true and BSY was false for at least one bus settle delay
2115 	 * (400 ns).
2116 	 *
2117 	 * We must assert BSY ourselves, until the target drops the SEL
2118 	 * signal.
2119 	 */
2120 
2121 	NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_BSY);
2122 	if (NCR5380_poll_politely(instance,
2123 	                          STATUS_REG, SR_SEL, 0, 2 * HZ) < 0) {
2124 		NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
2125 		return;
2126 	}
2127 	NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
2128 
2129 	/*
2130 	 * Wait for target to go into MSGIN.
2131 	 */
2132 
2133 	if (NCR5380_poll_politely(instance,
2134 	                          STATUS_REG, SR_REQ, SR_REQ, 2 * HZ) < 0) {
2135 		do_abort(instance);
2136 		return;
2137 	}
2138 
2139 #ifdef CONFIG_SUN3
2140 	/* acknowledge toggle to MSGIN */
2141 	NCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(PHASE_MSGIN));
2142 
2143 	/* peek at the byte without really hitting the bus */
2144 	msg[0] = NCR5380_read(CURRENT_SCSI_DATA_REG);
2145 #else
2146 	{
2147 		int len = 1;
2148 		unsigned char *data = msg;
2149 		unsigned char phase = PHASE_MSGIN;
2150 
2151 		NCR5380_transfer_pio(instance, &phase, &len, &data);
2152 
2153 		if (len) {
2154 			do_abort(instance);
2155 			return;
2156 		}
2157 	}
2158 #endif /* CONFIG_SUN3 */
2159 
2160 	if (!(msg[0] & 0x80)) {
2161 		shost_printk(KERN_ERR, instance, "expecting IDENTIFY message, got ");
2162 		spi_print_msg(msg);
2163 		printk("\n");
2164 		do_abort(instance);
2165 		return;
2166 	}
2167 	lun = msg[0] & 0x07;
2168 
2169 	/*
2170 	 * We need to add code for SCSI-II to track which devices have
2171 	 * I_T_L_Q nexuses established, and which have simple I_T_L
2172 	 * nexuses so we can chose to do additional data transfer.
2173 	 */
2174 
2175 	/*
2176 	 * Find the command corresponding to the I_T_L or I_T_L_Q  nexus we
2177 	 * just reestablished, and remove it from the disconnected queue.
2178 	 */
2179 
2180 	tmp = NULL;
2181 	list_for_each_entry(ncmd, &hostdata->disconnected, list) {
2182 		struct scsi_cmnd *cmd = NCR5380_to_scmd(ncmd);
2183 
2184 		if (target_mask == (1 << scmd_id(cmd)) &&
2185 		    lun == (u8)cmd->device->lun) {
2186 			list_del(&ncmd->list);
2187 			tmp = cmd;
2188 			break;
2189 		}
2190 	}
2191 
2192 	if (tmp) {
2193 		dsprintk(NDEBUG_RESELECTION | NDEBUG_QUEUES, instance,
2194 		         "reselect: removed %p from disconnected queue\n", tmp);
2195 	} else {
2196 		shost_printk(KERN_ERR, instance, "target bitmask 0x%02x lun %d not in disconnected queue.\n",
2197 		             target_mask, lun);
2198 		/*
2199 		 * Since we have an established nexus that we can't do anything
2200 		 * with, we must abort it.
2201 		 */
2202 		do_abort(instance);
2203 		return;
2204 	}
2205 
2206 #ifdef CONFIG_SUN3
2207 	{
2208 		void *d;
2209 		unsigned long count;
2210 
2211 		if (!tmp->SCp.this_residual && tmp->SCp.buffers_residual) {
2212 			count = tmp->SCp.buffer->length;
2213 			d = sg_virt(tmp->SCp.buffer);
2214 		} else {
2215 			count = tmp->SCp.this_residual;
2216 			d = tmp->SCp.ptr;
2217 		}
2218 
2219 		if (sun3_dma_setup_done != tmp &&
2220 		    sun3scsi_dma_xfer_len(count, tmp) > 0) {
2221 			sun3scsi_dma_setup(instance, d, count,
2222 			                   rq_data_dir(tmp->request));
2223 			sun3_dma_setup_done = tmp;
2224 		}
2225 	}
2226 
2227 	NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ACK);
2228 #endif /* CONFIG_SUN3 */
2229 
2230 	/* Accept message by clearing ACK */
2231 	NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
2232 
2233 	hostdata->connected = tmp;
2234 	dsprintk(NDEBUG_RESELECTION, instance, "nexus established, target %d, lun %llu\n",
2235 	         scmd_id(tmp), tmp->device->lun);
2236 }
2237 
2238 /**
2239  * list_find_cmd - test for presence of a command in a linked list
2240  * @haystack: list of commands
2241  * @needle: command to search for
2242  */
2243 
list_find_cmd(struct list_head * haystack,struct scsi_cmnd * needle)2244 static bool list_find_cmd(struct list_head *haystack,
2245                           struct scsi_cmnd *needle)
2246 {
2247 	struct NCR5380_cmd *ncmd;
2248 
2249 	list_for_each_entry(ncmd, haystack, list)
2250 		if (NCR5380_to_scmd(ncmd) == needle)
2251 			return true;
2252 	return false;
2253 }
2254 
2255 /**
2256  * list_remove_cmd - remove a command from linked list
2257  * @haystack: list of commands
2258  * @needle: command to remove
2259  */
2260 
list_del_cmd(struct list_head * haystack,struct scsi_cmnd * needle)2261 static bool list_del_cmd(struct list_head *haystack,
2262                          struct scsi_cmnd *needle)
2263 {
2264 	if (list_find_cmd(haystack, needle)) {
2265 		struct NCR5380_cmd *ncmd = scsi_cmd_priv(needle);
2266 
2267 		list_del(&ncmd->list);
2268 		return true;
2269 	}
2270 	return false;
2271 }
2272 
2273 /**
2274  * NCR5380_abort - scsi host eh_abort_handler() method
2275  * @cmd: the command to be aborted
2276  *
2277  * Try to abort a given command by removing it from queues and/or sending
2278  * the target an abort message. This may not succeed in causing a target
2279  * to abort the command. Nonetheless, the low-level driver must forget about
2280  * the command because the mid-layer reclaims it and it may be re-issued.
2281  *
2282  * The normal path taken by a command is as follows. For EH we trace this
2283  * same path to locate and abort the command.
2284  *
2285  * unissued -> selecting -> [unissued -> selecting ->]... connected ->
2286  * [disconnected -> connected ->]...
2287  * [autosense -> connected ->] done
2288  *
2289  * If cmd was not found at all then presumably it has already been completed,
2290  * in which case return SUCCESS to try to avoid further EH measures.
2291  *
2292  * If the command has not completed yet, we must not fail to find it.
2293  * We have no option but to forget the aborted command (even if it still
2294  * lacks sense data). The mid-layer may re-issue a command that is in error
2295  * recovery (see scsi_send_eh_cmnd), but the logic and data structures in
2296  * this driver are such that a command can appear on one queue only.
2297  *
2298  * The lock protects driver data structures, but EH handlers also use it
2299  * to serialize their own execution and prevent their own re-entry.
2300  */
2301 
NCR5380_abort(struct scsi_cmnd * cmd)2302 static int NCR5380_abort(struct scsi_cmnd *cmd)
2303 {
2304 	struct Scsi_Host *instance = cmd->device->host;
2305 	struct NCR5380_hostdata *hostdata = shost_priv(instance);
2306 	unsigned long flags;
2307 	int result = SUCCESS;
2308 
2309 	spin_lock_irqsave(&hostdata->lock, flags);
2310 
2311 #if (NDEBUG & NDEBUG_ANY)
2312 	scmd_printk(KERN_INFO, cmd, __func__);
2313 #endif
2314 	NCR5380_dprint(NDEBUG_ANY, instance);
2315 	NCR5380_dprint_phase(NDEBUG_ANY, instance);
2316 
2317 	if (list_del_cmd(&hostdata->unissued, cmd)) {
2318 		dsprintk(NDEBUG_ABORT, instance,
2319 		         "abort: removed %p from issue queue\n", cmd);
2320 		cmd->result = DID_ABORT << 16;
2321 		cmd->scsi_done(cmd); /* No tag or busy flag to worry about */
2322 		goto out;
2323 	}
2324 
2325 	if (hostdata->selecting == cmd) {
2326 		dsprintk(NDEBUG_ABORT, instance,
2327 		         "abort: cmd %p == selecting\n", cmd);
2328 		hostdata->selecting = NULL;
2329 		cmd->result = DID_ABORT << 16;
2330 		complete_cmd(instance, cmd);
2331 		goto out;
2332 	}
2333 
2334 	if (list_del_cmd(&hostdata->disconnected, cmd)) {
2335 		dsprintk(NDEBUG_ABORT, instance,
2336 		         "abort: removed %p from disconnected list\n", cmd);
2337 		/* Can't call NCR5380_select() and send ABORT because that
2338 		 * means releasing the lock. Need a bus reset.
2339 		 */
2340 		set_host_byte(cmd, DID_ERROR);
2341 		complete_cmd(instance, cmd);
2342 		result = FAILED;
2343 		goto out;
2344 	}
2345 
2346 	if (hostdata->connected == cmd) {
2347 		dsprintk(NDEBUG_ABORT, instance, "abort: cmd %p is connected\n", cmd);
2348 		hostdata->connected = NULL;
2349 		hostdata->dma_len = 0;
2350 		if (do_abort(instance)) {
2351 			set_host_byte(cmd, DID_ERROR);
2352 			complete_cmd(instance, cmd);
2353 			result = FAILED;
2354 			goto out;
2355 		}
2356 		set_host_byte(cmd, DID_ABORT);
2357 		complete_cmd(instance, cmd);
2358 		goto out;
2359 	}
2360 
2361 	if (list_del_cmd(&hostdata->autosense, cmd)) {
2362 		dsprintk(NDEBUG_ABORT, instance,
2363 		         "abort: removed %p from sense queue\n", cmd);
2364 		set_host_byte(cmd, DID_ERROR);
2365 		complete_cmd(instance, cmd);
2366 	}
2367 
2368 out:
2369 	if (result == FAILED)
2370 		dsprintk(NDEBUG_ABORT, instance, "abort: failed to abort %p\n", cmd);
2371 	else
2372 		dsprintk(NDEBUG_ABORT, instance, "abort: successfully aborted %p\n", cmd);
2373 
2374 	queue_work(hostdata->work_q, &hostdata->main_task);
2375 	maybe_release_dma_irq(instance);
2376 	spin_unlock_irqrestore(&hostdata->lock, flags);
2377 
2378 	return result;
2379 }
2380 
2381 
2382 /**
2383  * NCR5380_bus_reset - reset the SCSI bus
2384  * @cmd: SCSI command undergoing EH
2385  *
2386  * Returns SUCCESS
2387  */
2388 
NCR5380_bus_reset(struct scsi_cmnd * cmd)2389 static int NCR5380_bus_reset(struct scsi_cmnd *cmd)
2390 {
2391 	struct Scsi_Host *instance = cmd->device->host;
2392 	struct NCR5380_hostdata *hostdata = shost_priv(instance);
2393 	int i;
2394 	unsigned long flags;
2395 	struct NCR5380_cmd *ncmd;
2396 
2397 	spin_lock_irqsave(&hostdata->lock, flags);
2398 
2399 #if (NDEBUG & NDEBUG_ANY)
2400 	scmd_printk(KERN_INFO, cmd, __func__);
2401 #endif
2402 	NCR5380_dprint(NDEBUG_ANY, instance);
2403 	NCR5380_dprint_phase(NDEBUG_ANY, instance);
2404 
2405 	do_reset(instance);
2406 
2407 	/* reset NCR registers */
2408 	NCR5380_write(MODE_REG, MR_BASE);
2409 	NCR5380_write(TARGET_COMMAND_REG, 0);
2410 	NCR5380_write(SELECT_ENABLE_REG, 0);
2411 
2412 	/* After the reset, there are no more connected or disconnected commands
2413 	 * and no busy units; so clear the low-level status here to avoid
2414 	 * conflicts when the mid-level code tries to wake up the affected
2415 	 * commands!
2416 	 */
2417 
2418 	if (list_del_cmd(&hostdata->unissued, cmd)) {
2419 		cmd->result = DID_RESET << 16;
2420 		cmd->scsi_done(cmd);
2421 	}
2422 
2423 	if (hostdata->selecting) {
2424 		hostdata->selecting->result = DID_RESET << 16;
2425 		complete_cmd(instance, hostdata->selecting);
2426 		hostdata->selecting = NULL;
2427 	}
2428 
2429 	list_for_each_entry(ncmd, &hostdata->disconnected, list) {
2430 		struct scsi_cmnd *cmd = NCR5380_to_scmd(ncmd);
2431 
2432 		set_host_byte(cmd, DID_RESET);
2433 		complete_cmd(instance, cmd);
2434 	}
2435 	INIT_LIST_HEAD(&hostdata->disconnected);
2436 
2437 	list_for_each_entry(ncmd, &hostdata->autosense, list) {
2438 		struct scsi_cmnd *cmd = NCR5380_to_scmd(ncmd);
2439 
2440 		set_host_byte(cmd, DID_RESET);
2441 		cmd->scsi_done(cmd);
2442 	}
2443 	INIT_LIST_HEAD(&hostdata->autosense);
2444 
2445 	if (hostdata->connected) {
2446 		set_host_byte(hostdata->connected, DID_RESET);
2447 		complete_cmd(instance, hostdata->connected);
2448 		hostdata->connected = NULL;
2449 	}
2450 
2451 	for (i = 0; i < 8; ++i)
2452 		hostdata->busy[i] = 0;
2453 	hostdata->dma_len = 0;
2454 
2455 	queue_work(hostdata->work_q, &hostdata->main_task);
2456 	maybe_release_dma_irq(instance);
2457 	spin_unlock_irqrestore(&hostdata->lock, flags);
2458 
2459 	return SUCCESS;
2460 }
2461