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