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