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