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