![[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 irq, struct pt_regs * regs) {
/* */
604 probe_irq = irq;
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, struct pt_regs * regs) {
/* */
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 occurred 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;
1916 #if defined(PSEUDO_DMA) || defined(REAL_DMA_POLL)
1917 int transfersize;
1918 #endif
1919 unsigned char *data;
1920 unsigned char phase, tmp, extended_msg[10], old_phase=0xff;
1921 Scsi_Cmnd *cmd = (Scsi_Cmnd *) hostdata->connected;
1922 NCR5380_setup(instance);
1923
1924 while (1) {
1925 tmp = NCR5380_read(STATUS_REG);
1926 /* We only have a valid SCSI phase when REQ is asserted */
1927 if (tmp & SR_REQ) {
1928 phase = (tmp & PHASE_MASK);
1929 if (phase != old_phase) {
1930 old_phase = phase;
1931 #if (NDEBUG & NDEBUG_INFORMATION)
1932 NCR5380_print_phase(instance);
1933 #endif
1934 }
1935
1936 if (sink && (phase != PHASE_MSGOUT)) {
1937 NCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(tmp));
1938
1939 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN |
1940 ICR_ASSERT_ACK);
1941 while (NCR5380_read(STATUS_REG) & SR_REQ);
1942 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE |
1943 ICR_ASSERT_ATN);
1944 sink = 0;
1945 continue;
1946 }
1947
1948 switch (phase) {
1949 case PHASE_DATAIN:
1950 case PHASE_DATAOUT:
1951 #if (NDEBUG & NDEBUG_NO_DATAOUT)
1952 printk("scsi%d : NDEBUG_NO_DATAOUT set, attempted DATAOUT aborted\n",
1953 instance->host_no);
1954 sink = 1;
1955 msgout = ABORT;
1956 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN);
1957 break;
1958 #endif
1959 /*
1960 * If there is no room left in the current buffer in the
1961 * scatter-gather list, move onto the next one.
1962 */
1963
1964 if (!cmd->SCp.this_residual && cmd->SCp.buffers_residual) {
1965 ++cmd->SCp.buffer;
1966 --cmd->SCp.buffers_residual;
1967 cmd->SCp.this_residual = cmd->SCp.buffer->length;
1968 cmd->SCp.ptr = cmd->SCp.buffer->address;
1969 #if (NDEBUG & NDEBUG_INFORMATION)
1970 printk("scsi%d : %d bytes and %d buffers left\n",
1971 instance->host_no, cmd->SCp.this_residual,
1972 cmd->SCp.buffers_residual);
1973 #endif
1974 }
1975
1976 /*
1977 * The preferred transfer method is going to be
1978 * PSEUDO-DMA for systems that are strictly PIO,
1979 * since we can let the hardware do the handshaking.
1980 *
1981 * For this to work, we need to know the transfersize
1982 * ahead of time, since the pseudo-DMA code will sit
1983 * in an unconditional loop.
1984 */
1985
1986 #if defined(PSEUDO_DMA) || defined(REAL_DMA_POLL)
1987 #ifdef NCR5380_dma_xfer_len
1988 if (!cmd->device->borken &&
1989 (transfersize = NCR5380_dma_xfer_len(instance, cmd)) != 0) {
1990 #else
1991 transfersize = cmd->transfersize;
1992
1993 #ifdef LIMIT_TRANSFERSIZE /* If we have problems with interrupt service */
1994 if( transfersize > 512 )
1995 transfersize = 512;
1996 #endif /* LIMIT_TRANSFERSIZE */
1997
1998 if (!cmd->device->borken && transfersize &&
1999 cmd->SCp.this_residual && !(cmd->SCp.this_residual %
2000 transfersize)) {
2001 #endif
2002 len = transfersize;
2003 if (NCR5380_transfer_dma(instance, &phase,
2004 &len, (unsigned char **) &cmd->SCp.ptr)) {
2005 /*
2006 * If the watchdog timer fires, all future accesses to this
2007 * device will use the polled-IO.
2008 */
2009 printk("scsi%d : switching target %d lun %d to slow handshake\n",
2010 instance->host_no, cmd->target, cmd->lun);
2011 cmd->device->borken = 1;
2012 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE |
2013 ICR_ASSERT_ATN);
2014 sink = 1;
2015 msgout = ABORT;
2016 /* XXX - need to source or sink data here, as appropriate */
2017 } else
2018 cmd->SCp.this_residual -= transfersize - len;
2019 } else
2020 #endif /* defined(PSEUDO_DMA) || defined(REAL_DMA_POLL) */
2021 NCR5380_transfer_pio(instance, &phase,
2022 (int *) &cmd->SCp.this_residual, (unsigned char **)
2023 &cmd->SCp.ptr);
2024 break;
2025 case PHASE_MSGIN:
2026 len = 1;
2027 data = &tmp;
2028 NCR5380_transfer_pio(instance, &phase, &len, &data);
2029 cmd->SCp.Message = tmp;
2030
2031 switch (tmp) {
2032 /*
2033 * Linking lets us reduce the time required to get the
2034 * next command out to the device, hopefully this will
2035 * mean we don't waste another revolution due to the delays
2036 * required by ARBITRATION and another SELECTION.
2037 *
2038 * In the current implementation proposal, low level drivers
2039 * merely have to start the next command, pointed to by
2040 * next_link, done() is called as with unlinked commands.
2041 */
2042 #ifdef LINKED
2043 case LINKED_CMD_COMPLETE:
2044 case LINKED_FLG_CMD_COMPLETE:
2045 /* Accept message by clearing ACK */
2046 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
2047
2048 #if (NDEBUG & NDEBUG_LINKED)
2049 printk("scsi%d : target %d lun %d linked command complete.\n",
2050 instance->host_no, cmd->target, cmd->lun);
2051 #endif
2052 /*
2053 * Sanity check : A linked command should only terminate with
2054 * one of these messages if there are more linked commands
2055 * available.
2056 */
2057
2058 if (!cmd->next_link) {
2059 printk("scsi%d : target %d lun %d linked command complete, no next_link\n"
2060 instance->host_no, cmd->target, cmd->lun);
2061 sink = 1;
2062 msgout = ABORT;
2063 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE |
2064 ICR_ASSERT_ATN);
2065 break;
2066 }
2067
2068 initialize_SCp(cmd->next_link);
2069 /* The next command is still part of this process */
2070 cmd->next_link->tag = cmd->tag;
2071 cmd->result = cmd->SCp.Status | (cmd->SCp.Message << 8);
2072 #if (NDEBUG & NDEBUG_LINKED)
2073 printk("scsi%d : target %d lun %d linked request done, calling scsi_done().\n",
2074 instance->host_no, cmd->target, cmd->lun);
2075 #endif
2076 cmd->scsi_done(cmd);
2077 cmd = hostdata->connected;
2078 break;
2079 #endif /* def LINKED */
2080 case ABORT:
2081 case COMMAND_COMPLETE:
2082 /* Accept message by clearing ACK */
2083 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
2084 hostdata->connected = NULL;
2085 #if (NDEBUG & NDEBUG_QUEUES)
2086 printk("scsi%d : command for target %d, lun %d completed\n",
2087 instance->host_no, cmd->target, cmd->lun);
2088 #endif
2089 hostdata->busy[cmd->target] &= ~(1 << cmd->lun);
2090
2091 /*
2092 * I'm not sure what the correct thing to do here is :
2093 *
2094 * If the command that just executed is NOT a request
2095 * sense, the obvious thing to do is to set the result
2096 * code to the values of the stored parameters.
2097 *
2098 * If it was a REQUEST SENSE command, we need some way
2099 * to differentiate between the failure code of the original
2100 * and the failure code of the REQUEST sense - the obvious
2101 * case is success, where we fall through and leave the result
2102 * code unchanged.
2103 *
2104 * The non-obvious place is where the REQUEST SENSE failed
2105 */
2106
2107 if (cmd->cmnd[0] != REQUEST_SENSE)
2108 cmd->result = cmd->SCp.Status | (cmd->SCp.Message << 8);
2109 else if (cmd->SCp.Status != GOOD)
2110 cmd->result = (cmd->result & 0x00ffff) | (DID_ERROR << 16);
2111
2112 #ifdef AUTOSENSE
2113 if ((cmd->cmnd[0] != REQUEST_SENSE) &&
2114 (cmd->SCp.Status == CHECK_CONDITION)) {
2115 #if (NDEBUG & NDEBUG_AUTOSENSE)
2116 printk("scsi%d : performing request sense\n",
2117 instance->host_no);
2118 #endif
2119 cmd->cmnd[0] = REQUEST_SENSE;
2120 cmd->cmnd[1] &= 0xe0;
2121 cmd->cmnd[2] = 0;
2122 cmd->cmnd[3] = 0;
2123 cmd->cmnd[4] = sizeof(cmd->sense_buffer);
2124 cmd->cmnd[5] = 0;
2125
2126 cmd->SCp.buffer = NULL;
2127 cmd->SCp.buffers_residual = 0;
2128 cmd->SCp.ptr = (char *) cmd->sense_buffer;
2129 cmd->SCp.this_residual = sizeof(cmd->sense_buffer);
2130
2131 cli();
2132 cmd->host_scribble = (unsigned char *)
2133 hostdata->issue_queue;
2134 hostdata->issue_queue = (Scsi_Cmnd *) cmd;
2135 sti();
2136 #if (NDEBUG & NDEBUG_QUEUES)
2137 printk("scsi%d : REQUEST SENSE added to head of issue queue\n");
2138 #endif
2139 } else
2140 #endif /* def AUTOSENSE */
2141 cmd->scsi_done(cmd);
2142
2143 NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
2144 /*
2145 * Restore phase bits to 0 so an interrupted selection,
2146 * arbitration can resume.
2147 */
2148 NCR5380_write(TARGET_COMMAND_REG, 0);
2149
2150 while ((NCR5380_read(STATUS_REG) & SR_BSY) &&
2151 !hostdata->connected);
2152 return;
2153 case MESSAGE_REJECT:
2154 /* Accept message by clearing ACK */
2155 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
2156 switch (hostdata->last_message) {
2157 case HEAD_OF_QUEUE_TAG:
2158 case ORDERED_QUEUE_TAG:
2159 case SIMPLE_QUEUE_TAG:
2160 cmd->device->tagged_queue = 0;
2161 hostdata->busy[cmd->target] |= (1 << cmd->lun);
2162 break;
2163 default:
2164 break;
2165 }
2166 case DISCONNECT:
2167 /* Accept message by clearing ACK */
2168 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
2169 cmd->device->disconnect = 1;
2170 cli();
2171 cmd->host_scribble = (unsigned char *)
2172 hostdata->disconnected_queue;
2173 hostdata->connected = NULL;
2174 hostdata->disconnected_queue = cmd;
2175 sti();
2176 #if (NDEBUG & NDEBUG_QUEUES)
2177 printk("scsi%d : command for target %d lun %d was moved from connected to"
2178 " the disconnected_queue\n", instance->host_no,
2179 cmd->target, cmd->lun);
2180 #endif
2181 /*
2182 * Restore phase bits to 0 so an interrupted selection,
2183 * arbitration can resume.
2184 */
2185 NCR5380_write(TARGET_COMMAND_REG, 0);
2186
2187 /* Enable reselect interrupts */
2188 NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
2189 /* Wait for bus free to avoid nasty timeouts */
2190 while ((NCR5380_read(STATUS_REG) & SR_BSY) &&
2191 !hostdata->connected);
2192 return;
2193 /*
2194 * The SCSI data pointer is *IMPLICITLY* saved on a disconnect
2195 * operation, in violation of the SCSI spec so we can safely
2196 * ignore SAVE/RESTORE pointers calls.
2197 *
2198 * Unfortunately, some disks violate the SCSI spec and
2199 * don't issue the required SAVE_POINTERS message before
2200 * disconnecting, and we have to break spec to remain
2201 * compatible.
2202 */
2203 case SAVE_POINTERS:
2204 case RESTORE_POINTERS:
2205 /* Accept message by clearing ACK */
2206 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
2207 break;
2208 case EXTENDED_MESSAGE:
2209 /*
2210 * Extended messages are sent in the following format :
2211 * Byte
2212 * 0 EXTENDED_MESSAGE == 1
2213 * 1 length (includes one byte for code, doesn't
2214 * include first two bytes)
2215 * 2 code
2216 * 3..length+1 arguments
2217 *
2218 * Start the extended message buffer with the EXTENDED_MESSAGE
2219 * byte, since print_msg() wants the whole thing.
2220 */
2221 extended_msg[0] = EXTENDED_MESSAGE;
2222 /* Accept first byte by clearing ACK */
2223 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
2224
2225 #if (NDEBUG & NDEBUG_EXTENDED)
2226 printk("scsi%d : receiving extended message\n",
2227 instance->host_no);
2228 #endif
2229
2230 len = 2;
2231 data = extended_msg + 1;
2232 phase = PHASE_MSGIN;
2233 NCR5380_transfer_pio(instance, &phase, &len, &data);
2234
2235 #if (NDEBUG & NDEBUG_EXTENDED)
2236 printk("scsi%d : length=%d, code=0x%02x\n",
2237 instance->host_no, (int) extended_msg[1],
2238 (int) extended_msg[2]);
2239 #endif
2240
2241 if (!len && extended_msg[1] <=
2242 (sizeof (extended_msg) - 1)) {
2243 /* Accept third byte by clearing ACK */
2244 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
2245 len = extended_msg[1] - 1;
2246 data = extended_msg + 3;
2247 phase = PHASE_MSGIN;
2248
2249 NCR5380_transfer_pio(instance, &phase, &len, &data);
2250
2251 #if (NDEBUG & NDEBUG_EXTENDED)
2252 printk("scsi%d : message received, residual %d\n",
2253 instance->host_no, len);
2254 #endif
2255
2256 switch (extended_msg[2]) {
2257 case EXTENDED_SDTR:
2258 case EXTENDED_WDTR:
2259 case EXTENDED_MODIFY_DATA_POINTER:
2260 case EXTENDED_EXTENDED_IDENTIFY:
2261 tmp = 0;
2262 }
2263 } else if (len) {
2264 printk("scsi%d: error receiving extended message\n",
2265 instance->host_no);
2266 tmp = 0;
2267 } else {
2268 printk("scsi%d: extended message code %02x length %d is too long\n",
2269 instance->host_no, extended_msg[2], extended_msg[1]);
2270 tmp = 0;
2271 }
2272 /* Fall through to reject message */
2273
2274 /*
2275 * If we get something weird that we aren't expecting,
2276 * reject it.
2277 */
2278 default:
2279 if (!tmp) {
2280 printk("scsi%d: rejecting message ", instance->host_no);
2281 print_msg (extended_msg);
2282 printk("\n");
2283 } else if (tmp != EXTENDED_MESSAGE)
2284 printk("scsi%d: rejecting unknown message %02x from target %d, lun %d\n",
2285 instance->host_no, tmp, cmd->target, cmd->lun);
2286 else
2287 printk("scsi%d: rejecting unknown extended message code %02x, length %d from target %d, lun %d\n",
2288 instance->host_no, extended_msg[1], extended_msg[0], cmd->target, cmd->lun);
2289
2290 msgout = MESSAGE_REJECT;
2291 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE |
2292 ICR_ASSERT_ATN);
2293 break;
2294 } /* switch (tmp) */
2295 break;
2296 case PHASE_MSGOUT:
2297 len = 1;
2298 data = &msgout;
2299 hostdata->last_message = msgout;
2300 NCR5380_transfer_pio(instance, &phase, &len, &data);
2301 if (msgout == ABORT) {
2302 hostdata->busy[cmd->target] &= ~(1 << cmd->lun);
2303 hostdata->connected = NULL;
2304 cmd->result = DID_ERROR << 16;
2305 cmd->scsi_done(cmd);
2306 NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
2307 return;
2308 }
2309 msgout = NOP;
2310 break;
2311 case PHASE_CMDOUT:
2312 len = cmd->cmd_len;
2313 data = cmd->cmnd;
2314 /*
2315 * XXX for performance reasons, on machines with a
2316 * PSEUDO-DMA architecture we should probably
2317 * use the dma transfer function.
2318 */
2319 NCR5380_transfer_pio(instance, &phase, &len,
2320 &data);
2321 #ifdef USLEEP
2322 if (!disconnect && should_disconnect(cmd->cmnd[0])) {
2323 hostdata->time_expires = jiffies + USLEEP_SLEEP;
2324 #if (NDEBUG & NDEBUG_USLEEP)
2325 printk("scsi%d : issued command, sleeping until %ul\n", instance->host_no,
2326 hostdata->time_expires);
2327 #endif
2328 NCR5380_set_timer (instance);
2329 return;
2330 }
2331 #endif /* def USLEEP */
2332 break;
2333 case PHASE_STATIN:
2334 len = 1;
2335 data = &tmp;
2336 NCR5380_transfer_pio(instance, &phase, &len, &data);
2337 cmd->SCp.Status = tmp;
2338 break;
2339 default:
2340 printk("scsi%d : unknown phase\n", instance->host_no);
2341 #ifdef NDEBUG
2342 NCR5380_print(instance);
2343 #endif
2344 } /* switch(phase) */
2345 } /* if (tmp * SR_REQ) */
2346 #ifdef USLEEP
2347 else {
2348 if (!disconnect && hostdata->time_expires && jiffies >
2349 hostdata->time_expires) {
2350 hostdata->time_expires = jiffies + USLEEP_SLEEP;
2351 #if (NDEBUG & NDEBUG_USLEEP)
2352 printk("scsi%d : poll timed out, sleeping until %ul\n", instance->host_no,
2353 hostdata->time_expires);
2354 #endif
2355 NCR5380_set_timer (instance);
2356 return;
2357 }
2358 }
2359 #endif
2360 } /* while (1) */
2361 }
2362
2363 /*
2364 * Function : void NCR5380_reselect (struct Scsi_Host *instance)
2365 *
2366 * Purpose : does reselection, initializing the instance->connected
2367 * field to point to the Scsi_Cmnd for which the I_T_L or I_T_L_Q
2368 * nexus has been reestablished,
2369 *
2370 * Inputs : instance - this instance of the NCR5380.
2371 *
2372 */
2373
2374
2375 static void NCR5380_reselect (struct Scsi_Host *instance) {
/* */
2376 NCR5380_local_declare();
2377 struct NCR5380_hostdata *hostdata = (struct NCR5380_hostdata *)
2378 instance->hostdata;
2379 unsigned char target_mask;
2380 unsigned char lun, phase;
2381 int len;
2382 #ifdef SCSI2
2383 unsigned char tag;
2384 #endif
2385 unsigned char msg[3];
2386 unsigned char *data;
2387 Scsi_Cmnd *tmp = NULL, *prev;
2388 int abort = 0;
2389 NCR5380_setup(instance);
2390
2391 /*
2392 * Disable arbitration, etc. since the host adapter obviously
2393 * lost, and tell an interrupted NCR5380_select() to restart.
2394 */
2395
2396 NCR5380_write(MODE_REG, MR_BASE);
2397 hostdata->restart_select = 1;
2398
2399 target_mask = NCR5380_read(CURRENT_SCSI_DATA_REG) & ~(hostdata->id_mask);
2400
2401 #if (NDEBUG & NDEBUG_RESELECTION)
2402 printk("scsi%d : reselect\n", instance->host_no);
2403 #endif
2404
2405 /*
2406 * At this point, we have detected that our SCSI ID is on the bus,
2407 * SEL is true and BSY was false for at least one bus settle delay
2408 * (400 ns).
2409 *
2410 * We must assert BSY ourselves, until the target drops the SEL
2411 * signal.
2412 */
2413
2414 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_BSY);
2415
2416 while (NCR5380_read(STATUS_REG) & SR_SEL);
2417 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
2418
2419 /*
2420 * Wait for target to go into MSGIN.
2421 */
2422
2423 while (!(NCR5380_read(STATUS_REG) & SR_REQ));
2424
2425 len = 1;
2426 data = msg;
2427 phase = PHASE_MSGIN;
2428 NCR5380_transfer_pio(instance, &phase, &len, &data);
2429
2430
2431 if (!msg[0] & 0x80) {
2432 printk("scsi%d : expecting IDENTIFY message, got ",
2433 instance->host_no);
2434 print_msg(msg);
2435 abort = 1;
2436 } else {
2437 /* Accept message by clearing ACK */
2438 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
2439 lun = (msg[0] & 0x07);
2440
2441 /*
2442 * We need to add code for SCSI-II to track which devices have
2443 * I_T_L_Q nexuses established, and which have simple I_T_L
2444 * nexuses so we can chose to do additional data transfer.
2445 */
2446
2447 #ifdef SCSI2
2448 #error "SCSI-II tagged queueing is not supported yet"
2449 #endif
2450
2451 /*
2452 * Find the command corresponding to the I_T_L or I_T_L_Q nexus we
2453 * just reestablished, and remove it from the disconnected queue.
2454 */
2455
2456
2457 for (tmp = (Scsi_Cmnd *) hostdata->disconnected_queue, prev = NULL;
2458 tmp; prev = tmp, tmp = (Scsi_Cmnd *) tmp->host_scribble)
2459 if ((target_mask == (1 << tmp->target)) && (lun == tmp->lun)
2460 #ifdef SCSI2
2461 && (tag == tmp->tag)
2462 #endif
2463 ) {
2464 if (prev)
2465 prev->host_scribble = tmp->host_scribble;
2466 else
2467 hostdata->disconnected_queue = (Scsi_Cmnd *) tmp->host_scribble;
2468 tmp->host_scribble = NULL;
2469 break;
2470 }
2471
2472 if (!tmp) {
2473 #ifdef SCSI2
2474 printk("scsi%d : warning : target bitmask %02x lun %d tag %d not in disconnect_queue.\n",
2475 instance->host_no, target_mask, lun, tag);
2476 #else
2477 printk("scsi%d : warning : target bitmask %02x lun %d not in disconnect_queue.\n",
2478 instance->host_no, target_mask, lun);
2479 #endif
2480 /*
2481 * Since we have an established nexus that we can't do anything with,
2482 * we must abort it.
2483 */
2484 abort = 1;
2485 }
2486 }
2487
2488 if (abort) {
2489 msg[0] = ABORT;
2490 len = 1;
2491 data = msg;
2492 phase = PHASE_MSGOUT;
2493 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN);
2494 NCR5380_transfer_pio(instance, &phase, &len, &data);
2495 } else {
2496 hostdata->connected = tmp;
2497 #if (NDEBUG & NDEBUG_RESELECTION)
2498 printk"scsi%d : nexus established, target = %d, lun = %d, tag = %d\n",
2499 instance->host_no, tmp->target, tmp->lun, tmp->tag);
2500 #endif
2501 }
2502 }
2503
2504 /*
2505 * Function : void NCR5380_dma_complete (struct Scsi_Host *instance)
2506 *
2507 * Purpose : called by interrupt handler when DMA finishes or a phase
2508 * mismatch occurs (which would finish the DMA transfer).
2509 *
2510 * Inputs : instance - this instance of the NCR5380.
2511 *
2512 * Returns : pointer to the Scsi_Cmnd structure for which the I_T_L
2513 * nexus has been reestablished, on failure NULL is returned.
2514 */
2515
2516 #ifdef REAL_DMA
2517 static void NCR5380_dma_complete (NCR5380_instance *instance) {
/* */
2518 NCR5380_local_declare();
2519 struct NCR5380_hostdata *hostdata = (struct NCR5380_hostdata *
2520 instance->hostdata);
2521 int transferred;
2522 NCR5380_setup(instance);
2523
2524 /*
2525 * XXX this might not be right.
2526 *
2527 * Wait for final byte to transfer, ie wait for ACK to go false.
2528 *
2529 * We should use the Last Byte Sent bit, unfortunately this is
2530 * not available on the 5380/5381 (only the various CMOS chips)
2531 */
2532
2533 while (NCR5380_read(BUS_AND_STATUS_REG) & BASR_ACK);
2534
2535 NCR5380_write(MODE_REG, MR_BASE);
2536 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
2537
2538 /*
2539 * The only places we should see a phase mismatch and have to send
2540 * data from the same set of pointers will be the data transfer
2541 * phases. So, residual, requested length are only important here.
2542 */
2543
2544 if (!(hostdata->connected->SCp.phase & SR_CD)) {
2545 transferred = instance->dmalen - NCR5380_dma_residual();
2546 hostdata->connected->SCp.this_residual -= transferred;
2547 hostdata->connected->SCp.ptr += transferred;
2548 }
2549 }
2550 #endif /* def REAL_DMA */
2551
2552 /*
2553 * Function : int NCR5380_abort (Scsi_Cmnd *cmd)
2554 *
2555 * Purpose : abort a command
2556 *
2557 * Inputs : cmd - the Scsi_Cmnd to abort, code - code to set the
2558 * host byte of the result field to, if zero DID_ABORTED is
2559 * used.
2560 *
2561 * Returns : 0 - success, -1 on failure.
2562 *
2563 * XXX - there is no way to abort the command that is currently
2564 * connected, you have to wait for it to complete. If this is
2565 * a problem, we could implement longjmp() / setjmp(), setjmp()
2566 * called where the loop started in NCR5380_main().
2567 */
2568
2569 #ifndef NCR5380_abort
2570 static
2571 #endif
2572 int NCR5380_abort (Scsi_Cmnd *cmd) {
/* */
2573 NCR5380_local_declare();
2574 struct Scsi_Host *instance = cmd->host;
2575 struct NCR5380_hostdata *hostdata = (struct NCR5380_hostdata *)
2576 instance->hostdata;
2577 Scsi_Cmnd *tmp, **prev;
2578 unsigned char msg, phase, *msgptr;
2579 int len;
2580
2581 printk("scsi%d : aborting command\n", instance->host_no);
2582 print_Scsi_Cmnd (cmd);
2583
2584 NCR5380_print_status (instance);
2585
2586 cli();
2587 NCR5380_setup(instance);
2588
2589 #if (NDEBUG & NDEBUG_ABORT)
2590 printk("scsi%d : abort called\n", instance->host_no);
2591 printk(" basr 0x%X, sr 0x%X\n",
2592 NCR5380_read(BUS_AND_STATUS_REG), NCR5380_read(STATUS_REG));
2593 #endif
2594
2595 #if 0
2596 /*
2597 * Case 1 : If the command is the currently executing command,
2598 * we'll set the aborted flag and return control so that
2599 * information transfer routine can exit cleanly.
2600 */
2601
2602 if (hostdata->connected == cmd) {
2603 #if (NDEBUG & NDEBUG_ABORT)
2604 printk("scsi%d : aborting connected command\n", instance->host_no);
2605 #endif
2606 hostdata->aborted = 1;
2607 /*
2608 * We should perform BSY checking, and make sure we haven't slipped
2609 * into BUS FREE.
2610 */
2611
2612 NCR5380_write(INITIATOR_COMMAND_REG, ICR_ASSERT_ATN);
2613 /*
2614 * Since we can't change phases until we've completed the current
2615 * handshake, we have to source or sink a byte of data if the current
2616 * phase is not MSGOUT.
2617 */
2618
2619 /*
2620 * Return control to the executing NCR drive so we can clear the
2621 * aborted flag and get back into our main loop.
2622 */
2623
2624 return 0;
2625 }
2626 #endif
2627
2628 /*
2629 * Case 2 : If the command hasn't been issued yet, we simply remove it
2630 * from the issue queue.
2631 */
2632 for (prev = (Scsi_Cmnd **) &(hostdata->issue_queue),
2633 tmp = (Scsi_Cmnd *) hostdata->issue_queue;
2634 tmp; prev = (Scsi_Cmnd **) &(tmp->host_scribble), tmp =
2635 (Scsi_Cmnd *) tmp->host_scribble)
2636 if (cmd == tmp) {
2637 (*prev) = (Scsi_Cmnd *) tmp->host_scribble;
2638 tmp->host_scribble = NULL;
2639 tmp->result = DID_ABORT << 16;
2640 sti();
2641 #if (NDEBUG & NDEBUG_ABORT)
2642 printk("scsi%d : abort removed command from issue queue.\n",
2643 instance->host_no);
2644 #endif
2645 tmp->done(tmp);
2646 return SCSI_ABORT_SUCCESS;
2647 }
2648
2649 /*
2650 * Case 3 : If any commands are connected, we're going to fail the abort
2651 * and let the high level SCSI driver retry at a later time or
2652 * issue a reset.
2653 *
2654 * Timeouts, and therefore aborted commands, will be highly unlikely
2655 * and handling them cleanly in this situation would make the common
2656 * case of noresets less efficient, and would pollute our code. So,
2657 * we fail.
2658 */
2659
2660 if (hostdata->connected) {
2661 sti();
2662 #if (NDEBUG & NDEBUG_ABORT)
2663 printk("scsi%d : abort failed, command connected.\n", instance->host_no);
2664 #endif
2665 return SCSI_ABORT_NOT_RUNNING;
2666 }
2667
2668 /*
2669 * Case 4: If the command is currently disconnected from the bus, and
2670 * there are no connected commands, we reconnect the I_T_L or
2671 * I_T_L_Q nexus associated with it, go into message out, and send
2672 * an abort message.
2673 *
2674 * This case is especially ugly. In order to reestablish the nexus, we
2675 * need to call NCR5380_select(). The easiest way to implement this
2676 * function was to abort if the bus was busy, and let the interrupt
2677 * handler triggered on the SEL for reselect take care of lost arbitrations
2678 * where necessary, meaning interrupts need to be enabled.
2679 *
2680 * When interrupts are enabled, the queues may change - so we
2681 * can't remove it from the disconnected queue before selecting it
2682 * because that could cause a failure in hashing the nexus if that
2683 * device reselected.
2684 *
2685 * Since the queues may change, we can't use the pointers from when we
2686 * first locate it.
2687 *
2688 * So, we must first locate the command, and if NCR5380_select()
2689 * succeeds, then issue the abort, relocate the command and remove
2690 * it from the disconnected queue.
2691 */
2692
2693 for (tmp = (Scsi_Cmnd *) hostdata->disconnected_queue; tmp;
2694 tmp = (Scsi_Cmnd *) tmp->host_scribble)
2695 if (cmd == tmp) {
2696 sti();
2697 #if (NDEBUG & NDEBUG_ABORT)
2698 printk("scsi%d : aborting disconnected command.\n", instance->host_no);
2699 #endif
2700
2701 if (NCR5380_select (instance, cmd, (int) cmd->tag))
2702 return SCSI_ABORT_BUSY;
2703
2704 #if (NDEBUG & NDEBUG_ABORT)
2705 printk("scsi%d : nexus reestablished.\n", instance->host_no);
2706 #endif
2707
2708 msg = ABORT;
2709 msgptr = &msg;
2710 len = 1;
2711 phase = PHASE_MSGOUT;
2712 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN);
2713 NCR5380_transfer_pio (instance, &phase, &len, &msgptr);
2714
2715 cli();
2716 for (prev = (Scsi_Cmnd **) &(hostdata->disconnected_queue),
2717 tmp = (Scsi_Cmnd *) hostdata->disconnected_queue;
2718 tmp; prev = (Scsi_Cmnd **) &(tmp->host_scribble), tmp =
2719 (Scsi_Cmnd *) tmp->host_scribble)
2720 if (cmd == tmp) {
2721 *prev = (Scsi_Cmnd *) tmp->host_scribble;
2722 tmp->host_scribble = NULL;
2723 tmp->result = DID_ABORT << 16;
2724 sti();
2725 tmp->done(tmp);
2726 return SCSI_ABORT_SUCCESS;
2727 }
2728 }
2729
2730 /*
2731 * Case 5 : If we reached this point, the command was not found in any of
2732 * the queues.
2733 *
2734 * We probably reached this point because of an unlikely race condition
2735 * between the command completing successfully and the abortion code,
2736 * so we won't panic, but we will notify the user in case something really
2737 * broke.
2738 */
2739
2740 sti();
2741 printk("scsi%d : warning : SCSI command probably completed successfully\n"
2742 " before abortion\n", instance->host_no);
2743 return SCSI_ABORT_NOT_RUNNING;
2744 }
2745
2746
2747 /*
2748 * Function : int NCR5380_reset (Scsi_Cmnd *cmd)
2749 *
2750 * Purpose : reset the SCSI bus.
2751 *
2752 * Returns : SCSI_RESET_WAKEUP
2753 *
2754 */
2755
2756 #ifndef NCR5380_reset
2757 static
2758 #endif
2759 int NCR5380_reset (Scsi_Cmnd *cmd) {
/* ![[last]](../icons/n_last.png)
*/
2760 NCR5380_local_declare();
2761 NCR5380_setup(cmd->host);
2762
2763 NCR5380_print_status (cmd->host);
2764
2765 cli();
2766 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_RST);
2767 udelay(25);
2768 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
2769 sti();
2770
2771 return SCSI_RESET_WAKEUP;
2772 }
2773
![[bottom]](../icons/n_bottom.png){kind=icon}
*/