5e71a0beafca9cb1e8857f53af68773510e771d1
[linux-3.10.git] / drivers / scsi / 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  * DISTRIBUTION RELEASE 6. 
15  *
16  * For more information, please consult 
17  *
18  * NCR 5380 Family
19  * SCSI Protocol Controller
20  * Databook
21  *
22  * NCR Microelectronics
23  * 1635 Aeroplaza Drive
24  * Colorado Springs, CO 80916
25  * 1+ (719) 578-3400
26  * 1+ (800) 334-5454
27  */
28
29 /*
30  * $Log: NCR5380.c,v $
31
32  * Revision 1.10 1998/9/2       Alan Cox
33  *                              (alan@redhat.com)
34  * Fixed up the timer lockups reported so far. Things still suck. Looking 
35  * forward to 2.3 and per device request queues. Then it'll be possible to
36  * SMP thread this beast and improve life no end.
37  
38  * Revision 1.9  1997/7/27      Ronald van Cuijlenborg
39  *                              (ronald.van.cuijlenborg@tip.nl or nutty@dds.nl)
40  * (hopefully) fixed and enhanced USLEEP
41  * added support for DTC3181E card (for Mustek scanner)
42  *
43
44  * Revision 1.8                 Ingmar Baumgart
45  *                              (ingmar@gonzo.schwaben.de)
46  * added support for NCR53C400a card
47  *
48
49  * Revision 1.7  1996/3/2       Ray Van Tassle (rayvt@comm.mot.com)
50  * added proc_info
51  * added support needed for DTC 3180/3280
52  * fixed a couple of bugs
53  *
54
55  * Revision 1.5  1994/01/19  09:14:57  drew
56  * Fixed udelay() hack that was being used on DATAOUT phases
57  * instead of a proper wait for the final handshake.
58  *
59  * Revision 1.4  1994/01/19  06:44:25  drew
60  * *** empty log message ***
61  *
62  * Revision 1.3  1994/01/19  05:24:40  drew
63  * Added support for TCR LAST_BYTE_SENT bit.
64  *
65  * Revision 1.2  1994/01/15  06:14:11  drew
66  * REAL DMA support, bug fixes.
67  *
68  * Revision 1.1  1994/01/15  06:00:54  drew
69  * Initial revision
70  *
71  */
72
73 /*
74  * Further development / testing that should be done : 
75  * 1.  Cleanup the NCR5380_transfer_dma function and DMA operation complete
76  *     code so that everything does the same thing that's done at the 
77  *     end of a pseudo-DMA read operation.
78  *
79  * 2.  Fix REAL_DMA (interrupt driven, polled works fine) -
80  *     basically, transfer size needs to be reduced by one 
81  *     and the last byte read as is done with PSEUDO_DMA.
82  * 
83  * 4.  Test SCSI-II tagged queueing (I have no devices which support 
84  *      tagged queueing)
85  *
86  * 5.  Test linked command handling code after Eric is ready with 
87  *      the high level code.
88  */
89
90 #if (NDEBUG & NDEBUG_LISTS)
91 #define LIST(x,y) {printk("LINE:%d   Adding %p to %p\n", __LINE__, (void*)(x), (void*)(y)); if ((x)==(y)) udelay(5); }
92 #define REMOVE(w,x,y,z) {printk("LINE:%d   Removing: %p->%p  %p->%p \n", __LINE__, (void*)(w), (void*)(x), (void*)(y), (void*)(z)); if ((x)==(y)) udelay(5); }
93 #else
94 #define LIST(x,y)
95 #define REMOVE(w,x,y,z)
96 #endif
97
98 #ifndef notyet
99 #undef LINKED
100 #undef REAL_DMA
101 #endif
102
103 #ifdef REAL_DMA_POLL
104 #undef READ_OVERRUNS
105 #define READ_OVERRUNS
106 #endif
107
108 #ifdef BOARD_REQUIRES_NO_DELAY
109 #define io_recovery_delay(x)
110 #else
111 #define io_recovery_delay(x)    udelay(x)
112 #endif
113
114 /*
115  * Design
116  *
117  * This is a generic 5380 driver.  To use it on a different platform, 
118  * one simply writes appropriate system specific macros (ie, data
119  * transfer - some PC's will use the I/O bus, 68K's must use 
120  * memory mapped) and drops this file in their 'C' wrapper.
121  *
122  * (Note from hch:  unfortunately it was not enough for the different
123  * m68k folks and instead of improving this driver they copied it
124  * and hacked it up for their needs.  As a consequence they lost
125  * most updates to this driver.  Maybe someone will fix all these
126  * drivers to use a common core one day..)
127  *
128  * As far as command queueing, two queues are maintained for 
129  * each 5380 in the system - commands that haven't been issued yet,
130  * and commands that are currently executing.  This means that an 
131  * unlimited number of commands may be queued, letting 
132  * more commands propagate from the higher driver levels giving higher 
133  * throughput.  Note that both I_T_L and I_T_L_Q nexuses are supported, 
134  * allowing multiple commands to propagate all the way to a SCSI-II device 
135  * while a command is already executing.
136  *
137  *
138  * Issues specific to the NCR5380 : 
139  *
140  * When used in a PIO or pseudo-dma mode, the NCR5380 is a braindead 
141  * piece of hardware that requires you to sit in a loop polling for 
142  * the REQ signal as long as you are connected.  Some devices are 
143  * brain dead (ie, many TEXEL CD ROM drives) and won't disconnect 
144  * while doing long seek operations.
145  * 
146  * The workaround for this is to keep track of devices that have
147  * disconnected.  If the device hasn't disconnected, for commands that
148  * should disconnect, we do something like 
149  *
150  * while (!REQ is asserted) { sleep for N usecs; poll for M usecs }
151  * 
152  * Some tweaking of N and M needs to be done.  An algorithm based 
153  * on "time to data" would give the best results as long as short time
154  * to datas (ie, on the same track) were considered, however these 
155  * broken devices are the exception rather than the rule and I'd rather
156  * spend my time optimizing for the normal case.
157  *
158  * Architecture :
159  *
160  * At the heart of the design is a coroutine, NCR5380_main,
161  * which is started from a workqueue for each NCR5380 host in the
162  * system.  It attempts to establish I_T_L or I_T_L_Q nexuses by
163  * removing the commands from the issue queue and calling
164  * NCR5380_select() if a nexus is not established. 
165  *
166  * Once a nexus is established, the NCR5380_information_transfer()
167  * phase goes through the various phases as instructed by the target.
168  * if the target goes into MSG IN and sends a DISCONNECT message,
169  * the command structure is placed into the per instance disconnected
170  * queue, and NCR5380_main tries to find more work.  If the target is 
171  * idle for too long, the system will try to sleep.
172  *
173  * If a command has disconnected, eventually an interrupt will trigger,
174  * calling NCR5380_intr()  which will in turn call NCR5380_reselect
175  * to reestablish a nexus.  This will run main if necessary.
176  *
177  * On command termination, the done function will be called as 
178  * appropriate.
179  *
180  * SCSI pointers are maintained in the SCp field of SCSI command 
181  * structures, being initialized after the command is connected
182  * in NCR5380_select, and set as appropriate in NCR5380_information_transfer.
183  * Note that in violation of the standard, an implicit SAVE POINTERS operation
184  * is done, since some BROKEN disks fail to issue an explicit SAVE POINTERS.
185  */
186
187 /*
188  * Using this file :
189  * This file a skeleton Linux SCSI driver for the NCR 5380 series
190  * of chips.  To use it, you write an architecture specific functions 
191  * and macros and include this file in your driver.
192  *
193  * These macros control options : 
194  * AUTOPROBE_IRQ - if defined, the NCR5380_probe_irq() function will be 
195  *      defined.
196  * 
197  * AUTOSENSE - if defined, REQUEST SENSE will be performed automatically
198  *      for commands that return with a CHECK CONDITION status. 
199  *
200  * DIFFERENTIAL - if defined, NCR53c81 chips will use external differential
201  *      transceivers. 
202  *
203  * DONT_USE_INTR - if defined, never use interrupts, even if we probe or
204  *      override-configure an IRQ.
205  *
206  * LIMIT_TRANSFERSIZE - if defined, limit the pseudo-dma transfers to 512
207  *      bytes at a time.  Since interrupts are disabled by default during
208  *      these transfers, we might need this to give reasonable interrupt
209  *      service time if the transfer size gets too large.
210  *
211  * LINKED - if defined, linked commands are supported.
212  *
213  * PSEUDO_DMA - if defined, PSEUDO DMA is used during the data transfer phases.
214  *
215  * REAL_DMA - if defined, REAL DMA is used during the data transfer phases.
216  *
217  * REAL_DMA_POLL - if defined, REAL DMA is used but the driver doesn't
218  *      rely on phase mismatch and EOP interrupts to determine end 
219  *      of phase.
220  *
221  * UNSAFE - leave interrupts enabled during pseudo-DMA transfers.  You
222  *          only really want to use this if you're having a problem with
223  *          dropped characters during high speed communications, and even
224  *          then, you're going to be better off twiddling with transfersize
225  *          in the high level code.
226  *
227  * Defaults for these will be provided although the user may want to adjust 
228  * these to allocate CPU resources to the SCSI driver or "real" code.
229  * 
230  * USLEEP_SLEEP - amount of time, in jiffies, to sleep
231  *
232  * USLEEP_POLL - amount of time, in jiffies, to poll
233  *
234  * These macros MUST be defined :
235  * NCR5380_local_declare() - declare any local variables needed for your
236  *      transfer routines.
237  *
238  * NCR5380_setup(instance) - initialize any local variables needed from a given
239  *      instance of the host adapter for NCR5380_{read,write,pread,pwrite}
240  * 
241  * NCR5380_read(register)  - read from the specified register
242  *
243  * NCR5380_write(register, value) - write to the specific register 
244  *
245  * NCR5380_implementation_fields  - additional fields needed for this 
246  *      specific implementation of the NCR5380
247  *
248  * Either real DMA *or* pseudo DMA may be implemented
249  * REAL functions : 
250  * NCR5380_REAL_DMA should be defined if real DMA is to be used.
251  * Note that the DMA setup functions should return the number of bytes 
252  *      that they were able to program the controller for.
253  *
254  * Also note that generic i386/PC versions of these macros are 
255  *      available as NCR5380_i386_dma_write_setup,
256  *      NCR5380_i386_dma_read_setup, and NCR5380_i386_dma_residual.
257  *
258  * NCR5380_dma_write_setup(instance, src, count) - initialize
259  * NCR5380_dma_read_setup(instance, dst, count) - initialize
260  * NCR5380_dma_residual(instance); - residual count
261  *
262  * PSEUDO functions :
263  * NCR5380_pwrite(instance, src, count)
264  * NCR5380_pread(instance, dst, count);
265  *
266  * The generic driver is initialized by calling NCR5380_init(instance),
267  * after setting the appropriate host specific fields and ID.  If the 
268  * driver wishes to autoprobe for an IRQ line, the NCR5380_probe_irq(instance,
269  * possible) function may be used.
270  */
271
272 static int do_abort(struct Scsi_Host *host);
273 static void do_reset(struct Scsi_Host *host);
274
275 /*
276  *      initialize_SCp          -       init the scsi pointer field
277  *      @cmd: command block to set up
278  *
279  *      Set up the internal fields in the SCSI command.
280  */
281
282 static __inline__ void initialize_SCp(Scsi_Cmnd * cmd)
283 {
284         /* 
285          * Initialize the Scsi Pointer field so that all of the commands in the 
286          * various queues are valid.
287          */
288
289         if (cmd->use_sg) {
290                 cmd->SCp.buffer = (struct scatterlist *) cmd->buffer;
291                 cmd->SCp.buffers_residual = cmd->use_sg - 1;
292                 cmd->SCp.ptr = page_address(cmd->SCp.buffer->page)+
293                                cmd->SCp.buffer->offset;
294                 cmd->SCp.this_residual = cmd->SCp.buffer->length;
295         } else {
296                 cmd->SCp.buffer = NULL;
297                 cmd->SCp.buffers_residual = 0;
298                 cmd->SCp.ptr = (char *) cmd->request_buffer;
299                 cmd->SCp.this_residual = cmd->request_bufflen;
300         }
301 }
302
303 /**
304  *      NCR5380_poll_politely   -       wait for NCR5380 status bits
305  *      @instance: controller to poll
306  *      @reg: 5380 register to poll
307  *      @bit: Bitmask to check
308  *      @val: Value required to exit
309  *
310  *      Polls the NCR5380 in a reasonably efficient manner waiting for
311  *      an event to occur, after a short quick poll we begin giving the
312  *      CPU back in non IRQ contexts
313  *
314  *      Returns the value of the register or a negative error code.
315  */
316  
317 static int NCR5380_poll_politely(struct Scsi_Host *instance, int reg, int bit, int val, int t)
318 {
319         NCR5380_local_declare();
320         int n = 500;            /* At about 8uS a cycle for the cpu access */
321         unsigned long end = jiffies + t;
322         int r;
323         
324         NCR5380_setup(instance);
325
326         while( n-- > 0)
327         {
328                 r = NCR5380_read(reg);
329                 if((r & bit) == val)
330                         return 0;
331                 cpu_relax();
332         }
333         
334         /* t time yet ? */
335         while(time_before(jiffies, end))
336         {
337                 r = NCR5380_read(reg);
338                 if((r & bit) == val)
339                         return 0;
340                 if(!in_interrupt())
341                         yield();
342                 else
343                         cpu_relax();
344         }
345         return -ETIMEDOUT;
346 }
347
348 static struct {
349         unsigned char value;
350         const char *name;
351 } phases[] = {
352         {PHASE_DATAOUT, "DATAOUT"}, 
353         {PHASE_DATAIN, "DATAIN"}, 
354         {PHASE_CMDOUT, "CMDOUT"}, 
355         {PHASE_STATIN, "STATIN"}, 
356         {PHASE_MSGOUT, "MSGOUT"}, 
357         {PHASE_MSGIN, "MSGIN"}, 
358         {PHASE_UNKNOWN, "UNKNOWN"}
359 };
360
361 #ifdef NDEBUG
362 static struct {
363         unsigned char mask;
364         const char *name;
365 } signals[] = { 
366         {SR_DBP, "PARITY"}, 
367         {SR_RST, "RST"}, 
368         {SR_BSY, "BSY"}, 
369         {SR_REQ, "REQ"}, 
370         {SR_MSG, "MSG"}, 
371         {SR_CD, "CD"}, 
372         {SR_IO, "IO"}, 
373         {SR_SEL, "SEL"}, 
374         {0, NULL}
375 }, 
376 basrs[] = {
377         {BASR_ATN, "ATN"}, 
378         {BASR_ACK, "ACK"}, 
379         {0, NULL}
380 }, 
381 icrs[] = { 
382         {ICR_ASSERT_RST, "ASSERT RST"}, 
383         {ICR_ASSERT_ACK, "ASSERT ACK"}, 
384         {ICR_ASSERT_BSY, "ASSERT BSY"}, 
385         {ICR_ASSERT_SEL, "ASSERT SEL"}, 
386         {ICR_ASSERT_ATN, "ASSERT ATN"}, 
387         {ICR_ASSERT_DATA, "ASSERT DATA"}, 
388         {0, NULL}
389 }, 
390 mrs[] = { 
391         {MR_BLOCK_DMA_MODE, "MODE BLOCK DMA"}, 
392         {MR_TARGET, "MODE TARGET"}, 
393         {MR_ENABLE_PAR_CHECK, "MODE PARITY CHECK"}, 
394         {MR_ENABLE_PAR_INTR, "MODE PARITY INTR"}, 
395         {MR_MONITOR_BSY, "MODE MONITOR BSY"}, 
396         {MR_DMA_MODE, "MODE DMA"}, 
397         {MR_ARBITRATE, "MODE ARBITRATION"}, 
398         {0, NULL}
399 };
400
401 /**
402  *      NCR5380_print   -       print scsi bus signals
403  *      @instance:      adapter state to dump
404  *
405  *      Print the SCSI bus signals for debugging purposes
406  *
407  *      Locks: caller holds hostdata lock (not essential)
408  */
409
410 static void NCR5380_print(struct Scsi_Host *instance)
411 {
412         NCR5380_local_declare();
413         unsigned char status, data, basr, mr, icr, i;
414         NCR5380_setup(instance);
415
416         data = NCR5380_read(CURRENT_SCSI_DATA_REG);
417         status = NCR5380_read(STATUS_REG);
418         mr = NCR5380_read(MODE_REG);
419         icr = NCR5380_read(INITIATOR_COMMAND_REG);
420         basr = NCR5380_read(BUS_AND_STATUS_REG);
421
422         printk("STATUS_REG: %02x ", status);
423         for (i = 0; signals[i].mask; ++i)
424                 if (status & signals[i].mask)
425                         printk(",%s", signals[i].name);
426         printk("\nBASR: %02x ", basr);
427         for (i = 0; basrs[i].mask; ++i)
428                 if (basr & basrs[i].mask)
429                         printk(",%s", basrs[i].name);
430         printk("\nICR: %02x ", icr);
431         for (i = 0; icrs[i].mask; ++i)
432                 if (icr & icrs[i].mask)
433                         printk(",%s", icrs[i].name);
434         printk("\nMODE: %02x ", mr);
435         for (i = 0; mrs[i].mask; ++i)
436                 if (mr & mrs[i].mask)
437                         printk(",%s", mrs[i].name);
438         printk("\n");
439 }
440
441
442 /* 
443  *      NCR5380_print_phase     -       show SCSI phase
444  *      @instance: adapter to dump
445  *
446  *      Print the current SCSI phase for debugging purposes
447  *
448  *      Locks: none
449  */
450
451 static void NCR5380_print_phase(struct Scsi_Host *instance)
452 {
453         NCR5380_local_declare();
454         unsigned char status;
455         int i;
456         NCR5380_setup(instance);
457
458         status = NCR5380_read(STATUS_REG);
459         if (!(status & SR_REQ))
460                 printk("scsi%d : REQ not asserted, phase unknown.\n", instance->host_no);
461         else {
462                 for (i = 0; (phases[i].value != PHASE_UNKNOWN) && (phases[i].value != (status & PHASE_MASK)); ++i);
463                 printk("scsi%d : phase %s\n", instance->host_no, phases[i].name);
464         }
465 }
466 #endif
467
468 /*
469  * These need tweaking, and would probably work best as per-device 
470  * flags initialized differently for disk, tape, cd, etc devices.
471  * People with broken devices are free to experiment as to what gives
472  * the best results for them.
473  *
474  * USLEEP_SLEEP should be a minimum seek time.
475  *
476  * USLEEP_POLL should be a maximum rotational latency.
477  */
478 #ifndef USLEEP_SLEEP
479 /* 20 ms (reasonable hard disk speed) */
480 #define USLEEP_SLEEP (20*HZ/1000)
481 #endif
482 /* 300 RPM (floppy speed) */
483 #ifndef USLEEP_POLL
484 #define USLEEP_POLL (200*HZ/1000)
485 #endif
486 #ifndef USLEEP_WAITLONG
487 /* RvC: (reasonable time to wait on select error) */
488 #define USLEEP_WAITLONG USLEEP_SLEEP
489 #endif
490
491 /* 
492  * Function : int should_disconnect (unsigned char cmd)
493  *
494  * Purpose : decide weather a command would normally disconnect or 
495  *      not, since if it won't disconnect we should go to sleep.
496  *
497  * Input : cmd - opcode of SCSI command
498  *
499  * Returns : DISCONNECT_LONG if we should disconnect for a really long 
500  *      time (ie always, sleep, look for REQ active, sleep), 
501  *      DISCONNECT_TIME_TO_DATA if we would only disconnect for a normal
502  *      time-to-data delay, DISCONNECT_NONE if this command would return
503  *      immediately.
504  *
505  *      Future sleep algorithms based on time to data can exploit 
506  *      something like this so they can differentiate between "normal" 
507  *      (ie, read, write, seek) and unusual commands (ie, * format).
508  *
509  * Note : We don't deal with commands that handle an immediate disconnect,
510  *        
511  */
512
513 static int should_disconnect(unsigned char cmd)
514 {
515         switch (cmd) {
516         case READ_6:
517         case WRITE_6:
518         case SEEK_6:
519         case READ_10:
520         case WRITE_10:
521         case SEEK_10:
522                 return DISCONNECT_TIME_TO_DATA;
523         case FORMAT_UNIT:
524         case SEARCH_HIGH:
525         case SEARCH_LOW:
526         case SEARCH_EQUAL:
527                 return DISCONNECT_LONG;
528         default:
529                 return DISCONNECT_NONE;
530         }
531 }
532
533 static void NCR5380_set_timer(struct NCR5380_hostdata *hostdata, unsigned long timeout)
534 {
535         hostdata->time_expires = jiffies + timeout;
536         schedule_delayed_work(&hostdata->coroutine, timeout);
537 }
538
539
540 static int probe_irq __initdata = 0;
541
542 /**
543  *      probe_intr      -       helper for IRQ autoprobe
544  *      @irq: interrupt number
545  *      @dev_id: unused
546  *      @regs: unused
547  *
548  *      Set a flag to indicate the IRQ in question was received. This is
549  *      used by the IRQ probe code.
550  */
551  
552 static irqreturn_t __init probe_intr(int irq, void *dev_id,
553                                         struct pt_regs *regs)
554 {
555         probe_irq = irq;
556         return IRQ_HANDLED;
557 }
558
559 /**
560  *      NCR5380_probe_irq       -       find the IRQ of an NCR5380
561  *      @instance: NCR5380 controller
562  *      @possible: bitmask of ISA IRQ lines
563  *
564  *      Autoprobe for the IRQ line used by the NCR5380 by triggering an IRQ
565  *      and then looking to see what interrupt actually turned up.
566  *
567  *      Locks: none, irqs must be enabled on entry
568  */
569
570 static int __init NCR5380_probe_irq(struct Scsi_Host *instance, int possible)
571 {
572         NCR5380_local_declare();
573         struct NCR5380_hostdata *hostdata = (struct NCR5380_hostdata *) instance->hostdata;
574         unsigned long timeout;
575         int trying_irqs, i, mask;
576         NCR5380_setup(instance);
577
578         for (trying_irqs = i = 0, mask = 1; i < 16; ++i, mask <<= 1)
579                 if ((mask & possible) && (request_irq(i, &probe_intr, SA_INTERRUPT, "NCR-probe", NULL) == 0))
580                         trying_irqs |= mask;
581
582         timeout = jiffies + (250 * HZ / 1000);
583         probe_irq = SCSI_IRQ_NONE;
584
585         /*
586          * A interrupt is triggered whenever BSY = false, SEL = true
587          * and a bit set in the SELECT_ENABLE_REG is asserted on the 
588          * SCSI bus.
589          *
590          * Note that the bus is only driven when the phase control signals
591          * (I/O, C/D, and MSG) match those in the TCR, so we must reset that
592          * to zero.
593          */
594
595         NCR5380_write(TARGET_COMMAND_REG, 0);
596         NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
597         NCR5380_write(OUTPUT_DATA_REG, hostdata->id_mask);
598         NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_DATA | ICR_ASSERT_SEL);
599
600         while (probe_irq == SCSI_IRQ_NONE && time_before(jiffies, timeout))
601         {
602                 set_current_state(TASK_UNINTERRUPTIBLE);
603                 schedule_timeout(1);
604         }
605         
606         NCR5380_write(SELECT_ENABLE_REG, 0);
607         NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
608
609         for (i = 0, mask = 1; i < 16; ++i, mask <<= 1)
610                 if (trying_irqs & mask)
611                         free_irq(i, NULL);
612
613         return probe_irq;
614 }
615
616 /**
617  *      NCR58380_print_options  -       show options
618  *      @instance: unused for now
619  *
620  *      Called by probe code indicating the NCR5380 driver options that 
621  *      were selected. At some point this will switch to runtime options
622  *      read from the adapter in question
623  *
624  *      Locks: none
625  */
626
627 static void __init NCR5380_print_options(struct Scsi_Host *instance)
628 {
629         printk(" generic options"
630 #ifdef AUTOPROBE_IRQ
631                " AUTOPROBE_IRQ"
632 #endif
633 #ifdef AUTOSENSE
634                " AUTOSENSE"
635 #endif
636 #ifdef DIFFERENTIAL
637                " DIFFERENTIAL"
638 #endif
639 #ifdef REAL_DMA
640                " REAL DMA"
641 #endif
642 #ifdef REAL_DMA_POLL
643                " REAL DMA POLL"
644 #endif
645 #ifdef PARITY
646                " PARITY"
647 #endif
648 #ifdef PSEUDO_DMA
649                " PSEUDO DMA"
650 #endif
651 #ifdef UNSAFE
652                " UNSAFE "
653 #endif
654             );
655         printk(" USLEEP, USLEEP_POLL=%d USLEEP_SLEEP=%d", USLEEP_POLL, USLEEP_SLEEP);
656         printk(" generic release=%d", NCR5380_PUBLIC_RELEASE);
657         if (((struct NCR5380_hostdata *) instance->hostdata)->flags & FLAG_NCR53C400) {
658                 printk(" ncr53c400 release=%d", NCR53C400_PUBLIC_RELEASE);
659         }
660 }
661
662 /**
663  *      NCR5380_print_status    -       dump controller info
664  *      @instance: controller to dump
665  *
666  *      Print commands in the various queues, called from NCR5380_abort 
667  *      and NCR5380_debug to aid debugging.
668  *
669  *      Locks: called functions disable irqs
670  */
671
672 static void NCR5380_print_status(struct Scsi_Host *instance)
673 {
674         NCR5380_dprint(NDEBUG_ANY, instance);
675         NCR5380_dprint_phase(NDEBUG_ANY, instance);
676 }
677
678 /******************************************/
679 /*
680  * /proc/scsi/[dtc pas16 t128 generic]/[0-ASC_NUM_BOARD_SUPPORTED]
681  *
682  * *buffer: I/O buffer
683  * **start: if inout == FALSE pointer into buffer where user read should start
684  * offset: current offset
685  * length: length of buffer
686  * hostno: Scsi_Host host_no
687  * inout: TRUE - user is writing; FALSE - user is reading
688  *
689  * Return the number of bytes read from or written
690  */
691
692 #undef SPRINTF
693 #define SPRINTF(args...) do { if(pos < buffer + length-80) pos += sprintf(pos, ## args); } while(0)
694 static
695 char *lprint_Scsi_Cmnd(Scsi_Cmnd * cmd, char *pos, char *buffer, int length);
696 static
697 char *lprint_command(unsigned char *cmd, char *pos, char *buffer, int len);
698 static
699 char *lprint_opcode(int opcode, char *pos, char *buffer, int length);
700
701 static
702 int NCR5380_proc_info(struct Scsi_Host *instance, char *buffer, char **start, off_t offset, int length, int inout)
703 {
704         char *pos = buffer;
705         struct NCR5380_hostdata *hostdata;
706         Scsi_Cmnd *ptr;
707
708         hostdata = (struct NCR5380_hostdata *) instance->hostdata;
709
710         if (inout) {            /* Has data been written to the file ? */
711 #ifdef DTC_PUBLIC_RELEASE
712                 dtc_wmaxi = dtc_maxi = 0;
713 #endif
714 #ifdef PAS16_PUBLIC_RELEASE
715                 pas_wmaxi = pas_maxi = 0;
716 #endif
717                 return (-ENOSYS);       /* Currently this is a no-op */
718         }
719         SPRINTF("NCR5380 core release=%d.   ", NCR5380_PUBLIC_RELEASE);
720         if (((struct NCR5380_hostdata *) instance->hostdata)->flags & FLAG_NCR53C400)
721                 SPRINTF("ncr53c400 release=%d.  ", NCR53C400_PUBLIC_RELEASE);
722 #ifdef DTC_PUBLIC_RELEASE
723         SPRINTF("DTC 3180/3280 release %d", DTC_PUBLIC_RELEASE);
724 #endif
725 #ifdef T128_PUBLIC_RELEASE
726         SPRINTF("T128 release %d", T128_PUBLIC_RELEASE);
727 #endif
728 #ifdef GENERIC_NCR5380_PUBLIC_RELEASE
729         SPRINTF("Generic5380 release %d", GENERIC_NCR5380_PUBLIC_RELEASE);
730 #endif
731 #ifdef PAS16_PUBLIC_RELEASE
732         SPRINTF("PAS16 release=%d", PAS16_PUBLIC_RELEASE);
733 #endif
734
735         SPRINTF("\nBase Addr: 0x%05lX    ", (long) instance->base);
736         SPRINTF("io_port: %04x      ", (int) instance->io_port);
737         if (instance->irq == SCSI_IRQ_NONE)
738                 SPRINTF("IRQ: None.\n");
739         else
740                 SPRINTF("IRQ: %d.\n", instance->irq);
741
742 #ifdef DTC_PUBLIC_RELEASE
743         SPRINTF("Highwater I/O busy_spin_counts -- write: %d  read: %d\n", dtc_wmaxi, dtc_maxi);
744 #endif
745 #ifdef PAS16_PUBLIC_RELEASE
746         SPRINTF("Highwater I/O busy_spin_counts -- write: %d  read: %d\n", pas_wmaxi, pas_maxi);
747 #endif
748         spin_lock_irq(instance->host_lock);
749         if (!hostdata->connected)
750                 SPRINTF("scsi%d: no currently connected command\n", instance->host_no);
751         else
752                 pos = lprint_Scsi_Cmnd((Scsi_Cmnd *) hostdata->connected, pos, buffer, length);
753         SPRINTF("scsi%d: issue_queue\n", instance->host_no);
754         for (ptr = (Scsi_Cmnd *) hostdata->issue_queue; ptr; ptr = (Scsi_Cmnd *) ptr->host_scribble)
755                 pos = lprint_Scsi_Cmnd(ptr, pos, buffer, length);
756
757         SPRINTF("scsi%d: disconnected_queue\n", instance->host_no);
758         for (ptr = (Scsi_Cmnd *) hostdata->disconnected_queue; ptr; ptr = (Scsi_Cmnd *) ptr->host_scribble)
759                 pos = lprint_Scsi_Cmnd(ptr, pos, buffer, length);
760         spin_unlock_irq(instance->host_lock);
761         
762         *start = buffer;
763         if (pos - buffer < offset)
764                 return 0;
765         else if (pos - buffer - offset < length)
766                 return pos - buffer - offset;
767         return length;
768 }
769
770 static char *lprint_Scsi_Cmnd(Scsi_Cmnd * cmd, char *pos, char *buffer, int length)
771 {
772         SPRINTF("scsi%d : destination target %d, lun %d\n", cmd->device->host->host_no, cmd->device->id, cmd->device->lun);
773         SPRINTF("        command = ");
774         pos = lprint_command(cmd->cmnd, pos, buffer, length);
775         return (pos);
776 }
777
778 static char *lprint_command(unsigned char *command, char *pos, char *buffer, int length)
779 {
780         int i, s;
781         pos = lprint_opcode(command[0], pos, buffer, length);
782         for (i = 1, s = COMMAND_SIZE(command[0]); i < s; ++i)
783                 SPRINTF("%02x ", command[i]);
784         SPRINTF("\n");
785         return (pos);
786 }
787
788 static char *lprint_opcode(int opcode, char *pos, char *buffer, int length)
789 {
790         SPRINTF("%2d (0x%02x)", opcode, opcode);
791         return (pos);
792 }
793
794
795 /**
796  *      NCR5380_init    -       initialise an NCR5380
797  *      @instance: adapter to configure
798  *      @flags: control flags
799  *
800  *      Initializes *instance and corresponding 5380 chip,
801  *      with flags OR'd into the initial flags value.
802  *
803  *      Notes : I assume that the host, hostno, and id bits have been
804  *      set correctly.  I don't care about the irq and other fields. 
805  *
806  *      Returns 0 for success
807  *
808  *      Locks: interrupts must be enabled when we are called 
809  */
810
811 static int __devinit NCR5380_init(struct Scsi_Host *instance, int flags)
812 {
813         NCR5380_local_declare();
814         int i, pass;
815         unsigned long timeout;
816         struct NCR5380_hostdata *hostdata = (struct NCR5380_hostdata *) instance->hostdata;
817
818         if(in_interrupt())
819                 printk(KERN_ERR "NCR5380_init called with interrupts off!\n");
820         /* 
821          * On NCR53C400 boards, NCR5380 registers are mapped 8 past 
822          * the base address.
823          */
824
825 #ifdef NCR53C400
826         if (flags & FLAG_NCR53C400)
827                 instance->NCR5380_instance_name += NCR53C400_address_adjust;
828 #endif
829
830         NCR5380_setup(instance);
831
832         hostdata->aborted = 0;
833         hostdata->id_mask = 1 << instance->this_id;
834         for (i = hostdata->id_mask; i <= 0x80; i <<= 1)
835                 if (i > hostdata->id_mask)
836                         hostdata->id_higher_mask |= i;
837         for (i = 0; i < 8; ++i)
838                 hostdata->busy[i] = 0;
839 #ifdef REAL_DMA
840         hostdata->dmalen = 0;
841 #endif
842         hostdata->targets_present = 0;
843         hostdata->connected = NULL;
844         hostdata->issue_queue = NULL;
845         hostdata->disconnected_queue = NULL;
846         
847         INIT_WORK(&hostdata->coroutine, NCR5380_main, hostdata);
848         
849 #ifdef NCR5380_STATS
850         for (i = 0; i < 8; ++i) {
851                 hostdata->time_read[i] = 0;
852                 hostdata->time_write[i] = 0;
853                 hostdata->bytes_read[i] = 0;
854                 hostdata->bytes_write[i] = 0;
855         }
856         hostdata->timebase = 0;
857         hostdata->pendingw = 0;
858         hostdata->pendingr = 0;
859 #endif
860
861         /* The CHECK code seems to break the 53C400. Will check it later maybe */
862         if (flags & FLAG_NCR53C400)
863                 hostdata->flags = FLAG_HAS_LAST_BYTE_SENT | flags;
864         else
865                 hostdata->flags = FLAG_CHECK_LAST_BYTE_SENT | flags;
866
867         hostdata->host = instance;
868         hostdata->time_expires = 0;
869
870 #ifndef AUTOSENSE
871         if ((instance->cmd_per_lun > 1) || instance->can_queue > 1)
872                     printk(KERN_WARNING "scsi%d : WARNING : support for multiple outstanding commands enabled\n" "         without AUTOSENSE option, contingent allegiance conditions may\n"
873                            "         be incorrectly cleared.\n", instance->host_no);
874 #endif                          /* def AUTOSENSE */
875
876         NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
877         NCR5380_write(MODE_REG, MR_BASE);
878         NCR5380_write(TARGET_COMMAND_REG, 0);
879         NCR5380_write(SELECT_ENABLE_REG, 0);
880
881 #ifdef NCR53C400
882         if (hostdata->flags & FLAG_NCR53C400) {
883                 NCR5380_write(C400_CONTROL_STATUS_REG, CSR_BASE);
884         }
885 #endif
886
887         /* 
888          * Detect and correct bus wedge problems.
889          *
890          * If the system crashed, it may have crashed in a state 
891          * where a SCSI command was still executing, and the 
892          * SCSI bus is not in a BUS FREE STATE.
893          *
894          * If this is the case, we'll try to abort the currently
895          * established nexus which we know nothing about, and that
896          * failing, do a hard reset of the SCSI bus 
897          */
898
899         for (pass = 1; (NCR5380_read(STATUS_REG) & SR_BSY) && pass <= 6; ++pass) {
900                 switch (pass) {
901                 case 1:
902                 case 3:
903                 case 5:
904                         printk(KERN_INFO "scsi%d: SCSI bus busy, waiting up to five seconds\n", instance->host_no);
905                         timeout = jiffies + 5 * HZ;
906                         NCR5380_poll_politely(instance, STATUS_REG, SR_BSY, 0, 5*HZ);
907                         break;
908                 case 2:
909                         printk(KERN_WARNING "scsi%d: bus busy, attempting abort\n", instance->host_no);
910                         do_abort(instance);
911                         break;
912                 case 4:
913                         printk(KERN_WARNING "scsi%d: bus busy, attempting reset\n", instance->host_no);
914                         do_reset(instance);
915                         break;
916                 case 6:
917                         printk(KERN_ERR "scsi%d: bus locked solid or invalid override\n", instance->host_no);
918                         return -ENXIO;
919                 }
920         }
921         return 0;
922 }
923
924 /**
925  *      NCR5380_exit    -       remove an NCR5380
926  *      @instance: adapter to remove
927  */
928
929 static void __devexit NCR5380_exit(struct Scsi_Host *instance)
930 {
931         struct NCR5380_hostdata *hostdata = (struct NCR5380_hostdata *) instance->hostdata;
932
933         cancel_delayed_work(&hostdata->coroutine);
934         flush_scheduled_work();
935 }
936
937 /**
938  *      NCR5380_queue_command           -       queue a command
939  *      @cmd: SCSI command
940  *      @done: completion handler
941  *
942  *      cmd is added to the per instance issue_queue, with minor 
943  *      twiddling done to the host specific fields of cmd.  If the 
944  *      main coroutine is not running, it is restarted.
945  *
946  *      Locks: host lock taken by caller
947  */
948
949 static int NCR5380_queue_command(Scsi_Cmnd * cmd, void (*done) (Scsi_Cmnd *)) 
950 {
951         struct Scsi_Host *instance = cmd->device->host;
952         struct NCR5380_hostdata *hostdata = (struct NCR5380_hostdata *) instance->hostdata;
953         Scsi_Cmnd *tmp;
954
955 #if (NDEBUG & NDEBUG_NO_WRITE)
956         switch (cmd->cmnd[0]) {
957         case WRITE_6:
958         case WRITE_10:
959                 printk("scsi%d : WRITE attempted with NO_WRITE debugging flag set\n", instance->host_no);
960                 cmd->result = (DID_ERROR << 16);
961                 done(cmd);
962                 return 0;
963         }
964 #endif                          /* (NDEBUG & NDEBUG_NO_WRITE) */
965
966 #ifdef NCR5380_STATS
967         switch (cmd->cmnd[0]) {
968                 case WRITE:
969                 case WRITE_6:
970                 case WRITE_10:
971                         hostdata->time_write[cmd->device->id] -= (jiffies - hostdata->timebase);
972                         hostdata->bytes_write[cmd->device->id] += cmd->request_bufflen;
973                         hostdata->pendingw++;
974                         break;
975                 case READ:
976                 case READ_6:
977                 case READ_10:
978                         hostdata->time_read[cmd->device->id] -= (jiffies - hostdata->timebase);
979                         hostdata->bytes_read[cmd->device->id] += cmd->request_bufflen;
980                         hostdata->pendingr++;
981                         break;
982         }
983 #endif
984
985         /* 
986          * We use the host_scribble field as a pointer to the next command  
987          * in a queue 
988          */
989
990         cmd->host_scribble = NULL;
991         cmd->scsi_done = done;
992         cmd->result = 0;
993
994         /* 
995          * Insert the cmd into the issue queue. Note that REQUEST SENSE 
996          * commands are added to the head of the queue since any command will
997          * clear the contingent allegiance condition that exists and the 
998          * sense data is only guaranteed to be valid while the condition exists.
999          */
1000
1001         if (!(hostdata->issue_queue) || (cmd->cmnd[0] == REQUEST_SENSE)) {
1002                 LIST(cmd, hostdata->issue_queue);
1003                 cmd->host_scribble = (unsigned char *) hostdata->issue_queue;
1004                 hostdata->issue_queue = cmd;
1005         } else {
1006                 for (tmp = (Scsi_Cmnd *) hostdata->issue_queue; tmp->host_scribble; tmp = (Scsi_Cmnd *) tmp->host_scribble);
1007                 LIST(cmd, tmp);
1008                 tmp->host_scribble = (unsigned char *) cmd;
1009         }
1010         dprintk(NDEBUG_QUEUES, ("scsi%d : command added to %s of queue\n", instance->host_no, (cmd->cmnd[0] == REQUEST_SENSE) ? "head" : "tail"));
1011
1012         /* Run the coroutine if it isn't already running. */
1013         /* Kick off command processing */
1014         schedule_work(&hostdata->coroutine);
1015         return 0;
1016 }
1017
1018
1019 /**
1020  *      NCR5380_main    -       NCR state machines
1021  *
1022  *      NCR5380_main is a coroutine that runs as long as more work can 
1023  *      be done on the NCR5380 host adapters in a system.  Both 
1024  *      NCR5380_queue_command() and NCR5380_intr() will try to start it 
1025  *      in case it is not running.
1026  * 
1027  *      Locks: called as its own thread with no locks held. Takes the
1028  *      host lock and called routines may take the isa dma lock.
1029  */
1030
1031 static void NCR5380_main(void *p)
1032 {
1033         struct NCR5380_hostdata *hostdata = p;
1034         struct Scsi_Host *instance = hostdata->host;
1035         Scsi_Cmnd *tmp, *prev;
1036         int done;
1037         
1038         spin_lock_irq(instance->host_lock);
1039         do {
1040                 /* Lock held here */
1041                 done = 1;
1042                 if (!hostdata->connected && !hostdata->selecting) {
1043                         dprintk(NDEBUG_MAIN, ("scsi%d : not connected\n", instance->host_no));
1044                         /*
1045                          * Search through the issue_queue for a command destined
1046                          * for a target that's not busy.
1047                          */
1048                         for (tmp = (Scsi_Cmnd *) hostdata->issue_queue, prev = NULL; tmp; prev = tmp, tmp = (Scsi_Cmnd *) tmp->host_scribble) 
1049                         {
1050                                 if (prev != tmp)
1051                                         dprintk(NDEBUG_LISTS, ("MAIN tmp=%p   target=%d   busy=%d lun=%d\n", tmp, tmp->target, hostdata->busy[tmp->target], tmp->lun));
1052                                 /*  When we find one, remove it from the issue queue. */
1053                                 if (!(hostdata->busy[tmp->device->id] & (1 << tmp->device->lun))) {
1054                                         if (prev) {
1055                                                 REMOVE(prev, prev->host_scribble, tmp, tmp->host_scribble);
1056                                                 prev->host_scribble = tmp->host_scribble;
1057                                         } else {
1058                                                 REMOVE(-1, hostdata->issue_queue, tmp, tmp->host_scribble);
1059                                                 hostdata->issue_queue = (Scsi_Cmnd *) tmp->host_scribble;
1060                                         }
1061                                         tmp->host_scribble = NULL;
1062
1063                                         /* 
1064                                          * Attempt to establish an I_T_L nexus here. 
1065                                          * On success, instance->hostdata->connected is set.
1066                                          * On failure, we must add the command back to the
1067                                          *   issue queue so we can keep trying. 
1068                                          */
1069                                         dprintk(NDEBUG_MAIN|NDEBUG_QUEUES, ("scsi%d : main() : command for target %d lun %d removed from issue_queue\n", instance->host_no, tmp->target, tmp->lun));
1070         
1071                                         /*
1072                                          * A successful selection is defined as one that 
1073                                          * leaves us with the command connected and 
1074                                          * in hostdata->connected, OR has terminated the
1075                                          * command.
1076                                          *
1077                                          * With successful commands, we fall through
1078                                          * and see if we can do an information transfer,
1079                                          * with failures we will restart.
1080                                          */
1081                                         hostdata->selecting = NULL;
1082                                         /* RvC: have to preset this to indicate a new command is being performed */
1083
1084                                         if (!NCR5380_select(instance, tmp,
1085                                                             /* 
1086                                                              * REQUEST SENSE commands are issued without tagged
1087                                                              * queueing, even on SCSI-II devices because the 
1088                                                              * contingent allegiance condition exists for the 
1089                                                              * entire unit.
1090                                                              */
1091                                                             (tmp->cmnd[0] == REQUEST_SENSE) ? TAG_NONE : TAG_NEXT)) {
1092                                                 break;
1093                                         } else {
1094                                                 LIST(tmp, hostdata->issue_queue);
1095                                                 tmp->host_scribble = (unsigned char *) hostdata->issue_queue;
1096                                                 hostdata->issue_queue = tmp;
1097                                                 done = 0;
1098                                                 dprintk(NDEBUG_MAIN|NDEBUG_QUEUES, ("scsi%d : main(): select() failed, returned to issue_queue\n", instance->host_no));
1099                                         }
1100                                         /* lock held here still */
1101                                 }       /* if target/lun is not busy */
1102                         }       /* for */
1103                         /* exited locked */
1104                 }       /* if (!hostdata->connected) */
1105                 if (hostdata->selecting) {
1106                         tmp = (Scsi_Cmnd *) hostdata->selecting;
1107                         /* Selection will drop and retake the lock */
1108                         if (!NCR5380_select(instance, tmp, (tmp->cmnd[0] == REQUEST_SENSE) ? TAG_NONE : TAG_NEXT)) {
1109                                 /* Ok ?? */
1110                         } else {
1111                                 /* RvC: device failed, so we wait a long time
1112                                    this is needed for Mustek scanners, that
1113                                    do not respond to commands immediately
1114                                    after a scan */
1115                                 printk(KERN_DEBUG "scsi%d: device %d did not respond in time\n", instance->host_no, tmp->device->id);
1116                                 LIST(tmp, hostdata->issue_queue);
1117                                 tmp->host_scribble = (unsigned char *) hostdata->issue_queue;
1118                                 hostdata->issue_queue = tmp;
1119                                 NCR5380_set_timer(hostdata, USLEEP_WAITLONG);
1120                         }
1121                 }       /* if hostdata->selecting */
1122                 if (hostdata->connected
1123 #ifdef REAL_DMA
1124                     && !hostdata->dmalen
1125 #endif
1126                     && (!hostdata->time_expires || time_before_eq(hostdata->time_expires, jiffies))
1127                     ) {
1128                         dprintk(NDEBUG_MAIN, ("scsi%d : main() : performing information transfer\n", instance->host_no));
1129                         NCR5380_information_transfer(instance);
1130                         dprintk(NDEBUG_MAIN, ("scsi%d : main() : done set false\n", instance->host_no));
1131                         done = 0;
1132                 } else
1133                         break;
1134         } while (!done);
1135         
1136         spin_unlock_irq(instance->host_lock);
1137 }
1138
1139 #ifndef DONT_USE_INTR
1140
1141 /**
1142  *      NCR5380_intr    -       generic NCR5380 irq handler
1143  *      @irq: interrupt number
1144  *      @dev_id: device info
1145  *      @regs: registers (unused)
1146  *
1147  *      Handle interrupts, reestablishing I_T_L or I_T_L_Q nexuses
1148  *      from the disconnected queue, and restarting NCR5380_main() 
1149  *      as required.
1150  *
1151  *      Locks: takes the needed instance locks
1152  */
1153
1154 static irqreturn_t NCR5380_intr(int irq, void *dev_id, struct pt_regs *regs) 
1155 {
1156         NCR5380_local_declare();
1157         struct Scsi_Host *instance = (struct Scsi_Host *)dev_id;
1158         struct NCR5380_hostdata *hostdata = (struct NCR5380_hostdata *) instance->hostdata;
1159         int done;
1160         unsigned char basr;
1161         unsigned long flags;
1162
1163         dprintk(NDEBUG_INTR, ("scsi : NCR5380 irq %d triggered\n", irq));
1164
1165         do {
1166                 done = 1;
1167                 spin_lock_irqsave(instance->host_lock, flags);
1168                 /* Look for pending interrupts */
1169                 NCR5380_setup(instance);
1170                 basr = NCR5380_read(BUS_AND_STATUS_REG);
1171                 /* XXX dispatch to appropriate routine if found and done=0 */
1172                 if (basr & BASR_IRQ) {
1173                         NCR5380_dprint(NDEBUG_INTR, instance);
1174                         if ((NCR5380_read(STATUS_REG) & (SR_SEL | SR_IO)) == (SR_SEL | SR_IO)) {
1175                                 done = 0;
1176                                 dprintk(NDEBUG_INTR, ("scsi%d : SEL interrupt\n", instance->host_no));
1177                                 NCR5380_reselect(instance);
1178                                 (void) NCR5380_read(RESET_PARITY_INTERRUPT_REG);
1179                         } else if (basr & BASR_PARITY_ERROR) {
1180                                 dprintk(NDEBUG_INTR, ("scsi%d : PARITY interrupt\n", instance->host_no));
1181                                 (void) NCR5380_read(RESET_PARITY_INTERRUPT_REG);
1182                         } else if ((NCR5380_read(STATUS_REG) & SR_RST) == SR_RST) {
1183                                 dprintk(NDEBUG_INTR, ("scsi%d : RESET interrupt\n", instance->host_no));
1184                                 (void) NCR5380_read(RESET_PARITY_INTERRUPT_REG);
1185                         } else {
1186 #if defined(REAL_DMA)
1187                                 /*
1188                                  * We should only get PHASE MISMATCH and EOP interrupts
1189                                  * if we have DMA enabled, so do a sanity check based on
1190                                  * the current setting of the MODE register.
1191                                  */
1192
1193                                 if ((NCR5380_read(MODE_REG) & MR_DMA) && ((basr & BASR_END_DMA_TRANSFER) || !(basr & BASR_PHASE_MATCH))) {
1194                                         int transfered;
1195
1196                                         if (!hostdata->connected)
1197                                                 panic("scsi%d : received end of DMA interrupt with no connected cmd\n", instance->hostno);
1198
1199                                         transfered = (hostdata->dmalen - NCR5380_dma_residual(instance));
1200                                         hostdata->connected->SCp.this_residual -= transferred;
1201                                         hostdata->connected->SCp.ptr += transferred;
1202                                         hostdata->dmalen = 0;
1203
1204                                         (void) NCR5380_read(RESET_PARITY_INTERRUPT_REG);
1205                                                         
1206                                         /* FIXME: we need to poll briefly then defer a workqueue task ! */
1207                                         NCR5380_poll_politely(hostdata, BUS_AND_STATUS_REG, BASR_ACK, 0, 2*HZ);
1208
1209                                         NCR5380_write(MODE_REG, MR_BASE);
1210                                         NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
1211                                 }
1212 #else
1213                                 dprintk(NDEBUG_INTR, ("scsi : unknown interrupt, BASR 0x%X, MR 0x%X, SR 0x%x\n", basr, NCR5380_read(MODE_REG), NCR5380_read(STATUS_REG)));
1214                                 (void) NCR5380_read(RESET_PARITY_INTERRUPT_REG);
1215 #endif
1216                         }
1217                 }       /* if BASR_IRQ */
1218                 spin_unlock_irqrestore(instance->host_lock, flags);
1219                 if(!done)
1220                         schedule_work(&hostdata->coroutine);
1221         } while (!done);
1222         return IRQ_HANDLED;
1223 }
1224
1225 #endif 
1226
1227 /**
1228  *      collect_stats           -       collect stats on a scsi command
1229  *      @hostdata: adapter 
1230  *      @cmd: command being issued
1231  *
1232  *      Update the statistical data by parsing the command in question
1233  */
1234  
1235 static void collect_stats(struct NCR5380_hostdata *hostdata, Scsi_Cmnd * cmd) 
1236 {
1237 #ifdef NCR5380_STATS
1238         switch (cmd->cmnd[0]) {
1239         case WRITE:
1240         case WRITE_6:
1241         case WRITE_10:
1242                 hostdata->time_write[cmd->device->id] += (jiffies - hostdata->timebase);
1243                 hostdata->pendingw--;
1244                 break;
1245         case READ:
1246         case READ_6:
1247         case READ_10:
1248                 hostdata->time_read[cmd->device->id] += (jiffies - hostdata->timebase);
1249                 hostdata->pendingr--;
1250                 break;
1251         }
1252 #endif
1253 }
1254
1255
1256 /* 
1257  * Function : int NCR5380_select (struct Scsi_Host *instance, Scsi_Cmnd *cmd, 
1258  *      int tag);
1259  *
1260  * Purpose : establishes I_T_L or I_T_L_Q nexus for new or existing command,
1261  *      including ARBITRATION, SELECTION, and initial message out for 
1262  *      IDENTIFY and queue messages. 
1263  *
1264  * Inputs : instance - instantiation of the 5380 driver on which this 
1265  *      target lives, cmd - SCSI command to execute, tag - set to TAG_NEXT for 
1266  *      new tag, TAG_NONE for untagged queueing, otherwise set to the tag for 
1267  *      the command that is presently connected.
1268  * 
1269  * Returns : -1 if selection could not execute for some reason,
1270  *      0 if selection succeeded or failed because the target 
1271  *      did not respond.
1272  *
1273  * Side effects : 
1274  *      If bus busy, arbitration failed, etc, NCR5380_select() will exit 
1275  *              with registers as they should have been on entry - ie
1276  *              SELECT_ENABLE will be set appropriately, the NCR5380
1277  *              will cease to drive any SCSI bus signals.
1278  *
1279  *      If successful : I_T_L or I_T_L_Q nexus will be established, 
1280  *              instance->connected will be set to cmd.  
1281  *              SELECT interrupt will be disabled.
1282  *
1283  *      If failed (no target) : cmd->scsi_done() will be called, and the 
1284  *              cmd->result host byte set to DID_BAD_TARGET.
1285  *
1286  *      Locks: caller holds hostdata lock in IRQ mode
1287  */
1288  
1289 static int NCR5380_select(struct Scsi_Host *instance, Scsi_Cmnd * cmd, int tag) 
1290 {
1291         NCR5380_local_declare();
1292         struct NCR5380_hostdata *hostdata = (struct NCR5380_hostdata *) instance->hostdata;
1293         unsigned char tmp[3], phase;
1294         unsigned char *data;
1295         int len;
1296         unsigned long timeout;
1297         unsigned char value;
1298         int err;
1299         NCR5380_setup(instance);
1300
1301         if (hostdata->selecting)
1302                 goto part2;
1303
1304         hostdata->restart_select = 0;
1305
1306         NCR5380_dprint(NDEBUG_ARBITRATION, instance);
1307         dprintk(NDEBUG_ARBITRATION, ("scsi%d : starting arbitration, id = %d\n", instance->host_no, instance->this_id));
1308
1309         /* 
1310          * Set the phase bits to 0, otherwise the NCR5380 won't drive the 
1311          * data bus during SELECTION.
1312          */
1313
1314         NCR5380_write(TARGET_COMMAND_REG, 0);
1315
1316         /* 
1317          * Start arbitration.
1318          */
1319
1320         NCR5380_write(OUTPUT_DATA_REG, hostdata->id_mask);
1321         NCR5380_write(MODE_REG, MR_ARBITRATE);
1322
1323
1324         /* We can be relaxed here, interrupts are on, we are
1325            in workqueue context, the birds are singing in the trees */
1326         spin_unlock_irq(instance->host_lock);
1327         err = NCR5380_poll_politely(instance, INITIATOR_COMMAND_REG, ICR_ARBITRATION_PROGRESS, ICR_ARBITRATION_PROGRESS, 5*HZ);
1328         spin_lock_irq(instance->host_lock);
1329         if (err < 0) {
1330                 printk(KERN_DEBUG "scsi: arbitration timeout at %d\n", __LINE__);
1331                 NCR5380_write(MODE_REG, MR_BASE);
1332                 NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
1333                 goto failed;
1334         }
1335
1336         dprintk(NDEBUG_ARBITRATION, ("scsi%d : arbitration complete\n", instance->host_no));
1337
1338         /* 
1339          * The arbitration delay is 2.2us, but this is a minimum and there is 
1340          * no maximum so we can safely sleep for ceil(2.2) usecs to accommodate
1341          * the integral nature of udelay().
1342          *
1343          */
1344
1345         udelay(3);
1346
1347         /* Check for lost arbitration */
1348         if ((NCR5380_read(INITIATOR_COMMAND_REG) & ICR_ARBITRATION_LOST) || (NCR5380_read(CURRENT_SCSI_DATA_REG) & hostdata->id_higher_mask) || (NCR5380_read(INITIATOR_COMMAND_REG) & ICR_ARBITRATION_LOST)) {
1349                 NCR5380_write(MODE_REG, MR_BASE);
1350                 dprintk(NDEBUG_ARBITRATION, ("scsi%d : lost arbitration, deasserting MR_ARBITRATE\n", instance->host_no));
1351                 goto failed;
1352         }
1353         NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_SEL);
1354
1355         if (!(hostdata->flags & FLAG_DTC3181E) &&
1356             /* RvC: DTC3181E has some trouble with this
1357              *      so we simply removed it. Seems to work with
1358              *      only Mustek scanner attached
1359              */
1360             (NCR5380_read(INITIATOR_COMMAND_REG) & ICR_ARBITRATION_LOST)) {
1361                 NCR5380_write(MODE_REG, MR_BASE);
1362                 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
1363                 dprintk(NDEBUG_ARBITRATION, ("scsi%d : lost arbitration, deasserting ICR_ASSERT_SEL\n", instance->host_no));
1364                 goto failed;
1365         }
1366         /* 
1367          * Again, bus clear + bus settle time is 1.2us, however, this is 
1368          * a minimum so we'll udelay ceil(1.2)
1369          */
1370
1371         udelay(2);
1372
1373         dprintk(NDEBUG_ARBITRATION, ("scsi%d : won arbitration\n", instance->host_no));
1374
1375         /* 
1376          * Now that we have won arbitration, start Selection process, asserting 
1377          * the host and target ID's on the SCSI bus.
1378          */
1379
1380         NCR5380_write(OUTPUT_DATA_REG, (hostdata->id_mask | (1 << cmd->device->id)));
1381
1382         /* 
1383          * Raise ATN while SEL is true before BSY goes false from arbitration,
1384          * since this is the only way to guarantee that we'll get a MESSAGE OUT
1385          * phase immediately after selection.
1386          */
1387
1388         NCR5380_write(INITIATOR_COMMAND_REG, (ICR_BASE | ICR_ASSERT_BSY | ICR_ASSERT_DATA | ICR_ASSERT_ATN | ICR_ASSERT_SEL));
1389         NCR5380_write(MODE_REG, MR_BASE);
1390
1391         /* 
1392          * Reselect interrupts must be turned off prior to the dropping of BSY,
1393          * otherwise we will trigger an interrupt.
1394          */
1395         NCR5380_write(SELECT_ENABLE_REG, 0);
1396
1397         /*
1398          * The initiator shall then wait at least two deskew delays and release 
1399          * the BSY signal.
1400          */
1401         udelay(1);              /* wingel -- wait two bus deskew delay >2*45ns */
1402
1403         /* Reset BSY */
1404         NCR5380_write(INITIATOR_COMMAND_REG, (ICR_BASE | ICR_ASSERT_DATA | ICR_ASSERT_ATN | ICR_ASSERT_SEL));
1405
1406         /* 
1407          * Something weird happens when we cease to drive BSY - looks
1408          * like the board/chip is letting us do another read before the 
1409          * appropriate propagation delay has expired, and we're confusing
1410          * a BSY signal from ourselves as the target's response to SELECTION.
1411          *
1412          * A small delay (the 'C++' frontend breaks the pipeline with an
1413          * unnecessary jump, making it work on my 386-33/Trantor T128, the
1414          * tighter 'C' code breaks and requires this) solves the problem - 
1415          * the 1 us delay is arbitrary, and only used because this delay will 
1416          * be the same on other platforms and since it works here, it should 
1417          * work there.
1418          *
1419          * wingel suggests that this could be due to failing to wait
1420          * one deskew delay.
1421          */
1422
1423         udelay(1);
1424
1425         dprintk(NDEBUG_SELECTION, ("scsi%d : selecting target %d\n", instance->host_no, cmd->device->id));
1426
1427         /* 
1428          * The SCSI specification calls for a 250 ms timeout for the actual 
1429          * selection.
1430          */
1431
1432         timeout = jiffies + (250 * HZ / 1000);
1433
1434         /* 
1435          * XXX very interesting - we're seeing a bounce where the BSY we 
1436          * asserted is being reflected / still asserted (propagation delay?)
1437          * and it's detecting as true.  Sigh.
1438          */
1439
1440         hostdata->select_time = 0;      /* we count the clock ticks at which we polled */
1441         hostdata->selecting = cmd;
1442
1443 part2:
1444         /* RvC: here we enter after a sleeping period, or immediately after
1445            execution of part 1
1446            we poll only once ech clock tick */
1447         value = NCR5380_read(STATUS_REG) & (SR_BSY | SR_IO);
1448
1449         if (!value && (hostdata->select_time < HZ/4)) {
1450                 /* RvC: we still must wait for a device response */
1451                 hostdata->select_time++;        /* after 25 ticks the device has failed */
1452                 NCR5380_set_timer(hostdata, 1);
1453                 return 0;       /* RvC: we return here with hostdata->selecting set,
1454                                    to go to sleep */
1455         }
1456
1457         hostdata->selecting = NULL;/* clear this pointer, because we passed the
1458                                            waiting period */
1459         if ((NCR5380_read(STATUS_REG) & (SR_SEL | SR_IO)) == (SR_SEL | SR_IO)) {
1460                 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
1461                 NCR5380_reselect(instance);
1462                 printk("scsi%d : reselection after won arbitration?\n", instance->host_no);
1463                 NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
1464                 return -1;
1465         }
1466         /* 
1467          * No less than two deskew delays after the initiator detects the 
1468          * BSY signal is true, it shall release the SEL signal and may 
1469          * change the DATA BUS.                                     -wingel
1470          */
1471
1472         udelay(1);
1473
1474         NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN);
1475
1476         if (!(NCR5380_read(STATUS_REG) & SR_BSY)) {
1477                 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
1478                 if (hostdata->targets_present & (1 << cmd->device->id)) {
1479                         printk(KERN_DEBUG "scsi%d : weirdness\n", instance->host_no);
1480                         if (hostdata->restart_select)
1481                                 printk(KERN_DEBUG "\trestart select\n");
1482                         NCR5380_dprint(NDEBUG_SELECTION, instance);
1483                         NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
1484                         return -1;
1485                 }
1486                 cmd->result = DID_BAD_TARGET << 16;
1487                 collect_stats(hostdata, cmd);
1488                 cmd->scsi_done(cmd);
1489                 NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
1490                 dprintk(NDEBUG_SELECTION, ("scsi%d : target did not respond within 250ms\n", instance->host_no));
1491                 NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
1492                 return 0;
1493         }
1494         hostdata->targets_present |= (1 << cmd->device->id);
1495
1496         /*
1497          * Since we followed the SCSI spec, and raised ATN while SEL 
1498          * was true but before BSY was false during selection, the information
1499          * transfer phase should be a MESSAGE OUT phase so that we can send the
1500          * IDENTIFY message.
1501          * 
1502          * If SCSI-II tagged queuing is enabled, we also send a SIMPLE_QUEUE_TAG
1503          * message (2 bytes) with a tag ID that we increment with every command
1504          * until it wraps back to 0.
1505          *
1506          * XXX - it turns out that there are some broken SCSI-II devices,
1507          *       which claim to support tagged queuing but fail when more than
1508          *       some number of commands are issued at once.
1509          */
1510
1511         /* Wait for start of REQ/ACK handshake */
1512
1513         spin_unlock_irq(instance->host_lock);
1514         err = NCR5380_poll_politely(instance, STATUS_REG, SR_REQ, SR_REQ, HZ);
1515         spin_lock_irq(instance->host_lock);
1516         
1517         if(err) {
1518                 printk(KERN_ERR "scsi%d: timeout at NCR5380.c:%d\n", instance->host_no, __LINE__);
1519                 NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
1520                 goto failed;
1521         }
1522
1523         dprintk(NDEBUG_SELECTION, ("scsi%d : target %d selected, going into MESSAGE OUT phase.\n", instance->host_no, cmd->device->id));
1524         tmp[0] = IDENTIFY(((instance->irq == SCSI_IRQ_NONE) ? 0 : 1), cmd->device->lun);
1525
1526         len = 1;
1527         cmd->tag = 0;
1528
1529         /* Send message(s) */
1530         data = tmp;
1531         phase = PHASE_MSGOUT;
1532         NCR5380_transfer_pio(instance, &phase, &len, &data);
1533         dprintk(NDEBUG_SELECTION, ("scsi%d : nexus established.\n", instance->host_no));
1534         /* XXX need to handle errors here */
1535         hostdata->connected = cmd;
1536         hostdata->busy[cmd->device->id] |= (1 << cmd->device->lun);
1537
1538         if (cmd->SCp.ptr != (char *)cmd->sense_buffer) {
1539                 initialize_SCp(cmd);
1540         }
1541
1542         return 0;
1543
1544         /* Selection failed */
1545 failed:
1546         return -1;
1547
1548 }
1549
1550 /* 
1551  * Function : int NCR5380_transfer_pio (struct Scsi_Host *instance, 
1552  *      unsigned char *phase, int *count, unsigned char **data)
1553  *
1554  * Purpose : transfers data in given phase using polled I/O
1555  *
1556  * Inputs : instance - instance of driver, *phase - pointer to 
1557  *      what phase is expected, *count - pointer to number of 
1558  *      bytes to transfer, **data - pointer to data pointer.
1559  * 
1560  * Returns : -1 when different phase is entered without transferring
1561  *      maximum number of bytes, 0 if all bytes or transfered or exit
1562  *      is in same phase.
1563  *
1564  *      Also, *phase, *count, *data are modified in place.
1565  *
1566  * XXX Note : handling for bus free may be useful.
1567  */
1568
1569 /*
1570  * Note : this code is not as quick as it could be, however it 
1571  * IS 100% reliable, and for the actual data transfer where speed
1572  * counts, we will always do a pseudo DMA or DMA transfer.
1573  */
1574
1575 static int NCR5380_transfer_pio(struct Scsi_Host *instance, unsigned char *phase, int *count, unsigned char **data) {
1576         NCR5380_local_declare();
1577         unsigned char p = *phase, tmp;
1578         int c = *count;
1579         unsigned char *d = *data;
1580         /*
1581          *      RvC: some administrative data to process polling time
1582          */
1583         int break_allowed = 0;
1584         struct NCR5380_hostdata *hostdata = (struct NCR5380_hostdata *) instance->hostdata;
1585         NCR5380_setup(instance);
1586
1587         if (!(p & SR_IO))
1588                 dprintk(NDEBUG_PIO, ("scsi%d : pio write %d bytes\n", instance->host_no, c));
1589         else
1590                 dprintk(NDEBUG_PIO, ("scsi%d : pio read %d bytes\n", instance->host_no, c));
1591
1592         /* 
1593          * The NCR5380 chip will only drive the SCSI bus when the 
1594          * phase specified in the appropriate bits of the TARGET COMMAND
1595          * REGISTER match the STATUS REGISTER
1596          */
1597
1598          NCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(p));
1599
1600         /* RvC: don't know if this is necessary, but other SCSI I/O is short
1601          *      so breaks are not necessary there
1602          */
1603         if ((p == PHASE_DATAIN) || (p == PHASE_DATAOUT)) {
1604                 break_allowed = 1;
1605         }
1606         do {
1607                 /* 
1608                  * Wait for assertion of REQ, after which the phase bits will be 
1609                  * valid 
1610                  */
1611
1612                 /* RvC: we simply poll once, after that we stop temporarily
1613                  *      and let the device buffer fill up
1614                  *      if breaking is not allowed, we keep polling as long as needed
1615                  */
1616
1617                 /* FIXME */
1618                 while (!((tmp = NCR5380_read(STATUS_REG)) & SR_REQ) && !break_allowed);
1619                 if (!(tmp & SR_REQ)) {
1620                         /* timeout condition */
1621                         NCR5380_set_timer(hostdata, USLEEP_SLEEP);
1622                         break;
1623                 }
1624
1625                 dprintk(NDEBUG_HANDSHAKE, ("scsi%d : REQ detected\n", instance->host_no));
1626
1627                 /* Check for phase mismatch */
1628                 if ((tmp & PHASE_MASK) != p) {
1629                         dprintk(NDEBUG_HANDSHAKE, ("scsi%d : phase mismatch\n", instance->host_no));
1630                         NCR5380_dprint_phase(NDEBUG_HANDSHAKE, instance);
1631                         break;
1632                 }
1633                 /* Do actual transfer from SCSI bus to / from memory */
1634                 if (!(p & SR_IO))
1635                         NCR5380_write(OUTPUT_DATA_REG, *d);
1636                 else
1637                         *d = NCR5380_read(CURRENT_SCSI_DATA_REG);
1638
1639                 ++d;
1640
1641                 /* 
1642                  * The SCSI standard suggests that in MSGOUT phase, the initiator
1643                  * should drop ATN on the last byte of the message phase
1644                  * after REQ has been asserted for the handshake but before
1645                  * the initiator raises ACK.
1646                  */
1647
1648                 if (!(p & SR_IO)) {
1649                         if (!((p & SR_MSG) && c > 1)) {
1650                                 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_DATA);
1651                                 NCR5380_dprint(NDEBUG_PIO, instance);
1652                                 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_DATA | ICR_ASSERT_ACK);
1653                         } else {
1654                                 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_DATA | ICR_ASSERT_ATN);
1655                                 NCR5380_dprint(NDEBUG_PIO, instance);
1656                                 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_DATA | ICR_ASSERT_ATN | ICR_ASSERT_ACK);
1657                         }
1658                 } else {
1659                         NCR5380_dprint(NDEBUG_PIO, instance);
1660                         NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ACK);
1661                 }
1662
1663                 /* FIXME - if this fails bus reset ?? */
1664                 NCR5380_poll_politely(instance, STATUS_REG, SR_REQ, 0, 5*HZ);
1665                 dprintk(NDEBUG_HANDSHAKE, ("scsi%d : req false, handshake complete\n", instance->host_no));
1666
1667 /*
1668  * We have several special cases to consider during REQ/ACK handshaking : 
1669  * 1.  We were in MSGOUT phase, and we are on the last byte of the 
1670  *      message.  ATN must be dropped as ACK is dropped.
1671  *
1672  * 2.  We are in a MSGIN phase, and we are on the last byte of the  
1673  *      message.  We must exit with ACK asserted, so that the calling
1674  *      code may raise ATN before dropping ACK to reject the message.
1675  *
1676  * 3.  ACK and ATN are clear and the target may proceed as normal.
1677  */
1678                 if (!(p == PHASE_MSGIN && c == 1)) {
1679                         if (p == PHASE_MSGOUT && c > 1)
1680                                 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN);
1681                         else
1682                                 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
1683                 }
1684         } while (--c);
1685
1686         dprintk(NDEBUG_PIO, ("scsi%d : residual %d\n", instance->host_no, c));
1687
1688         *count = c;
1689         *data = d;
1690         tmp = NCR5380_read(STATUS_REG);
1691         if (tmp & SR_REQ)
1692                 *phase = tmp & PHASE_MASK;
1693         else
1694                 *phase = PHASE_UNKNOWN;
1695
1696         if (!c || (*phase == p))
1697                 return 0;
1698         else
1699                 return -1;
1700 }
1701
1702 /**
1703  *      do_reset        -       issue a reset command
1704  *      @host: adapter to reset
1705  *
1706  *      Issue a reset sequence to the NCR5380 and try and get the bus
1707  *      back into sane shape.
1708  *
1709  *      Locks: caller holds queue lock
1710  */
1711  
1712 static void do_reset(struct Scsi_Host *host) {
1713         NCR5380_local_declare();
1714         NCR5380_setup(host);
1715
1716         NCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(NCR5380_read(STATUS_REG) & PHASE_MASK));
1717         NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_RST);
1718         udelay(25);
1719         NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
1720 }
1721
1722 /*
1723  * Function : do_abort (Scsi_Host *host)
1724  * 
1725  * Purpose : abort the currently established nexus.  Should only be 
1726  *      called from a routine which can drop into a 
1727  * 
1728  * Returns : 0 on success, -1 on failure.
1729  *
1730  * Locks: queue lock held by caller
1731  *      FIXME: sort this out and get new_eh running
1732  */
1733
1734 static int do_abort(struct Scsi_Host *host) {
1735         NCR5380_local_declare();
1736         unsigned char *msgptr, phase, tmp;
1737         int len;
1738         int rc;
1739         NCR5380_setup(host);
1740
1741
1742         /* Request message out phase */
1743         NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN);
1744
1745         /* 
1746          * Wait for the target to indicate a valid phase by asserting 
1747          * REQ.  Once this happens, we'll have either a MSGOUT phase 
1748          * and can immediately send the ABORT message, or we'll have some 
1749          * other phase and will have to source/sink data.
1750          * 
1751          * We really don't care what value was on the bus or what value
1752          * the target sees, so we just handshake.
1753          */
1754
1755         rc = NCR5380_poll_politely(host, STATUS_REG, SR_REQ, SR_REQ, 60 * HZ);
1756         
1757         if(rc < 0)
1758                 return -1;
1759
1760         tmp = (unsigned char)rc;
1761         
1762         NCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(tmp));
1763
1764         if ((tmp & PHASE_MASK) != PHASE_MSGOUT) {
1765                 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN | ICR_ASSERT_ACK);
1766                 rc = NCR5380_poll_politely(host, STATUS_REG, SR_REQ, 0, 3*HZ);
1767                 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN);
1768                 if(rc == -1)
1769                         return -1;
1770         }
1771         tmp = ABORT;
1772         msgptr = &tmp;
1773         len = 1;
1774         phase = PHASE_MSGOUT;
1775         NCR5380_transfer_pio(host, &phase, &len, &msgptr);
1776
1777         /*
1778          * If we got here, and the command completed successfully,
1779          * we're about to go into bus free state.
1780          */
1781
1782         return len ? -1 : 0;
1783 }
1784
1785 #if defined(REAL_DMA) || defined(PSEUDO_DMA) || defined (REAL_DMA_POLL)
1786 /* 
1787  * Function : int NCR5380_transfer_dma (struct Scsi_Host *instance, 
1788  *      unsigned char *phase, int *count, unsigned char **data)
1789  *
1790  * Purpose : transfers data in given phase using either real
1791  *      or pseudo DMA.
1792  *
1793  * Inputs : instance - instance of driver, *phase - pointer to 
1794  *      what phase is expected, *count - pointer to number of 
1795  *      bytes to transfer, **data - pointer to data pointer.
1796  * 
1797  * Returns : -1 when different phase is entered without transferring
1798  *      maximum number of bytes, 0 if all bytes or transfered or exit
1799  *      is in same phase.
1800  *
1801  *      Also, *phase, *count, *data are modified in place.
1802  *
1803  *      Locks: io_request lock held by caller
1804  */
1805
1806
1807 static int NCR5380_transfer_dma(struct Scsi_Host *instance, unsigned char *phase, int *count, unsigned char **data) {
1808         NCR5380_local_declare();
1809         register int c = *count;
1810         register unsigned char p = *phase;
1811         register unsigned char *d = *data;
1812         unsigned char tmp;
1813         int foo;
1814 #if defined(REAL_DMA_POLL)
1815         int cnt, toPIO;
1816         unsigned char saved_data = 0, overrun = 0, residue;
1817 #endif
1818
1819         struct NCR5380_hostdata *hostdata = (struct NCR5380_hostdata *) instance->hostdata;
1820
1821         NCR5380_setup(instance);
1822
1823         if ((tmp = (NCR5380_read(STATUS_REG) & PHASE_MASK)) != p) {
1824                 *phase = tmp;
1825                 return -1;
1826         }
1827 #if defined(REAL_DMA) || defined(REAL_DMA_POLL)
1828 #ifdef READ_OVERRUNS
1829         if (p & SR_IO) {
1830                 c -= 2;
1831         }
1832 #endif
1833         dprintk(NDEBUG_DMA, ("scsi%d : initializing DMA channel %d for %s, %d bytes %s %0x\n", instance->host_no, instance->dma_channel, (p & SR_IO) ? "reading" : "writing", c, (p & SR_IO) ? "to" : "from", (unsigned) d));
1834         hostdata->dma_len = (p & SR_IO) ? NCR5380_dma_read_setup(instance, d, c) : NCR5380_dma_write_setup(instance, d, c);
1835 #endif
1836
1837         NCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(p));
1838
1839 #ifdef REAL_DMA
1840         NCR5380_write(MODE_REG, MR_BASE | MR_DMA_MODE | MR_ENABLE_EOP_INTR | MR_MONITOR_BSY);
1841 #elif defined(REAL_DMA_POLL)
1842         NCR5380_write(MODE_REG, MR_BASE | MR_DMA_MODE);
1843 #else
1844         /*
1845          * Note : on my sample board, watch-dog timeouts occurred when interrupts
1846          * were not disabled for the duration of a single DMA transfer, from 
1847          * before the setting of DMA mode to after transfer of the last byte.
1848          */
1849
1850 #if defined(PSEUDO_DMA) && defined(UNSAFE)
1851         spin_unlock_irq(instance->host_lock);
1852 #endif
1853         /* KLL May need eop and parity in 53c400 */
1854         if (hostdata->flags & FLAG_NCR53C400)
1855                 NCR5380_write(MODE_REG, MR_BASE | MR_DMA_MODE | MR_ENABLE_PAR_CHECK | MR_ENABLE_PAR_INTR | MR_ENABLE_EOP_INTR | MR_DMA_MODE | MR_MONITOR_BSY);
1856         else
1857                 NCR5380_write(MODE_REG, MR_BASE | MR_DMA_MODE);
1858 #endif                          /* def REAL_DMA */
1859
1860         dprintk(NDEBUG_DMA, ("scsi%d : mode reg = 0x%X\n", instance->host_no, NCR5380_read(MODE_REG)));
1861
1862         /* 
1863          *      On the PAS16 at least I/O recovery delays are not needed here.
1864          *      Everyone else seems to want them.
1865          */
1866
1867         if (p & SR_IO) {
1868                 io_recovery_delay(1);
1869                 NCR5380_write(START_DMA_INITIATOR_RECEIVE_REG, 0);
1870         } else {
1871                 io_recovery_delay(1);
1872                 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_DATA);
1873                 io_recovery_delay(1);
1874                 NCR5380_write(START_DMA_SEND_REG, 0);
1875                 io_recovery_delay(1);
1876         }
1877
1878 #if defined(REAL_DMA_POLL)
1879         do {
1880                 tmp = NCR5380_read(BUS_AND_STATUS_REG);
1881         } while ((tmp & BASR_PHASE_MATCH) && !(tmp & (BASR_BUSY_ERROR | BASR_END_DMA_TRANSFER)));
1882
1883 /*
1884    At this point, either we've completed DMA, or we have a phase mismatch,
1885    or we've unexpectedly lost BUSY (which is a real error).
1886
1887    For write DMAs, we want to wait until the last byte has been
1888    transferred out over the bus before we turn off DMA mode.  Alas, there
1889    seems to be no terribly good way of doing this on a 5380 under all
1890    conditions.  For non-scatter-gather operations, we can wait until REQ
1891    and ACK both go false, or until a phase mismatch occurs.  Gather-writes
1892    are nastier, since the device will be expecting more data than we
1893    are prepared to send it, and REQ will remain asserted.  On a 53C8[01] we
1894    could test LAST BIT SENT to assure transfer (I imagine this is precisely
1895    why this signal was added to the newer chips) but on the older 538[01]
1896    this signal does not exist.  The workaround for this lack is a watchdog;
1897    we bail out of the wait-loop after a modest amount of wait-time if
1898    the usual exit conditions are not met.  Not a terribly clean or
1899    correct solution :-%
1900
1901    Reads are equally tricky due to a nasty characteristic of the NCR5380.
1902    If the chip is in DMA mode for an READ, it will respond to a target's
1903    REQ by latching the SCSI data into the INPUT DATA register and asserting
1904    ACK, even if it has _already_ been notified by the DMA controller that
1905    the current DMA transfer has completed!  If the NCR5380 is then taken
1906    out of DMA mode, this already-acknowledged byte is lost.
1907
1908    This is not a problem for "one DMA transfer per command" reads, because
1909    the situation will never arise... either all of the data is DMA'ed
1910    properly, or the target switches to MESSAGE IN phase to signal a
1911    disconnection (either operation bringing the DMA to a clean halt).
1912    However, in order to handle scatter-reads, we must work around the
1913    problem.  The chosen fix is to DMA N-2 bytes, then check for the
1914    condition before taking the NCR5380 out of DMA mode.  One or two extra
1915    bytes are transferred via PIO as necessary to fill out the original
1916    request.
1917  */
1918
1919         if (p & SR_IO) {
1920 #ifdef READ_OVERRUNS
1921                 udelay(10);
1922                 if (((NCR5380_read(BUS_AND_STATUS_REG) & (BASR_PHASE_MATCH | BASR_ACK)) == (BASR_PHASE_MATCH | BASR_ACK))) {
1923                         saved_data = NCR5380_read(INPUT_DATA_REGISTER);
1924                         overrun = 1;
1925                 }
1926 #endif
1927         } else {
1928                 int limit = 100;
1929                 while (((tmp = NCR5380_read(BUS_AND_STATUS_REG)) & BASR_ACK) || (NCR5380_read(STATUS_REG) & SR_REQ)) {
1930                         if (!(tmp & BASR_PHASE_MATCH))
1931                                 break;
1932                         if (--limit < 0)
1933                                 break;
1934                 }
1935         }
1936
1937         dprintk(NDEBUG_DMA, ("scsi%d : polled DMA transfer complete, basr 0x%X, sr 0x%X\n", instance->host_no, tmp, NCR5380_read(STATUS_REG)));
1938
1939         NCR5380_write(MODE_REG, MR_BASE);
1940         NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
1941
1942         residue = NCR5380_dma_residual(instance);
1943         c -= residue;
1944         *count -= c;
1945         *data += c;
1946         *phase = NCR5380_read(STATUS_REG) & PHASE_MASK;
1947
1948 #ifdef READ_OVERRUNS
1949         if (*phase == p && (p & SR_IO) && residue == 0) {
1950                 if (overrun) {
1951                         dprintk(NDEBUG_DMA, ("Got an input overrun, using saved byte\n"));
1952                         **data = saved_data;
1953                         *data += 1;
1954                         *count -= 1;
1955                         cnt = toPIO = 1;
1956                 } else {
1957                         printk("No overrun??\n");
1958                         cnt = toPIO = 2;
1959                 }
1960                 dprintk(NDEBUG_DMA, ("Doing %d-byte PIO to 0x%X\n", cnt, *data));
1961                 NCR5380_transfer_pio(instance, phase, &cnt, data);
1962                 *count -= toPIO - cnt;
1963         }
1964 #endif
1965
1966         dprintk(NDEBUG_DMA, ("Return with data ptr = 0x%X, count %d, last 0x%X, next 0x%X\n", *data, *count, *(*data + *count - 1), *(*data + *count)));
1967         return 0;
1968
1969 #elif defined(REAL_DMA)
1970         return 0;
1971 #else                           /* defined(REAL_DMA_POLL) */
1972         if (p & SR_IO) {
1973 #ifdef DMA_WORKS_RIGHT
1974                 foo = NCR5380_pread(instance, d, c);
1975 #else
1976                 int diff = 1;
1977                 if (hostdata->flags & FLAG_NCR53C400) {
1978                         diff = 0;
1979                 }
1980                 if (!(foo = NCR5380_pread(instance, d, c - diff))) {
1981                         /*
1982                          * We can't disable DMA mode after successfully transferring 
1983                          * what we plan to be the last byte, since that would open up
1984                          * a race condition where if the target asserted REQ before 
1985                          * we got the DMA mode reset, the NCR5380 would have latched
1986                          * an additional byte into the INPUT DATA register and we'd
1987                          * have dropped it.
1988                          * 
1989                          * The workaround was to transfer one fewer bytes than we 
1990                          * intended to with the pseudo-DMA read function, wait for 
1991                          * the chip to latch the last byte, read it, and then disable
1992                          * pseudo-DMA mode.
1993                          * 
1994                          * After REQ is asserted, the NCR5380 asserts DRQ and ACK.
1995                          * REQ is deasserted when ACK is asserted, and not reasserted
1996                          * until ACK goes false.  Since the NCR5380 won't lower ACK
1997                          * until DACK is asserted, which won't happen unless we twiddle
1998                          * the DMA port or we take the NCR5380 out of DMA mode, we 
1999                          * can guarantee that we won't handshake another extra 
2000                          * byte.
2001                          */
2002
2003                         if (!(hostdata->flags & FLAG_NCR53C400)) {
2004                                 while (!(NCR5380_read(BUS_AND_STATUS_REG) & BASR_DRQ));
2005                                 /* Wait for clean handshake */
2006                                 while (NCR5380_read(STATUS_REG) & SR_REQ);
2007                                 d[c - 1] = NCR5380_read(INPUT_DATA_REG);
2008                         }
2009                 }
2010 #endif
2011         } else {
2012 #ifdef DMA_WORKS_RIGHT
2013                 foo = NCR5380_pwrite(instance, d, c);
2014 #else
2015                 int timeout;
2016                 dprintk(NDEBUG_C400_PWRITE, ("About to pwrite %d bytes\n", c));
2017                 if (!(foo = NCR5380_pwrite(instance, d, c))) {
2018                         /*
2019                          * Wait for the last byte to be sent.  If REQ is being asserted for 
2020                          * the byte we're interested, we'll ACK it and it will go false.  
2021                          */
2022                         if (!(hostdata->flags & FLAG_HAS_LAST_BYTE_SENT)) {
2023                                 timeout = 20000;
2024                                 while (!(NCR5380_read(BUS_AND_STATUS_REG) & BASR_DRQ) && (NCR5380_read(BUS_AND_STATUS_REG) & BASR_PHASE_MATCH));
2025
2026                                 if (!timeout)
2027                                         dprintk(NDEBUG_LAST_BYTE_SENT, ("scsi%d : timed out on last byte\n", instance->host_no));
2028
2029                                 if (hostdata->flags & FLAG_CHECK_LAST_BYTE_SENT) {
2030                                         hostdata->flags &= ~FLAG_CHECK_LAST_BYTE_SENT;
2031                                         if (NCR5380_read(TARGET_COMMAND_REG) & TCR_LAST_BYTE_SENT) {
2032                                                 hostdata->flags |= FLAG_HAS_LAST_BYTE_SENT;
2033                                                 dprintk(NDEBUG_LAST_WRITE_SENT, ("scsi%d : last bit sent works\n", instance->host_no));
2034                                         }
2035                                 }
2036                         } else {
2037                                 dprintk(NDEBUG_C400_PWRITE, ("Waiting for LASTBYTE\n"));
2038                                 while (!(NCR5380_read(TARGET_COMMAND_REG) & TCR_LAST_BYTE_SENT));
2039                                 dprintk(NDEBUG_C400_PWRITE, ("Got LASTBYTE\n"));
2040                         }
2041                 }
2042 #endif
2043         }
2044         NCR5380_write(MODE_REG, MR_BASE);
2045         NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
2046
2047         if ((!(p & SR_IO)) && (hostdata->flags & FLAG_NCR53C400)) {
2048                 dprintk(NDEBUG_C400_PWRITE, ("53C400w: Checking for IRQ\n"));
2049                 if (NCR5380_read(BUS_AND_STATUS_REG) & BASR_IRQ) {
2050                         dprintk(NDEBUG_C400_PWRITE, ("53C400w:    got it, reading reset interrupt reg\n"));
2051                         NCR5380_read(RESET_PARITY_INTERRUPT_REG);
2052                 } else {
2053                         printk("53C400w:    IRQ NOT THERE!\n");
2054                 }
2055         }
2056         *data = d + c;
2057         *count = 0;
2058         *phase = NCR5380_read(STATUS_REG) & PHASE_MASK;
2059 #if defined(PSEUDO_DMA) && defined(UNSAFE)
2060         spin_lock_irq(instance->host_lock);
2061 #endif                          /* defined(REAL_DMA_POLL) */
2062         return foo;
2063 #endif                          /* def REAL_DMA */
2064 }
2065 #endif                          /* defined(REAL_DMA) | defined(PSEUDO_DMA) */
2066
2067 /*
2068  * Function : NCR5380_information_transfer (struct Scsi_Host *instance)
2069  *
2070  * Purpose : run through the various SCSI phases and do as the target 
2071  *      directs us to.  Operates on the currently connected command, 
2072  *      instance->connected.
2073  *
2074  * Inputs : instance, instance for which we are doing commands
2075  *
2076  * Side effects : SCSI things happen, the disconnected queue will be 
2077  *      modified if a command disconnects, *instance->connected will
2078  *      change.
2079  *
2080  * XXX Note : we need to watch for bus free or a reset condition here 
2081  *      to recover from an unexpected bus free condition.
2082  *
2083  * Locks: io_request_lock held by caller in IRQ mode
2084  */
2085
2086 static void NCR5380_information_transfer(struct Scsi_Host *instance) {
2087         NCR5380_local_declare();
2088         struct NCR5380_hostdata *hostdata = (struct NCR5380_hostdata *)instance->hostdata;
2089         unsigned char msgout = NOP;
2090         int sink = 0;
2091         int len;
2092 #if defined(PSEUDO_DMA) || defined(REAL_DMA_POLL)
2093         int transfersize;
2094 #endif
2095         unsigned char *data;
2096         unsigned char phase, tmp, extended_msg[10], old_phase = 0xff;
2097         Scsi_Cmnd *cmd = (Scsi_Cmnd *) hostdata->connected;
2098         /* RvC: we need to set the end of the polling time */
2099         unsigned long poll_time = jiffies + USLEEP_POLL;
2100
2101         NCR5380_setup(instance);
2102
2103         while (1) {
2104                 tmp = NCR5380_read(STATUS_REG);
2105                 /* We only have a valid SCSI phase when REQ is asserted */
2106                 if (tmp & SR_REQ) {
2107                         phase = (tmp & PHASE_MASK);
2108                         if (phase != old_phase) {
2109                                 old_phase = phase;
2110                                 NCR5380_dprint_phase(NDEBUG_INFORMATION, instance);
2111                         }
2112                         if (sink && (phase != PHASE_MSGOUT)) {
2113                                 NCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(tmp));
2114
2115                                 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN | ICR_ASSERT_ACK);
2116                                 while (NCR5380_read(STATUS_REG) & SR_REQ);
2117                                 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN);
2118                                 sink = 0;
2119                                 continue;
2120                         }
2121                         switch (phase) {
2122                         case PHASE_DATAIN:
2123                         case PHASE_DATAOUT:
2124 #if (NDEBUG & NDEBUG_NO_DATAOUT)
2125                                 printk("scsi%d : NDEBUG_NO_DATAOUT set, attempted DATAOUT aborted\n", instance->host_no);
2126                                 sink = 1;
2127                                 do_abort(instance);
2128                                 cmd->result = DID_ERROR << 16;
2129                                 cmd->done(cmd);
2130                                 return;
2131 #endif
2132                                 /* 
2133                                  * If there is no room left in the current buffer in the
2134                                  * scatter-gather list, move onto the next one.
2135                                  */
2136
2137                                 if (!cmd->SCp.this_residual && cmd->SCp.buffers_residual) {
2138                                         ++cmd->SCp.buffer;
2139                                         --cmd->SCp.buffers_residual;
2140                                         cmd->SCp.this_residual = cmd->SCp.buffer->length;
2141                                         cmd->SCp.ptr = page_address(cmd->SCp.buffer->page)+
2142                                                        cmd->SCp.buffer->offset;
2143                                         dprintk(NDEBUG_INFORMATION, ("scsi%d : %d bytes and %d buffers left\n", instance->host_no, cmd->SCp.this_residual, cmd->SCp.buffers_residual));
2144                                 }
2145                                 /*
2146                                  * The preferred transfer method is going to be 
2147                                  * PSEUDO-DMA for systems that are strictly PIO,
2148                                  * since we can let the hardware do the handshaking.
2149                                  *
2150                                  * For this to work, we need to know the transfersize
2151                                  * ahead of time, since the pseudo-DMA code will sit
2152                                  * in an unconditional loop.
2153                                  */
2154
2155 #if defined(PSEUDO_DMA) || defined(REAL_DMA_POLL)
2156                                 /* KLL
2157                                  * PSEUDO_DMA is defined here. If this is the g_NCR5380
2158                                  * driver then it will always be defined, so the
2159                                  * FLAG_NO_PSEUDO_DMA is used to inhibit PDMA in the base
2160                                  * NCR5380 case.  I think this is a fairly clean solution.
2161                                  * We supplement these 2 if's with the flag.
2162                                  */
2163 #ifdef NCR5380_dma_xfer_len
2164                                 if (!cmd->device->borken && !(hostdata->flags & FLAG_NO_PSEUDO_DMA) && (transfersize = NCR5380_dma_xfer_len(instance, cmd)) != 0) {
2165 #else
2166                                 transfersize = cmd->transfersize;
2167
2168 #ifdef LIMIT_TRANSFERSIZE       /* If we have problems with interrupt service */
2169                                 if (transfersize > 512)
2170                                         transfersize = 512;
2171 #endif                          /* LIMIT_TRANSFERSIZE */
2172
2173                                 if (!cmd->device->borken && transfersize && !(hostdata->flags & FLAG_NO_PSEUDO_DMA) && cmd->SCp.this_residual && !(cmd->SCp.this_residual % transfersize)) {
2174                                         /* Limit transfers to 32K, for xx400 & xx406
2175                                          * pseudoDMA that transfers in 128 bytes blocks. */
2176                                         if (transfersize > 32 * 1024)
2177                                                 transfersize = 32 * 1024;
2178 #endif
2179                                         len = transfersize;
2180                                         if (NCR5380_transfer_dma(instance, &phase, &len, (unsigned char **) &cmd->SCp.ptr)) {
2181                                                 /*
2182                                                  * If the watchdog timer fires, all future accesses to this
2183                                                  * device will use the polled-IO.
2184                                                  */
2185                                                 printk("scsi%d : switching target %d lun %d to slow handshake\n", instance->host_no, cmd->device->id, cmd->device->lun);
2186                                                 cmd->device->borken = 1;
2187                                                 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN);
2188                                                 sink = 1;
2189                                                 do_abort(instance);
2190                                                 cmd->result = DID_ERROR << 16;
2191                                                 cmd->done(cmd);
2192                                                 /* XXX - need to source or sink data here, as appropriate */
2193                                         } else
2194                                                 cmd->SCp.this_residual -= transfersize - len;
2195                                 } else
2196 #endif                          /* defined(PSEUDO_DMA) || defined(REAL_DMA_POLL) */
2197                                         NCR5380_transfer_pio(instance, &phase, (int *) &cmd->SCp.this_residual, (unsigned char **)
2198                                                              &cmd->SCp.ptr);
2199                                 break;
2200                         case PHASE_MSGIN:
2201                                 len = 1;
2202                                 data = &tmp;
2203                                 NCR5380_transfer_pio(instance, &phase, &len, &data);
2204                                 cmd->SCp.Message = tmp;
2205
2206                                 switch (tmp) {
2207                                         /*
2208                                          * Linking lets us reduce the time required to get the 
2209                                          * next command out to the device, hopefully this will
2210                                          * mean we don't waste another revolution due to the delays
2211                                          * required by ARBITRATION and another SELECTION.
2212                                          *
2213                                          * In the current implementation proposal, low level drivers
2214                                          * merely have to start the next command, pointed to by 
2215                                          * next_link, done() is called as with unlinked commands.
2216                                          */
2217 #ifdef LINKED
2218                                 case LINKED_CMD_COMPLETE:
2219                                 case LINKED_FLG_CMD_COMPLETE:
2220                                         /* Accept message by clearing ACK */
2221                                         NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
2222                                         dprintk(NDEBUG_LINKED, ("scsi%d : target %d lun %d linked command complete.\n", instance->host_no, cmd->device->id, cmd->device->lun));
2223                                         /* 
2224                                          * Sanity check : A linked command should only terminate with
2225                                          * one of these messages if there are more linked commands
2226                                          * available.
2227                                          */
2228                                         if (!cmd->next_link) {
2229                                                 printk("scsi%d : target %d lun %d linked command complete, no next_link\n" instance->host_no, cmd->device->id, cmd->device->lun);
2230                                                 sink = 1;
2231                                                 do_abort(instance);
2232                                                 return;
2233                                         }
2234                                         initialize_SCp(cmd->next_link);
2235                                         /* The next command is still part of this process */
2236                                         cmd->next_link->tag = cmd->tag;
2237                                         cmd->result = cmd->SCp.Status | (cmd->SCp.Message << 8);
2238                                         dprintk(NDEBUG_LINKED, ("scsi%d : target %d lun %d linked request done, calling scsi_done().\n", instance->host_no, cmd->device->id, cmd->device->lun));
2239                                         collect_stats(hostdata, cmd);
2240                                         cmd->scsi_done(cmd);
2241                                         cmd = hostdata->connected;
2242                                         break;
2243 #endif                          /* def LINKED */
2244                                 case ABORT:
2245                                 case COMMAND_COMPLETE:
2246                                         /* Accept message by clearing ACK */
2247                                         sink = 1;
2248                                         NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
2249                                         hostdata->connected = NULL;
2250                                         dprintk(NDEBUG_QUEUES, ("scsi%d : command for target %d, lun %d completed\n", instance->host_no, cmd->device->id, cmd->device->lun));
2251                                         hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun);
2252
2253                                         /* 
2254                                          * I'm not sure what the correct thing to do here is : 
2255                                          * 
2256                                          * If the command that just executed is NOT a request 
2257                                          * sense, the obvious thing to do is to set the result
2258                                          * code to the values of the stored parameters.
2259                                          * 
2260                                          * If it was a REQUEST SENSE command, we need some way 
2261                                          * to differentiate between the failure code of the original
2262                                          * and the failure code of the REQUEST sense - the obvious
2263                                          * case is success, where we fall through and leave the result
2264                                          * code unchanged.
2265                                          * 
2266                                          * The non-obvious place is where the REQUEST SENSE failed 
2267                                          */
2268
2269                                         if (cmd->cmnd[0] != REQUEST_SENSE)
2270                                                 cmd->result = cmd->SCp.Status | (cmd->SCp.Message << 8);
2271                                         else if (status_byte(cmd->SCp.Status) != GOOD)
2272                                                 cmd->result = (cmd->result & 0x00ffff) | (DID_ERROR << 16);
2273
2274 #ifdef AUTOSENSE
2275                                         if ((cmd->cmnd[0] != REQUEST_SENSE) && (status_byte(cmd->SCp.Status) == CHECK_CONDITION)) {
2276                                                 dprintk(NDEBUG_AUTOSENSE, ("scsi%d : performing request sense\n", instance->host_no));
2277                                                 cmd->cmnd[0] = REQUEST_SENSE;
2278                                                 cmd->cmnd[1] &= 0xe0;
2279                                                 cmd->cmnd[2] = 0;
2280                                                 cmd->cmnd[3] = 0;
2281                                                 cmd->cmnd[4] = sizeof(cmd->sense_buffer);
2282                                                 cmd->cmnd[5] = 0;
2283
2284                                                 cmd->SCp.buffer = NULL;
2285                                                 cmd->SCp.buffers_residual = 0;
2286                                                 cmd->SCp.ptr = (char *) cmd->sense_buffer;
2287                                                 cmd->SCp.this_residual = sizeof(cmd->sense_buffer);
2288
2289                                                 LIST(cmd, hostdata->issue_queue);
2290                                                 cmd->host_scribble = (unsigned char *)
2291                                                     hostdata->issue_queue;
2292                                                 hostdata->issue_queue = (Scsi_Cmnd *) cmd;
2293                                                 dprintk(NDEBUG_QUEUES, ("scsi%d : REQUEST SENSE added to head of issue queue\n", instance->host_no));
2294                                         } else
2295 #endif                          /* def AUTOSENSE */
2296                                         {
2297                                                 collect_stats(hostdata, cmd);
2298                                                 cmd->scsi_done(cmd);
2299                                         }
2300
2301                                         NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
2302                                         /* 
2303                                          * Restore phase bits to 0 so an interrupted selection, 
2304                                          * arbitration can resume.
2305                                          */
2306                                         NCR5380_write(TARGET_COMMAND_REG, 0);
2307
2308                                         while ((NCR5380_read(STATUS_REG) & SR_BSY) && !hostdata->connected)
2309                                                 barrier();
2310                                         return;
2311                                 case MESSAGE_REJECT:
2312                                         /* Accept message by clearing ACK */
2313                                         NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
2314                                         switch (hostdata->last_message) {
2315                                         case HEAD_OF_QUEUE_TAG:
2316                                         case ORDERED_QUEUE_TAG:
2317                                         case SIMPLE_QUEUE_TAG:
2318                                                 cmd->device->simple_tags = 0;
2319                                                 hostdata->busy[cmd->device->id] |= (1 << cmd->device->lun);
2320                                                 break;
2321                                         default:
2322                                                 break;
2323                                         }
2324                                 case DISCONNECT:{
2325                                                 /* Accept message by clearing ACK */
2326                                                 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
2327                                                 cmd->device->disconnect = 1;
2328                                                 LIST(cmd, hostdata->disconnected_queue);
2329                                                 cmd->host_scribble = (unsigned char *)
2330                                                     hostdata->disconnected_queue;
2331                                                 hostdata->connected = NULL;
2332                                                 hostdata->disconnected_queue = cmd;
2333                                                 dprintk(NDEBUG_QUEUES, ("scsi%d : command for target %d lun %d was moved from connected to" "  the disconnected_queue\n", instance->host_no, cmd->device->id, cmd->device->lun));
2334                                                 /* 
2335                                                  * Restore phase bits to 0 so an interrupted selection, 
2336                                                  * arbitration can resume.
2337                                                  */
2338                                                 NCR5380_write(TARGET_COMMAND_REG, 0);
2339
2340                                                 /* Enable reselect interrupts */
2341                                                 NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
2342                                                 /* Wait for bus free to avoid nasty timeouts - FIXME timeout !*/
2343                                                 /* NCR538_poll_politely(instance, STATUS_REG, SR_BSY, 0, 30 * HZ); */
2344                                                 while ((NCR5380_read(STATUS_REG) & SR_BSY) && !hostdata->connected)
2345                                                         barrier();
2346                                                 return;
2347                                         }
2348                                         /* 
2349                                          * The SCSI data pointer is *IMPLICITLY* saved on a disconnect
2350                                          * operation, in violation of the SCSI spec so we can safely 
2351                                          * ignore SAVE/RESTORE pointers calls.
2352                                          *
2353                                          * Unfortunately, some disks violate the SCSI spec and 
2354                                          * don't issue the required SAVE_POINTERS message before
2355                                          * disconnecting, and we have to break spec to remain 
2356                                          * compatible.
2357                                          */
2358                                 case SAVE_POINTERS:
2359                                 case RESTORE_POINTERS:
2360                                         /* Accept message by clearing ACK */
2361                                         NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
2362                                         break;
2363                                 case EXTENDED_MESSAGE:
2364 /* 
2365  * Extended messages are sent in the following format :
2366  * Byte         
2367  * 0            EXTENDED_MESSAGE == 1
2368  * 1            length (includes one byte for code, doesn't 
2369  *              include first two bytes)
2370  * 2            code
2371  * 3..length+1  arguments
2372  *
2373  * Start the extended message buffer with the EXTENDED_MESSAGE
2374  * byte, since print_msg() wants the whole thing.  
2375  */
2376                                         extended_msg[0] = EXTENDED_MESSAGE;
2377                                         /* Accept first byte by clearing ACK */
2378                                         NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
2379                                         dprintk(NDEBUG_EXTENDED, ("scsi%d : receiving extended message\n", instance->host_no));
2380
2381                                         len = 2;
2382                                         data = extended_msg + 1;
2383                                         phase = PHASE_MSGIN;
2384                                         NCR5380_transfer_pio(instance, &phase, &len, &data);
2385
2386                                         dprintk(NDEBUG_EXTENDED, ("scsi%d : length=%d, code=0x%02x\n", instance->host_no, (int) extended_msg[1], (int) extended_msg[2]));
2387
2388                                         if (!len && extended_msg[1] <= (sizeof(extended_msg) - 1)) {
2389                                                 /* Accept third byte by clearing ACK */
2390                                                 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
2391                                                 len = extended_msg[1] - 1;
2392                                                 data = extended_msg + 3;
2393                                                 phase = PHASE_MSGIN;
2394
2395                                                 NCR5380_transfer_pio(instance, &phase, &len, &data);
2396                                                 dprintk(NDEBUG_EXTENDED, ("scsi%d : message received, residual %d\n", instance->host_no, len));
2397
2398                                                 switch (extended_msg[2]) {
2399                                                 case EXTENDED_SDTR:
2400                                                 case EXTENDED_WDTR:
2401                                                 case EXTENDED_MODIFY_DATA_POINTER:
2402                                                 case EXTENDED_EXTENDED_IDENTIFY:
2403                                                         tmp = 0;
2404                                                 }
2405                                         } else if (len) {
2406                                                 printk("scsi%d: error receiving extended message\n", instance->host_no);
2407                                                 tmp = 0;
2408                                         } else {
2409                                                 printk("scsi%d: extended message code %02x length %d is too long\n", instance->host_no, extended_msg[2], extended_msg[1]);
2410                                                 tmp = 0;
2411                                         }
2412                                         /* Fall through to reject message */
2413
2414                                         /* 
2415                                          * If we get something weird that we aren't expecting, 
2416                                          * reject it.
2417                                          */
2418                                 default:
2419                                         if (!tmp) {
2420                                                 printk("scsi%d: rejecting message ", instance->host_no);
2421                                                 print_msg(extended_msg);
2422                                                 printk("\n");
2423                                         } else if (tmp != EXTENDED_MESSAGE)
2424                                                 printk("scsi%d: rejecting unknown message %02x from target %d, lun %d\n", instance->host_no, tmp, cmd->device->id, cmd->device->lun);
2425                                         else
2426                                                 printk("scsi%d: rejecting unknown extended message code %02x, length %d from target %d, lun %d\n", instance->host_no, extended_msg[1], extended_msg[0], cmd->device->id, cmd->device->lun);
2427
2428                                         msgout = MESSAGE_REJECT;
2429                                         NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN);
2430                                         break;
2431                                 }       /* switch (tmp) */
2432                                 break;
2433                         case PHASE_MSGOUT:
2434                                 len = 1;
2435                                 data = &msgout;
2436                                 hostdata->last_message = msgout;
2437                                 NCR5380_transfer_pio(instance, &phase, &len, &data);
2438                                 if (msgout == ABORT) {
2439                                         hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun);
2440                                         hostdata->connected = NULL;
2441                                         cmd->result = DID_ERROR << 16;
2442                                         collect_stats(hostdata, cmd);
2443                                         cmd->scsi_done(cmd);
2444                                         NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
2445                                         return;
2446                                 }
2447                                 msgout = NOP;
2448                                 break;
2449                         case PHASE_CMDOUT:
2450                                 len = cmd->cmd_len;
2451                                 data = cmd->cmnd;
2452                                 /* 
2453                                  * XXX for performance reasons, on machines with a 
2454                                  * PSEUDO-DMA architecture we should probably 
2455                                  * use the dma transfer function.  
2456                                  */
2457                                 NCR5380_transfer_pio(instance, &phase, &len, &data);
2458                                 if (!cmd->device->disconnect && should_disconnect(cmd->cmnd[0])) {
2459                                         NCR5380_set_timer(hostdata, USLEEP_SLEEP);
2460                                         dprintk(NDEBUG_USLEEP, ("scsi%d : issued command, sleeping until %ul\n", instance->host_no, hostdata->time_expires));
2461                                         return;
2462                                 }
2463                                 break;
2464                         case PHASE_STATIN:
2465                                 len = 1;
2466                                 data = &tmp;
2467                                 NCR5380_transfer_pio(instance, &phase, &len, &data);
2468                                 cmd->SCp.Status = tmp;
2469                                 break;
2470                         default:
2471                                 printk("scsi%d : unknown phase\n", instance->host_no);
2472                                 NCR5380_dprint(NDEBUG_ALL, instance);
2473                         }       /* switch(phase) */
2474                 }               /* if (tmp * SR_REQ) */
2475                 else {
2476                         /* RvC: go to sleep if polling time expired
2477                          */
2478                         if (!cmd->device->disconnect && time_after_eq(jiffies, poll_time)) {
2479                                 NCR5380_set_timer(hostdata, USLEEP_SLEEP);
2480                                 dprintk(NDEBUG_USLEEP, ("scsi%d : poll timed out, sleeping until %ul\n", instance->host_no, hostdata->time_expires));
2481                                 return;
2482                         }
2483                 }
2484         }                       /* while (1) */
2485 }
2486
2487 /*
2488  * Function : void NCR5380_reselect (struct Scsi_Host *instance)
2489  *
2490  * Purpose : does reselection, initializing the instance->connected 
2491  *      field to point to the Scsi_Cmnd for which the I_T_L or I_T_L_Q 
2492  *      nexus has been reestablished,
2493  *      
2494  * Inputs : instance - this instance of the NCR5380.
2495  *
2496  * Locks: io_request_lock held by caller if IRQ driven
2497  */
2498
2499 static void NCR5380_reselect(struct Scsi_Host *instance) {
2500         NCR5380_local_declare();
2501         struct NCR5380_hostdata *hostdata = (struct NCR5380_hostdata *)
2502          instance->hostdata;
2503         unsigned char target_mask;
2504         unsigned char lun, phase;
2505         int len;
2506         unsigned char msg[3];
2507         unsigned char *data;
2508         Scsi_Cmnd *tmp = NULL, *prev;
2509         int abort = 0;
2510         NCR5380_setup(instance);
2511
2512         /*
2513          * Disable arbitration, etc. since the host adapter obviously
2514          * lost, and tell an interrupted NCR5380_select() to restart.
2515          */
2516
2517         NCR5380_write(MODE_REG, MR_BASE);
2518         hostdata->restart_select = 1;
2519
2520         target_mask = NCR5380_read(CURRENT_SCSI_DATA_REG) & ~(hostdata->id_mask);
2521         dprintk(NDEBUG_SELECTION, ("scsi%d : reselect\n", instance->host_no));
2522
2523         /* 
2524          * At this point, we have detected that our SCSI ID is on the bus,
2525          * SEL is true and BSY was false for at least one bus settle delay
2526          * (400 ns).
2527          *
2528          * We must assert BSY ourselves, until the target drops the SEL
2529          * signal.
2530          */
2531
2532         NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_BSY);
2533
2534         /* FIXME: timeout too long, must fail to workqueue */   
2535         if(NCR5380_poll_politely(instance, STATUS_REG, SR_SEL, 0, 2*HZ)<0)
2536                 abort = 1;
2537                 
2538         NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
2539
2540         /*
2541          * Wait for target to go into MSGIN.
2542          * FIXME: timeout needed and fail to work queeu
2543          */
2544
2545         if(NCR5380_poll_politely(instance, STATUS_REG, SR_REQ, SR_REQ, 2*HZ))
2546                 abort = 1;
2547
2548         len = 1;
2549         data = msg;
2550         phase = PHASE_MSGIN;
2551         NCR5380_transfer_pio(instance, &phase, &len, &data);
2552
2553         if (!(msg[0] & 0x80)) {
2554                 printk(KERN_ERR "scsi%d : expecting IDENTIFY message, got ", instance->host_no);
2555                 print_msg(msg);
2556                 abort = 1;
2557         } else {
2558                 /* Accept message by clearing ACK */
2559                 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
2560                 lun = (msg[0] & 0x07);
2561
2562                 /* 
2563                  * We need to add code for SCSI-II to track which devices have
2564                  * I_T_L_Q nexuses established, and which have simple I_T_L
2565                  * nexuses so we can chose to do additional data transfer.
2566                  */
2567
2568                 /* 
2569                  * Find the command corresponding to the I_T_L or I_T_L_Q  nexus we 
2570                  * just reestablished, and remove it from the disconnected queue.
2571                  */
2572
2573
2574                 for (tmp = (Scsi_Cmnd *) hostdata->disconnected_queue, prev = NULL; tmp; prev = tmp, tmp = (Scsi_Cmnd *) tmp->host_scribble)
2575                         if ((target_mask == (1 << tmp->device->id)) && (lun == tmp->device->lun)
2576                             ) {
2577                                 if (prev) {
2578                                         REMOVE(prev, prev->host_scribble, tmp, tmp->host_scribble);
2579                                         prev->host_scribble = tmp->host_scribble;
2580                                 } else {
2581                                         REMOVE(-1, hostdata->disconnected_queue, tmp, tmp->host_scribble);
2582                                         hostdata->disconnected_queue = (Scsi_Cmnd *) tmp->host_scribble;
2583                                 }
2584                                 tmp->host_scribble = NULL;
2585                                 break;
2586                         }
2587                 if (!tmp) {
2588                         printk(KERN_ERR "scsi%d : warning : target bitmask %02x lun %d not in disconnect_queue.\n", instance->host_no, target_mask, lun);
2589                         /* 
2590                          * Since we have an established nexus that we can't do anything with,
2591                          * we must abort it.  
2592                          */
2593                         abort = 1;
2594                 }
2595         }
2596
2597         if (abort) {
2598                 do_abort(instance);
2599         } else {
2600                 hostdata->connected = tmp;
2601                 dprintk(NDEBUG_RESELECTION, ("scsi%d : nexus established, target = %d, lun = %d, tag = %d\n", instance->host_no, tmp->target, tmp->lun, tmp->tag));
2602         }
2603 }
2604
2605 /*
2606  * Function : void NCR5380_dma_complete (struct Scsi_Host *instance)
2607  *
2608  * Purpose : called by interrupt handler when DMA finishes or a phase
2609  *      mismatch occurs (which would finish the DMA transfer).  
2610  *
2611  * Inputs : instance - this instance of the NCR5380.
2612  *
2613  * Returns : pointer to the Scsi_Cmnd structure for which the I_T_L
2614  *      nexus has been reestablished, on failure NULL is returned.
2615  */
2616
2617 #ifdef REAL_DMA
2618 static void NCR5380_dma_complete(NCR5380_instance * instance) {
2619         NCR5380_local_declare();
2620         struct NCR5380_hostdata *hostdata = (struct NCR5380_hostdata * instance->hostdata);
2621         int transferred;
2622         NCR5380_setup(instance);
2623
2624         /*
2625          * XXX this might not be right.
2626          *
2627          * Wait for final byte to transfer, ie wait for ACK to go false.
2628          *
2629          * We should use the Last Byte Sent bit, unfortunately this is 
2630          * not available on the 5380/5381 (only the various CMOS chips)
2631          *
2632          * FIXME: timeout, and need to handle long timeout/irq case
2633          */
2634
2635         NCR5380_poll_politely(instance, BUS_AND_STATUS_REG, BASR_ACK, 0, 5*HZ);
2636
2637         NCR5380_write(MODE_REG, MR_BASE);
2638         NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
2639
2640         /*
2641          * The only places we should see a phase mismatch and have to send
2642          * data from the same set of pointers will be the data transfer
2643          * phases.  So, residual, requested length are only important here.
2644          */
2645
2646         if (!(hostdata->connected->SCp.phase & SR_CD)) {
2647                 transferred = instance->dmalen - NCR5380_dma_residual();
2648                 hostdata->connected->SCp.this_residual -= transferred;
2649                 hostdata->connected->SCp.ptr += transferred;
2650         }
2651 }
2652 #endif                          /* def REAL_DMA */
2653
2654 /*
2655  * Function : int NCR5380_abort (Scsi_Cmnd *cmd)
2656  *
2657  * Purpose : abort a command
2658  *
2659  * Inputs : cmd - the Scsi_Cmnd to abort, code - code to set the 
2660  *      host byte of the result field to, if zero DID_ABORTED is 
2661  *      used.
2662  *
2663  * Returns : 0 - success, -1 on failure.
2664  *
2665  *      XXX - there is no way to abort the command that is currently 
2666  *      connected, you have to wait for it to complete.  If this is 
2667  *      a problem, we could implement longjmp() / setjmp(), setjmp()
2668  *      called where the loop started in NCR5380_main().
2669  *
2670  * Locks: host lock taken by caller
2671  */
2672
2673 static int NCR5380_abort(Scsi_Cmnd * cmd) {
2674         NCR5380_local_declare();
2675         struct Scsi_Host *instance = cmd->device->host;
2676         struct NCR5380_hostdata *hostdata = (struct NCR5380_hostdata *) instance->hostdata;
2677         Scsi_Cmnd *tmp, **prev;
2678         
2679         printk(KERN_WARNING "scsi%d : aborting command\n", instance->host_no);
2680         print_Scsi_Cmnd(cmd);
2681
2682         NCR5380_print_status(instance);
2683
2684         NCR5380_setup(instance);
2685
2686         dprintk(NDEBUG_ABORT, ("scsi%d : abort called\n", instance->host_no));
2687         dprintk(NDEBUG_ABORT, ("        basr 0x%X, sr 0x%X\n", NCR5380_read(BUS_AND_STATUS_REG), NCR5380_read(STATUS_REG)));
2688
2689 #if 0
2690 /*
2691  * Case 1 : If the command is the currently executing command, 
2692  * we'll set the aborted flag and return control so that 
2693  * information transfer routine can exit cleanly.
2694  */
2695
2696         if (hostdata->connected == cmd) {
2697                 dprintk(NDEBUG_ABORT, ("scsi%d : aborting connected command\n", instance->host_no));
2698                 hostdata->aborted = 1;
2699 /*
2700  * We should perform BSY checking, and make sure we haven't slipped
2701  * into BUS FREE.
2702  */
2703
2704                 NCR5380_write(INITIATOR_COMMAND_REG, ICR_ASSERT_ATN);
2705 /* 
2706  * Since we can't change phases until we've completed the current 
2707  * handshake, we have to source or sink a byte of data if the current
2708  * phase is not MSGOUT.
2709  */
2710
2711 /* 
2712  * Return control to the executing NCR drive so we can clear the
2713  * aborted flag and get back into our main loop.
2714  */
2715
2716                 return 0;
2717         }
2718 #endif
2719
2720 /* 
2721  * Case 2 : If the command hasn't been issued yet, we simply remove it 
2722  *          from the issue queue.
2723  */
2724  
2725         dprintk(NDEBUG_ABORT, ("scsi%d : abort going into loop.\n", instance->host_no));
2726         for (prev = (Scsi_Cmnd **) & (hostdata->issue_queue), tmp = (Scsi_Cmnd *) hostdata->issue_queue; tmp; prev = (Scsi_Cmnd **) & (tmp->host_scribble), tmp = (Scsi_Cmnd *) tmp->host_scribble)
2727                 if (cmd == tmp) {
2728                         REMOVE(5, *prev, tmp, tmp->host_scribble);
2729                         (*prev) = (Scsi_Cmnd *) tmp->host_scribble;
2730                         tmp->host_scribble = NULL;
2731                         tmp->result = DID_ABORT << 16;
2732                         dprintk(NDEBUG_ABORT, ("scsi%d : abort removed command from issue queue.\n", instance->host_no));
2733                         tmp->done(tmp);
2734                         return SUCCESS;
2735                 }
2736 #if (NDEBUG  & NDEBUG_ABORT)
2737         /* KLL */
2738                 else if (prev == tmp)
2739                         printk(KERN_ERR "scsi%d : LOOP\n", instance->host_no);
2740 #endif
2741
2742 /* 
2743  * Case 3 : If any commands are connected, we're going to fail the abort
2744  *          and let the high level SCSI driver retry at a later time or 
2745  *          issue a reset.
2746  *
2747  *          Timeouts, and therefore aborted commands, will be highly unlikely
2748  *          and handling them cleanly in this situation would make the common
2749  *          case of noresets less efficient, and would pollute our code.  So,
2750  *          we fail.
2751  */
2752
2753         if (hostdata->connected) {
2754                 dprintk(NDEBUG_ABORT, ("scsi%d : abort failed, command connected.\n", instance->host_no));
2755                 return FAILED;
2756         }
2757 /*
2758  * Case 4: If the command is currently disconnected from the bus, and 
2759  *      there are no connected commands, we reconnect the I_T_L or 
2760  *      I_T_L_Q nexus associated with it, go into message out, and send 
2761  *      an abort message.
2762  *
2763  * This case is especially ugly. In order to reestablish the nexus, we
2764  * need to call NCR5380_select().  The easiest way to implement this 
2765  * function was to abort if the bus was busy, and let the interrupt
2766  * handler triggered on the SEL for reselect take care of lost arbitrations
2767  * where necessary, meaning interrupts need to be enabled.
2768  *
2769  * When interrupts are enabled, the queues may change - so we 
2770  * can't remove it from the disconnected queue before selecting it
2771  * because that could cause a failure in hashing the nexus if that 
2772  * device reselected.
2773  * 
2774  * Since the queues may change, we can't use the pointers from when we
2775  * first locate it.
2776  *
2777  * So, we must first locate the command, and if NCR5380_select()
2778  * succeeds, then issue the abort, relocate the command and remove
2779  * it from the disconnected queue.
2780  */
2781
2782         for (tmp = (Scsi_Cmnd *) hostdata->disconnected_queue; tmp; tmp = (Scsi_Cmnd *) tmp->host_scribble)
2783                 if (cmd == tmp) {
2784                         dprintk(NDEBUG_ABORT, ("scsi%d : aborting disconnected command.\n", instance->host_no));
2785
2786                         if (NCR5380_select(instance, cmd, (int) cmd->tag))
2787                                 return FAILED;
2788                         dprintk(NDEBUG_ABORT, ("scsi%d : nexus reestablished.\n", instance->host_no));
2789
2790                         do_abort(instance);
2791
2792                         for (prev = (Scsi_Cmnd **) & (hostdata->disconnected_queue), tmp = (Scsi_Cmnd *) hostdata->disconnected_queue; tmp; prev = (Scsi_Cmnd **) & (tmp->host_scribble), tmp = (Scsi_Cmnd *) tmp->host_scribble)
2793                                 if (cmd == tmp) {
2794                                         REMOVE(5, *prev, tmp, tmp->host_scribble);
2795                                         *prev = (Scsi_Cmnd *) tmp->host_scribble;
2796                                         tmp->host_scribble = NULL;
2797                                         tmp->result = DID_ABORT << 16;
2798                                         tmp->done(tmp);
2799                                         return SUCCESS;
2800                                 }
2801                 }
2802 /*
2803  * Case 5 : If we reached this point, the command was not found in any of 
2804  *          the queues.
2805  *
2806  * We probably reached this point because of an unlikely race condition
2807  * between the command completing successfully and the abortion code,
2808  * so we won't panic, but we will notify the user in case something really
2809  * broke.
2810  */
2811         printk(KERN_WARNING "scsi%d : warning : SCSI command probably completed successfully\n"
2812                         "         before abortion\n", instance->host_no);
2813         return FAILED;
2814 }
2815
2816
2817 /* 
2818  * Function : int NCR5380_bus_reset (Scsi_Cmnd *cmd)
2819  * 
2820  * Purpose : reset the SCSI bus.
2821  *
2822  * Returns : SUCCESS
2823  *
2824  * Locks: host lock taken by caller
2825  */
2826
2827 static int NCR5380_bus_reset(Scsi_Cmnd * cmd) {
2828         NCR5380_local_declare();
2829         NCR5380_setup(cmd->device->host);
2830
2831         NCR5380_print_status(cmd->device->host);
2832         do_reset(cmd->device->host);
2833         return SUCCESS;
2834 }
2835
2836 /* 
2837  * Function : int NCR5380_device_reset (Scsi_Cmnd *cmd)
2838  * 
2839  * Purpose : reset a SCSI device
2840  *
2841  * Returns : FAILED
2842  *
2843  * Locks: io_request_lock held by caller
2844  */
2845
2846 static int NCR5380_device_reset(Scsi_Cmnd * cmd) {
2847         return FAILED;
2848 }
2849
2850 /* 
2851  * Function : int NCR5380_host_reset (Scsi_Cmnd *cmd)
2852  * 
2853  * Purpose : reset a SCSI device
2854  *
2855  * Returns : FAILED
2856  *
2857  * Locks: io_request_lock held by caller
2858  */
2859
2860 static int NCR5380_host_reset(Scsi_Cmnd * cmd) {
2861         return FAILED;
2862 }