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