![[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 /*
2 * NCR 5380 generic driver routines. These should make it *trivial*
3 * to implement 5380 SCSI drivers under Linux with a non-trantor
4 * architecture.
5 *
6 * Copyright 1993, Drew Eckhardt
7 * Visionary Computing
8 * (Unix and Linux consulting and custom programming)
9 * drew@colorado.edu
10 * +1 (303) 440-4894
11 *
12 * DISTRIBUTION REALEASE 3.
13 *
14 * For more information, please consult
15 *
16 * NCR 5380 Family
17 * SCSI Protocol Controller
18 * Databook
19 *
20 * NCR Microelectronics
21 * 1635 Aeroplaza Drive
22 * Colorado Springs, CO 80916
23 * 1+ (719) 578-3400
24 * 1+ (800) 334-5454
25 */
26
27 /*
28 * $Log: NCR5380.c,v $
29 */
30
31 /*
32 * Furthur development / testing that should be done :
33 * 1. Test USLEEP code
34 * 2. Test SCSI-II tagged queueing (I have no devices which support
35 * tagged queueing)
36 * 3. Flesh out REAL_DMA code (my sample board doesn't support this)
37 * Perhaps some of the 680x0 porting crew can help out here?
38 * 4. Test linked command handling code after Eric is ready with
39 * the high level code.
40 * 5. Tie instance handling into Eric's multi-host patches
41 */
42
43 #ifndef notyet
44 #undef LINKED
45 #undef USLEEP
46 #undef REAL_DMA
47 #endif
48
49 /*
50 * Design
51 * Issues :
52 *
53 * The other Linux SCSI drivers were written when Linux was Intel PC-only,
54 * and specifically for each board rather than each chip. This makes their
55 * adaptation to platforms like the Mac (Some of which use NCR5380's)
56 * more difficult than it has to be.
57 *
58 * Also, many of the SCSI drivers were written before the command queing
59 * routines were implemented, meaning their implementations of queued
60 * commands were hacked on rather than designed in from the start.
61 *
62 * When I designed the Linux SCSI drivers I figured that
63 * while having two different SCSI boards in a system might be useful
64 * for debugging things, two of the same type wouldn't be used.
65 * Well, I was wrong and a number of users have mailed me about running
66 * multiple high-performance SCSI boards in a server.
67 *
68 * Finally, when I get questions from users, I have no idea what
69 * revision of my driver they are running.
70 *
71 * This driver attempts to address these problems :
72 * This is a generic 5380 driver. To use it on a different platform,
73 * one simply writes appropriate system specific macros (ie, data
74 * transfer - some PC's will use the I/O bus, 68K's must use
75 * memory mapped) and drops this file in their 'C' wrapper.
76 *
77 * As far as command queueing, two queues are maintained for
78 * each 5380 in the system - commands that haven't been issued yet,
79 * and commands that are currently executing. This means that an
80 * unlimited number of commands may be queued, letting
81 * more commands propogate from the higher driver levels giving higher
82 * througput. Note that both I_T_L and I_T_L_Q nexuses are supported,
83 * allowing multiple commands to propogate all the way to a SCSI-II device
84 * while a command is allready executing.
85 *
86 * To solve the multiple-boards-in-the-same-system problem,
87 * there is a separate instance structure for each instance
88 * of a 5380 in the system. So, mutliple NCR5380 drivers will
89 * be able to coexist with appropriate changes to the high level
90 * SCSI code.
91 *
92 * A NCR5380_PUBLIC_REVISION macro is provided, with the release
93 * number (updated for each public release) printed by the
94 * NCR5380_print_options command, which should be called from the
95 * wrapper detect function, so that I know what release of the driver
96 * users are using.
97 *
98 * Issues specific to the NCR5380 :
99 *
100 * When used in a PIO or pseudo-dma mode, the NCR5380 is a braindead
101 * piece of hardware that requires you to sit in a loop polling for
102 * the REQ signal as long as you are connected. Some devices are
103 * brain dead (ie, many TEXEL CD ROM drives) and won't disconnect
104 * while doing long seek operations.
105 *
106 * The workarround for this is to keep track of devices that have
107 * disconnected. If the device hasn't disconnected, for commands that
108 * should disconnect, we do something like
109 *
110 * while (!REQ is asserted) { sleep for N usecs; poll for M usecs }
111 *
112 * Some tweaking of N and M needs to be done. An algorithm based
113 * on "time to data" would give the best results as long as short time
114 * to datas (ie, on the same track) were considered, however these
115 * broken devices are the exception rather than the rule and I'd rather
116 * spend my time optomizing for the normal case.
117 *
118 * Architecture :
119 *
120 * At the heart of the design is a corroutine, NCR5380_main,
121 * which is started when not running by the interrupt handler,
122 * timer, and queue command function. It attempts to establish
123 * I_T_L or I_T_L_Q nexuses by removing the commands from the
124 * issue queue and calling NCR5380_select() if a nexus
125 * is not established.
126 *
127 * Once a nexus is established, the NCR5380_information_transfer()
128 * phase goes through the various phases as instructed by the target.
129 * if the target goes into MSG IN and sends a DISCONNECT message,
130 * the command structure is placed into the per instance disconnected
131 * queue, and NCR5380_main tries to find more work. If USLEEP
132 * was defined, and the target is idle for too long, the system
133 * will try to sleep.
134 *
135 * If a command has disconnected, eventually an interrupt will trigger,
136 * calling NCR5380_intr() which will inturn call NCR5380_reselect
137 * to restablish a nexus. This will run main if necessary.
138 *
139 * On command termination, the done function will be called as
140 * appropriate.
141 *
142 * SCSI pointers are maintained in the SCp field of SCSI command
143 * structures, being initialized after the command is connected
144 * in NCR5380_select, and set as appropriate in NCR5380_information_transfer.
145 * Note that in violation of the standard, an implicit SAVE POINTERS operation
146 * is done, since some BROKEN disks fail to issue an explicit SAVE POINTERS.
147 */
148
149 /*
150 * Using this file :
151 * This file a skeleton Linux SCSI driver for the NCR 5380 series
152 * of chips. To use it, you write a architecture specific functions
153 * and macros and include this file in your driver.
154 *
155 * These macros control options :
156 * AUTOPROBE_IRQ - if defined, the NCR5380_probe_irq() function will be
157 * defined.
158 *
159 * AUTOSENSE - if defined, REQUEST SENSE will be performed automatically
160 * for commands that return with a CHECK CONDITION status.
161 *
162 * DIFFERENTIAL - if defined, NCR53c81 chips will use external differential
163 * tracievers.
164 *
165 * LINKED - if defined, linked commands are supported.
166 *
167 * PSEUDO_DMA - if defined, PSEUDO DMA is used during the data transfer phases.
168 *
169 * REAL_DMA - if defined, REAL DMA is used during the data transfer phases.
170 *
171 * SCSI2 - if defined, SCSI-2 tagged queing is used where possible
172 *
173 * UNSAFE - leave interrupts enabled during pseudo-DMA transfers. You
174 * only really want to use this if you're having a problem with
175 * dropped characters during high speed communications, and even
176 * then, you're going to be better off twiddling with transfersize
177 * in the high level code.
178 *
179 * USLEEP - if defined, on devices that aren't disconnecting from the
180 * bus, we will go to sleep so that the CPU can get real work done
181 * when we run a command that won't complete immediately.
182 *
183 * Note that if USLEEP is defined, NCR5380_TIMER *must* also be
184 * defined.
185 *
186 * Defaults for these will be provided if USLEEP is defined, although
187 * the user may want to adjust these to allocate CPU resources to
188 * the SCSI driver or "real" code.
189 *
190 * USLEEP_SLEEP - amount of time, in jiffies, to sleep
191 *
192 * USLEEP_POLL - amount of time, in jiffies, to poll
193 *
194 * These macros MUST be defined :
195 * NCR5380_local_declare() - declare any local variables needed for your transfer
196 * routines.
197 *
198 * NCR5380_setup(instance) - initialize any local variables needed from a given
199 * instance of the host adapter for NCR5380_{read,write,pread,pwrite}
200 *
201 * NCR5380_read(register) - read from the specified register
202 *
203 * NCR5380_write(register, value) - write to the specific register
204 *
205 * NCR5380_implementation_fields - additional fields needed for this
206 * specific implementation of the NCR5380
207 *
208 * Either real DMA *or* pseudo DMA may be implemented
209 * REAL functions :
210 * NCR5380_REAL_DMA should be defined if real DMA is to be used.
211 * NCR5380_dma_write_setup(instance, src, count) - initialize
212 * NCR5380_dma_read_setup(instance, dst, count) - initialize
213 * NCR5380_dma_residual(); - residual count
214 *
215 * PSEUDO functions :
216 * NCR5380_pwrite(instance, src, count)
217 * NCR5380_pread(instance, dst, count);
218 *
219 * If nothing specific to this implementation needs doing (ie, with external
220 * hardware), you must also define
221 *
222 * NCR5380_queue_command
223 * NCR5380_reset
224 * NCR5380_abort
225 *
226 * to be the global entry points into the specific driver, ie
227 * #define NCR5380_queue_command t128_queue_command.
228 *
229 * If this is not done, the routines will be defined as static functions
230 * with the NCR5380* names and the user must provide a globally
231 * accessable wrapper function.
232 *
233 * The generic driver is initialized by calling NCR5380_init(instance),
234 * after setting the appropriate host specific fields and ID. If the
235 * driver wishes to autoprobe for an IRQ line, the NCR5380_probe_irq(instance,
236 * possible) function may be used. Before the specific driver initialization
237 * code finishes, NCR5380_print_options should be called.
238 */
239
240 static struct Scsi_Host *first_instance = NULL;
241 static Scsi_Host_Template *the_template = NULL;
242
243 /*
244 * Function : void initialize_SCp(Scsi_Cmnd *cmd)
245 *
246 * Purpose : initialize the saved data pointers for cmd to point to the
247 * start of the buffer.
248 *
249 * Inputs : cmd - Scsi_Cmnd structure to have pointers reset.
250 */
251
252 static __inline__ void initialize_SCp(Scsi_Cmnd *cmd) {
/* ![[next]](../icons/right.png)
![[first]](../icons/n_first.png)
![[top]](../icons/top.png)
*/
253 /*
254 * Initialize the Scsi Pointer field so that all of the commands in the
255 * various queues are valid.
256 */
257
258 if (cmd->use_sg) {
259 cmd->SCp.buffer = (struct scatterlist *) cmd->buffer;
260 cmd->SCp.buffers_residual = cmd->use_sg - 1;
261 cmd->SCp.ptr = (char *) cmd->SCp.buffer->address;
262 cmd->SCp.this_residual = cmd->SCp.buffer->length;
263 } else {
264 cmd->SCp.buffer = NULL;
265 cmd->SCp.buffers_residual = 0;
266 cmd->SCp.ptr = (char *) cmd->request_buffer;
267 cmd->SCp.this_residual = cmd->request_bufflen;
268 }
269 }
270
271 #include <linux/delay.h>
272
273 #ifdef NDEBUG
274 static struct {
275 unsigned char mask;
276 char * name;}
277 signals[] = {{ SR_DBP, "PARITY"}, { SR_RST, "RST" }, { SR_BSY, "BSY" },
278 { SR_REQ, "REQ" }, { SR_MSG, "MSG" }, { SR_CD, "CD" }, { SR_IO, "IO" },
279 { SR_SEL, "SEL" }, {0, NULL}},
280 basrs[] = {{BASR_ATN, "ATN"}, {BASR_ACK, "ACK"}, {0, NULL}},
281 icrs[] = {{ICR_ASSERT_RST, "ASSERT RST"},{ICR_ASSERT_ACK, "ASSERT ACK"},
282 {ICR_ASSERT_BSY, "ASSERT BSY"}, {ICR_ASSERT_SEL, "ASSERT SEL"},
283 {ICR_ASSERT_ATN, "ASSERT ATN"}, {ICR_ASSERT_DATA, "ASSERT DATA"},
284 {0, NULL}},
285 mrs[] = {{MR_BLOCK_DMA_MODE, "MODE BLOCK DMA"}, {MR_TARGET, "MODE TARGET"},
286 {MR_ENABLE_PAR_CHECK, "MODE PARITY CHECK"}, {MR_ENABLE_PAR_INTR,
287 "MODE PARITY INTR"}, {MR_MONITOR_BSY, "MODE MONITOR BSY"},
288 {MR_DMA_MODE, "MODE DMA"}, {MR_ARBITRATE, "MODE ARBITRATION"},
289 {0, NULL}};
290
291 /*
292 * Function : void NCR5380_print(struct Scsi_Host *instance)
293 *
294 * Purpose : print the SCSI bus signals for debugging purposes
295 *
296 * Input : instance - which NCR5380
297 */
298
299 static void NCR5380_print(struct Scsi_Host *instance) {
/* ![[previous]](../icons/left.png)
*/
300 NCR5380_local_declare();
301 unsigned char status, data, basr, mr, icr, i;
302 NCR5380_setup(instance);
303 cli();
304 data = NCR5380_read(CURRENT_SCSI_DATA_REG);
305 status = NCR5380_read(STATUS_REG);
306 mr = NCR5380_read(MODE_REG);
307 icr = NCR5380_read(INITIATOR_COMMAND_REG);
308 basr = NCR5380_read(BUS_AND_STATUS_REG);
309 sti();
310 for (i = 0; signals[i].mask ; ++i)
311 if (status & signals[i].mask)
312 printk(" %s", signals[i].name);
313 for (i = 0; basrs[i].mask ; ++i)
314 if (basr & basrs[i].mask)
315 printk(" %s", basrs[i].name);
316 for (i = 0; icrs[i].mask; ++i)
317 if (icr & icrs[i].mask)
318 printk(" %s", icrs[i].name);
319 for (i = 0; mrs[i].mask; ++i)
320 if (mr & mrs[i].mask)
321 printk(" %s", mrs[i].name);
322 printk("\n");
323 }
324
325 static struct {
326 unsigned char value;
327 char *name;
328 } phases[] = {
329 {PHASE_DATAOUT, "DATAOUT"}, {PHASE_DATAIN, "DATAIN"}, {PHASE_CMDOUT, "CMDOUT"},
330 {PHASE_STATIN, "STATIN"}, {PHASE_MSGOUT, "MSGOUT"}, {PHASE_MSGIN, "MSGIN"},
331 {PHASE_UNKNOWN, "UNKNOWN"}};
332
333 /*
334 * Function : void NCR5380_print_phase(struct Scsi_Host *instance)
335 *
336 * Purpose : print the current SCSI phase for debugging purposes
337 *
338 * Input : instance - which NCR5380
339 */
340
341 static void NCR5380_print_phase(struct Scsi_Host *instance) {
/* */
342 NCR5380_local_declare();
343 unsigned char status;
344 int i;
345 NCR5380_setup(instance);
346
347 status = NCR5380_read(STATUS_REG);
348 if (!(status & SR_REQ))
349 printk("scsi%d : REQ not asserted, phase unknown.\n",
350 instance->host_no);
351 else {
352 for (i = 0; (phases[i].value != PHASE_UNKNOWN) &&
353 (phases[i].value != (status & PHASE_MASK)); ++i);
354 printk("scsi%d : phase %s\n", instance->host_no, phases[i].name);
355 }
356 }
357 #endif
358
359 /*
360 * We need to have our corroutine active given these constraints :
361 * 1. The mutex flag, main_running, can only be set when the main
362 * routine can actually process data, otherwise SCSI commands
363 * will never get issued.
364 *
365 * 2. NCR5380_main() shouldn't be called before it has exited, because
366 * other drivers have had kernel stack overflows in similar
367 * situations.
368 *
369 * 3. We don't want to inline NCR5380_main() because of space concerns,
370 * even though it is only called in two places.
371 *
372 * So, the solution is to set the mutex in an inline wrapper for the
373 * main corroutine, and have the main corroutine exit with interrupts
374 * disabled after the final search through the queues so that no race
375 * conditions are possible.
376 */
377
378 static volatile int main_running = 0;
379
380 /*
381 * Function : run_main(void)
382 *
383 * Purpose : insure that the coroutine is running and will process our
384 * request. main_running is checked/set here (in an inline function)
385 * rather than in NCR5380_main itself to reduce the chances of stack
386 * overflow.
387 *
388 */
389
390 static __inline__ void run_main(void) {
/* */
391 cli();
392 if (!main_running) {
393 main_running = 1;
394 NCR5380_main();
395 /*
396 * main_running is cleared in NCR5380_main once it can't do
397 * more work, and NCR5380_main exits with interrupts disabled.
398 */
399 sti();
400 } else
401 sti();
402 }
403
404 #ifdef USLEEP
405 #ifndef NCR5380_TIMER
406 #error "NCR5380_TIMER must be defined so that this type of NCR5380 driver gets a unique timer."
407 #endif
408
409 /*
410 * These need tweaking, and would probably work best as per-device
411 * flags initialized differently for disk, tape, cd, etc devices.
412 * People with broken devices are free to experiment as to what gives
413 * the best results for them.
414 *
415 * USLEEP_SLEEP should be a minimum seek time.
416 *
417 * USLEEP_POLL should be a maximum rotational latency.
418 */
419 #ifndef USLEEP_SLEEP
420 /* 20 ms (reasonable hard disk speed) */
421 #define USLEEP_SLEEP 2
422 #endif
423 /* 300 RPM (floppy speed) */
424 #ifndef USLEEP_POLL
425 #define USLEEP_POLL 20
426 #endif
427
428 static struct Scsi_Host * expires_first = NULL;
429
430 /*
431 * Function : int should_disconnect (unsigned char cmd)
432 *
433 * Purpose : decide weather a commmand would normally disconnect or
434 * not, since if it won't disconnect we should go to sleep.
435 *
436 * Input : cmd - opcode of SCSI command
437 *
438 * Returns : DISCONNECT_LONG if we should disconnect for a really long
439 * time (ie always, sleep, look for REQ active, sleep),
440 * DISCONNECT_TIME_TO_DATA if we would only disconnect for a normal
441 * time-to-data dealy, DISCONNECT_NONE if this command would return
442 * immediately.
443 *
444 * Future sleep algorithms based on time to data can exploit
445 * something like this so they can differentiate between "normal"
446 * (ie, read, write, seek) and unusual commands (ie, * format).
447 *
448 * Note : We don't deal with commands that handle an immediate disconnect,
449 *
450 */
451
452 static int should_disconnect (unsigned char cmd) {
/* */
453 switch (cmd) {
454 case READ_6:
455 case WRITE_6:
456 case SEEK_6:
457 case READ_10:
458 case WRITE_10:
459 case SEEK_10:
460 return DISCONNECT_TIME_TO_DATA;
461 case FORMAT_UNIT:
462 case SEARCH_HIGH:
463 case SEARCH_LOW:
464 case SEARCH_EQUAL:
465 return DISCONNECT_LONG;
466 default:
467 return DISCONNECT_NONE;
468 }
469 }
470
471 /*
472 * Assumes instance->time_expires has been set in higher level code.
473 */
474
475 static int NCR5380_set_timer (struct Scsi_Host *instance) {
/* */
476 struct Scsi_Host *tmp, **prev;
477
478 cli();
479 if (((struct NCR5380_hostdata *) (instance->host_data))->next_timer) {
480 sti();
481 return -1;
482 }
483
484 for (prev = &expires_first, tmp = expires_first; tmp;
485 prev = &(((struct NCR5380_hostdata *) tmp->host_data)->next_timer),
486 tmp = ((struct NCR5380_hostdata *) tmp->host_data)->next_timer)
487 if (instance->time_expires < tmp->time_expires)
488 break;
489
490 instance->next_timer = tmp;
491 *prev = instance;
492 timer_table[NCR5380_TIMER].expires = expires_first->time_expires;
493 timer_active |= 1 << NCR5380_TIMER;
494 sti;
495 return 0;
496 }
497
498 /* Doing something about unwanted rentrancy here might be useful */
499 void NCR5380_timer_fn(void) {
/* */
500 struct Scsi_Host *instance;
501 cli();
502 for (; expires_first && expires_first->time_expires >= jiffies; ) {
503 instance = ((NCR5380_hostdata *) expires_first->host_data)->
504 expires_next;
505 ((NCR5380_hostdata *) expires_first->host_data)->expires_next =
506 NULL;
507 ((NCR5380_hostdata *) expires_first->host_data)->time_expires =
508 0;
509 expires_first = instance;
510 }
511
512 if (expires_first) {
513 timer_table[NCR5380_TIMER].expires = ((NCR5380_hostdata *)
514 expires_first->host_data)->time_expires;
515 timer_active |= (1 << NCR5380_TIMER);
516 } else {
517 timer_table[NCR5380_TIMER].expires = 0;
518 timer_active &= ~(1 << MCR5380_TIMER);
519 }
520 sti();
521
522 run_main();
523 }
524 #endif /* def USLEEP */
525
526 static void NCR5380_all_init (void) {
/* */
527 static int done = 0;
528 if (!done) {
529 #if (NDEBUG & NDEBUG_INIT)
530 printk("scsi : NCR5380_all_init()\n");
531 #endif
532 done = 1;
533 #ifdef USLEEP
534 timer_table[NCR5380_TIMER].expires = 0;
535 timer_table[NCR5380_TIMER].fn = NCR5380_timer_fn;
536 #endif
537 }
538 }
539
540 #ifdef AUTOPROBE_IRQ
541 /*
542 * Function : int NCR5380_probe_irq (struct Scsi_Host *instance, int possible)
543 *
544 * Purpose : autoprobe for the IRQ line used by the NCR5380.
545 *
546 * Inputs : instance - pointer to this instance of the NCR5380 driver,
547 * possible - bitmask of permissable interrupts.
548 *
549 * Returns : number of the IRQ selected, IRQ_NONE if no interrupt fired.
550 *
551 * XXX no effort is made to deal with spurious interrupts.
552 */
553
554
555 static int probe_irq;
556 static void probe_intr (int sig) {
/* */
557 probe_irq = sig;
558 };
559 static struct sigaction probe_sigaction = { probe_intr, 0, SA_INTERRUPT,
560 NULL};
561
562 static int NCR5380_probe_irq (struct Scsi_Host *instance, int possible) {
/* */
563 NCR5380_local_declare();
564 struct NCR5380_hostdata *hostdata = (struct NCR5380_hostdata *)
565 instance->hostdata;
566 unsigned long timeout;
567 int trying_irqs, i, mask;
568 NCR5380_setup(instance);
569
570 for (trying_irqs = i = 0, mask = 1; i < 16; ++i, mask <<= 1)
571 if ((mask & possible) && (irqaction (i, &probe_sigaction)
572 == 0))
573 trying_irqs |= mask;
574
575 timeout = jiffies + 25;
576 probe_irq = IRQ_NONE;
577
578 /*
579 * A interrupt is triggered whenever BSY = false, SEL = true
580 * and a bit set in the SELECT_ENABLE_REG is asserted on the
581 * SCSI bus.
582 *
583 * Note that the bus is only driven when the phase control signals
584 * (I/O, C/D, and MSG) match those in the TCR, so we must reset that
585 * to zero.
586 */
587
588 NCR5380_write(TARGET_COMMAND_REG, 0);
589 NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
590 NCR5380_write(OUTPUT_DATA_REG, hostdata->id_mask);
591 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_DATA |
592 ICR_ASSERT_SEL);
593
594 while (probe_irq == IRQ_NONE && jiffies < timeout);
595
596 NCR5380_write(SELECT_ENABLE_REG, 0);
597 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
598
599 for (i = 0, mask = 1; i < 16; ++i, mask <<= 1)
600 if (trying_irqs & mask)
601 free_irq(i);
602
603 return probe_irq;
604 }
605 #endif /* AUTOPROBE_IRQ */
606
607 /*
608 * Function : void NCR58380_print_options (struct Scsi_Host *instance)
609 *
610 * Purpose : called by probe code indicating the NCR5380 driver
611 * options that were selected.
612 *
613 * Inputs : instance, pointer to this instance. Unused.
614 */
615
616 static void NCR5380_print_options (struct Scsi_Host *instance) {
/* */
617 printk(" generic options"
618 #ifdef AUTOPROBE_IRQ
619 " AUTOPROBE_IRQ"
620 #endif
621 #ifdef AUTOSENSE
622 " AUTOSENSE"
623 #endif
624 #ifdef DIFFERENTIAL
625 " DIFFERENTIAL"
626 #endif
627 #ifdef REALDMA
628 " REAL DMA"
629 #endif
630 #ifdef PARITY
631 " PARITY"
632 #endif
633 #ifdef PSEUDO_DMA
634 " PSEUDO DMA"
635 #endif
636 #ifdef SCSI2
637 " SCSI-2"
638 #endif
639 #ifdef UNSAFE
640 " UNSAFE "
641 #endif
642 );
643 #ifdef USLEEP
644 printk(" USLEEP, USLEEP_POLL=%d USLEEP_SLEEP=%d", USLEEP_POLL, USLEEP_SLEEP);
645 #endif
646 printk(" generic release=%d", NCR5380_PUBLIC_RELEASE);
647 }
648
649
650 /*
651 * Function : void NCR5380_init (struct Scsi_Host *instance)
652 *
653 * Purpose : initializies *instance and corresponding 5380 chip.
654 *
655 * Inputs : instance - instantiation of the 5380 driver.
656 *
657 * Notes : I assume that the host, hostno, and id bits have been
658 * set correctly. I don't care about the irq and other fields.
659 *
660 */
661
662 static void NCR5380_init (struct Scsi_Host *instance) {
/* */
663 NCR5380_local_declare();
664 int i;
665 struct NCR5380_hostdata *hostdata = (struct NCR5380_hostdata *)
666 instance->hostdata;
667 NCR5380_setup(instance);
668
669 NCR5380_all_init();
670
671 hostdata->id_mask = 1 << instance->this_id;
672 for (i = hostdata->id_mask; i <= 0x80; i <<= 1)
673 if (i > hostdata->id_mask)
674 hostdata->id_higher_mask |= i;
675 for (i = 0; i < 8; ++i)
676 hostdata->busy[i] = 0;
677 #ifdef REAL_DMA
678 hostdata->dmalen = 0;
679 #endif
680 hostdata->connected = NULL;
681 hostdata->issue_queue = NULL;
682 hostdata->disconnected_queue = NULL;
683
684 if (!the_template) {
685 the_template = instance->hostt;
686 first_instance = instance;
687 }
688
689
690 #ifdef USLEEP
691 hostdata->time_expires = 0;
692 hostdata->next_timer = NULL;
693 #endif
694
695 #ifndef AUTOSENSE
696 if ((instance->cmd_per_lun > 1) || instance->can_queue > 1))
697 printk("scsi%d : WARNING : support for multiple outstanding commands enabled\n"
698 " without AUTOSENSE option, contigent alligence conditions may\n"
699 " be incorrectly cleared.\n", instance->host_no);
700 #endif /* def AUTOSENSE */
701
702 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
703 NCR5380_write(MODE_REG, MR_BASE);
704 NCR5380_write(TARGET_COMMAND_REG, 0);
705 NCR5380_write(SELECT_ENABLE_REG, 0);
706 }
707
708 /*
709 * Function : int NCR5380_queue_command (Scsi_Cmnd *cmd,
710 * void (*done)(Scsi_Cmnd *))
711 *
712 * Purpose : enqueues a SCSI command
713 *
714 * Inputs : cmd - SCSI command, done - function called on completion, with
715 * a pointer to the command descriptor.
716 *
717 * Returns : 0
718 *
719 * Side effects :
720 * cmd is added to the per instance issue_queue, with minor
721 * twiddling done to the host specific fields of cmd. If the
722 * main coroutine is not running, it is restarted.
723 *
724 */
725
726 /* Only make static if a wrapper function is used */
727 #ifndef NCR5380_queue_command
728 static
729 #endif
730 int NCR5380_queue_command (Scsi_Cmnd *cmd, void (*done)(Scsi_Cmnd *)) {
/* */
731 struct NCR5380_hostdata *hostdata = (struct NCR5380_hostdata *)
732 cmd->host->hostdata;
733 Scsi_Cmnd *tmp;
734
735 #if (NDEBUG & NDEBUG_NO_WRITE)
736 switch (cmd->cmnd[0]) {
737 case WRITE:
738 case WRITE_10:
739 printk("scsi%d : WRITE attempted with NO_WRITE debugging flag set\n",
740 instance->host_no);
741 cmd->result = (DID_ERROR << 16);
742 done(cmd);
743 return 0;
744 }
745 #endif /* (NDEBUG & NDEBUG_NO_WRITE) */
746
747
748 /*
749 * We use the host_scribble field as a pointer to the next command
750 * in a queue
751 */
752
753 cmd->host_scribble = NULL;
754 cmd->scsi_done = done;
755
756 cmd->result = 0;
757
758
759 /*
760 * Insert the cmd into the issue queue. Note that REQUEST SENSE
761 * commands are added to the head of the queue since any command will
762 * clear the contingent allegience condition that exists and the
763 * sense data is only guranteed to be valid while the condition exists.
764 */
765
766 cli();
767 if (!(hostdata->issue_queue) || (cmd->cmnd[0] == REQUEST_SENSE)) {
768 cmd->host_scribble = (unsigned char *) hostdata->issue_queue;
769 hostdata->issue_queue = cmd;
770 } else {
771 for (tmp = (Scsi_Cmnd *) hostdata->issue_queue; tmp->host_scribble;
772 tmp = (Scsi_Cmnd *) tmp->host_scribble);
773 tmp->host_scribble = (unsigned char *) cmd;
774 }
775 #if (NDEBUG & NDEBUG_QUEUES)
776 printk("scsi%d : command added to %s of queue\n", instance->host_no,
777 (cmd->cmnd[0] == REQUEST_SENSE) ? "head" : "tail");
778 #endif
779
780 /* Run the coroutine if it isn't allready running. */
781 run_main();
782 return 0;
783 }
784
785 /*
786 * Function : NCR5380_main (void)
787 *
788 * Purpose : NCR5380_main is a corroutine that runs as long as more work can
789 * be done on the NCR5380 host adapters in a system. Both
790 * NCR5380_queue_command() and NCR5380_intr() will try to start it
791 * in case it is not running.
792 *
793 * NOTE : NCR5380_main exits with interrupts *disabled*, the caller should
794 * reenable them. This prevents rentrancy and kernel stack overflow.
795 */
796
797 static void NCR5380_main (void) {
/* */
798 Scsi_Cmnd *tmp, *prev;
799 struct Scsi_Host *instance;
800 struct NCR5380_hostdata *hostdata;
801 int done;
802
803 /*
804 * We run (with interrupts disabled) until we're sure that none of
805 * the host adapters have anything that can be done, at which point
806 * we set main_running to 0 and exit.
807 *
808 * Interrupts are enabled before doing various other internal
809 * instructions, after we've decided that we need to run through
810 * the loop again.
811 *
812 * this should prevent any race conditions.
813 */
814
815 do {
816 cli(); /* Freeze request queues */
817 done = 1;
818 for (instance = first_instance; instance && instance->hostt == the_template;
819 instance=instance->next) {
820 hostdata = (struct NCR5380_hostdata *) instance->hostdata;
821 cli();
822 if (!hostdata->connected) {
823 #if (NDEBUG & NDEBUG_MAIN)
824 printk("scsi%d : not connected\n", instance->host_no);
825 #endif
826 /*
827 * Search through the issue_queue for a command destined
828 * for a target that's not busy.
829 */
830 for (tmp = (Scsi_Cmnd *) hostdata->issue_queue,
831 prev = NULL; tmp; prev = tmp, tmp = (Scsi_Cmnd *)
832 tmp->host_scribble)
833
834 /* When we find one, remove it from the issue queue. */
835 if (!(hostdata->busy[tmp->target] & (1 << tmp->lun))) {
836 if (prev)
837 prev->host_scribble = tmp->host_scribble;
838 else
839 hostdata->issue_queue = (Scsi_Cmnd *) tmp->host_scribble;
840 tmp->host_scribble = NULL;
841
842 /* renable interrupts after finding one */
843 sti();
844
845 /*
846 * Attempt to establish an I_T_L nexus here.
847 * On success, instance->hostdata->connected is set.
848 * On failure, we must add the command back to the
849 * issue queue so we can keep trying.
850 */
851 #if (NDEBUG & (NDEBUG_MAIN | NDEBUG_QUEUES))
852 printk("scsi%d : main() : command for target %d lun %d removed from issue_queue\n",
853 instance->host_no, tmp->target, tmp->lun);
854 #endif
855 /*
856 * REQUEST SENSE commands are issued without tagged
857 * queueing, even on SCSI-II devices because the
858 * contingent alligence condition exists for the
859 * entire unit.
860 */
861
862 if (!NCR5380_select(instance, tmp,
863 (tmp->cmnd[0] == REQUEST_SENSE) ? TAG_NONE :
864 TAG_NEXT)) {
865 break;
866 } else {
867 cli();
868 tmp->host_scribble = (unsigned char *)
869 hostdata->issue_queue;
870 hostdata->issue_queue = tmp;
871 sti();
872 #if (NDEBUG & (NDEBUG_MAIN | NDEBUG_QUEUES))
873 printk("scsi%d : main(): select() failed, returned to issue_queue\n",
874 instance->host_no);
875 #endif
876 }
877 } /* if target/lun is not busy */
878 } /* if (!hostdata->connected) */
879
880 if (hostdata->connected
881 #ifdef REAL_DMA
882 && !hostdata->dmalen
883 #endif
884 #ifdef USLEEP
885 && (!hostdata->time_expires || hostdata->time_expires >= jiffies)
886 #endif
887 ) {
888 sti();
889 #if (NDEBUG & NDEBUG_MAIN)
890 printk("scsi%d : main() : performing information transfer\n",
891 instance->host_no);
892 #endif
893 NCR5380_information_transfer(instance);
894 #if (NDEBUG & NDEBUG_MAIN)
895 printk("scsi%d : main() : done set false\n", instance->host_no);
896 #endif
897 done = 0;
898 } else
899 break;
900 } /* for instance */
901 } while (!done);
902 main_running = 0;
903 }
904
905 /*
906 * Function : void NCR5380_intr (int irq)
907 *
908 * Purpose : handle interrupts, restablishing I_T_L or I_T_L_Q nexuses
909 * from the disconnected queue, and restarting NCR5380_main()
910 * as required.
911 *
912 * Inputs : int irq, irq that caused this interrupt.
913 *
914 */
915
916 static void NCR5380_intr (int irq) {
/* */
917 NCR5380_local_declare();
918 struct Scsi_Host *instance;
919 int done;
920 #if (NDEBUG & NDEBUG_INTR)
921 printk("scsi : NCR5380 irq %d triggered\n", irq);
922 #endif
923 do {
924 done = 1;
925 for (instance = first_instance; instance && (instance->hostt ==
926 the_template); instance = instance->next)
927 if (instance->irq == irq) {
928
929 /* Look for pending interrupts */
930 NCR5380_setup(instance);
931 /* XXX dispatch to appropriate routine if found and done=0 */
932 if (NCR5380_read(BUS_AND_STATUS_REG) & BASR_IRQ) {
933 #if (NDEBUG & NDEBUG_INTR)
934 NCR5380_print(instance);
935 #endif
936 if ((NCR5380_read(STATUS_REG) & (SR_SEL | SR_IO)) ==
937 (SR_SEL | SR_IO)) {
938 done = 0;
939 sti();
940 #if (NDEBUG & NDEBUG_INTR)
941 printk("scsi%d : SEL interrupt\n", instance->host_no);
942 #endif
943 NCR5380_reselect(instance);
944 (void) NCR5380_read(RESET_PARITY_INTERRUPT_REG);
945 } else if (NCR5380_read(BUS_AND_STATUS_REG) &
946 BASR_PARITY_ERROR) {
947 #if (NDEBUG & NDEBUG_INTR)
948 printk("scsi%d : PARITY interrupt\n", instance->host_no);
949 #endif
950 (void) NCR5380_read(RESET_PARITY_INTERRUPT_REG);
951 } else {
952 /*
953 * XXX the rest of the interrupt conditions should *only* occur during a
954 * DMA transfer, which I haven't gotten arround to fixing yet.
955 */
956
957 #if defined(REAL_DMA)
958 #else
959 #if (NDEBUG & NDEBUG_INTR)
960 printk("scsi : unknown interrupt\n");
961 #endif
962 #endif
963 }
964 } /* if BASR_IRQ */
965 if (!done)
966 run_main();
967 } /* if (instance->irq == irq) */
968 } while (!done);
969 }
970
971 /*
972 * Function : int NCR5380_select (struct Scsi_Host *instance, Scsi_Cmnd *cmd,
973 * int tag);
974 *
975 * Purpose : establishes I_T_L or I_T_L_Q nexus for new or existing command,
976 * including ARBITRATION, SELECTION, and initial message out for
977 * IDENTIFY and queue messages.
978 *
979 * Inputs : instance - instantiation of the 5380 driver on which this
980 * target lives, cmd - SCSI command to execute, tag - set to TAG_NEXT for
981 * new tag, TAG_NONE for untagged queueing, otherwise set to the tag for
982 * the command that is presently connected.
983 *
984 * Returns : -1 if selection could not execute for some reason,
985 * 0 if selection succeeeded or failed because the target
986 * did not respond.
987 *
988 * Side effects :
989 * If bus busy, arbitration failed, etc, NCR5380_select() will exit
990 * with registers as they should have been on entry - ie
991 * SELECT_ENABLE will be set appropriately, the NCR5380
992 * will cease to drive any SCSI bus signals.
993 *
994 * If successful : I_T_L or I_T_L_Q nexus will be established,
995 * instance->connected will be set to cmd.
996 * SELECT interrupt will be disabled.
997 *
998 * If failed (no target) : cmd->scsi_done() will be called, and the
999 * cmd->result host byte set to DID_BAD_TARGET.
1000 */
1001
1002 static int NCR5380_select (struct Scsi_Host *instance, Scsi_Cmnd *cmd,
/* */
1003 int tag) {
1004 NCR5380_local_declare();
1005 struct NCR5380_hostdata *hostdata = (struct NCR5380_hostdata*)
1006 instance->hostdata;
1007 unsigned char tmp[3], phase;
1008 unsigned char *data;
1009 int len;
1010 unsigned long timeout;
1011 NCR5380_setup(instance);
1012
1013 #if defined (NDEBUG) && (NDEBUG & NDEBUG_ARBITRATION)
1014 NCR5380_print(instance);
1015 printk("scsi%d : starting arbitration, id = %d\n", instance->host_no,
1016 instance->this_id);
1017 #endif
1018
1019 /*
1020 * Set the phase bits to 0, otherwise the NCR5380 won't drive the
1021 * data bus during SELECTION.
1022 */
1023
1024 NCR5380_write(TARGET_COMMAND_REG, 0);
1025
1026 /* Start arbitration */
1027 NCR5380_write(OUTPUT_DATA_REG, hostdata->id_mask);
1028 NCR5380_write(MODE_REG, MR_ARBITRATE);
1029
1030 /* Wait for arbitration logic to complete */
1031 while (!(NCR5380_read(INITIATOR_COMMAND_REG) & ICR_ARBITRATION_PROGRESS));
1032
1033 #if (NDEBUG & NDEBUG_ARBITRATION)
1034 printk("scsi%d : arbitration complete\n", instance->host_no);
1035 /* Avoid GCC 2.4.5 asm needs to many reloads error */
1036 __asm__("nop");
1037 #endif
1038
1039 /*
1040 * The arbitration delay is 2.2us, but this is a minimum and there is
1041 * no maximum so we can safely sleep for ceil(2.2) usecs to accomodate
1042 * the integral nature of udelay().
1043 *
1044 */
1045
1046 udelay(3);
1047
1048 /* Check for lost arbitration */
1049 if ((NCR5380_read(INITIATOR_COMMAND_REG) & ICR_ARBITRATION_LOST) ||
1050 (NCR5380_read(CURRENT_SCSI_DATA_REG) & hostdata->id_higher_mask) ||
1051 (NCR5380_read(INITIATOR_COMMAND_REG) & ICR_ARBITRATION_LOST)) {
1052 NCR5380_write(MODE_REG, MR_BASE);
1053 #if (NDEBUG & NDEBUG_ARBITRATION)
1054 printk("scsi%d : lost arbitration, deasserting MR_ARBITRATE\n",
1055 instance->host_no);
1056 #endif
1057 return -1;
1058 }
1059
1060 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_SEL);
1061
1062 if (NCR5380_read(INITIATOR_COMMAND_REG) & ICR_ARBITRATION_LOST) {
1063 NCR5380_write(MODE_REG, MR_BASE);
1064 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
1065 #if (NDEBUG & NDEBUG_ARBITRATION)
1066 printk("scsi%d : lost arbitration, deasserting ICR_ASSERT_SEL\n",
1067 instance->host_no);
1068 #endif
1069 return -1;
1070 }
1071
1072 /*
1073 * Again, bus clear + bus settle time is 1.2us, however, this is
1074 * a minimum so we'll udelay ceil(1.2)
1075 */
1076
1077 udelay(2);
1078
1079 #if (NDEBUG & NDEBUG_ARBITRATION)
1080 printk("scsi%d : won arbitration\n", instance->host_no);
1081 #endif
1082
1083 /*
1084 * Now that we have won arbitration, start Selection process, asserting
1085 * the host and target ID's on the SCSI bus.
1086 */
1087
1088 NCR5380_write(OUTPUT_DATA_REG, (hostdata->id_mask | (1 << cmd->target)));
1089
1090 /*
1091 * Raise ATN while SEL is true before BSY goes false from arbitration,
1092 * since this is the only way to gurantee that we'll get a MESSAGE OUT
1093 * phase immediately after selection.
1094 */
1095
1096 NCR5380_write(INITIATOR_COMMAND_REG, (ICR_BASE | ICR_ASSERT_BSY |
1097 ICR_ASSERT_DATA | ICR_ASSERT_ATN | ICR_ASSERT_SEL ));
1098 NCR5380_write(MODE_REG, MR_BASE);
1099
1100 /*
1101 * Reselect interrupts must be turned off prior to the dropping of BSY,
1102 * otherwise we will trigger an interrupt.
1103 */
1104 NCR5380_write(SELECT_ENABLE_REG, 0);
1105
1106 /* Reset BSY */
1107 NCR5380_write(INITIATOR_COMMAND_REG, (ICR_BASE | ICR_ASSERT_DATA |
1108 ICR_ASSERT_ATN | ICR_ASSERT_SEL));
1109
1110 /*
1111 * Something wierd happens when we cease to drive BSY - looks
1112 * like the board/chip is letting us do another read before the
1113 * appropriate propogation delay has expired, and we're confusing
1114 * a BSY signal from ourselves as the target's response to SELECTION.
1115 *
1116 * A small delay (the 'C++' frontend breaks the pipeline with an
1117 * unecessary jump, making it work on my 386-33/Trantor T128, the
1118 * tighter 'C' code breaks and requires this) solves the problem -
1119 * the 1 us delay is arbitrary, and only used because this delay will
1120 * be the same on other platforms and since it works here, it should
1121 * work there.
1122 */
1123
1124 udelay(1);
1125
1126 #if (NDEBUG & NDEBUG_SELECTION)
1127 printk("scsi%d : selecting target %d\n", instance->host_no, cmd->target);
1128 #endif
1129
1130 /*
1131 * The SCSI specification calls for a 250 ms timeout for the actual
1132 * selection.
1133 */
1134
1135 timeout = jiffies + 25;
1136
1137 /*
1138 * XXX very interesting - we're seeing a bounce where the BSY we
1139 * asserted is being reflected / still asserted (propogation delay?)
1140 * and it's detecting as true. Sigh.
1141 */
1142
1143 while ((jiffies < timeout) && !(NCR5380_read(STATUS_REG) & SR_BSY));
1144
1145 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN);
1146
1147 if (!(NCR5380_read(STATUS_REG) & SR_BSY)) {
1148 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
1149 cmd->result = DID_BAD_TARGET << 16;
1150 cmd->scsi_done(cmd);
1151 NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
1152 #if (NDEBUG & NDEBUG_SELECTION)
1153 printk("scsi%d : target did not respond within 250ms\n",
1154 instance->host_no);
1155 #endif
1156 return 0;
1157 }
1158
1159 /*
1160 * Since we followed the SCSI spec, and raised ATN while SEL
1161 * was true but before BSY was false during selection, the information
1162 * transfer phase should be a MESSAGE OUT phase so that we can send the
1163 * IDENTIFY message.
1164 *
1165 * If SCSI-II tagged queing is enabled, we also send a SIMPLE_QUEUE_TAG
1166 * message (2 bytes) with a tag ID that we increment with every command
1167 * until it wraps back to 0.
1168 *
1169 * XXX - it turns out that there are some broken SCSI-II devices,
1170 * which claim to support tagged queing but fail when more than
1171 * some number of commands are issued at once.
1172 */
1173
1174 /* Wait for start of REQ/ACK handshake */
1175 while (!(NCR5380_read(STATUS_REG) & SR_REQ));
1176
1177 #if (NDEBUG & NDEBUG_SELECTION)
1178 printk("scsi%d : target %d selected, going into MESSAGE OUT phase.\n",
1179 instance->host_no, cmd->target);
1180 #endif
1181 tmp[0] = IDENTIFY(((instance->irq == IRQ_NONE) ? 0 : 1), cmd->lun);
1182 #ifdef SCSI2
1183 if (scsi_devices[cmd->index].tagged_queue && (tag != TAG_NONE)) {
1184 tmp[1] = SIMPLE_QUEUE_TAG;
1185 if (tag == TAG_NEXT) {
1186 /* 0 is TAG_NONE, used to imply no tag for this command */
1187 if (scsi_devices[cmd->index].current_tag == 0)
1188 scsi_devices[cmd->index].current_tag = 1;
1189
1190 cmd->tag = scsi_devices[cmd->index].current_tag;
1191 scsi_devices[cmd->index].current_tag++;
1192 } else
1193 cmd->tag = (unsigned char) tag;
1194
1195 tmp[2] = cmd->tag;
1196 hostdata->last_message = SIMPLE_QUEUE_TAG;
1197 len = 3;
1198 } else
1199 #endif /* def SCSI2 */
1200 {
1201 len = 1;
1202 cmd->tag=0;
1203 }
1204
1205 /* Send message(s) */
1206 data = tmp;
1207 phase = PHASE_MSGOUT;
1208 NCR5380_transfer_pio(instance, &phase, &len, &data);
1209 #if (NDEBUG & NDEBUG_SELECTION)
1210 printk("scsi%d : nexus established.\n", instance->host_no);
1211 #endif
1212 /* XXX need to handle errors here */
1213 hostdata->connected = cmd;
1214 #ifdef SCSI2
1215 if (!scsi_devices[cmd->index].tagged_queue)
1216 #endif
1217 hostdata->busy[cmd->target] |= (1 << cmd->lun);
1218
1219 initialize_SCp(cmd);
1220
1221 return 0;
1222 }
1223
1224 /*
1225 * Function : int NCR5380_transfer_pio (struct Scsi_Host *instance,
1226 * unsigned char *phase, int *count, unsigned char **data)
1227 *
1228 * Purpose : transfers data in given phase using polled I/O
1229 *
1230 * Inputs : instance - instance of driver, *phase - pointer to
1231 * what phase is expected, *count - pointer to number of
1232 * bytes to transfer, **data - pointer to data pointer.
1233 *
1234 * Returns : -1 when different phase is enterred without transfering
1235 * maximum number of bytes, 0 if all bytes or transfered or exit
1236 * is in same phase.
1237 *
1238 * Also, *phase, *count, *data are modified in place.
1239 *
1240 * XXX Note : handling for bus free may be useful.
1241 */
1242
1243 /*
1244 * Note : this code is not as quick as it could be, however it
1245 * IS 100% reliable, and for the actual data transfer where speed
1246 * counts, we will always do a pseudo DMA or DMA transfer.
1247 */
1248
1249 static int NCR5380_transfer_pio (struct Scsi_Host *instance,
/* */
1250 unsigned char *phase, int *count, unsigned char **data) {
1251 NCR5380_local_declare();
1252 register unsigned char p = *phase, tmp;
1253 register int c = *count;
1254 register unsigned char *d = *data;
1255 NCR5380_setup(instance);
1256
1257 /*
1258 * The NCR5380 chip will only drive the SCSI bus when the
1259 * phase specified in the appropriate bits of the TARGET COMMAND
1260 * REGISTER match the STATUS REGISTER
1261 */
1262
1263 NCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(p));
1264
1265 do {
1266 /*
1267 * Wait for assertion of REQ, after which the phase bits will be
1268 * valid
1269 */
1270 while (!((tmp = NCR5380_read(STATUS_REG)) & SR_REQ));
1271
1272 #if (NDEBUG & NDEBUG_HANDSHAKE)
1273 printk("scsi%d : REQ detected\n", instance->host_no);
1274 #endif
1275
1276 /* Check for phase mismatch */
1277 if ((tmp & PHASE_MASK) != p) {
1278 #if (NDEBUG & NDEBUG_PIO)
1279 printk("scsi%d : phase mismatch\n", instance->host_no);
1280 NCR5380_print_phase(instance);
1281 #endif
1282 break;
1283 }
1284
1285 /* Do actual transfer from SCSI bus to / from memory */
1286 if (!(p & SR_IO))
1287 NCR5380_write(OUTPUT_DATA_REG, *d);
1288 else
1289 *d = NCR5380_read(CURRENT_SCSI_DATA_REG);
1290
1291 ++d;
1292
1293 /*
1294 * The SCSI standard suggests that in MSGOUT phase, the initiator
1295 * should drop ATN on the last byte of the message phase
1296 * after REQ has been asserted for the handshake but before
1297 * the initiator raises ACK.
1298 */
1299
1300 if (!(p & SR_IO)) {
1301 if (!((p & SR_MSG) && c > 1)) {
1302 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE |
1303 ICR_ASSERT_DATA);
1304 #if (NDEBUG & NDEBUG_PIO)
1305 NCR5380_print(instance);
1306 #endif
1307 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE |
1308 ICR_ASSERT_DATA | ICR_ASSERT_ACK);
1309 } else {
1310 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE |
1311 ICR_ASSERT_DATA | ICR_ASSERT_ATN);
1312 #if (NDEBUG & NDEBUG_PIO)
1313 NCR5380_print(instance);
1314 #endif
1315 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE |
1316 ICR_ASSERT_DATA | ICR_ASSERT_ATN | ICR_ASSERT_ACK);
1317 }
1318 } else {
1319 #if (NDEBUG & NDEBUG_PIO)
1320 NCR5380_print(instance);
1321 #endif
1322 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ACK);
1323 }
1324
1325 while (NCR5380_read(STATUS_REG) & SR_REQ);
1326
1327 #if (NDEBUG & NDEBUG_HANDSHAKE)
1328 printk("scsi%d : req false, handshake complete\n", instance->host_no);
1329 #endif
1330
1331 if (!(p == PHASE_MSGOUT && c > 1))
1332 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
1333 else
1334 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN);
1335 } while (--c);
1336
1337 #if (NDEBUG & NDEBUG_PIO)
1338 printk("scsi%d : residual %d\n", instance->host_no, c);
1339 #endif
1340
1341 *count = c;
1342 *data = d;
1343 tmp = NCR5380_read(STATUS_REG);
1344 if (tmp & SR_REQ)
1345 *phase = tmp & PHASE_MASK;
1346 else
1347 *phase = PHASE_UNKNOWN;
1348
1349 if (!c || (*phase == p))
1350 return 0;
1351 else
1352 return -1;
1353 }
1354
1355 #if defined(REAL_DMA) | defined(PSEUDO_DMA)
1356 /*
1357 * Function : int NCR5380_transfer_dma (struct Scsi_Host *instance,
1358 * unsigned char *phase, int *count, unsigned char **data)
1359 *
1360 * Purpose : transfers data in given phase using either real
1361 * or pseudo DMA.
1362 *
1363 * Inputs : instance - instance of driver, *phase - pointer to
1364 * what phase is expected, *count - pointer to number of
1365 * bytes to transfer, **data - pointer to data pointer.
1366 *
1367 * Returns : -1 when different phase is enterred without transfering
1368 * maximum number of bytes, 0 if all bytes or transfered or exit
1369 * is in same phase.
1370 *
1371 * Also, *phase, *count, *data are modified in place.
1372 *
1373 */
1374
1375
1376 static int NCR5380_transfer_dma (struct Scsi_Host *instance,
/* */
1377 unsigned char *phase, int *count, unsigned char **data) {
1378 NCR5380_local_declare();
1379 register int c = *count;
1380 register unsigned char p = *phase;
1381 register unsigned char *d = *data;
1382 unsigned char tmp;
1383 int foo;
1384 NCR5380_setup(instance);
1385
1386 #ifdef REAL_DMA
1387 instance->dmalen = c;
1388 if (p & SR_IO)
1389 NCR5380_dma_read_setup(d, c);
1390 else
1391 NCR5380_dma_write_setup(d, c);
1392 #endif
1393
1394
1395 if ((tmp = (NCR5380_read(STATUS_REG) & PHASE_MASK)) != p) {
1396 *phase = tmp;
1397 return -1;
1398 }
1399
1400 NCR5380_write(TARGET_COMMAND_REG, PHASE_SR_TO_TCR(p));
1401
1402 #ifdef REAL_DMA
1403 NCR5380_write(MODE_REG, MR_BASE | MR_DMA_MODE | MR_ENABLE_EOP_INTR | MR_MONITOR_BSY);
1404 #else
1405 /*
1406 * Note : on my sample board, watch-dog timeouts occured when interrupts
1407 * were not disabled for the duration of a single DMA transfer, from
1408 * before the setting of DMA mode to after transfer of the last byte.
1409 */
1410
1411 #ifndef UNSAFE
1412 cli();
1413 #endif
1414 NCR5380_write(MODE_REG, MR_BASE | MR_DMA_MODE);
1415 #endif
1416
1417 if (p & SR_IO)
1418 NCR5380_write(START_DMA_INITIATOR_RECIEVE_REG, 0);
1419 else {
1420 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_DATA);
1421 NCR5380_write(START_DMA_SEND_REG, 0);
1422 }
1423
1424 #ifdef REAL_DMA
1425 return 0;
1426 #else
1427 foo = ((p & SR_IO) ? NCR5380_pread(instance, d, c) :
1428 NCR5380_pwrite(instance, d, c));
1429 NCR5380_write(MODE_REG, MR_BASE);
1430 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
1431 *data = d + c;
1432 *count = 0;
1433 *phase = (NCR5380_read(STATUS_REG & PHASE_MASK));
1434 #ifndef UNSAFE
1435 sti();
1436 #endif
1437 return foo;
1438 #endif /* def REAL_DMA */
1439 }
1440 #endif /* defined(REAL_DMA) | defined(PSEUDO_DMA) */
1441
1442 /*
1443 * Function : NCR5380_information_transfer (struct Scsi_Host *instance)
1444 *
1445 * Purpose : run through the various SCSI phases and do as the target
1446 * directs us to. Operates on the currently connected command,
1447 * instance->connected.
1448 *
1449 * Inputs : instance, instance for which we are doing commands
1450 *
1451 * Side effects : SCSI things happen, the disconnected queue will be
1452 * modified if a command disconnects, *instance->connected will
1453 * change.
1454 *
1455 * XXX Note : we need to watch for bus free or a reset condition here
1456 * to recover from an unexpected bus free condition.
1457 */
1458
1459 static void NCR5380_information_transfer (struct Scsi_Host *instance) {
/* */
1460 NCR5380_local_declare();
1461 struct NCR5380_hostdata *hostdata = (struct NCR5380_hostdata *)
1462 instance->hostdata;
1463 unsigned char msgout = NOP;
1464 int len;
1465 unsigned char *data;
1466 unsigned char phase, tmp, old_phase=0xff;
1467 Scsi_Cmnd *cmd = (Scsi_Cmnd *) hostdata->connected;
1468 NCR5380_setup(instance);
1469
1470 while (1) {
1471 tmp = NCR5380_read(STATUS_REG);
1472 /* We only have a valid SCSI phase when REQ is asserted */
1473 if (tmp & SR_REQ) {
1474 phase = (tmp & PHASE_MASK);
1475 if (phase != old_phase) {
1476 old_phase = phase;
1477 #if (NDEBUG & NDEBUG_INFORMATION)
1478 NCR5380_print_phase(instance);
1479 #endif
1480 }
1481 switch (phase) {
1482 case PHASE_DATAIN:
1483 case PHASE_DATAOUT:
1484 #if (NDEBUG & NDEBUG_NO_DATAOUT)
1485 printk("scsi%d : NDEBUG_NO_DATAOUT set, attempted DATAOUT aborted\n",
1486 instance->host_no);
1487 msgout = ABORT;
1488 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN);
1489 break;
1490 #endif
1491 /*
1492 * If there is no room left in the current buffer in the
1493 * scatter-gather list, move onto the next one.
1494 */
1495
1496 if (!cmd->SCp.this_residual && cmd->SCp.buffers_residual) {
1497 ++cmd->SCp.buffer;
1498 --cmd->SCp.buffers_residual;
1499 cmd->SCp.this_residual = cmd->SCp.buffer->length;
1500 cmd->SCp.ptr = cmd->SCp.buffer->address;
1501 #if (NDEBUG & NDEBUG_INFORMATION)
1502 printk("scsi%d : %d bytes and %d buffers left\n",
1503 instance->host_no, cmd->SCp.this_residual,
1504 cmd->SCp.buffers_residual);
1505 #endif
1506 }
1507
1508 /*
1509 * The preffered transfer method is going to be
1510 * PSEUDO-DMA for systems that are strictly PIO,
1511 * since we can let the hardware do the handshaking.
1512 *
1513 * For this to work, we need to know the transfersize
1514 * ahead of time, since the pseudo-DMA code will sit
1515 * in an unconditional loop.
1516 */
1517
1518 #if (defined(PSEUDO_DMA))
1519 if (!scsi_devices[cmd->index].borken && cmd->transfersize &&
1520 cmd->SCp.this_residual && !(cmd->SCp.this_residual %
1521 cmd->transfersize)) {
1522 len = cmd->transfersize;
1523 if (NCR5380_transfer_dma(instance, &phase,
1524 &len, (unsigned char **) &cmd->SCp.ptr)) {
1525 /*
1526 * If the watchdog timer fires, all future accesses to this
1527 * device will use the polled-IO.
1528 */
1529 printk("scsi%d : switching target %d lun %d to slow handshake\n",
1530 instance->host_no, cmd->target, cmd->lun);
1531 scsi_devices[cmd->index].borken = 1;
1532 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE |
1533 ICR_ASSERT_ATN);
1534 msgout = ABORT;
1535 } else
1536 cmd->SCp.this_residual -= cmd->transfersize;
1537 } else
1538 #endif /* (defined(REAL_DMA) || defined(PSEUDO_DMA)) */
1539 NCR5380_transfer_pio(instance, &phase,
1540 (int *) &cmd->SCp.this_residual, (unsigned char **)
1541 &cmd->SCp.ptr);
1542 break;
1543 case PHASE_MSGIN:
1544 /*
1545 * XXX - we don't handle multi-byte messages here, since we
1546 * shouldn't get them after the I_T_L_Q nexus is established
1547 * for tagged queuing, and the host should initiate any
1548 * negotiations for sync. SCSI, etc.
1549 */
1550
1551 len = 1;
1552 data = &tmp;
1553 NCR5380_transfer_pio(instance, &phase, &len, &data);
1554 cmd->SCp.Message = tmp;
1555
1556 switch (tmp) {
1557 /*
1558 * Linking lets us reduce the time required to get the
1559 * next command out to the device, hopefully this will
1560 * mean we don't waste another revolution due to the delays
1561 * required by ARBITRATION and another SELECTION.
1562 *
1563 * In the current implementation proposal, low level drivers
1564 * merely have to start the next command, pointed to by
1565 * next_link, done() is called as with unlinked commands.
1566 */
1567 #ifdef LINKED
1568 case LINKED_CMD_COMPLETE:
1569 case LINKED_FLG_CMD_COMPLETE:
1570 #if (NDEBUG & NDEBUG_LINKED)
1571 printk("scsi%d : target %d lun %d linked command complete.\n",
1572 instance->host_no, cmd->target, cmd->lun);
1573 #endif
1574 /*
1575 * Sanity check : A linked command should only terminate with
1576 * one of these messages if there are more linked commands
1577 * available.
1578 */
1579
1580 if (!cmd->next_link) {
1581 printk("scsi%d : target %d lun %d linked command complete, no next_link\n"
1582 instance->host_no, cmd->target, cmd->lun);
1583 msgout = ABORT;
1584 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE |
1585 ICR_ASSERT_ATN);
1586 break;
1587 }
1588
1589 initialize_SCp(cmd->next_link);
1590 /* The next command is still part of this process */
1591 cmd->next_link->tag = cmd->tag;
1592 cmd->result = cmd->SCp.Status | (cmd->SCp.Message << 8);
1593 #if (NDEBUG & NDEBUG_LINKED)
1594 printk("scsi%d : target %d lun %d linked request done, calling scsi_done().\n",
1595 instance->host_no, cmd->target, cmd->lun);
1596 #endif
1597 cmd->scsi_done(cmd);
1598 cmd = hostdata->connected;
1599 break;
1600 #endif /* def LINKED */
1601 case ABORT:
1602 case COMMAND_COMPLETE:
1603 hostdata->connected = NULL;
1604 #if (NDEBUG & NDEBUG_QUEUES)
1605 printk("scsi%d : command for target %d, lun %d completed\n",
1606 instance->host_no, cmd->target, cmd->lun);
1607 #endif
1608 hostdata->busy[cmd->target] &= ~(1 << cmd->lun);
1609
1610 /*
1611 * Use the status and message bytes from the original
1612 * command.
1613 */
1614
1615 if (cmd->cmnd[0] != REQUEST_SENSE)
1616 cmd->result = cmd->SCp.Status | (cmd->SCp.Message << 8);
1617 else if (cmd->SCp.Status != GOOD)
1618 cmd->result = (cmd->result & 0x00ffff) | (DID_ERROR << 16);
1619 #ifdef AUTOSENSE
1620 if ((cmd->cmnd[0] != REQUEST_SENSE) &&
1621 (cmd->SCp.Status == CHECK_CONDITION)) {
1622 #if (NDEBUG & NDEBUG_AUTOSENSE)
1623 printk("scsi%d : performing request sense\n",
1624 instance->host_no);
1625 #endif
1626 cmd->cmnd[0] = REQUEST_SENSE;
1627 cmd->cmnd[1] &= 0xe0;
1628 cmd->cmnd[2] = 0;
1629 cmd->cmnd[3] = 0;
1630 cmd->cmnd[4] = sizeof(cmd->sense_buffer);
1631 cmd->cmnd[5] = 0;
1632
1633 cmd->SCp.buffer = NULL;
1634 cmd->SCp.buffers_residual = 0;
1635 cmd->SCp.ptr = (char *) cmd->sense_buffer;
1636 cmd->SCp.this_residual = sizeof(cmd->sense_buffer);
1637
1638 cli();
1639 cmd->host_scribble = (unsigned char *)
1640 hostdata->issue_queue;
1641 hostdata->issue_queue = (Scsi_Cmnd *) cmd;
1642 sti();
1643 #if (NDEBUG & NDEBUG_QUEUES)
1644 printk("scsi%d : REQUEST SENSE added to head of issue queue\n");
1645 #endif
1646 } else
1647 #endif /* def AUTOSENSE */
1648 cmd->scsi_done(cmd);
1649
1650 NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
1651 return;
1652 case MESSAGE_REJECT:
1653 switch (hostdata->last_message) {
1654 case HEAD_OF_QUEUE_TAG:
1655 case ORDERED_QUEUE_TAG:
1656 case SIMPLE_QUEUE_TAG:
1657 scsi_devices[cmd->index].tagged_queue = 0;
1658 hostdata->busy[cmd->target] |= (1 << cmd->lun);
1659 break;
1660 default:
1661 break;
1662 }
1663 case DISCONNECT:
1664 scsi_devices[cmd->index].disconnect = 1;
1665 cli();
1666 cmd->host_scribble = (unsigned char *)
1667 hostdata->disconnected_queue;
1668 hostdata->connected = NULL;
1669 hostdata->disconnected_queue = cmd;
1670 sti();
1671 #if (NDEBUG & NDEBUG_QUEUES)
1672 printk("scsi%d : command for target %d lun %d was moved from connected to"
1673 " the disconnected_queue\n", instance->host_no,
1674 cmd->target, cmd->lun);
1675 #endif
1676
1677 /* Enable reselect interupts */
1678 NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
1679 return;
1680 /*
1681 * The SCSI data pointer is *IMPLICITLY* saved on a disconnect
1682 * operation, in violation of the SCSI spec so we can safely
1683 * ignore SAVE/RESTORE pointers calls.
1684 *
1685 * Unfortunately, some disks violate the SCSI spec and
1686 * don't issue the required SAVE_POINTERS message before
1687 * disconnecting, and we have to break spec to remain
1688 * compatable.
1689 */
1690 case SAVE_POINTERS:
1691 case RESTORE_POINTERS:
1692 break;
1693 default:
1694 /*
1695 * XXX rejected messages should be handled in the pio data transfer phase,
1696 * since ATN should be raised before ACK goes false when we reject a message
1697 */
1698
1699 #ifdef notyet
1700 /*
1701 * If we get something wierd that we aren't expecting,
1702 * reject it.
1703 */
1704 msgout = MESSAGE_REJECT;
1705 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE |
1706 ICR_ASSERT_ATN);
1707 #endif
1708 break;
1709 } /* switch (tmp) */
1710 break;
1711 case PHASE_MSGOUT:
1712 len = 1;
1713 data = &msgout;
1714 hostdata->last_message = msgout;
1715 NCR5380_transfer_pio(instance, &phase, &len, &data);
1716 if (msgout == ABORT) {
1717 hostdata->busy[cmd->target] &= ~(1 << cmd->lun);
1718 hostdata->connected = NULL;
1719 cmd->result = DID_ERROR << 16;
1720 cmd->scsi_done(cmd);
1721 NCR5380_write(SELECT_ENABLE_REG, hostdata->id_mask);
1722 return;
1723 }
1724 msgout = NOP;
1725 break;
1726 case PHASE_CMDOUT:
1727 len = COMMAND_SIZE(cmd->cmnd[0]);
1728 data = cmd->cmnd;
1729 /*
1730 * XXX for performance reasons, on machines with a
1731 * PSEUDO-DMA architecture we should probably
1732 * use the dma transfer function.
1733 */
1734 NCR5380_transfer_pio(instance, &phase, &len,
1735 &data);
1736 #ifdef USLEEP
1737 if (!disconnect && should_disconnect(cmd->cmnd[0])) {
1738 hostdata->time_expires = jiffies + USLEEP_SLEEP;
1739 #if (NDEBUG & NDEBUG_USLEEP)
1740 printk("scsi%d : issued command, sleeping until %ul\n", instance->host_no,
1741 hostdata->time_expires);
1742 #endif
1743 NCR5380_set_timer (instance);
1744 return;
1745 }
1746 #endif /* def USLEEP */
1747 break;
1748 case PHASE_STATIN:
1749 len = 1;
1750 data = &tmp;
1751 NCR5380_transfer_pio(instance, &phase, &len, &data);
1752 cmd->SCp.Status = tmp;
1753 break;
1754 default:
1755 printk("scsi%d : unknown phase\n", instance->host_no);
1756 #ifdef NDEBUG
1757 NCR5380_print(instance);
1758 #endif
1759 } /* switch(phase) */
1760 } /* if (tmp * SR_REQ) */
1761 #ifdef USLEEP
1762 else {
1763 if (!disconnect && hostdata->time_expires && jiffies >
1764 hostdata->time_expires) {
1765 hostdata->time_expires = jiffies + USLEEP_SLEEP;
1766 #if (NDEBUG & NDEBUG_USLEEP)
1767 printk("scsi%d : poll timed out, sleeping until %ul\n", instance->host_no,
1768 hostdata->time_expires);
1769 #endif
1770 NCR5380_set_timer (instance);
1771 return;
1772 }
1773 }
1774 #endif
1775 } /* while (1) */
1776 }
1777
1778 /*
1779 * Function : void NCR5380_reselect (struct Scsi_Host *instance)
1780 *
1781 * Purpose : does reselection, initializing the instance->connected
1782 * field to point to the Scsi_Cmnd for which the I_T_L or I_T_L_Q
1783 * nexus has been restablished,
1784 *
1785 * Inputs : instance - this instance of the NCR5380.
1786 *
1787 */
1788
1789
1790 static void NCR5380_reselect (struct Scsi_Host *instance) {
/* */
1791 NCR5380_local_declare();
1792 struct NCR5380_hostdata *hostdata = (struct NCR5380_hostdata *)
1793 instance->hostdata;
1794 unsigned char target_mask;
1795 unsigned char lun, phase;
1796 int len;
1797 #ifdef SCSI2
1798 unsigned char tag;
1799 #endif
1800 unsigned char msg[3];
1801 unsigned char *data;
1802 Scsi_Cmnd *tmp = NULL, *prev;
1803 int abort = 0;
1804 NCR5380_setup(instance);
1805
1806 target_mask = NCR5380_read(CURRENT_SCSI_DATA_REG) & ~(hostdata->id_mask);
1807
1808 #if (NDEBUG & NDEBUG_RESELECTION)
1809 printk("scsi%d : reselect\n", instance->host_no);
1810 #endif
1811
1812 /*
1813 * At this point, we have detected that our SCSI ID is on the bus,
1814 * SEL is true and BSY was false for at least one bus settle delay
1815 * (400 ns).
1816 *
1817 * We must assert BSY ourselves, until the target drops the SEL
1818 * signal.
1819 */
1820
1821 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_BSY);
1822 while (NCR5380_read(STATUS_REG) & SR_SEL);
1823 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
1824
1825 /*
1826 * Wait for target to go into MSGIN.
1827 */
1828
1829 while (!(NCR5380_read(STATUS_REG) & SR_REQ));
1830
1831 len = 3;
1832 data = msg;
1833 phase = PHASE_MSGIN;
1834 NCR5380_transfer_pio(instance, &phase, &len, &data);
1835
1836 #ifdef SCSI2
1837 /*
1838 * If there was no residual from the attempt to transfer three bytes, then
1839 * the target sent the one byte IDENTIFY message followed by a two byte
1840 * queue message.
1841 *
1842 * If there were two bytes of residual, we got the IDENTIFY message
1843 * only.
1844 *
1845 * If there was one byte of residual, we got the IDENTIFY message
1846 * followed by a RESTORE pointers message (which was ignored -
1847 * see MSGIN phase of the NCR5380_information_transfer() function.
1848 */
1849
1850 if (!len)
1851 tag = msg[2];
1852 else
1853 tag = 0;
1854 #endif
1855
1856 if (!msg[0] & 0x80) {
1857 printk("scsi%d : expecting IDENTIFY message, got ",
1858 instance->host_no);
1859 print_msg(msg);
1860 abort = 1;
1861 } else {
1862
1863 lun = (msg[0] & 0x07);
1864
1865 /*
1866 * Find the command corresponding to the I_T_L or I_T_L_Q nexus we
1867 * just restablished, and remove it from the disconnected queue.
1868 */
1869
1870 for (tmp = (Scsi_Cmnd *) hostdata->disconnected_queue, prev = NULL;
1871 tmp; prev = tmp, tmp = (Scsi_Cmnd *) tmp->host_scribble)
1872 if ((target_mask == (1 << tmp->target)) && (lun == tmp->lun)
1873 #ifdef SCSI2
1874 && (tag == tmp->tag)
1875 #endif
1876 ) {
1877 if (prev)
1878 prev->host_scribble = tmp->host_scribble;
1879 else
1880 hostdata->disconnected_queue = (Scsi_Cmnd *) tmp->host_scribble;
1881 tmp->host_scribble = NULL;
1882 break;
1883 }
1884
1885 if (!tmp) {
1886 #ifdef SCSI2
1887 printk("scsi%d : warning : target bitmask %02x lun %d tag %d not in disconnect_queue.\n",
1888 instance->host_no, target_mask, lun, tag);
1889 #else
1890 printk("scsi%d : warning : target bitmask %02x lun %d not in disconnect_queue.\n",
1891 instance->host_no, target_mask, lun);
1892 #endif
1893 /*
1894 * Since we have an established nexus that we can't do anything with,
1895 * we must abort it.
1896 */
1897 abort = 1;
1898 }
1899 }
1900
1901 if (abort) {
1902 msg[0] = ABORT;
1903 len = 1;
1904 data = msg;
1905 phase = PHASE_MSGOUT;
1906 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN);
1907 NCR5380_transfer_pio(instance, &phase, &len, &data);
1908 } else {
1909 hostdata->connected = tmp;
1910 #if (NDEBUG & NDEBUG_RESELECTION)
1911 printk"scsi%d : nexus established, target = %d, lun = %d, tag = %d\n",
1912 instance->host_no, cmd->target, cmd->lun, cmd->tag);
1913 #endif
1914 }
1915 }
1916
1917 /*
1918 * Function : void NCR5380_dma_complete (struct Scsi_Host *instance)
1919 *
1920 * Purpose : called by interrupt handler when DMA finishes or a phase
1921 * mismatch occurs (which would finish the DMA transfer).
1922 *
1923 * Inputs : instance - this instance of the NCR5380.
1924 *
1925 * Returns : pointer to the Scsi_Cmnd structure for which the I_T_L
1926 * nexus has been restablished, on failure NULL is returned.
1927 */
1928
1929 #ifdef REAL_DMA
1930 static void NCR5380_dma_complete (NCR5380_instance *instance) {
/* */
1931 NCR5380_local_declare();
1932 struct NCR5380_hostdata *hostdata = (struct NCR5380_hostdata *
1933 instance->hostdata);
1934 int transferred;
1935 NCR5380_setup(instance);
1936
1937 /*
1938 * XXX this might not be right.
1939 *
1940 * Wait for final byte to transfer, ie wait for ACK to go false.
1941 *
1942 * We should use the Last Byte Sent bit, unfortunately this is
1943 * not available on the 5380/5381 (only the various CMOS chips)
1944 */
1945
1946 while (NCR5380_read(STATUS_REG) & SR_ACK);
1947
1948 NCR5380_write(MODE_REG, MR_BASE);
1949 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
1950
1951 /*
1952 * The only places we should see a phase mismatch and have to send
1953 * data from the same set of pointers will be the data transfer
1954 * phases. So, residual, requested length are only important here.
1955 */
1956
1957 if (!(hostdata->connected->SCp.phase & SR_CD)) {
1958 transferred = instance->dma_len - NCR5380_dma_residual();
1959 hostdata->connected->SCp.this_residual -= transferred;
1960 hostdata->connected->SCp.ptr += transferred;
1961 }
1962 }
1963 #endif /* def REAL_DMA */
1964
1965 /*
1966 * Function : int NCR5380_abort (Scsi_Cmnd *cmd, int code)
1967 *
1968 * Purpose : abort a command
1969 *
1970 * Inputs : cmd - the Scsi_Cmnd to abort, code - code to set the
1971 * host byte of the result field to, if zero DID_ABORTED is
1972 * used.
1973 *
1974 * Returns : 0 - success, -1 on failure.
1975 *
1976 * XXX - there is no way to abort the command that is currently
1977 * connected, you have to wait for it to complete. If this is
1978 * a problem, we could implement longjmp() / setjmp(), setjmp()
1979 * called where the loop started in NCR5380_main().
1980 */
1981
1982 #ifndef NCR5380_abort
1983 static
1984 #endif
1985 int NCR5380_abort (Scsi_Cmnd *cmd, int code) {
/* */
1986 NCR5380_local_declare();
1987 struct Scsi_Host *instance = cmd->host;
1988 struct NCR5380_hostdata *hostdata = (struct NCR5380_hostdata *)
1989 instance->hostdata;
1990 Scsi_Cmnd *tmp, **prev;
1991 unsigned char msg, phase, *msgptr;
1992 int len;
1993
1994 cli();
1995 NCR5380_setup(instance);
1996
1997 #if (NDEBUG & NDEBUG_ABORT)
1998 printk("scsi%d : abort called\n", instance->host_no);
1999 #endif
2000 /*
2001 * Case 1 : If the command hasn't been issued yet, we simply remove it
2002 * from the issue queue.
2003 */
2004 for (prev = (Scsi_Cmnd **) &(hostdata->issue_queue),
2005 tmp = (Scsi_Cmnd *) hostdata->issue_queue;
2006 tmp; prev = (Scsi_Cmnd **) &(tmp->host_scribble), tmp =
2007 (Scsi_Cmnd *) tmp->host_scribble)
2008 if (cmd == tmp) {
2009 (*prev) = (Scsi_Cmnd *) tmp->host_scribble;
2010 tmp->host_scribble = NULL;
2011 tmp->result = (code ? code : DID_ABORT) << 16;
2012 sti();
2013 #if (NDEBUG & NDEBUG_ABORT)
2014 printk("scsi%d : abort removed command from issue queue.\n",
2015 instance->host_no);
2016 #endif
2017 tmp->done(tmp);
2018 return 0;
2019 }
2020
2021 /*
2022 * Case 2 : If any commands are connected, we're going to fail the abort
2023 * and let the high level SCSI driver retry at a later time or
2024 * issue a reset.
2025 *
2026 * Timeouts, and therefore aborted commands, will be highly unlikely
2027 * and handling them cleanly in this situation would make the common
2028 * case of noresets less efficient, and would pollute our code. So,
2029 * we fail.
2030 */
2031
2032 if (hostdata->connected) {
2033 sti();
2034 #if (NDEBUG & NDEBUG_ABORT)
2035 printk("scsi%d : abort failed, command connected.\n", instance->host_no);
2036 #endif
2037 return -1;
2038 }
2039
2040 /*
2041 * Case 3: If the command is currently disconnected from the bus, and
2042 * there are no connected commands, we reconnect the I_T_L or
2043 * I_T_L_Q nexus associated with it, go into message out, and send
2044 * an abort message.
2045 *
2046 * This case is especially ugly. In order to resetablish the nexus, we
2047 * need to call NCR5380_select(). The easiest way to implement this
2048 * function was to abort if the bus was busy, and let the interrupt
2049 * handler triggered on the SEL for reselect take care of lost arbitrations
2050 * where necessary, meaning interrupts need to be enabled.
2051 *
2052 * When interrupts are enabled, the queues may change - so we
2053 * can't remove it from the disconnected queue before selecting it
2054 * because that could cause a failure in hashing the nexus if that
2055 * device reselected.
2056 *
2057 * Since the queues may change, we can't use the pointers from when we
2058 * first locate it.
2059 *
2060 * So, we must first locate the command, and if NCR5380_select()
2061 * succeeds, then issue the abort, relocate the command and remove
2062 * it from the disconnected queue.
2063 */
2064
2065 for (tmp = (Scsi_Cmnd *) hostdata->disconnected_queue; tmp;
2066 tmp = (Scsi_Cmnd *) tmp->host_scribble)
2067 if (cmd == tmp) {
2068 sti();
2069 #if (NDEBUG & NDEBUG_ABORT)
2070 printk("scsi%d : aborting disconnected command.\n", instance->host_no);
2071 #endif
2072
2073 if (NCR5380_select (instance, cmd, (int) cmd->tag))
2074 return 1;
2075
2076 #if (NDEBUG & NDEBUG_ABORT)
2077 printk("scsi%d : nexus restablished.\n", instance->host_no);
2078 #endif
2079
2080 msg = ABORT;
2081 msgptr = &msg;
2082 len = 1;
2083 phase = PHASE_MSGOUT;
2084 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_ATN);
2085 NCR5380_transfer_pio (instance, &phase, &len, &msgptr);
2086
2087 cli();
2088 for (prev = (Scsi_Cmnd **) &(hostdata->disconnected_queue),
2089 tmp = (Scsi_Cmnd *) hostdata->disconnected_queue;
2090 tmp; prev = (Scsi_Cmnd **) &(tmp->host_scribble), tmp =
2091 (Scsi_Cmnd *) tmp->host_scribble)
2092 if (cmd == tmp) {
2093 *prev = (Scsi_Cmnd *) tmp->host_scribble;
2094 tmp->host_scribble = NULL;
2095 tmp->result = (code ? code : DID_ABORT) << 16;
2096 sti();
2097 tmp->done(tmp);
2098 return 0;
2099 }
2100 }
2101
2102 /*
2103 * Case 4 : If we reached this point, the command was not found in any of
2104 * the queues.
2105 *
2106 * We probably reached this point because of an unlikely race condition
2107 * between the command completing successfully and the abortion code,
2108 * so we won't panic, but we will notify the user in case somethign really
2109 * broke.
2110 */
2111
2112 sti();
2113 printk("scsi%d : warning : SCSI command probably completed successfully\n"
2114 " before abortion\n", instance->host_no);
2115 return 0;
2116 }
2117
2118
2119 /*
2120 * Function : int NCR5380_reset (struct Scsi_Cmnd *)
2121 *
2122 * Purpose : reset the SCSI bus.
2123 *
2124 * Returns : 0
2125 */
2126
2127 #ifndef NCR5380_reset
2128 static
2129 #endif
2130 int NCR5380_reset (Scsi_Cmnd * SCpnt) {
/* ![[last]](../icons/n_last.png)
*/
2131 NCR5380_local_declare();
2132 struct Scsi_Host *instance;
2133 cli();
2134
2135 instance = SCpnt->host;
2136 NCR5380_setup(instance);
2137 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE | ICR_ASSERT_RST);
2138 udelay(1);
2139 NCR5380_write(INITIATOR_COMMAND_REG, ICR_BASE);
2140
2141 sti();
2142 if (SCpnt) SCpnt->flags |= NEEDS_JUMPSTART;
2143 return 0;
2144 }
![[bottom]](../icons/n_bottom.png){kind=icon}
*/