kevin/linux
1
Fork 0
Code
365bbe0d0c
linux/drivers/scsi/53c7xx.c

6104 lines
191 KiB
C
Raw Normal View History

Linux-2.6.12-rc2 Initial git repository build. I'm not bothering with the full history, even though we have it. We can create a separate "historical" git archive of that later if we want to, and in the meantime it's about 3.2GB when imported into git - space that would just make the early git days unnecessarily complicated, when we don't have a lot of good infrastructure for it. Let it rip!
2005-04-16 15:20:36 -07:00
/*
* 53c710 driver. Modified from Drew Eckhardts driver
* for 53c810 by Richard Hirst [richard@sleepie.demon.co.uk]
* Check out PERM_OPTIONS and EXPECTED_CLOCK, which may be defined in the
* relevant machine specific file (eg. mvme16x.[ch], amiga7xx.[ch]).
* There are also currently some defines at the top of 53c7xx.scr.
* The chip type is #defined in script_asm.pl, as well as the Makefile.
* Host scsi ID expected to be 7 - see NCR53c7x0_init().
*
* I have removed the PCI code and some of the 53c8xx specific code -
* simply to make this file smaller and easier to manage.
*
* MVME16x issues:
* Problems trying to read any chip registers in NCR53c7x0_init(), as they
* may never have been set by 16xBug (eg. If kernel has come in over tftp).
*/
/*
* Adapted for Linux/m68k Amiga platforms for the A4000T/A4091 and
* WarpEngine SCSI controllers.
* By Alan Hourihane <alanh@fairlite.demon.co.uk>
* Thanks to Richard Hirst for making it possible with the MVME additions
*/
/*
* 53c710 rev 0 doesn't support add with carry. Rev 1 and 2 does. To
* overcome this problem you can define FORCE_DSA_ALIGNMENT, which ensures
* that the DSA address is always xxxxxx00. If disconnection is not allowed,
* then the script only ever tries to add small (< 256) positive offsets to
* DSA, so lack of carry isn't a problem. FORCE_DSA_ALIGNMENT can, of course,
* be defined for all chip revisions at a small cost in memory usage.
*/
#define FORCE_DSA_ALIGNMENT
/*
* Selection timer does not always work on the 53c710, depending on the
* timing at the last disconnect, if this is a problem for you, try
* using validids as detailed below.
*
* Options for the NCR7xx driver
*
* noasync:0 - disables sync and asynchronous negotiation
* nosync:0 - disables synchronous negotiation (does async)
* nodisconnect:0 - disables disconnection
* validids:0x?? - Bitmask field that disallows certain ID's.
* - e.g. 0x03 allows ID 0,1
* - 0x1F allows ID 0,1,2,3,4
* opthi:n - replace top word of options with 'n'
* optlo:n - replace bottom word of options with 'n'
* - ALWAYS SPECIFY opthi THEN optlo <<<<<<<<<<
*/
/*
* PERM_OPTIONS are driver options which will be enabled for all NCR boards
* in the system at driver initialization time.
*
* Don't THINK about touching these in PERM_OPTIONS :
* OPTION_MEMORY_MAPPED
* 680x0 doesn't have an IO map!
*
* OPTION_DEBUG_TEST1
* Test 1 does bus mastering and interrupt tests, which will help weed
* out brain damaged main boards.
*
* Other PERM_OPTIONS settings are listed below. Note the actual options
* required are set in the relevant file (mvme16x.c, amiga7xx.c, etc):
*
* OPTION_NO_ASYNC
* Don't negotiate for asynchronous transfers on the first command
* when OPTION_ALWAYS_SYNCHRONOUS is set. Useful for dain bramaged
* devices which do something bad rather than sending a MESSAGE
* REJECT back to us like they should if they can't cope.
*
* OPTION_SYNCHRONOUS
* Enable support for synchronous transfers. Target negotiated
* synchronous transfers will be responded to. To initiate
* a synchronous transfer request, call
*
* request_synchronous (hostno, target)
*
* from within KGDB.
*
* OPTION_ALWAYS_SYNCHRONOUS
* Negotiate for synchronous transfers with every target after
* driver initialization or a SCSI bus reset. This is a bit dangerous,
* since there are some dain bramaged SCSI devices which will accept
* SDTR messages but keep talking asynchronously.
*
* OPTION_DISCONNECT
* Enable support for disconnect/reconnect. To change the
* default setting on a given host adapter, call
*
* request_disconnect (hostno, allow)
*
* where allow is non-zero to allow, 0 to disallow.
*
* If you really want to run 10MHz FAST SCSI-II transfers, you should
* know that the NCR driver currently ignores parity information. Most
* systems do 5MHz SCSI fine. I've seen a lot that have problems faster
* than 8MHz. To play it safe, we only request 5MHz transfers.
*
* If you'd rather get 10MHz transfers, edit sdtr_message and change
* the fourth byte from 50 to 25.
*/
/*
* Sponsored by
* iX Multiuser Multitasking Magazine
* Hannover, Germany
* hm@ix.de
*
* Copyright 1993, 1994, 1995 Drew Eckhardt
* Visionary Computing
* (Unix and Linux consulting and custom programming)
* drew@PoohSticks.ORG
* +1 (303) 786-7975
*
* TolerANT and SCSI SCRIPTS are registered trademarks of NCR Corporation.
*
* For more information, please consult
*
* NCR53C810
* SCSI I/O Processor
* Programmer's Guide
*
* NCR 53C810
* PCI-SCSI I/O Processor
* Data Manual
*
* NCR 53C810/53C820
* PCI-SCSI I/O Processor Design In Guide
*
* For literature on Symbios Logic Inc. formerly NCR, SCSI,
* and Communication products please call (800) 334-5454 or
* (719) 536-3300.
*
* PCI BIOS Specification Revision
* PCI Local Bus Specification
* PCI System Design Guide
*
* PCI Special Interest Group
* M/S HF3-15A
* 5200 N.E. Elam Young Parkway
* Hillsboro, Oregon 97124-6497
* +1 (503) 696-2000
* +1 (800) 433-5177
*/
/*
* Design issues :
* The cumulative latency needed to propagate a read/write request
* through the file system, buffer cache, driver stacks, SCSI host, and
* SCSI device is ultimately the limiting factor in throughput once we
* have a sufficiently fast host adapter.
*
* So, to maximize performance we want to keep the ratio of latency to data
* transfer time to a minimum by
* 1. Minimizing the total number of commands sent (typical command latency
* including drive and bus mastering host overhead is as high as 4.5ms)
* to transfer a given amount of data.
*
* This is accomplished by placing no arbitrary limit on the number
* of scatter/gather buffers supported, since we can transfer 1K
* per scatter/gather buffer without Eric's cluster patches,
* 4K with.
*
* 2. Minimizing the number of fatal interrupts serviced, since
* fatal interrupts halt the SCSI I/O processor. Basically,
* this means offloading the practical maximum amount of processing
* to the SCSI chip.
*
* On the NCR53c810/820/720, this is accomplished by using
* interrupt-on-the-fly signals when commands complete,
* and only handling fatal errors and SDTR / WDTR messages
* in the host code.
*
* On the NCR53c710, interrupts are generated as on the NCR53c8x0,
* only the lack of a interrupt-on-the-fly facility complicates
* things. Also, SCSI ID registers and commands are
* bit fielded rather than binary encoded.
*
* On the NCR53c700 and NCR53c700-66, operations that are done via
* indirect, table mode on the more advanced chips must be
* replaced by calls through a jump table which
* acts as a surrogate for the DSA. Unfortunately, this
* will mean that we must service an interrupt for each
* disconnect/reconnect.
*
* 3. Eliminating latency by pipelining operations at the different levels.
*
* This driver allows a configurable number of commands to be enqueued
* for each target/lun combination (experimentally, I have discovered
* that two seems to work best) and will ultimately allow for
* SCSI-II tagged queuing.
*
*
* Architecture :
* This driver is built around a Linux queue of commands waiting to
* be executed, and a shared Linux/NCR array of commands to start. Commands
* are transferred to the array by the run_process_issue_queue() function
* which is called whenever a command completes.
*
* As commands are completed, the interrupt routine is triggered,
* looks for commands in the linked list of completed commands with
* valid status, removes these commands from a list of running commands,
* calls the done routine, and flags their target/luns as not busy.
*
* Due to limitations in the intelligence of the NCR chips, certain
* concessions are made. In many cases, it is easier to dynamically
* generate/fix-up code rather than calculate on the NCR at run time.
* So, code is generated or fixed up for
*
* - Handling data transfers, using a variable number of MOVE instructions
* interspersed with CALL MSG_IN, WHEN MSGIN instructions.
*
* The DATAIN and DATAOUT routines are separate, so that an incorrect
* direction can be trapped, and space isn't wasted.
*
* It may turn out that we're better off using some sort
* of table indirect instruction in a loop with a variable
* sized table on the NCR53c710 and newer chips.
*
* - Checking for reselection (NCR53c710 and better)
*
* - Handling the details of SCSI context switches (NCR53c710 and better),
* such as reprogramming appropriate synchronous parameters,
* removing the dsa structure from the NCR's queue of outstanding
* commands, etc.
*
*/
#include <linux/module.h>
#include <linux/types.h>
#include <asm/setup.h>
#include <asm/dma.h>
#include <asm/io.h>
#include <asm/system.h>
#include <linux/delay.h>
#include <linux/signal.h>
#include <linux/sched.h>
#include <linux/errno.h>
#include <linux/string.h>
#include <linux/slab.h>
#include <linux/vmalloc.h>
#include <linux/mm.h>
#include <linux/ioport.h>
#include <linux/time.h>
#include <linux/blkdev.h>
#include <linux/spinlock.h>
#include <linux/interrupt.h>
#include <asm/pgtable.h>
#ifdef CONFIG_AMIGA
#include <asm/amigahw.h>
#include <asm/amigaints.h>
#include <asm/irq.h>
#define BIG_ENDIAN
#define NO_IO_SPACE
#endif
#ifdef CONFIG_MVME16x
#include <asm/mvme16xhw.h>
#define BIG_ENDIAN
#define NO_IO_SPACE
#define VALID_IDS
#endif
#ifdef CONFIG_BVME6000
#include <asm/bvme6000hw.h>
#define BIG_ENDIAN
#define NO_IO_SPACE
#define VALID_IDS
#endif
#include "scsi.h"
[PATCH] remove outdated print_* functions We have the scsi_print_* functions in the proper namespace for a long time now and there weren't a lot users left. Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2005-04-03 12:53:59 -07:00
#include <scsi/scsi_dbg.h>
Linux-2.6.12-rc2 Initial git repository build. I'm not bothering with the full history, even though we have it. We can create a separate "historical" git archive of that later if we want to, and in the meantime it's about 3.2GB when imported into git - space that would just make the early git days unnecessarily complicated, when we don't have a lot of good infrastructure for it. Let it rip!
2005-04-16 15:20:36 -07:00
#include <scsi/scsi_host.h>
[SCSI] Rename scsi_print_msg to spi_print_msg Rename scsi_print_msg to spi_print_msg and move its prototype from scsi_dbg.h to scsi_transport_spi.h Signed-off-by: Matthew Wilcox <matthew@wil.cx> Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2005-12-15 14:22:01 -07:00
#include <scsi/scsi_transport_spi.h>
Linux-2.6.12-rc2 Initial git repository build. I'm not bothering with the full history, even though we have it. We can create a separate "historical" git archive of that later if we want to, and in the meantime it's about 3.2GB when imported into git - space that would just make the early git days unnecessarily complicated, when we don't have a lot of good infrastructure for it. Let it rip!
2005-04-16 15:20:36 -07:00
#include "53c7xx.h"
#include <linux/stat.h>
#include <linux/stddef.h>
#ifdef NO_IO_SPACE
/*
* The following make the definitions in 53c7xx.h (write8, etc) smaller,
* we don't have separate i/o space anyway.
*/
#undef inb
#undef outb
#undef inw
#undef outw
#undef inl
#undef outl
#define inb(x) 1
#define inw(x) 1
#define inl(x) 1
#define outb(x,y) 1
#define outw(x,y) 1
#define outl(x,y) 1
#endif
static int check_address (unsigned long addr, int size);
static void dump_events (struct Scsi_Host *host, int count);
static Scsi_Cmnd * return_outstanding_commands (struct Scsi_Host *host,
int free, int issue);
static void hard_reset (struct Scsi_Host *host);
static void ncr_scsi_reset (struct Scsi_Host *host);
static void print_lots (struct Scsi_Host *host);
static void set_synchronous (struct Scsi_Host *host, int target, int sxfer,
int scntl3, int now_connected);
static int datapath_residual (struct Scsi_Host *host);
static const char * sbcl_to_phase (int sbcl);
static void print_progress (Scsi_Cmnd *cmd);
static void print_queues (struct Scsi_Host *host);
static void process_issue_queue (unsigned long flags);
static int shutdown (struct Scsi_Host *host);
static void abnormal_finished (struct NCR53c7x0_cmd *cmd, int result);
static int disable (struct Scsi_Host *host);
static int NCR53c7xx_run_tests (struct Scsi_Host *host);
IRQ: Maintain regs pointer globally rather than passing to IRQ handlers Maintain a per-CPU global "struct pt_regs *" variable which can be used instead of passing regs around manually through all ~1800 interrupt handlers in the Linux kernel. The regs pointer is used in few places, but it potentially costs both stack space and code to pass it around. On the FRV arch, removing the regs parameter from all the genirq function results in a 20% speed up of the IRQ exit path (ie: from leaving timer_interrupt() to leaving do_IRQ()). Where appropriate, an arch may override the generic storage facility and do something different with the variable. On FRV, for instance, the address is maintained in GR28 at all times inside the kernel as part of general exception handling. Having looked over the code, it appears that the parameter may be handed down through up to twenty or so layers of functions. Consider a USB character device attached to a USB hub, attached to a USB controller that posts its interrupts through a cascaded auxiliary interrupt controller. A character device driver may want to pass regs to the sysrq handler through the input layer which adds another few layers of parameter passing. I've build this code with allyesconfig for x86_64 and i386. I've runtested the main part of the code on FRV and i386, though I can't test most of the drivers. I've also done partial conversion for powerpc and MIPS - these at least compile with minimal configurations. This will affect all archs. Mostly the changes should be relatively easy. Take do_IRQ(), store the regs pointer at the beginning, saving the old one: struct pt_regs *old_regs = set_irq_regs(regs); And put the old one back at the end: set_irq_regs(old_regs); Don't pass regs through to generic_handle_irq() or __do_IRQ(). In timer_interrupt(), this sort of change will be necessary: - update_process_times(user_mode(regs)); - profile_tick(CPU_PROFILING, regs); + update_process_times(user_mode(get_irq_regs())); + profile_tick(CPU_PROFILING); I'd like to move update_process_times()'s use of get_irq_regs() into itself, except that i386, alone of the archs, uses something other than user_mode(). Some notes on the interrupt handling in the drivers: (*) input_dev() is now gone entirely. The regs pointer is no longer stored in the input_dev struct. (*) finish_unlinks() in drivers/usb/host/ohci-q.c needs checking. It does something different depending on whether it's been supplied with a regs pointer or not. (*) Various IRQ handler function pointers have been moved to type irq_handler_t. Signed-Off-By: David Howells <dhowells@redhat.com> (cherry picked from 1b16e7ac850969f38b375e511e3fa2f474a33867 commit)
2006-10-05 06:55:46 -07:00
static irqreturn_t NCR53c7x0_intr(int irq, void *dev_id);
Linux-2.6.12-rc2 Initial git repository build. I'm not bothering with the full history, even though we have it. We can create a separate "historical" git archive of that later if we want to, and in the meantime it's about 3.2GB when imported into git - space that would just make the early git days unnecessarily complicated, when we don't have a lot of good infrastructure for it. Let it rip!
2005-04-16 15:20:36 -07:00
static void NCR53c7x0_intfly (struct Scsi_Host *host);
static int ncr_halt (struct Scsi_Host *host);
static void intr_phase_mismatch (struct Scsi_Host *host, struct NCR53c7x0_cmd
*cmd);
static void intr_dma (struct Scsi_Host *host, struct NCR53c7x0_cmd *cmd);
static void print_dsa (struct Scsi_Host *host, u32 *dsa,
const char *prefix);
static int print_insn (struct Scsi_Host *host, const u32 *insn,
const char *prefix, int kernel);
static void NCR53c7xx_dsa_fixup (struct NCR53c7x0_cmd *cmd);
static void NCR53c7x0_init_fixup (struct Scsi_Host *host);
static int NCR53c7x0_dstat_sir_intr (struct Scsi_Host *host, struct
NCR53c7x0_cmd *cmd);
static void NCR53c7x0_soft_reset (struct Scsi_Host *host);
/* Size of event list (per host adapter) */
static int track_events = 0;
static struct Scsi_Host *first_host = NULL; /* Head of list of NCR boards */
[SCSI] remove Scsi_Host_Template typedef Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2005-10-31 10:31:40 -07:00
static struct scsi_host_template *the_template = NULL;
Linux-2.6.12-rc2 Initial git repository build. I'm not bothering with the full history, even though we have it. We can create a separate "historical" git archive of that later if we want to, and in the meantime it's about 3.2GB when imported into git - space that would just make the early git days unnecessarily complicated, when we don't have a lot of good infrastructure for it. Let it rip!
2005-04-16 15:20:36 -07:00
/* NCR53c710 script handling code */
#include "53c7xx_d.h"
#ifdef A_int_debug_sync
#define DEBUG_SYNC_INTR A_int_debug_sync
#endif
int NCR53c7xx_script_len = sizeof (SCRIPT);
int NCR53c7xx_dsa_len = A_dsa_end + Ent_dsa_zero - Ent_dsa_code_template;
#ifdef FORCE_DSA_ALIGNMENT
int CmdPageStart = (0 - Ent_dsa_zero - sizeof(struct NCR53c7x0_cmd)) & 0xff;
#endif
static char *setup_strings[] =
{"","","","","","","",""};
[SCSI] drivers/scsi: Use ARRAY_SIZE macro Use ARRAY_SIZE macro instead of sizeof(x)/sizeof(x[0]) and remove duplicates of the macro. Signed-off-by: Tobias Klauser <tklauser@nuerscht.ch> Signed-off-by: Andrew Morton <akpm@osdl.org> Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-06-08 22:23:48 -07:00
#define MAX_SETUP_STRINGS ARRAY_SIZE(setup_strings)
Linux-2.6.12-rc2 Initial git repository build. I'm not bothering with the full history, even though we have it. We can create a separate "historical" git archive of that later if we want to, and in the meantime it's about 3.2GB when imported into git - space that would just make the early git days unnecessarily complicated, when we don't have a lot of good infrastructure for it. Let it rip!
2005-04-16 15:20:36 -07:00
#define SETUP_BUFFER_SIZE 200
static char setup_buffer[SETUP_BUFFER_SIZE];
static char setup_used[MAX_SETUP_STRINGS];
void ncr53c7xx_setup (char *str, int *ints)
{
int i;
char *p1, *p2;
p1 = setup_buffer;
*p1 = '\0';
if (str)
strncpy(p1, str, SETUP_BUFFER_SIZE - strlen(setup_buffer));
setup_buffer[SETUP_BUFFER_SIZE - 1] = '\0';
p1 = setup_buffer;
i = 0;
while (*p1 && (i < MAX_SETUP_STRINGS)) {
p2 = strchr(p1, ',');
if (p2) {
*p2 = '\0';
if (p1 != p2)
setup_strings[i] = p1;
p1 = p2 + 1;
i++;
}
else {
setup_strings[i] = p1;
break;
}
}
for (i=0; i<MAX_SETUP_STRINGS; i++)
setup_used[i] = 0;
}
/* check_setup_strings() returns index if key found, 0 if not
*/
static int check_setup_strings(char *key, int *flags, int *val, char *buf)
{
int x;
char *cp;
for (x=0; x<MAX_SETUP_STRINGS; x++) {
if (setup_used[x])
continue;
if (!strncmp(setup_strings[x], key, strlen(key)))
break;
if (!strncmp(setup_strings[x], "next", strlen("next")))
return 0;
}
if (x == MAX_SETUP_STRINGS)
return 0;
setup_used[x] = 1;
cp = setup_strings[x] + strlen(key);
*val = -1;
if (*cp != ':')
return ++x;
cp++;
if ((*cp >= '0') && (*cp <= '9')) {
*val = simple_strtoul(cp,NULL,0);
}
return ++x;
}
/*
* KNOWN BUGS :
* - There is some sort of conflict when the PPP driver is compiled with
* support for 16 channels?
*
* - On systems which predate the 1.3.x initialization order change,
* the NCR driver will cause Cannot get free page messages to appear.
* These are harmless, but I don't know of an easy way to avoid them.
*
* - With OPTION_DISCONNECT, on two systems under unknown circumstances,
* we get a PHASE MISMATCH with DSA set to zero (suggests that we
* are occurring somewhere in the reselection code) where
* DSP=some value DCMD|DBC=same value.
*
* Closer inspection suggests that we may be trying to execute
* some portion of the DSA?
* scsi0 : handling residual transfer (+ 0 bytes from DMA FIFO)
* scsi0 : handling residual transfer (+ 0 bytes from DMA FIFO)
* scsi0 : no current command : unexpected phase MSGIN.
* DSP=0x1c46cc, DCMD|DBC=0x1c46ac, DSA=0x0
* DSPS=0x0, TEMP=0x1c3e70, DMODE=0x80
* scsi0 : DSP->
* 001c46cc : 0x001c46cc 0x00000000
* 001c46d4 : 0x001c5ea0 0x000011f8
*
* Changed the print code in the phase_mismatch handler so
* that we call print_lots to try to diagnose this.
*
*/
/*
* Possible future direction of architecture for max performance :
*
* We're using a single start array for the NCR chip. This is
* sub-optimal, because we cannot add a command which would conflict with
* an executing command to this start queue, and therefore must insert the
* next command for a given I/T/L combination after the first has completed;
* incurring our interrupt latency between SCSI commands.
*
* To allow further pipelining of the NCR and host CPU operation, we want
* to set things up so that immediately on termination of a command destined
* for a given LUN, we get that LUN busy again.
*
* To do this, we need to add a 32 bit pointer to which is jumped to
* on completion of a command. If no new command is available, this
* would point to the usual DSA issue queue select routine.
*
* If one were, it would point to a per-NCR53c7x0_cmd select routine
* which starts execution immediately, inserting the command at the head
* of the start queue if the NCR chip is selected or reselected.
*
* We would change so that we keep a list of outstanding commands
* for each unit, rather than a single running_list. We'd insert
* a new command into the right running list; if the NCR didn't
* have something running for that yet, we'd put it in the
* start queue as well. Some magic needs to happen to handle the
* race condition between the first command terminating before the
* new one is written.
*
* Potential for profiling :
* Call do_gettimeofday(struct timeval *tv) to get 800ns resolution.
*/
/*
* TODO :
* 1. To support WIDE transfers, not much needs to happen. We
* should do CHMOVE instructions instead of MOVEs when
* we have scatter/gather segments of uneven length. When
* we do this, we need to handle the case where we disconnect
* between segments.
*
* 2. Currently, when Icky things happen we do a FATAL(). Instead,
* we want to do an integrity check on the parts of the NCR hostdata
* structure which were initialized at boot time; FATAL() if that
* fails, and otherwise try to recover. Keep track of how many
* times this has happened within a single SCSI command; if it
* gets excessive, then FATAL().
*
* 3. Parity checking is currently disabled, and a few things should
* happen here now that we support synchronous SCSI transfers :
* 1. On soft-reset, we shoould set the EPC (Enable Parity Checking)
* and AAP (Assert SATN/ on parity error) bits in SCNTL0.
*
* 2. We should enable the parity interrupt in the SIEN0 register.
*
* 3. intr_phase_mismatch() needs to believe that message out is
* always an "acceptable" phase to have a mismatch in. If
* the old phase was MSG_IN, we should send a MESSAGE PARITY
* error. If the old phase was something else, we should send
* a INITIATOR_DETECTED_ERROR message. Note that this could
* cause a RESTORE POINTERS message; so we should handle that
* correctly first. Instead, we should probably do an
* initiator_abort.
*
* 4. MPEE bit of CTEST4 should be set so we get interrupted if
* we detect an error.
*
*
* 5. The initial code has been tested on the NCR53c810. I don't
* have access to NCR53c700, 700-66 (Forex boards), NCR53c710
* (NCR Pentium systems), NCR53c720, NCR53c820, or NCR53c825 boards to
* finish development on those platforms.
*
* NCR53c820/825/720 - need to add wide transfer support, including WDTR
* negotiation, programming of wide transfer capabilities
* on reselection and table indirect selection.
*
* NCR53c710 - need to add fatal interrupt or GEN code for
* command completion signaling. Need to modify all
* SDID, SCID, etc. registers, and table indirect select code
* since these use bit fielded (ie 1<<target) instead of
* binary encoded target ids. Need to accommodate
* different register mappings, probably scan through
* the SCRIPT code and change the non SFBR register operand
* of all MOVE instructions.
*
* It is rather worse than this actually, the 710 corrupts
* both TEMP and DSA when you do a MOVE MEMORY. This
* screws you up all over the place. MOVE MEMORY 4 with a
* destination of DSA seems to work OK, which helps some.
* Richard Hirst richard@sleepie.demon.co.uk
*
* NCR53c700/700-66 - need to add code to refix addresses on
* every nexus change, eliminate all table indirect code,
* very messy.
*
* 6. The NCR53c7x0 series is very popular on other platforms that
* could be running Linux - ie, some high performance AMIGA SCSI
* boards use it.
*
* So, I should include #ifdef'd code so that it is
* compatible with these systems.
*
* Specifically, the little Endian assumptions I made in my
* bit fields need to change, and if the NCR doesn't see memory
* the right way, we need to provide options to reverse words
* when the scripts are relocated.
*
* 7. Use vremap() to access memory mapped boards.
*/
/*
* Allow for simultaneous existence of multiple SCSI scripts so we
* can have a single driver binary for all of the family.
*
* - one for NCR53c700 and NCR53c700-66 chips (not yet supported)
* - one for rest (only the NCR53c810, 815, 820, and 825 are currently
* supported)
*
* So that we only need two SCSI scripts, we need to modify things so
* that we fixup register accesses in READ/WRITE instructions, and
* we'll also have to accommodate the bit vs. binary encoding of IDs
* with the 7xx chips.
*/
#define ROUNDUP(adr,type) \
((void *) (((long) (adr) + sizeof(type) - 1) & ~(sizeof(type) - 1)))
/*
* Function: issue_to_cmd
*
* Purpose: convert jump instruction in issue array to NCR53c7x0_cmd
* structure pointer.
*
* Inputs; issue - pointer to start of NOP or JUMP instruction
* in issue array.
*
* Returns: pointer to command on success; 0 if opcode is NOP.
*/
static inline struct NCR53c7x0_cmd *
issue_to_cmd (struct Scsi_Host *host, struct NCR53c7x0_hostdata *hostdata,
u32 *issue)
{
return (issue[0] != hostdata->NOP_insn) ?
/*
* If the IF TRUE bit is set, it's a JUMP instruction. The
* operand is a bus pointer to the dsa_begin routine for this DSA. The
* dsa field of the NCR53c7x0_cmd structure starts with the
* DSA code template. By converting to a virtual address,
* subtracting the code template size, and offset of the
* dsa field, we end up with a pointer to the start of the
* structure (alternatively, we could use the
* dsa_cmnd field, an anachronism from when we weren't
* sure what the relationship between the NCR structures
* and host structures were going to be.
*/
(struct NCR53c7x0_cmd *) ((char *) bus_to_virt (issue[1]) -
(hostdata->E_dsa_code_begin - hostdata->E_dsa_code_template) -
offsetof(struct NCR53c7x0_cmd, dsa))
/* If the IF TRUE bit is not set, it's a NOP */
: NULL;
}
/*
* FIXME: we should junk these, in favor of synchronous_want and
* wide_want in the NCR53c7x0_hostdata structure.
*/
/* Template for "preferred" synchronous transfer parameters. */
static const unsigned char sdtr_message[] = {
#ifdef CONFIG_SCSI_NCR53C7xx_FAST
EXTENDED_MESSAGE, 3 /* length */, EXTENDED_SDTR, 25 /* *4ns */, 8 /* off */
#else
EXTENDED_MESSAGE, 3 /* length */, EXTENDED_SDTR, 50 /* *4ns */, 8 /* off */
#endif
};
/* Template to request asynchronous transfers */
static const unsigned char async_message[] = {
EXTENDED_MESSAGE, 3 /* length */, EXTENDED_SDTR, 0, 0 /* asynchronous */
};
/* Template for "preferred" WIDE transfer parameters */
static const unsigned char wdtr_message[] = {
EXTENDED_MESSAGE, 2 /* length */, EXTENDED_WDTR, 1 /* 2^1 bytes */
};
#if 0
/*
* Function : struct Scsi_Host *find_host (int host)
*
* Purpose : KGDB support function which translates a host number
* to a host structure.
*
* Inputs : host - number of SCSI host
*
* Returns : NULL on failure, pointer to host structure on success.
*/
static struct Scsi_Host *
find_host (int host) {
struct Scsi_Host *h;
for (h = first_host; h && h->host_no != host; h = h->next);
if (!h) {
printk (KERN_ALERT "scsi%d not found\n", host);
return NULL;
} else if (h->hostt != the_template) {
printk (KERN_ALERT "scsi%d is not a NCR board\n", host);
return NULL;
}
return h;
}
#if 0
/*
* Function : request_synchronous (int host, int target)
*
* Purpose : KGDB interface which will allow us to negotiate for
* synchronous transfers. This ill be replaced with a more
* integrated function; perhaps a new entry in the scsi_host
* structure, accessible via an ioctl() or perhaps /proc/scsi.
*
* Inputs : host - number of SCSI host; target - number of target.
*
* Returns : 0 when negotiation has been setup for next SCSI command,
* -1 on failure.
*/
static int
request_synchronous (int host, int target) {
struct Scsi_Host *h;
struct NCR53c7x0_hostdata *hostdata;
unsigned long flags;
if (target < 0) {
printk (KERN_ALERT "target %d is bogus\n", target);
return -1;
}
if (!(h = find_host (host)))
return -1;
else if (h->this_id == target) {
printk (KERN_ALERT "target %d is host ID\n", target);
return -1;
}
[SCSI] audit drivers for incorrect max_id use max_id now means the maximum number of ids on the bus, which means it is one greater than the largest possible id number. Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-05-23 01:29:28 -07:00
else if (target >= h->max_id) {
Linux-2.6.12-rc2 Initial git repository build. I'm not bothering with the full history, even though we have it. We can create a separate "historical" git archive of that later if we want to, and in the meantime it's about 3.2GB when imported into git - space that would just make the early git days unnecessarily complicated, when we don't have a lot of good infrastructure for it. Let it rip!
2005-04-16 15:20:36 -07:00
printk (KERN_ALERT "target %d exceeds maximum of %d\n", target,
h->max_id);
return -1;
}
hostdata = (struct NCR53c7x0_hostdata *)h->hostdata[0];
local_irq_save(flags);
if (hostdata->initiate_sdtr & (1 << target)) {
local_irq_restore(flags);
printk (KERN_ALERT "target %d already doing SDTR\n", target);
return -1;
}
hostdata->initiate_sdtr |= (1 << target);
local_irq_restore(flags);
return 0;
}
#endif
/*
* Function : request_disconnect (int host, int on_or_off)
*
* Purpose : KGDB support function, tells us to allow or disallow
* disconnections.
*
* Inputs : host - number of SCSI host; on_or_off - non-zero to allow,
* zero to disallow.
*
* Returns : 0 on success, * -1 on failure.
*/
static int
request_disconnect (int host, int on_or_off) {
struct Scsi_Host *h;
struct NCR53c7x0_hostdata *hostdata;
if (!(h = find_host (host)))
return -1;
hostdata = (struct NCR53c7x0_hostdata *) h->hostdata[0];
if (on_or_off)
hostdata->options |= OPTION_DISCONNECT;
else
hostdata->options &= ~OPTION_DISCONNECT;
return 0;
}
#endif
/*
* Function : static void NCR53c7x0_driver_init (struct Scsi_Host *host)
*
* Purpose : Initialize internal structures, as required on startup, or
* after a SCSI bus reset.
*
* Inputs : host - pointer to this host adapter's structure
*/
static void
NCR53c7x0_driver_init (struct Scsi_Host *host) {
struct NCR53c7x0_hostdata *hostdata = (struct NCR53c7x0_hostdata *)
host->hostdata[0];
int i, j;
u32 *ncrcurrent;
for (i = 0; i < 16; ++i) {
hostdata->request_sense[i] = 0;
for (j = 0; j < 8; ++j)
hostdata->busy[i][j] = 0;
set_synchronous (host, i, /* sxfer */ 0, hostdata->saved_scntl3, 0);
}
hostdata->issue_queue = NULL;
hostdata->running_list = hostdata->finished_queue =
hostdata->ncrcurrent = NULL;
for (i = 0, ncrcurrent = (u32 *) hostdata->schedule;
i < host->can_queue; ++i, ncrcurrent += 2) {
ncrcurrent[0] = hostdata->NOP_insn;
ncrcurrent[1] = 0xdeadbeef;
}
ncrcurrent[0] = ((DCMD_TYPE_TCI|DCMD_TCI_OP_JUMP) << 24) | DBC_TCI_TRUE;
ncrcurrent[1] = (u32) virt_to_bus (hostdata->script) +
hostdata->E_wait_reselect;
hostdata->reconnect_dsa_head = 0;
hostdata->addr_reconnect_dsa_head = (u32)
virt_to_bus((void *) &(hostdata->reconnect_dsa_head));
hostdata->expecting_iid = 0;
hostdata->expecting_sto = 0;
if (hostdata->options & OPTION_ALWAYS_SYNCHRONOUS)
hostdata->initiate_sdtr = 0xffff;
else
hostdata->initiate_sdtr = 0;
hostdata->talked_to = 0;
hostdata->idle = 1;
}
/*
* Function : static int clock_to_ccf_710 (int clock)
*
* Purpose : Return the clock conversion factor for a given SCSI clock.
*
* Inputs : clock - SCSI clock expressed in Hz.
*
* Returns : ccf on success, -1 on failure.
*/
static int
clock_to_ccf_710 (int clock) {
if (clock <= 16666666)
return -1;
if (clock <= 25000000)
return 2; /* Divide by 1.0 */
else if (clock <= 37500000)
return 1; /* Divide by 1.5 */
else if (clock <= 50000000)
return 0; /* Divide by 2.0 */
else if (clock <= 66000000)
return 3; /* Divide by 3.0 */
else
return -1;
}
/*
* Function : static int NCR53c7x0_init (struct Scsi_Host *host)
*
* Purpose : initialize the internal structures for a given SCSI host
*
* Inputs : host - pointer to this host adapter's structure
*
* Preconditions : when this function is called, the chip_type
* field of the hostdata structure MUST have been set.
*
* Returns : 0 on success, -1 on failure.
*/
int
NCR53c7x0_init (struct Scsi_Host *host) {
NCR53c7x0_local_declare();
int i, ccf;
unsigned char revision;
struct NCR53c7x0_hostdata *hostdata = (struct NCR53c7x0_hostdata *)
host->hostdata[0];
/*
* There are some things which we need to know about in order to provide
* a semblance of support. Print 'em if they aren't what we expect,
* otherwise don't add to the noise.
*
* -1 means we don't know what to expect.
*/
int val, flags;
char buf[32];
int expected_id = -1;
int expected_clock = -1;
int uninitialized = 0;
#ifdef NO_IO_SPACE
int expected_mapping = OPTION_MEMORY_MAPPED;
#else
int expected_mapping = OPTION_IO_MAPPED;
#endif
for (i=0;i<7;i++)
hostdata->valid_ids[i] = 1; /* Default all ID's to scan */
/* Parse commandline flags */
if (check_setup_strings("noasync",&flags,&val,buf))
{
hostdata->options |= OPTION_NO_ASYNC;
hostdata->options &= ~(OPTION_SYNCHRONOUS | OPTION_ALWAYS_SYNCHRONOUS);
}
if (check_setup_strings("nosync",&flags,&val,buf))
{
hostdata->options &= ~(OPTION_SYNCHRONOUS | OPTION_ALWAYS_SYNCHRONOUS);
}
if (check_setup_strings("nodisconnect",&flags,&val,buf))
hostdata->options &= ~OPTION_DISCONNECT;
if (check_setup_strings("validids",&flags,&val,buf))
{
for (i=0;i<7;i++)
hostdata->valid_ids[i] = val & (1<<i);
}
if ((i = check_setup_strings("next",&flags,&val,buf)))
{
while (i)
setup_used[--i] = 1;
}
if (check_setup_strings("opthi",&flags,&val,buf))
hostdata->options = (long long)val << 32;
if (check_setup_strings("optlo",&flags,&val,buf))
hostdata->options |= val;
NCR53c7x0_local_setup(host);
switch (hostdata->chip) {
case 710:
case 770:
hostdata->dstat_sir_intr = NCR53c7x0_dstat_sir_intr;
hostdata->init_save_regs = NULL;
hostdata->dsa_fixup = NCR53c7xx_dsa_fixup;
hostdata->init_fixup = NCR53c7x0_init_fixup;
hostdata->soft_reset = NCR53c7x0_soft_reset;
hostdata->run_tests = NCR53c7xx_run_tests;
expected_clock = hostdata->scsi_clock;
expected_id = 7;
break;
default:
printk ("scsi%d : chip type of %d is not supported yet, detaching.\n",
host->host_no, hostdata->chip);
scsi_unregister (host);
return -1;
}
/* Assign constants accessed by NCR */
hostdata->NCR53c7xx_zero = 0;
hostdata->NCR53c7xx_msg_reject = MESSAGE_REJECT;
hostdata->NCR53c7xx_msg_abort = ABORT;
hostdata->NCR53c7xx_msg_nop = NOP;
hostdata->NOP_insn = (DCMD_TYPE_TCI|DCMD_TCI_OP_JUMP) << 24;
if (expected_mapping == -1 ||
(hostdata->options & (OPTION_MEMORY_MAPPED)) !=
(expected_mapping & OPTION_MEMORY_MAPPED))
printk ("scsi%d : using %s mapped access\n", host->host_no,
(hostdata->options & OPTION_MEMORY_MAPPED) ? "memory" :
"io");
hostdata->dmode = (hostdata->chip == 700 || hostdata->chip == 70066) ?
DMODE_REG_00 : DMODE_REG_10;
hostdata->istat = ((hostdata->chip / 100) == 8) ?
ISTAT_REG_800 : ISTAT_REG_700;
/* We have to assume that this may be the first access to the chip, so
* we must set EA in DCNTL. */
NCR53c7x0_write8 (DCNTL_REG, DCNTL_10_EA|DCNTL_10_COM);
/* Only the ISTAT register is readable when the NCR is running, so make
sure it's halted. */
ncr_halt(host);
/*
* XXX - the NCR53c700 uses bitfielded registers for SCID, SDID, etc,
* as does the 710 with one bit per SCSI ID. Conversely, the NCR
* uses a normal, 3 bit binary representation of these values.
*
* Get the rest of the NCR documentation, and FIND OUT where the change
* was.
*/
#if 0
/* May not be able to do this - chip my not have been set up yet */
tmp = hostdata->this_id_mask = NCR53c7x0_read8(SCID_REG);
for (host->this_id = 0; tmp != 1; tmp >>=1, ++host->this_id);
#else
host->this_id = 7;
#endif
/*
* Note : we should never encounter a board setup for ID0. So,
* if we see ID0, assume that it was uninitialized and set it
* to the industry standard 7.
*/
if (!host->this_id) {
printk("scsi%d : initiator ID was %d, changing to 7\n",
host->host_no, host->this_id);
host->this_id = 7;
hostdata->this_id_mask = 1 << 7;
uninitialized = 1;
};
if (expected_id == -1 || host->this_id != expected_id)
printk("scsi%d : using initiator ID %d\n", host->host_no,
host->this_id);
/*
* Save important registers to allow a soft reset.
*/
/*
* CTEST7 controls cache snooping, burst mode, and support for
* external differential drivers. This isn't currently used - the
* default value may not be optimal anyway.
* Even worse, it may never have been set up since reset.
*/
hostdata->saved_ctest7 = NCR53c7x0_read8(CTEST7_REG) & CTEST7_SAVE;
revision = (NCR53c7x0_read8(CTEST8_REG) & 0xF0) >> 4;
switch (revision) {
case 1: revision = 0; break;
case 2: revision = 1; break;
case 4: revision = 2; break;
case 8: revision = 3; break;
default: revision = 255; break;
}
printk("scsi%d: Revision 0x%x\n",host->host_no,revision);
if ((revision == 0 || revision == 255) && (hostdata->options & (OPTION_SYNCHRONOUS|OPTION_DISCONNECT|OPTION_ALWAYS_SYNCHRONOUS)))
{
printk ("scsi%d: Disabling sync working and disconnect/reselect\n",
host->host_no);
hostdata->options &= ~(OPTION_SYNCHRONOUS|OPTION_DISCONNECT|OPTION_ALWAYS_SYNCHRONOUS);
}
/*
* On NCR53c700 series chips, DCNTL controls the SCSI clock divisor,
* on 800 series chips, it allows for a totem-pole IRQ driver.
* NOTE saved_dcntl currently overwritten in init function.
* The value read here may be garbage anyway, MVME16x board at least
* does not initialise chip if kernel arrived via tftp.
*/
hostdata->saved_dcntl = NCR53c7x0_read8(DCNTL_REG);
/*
* DMODE controls DMA burst length, and on 700 series chips,
* 286 mode and bus width
* NOTE: On MVME16x, chip may have been reset, so this could be a
* power-on/reset default value.
*/
hostdata->saved_dmode = NCR53c7x0_read8(hostdata->dmode);
/*
* Now that burst length and enabled/disabled status is known,
* clue the user in on it.
*/
ccf = clock_to_ccf_710 (expected_clock);
for (i = 0; i < 16; ++i)
hostdata->cmd_allocated[i] = 0;
if (hostdata->init_save_regs)
hostdata->init_save_regs (host);
if (hostdata->init_fixup)
hostdata->init_fixup (host);
if (!the_template) {
the_template = host->hostt;
first_host = host;
}
/*
* Linux SCSI drivers have always been plagued with initialization
* problems - some didn't work with the BIOS disabled since they expected
* initialization from it, some didn't work when the networking code
* was enabled and registers got scrambled, etc.
*
* To avoid problems like this, in the future, we will do a soft
* reset on the SCSI chip, taking it back to a sane state.
*/
hostdata->soft_reset (host);
#if 1
hostdata->debug_count_limit = -1;
#else
hostdata->debug_count_limit = 1;
#endif
hostdata->intrs = -1;
hostdata->resets = -1;
memcpy ((void *) hostdata->synchronous_want, (void *) sdtr_message,
sizeof (hostdata->synchronous_want));
NCR53c7x0_driver_init (host);
[PATCH] irq-flags: scsi: Use the new IRQF_ constants Signed-off-by: Thomas Gleixner <tglx@linutronix.de> Cc: Ingo Molnar <mingo@elte.hu> Cc: "David S. Miller" <davem@davemloft.net> Cc: Benjamin Herrenschmidt <benh@kernel.crashing.org> Cc: James Bottomley <James.Bottomley@steeleye.com> Signed-off-by: Andrew Morton <akpm@osdl.org> Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-07-01 19:29:42 -07:00
if (request_irq(host->irq, NCR53c7x0_intr, IRQF_SHARED, "53c7xx", host))
Linux-2.6.12-rc2 Initial git repository build. I'm not bothering with the full history, even though we have it. We can create a separate "historical" git archive of that later if we want to, and in the meantime it's about 3.2GB when imported into git - space that would just make the early git days unnecessarily complicated, when we don't have a lot of good infrastructure for it. Let it rip!
2005-04-16 15:20:36 -07:00
{
printk("scsi%d : IRQ%d not free, detaching\n",
host->host_no, host->irq);
goto err_unregister;
}
if ((hostdata->run_tests && hostdata->run_tests(host) == -1) ||
(hostdata->options & OPTION_DEBUG_TESTS_ONLY)) {
/* XXX Should disable interrupts, etc. here */
goto err_free_irq;
} else {
if (host->io_port) {
host->n_io_port = 128;
if (!request_region (host->io_port, host->n_io_port, "ncr53c7xx"))
goto err_free_irq;
}
}
if (NCR53c7x0_read8 (SBCL_REG) & SBCL_BSY) {
printk ("scsi%d : bus wedge, doing SCSI reset\n", host->host_no);
hard_reset (host);
}
return 0;
err_free_irq:
free_irq(host->irq, NCR53c7x0_intr);
err_unregister:
scsi_unregister(host);
return -1;
}
/*
[SCSI] remove Scsi_Host_Template typedef Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2005-10-31 10:31:40 -07:00
* Function : int ncr53c7xx_init(struct scsi_host_template *tpnt, int board, int chip,
Linux-2.6.12-rc2 Initial git repository build. I'm not bothering with the full history, even though we have it. We can create a separate "historical" git archive of that later if we want to, and in the meantime it's about 3.2GB when imported into git - space that would just make the early git days unnecessarily complicated, when we don't have a lot of good infrastructure for it. Let it rip!
2005-04-16 15:20:36 -07:00
* unsigned long base, int io_port, int irq, int dma, long long options,
* int clock);
*
* Purpose : initializes a NCR53c7,8x0 based on base addresses,
* IRQ, and DMA channel.
*
* Inputs : tpnt - Template for this SCSI adapter, board - board level
* product, chip - 710
*
* Returns : 0 on success, -1 on failure.
*
*/
int
[SCSI] remove Scsi_Host_Template typedef Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2005-10-31 10:31:40 -07:00
ncr53c7xx_init (struct scsi_host_template *tpnt, int board, int chip,
Linux-2.6.12-rc2 Initial git repository build. I'm not bothering with the full history, even though we have it. We can create a separate "historical" git archive of that later if we want to, and in the meantime it's about 3.2GB when imported into git - space that would just make the early git days unnecessarily complicated, when we don't have a lot of good infrastructure for it. Let it rip!
2005-04-16 15:20:36 -07:00
unsigned long base, int io_port, int irq, int dma,
long long options, int clock)
{
struct Scsi_Host *instance;
struct NCR53c7x0_hostdata *hostdata;
char chip_str[80];
int script_len = 0, dsa_len = 0, size = 0, max_cmd_size = 0,
schedule_size = 0, ok = 0;
void *tmp;
unsigned long page;
switch (chip) {
case 710:
case 770:
schedule_size = (tpnt->can_queue + 1) * 8 /* JUMP instruction size */;
script_len = NCR53c7xx_script_len;
dsa_len = NCR53c7xx_dsa_len;
options |= OPTION_INTFLY;
sprintf (chip_str, "NCR53c%d", chip);
break;
default:
printk("scsi-ncr53c7xx : unsupported SCSI chip %d\n", chip);
return -1;
}
printk("scsi-ncr53c7xx : %s at memory 0x%lx, io 0x%x, irq %d",
chip_str, base, io_port, irq);
if (dma == DMA_NONE)
printk("\n");
else
printk(", dma %d\n", dma);
if (options & OPTION_DEBUG_PROBE_ONLY) {
printk ("scsi-ncr53c7xx : probe only enabled, aborting initialization\n");
return -1;
}
max_cmd_size = sizeof(struct NCR53c7x0_cmd) + dsa_len +
/* Size of dynamic part of command structure : */
2 * /* Worst case : we don't know if we need DATA IN or DATA out */
( 2 * /* Current instructions per scatter/gather segment */
tpnt->sg_tablesize +
3 /* Current startup / termination required per phase */
) *
8 /* Each instruction is eight bytes */;
/* Allocate fixed part of hostdata, dynamic part to hold appropriate
SCSI SCRIPT(tm) plus a single, maximum-sized NCR53c7x0_cmd structure.
We need a NCR53c7x0_cmd structure for scan_scsis() when we are
not loaded as a module, and when we're loaded as a module, we
can't use a non-dynamically allocated structure because modules
are vmalloc()'d, which can allow structures to cross page
boundaries and breaks our physical/virtual address assumptions
for DMA.
So, we stick it past the end of our hostdata structure.
ASSUMPTION :
Regardless of how many simultaneous SCSI commands we allow,
the probe code only executes a _single_ instruction at a time,
so we only need one here, and don't need to allocate NCR53c7x0_cmd
structures for each target until we are no longer in scan_scsis
and kmalloc() has become functional (memory_init() happens
after all device driver initialization).
*/
size = sizeof(struct NCR53c7x0_hostdata) + script_len +
/* Note that alignment will be guaranteed, since we put the command
allocated at probe time after the fixed-up SCSI script, which
consists of 32 bit words, aligned on a 32 bit boundary. But
on a 64bit machine we need 8 byte alignment for hostdata->free, so
we add in another 4 bytes to take care of potential misalignment
*/
(sizeof(void *) - sizeof(u32)) + max_cmd_size + schedule_size;
page = __get_free_pages(GFP_ATOMIC,1);
if(page==0)
{
printk(KERN_ERR "53c7xx: out of memory.\n");
return -ENOMEM;
}
#ifdef FORCE_DSA_ALIGNMENT
/*
* 53c710 rev.0 doesn't have an add-with-carry instruction.
* Ensure we allocate enough memory to force DSA alignment.
*/
size += 256;
#endif
/* Size should be < 8K, so we can fit it in two pages. */
if (size > 8192) {
printk(KERN_ERR "53c7xx: hostdata > 8K\n");
return -1;
}
instance = scsi_register (tpnt, 4);
if (!instance)
{
free_page(page);
return -1;
}
instance->hostdata[0] = page;
memset((void *)instance->hostdata[0], 0, 8192);
cache_push(virt_to_phys((void *)(instance->hostdata[0])), 8192);
cache_clear(virt_to_phys((void *)(instance->hostdata[0])), 8192);
kernel_set_cachemode((void *)instance->hostdata[0], 8192, IOMAP_NOCACHE_SER);
/* FIXME : if we ever support an ISA NCR53c7xx based board, we
need to check if the chip is running in a 16 bit mode, and if so
unregister it if it is past the 16M (0x1000000) mark */
hostdata = (struct NCR53c7x0_hostdata *)instance->hostdata[0];
hostdata->size = size;
hostdata->script_count = script_len / sizeof(u32);
hostdata->board = board;
hostdata->chip = chip;
/*
* Being memory mapped is more desirable, since
*
* - Memory accesses may be faster.
*
* - The destination and source address spaces are the same for
* all instructions, meaning we don't have to twiddle dmode or
* any other registers.
*
* So, we try for memory mapped, and if we don't get it,
* we go for port mapped, and that failing we tell the user
* it can't work.
*/
if (base) {
instance->base = base;
/* Check for forced I/O mapping */
if (!(options & OPTION_IO_MAPPED)) {
options |= OPTION_MEMORY_MAPPED;
ok = 1;
}
} else {
options &= ~OPTION_MEMORY_MAPPED;
}
if (io_port) {
instance->io_port = io_port;
options |= OPTION_IO_MAPPED;
ok = 1;
} else {
options &= ~OPTION_IO_MAPPED;
}
if (!ok) {
printk ("scsi%d : not initializing, no I/O or memory mapping known \n",
instance->host_no);
scsi_unregister (instance);
return -1;
}
instance->irq = irq;
instance->dma_channel = dma;
hostdata->options = options;
hostdata->dsa_len = dsa_len;
hostdata->max_cmd_size = max_cmd_size;
hostdata->num_cmds = 1;
hostdata->scsi_clock = clock;
/* Initialize single command */
tmp = (hostdata->script + hostdata->script_count);
#ifdef FORCE_DSA_ALIGNMENT
{
void *t = ROUNDUP(tmp, void *);
if (((u32)t & 0xff) > CmdPageStart)
t = (void *)((u32)t + 255);
t = (void *)(((u32)t & ~0xff) + CmdPageStart);
hostdata->free = t;
#if 0
printk ("scsi: Registered size increased by 256 to %d\n", size);
printk ("scsi: CmdPageStart = 0x%02x\n", CmdPageStart);
printk ("scsi: tmp = 0x%08x, hostdata->free set to 0x%08x\n",
(u32)tmp, (u32)t);
#endif
}
#else
hostdata->free = ROUNDUP(tmp, void *);
#endif
hostdata->free->real = tmp;
hostdata->free->size = max_cmd_size;
hostdata->free->free = NULL;
hostdata->free->next = NULL;
hostdata->extra_allocate = 0;
/* Allocate command start code space */
hostdata->schedule = (chip == 700 || chip == 70066) ?
NULL : (u32 *) ((char *)hostdata->free + max_cmd_size);
/*
* For diagnostic purposes, we don't really care how fast things blaze.
* For profiling, we want to access the 800ns resolution system clock,
* using a 'C' call on the host processor.
*
* Therefore, there's no need for the NCR chip to directly manipulate
* this data, and we should put it wherever is most convenient for
* Linux.
*/
if (track_events)
hostdata->events = (struct NCR53c7x0_event *) (track_events ?
vmalloc (sizeof (struct NCR53c7x0_event) * track_events) : NULL);
else
hostdata->events = NULL;
if (hostdata->events) {
memset ((void *) hostdata->events, 0, sizeof(struct NCR53c7x0_event) *
track_events);
hostdata->event_size = track_events;
hostdata->event_index = 0;
} else
hostdata->event_size = 0;
return NCR53c7x0_init(instance);
}
/*
* Function : static void NCR53c7x0_init_fixup (struct Scsi_Host *host)
*
* Purpose : copy and fixup the SCSI SCRIPTS(tm) code for this device.
*
* Inputs : host - pointer to this host adapter's structure
*
*/
static void
NCR53c7x0_init_fixup (struct Scsi_Host *host) {
NCR53c7x0_local_declare();
struct NCR53c7x0_hostdata *hostdata = (struct NCR53c7x0_hostdata *)
host->hostdata[0];
unsigned char tmp;
int i, ncr_to_memory, memory_to_ncr;
u32 base;
NCR53c7x0_local_setup(host);
/* XXX - NOTE : this code MUST be made endian aware */
/* Copy code into buffer that was allocated at detection time. */
memcpy ((void *) hostdata->script, (void *) SCRIPT,
sizeof(SCRIPT));
/* Fixup labels */
for (i = 0; i < PATCHES; ++i)
hostdata->script[LABELPATCHES[i]] +=
virt_to_bus(hostdata->script);
/* Fixup addresses of constants that used to be EXTERNAL */
patch_abs_32 (hostdata->script, 0, NCR53c7xx_msg_abort,
virt_to_bus(&(hostdata->NCR53c7xx_msg_abort)));
patch_abs_32 (hostdata->script, 0, NCR53c7xx_msg_reject,
virt_to_bus(&(hostdata->NCR53c7xx_msg_reject)));
patch_abs_32 (hostdata->script, 0, NCR53c7xx_zero,
virt_to_bus(&(hostdata->NCR53c7xx_zero)));
patch_abs_32 (hostdata->script, 0, NCR53c7xx_sink,
virt_to_bus(&(hostdata->NCR53c7xx_sink)));
patch_abs_32 (hostdata->script, 0, NOP_insn,
virt_to_bus(&(hostdata->NOP_insn)));
patch_abs_32 (hostdata->script, 0, schedule,
virt_to_bus((void *) hostdata->schedule));
/* Fixup references to external variables: */
for (i = 0; i < EXTERNAL_PATCHES_LEN; ++i)
hostdata->script[EXTERNAL_PATCHES[i].offset] +=
virt_to_bus(EXTERNAL_PATCHES[i].address);
/*
* Fixup absolutes set at boot-time.
*
* All non-code absolute variables suffixed with "dsa_" and "int_"
* are constants, and need no fixup provided the assembler has done
* it for us (I don't know what the "real" NCR assembler does in
* this case, my assembler does the right magic).
*/
patch_abs_rwri_data (hostdata->script, 0, dsa_save_data_pointer,
Ent_dsa_code_save_data_pointer - Ent_dsa_zero);
patch_abs_rwri_data (hostdata->script, 0, dsa_restore_pointers,
Ent_dsa_code_restore_pointers - Ent_dsa_zero);
patch_abs_rwri_data (hostdata->script, 0, dsa_check_reselect,
Ent_dsa_code_check_reselect - Ent_dsa_zero);
/*
* Just for the hell of it, preserve the settings of
* Burst Length and Enable Read Line bits from the DMODE
* register. Make sure SCRIPTS start automagically.
*/
#if defined(CONFIG_MVME16x) || defined(CONFIG_BVME6000)
/* We know better what we want than 16xBug does! */
tmp = DMODE_10_BL_8 | DMODE_10_FC2;
#else
tmp = NCR53c7x0_read8(DMODE_REG_10);
tmp &= (DMODE_BL_MASK | DMODE_10_FC2 | DMODE_10_FC1 | DMODE_710_PD |
DMODE_710_UO);
#endif
if (!(hostdata->options & OPTION_MEMORY_MAPPED)) {
base = (u32) host->io_port;
memory_to_ncr = tmp|DMODE_800_DIOM;
ncr_to_memory = tmp|DMODE_800_SIOM;
} else {
base = virt_to_bus((void *)host->base);
memory_to_ncr = ncr_to_memory = tmp;
}
/* SCRATCHB_REG_10 == SCRATCHA_REG_800, as it happens */
patch_abs_32 (hostdata->script, 0, addr_scratch, base + SCRATCHA_REG_800);
patch_abs_32 (hostdata->script, 0, addr_temp, base + TEMP_REG);
patch_abs_32 (hostdata->script, 0, addr_dsa, base + DSA_REG);
/*
* I needed some variables in the script to be accessible to
* both the NCR chip and the host processor. For these variables,
* I made the arbitrary decision to store them directly in the
* hostdata structure rather than in the RELATIVE area of the
* SCRIPTS.
*/
patch_abs_rwri_data (hostdata->script, 0, dmode_memory_to_memory, tmp);
patch_abs_rwri_data (hostdata->script, 0, dmode_memory_to_ncr, memory_to_ncr);
patch_abs_rwri_data (hostdata->script, 0, dmode_ncr_to_memory, ncr_to_memory);
patch_abs_32 (hostdata->script, 0, msg_buf,
virt_to_bus((void *)&(hostdata->msg_buf)));
patch_abs_32 (hostdata->script, 0, reconnect_dsa_head,
virt_to_bus((void *)&(hostdata->reconnect_dsa_head)));
patch_abs_32 (hostdata->script, 0, addr_reconnect_dsa_head,
virt_to_bus((void *)&(hostdata->addr_reconnect_dsa_head)));
patch_abs_32 (hostdata->script, 0, reselected_identify,
virt_to_bus((void *)&(hostdata->reselected_identify)));
/* reselected_tag is currently unused */
#if 0
patch_abs_32 (hostdata->script, 0, reselected_tag,
virt_to_bus((void *)&(hostdata->reselected_tag)));
#endif
patch_abs_32 (hostdata->script, 0, test_dest,
virt_to_bus((void*)&hostdata->test_dest));
patch_abs_32 (hostdata->script, 0, test_src,
virt_to_bus(&hostdata->test_source));
patch_abs_32 (hostdata->script, 0, saved_dsa,
virt_to_bus((void *)&hostdata->saved2_dsa));
patch_abs_32 (hostdata->script, 0, emulfly,
virt_to_bus((void *)&hostdata->emulated_intfly));
patch_abs_rwri_data (hostdata->script, 0, dsa_check_reselect,
(unsigned char)(Ent_dsa_code_check_reselect - Ent_dsa_zero));
/* These are for event logging; the ncr_event enum contains the
actual interrupt numbers. */
#ifdef A_int_EVENT_SELECT
patch_abs_32 (hostdata->script, 0, int_EVENT_SELECT, (u32) EVENT_SELECT);
#endif
#ifdef A_int_EVENT_DISCONNECT
patch_abs_32 (hostdata->script, 0, int_EVENT_DISCONNECT, (u32) EVENT_DISCONNECT);
#endif
#ifdef A_int_EVENT_RESELECT
patch_abs_32 (hostdata->script, 0, int_EVENT_RESELECT, (u32) EVENT_RESELECT);
#endif
#ifdef A_int_EVENT_COMPLETE
patch_abs_32 (hostdata->script, 0, int_EVENT_COMPLETE, (u32) EVENT_COMPLETE);
#endif
#ifdef A_int_EVENT_IDLE
patch_abs_32 (hostdata->script, 0, int_EVENT_IDLE, (u32) EVENT_IDLE);
#endif
#ifdef A_int_EVENT_SELECT_FAILED
patch_abs_32 (hostdata->script, 0, int_EVENT_SELECT_FAILED,
(u32) EVENT_SELECT_FAILED);
#endif
#ifdef A_int_EVENT_BEFORE_SELECT
patch_abs_32 (hostdata->script, 0, int_EVENT_BEFORE_SELECT,
(u32) EVENT_BEFORE_SELECT);
#endif
#ifdef A_int_EVENT_RESELECT_FAILED
patch_abs_32 (hostdata->script, 0, int_EVENT_RESELECT_FAILED,
(u32) EVENT_RESELECT_FAILED);
#endif
/*
* Make sure the NCR and Linux code agree on the location of
* certain fields.
*/
hostdata->E_accept_message = Ent_accept_message;
hostdata->E_command_complete = Ent_command_complete;
hostdata->E_cmdout_cmdout = Ent_cmdout_cmdout;
hostdata->E_data_transfer = Ent_data_transfer;
hostdata->E_debug_break = Ent_debug_break;
hostdata->E_dsa_code_template = Ent_dsa_code_template;
hostdata->E_dsa_code_template_end = Ent_dsa_code_template_end;
hostdata->E_end_data_transfer = Ent_end_data_transfer;
hostdata->E_initiator_abort = Ent_initiator_abort;
hostdata->E_msg_in = Ent_msg_in;
hostdata->E_other_transfer = Ent_other_transfer;
hostdata->E_other_in = Ent_other_in;
hostdata->E_other_out = Ent_other_out;
hostdata->E_reject_message = Ent_reject_message;
hostdata->E_respond_message = Ent_respond_message;
hostdata->E_select = Ent_select;
hostdata->E_select_msgout = Ent_select_msgout;
hostdata->E_target_abort = Ent_target_abort;
#ifdef Ent_test_0
hostdata->E_test_0 = Ent_test_0;
#endif
hostdata->E_test_1 = Ent_test_1;
hostdata->E_test_2 = Ent_test_2;
#ifdef Ent_test_3
hostdata->E_test_3 = Ent_test_3;
#endif
hostdata->E_wait_reselect = Ent_wait_reselect;
hostdata->E_dsa_code_begin = Ent_dsa_code_begin;
hostdata->dsa_cmdout = A_dsa_cmdout;
hostdata->dsa_cmnd = A_dsa_cmnd;
hostdata->dsa_datain = A_dsa_datain;
hostdata->dsa_dataout = A_dsa_dataout;
hostdata->dsa_end = A_dsa_end;
hostdata->dsa_msgin = A_dsa_msgin;
hostdata->dsa_msgout = A_dsa_msgout;
hostdata->dsa_msgout_other = A_dsa_msgout_other;
hostdata->dsa_next = A_dsa_next;
hostdata->dsa_select = A_dsa_select;
hostdata->dsa_start = Ent_dsa_code_template - Ent_dsa_zero;
hostdata->dsa_status = A_dsa_status;
hostdata->dsa_jump_dest = Ent_dsa_code_fix_jump - Ent_dsa_zero +
8 /* destination operand */;
/* sanity check */
if (A_dsa_fields_start != Ent_dsa_code_template_end -
Ent_dsa_zero)
printk("scsi%d : NCR dsa_fields start is %d not %d\n",
host->host_no, A_dsa_fields_start, Ent_dsa_code_template_end -
Ent_dsa_zero);
printk("scsi%d : NCR code relocated to 0x%lx (virt 0x%p)\n", host->host_no,
virt_to_bus(hostdata->script), hostdata->script);
}
/*
* Function : static int NCR53c7xx_run_tests (struct Scsi_Host *host)
*
* Purpose : run various verification tests on the NCR chip,
* including interrupt generation, and proper bus mastering
* operation.
*
* Inputs : host - a properly initialized Scsi_Host structure
*
* Preconditions : the NCR chip must be in a halted state.
*
* Returns : 0 if all tests were successful, -1 on error.
*
*/
static int
NCR53c7xx_run_tests (struct Scsi_Host *host) {
NCR53c7x0_local_declare();
struct NCR53c7x0_hostdata *hostdata = (struct NCR53c7x0_hostdata *)
host->hostdata[0];
unsigned long timeout;
u32 start;
int failed, i;
unsigned long flags;
NCR53c7x0_local_setup(host);
/* The NCR chip _must_ be idle to run the test scripts */
local_irq_save(flags);
if (!hostdata->idle) {
printk ("scsi%d : chip not idle, aborting tests\n", host->host_no);
local_irq_restore(flags);
return -1;
}
/*
* Check for functional interrupts, this could work as an
* autoprobe routine.
*/
if ((hostdata->options & OPTION_DEBUG_TEST1) &&
hostdata->state != STATE_DISABLED) {
hostdata->idle = 0;
hostdata->test_running = 1;
hostdata->test_completed = -1;
hostdata->test_dest = 0;
hostdata->test_source = 0xdeadbeef;
start = virt_to_bus (hostdata->script) + hostdata->E_test_1;
hostdata->state = STATE_RUNNING;
printk ("scsi%d : test 1", host->host_no);
NCR53c7x0_write32 (DSP_REG, start);
if (hostdata->options & OPTION_DEBUG_TRACE)
NCR53c7x0_write8 (DCNTL_REG, hostdata->saved_dcntl | DCNTL_SSM |
DCNTL_STD);
printk (" started\n");
local_irq_restore(flags);
/*
* This is currently a .5 second timeout, since (in theory) no slow
* board will take that long. In practice, we've seen one
* pentium which occassionally fails with this, but works with
* 10 times as much?
*/
timeout = jiffies + 5 * HZ / 10;
while ((hostdata->test_completed == -1) && time_before(jiffies, timeout))
barrier();
failed = 1;
if (hostdata->test_completed == -1)
printk ("scsi%d : driver test 1 timed out%s\n",host->host_no ,
(hostdata->test_dest == 0xdeadbeef) ?
" due to lost interrupt.\n"
" Please verify that the correct IRQ is being used for your board,\n"
: "");
else if (hostdata->test_completed != 1)
printk ("scsi%d : test 1 bad interrupt value (%d)\n",
host->host_no, hostdata->test_completed);
else
failed = (hostdata->test_dest != 0xdeadbeef);
if (hostdata->test_dest != 0xdeadbeef) {
printk ("scsi%d : driver test 1 read 0x%x instead of 0xdeadbeef indicating a\n"
" probable cache invalidation problem. Please configure caching\n"
" as write-through or disabled\n",
host->host_no, hostdata->test_dest);
}
if (failed) {
printk ("scsi%d : DSP = 0x%p (script at 0x%p, start at 0x%x)\n",
host->host_no, bus_to_virt(NCR53c7x0_read32(DSP_REG)),
hostdata->script, start);
printk ("scsi%d : DSPS = 0x%x\n", host->host_no,
NCR53c7x0_read32(DSPS_REG));
local_irq_restore(flags);
return -1;
}
hostdata->test_running = 0;
}
if ((hostdata->options & OPTION_DEBUG_TEST2) &&
hostdata->state != STATE_DISABLED) {
u32 dsa[48];
unsigned char identify = IDENTIFY(0, 0);
unsigned char cmd[6];
unsigned char data[36];
unsigned char status = 0xff;
unsigned char msg = 0xff;
cmd[0] = INQUIRY;
cmd[1] = cmd[2] = cmd[3] = cmd[5] = 0;
cmd[4] = sizeof(data);
dsa[2] = 1;
dsa[3] = virt_to_bus(&identify);
dsa[4] = 6;
dsa[5] = virt_to_bus(&cmd);
dsa[6] = sizeof(data);
dsa[7] = virt_to_bus(&data);
dsa[8] = 1;
dsa[9] = virt_to_bus(&status);
dsa[10] = 1;
dsa[11] = virt_to_bus(&msg);
for (i = 0; i < 6; ++i) {
#ifdef VALID_IDS
if (!hostdata->valid_ids[i])
continue;
#endif
local_irq_disable();
if (!hostdata->idle) {
printk ("scsi%d : chip not idle, aborting tests\n", host->host_no);
local_irq_restore(flags);
return -1;
}
/* 710: bit mapped scsi ID, async */
dsa[0] = (1 << i) << 16;
hostdata->idle = 0;
hostdata->test_running = 2;
hostdata->test_completed = -1;
start = virt_to_bus(hostdata->script) + hostdata->E_test_2;
hostdata->state = STATE_RUNNING;
NCR53c7x0_write32 (DSA_REG, virt_to_bus(dsa));
NCR53c7x0_write32 (DSP_REG, start);
if (hostdata->options & OPTION_DEBUG_TRACE)
NCR53c7x0_write8 (DCNTL_REG, hostdata->saved_dcntl |
DCNTL_SSM | DCNTL_STD);
local_irq_restore(flags);
timeout = jiffies + 5 * HZ; /* arbitrary */
while ((hostdata->test_completed == -1) && time_before(jiffies, timeout))
barrier();
NCR53c7x0_write32 (DSA_REG, 0);
if (hostdata->test_completed == 2) {
data[35] = 0;
printk ("scsi%d : test 2 INQUIRY to target %d, lun 0 : %s\n",
host->host_no, i, data + 8);
printk ("scsi%d : status ", host->host_no);
[PATCH] remove outdated print_* functions We have the scsi_print_* functions in the proper namespace for a long time now and there weren't a lot users left. Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2005-04-03 12:53:59 -07:00
scsi_print_status (status);
Linux-2.6.12-rc2 Initial git repository build. I'm not bothering with the full history, even though we have it. We can create a separate "historical" git archive of that later if we want to, and in the meantime it's about 3.2GB when imported into git - space that would just make the early git days unnecessarily complicated, when we don't have a lot of good infrastructure for it. Let it rip!
2005-04-16 15:20:36 -07:00
printk ("\nscsi%d : message ", host->host_no);
[SCSI] Rename scsi_print_msg to spi_print_msg Rename scsi_print_msg to spi_print_msg and move its prototype from scsi_dbg.h to scsi_transport_spi.h Signed-off-by: Matthew Wilcox <matthew@wil.cx> Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2005-12-15 14:22:01 -07:00
spi_print_msg(&msg);
Linux-2.6.12-rc2 Initial git repository build. I'm not bothering with the full history, even though we have it. We can create a separate "historical" git archive of that later if we want to, and in the meantime it's about 3.2GB when imported into git - space that would just make the early git days unnecessarily complicated, when we don't have a lot of good infrastructure for it. Let it rip!
2005-04-16 15:20:36 -07:00
printk ("\n");
} else if (hostdata->test_completed == 3) {
printk("scsi%d : test 2 no connection with target %d\n",
host->host_no, i);
if (!hostdata->idle) {
printk("scsi%d : not idle\n", host->host_no);
local_irq_restore(flags);
return -1;
}
} else if (hostdata->test_completed == -1) {
printk ("scsi%d : test 2 timed out\n", host->host_no);
local_irq_restore(flags);
return -1;
}
hostdata->test_running = 0;
}
}
local_irq_restore(flags);
return 0;
}
/*
* Function : static void NCR53c7xx_dsa_fixup (struct NCR53c7x0_cmd *cmd)
*
* Purpose : copy the NCR53c8xx dsa structure into cmd's dsa buffer,
* performing all necessary relocation.
*
* Inputs : cmd, a NCR53c7x0_cmd structure with a dsa area large
* enough to hold the NCR53c8xx dsa.
*/
static void
NCR53c7xx_dsa_fixup (struct NCR53c7x0_cmd *cmd) {
Scsi_Cmnd *c = cmd->cmd;
struct Scsi_Host *host = c->device->host;
struct NCR53c7x0_hostdata *hostdata = (struct NCR53c7x0_hostdata *)
host->hostdata[0];
int i;
memcpy (cmd->dsa, hostdata->script + (hostdata->E_dsa_code_template / 4),
hostdata->E_dsa_code_template_end - hostdata->E_dsa_code_template);
/*
* Note : within the NCR 'C' code, dsa points to the _start_
* of the DSA structure, and _not_ the offset of dsa_zero within
* that structure used to facilitate shorter signed offsets
* for the 8 bit ALU.
*
* The implications of this are that
*
* - 32 bit A_dsa_* absolute values require an additional
* dsa_zero added to their value to be correct, since they are
* relative to dsa_zero which is in essentially a separate
* space from the code symbols.
*
* - All other symbols require no special treatment.
*/
patch_abs_tci_data (cmd->dsa, Ent_dsa_code_template / sizeof(u32),
dsa_temp_lun, c->device->lun);
patch_abs_32 (cmd->dsa, Ent_dsa_code_template / sizeof(u32),
dsa_temp_addr_next, virt_to_bus(&cmd->dsa_next_addr));
patch_abs_32 (cmd->dsa, Ent_dsa_code_template / sizeof(u32),
dsa_temp_next, virt_to_bus(cmd->dsa) + Ent_dsa_zero -
Ent_dsa_code_template + A_dsa_next);
patch_abs_32 (cmd->dsa, Ent_dsa_code_template / sizeof(u32),
dsa_temp_sync, virt_to_bus((void *)hostdata->sync[c->device->id].script));
patch_abs_32 (cmd->dsa, Ent_dsa_code_template / sizeof(u32),
dsa_sscf_710, virt_to_bus((void *)&hostdata->sync[c->device->id].sscf_710));
patch_abs_tci_data (cmd->dsa, Ent_dsa_code_template / sizeof(u32),
dsa_temp_target, 1 << c->device->id);
/* XXX - new pointer stuff */
patch_abs_32 (cmd->dsa, Ent_dsa_code_template / sizeof(u32),
dsa_temp_addr_saved_pointer, virt_to_bus(&cmd->saved_data_pointer));
patch_abs_32 (cmd->dsa, Ent_dsa_code_template / sizeof(u32),
dsa_temp_addr_saved_residual, virt_to_bus(&cmd->saved_residual));
patch_abs_32 (cmd->dsa, Ent_dsa_code_template / sizeof(u32),
dsa_temp_addr_residual, virt_to_bus(&cmd->residual));
/* XXX - new start stuff */
patch_abs_32 (cmd->dsa, Ent_dsa_code_template / sizeof(u32),
dsa_temp_addr_dsa_value, virt_to_bus(&cmd->dsa_addr));
}
/*
* Function : run_process_issue_queue (void)
*
* Purpose : insure that the coroutine is running and will process our
* request. process_issue_queue_running is checked/set here (in an
* inline function) rather than in process_issue_queue itself to reduce
* the chances of stack overflow.
*
*/
static volatile int process_issue_queue_running = 0;
static __inline__ void
run_process_issue_queue(void) {
unsigned long flags;
local_irq_save(flags);
if (!process_issue_queue_running) {
process_issue_queue_running = 1;
process_issue_queue(flags);
/*
* process_issue_queue_running is cleared in process_issue_queue
* once it can't do more work, and process_issue_queue exits with
* interrupts disabled.
*/
}
local_irq_restore(flags);
}
/*
* Function : static void abnormal_finished (struct NCR53c7x0_cmd *cmd, int
* result)
*
* Purpose : mark SCSI command as finished, OR'ing the host portion
* of the result word into the result field of the corresponding
* Scsi_Cmnd structure, and removing it from the internal queues.
*
* Inputs : cmd - command, result - entire result field
*
* Preconditions : the NCR chip should be in a halted state when
* abnormal_finished is run, since it modifies structures which
* the NCR expects to have exclusive access to.
*/
static void
abnormal_finished (struct NCR53c7x0_cmd *cmd, int result) {
Scsi_Cmnd *c = cmd->cmd;
struct Scsi_Host *host = c->device->host;
struct NCR53c7x0_hostdata *hostdata = (struct NCR53c7x0_hostdata *)
host->hostdata[0];
unsigned long flags;
int left, found;
volatile struct NCR53c7x0_cmd * linux_search;
volatile struct NCR53c7x0_cmd * volatile *linux_prev;
volatile u32 *ncr_prev, *ncrcurrent, ncr_search;
#if 0
printk ("scsi%d: abnormal finished\n", host->host_no);
#endif
local_irq_save(flags);
found = 0;
/*
* Traverse the NCR issue array until we find a match or run out
* of instructions. Instructions in the NCR issue array are
* either JUMP or NOP instructions, which are 2 words in length.
*/
for (found = 0, left = host->can_queue, ncrcurrent = hostdata->schedule;
left > 0; --left, ncrcurrent += 2)
{
if (issue_to_cmd (host, hostdata, (u32 *) ncrcurrent) == cmd)
{
ncrcurrent[0] = hostdata->NOP_insn;
ncrcurrent[1] = 0xdeadbeef;
++found;
break;
}
}
/*
* Traverse the NCR reconnect list of DSA structures until we find
* a pointer to this dsa or have found too many command structures.
* We let prev point at the next field of the previous element or
* head of the list, so we don't do anything different for removing
* the head element.
*/
for (left = host->can_queue,
ncr_search = hostdata->reconnect_dsa_head,
ncr_prev = &hostdata->reconnect_dsa_head;
left >= 0 && ncr_search &&
((char*)bus_to_virt(ncr_search) + hostdata->dsa_start)
!= (char *) cmd->dsa;
ncr_prev = (u32*) ((char*)bus_to_virt(ncr_search) +
hostdata->dsa_next), ncr_search = *ncr_prev, --left);
if (left < 0)
printk("scsi%d: loop detected in ncr reconncect list\n",
host->host_no);
else if (ncr_search) {
if (found)
printk("scsi%d: scsi %ld in ncr issue array and reconnect lists\n",
host->host_no, c->pid);
else {
volatile u32 * next = (u32 *)
((char *)bus_to_virt(ncr_search) + hostdata->dsa_next);
*ncr_prev = *next;
/* If we're at the tail end of the issue queue, update that pointer too. */
found = 1;
}
}
/*
* Traverse the host running list until we find this command or discover
* we have too many elements, pointing linux_prev at the next field of the
* linux_previous element or head of the list, search at this element.
*/
for (left = host->can_queue, linux_search = hostdata->running_list,
linux_prev = &hostdata->running_list;
left >= 0 && linux_search && linux_search != cmd;
linux_prev = &(linux_search->next),
linux_search = linux_search->next, --left);
if (left < 0)
printk ("scsi%d: loop detected in host running list for scsi pid %ld\n",
host->host_no, c->pid);
else if (linux_search) {
*linux_prev = linux_search->next;
--hostdata->busy[c->device->id][c->device->lun];
}
/* Return the NCR command structure to the free list */
cmd->next = hostdata->free;
hostdata->free = cmd;
c->host_scribble = NULL;
/* And return */
c->result = result;
c->scsi_done(c);
local_irq_restore(flags);
run_process_issue_queue();
}
/*
* Function : static void intr_break (struct Scsi_Host *host,
* struct NCR53c7x0_cmd *cmd)
*
* Purpose : Handler for breakpoint interrupts from a SCSI script
*
* Inputs : host - pointer to this host adapter's structure,
* cmd - pointer to the command (if any) dsa was pointing
* to.
*
*/
static void
intr_break (struct Scsi_Host *host, struct
NCR53c7x0_cmd *cmd) {
NCR53c7x0_local_declare();
struct NCR53c7x0_break *bp;
#if 0
Scsi_Cmnd *c = cmd ? cmd->cmd : NULL;
#endif
u32 *dsp;
struct NCR53c7x0_hostdata *hostdata = (struct NCR53c7x0_hostdata *)
host->hostdata[0];
unsigned long flags;
NCR53c7x0_local_setup(host);
/*
* Find the break point corresponding to this address, and
* dump the appropriate debugging information to standard
* output.
*/
local_irq_save(flags);
dsp = (u32 *) bus_to_virt(NCR53c7x0_read32(DSP_REG));
for (bp = hostdata->breakpoints; bp && bp->address != dsp;
bp = bp->next);
if (!bp)
panic("scsi%d : break point interrupt from %p with no breakpoint!",
host->host_no, dsp);
/*
* Configure the NCR chip for manual start mode, so that we can
* point the DSP register at the instruction that follows the
* INT int_debug_break instruction.
*/
NCR53c7x0_write8 (hostdata->dmode,
NCR53c7x0_read8(hostdata->dmode)|DMODE_MAN);
/*
* And update the DSP register, using the size of the old
* instruction in bytes.
*/
local_irq_restore(flags);
}
/*
* Function : static void print_synchronous (const char *prefix,
* const unsigned char *msg)
*
* Purpose : print a pretty, user and machine parsable representation
* of a SDTR message, including the "real" parameters, data
* clock so we can tell transfer rate at a glance.
*
* Inputs ; prefix - text to prepend, msg - SDTR message (5 bytes)
*/
static void
print_synchronous (const char *prefix, const unsigned char *msg) {
if (msg[4]) {
int Hz = 1000000000 / (msg[3] * 4);
int integer = Hz / 1000000;
int fraction = (Hz - (integer * 1000000)) / 10000;
printk ("%speriod %dns offset %d %d.%02dMHz %s SCSI%s\n",
prefix, (int) msg[3] * 4, (int) msg[4], integer, fraction,
(((msg[3] * 4) < 200) ? "FAST" : "synchronous"),
(((msg[3] * 4) < 200) ? "-II" : ""));
} else
printk ("%sasynchronous SCSI\n", prefix);
}
/*
* Function : static void set_synchronous (struct Scsi_Host *host,
* int target, int sxfer, int scntl3, int now_connected)
*
* Purpose : reprogram transfers between the selected SCSI initiator and
* target with the given register values; in the indirect
* select operand, reselection script, and chip registers.
*
* Inputs : host - NCR53c7,8xx SCSI host, target - number SCSI target id,
* sxfer and scntl3 - NCR registers. now_connected - if non-zero,
* we should reprogram the registers now too.
*
* NOTE: For 53c710, scntl3 is actually used for SCF bits from
* SBCL, as we don't have a SCNTL3.
*/
static void
set_synchronous (struct Scsi_Host *host, int target, int sxfer, int scntl3,
int now_connected) {
NCR53c7x0_local_declare();
struct NCR53c7x0_hostdata *hostdata = (struct NCR53c7x0_hostdata *)
host->hostdata[0];
u32 *script;
NCR53c7x0_local_setup(host);
/* These are eight bit registers */
sxfer &= 0xff;
scntl3 &= 0xff;
hostdata->sync[target].sxfer_sanity = sxfer;
hostdata->sync[target].scntl3_sanity = scntl3;
/*
* HARD CODED : synchronous script is EIGHT words long. This
* must agree with 53c7.8xx.h
*/
if ((hostdata->chip != 700) && (hostdata->chip != 70066)) {
hostdata->sync[target].select_indirect = (1 << target) << 16 |
(sxfer << 8);
hostdata->sync[target].sscf_710 = scntl3;
script = (u32 *) hostdata->sync[target].script;
/* XXX - add NCR53c7x0 code to reprogram SCF bits if we want to */
script[0] = ((DCMD_TYPE_RWRI | DCMD_RWRI_OPC_MODIFY |
DCMD_RWRI_OP_MOVE) << 24) |
(SBCL_REG << 16) | (scntl3 << 8);
script[1] = 0;
script += 2;
script[0] = ((DCMD_TYPE_RWRI | DCMD_RWRI_OPC_MODIFY |
DCMD_RWRI_OP_MOVE) << 24) |
(SXFER_REG << 16) | (sxfer << 8);
script[1] = 0;
script += 2;
#ifdef DEBUG_SYNC_INTR
if (hostdata->options & OPTION_DEBUG_DISCONNECT) {
script[0] = ((DCMD_TYPE_TCI|DCMD_TCI_OP_INT) << 24) | DBC_TCI_TRUE;
script[1] = DEBUG_SYNC_INTR;
script += 2;
}
#endif
script[0] = ((DCMD_TYPE_TCI|DCMD_TCI_OP_RETURN) << 24) | DBC_TCI_TRUE;
script[1] = 0;
script += 2;
}
if (hostdata->options & OPTION_DEBUG_SYNCHRONOUS)
printk ("scsi%d : target %d sync parameters are sxfer=0x%x, scntl3=0x%x\n",
host->host_no, target, sxfer, scntl3);
if (now_connected) {
NCR53c7x0_write8(SBCL_REG, scntl3);
NCR53c7x0_write8(SXFER_REG, sxfer);
}
}
/*
* Function : static int asynchronous (struct Scsi_Host *host, int target)
*
* Purpose : reprogram between the selected SCSI Host adapter and target
* (assumed to be currently connected) for asynchronous transfers.
*
* Inputs : host - SCSI host structure, target - numeric target ID.
*
* Preconditions : the NCR chip should be in one of the halted states
*/
static void
asynchronous (struct Scsi_Host *host, int target) {
NCR53c7x0_local_declare();
struct NCR53c7x0_hostdata *hostdata = (struct NCR53c7x0_hostdata *)
host->hostdata[0];
NCR53c7x0_local_setup(host);
set_synchronous (host, target, /* no offset */ 0, hostdata->saved_scntl3,
1);
printk ("scsi%d : setting target %d to asynchronous SCSI\n",
host->host_no, target);
}
/*
* XXX - do we want to go out of our way (ie, add extra code to selection
* in the NCR53c710/NCR53c720 script) to reprogram the synchronous
* conversion bits, or can we be content in just setting the
* sxfer bits? I chose to do so [richard@sleepie.demon.co.uk]
*/
/* Table for NCR53c8xx synchronous values */
/* This table is also correct for 710, allowing that scf=4 is equivalent
* of SSCF=0 (ie use DCNTL, divide by 3) for a 50.01-66.00MHz clock.
* For any other clock values, we cannot use entries with SCF values of
* 4. I guess that for a 66MHz clock, the slowest it will set is 2MHz,
* and for a 50MHz clock, the slowest will be 2.27Mhz. Should check
* that a device doesn't try and negotiate sync below these limits!
*/
static const struct {
int div; /* Total clock divisor * 10 */
unsigned char scf; /* */
unsigned char tp; /* 4 + tp = xferp divisor */
} syncs[] = {
/* div scf tp div scf tp div scf tp */
{ 40, 1, 0}, { 50, 1, 1}, { 60, 1, 2},
{ 70, 1, 3}, { 75, 2, 1}, { 80, 1, 4},
{ 90, 1, 5}, { 100, 1, 6}, { 105, 2, 3},
{ 110, 1, 7}, { 120, 2, 4}, { 135, 2, 5},
{ 140, 3, 3}, { 150, 2, 6}, { 160, 3, 4},
{ 165, 2, 7}, { 180, 3, 5}, { 200, 3, 6},
{ 210, 4, 3}, { 220, 3, 7}, { 240, 4, 4},
{ 270, 4, 5}, { 300, 4, 6}, { 330, 4, 7}
};
/*
* Function : static void synchronous (struct Scsi_Host *host, int target,
* char *msg)
*
* Purpose : reprogram transfers between the selected SCSI initiator and
* target for synchronous SCSI transfers such that the synchronous
* offset is less than that requested and period at least as long
* as that requested. Also modify *msg such that it contains
* an appropriate response.
*
* Inputs : host - NCR53c7,8xx SCSI host, target - number SCSI target id,
* msg - synchronous transfer request.
*/
[SCSI] drivers/scsi: Use ARRAY_SIZE macro Use ARRAY_SIZE macro instead of sizeof(x)/sizeof(x[0]) and remove duplicates of the macro. Signed-off-by: Tobias Klauser <tklauser@nuerscht.ch> Signed-off-by: Andrew Morton <akpm@osdl.org> Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-06-08 22:23:48 -07:00
static void
Linux-2.6.12-rc2 Initial git repository build. I'm not bothering with the full history, even though we have it. We can create a separate "historical" git archive of that later if we want to, and in the meantime it's about 3.2GB when imported into git - space that would just make the early git days unnecessarily complicated, when we don't have a lot of good infrastructure for it. Let it rip!
2005-04-16 15:20:36 -07:00
synchronous (struct Scsi_Host *host, int target, char *msg) {
struct NCR53c7x0_hostdata *hostdata = (struct NCR53c7x0_hostdata *)
host->hostdata[0];
int desire, divisor, i, limit;
unsigned char scntl3, sxfer;
/* The diagnostic message fits on one line, even with max. width integers */
[SCSI] drivers/scsi: Use ARRAY_SIZE macro Use ARRAY_SIZE macro instead of sizeof(x)/sizeof(x[0]) and remove duplicates of the macro. Signed-off-by: Tobias Klauser <tklauser@nuerscht.ch> Signed-off-by: Andrew Morton <akpm@osdl.org> Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-06-08 22:23:48 -07:00
char buf[80];
Linux-2.6.12-rc2 Initial git repository build. I'm not bothering with the full history, even though we have it. We can create a separate "historical" git archive of that later if we want to, and in the meantime it's about 3.2GB when imported into git - space that would just make the early git days unnecessarily complicated, when we don't have a lot of good infrastructure for it. Let it rip!
2005-04-16 15:20:36 -07:00
/* Desired transfer clock in Hz */
desire = 1000000000L / (msg[3] * 4);
/* Scale the available SCSI clock by 10 so we get tenths */
divisor = (hostdata->scsi_clock * 10) / desire;
/* NCR chips can handle at most an offset of 8 */
if (msg[4] > 8)
msg[4] = 8;
if (hostdata->options & OPTION_DEBUG_SDTR)
[SCSI] drivers/scsi: Use ARRAY_SIZE macro Use ARRAY_SIZE macro instead of sizeof(x)/sizeof(x[0]) and remove duplicates of the macro. Signed-off-by: Tobias Klauser <tklauser@nuerscht.ch> Signed-off-by: Andrew Morton <akpm@osdl.org> Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-06-08 22:23:48 -07:00
printk("scsi%d : optimal synchronous divisor of %d.%01d\n",
Linux-2.6.12-rc2 Initial git repository build. I'm not bothering with the full history, even though we have it. We can create a separate "historical" git archive of that later if we want to, and in the meantime it's about 3.2GB when imported into git - space that would just make the early git days unnecessarily complicated, when we don't have a lot of good infrastructure for it. Let it rip!
2005-04-16 15:20:36 -07:00
host->host_no, divisor / 10, divisor % 10);
[SCSI] drivers/scsi: Use ARRAY_SIZE macro Use ARRAY_SIZE macro instead of sizeof(x)/sizeof(x[0]) and remove duplicates of the macro. Signed-off-by: Tobias Klauser <tklauser@nuerscht.ch> Signed-off-by: Andrew Morton <akpm@osdl.org> Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-06-08 22:23:48 -07:00
limit = ARRAY_SIZE(syncs) - 1;
Linux-2.6.12-rc2 Initial git repository build. I'm not bothering with the full history, even though we have it. We can create a separate "historical" git archive of that later if we want to, and in the meantime it's about 3.2GB when imported into git - space that would just make the early git days unnecessarily complicated, when we don't have a lot of good infrastructure for it. Let it rip!
2005-04-16 15:20:36 -07:00
for (i = 0; (i < limit) && (divisor > syncs[i].div); ++i);
if (hostdata->options & OPTION_DEBUG_SDTR)
[SCSI] drivers/scsi: Use ARRAY_SIZE macro Use ARRAY_SIZE macro instead of sizeof(x)/sizeof(x[0]) and remove duplicates of the macro. Signed-off-by: Tobias Klauser <tklauser@nuerscht.ch> Signed-off-by: Andrew Morton <akpm@osdl.org> Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-06-08 22:23:48 -07:00
printk("scsi%d : selected synchronous divisor of %d.%01d\n",
Linux-2.6.12-rc2 Initial git repository build. I'm not bothering with the full history, even though we have it. We can create a separate "historical" git archive of that later if we want to, and in the meantime it's about 3.2GB when imported into git - space that would just make the early git days unnecessarily complicated, when we don't have a lot of good infrastructure for it. Let it rip!
2005-04-16 15:20:36 -07:00
host->host_no, syncs[i].div / 10, syncs[i].div % 10);
msg[3] = ((1000000000L / hostdata->scsi_clock) * syncs[i].div / 10 / 4);
if (hostdata->options & OPTION_DEBUG_SDTR)
printk("scsi%d : selected synchronous period of %dns\n", host->host_no,
msg[3] * 4);
scntl3 = syncs[i].scf;
sxfer = (msg[4] << SXFER_MO_SHIFT) | (syncs[i].tp << 4);
if (hostdata->options & OPTION_DEBUG_SDTR)
printk ("scsi%d : sxfer=0x%x scntl3=0x%x\n",
host->host_no, (int) sxfer, (int) scntl3);
set_synchronous (host, target, sxfer, scntl3, 1);
sprintf (buf, "scsi%d : setting target %d to ", host->host_no, target);
print_synchronous (buf, msg);
}
/*
* Function : static int NCR53c7x0_dstat_sir_intr (struct Scsi_Host *host,
* struct NCR53c7x0_cmd *cmd)
*
* Purpose : Handler for INT generated instructions for the
* NCR53c810/820 SCSI SCRIPT
*
* Inputs : host - pointer to this host adapter's structure,
* cmd - pointer to the command (if any) dsa was pointing
* to.
*
*/
static int
NCR53c7x0_dstat_sir_intr (struct Scsi_Host *host, struct
NCR53c7x0_cmd *cmd) {
NCR53c7x0_local_declare();
int print;
Scsi_Cmnd *c = cmd ? cmd->cmd : NULL;
struct NCR53c7x0_hostdata *hostdata = (struct NCR53c7x0_hostdata *)
host->hostdata[0];
u32 dsps,*dsp; /* Argument of the INT instruction */
NCR53c7x0_local_setup(host);
dsps = NCR53c7x0_read32(DSPS_REG);
dsp = (u32 *) bus_to_virt(NCR53c7x0_read32(DSP_REG));
/* RGH 150597: Frig. Commands which fail with Check Condition are
* Flagged as successful - hack dsps to indicate check condition */
#if 0
/* RGH 200597: Need to disable for BVME6000, as it gets Check Conditions
* and then dies. Seems to handle Check Condition at startup, but
* not mid kernel build. */
if (dsps == A_int_norm_emulateintfly && cmd && cmd->result == 2)
dsps = A_int_err_check_condition;
#endif
if (hostdata->options & OPTION_DEBUG_INTR)
printk ("scsi%d : DSPS = 0x%x\n", host->host_no, dsps);
switch (dsps) {
case A_int_msg_1:
print = 1;
switch (hostdata->msg_buf[0]) {
/*
* Unless we've initiated synchronous negotiation, I don't
* think that this should happen.
*/
case MESSAGE_REJECT:
hostdata->dsp = hostdata->script + hostdata->E_accept_message /
sizeof(u32);
hostdata->dsp_changed = 1;
if (cmd && (cmd->flags & CMD_FLAG_SDTR)) {
printk ("scsi%d : target %d rejected SDTR\n", host->host_no,
c->device->id);
cmd->flags &= ~CMD_FLAG_SDTR;
asynchronous (host, c->device->id);
print = 0;
}
break;
case INITIATE_RECOVERY:
printk ("scsi%d : extended contingent allegiance not supported yet, rejecting\n",
host->host_no);
/* Fall through to default */
hostdata->dsp = hostdata->script + hostdata->E_reject_message /
sizeof(u32);
hostdata->dsp_changed = 1;
break;
default:
printk ("scsi%d : unsupported message, rejecting\n",
host->host_no);
hostdata->dsp = hostdata->script + hostdata->E_reject_message /
sizeof(u32);
hostdata->dsp_changed = 1;
}
if (print) {
printk ("scsi%d : received message", host->host_no);
if (c)
printk (" from target %d lun %d ", c->device->id, c->device->lun);
[SCSI] Rename scsi_print_msg to spi_print_msg Rename scsi_print_msg to spi_print_msg and move its prototype from scsi_dbg.h to scsi_transport_spi.h Signed-off-by: Matthew Wilcox <matthew@wil.cx> Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2005-12-15 14:22:01 -07:00
spi_print_msg((unsigned char *) hostdata->msg_buf);
Linux-2.6.12-rc2 Initial git repository build. I'm not bothering with the full history, even though we have it. We can create a separate "historical" git archive of that later if we want to, and in the meantime it's about 3.2GB when imported into git - space that would just make the early git days unnecessarily complicated, when we don't have a lot of good infrastructure for it. Let it rip!
2005-04-16 15:20:36 -07:00
printk("\n");
}
return SPECIFIC_INT_NOTHING;
case A_int_msg_sdtr:
/*
* At this point, hostdata->msg_buf contains
* 0 EXTENDED MESSAGE
* 1 length
* 2 SDTR
* 3 period * 4ns
* 4 offset
*/
if (cmd) {
char buf[80];
sprintf (buf, "scsi%d : target %d %s ", host->host_no, c->device->id,
(cmd->flags & CMD_FLAG_SDTR) ? "accepting" : "requesting");
print_synchronous (buf, (unsigned char *) hostdata->msg_buf);
/*
* Initiator initiated, won't happen unless synchronous
* transfers are enabled. If we get a SDTR message in
* response to our SDTR, we should program our parameters
* such that
* offset <= requested offset
* period >= requested period
*/
if (cmd->flags & CMD_FLAG_SDTR) {
cmd->flags &= ~CMD_FLAG_SDTR;
if (hostdata->msg_buf[4])
synchronous (host, c->device->id, (unsigned char *)
hostdata->msg_buf);
else
asynchronous (host, c->device->id);
hostdata->dsp = hostdata->script + hostdata->E_accept_message /
sizeof(u32);
hostdata->dsp_changed = 1;
return SPECIFIC_INT_NOTHING;
} else {
if (hostdata->options & OPTION_SYNCHRONOUS) {
cmd->flags |= CMD_FLAG_DID_SDTR;
synchronous (host, c->device->id, (unsigned char *)
hostdata->msg_buf);
} else {
hostdata->msg_buf[4] = 0; /* 0 offset = async */
asynchronous (host, c->device->id);
}
patch_dsa_32 (cmd->dsa, dsa_msgout_other, 0, 5);
patch_dsa_32 (cmd->dsa, dsa_msgout_other, 1, (u32)
virt_to_bus ((void *)&hostdata->msg_buf));
hostdata->dsp = hostdata->script +
hostdata->E_respond_message / sizeof(u32);
hostdata->dsp_changed = 1;
}
return SPECIFIC_INT_NOTHING;
}
/* Fall through to abort if we couldn't find a cmd, and
therefore a dsa structure to twiddle */
case A_int_msg_wdtr:
hostdata->dsp = hostdata->script + hostdata->E_reject_message /
sizeof(u32);
hostdata->dsp_changed = 1;
return SPECIFIC_INT_NOTHING;
case A_int_err_unexpected_phase:
if (hostdata->options & OPTION_DEBUG_INTR)
printk ("scsi%d : unexpected phase\n", host->host_no);
return SPECIFIC_INT_ABORT;
case A_int_err_selected:
if ((hostdata->chip / 100) == 8)
printk ("scsi%d : selected by target %d\n", host->host_no,
(int) NCR53c7x0_read8(SDID_REG_800) &7);
else
printk ("scsi%d : selected by target LCRC=0x%02x\n", host->host_no,
(int) NCR53c7x0_read8(LCRC_REG_10));
hostdata->dsp = hostdata->script + hostdata->E_target_abort /
sizeof(u32);
hostdata->dsp_changed = 1;
return SPECIFIC_INT_NOTHING;
case A_int_err_unexpected_reselect:
if ((hostdata->chip / 100) == 8)
printk ("scsi%d : unexpected reselect by target %d lun %d\n",
host->host_no, (int) NCR53c7x0_read8(SDID_REG_800) & 7,
hostdata->reselected_identify & 7);
else
printk ("scsi%d : unexpected reselect LCRC=0x%02x\n", host->host_no,
(int) NCR53c7x0_read8(LCRC_REG_10));
hostdata->dsp = hostdata->script + hostdata->E_initiator_abort /
sizeof(u32);
hostdata->dsp_changed = 1;
return SPECIFIC_INT_NOTHING;
/*
* Since contingent allegiance conditions are cleared by the next
* command issued to a target, we must issue a REQUEST SENSE
* command after receiving a CHECK CONDITION status, before
* another command is issued.
*
* Since this NCR53c7x0_cmd will be freed after use, we don't
* care if we step on the various fields, so modify a few things.
*/
case A_int_err_check_condition:
#if 0
if (hostdata->options & OPTION_DEBUG_INTR)
#endif
printk ("scsi%d : CHECK CONDITION\n", host->host_no);
if (!c) {
printk("scsi%d : CHECK CONDITION with no SCSI command\n",
host->host_no);
return SPECIFIC_INT_PANIC;
}
/*
* FIXME : this uses the normal one-byte selection message.
* We may want to renegotiate for synchronous & WIDE transfers
* since these could be the crux of our problem.
*
hostdata->NOP_insn* FIXME : once SCSI-II tagged queuing is implemented, we'll
* have to set this up so that the rest of the DSA
* agrees with this being an untagged queue'd command.
*/
patch_dsa_32 (cmd->dsa, dsa_msgout, 0, 1);
/*
* Modify the table indirect for COMMAND OUT phase, since
* Request Sense is a six byte command.
*/
patch_dsa_32 (cmd->dsa, dsa_cmdout, 0, 6);
/*
* The CDB is now mirrored in our local non-cached
* structure, but keep the old structure up to date as well,
* just in case anyone looks at it.
*/
/*
* XXX Need to worry about data buffer alignment/cache state
* XXX here, but currently never get A_int_err_check_condition,
* XXX so ignore problem for now.
*/
cmd->cmnd[0] = c->cmnd[0] = REQUEST_SENSE;
cmd->cmnd[0] = c->cmnd[1] &= 0xe0; /* Zero all but LUN */
cmd->cmnd[0] = c->cmnd[2] = 0;
cmd->cmnd[0] = c->cmnd[3] = 0;
cmd->cmnd[0] = c->cmnd[4] = sizeof(c->sense_buffer);
cmd->cmnd[0] = c->cmnd[5] = 0;
/*
* Disable dataout phase, and program datain to transfer to the
* sense buffer, and add a jump to other_transfer after the
* command so overflow/underrun conditions are detected.
*/
patch_dsa_32 (cmd->dsa, dsa_dataout, 0,
virt_to_bus(hostdata->script) + hostdata->E_other_transfer);
patch_dsa_32 (cmd->dsa, dsa_datain, 0,
virt_to_bus(cmd->data_transfer_start));
cmd->data_transfer_start[0] = (((DCMD_TYPE_BMI | DCMD_BMI_OP_MOVE_I |
DCMD_BMI_IO)) << 24) | sizeof(c->sense_buffer);
cmd->data_transfer_start[1] = (u32) virt_to_bus(c->sense_buffer);
cmd->data_transfer_start[2] = ((DCMD_TYPE_TCI | DCMD_TCI_OP_JUMP)
<< 24) | DBC_TCI_TRUE;
cmd->data_transfer_start[3] = (u32) virt_to_bus(hostdata->script) +
hostdata->E_other_transfer;
/*
* Currently, this command is flagged as completed, ie
* it has valid status and message data. Reflag it as
* incomplete. Q - need to do something so that original
* status, etc are used.
*/
cmd->result = cmd->cmd->result = 0xffff;
/*
* Restart command as a REQUEST SENSE.
*/
hostdata->dsp = (u32 *) hostdata->script + hostdata->E_select /
sizeof(u32);
hostdata->dsp_changed = 1;
return SPECIFIC_INT_NOTHING;
case A_int_debug_break:
return SPECIFIC_INT_BREAK;
case A_int_norm_aborted:
hostdata->dsp = (u32 *) hostdata->schedule;
hostdata->dsp_changed = 1;
if (cmd)
abnormal_finished (cmd, DID_ERROR << 16);
return SPECIFIC_INT_NOTHING;
case A_int_norm_emulateintfly:
NCR53c7x0_intfly(host);
return SPECIFIC_INT_NOTHING;
case A_int_test_1:
case A_int_test_2:
hostdata->idle = 1;
hostdata->test_completed = (dsps - A_int_test_1) / 0x00010000 + 1;
if (hostdata->options & OPTION_DEBUG_INTR)
printk("scsi%d : test%d complete\n", host->host_no,
hostdata->test_completed);
return SPECIFIC_INT_NOTHING;
#ifdef A_int_debug_reselected_ok
case A_int_debug_reselected_ok:
if (hostdata->options & (OPTION_DEBUG_SCRIPT|OPTION_DEBUG_INTR|
OPTION_DEBUG_DISCONNECT)) {
/*
* Note - this dsa is not based on location relative to
* the command structure, but to location relative to the
* DSA register
*/
u32 *dsa;
dsa = (u32 *) bus_to_virt (NCR53c7x0_read32(DSA_REG));
printk("scsi%d : reselected_ok (DSA = 0x%x (virt 0x%p)\n",
host->host_no, NCR53c7x0_read32(DSA_REG), dsa);
printk("scsi%d : resume address is 0x%x (virt 0x%p)\n",
host->host_no, cmd->saved_data_pointer,
bus_to_virt(cmd->saved_data_pointer));
print_insn (host, hostdata->script + Ent_reselected_ok /
sizeof(u32), "", 1);
if ((hostdata->chip / 100) == 8)
printk ("scsi%d : sxfer=0x%x, scntl3=0x%x\n",
host->host_no, NCR53c7x0_read8(SXFER_REG),
NCR53c7x0_read8(SCNTL3_REG_800));
else
printk ("scsi%d : sxfer=0x%x, cannot read SBCL\n",
host->host_no, NCR53c7x0_read8(SXFER_REG));
if (c) {
print_insn (host, (u32 *)
hostdata->sync[c->device->id].script, "", 1);
print_insn (host, (u32 *)
hostdata->sync[c->device->id].script + 2, "", 1);
}
}
return SPECIFIC_INT_RESTART;
#endif
#ifdef A_int_debug_reselect_check
case A_int_debug_reselect_check:
if (hostdata->options & (OPTION_DEBUG_SCRIPT|OPTION_DEBUG_INTR)) {
u32 *dsa;
#if 0
u32 *code;
#endif
/*
* Note - this dsa is not based on location relative to
* the command structure, but to location relative to the
* DSA register
*/
dsa = bus_to_virt (NCR53c7x0_read32(DSA_REG));
printk("scsi%d : reselected_check_next (DSA = 0x%lx (virt 0x%p))\n",
host->host_no, virt_to_bus(dsa), dsa);
if (dsa) {
printk("scsi%d : resume address is 0x%x (virt 0x%p)\n",
host->host_no, cmd->saved_data_pointer,
bus_to_virt (cmd->saved_data_pointer));
#if 0
printk("scsi%d : template code :\n", host->host_no);
for (code = dsa + (Ent_dsa_code_check_reselect - Ent_dsa_zero)
/ sizeof(u32); code < (dsa + Ent_dsa_zero / sizeof(u32));
code += print_insn (host, code, "", 1));
#endif
}
print_insn (host, hostdata->script + Ent_reselected_ok /
sizeof(u32), "", 1);
}
return SPECIFIC_INT_RESTART;
#endif
#ifdef A_int_debug_dsa_schedule
case A_int_debug_dsa_schedule:
if (hostdata->options & (OPTION_DEBUG_SCRIPT|OPTION_DEBUG_INTR)) {
u32 *dsa;
/*
* Note - this dsa is not based on location relative to
* the command structure, but to location relative to the
* DSA register
*/
dsa = (u32 *) bus_to_virt (NCR53c7x0_read32(DSA_REG));
printk("scsi%d : dsa_schedule (old DSA = 0x%lx (virt 0x%p))\n",
host->host_no, virt_to_bus(dsa), dsa);
if (dsa)
printk("scsi%d : resume address is 0x%x (virt 0x%p)\n"
" (temp was 0x%x (virt 0x%p))\n",
host->host_no, cmd->saved_data_pointer,
bus_to_virt (cmd->saved_data_pointer),
NCR53c7x0_read32 (TEMP_REG),
bus_to_virt (NCR53c7x0_read32(TEMP_REG)));
}
return SPECIFIC_INT_RESTART;
#endif
#ifdef A_int_debug_scheduled
case A_int_debug_scheduled:
if (hostdata->options & (OPTION_DEBUG_SCRIPT|OPTION_DEBUG_INTR)) {
printk("scsi%d : new I/O 0x%x (virt 0x%p) scheduled\n",
host->host_no, NCR53c7x0_read32(DSA_REG),
bus_to_virt(NCR53c7x0_read32(DSA_REG)));
}
return SPECIFIC_INT_RESTART;
#endif
#ifdef A_int_debug_idle
case A_int_debug_idle:
if (hostdata->options & (OPTION_DEBUG_SCRIPT|OPTION_DEBUG_INTR)) {
printk("scsi%d : idle\n", host->host_no);
}
return SPECIFIC_INT_RESTART;
#endif
#ifdef A_int_debug_cmd
case A_int_debug_cmd:
if (hostdata->options & (OPTION_DEBUG_SCRIPT|OPTION_DEBUG_INTR)) {
printk("scsi%d : command sent\n");
}
return SPECIFIC_INT_RESTART;
#endif
#ifdef A_int_debug_dsa_loaded
case A_int_debug_dsa_loaded:
if (hostdata->options & (OPTION_DEBUG_SCRIPT|OPTION_DEBUG_INTR)) {
printk("scsi%d : DSA loaded with 0x%x (virt 0x%p)\n", host->host_no,
NCR53c7x0_read32(DSA_REG),
bus_to_virt(NCR53c7x0_read32(DSA_REG)));
}
return SPECIFIC_INT_RESTART;
#endif
#ifdef A_int_debug_reselected
case A_int_debug_reselected:
if (hostdata->options & (OPTION_DEBUG_SCRIPT|OPTION_DEBUG_INTR|
OPTION_DEBUG_DISCONNECT)) {
if ((hostdata->chip / 100) == 8)
printk("scsi%d : reselected by target %d lun %d\n",
host->host_no, (int) NCR53c7x0_read8(SDID_REG_800) & ~0x80,
(int) hostdata->reselected_identify & 7);
else
printk("scsi%d : reselected by LCRC=0x%02x lun %d\n",
host->host_no, (int) NCR53c7x0_read8(LCRC_REG_10),
(int) hostdata->reselected_identify & 7);
print_queues(host);
}
return SPECIFIC_INT_RESTART;
#endif
#ifdef A_int_debug_disconnect_msg
case A_int_debug_disconnect_msg:
if (hostdata->options & (OPTION_DEBUG_SCRIPT|OPTION_DEBUG_INTR)) {
if (c)
printk("scsi%d : target %d lun %d disconnecting\n",
host->host_no, c->device->id, c->device->lun);
else
printk("scsi%d : unknown target disconnecting\n",
host->host_no);
}
return SPECIFIC_INT_RESTART;
#endif
#ifdef A_int_debug_disconnected
case A_int_debug_disconnected:
if (hostdata->options & (OPTION_DEBUG_SCRIPT|OPTION_DEBUG_INTR|
OPTION_DEBUG_DISCONNECT)) {
printk ("scsi%d : disconnected, new queues are\n",
host->host_no);
print_queues(host);
#if 0
/* Not valid on ncr53c710! */
printk ("scsi%d : sxfer=0x%x, scntl3=0x%x\n",
host->host_no, NCR53c7x0_read8(SXFER_REG),
NCR53c7x0_read8(SCNTL3_REG_800));
#endif
if (c) {
print_insn (host, (u32 *)
hostdata->sync[c->device->id].script, "", 1);
print_insn (host, (u32 *)
hostdata->sync[c->device->id].script + 2, "", 1);
}
}
return SPECIFIC_INT_RESTART;
#endif
#ifdef A_int_debug_panic
case A_int_debug_panic:
printk("scsi%d : int_debug_panic received\n", host->host_no);
print_lots (host);
return SPECIFIC_INT_PANIC;
#endif
#ifdef A_int_debug_saved
case A_int_debug_saved:
if (hostdata->options & (OPTION_DEBUG_SCRIPT|OPTION_DEBUG_INTR|
OPTION_DEBUG_DISCONNECT)) {
printk ("scsi%d : saved data pointer 0x%x (virt 0x%p)\n",
host->host_no, cmd->saved_data_pointer,
bus_to_virt (cmd->saved_data_pointer));
print_progress (c);
}
return SPECIFIC_INT_RESTART;
#endif
#ifdef A_int_debug_restored
case A_int_debug_restored:
if (hostdata->options & (OPTION_DEBUG_SCRIPT|OPTION_DEBUG_INTR|
OPTION_DEBUG_DISCONNECT)) {
if (cmd) {
int size;
printk ("scsi%d : restored data pointer 0x%x (virt 0x%p)\n",
host->host_no, cmd->saved_data_pointer, bus_to_virt (
cmd->saved_data_pointer));
size = print_insn (host, (u32 *)
bus_to_virt(cmd->saved_data_pointer), "", 1);
size = print_insn (host, (u32 *)
bus_to_virt(cmd->saved_data_pointer) + size, "", 1);
print_progress (c);
}
#if 0
printk ("scsi%d : datapath residual %d\n",
host->host_no, datapath_residual (host)) ;
#endif
}
return SPECIFIC_INT_RESTART;
#endif
#ifdef A_int_debug_sync
case A_int_debug_sync:
if (hostdata->options & (OPTION_DEBUG_SCRIPT|OPTION_DEBUG_INTR|
OPTION_DEBUG_DISCONNECT|OPTION_DEBUG_SDTR)) {
unsigned char sxfer = NCR53c7x0_read8 (SXFER_REG), scntl3;
if ((hostdata->chip / 100) == 8) {
scntl3 = NCR53c7x0_read8 (SCNTL3_REG_800);
if (c) {
if (sxfer != hostdata->sync[c->device->id].sxfer_sanity ||
scntl3 != hostdata->sync[c->device->id].scntl3_sanity) {
printk ("scsi%d : sync sanity check failed sxfer=0x%x, scntl3=0x%x",
host->host_no, sxfer, scntl3);
NCR53c7x0_write8 (SXFER_REG, sxfer);
NCR53c7x0_write8 (SCNTL3_REG_800, scntl3);
}
} else
printk ("scsi%d : unknown command sxfer=0x%x, scntl3=0x%x\n",
host->host_no, (int) sxfer, (int) scntl3);
} else {
if (c) {
if (sxfer != hostdata->sync[c->device->id].sxfer_sanity) {
printk ("scsi%d : sync sanity check failed sxfer=0x%x",
host->host_no, sxfer);
NCR53c7x0_write8 (SXFER_REG, sxfer);
NCR53c7x0_write8 (SBCL_REG,
hostdata->sync[c->device->id].sscf_710);
}
} else
printk ("scsi%d : unknown command sxfer=0x%x\n",
host->host_no, (int) sxfer);
}
}
return SPECIFIC_INT_RESTART;
#endif
#ifdef A_int_debug_datain
case A_int_debug_datain:
if (hostdata->options & (OPTION_DEBUG_SCRIPT|OPTION_DEBUG_INTR|
OPTION_DEBUG_DISCONNECT|OPTION_DEBUG_SDTR)) {
int size;
if ((hostdata->chip / 100) == 8)
printk ("scsi%d : In do_datain (%s) sxfer=0x%x, scntl3=0x%x\n"
" datapath residual=%d\n",
host->host_no, sbcl_to_phase (NCR53c7x0_read8 (SBCL_REG)),
(int) NCR53c7x0_read8(SXFER_REG),
(int) NCR53c7x0_read8(SCNTL3_REG_800),
datapath_residual (host)) ;
else
printk ("scsi%d : In do_datain (%s) sxfer=0x%x\n"
" datapath residual=%d\n",
host->host_no, sbcl_to_phase (NCR53c7x0_read8 (SBCL_REG)),
(int) NCR53c7x0_read8(SXFER_REG),
datapath_residual (host)) ;
print_insn (host, dsp, "", 1);
size = print_insn (host, (u32 *) bus_to_virt(dsp[1]), "", 1);
print_insn (host, (u32 *) bus_to_virt(dsp[1]) + size, "", 1);
}
return SPECIFIC_INT_RESTART;
#endif
#ifdef A_int_debug_check_dsa
case A_int_debug_check_dsa:
if (NCR53c7x0_read8 (SCNTL1_REG) & SCNTL1_CON) {
int sdid;
int tmp;
char *where;
if (hostdata->chip / 100 == 8)
sdid = NCR53c7x0_read8 (SDID_REG_800) & 15;
else {
tmp = NCR53c7x0_read8 (SDID_REG_700);
if (!tmp)
panic ("SDID_REG_700 = 0");
tmp >>= 1;
sdid = 0;
while (tmp) {
tmp >>= 1;
sdid++;
}
}
where = dsp - NCR53c7x0_insn_size(NCR53c7x0_read8
(DCMD_REG)) == hostdata->script +
Ent_select_check_dsa / sizeof(u32) ?
"selection" : "reselection";
if (c && sdid != c->device->id) {
printk ("scsi%d : SDID target %d != DSA target %d at %s\n",
host->host_no, sdid, c->device->id, where);
print_lots(host);
dump_events (host, 20);
return SPECIFIC_INT_PANIC;
}
}
return SPECIFIC_INT_RESTART;
#endif
default:
if ((dsps & 0xff000000) == 0x03000000) {
printk ("scsi%d : misc debug interrupt 0x%x\n",
host->host_no, dsps);
return SPECIFIC_INT_RESTART;
} else if ((dsps & 0xff000000) == 0x05000000) {
if (hostdata->events) {
struct NCR53c7x0_event *event;
++hostdata->event_index;
if (hostdata->event_index >= hostdata->event_size)
hostdata->event_index = 0;
event = (struct NCR53c7x0_event *) hostdata->events +
hostdata->event_index;
event->event = (enum ncr_event) dsps;
event->dsa = bus_to_virt(NCR53c7x0_read32(DSA_REG));
if (NCR53c7x0_read8 (SCNTL1_REG) & SCNTL1_CON) {
if (hostdata->chip / 100 == 8)
event->target = NCR53c7x0_read8(SSID_REG_800);
else {
unsigned char tmp, sdid;
tmp = NCR53c7x0_read8 (SDID_REG_700);
if (!tmp)
panic ("SDID_REG_700 = 0");
tmp >>= 1;
sdid = 0;
while (tmp) {
tmp >>= 1;
sdid++;
}
event->target = sdid;
}
}
else
event->target = 255;
if (event->event == EVENT_RESELECT)
event->lun = hostdata->reselected_identify & 0xf;
else if (c)
event->lun = c->device->lun;
else
event->lun = 255;
do_gettimeofday(&(event->time));
if (c) {
event->pid = c->pid;
memcpy ((void *) event->cmnd, (void *) c->cmnd,
sizeof (event->cmnd));
} else {
event->pid = -1;
}
}
return SPECIFIC_INT_RESTART;
}
printk ("scsi%d : unknown user interrupt 0x%x\n",
host->host_no, (unsigned) dsps);
return SPECIFIC_INT_PANIC;
}
}
/*
* XXX - the stock NCR assembler won't output the scriptu.h file,
* which undefine's all #define'd CPP symbols from the script.h
* file, which will create problems if you use multiple scripts
* with the same symbol names.
*
* If you insist on using NCR's assembler, you could generate
* scriptu.h from script.h using something like
*
* grep #define script.h | \
* sed 's/#define[ ][ ]*\([_a-zA-Z][_a-zA-Z0-9]*\).*$/#undefine \1/' \
* > scriptu.h
*/
#include "53c7xx_u.h"
/* XXX - add alternate script handling code here */
/*
* Function : static void NCR537xx_soft_reset (struct Scsi_Host *host)
*
* Purpose : perform a soft reset of the NCR53c7xx chip
*
* Inputs : host - pointer to this host adapter's structure
*
* Preconditions : NCR53c7x0_init must have been called for this
* host.
*
*/
static void
NCR53c7x0_soft_reset (struct Scsi_Host *host) {
NCR53c7x0_local_declare();
unsigned long flags;
struct NCR53c7x0_hostdata *hostdata = (struct NCR53c7x0_hostdata *)
host->hostdata[0];
NCR53c7x0_local_setup(host);
local_irq_save(flags);
/* Disable scsi chip and s/w level 7 ints */
#ifdef CONFIG_MVME16x
if (MACH_IS_MVME16x)
{
volatile unsigned long v;
v = *(volatile unsigned long *)0xfff4006c;
v &= ~0x8000;
*(volatile unsigned long *)0xfff4006c = v;
v = *(volatile unsigned long *)0xfff4202c;
v &= ~0x10;
*(volatile unsigned long *)0xfff4202c = v;
}
#endif
/* Anything specific for your hardware? */
/*
* Do a soft reset of the chip so that everything is
* reinitialized to the power-on state.
*
* Basically follow the procedure outlined in the NCR53c700
* data manual under Chapter Six, How to Use, Steps Necessary to
* Start SCRIPTS, with the exception of actually starting the
* script and setting up the synchronous transfer gunk.
*/
/* Should we reset the scsi bus here??????????????????? */
NCR53c7x0_write8(ISTAT_REG_700, ISTAT_10_SRST);
NCR53c7x0_write8(ISTAT_REG_700, 0);
/*
* saved_dcntl is set up in NCR53c7x0_init() before it is overwritten
* here. We should have some better way of working out the CF bit
* setting..
*/
hostdata->saved_dcntl = DCNTL_10_EA|DCNTL_10_COM;
if (hostdata->scsi_clock > 50000000)
hostdata->saved_dcntl |= DCNTL_700_CF_3;
else
if (hostdata->scsi_clock > 37500000)
hostdata->saved_dcntl |= DCNTL_700_CF_2;
#if 0
else
/* Any clocks less than 37.5MHz? */
#endif
if (hostdata->options & OPTION_DEBUG_TRACE)
NCR53c7x0_write8(DCNTL_REG, hostdata->saved_dcntl | DCNTL_SSM);
else
NCR53c7x0_write8(DCNTL_REG, hostdata->saved_dcntl);
/* Following disables snooping - snooping is not required, as non-
* cached pages are used for shared data, and appropriate use is
* made of cache_push/cache_clear. Indeed, for 68060
* enabling snooping causes disk corruption of ext2fs free block
* bitmaps and the like. If you have a 68060 with snooping hardwared
* on, then you need to enable CONFIG_060_WRITETHROUGH.
*/
NCR53c7x0_write8(CTEST7_REG, CTEST7_10_TT1|CTEST7_STD);
/* Actually burst of eight, according to my 53c710 databook */
NCR53c7x0_write8(hostdata->dmode, DMODE_10_BL_8 | DMODE_10_FC2);
NCR53c7x0_write8(SCID_REG, 1 << host->this_id);
NCR53c7x0_write8(SBCL_REG, 0);
NCR53c7x0_write8(SCNTL1_REG, SCNTL1_ESR_700);
NCR53c7x0_write8(SCNTL0_REG, ((hostdata->options & OPTION_PARITY) ?
SCNTL0_EPC : 0) | SCNTL0_EPG_700 | SCNTL0_ARB1 | SCNTL0_ARB2);
/*
* Enable all interrupts, except parity which we only want when
* the user requests it.
*/
NCR53c7x0_write8(DIEN_REG, DIEN_700_BF |
DIEN_ABRT | DIEN_SSI | DIEN_SIR | DIEN_700_OPC);
NCR53c7x0_write8(SIEN_REG_700, ((hostdata->options & OPTION_PARITY) ?
SIEN_PAR : 0) | SIEN_700_STO | SIEN_RST | SIEN_UDC |
SIEN_SGE | SIEN_MA);
#ifdef CONFIG_MVME16x
if (MACH_IS_MVME16x)
{
volatile unsigned long v;
/* Enable scsi chip and s/w level 7 ints */
v = *(volatile unsigned long *)0xfff40080;
v = (v & ~(0xf << 28)) | (4 << 28);
*(volatile unsigned long *)0xfff40080 = v;
v = *(volatile unsigned long *)0xfff4006c;
v |= 0x8000;
*(volatile unsigned long *)0xfff4006c = v;
v = *(volatile unsigned long *)0xfff4202c;
v = (v & ~0xff) | 0x10 | 4;
*(volatile unsigned long *)0xfff4202c = v;
}
#endif
/* Anything needed for your hardware? */
local_irq_restore(flags);
}
/*
* Function static struct NCR53c7x0_cmd *allocate_cmd (Scsi_Cmnd *cmd)
*
* Purpose : Return the first free NCR53c7x0_cmd structure (which are
* reused in a LIFO manner to minimize cache thrashing).
*
* Side effects : If we haven't yet scheduled allocation of NCR53c7x0_cmd
* structures for this device, do so. Attempt to complete all scheduled
* allocations using get_zeroed_page(), putting NCR53c7x0_cmd structures on
* the free list. Teach programmers not to drink and hack.
*
* Inputs : cmd - SCSI command
*
* Returns : NCR53c7x0_cmd structure allocated on behalf of cmd;
* NULL on failure.
*/
static void
my_free_page (void *addr, int dummy)
{
/* XXX This assumes default cache mode to be IOMAP_FULL_CACHING, which
* XXX may be invalid (CONFIG_060_WRITETHROUGH)
*/
kernel_set_cachemode((void *)addr, 4096, IOMAP_FULL_CACHING);
free_page ((u32)addr);
}
static struct NCR53c7x0_cmd *
allocate_cmd (Scsi_Cmnd *cmd) {
struct Scsi_Host *host = cmd->device->host;
struct NCR53c7x0_hostdata *hostdata =
(struct NCR53c7x0_hostdata *) host->hostdata[0];
u32 real; /* Real address */
int size; /* Size of *tmp */
struct NCR53c7x0_cmd *tmp;
unsigned long flags;
if (hostdata->options & OPTION_DEBUG_ALLOCATION)
printk ("scsi%d : num_cmds = %d, can_queue = %d\n"
" target = %d, lun = %d, %s\n",
host->host_no, hostdata->num_cmds, host->can_queue,
cmd->device->id, cmd->device->lun, (hostdata->cmd_allocated[cmd->device->id] &
(1 << cmd->device->lun)) ? "already allocated" : "not allocated");
/*
* If we have not yet reserved commands for this I_T_L nexus, and
* the device exists (as indicated by permanent Scsi_Cmnd structures
* being allocated under 1.3.x, or being outside of scan_scsis in
* 1.2.x), do so now.
*/
if (!(hostdata->cmd_allocated[cmd->device->id] & (1 << cmd->device->lun)) &&
cmd->device && cmd->device->has_cmdblocks) {
if ((hostdata->extra_allocate + hostdata->num_cmds) < host->can_queue)
hostdata->extra_allocate += host->cmd_per_lun;
hostdata->cmd_allocated[cmd->device->id] |= (1 << cmd->device->lun);
}
for (; hostdata->extra_allocate > 0 ; --hostdata->extra_allocate,
++hostdata->num_cmds) {
/* historically, kmalloc has returned unaligned addresses; pad so we
have enough room to ROUNDUP */
size = hostdata->max_cmd_size + sizeof (void *);
#ifdef FORCE_DSA_ALIGNMENT
/*
* 53c710 rev.0 doesn't have an add-with-carry instruction.
* Ensure we allocate enough memory to force alignment.
*/
size += 256;
#endif
/* FIXME: for ISA bus '7xx chips, we need to or GFP_DMA in here */
if (size > 4096) {
printk (KERN_ERR "53c7xx: allocate_cmd size > 4K\n");
return NULL;
}
real = get_zeroed_page(GFP_ATOMIC);
if (real == 0)
return NULL;
memset((void *)real, 0, 4096);
cache_push(virt_to_phys((void *)real), 4096);
cache_clear(virt_to_phys((void *)real), 4096);
kernel_set_cachemode((void *)real, 4096, IOMAP_NOCACHE_SER);
tmp = ROUNDUP(real, void *);
#ifdef FORCE_DSA_ALIGNMENT
{
if (((u32)tmp & 0xff) > CmdPageStart)
tmp = (struct NCR53c7x0_cmd *)((u32)tmp + 255);
tmp = (struct NCR53c7x0_cmd *)(((u32)tmp & ~0xff) + CmdPageStart);
#if 0
printk ("scsi: size = %d, real = 0x%08x, tmp set to 0x%08x\n",
size, real, (u32)tmp);
#endif
}
#endif
tmp->real = (void *)real;
tmp->size = size;
tmp->free = ((void (*)(void *, int)) my_free_page);
local_irq_save(flags);
tmp->next = hostdata->free;
hostdata->free = tmp;
local_irq_restore(flags);
}
local_irq_save(flags);
tmp = (struct NCR53c7x0_cmd *) hostdata->free;
if (tmp) {
hostdata->free = tmp->next;
}
local_irq_restore(flags);
if (!tmp)
printk ("scsi%d : can't allocate command for target %d lun %d\n",
host->host_no, cmd->device->id, cmd->device->lun);
return tmp;
}
/*
* Function static struct NCR53c7x0_cmd *create_cmd (Scsi_Cmnd *cmd)
*
*
* Purpose : allocate a NCR53c7x0_cmd structure, initialize it based on the
* Scsi_Cmnd structure passed in cmd, including dsa and Linux field
* initialization, and dsa code relocation.
*
* Inputs : cmd - SCSI command
*
* Returns : NCR53c7x0_cmd structure corresponding to cmd,
* NULL on failure.
*/
static struct NCR53c7x0_cmd *
create_cmd (Scsi_Cmnd *cmd) {
NCR53c7x0_local_declare();
struct Scsi_Host *host = cmd->device->host;
struct NCR53c7x0_hostdata *hostdata = (struct NCR53c7x0_hostdata *)
host->hostdata[0];
struct NCR53c7x0_cmd *tmp; /* NCR53c7x0_cmd structure for this command */
int datain, /* Number of instructions per phase */
dataout;
int data_transfer_instructions, /* Count of dynamic instructions */
i; /* Counter */
u32 *cmd_datain, /* Address of datain/dataout code */
*cmd_dataout; /* Incremented as we assemble */
#ifdef notyet
unsigned char *msgptr; /* Current byte in select message */
int msglen; /* Length of whole select message */
#endif
unsigned long flags;
u32 exp_select_indirect; /* Used in sanity check */
NCR53c7x0_local_setup(cmd->device->host);
if (!(tmp = allocate_cmd (cmd)))
return NULL;
/*
* Copy CDB and initialised result fields from Scsi_Cmnd to NCR53c7x0_cmd.
* We do this because NCR53c7x0_cmd may have a special cache mode
* selected to cope with lack of bus snooping, etc.
*/
memcpy(tmp->cmnd, cmd->cmnd, 12);
tmp->result = cmd->result;
/*
* Decide whether we need to generate commands for DATA IN,
* DATA OUT, neither, or both based on the SCSI command
*/
switch (cmd->cmnd[0]) {
/* These commands do DATA IN */
case INQUIRY:
case MODE_SENSE:
case READ_6:
case READ_10:
case READ_CAPACITY:
case REQUEST_SENSE:
case READ_BLOCK_LIMITS:
case READ_TOC:
datain = 2 * (cmd->use_sg ? cmd->use_sg : 1) + 3;
dataout = 0;
break;
/* These commands do DATA OUT */
case MODE_SELECT:
case WRITE_6:
case WRITE_10:
#if 0
printk("scsi%d : command is ", host->host_no);
[PATCH] remove outdated print_* functions We have the scsi_print_* functions in the proper namespace for a long time now and there weren't a lot users left. Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2005-04-03 12:53:59 -07:00
__scsi_print_command(cmd->cmnd);
Linux-2.6.12-rc2 Initial git repository build. I'm not bothering with the full history, even though we have it. We can create a separate "historical" git archive of that later if we want to, and in the meantime it's about 3.2GB when imported into git - space that would just make the early git days unnecessarily complicated, when we don't have a lot of good infrastructure for it. Let it rip!
2005-04-16 15:20:36 -07:00
#endif
#if 0
printk ("scsi%d : %d scatter/gather segments\n", host->host_no,
cmd->use_sg);
#endif
datain = 0;
dataout = 2 * (cmd->use_sg ? cmd->use_sg : 1) + 3;
#if 0
hostdata->options |= OPTION_DEBUG_INTR;
#endif
break;
/*
* These commands do no data transfer, we should force an
* interrupt if a data phase is attempted on them.
*/
case TEST_UNIT_READY:
case ALLOW_MEDIUM_REMOVAL:
case START_STOP:
datain = dataout = 0;
break;
/*
* We don't know about these commands, so generate code to handle
* both DATA IN and DATA OUT phases. More efficient to identify them
* and add them to the above cases.
*/
default:
printk("scsi%d : datain+dataout for command ", host->host_no);
[PATCH] remove outdated print_* functions We have the scsi_print_* functions in the proper namespace for a long time now and there weren't a lot users left. Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2005-04-03 12:53:59 -07:00
__scsi_print_command(cmd->cmnd);
Linux-2.6.12-rc2 Initial git repository build. I'm not bothering with the full history, even though we have it. We can create a separate "historical" git archive of that later if we want to, and in the meantime it's about 3.2GB when imported into git - space that would just make the early git days unnecessarily complicated, when we don't have a lot of good infrastructure for it. Let it rip!
2005-04-16 15:20:36 -07:00
datain = dataout = 2 * (cmd->use_sg ? cmd->use_sg : 1) + 3;
}
/*
* New code : so that active pointers work correctly regardless
* of where the saved data pointer is at, we want to immediately
* enter the dynamic code after selection, and on a non-data
* phase perform a CALL to the non-data phase handler, with
* returns back to this address.
*
* If a phase mismatch is encountered in the middle of a
* Block MOVE instruction, we want to _leave_ that instruction
* unchanged as the current case is, modify a temporary buffer,
* and point the active pointer (TEMP) at that.
*
* Furthermore, we want to implement a saved data pointer,
* set by the SAVE_DATA_POINTERs message.
*
* So, the data transfer segments will change to
* CALL data_transfer, WHEN NOT data phase
* MOVE x, x, WHEN data phase
* ( repeat )
* JUMP other_transfer
*/
data_transfer_instructions = datain + dataout;
/*
* When we perform a request sense, we overwrite various things,
* including the data transfer code. Make sure we have enough
* space to do that.
*/
if (data_transfer_instructions < 2)
data_transfer_instructions = 2;
/*
* The saved data pointer is set up so that a RESTORE POINTERS message
* will start the data transfer over at the beginning.
*/
tmp->saved_data_pointer = virt_to_bus (hostdata->script) +
hostdata->E_data_transfer;
/*
* Initialize Linux specific fields.
*/
tmp->cmd = cmd;
tmp->next = NULL;
tmp->flags = 0;
tmp->dsa_next_addr = virt_to_bus(tmp->dsa) + hostdata->dsa_next -
hostdata->dsa_start;
tmp->dsa_addr = virt_to_bus(tmp->dsa) - hostdata->dsa_start;
/*
* Calculate addresses of dynamic code to fill in DSA
*/
tmp->data_transfer_start = tmp->dsa + (hostdata->dsa_end -
hostdata->dsa_start) / sizeof(u32);
tmp->data_transfer_end = tmp->data_transfer_start +
2 * data_transfer_instructions;
cmd_datain = datain ? tmp->data_transfer_start : NULL;
cmd_dataout = dataout ? (datain ? cmd_datain + 2 * datain : tmp->
data_transfer_start) : NULL;
/*
* Fill in the NCR53c7x0_cmd structure as follows
* dsa, with fixed up DSA code
* datain code
* dataout code
*/
/* Copy template code into dsa and perform all necessary fixups */
if (hostdata->dsa_fixup)
hostdata->dsa_fixup(tmp);
patch_dsa_32(tmp->dsa, dsa_next, 0, 0);
/*
* XXX is this giving 53c710 access to the Scsi_Cmnd in some way?
* Do we need to change it for caching reasons?
*/
patch_dsa_32(tmp->dsa, dsa_cmnd, 0, virt_to_bus(cmd));
if (hostdata->options & OPTION_DEBUG_SYNCHRONOUS) {
exp_select_indirect = ((1 << cmd->device->id) << 16) |
(hostdata->sync[cmd->device->id].sxfer_sanity << 8);
if (hostdata->sync[cmd->device->id].select_indirect !=
exp_select_indirect) {
printk ("scsi%d : sanity check failed select_indirect=0x%x\n",
host->host_no, hostdata->sync[cmd->device->id].select_indirect);
FATAL(host);
}
}
patch_dsa_32(tmp->dsa, dsa_select, 0,
hostdata->sync[cmd->device->id].select_indirect);
/*
* Right now, we'll do the WIDE and SYNCHRONOUS negotiations on
* different commands; although it should be trivial to do them
* both at the same time.
*/
if (hostdata->initiate_wdtr & (1 << cmd->device->id)) {
memcpy ((void *) (tmp->select + 1), (void *) wdtr_message,
sizeof(wdtr_message));
patch_dsa_32(tmp->dsa, dsa_msgout, 0, 1 + sizeof(wdtr_message));
local_irq_save(flags);
hostdata->initiate_wdtr &= ~(1 << cmd->device->id);
local_irq_restore(flags);
} else if (hostdata->initiate_sdtr & (1 << cmd->device->id)) {
memcpy ((void *) (tmp->select + 1), (void *) sdtr_message,
sizeof(sdtr_message));
patch_dsa_32(tmp->dsa, dsa_msgout, 0, 1 + sizeof(sdtr_message));
tmp->flags |= CMD_FLAG_SDTR;
local_irq_save(flags);
hostdata->initiate_sdtr &= ~(1 << cmd->device->id);
local_irq_restore(flags);
}
#if 1
else if (!(hostdata->talked_to & (1 << cmd->device->id)) &&
!(hostdata->options & OPTION_NO_ASYNC)) {
memcpy ((void *) (tmp->select + 1), (void *) async_message,
sizeof(async_message));
patch_dsa_32(tmp->dsa, dsa_msgout, 0, 1 + sizeof(async_message));
tmp->flags |= CMD_FLAG_SDTR;
}
#endif
else
patch_dsa_32(tmp->dsa, dsa_msgout, 0, 1);
hostdata->talked_to |= (1 << cmd->device->id);
tmp->select[0] = (hostdata->options & OPTION_DISCONNECT) ?
IDENTIFY (1, cmd->device->lun) : IDENTIFY (0, cmd->device->lun);
patch_dsa_32(tmp->dsa, dsa_msgout, 1, virt_to_bus(tmp->select));
patch_dsa_32(tmp->dsa, dsa_cmdout, 0, cmd->cmd_len);
patch_dsa_32(tmp->dsa, dsa_cmdout, 1, virt_to_bus(tmp->cmnd));
patch_dsa_32(tmp->dsa, dsa_dataout, 0, cmd_dataout ?
virt_to_bus (cmd_dataout)
: virt_to_bus (hostdata->script) + hostdata->E_other_transfer);
patch_dsa_32(tmp->dsa, dsa_datain, 0, cmd_datain ?
virt_to_bus (cmd_datain)
: virt_to_bus (hostdata->script) + hostdata->E_other_transfer);
/*
* XXX - need to make endian aware, should use separate variables
* for both status and message bytes.
*/
patch_dsa_32(tmp->dsa, dsa_msgin, 0, 1);
/*
* FIXME : these only works for little endian. We probably want to
* provide message and status fields in the NCR53c7x0_cmd
* structure, and assign them to cmd->result when we're done.
*/
#ifdef BIG_ENDIAN
patch_dsa_32(tmp->dsa, dsa_msgin, 1, virt_to_bus(&tmp->result) + 2);
patch_dsa_32(tmp->dsa, dsa_status, 0, 1);
patch_dsa_32(tmp->dsa, dsa_status, 1, virt_to_bus(&tmp->result) + 3);
#else
patch_dsa_32(tmp->dsa, dsa_msgin, 1, virt_to_bus(&tmp->result) + 1);
patch_dsa_32(tmp->dsa, dsa_status, 0, 1);
patch_dsa_32(tmp->dsa, dsa_status, 1, virt_to_bus(&tmp->result));
#endif
patch_dsa_32(tmp->dsa, dsa_msgout_other, 0, 1);
patch_dsa_32(tmp->dsa, dsa_msgout_other, 1,
virt_to_bus(&(hostdata->NCR53c7xx_msg_nop)));
/*
* Generate code for zero or more of the DATA IN, DATA OUT phases
* in the format
*
* CALL data_transfer, WHEN NOT phase
* MOVE first buffer length, first buffer address, WHEN phase
* ...
* MOVE last buffer length, last buffer address, WHEN phase
* JUMP other_transfer
*/
/*
* See if we're getting to data transfer by generating an unconditional
* interrupt.
*/
#if 0
if (datain) {
cmd_datain[0] = 0x98080000;
cmd_datain[1] = 0x03ffd00d;
cmd_datain += 2;
}
#endif
/*
* XXX - I'm undecided whether all of this nonsense is faster
* in the long run, or whether I should just go and implement a loop
* on the NCR chip using table indirect mode?
*
* In any case, this is how it _must_ be done for 53c700/700-66 chips,
* so this stays even when we come up with something better.
*
* When we're limited to 1 simultaneous command, no overlapping processing,
* we're seeing 630K/sec, with 7% CPU usage on a slow Syquest 45M
* drive.
*
* Not bad, not good. We'll see.
*/
tmp->bounce.len = 0; /* Assume aligned buffer */
for (i = 0; cmd->use_sg ? (i < cmd->use_sg) : !i; cmd_datain += 4,
cmd_dataout += 4, ++i) {
u32 vbuf = cmd->use_sg
[SCSI] More buffer->request_buffer changes Seem like quite a few splipped through the cracks. Here's a patch to update all references I could find: Signed-off-by: Christoph Hellwig <hch@lst.de> Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-07-14 01:29:34 -07:00
? (u32)page_address(((struct scatterlist *)cmd->request_buffer)[i].page)+
((struct scatterlist *)cmd->request_buffer)[i].offset
Linux-2.6.12-rc2 Initial git repository build. I'm not bothering with the full history, even though we have it. We can create a separate "historical" git archive of that later if we want to, and in the meantime it's about 3.2GB when imported into git - space that would just make the early git days unnecessarily complicated, when we don't have a lot of good infrastructure for it. Let it rip!
2005-04-16 15:20:36 -07:00
: (u32)(cmd->request_buffer);
u32 bbuf = virt_to_bus((void *)vbuf);
u32 count = cmd->use_sg ?
[SCSI] More buffer->request_buffer changes Seem like quite a few splipped through the cracks. Here's a patch to update all references I could find: Signed-off-by: Christoph Hellwig <hch@lst.de> Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-07-14 01:29:34 -07:00
((struct scatterlist *)cmd->request_buffer)[i].length :
Linux-2.6.12-rc2 Initial git repository build. I'm not bothering with the full history, even though we have it. We can create a separate "historical" git archive of that later if we want to, and in the meantime it's about 3.2GB when imported into git - space that would just make the early git days unnecessarily complicated, when we don't have a lot of good infrastructure for it. Let it rip!
2005-04-16 15:20:36 -07:00
cmd->request_bufflen;
/*
* If we have buffers which are not aligned with 16 byte cache
* lines, then we just hope nothing accesses the other parts of
* those cache lines while the transfer is in progress. That would
* fill the cache, and subsequent reads of the dma data would pick
* up the wrong thing.
* XXX We need a bounce buffer to handle that correctly.
*/
if (((bbuf & 15) || (count & 15)) && (datain || dataout))
{
/* Bounce buffer needed */
if (cmd->use_sg)
printk ("53c7xx: Non-aligned buffer with use_sg\n");
else if (datain && dataout)
printk ("53c7xx: Non-aligned buffer with datain && dataout\n");
else if (count > 256)
printk ("53c7xx: Non-aligned transfer > 256 bytes\n");
else
{
if (datain)
{
tmp->bounce.len = count;
tmp->bounce.addr = vbuf;
bbuf = virt_to_bus(tmp->bounce.buf);
tmp->bounce.buf[0] = 0xff;
tmp->bounce.buf[1] = 0xfe;
tmp->bounce.buf[2] = 0xfd;
tmp->bounce.buf[3] = 0xfc;
}
if (dataout)
{
memcpy ((void *)tmp->bounce.buf, (void *)vbuf, count);
bbuf = virt_to_bus(tmp->bounce.buf);
}
}
}
if (datain) {
cache_clear(virt_to_phys((void *)vbuf), count);
/* CALL other_in, WHEN NOT DATA_IN */
cmd_datain[0] = ((DCMD_TYPE_TCI | DCMD_TCI_OP_CALL |
DCMD_TCI_IO) << 24) |
DBC_TCI_WAIT_FOR_VALID | DBC_TCI_COMPARE_PHASE;
cmd_datain[1] = virt_to_bus (hostdata->script) +
hostdata->E_other_in;
/* MOVE count, buf, WHEN DATA_IN */
cmd_datain[2] = ((DCMD_TYPE_BMI | DCMD_BMI_OP_MOVE_I | DCMD_BMI_IO)
<< 24) | count;
cmd_datain[3] = bbuf;
#if 0
print_insn (host, cmd_datain, "dynamic ", 1);
print_insn (host, cmd_datain + 2, "dynamic ", 1);
#endif
}
if (dataout) {
cache_push(virt_to_phys((void *)vbuf), count);
/* CALL other_out, WHEN NOT DATA_OUT */
cmd_dataout[0] = ((DCMD_TYPE_TCI | DCMD_TCI_OP_CALL) << 24) |
DBC_TCI_WAIT_FOR_VALID | DBC_TCI_COMPARE_PHASE;
cmd_dataout[1] = virt_to_bus(hostdata->script) +
hostdata->E_other_out;
/* MOVE count, buf, WHEN DATA+OUT */
cmd_dataout[2] = ((DCMD_TYPE_BMI | DCMD_BMI_OP_MOVE_I) << 24)
| count;
cmd_dataout[3] = bbuf;
#if 0
print_insn (host, cmd_dataout, "dynamic ", 1);
print_insn (host, cmd_dataout + 2, "dynamic ", 1);
#endif
}
}
/*
* Install JUMP instructions after the data transfer routines to return
* control to the do_other_transfer routines.
*/
if (datain) {
cmd_datain[0] = ((DCMD_TYPE_TCI | DCMD_TCI_OP_JUMP) << 24) |
DBC_TCI_TRUE;
cmd_datain[1] = virt_to_bus(hostdata->script) +
hostdata->E_other_transfer;
#if 0
print_insn (host, cmd_datain, "dynamic jump ", 1);
#endif
cmd_datain += 2;
}
#if 0
if (datain) {
cmd_datain[0] = 0x98080000;
cmd_datain[1] = 0x03ffdeed;
cmd_datain += 2;
}
#endif
if (dataout) {
cmd_dataout[0] = ((DCMD_TYPE_TCI | DCMD_TCI_OP_JUMP) << 24) |
DBC_TCI_TRUE;
cmd_dataout[1] = virt_to_bus(hostdata->script) +
hostdata->E_other_transfer;
#if 0
print_insn (host, cmd_dataout, "dynamic jump ", 1);
#endif
cmd_dataout += 2;
}
return tmp;
}
/*
* Function : int NCR53c7xx_queue_command (Scsi_Cmnd *cmd,
* void (*done)(Scsi_Cmnd *))
*
* Purpose : enqueues a SCSI command
*
* Inputs : cmd - SCSI command, done - function called on completion, with
* a pointer to the command descriptor.
*
* Returns : 0
*
* Side effects :
* cmd is added to the per instance driver issue_queue, with major
* twiddling done to the host specific fields of cmd. If the
* process_issue_queue coroutine isn't running, it is restarted.
*
* NOTE : we use the host_scribble field of the Scsi_Cmnd structure to
* hold our own data, and pervert the ptr field of the SCp field
* to create a linked list.
*/
int
NCR53c7xx_queue_command (Scsi_Cmnd *cmd, void (* done)(Scsi_Cmnd *)) {
struct Scsi_Host *host = cmd->device->host;
struct NCR53c7x0_hostdata *hostdata =
(struct NCR53c7x0_hostdata *) host->hostdata[0];
unsigned long flags;
Scsi_Cmnd *tmp;
cmd->scsi_done = done;
cmd->host_scribble = NULL;
cmd->SCp.ptr = NULL;
cmd->SCp.buffer = NULL;
#ifdef VALID_IDS
/* Ignore commands on invalid IDs */
if (!hostdata->valid_ids[cmd->device->id]) {
printk("scsi%d : ignoring target %d lun %d\n", host->host_no,
cmd->device->id, cmd->device->lun);
cmd->result = (DID_BAD_TARGET << 16);
done(cmd);
return 0;
}
#endif
local_irq_save(flags);
if ((hostdata->options & (OPTION_DEBUG_INIT_ONLY|OPTION_DEBUG_PROBE_ONLY))
|| ((hostdata->options & OPTION_DEBUG_TARGET_LIMIT) &&
!(hostdata->debug_lun_limit[cmd->device->id] & (1 << cmd->device->lun)))
#ifdef LINUX_1_2
|| cmd->device->id > 7
#else
[SCSI] audit drivers for incorrect max_id use max_id now means the maximum number of ids on the bus, which means it is one greater than the largest possible id number. Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-05-23 01:29:28 -07:00
|| cmd->device->id >= host->max_id
Linux-2.6.12-rc2 Initial git repository build. I'm not bothering with the full history, even though we have it. We can create a separate "historical" git archive of that later if we want to, and in the meantime it's about 3.2GB when imported into git - space that would just make the early git days unnecessarily complicated, when we don't have a lot of good infrastructure for it. Let it rip!
2005-04-16 15:20:36 -07:00
#endif
|| cmd->device->id == host->this_id
|| hostdata->state == STATE_DISABLED) {
printk("scsi%d : disabled or bad target %d lun %d\n", host->host_no,
cmd->device->id, cmd->device->lun);
cmd->result = (DID_BAD_TARGET << 16);
done(cmd);
local_irq_restore(flags);
return 0;
}
if ((hostdata->options & OPTION_DEBUG_NCOMMANDS_LIMIT) &&
(hostdata->debug_count_limit == 0)) {
printk("scsi%d : maximum commands exceeded\n", host->host_no);
cmd->result = (DID_BAD_TARGET << 16);
done(cmd);
local_irq_restore(flags);
return 0;
}
if (hostdata->options & OPTION_DEBUG_READ_ONLY) {
switch (cmd->cmnd[0]) {
case WRITE_6:
case WRITE_10:
printk("scsi%d : WRITE attempted with NO_WRITE debugging flag set\n",
host->host_no);
cmd->result = (DID_BAD_TARGET << 16);
done(cmd);
local_irq_restore(flags);
return 0;
}
}
if ((hostdata->options & OPTION_DEBUG_TARGET_LIMIT) &&
hostdata->debug_count_limit != -1)
--hostdata->debug_count_limit;
cmd->result = 0xffff; /* The NCR will overwrite message
and status with valid data */
cmd->host_scribble = (unsigned char *) tmp = create_cmd (cmd);
/*
* REQUEST SENSE commands are inserted at the head of the queue
* so that we do not clear the contingent allegiance condition
* they may be looking at.
*/
if (!(hostdata->issue_queue) || (cmd->cmnd[0] == REQUEST_SENSE)) {
cmd->SCp.ptr = (unsigned char *) hostdata->issue_queue;
hostdata->issue_queue = cmd;
} else {
for (tmp = (Scsi_Cmnd *) hostdata->issue_queue; tmp->SCp.ptr;
tmp = (Scsi_Cmnd *) tmp->SCp.ptr);
tmp->SCp.ptr = (unsigned char *) cmd;
}
local_irq_restore(flags);
run_process_issue_queue();
return 0;
}
/*
* Function : void to_schedule_list (struct Scsi_Host *host,
* struct NCR53c7x0_hostdata * hostdata, Scsi_Cmnd *cmd)
*
* Purpose : takes a SCSI command which was just removed from the
* issue queue, and deals with it by inserting it in the first
* free slot in the schedule list or by terminating it immediately.
*
* Inputs :
* host - SCSI host adapter; hostdata - hostdata structure for
* this adapter; cmd - a pointer to the command; should have
* the host_scribble field initialized to point to a valid
*
* Side effects :
* cmd is added to the per instance schedule list, with minor
* twiddling done to the host specific fields of cmd.
*
*/
static __inline__ void
to_schedule_list (struct Scsi_Host *host, struct NCR53c7x0_hostdata *hostdata,
struct NCR53c7x0_cmd *cmd) {
NCR53c7x0_local_declare();
Scsi_Cmnd *tmp = cmd->cmd;
unsigned long flags;
/* dsa start is negative, so subtraction is used */
volatile u32 *ncrcurrent;
int i;
NCR53c7x0_local_setup(host);
#if 0
printk("scsi%d : new dsa is 0x%lx (virt 0x%p)\n", host->host_no,
virt_to_bus(hostdata->dsa), hostdata->dsa);
#endif
local_irq_save(flags);
/*
* Work around race condition : if an interrupt fired and we
* got disabled forget about this command.
*/
if (hostdata->state == STATE_DISABLED) {
printk("scsi%d : driver disabled\n", host->host_no);
tmp->result = (DID_BAD_TARGET << 16);
cmd->next = (struct NCR53c7x0_cmd *) hostdata->free;
hostdata->free = cmd;
tmp->scsi_done(tmp);
local_irq_restore(flags);
return;
}
for (i = host->can_queue, ncrcurrent = hostdata->schedule;
i > 0 && ncrcurrent[0] != hostdata->NOP_insn;
--i, ncrcurrent += 2 /* JUMP instructions are two words */);
if (i > 0) {
++hostdata->busy[tmp->device->id][tmp->device->lun];
cmd->next = hostdata->running_list;
hostdata->running_list = cmd;
/* Restore this instruction to a NOP once the command starts */
cmd->dsa [(hostdata->dsa_jump_dest - hostdata->dsa_start) /
sizeof(u32)] = (u32) virt_to_bus ((void *)ncrcurrent);
/* Replace the current jump operand. */
ncrcurrent[1] =
virt_to_bus ((void *) cmd->dsa) + hostdata->E_dsa_code_begin -
hostdata->E_dsa_code_template;
/* Replace the NOP instruction with a JUMP */
ncrcurrent[0] = ((DCMD_TYPE_TCI|DCMD_TCI_OP_JUMP) << 24) |
DBC_TCI_TRUE;
} else {
printk ("scsi%d: no free slot\n", host->host_no);
disable(host);
tmp->result = (DID_ERROR << 16);
cmd->next = (struct NCR53c7x0_cmd *) hostdata->free;
hostdata->free = cmd;
tmp->scsi_done(tmp);
local_irq_restore(flags);
return;
}
/*
* If the NCR chip is in an idle state, start it running the scheduler
* immediately. Otherwise, signal the chip to jump to schedule as
* soon as it is idle.
*/
if (hostdata->idle) {
hostdata->idle = 0;
hostdata->state = STATE_RUNNING;
NCR53c7x0_write32 (DSP_REG, virt_to_bus ((void *)hostdata->schedule));
if (hostdata->options & OPTION_DEBUG_TRACE)
NCR53c7x0_write8 (DCNTL_REG, hostdata->saved_dcntl |
DCNTL_SSM | DCNTL_STD);
} else {
NCR53c7x0_write8(hostdata->istat, ISTAT_10_SIGP);
}
local_irq_restore(flags);
}
/*
* Function : busyp (struct Scsi_Host *host, struct NCR53c7x0_hostdata
* *hostdata, Scsi_Cmnd *cmd)
*
* Purpose : decide if we can pass the given SCSI command on to the
* device in question or not.
*
* Returns : non-zero when we're busy, 0 when we aren't.
*/
static __inline__ int
busyp (struct Scsi_Host *host, struct NCR53c7x0_hostdata *hostdata,
Scsi_Cmnd *cmd) {
/* FIXME : in the future, this needs to accommodate SCSI-II tagged
queuing, and we may be able to play with fairness here a bit.
*/
return hostdata->busy[cmd->device->id][cmd->device->lun];
}
/*
* Function : process_issue_queue (void)
*
* Purpose : transfer commands from the issue queue to NCR start queue
* of each NCR53c7/8xx in the system, avoiding kernel stack
* overflows when the scsi_done() function is invoked recursively.
*
* NOTE : process_issue_queue exits with interrupts *disabled*, so the
* caller must reenable them if it desires.
*
* NOTE : process_issue_queue should be called from both
* NCR53c7x0_queue_command() and from the interrupt handler
* after command completion in case NCR53c7x0_queue_command()
* isn't invoked again but we've freed up resources that are
* needed.
*/
static void
process_issue_queue (unsigned long flags) {
Scsi_Cmnd *tmp, *prev;
struct Scsi_Host *host;
struct NCR53c7x0_hostdata *hostdata;
int done;
/*
* We run (with interrupts disabled) until we're sure that none of
* the host adapters have anything that can be done, at which point
* we set process_issue_queue_running to 0 and exit.
*
* Interrupts are enabled before doing various other internal
* instructions, after we've decided that we need to run through
* the loop again.
*
*/
do {
local_irq_disable(); /* Freeze request queues */
done = 1;
for (host = first_host; host && host->hostt == the_template;
host = host->next) {
hostdata = (struct NCR53c7x0_hostdata *) host->hostdata[0];
local_irq_disable();
if (hostdata->issue_queue) {
if (hostdata->state == STATE_DISABLED) {
tmp = (Scsi_Cmnd *) hostdata->issue_queue;
hostdata->issue_queue = (Scsi_Cmnd *) tmp->SCp.ptr;
tmp->result = (DID_BAD_TARGET << 16);
if (tmp->host_scribble) {
((struct NCR53c7x0_cmd *)tmp->host_scribble)->next =
hostdata->free;
hostdata->free =
(struct NCR53c7x0_cmd *)tmp->host_scribble;
tmp->host_scribble = NULL;
}
tmp->scsi_done (tmp);
done = 0;
} else
for (tmp = (Scsi_Cmnd *) hostdata->issue_queue,
prev = NULL; tmp; prev = tmp, tmp = (Scsi_Cmnd *)
tmp->SCp.ptr)
if (!tmp->host_scribble ||
!busyp (host, hostdata, tmp)) {
if (prev)
prev->SCp.ptr = tmp->SCp.ptr;
else
hostdata->issue_queue = (Scsi_Cmnd *)
tmp->SCp.ptr;
tmp->SCp.ptr = NULL;
if (tmp->host_scribble) {
if (hostdata->options & OPTION_DEBUG_QUEUES)
printk ("scsi%d : moving command for target %d lun %d to start list\n",
host->host_no, tmp->device->id, tmp->device->lun);
to_schedule_list (host, hostdata,
(struct NCR53c7x0_cmd *)
tmp->host_scribble);
} else {
if (((tmp->result & 0xff) == 0xff) ||
((tmp->result & 0xff00) == 0xff00)) {
printk ("scsi%d : danger Will Robinson!\n",
host->host_no);
tmp->result = DID_ERROR << 16;
disable (host);
}
tmp->scsi_done(tmp);
}
done = 0;
} /* if target/lun is not busy */
} /* if hostdata->issue_queue */
if (!done)
local_irq_restore(flags);
} /* for host */
} while (!done);
process_issue_queue_running = 0;
}
/*
* Function : static void intr_scsi (struct Scsi_Host *host,
* struct NCR53c7x0_cmd *cmd)
*
* Purpose : handle all SCSI interrupts, indicated by the setting
* of the SIP bit in the ISTAT register.
*
* Inputs : host, cmd - host and NCR command causing the interrupt, cmd
* may be NULL.
*/
static void
intr_scsi (struct Scsi_Host *host, struct NCR53c7x0_cmd *cmd) {
NCR53c7x0_local_declare();
struct NCR53c7x0_hostdata *hostdata =
(struct NCR53c7x0_hostdata *) host->hostdata[0];
unsigned char sstat0_sist0, sist1, /* Registers */
fatal; /* Did a fatal interrupt
occur ? */
NCR53c7x0_local_setup(host);
fatal = 0;
sstat0_sist0 = NCR53c7x0_read8(SSTAT0_REG);
sist1 = 0;
if (hostdata->options & OPTION_DEBUG_INTR)
printk ("scsi%d : SIST0 0x%0x, SIST1 0x%0x\n", host->host_no,
sstat0_sist0, sist1);
/* 250ms selection timeout */
if (sstat0_sist0 & SSTAT0_700_STO) {
fatal = 1;
if (hostdata->options & OPTION_DEBUG_INTR) {
printk ("scsi%d : Selection Timeout\n", host->host_no);
if (cmd) {
printk("scsi%d : target %d, lun %d, command ",
host->host_no, cmd->cmd->device->id, cmd->cmd->device->lun);
[PATCH] remove outdated print_* functions We have the scsi_print_* functions in the proper namespace for a long time now and there weren't a lot users left. Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2005-04-03 12:53:59 -07:00
__scsi_print_command (cmd->cmd->cmnd);
Linux-2.6.12-rc2 Initial git repository build. I'm not bothering with the full history, even though we have it. We can create a separate "historical" git archive of that later if we want to, and in the meantime it's about 3.2GB when imported into git - space that would just make the early git days unnecessarily complicated, when we don't have a lot of good infrastructure for it. Let it rip!
2005-04-16 15:20:36 -07:00
printk("scsi%d : dsp = 0x%x (virt 0x%p)\n", host->host_no,
NCR53c7x0_read32(DSP_REG),
bus_to_virt(NCR53c7x0_read32(DSP_REG)));
} else {
printk("scsi%d : no command\n", host->host_no);
}
}
/*
* XXX - question : how do we want to handle the Illegal Instruction
* interrupt, which may occur before or after the Selection Timeout
* interrupt?
*/
if (1) {
hostdata->idle = 1;
hostdata->expecting_sto = 0;
if (hostdata->test_running) {
hostdata->test_running = 0;
hostdata->test_completed = 3;
} else if (cmd) {
abnormal_finished(cmd, DID_BAD_TARGET << 16);
}
#if 0
hostdata->intrs = 0;
#endif
}
}
/*
* FIXME : in theory, we can also get a UDC when a STO occurs.
*/
if (sstat0_sist0 & SSTAT0_UDC) {
fatal = 1;
if (cmd) {
printk("scsi%d : target %d lun %d unexpected disconnect\n",
host->host_no, cmd->cmd->device->id, cmd->cmd->device->lun);
print_lots (host);
abnormal_finished(cmd, DID_ERROR << 16);
} else
printk("scsi%d : unexpected disconnect (no command)\n",
host->host_no);
hostdata->dsp = (u32 *) hostdata->schedule;
hostdata->dsp_changed = 1;
}
/* SCSI PARITY error */
if (sstat0_sist0 & SSTAT0_PAR) {
fatal = 1;
if (cmd && cmd->cmd) {
printk("scsi%d : target %d lun %d parity error.\n",
host->host_no, cmd->cmd->device->id, cmd->cmd->device->lun);
abnormal_finished (cmd, DID_PARITY << 16);
} else
printk("scsi%d : parity error\n", host->host_no);
/* Should send message out, parity error */
/* XXX - Reduce synchronous transfer rate! */
hostdata->dsp = hostdata->script + hostdata->E_initiator_abort /
sizeof(u32);
hostdata->dsp_changed = 1;
/* SCSI GROSS error */
}
if (sstat0_sist0 & SSTAT0_SGE) {
fatal = 1;
printk("scsi%d : gross error, saved2_dsa = 0x%x\n", host->host_no,
(unsigned int)hostdata->saved2_dsa);
print_lots (host);
/*
* A SCSI gross error may occur when we have
*
* - A synchronous offset which causes the SCSI FIFO to be overwritten.
*
* - A REQ which causes the maximum synchronous offset programmed in
* the SXFER register to be exceeded.
*
* - A phase change with an outstanding synchronous offset.
*
* - Residual data in the synchronous data FIFO, with a transfer
* other than a synchronous receive is started.$#
*/
/* XXX Should deduce synchronous transfer rate! */
hostdata->dsp = hostdata->script + hostdata->E_initiator_abort /
sizeof(u32);
hostdata->dsp_changed = 1;
/* Phase mismatch */
}
if (sstat0_sist0 & SSTAT0_MA) {
fatal = 1;
if (hostdata->options & OPTION_DEBUG_INTR)
printk ("scsi%d : SSTAT0_MA\n", host->host_no);
intr_phase_mismatch (host, cmd);
}
#if 0
if (sstat0_sist0 & SIST0_800_RSL)
printk ("scsi%d : Oh no Mr. Bill!\n", host->host_no);
#endif
/*
* If a fatal SCSI interrupt occurs, we must insure that the DMA and
* SCSI FIFOs were flushed.
*/
if (fatal) {
if (!hostdata->dstat_valid) {
hostdata->dstat = NCR53c7x0_read8(DSTAT_REG);
hostdata->dstat_valid = 1;
}
if (!(hostdata->dstat & DSTAT_DFE)) {
printk ("scsi%d : DMA FIFO not empty\n", host->host_no);
/*
* Really need to check this code for 710 RGH.
* Havn't seen any problems, but maybe we should FLUSH before
* clearing sometimes.
*/
NCR53c7x0_write8 (CTEST8_REG, CTEST8_10_CLF);
while (NCR53c7x0_read8 (CTEST8_REG) & CTEST8_10_CLF)
;
hostdata->dstat |= DSTAT_DFE;
}
}
}
#ifdef CYCLIC_TRACE
/*
* The following implements a cyclic log of instructions executed, if you turn
* TRACE on. It will also print the log for you. Very useful when debugging
* 53c710 support, possibly not really needed any more.
*/
u32 insn_log[4096];
u32 insn_log_index = 0;
void log1 (u32 i)
{
insn_log[insn_log_index++] = i;
if (insn_log_index == 4096)
insn_log_index = 0;
}
void log_insn (u32 *ip)
{
log1 ((u32)ip);
log1 (*ip);
log1 (*(ip+1));
if (((*ip >> 24) & DCMD_TYPE_MASK) == DCMD_TYPE_MMI)
log1 (*(ip+2));
}
void dump_log(void)
{
int cnt = 0;
int i = insn_log_index;
int size;
struct Scsi_Host *host = first_host;
while (cnt < 4096) {
printk ("%08x (+%6x): ", insn_log[i], (insn_log[i] - (u32)&(((struct NCR53c7x0_hostdata *)host->hostdata[0])->script))/4);
if (++i == 4096)
i = 0;
cnt++;
if (((insn_log[i] >> 24) & DCMD_TYPE_MASK) == DCMD_TYPE_MMI)
size = 3;
else
size = 2;
while (size--) {
printk ("%08x ", insn_log[i]);
if (++i == 4096)
i = 0;
cnt++;
}
printk ("\n");
}
}
#endif
/*
* Function : static void NCR53c7x0_intfly (struct Scsi_Host *host)
*
* Purpose : Scan command queue for specified host, looking for completed
* commands.
*
* Inputs : Scsi_Host pointer.
*
* This is called from the interrupt handler, when a simulated INTFLY
* interrupt occurs.
*/
static void
NCR53c7x0_intfly (struct Scsi_Host *host)
{
NCR53c7x0_local_declare();
struct NCR53c7x0_hostdata *hostdata; /* host->hostdata[0] */
struct NCR53c7x0_cmd *cmd, /* command which halted */
**cmd_prev_ptr;
unsigned long flags;
char search_found = 0; /* Got at least one ? */
hostdata = (struct NCR53c7x0_hostdata *) host->hostdata[0];
NCR53c7x0_local_setup(host);
if (hostdata->options & OPTION_DEBUG_INTR)
printk ("scsi%d : INTFLY\n", host->host_no);
/*
* Traverse our list of running commands, and look
* for those with valid (non-0xff ff) status and message
* bytes encoded in the result which signify command
* completion.
*/
local_irq_save(flags);
restart:
for (cmd_prev_ptr = (struct NCR53c7x0_cmd **)&(hostdata->running_list),
cmd = (struct NCR53c7x0_cmd *) hostdata->running_list; cmd ;
cmd_prev_ptr = (struct NCR53c7x0_cmd **) &(cmd->next),
cmd = (struct NCR53c7x0_cmd *) cmd->next)
{
Scsi_Cmnd *tmp;
if (!cmd) {
printk("scsi%d : very weird.\n", host->host_no);
break;
}
if (!(tmp = cmd->cmd)) {
printk("scsi%d : weird. NCR53c7x0_cmd has no Scsi_Cmnd\n",
host->host_no);
continue;
}
/* Copy the result over now; may not be complete,
* but subsequent tests may as well be done on
* cached memory.
*/
tmp->result = cmd->result;
if (((tmp->result & 0xff) == 0xff) ||
((tmp->result & 0xff00) == 0xff00))
continue;
search_found = 1;
if (cmd->bounce.len)
memcpy ((void *)cmd->bounce.addr,
(void *)cmd->bounce.buf, cmd->bounce.len);
/* Important - remove from list _before_ done is called */
if (cmd_prev_ptr)
*cmd_prev_ptr = (struct NCR53c7x0_cmd *) cmd->next;
--hostdata->busy[tmp->device->id][tmp->device->lun];
cmd->next = hostdata->free;
hostdata->free = cmd;
tmp->host_scribble = NULL;
if (hostdata->options & OPTION_DEBUG_INTR) {
printk ("scsi%d : command complete : pid %lu, id %d,lun %d result 0x%x ",
host->host_no, tmp->pid, tmp->device->id, tmp->device->lun, tmp->result);
[PATCH] remove outdated print_* functions We have the scsi_print_* functions in the proper namespace for a long time now and there weren't a lot users left. Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2005-04-03 12:53:59 -07:00
__scsi_print_command (tmp->cmnd);
Linux-2.6.12-rc2 Initial git repository build. I'm not bothering with the full history, even though we have it. We can create a separate "historical" git archive of that later if we want to, and in the meantime it's about 3.2GB when imported into git - space that would just make the early git days unnecessarily complicated, when we don't have a lot of good infrastructure for it. Let it rip!
2005-04-16 15:20:36 -07:00
}
tmp->scsi_done(tmp);
goto restart;
}
local_irq_restore(flags);
if (!search_found) {
printk ("scsi%d : WARNING : INTFLY with no completed commands.\n",
host->host_no);
} else {
run_process_issue_queue();
}
return;
}
/*
IRQ: Maintain regs pointer globally rather than passing to IRQ handlers Maintain a per-CPU global "struct pt_regs *" variable which can be used instead of passing regs around manually through all ~1800 interrupt handlers in the Linux kernel. The regs pointer is used in few places, but it potentially costs both stack space and code to pass it around. On the FRV arch, removing the regs parameter from all the genirq function results in a 20% speed up of the IRQ exit path (ie: from leaving timer_interrupt() to leaving do_IRQ()). Where appropriate, an arch may override the generic storage facility and do something different with the variable. On FRV, for instance, the address is maintained in GR28 at all times inside the kernel as part of general exception handling. Having looked over the code, it appears that the parameter may be handed down through up to twenty or so layers of functions. Consider a USB character device attached to a USB hub, attached to a USB controller that posts its interrupts through a cascaded auxiliary interrupt controller. A character device driver may want to pass regs to the sysrq handler through the input layer which adds another few layers of parameter passing. I've build this code with allyesconfig for x86_64 and i386. I've runtested the main part of the code on FRV and i386, though I can't test most of the drivers. I've also done partial conversion for powerpc and MIPS - these at least compile with minimal configurations. This will affect all archs. Mostly the changes should be relatively easy. Take do_IRQ(), store the regs pointer at the beginning, saving the old one: struct pt_regs *old_regs = set_irq_regs(regs); And put the old one back at the end: set_irq_regs(old_regs); Don't pass regs through to generic_handle_irq() or __do_IRQ(). In timer_interrupt(), this sort of change will be necessary: - update_process_times(user_mode(regs)); - profile_tick(CPU_PROFILING, regs); + update_process_times(user_mode(get_irq_regs())); + profile_tick(CPU_PROFILING); I'd like to move update_process_times()'s use of get_irq_regs() into itself, except that i386, alone of the archs, uses something other than user_mode(). Some notes on the interrupt handling in the drivers: (*) input_dev() is now gone entirely. The regs pointer is no longer stored in the input_dev struct. (*) finish_unlinks() in drivers/usb/host/ohci-q.c needs checking. It does something different depending on whether it's been supplied with a regs pointer or not. (*) Various IRQ handler function pointers have been moved to type irq_handler_t. Signed-Off-By: David Howells <dhowells@redhat.com> (cherry picked from 1b16e7ac850969f38b375e511e3fa2f474a33867 commit)
2006-10-05 06:55:46 -07:00
* Function : static irqreturn_t NCR53c7x0_intr (int irq, void *dev_id)
Linux-2.6.12-rc2 Initial git repository build. I'm not bothering with the full history, even though we have it. We can create a separate "historical" git archive of that later if we want to, and in the meantime it's about 3.2GB when imported into git - space that would just make the early git days unnecessarily complicated, when we don't have a lot of good infrastructure for it. Let it rip!
2005-04-16 15:20:36 -07:00
*
* Purpose : handle NCR53c7x0 interrupts for all NCR devices sharing
* the same IRQ line.
*
[PATCH] irq-flags: scsi: Use the new IRQF_ constants Signed-off-by: Thomas Gleixner <tglx@linutronix.de> Cc: Ingo Molnar <mingo@elte.hu> Cc: "David S. Miller" <davem@davemloft.net> Cc: Benjamin Herrenschmidt <benh@kernel.crashing.org> Cc: James Bottomley <James.Bottomley@steeleye.com> Signed-off-by: Andrew Morton <akpm@osdl.org> Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-07-01 19:29:42 -07:00
* Inputs : Since we're using the IRQF_DISABLED interrupt handler
Linux-2.6.12-rc2 Initial git repository build. I'm not bothering with the full history, even though we have it. We can create a separate "historical" git archive of that later if we want to, and in the meantime it's about 3.2GB when imported into git - space that would just make the early git days unnecessarily complicated, when we don't have a lot of good infrastructure for it. Let it rip!
2005-04-16 15:20:36 -07:00
* semantics, irq indicates the interrupt which invoked
* this handler.
*
* On the 710 we simualte an INTFLY with a script interrupt, and the
* script interrupt handler will call back to this function.
*/
static irqreturn_t
IRQ: Maintain regs pointer globally rather than passing to IRQ handlers Maintain a per-CPU global "struct pt_regs *" variable which can be used instead of passing regs around manually through all ~1800 interrupt handlers in the Linux kernel. The regs pointer is used in few places, but it potentially costs both stack space and code to pass it around. On the FRV arch, removing the regs parameter from all the genirq function results in a 20% speed up of the IRQ exit path (ie: from leaving timer_interrupt() to leaving do_IRQ()). Where appropriate, an arch may override the generic storage facility and do something different with the variable. On FRV, for instance, the address is maintained in GR28 at all times inside the kernel as part of general exception handling. Having looked over the code, it appears that the parameter may be handed down through up to twenty or so layers of functions. Consider a USB character device attached to a USB hub, attached to a USB controller that posts its interrupts through a cascaded auxiliary interrupt controller. A character device driver may want to pass regs to the sysrq handler through the input layer which adds another few layers of parameter passing. I've build this code with allyesconfig for x86_64 and i386. I've runtested the main part of the code on FRV and i386, though I can't test most of the drivers. I've also done partial conversion for powerpc and MIPS - these at least compile with minimal configurations. This will affect all archs. Mostly the changes should be relatively easy. Take do_IRQ(), store the regs pointer at the beginning, saving the old one: struct pt_regs *old_regs = set_irq_regs(regs); And put the old one back at the end: set_irq_regs(old_regs); Don't pass regs through to generic_handle_irq() or __do_IRQ(). In timer_interrupt(), this sort of change will be necessary: - update_process_times(user_mode(regs)); - profile_tick(CPU_PROFILING, regs); + update_process_times(user_mode(get_irq_regs())); + profile_tick(CPU_PROFILING); I'd like to move update_process_times()'s use of get_irq_regs() into itself, except that i386, alone of the archs, uses something other than user_mode(). Some notes on the interrupt handling in the drivers: (*) input_dev() is now gone entirely. The regs pointer is no longer stored in the input_dev struct. (*) finish_unlinks() in drivers/usb/host/ohci-q.c needs checking. It does something different depending on whether it's been supplied with a regs pointer or not. (*) Various IRQ handler function pointers have been moved to type irq_handler_t. Signed-Off-By: David Howells <dhowells@redhat.com> (cherry picked from 1b16e7ac850969f38b375e511e3fa2f474a33867 commit)
2006-10-05 06:55:46 -07:00
NCR53c7x0_intr (int irq, void *dev_id)
Linux-2.6.12-rc2 Initial git repository build. I'm not bothering with the full history, even though we have it. We can create a separate "historical" git archive of that later if we want to, and in the meantime it's about 3.2GB when imported into git - space that would just make the early git days unnecessarily complicated, when we don't have a lot of good infrastructure for it. Let it rip!
2005-04-16 15:20:36 -07:00
{
NCR53c7x0_local_declare();
struct Scsi_Host *host; /* Host we are looking at */
unsigned char istat; /* Values of interrupt regs */
struct NCR53c7x0_hostdata *hostdata; /* host->hostdata[0] */
struct NCR53c7x0_cmd *cmd; /* command which halted */
u32 *dsa; /* DSA */
int handled = 0;
#ifdef NCR_DEBUG
char buf[80]; /* Debugging sprintf buffer */
size_t buflen; /* Length of same */
#endif
host = (struct Scsi_Host *)dev_id;
hostdata = (struct NCR53c7x0_hostdata *) host->hostdata[0];
NCR53c7x0_local_setup(host);
/*
* Only read istat once per loop, since reading it again will unstack
* interrupts
*/
while ((istat = NCR53c7x0_read8(hostdata->istat)) & (ISTAT_SIP|ISTAT_DIP)) {
handled = 1;
hostdata->dsp_changed = 0;
hostdata->dstat_valid = 0;
hostdata->state = STATE_HALTED;
if (NCR53c7x0_read8 (SSTAT2_REG) & SSTAT2_FF_MASK)
printk ("scsi%d : SCSI FIFO not empty\n", host->host_no);
/*
* NCR53c700 and NCR53c700-66 change the current SCSI
* process, hostdata->ncrcurrent, in the Linux driver so
* cmd = hostdata->ncrcurrent.
*
* With other chips, we must look through the commands
* executing and find the command structure which
* corresponds to the DSA register.
*/
if (hostdata->options & OPTION_700) {
cmd = (struct NCR53c7x0_cmd *) hostdata->ncrcurrent;
} else {
dsa = bus_to_virt(NCR53c7x0_read32(DSA_REG));
for (cmd = (struct NCR53c7x0_cmd *) hostdata->running_list;
cmd && (dsa + (hostdata->dsa_start / sizeof(u32))) != cmd->dsa;
cmd = (struct NCR53c7x0_cmd *)(cmd->next))
;
}
if (hostdata->options & OPTION_DEBUG_INTR) {
if (cmd) {
printk("scsi%d : interrupt for pid %lu, id %d, lun %d ",
host->host_no, cmd->cmd->pid, (int) cmd->cmd->device->id,
(int) cmd->cmd->device->lun);
[PATCH] remove outdated print_* functions We have the scsi_print_* functions in the proper namespace for a long time now and there weren't a lot users left. Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2005-04-03 12:53:59 -07:00
__scsi_print_command (cmd->cmd->cmnd);
Linux-2.6.12-rc2 Initial git repository build. I'm not bothering with the full history, even though we have it. We can create a separate "historical" git archive of that later if we want to, and in the meantime it's about 3.2GB when imported into git - space that would just make the early git days unnecessarily complicated, when we don't have a lot of good infrastructure for it. Let it rip!
2005-04-16 15:20:36 -07:00
} else {
printk("scsi%d : no active command\n", host->host_no);
}
}
if (istat & ISTAT_SIP) {
if (hostdata->options & OPTION_DEBUG_INTR)
printk ("scsi%d : ISTAT_SIP\n", host->host_no);
intr_scsi (host, cmd);
}
if (istat & ISTAT_DIP) {
if (hostdata->options & OPTION_DEBUG_INTR)
printk ("scsi%d : ISTAT_DIP\n", host->host_no);
intr_dma (host, cmd);
}
if (!hostdata->dstat_valid) {
hostdata->dstat = NCR53c7x0_read8(DSTAT_REG);
hostdata->dstat_valid = 1;
}
if (!(hostdata->dstat & DSTAT_DFE)) {
printk ("scsi%d : DMA FIFO not empty\n", host->host_no);
/* Really need to check this out for 710 RGH */
NCR53c7x0_write8 (CTEST8_REG, CTEST8_10_CLF);
while (NCR53c7x0_read8 (CTEST8_REG) & CTEST8_10_CLF)
;
hostdata->dstat |= DSTAT_DFE;
}
if (!hostdata->idle && hostdata->state == STATE_HALTED) {
if (!hostdata->dsp_changed)
hostdata->dsp = (u32 *)bus_to_virt(NCR53c7x0_read32(DSP_REG));
#if 0
printk("scsi%d : new dsp is 0x%lx (virt 0x%p)\n",
host->host_no, virt_to_bus(hostdata->dsp), hostdata->dsp);
#endif
hostdata->state = STATE_RUNNING;
NCR53c7x0_write32 (DSP_REG, virt_to_bus(hostdata->dsp));
if (hostdata->options & OPTION_DEBUG_TRACE) {
#ifdef CYCLIC_TRACE
log_insn (hostdata->dsp);
#else
print_insn (host, hostdata->dsp, "t ", 1);
#endif
NCR53c7x0_write8 (DCNTL_REG,
hostdata->saved_dcntl | DCNTL_SSM | DCNTL_STD);
}
}
}
return IRQ_HANDLED;
}
/*
* Function : static int abort_connected (struct Scsi_Host *host)
*
* Purpose : Assuming that the NCR SCSI processor is currently
* halted, break the currently established nexus. Clean
* up of the NCR53c7x0_cmd and Scsi_Cmnd structures should
* be done on receipt of the abort interrupt.
*
* Inputs : host - SCSI host
*
*/
static int
abort_connected (struct Scsi_Host *host) {
#ifdef NEW_ABORT
NCR53c7x0_local_declare();
#endif
struct NCR53c7x0_hostdata *hostdata = (struct NCR53c7x0_hostdata *)
host->hostdata[0];
/* FIXME : this probably should change for production kernels; at the
least, counter should move to a per-host structure. */
static int counter = 5;
#ifdef NEW_ABORT
int sstat, phase, offset;
u32 *script;
NCR53c7x0_local_setup(host);
#endif
if (--counter <= 0) {
disable(host);
return 0;
}
printk ("scsi%d : DANGER : abort_connected() called \n",
host->host_no);
#ifdef NEW_ABORT
/*
* New strategy : Rather than using a generic abort routine,
* we'll specifically try to source or sink the appropriate
* amount of data for the phase we're currently in (taking into
* account the current synchronous offset)
*/
sstat = (NCR53c8x0_read8 (SSTAT2_REG);
offset = OFFSET (sstat & SSTAT2_FF_MASK) >> SSTAT2_FF_SHIFT;
phase = sstat & SSTAT2_PHASE_MASK;
/*
* SET ATN
* MOVE source_or_sink, WHEN CURRENT PHASE
* < repeat for each outstanding byte >
* JUMP send_abort_message
*/
script = hostdata->abort_script = kmalloc (
8 /* instruction size */ * (
1 /* set ATN */ +
(!offset ? 1 : offset) /* One transfer per outstanding byte */ +
1 /* send abort message */),
GFP_ATOMIC);
#else /* def NEW_ABORT */
hostdata->dsp = hostdata->script + hostdata->E_initiator_abort /
sizeof(u32);
#endif /* def NEW_ABORT */
hostdata->dsp_changed = 1;
/* XXX - need to flag the command as aborted after the abort_connected
code runs
*/
return 0;
}
/*
* Function : static int datapath_residual (Scsi_Host *host)
*
* Purpose : return residual data count of what's in the chip.
*
* Inputs : host - SCSI host
*/
static int
datapath_residual (struct Scsi_Host *host) {
NCR53c7x0_local_declare();
int count, synchronous, sstat;
unsigned int ddir;
NCR53c7x0_local_setup(host);
/* COMPAT : the 700 and 700-66 need to use DFIFO_00_BO_MASK */
count = ((NCR53c7x0_read8 (DFIFO_REG) & DFIFO_10_BO_MASK) -
(NCR53c7x0_read32 (DBC_REG) & DFIFO_10_BO_MASK)) & DFIFO_10_BO_MASK;
synchronous = NCR53c7x0_read8 (SXFER_REG) & SXFER_MO_MASK;
/* COMPAT : DDIR is elsewhere on non-'8xx chips. */
ddir = NCR53c7x0_read8 (CTEST0_REG_700) & CTEST0_700_DDIR;
if (ddir) {
/* Receive */
if (synchronous)
count += (NCR53c7x0_read8 (SSTAT2_REG) & SSTAT2_FF_MASK) >> SSTAT2_FF_SHIFT;
else
if (NCR53c7x0_read8 (SSTAT1_REG) & SSTAT1_ILF)
++count;
} else {
/* Send */
sstat = NCR53c7x0_read8 (SSTAT1_REG);
if (sstat & SSTAT1_OLF)
++count;
if (synchronous && (sstat & SSTAT1_ORF))
++count;
}
return count;
}
/*
* Function : static const char * sbcl_to_phase (int sbcl)_
*
* Purpose : Convert SBCL register to user-parsable phase representation
*
* Inputs : sbcl - value of sbcl register
*/
static const char *
sbcl_to_phase (int sbcl) {
switch (sbcl & SBCL_PHASE_MASK) {
case SBCL_PHASE_DATAIN:
return "DATAIN";
case SBCL_PHASE_DATAOUT:
return "DATAOUT";
case SBCL_PHASE_MSGIN:
return "MSGIN";
case SBCL_PHASE_MSGOUT:
return "MSGOUT";
case SBCL_PHASE_CMDOUT:
return "CMDOUT";
case SBCL_PHASE_STATIN:
return "STATUSIN";
default:
return "unknown";
}
}
/*
* Function : static const char * sstat2_to_phase (int sstat)_
*
* Purpose : Convert SSTAT2 register to user-parsable phase representation
*
* Inputs : sstat - value of sstat register
*/
static const char *
sstat2_to_phase (int sstat) {
switch (sstat & SSTAT2_PHASE_MASK) {
case SSTAT2_PHASE_DATAIN:
return "DATAIN";
case SSTAT2_PHASE_DATAOUT:
return "DATAOUT";
case SSTAT2_PHASE_MSGIN:
return "MSGIN";
case SSTAT2_PHASE_MSGOUT:
return "MSGOUT";
case SSTAT2_PHASE_CMDOUT:
return "CMDOUT";
case SSTAT2_PHASE_STATIN:
return "STATUSIN";
default:
return "unknown";
}
}
/*
* Function : static void intr_phase_mismatch (struct Scsi_Host *host,
* struct NCR53c7x0_cmd *cmd)
*
* Purpose : Handle phase mismatch interrupts
*
* Inputs : host, cmd - host and NCR command causing the interrupt, cmd
* may be NULL.
*
* Side effects : The abort_connected() routine is called or the NCR chip
* is restarted, jumping to the command_complete entry point, or
* patching the address and transfer count of the current instruction
* and calling the msg_in entry point as appropriate.
*/
static void
intr_phase_mismatch (struct Scsi_Host *host, struct NCR53c7x0_cmd *cmd) {
NCR53c7x0_local_declare();
u32 dbc_dcmd, *dsp, *dsp_next;
unsigned char dcmd, sbcl;
struct NCR53c7x0_hostdata *hostdata = (struct NCR53c7x0_hostdata *)
host->hostdata[0];
int residual;
enum {ACTION_ABORT, ACTION_ABORT_PRINT, ACTION_CONTINUE} action =
ACTION_ABORT_PRINT;
const char *where = NULL;
NCR53c7x0_local_setup(host);
/*
* Corrective action is based on where in the SCSI SCRIPT(tm) the error
* occurred, as well as which SCSI phase we are currently in.
*/
dsp_next = bus_to_virt(NCR53c7x0_read32(DSP_REG));
/*
* Fetch the current instruction, and remove the operands for easier
* interpretation.
*/
dbc_dcmd = NCR53c7x0_read32(DBC_REG);
dcmd = (dbc_dcmd & 0xff000000) >> 24;
/*
* Like other processors, the NCR adjusts the instruction pointer before
* instruction decode. Set the DSP address back to what it should
* be for this instruction based on its size (2 or 3 32 bit words).
*/
dsp = dsp_next - NCR53c7x0_insn_size(dcmd);
/*
* Read new SCSI phase from the SBCL lines. Since all of our code uses
* a WHEN conditional instead of an IF conditional, we don't need to
* wait for a new REQ.
*/
sbcl = NCR53c7x0_read8(SBCL_REG) & SBCL_PHASE_MASK;
if (!cmd) {
action = ACTION_ABORT_PRINT;
where = "no current command";
/*
* The way my SCSI SCRIPTS(tm) are architected, recoverable phase
* mismatches should only occur where we're doing a multi-byte
* BMI instruction. Specifically, this means
*
* - select messages (a SCSI-I target may ignore additional messages
* after the IDENTIFY; any target may reject a SDTR or WDTR)
*
* - command out (targets may send a message to signal an error
* condition, or go into STATUSIN after they've decided
* they don't like the command.
*
* - reply_message (targets may reject a multi-byte message in the
* middle)
*
* - data transfer routines (command completion with buffer space
* left, disconnect message, or error message)
*/
} else if (((dsp >= cmd->data_transfer_start &&
dsp < cmd->data_transfer_end)) || dsp == (cmd->residual + 2)) {
if ((dcmd & (DCMD_TYPE_MASK|DCMD_BMI_OP_MASK|DCMD_BMI_INDIRECT|
DCMD_BMI_MSG|DCMD_BMI_CD)) == (DCMD_TYPE_BMI|
DCMD_BMI_OP_MOVE_I)) {
residual = datapath_residual (host);
if (hostdata->options & OPTION_DEBUG_DISCONNECT)
printk ("scsi%d : handling residual transfer (+ %d bytes from DMA FIFO)\n",
host->host_no, residual);
/*
* The first instruction is a CALL to the alternate handler for
* this data transfer phase, so we can do calls to
* munge_msg_restart as we would if control were passed
* from normal dynamic code.
*/
if (dsp != cmd->residual + 2) {
cmd->residual[0] = ((DCMD_TYPE_TCI | DCMD_TCI_OP_CALL |
((dcmd & DCMD_BMI_IO) ? DCMD_TCI_IO : 0)) << 24) |
DBC_TCI_WAIT_FOR_VALID | DBC_TCI_COMPARE_PHASE;
cmd->residual[1] = virt_to_bus(hostdata->script)
+ ((dcmd & DCMD_BMI_IO)
? hostdata->E_other_in : hostdata->E_other_out);
}
/*
* The second instruction is the a data transfer block
* move instruction, reflecting the pointer and count at the
* time of the phase mismatch.
*/
cmd->residual[2] = dbc_dcmd + residual;
cmd->residual[3] = NCR53c7x0_read32(DNAD_REG) - residual;
/*
* The third and final instruction is a jump to the instruction
* which follows the instruction which had to be 'split'
*/
if (dsp != cmd->residual + 2) {
cmd->residual[4] = ((DCMD_TYPE_TCI|DCMD_TCI_OP_JUMP)
<< 24) | DBC_TCI_TRUE;
cmd->residual[5] = virt_to_bus(dsp_next);
}
/*
* For the sake of simplicity, transfer control to the
* conditional CALL at the start of the residual buffer.
*/
hostdata->dsp = cmd->residual;
hostdata->dsp_changed = 1;
action = ACTION_CONTINUE;
} else {
where = "non-BMI dynamic DSA code";
action = ACTION_ABORT_PRINT;
}
} else if (dsp == (hostdata->script + hostdata->E_select_msgout / 4 + 2)) {
/* RGH 290697: Added +2 above, to compensate for the script
* instruction which disables the selection timer. */
/* Release ATN */
NCR53c7x0_write8 (SOCL_REG, 0);
switch (sbcl) {
/*
* Some devices (SQ555 come to mind) grab the IDENTIFY message
* sent on selection, and decide to go into COMMAND OUT phase
* rather than accepting the rest of the messages or rejecting
* them. Handle these devices gracefully.
*/
case SBCL_PHASE_CMDOUT:
hostdata->dsp = dsp + 2 /* two _words_ */;
hostdata->dsp_changed = 1;
printk ("scsi%d : target %d ignored SDTR and went into COMMAND OUT\n",
host->host_no, cmd->cmd->device->id);
cmd->flags &= ~CMD_FLAG_SDTR;
action = ACTION_CONTINUE;
break;
case SBCL_PHASE_MSGIN:
hostdata->dsp = hostdata->script + hostdata->E_msg_in /
sizeof(u32);
hostdata->dsp_changed = 1;
action = ACTION_CONTINUE;
break;
default:
where="select message out";
action = ACTION_ABORT_PRINT;
}
/*
* Some SCSI devices will interpret a command as they read the bytes
* off the SCSI bus, and may decide that the command is Bogus before
* they've read the entire command off the bus.
*/
} else if (dsp == hostdata->script + hostdata->E_cmdout_cmdout / sizeof
(u32)) {
hostdata->dsp = hostdata->script + hostdata->E_data_transfer /
sizeof (u32);
hostdata->dsp_changed = 1;
action = ACTION_CONTINUE;
/* FIXME : we need to handle message reject, etc. within msg_respond. */
#ifdef notyet
} else if (dsp == hostdata->script + hostdata->E_reply_message) {
switch (sbcl) {
/* Any other phase mismatches abort the currently executing command. */
#endif
} else {
where = "unknown location";
action = ACTION_ABORT_PRINT;
}
/* Flush DMA FIFO */
if (!hostdata->dstat_valid) {
hostdata->dstat = NCR53c7x0_read8(DSTAT_REG);
hostdata->dstat_valid = 1;
}
if (!(hostdata->dstat & DSTAT_DFE)) {
/* Really need to check this out for 710 RGH */
NCR53c7x0_write8 (CTEST8_REG, CTEST8_10_CLF);
while (NCR53c7x0_read8 (CTEST8_REG) & CTEST8_10_CLF);
hostdata->dstat |= DSTAT_DFE;
}
switch (action) {
case ACTION_ABORT_PRINT:
printk("scsi%d : %s : unexpected phase %s.\n",
host->host_no, where ? where : "unknown location",
sbcl_to_phase(sbcl));
print_lots (host);
/* Fall through to ACTION_ABORT */
case ACTION_ABORT:
abort_connected (host);
break;
case ACTION_CONTINUE:
break;
}
#if 0
if (hostdata->dsp_changed) {
printk("scsi%d: new dsp 0x%p\n", host->host_no, hostdata->dsp);
print_insn (host, hostdata->dsp, "", 1);
}
#endif
}
/*
* Function : static void intr_bf (struct Scsi_Host *host,
* struct NCR53c7x0_cmd *cmd)
*
* Purpose : handle BUS FAULT interrupts
*
* Inputs : host, cmd - host and NCR command causing the interrupt, cmd
* may be NULL.
*/
static void
intr_bf (struct Scsi_Host *host, struct NCR53c7x0_cmd *cmd) {
NCR53c7x0_local_declare();
u32 *dsp,
*next_dsp, /* Current dsp */
*dsa,
dbc_dcmd; /* DCMD (high eight bits) + DBC */
char *reason = NULL;
/* Default behavior is for a silent error, with a retry until we've
exhausted retries. */
enum {MAYBE, ALWAYS, NEVER} retry = MAYBE;
int report = 0;
NCR53c7x0_local_setup(host);
dbc_dcmd = NCR53c7x0_read32 (DBC_REG);
next_dsp = bus_to_virt (NCR53c7x0_read32(DSP_REG));
dsp = next_dsp - NCR53c7x0_insn_size ((dbc_dcmd >> 24) & 0xff);
/* FIXME - check chip type */
dsa = bus_to_virt (NCR53c7x0_read32(DSA_REG));
/*
* Bus faults can be caused by either a Bad Address or
* Target Abort. We should check the Received Target Abort
* bit of the PCI status register and Master Abort Bit.
*
* - Master Abort bit indicates that no device claimed
* the address with DEVSEL within five clocks
*
* - Target Abort bit indicates that a target claimed it,
* but changed its mind once it saw the byte enables.
*
*/
/* 53c710, not PCI system */
report = 1;
reason = "Unknown";
#ifndef notyet
report = 1;
#endif
if (report && reason)
{
printk(KERN_ALERT "scsi%d : BUS FAULT reason = %s\n",
host->host_no, reason ? reason : "unknown");
print_lots (host);
}
#ifndef notyet
retry = NEVER;
#endif
/*
* TODO : we should attempt to recover from any spurious bus
* faults. After X retries, we should figure that things are
* sufficiently wedged, and call NCR53c7xx_reset.
*
* This code should only get executed once we've decided that we
* cannot retry.
*/
if (retry == NEVER) {
printk(KERN_ALERT " mail richard@sleepie.demon.co.uk\n");
FATAL (host);
}
}
/*
* Function : static void intr_dma (struct Scsi_Host *host,
* struct NCR53c7x0_cmd *cmd)
*
* Purpose : handle all DMA interrupts, indicated by the setting
* of the DIP bit in the ISTAT register.
*
* Inputs : host, cmd - host and NCR command causing the interrupt, cmd
* may be NULL.
*/
static void
intr_dma (struct Scsi_Host *host, struct NCR53c7x0_cmd *cmd) {
NCR53c7x0_local_declare();
struct NCR53c7x0_hostdata *hostdata = (struct NCR53c7x0_hostdata *)
host->hostdata[0];
unsigned char dstat; /* DSTAT */
u32 *dsp,
*next_dsp, /* Current dsp */
*dsa,
dbc_dcmd; /* DCMD (high eight bits) + DBC */
int tmp;
unsigned long flags;
NCR53c7x0_local_setup(host);
if (!hostdata->dstat_valid) {
hostdata->dstat = NCR53c7x0_read8(DSTAT_REG);
hostdata->dstat_valid = 1;
}
dstat = hostdata->dstat;
if (hostdata->options & OPTION_DEBUG_INTR)
printk("scsi%d : DSTAT=0x%x\n", host->host_no, (int) dstat);
dbc_dcmd = NCR53c7x0_read32 (DBC_REG);
next_dsp = bus_to_virt(NCR53c7x0_read32(DSP_REG));
dsp = next_dsp - NCR53c7x0_insn_size ((dbc_dcmd >> 24) & 0xff);
/* XXX - check chip type */
dsa = bus_to_virt(NCR53c7x0_read32(DSA_REG));
/*
* DSTAT_ABRT is the aborted interrupt. This is set whenever the
* SCSI chip is aborted.
*
* With NCR53c700 and NCR53c700-66 style chips, we should only
* get this when the chip is currently running the accept
* reselect/select code and we have set the abort bit in the
* ISTAT register.
*
*/
if (dstat & DSTAT_ABRT) {
#if 0
/* XXX - add code here to deal with normal abort */
if ((hostdata->options & OPTION_700) && (hostdata->state ==
STATE_ABORTING)) {
} else
#endif
{
printk(KERN_ALERT "scsi%d : unexpected abort interrupt at\n"
" ", host->host_no);
print_insn (host, dsp, KERN_ALERT "s ", 1);
FATAL (host);
}
}
/*
* DSTAT_SSI is the single step interrupt. Should be generated
* whenever we have single stepped or are tracing.
*/
if (dstat & DSTAT_SSI) {
if (hostdata->options & OPTION_DEBUG_TRACE) {
/* Don't print instr. until we write DSP at end of intr function */
} else if (hostdata->options & OPTION_DEBUG_SINGLE) {
print_insn (host, dsp, "s ", 0);
local_irq_save(flags);
/* XXX - should we do this, or can we get away with writing dsp? */
NCR53c7x0_write8 (DCNTL_REG, (NCR53c7x0_read8(DCNTL_REG) &
~DCNTL_SSM) | DCNTL_STD);
local_irq_restore(flags);
} else {
printk(KERN_ALERT "scsi%d : unexpected single step interrupt at\n"
" ", host->host_no);
print_insn (host, dsp, KERN_ALERT "", 1);
printk(KERN_ALERT " mail drew@PoohSticks.ORG\n");
FATAL (host);
}
}
/*
* DSTAT_IID / DSTAT_OPC (same bit, same meaning, only the name
* is different) is generated whenever an illegal instruction is
* encountered.
*
* XXX - we may want to emulate INTFLY here, so we can use
* the same SCSI SCRIPT (tm) for NCR53c710 through NCR53c810
* chips.
*/
if (dstat & DSTAT_OPC) {
/*
* Ascertain if this IID interrupts occurred before or after a STO
* interrupt. Since the interrupt handling code now leaves
* DSP unmodified until _after_ all stacked interrupts have been
* processed, reading the DSP returns the original DSP register.
* This means that if dsp lies between the select code, and
* message out following the selection code (where the IID interrupt
* would have to have occurred by due to the implicit wait for REQ),
* we have an IID interrupt resulting from a STO condition and
* can ignore it.
*/
if (((dsp >= (hostdata->script + hostdata->E_select / sizeof(u32))) &&
(dsp <= (hostdata->script + hostdata->E_select_msgout /
sizeof(u32) + 8))) || (hostdata->test_running == 2)) {
if (hostdata->options & OPTION_DEBUG_INTR)
printk ("scsi%d : ignoring DSTAT_IID for SSTAT_STO\n",
host->host_no);
if (hostdata->expecting_iid) {
hostdata->expecting_iid = 0;
hostdata->idle = 1;
if (hostdata->test_running == 2) {
hostdata->test_running = 0;
hostdata->test_completed = 3;
} else if (cmd)
abnormal_finished (cmd, DID_BAD_TARGET << 16);
} else {
hostdata->expecting_sto = 1;
}
/*
* We can't guarantee we'll be able to execute the WAIT DISCONNECT
* instruction within the 3.4us of bus free and arbitration delay
* that a target can RESELECT in and assert REQ after we've dropped
* ACK. If this happens, we'll get an illegal instruction interrupt.
* Doing away with the WAIT DISCONNECT instructions broke everything,
* so instead I'll settle for moving one WAIT DISCONNECT a few
* instructions closer to the CLEAR ACK before it to minimize the
* chances of this happening, and handle it if it occurs anyway.
*
* Simply continue with what we were doing, and control should
* be transferred to the schedule routine which will ultimately
* pass control onto the reselection or selection (not yet)
* code.
*/
} else if (dbc_dcmd == 0x48000000 && (NCR53c7x0_read8 (SBCL_REG) &
SBCL_REQ)) {
if (!(hostdata->options & OPTION_NO_PRINT_RACE))
{
printk("scsi%d: REQ before WAIT DISCONNECT IID\n",
host->host_no);
hostdata->options |= OPTION_NO_PRINT_RACE;
}
} else {
printk(KERN_ALERT "scsi%d : invalid instruction\n", host->host_no);
print_lots (host);
printk(KERN_ALERT " mail Richard@sleepie.demon.co.uk with ALL\n"
" boot messages and diagnostic output\n");
FATAL (host);
}
}
/*
* DSTAT_BF are bus fault errors. DSTAT_800_BF is valid for 710 also.
*/
if (dstat & DSTAT_800_BF) {
intr_bf (host, cmd);
}
/*
* DSTAT_SIR interrupts are generated by the execution of
* the INT instruction. Since the exact values available
* are determined entirely by the SCSI script running,
* and are local to a particular script, a unique handler
* is called for each script.
*/
if (dstat & DSTAT_SIR) {
if (hostdata->options & OPTION_DEBUG_INTR)
printk ("scsi%d : DSTAT_SIR\n", host->host_no);
switch ((tmp = hostdata->dstat_sir_intr (host, cmd))) {
case SPECIFIC_INT_NOTHING:
case SPECIFIC_INT_RESTART:
break;
case SPECIFIC_INT_ABORT:
abort_connected(host);
break;
case SPECIFIC_INT_PANIC:
printk(KERN_ALERT "scsi%d : failure at ", host->host_no);
print_insn (host, dsp, KERN_ALERT "", 1);
printk(KERN_ALERT " dstat_sir_intr() returned SPECIFIC_INT_PANIC\n");
FATAL (host);
break;
case SPECIFIC_INT_BREAK:
intr_break (host, cmd);
break;
default:
printk(KERN_ALERT "scsi%d : failure at ", host->host_no);
print_insn (host, dsp, KERN_ALERT "", 1);
printk(KERN_ALERT" dstat_sir_intr() returned unknown value %d\n",
tmp);
FATAL (host);
}
}
}
/*
* Function : static int print_insn (struct Scsi_Host *host,
* u32 *insn, int kernel)
*
* Purpose : print numeric representation of the instruction pointed
* to by insn to the debugging or kernel message buffer
* as appropriate.
*
* If desired, a user level program can interpret this
* information.
*
* Inputs : host, insn - host, pointer to instruction, prefix -
* string to prepend, kernel - use printk instead of debugging buffer.
*
* Returns : size, in u32s, of instruction printed.
*/
/*
* FIXME: should change kernel parameter so that it takes an ENUM
* specifying severity - either KERN_ALERT or KERN_PANIC so
* all panic messages are output with the same severity.
*/
static int
print_insn (struct Scsi_Host *host, const u32 *insn,
const char *prefix, int kernel) {
char buf[160], /* Temporary buffer and pointer. ICKY
arbitrary length. */
*tmp;
unsigned char dcmd; /* dcmd register for *insn */
int size;
/*
* Check to see if the instruction pointer is not bogus before
* indirecting through it; avoiding red-zone at start of
* memory.
*
* FIXME: icky magic needs to happen here on non-intel boxes which
* don't have kernel memory mapped in like this. Might be reasonable
* to use vverify()?
*/
if (virt_to_phys((void *)insn) < PAGE_SIZE ||
virt_to_phys((void *)(insn + 8)) > virt_to_phys(high_memory) ||
((((dcmd = (insn[0] >> 24) & 0xff) & DCMD_TYPE_MMI) == DCMD_TYPE_MMI) &&
virt_to_phys((void *)(insn + 12)) > virt_to_phys(high_memory))) {
size = 0;
sprintf (buf, "%s%p: address out of range\n",
prefix, insn);
} else {
/*
* FIXME : (void *) cast in virt_to_bus should be unnecessary, because
* it should take const void * as argument.
*/
#if !defined(CONFIG_MVME16x) && !defined(CONFIG_BVME6000)
sprintf(buf, "%s0x%lx (virt 0x%p) : 0x%08x 0x%08x (virt 0x%p)",
(prefix ? prefix : ""), virt_to_bus((void *) insn), insn,
insn[0], insn[1], bus_to_virt (insn[1]));
#else
/* Remove virtual addresses to reduce output, as they are the same */
sprintf(buf, "%s0x%x (+%x) : 0x%08x 0x%08x",
(prefix ? prefix : ""), (u32)insn, ((u32)insn -
(u32)&(((struct NCR53c7x0_hostdata *)host->hostdata[0])->script))/4,
insn[0], insn[1]);
#endif
tmp = buf + strlen(buf);
if ((dcmd & DCMD_TYPE_MASK) == DCMD_TYPE_MMI) {
#if !defined(CONFIG_MVME16x) && !defined(CONFIG_BVME6000)
sprintf (tmp, " 0x%08x (virt 0x%p)\n", insn[2],
bus_to_virt(insn[2]));
#else
/* Remove virtual addr to reduce output, as it is the same */
sprintf (tmp, " 0x%08x\n", insn[2]);
#endif
size = 3;
} else {
sprintf (tmp, "\n");
size = 2;
}
}
if (kernel)
printk ("%s", buf);
#ifdef NCR_DEBUG
else {
size_t len = strlen(buf);
debugger_kernel_write(host, buf, len);
}
#endif
return size;
}
/*
* Function : int NCR53c7xx_abort (Scsi_Cmnd *cmd)
*
* Purpose : Abort an errant SCSI command, doing all necessary
* cleanup of the issue_queue, running_list, shared Linux/NCR
* dsa issue and reconnect queues.
*
* Inputs : cmd - command to abort, code - entire result field
*
* Returns : 0 on success, -1 on failure.
*/
int
NCR53c7xx_abort (Scsi_Cmnd *cmd) {
NCR53c7x0_local_declare();
struct Scsi_Host *host = cmd->device->host;
struct NCR53c7x0_hostdata *hostdata = host ? (struct NCR53c7x0_hostdata *)
host->hostdata[0] : NULL;
unsigned long flags;
struct NCR53c7x0_cmd *curr, **prev;
Scsi_Cmnd *me, **last;
#if 0
static long cache_pid = -1;
#endif
if (!host) {
printk ("Bogus SCSI command pid %ld; no host structure\n",
cmd->pid);
return SCSI_ABORT_ERROR;
} else if (!hostdata) {
printk ("Bogus SCSI host %d; no hostdata\n", host->host_no);
return SCSI_ABORT_ERROR;
}
NCR53c7x0_local_setup(host);
/*
* CHECK : I don't think that reading ISTAT will unstack any interrupts,
* since we need to write the INTF bit to clear it, and SCSI/DMA
* interrupts don't clear until we read SSTAT/SIST and DSTAT registers.
*
* See that this is the case. Appears to be correct on the 710, at least.
*
* I suspect that several of our failures may be coming from a new fatal
* interrupt (possibly due to a phase mismatch) happening after we've left
* the interrupt handler, but before the PIC has had the interrupt condition
* cleared.
*/
if (NCR53c7x0_read8(hostdata->istat) & (ISTAT_DIP|ISTAT_SIP)) {
printk ("scsi%d : dropped interrupt for command %ld\n", host->host_no,
cmd->pid);
NCR53c7x0_intr (host->irq, NULL, NULL);
return SCSI_ABORT_BUSY;
}
local_irq_save(flags);
#if 0
if (cache_pid == cmd->pid)
panic ("scsi%d : bloody fetus %d\n", host->host_no, cmd->pid);
else
cache_pid = cmd->pid;
#endif
/*
* The command could be hiding in the issue_queue. This would be very
* nice, as commands can't be moved from the high level driver's issue queue
* into the shared queue until an interrupt routine is serviced, and this
* moving is atomic.
*
* If this is the case, we don't have to worry about anything - we simply
* pull the command out of the old queue, and call it aborted.
*/
for (me = (Scsi_Cmnd *) hostdata->issue_queue,
last = (Scsi_Cmnd **) &(hostdata->issue_queue);
me && me != cmd; last = (Scsi_Cmnd **)&(me->SCp.ptr),
me = (Scsi_Cmnd *)me->SCp.ptr);
if (me) {
*last = (Scsi_Cmnd *) me->SCp.ptr;
if (me->host_scribble) {
((struct NCR53c7x0_cmd *)me->host_scribble)->next = hostdata->free;
hostdata->free = (struct NCR53c7x0_cmd *) me->host_scribble;
me->host_scribble = NULL;
}
cmd->result = DID_ABORT << 16;
cmd->scsi_done(cmd);
printk ("scsi%d : found command %ld in Linux issue queue\n",
host->host_no, me->pid);
local_irq_restore(flags);
run_process_issue_queue();
return SCSI_ABORT_SUCCESS;
}
/*
* That failing, the command could be in our list of already executing
* commands. If this is the case, drastic measures are called for.
*/
for (curr = (struct NCR53c7x0_cmd *) hostdata->running_list,
prev = (struct NCR53c7x0_cmd **) &(hostdata->running_list);
curr && curr->cmd != cmd; prev = (struct NCR53c7x0_cmd **)
&(curr->next), curr = (struct NCR53c7x0_cmd *) curr->next);
if (curr) {
if ((curr->result & 0xff) != 0xff && (curr->result & 0xff00) != 0xff00) {
cmd->result = curr->result;
if (prev)
*prev = (struct NCR53c7x0_cmd *) curr->next;
curr->next = (struct NCR53c7x0_cmd *) hostdata->free;
cmd->host_scribble = NULL;
hostdata->free = curr;
cmd->scsi_done(cmd);
printk ("scsi%d : found finished command %ld in running list\n",
host->host_no, cmd->pid);
local_irq_restore(flags);
return SCSI_ABORT_NOT_RUNNING;
} else {
printk ("scsi%d : DANGER : command running, can not abort.\n",
cmd->device->host->host_no);
local_irq_restore(flags);
return SCSI_ABORT_BUSY;
}
}
/*
* And if we couldn't find it in any of our queues, it must have been
* a dropped interrupt.
*/
curr = (struct NCR53c7x0_cmd *) cmd->host_scribble;
if (curr) {
curr->next = hostdata->free;
hostdata->free = curr;
cmd->host_scribble = NULL;
}
if (curr == NULL || ((curr->result & 0xff00) == 0xff00) ||
((curr->result & 0xff) == 0xff)) {
printk ("scsi%d : did this command ever run?\n", host->host_no);
cmd->result = DID_ABORT << 16;
} else {
printk ("scsi%d : probably lost INTFLY, normal completion\n",
host->host_no);
cmd->result = curr->result;
/*
* FIXME : We need to add an additional flag which indicates if a
* command was ever counted as BUSY, so if we end up here we can
* decrement the busy count if and only if it is necessary.
*/
--hostdata->busy[cmd->device->id][cmd->device->lun];
}
local_irq_restore(flags);
cmd->scsi_done(cmd);
/*
* We need to run process_issue_queue since termination of this command
* may allow another queued command to execute first?
*/
return SCSI_ABORT_NOT_RUNNING;
}
/*
* Function : int NCR53c7xx_reset (Scsi_Cmnd *cmd)
*
* Purpose : perform a hard reset of the SCSI bus and NCR
* chip.
*
* Inputs : cmd - command which caused the SCSI RESET
*
* Returns : 0 on success.
*/
int
NCR53c7xx_reset (Scsi_Cmnd *cmd, unsigned int reset_flags) {
NCR53c7x0_local_declare();
unsigned long flags;
int found = 0;
struct NCR53c7x0_cmd * c;
Scsi_Cmnd *tmp;
/*
* When we call scsi_done(), it's going to wake up anything sleeping on the
* resources which were in use by the aborted commands, and we'll start to
* get new commands.
*
* We can't let this happen until after we've re-initialized the driver
* structures, and can't reinitialize those structures until after we've
* dealt with their contents.
*
* So, we need to find all of the commands which were running, stick
* them on a linked list of completed commands (we'll use the host_scribble
* pointer), do our reinitialization, and then call the done function for
* each command.
*/
Scsi_Cmnd *nuke_list = NULL;
struct Scsi_Host *host = cmd->device->host;
struct NCR53c7x0_hostdata *hostdata =
(struct NCR53c7x0_hostdata *) host->hostdata[0];
NCR53c7x0_local_setup(host);
local_irq_save(flags);
ncr_halt (host);
print_lots (host);
dump_events (host, 30);
ncr_scsi_reset (host);
for (tmp = nuke_list = return_outstanding_commands (host, 1 /* free */,
0 /* issue */ ); tmp; tmp = (Scsi_Cmnd *) tmp->SCp.buffer)
if (tmp == cmd) {
found = 1;
break;
}
/*
* If we didn't find the command which caused this reset in our running
* list, then we've lost it. See that it terminates normally anyway.
*/
if (!found) {
c = (struct NCR53c7x0_cmd *) cmd->host_scribble;
if (c) {
cmd->host_scribble = NULL;
c->next = hostdata->free;
hostdata->free = c;
} else
printk ("scsi%d: lost command %ld\n", host->host_no, cmd->pid);
cmd->SCp.buffer = (struct scatterlist *) nuke_list;
nuke_list = cmd;
}
NCR53c7x0_driver_init (host);
hostdata->soft_reset (host);
if (hostdata->resets == 0)
disable(host);
else if (hostdata->resets != -1)
--hostdata->resets;
local_irq_restore(flags);
for (; nuke_list; nuke_list = tmp) {
tmp = (Scsi_Cmnd *) nuke_list->SCp.buffer;
nuke_list->result = DID_RESET << 16;
nuke_list->scsi_done (nuke_list);
}
local_irq_restore(flags);
return SCSI_RESET_SUCCESS;
}
/*
* The NCR SDMS bios follows Annex A of the SCSI-CAM draft, and
* therefore shares the scsicam_bios_param function.
*/
/*
* Function : int insn_to_offset (Scsi_Cmnd *cmd, u32 *insn)
*
* Purpose : convert instructions stored at NCR pointer into data
* pointer offset.
*
* Inputs : cmd - SCSI command; insn - pointer to instruction. Either current
* DSP, or saved data pointer.
*
* Returns : offset on success, -1 on failure.
*/
static int
insn_to_offset (Scsi_Cmnd *cmd, u32 *insn) {
struct NCR53c7x0_hostdata *hostdata =
(struct NCR53c7x0_hostdata *) cmd->device->host->hostdata[0];
struct NCR53c7x0_cmd *ncmd =
(struct NCR53c7x0_cmd *) cmd->host_scribble;
int offset = 0, buffers;
struct scatterlist *segment;
char *ptr;
int found = 0;
/*
* With the current code implementation, if the insn is inside dynamically
* generated code, the data pointer will be the instruction preceding
* the next transfer segment.
*/
if (!check_address ((unsigned long) ncmd, sizeof (struct NCR53c7x0_cmd)) &&
((insn >= ncmd->data_transfer_start &&
insn < ncmd->data_transfer_end) ||
(insn >= ncmd->residual &&
insn < (ncmd->residual +
sizeof(ncmd->residual))))) {
ptr = bus_to_virt(insn[3]);
if ((buffers = cmd->use_sg)) {
for (offset = 0,
[SCSI] More buffer->request_buffer changes Seem like quite a few splipped through the cracks. Here's a patch to update all references I could find: Signed-off-by: Christoph Hellwig <hch@lst.de> Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2006-07-14 01:29:34 -07:00
segment = (struct scatterlist *) cmd->request_buffer;
Linux-2.6.12-rc2 Initial git repository build. I'm not bothering with the full history, even though we have it. We can create a separate "historical" git archive of that later if we want to, and in the meantime it's about 3.2GB when imported into git - space that would just make the early git days unnecessarily complicated, when we don't have a lot of good infrastructure for it. Let it rip!
2005-04-16 15:20:36 -07:00
buffers && !((found = ((ptr >= (char *)page_address(segment->page)+segment->offset) &&
(ptr < ((char *)page_address(segment->page)+segment->offset+segment->length)))));
--buffers, offset += segment->length, ++segment)
#if 0
printk("scsi%d: comparing 0x%p to 0x%p\n",
cmd->device->host->host_no, saved, page_address(segment->page+segment->offset);
#else
;
#endif
offset += ptr - ((char *)page_address(segment->page)+segment->offset);
} else {
found = 1;
offset = ptr - (char *) (cmd->request_buffer);
}
} else if ((insn >= hostdata->script +
hostdata->E_data_transfer / sizeof(u32)) &&
(insn <= hostdata->script +
hostdata->E_end_data_transfer / sizeof(u32))) {
found = 1;
offset = 0;
}
return found ? offset : -1;
}
/*
* Function : void print_progress (Scsi_Cmnd *cmd)
*
* Purpose : print the current location of the saved data pointer
*
* Inputs : cmd - command we are interested in
*
*/
static void
print_progress (Scsi_Cmnd *cmd) {
NCR53c7x0_local_declare();
struct NCR53c7x0_cmd *ncmd =
(struct NCR53c7x0_cmd *) cmd->host_scribble;
int offset, i;
char *where;
u32 *ptr;
NCR53c7x0_local_setup (cmd->device->host);
if (check_address ((unsigned long) ncmd,sizeof (struct NCR53c7x0_cmd)) == 0)
{
printk("\nNCR53c7x0_cmd fields:\n");
printk(" bounce.len=0x%x, addr=0x%0x, buf[]=0x%02x %02x %02x %02x\n",
ncmd->bounce.len, ncmd->bounce.addr, ncmd->bounce.buf[0],
ncmd->bounce.buf[1], ncmd->bounce.buf[2], ncmd->bounce.buf[3]);
printk(" result=%04x, cdb[0]=0x%02x\n", ncmd->result, ncmd->cmnd[0]);
}
for (i = 0; i < 2; ++i) {
if (check_address ((unsigned long) ncmd,
sizeof (struct NCR53c7x0_cmd)) == -1)
continue;
if (!i) {
where = "saved";
ptr = bus_to_virt(ncmd->saved_data_pointer);
} else {
where = "active";
ptr = bus_to_virt (NCR53c7x0_read32 (DSP_REG) -
NCR53c7x0_insn_size (NCR53c7x0_read8 (DCMD_REG)) *
sizeof(u32));
}
offset = insn_to_offset (cmd, ptr);
if (offset != -1)
printk ("scsi%d : %s data pointer at offset %d\n",
cmd->device->host->host_no, where, offset);
else {
int size;
printk ("scsi%d : can't determine %s data pointer offset\n",
cmd->device->host->host_no, where);
if (ncmd) {
size = print_insn (cmd->device->host,
bus_to_virt(ncmd->saved_data_pointer), "", 1);
print_insn (cmd->device->host,
bus_to_virt(ncmd->saved_data_pointer) + size * sizeof(u32),
"", 1);
}
}
}
}
static void
print_dsa (struct Scsi_Host *host, u32 *dsa, const char *prefix) {
struct NCR53c7x0_hostdata *hostdata = (struct NCR53c7x0_hostdata *)
host->hostdata[0];
int i, len;
char *ptr;
Scsi_Cmnd *cmd;
if (check_address ((unsigned long) dsa, hostdata->dsa_end -
hostdata->dsa_start) == -1) {
printk("scsi%d : bad dsa virt 0x%p\n", host->host_no, dsa);
return;
}
printk("%sscsi%d : dsa at phys 0x%lx (virt 0x%p)\n"
" + %d : dsa_msgout length = %u, data = 0x%x (virt 0x%p)\n" ,
prefix ? prefix : "",
host->host_no, virt_to_bus (dsa), dsa, hostdata->dsa_msgout,
dsa[hostdata->dsa_msgout / sizeof(u32)],
dsa[hostdata->dsa_msgout / sizeof(u32) + 1],
bus_to_virt (dsa[hostdata->dsa_msgout / sizeof(u32) + 1]));
/*
* Only print messages if they're sane in length so we don't
* blow the kernel printk buffer on something which won't buy us
* anything.
*/
if (dsa[hostdata->dsa_msgout / sizeof(u32)] <
sizeof (hostdata->free->select))
for (i = dsa[hostdata->dsa_msgout / sizeof(u32)],
ptr = bus_to_virt (dsa[hostdata->dsa_msgout / sizeof(u32) + 1]);
i > 0 && !check_address ((unsigned long) ptr, 1);
ptr += len, i -= len) {
printk(" ");
[SCSI] Rename scsi_print_msg to spi_print_msg Rename scsi_print_msg to spi_print_msg and move its prototype from scsi_dbg.h to scsi_transport_spi.h Signed-off-by: Matthew Wilcox <matthew@wil.cx> Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2005-12-15 14:22:01 -07:00
len = spi_print_msg(ptr);
Linux-2.6.12-rc2 Initial git repository build. I'm not bothering with the full history, even though we have it. We can create a separate "historical" git archive of that later if we want to, and in the meantime it's about 3.2GB when imported into git - space that would just make the early git days unnecessarily complicated, when we don't have a lot of good infrastructure for it. Let it rip!
2005-04-16 15:20:36 -07:00
printk("\n");
if (!len)
break;
}
printk(" + %d : select_indirect = 0x%x\n",
hostdata->dsa_select, dsa[hostdata->dsa_select / sizeof(u32)]);
cmd = (Scsi_Cmnd *) bus_to_virt(dsa[hostdata->dsa_cmnd / sizeof(u32)]);
printk(" + %d : dsa_cmnd = 0x%x ", hostdata->dsa_cmnd,
(u32) virt_to_bus(cmd));
/* XXX Maybe we should access cmd->host_scribble->result here. RGH */
if (cmd) {
printk(" result = 0x%x, target = %d, lun = %d, cmd = ",
cmd->result, cmd->device->id, cmd->device->lun);
[PATCH] remove outdated print_* functions We have the scsi_print_* functions in the proper namespace for a long time now and there weren't a lot users left. Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2005-04-03 12:53:59 -07:00
__scsi_print_command(cmd->cmnd);
Linux-2.6.12-rc2 Initial git repository build. I'm not bothering with the full history, even though we have it. We can create a separate "historical" git archive of that later if we want to, and in the meantime it's about 3.2GB when imported into git - space that would just make the early git days unnecessarily complicated, when we don't have a lot of good infrastructure for it. Let it rip!
2005-04-16 15:20:36 -07:00
} else
printk("\n");
printk(" + %d : dsa_next = 0x%x\n", hostdata->dsa_next,
dsa[hostdata->dsa_next / sizeof(u32)]);
if (cmd) {
printk("scsi%d target %d : sxfer_sanity = 0x%x, scntl3_sanity = 0x%x\n"
" script : ",
host->host_no, cmd->device->id,
hostdata->sync[cmd->device->id].sxfer_sanity,
hostdata->sync[cmd->device->id].scntl3_sanity);
for (i = 0; i < (sizeof(hostdata->sync[cmd->device->id].script) / 4); ++i)
printk ("0x%x ", hostdata->sync[cmd->device->id].script[i]);
printk ("\n");
print_progress (cmd);
}
}
/*
* Function : void print_queues (Scsi_Host *host)
*
* Purpose : print the contents of the NCR issue and reconnect queues
*
* Inputs : host - SCSI host we are interested in
*
*/
static void
print_queues (struct Scsi_Host *host) {
struct NCR53c7x0_hostdata *hostdata = (struct NCR53c7x0_hostdata *)
host->hostdata[0];
u32 *dsa, *next_dsa;
volatile u32 *ncrcurrent;
int left;
Scsi_Cmnd *cmd, *next_cmd;
unsigned long flags;
printk ("scsi%d : issue queue\n", host->host_no);
for (left = host->can_queue, cmd = (Scsi_Cmnd *) hostdata->issue_queue;
left >= 0 && cmd;
cmd = next_cmd) {
next_cmd = (Scsi_Cmnd *) cmd->SCp.ptr;
local_irq_save(flags);
if (cmd->host_scribble) {
if (check_address ((unsigned long) (cmd->host_scribble),
sizeof (cmd->host_scribble)) == -1)
printk ("scsi%d: scsi pid %ld bad pointer to NCR53c7x0_cmd\n",
host->host_no, cmd->pid);
/* print_dsa does sanity check on address, no need to check */
else
print_dsa (host, ((struct NCR53c7x0_cmd *) cmd->host_scribble)
-> dsa, "");
} else
printk ("scsi%d : scsi pid %ld for target %d lun %d has no NCR53c7x0_cmd\n",
host->host_no, cmd->pid, cmd->device->id, cmd->device->lun);
local_irq_restore(flags);
}
if (left <= 0) {
printk ("scsi%d : loop detected in issue queue\n",
host->host_no);
}
/*
* Traverse the NCR reconnect and start DSA structures, printing out
* each element until we hit the end or detect a loop. Currently,
* the reconnect structure is a linked list; and the start structure
* is an array. Eventually, the reconnect structure will become a
* list as well, since this simplifies the code.
*/
printk ("scsi%d : schedule dsa array :\n", host->host_no);
for (left = host->can_queue, ncrcurrent = hostdata->schedule;
left > 0; ncrcurrent += 2, --left)
if (ncrcurrent[0] != hostdata->NOP_insn)
/* FIXME : convert pointer to dsa_begin to pointer to dsa. */
print_dsa (host, bus_to_virt (ncrcurrent[1] -
(hostdata->E_dsa_code_begin -
hostdata->E_dsa_code_template)), "");
printk ("scsi%d : end schedule dsa array\n", host->host_no);
printk ("scsi%d : reconnect_dsa_head :\n", host->host_no);
for (left = host->can_queue,
dsa = bus_to_virt (hostdata->reconnect_dsa_head);
left >= 0 && dsa;
dsa = next_dsa) {
local_irq_save(flags);
if (check_address ((unsigned long) dsa, sizeof(dsa)) == -1) {
printk ("scsi%d: bad DSA pointer 0x%p", host->host_no,
dsa);
next_dsa = NULL;
}
else
{
next_dsa = bus_to_virt(dsa[hostdata->dsa_next / sizeof(u32)]);
print_dsa (host, dsa, "");
}
local_irq_restore(flags);
}
printk ("scsi%d : end reconnect_dsa_head\n", host->host_no);
if (left < 0)
printk("scsi%d: possible loop in ncr reconnect list\n",
host->host_no);
}
static void
print_lots (struct Scsi_Host *host) {
NCR53c7x0_local_declare();
struct NCR53c7x0_hostdata *hostdata =
(struct NCR53c7x0_hostdata *) host->hostdata[0];
u32 *dsp_next, *dsp, *dsa, dbc_dcmd;
unsigned char dcmd, sbcl;
int i, size;
NCR53c7x0_local_setup(host);
if ((dsp_next = bus_to_virt(NCR53c7x0_read32 (DSP_REG)))) {
dbc_dcmd = NCR53c7x0_read32(DBC_REG);
dcmd = (dbc_dcmd & 0xff000000) >> 24;
dsp = dsp_next - NCR53c7x0_insn_size(dcmd);
dsa = bus_to_virt(NCR53c7x0_read32(DSA_REG));
sbcl = NCR53c7x0_read8 (SBCL_REG);
/*
* For the 53c710, the following will report value 0 for SCNTL3
* and STEST0 - we don't have these registers.
*/
printk ("scsi%d : DCMD|DBC=0x%x, DNAD=0x%x (virt 0x%p)\n"
" DSA=0x%lx (virt 0x%p)\n"
" DSPS=0x%x, TEMP=0x%x (virt 0x%p), DMODE=0x%x\n"
" SXFER=0x%x, SCNTL3=0x%x\n"
" %s%s%sphase=%s, %d bytes in SCSI FIFO\n"
" SCRATCH=0x%x, saved2_dsa=0x%0lx\n",
host->host_no, dbc_dcmd, NCR53c7x0_read32(DNAD_REG),
bus_to_virt(NCR53c7x0_read32(DNAD_REG)),
virt_to_bus(dsa), dsa,
NCR53c7x0_read32(DSPS_REG), NCR53c7x0_read32(TEMP_REG),
bus_to_virt (NCR53c7x0_read32(TEMP_REG)),
(int) NCR53c7x0_read8(hostdata->dmode),
(int) NCR53c7x0_read8(SXFER_REG),
((hostdata->chip / 100) == 8) ?
(int) NCR53c7x0_read8(SCNTL3_REG_800) : 0,
(sbcl & SBCL_BSY) ? "BSY " : "",
(sbcl & SBCL_SEL) ? "SEL " : "",
(sbcl & SBCL_REQ) ? "REQ " : "",
sstat2_to_phase(NCR53c7x0_read8 (((hostdata->chip / 100) == 8) ?
SSTAT1_REG : SSTAT2_REG)),
(NCR53c7x0_read8 ((hostdata->chip / 100) == 8 ?
SSTAT1_REG : SSTAT2_REG) & SSTAT2_FF_MASK) >> SSTAT2_FF_SHIFT,
((hostdata->chip / 100) == 8) ? NCR53c7x0_read8 (STEST0_REG_800) :
NCR53c7x0_read32(SCRATCHA_REG_800),
hostdata->saved2_dsa);
printk ("scsi%d : DSP 0x%lx (virt 0x%p) ->\n", host->host_no,
virt_to_bus(dsp), dsp);
for (i = 6; i > 0; --i, dsp += size)
size = print_insn (host, dsp, "", 1);
if (NCR53c7x0_read8 (SCNTL1_REG) & SCNTL1_CON) {
if ((hostdata->chip / 100) == 8)
printk ("scsi%d : connected (SDID=0x%x, SSID=0x%x)\n",
host->host_no, NCR53c7x0_read8 (SDID_REG_800),
NCR53c7x0_read8 (SSID_REG_800));
else
printk ("scsi%d : connected (SDID=0x%x)\n",
host->host_no, NCR53c7x0_read8 (SDID_REG_700));
print_dsa (host, dsa, "");
}
#if 1
print_queues (host);
#endif
}
}
/*
* Function : static int shutdown (struct Scsi_Host *host)
*
* Purpose : does a clean (we hope) shutdown of the NCR SCSI
* chip. Use prior to dumping core, unloading the NCR driver,
*
* Returns : 0 on success
*/
static int
shutdown (struct Scsi_Host *host) {
NCR53c7x0_local_declare();
unsigned long flags;
struct NCR53c7x0_hostdata *hostdata = (struct NCR53c7x0_hostdata *)
host->hostdata[0];
NCR53c7x0_local_setup(host);
local_irq_save(flags);
/* Get in a state where we can reset the SCSI bus */
ncr_halt (host);
ncr_scsi_reset (host);
hostdata->soft_reset(host);
disable (host);
local_irq_restore(flags);
return 0;
}
/*
* Function : void ncr_scsi_reset (struct Scsi_Host *host)
*
* Purpose : reset the SCSI bus.
*/
static void
ncr_scsi_reset (struct Scsi_Host *host) {
NCR53c7x0_local_declare();
unsigned long flags;
NCR53c7x0_local_setup(host);
local_irq_save(flags);
NCR53c7x0_write8(SCNTL1_REG, SCNTL1_RST);
udelay(25); /* Minimum amount of time to assert RST */
NCR53c7x0_write8(SCNTL1_REG, 0);
local_irq_restore(flags);
}
/*
* Function : void hard_reset (struct Scsi_Host *host)
*
*/
static void
hard_reset (struct Scsi_Host *host) {
struct NCR53c7x0_hostdata *hostdata = (struct NCR53c7x0_hostdata *)
host->hostdata[0];
unsigned long flags;
local_irq_save(flags);
ncr_scsi_reset(host);
NCR53c7x0_driver_init (host);
if (hostdata->soft_reset)
hostdata->soft_reset (host);
local_irq_restore(flags);
}
/*
* Function : Scsi_Cmnd *return_outstanding_commands (struct Scsi_Host *host,
* int free, int issue)
*
* Purpose : return a linked list (using the SCp.buffer field as next,
* so we don't perturb hostdata. We don't use a field of the
* NCR53c7x0_cmd structure since we may not have allocated one
* for the command causing the reset.) of Scsi_Cmnd structures that
* had propagated below the Linux issue queue level. If free is set,
* free the NCR53c7x0_cmd structures which are associated with
* the Scsi_Cmnd structures, and clean up any internal
* NCR lists that the commands were on. If issue is set,
* also return commands in the issue queue.
*
* Returns : linked list of commands
*
* NOTE : the caller should insure that the NCR chip is halted
* if the free flag is set.
*/
static Scsi_Cmnd *
return_outstanding_commands (struct Scsi_Host *host, int free, int issue) {
struct NCR53c7x0_hostdata *hostdata = (struct NCR53c7x0_hostdata *)
host->hostdata[0];
struct NCR53c7x0_cmd *c;
int i;
u32 *ncrcurrent;
Scsi_Cmnd *list = NULL, *tmp;
for (c = (struct NCR53c7x0_cmd *) hostdata->running_list; c;
c = (struct NCR53c7x0_cmd *) c->next) {
if (c->cmd->SCp.buffer) {
printk ("scsi%d : loop detected in running list!\n", host->host_no);
break;
} else {
printk ("Duh? Bad things happening in the NCR driver\n");
break;
}
c->cmd->SCp.buffer = (struct scatterlist *) list;
list = c->cmd;
if (free) {
c->next = hostdata->free;
hostdata->free = c;
}
}
if (free) {
for (i = 0, ncrcurrent = (u32 *) hostdata->schedule;
i < host->can_queue; ++i, ncrcurrent += 2) {
ncrcurrent[0] = hostdata->NOP_insn;
ncrcurrent[1] = 0xdeadbeef;
}
hostdata->ncrcurrent = NULL;
}
if (issue) {
for (tmp = (Scsi_Cmnd *) hostdata->issue_queue; tmp; tmp = tmp->next) {
if (tmp->SCp.buffer) {
printk ("scsi%d : loop detected in issue queue!\n",
host->host_no);
break;
}
tmp->SCp.buffer = (struct scatterlist *) list;
list = tmp;
}
if (free)
hostdata->issue_queue = NULL;
}
return list;
}
/*
* Function : static int disable (struct Scsi_Host *host)
*
* Purpose : disables the given NCR host, causing all commands
* to return a driver error. Call this so we can unload the
* module during development and try again. Eventually,
* we should be able to find clean workarounds for these
* problems.
*
* Inputs : host - hostadapter to twiddle
*
* Returns : 0 on success.
*/
static int
disable (struct Scsi_Host *host) {
struct NCR53c7x0_hostdata *hostdata = (struct NCR53c7x0_hostdata *)
host->hostdata[0];
unsigned long flags;
Scsi_Cmnd *nuke_list, *tmp;
local_irq_save(flags);
if (hostdata->state != STATE_HALTED)
ncr_halt (host);
nuke_list = return_outstanding_commands (host, 1 /* free */, 1 /* issue */);
hard_reset (host);
hostdata->state = STATE_DISABLED;
local_irq_restore(flags);
printk ("scsi%d : nuking commands\n", host->host_no);
for (; nuke_list; nuke_list = tmp) {
tmp = (Scsi_Cmnd *) nuke_list->SCp.buffer;
nuke_list->result = DID_ERROR << 16;
nuke_list->scsi_done(nuke_list);
}
printk ("scsi%d : done. \n", host->host_no);
printk (KERN_ALERT "scsi%d : disabled. Unload and reload\n",
host->host_no);
return 0;
}
/*
* Function : static int ncr_halt (struct Scsi_Host *host)
*
* Purpose : halts the SCSI SCRIPTS(tm) processor on the NCR chip
*
* Inputs : host - SCSI chip to halt
*
* Returns : 0 on success
*/
static int
ncr_halt (struct Scsi_Host *host) {
NCR53c7x0_local_declare();
unsigned long flags;
unsigned char istat, tmp;
struct NCR53c7x0_hostdata *hostdata = (struct NCR53c7x0_hostdata *)
host->hostdata[0];
int stage;
NCR53c7x0_local_setup(host);
local_irq_save(flags);
/* Stage 0 : eat all interrupts
Stage 1 : set ABORT
Stage 2 : eat all but abort interrupts
Stage 3 : eat all interrupts
*/
for (stage = 0;;) {
if (stage == 1) {
NCR53c7x0_write8(hostdata->istat, ISTAT_ABRT);
++stage;
}
istat = NCR53c7x0_read8 (hostdata->istat);
if (istat & ISTAT_SIP) {
tmp = NCR53c7x0_read8(SSTAT0_REG);
} else if (istat & ISTAT_DIP) {
tmp = NCR53c7x0_read8(DSTAT_REG);
if (stage == 2) {
if (tmp & DSTAT_ABRT) {
NCR53c7x0_write8(hostdata->istat, 0);
++stage;
} else {
printk(KERN_ALERT "scsi%d : could not halt NCR chip\n",
host->host_no);
disable (host);
}
}
}
if (!(istat & (ISTAT_SIP|ISTAT_DIP))) {
if (stage == 0)
++stage;
else if (stage == 3)
break;
}
}
hostdata->state = STATE_HALTED;
local_irq_restore(flags);
#if 0
print_lots (host);
#endif
return 0;
}
/*
* Function: event_name (int event)
*
* Purpose: map event enum into user-readable strings.
*/
static const char *
event_name (int event) {
switch (event) {
case EVENT_NONE: return "none";
case EVENT_ISSUE_QUEUE: return "to issue queue";
case EVENT_START_QUEUE: return "to start queue";
case EVENT_SELECT: return "selected";
case EVENT_DISCONNECT: return "disconnected";
case EVENT_RESELECT: return "reselected";
case EVENT_COMPLETE: return "completed";
case EVENT_IDLE: return "idle";
case EVENT_SELECT_FAILED: return "select failed";
case EVENT_BEFORE_SELECT: return "before select";
case EVENT_RESELECT_FAILED: return "reselect failed";
default: return "unknown";
}
}
/*
* Function : void dump_events (struct Scsi_Host *host, count)
*
* Purpose : print last count events which have occurred.
*/
static void
dump_events (struct Scsi_Host *host, int count) {
struct NCR53c7x0_hostdata *hostdata = (struct NCR53c7x0_hostdata *)
host->hostdata[0];
struct NCR53c7x0_event event;
int i;
unsigned long flags;
if (hostdata->events) {
if (count > hostdata->event_size)
count = hostdata->event_size;
for (i = hostdata->event_index; count > 0;
i = (i ? i - 1 : hostdata->event_size -1), --count) {
/*
* By copying the event we're currently examining with interrupts
* disabled, we can do multiple printk(), etc. operations and
* still be guaranteed that they're happening on the same
* event structure.
*/
local_irq_save(flags);
#if 0
event = hostdata->events[i];
#else
memcpy ((void *) &event, (void *) &(hostdata->events[i]),
sizeof(event));
#endif
local_irq_restore(flags);
printk ("scsi%d : %s event %d at %ld secs %ld usecs target %d lun %d\n",
host->host_no, event_name (event.event), count,
(long) event.time.tv_sec, (long) event.time.tv_usec,
event.target, event.lun);
if (event.dsa)
printk (" event for dsa 0x%lx (virt 0x%p)\n",
virt_to_bus(event.dsa), event.dsa);
if (event.pid != -1) {
printk (" event for pid %ld ", event.pid);
[PATCH] remove outdated print_* functions We have the scsi_print_* functions in the proper namespace for a long time now and there weren't a lot users left. Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>
2005-04-03 12:53:59 -07:00
__scsi_print_command (event.cmnd);
Linux-2.6.12-rc2 Initial git repository build. I'm not bothering with the full history, even though we have it. We can create a separate "historical" git archive of that later if we want to, and in the meantime it's about 3.2GB when imported into git - space that would just make the early git days unnecessarily complicated, when we don't have a lot of good infrastructure for it. Let it rip!
2005-04-16 15:20:36 -07:00
}
}
}
}
/*
* Function: check_address
*
* Purpose: Check to see if a possibly corrupt pointer will fault the
* kernel.
*
* Inputs: addr - address; size - size of area
*
* Returns: 0 if area is OK, -1 on error.
*
* NOTES: should be implemented in terms of vverify on kernels
* that have it.
*/
static int
check_address (unsigned long addr, int size) {
return (virt_to_phys((void *)addr) < PAGE_SIZE || virt_to_phys((void *)(addr + size)) > virt_to_phys(high_memory) ? -1 : 0);
}
#ifdef MODULE
int
NCR53c7x0_release(struct Scsi_Host *host) {
struct NCR53c7x0_hostdata *hostdata =
(struct NCR53c7x0_hostdata *) host->hostdata[0];
struct NCR53c7x0_cmd *cmd, *tmp;
shutdown (host);
if (host->irq != SCSI_IRQ_NONE)
{
int irq_count;
struct Scsi_Host *tmp;
for (irq_count = 0, tmp = first_host; tmp; tmp = tmp->next)
if (tmp->hostt == the_template && tmp->irq == host->irq)
++irq_count;
if (irq_count == 1)
free_irq(host->irq, NULL);
}
if (host->dma_channel != DMA_NONE)
free_dma(host->dma_channel);
if (host->io_port)
release_region(host->io_port, host->n_io_port);
for (cmd = (struct NCR53c7x0_cmd *) hostdata->free; cmd; cmd = tmp,
--hostdata->num_cmds) {
tmp = (struct NCR53c7x0_cmd *) cmd->next;
/*
* If we're going to loop, try to stop it to get a more accurate
* count of the leaked commands.
*/
cmd->next = NULL;
if (cmd->free)
cmd->free ((void *) cmd->real, cmd->size);
}
if (hostdata->num_cmds)
printk ("scsi%d : leaked %d NCR53c7x0_cmd structures\n",
host->host_no, hostdata->num_cmds);
[PATCH] vfree and kfree cleanup in drivers/ This patch does a full cleanup of 'NULL checks before vfree', and a partial cleanup of calls to kfree for all of drivers/ - the kfree bit is partial in that I only did the files that also had vfree calls in them. The patch also gets rid of some redundant (void *) casts of pointers being passed to [vk]free, and a some tiny whitespace corrections also crept in. Signed-off-by: Jesper Juhl <jesper.juhl@gmail.com> Signed-off-by: Andrew Morton <akpm@osdl.org> Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-09-10 00:26:54 -07:00
vfree(hostdata->events);
Linux-2.6.12-rc2 Initial git repository build. I'm not bothering with the full history, even though we have it. We can create a separate "historical" git archive of that later if we want to, and in the meantime it's about 3.2GB when imported into git - space that would just make the early git days unnecessarily complicated, when we don't have a lot of good infrastructure for it. Let it rip!
2005-04-16 15:20:36 -07:00
/* XXX This assumes default cache mode to be IOMAP_FULL_CACHING, which
* XXX may be invalid (CONFIG_060_WRITETHROUGH)
*/
kernel_set_cachemode((void *)hostdata, 8192, IOMAP_FULL_CACHING);
free_pages ((u32)hostdata, 1);
return 1;
}
#endif /* def MODULE */
Copy Permalink