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