Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
atari_NCR5380.c
Go to the documentation of this file.
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)
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  * ++roman: To port the 5380 driver to the Atari, I had to do some changes in
31  * this file, too:
32  *
33  * - Some of the debug statements were incorrect (undefined variables and the
34  * like). I fixed that.
35  *
36  * - In information_transfer(), I think a #ifdef was wrong. Looking at the
37  * possible DMA transfer size should also happen for REAL_DMA. I added this
38  * in the #if statement.
39  *
40  * - When using real DMA, information_transfer() should return in a DATAOUT
41  * phase after starting the DMA. It has nothing more to do.
42  *
43  * - The interrupt service routine should run main after end of DMA, too (not
44  * only after RESELECTION interrupts). Additionally, it should _not_ test
45  * for more interrupts after running main, since a DMA process may have
46  * been started and interrupts are turned on now. The new int could happen
47  * inside the execution of NCR5380_intr(), leading to recursive
48  * calls.
49  *
50  * - I've added a function merge_contiguous_buffers() that tries to
51  * merge scatter-gather buffers that are located at contiguous
52  * physical addresses and can be processed with the same DMA setup.
53  * Since most scatter-gather operations work on a page (4K) of
54  * 4 buffers (1K), in more than 90% of all cases three interrupts and
55  * DMA setup actions are saved.
56  *
57  * - I've deleted all the stuff for AUTOPROBE_IRQ, REAL_DMA_POLL, PSEUDO_DMA
58  * and USLEEP, because these were messing up readability and will never be
59  * needed for Atari SCSI.
60  *
61  * - I've revised the NCR5380_main() calling scheme (relax the 'main_running'
62  * stuff), and 'main' is executed in a bottom half if awoken by an
63  * interrupt.
64  *
65  * - The code was quite cluttered up by "#if (NDEBUG & NDEBUG_*) printk..."
66  * constructs. In my eyes, this made the source rather unreadable, so I
67  * finally replaced that by the *_PRINTK() macros.
68  *
69  */
70 
71 /*
72  * Further development / testing that should be done :
73  * 1. Test linked command handling code after Eric is ready with
74  * the high level code.
75  */
76 #include <scsi/scsi_dbg.h>
78 
79 #if (NDEBUG & NDEBUG_LISTS)
80 #define LIST(x, y) \
81  do { \
82  printk("LINE:%d Adding %p to %p\n", \
83  __LINE__, (void*)(x), (void*)(y)); \
84  if ((x) == (y)) \
85  udelay(5); \
86  } while (0)
87 #define REMOVE(w, x, y, z) \
88  do { \
89  printk("LINE:%d Removing: %p->%p %p->%p \n", \
90  __LINE__, (void*)(w), (void*)(x), \
91  (void*)(y), (void*)(z)); \
92  if ((x) == (y)) \
93  udelay(5); \
94  } while (0)
95 #else
96 #define LIST(x,y)
97 #define REMOVE(w,x,y,z)
98 #endif
99 
100 #ifndef notyet
101 #undef LINKED
102 #endif
103 
104 /*
105  * Design
106  * Issues :
107  *
108  * The other Linux SCSI drivers were written when Linux was Intel PC-only,
109  * and specifically for each board rather than each chip. This makes their
110  * adaptation to platforms like the Mac (Some of which use NCR5380's)
111  * more difficult than it has to be.
112  *
113  * Also, many of the SCSI drivers were written before the command queuing
114  * routines were implemented, meaning their implementations of queued
115  * commands were hacked on rather than designed in from the start.
116  *
117  * When I designed the Linux SCSI drivers I figured that
118  * while having two different SCSI boards in a system might be useful
119  * for debugging things, two of the same type wouldn't be used.
120  * Well, I was wrong and a number of users have mailed me about running
121  * multiple high-performance SCSI boards in a server.
122  *
123  * Finally, when I get questions from users, I have no idea what
124  * revision of my driver they are running.
125  *
126  * This driver attempts to address these problems :
127  * This is a generic 5380 driver. To use it on a different platform,
128  * one simply writes appropriate system specific macros (ie, data
129  * transfer - some PC's will use the I/O bus, 68K's must use
130  * memory mapped) and drops this file in their 'C' wrapper.
131  *
132  * As far as command queueing, two queues are maintained for
133  * each 5380 in the system - commands that haven't been issued yet,
134  * and commands that are currently executing. This means that an
135  * unlimited number of commands may be queued, letting
136  * more commands propagate from the higher driver levels giving higher
137  * throughput. Note that both I_T_L and I_T_L_Q nexuses are supported,
138  * allowing multiple commands to propagate all the way to a SCSI-II device
139  * while a command is already executing.
140  *
141  * To solve the multiple-boards-in-the-same-system problem,
142  * there is a separate instance structure for each instance
143  * of a 5380 in the system. So, multiple NCR5380 drivers will
144  * be able to coexist with appropriate changes to the high level
145  * SCSI code.
146  *
147  * A NCR5380_PUBLIC_REVISION macro is provided, with the release
148  * number (updated for each public release) printed by the
149  * NCR5380_print_options command, which should be called from the
150  * wrapper detect function, so that I know what release of the driver
151  * users are using.
152  *
153  * Issues specific to the NCR5380 :
154  *
155  * When used in a PIO or pseudo-dma mode, the NCR5380 is a braindead
156  * piece of hardware that requires you to sit in a loop polling for
157  * the REQ signal as long as you are connected. Some devices are
158  * brain dead (ie, many TEXEL CD ROM drives) and won't disconnect
159  * while doing long seek operations.
160  *
161  * The workaround for this is to keep track of devices that have
162  * disconnected. If the device hasn't disconnected, for commands that
163  * should disconnect, we do something like
164  *
165  * while (!REQ is asserted) { sleep for N usecs; poll for M usecs }
166  *
167  * Some tweaking of N and M needs to be done. An algorithm based
168  * on "time to data" would give the best results as long as short time
169  * to datas (ie, on the same track) were considered, however these
170  * broken devices are the exception rather than the rule and I'd rather
171  * spend my time optimizing for the normal case.
172  *
173  * Architecture :
174  *
175  * At the heart of the design is a coroutine, NCR5380_main,
176  * which is started when not running by the interrupt handler,
177  * timer, and queue command function. It attempts to establish
178  * I_T_L or I_T_L_Q nexuses by removing the commands from the
179  * issue queue and calling NCR5380_select() if a nexus
180  * is not established.
181  *
182  * Once a nexus is established, the NCR5380_information_transfer()
183  * phase goes through the various phases as instructed by the target.
184  * if the target goes into MSG IN and sends a DISCONNECT message,
185  * the command structure is placed into the per instance disconnected
186  * queue, and NCR5380_main tries to find more work. If USLEEP
187  * was defined, and the target is idle for too long, the system
188  * will try to sleep.
189  *
190  * If a command has disconnected, eventually an interrupt will trigger,
191  * calling NCR5380_intr() which will in turn call NCR5380_reselect
192  * to reestablish a nexus. This will run main if necessary.
193  *
194  * On command termination, the done function will be called as
195  * appropriate.
196  *
197  * SCSI pointers are maintained in the SCp field of SCSI command
198  * structures, being initialized after the command is connected
199  * in NCR5380_select, and set as appropriate in NCR5380_information_transfer.
200  * Note that in violation of the standard, an implicit SAVE POINTERS operation
201  * is done, since some BROKEN disks fail to issue an explicit SAVE POINTERS.
202  */
203 
204 /*
205  * Using this file :
206  * This file a skeleton Linux SCSI driver for the NCR 5380 series
207  * of chips. To use it, you write an architecture specific functions
208  * and macros and include this file in your driver.
209  *
210  * These macros control options :
211  * AUTOSENSE - if defined, REQUEST SENSE will be performed automatically
212  * for commands that return with a CHECK CONDITION status.
213  *
214  * LINKED - if defined, linked commands are supported.
215  *
216  * REAL_DMA - if defined, REAL DMA is used during the data transfer phases.
217  *
218  * SUPPORT_TAGS - if defined, SCSI-2 tagged queuing is used where possible
219  *
220  * These macros MUST be defined :
221  *
222  * NCR5380_read(register) - read from the specified register
223  *
224  * NCR5380_write(register, value) - write to the specific register
225  *
226  * Either real DMA *or* pseudo DMA may be implemented
227  * REAL functions :
228  * NCR5380_REAL_DMA should be defined if real DMA is to be used.
229  * Note that the DMA setup functions should return the number of bytes
230  * that they were able to program the controller for.
231  *
232  * Also note that generic i386/PC versions of these macros are
233  * available as NCR5380_i386_dma_write_setup,
234  * NCR5380_i386_dma_read_setup, and NCR5380_i386_dma_residual.
235  *
236  * NCR5380_dma_write_setup(instance, src, count) - initialize
237  * NCR5380_dma_read_setup(instance, dst, count) - initialize
238  * NCR5380_dma_residual(instance); - residual count
239  *
240  * PSEUDO functions :
241  * NCR5380_pwrite(instance, src, count)
242  * NCR5380_pread(instance, dst, count);
243  *
244  * If nothing specific to this implementation needs doing (ie, with external
245  * hardware), you must also define
246  *
247  * NCR5380_queue_command
248  * NCR5380_reset
249  * NCR5380_abort
250  * NCR5380_proc_info
251  *
252  * to be the global entry points into the specific driver, ie
253  * #define NCR5380_queue_command t128_queue_command.
254  *
255  * If this is not done, the routines will be defined as static functions
256  * with the NCR5380* names and the user must provide a globally
257  * accessible wrapper function.
258  *
259  * The generic driver is initialized by calling NCR5380_init(instance),
260  * after setting the appropriate host specific fields and ID. If the
261  * driver wishes to autoprobe for an IRQ line, the NCR5380_probe_irq(instance,
262  * possible) function may be used. Before the specific driver initialization
263  * code finishes, NCR5380_print_options should be called.
264  */
265 
266 static struct Scsi_Host *first_instance = NULL;
267 static struct scsi_host_template *the_template = NULL;
268 
269 /* Macros ease life... :-) */
270 #define SETUP_HOSTDATA(in) \
271  struct NCR5380_hostdata *hostdata = \
272  (struct NCR5380_hostdata *)(in)->hostdata
273 #define HOSTDATA(in) ((struct NCR5380_hostdata *)(in)->hostdata)
274 
275 #define NEXT(cmd) ((Scsi_Cmnd *)(cmd)->host_scribble)
276 #define SET_NEXT(cmd,next) ((cmd)->host_scribble = (void *)(next))
277 #define NEXTADDR(cmd) ((Scsi_Cmnd **)&(cmd)->host_scribble)
278 
279 #define HOSTNO instance->host_no
280 #define H_NO(cmd) (cmd)->device->host->host_no
281 
282 #ifdef SUPPORT_TAGS
283 
284 /*
285  * Functions for handling tagged queuing
286  * =====================================
287  *
288  * ++roman (01/96): Now I've implemented SCSI-2 tagged queuing. Some notes:
289  *
290  * Using consecutive numbers for the tags is no good idea in my eyes. There
291  * could be wrong re-usings if the counter (8 bit!) wraps and some early
292  * command has been preempted for a long time. My solution: a bitfield for
293  * remembering used tags.
294  *
295  * There's also the problem that each target has a certain queue size, but we
296  * cannot know it in advance :-( We just see a QUEUE_FULL status being
297  * returned. So, in this case, the driver internal queue size assumption is
298  * reduced to the number of active tags if QUEUE_FULL is returned by the
299  * target. The command is returned to the mid-level, but with status changed
300  * to BUSY, since --as I've seen-- the mid-level can't handle QUEUE_FULL
301  * correctly.
302  *
303  * We're also not allowed running tagged commands as long as an untagged
304  * command is active. And REQUEST SENSE commands after a contingent allegiance
305  * condition _must_ be untagged. To keep track whether an untagged command has
306  * been issued, the host->busy array is still employed, as it is without
307  * support for tagged queuing.
308  *
309  * One could suspect that there are possible race conditions between
310  * is_lun_busy(), cmd_get_tag() and cmd_free_tag(). But I think this isn't the
311  * case: is_lun_busy() and cmd_get_tag() are both called from NCR5380_main(),
312  * which already guaranteed to be running at most once. It is also the only
313  * place where tags/LUNs are allocated. So no other allocation can slip
314  * between that pair, there could only happen a reselection, which can free a
315  * tag, but that doesn't hurt. Only the sequence in cmd_free_tag() becomes
316  * important: the tag bit must be cleared before 'nr_allocated' is decreased.
317  */
318 
319 /* -1 for TAG_NONE is not possible with unsigned char cmd->tag */
320 #undef TAG_NONE
321 #define TAG_NONE 0xff
322 
323 typedef struct {
324  DECLARE_BITMAP(allocated, MAX_TAGS);
325  int nr_allocated;
326  int queue_size;
327 } TAG_ALLOC;
328 
329 static TAG_ALLOC TagAlloc[8][8]; /* 8 targets and 8 LUNs */
330 
331 
332 static void __init init_tags(void)
333 {
334  int target, lun;
335  TAG_ALLOC *ta;
336 
337  if (!setup_use_tagged_queuing)
338  return;
339 
340  for (target = 0; target < 8; ++target) {
341  for (lun = 0; lun < 8; ++lun) {
342  ta = &TagAlloc[target][lun];
343  bitmap_zero(ta->allocated, MAX_TAGS);
344  ta->nr_allocated = 0;
345  /* At the beginning, assume the maximum queue size we could
346  * support (MAX_TAGS). This value will be decreased if the target
347  * returns QUEUE_FULL status.
348  */
349  ta->queue_size = MAX_TAGS;
350  }
351  }
352 }
353 
354 
355 /* Check if we can issue a command to this LUN: First see if the LUN is marked
356  * busy by an untagged command. If the command should use tagged queuing, also
357  * check that there is a free tag and the target's queue won't overflow. This
358  * function should be called with interrupts disabled to avoid race
359  * conditions.
360  */
361 
362 static int is_lun_busy(Scsi_Cmnd *cmd, int should_be_tagged)
363 {
364  SETUP_HOSTDATA(cmd->device->host);
365 
366  if (hostdata->busy[cmd->device->id] & (1 << cmd->device->lun))
367  return 1;
368  if (!should_be_tagged ||
369  !setup_use_tagged_queuing || !cmd->device->tagged_supported)
370  return 0;
371  if (TagAlloc[cmd->device->id][cmd->device->lun].nr_allocated >=
372  TagAlloc[cmd->device->id][cmd->device->lun].queue_size) {
373  TAG_PRINTK("scsi%d: target %d lun %d: no free tags\n",
374  H_NO(cmd), cmd->device->id, cmd->device->lun);
375  return 1;
376  }
377  return 0;
378 }
379 
380 
381 /* Allocate a tag for a command (there are no checks anymore, check_lun_busy()
382  * must be called before!), or reserve the LUN in 'busy' if the command is
383  * untagged.
384  */
385 
386 static void cmd_get_tag(Scsi_Cmnd *cmd, int should_be_tagged)
387 {
388  SETUP_HOSTDATA(cmd->device->host);
389 
390  /* If we or the target don't support tagged queuing, allocate the LUN for
391  * an untagged command.
392  */
393  if (!should_be_tagged ||
394  !setup_use_tagged_queuing || !cmd->device->tagged_supported) {
395  cmd->tag = TAG_NONE;
396  hostdata->busy[cmd->device->id] |= (1 << cmd->device->lun);
397  TAG_PRINTK("scsi%d: target %d lun %d now allocated by untagged "
398  "command\n", H_NO(cmd), cmd->device->id, cmd->device->lun);
399  } else {
400  TAG_ALLOC *ta = &TagAlloc[cmd->device->id][cmd->device->lun];
401 
402  cmd->tag = find_first_zero_bit(ta->allocated, MAX_TAGS);
403  set_bit(cmd->tag, ta->allocated);
404  ta->nr_allocated++;
405  TAG_PRINTK("scsi%d: using tag %d for target %d lun %d "
406  "(now %d tags in use)\n",
407  H_NO(cmd), cmd->tag, cmd->device->id,
408  cmd->device->lun, ta->nr_allocated);
409  }
410 }
411 
412 
413 /* Mark the tag of command 'cmd' as free, or in case of an untagged command,
414  * unlock the LUN.
415  */
416 
417 static void cmd_free_tag(Scsi_Cmnd *cmd)
418 {
419  SETUP_HOSTDATA(cmd->device->host);
420 
421  if (cmd->tag == TAG_NONE) {
422  hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun);
423  TAG_PRINTK("scsi%d: target %d lun %d untagged cmd finished\n",
424  H_NO(cmd), cmd->device->id, cmd->device->lun);
425  } else if (cmd->tag >= MAX_TAGS) {
426  printk(KERN_NOTICE "scsi%d: trying to free bad tag %d!\n",
427  H_NO(cmd), cmd->tag);
428  } else {
429  TAG_ALLOC *ta = &TagAlloc[cmd->device->id][cmd->device->lun];
430  clear_bit(cmd->tag, ta->allocated);
431  ta->nr_allocated--;
432  TAG_PRINTK("scsi%d: freed tag %d for target %d lun %d\n",
433  H_NO(cmd), cmd->tag, cmd->device->id, cmd->device->lun);
434  }
435 }
436 
437 
438 static void free_all_tags(void)
439 {
440  int target, lun;
441  TAG_ALLOC *ta;
442 
443  if (!setup_use_tagged_queuing)
444  return;
445 
446  for (target = 0; target < 8; ++target) {
447  for (lun = 0; lun < 8; ++lun) {
448  ta = &TagAlloc[target][lun];
449  bitmap_zero(ta->allocated, MAX_TAGS);
450  ta->nr_allocated = 0;
451  }
452  }
453 }
454 
455 #endif /* SUPPORT_TAGS */
456 
457 
458 /*
459  * Function: void merge_contiguous_buffers( Scsi_Cmnd *cmd )
460  *
461  * Purpose: Try to merge several scatter-gather requests into one DMA
462  * transfer. This is possible if the scatter buffers lie on
463  * physical contiguous addresses.
464  *
465  * Parameters: Scsi_Cmnd *cmd
466  * The command to work on. The first scatter buffer's data are
467  * assumed to be already transferred into ptr/this_residual.
468  */
469 
470 static void merge_contiguous_buffers(Scsi_Cmnd *cmd)
471 {
472  unsigned long endaddr;
473 #if (NDEBUG & NDEBUG_MERGING)
474  unsigned long oldlen = cmd->SCp.this_residual;
475  int cnt = 1;
476 #endif
477 
478  for (endaddr = virt_to_phys(cmd->SCp.ptr + cmd->SCp.this_residual - 1) + 1;
479  cmd->SCp.buffers_residual &&
480  virt_to_phys(sg_virt(&cmd->SCp.buffer[1])) == endaddr;) {
481  MER_PRINTK("VTOP(%p) == %08lx -> merging\n",
482  page_address(sg_page(&cmd->SCp.buffer[1])), endaddr);
483 #if (NDEBUG & NDEBUG_MERGING)
484  ++cnt;
485 #endif
486  ++cmd->SCp.buffer;
487  --cmd->SCp.buffers_residual;
488  cmd->SCp.this_residual += cmd->SCp.buffer->length;
489  endaddr += cmd->SCp.buffer->length;
490  }
491 #if (NDEBUG & NDEBUG_MERGING)
492  if (oldlen != cmd->SCp.this_residual)
493  MER_PRINTK("merged %d buffers from %p, new length %08x\n",
494  cnt, cmd->SCp.ptr, cmd->SCp.this_residual);
495 #endif
496 }
497 
498 /*
499  * Function : void initialize_SCp(Scsi_Cmnd *cmd)
500  *
501  * Purpose : initialize the saved data pointers for cmd to point to the
502  * start of the buffer.
503  *
504  * Inputs : cmd - Scsi_Cmnd structure to have pointers reset.
505  */
506 
507 static inline void initialize_SCp(Scsi_Cmnd *cmd)
508 {
509  /*
510  * Initialize the Scsi Pointer field so that all of the commands in the
511  * various queues are valid.
512  */
513 
514  if (scsi_bufflen(cmd)) {
515  cmd->SCp.buffer = scsi_sglist(cmd);
516  cmd->SCp.buffers_residual = scsi_sg_count(cmd) - 1;
517  cmd->SCp.ptr = sg_virt(cmd->SCp.buffer);
518  cmd->SCp.this_residual = cmd->SCp.buffer->length;
519  /* ++roman: Try to merge some scatter-buffers if they are at
520  * contiguous physical addresses.
521  */
522  merge_contiguous_buffers(cmd);
523  } else {
524  cmd->SCp.buffer = NULL;
525  cmd->SCp.buffers_residual = 0;
526  cmd->SCp.ptr = NULL;
527  cmd->SCp.this_residual = 0;
528  }
529 }
530 
531 #include <linux/delay.h>
532 
533 #if NDEBUG
534 static struct {
535  unsigned char mask;
536  const char *name;
537 } signals[] = {
538  { SR_DBP, "PARITY"}, { SR_RST, "RST" }, { SR_BSY, "BSY" },
539  { SR_REQ, "REQ" }, { SR_MSG, "MSG" }, { SR_CD, "CD" }, { SR_IO, "IO" },
540  { SR_SEL, "SEL" }, {0, NULL}
541 }, basrs[] = {
542  {BASR_ATN, "ATN"}, {BASR_ACK, "ACK"}, {0, NULL}
543 }, icrs[] = {
544  {ICR_ASSERT_RST, "ASSERT RST"},{ICR_ASSERT_ACK, "ASSERT ACK"},
545  {ICR_ASSERT_BSY, "ASSERT BSY"}, {ICR_ASSERT_SEL, "ASSERT SEL"},
546  {ICR_ASSERT_ATN, "ASSERT ATN"}, {ICR_ASSERT_DATA, "ASSERT DATA"},
547  {0, NULL}
548 }, mrs[] = {
549  {MR_BLOCK_DMA_MODE, "MODE BLOCK DMA"}, {MR_TARGET, "MODE TARGET"},
550  {MR_ENABLE_PAR_CHECK, "MODE PARITY CHECK"}, {MR_ENABLE_PAR_INTR,
551  "MODE PARITY INTR"}, {MR_ENABLE_EOP_INTR,"MODE EOP INTR"},
552  {MR_MONITOR_BSY, "MODE MONITOR BSY"},
553  {MR_DMA_MODE, "MODE DMA"}, {MR_ARBITRATE, "MODE ARBITRATION"},
554  {0, NULL}
555 };
556 
557 /*
558  * Function : void NCR5380_print(struct Scsi_Host *instance)
559  *
560  * Purpose : print the SCSI bus signals for debugging purposes
561  *
562  * Input : instance - which NCR5380
563  */
564 
565 static void NCR5380_print(struct Scsi_Host *instance)
566 {
567  unsigned char status, data, basr, mr, icr, i;
568  unsigned long flags;
569 
570  local_irq_save(flags);
572  status = NCR5380_read(STATUS_REG);
573  mr = NCR5380_read(MODE_REG);
576  local_irq_restore(flags);
577  printk("STATUS_REG: %02x ", status);
578  for (i = 0; signals[i].mask; ++i)
579  if (status & signals[i].mask)
580  printk(",%s", signals[i].name);
581  printk("\nBASR: %02x ", basr);
582  for (i = 0; basrs[i].mask; ++i)
583  if (basr & basrs[i].mask)
584  printk(",%s", basrs[i].name);
585  printk("\nICR: %02x ", icr);
586  for (i = 0; icrs[i].mask; ++i)
587  if (icr & icrs[i].mask)
588  printk(",%s", icrs[i].name);
589  printk("\nMODE: %02x ", mr);
590  for (i = 0; mrs[i].mask; ++i)
591  if (mr & mrs[i].mask)
592  printk(",%s", mrs[i].name);
593  printk("\n");
594 }
595 
596 static struct {
597  unsigned char value;
598  const char *name;
599 } phases[] = {
600  {PHASE_DATAOUT, "DATAOUT"}, {PHASE_DATAIN, "DATAIN"}, {PHASE_CMDOUT, "CMDOUT"},
601  {PHASE_STATIN, "STATIN"}, {PHASE_MSGOUT, "MSGOUT"}, {PHASE_MSGIN, "MSGIN"},
602  {PHASE_UNKNOWN, "UNKNOWN"}
603 };
604 
605 /*
606  * Function : void NCR5380_print_phase(struct Scsi_Host *instance)
607  *
608  * Purpose : print the current SCSI phase for debugging purposes
609  *
610  * Input : instance - which NCR5380
611  */
612 
613 static void NCR5380_print_phase(struct Scsi_Host *instance)
614 {
615  unsigned char status;
616  int i;
617 
618  status = NCR5380_read(STATUS_REG);
619  if (!(status & SR_REQ))
620  printk(KERN_DEBUG "scsi%d: REQ not asserted, phase unknown.\n", HOSTNO);
621  else {
622  for (i = 0; (phases[i].value != PHASE_UNKNOWN) &&
623  (phases[i].value != (status & PHASE_MASK)); ++i)
624  ;
625  printk(KERN_DEBUG "scsi%d: phase %s\n", HOSTNO, phases[i].name);
626  }
627 }
628 
629 #else /* !NDEBUG */
630 
631 /* dummies... */
632 static inline void NCR5380_print(struct Scsi_Host *instance)
633 {
634 };
635 static inline void NCR5380_print_phase(struct Scsi_Host *instance)
636 {
637 };
638 
639 #endif
640 
641 /*
642  * ++roman: New scheme of calling NCR5380_main()
643  *
644  * If we're not in an interrupt, we can call our main directly, it cannot be
645  * already running. Else, we queue it on a task queue, if not 'main_running'
646  * tells us that a lower level is already executing it. This way,
647  * 'main_running' needs not be protected in a special way.
648  *
649  * queue_main() is a utility function for putting our main onto the task
650  * queue, if main_running is false. It should be called only from a
651  * interrupt or bottom half.
652  */
653 
654 #include <linux/gfp.h>
655 #include <linux/workqueue.h>
656 #include <linux/interrupt.h>
657 
658 static volatile int main_running;
659 static DECLARE_WORK(NCR5380_tqueue, NCR5380_main);
660 
661 static inline void queue_main(void)
662 {
663  if (!main_running) {
664  /* If in interrupt and NCR5380_main() not already running,
665  queue it on the 'immediate' task queue, to be processed
666  immediately after the current interrupt processing has
667  finished. */
668  schedule_work(&NCR5380_tqueue);
669  }
670  /* else: nothing to do: the running NCR5380_main() will pick up
671  any newly queued command. */
672 }
673 
674 
675 static inline void NCR5380_all_init(void)
676 {
677  static int done = 0;
678  if (!done) {
679  INI_PRINTK("scsi : NCR5380_all_init()\n");
680  done = 1;
681  }
682 }
683 
684 
685 /*
686  * Function : void NCR58380_print_options (struct Scsi_Host *instance)
687  *
688  * Purpose : called by probe code indicating the NCR5380 driver
689  * options that were selected.
690  *
691  * Inputs : instance, pointer to this instance. Unused.
692  */
693 
694 static void __init NCR5380_print_options(struct Scsi_Host *instance)
695 {
696  printk(" generic options"
697 #ifdef AUTOSENSE
698  " AUTOSENSE"
699 #endif
700 #ifdef REAL_DMA
701  " REAL DMA"
702 #endif
703 #ifdef PARITY
704  " PARITY"
705 #endif
706 #ifdef SUPPORT_TAGS
707  " SCSI-2 TAGGED QUEUING"
708 #endif
709  );
710  printk(" generic release=%d", NCR5380_PUBLIC_RELEASE);
711 }
712 
713 /*
714  * Function : void NCR5380_print_status (struct Scsi_Host *instance)
715  *
716  * Purpose : print commands in the various queues, called from
717  * NCR5380_abort and NCR5380_debug to aid debugging.
718  *
719  * Inputs : instance, pointer to this instance.
720  */
721 
722 static void NCR5380_print_status(struct Scsi_Host *instance)
723 {
724  char *pr_bfr;
725  char *start;
726  int len;
727 
730 
731  pr_bfr = (char *)__get_free_page(GFP_ATOMIC);
732  if (!pr_bfr) {
733  printk("NCR5380_print_status: no memory for print buffer\n");
734  return;
735  }
736  len = NCR5380_proc_info(instance, pr_bfr, &start, 0, PAGE_SIZE, 0);
737  pr_bfr[len] = 0;
738  printk("\n%s\n", pr_bfr);
739  free_page((unsigned long)pr_bfr);
740 }
741 
742 
743 /******************************************/
744 /*
745  * /proc/scsi/[dtc pas16 t128 generic]/[0-ASC_NUM_BOARD_SUPPORTED]
746  *
747  * *buffer: I/O buffer
748  * **start: if inout == FALSE pointer into buffer where user read should start
749  * offset: current offset
750  * length: length of buffer
751  * hostno: Scsi_Host host_no
752  * inout: TRUE - user is writing; FALSE - user is reading
753  *
754  * Return the number of bytes read from or written
755 */
756 
757 #undef SPRINTF
758 #define SPRINTF(fmt,args...) \
759  do { \
760  if (pos + strlen(fmt) + 20 /* slop */ < buffer + length) \
761  pos += sprintf(pos, fmt , ## args); \
762  } while(0)
763 static char *lprint_Scsi_Cmnd(Scsi_Cmnd *cmd, char *pos, char *buffer, int length);
764 
765 static int NCR5380_proc_info(struct Scsi_Host *instance, char *buffer,
766  char **start, off_t offset, int length, int inout)
767 {
768  char *pos = buffer;
769  struct NCR5380_hostdata *hostdata;
770  Scsi_Cmnd *ptr;
771  unsigned long flags;
772  off_t begin = 0;
773 #define check_offset() \
774  do { \
775  if (pos - buffer < offset - begin) { \
776  begin += pos - buffer; \
777  pos = buffer; \
778  } \
779  } while (0)
780 
781  hostdata = (struct NCR5380_hostdata *)instance->hostdata;
782 
783  if (inout) /* Has data been written to the file ? */
784  return -ENOSYS; /* Currently this is a no-op */
785  SPRINTF("NCR5380 core release=%d.\n", NCR5380_PUBLIC_RELEASE);
786  check_offset();
787  local_irq_save(flags);
788  SPRINTF("NCR5380: coroutine is%s running.\n",
789  main_running ? "" : "n't");
790  check_offset();
791  if (!hostdata->connected)
792  SPRINTF("scsi%d: no currently connected command\n", HOSTNO);
793  else
794  pos = lprint_Scsi_Cmnd((Scsi_Cmnd *) hostdata->connected,
795  pos, buffer, length);
796  SPRINTF("scsi%d: issue_queue\n", HOSTNO);
797  check_offset();
798  for (ptr = (Scsi_Cmnd *)hostdata->issue_queue; ptr; ptr = NEXT(ptr)) {
799  pos = lprint_Scsi_Cmnd(ptr, pos, buffer, length);
800  check_offset();
801  }
802 
803  SPRINTF("scsi%d: disconnected_queue\n", HOSTNO);
804  check_offset();
805  for (ptr = (Scsi_Cmnd *) hostdata->disconnected_queue; ptr;
806  ptr = NEXT(ptr)) {
807  pos = lprint_Scsi_Cmnd(ptr, pos, buffer, length);
808  check_offset();
809  }
810 
811  local_irq_restore(flags);
812  *start = buffer + (offset - begin);
813  if (pos - buffer < offset - begin)
814  return 0;
815  else if (pos - buffer - (offset - begin) < length)
816  return pos - buffer - (offset - begin);
817  return length;
818 }
819 
820 static char *lprint_Scsi_Cmnd(Scsi_Cmnd *cmd, char *pos, char *buffer, int length)
821 {
822  int i, s;
823  unsigned char *command;
824  SPRINTF("scsi%d: destination target %d, lun %d\n",
825  H_NO(cmd), cmd->device->id, cmd->device->lun);
826  SPRINTF(" command = ");
827  command = cmd->cmnd;
828  SPRINTF("%2d (0x%02x)", command[0], command[0]);
829  for (i = 1, s = COMMAND_SIZE(command[0]); i < s; ++i)
830  SPRINTF(" %02x", command[i]);
831  SPRINTF("\n");
832  return pos;
833 }
834 
835 
836 /*
837  * Function : void NCR5380_init (struct Scsi_Host *instance)
838  *
839  * Purpose : initializes *instance and corresponding 5380 chip.
840  *
841  * Inputs : instance - instantiation of the 5380 driver.
842  *
843  * Notes : I assume that the host, hostno, and id bits have been
844  * set correctly. I don't care about the irq and other fields.
845  *
846  */
847 
848 static int __init NCR5380_init(struct Scsi_Host *instance, int flags)
849 {
850  int i;
851  SETUP_HOSTDATA(instance);
852 
853  NCR5380_all_init();
854 
855  hostdata->aborted = 0;
856  hostdata->id_mask = 1 << instance->this_id;
857  hostdata->id_higher_mask = 0;
858  for (i = hostdata->id_mask; i <= 0x80; i <<= 1)
859  if (i > hostdata->id_mask)
860  hostdata->id_higher_mask |= i;
861  for (i = 0; i < 8; ++i)
862  hostdata->busy[i] = 0;
863 #ifdef SUPPORT_TAGS
864  init_tags();
865 #endif
866 #if defined (REAL_DMA)
867  hostdata->dma_len = 0;
868 #endif
869  hostdata->targets_present = 0;
870  hostdata->connected = NULL;
871  hostdata->issue_queue = NULL;
872  hostdata->disconnected_queue = NULL;
873  hostdata->flags = FLAG_CHECK_LAST_BYTE_SENT;
874 
875  if (!the_template) {
876  the_template = instance->hostt;
877  first_instance = instance;
878  }
879 
880 #ifndef AUTOSENSE
881  if ((instance->cmd_per_lun > 1) || (instance->can_queue > 1))
882  printk("scsi%d: WARNING : support for multiple outstanding commands enabled\n"
883  " without AUTOSENSE option, contingent allegiance conditions may\n"
884  " be incorrectly cleared.\n", HOSTNO);
885 #endif /* def AUTOSENSE */
886 
891 
892  return 0;
893 }
894 
895 static void NCR5380_exit(struct Scsi_Host *instance)
896 {
897  /* Empty, as we didn't schedule any delayed work */
898 }
899 
900 /*
901  * Function : int NCR5380_queue_command (Scsi_Cmnd *cmd,
902  * void (*done)(Scsi_Cmnd *))
903  *
904  * Purpose : enqueues a SCSI command
905  *
906  * Inputs : cmd - SCSI command, done - function called on completion, with
907  * a pointer to the command descriptor.
908  *
909  * Returns : 0
910  *
911  * Side effects :
912  * cmd is added to the per instance issue_queue, with minor
913  * twiddling done to the host specific fields of cmd. If the
914  * main coroutine is not running, it is restarted.
915  *
916  */
917 
918 static int NCR5380_queue_command_lck(Scsi_Cmnd *cmd, void (*done)(Scsi_Cmnd *))
919 {
920  SETUP_HOSTDATA(cmd->device->host);
921  Scsi_Cmnd *tmp;
922  unsigned long flags;
923 
924 #if (NDEBUG & NDEBUG_NO_WRITE)
925  switch (cmd->cmnd[0]) {
926  case WRITE_6:
927  case WRITE_10:
928  printk(KERN_NOTICE "scsi%d: WRITE attempted with NO_WRITE debugging flag set\n",
929  H_NO(cmd));
930  cmd->result = (DID_ERROR << 16);
931  done(cmd);
932  return 0;
933  }
934 #endif /* (NDEBUG & NDEBUG_NO_WRITE) */
935 
936 #ifdef NCR5380_STATS
937 # if 0
938  if (!hostdata->connected && !hostdata->issue_queue &&
939  !hostdata->disconnected_queue) {
940  hostdata->timebase = jiffies;
941  }
942 # endif
943 # ifdef NCR5380_STAT_LIMIT
944  if (scsi_bufflen(cmd) > NCR5380_STAT_LIMIT)
945 # endif
946  switch (cmd->cmnd[0]) {
947  case WRITE:
948  case WRITE_6:
949  case WRITE_10:
950  hostdata->time_write[cmd->device->id] -= (jiffies - hostdata->timebase);
951  hostdata->bytes_write[cmd->device->id] += scsi_bufflen(cmd);
952  hostdata->pendingw++;
953  break;
954  case READ:
955  case READ_6:
956  case READ_10:
957  hostdata->time_read[cmd->device->id] -= (jiffies - hostdata->timebase);
958  hostdata->bytes_read[cmd->device->id] += scsi_bufflen(cmd);
959  hostdata->pendingr++;
960  break;
961  }
962 #endif
963 
964  /*
965  * We use the host_scribble field as a pointer to the next command
966  * in a queue
967  */
968 
969  SET_NEXT(cmd, NULL);
970  cmd->scsi_done = done;
971 
972  cmd->result = 0;
973 
974  /*
975  * Insert the cmd into the issue queue. Note that REQUEST SENSE
976  * commands are added to the head of the queue since any command will
977  * clear the contingent allegiance condition that exists and the
978  * sense data is only guaranteed to be valid while the condition exists.
979  */
980 
981  local_irq_save(flags);
982  /* ++guenther: now that the issue queue is being set up, we can lock ST-DMA.
983  * Otherwise a running NCR5380_main may steal the lock.
984  * Lock before actually inserting due to fairness reasons explained in
985  * atari_scsi.c. If we insert first, then it's impossible for this driver
986  * to release the lock.
987  * Stop timer for this command while waiting for the lock, or timeouts
988  * may happen (and they really do), and it's no good if the command doesn't
989  * appear in any of the queues.
990  * ++roman: Just disabling the NCR interrupt isn't sufficient here,
991  * because also a timer int can trigger an abort or reset, which would
992  * alter queues and touch the lock.
993  */
994  if (!IS_A_TT()) {
995  /* perhaps stop command timer here */
996  falcon_get_lock();
997  /* perhaps restart command timer here */
998  }
999  if (!(hostdata->issue_queue) || (cmd->cmnd[0] == REQUEST_SENSE)) {
1000  LIST(cmd, hostdata->issue_queue);
1001  SET_NEXT(cmd, hostdata->issue_queue);
1002  hostdata->issue_queue = cmd;
1003  } else {
1004  for (tmp = (Scsi_Cmnd *)hostdata->issue_queue;
1005  NEXT(tmp); tmp = NEXT(tmp))
1006  ;
1007  LIST(cmd, tmp);
1008  SET_NEXT(tmp, cmd);
1009  }
1010  local_irq_restore(flags);
1011 
1012  QU_PRINTK("scsi%d: command added to %s of queue\n", H_NO(cmd),
1013  (cmd->cmnd[0] == REQUEST_SENSE) ? "head" : "tail");
1014 
1015  /* If queue_command() is called from an interrupt (real one or bottom
1016  * half), we let queue_main() do the job of taking care about main. If it
1017  * is already running, this is a no-op, else main will be queued.
1018  *
1019  * If we're not in an interrupt, we can call NCR5380_main()
1020  * unconditionally, because it cannot be already running.
1021  */
1022  if (in_interrupt() || ((flags >> 8) & 7) >= 6)
1023  queue_main();
1024  else
1025  NCR5380_main(NULL);
1026  return 0;
1027 }
1028 
1030 
1031 /*
1032  * Function : NCR5380_main (void)
1033  *
1034  * Purpose : NCR5380_main is a coroutine that runs as long as more work can
1035  * be done on the NCR5380 host adapters in a system. Both
1036  * NCR5380_queue_command() and NCR5380_intr() will try to start it
1037  * in case it is not running.
1038  *
1039  * NOTE : NCR5380_main exits with interrupts *disabled*, the caller should
1040  * reenable them. This prevents reentrancy and kernel stack overflow.
1041  */
1042 
1043 static void NCR5380_main(struct work_struct *work)
1044 {
1045  Scsi_Cmnd *tmp, *prev;
1046  struct Scsi_Host *instance = first_instance;
1047  struct NCR5380_hostdata *hostdata = HOSTDATA(instance);
1048  int done;
1049  unsigned long flags;
1050 
1051  /*
1052  * We run (with interrupts disabled) until we're sure that none of
1053  * the host adapters have anything that can be done, at which point
1054  * we set main_running to 0 and exit.
1055  *
1056  * Interrupts are enabled before doing various other internal
1057  * instructions, after we've decided that we need to run through
1058  * the loop again.
1059  *
1060  * this should prevent any race conditions.
1061  *
1062  * ++roman: Just disabling the NCR interrupt isn't sufficient here,
1063  * because also a timer int can trigger an abort or reset, which can
1064  * alter queues and touch the Falcon lock.
1065  */
1066 
1067  /* Tell int handlers main() is now already executing. Note that
1068  no races are possible here. If an int comes in before
1069  'main_running' is set here, and queues/executes main via the
1070  task queue, it doesn't do any harm, just this instance of main
1071  won't find any work left to do. */
1072  if (main_running)
1073  return;
1074  main_running = 1;
1075 
1076  local_save_flags(flags);
1077  do {
1078  local_irq_disable(); /* Freeze request queues */
1079  done = 1;
1080 
1081  if (!hostdata->connected) {
1082  MAIN_PRINTK("scsi%d: not connected\n", HOSTNO);
1083  /*
1084  * Search through the issue_queue for a command destined
1085  * for a target that's not busy.
1086  */
1087 #if (NDEBUG & NDEBUG_LISTS)
1088  for (tmp = (Scsi_Cmnd *) hostdata->issue_queue, prev = NULL;
1089  tmp && (tmp != prev); prev = tmp, tmp = NEXT(tmp))
1090  ;
1091  /*printk("%p ", tmp);*/
1092  if ((tmp == prev) && tmp)
1093  printk(" LOOP\n");
1094  /* else printk("\n"); */
1095 #endif
1096  for (tmp = (Scsi_Cmnd *) hostdata->issue_queue,
1097  prev = NULL; tmp; prev = tmp, tmp = NEXT(tmp)) {
1098 
1099 #if (NDEBUG & NDEBUG_LISTS)
1100  if (prev != tmp)
1101  printk("MAIN tmp=%p target=%d busy=%d lun=%d\n",
1102  tmp, tmp->device->id, hostdata->busy[tmp->device->id],
1103  tmp->device->lun);
1104 #endif
1105  /* When we find one, remove it from the issue queue. */
1106  /* ++guenther: possible race with Falcon locking */
1107  if (
1108 #ifdef SUPPORT_TAGS
1109  !is_lun_busy( tmp, tmp->cmnd[0] != REQUEST_SENSE)
1110 #else
1111  !(hostdata->busy[tmp->device->id] & (1 << tmp->device->lun))
1112 #endif
1113  ) {
1114  /* ++guenther: just to be sure, this must be atomic */
1116  if (prev) {
1117  REMOVE(prev, NEXT(prev), tmp, NEXT(tmp));
1118  SET_NEXT(prev, NEXT(tmp));
1119  } else {
1120  REMOVE(-1, hostdata->issue_queue, tmp, NEXT(tmp));
1121  hostdata->issue_queue = NEXT(tmp);
1122  }
1123  SET_NEXT(tmp, NULL);
1124  falcon_dont_release++;
1125 
1126  /* reenable interrupts after finding one */
1127  local_irq_restore(flags);
1128 
1129  /*
1130  * Attempt to establish an I_T_L nexus here.
1131  * On success, instance->hostdata->connected is set.
1132  * On failure, we must add the command back to the
1133  * issue queue so we can keep trying.
1134  */
1135  MAIN_PRINTK("scsi%d: main(): command for target %d "
1136  "lun %d removed from issue_queue\n",
1137  HOSTNO, tmp->device->id, tmp->device->lun);
1138  /*
1139  * REQUEST SENSE commands are issued without tagged
1140  * queueing, even on SCSI-II devices because the
1141  * contingent allegiance condition exists for the
1142  * entire unit.
1143  */
1144  /* ++roman: ...and the standard also requires that
1145  * REQUEST SENSE command are untagged.
1146  */
1147 
1148 #ifdef SUPPORT_TAGS
1149  cmd_get_tag(tmp, tmp->cmnd[0] != REQUEST_SENSE);
1150 #endif
1151  if (!NCR5380_select(instance, tmp,
1152  (tmp->cmnd[0] == REQUEST_SENSE) ? TAG_NONE :
1153  TAG_NEXT)) {
1154  falcon_dont_release--;
1155  /* release if target did not response! */
1156  falcon_release_lock_if_possible(hostdata);
1157  break;
1158  } else {
1160  LIST(tmp, hostdata->issue_queue);
1161  SET_NEXT(tmp, hostdata->issue_queue);
1162  hostdata->issue_queue = tmp;
1163 #ifdef SUPPORT_TAGS
1164  cmd_free_tag(tmp);
1165 #endif
1166  falcon_dont_release--;
1167  local_irq_restore(flags);
1168  MAIN_PRINTK("scsi%d: main(): select() failed, "
1169  "returned to issue_queue\n", HOSTNO);
1170  if (hostdata->connected)
1171  break;
1172  }
1173  } /* if target/lun/target queue is not busy */
1174  } /* for issue_queue */
1175  } /* if (!hostdata->connected) */
1176 
1177  if (hostdata->connected
1178 #ifdef REAL_DMA
1179  && !hostdata->dma_len
1180 #endif
1181  ) {
1182  local_irq_restore(flags);
1183  MAIN_PRINTK("scsi%d: main: performing information transfer\n",
1184  HOSTNO);
1185  NCR5380_information_transfer(instance);
1186  MAIN_PRINTK("scsi%d: main: done set false\n", HOSTNO);
1187  done = 0;
1188  }
1189  } while (!done);
1190 
1191  /* Better allow ints _after_ 'main_running' has been cleared, else
1192  an interrupt could believe we'll pick up the work it left for
1193  us, but we won't see it anymore here... */
1194  main_running = 0;
1195  local_irq_restore(flags);
1196 }
1197 
1198 
1199 #ifdef REAL_DMA
1200 /*
1201  * Function : void NCR5380_dma_complete (struct Scsi_Host *instance)
1202  *
1203  * Purpose : Called by interrupt handler when DMA finishes or a phase
1204  * mismatch occurs (which would finish the DMA transfer).
1205  *
1206  * Inputs : instance - this instance of the NCR5380.
1207  *
1208  */
1209 
1210 static void NCR5380_dma_complete(struct Scsi_Host *instance)
1211 {
1212  SETUP_HOSTDATA(instance);
1213  int transfered, saved_data = 0, overrun = 0, cnt, toPIO;
1214  unsigned char **data, p;
1215  volatile int *count;
1216 
1217  if (!hostdata->connected) {
1218  printk(KERN_WARNING "scsi%d: received end of DMA interrupt with "
1219  "no connected cmd\n", HOSTNO);
1220  return;
1221  }
1222 
1223  if (atari_read_overruns) {
1224  p = hostdata->connected->SCp.phase;
1225  if (p & SR_IO) {
1226  udelay(10);
1230  saved_data = NCR5380_read(INPUT_DATA_REG);
1231  overrun = 1;
1232  DMA_PRINTK("scsi%d: read overrun handled\n", HOSTNO);
1233  }
1234  }
1235  }
1236 
1237  DMA_PRINTK("scsi%d: real DMA transfer complete, basr 0x%X, sr 0x%X\n",
1240 
1244 
1245  transfered = hostdata->dma_len - NCR5380_dma_residual(instance);
1246  hostdata->dma_len = 0;
1247 
1248  data = (unsigned char **)&hostdata->connected->SCp.ptr;
1249  count = &hostdata->connected->SCp.this_residual;
1250  *data += transfered;
1251  *count -= transfered;
1252 
1253  if (atari_read_overruns) {
1254  if ((NCR5380_read(STATUS_REG) & PHASE_MASK) == p && (p & SR_IO)) {
1255  cnt = toPIO = atari_read_overruns;
1256  if (overrun) {
1257  DMA_PRINTK("Got an input overrun, using saved byte\n");
1258  *(*data)++ = saved_data;
1259  (*count)--;
1260  cnt--;
1261  toPIO--;
1262  }
1263  DMA_PRINTK("Doing %d-byte PIO to 0x%08lx\n", cnt, (long)*data);
1264  NCR5380_transfer_pio(instance, &p, &cnt, data);
1265  *count -= toPIO - cnt;
1266  }
1267  }
1268 }
1269 #endif /* REAL_DMA */
1270 
1271 
1272 /*
1273  * Function : void NCR5380_intr (int irq)
1274  *
1275  * Purpose : handle interrupts, reestablishing I_T_L or I_T_L_Q nexuses
1276  * from the disconnected queue, and restarting NCR5380_main()
1277  * as required.
1278  *
1279  * Inputs : int irq, irq that caused this interrupt.
1280  *
1281  */
1282 
1283 static irqreturn_t NCR5380_intr(int irq, void *dev_id)
1284 {
1285  struct Scsi_Host *instance = first_instance;
1286  int done = 1, handled = 0;
1287  unsigned char basr;
1288 
1289  INT_PRINTK("scsi%d: NCR5380 irq triggered\n", HOSTNO);
1290 
1291  /* Look for pending interrupts */
1293  INT_PRINTK("scsi%d: BASR=%02x\n", HOSTNO, basr);
1294  /* dispatch to appropriate routine if found and done=0 */
1295  if (basr & BASR_IRQ) {
1297  if ((NCR5380_read(STATUS_REG) & (SR_SEL|SR_IO)) == (SR_SEL|SR_IO)) {
1298  done = 0;
1299  ENABLE_IRQ();
1300  INT_PRINTK("scsi%d: SEL interrupt\n", HOSTNO);
1301  NCR5380_reselect(instance);
1303  } else if (basr & BASR_PARITY_ERROR) {
1304  INT_PRINTK("scsi%d: PARITY interrupt\n", HOSTNO);
1306  } else if ((NCR5380_read(STATUS_REG) & SR_RST) == SR_RST) {
1307  INT_PRINTK("scsi%d: RESET interrupt\n", HOSTNO);
1309  } else {
1310  /*
1311  * The rest of the interrupt conditions can occur only during a
1312  * DMA transfer
1313  */
1314 
1315 #if defined(REAL_DMA)
1316  /*
1317  * We should only get PHASE MISMATCH and EOP interrupts if we have
1318  * DMA enabled, so do a sanity check based on the current setting
1319  * of the MODE register.
1320  */
1321 
1322  if ((NCR5380_read(MODE_REG) & MR_DMA_MODE) &&
1323  ((basr & BASR_END_DMA_TRANSFER) ||
1324  !(basr & BASR_PHASE_MATCH))) {
1325 
1326  INT_PRINTK("scsi%d: PHASE MISM or EOP interrupt\n", HOSTNO);
1327  NCR5380_dma_complete( instance );
1328  done = 0;
1329  ENABLE_IRQ();
1330  } else
1331 #endif /* REAL_DMA */
1332  {
1333 /* MS: Ignore unknown phase mismatch interrupts (caused by EOP interrupt) */
1334  if (basr & BASR_PHASE_MATCH)
1335  printk(KERN_NOTICE "scsi%d: unknown interrupt, "
1336  "BASR 0x%x, MR 0x%x, SR 0x%x\n",
1337  HOSTNO, basr, NCR5380_read(MODE_REG),
1340  }
1341  } /* if !(SELECTION || PARITY) */
1342  handled = 1;
1343  } /* BASR & IRQ */ else {
1344  printk(KERN_NOTICE "scsi%d: interrupt without IRQ bit set in BASR, "
1345  "BASR 0x%X, MR 0x%X, SR 0x%x\n", HOSTNO, basr,
1348  }
1349 
1350  if (!done) {
1351  INT_PRINTK("scsi%d: in int routine, calling main\n", HOSTNO);
1352  /* Put a call to NCR5380_main() on the queue... */
1353  queue_main();
1354  }
1355  return IRQ_RETVAL(handled);
1356 }
1357 
1358 #ifdef NCR5380_STATS
1359 static void collect_stats(struct NCR5380_hostdata* hostdata, Scsi_Cmnd *cmd)
1360 {
1361 # ifdef NCR5380_STAT_LIMIT
1362  if (scsi_bufflen(cmd) > NCR5380_STAT_LIMIT)
1363 # endif
1364  switch (cmd->cmnd[0]) {
1365  case WRITE:
1366  case WRITE_6:
1367  case WRITE_10:
1368  hostdata->time_write[cmd->device->id] += (jiffies - hostdata->timebase);
1369  /*hostdata->bytes_write[cmd->device->id] += scsi_bufflen(cmd);*/
1370  hostdata->pendingw--;
1371  break;
1372  case READ:
1373  case READ_6:
1374  case READ_10:
1375  hostdata->time_read[cmd->device->id] += (jiffies - hostdata->timebase);
1376  /*hostdata->bytes_read[cmd->device->id] += scsi_bufflen(cmd);*/
1377  hostdata->pendingr--;
1378  break;
1379  }
1380 }
1381 #endif
1382 
1383 /*
1384  * Function : int NCR5380_select (struct Scsi_Host *instance, Scsi_Cmnd *cmd,
1385  * int tag);
1386  *
1387  * Purpose : establishes I_T_L or I_T_L_Q nexus for new or existing command,
1388  * including ARBITRATION, SELECTION, and initial message out for
1389  * IDENTIFY and queue messages.
1390  *
1391  * Inputs : instance - instantiation of the 5380 driver on which this
1392  * target lives, cmd - SCSI command to execute, tag - set to TAG_NEXT for
1393  * new tag, TAG_NONE for untagged queueing, otherwise set to the tag for
1394  * the command that is presently connected.
1395  *
1396  * Returns : -1 if selection could not execute for some reason,
1397  * 0 if selection succeeded or failed because the target
1398  * did not respond.
1399  *
1400  * Side effects :
1401  * If bus busy, arbitration failed, etc, NCR5380_select() will exit
1402  * with registers as they should have been on entry - ie
1403  * SELECT_ENABLE will be set appropriately, the NCR5380
1404  * will cease to drive any SCSI bus signals.
1405  *
1406  * If successful : I_T_L or I_T_L_Q nexus will be established,
1407  * instance->connected will be set to cmd.
1408  * SELECT interrupt will be disabled.
1409  *
1410  * If failed (no target) : cmd->scsi_done() will be called, and the
1411  * cmd->result host byte set to DID_BAD_TARGET.
1412  */
1413 
1414 static int NCR5380_select(struct Scsi_Host *instance, Scsi_Cmnd *cmd, int tag)
1415 {
1416  SETUP_HOSTDATA(instance);
1417  unsigned char tmp[3], phase;
1418  unsigned char *data;
1419  int len;
1420  unsigned long timeout;
1421  unsigned long flags;
1422 
1423  hostdata->restart_select = 0;
1425  ARB_PRINTK("scsi%d: starting arbitration, id = %d\n", HOSTNO,
1426  instance->this_id);
1427 
1428  /*
1429  * Set the phase bits to 0, otherwise the NCR5380 won't drive the
1430  * data bus during SELECTION.
1431  */
1432 
1433  local_irq_save(flags);
1434  if (hostdata->connected) {
1435  local_irq_restore(flags);
1436  return -1;
1437  }
1439 
1440  /*
1441  * Start arbitration.
1442  */
1443 
1446 
1447  local_irq_restore(flags);
1448 
1449  /* Wait for arbitration logic to complete */
1450 #if defined(NCR_TIMEOUT)
1451  {
1452  unsigned long timeout = jiffies + 2*NCR_TIMEOUT;
1453 
1455  time_before(jiffies, timeout) && !hostdata->connected)
1456  ;
1457  if (time_after_eq(jiffies, timeout)) {
1458  printk("scsi : arbitration timeout at %d\n", __LINE__);
1461  return -1;
1462  }
1463  }
1464 #else /* NCR_TIMEOUT */
1465  while (!(NCR5380_read(INITIATOR_COMMAND_REG) & ICR_ARBITRATION_PROGRESS) &&
1466  !hostdata->connected)
1467  ;
1468 #endif
1469 
1470  ARB_PRINTK("scsi%d: arbitration complete\n", HOSTNO);
1471 
1472  if (hostdata->connected) {
1474  return -1;
1475  }
1476  /*
1477  * The arbitration delay is 2.2us, but this is a minimum and there is
1478  * no maximum so we can safely sleep for ceil(2.2) usecs to accommodate
1479  * the integral nature of udelay().
1480  *
1481  */
1482 
1483  udelay(3);
1484 
1485  /* Check for lost arbitration */
1488  (NCR5380_read(INITIATOR_COMMAND_REG) & ICR_ARBITRATION_LOST) ||
1489  hostdata->connected) {
1491  ARB_PRINTK("scsi%d: lost arbitration, deasserting MR_ARBITRATE\n",
1492  HOSTNO);
1493  return -1;
1494  }
1495 
1496  /* after/during arbitration, BSY should be asserted.
1497  IBM DPES-31080 Version S31Q works now */
1498  /* Tnx to [email protected] for finding this! (Roman) */
1501 
1502  if ((NCR5380_read(INITIATOR_COMMAND_REG) & ICR_ARBITRATION_LOST) ||
1503  hostdata->connected) {
1506  ARB_PRINTK("scsi%d: lost arbitration, deasserting ICR_ASSERT_SEL\n",
1507  HOSTNO);
1508  return -1;
1509  }
1510 
1511  /*
1512  * Again, bus clear + bus settle time is 1.2us, however, this is
1513  * a minimum so we'll udelay ceil(1.2)
1514  */
1515 
1516 #ifdef CONFIG_ATARI_SCSI_TOSHIBA_DELAY
1517  /* ++roman: But some targets (see above :-) seem to need a bit more... */
1518  udelay(15);
1519 #else
1520  udelay(2);
1521 #endif
1522 
1523  if (hostdata->connected) {
1526  return -1;
1527  }
1528 
1529  ARB_PRINTK("scsi%d: won arbitration\n", HOSTNO);
1530 
1531  /*
1532  * Now that we have won arbitration, start Selection process, asserting
1533  * the host and target ID's on the SCSI bus.
1534  */
1535 
1536  NCR5380_write(OUTPUT_DATA_REG, (hostdata->id_mask | (1 << cmd->device->id)));
1537 
1538  /*
1539  * Raise ATN while SEL is true before BSY goes false from arbitration,
1540  * since this is the only way to guarantee that we'll get a MESSAGE OUT
1541  * phase immediately after selection.
1542  */
1543 
1547 
1548  /*
1549  * Reselect interrupts must be turned off prior to the dropping of BSY,
1550  * otherwise we will trigger an interrupt.
1551  */
1552 
1553  if (hostdata->connected) {
1555  return -1;
1556  }
1557 
1559 
1560  /*
1561  * The initiator shall then wait at least two deskew delays and release
1562  * the BSY signal.
1563  */
1564  udelay(1); /* wingel -- wait two bus deskew delay >2*45ns */
1565 
1566  /* Reset BSY */
1569 
1570  /*
1571  * Something weird happens when we cease to drive BSY - looks
1572  * like the board/chip is letting us do another read before the
1573  * appropriate propagation delay has expired, and we're confusing
1574  * a BSY signal from ourselves as the target's response to SELECTION.
1575  *
1576  * A small delay (the 'C++' frontend breaks the pipeline with an
1577  * unnecessary jump, making it work on my 386-33/Trantor T128, the
1578  * tighter 'C' code breaks and requires this) solves the problem -
1579  * the 1 us delay is arbitrary, and only used because this delay will
1580  * be the same on other platforms and since it works here, it should
1581  * work there.
1582  *
1583  * wingel suggests that this could be due to failing to wait
1584  * one deskew delay.
1585  */
1586 
1587  udelay(1);
1588 
1589  SEL_PRINTK("scsi%d: selecting target %d\n", HOSTNO, cmd->device->id);
1590 
1591  /*
1592  * The SCSI specification calls for a 250 ms timeout for the actual
1593  * selection.
1594  */
1595 
1596  timeout = jiffies + 25;
1597 
1598  /*
1599  * XXX very interesting - we're seeing a bounce where the BSY we
1600  * asserted is being reflected / still asserted (propagation delay?)
1601  * and it's detecting as true. Sigh.
1602  */
1603 
1604 #if 0
1605  /* ++roman: If a target conformed to the SCSI standard, it wouldn't assert
1606  * IO while SEL is true. But again, there are some disks out the in the
1607  * world that do that nevertheless. (Somebody claimed that this announces
1608  * reselection capability of the target.) So we better skip that test and
1609  * only wait for BSY... (Famous german words: Der Kl├╝gere gibt nach :-)
1610  */
1611 
1612  while (time_before(jiffies, timeout) &&
1613  !(NCR5380_read(STATUS_REG) & (SR_BSY | SR_IO)))
1614  ;
1615 
1616  if ((NCR5380_read(STATUS_REG) & (SR_SEL | SR_IO)) == (SR_SEL | SR_IO)) {
1618  NCR5380_reselect(instance);
1619  printk(KERN_ERR "scsi%d: reselection after won arbitration?\n",
1620  HOSTNO);
1622  return -1;
1623  }
1624 #else
1625  while (time_before(jiffies, timeout) && !(NCR5380_read(STATUS_REG) & SR_BSY))
1626  ;
1627 #endif
1628 
1629  /*
1630  * No less than two deskew delays after the initiator detects the
1631  * BSY signal is true, it shall release the SEL signal and may
1632  * change the DATA BUS. -wingel
1633  */
1634 
1635  udelay(1);
1636 
1638 
1639  if (!(NCR5380_read(STATUS_REG) & SR_BSY)) {
1641  if (hostdata->targets_present & (1 << cmd->device->id)) {
1642  printk(KERN_ERR "scsi%d: weirdness\n", HOSTNO);
1643  if (hostdata->restart_select)
1644  printk(KERN_NOTICE "\trestart select\n");
1647  return -1;
1648  }
1649  cmd->result = DID_BAD_TARGET << 16;
1650 #ifdef NCR5380_STATS
1651  collect_stats(hostdata, cmd);
1652 #endif
1653 #ifdef SUPPORT_TAGS
1654  cmd_free_tag(cmd);
1655 #endif
1656  cmd->scsi_done(cmd);
1658  SEL_PRINTK("scsi%d: target did not respond within 250ms\n", HOSTNO);
1660  return 0;
1661  }
1662 
1663  hostdata->targets_present |= (1 << cmd->device->id);
1664 
1665  /*
1666  * Since we followed the SCSI spec, and raised ATN while SEL
1667  * was true but before BSY was false during selection, the information
1668  * transfer phase should be a MESSAGE OUT phase so that we can send the
1669  * IDENTIFY message.
1670  *
1671  * If SCSI-II tagged queuing is enabled, we also send a SIMPLE_QUEUE_TAG
1672  * message (2 bytes) with a tag ID that we increment with every command
1673  * until it wraps back to 0.
1674  *
1675  * XXX - it turns out that there are some broken SCSI-II devices,
1676  * which claim to support tagged queuing but fail when more than
1677  * some number of commands are issued at once.
1678  */
1679 
1680  /* Wait for start of REQ/ACK handshake */
1681  while (!(NCR5380_read(STATUS_REG) & SR_REQ))
1682  ;
1683 
1684  SEL_PRINTK("scsi%d: target %d selected, going into MESSAGE OUT phase.\n",
1685  HOSTNO, cmd->device->id);
1686  tmp[0] = IDENTIFY(1, cmd->device->lun);
1687 
1688 #ifdef SUPPORT_TAGS
1689  if (cmd->tag != TAG_NONE) {
1690  tmp[1] = hostdata->last_message = SIMPLE_QUEUE_TAG;
1691  tmp[2] = cmd->tag;
1692  len = 3;
1693  } else
1694  len = 1;
1695 #else
1696  len = 1;
1697  cmd->tag = 0;
1698 #endif /* SUPPORT_TAGS */
1699 
1700  /* Send message(s) */
1701  data = tmp;
1702  phase = PHASE_MSGOUT;
1703  NCR5380_transfer_pio(instance, &phase, &len, &data);
1704  SEL_PRINTK("scsi%d: nexus established.\n", HOSTNO);
1705  /* XXX need to handle errors here */
1706  hostdata->connected = cmd;
1707 #ifndef SUPPORT_TAGS
1708  hostdata->busy[cmd->device->id] |= (1 << cmd->device->lun);
1709 #endif
1710 
1711  initialize_SCp(cmd);
1712 
1713  return 0;
1714 }
1715 
1716 /*
1717  * Function : int NCR5380_transfer_pio (struct Scsi_Host *instance,
1718  * unsigned char *phase, int *count, unsigned char **data)
1719  *
1720  * Purpose : transfers data in given phase using polled I/O
1721  *
1722  * Inputs : instance - instance of driver, *phase - pointer to
1723  * what phase is expected, *count - pointer to number of
1724  * bytes to transfer, **data - pointer to data pointer.
1725  *
1726  * Returns : -1 when different phase is entered without transferring
1727  * maximum number of bytes, 0 if all bytes are transferred or exit
1728  * is in same phase.
1729  *
1730  * Also, *phase, *count, *data are modified in place.
1731  *
1732  * XXX Note : handling for bus free may be useful.
1733  */
1734 
1735 /*
1736  * Note : this code is not as quick as it could be, however it
1737  * IS 100% reliable, and for the actual data transfer where speed
1738  * counts, we will always do a pseudo DMA or DMA transfer.
1739  */
1740 
1741 static int NCR5380_transfer_pio(struct Scsi_Host *instance,
1742  unsigned char *phase, int *count,
1743  unsigned char **data)
1744 {
1745  register unsigned char p = *phase, tmp;
1746  register int c = *count;
1747  register unsigned char *d = *data;
1748 
1749  /*
1750  * The NCR5380 chip will only drive the SCSI bus when the
1751  * phase specified in the appropriate bits of the TARGET COMMAND
1752  * REGISTER match the STATUS REGISTER
1753  */
1754 
1756 
1757  do {
1758  /*
1759  * Wait for assertion of REQ, after which the phase bits will be
1760  * valid
1761  */
1762  while (!((tmp = NCR5380_read(STATUS_REG)) & SR_REQ))
1763  ;
1764 
1765  HSH_PRINTK("scsi%d: REQ detected\n", HOSTNO);
1766 
1767  /* Check for phase mismatch */
1768  if ((tmp & PHASE_MASK) != p) {
1769  PIO_PRINTK("scsi%d: phase mismatch\n", HOSTNO);
1771  break;
1772  }
1773 
1774  /* Do actual transfer from SCSI bus to / from memory */
1775  if (!(p & SR_IO))
1777  else
1779 
1780  ++d;
1781 
1782  /*
1783  * The SCSI standard suggests that in MSGOUT phase, the initiator
1784  * should drop ATN on the last byte of the message phase
1785  * after REQ has been asserted for the handshake but before
1786  * the initiator raises ACK.
1787  */
1788 
1789  if (!(p & SR_IO)) {
1790  if (!((p & SR_MSG) && c > 1)) {
1795  } else {
1801  }
1802  } else {
1805  }
1806 
1807  while (NCR5380_read(STATUS_REG) & SR_REQ)
1808  ;
1809 
1810  HSH_PRINTK("scsi%d: req false, handshake complete\n", HOSTNO);
1811 
1812  /*
1813  * We have several special cases to consider during REQ/ACK handshaking :
1814  * 1. We were in MSGOUT phase, and we are on the last byte of the
1815  * message. ATN must be dropped as ACK is dropped.
1816  *
1817  * 2. We are in a MSGIN phase, and we are on the last byte of the
1818  * message. We must exit with ACK asserted, so that the calling
1819  * code may raise ATN before dropping ACK to reject the message.
1820  *
1821  * 3. ACK and ATN are clear and the target may proceed as normal.
1822  */
1823  if (!(p == PHASE_MSGIN && c == 1)) {
1824  if (p == PHASE_MSGOUT && c > 1)
1826  else
1828  }
1829  } while (--c);
1830 
1831  PIO_PRINTK("scsi%d: residual %d\n", HOSTNO, c);
1832 
1833  *count = c;
1834  *data = d;
1835  tmp = NCR5380_read(STATUS_REG);
1836  /* The phase read from the bus is valid if either REQ is (already)
1837  * asserted or if ACK hasn't been released yet. The latter is the case if
1838  * we're in MSGIN and all wanted bytes have been received.
1839  */
1840  if ((tmp & SR_REQ) || (p == PHASE_MSGIN && c == 0))
1841  *phase = tmp & PHASE_MASK;
1842  else
1843  *phase = PHASE_UNKNOWN;
1844 
1845  if (!c || (*phase == p))
1846  return 0;
1847  else
1848  return -1;
1849 }
1850 
1851 /*
1852  * Function : do_abort (Scsi_Host *host)
1853  *
1854  * Purpose : abort the currently established nexus. Should only be
1855  * called from a routine which can drop into a
1856  *
1857  * Returns : 0 on success, -1 on failure.
1858  */
1859 
1860 static int do_abort(struct Scsi_Host *host)
1861 {
1862  unsigned char tmp, *msgptr, phase;
1863  int len;
1864 
1865  /* Request message out phase */
1867 
1868  /*
1869  * Wait for the target to indicate a valid phase by asserting
1870  * REQ. Once this happens, we'll have either a MSGOUT phase
1871  * and can immediately send the ABORT message, or we'll have some
1872  * other phase and will have to source/sink data.
1873  *
1874  * We really don't care what value was on the bus or what value
1875  * the target sees, so we just handshake.
1876  */
1877 
1878  while (!((tmp = NCR5380_read(STATUS_REG)) & SR_REQ))
1879  ;
1880 
1882 
1883  if ((tmp & PHASE_MASK) != PHASE_MSGOUT) {
1885  ICR_ASSERT_ACK);
1886  while (NCR5380_read(STATUS_REG) & SR_REQ)
1887  ;
1889  }
1890 
1891  tmp = ABORT;
1892  msgptr = &tmp;
1893  len = 1;
1894  phase = PHASE_MSGOUT;
1895  NCR5380_transfer_pio(host, &phase, &len, &msgptr);
1896 
1897  /*
1898  * If we got here, and the command completed successfully,
1899  * we're about to go into bus free state.
1900  */
1901 
1902  return len ? -1 : 0;
1903 }
1904 
1905 #if defined(REAL_DMA)
1906 /*
1907  * Function : int NCR5380_transfer_dma (struct Scsi_Host *instance,
1908  * unsigned char *phase, int *count, unsigned char **data)
1909  *
1910  * Purpose : transfers data in given phase using either real
1911  * or pseudo DMA.
1912  *
1913  * Inputs : instance - instance of driver, *phase - pointer to
1914  * what phase is expected, *count - pointer to number of
1915  * bytes to transfer, **data - pointer to data pointer.
1916  *
1917  * Returns : -1 when different phase is entered without transferring
1918  * maximum number of bytes, 0 if all bytes or transferred or exit
1919  * is in same phase.
1920  *
1921  * Also, *phase, *count, *data are modified in place.
1922  *
1923  */
1924 
1925 
1926 static int NCR5380_transfer_dma(struct Scsi_Host *instance,
1927  unsigned char *phase, int *count,
1928  unsigned char **data)
1929 {
1930  SETUP_HOSTDATA(instance);
1931  register int c = *count;
1932  register unsigned char p = *phase;
1933  register unsigned char *d = *data;
1934  unsigned char tmp;
1935  unsigned long flags;
1936 
1937  if ((tmp = (NCR5380_read(STATUS_REG) & PHASE_MASK)) != p) {
1938  *phase = tmp;
1939  return -1;
1940  }
1941 
1942  if (atari_read_overruns && (p & SR_IO))
1943  c -= atari_read_overruns;
1944 
1945  DMA_PRINTK("scsi%d: initializing DMA for %s, %d bytes %s %p\n",
1946  HOSTNO, (p & SR_IO) ? "reading" : "writing",
1947  c, (p & SR_IO) ? "to" : "from", d);
1948 
1950 
1951 #ifdef REAL_DMA
1953 #endif /* def REAL_DMA */
1954 
1955  if (IS_A_TT()) {
1956  /* On the Medusa, it is a must to initialize the DMA before
1957  * starting the NCR. This is also the cleaner way for the TT.
1958  */
1959  local_irq_save(flags);
1960  hostdata->dma_len = (p & SR_IO) ?
1961  NCR5380_dma_read_setup(instance, d, c) :
1962  NCR5380_dma_write_setup(instance, d, c);
1963  local_irq_restore(flags);
1964  }
1965 
1966  if (p & SR_IO)
1968  else {
1971  }
1972 
1973  if (!IS_A_TT()) {
1974  /* On the Falcon, the DMA setup must be done after the last */
1975  /* NCR access, else the DMA setup gets trashed!
1976  */
1977  local_irq_save(flags);
1978  hostdata->dma_len = (p & SR_IO) ?
1979  NCR5380_dma_read_setup(instance, d, c) :
1980  NCR5380_dma_write_setup(instance, d, c);
1981  local_irq_restore(flags);
1982  }
1983  return 0;
1984 }
1985 #endif /* defined(REAL_DMA) */
1986 
1987 /*
1988  * Function : NCR5380_information_transfer (struct Scsi_Host *instance)
1989  *
1990  * Purpose : run through the various SCSI phases and do as the target
1991  * directs us to. Operates on the currently connected command,
1992  * instance->connected.
1993  *
1994  * Inputs : instance, instance for which we are doing commands
1995  *
1996  * Side effects : SCSI things happen, the disconnected queue will be
1997  * modified if a command disconnects, *instance->connected will
1998  * change.
1999  *
2000  * XXX Note : we need to watch for bus free or a reset condition here
2001  * to recover from an unexpected bus free condition.
2002  */
2003 
2004 static void NCR5380_information_transfer(struct Scsi_Host *instance)
2005 {
2006  SETUP_HOSTDATA(instance);
2007  unsigned long flags;
2008  unsigned char msgout = NOP;
2009  int sink = 0;
2010  int len;
2011 #if defined(REAL_DMA)
2012  int transfersize;
2013 #endif
2014  unsigned char *data;
2015  unsigned char phase, tmp, extended_msg[10], old_phase = 0xff;
2016  Scsi_Cmnd *cmd = (Scsi_Cmnd *) hostdata->connected;
2017 
2018  while (1) {
2019  tmp = NCR5380_read(STATUS_REG);
2020  /* We only have a valid SCSI phase when REQ is asserted */
2021  if (tmp & SR_REQ) {
2022  phase = (tmp & PHASE_MASK);
2023  if (phase != old_phase) {
2024  old_phase = phase;
2026  }
2027 
2028  if (sink && (phase != PHASE_MSGOUT)) {
2030 
2032  ICR_ASSERT_ACK);
2033  while (NCR5380_read(STATUS_REG) & SR_REQ)
2034  ;
2036  ICR_ASSERT_ATN);
2037  sink = 0;
2038  continue;
2039  }
2040 
2041  switch (phase) {
2042  case PHASE_DATAOUT:
2043 #if (NDEBUG & NDEBUG_NO_DATAOUT)
2044  printk("scsi%d: NDEBUG_NO_DATAOUT set, attempted DATAOUT "
2045  "aborted\n", HOSTNO);
2046  sink = 1;
2047  do_abort(instance);
2048  cmd->result = DID_ERROR << 16;
2049  cmd->scsi_done(cmd);
2050  return;
2051 #endif
2052  case PHASE_DATAIN:
2053  /*
2054  * If there is no room left in the current buffer in the
2055  * scatter-gather list, move onto the next one.
2056  */
2057 
2058  if (!cmd->SCp.this_residual && cmd->SCp.buffers_residual) {
2059  ++cmd->SCp.buffer;
2060  --cmd->SCp.buffers_residual;
2061  cmd->SCp.this_residual = cmd->SCp.buffer->length;
2062  cmd->SCp.ptr = sg_virt(cmd->SCp.buffer);
2063  /* ++roman: Try to merge some scatter-buffers if
2064  * they are at contiguous physical addresses.
2065  */
2066  merge_contiguous_buffers(cmd);
2067  INF_PRINTK("scsi%d: %d bytes and %d buffers left\n",
2068  HOSTNO, cmd->SCp.this_residual,
2069  cmd->SCp.buffers_residual);
2070  }
2071 
2072  /*
2073  * The preferred transfer method is going to be
2074  * PSEUDO-DMA for systems that are strictly PIO,
2075  * since we can let the hardware do the handshaking.
2076  *
2077  * For this to work, we need to know the transfersize
2078  * ahead of time, since the pseudo-DMA code will sit
2079  * in an unconditional loop.
2080  */
2081 
2082  /* ++roman: I suggest, this should be
2083  * #if def(REAL_DMA)
2084  * instead of leaving REAL_DMA out.
2085  */
2086 
2087 #if defined(REAL_DMA)
2088  if (!cmd->device->borken &&
2089  (transfersize = NCR5380_dma_xfer_len(instance,cmd,phase)) > 31) {
2090  len = transfersize;
2091  cmd->SCp.phase = phase;
2092  if (NCR5380_transfer_dma(instance, &phase,
2093  &len, (unsigned char **)&cmd->SCp.ptr)) {
2094  /*
2095  * If the watchdog timer fires, all future
2096  * accesses to this device will use the
2097  * polled-IO. */
2098  printk(KERN_NOTICE "scsi%d: switching target %d "
2099  "lun %d to slow handshake\n", HOSTNO,
2100  cmd->device->id, cmd->device->lun);
2101  cmd->device->borken = 1;
2103  ICR_ASSERT_ATN);
2104  sink = 1;
2105  do_abort(instance);
2106  cmd->result = DID_ERROR << 16;
2107  cmd->scsi_done(cmd);
2108  /* XXX - need to source or sink data here, as appropriate */
2109  } else {
2110 #ifdef REAL_DMA
2111  /* ++roman: When using real DMA,
2112  * information_transfer() should return after
2113  * starting DMA since it has nothing more to
2114  * do.
2115  */
2116  return;
2117 #else
2118  cmd->SCp.this_residual -= transfersize - len;
2119 #endif
2120  }
2121  } else
2122 #endif /* defined(REAL_DMA) */
2123  NCR5380_transfer_pio(instance, &phase,
2124  (int *)&cmd->SCp.this_residual,
2125  (unsigned char **)&cmd->SCp.ptr);
2126  break;
2127  case PHASE_MSGIN:
2128  len = 1;
2129  data = &tmp;
2130  NCR5380_write(SELECT_ENABLE_REG, 0); /* disable reselects */
2131  NCR5380_transfer_pio(instance, &phase, &len, &data);
2132  cmd->SCp.Message = tmp;
2133 
2134  switch (tmp) {
2135  /*
2136  * Linking lets us reduce the time required to get the
2137  * next command out to the device, hopefully this will
2138  * mean we don't waste another revolution due to the delays
2139  * required by ARBITRATION and another SELECTION.
2140  *
2141  * In the current implementation proposal, low level drivers
2142  * merely have to start the next command, pointed to by
2143  * next_link, done() is called as with unlinked commands.
2144  */
2145 #ifdef LINKED
2146  case LINKED_CMD_COMPLETE:
2148  /* Accept message by clearing ACK */
2150 
2151  LNK_PRINTK("scsi%d: target %d lun %d linked command "
2152  "complete.\n", HOSTNO, cmd->device->id, cmd->device->lun);
2153 
2154  /* Enable reselect interrupts */
2156  /*
2157  * Sanity check : A linked command should only terminate
2158  * with one of these messages if there are more linked
2159  * commands available.
2160  */
2161 
2162  if (!cmd->next_link) {
2163  printk(KERN_NOTICE "scsi%d: target %d lun %d "
2164  "linked command complete, no next_link\n",
2165  HOSTNO, cmd->device->id, cmd->device->lun);
2166  sink = 1;
2167  do_abort(instance);
2168  return;
2169  }
2170 
2171  initialize_SCp(cmd->next_link);
2172  /* The next command is still part of this process; copy it
2173  * and don't free it! */
2174  cmd->next_link->tag = cmd->tag;
2175  cmd->result = cmd->SCp.Status | (cmd->SCp.Message << 8);
2176  LNK_PRINTK("scsi%d: target %d lun %d linked request "
2177  "done, calling scsi_done().\n",
2178  HOSTNO, cmd->device->id, cmd->device->lun);
2179 #ifdef NCR5380_STATS
2180  collect_stats(hostdata, cmd);
2181 #endif
2182  cmd->scsi_done(cmd);
2183  cmd = hostdata->connected;
2184  break;
2185 #endif /* def LINKED */
2186  case ABORT:
2187  case COMMAND_COMPLETE:
2188  /* Accept message by clearing ACK */
2190  /* ++guenther: possible race with Falcon locking */
2191  falcon_dont_release++;
2192  hostdata->connected = NULL;
2193  QU_PRINTK("scsi%d: command for target %d, lun %d "
2194  "completed\n", HOSTNO, cmd->device->id, cmd->device->lun);
2195 #ifdef SUPPORT_TAGS
2196  cmd_free_tag(cmd);
2197  if (status_byte(cmd->SCp.Status) == QUEUE_FULL) {
2198  /* Turn a QUEUE FULL status into BUSY, I think the
2199  * mid level cannot handle QUEUE FULL :-( (The
2200  * command is retried after BUSY). Also update our
2201  * queue size to the number of currently issued
2202  * commands now.
2203  */
2204  /* ++Andreas: the mid level code knows about
2205  QUEUE_FULL now. */
2206  TAG_ALLOC *ta = &TagAlloc[cmd->device->id][cmd->device->lun];
2207  TAG_PRINTK("scsi%d: target %d lun %d returned "
2208  "QUEUE_FULL after %d commands\n",
2209  HOSTNO, cmd->device->id, cmd->device->lun,
2210  ta->nr_allocated);
2211  if (ta->queue_size > ta->nr_allocated)
2212  ta->nr_allocated = ta->queue_size;
2213  }
2214 #else
2215  hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun);
2216 #endif
2217  /* Enable reselect interrupts */
2219 
2220  /*
2221  * I'm not sure what the correct thing to do here is :
2222  *
2223  * If the command that just executed is NOT a request
2224  * sense, the obvious thing to do is to set the result
2225  * code to the values of the stored parameters.
2226  *
2227  * If it was a REQUEST SENSE command, we need some way to
2228  * differentiate between the failure code of the original
2229  * and the failure code of the REQUEST sense - the obvious
2230  * case is success, where we fall through and leave the
2231  * result code unchanged.
2232  *
2233  * The non-obvious place is where the REQUEST SENSE failed
2234  */
2235 
2236  if (cmd->cmnd[0] != REQUEST_SENSE)
2237  cmd->result = cmd->SCp.Status | (cmd->SCp.Message << 8);
2238  else if (status_byte(cmd->SCp.Status) != GOOD)
2239  cmd->result = (cmd->result & 0x00ffff) | (DID_ERROR << 16);
2240 
2241 #ifdef AUTOSENSE
2242  if ((cmd->cmnd[0] == REQUEST_SENSE) &&
2243  hostdata->ses.cmd_len) {
2244  scsi_eh_restore_cmnd(cmd, &hostdata->ses);
2245  hostdata->ses.cmd_len = 0 ;
2246  }
2247 
2248  if ((cmd->cmnd[0] != REQUEST_SENSE) &&
2249  (status_byte(cmd->SCp.Status) == CHECK_CONDITION)) {
2250  scsi_eh_prep_cmnd(cmd, &hostdata->ses, NULL, 0, ~0);
2251 
2252  ASEN_PRINTK("scsi%d: performing request sense\n", HOSTNO);
2253 
2254  local_irq_save(flags);
2255  LIST(cmd,hostdata->issue_queue);
2256  SET_NEXT(cmd, hostdata->issue_queue);
2257  hostdata->issue_queue = (Scsi_Cmnd *) cmd;
2258  local_irq_restore(flags);
2259  QU_PRINTK("scsi%d: REQUEST SENSE added to head of "
2260  "issue queue\n", H_NO(cmd));
2261  } else
2262 #endif /* def AUTOSENSE */
2263  {
2264 #ifdef NCR5380_STATS
2265  collect_stats(hostdata, cmd);
2266 #endif
2267  cmd->scsi_done(cmd);
2268  }
2269 
2271  /*
2272  * Restore phase bits to 0 so an interrupted selection,
2273  * arbitration can resume.
2274  */
2276 
2277  while ((NCR5380_read(STATUS_REG) & SR_BSY) && !hostdata->connected)
2278  barrier();
2279 
2280  falcon_dont_release--;
2281  /* ++roman: For Falcon SCSI, release the lock on the
2282  * ST-DMA here if no other commands are waiting on the
2283  * disconnected queue.
2284  */
2285  falcon_release_lock_if_possible(hostdata);
2286  return;
2287  case MESSAGE_REJECT:
2288  /* Accept message by clearing ACK */
2290  /* Enable reselect interrupts */
2292  switch (hostdata->last_message) {
2293  case HEAD_OF_QUEUE_TAG:
2294  case ORDERED_QUEUE_TAG:
2295  case SIMPLE_QUEUE_TAG:
2296  /* The target obviously doesn't support tagged
2297  * queuing, even though it announced this ability in
2298  * its INQUIRY data ?!? (maybe only this LUN?) Ok,
2299  * clear 'tagged_supported' and lock the LUN, since
2300  * the command is treated as untagged further on.
2301  */
2302  cmd->device->tagged_supported = 0;
2303  hostdata->busy[cmd->device->id] |= (1 << cmd->device->lun);
2304  cmd->tag = TAG_NONE;
2305  TAG_PRINTK("scsi%d: target %d lun %d rejected "
2306  "QUEUE_TAG message; tagged queuing "
2307  "disabled\n",
2308  HOSTNO, cmd->device->id, cmd->device->lun);
2309  break;
2310  }
2311  break;
2312  case DISCONNECT:
2313  /* Accept message by clearing ACK */
2315  local_irq_save(flags);
2316  cmd->device->disconnect = 1;
2317  LIST(cmd,hostdata->disconnected_queue);
2318  SET_NEXT(cmd, hostdata->disconnected_queue);
2319  hostdata->connected = NULL;
2320  hostdata->disconnected_queue = cmd;
2321  local_irq_restore(flags);
2322  QU_PRINTK("scsi%d: command for target %d lun %d was "
2323  "moved from connected to the "
2324  "disconnected_queue\n", HOSTNO,
2325  cmd->device->id, cmd->device->lun);
2326  /*
2327  * Restore phase bits to 0 so an interrupted selection,
2328  * arbitration can resume.
2329  */
2331 
2332  /* Enable reselect interrupts */
2334  /* Wait for bus free to avoid nasty timeouts */
2335  while ((NCR5380_read(STATUS_REG) & SR_BSY) && !hostdata->connected)
2336  barrier();
2337  return;
2338  /*
2339  * The SCSI data pointer is *IMPLICITLY* saved on a disconnect
2340  * operation, in violation of the SCSI spec so we can safely
2341  * ignore SAVE/RESTORE pointers calls.
2342  *
2343  * Unfortunately, some disks violate the SCSI spec and
2344  * don't issue the required SAVE_POINTERS message before
2345  * disconnecting, and we have to break spec to remain
2346  * compatible.
2347  */
2348  case SAVE_POINTERS:
2349  case RESTORE_POINTERS:
2350  /* Accept message by clearing ACK */
2352  /* Enable reselect interrupts */
2354  break;
2355  case EXTENDED_MESSAGE:
2356  /*
2357  * Extended messages are sent in the following format :
2358  * Byte
2359  * 0 EXTENDED_MESSAGE == 1
2360  * 1 length (includes one byte for code, doesn't
2361  * include first two bytes)
2362  * 2 code
2363  * 3..length+1 arguments
2364  *
2365  * Start the extended message buffer with the EXTENDED_MESSAGE
2366  * byte, since spi_print_msg() wants the whole thing.
2367  */
2368  extended_msg[0] = EXTENDED_MESSAGE;
2369  /* Accept first byte by clearing ACK */
2371 
2372  EXT_PRINTK("scsi%d: receiving extended message\n", HOSTNO);
2373 
2374  len = 2;
2375  data = extended_msg + 1;
2376  phase = PHASE_MSGIN;
2377  NCR5380_transfer_pio(instance, &phase, &len, &data);
2378  EXT_PRINTK("scsi%d: length=%d, code=0x%02x\n", HOSTNO,
2379  (int)extended_msg[1], (int)extended_msg[2]);
2380 
2381  if (!len && extended_msg[1] <=
2382  (sizeof(extended_msg) - 1)) {
2383  /* Accept third byte by clearing ACK */
2385  len = extended_msg[1] - 1;
2386  data = extended_msg + 3;
2387  phase = PHASE_MSGIN;
2388 
2389  NCR5380_transfer_pio(instance, &phase, &len, &data);
2390  EXT_PRINTK("scsi%d: message received, residual %d\n",
2391  HOSTNO, len);
2392 
2393  switch (extended_msg[2]) {
2394  case EXTENDED_SDTR:
2395  case EXTENDED_WDTR:
2398  tmp = 0;
2399  }
2400  } else if (len) {
2401  printk(KERN_NOTICE "scsi%d: error receiving "
2402  "extended message\n", HOSTNO);
2403  tmp = 0;
2404  } else {
2405  printk(KERN_NOTICE "scsi%d: extended message "
2406  "code %02x length %d is too long\n",
2407  HOSTNO, extended_msg[2], extended_msg[1]);
2408  tmp = 0;
2409  }
2410  /* Fall through to reject message */
2411 
2412  /*
2413  * If we get something weird that we aren't expecting,
2414  * reject it.
2415  */
2416  default:
2417  if (!tmp) {
2418  printk(KERN_DEBUG "scsi%d: rejecting message ", HOSTNO);
2419  spi_print_msg(extended_msg);
2420  printk("\n");
2421  } else if (tmp != EXTENDED_MESSAGE)
2422  printk(KERN_DEBUG "scsi%d: rejecting unknown "
2423  "message %02x from target %d, lun %d\n",
2424  HOSTNO, tmp, cmd->device->id, cmd->device->lun);
2425  else
2426  printk(KERN_DEBUG "scsi%d: rejecting unknown "
2427  "extended message "
2428  "code %02x, length %d from target %d, lun %d\n",
2429  HOSTNO, extended_msg[1], extended_msg[0],
2430  cmd->device->id, cmd->device->lun);
2431 
2432 
2433  msgout = MESSAGE_REJECT;
2435  break;
2436  } /* switch (tmp) */
2437  break;
2438  case PHASE_MSGOUT:
2439  len = 1;
2440  data = &msgout;
2441  hostdata->last_message = msgout;
2442  NCR5380_transfer_pio(instance, &phase, &len, &data);
2443  if (msgout == ABORT) {
2444 #ifdef SUPPORT_TAGS
2445  cmd_free_tag(cmd);
2446 #else
2447  hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun);
2448 #endif
2449  hostdata->connected = NULL;
2450  cmd->result = DID_ERROR << 16;
2451 #ifdef NCR5380_STATS
2452  collect_stats(hostdata, cmd);
2453 #endif
2454  cmd->scsi_done(cmd);
2456  falcon_release_lock_if_possible(hostdata);
2457  return;
2458  }
2459  msgout = NOP;
2460  break;
2461  case PHASE_CMDOUT:
2462  len = cmd->cmd_len;
2463  data = cmd->cmnd;
2464  /*
2465  * XXX for performance reasons, on machines with a
2466  * PSEUDO-DMA architecture we should probably
2467  * use the dma transfer function.
2468  */
2469  NCR5380_transfer_pio(instance, &phase, &len, &data);
2470  break;
2471  case PHASE_STATIN:
2472  len = 1;
2473  data = &tmp;
2474  NCR5380_transfer_pio(instance, &phase, &len, &data);
2475  cmd->SCp.Status = tmp;
2476  break;
2477  default:
2478  printk("scsi%d: unknown phase\n", HOSTNO);
2480  } /* switch(phase) */
2481  } /* if (tmp * SR_REQ) */
2482  } /* while (1) */
2483 }
2484 
2485 /*
2486  * Function : void NCR5380_reselect (struct Scsi_Host *instance)
2487  *
2488  * Purpose : does reselection, initializing the instance->connected
2489  * field to point to the Scsi_Cmnd for which the I_T_L or I_T_L_Q
2490  * nexus has been reestablished,
2491  *
2492  * Inputs : instance - this instance of the NCR5380.
2493  *
2494  */
2495 
2496 
2497 static void NCR5380_reselect(struct Scsi_Host *instance)
2498 {
2499  SETUP_HOSTDATA(instance);
2500  unsigned char target_mask;
2501  unsigned char lun, phase;
2502  int len;
2503 #ifdef SUPPORT_TAGS
2504  unsigned char tag;
2505 #endif
2506  unsigned char msg[3];
2507  unsigned char *data;
2508  Scsi_Cmnd *tmp = NULL, *prev;
2509 /* unsigned long flags; */
2510 
2511  /*
2512  * Disable arbitration, etc. since the host adapter obviously
2513  * lost, and tell an interrupted NCR5380_select() to restart.
2514  */
2515 
2517  hostdata->restart_select = 1;
2518 
2519  target_mask = NCR5380_read(CURRENT_SCSI_DATA_REG) & ~(hostdata->id_mask);
2520 
2521  RSL_PRINTK("scsi%d: reselect\n", HOSTNO);
2522 
2523  /*
2524  * At this point, we have detected that our SCSI ID is on the bus,
2525  * SEL is true and BSY was false for at least one bus settle delay
2526  * (400 ns).
2527  *
2528  * We must assert BSY ourselves, until the target drops the SEL
2529  * signal.
2530  */
2531 
2533 
2534  while (NCR5380_read(STATUS_REG) & SR_SEL)
2535  ;
2537 
2538  /*
2539  * Wait for target to go into MSGIN.
2540  */
2541 
2542  while (!(NCR5380_read(STATUS_REG) & SR_REQ))
2543  ;
2544 
2545  len = 1;
2546  data = msg;
2547  phase = PHASE_MSGIN;
2548  NCR5380_transfer_pio(instance, &phase, &len, &data);
2549 
2550  if (!(msg[0] & 0x80)) {
2551  printk(KERN_DEBUG "scsi%d: expecting IDENTIFY message, got ", HOSTNO);
2552  spi_print_msg(msg);
2553  do_abort(instance);
2554  return;
2555  }
2556  lun = (msg[0] & 0x07);
2557 
2558 #ifdef SUPPORT_TAGS
2559  /* If the phase is still MSGIN, the target wants to send some more
2560  * messages. In case it supports tagged queuing, this is probably a
2561  * SIMPLE_QUEUE_TAG for the I_T_L_Q nexus.
2562  */
2563  tag = TAG_NONE;
2564  if (phase == PHASE_MSGIN && setup_use_tagged_queuing) {
2565  /* Accept previous IDENTIFY message by clearing ACK */
2567  len = 2;
2568  data = msg + 1;
2569  if (!NCR5380_transfer_pio(instance, &phase, &len, &data) &&
2570  msg[1] == SIMPLE_QUEUE_TAG)
2571  tag = msg[2];
2572  TAG_PRINTK("scsi%d: target mask %02x, lun %d sent tag %d at "
2573  "reselection\n", HOSTNO, target_mask, lun, tag);
2574  }
2575 #endif
2576 
2577  /*
2578  * Find the command corresponding to the I_T_L or I_T_L_Q nexus we
2579  * just reestablished, and remove it from the disconnected queue.
2580  */
2581 
2582  for (tmp = (Scsi_Cmnd *) hostdata->disconnected_queue, prev = NULL;
2583  tmp; prev = tmp, tmp = NEXT(tmp)) {
2584  if ((target_mask == (1 << tmp->device->id)) && (lun == tmp->device->lun)
2585 #ifdef SUPPORT_TAGS
2586  && (tag == tmp->tag)
2587 #endif
2588  ) {
2589  /* ++guenther: prevent race with falcon_release_lock */
2590  falcon_dont_release++;
2591  if (prev) {
2592  REMOVE(prev, NEXT(prev), tmp, NEXT(tmp));
2593  SET_NEXT(prev, NEXT(tmp));
2594  } else {
2595  REMOVE(-1, hostdata->disconnected_queue, tmp, NEXT(tmp));
2596  hostdata->disconnected_queue = NEXT(tmp);
2597  }
2598  SET_NEXT(tmp, NULL);
2599  break;
2600  }
2601  }
2602 
2603  if (!tmp) {
2604  printk(KERN_WARNING "scsi%d: warning: target bitmask %02x lun %d "
2605 #ifdef SUPPORT_TAGS
2606  "tag %d "
2607 #endif
2608  "not in disconnected_queue.\n",
2609  HOSTNO, target_mask, lun
2610 #ifdef SUPPORT_TAGS
2611  , tag
2612 #endif
2613  );
2614  /*
2615  * Since we have an established nexus that we can't do anything
2616  * with, we must abort it.
2617  */
2618  do_abort(instance);
2619  return;
2620  }
2621 
2622  /* Accept message by clearing ACK */
2624 
2625  hostdata->connected = tmp;
2626  RSL_PRINTK("scsi%d: nexus established, target = %d, lun = %d, tag = %d\n",
2627  HOSTNO, tmp->device->id, tmp->device->lun, tmp->tag);
2628  falcon_dont_release--;
2629 }
2630 
2631 
2632 /*
2633  * Function : int NCR5380_abort (Scsi_Cmnd *cmd)
2634  *
2635  * Purpose : abort a command
2636  *
2637  * Inputs : cmd - the Scsi_Cmnd to abort, code - code to set the
2638  * host byte of the result field to, if zero DID_ABORTED is
2639  * used.
2640  *
2641  * Returns : 0 - success, -1 on failure.
2642  *
2643  * XXX - there is no way to abort the command that is currently
2644  * connected, you have to wait for it to complete. If this is
2645  * a problem, we could implement longjmp() / setjmp(), setjmp()
2646  * called where the loop started in NCR5380_main().
2647  */
2648 
2649 static
2650 int NCR5380_abort(Scsi_Cmnd *cmd)
2651 {
2652  struct Scsi_Host *instance = cmd->device->host;
2653  SETUP_HOSTDATA(instance);
2654  Scsi_Cmnd *tmp, **prev;
2655  unsigned long flags;
2656 
2657  printk(KERN_NOTICE "scsi%d: aborting command\n", HOSTNO);
2658  scsi_print_command(cmd);
2659 
2660  NCR5380_print_status(instance);
2661 
2662  local_irq_save(flags);
2663 
2664  if (!IS_A_TT() && !falcon_got_lock)
2665  printk(KERN_ERR "scsi%d: !!BINGO!! Falcon has no lock in NCR5380_abort\n",
2666  HOSTNO);
2667 
2668  ABRT_PRINTK("scsi%d: abort called basr 0x%02x, sr 0x%02x\n", HOSTNO,
2671 
2672 #if 1
2673  /*
2674  * Case 1 : If the command is the currently executing command,
2675  * we'll set the aborted flag and return control so that
2676  * information transfer routine can exit cleanly.
2677  */
2678 
2679  if (hostdata->connected == cmd) {
2680 
2681  ABRT_PRINTK("scsi%d: aborting connected command\n", HOSTNO);
2682  /*
2683  * We should perform BSY checking, and make sure we haven't slipped
2684  * into BUS FREE.
2685  */
2686 
2687  /* NCR5380_write(INITIATOR_COMMAND_REG, ICR_ASSERT_ATN); */
2688  /*
2689  * Since we can't change phases until we've completed the current
2690  * handshake, we have to source or sink a byte of data if the current
2691  * phase is not MSGOUT.
2692  */
2693 
2694  /*
2695  * Return control to the executing NCR drive so we can clear the
2696  * aborted flag and get back into our main loop.
2697  */
2698 
2699  if (do_abort(instance) == 0) {
2700  hostdata->aborted = 1;
2701  hostdata->connected = NULL;
2702  cmd->result = DID_ABORT << 16;
2703 #ifdef SUPPORT_TAGS
2704  cmd_free_tag(cmd);
2705 #else
2706  hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun);
2707 #endif
2708  local_irq_restore(flags);
2709  cmd->scsi_done(cmd);
2710  falcon_release_lock_if_possible(hostdata);
2711  return SCSI_ABORT_SUCCESS;
2712  } else {
2713 /* local_irq_restore(flags); */
2714  printk("scsi%d: abort of connected command failed!\n", HOSTNO);
2715  return SCSI_ABORT_ERROR;
2716  }
2717  }
2718 #endif
2719 
2720  /*
2721  * Case 2 : If the command hasn't been issued yet, we simply remove it
2722  * from the issue queue.
2723  */
2724  for (prev = (Scsi_Cmnd **)&(hostdata->issue_queue),
2725  tmp = (Scsi_Cmnd *)hostdata->issue_queue;
2726  tmp; prev = NEXTADDR(tmp), tmp = NEXT(tmp)) {
2727  if (cmd == tmp) {
2728  REMOVE(5, *prev, tmp, NEXT(tmp));
2729  (*prev) = NEXT(tmp);
2730  SET_NEXT(tmp, NULL);
2731  tmp->result = DID_ABORT << 16;
2732  local_irq_restore(flags);
2733  ABRT_PRINTK("scsi%d: abort removed command from issue queue.\n",
2734  HOSTNO);
2735  /* Tagged queuing note: no tag to free here, hasn't been assigned
2736  * yet... */
2737  tmp->scsi_done(tmp);
2738  falcon_release_lock_if_possible(hostdata);
2739  return SCSI_ABORT_SUCCESS;
2740  }
2741  }
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  local_irq_restore(flags);
2756  ABRT_PRINTK("scsi%d: abort failed, command connected.\n", HOSTNO);
2757  return SCSI_ABORT_SNOOZE;
2758  }
2759 
2760  /*
2761  * Case 4: If the command is currently disconnected from the bus, and
2762  * there are no connected commands, we reconnect the I_T_L or
2763  * I_T_L_Q nexus associated with it, go into message out, and send
2764  * an abort message.
2765  *
2766  * This case is especially ugly. In order to reestablish the nexus, we
2767  * need to call NCR5380_select(). The easiest way to implement this
2768  * function was to abort if the bus was busy, and let the interrupt
2769  * handler triggered on the SEL for reselect take care of lost arbitrations
2770  * where necessary, meaning interrupts need to be enabled.
2771  *
2772  * When interrupts are enabled, the queues may change - so we
2773  * can't remove it from the disconnected queue before selecting it
2774  * because that could cause a failure in hashing the nexus if that
2775  * device reselected.
2776  *
2777  * Since the queues may change, we can't use the pointers from when we
2778  * first locate it.
2779  *
2780  * So, we must first locate the command, and if NCR5380_select()
2781  * succeeds, then issue the abort, relocate the command and remove
2782  * it from the disconnected queue.
2783  */
2784 
2785  for (tmp = (Scsi_Cmnd *) hostdata->disconnected_queue; tmp;
2786  tmp = NEXT(tmp)) {
2787  if (cmd == tmp) {
2788  local_irq_restore(flags);
2789  ABRT_PRINTK("scsi%d: aborting disconnected command.\n", HOSTNO);
2790 
2791  if (NCR5380_select(instance, cmd, (int)cmd->tag))
2792  return SCSI_ABORT_BUSY;
2793 
2794  ABRT_PRINTK("scsi%d: nexus reestablished.\n", HOSTNO);
2795 
2796  do_abort(instance);
2797 
2798  local_irq_save(flags);
2799  for (prev = (Scsi_Cmnd **)&(hostdata->disconnected_queue),
2800  tmp = (Scsi_Cmnd *)hostdata->disconnected_queue;
2801  tmp; prev = NEXTADDR(tmp), tmp = NEXT(tmp)) {
2802  if (cmd == tmp) {
2803  REMOVE(5, *prev, tmp, NEXT(tmp));
2804  *prev = NEXT(tmp);
2805  SET_NEXT(tmp, NULL);
2806  tmp->result = DID_ABORT << 16;
2807  /* We must unlock the tag/LUN immediately here, since the
2808  * target goes to BUS FREE and doesn't send us another
2809  * message (COMMAND_COMPLETE or the like)
2810  */
2811 #ifdef SUPPORT_TAGS
2812  cmd_free_tag(tmp);
2813 #else
2814  hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun);
2815 #endif
2816  local_irq_restore(flags);
2817  tmp->scsi_done(tmp);
2818  falcon_release_lock_if_possible(hostdata);
2819  return SCSI_ABORT_SUCCESS;
2820  }
2821  }
2822  }
2823  }
2824 
2825  /*
2826  * Case 5 : If we reached this point, the command was not found in any of
2827  * the queues.
2828  *
2829  * We probably reached this point because of an unlikely race condition
2830  * between the command completing successfully and the abortion code,
2831  * so we won't panic, but we will notify the user in case something really
2832  * broke.
2833  */
2834 
2835  local_irq_restore(flags);
2836  printk(KERN_INFO "scsi%d: warning : SCSI command probably completed successfully before abortion\n", HOSTNO);
2837 
2838  /* Maybe it is sufficient just to release the ST-DMA lock... (if
2839  * possible at all) At least, we should check if the lock could be
2840  * released after the abort, in case it is kept due to some bug.
2841  */
2842  falcon_release_lock_if_possible(hostdata);
2843 
2844  return SCSI_ABORT_NOT_RUNNING;
2845 }
2846 
2847 
2848 /*
2849  * Function : int NCR5380_reset (Scsi_Cmnd *cmd)
2850  *
2851  * Purpose : reset the SCSI bus.
2852  *
2853  * Returns : SCSI_RESET_WAKEUP
2854  *
2855  */
2856 
2857 static int NCR5380_bus_reset(Scsi_Cmnd *cmd)
2858 {
2859  SETUP_HOSTDATA(cmd->device->host);
2860  int i;
2861  unsigned long flags;
2862 #if 1
2863  Scsi_Cmnd *connected, *disconnected_queue;
2864 #endif
2865 
2866  if (!IS_A_TT() && !falcon_got_lock)
2867  printk(KERN_ERR "scsi%d: !!BINGO!! Falcon has no lock in NCR5380_reset\n",
2868  H_NO(cmd));
2869 
2870  NCR5380_print_status(cmd->device->host);
2871 
2872  /* get in phase */
2875  /* assert RST */
2877  udelay(40);
2878  /* reset NCR registers */
2883  /* ++roman: reset interrupt condition! otherwise no interrupts don't get
2884  * through anymore ... */
2886 
2887 #if 1 /* XXX Should now be done by midlevel code, but it's broken XXX */
2888  /* XXX see below XXX */
2889 
2890  /* MSch: old-style reset: actually abort all command processing here */
2891 
2892  /* After the reset, there are no more connected or disconnected commands
2893  * and no busy units; to avoid problems with re-inserting the commands
2894  * into the issue_queue (via scsi_done()), the aborted commands are
2895  * remembered in local variables first.
2896  */
2897  local_irq_save(flags);
2898  connected = (Scsi_Cmnd *)hostdata->connected;
2899  hostdata->connected = NULL;
2900  disconnected_queue = (Scsi_Cmnd *)hostdata->disconnected_queue;
2901  hostdata->disconnected_queue = NULL;
2902 #ifdef SUPPORT_TAGS
2903  free_all_tags();
2904 #endif
2905  for (i = 0; i < 8; ++i)
2906  hostdata->busy[i] = 0;
2907 #ifdef REAL_DMA
2908  hostdata->dma_len = 0;
2909 #endif
2910  local_irq_restore(flags);
2911 
2912  /* In order to tell the mid-level code which commands were aborted,
2913  * set the command status to DID_RESET and call scsi_done() !!!
2914  * This ultimately aborts processing of these commands in the mid-level.
2915  */
2916 
2917  if ((cmd = connected)) {
2918  ABRT_PRINTK("scsi%d: reset aborted a connected command\n", H_NO(cmd));
2919  cmd->result = (cmd->result & 0xffff) | (DID_RESET << 16);
2920  cmd->scsi_done(cmd);
2921  }
2922 
2923  for (i = 0; (cmd = disconnected_queue); ++i) {
2924  disconnected_queue = NEXT(cmd);
2925  SET_NEXT(cmd, NULL);
2926  cmd->result = (cmd->result & 0xffff) | (DID_RESET << 16);
2927  cmd->scsi_done(cmd);
2928  }
2929  if (i > 0)
2930  ABRT_PRINTK("scsi: reset aborted %d disconnected command(s)\n", i);
2931 
2932  /* The Falcon lock should be released after a reset...
2933  */
2934  /* ++guenther: moved to atari_scsi_reset(), to prevent a race between
2935  * unlocking and enabling dma interrupt.
2936  */
2937 /* falcon_release_lock_if_possible( hostdata );*/
2938 
2939  /* since all commands have been explicitly terminated, we need to tell
2940  * the midlevel code that the reset was SUCCESSFUL, and there is no
2941  * need to 'wake up' the commands by a request_sense
2942  */
2944 #else /* 1 */
2945 
2946  /* MSch: new-style reset handling: let the mid-level do what it can */
2947 
2948  /* ++guenther: MID-LEVEL IS STILL BROKEN.
2949  * Mid-level is supposed to requeue all commands that were active on the
2950  * various low-level queues. In fact it does this, but that's not enough
2951  * because all these commands are subject to timeout. And if a timeout
2952  * happens for any removed command, *_abort() is called but all queues
2953  * are now empty. Abort then gives up the falcon lock, which is fatal,
2954  * since the mid-level will queue more commands and must have the lock
2955  * (it's all happening inside timer interrupt handler!!).
2956  * Even worse, abort will return NOT_RUNNING for all those commands not
2957  * on any queue, so they won't be retried ...
2958  *
2959  * Conclusion: either scsi.c disables timeout for all resetted commands
2960  * immediately, or we lose! As of linux-2.0.20 it doesn't.
2961  */
2962 
2963  /* After the reset, there are no more connected or disconnected commands
2964  * and no busy units; so clear the low-level status here to avoid
2965  * conflicts when the mid-level code tries to wake up the affected
2966  * commands!
2967  */
2968 
2969  if (hostdata->issue_queue)
2970  ABRT_PRINTK("scsi%d: reset aborted issued command(s)\n", H_NO(cmd));
2971  if (hostdata->connected)
2972  ABRT_PRINTK("scsi%d: reset aborted a connected command\n", H_NO(cmd));
2973  if (hostdata->disconnected_queue)
2974  ABRT_PRINTK("scsi%d: reset aborted disconnected command(s)\n", H_NO(cmd));
2975 
2976  local_irq_save(flags);
2977  hostdata->issue_queue = NULL;
2978  hostdata->connected = NULL;
2979  hostdata->disconnected_queue = NULL;
2980 #ifdef SUPPORT_TAGS
2981  free_all_tags();
2982 #endif
2983  for (i = 0; i < 8; ++i)
2984  hostdata->busy[i] = 0;
2985 #ifdef REAL_DMA
2986  hostdata->dma_len = 0;
2987 #endif
2988  local_irq_restore(flags);
2989 
2990  /* we did no complete reset of all commands, so a wakeup is required */
2992 #endif /* 1 */
2993 }