![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to 53c78xx.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / i386 / i386at / gpl / linux / scsi|
Return to 53c78xx.c CVS log | Up to [GnuMach] / Gnu-Mach / i386 / i386at / gpl / linux / scsi |
1.1 root 1: /*
2: * PERM_OPTIONS are driver options which will be enabled for all NCR boards
3: * in the system at driver initialization time.
4: *
5: * Don't THINK about touching these in PERM_OPTIONS :
6: * OPTION_IO_MAPPED
7: * Memory mapped IO does not work under i86 Linux.
8: *
9: * OPTION_DEBUG_TEST1
10: * Test 1 does bus mastering and interrupt tests, which will help weed
11: * out brain damaged main boards.
12: *
13: * These are development kernel changes. Code for them included in this
14: * driver release may or may not work. If you turn them on, you should be
15: * running the latest copy of the development sources from
16: *
17: * ftp://tsx-11.mit.edu/pub/linux/ALPHA/scsi/53c7,8xx
18: *
19: * and be subscribed to the [email protected] mailing list. To
20: * subscribe, send mail to [email protected] with
21: *
22: * subscribe ncr53c810
23: *
24: * in the text.
25: *
26: *
27: * OPTION_NOASYNC
28: * Don't negotiate for asynchronous transfers on the first command
29: * when OPTION_ALWAYS_SYNCHRONOUS is set. Useful for dain bramaged
30: * devices which do something bad rather than sending a MESSAGE
31: * REJECT back to us like they should if they can't cope.
32: *
33: * OPTION_SYNCHRONOUS
34: * Enable support for synchronous transfers. Target negotiated
35: * synchronous transfers will be responded to. To initiate
36: * a synchronous transfer request, call
37: *
38: * request_synchronous (hostno, target)
39: *
40: * from within KGDB.
41: *
42: * OPTION_ALWAYS_SYNCHRONOUS
43: * Negotiate for synchronous transfers with every target after
44: * driver initialization or a SCSI bus reset. This is a bit dangerous,
45: * since there are some dain bramaged SCSI devices which will accept
46: * SDTR messages but keep talking asynchronously.
47: *
48: * OPTION_DISCONNECT
49: * Enable support for disconnect/reconnect. To change the
50: * default setting on a given host adapter, call
51: *
52: * request_disconnect (hostno, allow)
53: *
54: * where allow is non-zero to allow, 0 to disallow.
55: *
56: * If you really want to run 10MHz FAST SCSI-II transfers, you should
57: * know that the NCR driver currently ignores parity information. Most
58: * systems do 5MHz SCSI fine. I've seen a lot that have problems faster
59: * than 8MHz. To play it safe, we only request 5MHz transfers.
60: *
61: * If you'd rather get 10MHz transfers, edit sdtr_message and change
62: * the fourth byte from 50 to 25.
63: */
64:
65: #define PERM_OPTIONS (OPTION_IO_MAPPED|OPTION_DEBUG_TEST1|OPTION_DISCONNECT|\
66: OPTION_SYNCHRONOUS)
67:
68: /*
69: * Sponsored by
70: * iX Multiuser Multitasking Magazine
71: * Hannover, Germany
72: * [email protected]
73: *
74: * Copyright 1993, 1994, 1995 Drew Eckhardt
75: * Visionary Computing
76: * (Unix and Linux consulting and custom programming)
77: * [email protected]
78: * +1 (303) 786-7975
79: *
80: * TolerANT and SCSI SCRIPTS are registered trademarks of NCR Corporation.
81: *
82: * For more information, please consult
83: *
84: * NCR53C810
85: * SCSI I/O Processor
86: * Programmer's Guide
87: *
88: * NCR 53C810
89: * PCI-SCSI I/O Processor
90: * Data Manual
91: *
92: * NCR 53C810/53C820
93: * PCI-SCSI I/O Processor Design In Guide
94: *
95: * For literature on Symbios Logic Inc. formerly NCR, SCSI,
96: * and Communication products please call (800) 334-5454 or
97: * (719) 536-3300.
98: *
99: * PCI BIOS Specification Revision
100: * PCI Local Bus Specification
101: * PCI System Design Guide
102: *
103: * PCI Special Interest Group
104: * M/S HF3-15A
105: * 5200 N.E. Elam Young Parkway
106: * Hillsboro, Oregon 97124-6497
107: * +1 (503) 696-2000
108: * +1 (800) 433-5177
109: */
110:
111: /*
112: * Design issues :
113: * The cumulative latency needed to propagate a read/write request
114: * through the file system, buffer cache, driver stacks, SCSI host, and
115: * SCSI device is ultimately the limiting factor in throughput once we
116: * have a sufficiently fast host adapter.
117: *
118: * So, to maximize performance we want to keep the ratio of latency to data
119: * transfer time to a minimum by
120: * 1. Minimizing the total number of commands sent (typical command latency
121: * including drive and bus mastering host overhead is as high as 4.5ms)
122: * to transfer a given amount of data.
123: *
124: * This is accomplished by placing no arbitrary limit on the number
125: * of scatter/gather buffers supported, since we can transfer 1K
126: * per scatter/gather buffer without Eric's cluster patches,
127: * 4K with.
128: *
129: * 2. Minimizing the number of fatal interrupts serviced, since
130: * fatal interrupts halt the SCSI I/O processor. Basically,
131: * this means offloading the practical maximum amount of processing
132: * to the SCSI chip.
133: *
134: * On the NCR53c810/820/720, this is accomplished by using
135: * interrupt-on-the-fly signals when commands complete,
136: * and only handling fatal errors and SDTR / WDTR messages
137: * in the host code.
138: *
139: * On the NCR53c710, interrupts are generated as on the NCR53c8x0,
140: * only the lack of a interrupt-on-the-fly facility complicates
141: * things. Also, SCSI ID registers and commands are
142: * bit fielded rather than binary encoded.
143: *
144: * On the NCR53c700 and NCR53c700-66, operations that are done via
145: * indirect, table mode on the more advanced chips must be
146: * replaced by calls through a jump table which
147: * acts as a surrogate for the DSA. Unfortunately, this
148: * will mean that we must service an interrupt for each
149: * disconnect/reconnect.
150: *
151: * 3. Eliminating latency by pipelining operations at the different levels.
152: *
153: * This driver allows a configurable number of commands to be enqueued
154: * for each target/lun combination (experimentally, I have discovered
155: * that two seems to work best) and will ultimately allow for
156: * SCSI-II tagged queuing.
157: *
158: *
159: * Architecture :
160: * This driver is built around a Linux queue of commands waiting to
161: * be executed, and a shared Linux/NCR array of commands to start. Commands
162: * are transfered to the array by the run_process_issue_queue() function
163: * which is called whenever a command completes.
164: *
165: * As commands are completed, the interrupt routine is triggered,
166: * looks for commands in the linked list of completed commands with
167: * valid status, removes these commands from a list of running commands,
168: * calls the done routine, and flags their target/luns as not busy.
169: *
170: * Due to limitations in the intelligence of the NCR chips, certain
171: * concessions are made. In many cases, it is easier to dynamically
172: * generate/fix-up code rather than calculate on the NCR at run time.
173: * So, code is generated or fixed up for
174: *
175: * - Handling data transfers, using a variable number of MOVE instructions
176: * interspersed with CALL MSG_IN, WHEN MSGIN instructions.
177: *
178: * The DATAIN and DATAOUT routines are separate, so that an incorrect
179: * direction can be trapped, and space isn't wasted.
180: *
181: * It may turn out that we're better off using some sort
182: * of table indirect instruction in a loop with a variable
183: * sized table on the NCR53c710 and newer chips.
184: *
185: * - Checking for reselection (NCR53c710 and better)
186: *
187: * - Handling the details of SCSI context switches (NCR53c710 and better),
188: * such as reprogramming appropriate synchronous parameters,
189: * removing the dsa structure from the NCR's queue of outstanding
190: * commands, etc.
191: *
192: */
193:
194: /*
195: * Accommodate differences between stock 1.2.x and 1.3.x asm-i386/types.h
196: * so lusers can drop in 53c7,8xx.* and get something which compiles
197: * without warnings.
198: */
199:
200: #if !defined(LINUX_1_2) && !defined(LINUX_1_3)
201: #include <linux/version.h>
202: #if LINUX_VERSION_CODE > 65536 + 3 * 256
203: #define LINUX_1_3
204: #else
205: #define LINUX_1_2
206: #endif
207: #endif
208:
209: #ifdef LINUX_1_2
210: #define u32 bogus_u32
211: #define s32 bogus_s32
212: #include <asm/types.h>
213: #undef u32
214: #undef s32
215: typedef __signed__ int s32;
216: typedef unsigned int u32;
217: #endif /* def LINUX_1_2 */
218:
219: #ifdef MODULE
220: #include <linux/module.h>
221: #endif
222:
223: #include <asm/dma.h>
224: #include <asm/io.h>
225: #include <asm/system.h>
226: #include <linux/delay.h>
227: #include <linux/signal.h>
228: #include <linux/sched.h>
229: #include <linux/errno.h>
230: #include <linux/bios32.h>
231: #include <linux/pci.h>
232: #include <linux/proc_fs.h>
233: #include <linux/string.h>
234: #include <linux/malloc.h>
235: #include <linux/mm.h>
236: #include <linux/ioport.h>
237: #include <linux/time.h>
238: #ifdef LINUX_1_2
239: #include "../block/blk.h"
240: #else
241: #include <linux/blk.h>
242: #endif
243: #undef current
244:
245: #include "scsi.h"
246: #include "hosts.h"
247: #include "53c7,8xx.h"
248: #include "constants.h"
249: #include "sd.h"
250: #include <linux/stat.h>
251: #include <linux/stddef.h>
252:
253: #ifndef LINUX_1_2
254: struct proc_dir_entry proc_scsi_ncr53c7xx = {
255: PROC_SCSI_NCR53C7xx, 9, "ncr53c7xx",
256: S_IFDIR | S_IRUGO | S_IXUGO, 2
257: };
258: #endif
259:
260: static int check_address (unsigned long addr, int size);
261: static void dump_events (struct Scsi_Host *host, int count);
262: static Scsi_Cmnd * return_outstanding_commands (struct Scsi_Host *host,
263: int free, int issue);
264: static void hard_reset (struct Scsi_Host *host);
265: static void ncr_scsi_reset (struct Scsi_Host *host);
266: static void print_lots (struct Scsi_Host *host);
267: static void set_synchronous (struct Scsi_Host *host, int target, int sxfer,
268: int scntl3, int now_connected);
269: static int datapath_residual (struct Scsi_Host *host);
270: static const char * sbcl_to_phase (int sbcl);
271: static void print_progress (Scsi_Cmnd *cmd);
272: static void print_queues (struct Scsi_Host *host);
273: static void process_issue_queue (unsigned long flags);
274: static int shutdown (struct Scsi_Host *host);
275: static void abnormal_finished (struct NCR53c7x0_cmd *cmd, int result);
276: static int disable (struct Scsi_Host *host);
277: static int NCR53c8xx_run_tests (struct Scsi_Host *host);
278: static int NCR53c8xx_script_len;
279: static int NCR53c8xx_dsa_len;
280: static void NCR53c7x0_intr(int irq, struct pt_regs * regs);
281: static int ncr_halt (struct Scsi_Host *host);
282: static void intr_phase_mismatch (struct Scsi_Host *host, struct NCR53c7x0_cmd
283: *cmd);
284: static void intr_dma (struct Scsi_Host *host, struct NCR53c7x0_cmd *cmd);
285: static void print_dsa (struct Scsi_Host *host, u32 *dsa,
286: const char *prefix);
287: static int print_insn (struct Scsi_Host *host, const u32 *insn,
288: const char *prefix, int kernel);
289:
290: static void NCR53c8xx_dsa_fixup (struct NCR53c7x0_cmd *cmd);
291: static void NCR53c8x0_init_fixup (struct Scsi_Host *host);
292: static int NCR53c8x0_dstat_sir_intr (struct Scsi_Host *host, struct
293: NCR53c7x0_cmd *cmd);
294: static void NCR53c8x0_soft_reset (struct Scsi_Host *host);
295:
296: /* INSMOD variables */
297: static long long perm_options = PERM_OPTIONS;
298: /* 14 = .5s; 15 is max; decreasing divides by two. */
299: static int selection_timeout = 14;
300: /* Size of event list (per host adapter) */
301: static int track_events = 0;
302:
303: static struct Scsi_Host *first_host = NULL; /* Head of list of NCR boards */
304: static Scsi_Host_Template *the_template = NULL;
305:
306: /*
307: * KNOWN BUGS :
308: * - There is some sort of conflict when the PPP driver is compiled with
309: * support for 16 channels?
310: *
311: * - On systems which predate the 1.3.x initialization order change,
312: * the NCR driver will cause Cannot get free page messages to appear.
313: * These are harmless, but I don't know of an easy way to avoid them.
314: *
315: * - With OPTION_DISCONNECT, on two systems under unknown circumstances,
316: * we get a PHASE MISMATCH with DSA set to zero (suggests that we
317: * are occurring somewhere in the reselection code) where
318: * DSP=some value DCMD|DBC=same value.
319: *
320: * Closer inspection suggests that we may be trying to execute
321: * some portion of the DSA?
322: * scsi0 : handling residual transfer (+ 0 bytes from DMA FIFO)
323: * scsi0 : handling residual transfer (+ 0 bytes from DMA FIFO)
324: * scsi0 : no current command : unexpected phase MSGIN.
325: * DSP=0x1c46cc, DCMD|DBC=0x1c46ac, DSA=0x0
326: * DSPS=0x0, TEMP=0x1c3e70, DMODE=0x80
327: * scsi0 : DSP->
328: * 001c46cc : 0x001c46cc 0x00000000
329: * 001c46d4 : 0x001c5ea0 0x000011f8
330: *
331: * Changed the print code in the phase_mismatch handler so
332: * that we call print_lots to try and diagnose this.
333: *
334: */
335:
336: /*
337: * Possible future direction of architecture for max performance :
338: *
339: * We're using a single start array for the NCR chip. This is
340: * sub-optimal, because we cannot add a command which would conflict with
341: * an executing command to this start queue, and therefore must insert the
342: * next command for a given I/T/L combination after the first has completed;
343: * incurring our interrupt latency between SCSI commands.
344: *
345: * To allow furthur pipelining of the NCR and host CPU operation, we want
346: * to set things up so that immediately on termination of a command destined
347: * for a given LUN, we get that LUN busy again.
348: *
349: * To do this, we need to add a 32 bit pointer to which is jumped to
350: * on completion of a command. If no new command is available, this
351: * would point to the usual DSA issue queue select routine.
352: *
353: * If one were, it would point to a per-NCR53c7x0_cmd select routine
354: * which starts execution immediately, inserting the command at the head
355: * of the start queue if the NCR chip is selected or reselected.
356: *
357: * We would chanage so that we keep a list of outstanding commands
358: * for each unit, rather than a single running_list. We'd insert
359: * a new command into the right running list; if the NCR didn't
360: * have something running for that yet, we'd put it in the
361: * start queue as well. Some magic needs to happen to handle the
362: * race condition between the first command terminating before the
363: * new one is written.
364: *
365: * Potential for profiling :
366: * Call do_gettimeofday(struct timeval *tv) to get 800ns resolution.
367: */
368:
369:
370: /*
371: * TODO :
372: * 1. To support WIDE transfers, not much needs to happen. We
373: * should do CHMOVE instructions instead of MOVEs when
374: * we have scatter/gather segments of uneven length. When
375: * we do this, we need to handle the case where we disconnect
376: * between segments.
377: *
378: * 2. Currently, when Icky things happen we do a FATAL(). Instead,
379: * we want to do an integrity check on the parts of the NCR hostdata
380: * structure which were initialized at boot time; FATAL() if that
381: * fails, and otherwise try to recover. Keep track of how many
382: * times this has happened within a single SCSI command; if it
383: * gets excessive, then FATAL().
384: *
385: * 3. Parity checking is currently disabled, and a few things should
386: * happen here now that we support synchronous SCSI transfers :
387: * 1. On soft-reset, we shuld set the EPC (Enable Parity Checking)
388: * and AAP (Assert SATN/ on parity error) bits in SCNTL0.
389: *
390: * 2. We should enable the parity interrupt in the SIEN0 register.
391: *
392: * 3. intr_phase_mismatch() needs to believe that message out is
393: * allways an "acceptable" phase to have a mismatch in. If
394: * the old phase was MSG_IN, we should send a MESSAGE PARITY
395: * error. If the old phase was something else, we should send
396: * a INITIATOR_DETECTED_ERROR message. Note that this could
397: * cause a RESTORE POINTERS message; so we should handle that
398: * correctly first. Instead, we should probably do an
399: * initiator_abort.
400: *
401: * 4. MPEE bit of CTEST4 should be set so we get interrupted if
402: * we detect an error.
403: *
404: *
405: * 5. The initial code has been tested on the NCR53c810. I don't
406: * have access to NCR53c700, 700-66 (Forex boards), NCR53c710
407: * (NCR Pentium systems), NCR53c720, NCR53c820, or NCR53c825 boards to
408: * finish development on those platforms.
409: *
410: * NCR53c820/825/720 - need to add wide transfer support, including WDTR
411: * negotiation, programming of wide transfer capabilities
412: * on reselection and table indirect selection.
413: *
414: * NCR53c710 - need to add fatal interrupt or GEN code for
415: * command completion signaling. Need to modify all
416: * SDID, SCID, etc. registers, and table indirect select code
417: * since these use bit fielded (ie 1<<target) instead of
418: * binary encoded target ids. Need to accomodate
419: * different register mappings, probably scan through
420: * the SCRIPT code and change the non SFBR register operand
421: * of all MOVE instructions.
422: *
423: * NCR53c700/700-66 - need to add code to refix addresses on
424: * every nexus change, eliminate all table indirect code,
425: * very messy.
426: *
427: * 6. The NCR53c7x0 series is very popular on other platforms that
428: * could be running Linux - ie, some high performance AMIGA SCSI
429: * boards use it.
430: *
431: * So, I should include #ifdef'd code so that it is
432: * compatible with these systems.
433: *
434: * Specifically, the little Endian assumptions I made in my
435: * bit fields need to change, and if the NCR doesn't see memory
436: * the right way, we need to provide options to reverse words
437: * when the scripts are relocated.
438: *
439: * 7. Use vremap() to access memory mapped boards.
440: */
441:
442: /*
443: * Allow for simultaneous existence of multiple SCSI scripts so we
444: * can have a single driver binary for all of the family.
445: *
446: * - one for NCR53c700 and NCR53c700-66 chips (not yet supported)
447: * - one for rest (only the NCR53c810, 815, 820, and 825 are currently
448: * supported)
449: *
450: * So that we only need two SCSI scripts, we need to modify things so
451: * that we fixup register accesses in READ/WRITE instructions, and
452: * we'll also have to accomodate the bit vs. binary encoding of IDs
453: * with the 7xx chips.
454: */
455:
456: /*
457: * Use pci_chips_ids to translate in both directions between PCI device ID
458: * and chip numbers.
459: */
460:
461: static struct {
462: unsigned short pci_device_id;
463: int chip;
464: /*
465: * The revision field of the PCI_CLASS_REVISION register is compared
466: * against each of these fields if the field is not -1. If it
467: * is less than min_revision or larger than max_revision, a warning
468: * message is printed.
469: */
470: int max_revision;
471: int min_revision;
472: } pci_chip_ids[] = {
473: {PCI_DEVICE_ID_NCR_53C810, 810, 2, 1},
474: {PCI_DEVICE_ID_NCR_53C815, 815, 3, 2},
475: {PCI_DEVICE_ID_NCR_53C820, 820, -1, -1},
476: {PCI_DEVICE_ID_NCR_53C825, 825, -1, -1}
477: };
478:
479: #define NPCI_CHIP_IDS (sizeof (pci_chip_ids) / sizeof(pci_chip_ids[0]))
480:
481: #define ROUNDUP(adr,type) \
482: ((void *) (((long) (adr) + sizeof(type) - 1) & ~(sizeof(type) - 1)))
483:
484: /*
485: * Forced detection and autoprobe code for various hardware. Currently,
486: * entry points for these are not included in init/main.c because if the
487: * PCI BIOS code isn't working right, you're not going to be able to use
488: * the hardware anyways; this way we force users to solve their
489: * problems rather than forcing detection and blaming us when it
490: * does not work.
491: */
492:
493: static struct override {
494: int chip; /* 700, 70066, 710, 720, 810, 820 */
495: int board; /* Any special board level gunk */
496: unsigned pci:1;
497: union {
498: struct {
499: int base; /* Memory address - indicates memory mapped regs */
500: int io_port;/* I/O port address - indicates I/O mapped regs */
501: int irq; /* IRQ line */
502: int dma; /* DMA channel - often none */
503: } normal;
504: struct {
505: int bus;
506: int device;
507: int function;
508: } pci;
509: } data;
510: long long options;
511: } overrides [4] = {{0,},};
512: static int commandline_current = 0;
513: static int no_overrides = 0;
514:
515: #if 0
516: #define OVERRIDE_LIMIT (sizeof(overrides) / sizeof(struct override))
517: #else
518: #define OVERRIDE_LIMIT commandline_current
519: #endif
520:
521: /*
522: * Function: issue_to_cmd
523: *
524: * Purpose: convert jump instruction in issue array to NCR53c7x0_cmd
525: * structure pointer.
526: *
527: * Inputs; issue - pointer to start of NOP or JUMP instruction
528: * in issue array.
529: *
530: * Returns: pointer to command on success; 0 if opcode is NOP.
531: */
532:
533: static inline struct NCR53c7x0_cmd *
534: issue_to_cmd (struct Scsi_Host *host, struct NCR53c7x0_hostdata *hostdata,
535: u32 *issue)
536: {
537: return (issue[0] != hostdata->NOP_insn) ?
538: /*
539: * If the IF TRUE bit is set, it's a JUMP instruction. The
540: * operand is a bus pointer to the dsa_begin routine for this DSA. The
541: * dsa field of the NCR53c7x0_cmd structure starts with the
542: * DSA code template. By converting to a virtual address,
543: * subtracting the code template size, and offset of the
544: * dsa field, we end up with a pointer to the start of the
545: * structure (alternatively, we could use the
546: * dsa_cmnd field, an anachronism from when we weren't
547: * sure what the relationship between the NCR structures
548: * and host structures were going to be.
549: */
550: (struct NCR53c7x0_cmd *) ((char *) bus_to_virt (issue[1]) -
551: (hostdata->E_dsa_code_begin - hostdata->E_dsa_code_template) -
552: offsetof(struct NCR53c7x0_cmd, dsa))
553: /* If the IF TRUE bit is not set, it's a NOP */
554: : NULL;
555: }
556:
557:
558: /*
559: * Function : static internal_setup(int board, int chip, char *str, int *ints)
560: *
561: * Purpose : LILO command line initialization of the overrides array,
562: *
563: * Inputs : board - currently, unsupported. chip - 700, 70066, 710, 720
564: * 810, 815, 820, 825, although currently only the NCR53c810 is
565: * supported.
566: *
567: */
568:
569: static void
570: internal_setup(int board, int chip, char *str, int *ints) {
571: unsigned char pci; /* Specifies a PCI override, with bus, device,
572: function */
573:
574: pci = (str && !strcmp (str, "pci")) ? 1 : 0;
575:
576: /*
577: * Override syntaxes are as follows :
578: * ncr53c700,ncr53c700-66,ncr53c710,ncr53c720=mem,io,irq,dma
579: * ncr53c810,ncr53c820,ncr53c825=mem,io,irq or pci,bus,device,function
580: */
581:
582: if (commandline_current < OVERRIDE_LIMIT) {
583: overrides[commandline_current].pci = pci ? 1 : 0;
584: if (!pci) {
585: overrides[commandline_current].data.normal.base = ints[1];
586: overrides[commandline_current].data.normal.io_port = ints[2];
587: overrides[commandline_current].data.normal.irq = ints[3];
588: overrides[commandline_current].data.normal.dma = (ints[0] >= 4) ?
589: ints[4] : DMA_NONE;
590: /* FIXME: options is now a long long */
591: overrides[commandline_current].options = (ints[0] >= 5) ?
592: ints[5] : 0;
593: } else {
594: overrides[commandline_current].data.pci.bus = ints[1];
595: overrides[commandline_current].data.pci.device = ints[2];
596: overrides[commandline_current].data.pci.function = ints[3];
597: /* FIXME: options is now a long long */
598: overrides[commandline_current].options = (ints[0] >= 4) ?
599: ints[4] : 0;
600: }
601: overrides[commandline_current].board = board;
602: overrides[commandline_current].chip = chip;
603: ++commandline_current;
604: ++no_overrides;
605: } else {
606: printk ("53c7,7x0.c:internal_setup() : too many overrides\n");
607: }
608: }
609:
610: /*
611: * XXX - we might want to implement a single override function
612: * with a chip type field, revamp the command line configuration,
613: * etc.
614: */
615:
616: #define setup_wrapper(x) \
617: void ncr53c##x##_setup (char *str, int *ints) { \
618: internal_setup (BOARD_GENERIC, x, str, ints); \
619: }
620:
621: setup_wrapper(700)
622: setup_wrapper(70066)
623: setup_wrapper(710)
624: setup_wrapper(720)
625: setup_wrapper(810)
626: setup_wrapper(815)
627: setup_wrapper(820)
628: setup_wrapper(825)
629:
630: /*
631: * FIXME: we should junk these, in favor of synchronous_want and
632: * wide_want in the NCR53c7x0_hostdata structure.
633: */
634:
635: /* Template for "preferred" synchronous transfer parameters. */
636:
637: static const unsigned char sdtr_message[] = {
638: EXTENDED_MESSAGE, 3 /* length */, EXTENDED_SDTR, 50 /* *4ns */, 8 /* off */
639: };
640:
641: /* Template to request asynchronous transfers */
642:
643: static const unsigned char async_message[] = {
644: EXTENDED_MESSAGE, 3 /* length */, EXTENDED_SDTR, 0, 0 /* asynchronous */
645: };
646:
647: /* Template for "preferred" WIDE transfer parameters */
648:
649: static const unsigned char wdtr_message[] = {
650: EXTENDED_MESSAGE, 2 /* length */, EXTENDED_WDTR, 1 /* 2^1 bytes */
651: };
652:
653: /*
654: * Function : struct Scsi_Host *find_host (int host)
655: *
656: * Purpose : KGDB support function which translates a host number
657: * to a host structure.
658: *
659: * Inputs : host - number of SCSI host
660: *
661: * Returns : NULL on failure, pointer to host structure on success.
662: */
663:
664: static struct Scsi_Host *
665: find_host (int host) {
666: struct Scsi_Host *h;
667: for (h = first_host; h && h->host_no != host; h = h->next);
668: if (!h) {
669: printk (KERN_ALERT "scsi%d not found\n", host);
670: return NULL;
671: } else if (h->hostt != the_template) {
672: printk (KERN_ALERT "scsi%d is not a NCR board\n", host);
673: return NULL;
674: }
675: return h;
676: }
677:
678: /*
679: * Function : request_synchronous (int host, int target)
680: *
681: * Purpose : KGDB interface which will allow us to negotiate for
682: * synchronous transfers. This ill be replaced with a more
683: * integrated function; perhaps a new entry in the scsi_host
684: * structure, accessable via an ioctl() or perhaps /proc/scsi.
685: *
686: * Inputs : host - number of SCSI host; target - number of target.
687: *
688: * Returns : 0 when negotiation has been setup for next SCSI command,
689: * -1 on failure.
690: */
691:
692: static int
693: request_synchronous (int host, int target) {
694: struct Scsi_Host *h;
695: struct NCR53c7x0_hostdata *hostdata;
696: unsigned long flags;
697: if (target < 0) {
698: printk (KERN_ALERT "target %d is bogus\n", target);
699: return -1;
700: }
701: if (!(h = find_host (host)))
702: return -1;
703: else if (h->this_id == target) {
704: printk (KERN_ALERT "target %d is host ID\n", target);
705: return -1;
706: }
707: #ifndef LINUX_1_2
708: else if (target > h->max_id) {
709: printk (KERN_ALERT "target %d exceeds maximum of %d\n", target,
710: h->max_id);
711: return -1;
712: }
713: #endif
714: hostdata = (struct NCR53c7x0_hostdata *)h->hostdata;
715:
716: save_flags(flags);
717: cli();
718: if (hostdata->initiate_sdtr & (1 << target)) {
719: restore_flags(flags);
720: printk (KERN_ALERT "target %d allready doing SDTR\n", target);
721: return -1;
722: }
723: hostdata->initiate_sdtr |= (1 << target);
724: restore_flags(flags);
725: return 0;
726: }
727:
728: /*
729: * Function : request_disconnect (int host, int on_or_off)
730: *
731: * Purpose : KGDB support function, tells us to allow or disallow
732: * disconnections.
733: *
734: * Inputs : host - number of SCSI host; on_or_off - non-zero to allow,
735: * zero to disallow.
736: *
737: * Returns : 0 on success, * -1 on failure.
738: */
739:
740: static int
741: request_disconnect (int host, int on_or_off) {
742: struct Scsi_Host *h;
743: struct NCR53c7x0_hostdata *hostdata;
744: if (!(h = find_host (host)))
745: return -1;
746: hostdata = (struct NCR53c7x0_hostdata *) h->hostdata;
747: if (on_or_off)
748: hostdata->options |= OPTION_DISCONNECT;
749: else
750: hostdata->options &= ~OPTION_DISCONNECT;
751: return 0;
752: }
753:
754: /*
755: * Function : static void NCR53c7x0_driver_init (struct Scsi_Host *host)
756: *
757: * Purpose : Initialize internal structures, as required on startup, or
758: * after a SCSI bus reset.
759: *
760: * Inputs : host - pointer to this host adapter's structure
761: */
762:
763: static void
764: NCR53c7x0_driver_init (struct Scsi_Host *host) {
765: struct NCR53c7x0_hostdata *hostdata = (struct NCR53c7x0_hostdata *)
766: host->hostdata;
767: int i, j;
768: u32 *current;
769: for (i = 0; i < 16; ++i) {
770: hostdata->request_sense[i] = 0;
771: for (j = 0; j < 8; ++j)
772: hostdata->busy[i][j] = 0;
773: set_synchronous (host, i, /* sxfer */ 0, hostdata->saved_scntl3, 0);
774: }
775: hostdata->issue_queue = NULL;
776: hostdata->running_list = hostdata->finished_queue =
777: hostdata->current = NULL;
778: for (i = 0, current = (u32 *) hostdata->schedule;
779: i < host->can_queue; ++i, current += 2) {
780: current[0] = hostdata->NOP_insn;
781: current[1] = 0xdeadbeef;
782: }
783: current[0] = ((DCMD_TYPE_TCI|DCMD_TCI_OP_JUMP) << 24) | DBC_TCI_TRUE;
784: current[1] = (u32) virt_to_bus (hostdata->script) +
785: hostdata->E_wait_reselect;
786: hostdata->reconnect_dsa_head = 0;
787: hostdata->addr_reconnect_dsa_head = (u32)
788: virt_to_bus((void *) &(hostdata->reconnect_dsa_head));
789: hostdata->expecting_iid = 0;
790: hostdata->expecting_sto = 0;
791: if (hostdata->options & OPTION_ALWAYS_SYNCHRONOUS)
792: hostdata->initiate_sdtr = 0xffff;
793: else
794: hostdata->initiate_sdtr = 0;
795: hostdata->talked_to = 0;
796: hostdata->idle = 1;
797: }
798:
799: /*
800: * Function : static int ccf_to_clock (int ccf)
801: *
802: * Purpose : Return the largest SCSI clock allowable for a given
803: * clock conversion factor, allowing us to do synchronous periods
804: * when we don't know what the SCSI clock is by taking at least
805: * as long as the device says we can.
806: *
807: * Inputs : ccf
808: *
809: * Returns : clock on success, -1 on failure.
810: */
811:
812: static int
813: ccf_to_clock (int ccf) {
814: switch (ccf) {
815: case 1: return 25000000; /* Divide by 1.0 */
816: case 2: return 37500000; /* Divide by 1.5 */
817: case 3: return 50000000; /* Divide by 2.0 */
818: case 0: /* Divide by 3.0 */
819: case 4: return 66000000;
820: default: return -1;
821: }
822: }
823:
824: /*
825: * Function : static int clock_to_ccf (int clock)
826: *
827: * Purpose : Return the clock conversion factor for a given SCSI clock.
828: *
829: * Inputs : clock - SCSI clock expressed in Hz.
830: *
831: * Returns : ccf on success, -1 on failure.
832: */
833:
834: static int
835: clock_to_ccf (int clock) {
836: if (clock < 16666666)
837: return -1;
838: if (clock < 25000000)
839: return 1; /* Divide by 1.0 */
840: else if (clock < 37500000)
841: return 2; /* Divide by 1.5 */
842: else if (clock < 50000000)
843: return 3; /* Divide by 2.0 */
844: else if (clock < 66000000)
845: return 4; /* Divide by 3.0 */
846: else
847: return -1;
848: }
849:
850: /*
851: * Function : static int NCR53c7x0_init (struct Scsi_Host *host)
852: *
853: * Purpose : initialize the internal structures for a given SCSI host
854: *
855: * Inputs : host - pointer to this host adapter's structure
856: *
857: * Preconditions : when this function is called, the chip_type
858: * field of the hostdata structure MUST have been set.
859: *
860: * Returns : 0 on success, -1 on failure.
861: */
862:
863: static int
864: NCR53c7x0_init (struct Scsi_Host *host) {
865: NCR53c7x0_local_declare();
866: int i, ccf, expected_ccf;
867: struct NCR53c7x0_hostdata *hostdata = (struct NCR53c7x0_hostdata *)
868: host->hostdata;
869: struct Scsi_Host *search;
870: /*
871: * There are some things which we need to know about in order to provide
872: * a semblance of support. Print 'em if they aren't what we expect,
873: * otherwise don't add to the noise.
874: *
875: * -1 means we don't know what to expect.
876: */
877: int expected_id = -1;
878: int expected_clock = -1;
879: int uninitialized = 0;
880: /*
881: * FIXME : this is only on Intel boxes. On other platforms, this
882: * will differ.
883: */
884: int expected_mapping = OPTION_IO_MAPPED;
885: NCR53c7x0_local_setup(host);
886:
887: switch (hostdata->chip) {
888: case 820:
889: case 825:
890: #ifdef notyet
891: host->max_id = 15;
892: #endif
893: /* Fall through */
894: case 810:
895: case 815:
896: hostdata->dstat_sir_intr = NCR53c8x0_dstat_sir_intr;
897: hostdata->init_save_regs = NULL;
898: hostdata->dsa_fixup = NCR53c8xx_dsa_fixup;
899: hostdata->init_fixup = NCR53c8x0_init_fixup;
900: hostdata->soft_reset = NCR53c8x0_soft_reset;
901: hostdata->run_tests = NCR53c8xx_run_tests;
902: /* Is the SCSI clock ever anything else on these chips? */
903: expected_clock = hostdata->scsi_clock = 40000000;
904: expected_id = 7;
905: break;
906: default:
907: printk ("scsi%d : chip type of %d is not supported yet, detaching.\n",
908: host->host_no, hostdata->chip);
909: scsi_unregister (host);
910: return -1;
911: }
912:
913: /* Assign constants accessed by NCR */
914: hostdata->NCR53c7xx_zero = 0;
915: hostdata->NCR53c7xx_msg_reject = MESSAGE_REJECT;
916: hostdata->NCR53c7xx_msg_abort = ABORT;
917: hostdata->NCR53c7xx_msg_nop = NOP;
918: hostdata->NOP_insn = (DCMD_TYPE_TCI|DCMD_TCI_OP_JUMP) << 24;
919:
920: if (expected_mapping == -1 ||
921: (hostdata->options & (OPTION_MEMORY_MAPPED)) !=
922: (expected_mapping & OPTION_MEMORY_MAPPED))
923: printk ("scsi%d : using %s mapped access\n", host->host_no,
924: (hostdata->options & OPTION_MEMORY_MAPPED) ? "memory" :
925: "io");
926:
927: hostdata->dmode = (hostdata->chip == 700 || hostdata->chip == 70066) ?
928: DMODE_REG_00 : DMODE_REG_10;
929: hostdata->istat = ((hostdata->chip / 100) == 8) ?
930: ISTAT_REG_800 : ISTAT_REG_700;
931:
932: /* Only the ISTAT register is readable when the NCR is running, so make
933: sure it's halted. */
934: ncr_halt(host);
935:
936: /*
937: * XXX - the NCR53c700 uses bitfielded registers for SCID, SDID, etc,
938: * as does the 710 with one bit per SCSI ID. Conversely, the NCR
939: * uses a normal, 3 bit binary representation of these values.
940: *
941: * Get the rest of the NCR documentation, and FIND OUT where the change
942: * was.
943: */
944: #if 0
945: tmp = hostdata->this_id_mask = NCR53c7x0_read8(SCID_REG);
946: for (host->this_id = 0; tmp != 1; tmp >>=1, ++host->this_id);
947: #else
948: host->this_id = NCR53c7x0_read8(SCID_REG) & 15;
949: if (host->this_id == 0)
950: host->this_id = 7; /* sanitize hostid---0 doesn't make sense */
951: hostdata->this_id_mask = 1 << host->this_id;
952: #endif
953:
954: /*
955: * Note : we should never encounter a board setup for ID0. So,
956: * if we see ID0, assume that it was uninitialized and set it
957: * to the industry standard 7.
958: */
959: if (!host->this_id) {
960: printk("scsi%d : initiator ID was %d, changing to 7\n",
961: host->host_no, host->this_id);
962: host->this_id = 7;
963: hostdata->this_id_mask = 1 << 7;
964: uninitialized = 1;
965: };
966:
967: if (expected_id == -1 || host->this_id != expected_id)
968: printk("scsi%d : using initiator ID %d\n", host->host_no,
969: host->this_id);
970:
971: /*
972: * Save important registers to allow a soft reset.
973: */
974:
975: if ((hostdata->chip / 100) == 8) {
976: /*
977: * CTEST4 controls burst mode disable.
978: */
979: hostdata->saved_ctest4 = NCR53c7x0_read8(CTEST4_REG_800) &
980: CTEST4_800_SAVE;
981: } else {
982: /*
983: * CTEST7 controls cache snooping, burst mode, and support for
984: * external differential drivers.
985: */
986: hostdata->saved_ctest7 = NCR53c7x0_read8(CTEST7_REG) & CTEST7_SAVE;
987: }
988:
989: /*
990: * On NCR53c700 series chips, DCNTL controls the SCSI clock divisor,
991: * on 800 series chips, it allows for a totem-pole IRQ driver.
992: */
993:
994: hostdata->saved_dcntl = NCR53c7x0_read8(DCNTL_REG);
995:
996: /*
997: * DCNTL_800_IRQM controls weather we are using an open drain
998: * driver (reset) or totem pole driver (set). In all cases,
999: * it's level active. I suppose this is an issue when we're trying to
1000: * wire-or the same PCI INTx line?
1001: */
1002: if ((hostdata->chip / 100) == 8)
1003: hostdata->saved_dcntl &= ~DCNTL_800_IRQM;
1004:
1005: /*
1006: * DMODE controls DMA burst length, and on 700 series chips,
1007: * 286 mode and bus width
1008: */
1009: hostdata->saved_dmode = NCR53c7x0_read8(hostdata->dmode);
1010:
1011: /*
1012: * Now that burst length and enabled/disabled status is known,
1013: * clue the user in on it.
1014: */
1015:
1016: if ((hostdata->chip / 100) == 8) {
1017: if (hostdata->saved_ctest4 & CTEST4_800_BDIS) {
1018: printk ("scsi%d : burst mode disabled\n", host->host_no);
1019: } else {
1020: switch (hostdata->saved_dmode & DMODE_BL_MASK) {
1021: case DMODE_BL_2: i = 2; break;
1022: case DMODE_BL_4: i = 4; break;
1023: case DMODE_BL_8: i = 8; break;
1024: case DMODE_BL_16: i = 16; break;
1025: default: i = 0;
1026: }
1027: printk ("scsi%d : burst length %d\n", host->host_no, i);
1028: }
1029: }
1030:
1031: /*
1032: * On NCR53c810 and NCR53c820 chips, SCNTL3 contails the synchronous
1033: * and normal clock conversion factors.
1034: */
1035: if (hostdata->chip / 100 == 8) {
1036: expected_ccf = clock_to_ccf (expected_clock);
1037: hostdata->saved_scntl3 = NCR53c7x0_read8(SCNTL3_REG_800);
1038: ccf = hostdata->saved_scntl3 & SCNTL3_800_CCF_MASK;
1039: if (expected_ccf != -1 && ccf != expected_ccf && !ccf) {
1040: hostdata->saved_scntl3 = (hostdata->saved_scntl3 &
1041: ~SCNTL3_800_CCF_MASK) | expected_ccf;
1042: if (!uninitialized) {
1043: printk ("scsi%d : reset ccf to %d from %d\n",
1044: host->host_no, expected_ccf, ccf);
1045: uninitialized = 1;
1046: }
1047: }
1048: } else
1049: ccf = 0;
1050:
1051: /*
1052: * If we don't have a SCSI clock programmed, pick one on the upper
1053: * bound of that allowed by NCR so that our transfers err on the
1054: * slow side, since transfer period must be >= the agreed
1055: * upon period.
1056: */
1057:
1058: if ((!hostdata->scsi_clock) && (hostdata->scsi_clock = ccf_to_clock (ccf))
1059: == -1) {
1060: printk ("scsi%d : clock conversion factor %d unknown.\n"
1061: " synchronous transfers disabled\n",
1062: host->host_no, ccf);
1063: hostdata->options &= ~OPTION_SYNCHRONOUS;
1064: hostdata->scsi_clock = 0;
1065: }
1066:
1067: if (expected_clock == -1 || hostdata->scsi_clock != expected_clock)
1068: printk ("scsi%d : using %dMHz SCSI clock\n", host->host_no,
1069: hostdata->scsi_clock / 1000000);
1070:
1071: for (i = 0; i < 16; ++i)
1072: hostdata->cmd_allocated[i] = 0;
1073:
1074: if (hostdata->init_save_regs)
1075: hostdata->init_save_regs (host);
1076: if (hostdata->init_fixup)
1077: hostdata->init_fixup (host);
1078:
1079: if (!the_template) {
1080: the_template = host->hostt;
1081: first_host = host;
1082: }
1083:
1084: /*
1085: * Linux SCSI drivers have always been plagued with initialization
1086: * problems - some didn't work with the BIOS disabled since they expected
1087: * initialization from it, some didn't work when the networking code
1088: * was enabled and registers got scrambled, etc.
1089: *
1090: * To avoid problems like this, in the future, we will do a soft
1091: * reset on the SCSI chip, taking it back to a sane state.
1092: */
1093:
1094: hostdata->soft_reset (host);
1095:
1096: #if 1
1097: hostdata->debug_count_limit = -1;
1098: #else
1099: hostdata->debug_count_limit = 1;
1100: #endif
1101: hostdata->intrs = -1;
1102: hostdata->resets = -1;
1103: memcpy ((void *) hostdata->synchronous_want, (void *) sdtr_message,
1104: sizeof (hostdata->synchronous_want));
1105:
1106: NCR53c7x0_driver_init (host);
1107:
1108: /*
1109: * Set up an interrupt handler if we aren't already sharing an IRQ
1110: * with another board.
1111: */
1112:
1113: for (search = first_host; search && !(search->hostt == the_template &&
1114: search->irq == host->irq && search != host); search=search->next);
1115:
1116: if (!search) {
1117: if (request_irq(host->irq, NCR53c7x0_intr, SA_INTERRUPT, "53c7,8xx")) {
1118: printk("scsi%d : IRQ%d not free, detaching\n"
1119: " You have either a configuration problem, or a\n"
1120: " broken BIOS. You may wish to manually assign\n"
1121: " an interrupt to the NCR board rather than using\n"
1122: " an automatic setting.\n",
1123: host->host_no, host->irq);
1124: scsi_unregister (host);
1125: return -1;
1126: }
1127: } else {
1128: printk("scsi%d : using interrupt handler previously installed for scsi%d\n",
1129: host->host_no, search->host_no);
1130: }
1131:
1132:
1133: if ((hostdata->run_tests && hostdata->run_tests(host) == -1) ||
1134: (hostdata->options & OPTION_DEBUG_TESTS_ONLY)) {
1135: /* XXX Should disable interrupts, etc. here */
1136: scsi_unregister (host);
1137: return -1;
1138: } else {
1139: if (host->io_port) {
1140: host->n_io_port = 128;
1141: request_region (host->io_port, host->n_io_port, "ncr53c7,8xx");
1142: }
1143: }
1144:
1145: if (NCR53c7x0_read8 (SBCL_REG) & SBCL_BSY) {
1146: printk ("scsi%d : bus wedge, doing SCSI reset\n", host->host_no);
1147: hard_reset (host);
1148: }
1149: return 0;
1150: }
1151:
1152: /*
1153: * Function : static int normal_init(Scsi_Host_Template *tpnt, int board,
1154: * int chip, u32 base, int io_port, int irq, int dma, int pcivalid,
1155: * unsigned char pci_bus, unsigned char pci_device_fn,
1156: * long long options);
1157: *
1158: * Purpose : initializes a NCR53c7,8x0 based on base addresses,
1159: * IRQ, and DMA channel.
1160: *
1161: * Useful where a new NCR chip is backwards compatible with
1162: * a supported chip, but the DEVICE ID has changed so it
1163: * doesn't show up when the autoprobe does a pcibios_find_device.
1164: *
1165: * Inputs : tpnt - Template for this SCSI adapter, board - board level
1166: * product, chip - 810, 820, or 825, bus - PCI bus, device_fn -
1167: * device and function encoding as used by PCI BIOS calls.
1168: *
1169: * Returns : 0 on success, -1 on failure.
1170: *
1171: */
1172:
1173: static int
1174: normal_init (Scsi_Host_Template *tpnt, int board, int chip,
1175: u32 base, int io_port, int irq, int dma, int pci_valid,
1176: unsigned char pci_bus, unsigned char pci_device_fn, long long options) {
1177: struct Scsi_Host *instance;
1178: struct NCR53c7x0_hostdata *hostdata;
1179: char chip_str[80];
1180: int script_len = 0, dsa_len = 0, size = 0, max_cmd_size = 0,
1181: schedule_size = 0, ok = 0;
1182: void *tmp;
1183:
1184: options |= perm_options;
1185:
1186: switch (chip) {
1187: case 825:
1188: case 820:
1189: case 815:
1190: case 810:
1191: schedule_size = (tpnt->can_queue + 1) * 8 /* JUMP instruction size */;
1192: script_len = NCR53c8xx_script_len;
1193: dsa_len = NCR53c8xx_dsa_len;
1194: options |= OPTION_INTFLY;
1195: sprintf (chip_str, "NCR53c%d", chip);
1196: break;
1197: default:
1198: printk("scsi-ncr53c7,8xx : unsupported SCSI chip %d\n", chip);
1199: return -1;
1200: }
1201:
1202: printk("scsi-ncr53c7,8xx : %s at memory 0x%x, io 0x%x, irq %d",
1203: chip_str, (unsigned) base, io_port, irq);
1204: if (dma == DMA_NONE)
1205: printk("\n");
1206: else
1207: printk(", dma %d\n", dma);
1208:
1209: if ((chip / 100 == 8) && !pci_valid)
1210: printk ("scsi-ncr53c7,8xx : for better reliability and performance, please use the\n"
1211: " PCI override instead.\n"
1212: " Syntax : ncr53c8{10,15,20,25}=pci,<bus>,<device>,<function>\n"
1213: " <bus> and <device> are usually 0.\n");
1214:
1215: if (options & OPTION_DEBUG_PROBE_ONLY) {
1216: printk ("scsi-ncr53c7,8xx : probe only enabled, aborting initialization\n");
1217: return -1;
1218: }
1219:
1220: max_cmd_size = sizeof(struct NCR53c7x0_cmd) + dsa_len +
1221: /* Size of dynamic part of command structure : */
1222: 2 * /* Worst case : we don't know if we need DATA IN or DATA out */
1223: ( 2 * /* Current instructions per scatter/gather segment */
1224: tpnt->sg_tablesize +
1225: 3 /* Current startup / termination required per phase */
1226: ) *
1227: 8 /* Each instruction is eight bytes */;
1228:
1229: /* Allocate fixed part of hostdata, dynamic part to hold appropriate
1230: SCSI SCRIPT(tm) plus a single, maximum-sized NCR53c7x0_cmd structure.
1231:
1232: We need a NCR53c7x0_cmd structure for scan_scsis() when we are
1233: not loaded as a module, and when we're loaded as a module, we
1234: can't use a non-dynamically allocated structure because modules
1235: are vmalloc()'d, which can allow structures to cross page
1236: boundaries and breaks our physical/virtual address assumptions
1237: for DMA.
1238:
1239: So, we stick it past the end of our hostdata structure.
1240:
1241: ASSUMPTION :
1242: Regardless of how many simultaneous SCSI commands we allow,
1243: the probe code only executes a _single_ instruction at a time,
1244: so we only need one here, and don't need to allocate NCR53c7x0_cmd
1245: structures for each target until we are no longer in scan_scsis
1246: and kmalloc() has become functional (memory_init() happens
1247: after all device driver initialization).
1248: */
1249:
1250: size = sizeof(struct NCR53c7x0_hostdata) + script_len +
1251: /* Note that alignment will be guaranteed, since we put the command
1252: allocated at probe time after the fixed-up SCSI script, which
1253: consists of 32 bit words, aligned on a 32 bit boundary. But
1254: on a 64bit machine we need 8 byte alignment for hostdata->free, so
1255: we add in another 4 bytes to take care of potential misalignment
1256: */
1257: (sizeof(void *) - sizeof(u32)) + max_cmd_size + schedule_size;
1258:
1259: instance = scsi_register (tpnt, size);
1260: if (!instance)
1261: return -1;
1262:
1263: /* FIXME : if we ever support an ISA NCR53c7xx based board, we
1264: need to check if the chip is running in a 16 bit mode, and if so
1265: unregister it if it is past the 16M (0x1000000) mark */
1266:
1267: hostdata = (struct NCR53c7x0_hostdata *)
1268: instance->hostdata;
1269: hostdata->size = size;
1270: hostdata->script_count = script_len / sizeof(u32);
1271: hostdata = (struct NCR53c7x0_hostdata *) instance->hostdata;
1272: hostdata->board = board;
1273: hostdata->chip = chip;
1274: if ((hostdata->pci_valid = pci_valid)) {
1275: hostdata->pci_bus = pci_bus;
1276: hostdata->pci_device_fn = pci_device_fn;
1277: }
1278:
1279: /*
1280: * Being memory mapped is more desirable, since
1281: *
1282: * - Memory accesses may be faster.
1283: *
1284: * - The destination and source address spaces are the same for
1285: * all instructions, meaning we don't have to twiddle dmode or
1286: * any other registers.
1287: *
1288: * So, we try for memory mapped, and if we don't get it,
1289: * we go for port mapped, and that failing we tell the user
1290: * it can't work.
1291: */
1292:
1293: if (base) {
1294: instance->base = (unsigned char *) (unsigned long) base;
1295: /* Check for forced I/O mapping */
1296: if (!(options & OPTION_IO_MAPPED)) {
1297: options |= OPTION_MEMORY_MAPPED;
1298: ok = 1;
1299: }
1300: } else {
1301: options &= ~OPTION_MEMORY_MAPPED;
1302: }
1303:
1304: if (io_port) {
1305: instance->io_port = io_port;
1306: options |= OPTION_IO_MAPPED;
1307: ok = 1;
1308: } else {
1309: options &= ~OPTION_IO_MAPPED;
1310: }
1311:
1312: if (!ok) {
1313: printk ("scsi%d : not initializing, no I/O or memory mapping known \n",
1314: instance->host_no);
1315: scsi_unregister (instance);
1316: return -1;
1317: }
1318: instance->irq = irq;
1319: instance->dma_channel = dma;
1320:
1321: hostdata->options = options;
1322: hostdata->dsa_len = dsa_len;
1323: hostdata->max_cmd_size = max_cmd_size;
1324: hostdata->num_cmds = 1;
1325: /* Initialize single command */
1326: tmp = (hostdata->script + hostdata->script_count);
1327: hostdata->free = ROUNDUP(tmp, void *);
1328: hostdata->free->real = tmp;
1329: hostdata->free->size = max_cmd_size;
1330: hostdata->free->free = NULL;
1331: hostdata->free->next = NULL;
1332: hostdata->extra_allocate = 0;
1333:
1334: /* Allocate command start code space */
1335: hostdata->schedule = (chip == 700 || chip == 70066) ?
1336: NULL : (u32 *) ((char *)hostdata->free + max_cmd_size);
1337:
1338: /*
1339: * For diagnostic purposes, we don't really care how fast things blaze.
1340: * For profiling, we want to access the 800ns resolution system clock,
1341: * using a 'C' call on the host processor.
1342: *
1343: * Therefore, there's no need for the NCR chip to directly manipulate
1344: * this data, and we should put it wherever is most convienient for
1345: * Linux.
1346: */
1347: if (track_events)
1348: hostdata->events = (struct NCR53c7x0_event *) (track_events ?
1349: vmalloc (sizeof (struct NCR53c7x0_event) * track_events) : NULL);
1350: else
1351: hostdata->events = NULL;
1352:
1353: if (hostdata->events) {
1354: memset ((void *) hostdata->events, 0, sizeof(struct NCR53c7x0_event) *
1355: track_events);
1356: hostdata->event_size = track_events;
1357: hostdata->event_index = 0;
1358: } else
1359: hostdata->event_size = 0;
1360:
1361: return NCR53c7x0_init(instance);
1362: }
1363:
1364:
1365: /*
1366: * Function : static int ncr_pci_init(Scsi_Host_Template *tpnt, int board,
1367: * int chip, int bus, int device_fn, long long options)
1368: *
1369: * Purpose : initializes a NCR53c800 family based on the PCI
1370: * bus, device, and function location of it. Allows
1371: * reprogramming of latency timer and determining addresses
1372: * and whether bus mastering, etc. are OK.
1373: *
1374: * Useful where a new NCR chip is backwards compatible with
1375: * a supported chip, but the DEVICE ID has changed so it
1376: * doesn't show up when the autoprobe does a pcibios_find_device.
1377: *
1378: * Inputs : tpnt - Template for this SCSI adapter, board - board level
1379: * product, chip - 810, 820, or 825, bus - PCI bus, device_fn -
1380: * device and function encoding as used by PCI BIOS calls.
1381: *
1382: * Returns : 0 on success, -1 on failure.
1383: *
1384: */
1385:
1386: static int
1387: ncr_pci_init (Scsi_Host_Template *tpnt, int board, int chip,
1388: unsigned char bus, unsigned char device_fn, long long options) {
1389: unsigned short vendor_id, device_id, command;
1390: #ifdef LINUX_1_2
1391: unsigned long
1392: #else
1393: unsigned int
1394: #endif
1395: base, io_port;
1396: unsigned char irq, revision;
1397: int error, expected_chip;
1398: int expected_id = -1, max_revision = -1, min_revision = -1;
1399: int i;
1400:
1401: printk("scsi-ncr53c7,8xx : at PCI bus %d, device %d, function %d\n",
1402: bus, (int) (device_fn & 0xf8) >> 3,
1403: (int) device_fn & 7);
1404:
1405: if (!pcibios_present()) {
1406: printk("scsi-ncr53c7,8xx : not initializing due to lack of PCI BIOS,\n"
1407: " try using memory, port, irq override instead.\n");
1408: return -1;
1409: }
1410:
1411: if ((error = pcibios_read_config_word (bus, device_fn, PCI_VENDOR_ID,
1412: &vendor_id)) ||
1413: (error = pcibios_read_config_word (bus, device_fn, PCI_DEVICE_ID,
1414: &device_id)) ||
1415: (error = pcibios_read_config_word (bus, device_fn, PCI_COMMAND,
1416: &command)) ||
1417: (error = pcibios_read_config_dword (bus, device_fn,
1418: PCI_BASE_ADDRESS_0, &io_port)) ||
1419: (error = pcibios_read_config_dword (bus, device_fn,
1420: PCI_BASE_ADDRESS_1, &base)) ||
1421: (error = pcibios_read_config_byte (bus, device_fn, PCI_CLASS_REVISION,
1422: &revision)) ||
1423: (error = pcibios_read_config_byte (bus, device_fn, PCI_INTERRUPT_LINE,
1424: &irq))) {
1425: printk ("scsi-ncr53c7,8xx : error %s not initializing due to error reading configuration space\n"
1426: " perhaps you specified an incorrect PCI bus, device, or function.\n"
1427: , pcibios_strerror(error));
1428: return -1;
1429: }
1430:
1431: /* If any one ever clones the NCR chips, this will have to change */
1432:
1433: if (vendor_id != PCI_VENDOR_ID_NCR) {
1434: printk ("scsi-ncr53c7,8xx : not initializing, 0x%04x is not NCR vendor ID\n",
1435: (int) vendor_id);
1436: return -1;
1437: }
1438:
1439:
1440: /*
1441: * Bit 0 is the address space indicator and must be one for I/O
1442: * space mappings, bit 1 is reserved, discard them after checking
1443: * that they have the correct value of 1.
1444: */
1445:
1446: if (command & PCI_COMMAND_IO) {
1447: if ((io_port & 3) != 1) {
1448: printk ("scsi-ncr53c7,8xx : disabling I/O mapping since base address 0 (0x%x)\n"
1449: " bits 0..1 indicate a non-IO mapping\n",
1450: (unsigned) io_port);
1451: io_port = 0;
1452: } else
1453: io_port &= PCI_BASE_ADDRESS_IO_MASK;
1454: } else {
1455: io_port = 0;
1456: }
1457:
1458: if (command & PCI_COMMAND_MEMORY) {
1459: if ((base & PCI_BASE_ADDRESS_SPACE) != PCI_BASE_ADDRESS_SPACE_MEMORY) {
1460: printk("scsi-ncr53c7,8xx : disabling memory mapping since base address 1\n"
1461: " contains a non-memory mapping\n");
1462: base = 0;
1463: } else
1464: base &= PCI_BASE_ADDRESS_MEM_MASK;
1465: } else {
1466: base = 0;
1467: }
1468:
1469: if (!io_port && !base) {
1470: printk ("scsi-ncr53c7,8xx : not initializing, both I/O and memory mappings disabled\n");
1471: return -1;
1472: }
1473:
1474: if (!(command & PCI_COMMAND_MASTER)) {
1475: printk ("scsi-ncr53c7,8xx : not initializing, BUS MASTERING was disabled\n");
1476: return -1;
1477: }
1478:
1479: for (i = 0; i < NPCI_CHIP_IDS; ++i) {
1480: if (device_id == pci_chip_ids[i].pci_device_id) {
1481: max_revision = pci_chip_ids[i].max_revision;
1482: min_revision = pci_chip_ids[i].min_revision;
1483: expected_chip = pci_chip_ids[i].chip;
1484: }
1485: if (chip == pci_chip_ids[i].chip)
1486: expected_id = pci_chip_ids[i].pci_device_id;
1487: }
1488:
1489: if (chip && device_id != expected_id)
1490: printk ("scsi-ncr53c7,8xx : warning : device id of 0x%04x doesn't\n"
1491: " match expected 0x%04x\n",
1492: (unsigned int) device_id, (unsigned int) expected_id );
1493:
1494: if (max_revision != -1 && revision > max_revision)
1495: printk ("scsi-ncr53c7,8xx : warning : revision of %d is greater than %d.\n",
1496: (int) revision, max_revision);
1497: else if (min_revision != -1 && revision < min_revision)
1498: printk ("scsi-ncr53c7,8xx : warning : revision of %d is less than %d.\n",
1499: (int) revision, min_revision);
1500:
1501: if (io_port && check_region (io_port, 128)) {
1502: printk ("scsi-ncr53c7,8xx : IO region 0x%x to 0x%x is in use\n",
1503: (unsigned) io_port, (unsigned) io_port + 127);
1504: return -1;
1505: }
1506:
1507: return normal_init (tpnt, board, chip, (int) base, io_port,
1508: (int) irq, DMA_NONE, 1, bus, device_fn, options);
1509: }
1510:
1511:
1512: /*
1513: * Function : int NCR53c7xx_detect(Scsi_Host_Template *tpnt)
1514: *
1515: * Purpose : detects and initializes NCR53c7,8x0 SCSI chips
1516: * that were autoprobed, overridden on the LILO command line,
1517: * or specified at compile time.
1518: *
1519: * Inputs : tpnt - template for this SCSI adapter
1520: *
1521: * Returns : number of host adapters detected
1522: *
1523: */
1524:
1525: int
1526: NCR53c7xx_detect(Scsi_Host_Template *tpnt) {
1527: int i;
1528: int current_override;
1529: int count; /* Number of boards detected */
1530: unsigned char pci_bus, pci_device_fn;
1531: static short pci_index=0; /* Device index to PCI BIOS calls */
1532:
1533: #ifndef LINUX_1_2
1534: tpnt->proc_dir = &proc_scsi_ncr53c7xx;
1535: #endif
1536:
1537: for (current_override = count = 0; current_override < OVERRIDE_LIMIT;
1538: ++current_override) {
1539: if (overrides[current_override].pci ?
1540: !ncr_pci_init (tpnt, overrides[current_override].board,
1541: overrides[current_override].chip,
1542: (unsigned char) overrides[current_override].data.pci.bus,
1543: (((overrides[current_override].data.pci.device
1544: << 3) & 0xf8)|(overrides[current_override].data.pci.function &
1545: 7)), overrides[current_override].options):
1546: !normal_init (tpnt, overrides[current_override].board,
1547: overrides[current_override].chip,
1548: overrides[current_override].data.normal.base,
1549: overrides[current_override].data.normal.io_port,
1550: overrides[current_override].data.normal.irq,
1551: overrides[current_override].data.normal.dma,
1552: 0 /* PCI data invalid */, 0 /* PCI bus place holder */,
1553: 0 /* PCI device_function place holder */,
1554: overrides[current_override].options)) {
1555: ++count;
1556: }
1557: }
1558:
1559: if (pcibios_present()) {
1560: for (i = 0; i < NPCI_CHIP_IDS; ++i)
1561: for (pci_index = 0;
1562: !pcibios_find_device (PCI_VENDOR_ID_NCR,
1563: pci_chip_ids[i].pci_device_id, pci_index, &pci_bus,
1564: &pci_device_fn);
1565: ++pci_index)
1566: if (!ncr_pci_init (tpnt, BOARD_GENERIC, pci_chip_ids[i].chip,
1567: pci_bus, pci_device_fn, /* no options */ 0))
1568: ++count;
1569: }
1570: return count;
1571: }
1572:
1573: /* NCR53c810 and NCR53c820 script handling code */
1574:
1575: #include "53c8xx_d.h"
1576: #ifdef A_int_debug_sync
1577: #define DEBUG_SYNC_INTR A_int_debug_sync
1578: #endif
1579: static int NCR53c8xx_script_len = sizeof (SCRIPT);
1580: static int NCR53c8xx_dsa_len = A_dsa_end + Ent_dsa_zero - Ent_dsa_code_template;
1581:
1582: /*
1583: * Function : static void NCR53c8x0_init_fixup (struct Scsi_Host *host)
1584: *
1585: * Purpose : copy and fixup the SCSI SCRIPTS(tm) code for this device.
1586: *
1587: * Inputs : host - pointer to this host adapter's structure
1588: *
1589: */
1590:
1591: static void
1592: NCR53c8x0_init_fixup (struct Scsi_Host *host) {
1593: NCR53c7x0_local_declare();
1594: struct NCR53c7x0_hostdata *hostdata = (struct NCR53c7x0_hostdata *)
1595: host->hostdata;
1596: unsigned char tmp;
1597: int i, ncr_to_memory, memory_to_ncr;
1598: u32 base;
1599: NCR53c7x0_local_setup(host);
1600:
1601:
1602: /* XXX - NOTE : this code MUST be made endian aware */
1603: /* Copy code into buffer that was allocated at detection time. */
1604: memcpy ((void *) hostdata->script, (void *) SCRIPT,
1605: sizeof(SCRIPT));
1606: /* Fixup labels */
1607: for (i = 0; i < PATCHES; ++i)
1608: hostdata->script[LABELPATCHES[i]] +=
1609: virt_to_bus(hostdata->script);
1610: /* Fixup addresses of constants that used to be EXTERNAL */
1611:
1612: patch_abs_32 (hostdata->script, 0, NCR53c7xx_msg_abort,
1613: virt_to_bus(&(hostdata->NCR53c7xx_msg_abort)));
1614: patch_abs_32 (hostdata->script, 0, NCR53c7xx_msg_reject,
1615: virt_to_bus(&(hostdata->NCR53c7xx_msg_reject)));
1616: patch_abs_32 (hostdata->script, 0, NCR53c7xx_zero,
1617: virt_to_bus(&(hostdata->NCR53c7xx_zero)));
1618: patch_abs_32 (hostdata->script, 0, NCR53c7xx_sink,
1619: virt_to_bus(&(hostdata->NCR53c7xx_sink)));
1620: patch_abs_32 (hostdata->script, 0, NOP_insn,
1621: virt_to_bus(&(hostdata->NOP_insn)));
1622: patch_abs_32 (hostdata->script, 0, schedule,
1623: virt_to_bus((void *) hostdata->schedule));
1624:
1625: /* Fixup references to external variables: */
1626: for (i = 0; i < EXTERNAL_PATCHES_LEN; ++i)
1627: hostdata->script[EXTERNAL_PATCHES[i].offset] +=
1628: virt_to_bus(EXTERNAL_PATCHES[i].address);
1629:
1630: /*
1631: * Fixup absolutes set at boot-time.
1632: *
1633: * All non-code absolute variables suffixed with "dsa_" and "int_"
1634: * are constants, and need no fixup provided the assembler has done
1635: * it for us (I don't know what the "real" NCR assembler does in
1636: * this case, my assembler does the right magic).
1637: */
1638:
1639: patch_abs_rwri_data (hostdata->script, 0, dsa_save_data_pointer,
1640: Ent_dsa_code_save_data_pointer - Ent_dsa_zero);
1641: patch_abs_rwri_data (hostdata->script, 0, dsa_restore_pointers,
1642: Ent_dsa_code_restore_pointers - Ent_dsa_zero);
1643: patch_abs_rwri_data (hostdata->script, 0, dsa_check_reselect,
1644: Ent_dsa_code_check_reselect - Ent_dsa_zero);
1645:
1646: /*
1647: * Just for the hell of it, preserve the settings of
1648: * Burst Length and Enable Read Line bits from the DMODE
1649: * register. Make sure SCRIPTS start automagically.
1650: */
1651:
1652: tmp = NCR53c7x0_read8(DMODE_REG_10);
1653: tmp &= (DMODE_800_ERL | DMODE_BL_MASK);
1654:
1655: if (!(hostdata->options & OPTION_MEMORY_MAPPED)) {
1656: base = (u32) host->io_port;
1657: memory_to_ncr = tmp|DMODE_800_DIOM;
1658: ncr_to_memory = tmp|DMODE_800_SIOM;
1659: } else {
1660: base = virt_to_bus(host->base);
1661: memory_to_ncr = ncr_to_memory = tmp;
1662: }
1663:
1664: patch_abs_32 (hostdata->script, 0, addr_scratch, base + SCRATCHA_REG_800);
1665: patch_abs_32 (hostdata->script, 0, addr_temp, base + TEMP_REG);
1666:
1667: /*
1668: * I needed some variables in the script to be accessible to
1669: * both the NCR chip and the host processor. For these variables,
1670: * I made the arbitrary decision to store them directly in the
1671: * hostdata structure rather than in the RELATIVE area of the
1672: * SCRIPTS.
1673: */
1674:
1675:
1676: patch_abs_rwri_data (hostdata->script, 0, dmode_memory_to_memory, tmp);
1677: patch_abs_rwri_data (hostdata->script, 0, dmode_memory_to_ncr, memory_to_ncr);
1678: patch_abs_rwri_data (hostdata->script, 0, dmode_ncr_to_memory, ncr_to_memory);
1679:
1680: patch_abs_32 (hostdata->script, 0, msg_buf,
1681: virt_to_bus((void *)&(hostdata->msg_buf)));
1682: patch_abs_32 (hostdata->script, 0, reconnect_dsa_head,
1683: virt_to_bus((void *)&(hostdata->reconnect_dsa_head)));
1684: patch_abs_32 (hostdata->script, 0, addr_reconnect_dsa_head,
1685: virt_to_bus((void *)&(hostdata->addr_reconnect_dsa_head)));
1686: patch_abs_32 (hostdata->script, 0, reselected_identify,
1687: virt_to_bus((void *)&(hostdata->reselected_identify)));
1688: /* reselected_tag is currently unused */
1689: #if 0
1690: patch_abs_32 (hostdata->script, 0, reselected_tag,
1691: virt_to_bus((void *)&(hostdata->reselected_tag)));
1692: #endif
1693:
1694: patch_abs_32 (hostdata->script, 0, test_dest,
1695: virt_to_bus((void*)&hostdata->test_dest));
1696: patch_abs_32 (hostdata->script, 0, test_src,
1697: virt_to_bus(&hostdata->test_source));
1698:
1699: patch_abs_rwri_data (hostdata->script, 0, dsa_check_reselect,
1700: (unsigned char)(Ent_dsa_code_check_reselect - Ent_dsa_zero));
1701:
1702: /* These are for event logging; the ncr_event enum contains the
1703: actual interrupt numbers. */
1704: #ifdef A_int_EVENT_SELECT
1705: patch_abs_32 (hostdata->script, 0, int_EVENT_SELECT, (u32) EVENT_SELECT);
1706: #endif
1707: #ifdef A_int_EVENT_DISCONNECT
1708: patch_abs_32 (hostdata->script, 0, int_EVENT_DISCONNECT, (u32) EVENT_DISCONNECT);
1709: #endif
1710: #ifdef A_int_EVENT_RESELECT
1711: patch_abs_32 (hostdata->script, 0, int_EVENT_RESELECT, (u32) EVENT_RESELECT);
1712: #endif
1713: #ifdef A_int_EVENT_COMPLETE
1714: patch_abs_32 (hostdata->script, 0, int_EVENT_COMPLETE, (u32) EVENT_COMPLETE);
1715: #endif
1716: #ifdef A_int_EVENT_IDLE
1717: patch_abs_32 (hostdata->script, 0, int_EVENT_IDLE, (u32) EVENT_IDLE);
1718: #endif
1719: #ifdef A_int_EVENT_SELECT_FAILED
1720: patch_abs_32 (hostdata->script, 0, int_EVENT_SELECT_FAILED,
1721: (u32) EVENT_SELECT_FAILED);
1722: #endif
1723: #ifdef A_int_EVENT_BEFORE_SELECT
1724: patch_abs_32 (hostdata->script, 0, int_EVENT_BEFORE_SELECT,
1725: (u32) EVENT_BEFORE_SELECT);
1726: #endif
1727: #ifdef A_int_EVENT_RESELECT_FAILED
1728: patch_abs_32 (hostdata->script, 0, int_EVENT_RESELECT_FAILED,
1729: (u32) EVENT_RESELECT_FAILED);
1730: #endif
1731:
1732: /*
1733: * Make sure the NCR and Linux code agree on the location of
1734: * certain fields.
1735: */
1736:
1737: hostdata->E_accept_message = Ent_accept_message;
1738: hostdata->E_command_complete = Ent_command_complete;
1739: hostdata->E_cmdout_cmdout = Ent_cmdout_cmdout;
1740: hostdata->E_data_transfer = Ent_data_transfer;
1741: hostdata->E_debug_break = Ent_debug_break;
1742: hostdata->E_dsa_code_template = Ent_dsa_code_template;
1743: hostdata->E_dsa_code_template_end = Ent_dsa_code_template_end;
1744: hostdata->E_end_data_transfer = Ent_end_data_transfer;
1745: hostdata->E_initiator_abort = Ent_initiator_abort;
1746: hostdata->E_msg_in = Ent_msg_in;
1747: hostdata->E_other_transfer = Ent_other_transfer;
1748: hostdata->E_other_in = Ent_other_in;
1749: hostdata->E_other_out = Ent_other_out;
1750: hostdata->E_reject_message = Ent_reject_message;
1751: hostdata->E_respond_message = Ent_respond_message;
1752: hostdata->E_select = Ent_select;
1753: hostdata->E_select_msgout = Ent_select_msgout;
1754: hostdata->E_target_abort = Ent_target_abort;
1755: #ifdef Ent_test_0
1756: hostdata->E_test_0 = Ent_test_0;
1757: #endif
1758: hostdata->E_test_1 = Ent_test_1;
1759: hostdata->E_test_2 = Ent_test_2;
1760: #ifdef Ent_test_3
1761: hostdata->E_test_3 = Ent_test_3;
1762: #endif
1763: hostdata->E_wait_reselect = Ent_wait_reselect;
1764: hostdata->E_dsa_code_begin = Ent_dsa_code_begin;
1765:
1766: hostdata->dsa_cmdout = A_dsa_cmdout;
1767: hostdata->dsa_cmnd = A_dsa_cmnd;
1768: hostdata->dsa_datain = A_dsa_datain;
1769: hostdata->dsa_dataout = A_dsa_dataout;
1770: hostdata->dsa_end = A_dsa_end;
1771: hostdata->dsa_msgin = A_dsa_msgin;
1772: hostdata->dsa_msgout = A_dsa_msgout;
1773: hostdata->dsa_msgout_other = A_dsa_msgout_other;
1774: hostdata->dsa_next = A_dsa_next;
1775: hostdata->dsa_select = A_dsa_select;
1776: hostdata->dsa_start = Ent_dsa_code_template - Ent_dsa_zero;
1777: hostdata->dsa_status = A_dsa_status;
1778: hostdata->dsa_jump_dest = Ent_dsa_code_fix_jump - Ent_dsa_zero +
1779: 8 /* destination operand */;
1780:
1781: /* sanity check */
1782: if (A_dsa_fields_start != Ent_dsa_code_template_end -
1783: Ent_dsa_zero)
1784: printk("scsi%d : NCR dsa_fields start is %d not %d\n",
1785: host->host_no, A_dsa_fields_start, Ent_dsa_code_template_end -
1786: Ent_dsa_zero);
1787:
1788: printk("scsi%d : NCR code relocated to 0x%lx (virt 0x%p)\n", host->host_no,
1789: virt_to_bus(hostdata->script), hostdata->script);
1790: }
1791:
1792: /*
1793: * Function : static int NCR53c8xx_run_tests (struct Scsi_Host *host)
1794: *
1795: * Purpose : run various verification tests on the NCR chip,
1796: * including interrupt generation, and proper bus mastering
1797: * operation.
1798: *
1799: * Inputs : host - a properly initialized Scsi_Host structure
1800: *
1801: * Preconditions : the NCR chip must be in a halted state.
1802: *
1803: * Returns : 0 if all tests were successful, -1 on error.
1804: *
1805: */
1806:
1807: static int
1808: NCR53c8xx_run_tests (struct Scsi_Host *host) {
1809: NCR53c7x0_local_declare();
1810: struct NCR53c7x0_hostdata *hostdata = (struct NCR53c7x0_hostdata *)
1811: host->hostdata;
1812: unsigned long timeout;
1813: u32 start;
1814: int failed, i;
1815: unsigned long flags;
1816: NCR53c7x0_local_setup(host);
1817:
1818: /* The NCR chip _must_ be idle to run the test scripts */
1819:
1820: save_flags(flags);
1821: cli();
1822: if (!hostdata->idle) {
1823: printk ("scsi%d : chip not idle, aborting tests\n", host->host_no);
1824: restore_flags(flags);
1825: return -1;
1826: }
1827:
1828: /*
1829: * Check for functional interrupts, this could work as an
1830: * autoprobe routine.
1831: */
1832:
1833: if ((hostdata->options & OPTION_DEBUG_TEST1) &&
1834: hostdata->state != STATE_DISABLED) {
1835: hostdata->idle = 0;
1836: hostdata->test_running = 1;
1837: hostdata->test_completed = -1;
1838: hostdata->test_dest = 0;
1839: hostdata->test_source = 0xdeadbeef;
1840: start = virt_to_bus (hostdata->script) + hostdata->E_test_1;
1841: hostdata->state = STATE_RUNNING;
1842: printk ("scsi%d : test 1", host->host_no);
1843: NCR53c7x0_write32 (DSP_REG, start);
1844: printk (" started\n");
1845: sti();
1846:
1847: /*
1848: * This is currently a .5 second timeout, since (in theory) no slow
1849: * board will take that long. In practice, we've seen one
1850: * pentium which ocassionally fails with this, but works with
1851: * 10 times as much?
1852: */
1853:
1854: timeout = jiffies + 5 * HZ / 10;
1855: while ((hostdata->test_completed == -1) && jiffies < timeout)
1856: barrier();
1857:
1858: failed = 1;
1859: if (hostdata->test_completed == -1)
1860: printk ("scsi%d : driver test 1 timed out%s\n",host->host_no ,
1861: (hostdata->test_dest == 0xdeadbeef) ?
1862: " due to lost interrupt.\n"
1863: " Please verify that the correct IRQ is being used for your board,\n"
1864: " and that the motherboard IRQ jumpering matches the PCI setup on\n"
1865: " PCI systems.\n"
1866: " If you are using a NCR53c810 board in a PCI system, you should\n"
1867: " also verify that the board is jumpered to use PCI INTA, since\n"
1868: " most PCI motherboards lack support for INTB, INTC, and INTD.\n"
1869: : "");
1870: else if (hostdata->test_completed != 1)
1871: printk ("scsi%d : test 1 bad interrupt value (%d)\n",
1872: host->host_no, hostdata->test_completed);
1873: else
1874: failed = (hostdata->test_dest != 0xdeadbeef);
1875:
1876: if (hostdata->test_dest != 0xdeadbeef) {
1877: printk ("scsi%d : driver test 1 read 0x%x instead of 0xdeadbeef indicating a\n"
1878: " probable cache invalidation problem. Please configure caching\n"
1879: " as write-through or disabled\n",
1880: host->host_no, hostdata->test_dest);
1881: }
1882:
1883: if (failed) {
1884: printk ("scsi%d : DSP = 0x%p (script at 0x%p, start at 0x%x)\n",
1885: host->host_no, bus_to_virt(NCR53c7x0_read32(DSP_REG)),
1886: hostdata->script, start);
1887: printk ("scsi%d : DSPS = 0x%x\n", host->host_no,
1888: NCR53c7x0_read32(DSPS_REG));
1889: restore_flags(flags);
1890: return -1;
1891: }
1892: hostdata->test_running = 0;
1893: }
1894:
1895: if ((hostdata->options & OPTION_DEBUG_TEST2) &&
1896: hostdata->state != STATE_DISABLED) {
1897: u32 dsa[48];
1898: unsigned char identify = IDENTIFY(0, 0);
1899: unsigned char cmd[6];
1900: unsigned char data[36];
1901: unsigned char status = 0xff;
1902: unsigned char msg = 0xff;
1903:
1904: cmd[0] = INQUIRY;
1905: cmd[1] = cmd[2] = cmd[3] = cmd[5] = 0;
1906: cmd[4] = sizeof(data);
1907:
1908: dsa[2] = 1;
1909: dsa[3] = virt_to_bus(&identify);
1910: dsa[4] = 6;
1911: dsa[5] = virt_to_bus(&cmd);
1912: dsa[6] = sizeof(data);
1913: dsa[7] = virt_to_bus(&data);
1914: dsa[8] = 1;
1915: dsa[9] = virt_to_bus(&status);
1916: dsa[10] = 1;
1917: dsa[11] = virt_to_bus(&msg);
1918:
1919: for (i = 0; i < 3; ++i) {
1920: cli();
1921: if (!hostdata->idle) {
1922: printk ("scsi%d : chip not idle, aborting tests\n", host->host_no);
1923: restore_flags(flags);
1924: return -1;
1925: }
1926:
1927: /* SCNTL3 SDID */
1928: dsa[0] = (0x33 << 24) | (i << 16) ;
1929: hostdata->idle = 0;
1930: hostdata->test_running = 2;
1931: hostdata->test_completed = -1;
1932: start = virt_to_bus(hostdata->script) + hostdata->E_test_2;
1933: hostdata->state = STATE_RUNNING;
1934: NCR53c7x0_write32 (DSA_REG, virt_to_bus(dsa));
1935: NCR53c7x0_write32 (DSP_REG, start);
1936: sti();
1937:
1938: timeout = jiffies + 5 * HZ; /* arbitrary */
1939: while ((hostdata->test_completed == -1) && jiffies < timeout)
1940: barrier();
1941: NCR53c7x0_write32 (DSA_REG, 0);
1942:
1943: if (hostdata->test_completed == 2) {
1944: data[35] = 0;
1945: printk ("scsi%d : test 2 INQUIRY to target %d, lun 0 : %s\n",
1946: host->host_no, i, data + 8);
1947: printk ("scsi%d : status ", host->host_no);
1948: print_status (status);
1949: printk ("\nscsi%d : message ", host->host_no);
1950: print_msg (&msg);
1951: printk ("\n");
1952: } else if (hostdata->test_completed == 3) {
1953: printk("scsi%d : test 2 no connection with target %d\n",
1954: host->host_no, i);
1955: if (!hostdata->idle) {
1956: printk("scsi%d : not idle\n", host->host_no);
1957: restore_flags(flags);
1958: return -1;
1959: }
1960: } else if (hostdata->test_completed == -1) {
1961: printk ("scsi%d : test 2 timed out\n", host->host_no);
1962: restore_flags(flags);
1963: return -1;
1964: }
1965: hostdata->test_running = 0;
1966: }
1967: }
1968:
1969: restore_flags(flags);
1970: return 0;
1971: }
1972:
1973: /*
1974: * Function : static void NCR53c8xx_dsa_fixup (struct NCR53c7x0_cmd *cmd)
1975: *
1976: * Purpose : copy the NCR53c8xx dsa structure into cmd's dsa buffer,
1977: * performing all necessary relocation.
1978: *
1979: * Inputs : cmd, a NCR53c7x0_cmd structure with a dsa area large
1980: * enough to hold the NCR53c8xx dsa.
1981: */
1982:
1983: static void
1984: NCR53c8xx_dsa_fixup (struct NCR53c7x0_cmd *cmd) {
1985: Scsi_Cmnd *c = cmd->cmd;
1986: struct Scsi_Host *host = c->host;
1987: struct NCR53c7x0_hostdata *hostdata = (struct NCR53c7x0_hostdata *)
1988: host->hostdata;
1989: int i;
1990:
1991: memcpy (cmd->dsa, hostdata->script + (hostdata->E_dsa_code_template / 4),
1992: hostdata->E_dsa_code_template_end - hostdata->E_dsa_code_template);
1993:
1994: /*
1995: * Note : within the NCR 'C' code, dsa points to the _start_
1996: * of the DSA structure, and _not_ the offset of dsa_zero within
1997: * that structure used to facilitate shorter signed offsets
1998: * for the 8 bit ALU.
1999: *
2000: * The implications of this are that
2001: *
2002: * - 32 bit A_dsa_* absolute values require an additional
2003: * dsa_zero added to their value to be correct, since they are
2004: * relative to dsa_zero which is in essentially a separate
2005: * space from the code symbols.
2006: *
2007: * - All other symbols require no special treatment.
2008: */
2009:
2010: patch_abs_tci_data (cmd->dsa, Ent_dsa_code_template / sizeof(u32),
2011: dsa_temp_lun, c->lun);
2012: patch_abs_32 (cmd->dsa, Ent_dsa_code_template / sizeof(u32),
2013: dsa_temp_addr_next, virt_to_bus(&cmd->dsa_next_addr));
2014: patch_abs_32 (cmd->dsa, Ent_dsa_code_template / sizeof(u32),
2015: dsa_temp_next, virt_to_bus(cmd->dsa) + Ent_dsa_zero -
2016: Ent_dsa_code_template + A_dsa_next);
2017: patch_abs_32 (cmd->dsa, Ent_dsa_code_template / sizeof(u32),
2018: dsa_temp_sync, virt_to_bus((void *)hostdata->sync[c->target].script));
2019: patch_abs_tci_data (cmd->dsa, Ent_dsa_code_template / sizeof(u32),
2020: dsa_temp_target, c->target);
2021: /* XXX - new pointer stuff */
2022: patch_abs_32 (cmd->dsa, Ent_dsa_code_template / sizeof(u32),
2023: dsa_temp_addr_saved_pointer, virt_to_bus(&cmd->saved_data_pointer));
2024: patch_abs_32 (cmd->dsa, Ent_dsa_code_template / sizeof(u32),
2025: dsa_temp_addr_saved_residual, virt_to_bus(&cmd->saved_residual));
2026: patch_abs_32 (cmd->dsa, Ent_dsa_code_template / sizeof(u32),
2027: dsa_temp_addr_residual, virt_to_bus(&cmd->residual));
2028:
2029: /* XXX - new start stuff */
2030: patch_abs_32 (cmd->dsa, Ent_dsa_code_template / sizeof(u32),
2031: dsa_temp_addr_dsa_value, virt_to_bus(&cmd->dsa_addr));
2032:
2033: }
2034:
2035: /*
2036: * Function : run_process_issue_queue (void)
2037: *
2038: * Purpose : insure that the coroutine is running and will process our
2039: * request. process_issue_queue_running is checked/set here (in an
2040: * inline function) rather than in process_issue_queue itself to reduce
2041: * the chances of stack overflow.
2042: *
2043: */
2044:
2045: static volatile int process_issue_queue_running = 0;
2046:
2047: static __inline__ void
2048: run_process_issue_queue(void) {
2049: unsigned long flags;
2050: save_flags (flags);
2051: cli();
2052: if (!process_issue_queue_running) {
2053: process_issue_queue_running = 1;
2054: process_issue_queue(flags);
2055: /*
2056: * process_issue_queue_running is cleared in process_issue_queue
2057: * once it can't do more work, and process_issue_queue exits with
2058: * interrupts disabled.
2059: */
2060: }
2061: restore_flags (flags);
2062: }
2063:
2064: /*
2065: * Function : static void abnormal_finished (struct NCR53c7x0_cmd *cmd, int
2066: * result)
2067: *
2068: * Purpose : mark SCSI command as finished, OR'ing the host portion
2069: * of the result word into the result field of the corresponding
2070: * Scsi_Cmnd structure, and removing it from the internal queues.
2071: *
2072: * Inputs : cmd - command, result - entire result field
2073: *
2074: * Preconditions : the NCR chip should be in a halted state when
2075: * abnormal_finished is run, since it modifies structures which
2076: * the NCR expects to have exclusive access to.
2077: */
2078:
2079: static void
2080: abnormal_finished (struct NCR53c7x0_cmd *cmd, int result) {
2081: Scsi_Cmnd *c = cmd->cmd;
2082: struct Scsi_Host *host = c->host;
2083: struct NCR53c7x0_hostdata *hostdata = (struct NCR53c7x0_hostdata *)
2084: host->hostdata;
2085: unsigned long flags;
2086: int left, found;
2087: volatile struct NCR53c7x0_cmd * linux_search;
2088: volatile struct NCR53c7x0_cmd * volatile *linux_prev;
2089: volatile u32 *ncr_prev, *current, ncr_search;
2090:
2091: #if 0
2092: printk ("scsi%d: abnormal finished\n", host->host_no);
2093: #endif
2094:
2095: save_flags(flags);
2096: cli();
2097: found = 0;
2098: /*
2099: * Traverse the NCR issue array until we find a match or run out
2100: * of instructions. Instructions in the NCR issue array are
2101: * either JUMP or NOP instructions, which are 2 words in length.
2102: */
2103:
2104:
2105: for (found = 0, left = host->can_queue, current = hostdata->schedule;
2106: left > 0; --left, current += 2)
2107: {
2108: if (issue_to_cmd (host, hostdata, (u32 *) current) == cmd)
2109: {
2110: current[0] = hostdata->NOP_insn;
2111: current[1] = 0xdeadbeef;
2112: ++found;
2113: break;
2114: }
2115: }
2116:
2117: /*
2118: * Traverse the NCR reconnect list of DSA structures until we find
2119: * a pointer to this dsa or have found too many command structures.
2120: * We let prev point at the next field of the previous element or
2121: * head of the list, so we don't do anything different for removing
2122: * the head element.
2123: */
2124:
2125: for (left = host->can_queue,
2126: ncr_search = hostdata->reconnect_dsa_head,
2127: ncr_prev = &hostdata->reconnect_dsa_head;
2128: left >= 0 && ncr_search &&
2129: ((char*)bus_to_virt(ncr_search) + hostdata->dsa_start)
2130: != (char *) cmd->dsa;
2131: ncr_prev = (u32*) ((char*)bus_to_virt(ncr_search) +
2132: hostdata->dsa_next), ncr_search = *ncr_prev, --left);
2133:
2134: if (left < 0)
2135: printk("scsi%d: loop detected in ncr reonncect list\n",
2136: host->host_no);
2137: else if (ncr_search)
2138: if (found)
2139: printk("scsi%d: scsi %ld in ncr issue array and reconnect lists\n",
2140: host->host_no, c->pid);
2141: else {
2142: volatile u32 * next = (u32 *)
2143: ((char *)bus_to_virt(ncr_search) + hostdata->dsa_next);
2144: *ncr_prev = *next;
2145: /* If we're at the tail end of the issue queue, update that pointer too. */
2146: found = 1;
2147: }
2148:
2149: /*
2150: * Traverse the host running list until we find this command or discover
2151: * we have too many elements, pointing linux_prev at the next field of the
2152: * linux_previous element or head of the list, search at this element.
2153: */
2154:
2155: for (left = host->can_queue, linux_search = hostdata->running_list,
2156: linux_prev = &hostdata->running_list;
2157: left >= 0 && linux_search && linux_search != cmd;
2158: linux_prev = &(linux_search->next),
2159: linux_search = linux_search->next, --left);
2160:
2161: if (left < 0)
2162: printk ("scsi%d: loop detected in host running list for scsi pid %ld\n",
2163: host->host_no, c->pid);
2164: else if (linux_search) {
2165: *linux_prev = linux_search->next;
2166: --hostdata->busy[c->target][c->lun];
2167: }
2168:
2169: /* Return the NCR command structure to the free list */
2170: cmd->next = hostdata->free;
2171: hostdata->free = cmd;
2172: c->host_scribble = NULL;
2173:
2174: /* And return */
2175: c->result = result;
2176: c->scsi_done(c);
2177:
2178: restore_flags(flags);
2179: run_process_issue_queue();
2180: }
2181:
2182: /*
2183: * Function : static void intr_break (struct Scsi_Host *host,
2184: * struct NCR53c7x0_cmd *cmd)
2185: *
2186: * Purpose : Handler for breakpoint interrupts from a SCSI script
2187: *
2188: * Inputs : host - pointer to this host adapter's structure,
2189: * cmd - pointer to the command (if any) dsa was pointing
2190: * to.
2191: *
2192: */
2193:
2194: static void
2195: intr_break (struct Scsi_Host *host, struct
2196: NCR53c7x0_cmd *cmd) {
2197: NCR53c7x0_local_declare();
2198: struct NCR53c7x0_break *bp;
2199: #if 0
2200: Scsi_Cmnd *c = cmd ? cmd->cmd : NULL;
2201: #endif
2202: u32 *dsp;
2203: struct NCR53c7x0_hostdata *hostdata = (struct NCR53c7x0_hostdata *)
2204: host->hostdata;
2205: unsigned long flags;
2206: NCR53c7x0_local_setup(host);
2207:
2208: /*
2209: * Find the break point corresponding to this address, and
2210: * dump the appropriate debugging information to standard
2211: * output.
2212: */
2213: save_flags(flags);
2214: cli();
2215: dsp = (u32 *) bus_to_virt(NCR53c7x0_read32(DSP_REG));
2216: for (bp = hostdata->breakpoints; bp && bp->address != dsp;
2217: bp = bp->next);
2218: if (!bp)
2219: panic("scsi%d : break point interrupt from %p with no breakpoint!",
2220: host->host_no, dsp);
2221:
2222: /*
2223: * Configure the NCR chip for manual start mode, so that we can
2224: * point the DSP register at the instruction that follows the
2225: * INT int_debug_break instruction.
2226: */
2227:
2228: NCR53c7x0_write8 (hostdata->dmode,
2229: NCR53c7x0_read8(hostdata->dmode)|DMODE_MAN);
2230:
2231: /*
2232: * And update the DSP register, using the size of the old
2233: * instruction in bytes.
2234: */
2235:
2236: restore_flags(flags);
2237: }
2238: /*
2239: * Function : static void print_synchronous (const char *prefix,
2240: * const unsigned char *msg)
2241: *
2242: * Purpose : print a pretty, user and machine parsable representation
2243: * of a SDTR message, including the "real" parameters, data
2244: * clock so we can tell transfer rate at a glance.
2245: *
2246: * Inputs ; prefix - text to prepend, msg - SDTR message (5 bytes)
2247: */
2248:
2249: static void
2250: print_synchronous (const char *prefix, const unsigned char *msg) {
2251: if (msg[4]) {
2252: int Hz = 1000000000 / (msg[3] * 4);
2253: int integer = Hz / 1000000;
2254: int fraction = (Hz - (integer * 1000000)) / 10000;
2255: printk ("%speriod %dns offset %d %d.%02dMHz %s SCSI%s\n",
2256: prefix, (int) msg[3] * 4, (int) msg[4], integer, fraction,
2257: (((msg[3] * 4) < 200) ? "FAST" : "synchronous"),
2258: (((msg[3] * 4) < 200) ? "-II" : ""));
2259: } else
2260: printk ("%sasynchronous SCSI\n", prefix);
2261: }
2262:
2263: /*
2264: * Function : static void set_synchronous (struct Scsi_Host *host,
2265: * int target, int sxfer, int scntl3, int now_connected)
2266: *
2267: * Purpose : reprogram transfers between the selected SCSI initiator and
2268: * target with the given register values; in the indirect
2269: * select operand, reselection script, and chip registers.
2270: *
2271: * Inputs : host - NCR53c7,8xx SCSI host, target - number SCSI target id,
2272: * sxfer and scntl3 - NCR registers. now_connected - if non-zero,
2273: * we should reprogram the registers now too.
2274: */
2275:
2276: static void
2277: set_synchronous (struct Scsi_Host *host, int target, int sxfer, int scntl3,
2278: int now_connected) {
2279: NCR53c7x0_local_declare();
2280: struct NCR53c7x0_hostdata *hostdata = (struct NCR53c7x0_hostdata *)
2281: host->hostdata;
2282: u32 *script;
2283: NCR53c7x0_local_setup(host);
2284:
2285: /* These are eight bit registers */
2286: sxfer &= 0xff;
2287: scntl3 &= 0xff;
2288:
2289: hostdata->sync[target].sxfer_sanity = sxfer;
2290: hostdata->sync[target].scntl3_sanity = scntl3;
2291:
2292: /*
2293: * HARD CODED : synchronous script is EIGHT words long. This
2294: * must agree with 53c7.8xx.h
2295: */
2296:
2297: if ((hostdata->chip != 700) && (hostdata->chip != 70066)) {
2298: hostdata->sync[target].select_indirect = (scntl3 << 24) |
2299: (target << 16) | (sxfer << 8);
2300:
2301: script = (u32 *) hostdata->sync[target].script;
2302:
2303: /* XXX - add NCR53c7x0 code to reprogram SCF bits if we want to */
2304: if ((hostdata->chip / 100) == 8) {
2305: script[0] = ((DCMD_TYPE_RWRI | DCMD_RWRI_OPC_MODIFY |
2306: DCMD_RWRI_OP_MOVE) << 24) |
2307: (SCNTL3_REG_800 << 16) | (scntl3 << 8);
2308: script[1] = 0;
2309: script += 2;
2310: }
2311:
2312: script[0] = ((DCMD_TYPE_RWRI | DCMD_RWRI_OPC_MODIFY |
2313: DCMD_RWRI_OP_MOVE) << 24) |
2314: (SXFER_REG << 16) | (sxfer << 8);
2315: script[1] = 0;
2316: script += 2;
2317:
2318: #ifdef DEBUG_SYNC_INTR
2319: if (hostdata->options & OPTION_DEBUG_DISCONNECT) {
2320: script[0] = ((DCMD_TYPE_TCI|DCMD_TCI_OP_INT) << 24) | DBC_TCI_TRUE;
2321: script[1] = DEBUG_SYNC_INTR;
2322: script += 2;
2323: }
2324: #endif
2325:
2326: script[0] = ((DCMD_TYPE_TCI|DCMD_TCI_OP_RETURN) << 24) | DBC_TCI_TRUE;
2327: script[1] = 0;
2328: script += 2;
2329: }
2330:
2331: if (hostdata->options & OPTION_DEBUG_SYNCHRONOUS)
2332: printk ("scsi%d : target %d sync parameters are sxfer=0x%x, scntl3=0x%x\n",
2333: host->host_no, target, sxfer, scntl3);
2334:
2335: if (now_connected) {
2336: if ((hostdata->chip / 100) == 8)
2337: NCR53c7x0_write8(SCNTL3_REG_800, scntl3);
2338: NCR53c7x0_write8(SXFER_REG, sxfer);
2339: }
2340: }
2341:
2342:
2343: /*
2344: * Function : static int asynchronous (struct Scsi_Host *host, int target)
2345: *
2346: * Purpose : reprogram between the selected SCSI Host adapter and target
2347: * (assumed to be currently connected) for asynchronous transfers.
2348: *
2349: * Inputs : host - SCSI host structure, target - numeric target ID.
2350: *
2351: * Preconditions : the NCR chip should be in one of the halted states
2352: */
2353:
2354: static void
2355: asynchronous (struct Scsi_Host *host, int target) {
2356: NCR53c7x0_local_declare();
2357: struct NCR53c7x0_hostdata *hostdata = (struct NCR53c7x0_hostdata *)
2358: host->hostdata;
2359: NCR53c7x0_local_setup(host);
2360: set_synchronous (host, target, /* no offset */ 0, hostdata->saved_scntl3,
2361: 1);
2362: printk ("scsi%d : setting target %d to asynchronous SCSI\n",
2363: host->host_no, target);
2364: }
2365:
2366: /*
2367: * XXX - do we want to go out of our way (ie, add extra code to selection
2368: * in the NCR53c710/NCR53c720 script) to reprogram the synchronous
2369: * conversion bits, or can we be content in just setting the
2370: * sxfer bits?
2371: */
2372:
2373: /* Table for NCR53c8xx synchronous values */
2374: static const struct {
2375: int div; /* Total clock divisor * 10 */
2376: unsigned char scf; /* */
2377: unsigned char tp; /* 4 + tp = xferp divisor */
2378: } syncs[] = {
2379: /* div scf tp div scf tp div scf tp */
2380: { 40, 1, 0}, { 50, 1, 1}, { 60, 1, 2},
2381: { 70, 1, 3}, { 75, 2, 1}, { 80, 1, 4},
2382: { 90, 1, 5}, { 100, 1, 6}, { 105, 2, 3},
2383: { 110, 1, 7}, { 120, 2, 4}, { 135, 2, 5},
2384: { 140, 3, 3}, { 150, 2, 6}, { 160, 3, 4},
2385: { 165, 2, 7}, { 180, 3, 5}, { 200, 3, 6},
2386: { 210, 4, 3}, { 220, 3, 7}, { 240, 4, 4},
2387: { 270, 4, 5}, { 300, 4, 6}, { 330, 4, 7}
2388: };
2389:
2390: /*
2391: * Function : static void synchronous (struct Scsi_Host *host, int target,
2392: * char *msg)
2393: *
2394: * Purpose : reprogram transfers between the selected SCSI initiator and
2395: * target for synchronous SCSI transfers such that the synchronous
2396: * offset is less than that requested and period at least as long
2397: * as that requested. Also modify *msg such that it contains
2398: * an appropriate response.
2399: *
2400: * Inputs : host - NCR53c7,8xx SCSI host, target - number SCSI target id,
2401: * msg - synchronous transfer request.
2402: */
2403:
2404:
2405: static void
2406: synchronous (struct Scsi_Host *host, int target, char *msg) {
2407: struct NCR53c7x0_hostdata *hostdata = (struct NCR53c7x0_hostdata *)
2408: host->hostdata;
2409: int desire, divisor, i, limit;
2410: unsigned char scntl3, sxfer;
2411: /* The diagnostic message fits on one line, even with max. width integers */
2412: char buf[80];
2413:
2414: /* Desired transfer clock in Hz */
2415: desire = 1000000000L / (msg[3] * 4);
2416: /* Scale the available SCSI clock by 10 so we get tenths */
2417: divisor = (hostdata->scsi_clock * 10) / desire;
2418:
2419: /* NCR chips can handle at most an offset of 8 */
2420: if (msg[4] > 8)
2421: msg[4] = 8;
2422:
2423: if (hostdata->options & OPTION_DEBUG_SDTR)
2424: printk("scsi%d : optimal synchronous divisor of %d.%01d\n",
2425: host->host_no, divisor / 10, divisor % 10);
2426:
2427: limit = (sizeof(syncs) / sizeof(syncs[0]) -1);
2428: for (i = 0; (i < limit) && (divisor > syncs[i].div); ++i);
2429:
2430: if (hostdata->options & OPTION_DEBUG_SDTR)
2431: printk("scsi%d : selected synchronous divisor of %d.%01d\n",
2432: host->host_no, syncs[i].div / 10, syncs[i].div % 10);
2433:
2434: msg[3] = ((1000000000L / hostdata->scsi_clock) * syncs[i].div / 10 / 4);
2435:
2436: if (hostdata->options & OPTION_DEBUG_SDTR)
2437: printk("scsi%d : selected synchronous period of %dns\n", host->host_no,
2438: msg[3] * 4);
2439:
2440: scntl3 = (hostdata->chip / 100 == 8) ? ((hostdata->saved_scntl3 &
2441: ~SCNTL3_800_SCF_MASK) | (syncs[i].scf << SCNTL3_800_SCF_SHIFT)) : 0;
2442: sxfer = (msg[4] << SXFER_MO_SHIFT) | ((syncs[i].tp) << SXFER_TP_SHIFT);
2443: if (hostdata->options & OPTION_DEBUG_SDTR)
2444: printk ("scsi%d : sxfer=0x%x scntl3=0x%x\n",
2445: host->host_no, (int) sxfer, (int) scntl3);
2446: set_synchronous (host, target, sxfer, scntl3, 1);
2447: sprintf (buf, "scsi%d : setting target %d to ", host->host_no, target);
2448: print_synchronous (buf, msg);
2449: }
2450:
2451: /*
2452: * Function : static int NCR53c8x0_dstat_sir_intr (struct Scsi_Host *host,
2453: * struct NCR53c7x0_cmd *cmd)
2454: *
2455: * Purpose : Handler for INT generated instructions for the
2456: * NCR53c810/820 SCSI SCRIPT
2457: *
2458: * Inputs : host - pointer to this host adapter's structure,
2459: * cmd - pointer to the command (if any) dsa was pointing
2460: * to.
2461: *
2462: */
2463:
2464: static int
2465: NCR53c8x0_dstat_sir_intr (struct Scsi_Host *host, struct
2466: NCR53c7x0_cmd *cmd) {
2467: NCR53c7x0_local_declare();
2468: int print;
2469: Scsi_Cmnd *c = cmd ? cmd->cmd : NULL;
2470: struct NCR53c7x0_hostdata *hostdata = (struct NCR53c7x0_hostdata *)
2471: host->hostdata;
2472: u32 dsps,*dsp; /* Argument of the INT instruction */
2473: NCR53c7x0_local_setup(host);
2474: dsps = NCR53c7x0_read32(DSPS_REG);
2475: dsp = (u32 *) bus_to_virt(NCR53c7x0_read32(DSP_REG));
2476:
2477: if (hostdata->options & OPTION_DEBUG_INTR)
2478: printk ("scsi%d : DSPS = 0x%x\n", host->host_no, dsps);
2479:
2480: switch (dsps) {
2481: case A_int_msg_1:
2482: print = 1;
2483: switch (hostdata->msg_buf[0]) {
2484: /*
2485: * Unless we've initiated synchronous negotiation, I don't
2486: * think that this should happen.
2487: */
2488: case MESSAGE_REJECT:
2489: hostdata->dsp = hostdata->script + hostdata->E_accept_message /
2490: sizeof(u32);
2491: hostdata->dsp_changed = 1;
2492: if (cmd && (cmd->flags & CMD_FLAG_SDTR)) {
2493: printk ("scsi%d : target %d rejected SDTR\n", host->host_no,
2494: c->target);
2495: cmd->flags &= ~CMD_FLAG_SDTR;
2496: asynchronous (host, c->target);
2497: print = 0;
2498: }
2499: break;
2500: case INITIATE_RECOVERY:
2501: printk ("scsi%d : extended contingent allegiance not supported yet, rejecting\n",
2502: host->host_no);
2503: /* Fall through to default */
2504: hostdata->dsp = hostdata->script + hostdata->E_reject_message /
2505: sizeof(u32);
2506: hostdata->dsp_changed = 1;
2507: break;
2508: default:
2509: printk ("scsi%d : unsupported message, resjecting\n",
2510: host->host_no);
2511: hostdata->dsp = hostdata->script + hostdata->E_reject_message /
2512: sizeof(u32);
2513: hostdata->dsp_changed = 1;
2514: }
2515: if (print) {
2516: printk ("scsi%d : received message", host->host_no);
2517: if (c)
2518: printk (" from target %d lun %d ", c->target, c->lun);
2519: print_msg ((unsigned char *) hostdata->msg_buf);
2520: printk("\n");
2521: }
2522:
2523: return SPECIFIC_INT_NOTHING;
2524:
2525:
2526: case A_int_msg_sdtr:
2527: /*
2528: * At this point, hostdata->msg_buf contains
2529: * 0 EXTENDED MESSAGE
2530: * 1 length
2531: * 2 SDTR
2532: * 3 period * 4ns
2533: * 4 offset
2534: */
2535:
2536: if (cmd) {
2537: char buf[80];
2538: sprintf (buf, "scsi%d : target %d %s ", host->host_no, c->target,
2539: (cmd->flags & CMD_FLAG_SDTR) ? "accepting" : "requesting");
2540: print_synchronous (buf, (unsigned char *) hostdata->msg_buf);
2541:
2542: /*
2543: * Initiator initiated, won't happen unless synchronous
2544: * transfers are enabled. If we get a SDTR message in
2545: * response to our SDTR, we should program our parameters
2546: * such that
2547: * offset <= requested offset
2548: * period >= requested period
2549: */
2550: if (cmd->flags & CMD_FLAG_SDTR) {
2551: cmd->flags &= ~CMD_FLAG_SDTR;
2552: if (hostdata->msg_buf[4])
2553: synchronous (host, c->target, (unsigned char *)
2554: hostdata->msg_buf);
2555: else
2556: asynchronous (host, c->target);
2557: hostdata->dsp = hostdata->script + hostdata->E_accept_message /
2558: sizeof(u32);
2559: hostdata->dsp_changed = 1;
2560: return SPECIFIC_INT_NOTHING;
2561: } else {
2562: if (hostdata->options & OPTION_SYNCHRONOUS) {
2563: cmd->flags |= CMD_FLAG_DID_SDTR;
2564: synchronous (host, c->target, (unsigned char *)
2565: hostdata->msg_buf);
2566: } else {
2567: hostdata->msg_buf[4] = 0; /* 0 offset = async */
2568: asynchronous (host, c->target);
2569: }
2570: patch_dsa_32 (cmd->dsa, dsa_msgout_other, 0, 5);
2571: patch_dsa_32 (cmd->dsa, dsa_msgout_other, 1, (u32)
2572: virt_to_bus ((void *)&hostdata->msg_buf));
2573: hostdata->dsp = hostdata->script +
2574: hostdata->E_respond_message / sizeof(u32);
2575: hostdata->dsp_changed = 1;
2576: }
2577: return SPECIFIC_INT_NOTHING;
2578: }
2579: /* Fall through to abort if we couldn't find a cmd, and
2580: therefore a dsa structure to twiddle */
2581: case A_int_msg_wdtr:
2582: hostdata->dsp = hostdata->script + hostdata->E_reject_message /
2583: sizeof(u32);
2584: hostdata->dsp_changed = 1;
2585: return SPECIFIC_INT_NOTHING;
2586: case A_int_err_unexpected_phase:
2587: if (hostdata->options & OPTION_DEBUG_INTR)
2588: printk ("scsi%d : unexpected phase\n", host->host_no);
2589: return SPECIFIC_INT_ABORT;
2590: case A_int_err_selected:
2591: printk ("scsi%d : selected by target %d\n", host->host_no,
2592: (int) NCR53c7x0_read8(SDID_REG_800) &7);
2593: hostdata->dsp = hostdata->script + hostdata->E_target_abort /
2594: sizeof(u32);
2595: hostdata->dsp_changed = 1;
2596: return SPECIFIC_INT_NOTHING;
2597: case A_int_err_unexpected_reselect:
2598: printk ("scsi%d : unexpected reselect by target %d lun %d\n",
2599: host->host_no, (int) NCR53c7x0_read8(SDID_REG_800) & 7,
2600: hostdata->reselected_identify & 7);
2601: hostdata->dsp = hostdata->script + hostdata->E_initiator_abort /
2602: sizeof(u32);
2603: hostdata->dsp_changed = 1;
2604: return SPECIFIC_INT_NOTHING;
2605: /*
2606: * Since contingent allegiance conditions are cleared by the next
2607: * command issued to a target, we must issue a REQUEST SENSE
2608: * command after receiving a CHECK CONDITION status, before
2609: * another command is issued.
2610: *
2611: * Since this NCR53c7x0_cmd will be freed after use, we don't
2612: * care if we step on the various fields, so modify a few things.
2613: */
2614: case A_int_err_check_condition:
2615: #if 0
2616: if (hostdata->options & OPTION_DEBUG_INTR)
2617: #endif
2618: printk ("scsi%d : CHECK CONDITION\n", host->host_no);
2619: if (!c) {
2620: printk("scsi%d : CHECK CONDITION with no SCSI command\n",
2621: host->host_no);
2622: return SPECIFIC_INT_PANIC;
2623: }
2624:
2625: /*
2626: * FIXME : this uses the normal one-byte selection message.
2627: * We may want to renegotiate for synchronous & WIDE transfers
2628: * since these could be the crux of our problem.
2629: *
2630: hostdata->NOP_insn* FIXME : once SCSI-II tagged queuing is implemented, we'll
2631: * have to set this up so that the rest of the DSA
2632: * agrees with this being an untagged queue'd command.
2633: */
2634:
2635: patch_dsa_32 (cmd->dsa, dsa_msgout, 0, 1);
2636:
2637: /*
2638: * Modify the table indirect for COMMAND OUT phase, since
2639: * Request Sense is a six byte command.
2640: */
2641:
2642: patch_dsa_32 (cmd->dsa, dsa_cmdout, 0, 6);
2643:
2644: c->cmnd[0] = REQUEST_SENSE;
2645: c->cmnd[1] &= 0xe0; /* Zero all but LUN */
2646: c->cmnd[2] = 0;
2647: c->cmnd[3] = 0;
2648: c->cmnd[4] = sizeof(c->sense_buffer);
2649: c->cmnd[5] = 0;
2650:
2651: /*
2652: * Disable dataout phase, and program datain to transfer to the
2653: * sense buffer, and add a jump to other_transfer after the
2654: * command so overflow/underrun conditions are detected.
2655: */
2656:
2657: patch_dsa_32 (cmd->dsa, dsa_dataout, 0,
2658: virt_to_bus(hostdata->script) + hostdata->E_other_transfer);
2659: patch_dsa_32 (cmd->dsa, dsa_datain, 0,
2660: virt_to_bus(cmd->data_transfer_start));
2661: cmd->data_transfer_start[0] = (((DCMD_TYPE_BMI | DCMD_BMI_OP_MOVE_I |
2662: DCMD_BMI_IO)) << 24) | sizeof(c->sense_buffer);
2663: cmd->data_transfer_start[1] = (u32) virt_to_bus(c->sense_buffer);
2664:
2665: cmd->data_transfer_start[2] = ((DCMD_TYPE_TCI | DCMD_TCI_OP_JUMP)
2666: << 24) | DBC_TCI_TRUE;
2667: cmd->data_transfer_start[3] = (u32) virt_to_bus(hostdata->script) +
2668: hostdata->E_other_transfer;
2669:
2670: /*
2671: * Currently, this command is flagged as completed, ie
2672: * it has valid status and message data. Reflag it as
2673: * incomplete. Q - need to do something so that original
2674: * status, etc are used.
2675: */
2676:
2677: cmd->cmd->result = 0xffff;
2678:
2679: /*
2680: * Restart command as a REQUEST SENSE.
2681: */
2682: hostdata->dsp = (u32 *) hostdata->script + hostdata->E_select /
2683: sizeof(u32);
2684: hostdata->dsp_changed = 1;
2685: return SPECIFIC_INT_NOTHING;
2686: case A_int_debug_break:
2687: return SPECIFIC_INT_BREAK;
2688: case A_int_norm_aborted:
2689: hostdata->dsp = (u32 *) hostdata->schedule;
2690: hostdata->dsp_changed = 1;
2691: if (cmd)
2692: abnormal_finished (cmd, DID_ERROR << 16);
2693: return SPECIFIC_INT_NOTHING;
2694: case A_int_test_1:
2695: case A_int_test_2:
2696: hostdata->idle = 1;
2697: hostdata->test_completed = (dsps - A_int_test_1) / 0x00010000 + 1;
2698: if (hostdata->options & OPTION_DEBUG_INTR)
2699: printk("scsi%d : test%d complete\n", host->host_no,
2700: hostdata->test_completed);
2701: return SPECIFIC_INT_NOTHING;
2702: #ifdef A_int_debug_reselected_ok
2703: case A_int_debug_reselected_ok:
2704: if (hostdata->options & (OPTION_DEBUG_SCRIPT|OPTION_DEBUG_INTR|
2705: OPTION_DEBUG_DISCONNECT)) {
2706: /*
2707: * Note - this dsa is not based on location relative to
2708: * the command structure, but to location relative to the
2709: * DSA register
2710: */
2711: u32 *dsa;
2712: dsa = (u32 *) bus_to_virt (NCR53c7x0_read32(DSA_REG));
2713:
2714: printk("scsi%d : reselected_ok (DSA = 0x%x (virt 0x%p)\n",
2715: host->host_no, NCR53c7x0_read32(DSA_REG), dsa);
2716: printk("scsi%d : resume address is 0x%x (virt 0x%p)\n",
2717: host->host_no, cmd->saved_data_pointer,
2718: bus_to_virt(cmd->saved_data_pointer));
2719: print_insn (host, hostdata->script + Ent_reselected_ok /
2720: sizeof(u32), "", 1);
2721: printk ("scsi%d : sxfer=0x%x, scntl3=0x%x\n",
2722: host->host_no, NCR53c7x0_read8(SXFER_REG),
2723: NCR53c7x0_read8(SCNTL3_REG_800));
2724: if (c) {
2725: print_insn (host, (u32 *)
2726: hostdata->sync[c->target].script, "", 1);
2727: print_insn (host, (u32 *)
2728: hostdata->sync[c->target].script + 2, "", 1);
2729: }
2730: }
2731: return SPECIFIC_INT_RESTART;
2732: #endif
2733: #ifdef A_int_debug_reselect_check
2734: case A_int_debug_reselect_check:
2735: if (hostdata->options & (OPTION_DEBUG_SCRIPT|OPTION_DEBUG_INTR)) {
2736: u32 *dsa;
2737: #if 0
2738: u32 *code;
2739: #endif
2740: /*
2741: * Note - this dsa is not based on location relative to
2742: * the command structure, but to location relative to the
2743: * DSA register
2744: */
2745: dsa = bus_to_virt (NCR53c7x0_read32(DSA_REG));
2746: printk("scsi%d : reselected_check_next (DSA = 0x%lx (virt 0x%p))\n",
2747: host->host_no, virt_to_bus(dsa), dsa);
2748: if (dsa) {
2749: printk("scsi%d : resume address is 0x%x (virt 0x%p)\n",
2750: host->host_no, cmd->saved_data_pointer,
2751: bus_to_virt (cmd->saved_data_pointer));
2752: #if 0
2753: printk("scsi%d : template code :\n", host->host_no);
2754: for (code = dsa + (Ent_dsa_code_check_reselect - Ent_dsa_zero)
2755: / sizeof(u32); code < (dsa + Ent_dsa_zero / sizeof(u32));
2756: code += print_insn (host, code, "", 1));
2757: #endif
2758: }
2759: print_insn (host, hostdata->script + Ent_reselected_ok /
2760: sizeof(u32), "", 1);
2761: }
2762: return SPECIFIC_INT_RESTART;
2763: #endif
2764: #ifdef A_int_debug_dsa_schedule
2765: case A_int_debug_dsa_schedule:
2766: if (hostdata->options & (OPTION_DEBUG_SCRIPT|OPTION_DEBUG_INTR)) {
2767: u32 *dsa;
2768: /*
2769: * Note - this dsa is not based on location relative to
2770: * the command structure, but to location relative to the
2771: * DSA register
2772: */
2773: dsa = (u32 *) bus_to_virt (NCR53c7x0_read32(DSA_REG));
2774: printk("scsi%d : dsa_schedule (old DSA = 0x%lx (virt 0x%p))\n",
2775: host->host_no, virt_to_bus(dsa), dsa);
2776: if (dsa)
2777: printk("scsi%d : resume address is 0x%x (virt 0x%p)\n"
2778: " (temp was 0x%x (virt 0x%p))\n",
2779: host->host_no, cmd->saved_data_pointer,
2780: bus_to_virt (cmd->saved_data_pointer),
2781: NCR53c7x0_read32 (TEMP_REG),
2782: bus_to_virt (NCR53c7x0_read32(TEMP_REG)));
2783: }
2784: return SPECIFIC_INT_RESTART;
2785: #endif
2786: #ifdef A_int_debug_scheduled
2787: case A_int_debug_scheduled:
2788: if (hostdata->options & (OPTION_DEBUG_SCRIPT|OPTION_DEBUG_INTR)) {
2789: printk("scsi%d : new I/O 0x%x (virt 0x%p) scheduled\n",
2790: host->host_no, NCR53c7x0_read32(DSA_REG),
2791: bus_to_virt(NCR53c7x0_read32(DSA_REG)));
2792: }
2793: return SPECIFIC_INT_RESTART;
2794: #endif
2795: #ifdef A_int_debug_idle
2796: case A_int_debug_idle:
2797: if (hostdata->options & (OPTION_DEBUG_SCRIPT|OPTION_DEBUG_INTR)) {
2798: printk("scsi%d : idle\n", host->host_no);
2799: }
2800: return SPECIFIC_INT_RESTART;
2801: #endif
2802: #ifdef A_int_debug_cmd
2803: case A_int_debug_cmd:
2804: if (hostdata->options & (OPTION_DEBUG_SCRIPT|OPTION_DEBUG_INTR)) {
2805: printk("scsi%d : command sent\n");
2806: }
2807: return SPECIFIC_INT_RESTART;
2808: #endif
2809: #ifdef A_int_debug_dsa_loaded
2810: case A_int_debug_dsa_loaded:
2811: if (hostdata->options & (OPTION_DEBUG_SCRIPT|OPTION_DEBUG_INTR)) {
2812: printk("scsi%d : DSA loaded with 0x%x (virt 0x%p)\n", host->host_no,
2813: NCR53c7x0_read32(DSA_REG),
2814: bus_to_virt(NCR53c7x0_read32(DSA_REG)));
2815: }
2816: return SPECIFIC_INT_RESTART;
2817: #endif
2818: #ifdef A_int_debug_reselected
2819: case A_int_debug_reselected:
2820: if (hostdata->options & (OPTION_DEBUG_SCRIPT|OPTION_DEBUG_INTR|
2821: OPTION_DEBUG_DISCONNECT)) {
2822: printk("scsi%d : reselected by target %d lun %d\n",
2823: host->host_no, (int) NCR53c7x0_read8(SDID_REG_800) & ~0x80,
2824: (int) hostdata->reselected_identify & 7);
2825: print_queues(host);
2826: }
2827: return SPECIFIC_INT_RESTART;
2828: #endif
2829: #ifdef A_int_debug_disconnect_msg
2830: case A_int_debug_disconnect_msg:
2831: if (hostdata->options & (OPTION_DEBUG_SCRIPT|OPTION_DEBUG_INTR)) {
2832: if (c)
2833: printk("scsi%d : target %d lun %d disconnecting\n",
2834: host->host_no, c->target, c->lun);
2835: else
2836: printk("scsi%d : unknown target disconnecting\n",
2837: host->host_no);
2838: }
2839: return SPECIFIC_INT_RESTART;
2840: #endif
2841: #ifdef A_int_debug_disconnected
2842: case A_int_debug_disconnected:
2843: if (hostdata->options & (OPTION_DEBUG_SCRIPT|OPTION_DEBUG_INTR|
2844: OPTION_DEBUG_DISCONNECT)) {
2845: printk ("scsi%d : disconnected, new queues are\n",
2846: host->host_no);
2847: print_queues(host);
2848: #if 0
2849: printk ("scsi%d : sxfer=0x%x, scntl3=0x%x\n",
2850: host->host_no, NCR53c7x0_read8(SXFER_REG),
2851: NCR53c7x0_read8(SCNTL3_REG_800));
2852: #endif
2853: if (c) {
2854: print_insn (host, (u32 *)
2855: hostdata->sync[c->target].script, "", 1);
2856: print_insn (host, (u32 *)
2857: hostdata->sync[c->target].script + 2, "", 1);
2858: }
2859: }
2860: return SPECIFIC_INT_RESTART;
2861: #endif
2862: #ifdef A_int_debug_panic
2863: case A_int_debug_panic:
2864: printk("scsi%d : int_debug_panic received\n", host->host_no);
2865: print_lots (host);
2866: return SPECIFIC_INT_PANIC;
2867: #endif
2868: #ifdef A_int_debug_saved
2869: case A_int_debug_saved:
2870: if (hostdata->options & (OPTION_DEBUG_SCRIPT|OPTION_DEBUG_INTR|
2871: OPTION_DEBUG_DISCONNECT)) {
2872: printk ("scsi%d : saved data pointer 0x%x (virt 0x%p)\n",
2873: host->host_no, cmd->saved_data_pointer,
2874: bus_to_virt (cmd->saved_data_pointer));
2875: print_progress (c);
2876: }
2877: return SPECIFIC_INT_RESTART;
2878: #endif
2879: #ifdef A_int_debug_restored
2880: case A_int_debug_restored:
2881: if (hostdata->options & (OPTION_DEBUG_SCRIPT|OPTION_DEBUG_INTR|
2882: OPTION_DEBUG_DISCONNECT)) {
2883: if (cmd) {
2884: int size;
2885: printk ("scsi%d : restored data pointer 0x%x (virt 0x%p)\n",
2886: host->host_no, cmd->saved_data_pointer, bus_to_virt (
2887: cmd->saved_data_pointer));
2888: size = print_insn (host, (u32 *)
2889: bus_to_virt(cmd->saved_data_pointer), "", 1);
2890: size = print_insn (host, (u32 *)
2891: bus_to_virt(cmd->saved_data_pointer) + size, "", 1);
2892: print_progress (c);
2893: }
2894: #if 0
2895: printk ("scsi%d : datapath residual %d\n",
2896: host->host_no, datapath_residual (host)) ;
2897: #endif
2898: }
2899: return SPECIFIC_INT_RESTART;
2900: #endif
2901: #ifdef A_int_debug_sync
2902: case A_int_debug_sync:
2903: if (hostdata->options & (OPTION_DEBUG_SCRIPT|OPTION_DEBUG_INTR|
2904: OPTION_DEBUG_DISCONNECT|OPTION_DEBUG_SDTR)) {
2905: unsigned char sxfer = NCR53c7x0_read8 (SXFER_REG),
2906: scntl3 = NCR53c7x0_read8 (SCNTL3_REG_800);
2907: if (c) {
2908: if (sxfer != hostdata->sync[c->target].sxfer_sanity ||
2909: scntl3 != hostdata->sync[c->target].scntl3_sanity) {
2910: printk ("scsi%d : sync sanity check failed sxfer=0x%x, scntl3=0x%x",
2911: host->host_no, sxfer, scntl3);
2912: NCR53c7x0_write8 (SXFER_REG, sxfer);
2913: NCR53c7x0_write8 (SCNTL3_REG_800, scntl3);
2914: }
2915: } else
2916: printk ("scsi%d : unknown command sxfer=0x%x, scntl3=0x%x\n",
2917: host->host_no, (int) sxfer, (int) scntl3);
2918: }
2919: return SPECIFIC_INT_RESTART;
2920: #endif
2921: #ifdef A_int_debug_datain
2922: case A_int_debug_datain:
2923: if (hostdata->options & (OPTION_DEBUG_SCRIPT|OPTION_DEBUG_INTR|
2924: OPTION_DEBUG_DISCONNECT|OPTION_DEBUG_SDTR)) {
2925: int size;
2926: printk ("scsi%d : In do_datain (%s) sxfer=0x%x, scntl3=0x%x\n"
2927: " datapath residual=%d\n",
2928: host->host_no, sbcl_to_phase (NCR53c7x0_read8 (SBCL_REG)),
2929: (int) NCR53c7x0_read8(SXFER_REG),
2930: (int) NCR53c7x0_read8(SCNTL3_REG_800),
2931: datapath_residual (host)) ;
2932: print_insn (host, dsp, "", 1);
2933: size = print_insn (host, (u32 *) bus_to_virt(dsp[1]), "", 1);
2934: print_insn (host, (u32 *) bus_to_virt(dsp[1]) + size, "", 1);
2935: }
2936: return SPECIFIC_INT_RESTART;
2937: #endif
2938: /*
2939: * FIXME : for 7xx support, we need to read SDID_REG_700 and handle
2940: * the comparison as bitfielded, not binary.
2941: */
2942: #ifdef A_int_debug_check_dsa
2943: case A_int_debug_check_dsa:
2944: if (NCR53c7x0_read8 (SCNTL1_REG) & SCNTL1_CON) {
2945: int sdid = NCR53c7x0_read8 (SDID_REG_800) & 15;
2946: char *where = dsp - NCR53c7x0_insn_size(NCR53c7x0_read8
2947: (DCMD_REG)) == hostdata->script +
2948: Ent_select_check_dsa / sizeof(u32) ?
2949: "selection" : "reselection";
2950: if (c && sdid != c->target) {
2951: printk ("scsi%d : SDID target %d != DSA target %d at %s\n",
2952: host->host_no, sdid, c->target, where);
2953: print_lots(host);
2954: dump_events (host, 20);
2955: return SPECIFIC_INT_PANIC;
2956: }
2957: }
2958: return SPECIFIC_INT_RESTART;
2959: #endif
2960: default:
2961: if ((dsps & 0xff000000) == 0x03000000) {
2962: printk ("scsi%d : misc debug interrupt 0x%x\n",
2963: host->host_no, dsps);
2964: return SPECIFIC_INT_RESTART;
2965: } else if ((dsps & 0xff000000) == 0x05000000) {
2966: if (hostdata->events) {
2967: struct NCR53c7x0_event *event;
2968: ++hostdata->event_index;
2969: if (hostdata->event_index >= hostdata->event_size)
2970: hostdata->event_index = 0;
2971: event = (struct NCR53c7x0_event *) hostdata->events +
2972: hostdata->event_index;
2973: event->event = (enum ncr_event) dsps;
2974: event->dsa = bus_to_virt(NCR53c7x0_read32(DSA_REG));
2975: /* FIXME : this needs to change for the '7xx family */
2976: if (NCR53c7x0_read8 (SCNTL1_REG) & SCNTL1_CON)
2977: event->target = NCR53c7x0_read8(SSID_REG_800);
2978: else
2979: event->target = 255;
2980:
2981: if (event->event == EVENT_RESELECT)
2982: event->lun = hostdata->reselected_identify & 0xf;
2983: else if (c)
2984: event->lun = c->lun;
2985: else
2986: event->lun = 255;
2987: do_gettimeofday(&(event->time));
2988: if (c) {
2989: event->pid = c->pid;
2990: memcpy ((void *) event->cmnd, (void *) c->cmnd,
2991: sizeof (event->cmnd));
2992: } else {
2993: event->pid = -1;
2994: }
2995: }
2996: return SPECIFIC_INT_RESTART;
2997: }
2998:
2999: printk ("scsi%d : unknown user interrupt 0x%x\n",
3000: host->host_no, (unsigned) dsps);
3001: return SPECIFIC_INT_PANIC;
3002: }
3003: }
3004:
3005: /*
3006: * XXX - the stock NCR assembler won't output the scriptu.h file,
3007: * which undefine's all #define'd CPP symbols from the script.h
3008: * file, which will create problems if you use multiple scripts
3009: * with the same symbol names.
3010: *
3011: * If you insist on using NCR's assembler, you could generate
3012: * scriptu.h from script.h using something like
3013: *
3014: * grep #define script.h | \
3015: * sed 's/#define[ ][ ]*\([_a-zA-Z][_a-zA-Z0-9]*\).*$/#undefine \1/' \
3016: * > scriptu.h
3017: */
3018:
3019: #include "53c8xx_u.h"
3020:
3021: /* XXX - add alternate script handling code here */
3022:
3023:
3024: #ifdef NCR_DEBUG
3025: /*
3026: * Debugging without a debugger is no fun. So, I've provided
3027: * a debugging interface in the NCR53c7x0 driver. To avoid
3028: * kernel cruft, there's just enough here to act as an interface
3029: * to a user level debugger (aka, GDB).
3030: *
3031: *
3032: * The following restrictions apply to debugger commands :
3033: * 1. The command must be terminated by a newline.
3034: * 2. Command length must be less than 80 bytes including the
3035: * newline.
3036: * 3. The entire command must be written with one system call.
3037: */
3038:
3039: static const char debugger_help =
3040: "bc <addr> - clear breakpoint\n"
3041: "bl - list breakpoints\n"
3042: "bs <addr> - set breakpoint\n"
3043: "g - start\n"
3044: "h - halt\n"
3045: "? - this message\n"
3046: "i - info\n"
3047: "mp <addr> <size> - print memory\n"
3048: "ms <addr> <size> <value> - store memory\n"
3049: "rp <num> <size> - print register\n"
3050: "rs <num> <size> <value> - store register\n"
3051: "s - single step\n"
3052: "tb - begin trace \n"
3053: "te - end trace\n";
3054:
3055: /*
3056: * Whenever we change a break point, we should probably
3057: * set the NCR up so that it is in a single step mode.
3058: */
3059:
3060: static int debugger_fn_bc (struct Scsi_Host *host, struct debugger_token *token,
3061: u32 args[]) {
3062: struct NCR53c7x0_hostdata *hostdata = (struct NCR53c7x0_hostdata *)
3063: instance->hostdata;
3064: struct NCR53c7x0_break *bp, **prev;
3065: unsigned long flags;
3066: save_flags(flags);
3067: cli();
3068: for (bp = (struct NCR53c7x0_break *) instance->breakpoints,
3069: prev = (struct NCR53c7x0_break **) &instance->breakpoints;
3070: bp; prev = (struct NCR53c7x0_break **) &(bp->next),
3071: bp = (struct NCR53c7x0_break *) bp->next);
3072:
3073: if (!bp) {
3074: restore_flags(flags);
3075: return -EIO;
3076: }
3077:
3078: /*
3079: * XXX - we need to insure that the processor is halted
3080: * here in order to prevent a race condition.
3081: */
3082:
3083: memcpy ((void *) bp->addr, (void *) bp->old, sizeof(bp->old));
3084: if (prev)
3085: *prev = bp->next;
3086:
3087: restore_flags(flags);
3088: return 0;
3089: }
3090:
3091:
3092: static int
3093: debugger_fn_bl (struct Scsi_Host *host, struct debugger_token *token,
3094: u32 args[]) {
3095: struct NCR53c7x0_hostdata *hostdata = (struct NCR53c7x0_hostdata *)
3096: host->hostdata;
3097: struct NCR53c7x0_break *bp;
3098: char buf[80];
3099: size_t len;
3100: unsigned long flags;
3101: /*
3102: * XXX - we need to insure that the processor is halted
3103: * here in order to prevent a race condition. So, if the
3104: * processor isn't halted, print an error message and continue.
3105: */
3106:
3107: sprintf (buf, "scsi%d : bp : warning : processor not halted\b",
3108: host->host_no);
3109: debugger_kernel_write (host, buf, strlen(buf));
3110:
3111: save_flags(flags);
3112: cli();
3113: for (bp = (struct NCR53c7x0_break *) host->breakpoints;
3114: bp; bp = (struct NCR53c7x0_break *) bp->next); {
3115: sprintf (buf, "scsi%d : bp : success : at %08x, replaces %08x %08x",
3116: bp->addr, bp->old[0], bp->old[1]);
3117: len = strlen(buf);
3118: if ((bp->old[0] & (DCMD_TYPE_MASK << 24)) ==
3119: (DCMD_TYPE_MMI << 24)) {
3120: sprintf(buf + len, "%08x\n", * (u32 *) bp->addr);
3121: } else {
3122: sprintf(buf + len, "\n");
3123: }
3124: len = strlen(buf);
3125: debugger_kernel_write (host, buf, len);
3126: }
3127: restore_flags(flags);
3128: return 0;
3129: }
3130:
3131: static int
3132: debugger_fn_bs (struct Scsi_Host *host, struct debugger_token *token,
3133: u32 args[]) {
3134: struct NCR53c7x0_hostdata *hostdata = (struct NCR53c7x0_hostdata *)
3135: host->hostdata;
3136: struct NCR53c7x0_break *bp;
3137: char buf[80];
3138: size_t len;
3139: unsigned long flags;
3140: save_flags(flags);
3141: cli();
3142:
3143: if (hostdata->state != STATE_HALTED) {
3144: sprintf (buf, "scsi%d : bs : failure : NCR not halted\n", host->host_no);
3145: debugger_kernel_write (host, buf, strlen(buf));
3146: restore_flags(flags);
3147: return -1;
3148: }
3149:
3150: if (!(bp = kmalloc (sizeof (struct NCR53c7x0_break)))) {
3151: printk ("scsi%d : kmalloc(%d) of breakpoint structure failed, try again\n",
3152: host->host_no, sizeof(struct NCR53c7x0_break));
3153: restore_flags(flags);
3154: return -1;
3155: }
3156:
3157: bp->address = (u32 *) args[0];
3158: memcpy ((void *) bp->old_instruction, (void *) bp->address, 8);
3159: bp->old_size = (((bp->old_instruction[0] >> 24) & DCMD_TYPE_MASK) ==
3160: DCMD_TYPE_MMI ? 3 : 2;
3161: bp->next = hostdata->breakpoints;
3162: hostdata->breakpoints = bp->next;
3163: memcpy ((void *) bp->address, (void *) hostdata->E_debug_break, 8);
3164:
3165: restore_flags(flags);
3166: return 0;
3167: }
3168:
3169: #define TOKEN(name,nargs) {#name, nargs, debugger_fn_##name}
3170: static const struct debugger_token {
3171: char *name;
3172: int numargs;
3173: int (*fn)(struct debugger_token *token, u32 args[]);
3174: } debugger_tokens[] = {
3175: TOKEN(bc,1), TOKEN(bl,0), TOKEN(bs,1), TOKEN(g,0), TOKEN(halt,0),
3176: {DT_help, "?", 0} , TOKEN(h,0), TOKEN(i,0), TOKEN(mp,2),
3177: TOKEN(ms,3), TOKEN(rp,2), TOKEN(rs,2), TOKEN(s,0), TOKEN(tb,0), TOKEN(te,0)
3178: };
3179:
3180: #define NDT sizeof(debugger_tokens / sizeof(struct debugger_token))
3181:
3182: static struct Scsi_Host * inode_to_host (struct inode *inode) {
3183: int dev;
3184: struct Scsi_Host *tmp;
3185: for (dev = MINOR(inode->rdev), host = first_host;
3186: (host->hostt == the_template); --dev, host = host->next)
3187: if (!dev) return host;
3188: return NULL;
3189: }
3190:
3191:
3192: static int
3193: debugger_user_write (struct inode *inode,struct file *filp,
3194: char *buf,int count) {
3195: struct Scsi_Host *host; /* This SCSI host */
3196: struct NCR53c7x0_hostadata *hostdata;
3197: char input_buf[80], /* Kernel space copy of buf */
3198: *ptr; /* Pointer to argument list */
3199: u32 args[3]; /* Arguments */
3200: int i, j, error, len;
3201:
3202: if (!(host = inode_to_host(inode)))
3203: return -ENXIO;
3204:
3205: hostdata = (struct NCR53c7x0_hostdata *) host->hostdata;
3206:
3207: if (error = verify_area(VERIFY_READ,buf,count))
3208: return error;
3209:
3210: if (count > 80)
3211: return -EIO;
3212:
3213: memcpy_from_fs(input_buf, buf, count);
3214:
3215: if (input_buf[count - 1] != '\n')
3216: return -EIO;
3217:
3218: input_buf[count - 1]=0;
3219:
3220: for (i = 0; i < NDT; ++i) {
3221: len = strlen (debugger_tokens[i].name);
3222: if (!strncmp(input_buf, debugger_tokens[i].name, len))
3223: break;
3224: };
3225:
3226: if (i == NDT)
3227: return -EIO;
3228:
3229: for (ptr = input_buf + len, j = 0; j < debugger_tokens[i].nargs && *ptr;) {
3230: if (*ptr == ' ' || *ptr == '\t') {
3231: ++ptr;
3232: } else if (isdigit(*ptr)) {
3233: args[j++] = simple_strtoul (ptr, &ptr, 0);
3234: } else {
3235: return -EIO;
3236: }
3237: }
3238:
3239: if (j != debugger_tokens[i].nargs)
3240: return -EIO;
3241:
3242: return count;
3243: }
3244:
3245: static int
3246: debugger_user_read (struct inode *inode,struct file *filp,
3247: char *buf,int count) {
3248: struct Scsi_Host *instance;
3249:
3250: }
3251:
3252: static int
3253: debugger_kernel_write (struct Scsi_Host *host, char *buf, size_t
3254: buflen) {
3255: struct NCR53c7x0_hostdata *hostdata = (struct NCR53c7x0_hostdata *)
3256: host->hostdata;
3257: int copy, left;
3258: unsigned long flags;
3259: save_flags(flags);
3260: cli();
3261: while (buflen) {
3262: left = (hostdata->debug_buf + hostdata->debug_size - 1) -
3263: hostdata->debug_write;
3264: copy = (buflen <= left) ? buflen : left;
3265: memcpy (hostdata->debug_write, buf, copy);
3266: buf += copy;
3267: buflen -= copy;
3268: hostdata->debug_count += copy;
3269: if ((hostdata->debug_write += copy) ==
3270: (hostdata->debug_buf + hostdata->debug_size))
3271: hosdata->debug_write = hostdata->debug_buf;
3272: }
3273: restore_flags(flags);
3274: }
3275:
3276: #endif /* def NCRDEBUG */
3277:
3278: /*
3279: * Function : static void NCR538xx_soft_reset (struct Scsi_Host *host)
3280: *
3281: * Purpose : perform a soft reset of the NCR53c8xx chip
3282: *
3283: * Inputs : host - pointer to this host adapter's structure
3284: *
3285: * Preconditions : NCR53c7x0_init must have been called for this
3286: * host.
3287: *
3288: */
3289:
3290: static void
3291: NCR53c8x0_soft_reset (struct Scsi_Host *host) {
3292: NCR53c7x0_local_declare();
3293: struct NCR53c7x0_hostdata *hostdata = (struct NCR53c7x0_hostdata *)
3294: host->hostdata;
3295: NCR53c7x0_local_setup(host);
3296:
3297:
3298: /*
3299: * Do a soft reset of the chip so that everything is
3300: * reinitialized to the power-on state.
3301: *
3302: * Basically follow the procedure outlined in the NCR53c700
3303: * data manual under Chapter Six, How to Use, Steps Necessary to
3304: * Start SCRIPTS, with the exception of actually starting the
3305: * script and setting up the synchronous transfer gunk.
3306: */
3307:
3308: NCR53c7x0_write8(ISTAT_REG_800, ISTAT_10_SRST);
3309: NCR53c7x0_write8(ISTAT_REG_800, 0);
3310: NCR53c7x0_write8(hostdata->dmode, hostdata->saved_dmode & ~DMODE_MAN);
3311:
3312:
3313: /*
3314: * Respond to reselection by targets and use our _initiator_ SCSI ID
3315: * for arbitration. If notyet, also respond to SCSI selection.
3316: *
3317: * XXX - Note : we must reprogram this when reselecting as
3318: * a target.
3319: */
3320:
3321: #ifdef notyet
3322: NCR53c7x0_write8(SCID_REG, (host->this_id & 7)|SCID_800_RRE|SCID_800_SRE);
3323: #else
3324: NCR53c7x0_write8(SCID_REG, (host->this_id & 7)|SCID_800_RRE);
3325: #endif
3326: NCR53c7x0_write8(RESPID_REG_800, hostdata->this_id_mask);
3327:
3328: /*
3329: * Use a maximum (1.6) second handshake to handshake timeout,
3330: * and SCSI recommended .5s selection timeout.
3331: */
3332:
3333: /*
3334: * The new gcc won't recognize preprocessing directives
3335: * within macro args.
3336: */
3337: #if 0
3338: NCR53c7x0_write8(STIME0_REG_800,
3339: ((selection_timeout << STIME0_800_SEL_SHIFT) & STIME0_800_SEL_MASK)
3340: | ((15 << STIME0_800_HTH_SHIFT) & STIME0_800_HTH_MASK));
3341: #else
3342: /* Disable HTH interrupt */
3343: NCR53c7x0_write8(STIME0_REG_800,
3344: ((selection_timeout << STIME0_800_SEL_SHIFT) & STIME0_800_SEL_MASK));
3345: #endif
3346:
3347:
3348: /*
3349: * Enable active negation for happy synchronous transfers.
3350: */
3351:
3352: NCR53c7x0_write8(STEST3_REG_800, STEST3_800_TE);
3353:
3354: /*
3355: * Enable all interrupts, except parity which we only want when
3356: * the user requests it.
3357: */
3358:
3359: NCR53c7x0_write8(DIEN_REG, DIEN_800_MDPE | DIEN_800_BF |
3360: DIEN_ABRT | DIEN_SSI | DIEN_SIR | DIEN_800_IID);
3361:
3362:
3363: NCR53c7x0_write8(SIEN0_REG_800, ((hostdata->options & OPTION_PARITY) ?
3364: SIEN_PAR : 0) | SIEN_RST | SIEN_UDC | SIEN_SGE | SIEN_MA);
3365: NCR53c7x0_write8(SIEN1_REG_800, SIEN1_800_STO | SIEN1_800_HTH);
3366:
3367: /*
3368: * Use saved clock frequency divisor and scripts loaded in 16 bit
3369: * mode flags from the saved dcntl.
3370: */
3371:
3372: NCR53c7x0_write8(DCNTL_REG, hostdata->saved_dcntl);
3373: NCR53c7x0_write8(CTEST4_REG_800, hostdata->saved_ctest4);
3374:
3375: /* Enable active negation */
3376: NCR53c7x0_write8(STEST3_REG_800, STEST3_800_TE);
3377: }
3378:
3379: /*
3380: * Function static struct NCR53c7x0_cmd *allocate_cmd (Scsi_Cmnd *cmd)
3381: *
3382: * Purpose : Return the first free NCR53c7x0_cmd structure (which are
3383: * reused in a LIFO maner to minimize cache thrashing).
3384: *
3385: * Side effects : If we haven't yet scheduled allocation of NCR53c7x0_cmd
3386: * structures for this device, do so. Attempt to complete all scheduled
3387: * allocations using kmalloc(), putting NCR53c7x0_cmd structures on
3388: * the free list. Teach programmers not to drink and hack.
3389: *
3390: * Inputs : cmd - SCSI command
3391: *
3392: * Returns : NCR53c7x0_cmd structure allocated on behalf of cmd;
3393: * NULL on failure.
3394: */
3395:
3396: static struct NCR53c7x0_cmd *
3397: allocate_cmd (Scsi_Cmnd *cmd) {
3398: struct Scsi_Host *host = cmd->host;
3399: struct NCR53c7x0_hostdata *hostdata =
3400: (struct NCR53c7x0_hostdata *) host->hostdata;
3401: void *real; /* Real address */
3402: int size; /* Size of *tmp */
3403: struct NCR53c7x0_cmd *tmp;
3404: unsigned long flags;
3405:
3406: if (hostdata->options & OPTION_DEBUG_ALLOCATION)
3407: printk ("scsi%d : num_cmds = %d, can_queue = %d\n"
3408: " target = %d, lun = %d, %s\n",
3409: host->host_no, hostdata->num_cmds, host->can_queue,
3410: cmd->target, cmd->lun, (hostdata->cmd_allocated[cmd->target] &
3411: (1 << cmd->lun)) ? "allready allocated" : "not allocated");
3412:
3413: /*
3414: * If we have not yet reserved commands for this I_T_L nexus, and
3415: * the device exists (as indicated by permanant Scsi_Cmnd structures
3416: * being allocated under 1.3.x, or being outside of scan_scsis in
3417: * 1.2.x), do so now.
3418: */
3419: if (!(hostdata->cmd_allocated[cmd->target] & (1 << cmd->lun)) &&
3420: #ifdef LINUX_1_2
3421: !in_scan_scsis
3422: #else
3423: cmd->device && cmd->device->has_cmdblocks
3424: #endif
3425: ) {
3426: if ((hostdata->extra_allocate + hostdata->num_cmds) < host->can_queue)
3427: hostdata->extra_allocate += host->cmd_per_lun;
3428: hostdata->cmd_allocated[cmd->target] |= (1 << cmd->lun);
3429: }
3430:
3431: for (; hostdata->extra_allocate > 0 ; --hostdata->extra_allocate,
3432: ++hostdata->num_cmds) {
3433: /* historically, kmalloc has returned unaligned addresses; pad so we
3434: have enough room to ROUNDUP */
3435: size = hostdata->max_cmd_size + sizeof (void *);
3436: /* FIXME: for ISA bus '7xx chips, we need to or GFP_DMA in here */
3437: real = kmalloc (size, GFP_ATOMIC);
3438: if (!real) {
3439: if (hostdata->options & OPTION_DEBUG_ALLOCATION)
3440: printk ("scsi%d : kmalloc(%d) failed\n",
3441: host->host_no, size);
3442: break;
3443: }
3444: tmp = ROUNDUP(real, void *);
3445: tmp->real = real;
3446: tmp->size = size;
3447: #ifdef LINUX_1_2
3448: tmp->free = ((void (*)(void *, int)) kfree_s);
3449: #else
3450: tmp->free = ((void (*)(void *, int)) kfree);
3451: #endif
3452: save_flags (flags);
3453: cli();
3454: tmp->next = hostdata->free;
3455: hostdata->free = tmp;
3456: restore_flags (flags);
3457: }
3458: save_flags(flags);
3459: cli();
3460: tmp = (struct NCR53c7x0_cmd *) hostdata->free;
3461: if (tmp) {
3462: hostdata->free = tmp->next;
3463: }
3464: restore_flags(flags);
3465: if (!tmp)
3466: printk ("scsi%d : can't allocate command for target %d lun %d\n",
3467: host->host_no, cmd->target, cmd->lun);
3468: return tmp;
3469: }
3470:
3471: /*
3472: * Function static struct NCR53c7x0_cmd *create_cmd (Scsi_Cmnd *cmd)
3473: *
3474: *
3475: * Purpose : allocate a NCR53c7x0_cmd structure, initialize it based on the
3476: * Scsi_Cmnd structure passed in cmd, including dsa and Linux field
3477: * initialization, and dsa code relocation.
3478: *
3479: * Inputs : cmd - SCSI command
3480: *
3481: * Returns : NCR53c7x0_cmd structure corresponding to cmd,
3482: * NULL on failure.
3483: */
3484:
3485: static struct NCR53c7x0_cmd *
3486: create_cmd (Scsi_Cmnd *cmd) {
3487: NCR53c7x0_local_declare();
3488: struct Scsi_Host *host = cmd->host;
3489: struct NCR53c7x0_hostdata *hostdata = (struct NCR53c7x0_hostdata *)
3490: host->hostdata;
3491: struct NCR53c7x0_cmd *tmp; /* NCR53c7x0_cmd structure for this command */
3492: int datain, /* Number of instructions per phase */
3493: dataout;
3494: int data_transfer_instructions, /* Count of dynamic instructions */
3495: i; /* Counter */
3496: u32 *cmd_datain, /* Address of datain/dataout code */
3497: *cmd_dataout; /* Incremented as we assemble */
3498: #ifdef notyet
3499: unsigned char *msgptr; /* Current byte in select message */
3500: int msglen; /* Length of whole select message */
3501: #endif
3502: unsigned long flags;
3503: NCR53c7x0_local_setup(cmd->host);
3504:
3505: if (!(tmp = allocate_cmd (cmd)))
3506: return NULL;
3507:
3508:
3509: /*
3510: * Decide whether we need to generate commands for DATA IN,
3511: * DATA OUT, neither, or both based on the SCSI command
3512: */
3513:
3514: switch (cmd->cmnd[0]) {
3515: /* These commands do DATA IN */
3516: case INQUIRY:
3517: case MODE_SENSE:
3518: case READ_6:
3519: case READ_10:
3520: case READ_CAPACITY:
3521: case REQUEST_SENSE:
3522: datain = 2 * (cmd->use_sg ? cmd->use_sg : 1) + 3;
3523: dataout = 0;
3524: break;
3525: /* These commands do DATA OUT */
3526: case MODE_SELECT:
3527: case WRITE_6:
3528: case WRITE_10:
3529: #if 0
3530: printk("scsi%d : command is ", host->host_no);
3531: print_command(cmd->cmnd);
3532: #endif
3533: #if 0
3534: printk ("scsi%d : %d scatter/gather segments\n", host->host_no,
3535: cmd->use_sg);
3536: #endif
3537: datain = 0;
3538: dataout = 2 * (cmd->use_sg ? cmd->use_sg : 1) + 3;
3539: #if 0
3540: hostdata->options |= OPTION_DEBUG_INTR;
3541: #endif
3542: break;
3543: /*
3544: * These commands do no data transfer, we should force an
3545: * interrupt if a data phase is attempted on them.
3546: */
3547: case START_STOP:
3548: case TEST_UNIT_READY:
3549: datain = dataout = 0;
3550: break;
3551: /*
3552: * We don't know about these commands, so generate code to handle
3553: * both DATA IN and DATA OUT phases.
3554: */
3555: default:
3556: datain = dataout = 2 * (cmd->use_sg ? cmd->use_sg : 1) + 3;
3557: }
3558:
3559: /*
3560: * New code : so that active pointers work correctly irregardless
3561: * of where the saved data pointer is at, we want to immediately
3562: * enter the dynamic code after selection, and on a non-data
3563: * phase perform a CALL to the non-data phase handler, with
3564: * returns back to this address.
3565: *
3566: * If a phase mismatch is encountered in the middle of a
3567: * Block MOVE instruction, we want to _leave_ that instruction
3568: * unchanged as the current case is, modify a temporary buffer,
3569: * and point the active pointer (TEMP) at that.
3570: *
3571: * Furthermore, we want to implement a saved data pointer,
3572: * set by the SAVE_DATA_POINTERs message.
3573: *
3574: * So, the data transfer segments will change to
3575: * CALL data_transfer, WHEN NOT data phase
3576: * MOVE x, x, WHEN data phase
3577: * ( repeat )
3578: * JUMP other_transfer
3579: */
3580:
3581: data_transfer_instructions = datain + dataout;
3582:
3583: /*
3584: * When we perform a request sense, we overwrite various things,
3585: * including the data transfer code. Make sure we have enough
3586: * space to do that.
3587: */
3588:
3589: if (data_transfer_instructions < 2)
3590: data_transfer_instructions = 2;
3591:
3592:
3593: /*
3594: * The saved data pointer is set up so that a RESTORE POINTERS message
3595: * will start the data transfer over at the beggining.
3596: */
3597:
3598: tmp->saved_data_pointer = virt_to_bus (hostdata->script) +
3599: hostdata->E_data_transfer;
3600:
3601: /*
3602: * Initialize Linux specific fields.
3603: */
3604:
3605: tmp->cmd = cmd;
3606: tmp->next = NULL;
3607: tmp->flags = 0;
3608: tmp->dsa_next_addr = virt_to_bus(tmp->dsa) + hostdata->dsa_next -
3609: hostdata->dsa_start;
3610: tmp->dsa_addr = virt_to_bus(tmp->dsa) - hostdata->dsa_start;
3611:
3612: /*
3613: * Calculate addresses of dynamic code to fill in DSA
3614: */
3615:
3616: tmp->data_transfer_start = tmp->dsa + (hostdata->dsa_end -
3617: hostdata->dsa_start) / sizeof(u32);
3618: tmp->data_transfer_end = tmp->data_transfer_start +
3619: 2 * data_transfer_instructions;
3620:
3621: cmd_datain = datain ? tmp->data_transfer_start : NULL;
3622: cmd_dataout = dataout ? (datain ? cmd_datain + 2 * datain : tmp->
3623: data_transfer_start) : NULL;
3624:
3625: /*
3626: * Fill in the NCR53c7x0_cmd structure as follows
3627: * dsa, with fixed up DSA code
3628: * datain code
3629: * dataout code
3630: */
3631:
3632: /* Copy template code into dsa and perform all necessary fixups */
3633: if (hostdata->dsa_fixup)
3634: hostdata->dsa_fixup(tmp);
3635:
3636: patch_dsa_32(tmp->dsa, dsa_next, 0, 0);
3637: patch_dsa_32(tmp->dsa, dsa_cmnd, 0, virt_to_bus(cmd));
3638:
3639: if (hostdata->options & OPTION_DEBUG_SYNCHRONOUS)
3640: if (hostdata->sync[cmd->target].select_indirect !=
3641: ((hostdata->sync[cmd->target].scntl3_sanity << 24) |
3642: (cmd->target << 16) |
3643: (hostdata->sync[cmd->target].sxfer_sanity << 8))) {
3644: printk ("scsi%d : sanity check failed select_indirect=0x%x\n",
3645: host->host_no, hostdata->sync[cmd->target].select_indirect);
3646: FATAL(host);
3647:
3648: }
3649:
3650: patch_dsa_32(tmp->dsa, dsa_select, 0, hostdata->sync[cmd->target].
3651: select_indirect);
3652: /*
3653: * Right now, we'll do the WIDE and SYNCHRONOUS negotiations on
3654: * different commands; although it should be trivial to do them
3655: * both at the same time.
3656: */
3657: if (hostdata->initiate_wdtr & (1 << cmd->target)) {
3658: memcpy ((void *) (tmp->select + 1), (void *) wdtr_message,
3659: sizeof(wdtr_message));
3660: patch_dsa_32(tmp->dsa, dsa_msgout, 0, 1 + sizeof(wdtr_message));
3661: save_flags(flags);
3662: cli();
3663: hostdata->initiate_wdtr &= ~(1 << cmd->target);
3664: restore_flags(flags);
3665: } else if (hostdata->initiate_sdtr & (1 << cmd->target)) {
3666: memcpy ((void *) (tmp->select + 1), (void *) sdtr_message,
3667: sizeof(sdtr_message));
3668: patch_dsa_32(tmp->dsa, dsa_msgout, 0, 1 + sizeof(sdtr_message));
3669: tmp->flags |= CMD_FLAG_SDTR;
3670: save_flags(flags);
3671: cli();
3672: hostdata->initiate_sdtr &= ~(1 << cmd->target);
3673: restore_flags(flags);
3674:
3675: }
3676: #if 1
3677: else if (!(hostdata->talked_to & (1 << cmd->target)) &&
3678: !(hostdata->options & OPTION_NO_ASYNC)) {
3679: memcpy ((void *) (tmp->select + 1), (void *) async_message,
3680: sizeof(async_message));
3681: patch_dsa_32(tmp->dsa, dsa_msgout, 0, 1 + sizeof(async_message));
3682: tmp->flags |= CMD_FLAG_SDTR;
3683: }
3684: #endif
3685: else
3686: patch_dsa_32(tmp->dsa, dsa_msgout, 0, 1);
3687: hostdata->talked_to |= (1 << cmd->target);
3688: tmp->select[0] = (hostdata->options & OPTION_DISCONNECT) ?
3689: IDENTIFY (1, cmd->lun) : IDENTIFY (0, cmd->lun);
3690: patch_dsa_32(tmp->dsa, dsa_msgout, 1, virt_to_bus(tmp->select));
3691: patch_dsa_32(tmp->dsa, dsa_cmdout, 0, cmd->cmd_len);
3692: patch_dsa_32(tmp->dsa, dsa_cmdout, 1, virt_to_bus(cmd->cmnd));
3693: patch_dsa_32(tmp->dsa, dsa_dataout, 0, cmd_dataout ?
3694: virt_to_bus (cmd_dataout)
3695: : virt_to_bus (hostdata->script) + hostdata->E_other_transfer);
3696: patch_dsa_32(tmp->dsa, dsa_datain, 0, cmd_datain ?
3697: virt_to_bus (cmd_datain)
3698: : virt_to_bus (hostdata->script) + hostdata->E_other_transfer);
3699: /*
3700: * XXX - need to make endian aware, should use separate variables
3701: * for both status and message bytes.
3702: */
3703: patch_dsa_32(tmp->dsa, dsa_msgin, 0, 1);
3704: /*
3705: * FIXME : these only works for little endian. We probably want to
3706: * provide message and status fields in the NCR53c7x0_cmd
3707: * structure, and assign them to cmd->result when we're done.
3708: */
3709: patch_dsa_32(tmp->dsa, dsa_msgin, 1, virt_to_bus(&cmd->result) + 1);
3710: patch_dsa_32(tmp->dsa, dsa_status, 0, 1);
3711: patch_dsa_32(tmp->dsa, dsa_status, 1, virt_to_bus(&cmd->result));
3712: patch_dsa_32(tmp->dsa, dsa_msgout_other, 0, 1);
3713: patch_dsa_32(tmp->dsa, dsa_msgout_other, 1,
3714: virt_to_bus(&(hostdata->NCR53c7xx_msg_nop)));
3715:
3716: /*
3717: * Generate code for zero or more of the DATA IN, DATA OUT phases
3718: * in the format
3719: *
3720: * CALL data_transfer, WHEN NOT phase
3721: * MOVE first buffer length, first buffer address, WHEN phase
3722: * ...
3723: * MOVE last buffer length, last buffer address, WHEN phase
3724: * JUMP other_transfer
3725: */
3726:
3727: /*
3728: * See if we're getting to data transfer by generating an unconditional
3729: * interrupt.
3730: */
3731: #if 0
3732: if (datain) {
3733: cmd_datain[0] = 0x98080000;
3734: cmd_datain[1] = 0x03ffd00d;
3735: cmd_datain += 2;
3736: }
3737: #endif
3738:
3739: /*
3740: * XXX - I'm undecided whether all of this nonsense is faster
3741: * in the long run, or whether I should just go and implement a loop
3742: * on the NCR chip using table indirect mode?
3743: *
3744: * In any case, this is how it _must_ be done for 53c700/700-66 chips,
3745: * so this stays even when we come up with something better.
3746: *
3747: * When we're limited to 1 simultaneous command, no overlapping processing,
3748: * we're seeing 630K/sec, with 7% CPU usage on a slow Syquest 45M
3749: * drive.
3750: *
3751: * Not bad, not good. We'll see.
3752: */
3753:
3754: for (i = 0; cmd->use_sg ? (i < cmd->use_sg) : !i; cmd_datain += 4,
3755: cmd_dataout += 4, ++i) {
3756: u32 buf = cmd->use_sg ?
3757: virt_to_bus(((struct scatterlist *)cmd->buffer)[i].address) :
3758: virt_to_bus(cmd->request_buffer);
3759: u32 count = cmd->use_sg ?
3760: ((struct scatterlist *)cmd->buffer)[i].length :
3761: cmd->request_bufflen;
3762:
3763: if (datain) {
3764: /* CALL other_in, WHEN NOT DATA_IN */
3765: cmd_datain[0] = ((DCMD_TYPE_TCI | DCMD_TCI_OP_CALL |
3766: DCMD_TCI_IO) << 24) |
3767: DBC_TCI_WAIT_FOR_VALID | DBC_TCI_COMPARE_PHASE;
3768: cmd_datain[1] = virt_to_bus (hostdata->script) +
3769: hostdata->E_other_in;
3770: /* MOVE count, buf, WHEN DATA_IN */
3771: cmd_datain[2] = ((DCMD_TYPE_BMI | DCMD_BMI_OP_MOVE_I | DCMD_BMI_IO)
3772: << 24) | count;
3773: cmd_datain[3] = buf;
3774: #if 0
3775: print_insn (host, cmd_datain, "dynamic ", 1);
3776: print_insn (host, cmd_datain + 2, "dynamic ", 1);
3777: #endif
3778: }
3779: if (dataout) {
3780: /* CALL other_out, WHEN NOT DATA_OUT */
3781: cmd_dataout[0] = ((DCMD_TYPE_TCI | DCMD_TCI_OP_CALL) << 24) |
3782: DBC_TCI_WAIT_FOR_VALID | DBC_TCI_COMPARE_PHASE;
3783: cmd_dataout[1] = virt_to_bus(hostdata->script) +
3784: hostdata->E_other_out;
3785: /* MOVE count, buf, WHEN DATA+OUT */
3786: cmd_dataout[2] = ((DCMD_TYPE_BMI | DCMD_BMI_OP_MOVE_I) << 24)
3787: | count;
3788: cmd_dataout[3] = buf;
3789: #if 0
3790: print_insn (host, cmd_dataout, "dynamic ", 1);
3791: print_insn (host, cmd_dataout + 2, "dynamic ", 1);
3792: #endif
3793: }
3794: }
3795:
3796: /*
3797: * Install JUMP instructions after the data transfer routines to return
3798: * control to the do_other_transfer routines.
3799: */
3800:
3801:
3802: if (datain) {
3803: cmd_datain[0] = ((DCMD_TYPE_TCI | DCMD_TCI_OP_JUMP) << 24) |
3804: DBC_TCI_TRUE;
3805: cmd_datain[1] = virt_to_bus(hostdata->script) +
3806: hostdata->E_other_transfer;
3807: #if 0
3808: print_insn (host, cmd_datain, "dynamic jump ", 1);
3809: #endif
3810: cmd_datain += 2;
3811: }
3812: #if 0
3813: if (datain) {
3814: cmd_datain[0] = 0x98080000;
3815: cmd_datain[1] = 0x03ffdeed;
3816: cmd_datain += 2;
3817: }
3818: #endif
3819: if (dataout) {
3820: cmd_dataout[0] = ((DCMD_TYPE_TCI | DCMD_TCI_OP_JUMP) << 24) |
3821: DBC_TCI_TRUE;
3822: cmd_dataout[1] = virt_to_bus(hostdata->script) +
3823: hostdata->E_other_transfer;
3824: #if 0
3825: print_insn (host, cmd_dataout, "dynamic jump ", 1);
3826: #endif
3827: cmd_dataout += 2;
3828: }
3829: return tmp;
3830: }
3831:
3832: /*
3833: * Function : int NCR53c7xx_queue_command (Scsi_Cmnd *cmd,
3834: * void (*done)(Scsi_Cmnd *))
3835: *
3836: * Purpose : enqueues a SCSI command
3837: *
3838: * Inputs : cmd - SCSI command, done - function called on completion, with
3839: * a pointer to the command descriptor.
3840: *
3841: * Returns : 0
3842: *
3843: * Side effects :
3844: * cmd is added to the per instance driver issue_queue, with major
3845: * twiddling done to the host specific fields of cmd. If the
3846: * process_issue_queue corouting isn't running, it is restarted.
3847: *
3848: * NOTE : we use the host_scribble field of the Scsi_Cmnd structure to
3849: * hold our own data, and pervert the ptr field of the SCp field
3850: * to create a linked list.
3851: */
3852:
3853: int
3854: NCR53c7xx_queue_command (Scsi_Cmnd *cmd, void (* done)(Scsi_Cmnd *)) {
3855: struct Scsi_Host *host = cmd->host;
3856: struct NCR53c7x0_hostdata *hostdata =
3857: (struct NCR53c7x0_hostdata *) host->hostdata;
3858: unsigned long flags;
3859: Scsi_Cmnd *tmp;
3860:
3861: cmd->scsi_done = done;
3862: cmd->host_scribble = NULL;
3863: cmd->SCp.ptr = NULL;
3864: cmd->SCp.buffer = NULL;
3865:
3866: save_flags(flags);
3867: cli();
3868: if ((hostdata->options & (OPTION_DEBUG_INIT_ONLY|OPTION_DEBUG_PROBE_ONLY))
3869: || ((hostdata->options & OPTION_DEBUG_TARGET_LIMIT) &&
3870: !(hostdata->debug_lun_limit[cmd->target] & (1 << cmd->lun)))
3871: #ifdef LINUX_1_2
3872: || cmd->target > 7
3873: #else
3874: || cmd->target > host->max_id
3875: #endif
3876: || cmd->target == host->this_id
3877: || hostdata->state == STATE_DISABLED) {
3878: printk("scsi%d : disabled or bad target %d lun %d\n", host->host_no,
3879: cmd->target, cmd->lun);
3880: cmd->result = (DID_BAD_TARGET << 16);
3881: } else if ((hostdata->options & OPTION_DEBUG_NCOMMANDS_LIMIT) &&
3882: (hostdata->debug_count_limit == 0)) {
3883: printk("scsi%d : maximum commands exceeded\n", host->host_no);
3884: cmd->result = (DID_BAD_TARGET << 16);
3885: cmd->result = (DID_BAD_TARGET << 16);
3886: } else if (hostdata->options & OPTION_DEBUG_READ_ONLY) {
3887: switch (cmd->cmnd[0]) {
3888: case WRITE_6:
3889: case WRITE_10:
3890: printk("scsi%d : WRITE attempted with NO_WRITE debugging flag set\n",
3891: host->host_no);
3892: cmd->result = (DID_BAD_TARGET << 16);
3893: }
3894: } else {
3895: if ((hostdata->options & OPTION_DEBUG_TARGET_LIMIT) &&
3896: hostdata->debug_count_limit != -1)
3897: --hostdata->debug_count_limit;
3898: restore_flags (flags);
3899: cmd->result = 0xffff; /* The NCR will overwrite message
3900: and status with valid data */
3901: cmd->host_scribble = (unsigned char *) tmp = create_cmd (cmd);
3902: }
3903: cli();
3904: /*
3905: * REQUEST SENSE commands are inserted at the head of the queue
3906: * so that we do not clear the contingent allegience condition
3907: * they may be looking at.
3908: */
3909:
3910: if (!(hostdata->issue_queue) || (cmd->cmnd[0] == REQUEST_SENSE)) {
3911: cmd->SCp.ptr = (unsigned char *) hostdata->issue_queue;
3912: hostdata->issue_queue = cmd;
3913: } else {
3914: for (tmp = (Scsi_Cmnd *) hostdata->issue_queue; tmp->SCp.ptr;
3915: tmp = (Scsi_Cmnd *) tmp->SCp.ptr);
3916: tmp->SCp.ptr = (unsigned char *) cmd;
3917: }
3918: restore_flags (flags);
3919: run_process_issue_queue();
3920: return 0;
3921: }
3922:
3923: /*
3924: * Function : void to_schedule_list (struct Scsi_Host *host,
3925: * struct NCR53c7x0_hostdata * hostdata, Scsi_Cmnd *cmd)
3926: *
3927: * Purpose : takes a SCSI command which was just removed from the
3928: * issue queue, and deals with it by inserting it in the first
3929: * free slot in the schedule list or by terminating it immediately.
3930: *
3931: * Inputs :
3932: * host - SCSI host adater; hostdata - hostdata structure for
3933: * this adapter; cmd - a pointer to the command; should have
3934: * the host_scribble field initialized to point to a valid
3935: *
3936: * Side effects :
3937: * cmd is added to the per instance schedule list, with minor
3938: * twiddling done to the host specific fields of cmd.
3939: *
3940: */
3941:
3942: static __inline__ void
3943: to_schedule_list (struct Scsi_Host *host, struct NCR53c7x0_hostdata *hostdata,
3944: struct NCR53c7x0_cmd *cmd) {
3945: NCR53c7x0_local_declare();
3946: Scsi_Cmnd *tmp = cmd->cmd;
3947: unsigned long flags;
3948: /* dsa start is negative, so subtraction is used */
3949: volatile u32 *current;
3950:
3951: int i;
3952: NCR53c7x0_local_setup(host);
3953: #if 0
3954: printk("scsi%d : new dsa is 0x%lx (virt 0x%p)\n", host->host_no,
3955: virt_to_bus(dsa), dsa);
3956: #endif
3957:
3958: save_flags(flags);
3959: cli();
3960:
3961: /*
3962: * Work arround race condition : if an interrupt fired and we
3963: * got disabled forget about this command.
3964: */
3965:
3966: if (hostdata->state == STATE_DISABLED) {
3967: printk("scsi%d : driver disabled\n", host->host_no);
3968: tmp->result = (DID_BAD_TARGET << 16);
3969: cmd->next = (struct NCR53c7x0_cmd *) hostdata->free;
3970: hostdata->free = cmd;
3971: tmp->scsi_done(tmp);
3972: restore_flags (flags);
3973: return;
3974: }
3975:
3976: for (i = host->can_queue, current = hostdata->schedule;
3977: i > 0 && current[0] != hostdata->NOP_insn;
3978: --i, current += 2 /* JUMP instructions are two words */);
3979:
3980: if (i > 0) {
3981: ++hostdata->busy[tmp->target][tmp->lun];
3982: cmd->next = hostdata->running_list;
3983: hostdata->running_list = cmd;
3984:
3985: /* Restore this instruction to a NOP once the command starts */
3986: cmd->dsa [(hostdata->dsa_jump_dest - hostdata->dsa_start) /
3987: sizeof(u32)] = (u32) virt_to_bus ((void *)current);
3988: /* Replace the current jump operand. */
3989: current[1] =
3990: virt_to_bus ((void *) cmd->dsa) + hostdata->E_dsa_code_begin -
3991: hostdata->E_dsa_code_template;
3992: /* Replace the NOP instruction with a JUMP */
3993: current[0] = ((DCMD_TYPE_TCI|DCMD_TCI_OP_JUMP) << 24) |
3994: DBC_TCI_TRUE;
3995: } else {
3996: printk ("scsi%d: no free slot\n", host->host_no);
3997: disable(host);
3998: tmp->result = (DID_ERROR << 16);
3999: cmd->next = (struct NCR53c7x0_cmd *) hostdata->free;
4000: hostdata->free = cmd;
4001: tmp->scsi_done(tmp);
4002: restore_flags (flags);
4003: return;
4004: }
4005:
4006: /*
4007: * If the NCR chip is in an idle state, start it running the scheduler
4008: * immediately. Otherwise, signal the chip to jump to schedule as
4009: * soon as it is idle.
4010: */
4011: if (hostdata->idle) {
4012: hostdata->idle = 0;
4013: hostdata->state = STATE_RUNNING;
4014: NCR53c7x0_write32 (DSP_REG, virt_to_bus ((void *)hostdata->schedule));
4015: } else {
4016: NCR53c7x0_write8(hostdata->istat, ISTAT_10_SIGP);
4017: }
4018:
4019: restore_flags(flags);
4020: }
4021:
4022: /*
4023: * Function : busyp (struct Scsi_Host *host, struct NCR53c7x0_hostdata
4024: * *hostdata, Scsi_Cmnd *cmd)
4025: *
4026: * Purpose : decide if we can pass the given SCSI command on to the
4027: * device in question or not.
4028: *
4029: * Returns : non-zero when we're busy, 0 when we aren't.
4030: */
4031:
4032: static __inline__ int
4033: busyp (struct Scsi_Host *host, struct NCR53c7x0_hostdata *hostdata,
4034: Scsi_Cmnd *cmd) {
4035: /* FIXME : in the future, this needs to accomodate SCSI-II tagged
4036: queuing, and we may be able to play with fairness here a bit.
4037: */
4038: return hostdata->busy[cmd->target][cmd->lun];
4039: }
4040:
4041: /*
4042: * Function : process_issue_queue (void)
4043: *
4044: * Purpose : transfer commands from the issue queue to NCR start queue
4045: * of each NCR53c7/8xx in the system, avoiding kernel stack
4046: * overflows when the scsi_done() function is invoked recursively.
4047: *
4048: * NOTE : process_issue_queue exits with interrupts *disabled*, so the
4049: * caller must renable them if it desires.
4050: *
4051: * NOTE : process_issue_queue should be called from both
4052: * NCR53c7x0_queue_command() and from the interrupt handler
4053: * after command completion in case NCR53c7x0_queue_command()
4054: * isn't invoked again but we've freed up resources that are
4055: * needed.
4056: */
4057:
4058: static void
4059: process_issue_queue (unsigned long flags) {
4060: Scsi_Cmnd *tmp, *prev;
4061: struct Scsi_Host *host;
4062: struct NCR53c7x0_hostdata *hostdata;
4063: int done;
4064:
4065: /*
4066: * We run (with interrupts disabled) until we're sure that none of
4067: * the host adapters have anything that can be done, at which point
4068: * we set process_issue_queue_running to 0 and exit.
4069: *
4070: * Interrupts are enabled before doing various other internal
4071: * instructions, after we've decided that we need to run through
4072: * the loop again.
4073: *
4074: */
4075:
4076: do {
4077: cli(); /* Freeze request queues */
4078: done = 1;
4079: for (host = first_host; host && host->hostt == the_template;
4080: host = host->next) {
4081: hostdata = (struct NCR53c7x0_hostdata *) host->hostdata;
4082: cli();
4083: if (hostdata->issue_queue) {
4084: if (hostdata->state == STATE_DISABLED) {
4085: tmp = (Scsi_Cmnd *) hostdata->issue_queue;
4086: hostdata->issue_queue = (Scsi_Cmnd *) tmp->SCp.ptr;
4087: tmp->result = (DID_BAD_TARGET << 16);
4088: if (tmp->host_scribble) {
4089: ((struct NCR53c7x0_cmd *)tmp->host_scribble)->next =
4090: hostdata->free;
4091: hostdata->free =
4092: (struct NCR53c7x0_cmd *)tmp->host_scribble;
4093: tmp->host_scribble = NULL;
4094: }
4095: tmp->scsi_done (tmp);
4096: done = 0;
4097: } else
4098: for (tmp = (Scsi_Cmnd *) hostdata->issue_queue,
4099: prev = NULL; tmp; prev = tmp, tmp = (Scsi_Cmnd *)
4100: tmp->SCp.ptr)
4101: if (!tmp->host_scribble ||
4102: !busyp (host, hostdata, tmp)) {
4103: if (prev)
4104: prev->SCp.ptr = tmp->SCp.ptr;
4105: else
4106: hostdata->issue_queue = (Scsi_Cmnd *)
4107: tmp->SCp.ptr;
4108: tmp->SCp.ptr = NULL;
4109: if (tmp->host_scribble) {
4110: if (hostdata->options & OPTION_DEBUG_QUEUES)
4111: printk ("scsi%d : moving command for target %d lun %d to start list\n",
4112: host->host_no, tmp->target, tmp->lun);
4113:
4114:
4115: to_schedule_list (host, hostdata,
4116: (struct NCR53c7x0_cmd *)
4117: tmp->host_scribble);
4118: } else {
4119: if (((tmp->result & 0xff) == 0xff) ||
4120: ((tmp->result & 0xff00) == 0xff00)) {
4121: printk ("scsi%d : danger Will Robinson!\n",
4122: host->host_no);
4123: tmp->result = DID_ERROR << 16;
4124: disable (host);
4125: }
4126: tmp->scsi_done(tmp);
4127: }
4128: done = 0;
4129: } /* if target/lun is not busy */
4130: } /* if hostdata->issue_queue */
4131: if (!done)
4132: restore_flags (flags);
4133: } /* for host */
4134: } while (!done);
4135: process_issue_queue_running = 0;
4136: }
4137:
4138: /*
4139: * Function : static void intr_scsi (struct Scsi_Host *host,
4140: * struct NCR53c7x0_cmd *cmd)
4141: *
4142: * Purpose : handle all SCSI interrupts, indicated by the setting
4143: * of the SIP bit in the ISTAT register.
4144: *
4145: * Inputs : host, cmd - host and NCR command causing the interrupt, cmd
4146: * may be NULL.
4147: */
4148:
4149: static void
4150: intr_scsi (struct Scsi_Host *host, struct NCR53c7x0_cmd *cmd) {
4151: NCR53c7x0_local_declare();
4152: struct NCR53c7x0_hostdata *hostdata =
4153: (struct NCR53c7x0_hostdata *) host->hostdata;
4154: unsigned char sstat0_sist0, sist1, /* Registers */
4155: fatal; /* Did a fatal interrupt
4156: occur ? */
4157:
4158: int is_8xx_chip;
4159: NCR53c7x0_local_setup(host);
4160:
4161: fatal = 0;
4162:
4163: is_8xx_chip = ((unsigned) (hostdata->chip - 800)) < 100;
4164: if (is_8xx_chip) {
4165: sstat0_sist0 = NCR53c7x0_read8(SIST0_REG_800);
4166: udelay(1);
4167: sist1 = NCR53c7x0_read8(SIST1_REG_800);
4168: } else {
4169: sstat0_sist0 = NCR53c7x0_read8(SSTAT0_REG);
4170: sist1 = 0;
4171: }
4172:
4173: if (hostdata->options & OPTION_DEBUG_INTR)
4174: printk ("scsi%d : SIST0 0x%0x, SIST1 0x%0x\n", host->host_no,
4175: sstat0_sist0, sist1);
4176:
4177: /* 250ms selection timeout */
4178: if ((is_8xx_chip && (sist1 & SIST1_800_STO)) ||
4179: (!is_8xx_chip && (sstat0_sist0 & SSTAT0_700_STO))) {
4180: fatal = 1;
4181: if (hostdata->options & OPTION_DEBUG_INTR) {
4182: printk ("scsi%d : Selection Timeout\n", host->host_no);
4183: if (cmd) {
4184: printk("scsi%d : target %d, lun %d, command ",
4185: host->host_no, cmd->cmd->target, cmd->cmd->lun);
4186: print_command (cmd->cmd->cmnd);
4187: printk("scsi%d : dsp = 0x%x (virt 0x%p)\n", host->host_no,
4188: NCR53c7x0_read32(DSP_REG),
4189: bus_to_virt(NCR53c7x0_read32(DSP_REG)));
4190: } else {
4191: printk("scsi%d : no command\n", host->host_no);
4192: }
4193: }
4194: /*
4195: * XXX - question : how do we want to handle the Illegal Instruction
4196: * interrupt, which may occur before or after the Selection Timeout
4197: * interrupt?
4198: */
4199:
4200: if (1) {
4201: hostdata->idle = 1;
4202: hostdata->expecting_sto = 0;
4203:
4204: if (hostdata->test_running) {
4205: hostdata->test_running = 0;
4206: hostdata->test_completed = 3;
4207: } else if (cmd) {
4208: abnormal_finished(cmd, DID_BAD_TARGET << 16);
4209: }
4210: #if 0
4211: hostdata->intrs = 0;
4212: #endif
4213: }
4214: }
4215:
4216: /*
4217: * FIXME : in theory, we can also get a UDC when a STO occurs.
4218: */
4219: if (sstat0_sist0 & SSTAT0_UDC) {
4220: fatal = 1;
4221: if (cmd) {
4222: printk("scsi%d : target %d lun %d unexpected disconnect\n",
4223: host->host_no, cmd->cmd->target, cmd->cmd->lun);
4224: print_lots (host);
4225: abnormal_finished(cmd, DID_ERROR << 16);
4226: } else
4227: printk("scsi%d : unexpected disconnect (no command)\n",
4228: host->host_no);
4229:
4230: hostdata->dsp = (u32 *) hostdata->schedule;
4231: hostdata->dsp_changed = 1;
4232: }
4233:
4234: /* SCSI PARITY error */
4235: if (sstat0_sist0 & SSTAT0_PAR) {
4236: fatal = 1;
4237: if (cmd && cmd->cmd) {
4238: printk("scsi%d : target %d lun %d parity error.\n",
4239: host->host_no, cmd->cmd->target, cmd->cmd->lun);
4240: abnormal_finished (cmd, DID_PARITY << 16);
4241: } else
4242: printk("scsi%d : parity error\n", host->host_no);
4243: /* Should send message out, parity error */
4244:
4245: /* XXX - Reduce synchronous transfer rate! */
4246: hostdata->dsp = hostdata->script + hostdata->E_initiator_abort /
4247: sizeof(u32);
4248: hostdata->dsp_changed = 1;
4249: /* SCSI GROSS error */
4250: }
4251:
4252: if (sstat0_sist0 & SSTAT0_SGE) {
4253: fatal = 1;
4254: printk("scsi%d : gross error\n", host->host_no);
4255: /* Reset SCSI offset */
4256: if ((hostdata->chip / 100) == 8) {
4257: NCR53c7x0_write8 (STEST2_REG_800, STEST2_800_ROF);
4258: }
4259:
4260: /*
4261: * A SCSI gross error may occur when we have
4262: *
4263: * - A synchronous offset which causes the SCSI FIFO to be overwritten.
4264: *
4265: * - A REQ which causes the maxmimum synchronous offset programmed in
4266: * the SXFER register to be exceeded.
4267: *
4268: * - A phase change with an outstanding synchronous offset.
4269: *
4270: * - Residual data in the synchronous data FIFO, with a transfer
4271: * other than a synchronous receive is started.$#
4272: */
4273:
4274:
4275: /* XXX Should deduce synchronous transfer rate! */
4276: hostdata->dsp = hostdata->script + hostdata->E_initiator_abort /
4277: sizeof(u32);
4278: hostdata->dsp_changed = 1;
4279: /* Phase mismatch */
4280: }
4281:
4282: if (sstat0_sist0 & SSTAT0_MA) {
4283: fatal = 1;
4284: if (hostdata->options & OPTION_DEBUG_INTR)
4285: printk ("scsi%d : SSTAT0_MA\n", host->host_no);
4286: intr_phase_mismatch (host, cmd);
4287: }
4288:
4289: #if 0
4290: if (sstat0_sist0 & SIST0_800_RSL)
4291: printk ("scsi%d : Oh no Mr. Bill!\n", host->host_no);
4292: #endif
4293:
4294: /*
4295: * If a fatal SCSI interrupt occurs, we must insure that the DMA and
4296: * SCSI FIFOs were flushed.
4297: */
4298:
4299: if (fatal) {
4300: if (!hostdata->dstat_valid) {
4301: hostdata->dstat = NCR53c7x0_read8(DSTAT_REG);
4302: hostdata->dstat_valid = 1;
4303: }
4304:
4305: /* XXX - code check for 700/800 chips */
4306: if (!(hostdata->dstat & DSTAT_DFE)) {
4307: printk ("scsi%d : DMA FIFO not empty\n", host->host_no);
4308: if (NCR53c7x0_read8 (CTEST2_REG_800) & CTEST2_800_DDIR) {
4309: printk ("scsi%d: Flushing DMA FIFO\n",
4310: host->host_no);
4311: NCR53c7x0_write8 (CTEST3_REG_800, CTEST3_800_FLF);
4312: while (!((hostdata->dstat = NCR53c7x0_read8(DSTAT_REG)) &
4313: DSTAT_DFE));
4314: } else {
4315: NCR53c7x0_write8 (CTEST3_REG_800, CTEST3_800_CLF);
4316: while (NCR53c7x0_read8 (CTEST3_REG_800) & CTEST3_800_CLF);
4317: }
4318: hostdata->dstat |= DSTAT_DFE;
4319: }
4320: }
4321: }
4322:
4323: /*
4324: * Function : static void NCR53c7x0_intr (int irq, struct pt_regs * regs)
4325: *
4326: * Purpose : handle NCR53c7x0 interrupts for all NCR devices sharing
4327: * the same IRQ line.
4328: *
4329: * Inputs : Since we're using the SA_INTERRUPT interrupt handler
4330: * semantics, irq indicates the interrupt which invoked
4331: * this handler.
4332: */
4333:
4334: static void
4335: NCR53c7x0_intr (int irq, struct pt_regs * regs) {
4336: NCR53c7x0_local_declare();
4337: struct Scsi_Host *host; /* Host we are looking at */
4338: unsigned char istat; /* Values of interrupt regs */
4339: struct NCR53c7x0_hostdata *hostdata; /* host->hostdata */
4340: struct NCR53c7x0_cmd *cmd, /* command which halted */
4341: **cmd_prev_ptr;
4342: u32 *dsa; /* DSA */
4343: int done = 1; /* Indicates when handler
4344: should terminate */
4345: int interrupted = 0; /* This HA generated
4346: an interrupt */
4347: int have_intfly; /* Don't print warning
4348: messages when we stack
4349: INTFLYs */
4350: unsigned long flags;
4351:
4352: #ifdef NCR_DEBUG
4353: char buf[80]; /* Debugging sprintf buffer */
4354: size_t buflen; /* Length of same */
4355: #endif
4356:
4357: do {
4358: done = 1;
4359: for (host = first_host; host; host = host->next)
4360: if (host->hostt == the_template && host->irq == irq) {
4361: NCR53c7x0_local_setup(host);
4362:
4363: hostdata = (struct NCR53c7x0_hostdata *) host->hostdata;
4364: hostdata->dsp_changed = 0;
4365: interrupted = 0;
4366: have_intfly = 0;
4367:
4368: do {
4369: int is_8xx_chip;
4370:
4371: hostdata->dstat_valid = 0;
4372: interrupted = 0;
4373: /*
4374: * Only read istat once, since reading it again will unstack
4375: * interrupts?
4376: */
4377: istat = NCR53c7x0_read8(hostdata->istat);
4378:
4379: /*
4380: * INTFLY interrupts are used by the NCR53c720, NCR53c810,
4381: * and NCR53c820 to signify completion of a command. Since
4382: * the SCSI processor continues running, we can't just look
4383: * at the contents of the DSA register and continue running.
4384: */
4385: /* XXX - this is too big, offends my sense of aesthetics, and should
4386: move to intr_intfly() */
4387: is_8xx_chip = ((unsigned) (hostdata->chip - 800)) < 100;
4388: if ((hostdata->options & OPTION_INTFLY) &&
4389: (is_8xx_chip && (istat & ISTAT_800_INTF))) {
4390: char search_found = 0; /* Got at least one ? */
4391: done = 0;
4392: interrupted = 1;
4393:
4394: /*
4395: * Clear the INTF bit by writing a one.
4396: * This reset operation is self-clearing.
4397: */
4398: NCR53c7x0_write8(hostdata->istat, istat|ISTAT_800_INTF);
4399:
4400: if (hostdata->options & OPTION_DEBUG_INTR)
4401: printk ("scsi%d : INTFLY\n", host->host_no);
4402:
4403: /*
4404: * Traverse our list of running commands, and look
4405: * for those with valid (non-0xff ff) status and message
4406: * bytes encoded in the result which signify command
4407: * completion.
4408: */
4409:
4410:
4411: save_flags(flags);
4412: cli();
4413: restart:
4414: for (cmd_prev_ptr = (struct NCR53c7x0_cmd **)
4415: &(hostdata->running_list), cmd =
4416: (struct NCR53c7x0_cmd *) hostdata->running_list; cmd ;
4417: cmd_prev_ptr = (struct NCR53c7x0_cmd **) &(cmd->next),
4418: cmd = (struct NCR53c7x0_cmd *) cmd->next) {
4419: Scsi_Cmnd *tmp;
4420:
4421: if (!cmd) {
4422: printk("scsi%d : very weird.\n", host->host_no);
4423: break;
4424: }
4425:
4426: if (!(tmp = cmd->cmd)) {
4427: printk("scsi%d : weird. NCR53c7x0_cmd has no Scsi_Cmnd\n",
4428: host->host_no);
4429: continue;
4430: }
4431: #if 0
4432: printk ("scsi%d : looking at result of 0x%x\n",
4433: host->host_no, cmd->cmd->result);
4434: #endif
4435:
4436: if (((tmp->result & 0xff) == 0xff) ||
4437: ((tmp->result & 0xff00) == 0xff00))
4438: continue;
4439:
4440: search_found = 1;
4441:
4442: /* Important - remove from list _before_ done is called */
4443: if (cmd_prev_ptr)
4444: *cmd_prev_ptr = (struct NCR53c7x0_cmd *) cmd->next;
4445:
4446: --hostdata->busy[tmp->target][tmp->lun];
4447: cmd->next = hostdata->free;
4448: hostdata->free = cmd;
4449:
4450: tmp->host_scribble = NULL;
4451:
4452: if (hostdata->options & OPTION_DEBUG_INTR) {
4453: printk ("scsi%d : command complete : pid %lu, id %d,lun %d result 0x%x ",
4454: host->host_no, tmp->pid, tmp->target, tmp->lun, tmp->result);
4455: print_command (tmp->cmnd);
4456: }
4457:
4458: #if 0
4459: hostdata->options &= ~OPTION_DEBUG_INTR;
4460: #endif
4461: tmp->scsi_done(tmp);
4462: goto restart;
4463:
4464: }
4465: restore_flags(flags);
4466:
4467: /*
4468: * I think that we're stacking INTFLY interrupts; taking care of
4469: * all the finished commands on the first one, and then getting
4470: * worried when we see the next one. The magic with have_intfly
4471: * should tell if this is the case..
4472: */
4473:
4474: if (!search_found && !have_intfly) {
4475: printk ("scsi%d : WARNING : INTFLY with no completed commands.\n",
4476: host->host_no);
4477: } else if (!have_intfly) {
4478: have_intfly = 1;
4479: run_process_issue_queue();
4480: }
4481: }
4482:
4483: if (istat & (ISTAT_SIP|ISTAT_DIP)) {
4484: done = 0;
4485: interrupted = 1;
4486: hostdata->state = STATE_HALTED;
4487:
4488: if (NCR53c7x0_read8 ((hostdata->chip / 100) == 8 ?
4489: SSTAT1_REG : SSTAT2_REG) & SSTAT2_FF_MASK)
4490: printk ("scsi%d : SCSI FIFO not empty\n",
4491: host->host_no);
4492:
4493: /*
4494: * NCR53c700 and NCR53c700-66 change the current SCSI
4495: * process, hostdata->current, in the Linux driver so
4496: * cmd = hostdata->current.
4497: *
4498: * With other chips, we must look through the commands
4499: * executing and find the command structure which
4500: * corresponds to the DSA register.
4501: */
4502:
4503: if (hostdata->options & OPTION_700) {
4504: cmd = (struct NCR53c7x0_cmd *) hostdata->current;
4505: } else {
4506: dsa = bus_to_virt(NCR53c7x0_read32(DSA_REG));
4507: for (cmd = (struct NCR53c7x0_cmd *)
4508: hostdata->running_list; cmd &&
4509: (dsa + (hostdata->dsa_start / sizeof(u32))) !=
4510: cmd->dsa;
4511: cmd = (struct NCR53c7x0_cmd *)(cmd->next));
4512: }
4513: if (hostdata->options & OPTION_DEBUG_INTR) {
4514: if (cmd) {
4515: printk("scsi%d : interrupt for pid %lu, id %d, lun %d ",
4516: host->host_no, cmd->cmd->pid, (int) cmd->cmd->target,
4517: (int) cmd->cmd->lun);
4518: print_command (cmd->cmd->cmnd);
4519: } else {
4520: printk("scsi%d : no active command\n", host->host_no);
4521: }
4522: }
4523:
4524: if (istat & ISTAT_SIP) {
4525: if (hostdata->options & OPTION_DEBUG_INTR)
4526: printk ("scsi%d : ISTAT_SIP\n", host->host_no);
4527: intr_scsi (host, cmd);
4528: }
4529:
4530: if (istat & ISTAT_DIP) {
4531: if (hostdata->options & OPTION_DEBUG_INTR)
4532: printk ("scsi%d : ISTAT_DIP\n", host->host_no);
4533: intr_dma (host, cmd);
4534: }
4535:
4536: if (!hostdata->dstat_valid) {
4537: hostdata->dstat = NCR53c7x0_read8(DSTAT_REG);
4538: hostdata->dstat_valid = 1;
4539: }
4540:
4541: /* XXX - code check for 700/800 chips */
4542: if (!(hostdata->dstat & DSTAT_DFE)) {
4543: printk ("scsi%d : DMA FIFO not empty\n", host->host_no);
4544: if (NCR53c7x0_read8 (CTEST2_REG_800) & CTEST2_800_DDIR) {
4545: printk ("scsi%d: Flushing DMA FIFO\n",
4546: host->host_no);
4547: NCR53c7x0_write8 (CTEST3_REG_800, CTEST3_800_FLF);
4548: while (!((hostdata->dstat = NCR53c7x0_read8(DSTAT_REG)) &
4549: DSTAT_DFE));
4550: } else
4551: {
4552: NCR53c7x0_write8 (CTEST3_REG_800, CTEST3_800_CLF);
4553: while (NCR53c7x0_read8 (CTEST3_REG_800) & CTEST3_800_CLF);
4554: }
4555: hostdata->dstat |= DSTAT_DFE;
4556: }
4557: }
4558: } while (interrupted);
4559:
4560:
4561:
4562: if (hostdata->intrs != -1)
4563: hostdata->intrs++;
4564: #if 0
4565: if (hostdata->intrs > 40) {
4566: printk("scsi%d : too many interrupts, halting", host->host_no);
4567: disable(host);
4568: }
4569: #endif
4570:
4571: if (!hostdata->idle && hostdata->state == STATE_HALTED) {
4572: if (!hostdata->dsp_changed) {
4573: hostdata->dsp = (u32 *)
4574: bus_to_virt(NCR53c7x0_read32(DSP_REG));
4575: }
4576:
4577: #if 0
4578: printk("scsi%d : new dsp is 0x%lx (virt 0x%p)\n",
4579: host->host_no, virt_to_bus(hostdata->dsp), hostdata->dsp);
4580: #endif
4581:
4582: hostdata->state = STATE_RUNNING;
4583: NCR53c7x0_write32 (DSP_REG, virt_to_bus(hostdata->dsp));
4584: }
4585: }
4586: } while (!done);
4587: }
4588:
4589:
4590: /*
4591: * Function : static int abort_connected (struct Scsi_Host *host)
4592: *
4593: * Purpose : Assuming that the NCR SCSI processor is currently
4594: * halted, break the currently established nexus. Clean
4595: * up of the NCR53c7x0_cmd and Scsi_Cmnd structures should
4596: * be done on receipt of the abort interrupt.
4597: *
4598: * Inputs : host - SCSI host
4599: *
4600: */
4601:
4602: static int
4603: abort_connected (struct Scsi_Host *host) {
4604: #ifdef NEW_ABORT
4605: NCR53c7x0_local_declare();
4606: #endif
4607: struct NCR53c7x0_hostdata *hostdata = (struct NCR53c7x0_hostdata *)
4608: host->hostdata;
4609: /* FIXME : this probably should change for production kernels; at the
4610: least, counter sould move to a per-host structure. */
4611: static int counter = 5;
4612: #ifdef NEW_ABORT
4613: int sstat, phase, offset;
4614: u32 *script;
4615: NCR53c7x0_local_setup(host);
4616: #endif
4617:
4618: if (--counter <= 0) {
4619: disable(host);
4620: return 0;
4621: }
4622:
4623: printk ("scsi%d : DANGER : abort_connected() called \n",
4624: host->host_no);
4625:
4626: #ifdef NEW_ABORT
4627:
4628: /*
4629: * New strategy : Rather than using a generic abort routine,
4630: * we'll specifically try to source or sink the appropriate
4631: * amount of data for the phase we're currently in (taking into
4632: * account the current synchronous offset)
4633: */
4634:
4635: sstat = (NCR53c8x0_read8 ((chip / 100) == 8 ? SSTAT1_REG : SSTAT2_REG);
4636: offset = OFFSET (sstat & SSTAT2_FF_MASK) >> SSTAT2_FF_SHIFT;
4637: phase = sstat & SSTAT2_PHASE_MASK;
4638:
4639: /*
4640: * SET ATN
4641: * MOVE source_or_sink, WHEN CURRENT PHASE
4642: * < repeat for each outstanding byte >
4643: * JUMP send_abort_message
4644: */
4645:
4646: script = hostdata->abort_script = kmalloc (
4647: 8 /* instruction size */ * (
4648: 1 /* set ATN */ +
4649: (!offset ? 1 : offset) /* One transfer per outstanding byte */ +
4650: 1 /* send abort message */),
4651: GFP_ATOMIC);
4652:
4653:
4654: #else /* def NEW_ABORT */
4655: hostdata->dsp = hostdata->script + hostdata->E_initiator_abort /
4656: sizeof(u32);
4657: #endif /* def NEW_ABORT */
4658: hostdata->dsp_changed = 1;
4659:
4660: /* XXX - need to flag the command as aborted after the abort_connected
4661: code runs
4662: */
4663: return 0;
4664: }
4665:
4666: /*
4667: * Function : static int datapath_residual (Scsi_Host *host)
4668: *
4669: * Purpose : return residual data count of what's in the chip.
4670: *
4671: * Inputs : host - SCSI host
4672: */
4673:
4674: static int
4675: datapath_residual (struct Scsi_Host *host) {
4676: NCR53c7x0_local_declare();
4677: struct NCR53c7x0_hostdata *hostdata = (struct NCR53c7x0_hostdata *)
4678: host->hostdata;
4679: int count, synchronous, sstat;
4680: NCR53c7x0_local_setup(host);
4681: /* COMPAT : the 700 and 700-66 need to use DFIFO_00_BO_MASK */
4682: count = ((NCR53c7x0_read8 (DFIFO_REG) & DFIFO_10_BO_MASK) -
4683: (NCR53c7x0_read32 (DBC_REG) & DFIFO_10_BO_MASK)) & DFIFO_10_BO_MASK;
4684: synchronous = NCR53c7x0_read8 (SXFER_REG) & SXFER_MO_MASK;
4685: /* COMPAT : DDIR is elsewhere on non-'8xx chips. */
4686: if (NCR53c7x0_read8 (CTEST2_REG_800) & CTEST2_800_DDIR) {
4687: /* Receive */
4688: if (synchronous)
4689: count += (NCR53c7x0_read8 ((hostdata->chip / 100) == 8 ?
4690: SSTAT1_REG : SSTAT2_REG) & SSTAT2_FF_MASK) >> SSTAT2_FF_SHIFT;
4691: else
4692: if (NCR53c7x0_read8 ((hostdata->chip / 100) == 8 ?
4693: SSTAT0_REG : SSTAT1_REG) & SSTAT1_ILF)
4694: ++count;
4695: } else {
4696: /* Send */
4697: sstat = ((hostdata->chip / 100) == 8) ? NCR53c7x0_read8 (SSTAT0_REG) :
4698: NCR53c7x0_read8 (SSTAT1_REG);
4699: if (sstat & SSTAT1_OLF)
4700: ++count;
4701: if (synchronous && (sstat & SSTAT1_ORF))
4702: ++count;
4703: }
4704: return count;
4705: }
4706:
4707: /*
4708: * Function : static const char * sbcl_to_phase (int sbcl)_
4709: *
4710: * Purpose : Convert SBCL register to user-parsable phase representation
4711: *
4712: * Inputs : sbcl - value of sbcl register
4713: */
4714:
4715:
4716: static const char *
4717: sbcl_to_phase (int sbcl) {
4718: switch (sbcl & SBCL_PHASE_MASK) {
4719: case SBCL_PHASE_DATAIN:
4720: return "DATAIN";
4721: case SBCL_PHASE_DATAOUT:
4722: return "DATAOUT";
4723: case SBCL_PHASE_MSGIN:
4724: return "MSGIN";
4725: case SBCL_PHASE_MSGOUT:
4726: return "MSGOUT";
4727: case SBCL_PHASE_CMDOUT:
4728: return "CMDOUT";
4729: case SBCL_PHASE_STATIN:
4730: return "STATUSIN";
4731: default:
4732: return "unknown";
4733: }
4734: }
4735:
4736: /*
4737: * Function : static const char * sstat2_to_phase (int sstat)_
4738: *
4739: * Purpose : Convert SSTAT2 register to user-parsable phase representation
4740: *
4741: * Inputs : sstat - value of sstat register
4742: */
4743:
4744:
4745: static const char *
4746: sstat2_to_phase (int sstat) {
4747: switch (sstat & SSTAT2_PHASE_MASK) {
4748: case SSTAT2_PHASE_DATAIN:
4749: return "DATAIN";
4750: case SSTAT2_PHASE_DATAOUT:
4751: return "DATAOUT";
4752: case SSTAT2_PHASE_MSGIN:
4753: return "MSGIN";
4754: case SSTAT2_PHASE_MSGOUT:
4755: return "MSGOUT";
4756: case SSTAT2_PHASE_CMDOUT:
4757: return "CMDOUT";
4758: case SSTAT2_PHASE_STATIN:
4759: return "STATUSIN";
4760: default:
4761: return "unknown";
4762: }
4763: }
4764:
4765: /*
4766: * Function : static void intr_phase_mismatch (struct Scsi_Host *host,
4767: * struct NCR53c7x0_cmd *cmd)
4768: *
4769: * Purpose : Handle phase mismatch interrupts
4770: *
4771: * Inputs : host, cmd - host and NCR command causing the interrupt, cmd
4772: * may be NULL.
4773: *
4774: * Side effects : The abort_connected() routine is called or the NCR chip
4775: * is restarted, jumping to the command_complete entry point, or
4776: * patching the address and transfer count of the current instruction
4777: * and calling the msg_in entry point as appropriate.
4778: */
4779:
4780: static void
4781: intr_phase_mismatch (struct Scsi_Host *host, struct NCR53c7x0_cmd *cmd) {
4782: NCR53c7x0_local_declare();
4783: u32 dbc_dcmd, *dsp, *dsp_next;
4784: unsigned char dcmd, sbcl;
4785: struct NCR53c7x0_hostdata *hostdata = (struct NCR53c7x0_hostdata *)
4786: host->hostdata;
4787: int residual;
4788: enum {ACTION_ABORT, ACTION_ABORT_PRINT, ACTION_CONTINUE} action =
4789: ACTION_ABORT_PRINT;
4790: const char *where = NULL;
4791: NCR53c7x0_local_setup(host);
4792:
4793: /*
4794: * Corrective action is based on where in the SCSI SCRIPT(tm) the error
4795: * occurred, as well as which SCSI phase we are currently in.
4796: */
4797: dsp_next = bus_to_virt(NCR53c7x0_read32(DSP_REG));
4798:
4799: /*
4800: * Fetch the current instruction, and remove the operands for easier
4801: * interpretation.
4802: */
4803: dbc_dcmd = NCR53c7x0_read32(DBC_REG);
4804: dcmd = (dbc_dcmd & 0xff000000) >> 24;
4805: /*
4806: * Like other processors, the NCR adjusts the instruction pointer before
4807: * instruction decode. Set the DSP address back to what it should
4808: * be for this instruction based on its size (2 or 3 32 bit words).
4809: */
4810: dsp = dsp_next - NCR53c7x0_insn_size(dcmd);
4811:
4812:
4813: /*
4814: * Read new SCSI phase from the SBCL lines. Since all of our code uses
4815: * a WHEN conditional instead of an IF conditional, we don't need to
4816: * wait for a new REQ.
4817: */
4818: sbcl = NCR53c7x0_read8(SBCL_REG) & SBCL_PHASE_MASK;
4819:
4820: if (!cmd) {
4821: action = ACTION_ABORT_PRINT;
4822: where = "no current command";
4823: /*
4824: * The way my SCSI SCRIPTS(tm) are architected, recoverable phase
4825: * mismatches should only occur where we're doing a multi-byte
4826: * BMI instruction. Specifically, this means
4827: *
4828: * - select messages (a SCSI-I target may ignore additional messages
4829: * after the IDENTIFY; any target may reject a SDTR or WDTR)
4830: *
4831: * - command out (targets may send a message to signal an error
4832: * condition, or go into STATUSIN after they've decided
4833: * they don't like the command.
4834: *
4835: * - reply_message (targets may reject a multi-byte message in the
4836: * middle)
4837: *
4838: * - data transfer routines (command completion with buffer space
4839: * left, disconnect message, or error message)
4840: */
4841: } else if (((dsp >= cmd->data_transfer_start &&
4842: dsp < cmd->data_transfer_end)) || dsp == (cmd->residual + 2)) {
4843: if ((dcmd & (DCMD_TYPE_MASK|DCMD_BMI_OP_MASK|DCMD_BMI_INDIRECT|
4844: DCMD_BMI_MSG|DCMD_BMI_CD)) == (DCMD_TYPE_BMI|
4845: DCMD_BMI_OP_MOVE_I)) {
4846: residual = datapath_residual (host);
4847: if (hostdata->options & OPTION_DEBUG_DISCONNECT)
4848: printk ("scsi%d : handling residual transfer (+ %d bytes from DMA FIFO)\n",
4849: host->host_no, residual);
4850:
4851: /*
4852: * The first instruction is a CALL to the alternate handler for
4853: * this data transfer phase, so we can do calls to
4854: * munge_msg_restart as we would if control were passed
4855: * from normal dynamic code.
4856: */
4857: if (dsp != cmd->residual + 2) {
4858: cmd->residual[0] = ((DCMD_TYPE_TCI | DCMD_TCI_OP_CALL |
4859: ((dcmd & DCMD_BMI_IO) ? DCMD_TCI_IO : 0)) << 24) |
4860: DBC_TCI_WAIT_FOR_VALID | DBC_TCI_COMPARE_PHASE;
4861: cmd->residual[1] = virt_to_bus(hostdata->script)
4862: + ((dcmd & DCMD_BMI_IO)
4863: ? hostdata->E_other_in : hostdata->E_other_out);
4864: }
4865:
4866: /*
4867: * The second instruction is the a data transfer block
4868: * move instruction, reflecting the pointer and count at the
4869: * time of the phase mismatch.
4870: */
4871: cmd->residual[2] = dbc_dcmd + residual;
4872: cmd->residual[3] = NCR53c7x0_read32(DNAD_REG) - residual;
4873:
4874: /*
4875: * The third and final instruction is a jump to the instruction
4876: * which follows the instruction which had to be 'split'
4877: */
4878: if (dsp != cmd->residual + 2) {
4879: cmd->residual[4] = ((DCMD_TYPE_TCI|DCMD_TCI_OP_JUMP)
4880: << 24) | DBC_TCI_TRUE;
4881: cmd->residual[5] = virt_to_bus(dsp_next);
4882: }
4883:
4884: /*
4885: * For the sake of simplicity, transfer control to the
4886: * conditional CALL at the start of the residual buffer.
4887: */
4888: hostdata->dsp = cmd->residual;
4889: hostdata->dsp_changed = 1;
4890: action = ACTION_CONTINUE;
4891: } else {
4892: where = "non-BMI dynamic DSA code";
4893: action = ACTION_ABORT_PRINT;
4894: }
4895: } else if (dsp == (hostdata->script + hostdata->E_select_msgout / 4)) {
4896: /* Release ATN */
4897: NCR53c7x0_write8 (SOCL_REG, 0);
4898: switch (sbcl) {
4899: /*
4900: * Some devices (SQ555 come to mind) grab the IDENTIFY message
4901: * sent on selection, and decide to go into COMMAND OUT phase
4902: * rather than accepting the rest of the messages or rejecting
4903: * them. Handle these devices gracefully.
4904: */
4905: case SBCL_PHASE_CMDOUT:
4906: hostdata->dsp = dsp + 2 /* two _words_ */;
4907: hostdata->dsp_changed = 1;
4908: printk ("scsi%d : target %d ignored SDTR and went into COMMAND OUT\n",
4909: host->host_no, cmd->cmd->target);
4910: cmd->flags &= ~CMD_FLAG_SDTR;
4911: action = ACTION_CONTINUE;
4912: break;
4913: case SBCL_PHASE_MSGIN:
4914: hostdata->dsp = hostdata->script + hostdata->E_msg_in /
4915: sizeof(u32);
4916: hostdata->dsp_changed = 1;
4917: action = ACTION_CONTINUE;
4918: break;
4919: default:
4920: where="select message out";
4921: action = ACTION_ABORT_PRINT;
4922: }
4923: /*
4924: * Some SCSI devices will interpret a command as they read the bytes
4925: * off the SCSI bus, and may decide that the command is Bogus before
4926: * they've read the entire commad off the bus.
4927: */
4928: } else if (dsp == hostdata->script + hostdata->E_cmdout_cmdout / sizeof
4929: (u32)) {
4930: hostdata->dsp = hostdata->script + hostdata->E_data_transfer /
4931: sizeof (u32);
4932: hostdata->dsp_changed = 1;
4933: action = ACTION_CONTINUE;
4934: /* FIXME : we need to handle message reject, etc. within msg_respond. */
4935: #ifdef notyet
4936: } else if (dsp == hostdata->script + hostdata->E_reply_message) {
4937: switch (sbcl) {
4938: /* Any other phase mismatches abort the currently executing command. */
4939: #endif
4940: } else {
4941: where = "unknown location";
4942: action = ACTION_ABORT_PRINT;
4943: }
4944:
4945: /* Flush DMA FIFO */
4946: if (!hostdata->dstat_valid) {
4947: hostdata->dstat = NCR53c7x0_read8(DSTAT_REG);
4948: hostdata->dstat_valid = 1;
4949: }
4950: if (!(hostdata->dstat & DSTAT_DFE)) {
4951: if (NCR53c7x0_read8 (CTEST2_REG_800) & CTEST2_800_DDIR) {
4952: printk ("scsi%d: Flushing DMA FIFO\n",
4953: host->host_no);
4954: NCR53c7x0_write8 (CTEST3_REG_800, CTEST3_800_FLF);
4955: /* FIXME : what about stacked DMA interrupts? */
4956: while (!((hostdata->dstat = NCR53c7x0_read8(DSTAT_REG)) &
4957: DSTAT_DFE));
4958: } else {
4959: NCR53c7x0_write8 (CTEST3_REG_800, CTEST3_800_CLF);
4960: while (NCR53c7x0_read8 (CTEST3_REG_800) & CTEST3_800_CLF);
4961: }
4962: hostdata->dstat |= DSTAT_DFE;
4963: }
4964:
4965: switch (action) {
4966: case ACTION_ABORT_PRINT:
4967: printk("scsi%d : %s : unexpected phase %s.\n",
4968: host->host_no, where ? where : "unknown location",
4969: sbcl_to_phase(sbcl));
4970: print_lots (host);
4971: /* Fall through to ACTION_ABORT */
4972: case ACTION_ABORT:
4973: abort_connected (host);
4974: break;
4975: case ACTION_CONTINUE:
4976: break;
4977: }
4978:
4979: #if 0
4980: if (hostdata->dsp_changed) {
4981: printk("scsi%d: new dsp 0x%p\n", host->host_no, hostdata->dsp);
4982: print_insn (host, hostdata->dsp, "", 1);
4983: }
4984: #endif
4985:
4986: }
4987:
4988: /*
4989: * Function : static void intr_bf (struct Scsi_Host *host,
4990: * struct NCR53c7x0_cmd *cmd)
4991: *
4992: * Purpose : handle BUS FAULT interrupts
4993: *
4994: * Inputs : host, cmd - host and NCR command causing the interrupt, cmd
4995: * may be NULL.
4996: */
4997:
4998: static void
4999: intr_bf (struct Scsi_Host *host, struct NCR53c7x0_cmd *cmd) {
5000: NCR53c7x0_local_declare();
5001: struct NCR53c7x0_hostdata *hostdata = (struct NCR53c7x0_hostdata *)
5002: host->hostdata;
5003: u32 *dsp,
5004: *next_dsp, /* Current dsp */
5005: *dsa,
5006: dbc_dcmd; /* DCMD (high eight bits) + DBC */
5007: unsigned short pci_status;
5008: int tmp;
5009: unsigned long flags;
5010: char *reason = NULL;
5011: /* Default behavior is for a silent error, with a retry until we've
5012: exhausted retries. */
5013: enum {MAYBE, ALWAYS, NEVER} retry = MAYBE;
5014: int report = 0;
5015: NCR53c7x0_local_setup(host);
5016:
5017: dbc_dcmd = NCR53c7x0_read32 (DBC_REG);
5018: next_dsp = bus_to_virt (NCR53c7x0_read32(DSP_REG));
5019: dsp = next_dsp - NCR53c7x0_insn_size ((dbc_dcmd >> 24) & 0xff);
5020: /* FIXME - check chip type */
5021: dsa = bus_to_virt (NCR53c7x0_read32(DSA_REG));
5022:
5023: /*
5024: * Bus faults can be caused by either a Bad Address or
5025: * Target Abort. We should check the Received Target Abort
5026: * bit of the PCI status register and Master Abort Bit.
5027: *
5028: * - Master Abort bit indicates that no device claimed
5029: * the address with DEVSEL within five clocks
5030: *
5031: * - Target Abort bit indicates that a target claimed it,
5032: * but changed its mind once it saw the byte enables.
5033: *
5034: */
5035:
5036: if ((hostdata->chip / 100) == 8) {
5037: save_flags (flags);
5038: cli();
5039: tmp = pcibios_read_config_word (hostdata->pci_bus,
5040: hostdata->pci_device_fn, PCI_STATUS, &pci_status);
5041: restore_flags (flags);
5042: if (tmp == PCIBIOS_SUCCESSFUL) {
5043: if (pci_status & PCI_STATUS_REC_TARGET_ABORT) {
5044: reason = "PCI target abort";
5045: pci_status &= ~PCI_STATUS_REC_TARGET_ABORT;
5046: } else if (pci_status & PCI_STATUS_REC_MASTER_ABORT) {
5047: reason = "No device asserted PCI DEVSEL within five bus clocks";
5048: pci_status &= ~PCI_STATUS_REC_MASTER_ABORT;
5049: } else if (pci_status & PCI_STATUS_PARITY) {
5050: report = 1;
5051: pci_status &= ~PCI_STATUS_PARITY;
5052: }
5053: } else {
5054: printk ("scsi%d : couldn't read status register : %s\n",
5055: host->host_no, pcibios_strerror (tmp));
5056: retry = NEVER;
5057: }
5058: }
5059:
5060: #ifndef notyet
5061: report = 1;
5062: #endif
5063: if (report && reason) {
5064: printk(KERN_ALERT "scsi%d : BUS FAULT reason = %s\n",
5065: host->host_no, reason ? reason : "unknown");
5066: print_lots (host);
5067: }
5068:
5069: #ifndef notyet
5070: retry = NEVER;
5071: #endif
5072:
5073: /*
5074: * TODO : we should attempt to recover from any spurious bus
5075: * faults. After X retries, we should figure that things are
5076: * sufficiently wedged, and call NCR53c7xx_reset.
5077: *
5078: * This code should only get executed once we've decided that we
5079: * cannot retry.
5080: */
5081:
5082: if (retry == NEVER) {
5083: printk(KERN_ALERT " mail [email protected]\n");
5084: FATAL (host);
5085: }
5086: }
5087:
5088: /*
5089: * Function : static void intr_dma (struct Scsi_Host *host,
5090: * struct NCR53c7x0_cmd *cmd)
5091: *
5092: * Purpose : handle all DMA interrupts, indicated by the setting
5093: * of the DIP bit in the ISTAT register.
5094: *
5095: * Inputs : host, cmd - host and NCR command causing the interrupt, cmd
5096: * may be NULL.
5097: */
5098:
5099: static void
5100: intr_dma (struct Scsi_Host *host, struct NCR53c7x0_cmd *cmd) {
5101: NCR53c7x0_local_declare();
5102: struct NCR53c7x0_hostdata *hostdata = (struct NCR53c7x0_hostdata *)
5103: host->hostdata;
5104: unsigned char dstat; /* DSTAT */
5105: u32 *dsp,
5106: *next_dsp, /* Current dsp */
5107: *dsa,
5108: dbc_dcmd; /* DCMD (high eight bits) + DBC */
5109: int tmp;
5110: unsigned long flags;
5111: NCR53c7x0_local_setup(host);
5112:
5113: if (!hostdata->dstat_valid) {
5114: hostdata->dstat = NCR53c7x0_read8(DSTAT_REG);
5115: hostdata->dstat_valid = 1;
5116: }
5117:
5118: dstat = hostdata->dstat;
5119:
5120: if (hostdata->options & OPTION_DEBUG_INTR)
5121: printk("scsi%d : DSTAT=0x%x\n", host->host_no, (int) dstat);
5122:
5123: dbc_dcmd = NCR53c7x0_read32 (DBC_REG);
5124: next_dsp = bus_to_virt(NCR53c7x0_read32(DSP_REG));
5125: dsp = next_dsp - NCR53c7x0_insn_size ((dbc_dcmd >> 24) & 0xff);
5126: /* XXX - check chip type */
5127: dsa = bus_to_virt(NCR53c7x0_read32(DSA_REG));
5128:
5129: /*
5130: * DSTAT_ABRT is the aborted interrupt. This is set whenever the
5131: * SCSI chip is aborted.
5132: *
5133: * With NCR53c700 and NCR53c700-66 style chips, we should only
5134: * get this when the chip is currently running the accept
5135: * reselect/select code and we have set the abort bit in the
5136: * ISTAT register.
5137: *
5138: */
5139:
5140: if (dstat & DSTAT_ABRT) {
5141: #if 0
5142: /* XXX - add code here to deal with normal abort */
5143: if ((hostdata->options & OPTION_700) && (hostdata->state ==
5144: STATE_ABORTING)) {
5145: } else
5146: #endif
5147: {
5148: printk(KERN_ALERT "scsi%d : unexpected abort interrupt at\n"
5149: " ", host->host_no);
5150: print_insn (host, dsp, KERN_ALERT "s ", 1);
5151: FATAL (host);
5152: }
5153: }
5154:
5155: /*
5156: * DSTAT_SSI is the single step interrupt. Should be generated
5157: * whenever we have single stepped or are tracing.
5158: */
5159:
5160: if (dstat & DSTAT_SSI) {
5161: if (hostdata->options & OPTION_DEBUG_TRACE) {
5162: } else if (hostdata->options & OPTION_DEBUG_SINGLE) {
5163: print_insn (host, dsp, "s ", 0);
5164: save_flags(flags);
5165: cli();
5166: /* XXX - should we do this, or can we get away with writing dsp? */
5167:
5168: NCR53c7x0_write8 (DCNTL_REG, (NCR53c7x0_read8(DCNTL_REG) &
5169: ~DCNTL_SSM) | DCNTL_STD);
5170: restore_flags(flags);
5171: } else {
5172: printk(KERN_ALERT "scsi%d : unexpected single step interrupt at\n"
5173: " ", host->host_no);
5174: print_insn (host, dsp, KERN_ALERT "", 1);
5175: printk(KERN_ALERT " mail [email protected]\n");
5176: FATAL (host);
5177: }
5178: }
5179:
5180: /*
5181: * DSTAT_IID / DSTAT_OPC (same bit, same meaning, only the name
5182: * is different) is generated whenever an illegal instruction is
5183: * encountered.
5184: *
5185: * XXX - we may want to emulate INTFLY here, so we can use
5186: * the same SCSI SCRIPT (tm) for NCR53c710 through NCR53c810
5187: * chips.
5188: */
5189:
5190: if (dstat & DSTAT_OPC) {
5191: /*
5192: * Ascertain if this IID interrupts occurred before or after a STO
5193: * interrupt. Since the interrupt handling code now leaves
5194: * DSP unmodified until _after_ all stacked interrupts have been
5195: * processed, reading the DSP returns the original DSP register.
5196: * This means that if dsp lies between the select code, and
5197: * message out following the selection code (where the IID interrupt
5198: * would have to have occurred by due to the implicit wait for REQ),
5199: * we have an IID interrupt resulting from a STO condition and
5200: * can ignore it.
5201: */
5202:
5203: if (((dsp >= (hostdata->script + hostdata->E_select / sizeof(u32))) &&
5204: (dsp <= (hostdata->script + hostdata->E_select_msgout /
5205: sizeof(u32) + 8))) || (hostdata->test_running == 2)) {
5206: if (hostdata->options & OPTION_DEBUG_INTR)
5207: printk ("scsi%d : ignoring DSTAT_IID for SSTAT_STO\n",
5208: host->host_no);
5209: if (hostdata->expecting_iid) {
5210: hostdata->expecting_iid = 0;
5211: hostdata->idle = 1;
5212: if (hostdata->test_running == 2) {
5213: hostdata->test_running = 0;
5214: hostdata->test_completed = 3;
5215: } else if (cmd)
5216: abnormal_finished (cmd, DID_BAD_TARGET << 16);
5217: } else {
5218: hostdata->expecting_sto = 1;
5219: }
5220: /*
5221: * We can't guarantee we'll be able to execute the WAIT DISCONNECT
5222: * instruction within the 3.4us of bus free and arbitration delay
5223: * that a target can RESELECT in and assert REQ after we've dropped
5224: * ACK. If this happens, we'll get an illegal instruction interrupt.
5225: * Doing away with the WAIT DISCONNECT instructions broke everything,
5226: * so instead I'll settle for moving one WAIT DISCONNECT a few
5227: * instructions closer to the CLEAR ACK before it to minimize the
5228: * chances of this happening, and handle it if it occurs anyway.
5229: *
5230: * Simply continue with what we were doing, and control should
5231: * be transfered to the schedule routine which will ultimately
5232: * pass control onto the reselection or selection (not yet)
5233: * code.
5234: */
5235: } else if (dbc_dcmd == 0x48000000 && (NCR53c7x0_read8 (SBCL_REG) &
5236: SBCL_REQ)) {
5237: if (!(hostdata->options & OPTION_NO_PRINT_RACE))
5238: {
5239: printk("scsi%d: REQ before WAIT DISCONNECT IID\n",
5240: host->host_no);
5241: hostdata->options |= OPTION_NO_PRINT_RACE;
5242: }
5243: } else {
5244: printk(KERN_ALERT "scsi%d : illegal instruction\n", host->host_no);
5245: print_lots (host);
5246: printk(KERN_ALERT " mail [email protected] with ALL\n"
5247: " boot messages and diagnostic output\n");
5248: FATAL (host);
5249: }
5250: }
5251:
5252: /*
5253: * DSTAT_BF are bus fault errors
5254: */
5255:
5256: if (dstat & DSTAT_800_BF) {
5257: intr_bf (host, cmd);
5258: }
5259:
5260:
5261: /*
5262: * DSTAT_SIR interrupts are generated by the execution of
5263: * the INT instruction. Since the exact values available
5264: * are determined entirely by the SCSI script running,
5265: * and are local to a particular script, a unique handler
5266: * is called for each script.
5267: */
5268:
5269: if (dstat & DSTAT_SIR) {
5270: if (hostdata->options & OPTION_DEBUG_INTR)
5271: printk ("scsi%d : DSTAT_SIR\n", host->host_no);
5272: switch ((tmp = hostdata->dstat_sir_intr (host, cmd))) {
5273: case SPECIFIC_INT_NOTHING:
5274: case SPECIFIC_INT_RESTART:
5275: break;
5276: case SPECIFIC_INT_ABORT:
5277: abort_connected(host);
5278: break;
5279: case SPECIFIC_INT_PANIC:
5280: printk(KERN_ALERT "scsi%d : failure at ", host->host_no);
5281: print_insn (host, dsp, KERN_ALERT "", 1);
5282: printk(KERN_ALERT " dstat_sir_intr() returned SPECIFIC_INT_PANIC\n");
5283: FATAL (host);
5284: break;
5285: case SPECIFIC_INT_BREAK:
5286: intr_break (host, cmd);
5287: break;
5288: default:
5289: printk(KERN_ALERT "scsi%d : failure at ", host->host_no);
5290: print_insn (host, dsp, KERN_ALERT "", 1);
5291: printk(KERN_ALERT" dstat_sir_intr() returned unknown value %d\n",
5292: tmp);
5293: FATAL (host);
5294: }
5295: }
5296:
5297: if ((hostdata->chip / 100) == 8 && (dstat & DSTAT_800_MDPE)) {
5298: printk(KERN_ALERT "scsi%d : Master Data Parity Error\n",
5299: host->host_no);
5300: FATAL (host);
5301: }
5302: }
5303:
5304: /*
5305: * Function : static int print_insn (struct Scsi_Host *host,
5306: * u32 *insn, int kernel)
5307: *
5308: * Purpose : print numeric representation of the instruction pointed
5309: * to by insn to the debugging or kernel message buffer
5310: * as appropriate.
5311: *
5312: * If desired, a user level program can interpret this
5313: * information.
5314: *
5315: * Inputs : host, insn - host, pointer to instruction, prefix -
5316: * string to prepend, kernel - use printk instead of debugging buffer.
5317: *
5318: * Returns : size, in u32s, of instruction printed.
5319: */
5320:
5321: /*
5322: * FIXME: should change kernel parameter so that it takes an ENUM
5323: * specifying severity - either KERN_ALERT or KERN_PANIC so
5324: * all panic messages are output with the same severity.
5325: */
5326:
5327: static int
5328: print_insn (struct Scsi_Host *host, const u32 *insn,
5329: const char *prefix, int kernel) {
5330: char buf[160], /* Temporary buffer and pointer. ICKY
5331: arbitrary length. */
5332:
5333:
5334: *tmp;
5335: unsigned char dcmd; /* dcmd register for *insn */
5336: int size;
5337:
5338: /*
5339: * Check to see if the instruction pointer is not bogus before
5340: * indirecting through it; avoiding red-zone at start of
5341: * memory.
5342: *
5343: * FIXME: icky magic needs to happen here on non-intel boxes which
5344: * don't have kernel memory mapped in like this. Might be reasonable
5345: * to use vverify()?
5346: */
5347:
5348: if (MAP_NR(insn) < 1 || MAP_NR(insn + 8) > MAP_NR(high_memory) ||
5349: ((((dcmd = (insn[0] >> 24) & 0xff) & DCMD_TYPE_MMI) == DCMD_TYPE_MMI) &&
5350: MAP_NR(insn + 12) > MAP_NR(high_memory))) {
5351: size = 0;
5352: sprintf (buf, "%s%p: address out of range\n",
5353: prefix, insn);
5354: } else {
5355: /*
5356: * FIXME : (void *) cast in virt_to_bus should be unecessary, because
5357: * it should take const void * as argument.
5358: */
5359: sprintf(buf, "%s0x%lx (virt 0x%p) : 0x%08x 0x%08x (virt 0x%p)",
5360: (prefix ? prefix : ""), virt_to_bus((void *) insn), insn,
5361: insn[0], insn[1], bus_to_virt (insn[1]));
5362: tmp = buf + strlen(buf);
5363: if ((dcmd & DCMD_TYPE_MASK) == DCMD_TYPE_MMI) {
5364: sprintf (tmp, " 0x%08x (virt 0x%p)\n", insn[2],
5365: bus_to_virt(insn[2]));
5366: size = 3;
5367: } else {
5368: sprintf (tmp, "\n");
5369: size = 2;
5370: }
5371: }
5372:
5373: if (kernel)
5374: printk ("%s", buf);
5375: #ifdef NCR_DEBUG
5376: else {
5377: size_t len = strlen(buf);
5378: debugger_kernel_write(host, buf, len);
5379: }
5380: #endif
5381: return size;
5382: }
5383:
5384: /*
5385: * Function : static const char *ncr_state (int state)
5386: *
5387: * Purpose : convert state (probably from hostdata->state) to a string
5388: *
5389: * Inputs : state
5390: *
5391: * Returns : char * representation of state, "unknown" on error.
5392: */
5393:
5394: static const char *
5395: ncr_state (int state) {
5396: switch (state) {
5397: case STATE_HALTED: return "halted";
5398: case STATE_WAITING: return "waiting";
5399: case STATE_RUNNING: return "running";
5400: case STATE_ABORTING: return "aborting";
5401: case STATE_DISABLED: return "disabled";
5402: default: return "unknown";
5403: }
5404: }
5405:
5406: /*
5407: * Function : int NCR53c7xx_abort (Scsi_Cmnd *cmd)
5408: *
5409: * Purpose : Abort an errant SCSI command, doing all necessary
5410: * cleanup of the issue_queue, running_list, shared Linux/NCR
5411: * dsa issue and reconnect queues.
5412: *
5413: * Inputs : cmd - command to abort, code - entire result field
5414: *
5415: * Returns : 0 on success, -1 on failure.
5416: */
5417:
5418: int
5419: NCR53c7xx_abort (Scsi_Cmnd *cmd) {
5420: NCR53c7x0_local_declare();
5421: struct Scsi_Host *host = cmd->host;
5422: struct NCR53c7x0_hostdata *hostdata = host ? (struct NCR53c7x0_hostdata *)
5423: host->hostdata : NULL;
5424: unsigned long flags;
5425: struct NCR53c7x0_cmd *curr, **prev;
5426: Scsi_Cmnd *me, **last;
5427: #if 0
5428: static long cache_pid = -1;
5429: #endif
5430:
5431:
5432: if (!host) {
5433: printk ("Bogus SCSI command pid %ld; no host structure\n",
5434: cmd->pid);
5435: return SCSI_ABORT_ERROR;
5436: } else if (!hostdata) {
5437: printk ("Bogus SCSI host %d; no hostdata\n", host->host_no);
5438: return SCSI_ABORT_ERROR;
5439: }
5440: NCR53c7x0_local_setup(host);
5441:
5442: /*
5443: * CHECK : I don't think that reading ISTAT will unstack any interrupts,
5444: * since we need to write the INTF bit to clear it, and SCSI/DMA
5445: * interrupts don't clear until we read SSTAT/SIST and DSTAT registers.
5446: *
5447: * See that this is the case.
5448: *
5449: * I suspect that several of our failures may be coming from a new fatal
5450: * interrupt (possibly due to a phase mismatch) happening after we've left
5451: * the interrupt handler, but before the PIC has had the interrupt condition
5452: * cleared.
5453: */
5454:
5455: if (NCR53c7x0_read8(hostdata->istat) &
5456: (ISTAT_DIP|ISTAT_SIP|
5457: (hostdata->chip / 100 == 8 ? ISTAT_800_INTF : 0))) {
5458: printk ("scsi%d : dropped interrupt for command %ld\n", host->host_no,
5459: cmd->pid);
5460: NCR53c7x0_intr (host->irq, NULL);
5461: return SCSI_ABORT_BUSY;
5462: }
5463:
5464: save_flags(flags);
5465: cli();
5466: #if 0
5467: if (cache_pid == cmd->pid)
5468: panic ("scsi%d : bloody fetus %d\n", host->host_no, cmd->pid);
5469: else
5470: cache_pid = cmd->pid;
5471: #endif
5472:
5473:
5474: /*
5475: * The command could be hiding in the issue_queue. This would be very
5476: * nice, as commands can't be moved from the high level driver's issue queue
5477: * into the shared queue until an interrupt routine is serviced, and this
5478: * moving is atomic.
5479: *
5480: * If this is the case, we don't have to worry about anything - we simply
5481: * pull the command out of the old queue, and call it aborted.
5482: */
5483:
5484: for (me = (Scsi_Cmnd *) hostdata->issue_queue,
5485: last = (Scsi_Cmnd **) &(hostdata->issue_queue);
5486: me && me != cmd; last = (Scsi_Cmnd **)&(me->SCp.ptr),
5487: me = (Scsi_Cmnd *)me->SCp.ptr);
5488:
5489: if (me) {
5490: *last = (Scsi_Cmnd *) me->SCp.ptr;
5491: if (me->host_scribble) {
5492: ((struct NCR53c7x0_cmd *)me->host_scribble)->next = hostdata->free;
5493: hostdata->free = (struct NCR53c7x0_cmd *) me->host_scribble;
5494: me->host_scribble = NULL;
5495: }
5496: cmd->result = DID_ABORT << 16;
5497: cmd->scsi_done(cmd);
5498: printk ("scsi%d : found command %ld in Linux issue queue\n",
5499: host->host_no, me->pid);
5500: restore_flags(flags);
5501: run_process_issue_queue();
5502: return SCSI_ABORT_SUCCESS;
5503: }
5504:
5505: /*
5506: * That failing, the command could be in our list of already executing
5507: * commands. If this is the case, drastic measures are called for.
5508: */
5509:
5510: for (curr = (struct NCR53c7x0_cmd *) hostdata->running_list,
5511: prev = (struct NCR53c7x0_cmd **) &(hostdata->running_list);
5512: curr && curr->cmd != cmd; prev = (struct NCR53c7x0_cmd **)
5513: &(curr->next), curr = (struct NCR53c7x0_cmd *) curr->next);
5514:
5515: if (curr) {
5516: if ((cmd->result & 0xff) != 0xff && (cmd->result & 0xff00) != 0xff00) {
5517: if (prev)
5518: *prev = (struct NCR53c7x0_cmd *) curr->next;
5519: curr->next = (struct NCR53c7x0_cmd *) hostdata->free;
5520: cmd->host_scribble = NULL;
5521: hostdata->free = curr;
5522: cmd->scsi_done(cmd);
5523: printk ("scsi%d : found finished command %ld in running list\n",
5524: host->host_no, cmd->pid);
5525: restore_flags(flags);
5526: return SCSI_ABORT_NOT_RUNNING;
5527: } else {
5528: printk ("scsi%d : DANGER : command running, can not abort.\n",
5529: cmd->host->host_no);
5530: restore_flags(flags);
5531: return SCSI_ABORT_BUSY;
5532: }
5533: }
5534:
5535: /*
5536: * And if we couldn't find it in any of our queues, it must have been
5537: * a dropped interrupt.
5538: */
5539:
5540: curr = (struct NCR53c7x0_cmd *) cmd->host_scribble;
5541: if (curr) {
5542: curr->next = hostdata->free;
5543: hostdata->free = curr;
5544: cmd->host_scribble = NULL;
5545: }
5546:
5547: if (((cmd->result & 0xff00) == 0xff00) ||
5548: ((cmd->result & 0xff) == 0xff)) {
5549: printk ("scsi%d : did this command ever run?\n", host->host_no);
5550: cmd->result = DID_ABORT << 16;
5551: } else {
5552: printk ("scsi%d : probably lost INTFLY, normal completion\n",
5553: host->host_no);
5554: /*
5555: * FIXME : We need to add an additional flag which indicates if a
5556: * command was ever counted as BUSY, so if we end up here we can
5557: * decrement the busy count if and only if it is necessary.
5558: */
5559: --hostdata->busy[cmd->target][cmd->lun];
5560: }
5561: restore_flags(flags);
5562: cmd->scsi_done(cmd);
5563:
5564: /*
5565: * We need to run process_issue_queue since termination of this command
5566: * may allow another queued command to execute first?
5567: */
5568: return SCSI_ABORT_NOT_RUNNING;
5569: }
5570:
5571: /*
5572: * Function : int NCR53c7xx_reset (Scsi_Cmnd *cmd)
5573: *
5574: * Purpose : perform a hard reset of the SCSI bus and NCR
5575: * chip.
5576: *
5577: * Inputs : cmd - command which caused the SCSI RESET
5578: *
5579: * Returns : 0 on success.
5580: */
5581:
5582: int
5583: NCR53c7xx_reset (Scsi_Cmnd *cmd) {
5584: NCR53c7x0_local_declare();
5585: unsigned long flags;
5586: int found = 0;
5587: struct NCR53c7x0_cmd * c;
5588: Scsi_Cmnd *tmp;
5589: /*
5590: * When we call scsi_done(), it's going to wake up anything sleeping on the
5591: * resources which were in use by the aborted commands, and we'll start to
5592: * get new commands.
5593: *
5594: * We can't let this happen until after we've re-initialized the driver
5595: * structures, and can't reinitilize those structures until after we've
5596: * dealt with their contents.
5597: *
5598: * So, we need to find all of the commands which were running, stick
5599: * them on a linked list of completed commands (we'll use the host_scribble
5600: * pointer), do our reinitialization, and then call the done function for
5601: * each command.
5602: */
5603: Scsi_Cmnd *nuke_list = NULL;
5604: struct Scsi_Host *host = cmd->host;
5605: struct NCR53c7x0_hostdata *hostdata =
5606: (struct NCR53c7x0_hostdata *) host->hostdata;
5607:
5608: NCR53c7x0_local_setup(host);
5609: save_flags(flags);
5610: cli();
5611: ncr_halt (host);
5612: print_lots (host);
5613: dump_events (host, 30);
5614: ncr_scsi_reset (host);
5615: for (tmp = nuke_list = return_outstanding_commands (host, 1 /* free */,
5616: 0 /* issue */ ); tmp; tmp = (Scsi_Cmnd *) tmp->SCp.buffer)
5617: if (tmp == cmd) {
5618: found = 1;
5619: break;
5620: }
5621:
5622: /*
5623: * If we didn't find the command which caused this reset in our running
5624: * list, then we've lost it. See that it terminates normally anyway.
5625: */
5626: if (!found) {
5627: c = (struct NCR53c7x0_cmd *) cmd->host_scribble;
5628: if (c) {
5629: cmd->host_scribble = NULL;
5630: c->next = hostdata->free;
5631: hostdata->free = c;
5632: } else
5633: printk ("scsi%d: lost command %ld\n", host->host_no, cmd->pid);
5634: cmd->SCp.buffer = (struct scatterlist *) nuke_list;
5635: nuke_list = cmd;
5636: }
5637:
5638: NCR53c7x0_driver_init (host);
5639: hostdata->soft_reset (host);
5640: if (hostdata->resets == 0)
5641: disable(host);
5642: else if (hostdata->resets != -1)
5643: --hostdata->resets;
5644: sti();
5645: for (; nuke_list; nuke_list = tmp) {
5646: tmp = (Scsi_Cmnd *) nuke_list->SCp.buffer;
5647: nuke_list->result = DID_RESET << 16;
5648: nuke_list->scsi_done (nuke_list);
5649: }
5650: restore_flags(flags);
5651: return SCSI_RESET_SUCCESS;
5652: }
5653:
5654: /*
5655: * The NCR SDMS bios follows Annex A of the SCSI-CAM draft, and
5656: * therefore shares the scsicam_bios_param function.
5657: */
5658:
5659: /*
5660: * Function : int insn_to_offset (Scsi_Cmnd *cmd, u32 *insn)
5661: *
5662: * Purpose : convert instructions stored at NCR pointer into data
5663: * pointer offset.
5664: *
5665: * Inputs : cmd - SCSI command; insn - pointer to instruction. Either current
5666: * DSP, or saved data pointer.
5667: *
5668: * Returns : offset on success, -1 on failure.
5669: */
5670:
5671:
5672: static int
5673: insn_to_offset (Scsi_Cmnd *cmd, u32 *insn) {
5674: struct NCR53c7x0_hostdata *hostdata =
5675: (struct NCR53c7x0_hostdata *) cmd->host->hostdata;
5676: struct NCR53c7x0_cmd *ncmd =
5677: (struct NCR53c7x0_cmd *) cmd->host_scribble;
5678: int offset = 0, buffers;
5679: struct scatterlist *segment;
5680: char *ptr;
5681: int found = 0;
5682:
5683: /*
5684: * With the current code implementation, if the insn is inside dynamically
5685: * generated code, the data pointer will be the instruction preceeding
5686: * the next transfer segment.
5687: */
5688:
5689: if (!check_address ((unsigned long) ncmd, sizeof (struct NCR53c7x0_cmd)) &&
5690: ((insn >= ncmd->data_transfer_start &&
5691: insn < ncmd->data_transfer_end) ||
5692: (insn >= ncmd->residual &&
5693: insn < (ncmd->residual +
5694: sizeof(ncmd->residual))))) {
5695: ptr = bus_to_virt(insn[3]);
5696:
5697: if ((buffers = cmd->use_sg)) {
5698: for (offset = 0,
5699: segment = (struct scatterlist *) cmd->buffer;
5700: buffers && !((found = ((ptr >= segment->address) &&
5701: (ptr < (segment->address + segment->length)))));
5702: --buffers, offset += segment->length, ++segment)
5703: #if 0
5704: printk("scsi%d: comparing 0x%p to 0x%p\n",
5705: cmd->host->host_no, saved, segment->address);
5706: #else
5707: ;
5708: #endif
5709: offset += ptr - segment->address;
5710: } else {
5711: found = 1;
5712: offset = ptr - (char *) (cmd->request_buffer);
5713: }
5714: } else if ((insn >= hostdata->script +
5715: hostdata->E_data_transfer / sizeof(u32)) &&
5716: (insn <= hostdata->script +
5717: hostdata->E_end_data_transfer / sizeof(u32))) {
5718: found = 1;
5719: offset = 0;
5720: }
5721: return found ? offset : -1;
5722: }
5723:
5724:
5725:
5726: /*
5727: * Function : void print_progress (Scsi_Cmnd *cmd)
5728: *
5729: * Purpose : print the current location of the saved data pointer
5730: *
5731: * Inputs : cmd - command we are interested in
5732: *
5733: */
5734:
5735: static void
5736: print_progress (Scsi_Cmnd *cmd) {
5737: NCR53c7x0_local_declare();
5738: struct NCR53c7x0_cmd *ncmd =
5739: (struct NCR53c7x0_cmd *) cmd->host_scribble;
5740: int offset, i;
5741: char *where;
5742: u32 *ptr;
5743: NCR53c7x0_local_setup (cmd->host);
5744: for (i = 0; i < 2; ++i) {
5745: if (check_address ((unsigned long) ncmd,
5746: sizeof (struct NCR53c7x0_cmd)) == -1)
5747: continue;
5748: if (!i) {
5749: where = "saved";
5750: ptr = bus_to_virt(ncmd->saved_data_pointer);
5751: } else {
5752: where = "active";
5753: ptr = bus_to_virt (NCR53c7x0_read32 (DSP_REG) -
5754: NCR53c7x0_insn_size (NCR53c7x0_read8 (DCMD_REG)) *
5755: sizeof(u32));
5756: }
5757: offset = insn_to_offset (cmd, ptr);
5758:
5759: if (offset != -1)
5760: printk ("scsi%d : %s data pointer at offset %d\n",
5761: cmd->host->host_no, where, offset);
5762: else {
5763: int size;
5764: printk ("scsi%d : can't determine %s data pointer offset\n",
5765: cmd->host->host_no, where);
5766: if (ncmd) {
5767: size = print_insn (cmd->host,
5768: bus_to_virt(ncmd->saved_data_pointer), "", 1);
5769: print_insn (cmd->host,
5770: bus_to_virt(ncmd->saved_data_pointer) + size * sizeof(u32),
5771: "", 1);
5772: }
5773: }
5774: }
5775: }
5776:
5777:
5778: static void
5779: print_dsa (struct Scsi_Host *host, u32 *dsa, const char *prefix) {
5780: struct NCR53c7x0_hostdata *hostdata = (struct NCR53c7x0_hostdata *)
5781: host->hostdata;
5782: int i, len;
5783: char *ptr;
5784: Scsi_Cmnd *cmd;
5785:
5786: if (check_address ((unsigned long) dsa, hostdata->dsa_end -
5787: hostdata->dsa_start) == -1) {
5788: printk("scsi%d : bad dsa virt 0x%p\n", host->host_no, dsa);
5789: return;
5790: }
5791: printk("%sscsi%d : dsa at phys 0x%lx (virt 0x%p)\n"
5792: " + %d : dsa_msgout length = %u, data = 0x%x (virt 0x%p)\n" ,
5793: prefix ? prefix : "",
5794: host->host_no, virt_to_bus (dsa), dsa, hostdata->dsa_msgout,
5795: dsa[hostdata->dsa_msgout / sizeof(u32)],
5796: dsa[hostdata->dsa_msgout / sizeof(u32) + 1],
5797: bus_to_virt (dsa[hostdata->dsa_msgout / sizeof(u32) + 1]));
5798:
5799: /*
5800: * Only print messages if they're sane in length so we don't
5801: * blow the kernel printk buffer on something which won't buy us
5802: * anything.
5803: */
5804:
5805: if (dsa[hostdata->dsa_msgout / sizeof(u32)] <
5806: sizeof (hostdata->free->select))
5807: for (i = dsa[hostdata->dsa_msgout / sizeof(u32)],
5808: ptr = bus_to_virt (dsa[hostdata->dsa_msgout / sizeof(u32) + 1]);
5809: i > 0 && !check_address ((unsigned long) ptr, 1);
5810: ptr += len, i -= len) {
5811: printk(" ");
5812: len = print_msg (ptr);
5813: printk("\n");
5814: if (!len)
5815: break;
5816: }
5817:
5818: printk(" + %d : select_indirect = 0x%x\n",
5819: hostdata->dsa_select, dsa[hostdata->dsa_select / sizeof(u32)]);
5820: cmd = (Scsi_Cmnd *) bus_to_virt(dsa[hostdata->dsa_cmnd / sizeof(u32)]);
5821: printk(" + %d : dsa_cmnd = 0x%x ", hostdata->dsa_cmnd,
5822: (u32) virt_to_bus(cmd));
5823: if (cmd) {
5824: printk(" result = 0x%x, target = %d, lun = %d, cmd = ",
5825: cmd->result, cmd->target, cmd->lun);
5826: print_command(cmd->cmnd);
5827: } else
5828: printk("\n");
5829: printk(" + %d : dsa_next = 0x%x\n", hostdata->dsa_next,
5830: dsa[hostdata->dsa_next / sizeof(u32)]);
5831: if (cmd) {
5832: printk("scsi%d target %d : sxfer_sanity = 0x%x, scntl3_sanity = 0x%x\n"
5833: " script : ",
5834: host->host_no, cmd->target,
5835: hostdata->sync[cmd->target].sxfer_sanity,
5836: hostdata->sync[cmd->target].scntl3_sanity);
5837: for (i = 0; i < (sizeof(hostdata->sync[cmd->target].script) / 4); ++i)
5838: printk ("0x%x ", hostdata->sync[cmd->target].script[i]);
5839: printk ("\n");
5840: print_progress (cmd);
5841: }
5842: }
5843: /*
5844: * Function : void print_queues (Scsi_Host *host)
5845: *
5846: * Purpose : print the contents of the NCR issue and reconnect queues
5847: *
5848: * Inputs : host - SCSI host we are interested in
5849: *
5850: */
5851:
5852: static void
5853: print_queues (struct Scsi_Host *host) {
5854: struct NCR53c7x0_hostdata *hostdata = (struct NCR53c7x0_hostdata *)
5855: host->hostdata;
5856: u32 *dsa, *next_dsa;
5857: volatile u32 *current;
5858: int left;
5859: Scsi_Cmnd *cmd, *next_cmd;
5860: unsigned long flags;
5861:
5862: printk ("scsi%d : issue queue\n", host->host_no);
5863:
5864: for (left = host->can_queue, cmd = (Scsi_Cmnd *) hostdata->issue_queue;
5865: left >= 0 && cmd;
5866: cmd = next_cmd) {
5867: next_cmd = (Scsi_Cmnd *) cmd->SCp.ptr;
5868: save_flags(flags);
5869: cli();
5870: if (cmd->host_scribble) {
5871: if (check_address ((unsigned long) (cmd->host_scribble),
5872: sizeof (cmd->host_scribble)) == -1)
5873: printk ("scsi%d: scsi pid %ld bad pointer to NCR53c7x0_cmd\n",
5874: host->host_no, cmd->pid);
5875: /* print_dsa does sanity check on address, no need to check */
5876: else
5877: print_dsa (host, ((struct NCR53c7x0_cmd *) cmd->host_scribble)
5878: -> dsa, "");
5879: } else
5880: printk ("scsi%d : scsi pid %ld for target %d lun %d has no NCR53c7x0_cmd\n",
5881: host->host_no, cmd->pid, cmd->target, cmd->lun);
5882: restore_flags(flags);
5883: }
5884:
5885: if (left <= 0) {
5886: printk ("scsi%d : loop detected in issue queue\n",
5887: host->host_no);
5888: }
5889:
5890: /*
5891: * Traverse the NCR reconnect and start DSA structures, printing out
5892: * each element until we hit the end or detect a loop. Currently,
5893: * the reconnect structure is a linked list; and the start structure
5894: * is an array. Eventually, the reconnect structure will become a
5895: * list as well, since this simplifies the code.
5896: */
5897:
5898: printk ("scsi%d : schedule dsa array :\n", host->host_no);
5899: for (left = host->can_queue, current = hostdata->schedule;
5900: left > 0; current += 2, --left)
5901: if (current[0] != hostdata->NOP_insn)
5902: /* FIXME : convert pointer to dsa_begin to pointer to dsa. */
5903: print_dsa (host, bus_to_virt (current[1] -
5904: (hostdata->E_dsa_code_begin -
5905: hostdata->E_dsa_code_template)), "");
5906: printk ("scsi%d : end schedule dsa array\n", host->host_no);
5907:
5908: printk ("scsi%d : reconnect_dsa_head :\n", host->host_no);
5909:
5910: for (left = host->can_queue,
5911: dsa = bus_to_virt (hostdata->reconnect_dsa_head);
5912: left >= 0 && dsa;
5913: dsa = next_dsa) {
5914: save_flags (flags);
5915: cli();
5916: if (check_address ((unsigned long) dsa, sizeof(dsa)) == -1) {
5917: printk ("scsi%d: bad DSA pointer 0x%p", host->host_no,
5918: dsa);
5919: next_dsa = NULL;
5920: }
5921: else
5922: {
5923: next_dsa = bus_to_virt(dsa[hostdata->dsa_next / sizeof(u32)]);
5924: print_dsa (host, dsa, "");
5925: }
5926: restore_flags(flags);
5927: }
5928: printk ("scsi%d : end reconnect_dsa_head\n", host->host_no);
5929: if (left < 0)
5930: printk("scsi%d: possible loop in ncr reconnect list\n",
5931: host->host_no);
5932: }
5933:
5934: static void
5935: print_lots (struct Scsi_Host *host) {
5936: NCR53c7x0_local_declare();
5937: struct NCR53c7x0_hostdata *hostdata =
5938: (struct NCR53c7x0_hostdata *) host->hostdata;
5939: u32 *dsp_next, *dsp, *dsa, dbc_dcmd;
5940: unsigned char dcmd, sbcl;
5941: int i, size;
5942: NCR53c7x0_local_setup(host);
5943:
5944: if ((dsp_next = bus_to_virt(NCR53c7x0_read32 (DSP_REG)))) {
5945: dbc_dcmd = NCR53c7x0_read32(DBC_REG);
5946: dcmd = (dbc_dcmd & 0xff000000) >> 24;
5947: dsp = dsp_next - NCR53c7x0_insn_size(dcmd);
5948: dsa = bus_to_virt(NCR53c7x0_read32(DSA_REG));
5949: sbcl = NCR53c7x0_read8 (SBCL_REG);
5950:
5951:
5952: printk ("scsi%d : DCMD|DBC=0x%x, DNAD=0x%x (virt 0x%p)\n"
5953: " DSA=0x%lx (virt 0x%p)\n"
5954: " DSPS=0x%x, TEMP=0x%x (virt 0x%p), DMODE=0x%x\n"
5955: " SXFER=0x%x, SCNTL3=0x%x\n"
5956: " %s%s%sphase=%s, %d bytes in SCSI FIFO\n"
5957: " STEST0=0x%x\n",
5958: host->host_no, dbc_dcmd, NCR53c7x0_read32(DNAD_REG),
5959: bus_to_virt(NCR53c7x0_read32(DNAD_REG)),
5960: virt_to_bus(dsa), dsa,
5961: NCR53c7x0_read32(DSPS_REG), NCR53c7x0_read32(TEMP_REG),
5962: bus_to_virt (NCR53c7x0_read32(TEMP_REG)),
5963: (int) NCR53c7x0_read8(hostdata->dmode),
5964: (int) NCR53c7x0_read8(SXFER_REG),
5965: (int) NCR53c7x0_read8(SCNTL3_REG_800),
5966: (sbcl & SBCL_BSY) ? "BSY " : "",
5967: (sbcl & SBCL_SEL) ? "SEL " : "",
5968: (sbcl & SBCL_REQ) ? "REQ " : "",
5969: sstat2_to_phase(NCR53c7x0_read8 (((hostdata->chip / 100) == 8) ?
5970: SSTAT1_REG : SSTAT2_REG)),
5971: (NCR53c7x0_read8 ((hostdata->chip / 100) == 8 ?
5972: SSTAT1_REG : SSTAT2_REG) & SSTAT2_FF_MASK) >> SSTAT2_FF_SHIFT,
5973: NCR53c7x0_read8 (STEST0_REG_800));
5974: printk ("scsi%d : DSP 0x%lx (virt 0x%p) ->\n", host->host_no,
5975: virt_to_bus(dsp), dsp);
5976: for (i = 6; i > 0; --i, dsp += size)
5977: size = print_insn (host, dsp, "", 1);
5978: if (NCR53c7x0_read8 (SCNTL1_REG) & SCNTL1_CON) {
5979: printk ("scsi%d : connected (SDID=0x%x, SSID=0x%x)\n",
5980: host->host_no, NCR53c7x0_read8 (SDID_REG_800),
5981: NCR53c7x0_read8 (SSID_REG_800));
5982: print_dsa (host, dsa, "");
5983: }
5984:
5985: #if 1
5986: print_queues (host);
5987: #endif
5988: }
5989: }
5990:
5991: /*
5992: * Function : static int shutdown (struct Scsi_Host *host)
5993: *
5994: * Purpose : does a clean (we hope) shutdown of the NCR SCSI
5995: * chip. Use prior to dumping core, unloading the NCR driver,
5996: *
5997: * Returns : 0 on success
5998: */
5999: static int
6000: shutdown (struct Scsi_Host *host) {
6001: NCR53c7x0_local_declare();
6002: unsigned long flags;
6003: struct NCR53c7x0_hostdata *hostdata = (struct NCR53c7x0_hostdata *)
6004: host->hostdata;
6005: NCR53c7x0_local_setup(host);
6006: save_flags (flags);
6007: cli();
6008: /* Get in a state where we can reset the SCSI bus */
6009: ncr_halt (host);
6010: ncr_scsi_reset (host);
6011: hostdata->soft_reset(host);
6012:
6013: disable (host);
6014: restore_flags (flags);
6015: return 0;
6016: }
6017:
6018: /*
6019: * Function : void ncr_scsi_reset (struct Scsi_Host *host)
6020: *
6021: * Purpose : reset the SCSI bus.
6022: */
6023:
6024: static void
6025: ncr_scsi_reset (struct Scsi_Host *host) {
6026: NCR53c7x0_local_declare();
6027: struct NCR53c7x0_hostdata *hostdata = (struct NCR53c7x0_hostdata *)
6028: host->hostdata;
6029: unsigned long flags;
6030: int sien = 0;
6031: NCR53c7x0_local_setup(host);
6032: save_flags (flags);
6033: cli();
6034: if ((hostdata->chip / 100) == 8) {
6035: sien = NCR53c7x0_read8(SIEN0_REG_800);
6036: NCR53c7x0_write8(SIEN0_REG_800, sien & ~SIEN_RST);
6037: }
6038: NCR53c7x0_write8(SCNTL1_REG, SCNTL1_RST);
6039: udelay(25); /* Minimum amount of time to assert RST */
6040: NCR53c7x0_write8(SCNTL1_REG, 0);
6041: if ((hostdata->chip / 100) == 8) {
6042: NCR53c7x0_write8(SIEN0_REG_800, sien);
6043: }
6044: restore_flags (flags);
6045: }
6046:
6047: /*
6048: * Function : void hard_reset (struct Scsi_Host *host)
6049: *
6050: */
6051:
6052: static void
6053: hard_reset (struct Scsi_Host *host) {
6054: struct NCR53c7x0_hostdata *hostdata = (struct NCR53c7x0_hostdata *)
6055: host->hostdata;
6056: unsigned long flags;
6057: save_flags (flags);
6058: cli();
6059: ncr_scsi_reset(host);
6060: NCR53c7x0_driver_init (host);
6061: if (hostdata->soft_reset)
6062: hostdata->soft_reset (host);
6063: restore_flags(flags);
6064: }
6065:
6066:
6067: /*
6068: * Function : Scsi_Cmnd *return_outstanding_commands (struct Scsi_Host *host,
6069: * int free, int issue)
6070: *
6071: * Purpose : return a linked list (using the SCp.buffer field as next,
6072: * so we don't perturb hostdata. We don't use a field of the
6073: * NCR53c7x0_cmd structure since we may not have allocated one
6074: * for the command causing the reset.) of Scsi_Cmnd structures that
6075: * had propogated bellow the Linux issue queue level. If free is set,
6076: * free the NCR53c7x0_cmd structures which are associated with
6077: * the Scsi_Cmnd structures, and clean up any internal
6078: * NCR lists that the commands were on. If issue is set,
6079: * also return commands in the issue queue.
6080: *
6081: * Returns : linked list of commands
6082: *
6083: * NOTE : the caller should insure that the NCR chip is halted
6084: * if the free flag is set.
6085: */
6086:
6087: static Scsi_Cmnd *
6088: return_outstanding_commands (struct Scsi_Host *host, int free, int issue) {
6089: struct NCR53c7x0_hostdata *hostdata = (struct NCR53c7x0_hostdata *)
6090: host->hostdata;
6091: struct NCR53c7x0_cmd *c;
6092: int i;
6093: u32 *current;
6094: Scsi_Cmnd *list = NULL, *tmp;
6095: for (c = (struct NCR53c7x0_cmd *) hostdata->running_list; c;
6096: c = (struct NCR53c7x0_cmd *) c->next) {
6097: if (c->cmd->SCp.buffer) {
6098: printk ("scsi%d : loop detected in running list!\n", host->host_no);
6099: break;
6100: } else {
6101: printk ("The sti() implicit in a printk() prevents hangs\n");
6102: break;
6103: }
6104:
6105: c->cmd->SCp.buffer = (struct scatterlist *) list;
6106: list = c->cmd;
6107: if (free) {
6108: c->next = hostdata->free;
6109: hostdata->free = c;
6110: }
6111: }
6112:
6113: if (free) {
6114: for (i = 0, current = (u32 *) hostdata->schedule;
6115: i < host->can_queue; ++i, current += 2) {
6116: current[0] = hostdata->NOP_insn;
6117: current[1] = 0xdeadbeef;
6118: }
6119: hostdata->current = NULL;
6120: }
6121:
6122: if (issue) {
6123: for (tmp = (Scsi_Cmnd *) hostdata->issue_queue; tmp; tmp = tmp->next) {
6124: if (tmp->SCp.buffer) {
6125: printk ("scsi%d : loop detected in issue queue!\n",
6126: host->host_no);
6127: break;
6128: }
6129: tmp->SCp.buffer = (struct scatterlist *) list;
6130: list = tmp;
6131: }
6132: if (free)
6133: hostdata->issue_queue = NULL;
6134:
6135: }
6136: return list;
6137: }
6138:
6139: /*
6140: * Function : static int disable (struct Scsi_Host *host)
6141: *
6142: * Purpose : disables the given NCR host, causing all commands
6143: * to return a driver error. Call this so we can unload the
6144: * module during development and try again. Eventually,
6145: * we should be able to find clean workarrounds for these
6146: * problems.
6147: *
6148: * Inputs : host - hostadapter to twiddle
6149: *
6150: * Returns : 0 on success.
6151: */
6152:
6153: static int
6154: disable (struct Scsi_Host *host) {
6155: struct NCR53c7x0_hostdata *hostdata = (struct NCR53c7x0_hostdata *)
6156: host->hostdata;
6157: unsigned long flags;
6158: Scsi_Cmnd *nuke_list, *tmp;
6159: save_flags(flags);
6160: cli();
6161: if (hostdata->state != STATE_HALTED)
6162: ncr_halt (host);
6163: nuke_list = return_outstanding_commands (host, 1 /* free */, 1 /* issue */);
6164: hard_reset (host);
6165: hostdata->state = STATE_DISABLED;
6166: restore_flags(flags);
6167: printk ("scsi%d : nuking commands\n", host->host_no);
6168: for (; nuke_list; nuke_list = tmp) {
6169: tmp = (Scsi_Cmnd *) nuke_list->SCp.buffer;
6170: nuke_list->result = DID_ERROR << 16;
6171: nuke_list->scsi_done(nuke_list);
6172: }
6173: printk ("scsi%d : done. \n", host->host_no);
6174: printk (KERN_ALERT "scsi%d : disabled. Unload and reload\n",
6175: host->host_no);
6176: return 0;
6177: }
6178:
6179: /*
6180: * Function : static int ncr_halt (struct Scsi_Host *host)
6181: *
6182: * Purpose : halts the SCSI SCRIPTS(tm) processor on the NCR chip
6183: *
6184: * Inputs : host - SCSI chip to halt
6185: *
6186: * Returns : 0 on success
6187: */
6188:
6189: static int
6190: ncr_halt (struct Scsi_Host *host) {
6191: NCR53c7x0_local_declare();
6192: unsigned long flags;
6193: unsigned char istat, tmp;
6194: struct NCR53c7x0_hostdata *hostdata = (struct NCR53c7x0_hostdata *)
6195: host->hostdata;
6196: int stage;
6197: NCR53c7x0_local_setup(host);
6198:
6199: save_flags(flags);
6200: cli();
6201: /* Stage 0 : eat all interrupts
6202: Stage 1 : set ABORT
6203: Stage 2 : eat all but abort interrupts
6204: Stage 3 : eat all interrupts
6205: */
6206: for (stage = 0;;) {
6207: if (stage == 1) {
6208: NCR53c7x0_write8(hostdata->istat, ISTAT_ABRT);
6209: ++stage;
6210: }
6211: istat = NCR53c7x0_read8 (hostdata->istat);
6212: if (istat & ISTAT_SIP) {
6213: if ((hostdata->chip / 100) == 8) {
6214: tmp = NCR53c7x0_read8(SIST0_REG_800);
6215: udelay(1);
6216: tmp = NCR53c7x0_read8(SIST1_REG_800);
6217: } else {
6218: tmp = NCR53c7x0_read8(SSTAT0_REG);
6219: }
6220: } else if (istat & ISTAT_DIP) {
6221: tmp = NCR53c7x0_read8(DSTAT_REG);
6222: if (stage == 2) {
6223: if (tmp & DSTAT_ABRT) {
6224: NCR53c7x0_write8(hostdata->istat, 0);
6225: ++stage;
6226: } else {
6227: printk(KERN_ALERT "scsi%d : could not halt NCR chip\n",
6228: host->host_no);
6229: disable (host);
6230: }
6231: }
6232: }
6233: if (!(istat & (ISTAT_SIP|ISTAT_DIP)))
6234: if (stage == 0)
6235: ++stage;
6236: else if (stage == 3)
6237: break;
6238: }
6239: hostdata->state = STATE_HALTED;
6240: restore_flags(flags);
6241: #if 0
6242: print_lots (host);
6243: #endif
6244: return 0;
6245: }
6246:
6247: /*
6248: * Function: event_name (int event)
6249: *
6250: * Purpose: map event enum into user-readable strings.
6251: */
6252:
6253: static const char *
6254: event_name (int event) {
6255: switch (event) {
6256: case EVENT_NONE: return "none";
6257: case EVENT_ISSUE_QUEUE: return "to issue queue";
6258: case EVENT_START_QUEUE: return "to start queue";
6259: case EVENT_SELECT: return "selected";
6260: case EVENT_DISCONNECT: return "disconnected";
6261: case EVENT_RESELECT: return "reselected";
6262: case EVENT_COMPLETE: return "completed";
6263: case EVENT_IDLE: return "idle";
6264: case EVENT_SELECT_FAILED: return "select failed";
6265: case EVENT_BEFORE_SELECT: return "before select";
6266: case EVENT_RESELECT_FAILED: return "reselect failed";
6267: default: return "unknown";
6268: }
6269: }
6270:
6271: /*
6272: * Function : void dump_events (struct Scsi_Host *host, count)
6273: *
6274: * Purpose : print last count events which have occurred.
6275: */
6276: static void
6277: dump_events (struct Scsi_Host *host, int count) {
6278: struct NCR53c7x0_hostdata *hostdata = (struct NCR53c7x0_hostdata *)
6279: host->hostdata;
6280: struct NCR53c7x0_event event;
6281: int i;
6282: unsigned long flags;
6283: if (hostdata->events) {
6284: if (count > hostdata->event_size)
6285: count = hostdata->event_size;
6286: for (i = hostdata->event_index; count > 0;
6287: i = (i ? i - 1 : hostdata->event_size -1), --count) {
6288: save_flags(flags);
6289: /*
6290: * By copying the event we're currently examinging with interrupts
6291: * disabled, we can do multiple printk(), etc. operations and
6292: * still be guaranteed that they're happening on the same
6293: * event structure.
6294: */
6295: cli();
6296: #if 0
6297: event = hostdata->events[i];
6298: #else
6299: memcpy ((void *) &event, (void *) &(hostdata->events[i]),
6300: sizeof(event));
6301: #endif
6302:
6303: restore_flags(flags);
6304: printk ("scsi%d : %s event %d at %ld secs %ld usecs target %d lun %d\n",
6305: host->host_no, event_name (event.event), count,
6306: (long) event.time.tv_sec, (long) event.time.tv_usec,
6307: event.target, event.lun);
6308: if (event.dsa)
6309: printk (" event for dsa 0x%lx (virt 0x%p)\n",
6310: virt_to_bus(event.dsa), event.dsa);
6311: if (event.pid != -1) {
6312: printk (" event for pid %ld ", event.pid);
6313: print_command (event.cmnd);
6314: }
6315: }
6316: }
6317: }
6318:
6319: /*
6320: * Function: check_address
6321: *
6322: * Purpose: Check to see if a possibly corrupt pointer will fault the
6323: * kernel.
6324: *
6325: * Inputs: addr - address; size - size of area
6326: *
6327: * Returns: 0 if area is OK, -1 on error.
6328: *
6329: * NOTES: should be implemented in terms of vverify on kernels
6330: * that have it.
6331: */
6332:
6333: static int
6334: check_address (unsigned long addr, int size) {
6335: return (MAP_NR(addr) < 1 || MAP_NR(addr + size) > MAP_NR(high_memory) ?
6336: -1 : 0);
6337: }
6338:
6339: #ifdef MODULE
6340: int
6341: NCR53c7x0_release(struct Scsi_Host *host) {
6342: struct NCR53c7x0_hostdata *hostdata =
6343: (struct NCR53c7x0_hostdata *) host->hostdata;
6344: struct NCR53c7x0_cmd *cmd, *tmp;
6345: shutdown (host);
6346: if (host->irq != IRQ_NONE)
6347: {
6348: int irq_count;
6349: struct Scsi_Host *tmp;
6350: for (irq_count = 0, tmp = first_host; tmp; tmp = tmp->next)
6351: if (tmp->hostt == the_template && tmp->irq == host->irq)
6352: ++irq_count;
6353: if (irq_count == 1)
6354: free_irq(host->irq);
6355: }
6356: if (host->dma_channel != DMA_NONE)
6357: free_dma(host->dma_channel);
6358: if (host->io_port)
6359: release_region(host->io_port, host->n_io_port);
6360:
6361: for (cmd = (struct NCR53c7x0_cmd *) hostdata->free; cmd; cmd = tmp,
6362: --hostdata->num_cmds) {
6363: tmp = (struct NCR53c7x0_cmd *) cmd->next;
6364: /*
6365: * If we're going to loop, try to stop it to get a more accurate
6366: * count of the leaked commands.
6367: */
6368: cmd->next = NULL;
6369: if (cmd->free)
6370: cmd->free ((void *) cmd->real, cmd->size);
6371: }
6372: if (hostdata->num_cmds)
6373: printk ("scsi%d : leaked %d NCR53c7x0_cmd structures\n",
6374: host->host_no, hostdata->num_cmds);
6375: if (hostdata->events)
6376: vfree ((void *)hostdata->events);
6377: return 1;
6378: }
6379: Scsi_Host_Template driver_template = NCR53c7xx;
6380: #include "scsi_module.c"
6381: #endif /* def MODULE */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.