2 * NCR 5380 generic driver routines. These should make it *trivial*
3 * to implement 5380 SCSI drivers under Linux with a non-trantor
6 * Note that these routines also work with NR53c400 family chips.
8 * Copyright 1993, Drew Eckhardt
10 * (Unix and Linux consulting and custom programming)
14 * For more information, please consult
17 * SCSI Protocol Controller
20 * NCR Microelectronics
21 * 1635 Aeroplaza Drive
22 * Colorado Springs, CO 80916
28 * ++roman: To port the 5380 driver to the Atari, I had to do some changes in
31 * - Some of the debug statements were incorrect (undefined variables and the
32 * like). I fixed that.
34 * - In information_transfer(), I think a #ifdef was wrong. Looking at the
35 * possible DMA transfer size should also happen for REAL_DMA. I added this
36 * in the #if statement.
38 * - When using real DMA, information_transfer() should return in a DATAOUT
39 * phase after starting the DMA. It has nothing more to do.
41 * - The interrupt service routine should run main after end of DMA, too (not
42 * only after RESELECTION interrupts). Additionally, it should _not_ test
43 * for more interrupts after running main, since a DMA process may have
44 * been started and interrupts are turned on now. The new int could happen
45 * inside the execution of NCR5380_intr(), leading to recursive
48 * - I've added a function merge_contiguous_buffers() that tries to
49 * merge scatter-gather buffers that are located at contiguous
50 * physical addresses and can be processed with the same DMA setup.
51 * Since most scatter-gather operations work on a page (4K) of
52 * 4 buffers (1K), in more than 90% of all cases three interrupts and
53 * DMA setup actions are saved.
55 * - I've deleted all the stuff for AUTOPROBE_IRQ, REAL_DMA_POLL, PSEUDO_DMA
56 * and USLEEP, because these were messing up readability and will never be
57 * needed for Atari SCSI.
59 * - I've revised the NCR5380_main() calling scheme (relax the 'main_running'
60 * stuff), and 'main' is executed in a bottom half if awoken by an
63 * - The code was quite cluttered up by "#if (NDEBUG & NDEBUG_*) printk..."
64 * constructs. In my eyes, this made the source rather unreadable, so I
65 * finally replaced that by the *_PRINTK() macros.
69 /* Adapted for the sun3 by Sam Creasey. */
71 #if (NDEBUG & NDEBUG_LISTS)
74 printk("LINE:%d Adding %p to %p\n", \
75 __LINE__, (void*)(x), (void*)(y)); \
79 #define REMOVE(w, x, y, z) \
81 printk("LINE:%d Removing: %p->%p %p->%p \n", \
82 __LINE__, (void*)(w), (void*)(x), \
83 (void*)(y), (void*)(z)); \
89 #define REMOVE(w,x,y,z)
95 * This is a generic 5380 driver. To use it on a different platform,
96 * one simply writes appropriate system specific macros (ie, data
97 * transfer - some PC's will use the I/O bus, 68K's must use
98 * memory mapped) and drops this file in their 'C' wrapper.
100 * As far as command queueing, two queues are maintained for
101 * each 5380 in the system - commands that haven't been issued yet,
102 * and commands that are currently executing. This means that an
103 * unlimited number of commands may be queued, letting
104 * more commands propagate from the higher driver levels giving higher
105 * throughput. Note that both I_T_L and I_T_L_Q nexuses are supported,
106 * allowing multiple commands to propagate all the way to a SCSI-II device
107 * while a command is already executing.
110 * Issues specific to the NCR5380 :
112 * When used in a PIO or pseudo-dma mode, the NCR5380 is a braindead
113 * piece of hardware that requires you to sit in a loop polling for
114 * the REQ signal as long as you are connected. Some devices are
115 * brain dead (ie, many TEXEL CD ROM drives) and won't disconnect
116 * while doing long seek operations. [...] These
117 * broken devices are the exception rather than the rule and I'd rather
118 * spend my time optimizing for the normal case.
122 * At the heart of the design is a coroutine, NCR5380_main,
123 * which is started from a workqueue for each NCR5380 host in the
124 * system. It attempts to establish I_T_L or I_T_L_Q nexuses by
125 * removing the commands from the issue queue and calling
126 * NCR5380_select() if a nexus is not established.
128 * Once a nexus is established, the NCR5380_information_transfer()
129 * phase goes through the various phases as instructed by the target.
130 * if the target goes into MSG IN and sends a DISCONNECT message,
131 * the command structure is placed into the per instance disconnected
132 * queue, and NCR5380_main tries to find more work. If the target is
133 * idle for too long, the system will try to sleep.
135 * If a command has disconnected, eventually an interrupt will trigger,
136 * calling NCR5380_intr() which will in turn call NCR5380_reselect
137 * to reestablish a nexus. This will run main if necessary.
139 * On command termination, the done function will be called as
142 * SCSI pointers are maintained in the SCp field of SCSI command
143 * structures, being initialized after the command is connected
144 * in NCR5380_select, and set as appropriate in NCR5380_information_transfer.
145 * Note that in violation of the standard, an implicit SAVE POINTERS operation
146 * is done, since some BROKEN disks fail to issue an explicit SAVE POINTERS.
151 * This file a skeleton Linux SCSI driver for the NCR 5380 series
152 * of chips. To use it, you write an architecture specific functions
153 * and macros and include this file in your driver.
155 * These macros control options :
156 * AUTOSENSE - if defined, REQUEST SENSE will be performed automatically
157 * for commands that return with a CHECK CONDITION status.
159 * DIFFERENTIAL - if defined, NCR53c81 chips will use external differential
162 * REAL_DMA - if defined, REAL DMA is used during the data transfer phases.
164 * SUPPORT_TAGS - if defined, SCSI-2 tagged queuing is used where possible
166 * These macros MUST be defined :
168 * NCR5380_read(register) - read from the specified register
170 * NCR5380_write(register, value) - write to the specific register
172 * NCR5380_implementation_fields - additional fields needed for this
173 * specific implementation of the NCR5380
175 * Either real DMA *or* pseudo DMA may be implemented
177 * NCR5380_REAL_DMA should be defined if real DMA is to be used.
178 * Note that the DMA setup functions should return the number of bytes
179 * that they were able to program the controller for.
181 * Also note that generic i386/PC versions of these macros are
182 * available as NCR5380_i386_dma_write_setup,
183 * NCR5380_i386_dma_read_setup, and NCR5380_i386_dma_residual.
185 * NCR5380_dma_write_setup(instance, src, count) - initialize
186 * NCR5380_dma_read_setup(instance, dst, count) - initialize
187 * NCR5380_dma_residual(instance); - residual count
190 * NCR5380_pwrite(instance, src, count)
191 * NCR5380_pread(instance, dst, count);
193 * The generic driver is initialized by calling NCR5380_init(instance),
194 * after setting the appropriate host specific fields and ID. If the
195 * driver wishes to autoprobe for an IRQ line, the NCR5380_probe_irq(instance,
196 * possible) function may be used.
199 /* Macros ease life... :-) */
200 #define SETUP_HOSTDATA(in) \
201 struct NCR5380_hostdata *hostdata = \
202 (struct NCR5380_hostdata *)(in)->hostdata
203 #define HOSTDATA(in) ((struct NCR5380_hostdata *)(in)->hostdata)
205 #define NEXT(cmd) ((struct scsi_cmnd *)(cmd)->host_scribble)
206 #define SET_NEXT(cmd,next) ((cmd)->host_scribble = (void *)(next))
207 #define NEXTADDR(cmd) ((struct scsi_cmnd **)&(cmd)->host_scribble)
209 #define HOSTNO instance->host_no
211 static int do_abort(struct Scsi_Host *);
212 static void do_reset(struct Scsi_Host *);
217 * Functions for handling tagged queuing
218 * =====================================
220 * ++roman (01/96): Now I've implemented SCSI-2 tagged queuing. Some notes:
222 * Using consecutive numbers for the tags is no good idea in my eyes. There
223 * could be wrong re-usings if the counter (8 bit!) wraps and some early
224 * command has been preempted for a long time. My solution: a bitfield for
225 * remembering used tags.
227 * There's also the problem that each target has a certain queue size, but we
228 * cannot know it in advance :-( We just see a QUEUE_FULL status being
229 * returned. So, in this case, the driver internal queue size assumption is
230 * reduced to the number of active tags if QUEUE_FULL is returned by the
233 * We're also not allowed running tagged commands as long as an untagged
234 * command is active. And REQUEST SENSE commands after a contingent allegiance
235 * condition _must_ be untagged. To keep track whether an untagged command has
236 * been issued, the host->busy array is still employed, as it is without
237 * support for tagged queuing.
239 * One could suspect that there are possible race conditions between
240 * is_lun_busy(), cmd_get_tag() and cmd_free_tag(). But I think this isn't the
241 * case: is_lun_busy() and cmd_get_tag() are both called from NCR5380_main(),
242 * which already guaranteed to be running at most once. It is also the only
243 * place where tags/LUNs are allocated. So no other allocation can slip
244 * between that pair, there could only happen a reselection, which can free a
245 * tag, but that doesn't hurt. Only the sequence in cmd_free_tag() becomes
246 * important: the tag bit must be cleared before 'nr_allocated' is decreased.
249 static void __init init_tags(struct NCR5380_hostdata *hostdata)
252 struct tag_alloc *ta;
254 if (!(hostdata->flags & FLAG_TAGGED_QUEUING))
257 for (target = 0; target < 8; ++target) {
258 for (lun = 0; lun < 8; ++lun) {
259 ta = &hostdata->TagAlloc[target][lun];
260 bitmap_zero(ta->allocated, MAX_TAGS);
261 ta->nr_allocated = 0;
262 /* At the beginning, assume the maximum queue size we could
263 * support (MAX_TAGS). This value will be decreased if the target
264 * returns QUEUE_FULL status.
266 ta->queue_size = MAX_TAGS;
272 /* Check if we can issue a command to this LUN: First see if the LUN is marked
273 * busy by an untagged command. If the command should use tagged queuing, also
274 * check that there is a free tag and the target's queue won't overflow. This
275 * function should be called with interrupts disabled to avoid race
279 static int is_lun_busy(struct scsi_cmnd *cmd, int should_be_tagged)
281 u8 lun = cmd->device->lun;
282 struct Scsi_Host *instance = cmd->device->host;
283 struct NCR5380_hostdata *hostdata = shost_priv(instance);
285 if (hostdata->busy[cmd->device->id] & (1 << lun))
287 if (!should_be_tagged ||
288 !(hostdata->flags & FLAG_TAGGED_QUEUING) ||
289 !cmd->device->tagged_supported)
291 if (hostdata->TagAlloc[scmd_id(cmd)][lun].nr_allocated >=
292 hostdata->TagAlloc[scmd_id(cmd)][lun].queue_size) {
293 dsprintk(NDEBUG_TAGS, instance, "target %d lun %d: no free tags\n",
301 /* Allocate a tag for a command (there are no checks anymore, check_lun_busy()
302 * must be called before!), or reserve the LUN in 'busy' if the command is
306 static void cmd_get_tag(struct scsi_cmnd *cmd, int should_be_tagged)
308 u8 lun = cmd->device->lun;
309 struct Scsi_Host *instance = cmd->device->host;
310 struct NCR5380_hostdata *hostdata = shost_priv(instance);
312 /* If we or the target don't support tagged queuing, allocate the LUN for
313 * an untagged command.
315 if (!should_be_tagged ||
316 !(hostdata->flags & FLAG_TAGGED_QUEUING) ||
317 !cmd->device->tagged_supported) {
319 hostdata->busy[cmd->device->id] |= (1 << lun);
320 dsprintk(NDEBUG_TAGS, instance, "target %d lun %d now allocated by untagged command\n",
323 struct tag_alloc *ta = &hostdata->TagAlloc[scmd_id(cmd)][lun];
325 cmd->tag = find_first_zero_bit(ta->allocated, MAX_TAGS);
326 set_bit(cmd->tag, ta->allocated);
328 dsprintk(NDEBUG_TAGS, instance, "using tag %d for target %d lun %d (%d tags allocated)\n",
329 cmd->tag, scmd_id(cmd), lun, ta->nr_allocated);
334 /* Mark the tag of command 'cmd' as free, or in case of an untagged command,
338 static void cmd_free_tag(struct scsi_cmnd *cmd)
340 u8 lun = cmd->device->lun;
341 struct Scsi_Host *instance = cmd->device->host;
342 struct NCR5380_hostdata *hostdata = shost_priv(instance);
344 if (cmd->tag == TAG_NONE) {
345 hostdata->busy[cmd->device->id] &= ~(1 << lun);
346 dsprintk(NDEBUG_TAGS, instance, "target %d lun %d untagged cmd freed\n",
348 } else if (cmd->tag >= MAX_TAGS) {
349 shost_printk(KERN_NOTICE, instance,
350 "trying to free bad tag %d!\n", cmd->tag);
352 struct tag_alloc *ta = &hostdata->TagAlloc[scmd_id(cmd)][lun];
353 clear_bit(cmd->tag, ta->allocated);
355 dsprintk(NDEBUG_TAGS, instance, "freed tag %d for target %d lun %d\n",
356 cmd->tag, scmd_id(cmd), lun);
361 static void free_all_tags(struct NCR5380_hostdata *hostdata)
364 struct tag_alloc *ta;
366 if (!(hostdata->flags & FLAG_TAGGED_QUEUING))
369 for (target = 0; target < 8; ++target) {
370 for (lun = 0; lun < 8; ++lun) {
371 ta = &hostdata->TagAlloc[target][lun];
372 bitmap_zero(ta->allocated, MAX_TAGS);
373 ta->nr_allocated = 0;
378 #endif /* SUPPORT_TAGS */
382 * Function: void merge_contiguous_buffers( struct scsi_cmnd *cmd )
384 * Purpose: Try to merge several scatter-gather requests into one DMA
385 * transfer. This is possible if the scatter buffers lie on
386 * physical contiguous addresses.
388 * Parameters: struct scsi_cmnd *cmd
389 * The command to work on. The first scatter buffer's data are
390 * assumed to be already transferred into ptr/this_residual.
393 static void merge_contiguous_buffers(struct scsi_cmnd *cmd)
395 #if !defined(CONFIG_SUN3)
396 unsigned long endaddr;
397 #if (NDEBUG & NDEBUG_MERGING)
398 unsigned long oldlen = cmd->SCp.this_residual;
402 for (endaddr = virt_to_phys(cmd->SCp.ptr + cmd->SCp.this_residual - 1) + 1;
403 cmd->SCp.buffers_residual &&
404 virt_to_phys(sg_virt(&cmd->SCp.buffer[1])) == endaddr;) {
405 dprintk(NDEBUG_MERGING, "VTOP(%p) == %08lx -> merging\n",
406 page_address(sg_page(&cmd->SCp.buffer[1])), endaddr);
407 #if (NDEBUG & NDEBUG_MERGING)
411 --cmd->SCp.buffers_residual;
412 cmd->SCp.this_residual += cmd->SCp.buffer->length;
413 endaddr += cmd->SCp.buffer->length;
415 #if (NDEBUG & NDEBUG_MERGING)
416 if (oldlen != cmd->SCp.this_residual)
417 dprintk(NDEBUG_MERGING, "merged %d buffers from %p, new length %08x\n",
418 cnt, cmd->SCp.ptr, cmd->SCp.this_residual);
420 #endif /* !defined(CONFIG_SUN3) */
424 * initialize_SCp - init the scsi pointer field
425 * @cmd: command block to set up
427 * Set up the internal fields in the SCSI command.
430 static inline void initialize_SCp(struct scsi_cmnd *cmd)
433 * Initialize the Scsi Pointer field so that all of the commands in the
434 * various queues are valid.
437 if (scsi_bufflen(cmd)) {
438 cmd->SCp.buffer = scsi_sglist(cmd);
439 cmd->SCp.buffers_residual = scsi_sg_count(cmd) - 1;
440 cmd->SCp.ptr = sg_virt(cmd->SCp.buffer);
441 cmd->SCp.this_residual = cmd->SCp.buffer->length;
442 /* ++roman: Try to merge some scatter-buffers if they are at
443 * contiguous physical addresses.
445 merge_contiguous_buffers(cmd);
447 cmd->SCp.buffer = NULL;
448 cmd->SCp.buffers_residual = 0;
450 cmd->SCp.this_residual = 0;
455 * NCR5380_poll_politely2 - wait for two chip register values
456 * @instance: controller to poll
457 * @reg1: 5380 register to poll
458 * @bit1: Bitmask to check
459 * @val1: Expected value
460 * @reg2: Second 5380 register to poll
461 * @bit2: Second bitmask to check
462 * @val2: Second expected value
463 * @wait: Time-out in jiffies
465 * Polls the chip in a reasonably efficient manner waiting for an
466 * event to occur. After a short quick poll we begin to yield the CPU
467 * (if possible). In irq contexts the time-out is arbitrarily limited.
468 * Callers may hold locks as long as they are held in irq mode.
470 * Returns 0 if either or both event(s) occurred otherwise -ETIMEDOUT.
473 static int NCR5380_poll_politely2(struct Scsi_Host *instance,
474 int reg1, int bit1, int val1,
475 int reg2, int bit2, int val2, int wait)
477 struct NCR5380_hostdata *hostdata = shost_priv(instance);
478 unsigned long deadline = jiffies + wait;
481 /* Busy-wait for up to 10 ms */
482 n = min(10000U, jiffies_to_usecs(wait));
483 n *= hostdata->accesses_per_ms;
486 if ((NCR5380_read(reg1) & bit1) == val1)
488 if ((NCR5380_read(reg2) & bit2) == val2)
493 if (irqs_disabled() || in_interrupt())
496 /* Repeatedly sleep for 1 ms until deadline */
497 while (time_is_after_jiffies(deadline)) {
498 schedule_timeout_uninterruptible(1);
499 if ((NCR5380_read(reg1) & bit1) == val1)
501 if ((NCR5380_read(reg2) & bit2) == val2)
508 static inline int NCR5380_poll_politely(struct Scsi_Host *instance,
509 int reg, int bit, int val, int wait)
511 return NCR5380_poll_politely2(instance, reg, bit, val,
512 reg, bit, val, wait);
520 { SR_DBP, "PARITY"}, { SR_RST, "RST" }, { SR_BSY, "BSY" },
521 { SR_REQ, "REQ" }, { SR_MSG, "MSG" }, { SR_CD, "CD" }, { SR_IO, "IO" },
522 { SR_SEL, "SEL" }, {0, NULL}
524 {BASR_ATN, "ATN"}, {BASR_ACK, "ACK"}, {0, NULL}
526 {ICR_ASSERT_RST, "ASSERT RST"},{ICR_ASSERT_ACK, "ASSERT ACK"},
527 {ICR_ASSERT_BSY, "ASSERT BSY"}, {ICR_ASSERT_SEL, "ASSERT SEL"},
528 {ICR_ASSERT_ATN, "ASSERT ATN"}, {ICR_ASSERT_DATA, "ASSERT DATA"},
531 {MR_BLOCK_DMA_MODE, "MODE BLOCK DMA"}, {MR_TARGET, "MODE TARGET"},
532 {MR_ENABLE_PAR_CHECK, "MODE PARITY CHECK"}, {MR_ENABLE_PAR_INTR,
533 "MODE PARITY INTR"}, {MR_ENABLE_EOP_INTR,"MODE EOP INTR"},
534 {MR_MONITOR_BSY, "MODE MONITOR BSY"},
535 {MR_DMA_MODE, "MODE DMA"}, {MR_ARBITRATE, "MODE ARBITRATION"},
540 * NCR5380_print - print scsi bus signals
541 * @instance: adapter state to dump
543 * Print the SCSI bus signals for debugging purposes
546 static void NCR5380_print(struct Scsi_Host *instance)
548 unsigned char status, data, basr, mr, icr, i;
550 data = NCR5380_read(CURRENT_SCSI_DATA_REG);
551 status = NCR5380_read(STATUS_REG);
552 mr = NCR5380_read(MODE_REG);
553 icr = NCR5380_read(INITIATOR_COMMAND_REG);
554 basr = NCR5380_read(BUS_AND_STATUS_REG);
556 printk("STATUS_REG: %02x ", status);
557 for (i = 0; signals[i].mask; ++i)
558 if (status & signals[i].mask)
559 printk(",%s", signals[i].name);
560 printk("\nBASR: %02x ", basr);
561 for (i = 0; basrs[i].mask; ++i)
562 if (basr & basrs[i].mask)
563 printk(",%s", basrs[i].name);
564 printk("\nICR: %02x ", icr);
565 for (i = 0; icrs[i].mask; ++i)
566 if (icr & icrs[i].mask)
567 printk(",%s", icrs[i].name);
568 printk("\nMODE: %02x ", mr);
569 for (i = 0; mrs[i].mask; ++i)
570 if (mr & mrs[i].mask)
571 printk(",%s", mrs[i].name);
579 {PHASE_DATAOUT, "DATAOUT"}, {PHASE_DATAIN, "DATAIN"}, {PHASE_CMDOUT, "CMDOUT"},
580 {PHASE_STATIN, "STATIN"}, {PHASE_MSGOUT, "MSGOUT"}, {PHASE_MSGIN, "MSGIN"},
581 {PHASE_UNKNOWN, "UNKNOWN"}
585 * NCR5380_print_phase - show SCSI phase
586 * @instance: adapter to dump
588 * Print the current SCSI phase for debugging purposes
593 static void NCR5380_print_phase(struct Scsi_Host *instance)
595 unsigned char status;
598 status = NCR5380_read(STATUS_REG);
599 if (!(status & SR_REQ))
600 printk(KERN_DEBUG "scsi%d: REQ not asserted, phase unknown.\n", HOSTNO);
602 for (i = 0; (phases[i].value != PHASE_UNKNOWN) &&
603 (phases[i].value != (status & PHASE_MASK)); ++i)
605 printk(KERN_DEBUG "scsi%d: phase %s\n", HOSTNO, phases[i].name);
612 * NCR58380_info - report driver and host information
613 * @instance: relevant scsi host instance
615 * For use as the host template info() handler.
620 static const char *NCR5380_info(struct Scsi_Host *instance)
622 struct NCR5380_hostdata *hostdata = shost_priv(instance);
624 return hostdata->info;
627 static void prepare_info(struct Scsi_Host *instance)
629 struct NCR5380_hostdata *hostdata = shost_priv(instance);
631 snprintf(hostdata->info, sizeof(hostdata->info),
632 "%s, io_port 0x%lx, n_io_port %d, "
633 "base 0x%lx, irq %d, "
634 "can_queue %d, cmd_per_lun %d, "
635 "sg_tablesize %d, this_id %d, "
638 instance->hostt->name, instance->io_port, instance->n_io_port,
639 instance->base, instance->irq,
640 instance->can_queue, instance->cmd_per_lun,
641 instance->sg_tablesize, instance->this_id,
642 hostdata->flags & FLAG_TAGGED_QUEUING ? "TAGGED_QUEUING " : "",
643 hostdata->flags & FLAG_TOSHIBA_DELAY ? "TOSHIBA_DELAY " : "",
660 * NCR5380_init - initialise an NCR5380
661 * @instance: adapter to configure
662 * @flags: control flags
664 * Initializes *instance and corresponding 5380 chip,
665 * with flags OR'd into the initial flags value.
667 * Notes : I assume that the host, hostno, and id bits have been
668 * set correctly. I don't care about the irq and other fields.
670 * Returns 0 for success
673 static int __init NCR5380_init(struct Scsi_Host *instance, int flags)
676 SETUP_HOSTDATA(instance);
677 unsigned long deadline;
679 hostdata->host = instance;
680 hostdata->id_mask = 1 << instance->this_id;
681 hostdata->id_higher_mask = 0;
682 for (i = hostdata->id_mask; i <= 0x80; i <<= 1)
683 if (i > hostdata->id_mask)
684 hostdata->id_higher_mask |= i;
685 for (i = 0; i < 8; ++i)
686 hostdata->busy[i] = 0;
690 #if defined (REAL_DMA)
691 hostdata->dma_len = 0;
693 spin_lock_init(&hostdata->lock);
694 hostdata->connected = NULL;
695 hostdata->issue_queue = NULL;
696 hostdata->disconnected_queue = NULL;
697 hostdata->flags = flags;
699 INIT_WORK(&hostdata->main_task, NCR5380_main);
700 hostdata->work_q = alloc_workqueue("ncr5380_%d",
701 WQ_UNBOUND | WQ_MEM_RECLAIM,
702 1, instance->host_no);
703 if (!hostdata->work_q)
706 prepare_info(instance);
708 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
709 NCR5380_write(MODE_REG, MR_BASE);
710 NCR5380_write(TARGET_COMMAND_REG, 0);
711 NCR5380_write(SELECT_ENABLE_REG, 0);
713 /* Calibrate register polling loop */
715 deadline = jiffies + 1;
718 } while (time_is_after_jiffies(deadline));
719 deadline += msecs_to_jiffies(256);
721 NCR5380_read(STATUS_REG);
724 } while (time_is_after_jiffies(deadline));
725 hostdata->accesses_per_ms = i / 256;
731 * NCR5380_maybe_reset_bus - Detect and correct bus wedge problems.
732 * @instance: adapter to check
734 * If the system crashed, it may have crashed with a connected target and
735 * the SCSI bus busy. Check for BUS FREE phase. If not, try to abort the
736 * currently established nexus, which we know nothing about. Failing that
739 * Note that a bus reset will cause the chip to assert IRQ.
741 * Returns 0 if successful, otherwise -ENXIO.
744 static int NCR5380_maybe_reset_bus(struct Scsi_Host *instance)
746 struct NCR5380_hostdata *hostdata = shost_priv(instance);
749 for (pass = 1; (NCR5380_read(STATUS_REG) & SR_BSY) && pass <= 6; ++pass) {
754 shost_printk(KERN_ERR, instance, "SCSI bus busy, waiting up to five seconds\n");
755 NCR5380_poll_politely(instance,
756 STATUS_REG, SR_BSY, 0, 5 * HZ);
759 shost_printk(KERN_ERR, instance, "bus busy, attempting abort\n");
763 shost_printk(KERN_ERR, instance, "bus busy, attempting reset\n");
765 /* Wait after a reset; the SCSI standard calls for
766 * 250ms, we wait 500ms to be on the safe side.
767 * But some Toshiba CD-ROMs need ten times that.
769 if (hostdata->flags & FLAG_TOSHIBA_DELAY)
775 shost_printk(KERN_ERR, instance, "bus locked solid\n");
783 * NCR5380_exit - remove an NCR5380
784 * @instance: adapter to remove
786 * Assumes that no more work can be queued (e.g. by NCR5380_intr).
789 static void NCR5380_exit(struct Scsi_Host *instance)
791 struct NCR5380_hostdata *hostdata = shost_priv(instance);
793 cancel_work_sync(&hostdata->main_task);
794 destroy_workqueue(hostdata->work_q);
798 * NCR5380_queue_command - queue a command
799 * @instance: the relevant SCSI adapter
802 * cmd is added to the per-instance issue queue, with minor
803 * twiddling done to the host specific fields of cmd. If the
804 * main coroutine is not running, it is restarted.
807 static int NCR5380_queue_command(struct Scsi_Host *instance,
808 struct scsi_cmnd *cmd)
810 struct NCR5380_hostdata *hostdata = shost_priv(instance);
811 struct scsi_cmnd *tmp;
814 #if (NDEBUG & NDEBUG_NO_WRITE)
815 switch (cmd->cmnd[0]) {
818 shost_printk(KERN_DEBUG, instance, "WRITE attempted with NDEBUG_NO_WRITE set\n");
819 cmd->result = (DID_ERROR << 16);
823 #endif /* (NDEBUG & NDEBUG_NO_WRITE) */
826 * We use the host_scribble field as a pointer to the next command
834 * Insert the cmd into the issue queue. Note that REQUEST SENSE
835 * commands are added to the head of the queue since any command will
836 * clear the contingent allegiance condition that exists and the
837 * sense data is only guaranteed to be valid while the condition exists.
840 /* ++guenther: now that the issue queue is being set up, we can lock ST-DMA.
841 * Otherwise a running NCR5380_main may steal the lock.
842 * Lock before actually inserting due to fairness reasons explained in
843 * atari_scsi.c. If we insert first, then it's impossible for this driver
844 * to release the lock.
845 * Stop timer for this command while waiting for the lock, or timeouts
846 * may happen (and they really do), and it's no good if the command doesn't
847 * appear in any of the queues.
848 * ++roman: Just disabling the NCR interrupt isn't sufficient here,
849 * because also a timer int can trigger an abort or reset, which would
850 * alter queues and touch the lock.
852 if (!NCR5380_acquire_dma_irq(instance))
853 return SCSI_MLQUEUE_HOST_BUSY;
855 spin_lock_irqsave(&hostdata->lock, flags);
858 * Insert the cmd into the issue queue. Note that REQUEST SENSE
859 * commands are added to the head of the queue since any command will
860 * clear the contingent allegiance condition that exists and the
861 * sense data is only guaranteed to be valid while the condition exists.
864 if (!(hostdata->issue_queue) || (cmd->cmnd[0] == REQUEST_SENSE)) {
865 LIST(cmd, hostdata->issue_queue);
866 SET_NEXT(cmd, hostdata->issue_queue);
867 hostdata->issue_queue = cmd;
869 for (tmp = (struct scsi_cmnd *)hostdata->issue_queue;
870 NEXT(tmp); tmp = NEXT(tmp))
875 spin_unlock_irqrestore(&hostdata->lock, flags);
877 dsprintk(NDEBUG_QUEUES, instance, "command %p added to %s of queue\n",
878 cmd, (cmd->cmnd[0] == REQUEST_SENSE) ? "head" : "tail");
880 /* Kick off command processing */
881 queue_work(hostdata->work_q, &hostdata->main_task);
885 static inline void maybe_release_dma_irq(struct Scsi_Host *instance)
887 struct NCR5380_hostdata *hostdata = shost_priv(instance);
889 /* Caller does the locking needed to set & test these data atomically */
890 if (!hostdata->disconnected_queue &&
891 !hostdata->issue_queue &&
892 !hostdata->connected &&
893 !hostdata->retain_dma_intr)
894 NCR5380_release_dma_irq(instance);
898 * NCR5380_main - NCR state machines
900 * NCR5380_main is a coroutine that runs as long as more work can
901 * be done on the NCR5380 host adapters in a system. Both
902 * NCR5380_queue_command() and NCR5380_intr() will try to start it
903 * in case it is not running.
905 * Locks: called as its own thread with no locks held.
908 static void NCR5380_main(struct work_struct *work)
910 struct NCR5380_hostdata *hostdata =
911 container_of(work, struct NCR5380_hostdata, main_task);
912 struct Scsi_Host *instance = hostdata->host;
913 struct scsi_cmnd *tmp, *prev;
917 * ++roman: Just disabling the NCR interrupt isn't sufficient here,
918 * because also a timer int can trigger an abort or reset, which can
919 * alter queues and touch the Falcon lock.
922 spin_lock_irq(&hostdata->lock);
926 if (!hostdata->connected) {
927 dprintk(NDEBUG_MAIN, "scsi%d: not connected\n", HOSTNO);
929 * Search through the issue_queue for a command destined
930 * for a target that's not busy.
932 #if (NDEBUG & NDEBUG_LISTS)
933 for (tmp = (struct scsi_cmnd *) hostdata->issue_queue, prev = NULL;
934 tmp && (tmp != prev); prev = tmp, tmp = NEXT(tmp))
936 /*printk("%p ", tmp);*/
937 if ((tmp == prev) && tmp)
939 /* else printk("\n"); */
941 for (tmp = (struct scsi_cmnd *) hostdata->issue_queue,
942 prev = NULL; tmp; prev = tmp, tmp = NEXT(tmp)) {
943 u8 lun = tmp->device->lun;
945 dprintk(NDEBUG_LISTS,
946 "MAIN tmp=%p target=%d busy=%d lun=%d\n",
947 tmp, scmd_id(tmp), hostdata->busy[scmd_id(tmp)],
949 /* When we find one, remove it from the issue queue. */
952 !is_lun_busy( tmp, tmp->cmnd[0] != REQUEST_SENSE)
954 !(hostdata->busy[tmp->device->id] & (1 << lun))
958 REMOVE(prev, NEXT(prev), tmp, NEXT(tmp));
959 SET_NEXT(prev, NEXT(tmp));
961 REMOVE(-1, hostdata->issue_queue, tmp, NEXT(tmp));
962 hostdata->issue_queue = NEXT(tmp);
965 hostdata->retain_dma_intr++;
968 * Attempt to establish an I_T_L nexus here.
969 * On success, instance->hostdata->connected is set.
970 * On failure, we must add the command back to the
971 * issue queue so we can keep trying.
973 dprintk(NDEBUG_MAIN, "scsi%d: main(): command for target %d "
974 "lun %d removed from issue_queue\n",
975 HOSTNO, tmp->device->id, lun);
977 * REQUEST SENSE commands are issued without tagged
978 * queueing, even on SCSI-II devices because the
979 * contingent allegiance condition exists for the
982 /* ++roman: ...and the standard also requires that
983 * REQUEST SENSE command are untagged.
987 cmd_get_tag(tmp, tmp->cmnd[0] != REQUEST_SENSE);
989 if (!NCR5380_select(instance, tmp)) {
990 /* OK or bad target */
991 hostdata->retain_dma_intr--;
992 maybe_release_dma_irq(instance);
995 LIST(tmp, hostdata->issue_queue);
996 SET_NEXT(tmp, hostdata->issue_queue);
997 hostdata->issue_queue = tmp;
1001 hostdata->retain_dma_intr--;
1003 dprintk(NDEBUG_MAIN, "scsi%d: main(): select() failed, "
1004 "returned to issue_queue\n", HOSTNO);
1006 if (hostdata->connected)
1008 } /* if target/lun/target queue is not busy */
1009 } /* for issue_queue */
1010 } /* if (!hostdata->connected) */
1012 if (hostdata->connected
1014 && !hostdata->dma_len
1017 dprintk(NDEBUG_MAIN, "scsi%d: main: performing information transfer\n",
1019 NCR5380_information_transfer(instance);
1020 dprintk(NDEBUG_MAIN, "scsi%d: main: done set false\n", HOSTNO);
1024 spin_unlock_irq(&hostdata->lock);
1030 * Function : void NCR5380_dma_complete (struct Scsi_Host *instance)
1032 * Purpose : Called by interrupt handler when DMA finishes or a phase
1033 * mismatch occurs (which would finish the DMA transfer).
1035 * Inputs : instance - this instance of the NCR5380.
1039 static void NCR5380_dma_complete(struct Scsi_Host *instance)
1041 SETUP_HOSTDATA(instance);
1043 unsigned char **data;
1044 volatile int *count;
1045 int saved_data = 0, overrun = 0;
1048 if (hostdata->read_overruns) {
1049 p = hostdata->connected->SCp.phase;
1052 if ((NCR5380_read(BUS_AND_STATUS_REG) &
1053 (BASR_PHASE_MATCH|BASR_ACK)) ==
1054 (BASR_PHASE_MATCH|BASR_ACK)) {
1055 saved_data = NCR5380_read(INPUT_DATA_REG);
1057 dprintk(NDEBUG_DMA, "scsi%d: read overrun handled\n", HOSTNO);
1062 #if defined(CONFIG_SUN3)
1063 if ((sun3scsi_dma_finish(rq_data_dir(hostdata->connected->request)))) {
1064 pr_err("scsi%d: overrun in UDC counter -- not prepared to deal with this!\n",
1069 /* make sure we're not stuck in a data phase */
1070 if ((NCR5380_read(BUS_AND_STATUS_REG) & (BASR_PHASE_MATCH | BASR_ACK)) ==
1071 (BASR_PHASE_MATCH | BASR_ACK)) {
1072 pr_err("scsi%d: BASR %02x\n", instance->host_no,
1073 NCR5380_read(BUS_AND_STATUS_REG));
1074 pr_err("scsi%d: bus stuck in data phase -- probably a single byte overrun!\n",
1080 NCR5380_write(MODE_REG, MR_BASE);
1081 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
1082 NCR5380_read(RESET_PARITY_INTERRUPT_REG);
1084 transferred = hostdata->dma_len - NCR5380_dma_residual(instance);
1085 hostdata->dma_len = 0;
1087 data = (unsigned char **)&hostdata->connected->SCp.ptr;
1088 count = &hostdata->connected->SCp.this_residual;
1089 *data += transferred;
1090 *count -= transferred;
1092 if (hostdata->read_overruns) {
1095 if ((NCR5380_read(STATUS_REG) & PHASE_MASK) == p && (p & SR_IO)) {
1096 cnt = toPIO = hostdata->read_overruns;
1098 dprintk(NDEBUG_DMA, "Got an input overrun, using saved byte\n");
1099 *(*data)++ = saved_data;
1104 dprintk(NDEBUG_DMA, "Doing %d-byte PIO to 0x%08lx\n", cnt, (long)*data);
1105 NCR5380_transfer_pio(instance, &p, &cnt, data);
1106 *count -= toPIO - cnt;
1110 #endif /* REAL_DMA */
1114 * NCR5380_intr - generic NCR5380 irq handler
1115 * @irq: interrupt number
1116 * @dev_id: device info
1118 * Handle interrupts, reestablishing I_T_L or I_T_L_Q nexuses
1119 * from the disconnected queue, and restarting NCR5380_main()
1122 * The chip can assert IRQ in any of six different conditions. The IRQ flag
1123 * is then cleared by reading the Reset Parity/Interrupt Register (RPIR).
1124 * Three of these six conditions are latched in the Bus and Status Register:
1125 * - End of DMA (cleared by ending DMA Mode)
1126 * - Parity error (cleared by reading RPIR)
1127 * - Loss of BSY (cleared by reading RPIR)
1128 * Two conditions have flag bits that are not latched:
1129 * - Bus phase mismatch (non-maskable in DMA Mode, cleared by ending DMA Mode)
1130 * - Bus reset (non-maskable)
1131 * The remaining condition has no flag bit at all:
1132 * - Selection/reselection
1134 * Hence, establishing the cause(s) of any interrupt is partly guesswork.
1135 * In "The DP8490 and DP5380 Comparison Guide", National Semiconductor
1136 * claimed that "the design of the [DP8490] interrupt logic ensures
1137 * interrupts will not be lost (they can be on the DP5380)."
1138 * The L5380/53C80 datasheet from LOGIC Devices has more details.
1140 * Checking for bus reset by reading RST is futile because of interrupt
1141 * latency, but a bus reset will reset chip logic. Checking for parity error
1142 * is unnecessary because that interrupt is never enabled. A Loss of BSY
1143 * condition will clear DMA Mode. We can tell when this occurs because the
1144 * the Busy Monitor interrupt is enabled together with DMA Mode.
1147 static irqreturn_t NCR5380_intr(int irq, void *dev_id)
1149 struct Scsi_Host *instance = dev_id;
1150 struct NCR5380_hostdata *hostdata = shost_priv(instance);
1153 unsigned long flags;
1155 spin_lock_irqsave(&hostdata->lock, flags);
1157 basr = NCR5380_read(BUS_AND_STATUS_REG);
1158 if (basr & BASR_IRQ) {
1159 unsigned char mr = NCR5380_read(MODE_REG);
1160 unsigned char sr = NCR5380_read(STATUS_REG);
1162 dprintk(NDEBUG_INTR, "scsi%d: IRQ %d, BASR 0x%02x, SR 0x%02x, MR 0x%02x\n",
1163 HOSTNO, irq, basr, sr, mr);
1165 #if defined(REAL_DMA)
1166 if ((mr & MR_DMA_MODE) || (mr & MR_MONITOR_BSY)) {
1167 /* Probably End of DMA, Phase Mismatch or Loss of BSY.
1168 * We ack IRQ after clearing Mode Register. Workarounds
1169 * for End of DMA errata need to happen in DMA Mode.
1172 dprintk(NDEBUG_INTR, "scsi%d: interrupt in DMA mode\n", HOSTNO);
1174 if (hostdata->connected) {
1175 NCR5380_dma_complete(instance);
1176 queue_work(hostdata->work_q, &hostdata->main_task);
1178 NCR5380_write(MODE_REG, MR_BASE);
1179 NCR5380_read(RESET_PARITY_INTERRUPT_REG);
1182 #endif /* REAL_DMA */
1183 if ((NCR5380_read(CURRENT_SCSI_DATA_REG) & hostdata->id_mask) &&
1184 (sr & (SR_SEL | SR_IO | SR_BSY | SR_RST)) == (SR_SEL | SR_IO)) {
1185 /* Probably reselected */
1186 NCR5380_write(SELECT_ENABLE_REG, 0);
1187 NCR5380_read(RESET_PARITY_INTERRUPT_REG);
1189 dprintk(NDEBUG_INTR, "scsi%d: interrupt with SEL and IO\n",
1192 if (!hostdata->connected) {
1193 NCR5380_reselect(instance);
1194 queue_work(hostdata->work_q, &hostdata->main_task);
1196 if (!hostdata->connected)
1197 NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
1199 /* Probably Bus Reset */
1200 NCR5380_read(RESET_PARITY_INTERRUPT_REG);
1202 dprintk(NDEBUG_INTR, "scsi%d: unknown interrupt\n", HOSTNO);
1203 #ifdef SUN3_SCSI_VME
1204 dregs->csr |= CSR_DMA_ENABLE;
1209 shost_printk(KERN_NOTICE, instance, "interrupt without IRQ bit\n");
1210 #ifdef SUN3_SCSI_VME
1211 dregs->csr |= CSR_DMA_ENABLE;
1215 spin_unlock_irqrestore(&hostdata->lock, flags);
1217 return IRQ_RETVAL(handled);
1221 * Function : int NCR5380_select(struct Scsi_Host *instance,
1222 * struct scsi_cmnd *cmd)
1224 * Purpose : establishes I_T_L or I_T_L_Q nexus for new or existing command,
1225 * including ARBITRATION, SELECTION, and initial message out for
1226 * IDENTIFY and queue messages.
1228 * Inputs : instance - instantiation of the 5380 driver on which this
1229 * target lives, cmd - SCSI command to execute.
1231 * Returns : -1 if selection failed but should be retried.
1232 * 0 if selection failed and should not be retried.
1233 * 0 if selection succeeded completely (hostdata->connected == cmd).
1236 * If bus busy, arbitration failed, etc, NCR5380_select() will exit
1237 * with registers as they should have been on entry - ie
1238 * SELECT_ENABLE will be set appropriately, the NCR5380
1239 * will cease to drive any SCSI bus signals.
1241 * If successful : I_T_L or I_T_L_Q nexus will be established,
1242 * instance->connected will be set to cmd.
1243 * SELECT interrupt will be disabled.
1245 * If failed (no target) : cmd->scsi_done() will be called, and the
1246 * cmd->result host byte set to DID_BAD_TARGET.
1249 static int NCR5380_select(struct Scsi_Host *instance, struct scsi_cmnd *cmd)
1251 SETUP_HOSTDATA(instance);
1252 unsigned char tmp[3], phase;
1253 unsigned char *data;
1257 NCR5380_dprint(NDEBUG_ARBITRATION, instance);
1258 dprintk(NDEBUG_ARBITRATION, "scsi%d: starting arbitration, id = %d\n", HOSTNO,
1262 * Set the phase bits to 0, otherwise the NCR5380 won't drive the
1263 * data bus during SELECTION.
1266 NCR5380_write(TARGET_COMMAND_REG, 0);
1269 * Start arbitration.
1272 NCR5380_write(OUTPUT_DATA_REG, hostdata->id_mask);
1273 NCR5380_write(MODE_REG, MR_ARBITRATE);
1275 /* The chip now waits for BUS FREE phase. Then after the 800 ns
1276 * Bus Free Delay, arbitration will begin.
1279 spin_unlock_irq(&hostdata->lock);
1280 err = NCR5380_poll_politely2(instance, MODE_REG, MR_ARBITRATE, 0,
1281 INITIATOR_COMMAND_REG, ICR_ARBITRATION_PROGRESS,
1282 ICR_ARBITRATION_PROGRESS, HZ);
1283 spin_lock_irq(&hostdata->lock);
1284 if (!(NCR5380_read(MODE_REG) & MR_ARBITRATE)) {
1285 /* Reselection interrupt */
1289 NCR5380_write(MODE_REG, MR_BASE);
1290 shost_printk(KERN_ERR, instance,
1291 "select: arbitration timeout\n");
1294 spin_unlock_irq(&hostdata->lock);
1296 /* The SCSI-2 arbitration delay is 2.4 us */
1299 /* Check for lost arbitration */
1300 if ((NCR5380_read(INITIATOR_COMMAND_REG) & ICR_ARBITRATION_LOST) ||
1301 (NCR5380_read(CURRENT_SCSI_DATA_REG) & hostdata->id_higher_mask) ||
1302 (NCR5380_read(INITIATOR_COMMAND_REG) & ICR_ARBITRATION_LOST)) {
1303 NCR5380_write(MODE_REG, MR_BASE);
1304 dprintk(NDEBUG_ARBITRATION, "scsi%d: lost arbitration, deasserting MR_ARBITRATE\n",
1306 spin_lock_irq(&hostdata->lock);
1310 /* After/during arbitration, BSY should be asserted.
1311 * IBM DPES-31080 Version S31Q works now
1312 * Tnx to Thomas_Roesch@m2.maus.de for finding this! (Roman)
1314 NCR5380_write(INITIATOR_COMMAND_REG,
1315 ICR_BASE | ICR_ASSERT_SEL | ICR_ASSERT_BSY);
1318 * Again, bus clear + bus settle time is 1.2us, however, this is
1319 * a minimum so we'll udelay ceil(1.2)
1322 if (hostdata->flags & FLAG_TOSHIBA_DELAY)
1327 spin_lock_irq(&hostdata->lock);
1329 /* NCR5380_reselect() clears MODE_REG after a reselection interrupt */
1330 if (!(NCR5380_read(MODE_REG) & MR_ARBITRATE))
1333 dprintk(NDEBUG_ARBITRATION, "scsi%d: won arbitration\n", HOSTNO);
1336 * Now that we have won arbitration, start Selection process, asserting
1337 * the host and target ID's on the SCSI bus.
1340 NCR5380_write(OUTPUT_DATA_REG, (hostdata->id_mask | (1 << cmd->device->id)));
1343 * Raise ATN while SEL is true before BSY goes false from arbitration,
1344 * since this is the only way to guarantee that we'll get a MESSAGE OUT
1345 * phase immediately after selection.
1348 NCR5380_write(INITIATOR_COMMAND_REG, (ICR_BASE | ICR_ASSERT_BSY |
1349 ICR_ASSERT_DATA | ICR_ASSERT_ATN | ICR_ASSERT_SEL ));
1350 NCR5380_write(MODE_REG, MR_BASE);
1353 * Reselect interrupts must be turned off prior to the dropping of BSY,
1354 * otherwise we will trigger an interrupt.
1356 NCR5380_write(SELECT_ENABLE_REG, 0);
1358 spin_unlock_irq(&hostdata->lock);
1361 * The initiator shall then wait at least two deskew delays and release
1364 udelay(1); /* wingel -- wait two bus deskew delay >2*45ns */
1367 NCR5380_write(INITIATOR_COMMAND_REG, (ICR_BASE | ICR_ASSERT_DATA |
1368 ICR_ASSERT_ATN | ICR_ASSERT_SEL));
1371 * Something weird happens when we cease to drive BSY - looks
1372 * like the board/chip is letting us do another read before the
1373 * appropriate propagation delay has expired, and we're confusing
1374 * a BSY signal from ourselves as the target's response to SELECTION.
1376 * A small delay (the 'C++' frontend breaks the pipeline with an
1377 * unnecessary jump, making it work on my 386-33/Trantor T128, the
1378 * tighter 'C' code breaks and requires this) solves the problem -
1379 * the 1 us delay is arbitrary, and only used because this delay will
1380 * be the same on other platforms and since it works here, it should
1383 * wingel suggests that this could be due to failing to wait
1389 dprintk(NDEBUG_SELECTION, "scsi%d: selecting target %d\n", HOSTNO, cmd->device->id);
1392 * The SCSI specification calls for a 250 ms timeout for the actual
1396 err = NCR5380_poll_politely(instance, STATUS_REG, SR_BSY, SR_BSY,
1397 msecs_to_jiffies(250));
1399 if ((NCR5380_read(STATUS_REG) & (SR_SEL | SR_IO)) == (SR_SEL | SR_IO)) {
1400 spin_lock_irq(&hostdata->lock);
1401 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
1402 NCR5380_reselect(instance);
1403 if (!hostdata->connected)
1404 NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
1405 printk(KERN_ERR "scsi%d: reselection after won arbitration?\n",
1411 spin_lock_irq(&hostdata->lock);
1412 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
1413 cmd->result = DID_BAD_TARGET << 16;
1417 cmd->scsi_done(cmd);
1418 NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
1419 dprintk(NDEBUG_SELECTION, "scsi%d: target did not respond within 250ms\n", HOSTNO);
1424 * No less than two deskew delays after the initiator detects the
1425 * BSY signal is true, it shall release the SEL signal and may
1426 * change the DATA BUS. -wingel
1431 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN);
1434 * Since we followed the SCSI spec, and raised ATN while SEL
1435 * was true but before BSY was false during selection, the information
1436 * transfer phase should be a MESSAGE OUT phase so that we can send the
1439 * If SCSI-II tagged queuing is enabled, we also send a SIMPLE_QUEUE_TAG
1440 * message (2 bytes) with a tag ID that we increment with every command
1441 * until it wraps back to 0.
1443 * XXX - it turns out that there are some broken SCSI-II devices,
1444 * which claim to support tagged queuing but fail when more than
1445 * some number of commands are issued at once.
1448 /* Wait for start of REQ/ACK handshake */
1450 err = NCR5380_poll_politely(instance, STATUS_REG, SR_REQ, SR_REQ, HZ);
1451 spin_lock_irq(&hostdata->lock);
1453 shost_printk(KERN_ERR, instance, "select: REQ timeout\n");
1454 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
1455 NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
1459 dprintk(NDEBUG_SELECTION, "scsi%d: target %d selected, going into MESSAGE OUT phase.\n",
1460 HOSTNO, cmd->device->id);
1461 tmp[0] = IDENTIFY(1, cmd->device->lun);
1464 if (cmd->tag != TAG_NONE) {
1465 tmp[1] = hostdata->last_message = SIMPLE_QUEUE_TAG;
1473 #endif /* SUPPORT_TAGS */
1475 /* Send message(s) */
1477 phase = PHASE_MSGOUT;
1478 NCR5380_transfer_pio(instance, &phase, &len, &data);
1479 dprintk(NDEBUG_SELECTION, "scsi%d: nexus established.\n", HOSTNO);
1480 /* XXX need to handle errors here */
1482 hostdata->connected = cmd;
1483 #ifndef SUPPORT_TAGS
1484 hostdata->busy[cmd->device->id] |= (1 << cmd->device->lun);
1486 #ifdef SUN3_SCSI_VME
1487 dregs->csr |= CSR_INTR;
1490 initialize_SCp(cmd);
1496 * Function : int NCR5380_transfer_pio (struct Scsi_Host *instance,
1497 * unsigned char *phase, int *count, unsigned char **data)
1499 * Purpose : transfers data in given phase using polled I/O
1501 * Inputs : instance - instance of driver, *phase - pointer to
1502 * what phase is expected, *count - pointer to number of
1503 * bytes to transfer, **data - pointer to data pointer.
1505 * Returns : -1 when different phase is entered without transferring
1506 * maximum number of bytes, 0 if all bytes are transferred or exit
1509 * Also, *phase, *count, *data are modified in place.
1511 * XXX Note : handling for bus free may be useful.
1515 * Note : this code is not as quick as it could be, however it
1516 * IS 100% reliable, and for the actual data transfer where speed
1517 * counts, we will always do a pseudo DMA or DMA transfer.
1520 static int NCR5380_transfer_pio(struct Scsi_Host *instance,
1521 unsigned char *phase, int *count,
1522 unsigned char **data)
1524 register unsigned char p = *phase, tmp;
1525 register int c = *count;
1526 register unsigned char *d = *data;
1529 * The NCR5380 chip will only drive the SCSI bus when the
1530 * phase specified in the appropriate bits of the TARGET COMMAND
1531 * REGISTER match the STATUS REGISTER
1534 NCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(p));
1538 * Wait for assertion of REQ, after which the phase bits will be
1542 if (NCR5380_poll_politely(instance, STATUS_REG, SR_REQ, SR_REQ, HZ) < 0)
1545 dprintk(NDEBUG_HANDSHAKE, "scsi%d: REQ detected\n", HOSTNO);
1547 /* Check for phase mismatch */
1548 if ((NCR5380_read(STATUS_REG) & PHASE_MASK) != p) {
1549 dprintk(NDEBUG_PIO, "scsi%d: phase mismatch\n", HOSTNO);
1550 NCR5380_dprint_phase(NDEBUG_PIO, instance);
1554 /* Do actual transfer from SCSI bus to / from memory */
1556 NCR5380_write(OUTPUT_DATA_REG, *d);
1558 *d = NCR5380_read(CURRENT_SCSI_DATA_REG);
1563 * The SCSI standard suggests that in MSGOUT phase, the initiator
1564 * should drop ATN on the last byte of the message phase
1565 * after REQ has been asserted for the handshake but before
1566 * the initiator raises ACK.
1570 if (!((p & SR_MSG) && c > 1)) {
1571 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_DATA);
1572 NCR5380_dprint(NDEBUG_PIO, instance);
1573 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE |
1574 ICR_ASSERT_DATA | ICR_ASSERT_ACK);
1576 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE |
1577 ICR_ASSERT_DATA | ICR_ASSERT_ATN);
1578 NCR5380_dprint(NDEBUG_PIO, instance);
1579 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE |
1580 ICR_ASSERT_DATA | ICR_ASSERT_ATN | ICR_ASSERT_ACK);
1583 NCR5380_dprint(NDEBUG_PIO, instance);
1584 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ACK);
1587 if (NCR5380_poll_politely(instance,
1588 STATUS_REG, SR_REQ, 0, 5 * HZ) < 0)
1591 dprintk(NDEBUG_HANDSHAKE, "scsi%d: req false, handshake complete\n", HOSTNO);
1594 * We have several special cases to consider during REQ/ACK handshaking :
1595 * 1. We were in MSGOUT phase, and we are on the last byte of the
1596 * message. ATN must be dropped as ACK is dropped.
1598 * 2. We are in a MSGIN phase, and we are on the last byte of the
1599 * message. We must exit with ACK asserted, so that the calling
1600 * code may raise ATN before dropping ACK to reject the message.
1602 * 3. ACK and ATN are clear and the target may proceed as normal.
1604 if (!(p == PHASE_MSGIN && c == 1)) {
1605 if (p == PHASE_MSGOUT && c > 1)
1606 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN);
1608 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
1612 dprintk(NDEBUG_PIO, "scsi%d: residual %d\n", HOSTNO, c);
1616 tmp = NCR5380_read(STATUS_REG);
1617 /* The phase read from the bus is valid if either REQ is (already)
1618 * asserted or if ACK hasn't been released yet. The latter applies if
1619 * we're in MSG IN, DATA IN or STATUS and all bytes have been received.
1621 if ((tmp & SR_REQ) || ((tmp & SR_IO) && c == 0))
1622 *phase = tmp & PHASE_MASK;
1624 *phase = PHASE_UNKNOWN;
1626 if (!c || (*phase == p))
1633 * do_reset - issue a reset command
1634 * @instance: adapter to reset
1636 * Issue a reset sequence to the NCR5380 and try and get the bus
1637 * back into sane shape.
1639 * This clears the reset interrupt flag because there may be no handler for
1640 * it. When the driver is initialized, the NCR5380_intr() handler has not yet
1641 * been installed. And when in EH we may have released the ST DMA interrupt.
1644 static void do_reset(struct Scsi_Host *instance)
1646 unsigned long flags;
1648 local_irq_save(flags);
1649 NCR5380_write(TARGET_COMMAND_REG,
1650 PHASE_SR_TO_TCR(NCR5380_read(STATUS_REG) & PHASE_MASK));
1651 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_RST);
1653 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
1654 (void)NCR5380_read(RESET_PARITY_INTERRUPT_REG);
1655 local_irq_restore(flags);
1659 * do_abort - abort the currently established nexus by going to
1660 * MESSAGE OUT phase and sending an ABORT message.
1661 * @instance: relevant scsi host instance
1663 * Returns 0 on success, -1 on failure.
1666 static int do_abort(struct Scsi_Host *instance)
1668 unsigned char tmp, *msgptr, phase;
1672 /* Request message out phase */
1673 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN);
1676 * Wait for the target to indicate a valid phase by asserting
1677 * REQ. Once this happens, we'll have either a MSGOUT phase
1678 * and can immediately send the ABORT message, or we'll have some
1679 * other phase and will have to source/sink data.
1681 * We really don't care what value was on the bus or what value
1682 * the target sees, so we just handshake.
1685 rc = NCR5380_poll_politely(instance, STATUS_REG, SR_REQ, SR_REQ, 10 * HZ);
1689 tmp = NCR5380_read(STATUS_REG) & PHASE_MASK;
1691 NCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(tmp));
1693 if (tmp != PHASE_MSGOUT) {
1694 NCR5380_write(INITIATOR_COMMAND_REG,
1695 ICR_BASE | ICR_ASSERT_ATN | ICR_ASSERT_ACK);
1696 rc = NCR5380_poll_politely(instance, STATUS_REG, SR_REQ, 0, 3 * HZ);
1699 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN);
1705 phase = PHASE_MSGOUT;
1706 NCR5380_transfer_pio(instance, &phase, &len, &msgptr);
1709 * If we got here, and the command completed successfully,
1710 * we're about to go into bus free state.
1713 return len ? -1 : 0;
1716 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
1720 #if defined(REAL_DMA)
1722 * Function : int NCR5380_transfer_dma (struct Scsi_Host *instance,
1723 * unsigned char *phase, int *count, unsigned char **data)
1725 * Purpose : transfers data in given phase using either real
1728 * Inputs : instance - instance of driver, *phase - pointer to
1729 * what phase is expected, *count - pointer to number of
1730 * bytes to transfer, **data - pointer to data pointer.
1732 * Returns : -1 when different phase is entered without transferring
1733 * maximum number of bytes, 0 if all bytes or transferred or exit
1736 * Also, *phase, *count, *data are modified in place.
1741 static int NCR5380_transfer_dma(struct Scsi_Host *instance,
1742 unsigned char *phase, int *count,
1743 unsigned char **data)
1745 SETUP_HOSTDATA(instance);
1746 register int c = *count;
1747 register unsigned char p = *phase;
1749 #if defined(CONFIG_SUN3)
1751 if (!sun3_dma_setup_done) {
1752 pr_err("scsi%d: transfer_dma without setup!\n",
1756 hostdata->dma_len = c;
1758 dprintk(NDEBUG_DMA, "scsi%d: initializing DMA for %s, %d bytes %s %p\n",
1759 instance->host_no, (p & SR_IO) ? "reading" : "writing",
1760 c, (p & SR_IO) ? "to" : "from", *data);
1762 /* netbsd turns off ints here, why not be safe and do it too */
1764 /* send start chain */
1765 sun3scsi_dma_start(c, *data);
1767 NCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(p));
1768 NCR5380_write(MODE_REG, MR_BASE | MR_DMA_MODE | MR_MONITOR_BSY |
1769 MR_ENABLE_EOP_INTR);
1771 NCR5380_write(INITIATOR_COMMAND_REG, 0);
1772 NCR5380_write(START_DMA_INITIATOR_RECEIVE_REG, 0);
1774 NCR5380_write(INITIATOR_COMMAND_REG, ICR_ASSERT_DATA);
1775 NCR5380_write(START_DMA_SEND_REG, 0);
1778 #ifdef SUN3_SCSI_VME
1779 dregs->csr |= CSR_DMA_ENABLE;
1782 sun3_dma_active = 1;
1784 #else /* !defined(CONFIG_SUN3) */
1785 register unsigned char *d = *data;
1788 if ((tmp = (NCR5380_read(STATUS_REG) & PHASE_MASK)) != p) {
1793 if (hostdata->read_overruns && (p & SR_IO))
1794 c -= hostdata->read_overruns;
1796 dprintk(NDEBUG_DMA, "scsi%d: initializing DMA for %s, %d bytes %s %p\n",
1797 HOSTNO, (p & SR_IO) ? "reading" : "writing",
1798 c, (p & SR_IO) ? "to" : "from", d);
1800 NCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(p));
1801 NCR5380_write(MODE_REG, MR_BASE | MR_DMA_MODE | MR_MONITOR_BSY |
1802 MR_ENABLE_EOP_INTR);
1804 if (!(hostdata->flags & FLAG_LATE_DMA_SETUP)) {
1805 /* On the Medusa, it is a must to initialize the DMA before
1806 * starting the NCR. This is also the cleaner way for the TT.
1808 hostdata->dma_len = (p & SR_IO) ?
1809 NCR5380_dma_read_setup(instance, d, c) :
1810 NCR5380_dma_write_setup(instance, d, c);
1814 NCR5380_write(START_DMA_INITIATOR_RECEIVE_REG, 0);
1816 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_DATA);
1817 NCR5380_write(START_DMA_SEND_REG, 0);
1820 if (hostdata->flags & FLAG_LATE_DMA_SETUP) {
1821 /* On the Falcon, the DMA setup must be done after the last */
1822 /* NCR access, else the DMA setup gets trashed!
1824 hostdata->dma_len = (p & SR_IO) ?
1825 NCR5380_dma_read_setup(instance, d, c) :
1826 NCR5380_dma_write_setup(instance, d, c);
1828 #endif /* !defined(CONFIG_SUN3) */
1832 #endif /* defined(REAL_DMA) */
1835 * Function : NCR5380_information_transfer (struct Scsi_Host *instance)
1837 * Purpose : run through the various SCSI phases and do as the target
1838 * directs us to. Operates on the currently connected command,
1839 * instance->connected.
1841 * Inputs : instance, instance for which we are doing commands
1843 * Side effects : SCSI things happen, the disconnected queue will be
1844 * modified if a command disconnects, *instance->connected will
1847 * XXX Note : we need to watch for bus free or a reset condition here
1848 * to recover from an unexpected bus free condition.
1851 static void NCR5380_information_transfer(struct Scsi_Host *instance)
1853 SETUP_HOSTDATA(instance);
1854 unsigned char msgout = NOP;
1857 #if defined(REAL_DMA)
1860 unsigned char *data;
1861 unsigned char phase, tmp, extended_msg[10], old_phase = 0xff;
1862 struct scsi_cmnd *cmd;
1864 #ifdef SUN3_SCSI_VME
1865 dregs->csr |= CSR_INTR;
1868 while ((cmd = hostdata->connected)) {
1869 tmp = NCR5380_read(STATUS_REG);
1870 /* We only have a valid SCSI phase when REQ is asserted */
1872 phase = (tmp & PHASE_MASK);
1873 if (phase != old_phase) {
1875 NCR5380_dprint_phase(NDEBUG_INFORMATION, instance);
1877 #if defined(CONFIG_SUN3)
1878 if (phase == PHASE_CMDOUT) {
1879 #if defined(REAL_DMA)
1881 unsigned long count;
1883 if (!cmd->SCp.this_residual && cmd->SCp.buffers_residual) {
1884 count = cmd->SCp.buffer->length;
1885 d = sg_virt(cmd->SCp.buffer);
1887 count = cmd->SCp.this_residual;
1890 /* this command setup for dma yet? */
1891 if ((count >= DMA_MIN_SIZE) && (sun3_dma_setup_done != cmd)) {
1892 if (cmd->request->cmd_type == REQ_TYPE_FS) {
1893 sun3scsi_dma_setup(d, count,
1894 rq_data_dir(cmd->request));
1895 sun3_dma_setup_done = cmd;
1899 #ifdef SUN3_SCSI_VME
1900 dregs->csr |= CSR_INTR;
1903 #endif /* CONFIG_SUN3 */
1905 if (sink && (phase != PHASE_MSGOUT)) {
1906 NCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(tmp));
1908 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN |
1910 while (NCR5380_read(STATUS_REG) & SR_REQ)
1912 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE |
1920 #if (NDEBUG & NDEBUG_NO_DATAOUT)
1921 printk("scsi%d: NDEBUG_NO_DATAOUT set, attempted DATAOUT "
1922 "aborted\n", HOSTNO);
1925 cmd->result = DID_ERROR << 16;
1926 cmd->scsi_done(cmd);
1931 * If there is no room left in the current buffer in the
1932 * scatter-gather list, move onto the next one.
1935 if (!cmd->SCp.this_residual && cmd->SCp.buffers_residual) {
1937 --cmd->SCp.buffers_residual;
1938 cmd->SCp.this_residual = cmd->SCp.buffer->length;
1939 cmd->SCp.ptr = sg_virt(cmd->SCp.buffer);
1940 /* ++roman: Try to merge some scatter-buffers if
1941 * they are at contiguous physical addresses.
1943 merge_contiguous_buffers(cmd);
1944 dprintk(NDEBUG_INFORMATION, "scsi%d: %d bytes and %d buffers left\n",
1945 HOSTNO, cmd->SCp.this_residual,
1946 cmd->SCp.buffers_residual);
1950 * The preferred transfer method is going to be
1951 * PSEUDO-DMA for systems that are strictly PIO,
1952 * since we can let the hardware do the handshaking.
1954 * For this to work, we need to know the transfersize
1955 * ahead of time, since the pseudo-DMA code will sit
1956 * in an unconditional loop.
1959 /* ++roman: I suggest, this should be
1961 * instead of leaving REAL_DMA out.
1964 #if defined(REAL_DMA)
1965 #if !defined(CONFIG_SUN3)
1967 if (!cmd->device->borken)
1969 transfersize = NCR5380_dma_xfer_len(instance, cmd, phase);
1971 if (transfersize >= DMA_MIN_SIZE) {
1973 cmd->SCp.phase = phase;
1974 if (NCR5380_transfer_dma(instance, &phase,
1975 &len, (unsigned char **)&cmd->SCp.ptr)) {
1977 * If the watchdog timer fires, all future
1978 * accesses to this device will use the
1980 scmd_printk(KERN_INFO, cmd,
1981 "switching to slow handshake\n");
1982 cmd->device->borken = 1;
1985 cmd->result = DID_ERROR << 16;
1986 cmd->scsi_done(cmd);
1987 /* XXX - need to source or sink data here, as appropriate */
1990 /* ++roman: When using real DMA,
1991 * information_transfer() should return after
1992 * starting DMA since it has nothing more to
1997 cmd->SCp.this_residual -= transfersize - len;
2001 #endif /* defined(REAL_DMA) */
2003 spin_unlock_irq(&hostdata->lock);
2004 NCR5380_transfer_pio(instance, &phase,
2005 (int *)&cmd->SCp.this_residual,
2006 (unsigned char **)&cmd->SCp.ptr);
2007 spin_lock_irq(&hostdata->lock);
2009 #if defined(CONFIG_SUN3) && defined(REAL_DMA)
2010 /* if we had intended to dma that command clear it */
2011 if (sun3_dma_setup_done == cmd)
2012 sun3_dma_setup_done = NULL;
2018 NCR5380_transfer_pio(instance, &phase, &len, &data);
2019 cmd->SCp.Message = tmp;
2023 case COMMAND_COMPLETE:
2024 /* Accept message by clearing ACK */
2025 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
2026 dprintk(NDEBUG_QUEUES, "scsi%d: command for target %d, lun %llu "
2027 "completed\n", HOSTNO, cmd->device->id, cmd->device->lun);
2029 hostdata->connected = NULL;
2032 if (status_byte(cmd->SCp.Status) == QUEUE_FULL) {
2033 struct tag_alloc *ta = &hostdata->TagAlloc[scmd_id(cmd)][cmd->device->lun];
2034 dprintk(NDEBUG_TAGS, "scsi%d: target %d lun %llu returned "
2035 "QUEUE_FULL after %d commands\n",
2036 HOSTNO, cmd->device->id, cmd->device->lun,
2038 if (ta->queue_size > ta->nr_allocated)
2039 ta->queue_size = ta->nr_allocated;
2042 hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun);
2046 * I'm not sure what the correct thing to do here is :
2048 * If the command that just executed is NOT a request
2049 * sense, the obvious thing to do is to set the result
2050 * code to the values of the stored parameters.
2052 * If it was a REQUEST SENSE command, we need some way to
2053 * differentiate between the failure code of the original
2054 * and the failure code of the REQUEST sense - the obvious
2055 * case is success, where we fall through and leave the
2056 * result code unchanged.
2058 * The non-obvious place is where the REQUEST SENSE failed
2061 if (cmd->cmnd[0] != REQUEST_SENSE)
2062 cmd->result = cmd->SCp.Status | (cmd->SCp.Message << 8);
2063 else if (status_byte(cmd->SCp.Status) != GOOD)
2064 cmd->result = (cmd->result & 0x00ffff) | (DID_ERROR << 16);
2066 if ((cmd->cmnd[0] == REQUEST_SENSE) &&
2067 hostdata->ses.cmd_len) {
2068 scsi_eh_restore_cmnd(cmd, &hostdata->ses);
2069 hostdata->ses.cmd_len = 0 ;
2072 if ((cmd->cmnd[0] != REQUEST_SENSE) &&
2073 (status_byte(cmd->SCp.Status) == CHECK_CONDITION)) {
2074 scsi_eh_prep_cmnd(cmd, &hostdata->ses, NULL, 0, ~0);
2076 dprintk(NDEBUG_AUTOSENSE, "scsi%d: performing request sense\n", HOSTNO);
2078 LIST(cmd,hostdata->issue_queue);
2079 SET_NEXT(cmd, hostdata->issue_queue);
2080 hostdata->issue_queue = (struct scsi_cmnd *) cmd;
2081 dsprintk(NDEBUG_QUEUES, instance,
2082 "REQUEST SENSE cmd %p added to head of issue queue\n",
2085 cmd->scsi_done(cmd);
2089 * Restore phase bits to 0 so an interrupted selection,
2090 * arbitration can resume.
2092 NCR5380_write(TARGET_COMMAND_REG, 0);
2094 /* Enable reselect interrupts */
2095 NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
2097 /* ++roman: For Falcon SCSI, release the lock on the
2098 * ST-DMA here if no other commands are waiting on the
2099 * disconnected queue.
2101 maybe_release_dma_irq(instance);
2103 case MESSAGE_REJECT:
2104 /* Accept message by clearing ACK */
2105 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
2106 switch (hostdata->last_message) {
2107 case HEAD_OF_QUEUE_TAG:
2108 case ORDERED_QUEUE_TAG:
2109 case SIMPLE_QUEUE_TAG:
2110 /* The target obviously doesn't support tagged
2111 * queuing, even though it announced this ability in
2112 * its INQUIRY data ?!? (maybe only this LUN?) Ok,
2113 * clear 'tagged_supported' and lock the LUN, since
2114 * the command is treated as untagged further on.
2116 cmd->device->tagged_supported = 0;
2117 hostdata->busy[cmd->device->id] |= (1 << cmd->device->lun);
2118 cmd->tag = TAG_NONE;
2119 dprintk(NDEBUG_TAGS, "scsi%d: target %d lun %llu rejected "
2120 "QUEUE_TAG message; tagged queuing "
2122 HOSTNO, cmd->device->id, cmd->device->lun);
2127 /* Accept message by clearing ACK */
2128 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
2129 LIST(cmd,hostdata->disconnected_queue);
2130 SET_NEXT(cmd, hostdata->disconnected_queue);
2131 hostdata->connected = NULL;
2132 hostdata->disconnected_queue = cmd;
2133 dprintk(NDEBUG_QUEUES, "scsi%d: command for target %d lun %llu was "
2134 "moved from connected to the "
2135 "disconnected_queue\n", HOSTNO,
2136 cmd->device->id, cmd->device->lun);
2138 * Restore phase bits to 0 so an interrupted selection,
2139 * arbitration can resume.
2141 NCR5380_write(TARGET_COMMAND_REG, 0);
2143 /* Enable reselect interrupts */
2144 NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
2145 #ifdef SUN3_SCSI_VME
2146 dregs->csr |= CSR_DMA_ENABLE;
2150 * The SCSI data pointer is *IMPLICITLY* saved on a disconnect
2151 * operation, in violation of the SCSI spec so we can safely
2152 * ignore SAVE/RESTORE pointers calls.
2154 * Unfortunately, some disks violate the SCSI spec and
2155 * don't issue the required SAVE_POINTERS message before
2156 * disconnecting, and we have to break spec to remain
2160 case RESTORE_POINTERS:
2161 /* Accept message by clearing ACK */
2162 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
2164 case EXTENDED_MESSAGE:
2166 * Extended messages are sent in the following format :
2168 * 0 EXTENDED_MESSAGE == 1
2169 * 1 length (includes one byte for code, doesn't
2170 * include first two bytes)
2172 * 3..length+1 arguments
2174 * Start the extended message buffer with the EXTENDED_MESSAGE
2175 * byte, since spi_print_msg() wants the whole thing.
2177 extended_msg[0] = EXTENDED_MESSAGE;
2178 /* Accept first byte by clearing ACK */
2179 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
2181 spin_unlock_irq(&hostdata->lock);
2183 dprintk(NDEBUG_EXTENDED, "scsi%d: receiving extended message\n", HOSTNO);
2186 data = extended_msg + 1;
2187 phase = PHASE_MSGIN;
2188 NCR5380_transfer_pio(instance, &phase, &len, &data);
2189 dprintk(NDEBUG_EXTENDED, "scsi%d: length=%d, code=0x%02x\n", HOSTNO,
2190 (int)extended_msg[1], (int)extended_msg[2]);
2192 if (!len && extended_msg[1] > 0 &&
2193 extended_msg[1] <= sizeof(extended_msg) - 2) {
2194 /* Accept third byte by clearing ACK */
2195 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
2196 len = extended_msg[1] - 1;
2197 data = extended_msg + 3;
2198 phase = PHASE_MSGIN;
2200 NCR5380_transfer_pio(instance, &phase, &len, &data);
2201 dprintk(NDEBUG_EXTENDED, "scsi%d: message received, residual %d\n",
2204 switch (extended_msg[2]) {
2207 case EXTENDED_MODIFY_DATA_POINTER:
2208 case EXTENDED_EXTENDED_IDENTIFY:
2212 printk(KERN_NOTICE "scsi%d: error receiving "
2213 "extended message\n", HOSTNO);
2216 printk(KERN_NOTICE "scsi%d: extended message "
2217 "code %02x length %d is too long\n",
2218 HOSTNO, extended_msg[2], extended_msg[1]);
2222 spin_lock_irq(&hostdata->lock);
2223 if (!hostdata->connected)
2226 /* Fall through to reject message */
2229 * If we get something weird that we aren't expecting,
2234 printk(KERN_INFO "scsi%d: rejecting message ",
2236 spi_print_msg(extended_msg);
2238 } else if (tmp != EXTENDED_MESSAGE)
2239 scmd_printk(KERN_INFO, cmd,
2240 "rejecting unknown message %02x\n",
2243 scmd_printk(KERN_INFO, cmd,
2244 "rejecting unknown extended message code %02x, length %d\n",
2245 extended_msg[1], extended_msg[0]);
2247 msgout = MESSAGE_REJECT;
2248 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN);
2250 } /* switch (tmp) */
2255 hostdata->last_message = msgout;
2256 NCR5380_transfer_pio(instance, &phase, &len, &data);
2257 if (msgout == ABORT) {
2261 hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun);
2263 hostdata->connected = NULL;
2264 cmd->result = DID_ERROR << 16;
2265 maybe_release_dma_irq(instance);
2266 cmd->scsi_done(cmd);
2267 NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
2276 * XXX for performance reasons, on machines with a
2277 * PSEUDO-DMA architecture we should probably
2278 * use the dma transfer function.
2280 NCR5380_transfer_pio(instance, &phase, &len, &data);
2285 NCR5380_transfer_pio(instance, &phase, &len, &data);
2286 cmd->SCp.Status = tmp;
2289 printk("scsi%d: unknown phase\n", HOSTNO);
2290 NCR5380_dprint(NDEBUG_ANY, instance);
2291 } /* switch(phase) */
2293 spin_unlock_irq(&hostdata->lock);
2294 NCR5380_poll_politely(instance, STATUS_REG, SR_REQ, SR_REQ, HZ);
2295 spin_lock_irq(&hostdata->lock);
2301 * Function : void NCR5380_reselect (struct Scsi_Host *instance)
2303 * Purpose : does reselection, initializing the instance->connected
2304 * field to point to the scsi_cmnd for which the I_T_L or I_T_L_Q
2305 * nexus has been reestablished,
2307 * Inputs : instance - this instance of the NCR5380.
2312 /* it might eventually prove necessary to do a dma setup on
2313 reselection, but it doesn't seem to be needed now -- sam */
2315 static void NCR5380_reselect(struct Scsi_Host *instance)
2317 SETUP_HOSTDATA(instance);
2318 unsigned char target_mask;
2323 unsigned char msg[3];
2324 int __maybe_unused len;
2325 unsigned char __maybe_unused *data, __maybe_unused phase;
2326 struct scsi_cmnd *tmp = NULL, *prev;
2329 * Disable arbitration, etc. since the host adapter obviously
2330 * lost, and tell an interrupted NCR5380_select() to restart.
2333 NCR5380_write(MODE_REG, MR_BASE);
2335 target_mask = NCR5380_read(CURRENT_SCSI_DATA_REG) & ~(hostdata->id_mask);
2337 dprintk(NDEBUG_RESELECTION, "scsi%d: reselect\n", HOSTNO);
2340 * At this point, we have detected that our SCSI ID is on the bus,
2341 * SEL is true and BSY was false for at least one bus settle delay
2344 * We must assert BSY ourselves, until the target drops the SEL
2348 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_BSY);
2349 if (NCR5380_poll_politely(instance,
2350 STATUS_REG, SR_SEL, 0, 2 * HZ) < 0) {
2351 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
2354 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
2357 * Wait for target to go into MSGIN.
2360 if (NCR5380_poll_politely(instance,
2361 STATUS_REG, SR_REQ, SR_REQ, 2 * HZ) < 0) {
2366 #if defined(CONFIG_SUN3) && defined(REAL_DMA)
2367 /* acknowledge toggle to MSGIN */
2368 NCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(PHASE_MSGIN));
2370 /* peek at the byte without really hitting the bus */
2371 msg[0] = NCR5380_read(CURRENT_SCSI_DATA_REG);
2375 phase = PHASE_MSGIN;
2376 NCR5380_transfer_pio(instance, &phase, &len, &data);
2384 if (!(msg[0] & 0x80)) {
2385 shost_printk(KERN_ERR, instance, "expecting IDENTIFY message, got ");
2391 lun = msg[0] & 0x07;
2393 #if defined(SUPPORT_TAGS) && !defined(CONFIG_SUN3)
2394 /* If the phase is still MSGIN, the target wants to send some more
2395 * messages. In case it supports tagged queuing, this is probably a
2396 * SIMPLE_QUEUE_TAG for the I_T_L_Q nexus.
2399 if (phase == PHASE_MSGIN && (hostdata->flags & FLAG_TAGGED_QUEUING)) {
2400 /* Accept previous IDENTIFY message by clearing ACK */
2401 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
2404 if (!NCR5380_transfer_pio(instance, &phase, &len, &data) &&
2405 msg[1] == SIMPLE_QUEUE_TAG)
2407 dprintk(NDEBUG_TAGS, "scsi%d: target mask %02x, lun %d sent tag %d at "
2408 "reselection\n", HOSTNO, target_mask, lun, tag);
2413 * Find the command corresponding to the I_T_L or I_T_L_Q nexus we
2414 * just reestablished, and remove it from the disconnected queue.
2417 for (tmp = (struct scsi_cmnd *) hostdata->disconnected_queue, prev = NULL;
2418 tmp; prev = tmp, tmp = NEXT(tmp)) {
2419 if ((target_mask == (1 << tmp->device->id)) && (lun == (u8)tmp->device->lun)
2421 && (tag == tmp->tag)
2425 REMOVE(prev, NEXT(prev), tmp, NEXT(tmp));
2426 SET_NEXT(prev, NEXT(tmp));
2428 REMOVE(-1, hostdata->disconnected_queue, tmp, NEXT(tmp));
2429 hostdata->disconnected_queue = NEXT(tmp);
2431 SET_NEXT(tmp, NULL);
2438 shost_printk(KERN_ERR, instance, "target bitmask 0x%02x lun %d tag %d not in disconnected queue.\n",
2439 target_mask, lun, tag);
2441 shost_printk(KERN_ERR, instance, "target bitmask 0x%02x lun %d not in disconnected queue.\n",
2445 * Since we have an established nexus that we can't do anything
2446 * with, we must abort it.
2452 #if defined(CONFIG_SUN3) && defined(REAL_DMA)
2453 /* engage dma setup for the command we just saw */
2456 unsigned long count;
2458 if (!tmp->SCp.this_residual && tmp->SCp.buffers_residual) {
2459 count = tmp->SCp.buffer->length;
2460 d = sg_virt(tmp->SCp.buffer);
2462 count = tmp->SCp.this_residual;
2465 /* setup this command for dma if not already */
2466 if ((count >= DMA_MIN_SIZE) && (sun3_dma_setup_done != tmp)) {
2467 sun3scsi_dma_setup(d, count, rq_data_dir(tmp->request));
2468 sun3_dma_setup_done = tmp;
2472 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ACK);
2475 /* Accept message by clearing ACK */
2476 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
2478 #if defined(SUPPORT_TAGS) && defined(CONFIG_SUN3)
2479 /* If the phase is still MSGIN, the target wants to send some more
2480 * messages. In case it supports tagged queuing, this is probably a
2481 * SIMPLE_QUEUE_TAG for the I_T_L_Q nexus.
2484 if (phase == PHASE_MSGIN && setup_use_tagged_queuing) {
2485 /* Accept previous IDENTIFY message by clearing ACK */
2486 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
2489 if (!NCR5380_transfer_pio(instance, &phase, &len, &data) &&
2490 msg[1] == SIMPLE_QUEUE_TAG)
2492 dprintk(NDEBUG_TAGS, "scsi%d: target mask %02x, lun %d sent tag %d at reselection\n"
2493 HOSTNO, target_mask, lun, tag);
2497 hostdata->connected = tmp;
2498 dprintk(NDEBUG_RESELECTION, "scsi%d: nexus established, target = %d, lun = %llu, tag = %d\n",
2499 HOSTNO, tmp->device->id, tmp->device->lun, tmp->tag);
2504 * Function : int NCR5380_abort (struct scsi_cmnd *cmd)
2506 * Purpose : abort a command
2508 * Inputs : cmd - the scsi_cmnd to abort, code - code to set the
2509 * host byte of the result field to, if zero DID_ABORTED is
2512 * Returns : SUCCESS - success, FAILED on failure.
2514 * XXX - there is no way to abort the command that is currently
2515 * connected, you have to wait for it to complete. If this is
2516 * a problem, we could implement longjmp() / setjmp(), setjmp()
2517 * called where the loop started in NCR5380_main().
2521 int NCR5380_abort(struct scsi_cmnd *cmd)
2523 struct Scsi_Host *instance = cmd->device->host;
2524 SETUP_HOSTDATA(instance);
2525 struct scsi_cmnd *tmp, **prev;
2526 unsigned long flags;
2528 scmd_printk(KERN_NOTICE, cmd, "aborting command\n");
2530 spin_lock_irqsave(&hostdata->lock, flags);
2532 NCR5380_dprint(NDEBUG_ANY, instance);
2533 NCR5380_dprint_phase(NDEBUG_ANY, instance);
2535 dprintk(NDEBUG_ABORT, "scsi%d: abort called basr 0x%02x, sr 0x%02x\n", HOSTNO,
2536 NCR5380_read(BUS_AND_STATUS_REG),
2537 NCR5380_read(STATUS_REG));
2541 * Case 1 : If the command is the currently executing command,
2542 * we'll set the aborted flag and return control so that
2543 * information transfer routine can exit cleanly.
2546 if (hostdata->connected == cmd) {
2548 dprintk(NDEBUG_ABORT, "scsi%d: aborting connected command\n", HOSTNO);
2550 * We should perform BSY checking, and make sure we haven't slipped
2554 /* NCR5380_write(INITIATOR_COMMAND_REG, ICR_ASSERT_ATN); */
2556 * Since we can't change phases until we've completed the current
2557 * handshake, we have to source or sink a byte of data if the current
2558 * phase is not MSGOUT.
2562 * Return control to the executing NCR drive so we can clear the
2563 * aborted flag and get back into our main loop.
2566 if (do_abort(instance) == 0) {
2567 hostdata->connected = NULL;
2568 cmd->result = DID_ABORT << 16;
2572 hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun);
2574 maybe_release_dma_irq(instance);
2575 spin_unlock_irqrestore(&hostdata->lock, flags);
2576 cmd->scsi_done(cmd);
2579 spin_unlock_irqrestore(&hostdata->lock, flags);
2580 printk("scsi%d: abort of connected command failed!\n", HOSTNO);
2587 * Case 2 : If the command hasn't been issued yet, we simply remove it
2588 * from the issue queue.
2590 for (prev = (struct scsi_cmnd **)&(hostdata->issue_queue),
2591 tmp = (struct scsi_cmnd *)hostdata->issue_queue;
2592 tmp; prev = NEXTADDR(tmp), tmp = NEXT(tmp)) {
2594 REMOVE(5, *prev, tmp, NEXT(tmp));
2595 (*prev) = NEXT(tmp);
2596 SET_NEXT(tmp, NULL);
2597 tmp->result = DID_ABORT << 16;
2598 maybe_release_dma_irq(instance);
2599 spin_unlock_irqrestore(&hostdata->lock, flags);
2600 dprintk(NDEBUG_ABORT, "scsi%d: abort removed command from issue queue.\n",
2602 /* Tagged queuing note: no tag to free here, hasn't been assigned
2604 tmp->scsi_done(tmp);
2610 * Case 3 : If any commands are connected, we're going to fail the abort
2611 * and let the high level SCSI driver retry at a later time or
2614 * Timeouts, and therefore aborted commands, will be highly unlikely
2615 * and handling them cleanly in this situation would make the common
2616 * case of noresets less efficient, and would pollute our code. So,
2620 if (hostdata->connected) {
2621 spin_unlock_irqrestore(&hostdata->lock, flags);
2622 dprintk(NDEBUG_ABORT, "scsi%d: abort failed, command connected.\n", HOSTNO);
2627 * Case 4: If the command is currently disconnected from the bus, and
2628 * there are no connected commands, we reconnect the I_T_L or
2629 * I_T_L_Q nexus associated with it, go into message out, and send
2632 * This case is especially ugly. In order to reestablish the nexus, we
2633 * need to call NCR5380_select(). The easiest way to implement this
2634 * function was to abort if the bus was busy, and let the interrupt
2635 * handler triggered on the SEL for reselect take care of lost arbitrations
2636 * where necessary, meaning interrupts need to be enabled.
2638 * When interrupts are enabled, the queues may change - so we
2639 * can't remove it from the disconnected queue before selecting it
2640 * because that could cause a failure in hashing the nexus if that
2641 * device reselected.
2643 * Since the queues may change, we can't use the pointers from when we
2646 * So, we must first locate the command, and if NCR5380_select()
2647 * succeeds, then issue the abort, relocate the command and remove
2648 * it from the disconnected queue.
2651 for (tmp = (struct scsi_cmnd *) hostdata->disconnected_queue; tmp;
2654 dprintk(NDEBUG_ABORT, "scsi%d: aborting disconnected command.\n", HOSTNO);
2656 if (NCR5380_select(instance, cmd)) {
2657 spin_unlock_irq(&hostdata->lock);
2660 dprintk(NDEBUG_ABORT, "scsi%d: nexus reestablished.\n", HOSTNO);
2664 for (prev = (struct scsi_cmnd **)&(hostdata->disconnected_queue),
2665 tmp = (struct scsi_cmnd *)hostdata->disconnected_queue;
2666 tmp; prev = NEXTADDR(tmp), tmp = NEXT(tmp)) {
2668 REMOVE(5, *prev, tmp, NEXT(tmp));
2670 SET_NEXT(tmp, NULL);
2671 tmp->result = DID_ABORT << 16;
2672 /* We must unlock the tag/LUN immediately here, since the
2673 * target goes to BUS FREE and doesn't send us another
2674 * message (COMMAND_COMPLETE or the like)
2679 hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun);
2681 maybe_release_dma_irq(instance);
2682 spin_unlock_irqrestore(&hostdata->lock, flags);
2683 tmp->scsi_done(tmp);
2690 /* Maybe it is sufficient just to release the ST-DMA lock... (if
2691 * possible at all) At least, we should check if the lock could be
2692 * released after the abort, in case it is kept due to some bug.
2694 maybe_release_dma_irq(instance);
2695 spin_unlock_irqrestore(&hostdata->lock, flags);
2698 * Case 5 : If we reached this point, the command was not found in any of
2701 * We probably reached this point because of an unlikely race condition
2702 * between the command completing successfully and the abortion code,
2703 * so we won't panic, but we will notify the user in case something really
2707 printk(KERN_INFO "scsi%d: warning : SCSI command probably completed successfully before abortion\n", HOSTNO);
2714 * NCR5380_bus_reset - reset the SCSI bus
2715 * @cmd: SCSI command undergoing EH
2720 static int NCR5380_bus_reset(struct scsi_cmnd *cmd)
2722 struct Scsi_Host *instance = cmd->device->host;
2723 struct NCR5380_hostdata *hostdata = shost_priv(instance);
2725 unsigned long flags;
2727 spin_lock_irqsave(&hostdata->lock, flags);
2729 #if (NDEBUG & NDEBUG_ANY)
2730 scmd_printk(KERN_INFO, cmd, "performing bus reset\n");
2732 NCR5380_dprint(NDEBUG_ANY, instance);
2733 NCR5380_dprint_phase(NDEBUG_ANY, instance);
2737 /* reset NCR registers */
2738 NCR5380_write(MODE_REG, MR_BASE);
2739 NCR5380_write(TARGET_COMMAND_REG, 0);
2740 NCR5380_write(SELECT_ENABLE_REG, 0);
2742 /* After the reset, there are no more connected or disconnected commands
2743 * and no busy units; so clear the low-level status here to avoid
2744 * conflicts when the mid-level code tries to wake up the affected
2748 if (hostdata->issue_queue)
2749 dsprintk(NDEBUG_ABORT, instance, "reset aborted issued command(s)\n");
2750 if (hostdata->connected)
2751 dsprintk(NDEBUG_ABORT, instance, "reset aborted a connected command\n");
2752 if (hostdata->disconnected_queue)
2753 dsprintk(NDEBUG_ABORT, instance, "reset aborted disconnected command(s)\n");
2755 hostdata->issue_queue = NULL;
2756 hostdata->connected = NULL;
2757 hostdata->disconnected_queue = NULL;
2759 free_all_tags(hostdata);
2761 for (i = 0; i < 8; ++i)
2762 hostdata->busy[i] = 0;
2764 hostdata->dma_len = 0;
2767 maybe_release_dma_irq(instance);
2768 spin_unlock_irqrestore(&hostdata->lock, flags);