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