53c700.c revision df0ae2497ddefd72a87f3a3b34ff32455d7d4ae0
11da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* -*- mode: c; c-basic-offset: 8 -*- */
21da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
31da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* NCR (or Symbios) 53c700 and 53c700-66 Driver
41da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds *
51da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Copyright (C) 2001 by James.Bottomley@HansenPartnership.com
61da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds**-----------------------------------------------------------------------------
71da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds**
81da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds**  This program is free software; you can redistribute it and/or modify
91da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds**  it under the terms of the GNU General Public License as published by
101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds**  the Free Software Foundation; either version 2 of the License, or
111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds**  (at your option) any later version.
121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds**
131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds**  This program is distributed in the hope that it will be useful,
141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds**  but WITHOUT ANY WARRANTY; without even the implied warranty of
151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds**  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds**  GNU General Public License for more details.
171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds**
181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds**  You should have received a copy of the GNU General Public License
191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds**  along with this program; if not, write to the Free Software
201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds**  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds**
221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds**-----------------------------------------------------------------------------
231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */
241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* Notes:
261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds *
271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * This driver is designed exclusively for these chips (virtually the
281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * earliest of the scripts engine chips).  They need their own drivers
291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * because they are missing so many of the scripts and snazzy register
301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * features of their elder brothers (the 710, 720 and 770).
311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds *
321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * The 700 is the lowliest of the line, it can only do async SCSI.
331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * The 700-66 can at least do synchronous SCSI up to 10MHz.
341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds *
351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * The 700 chip has no host bus interface logic of its own.  However,
361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * it is usually mapped to a location with well defined register
371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * offsets.  Therefore, if you can determine the base address and the
381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * irq your board incorporating this chip uses, you can probably use
391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * this driver to run it (although you'll probably have to write a
401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * minimal wrapper for the purpose---see the NCR_D700 driver for
411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * details about how to do this).
421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds *
431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds *
441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * TODO List:
451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds *
461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 1. Better statistics in the proc fs
471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds *
481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 2. Implement message queue (queues SCSI messages like commands) and make
491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds *    the abort and device reset functions use them.
501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * */
511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* CHANGELOG
531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds *
541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Version 2.8
551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds *
561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Fixed bad bug affecting tag starvation processing (previously the
571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * driver would hang the system if too many tags starved.  Also fixed
581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * bad bug having to do with 10 byte command processing and REQUEST
591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * SENSE (the command would loop forever getting a transfer length
601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * mismatch in the CMD phase).
611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds *
621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Version 2.7
631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds *
641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Fixed scripts problem which caused certain devices (notably CDRWs)
651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * to hang on initial INQUIRY.  Updated NCR_700_readl/writel to use
661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * __raw_readl/writel for parisc compatibility (Thomas
671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Bogendoerfer). Added missing SCp->request_bufflen initialisation
681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * for sense requests (Ryan Bradetich).
691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds *
701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Version 2.6
711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds *
721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Following test of the 64 bit parisc kernel by Richard Hirst,
731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * several problems have now been corrected.  Also adds support for
741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * consistent memory allocation.
751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds *
761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Version 2.5
771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds *
781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * More Compatibility changes for 710 (now actually works).  Enhanced
791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * support for odd clock speeds which constrain SDTR negotiations.
801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * correct cacheline separation for scsi messages and status for
811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * incoherent architectures.  Use of the pci mapping functions on
821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * buffers to begin support for 64 bit drivers.
831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds *
841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Version 2.4
851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds *
861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Added support for the 53c710 chip (in 53c700 emulation mode only---no
871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * special 53c710 instructions or registers are used).
881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds *
891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Version 2.3
901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds *
911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * More endianness/cache coherency changes.
921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds *
931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Better bad device handling (handles devices lying about tag
941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * queueing support and devices which fail to provide sense data on
951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * contingent allegiance conditions)
961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds *
971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Many thanks to Richard Hirst <rhirst@linuxcare.com> for patiently
981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * debugging this driver on the parisc architecture and suggesting
991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * many improvements and bug fixes.
1001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds *
1011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Thanks also go to Linuxcare Inc. for providing several PARISC
1021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * machines for me to debug the driver on.
1031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds *
1041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Version 2.2
1051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds *
1061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Made the driver mem or io mapped; added endian invariance; added
1071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * dma cache flushing operations for architectures which need it;
1081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * added support for more varied clocking speeds.
1091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds *
1101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Version 2.1
1111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds *
1121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Initial modularisation from the D700.  See NCR_D700.c for the rest of
1131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * the changelog.
1141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * */
1151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define NCR_700_VERSION "2.8"
1161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
1171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/config.h>
1181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/kernel.h>
1191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/types.h>
1201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/string.h>
1211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/ioport.h>
1221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/delay.h>
1231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/spinlock.h>
1241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/completion.h>
1251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/sched.h>
1261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/init.h>
1271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/proc_fs.h>
1281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/blkdev.h>
1291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/module.h>
1301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/interrupt.h>
1311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <asm/dma.h>
1321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <asm/system.h>
1331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <asm/io.h>
1341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <asm/pgtable.h>
1351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <asm/byteorder.h>
1361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
1371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <scsi/scsi.h>
1381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <scsi/scsi_cmnd.h>
1391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <scsi/scsi_dbg.h>
1401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <scsi/scsi_eh.h>
1411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <scsi/scsi_host.h>
1421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <scsi/scsi_tcq.h>
1431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <scsi/scsi_transport.h>
1441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <scsi/scsi_transport_spi.h>
1451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
1461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include "53c700.h"
1471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
1481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* NOTE: For 64 bit drivers there are points in the code where we use
1491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * a non dereferenceable pointer to point to a structure in dma-able
1501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * memory (which is 32 bits) so that we can use all of the structure
1511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * operations but take the address at the end.  This macro allows us
1521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * to truncate the 64 bit pointer down to 32 bits without the compiler
1531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * complaining */
1541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define to32bit(x)	((__u32)((unsigned long)(x)))
1551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
1561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#ifdef NCR_700_DEBUG
1571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define STATIC
1581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#else
1591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#define STATIC static
1601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif
1611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
1621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsMODULE_AUTHOR("James Bottomley");
1631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsMODULE_DESCRIPTION("53c700 and 53c700-66 Driver");
1641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsMODULE_LICENSE("GPL");
1651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
1661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* This is the script */
1671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include "53c700_d.h"
1681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
1691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
1701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsSTATIC int NCR_700_queuecommand(struct scsi_cmnd *, void (*done)(struct scsi_cmnd *));
1711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsSTATIC int NCR_700_abort(struct scsi_cmnd * SCpnt);
1721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsSTATIC int NCR_700_bus_reset(struct scsi_cmnd * SCpnt);
1731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsSTATIC int NCR_700_host_reset(struct scsi_cmnd * SCpnt);
1741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsSTATIC void NCR_700_chip_setup(struct Scsi_Host *host);
1751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsSTATIC void NCR_700_chip_reset(struct Scsi_Host *host);
1761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsSTATIC int NCR_700_slave_configure(struct scsi_device *SDpnt);
1771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsSTATIC void NCR_700_slave_destroy(struct scsi_device *SDpnt);
1781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int NCR_700_change_queue_depth(struct scsi_device *SDpnt, int depth);
1791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int NCR_700_change_queue_type(struct scsi_device *SDpnt, int depth);
1801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
1811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsSTATIC struct device_attribute *NCR_700_dev_attrs[];
1821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
1831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsSTATIC struct scsi_transport_template *NCR_700_transport_template = NULL;
1841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
1851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic char *NCR_700_phase[] = {
1861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	"",
1871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	"after selection",
1881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	"before command phase",
1891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	"after command phase",
1901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	"after status phase",
1911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	"after data in phase",
1921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	"after data out phase",
1931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	"during data phase",
1941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds};
1951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
1961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic char *NCR_700_condition[] = {
1971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	"",
1981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	"NOT MSG_OUT",
1991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	"UNEXPECTED PHASE",
2001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	"NOT MSG_IN",
2011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	"UNEXPECTED MSG",
2021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	"MSG_IN",
2031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	"SDTR_MSG RECEIVED",
2041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	"REJECT_MSG RECEIVED",
2051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	"DISCONNECT_MSG RECEIVED",
2061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	"MSG_OUT",
2071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	"DATA_IN",
2081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
2091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds};
2101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
2111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic char *NCR_700_fatal_messages[] = {
2121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	"unexpected message after reselection",
2131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	"still MSG_OUT after message injection",
2141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	"not MSG_IN after selection",
2151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	"Illegal message length received",
2161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds};
2171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
2181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic char *NCR_700_SBCL_bits[] = {
2191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	"IO ",
2201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	"CD ",
2211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	"MSG ",
2221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	"ATN ",
2231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	"SEL ",
2241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	"BSY ",
2251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	"ACK ",
2261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	"REQ ",
2271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds};
2281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
2291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic char *NCR_700_SBCL_to_phase[] = {
2301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	"DATA_OUT",
2311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	"DATA_IN",
2321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	"CMD_OUT",
2331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	"STATE",
2341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	"ILLEGAL PHASE",
2351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	"ILLEGAL PHASE",
2361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	"MSG OUT",
2371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	"MSG IN",
2381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds};
2391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
2401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic __u8 NCR_700_SDTR_msg[] = {
2411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	0x01,			/* Extended message */
2421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	0x03,			/* Extended message Length */
2431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	0x01,			/* SDTR Extended message */
2441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	NCR_700_MIN_PERIOD,
2451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	NCR_700_MAX_OFFSET
2461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds};
2471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
2481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* This translates the SDTR message offset and period to a value
2491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * which can be loaded into the SXFER_REG.
2501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds *
2511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * NOTE: According to SCSI-2, the true transfer period (in ns) is
2521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds *       actually four times this period value */
2531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic inline __u8
2541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsNCR_700_offset_period_to_sxfer(struct NCR_700_Host_Parameters *hostdata,
2551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			       __u8 offset, __u8 period)
2561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{
2571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	int XFERP;
2581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
2591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	__u8 min_xferp = (hostdata->chip710
2601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			  ? NCR_710_MIN_XFERP : NCR_700_MIN_XFERP);
2611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	__u8 max_offset = (hostdata->chip710
2621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			   ? NCR_710_MAX_OFFSET : NCR_700_MAX_OFFSET);
2631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
2641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	if(offset == 0)
2651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		return 0;
2661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
2671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	if(period < hostdata->min_period) {
2681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		printk(KERN_WARNING "53c700: Period %dns is less than this chip's minimum, setting to %d\n", period*4, NCR_700_SDTR_msg[3]*4);
2691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		period = hostdata->min_period;
2701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	}
2711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	XFERP = (period*4 * hostdata->sync_clock)/1000 - 4;
2721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	if(offset > max_offset) {
2731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		printk(KERN_WARNING "53c700: Offset %d exceeds chip maximum, setting to %d\n",
2741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		       offset, max_offset);
2751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		offset = max_offset;
2761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	}
2771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	if(XFERP < min_xferp) {
2781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		printk(KERN_WARNING "53c700: XFERP %d is less than minium, setting to %d\n",
2791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		       XFERP,  min_xferp);
2801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		XFERP =  min_xferp;
2811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	}
2821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	return (offset & 0x0f) | (XFERP & 0x07)<<4;
2831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds}
2841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
2851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic inline __u8
2861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsNCR_700_get_SXFER(struct scsi_device *SDp)
2871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{
2881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	struct NCR_700_Host_Parameters *hostdata =
2891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		(struct NCR_700_Host_Parameters *)SDp->host->hostdata[0];
2901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
2911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	return NCR_700_offset_period_to_sxfer(hostdata,
2921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds					      spi_offset(SDp->sdev_target),
2931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds					      spi_period(SDp->sdev_target));
2941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds}
2951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
2961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstruct Scsi_Host *
2971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsNCR_700_detect(struct scsi_host_template *tpnt,
2981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	       struct NCR_700_Host_Parameters *hostdata, struct device *dev)
2991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{
3001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	dma_addr_t pScript, pSlots;
3011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	__u8 *memory;
3021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	__u32 *script;
3031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	struct Scsi_Host *host;
3041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	static int banner = 0;
3051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	int j;
3061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
3071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	if(tpnt->sdev_attrs == NULL)
3081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		tpnt->sdev_attrs = NCR_700_dev_attrs;
3091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
3101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	memory = dma_alloc_noncoherent(hostdata->dev, TOTAL_MEM_SIZE,
3111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				       &pScript, GFP_KERNEL);
3121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	if(memory == NULL) {
3131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		printk(KERN_ERR "53c700: Failed to allocate memory for driver, detatching\n");
3141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		return NULL;
3151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	}
3161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
3171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	script = (__u32 *)memory;
3181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	hostdata->msgin = memory + MSGIN_OFFSET;
3191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	hostdata->msgout = memory + MSGOUT_OFFSET;
3201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	hostdata->status = memory + STATUS_OFFSET;
3211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	/* all of these offsets are L1_CACHE_BYTES separated.  It is fatal
3221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	 * if this isn't sufficient separation to avoid dma flushing issues */
3231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	BUG_ON(!dma_is_consistent(pScript) && L1_CACHE_BYTES < dma_get_cache_alignment());
3241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	hostdata->slots = (struct NCR_700_command_slot *)(memory + SLOTS_OFFSET);
3251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	hostdata->dev = dev;
3261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
3271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	pSlots = pScript + SLOTS_OFFSET;
3281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
3291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	/* Fill in the missing routines from the host template */
3301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	tpnt->queuecommand = NCR_700_queuecommand;
3311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	tpnt->eh_abort_handler = NCR_700_abort;
3321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	tpnt->eh_bus_reset_handler = NCR_700_bus_reset;
3331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	tpnt->eh_host_reset_handler = NCR_700_host_reset;
3341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	tpnt->can_queue = NCR_700_COMMAND_SLOTS_PER_HOST;
3351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	tpnt->sg_tablesize = NCR_700_SG_SEGMENTS;
3361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	tpnt->cmd_per_lun = NCR_700_CMD_PER_LUN;
3371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	tpnt->use_clustering = ENABLE_CLUSTERING;
3381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	tpnt->slave_configure = NCR_700_slave_configure;
3391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	tpnt->slave_destroy = NCR_700_slave_destroy;
3401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	tpnt->change_queue_depth = NCR_700_change_queue_depth;
3411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	tpnt->change_queue_type = NCR_700_change_queue_type;
3421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
3431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	if(tpnt->name == NULL)
3441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		tpnt->name = "53c700";
3451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	if(tpnt->proc_name == NULL)
3461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		tpnt->proc_name = "53c700";
3471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
3481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
3491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	host = scsi_host_alloc(tpnt, 4);
3501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	if (!host)
3511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		return NULL;
3521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	memset(hostdata->slots, 0, sizeof(struct NCR_700_command_slot)
3531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	       * NCR_700_COMMAND_SLOTS_PER_HOST);
3541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	for(j = 0; j < NCR_700_COMMAND_SLOTS_PER_HOST; j++) {
3551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		dma_addr_t offset = (dma_addr_t)((unsigned long)&hostdata->slots[j].SG[0]
3561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds					  - (unsigned long)&hostdata->slots[0].SG[0]);
3571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		hostdata->slots[j].pSG = (struct NCR_700_SG_List *)((unsigned long)(pSlots + offset));
3581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		if(j == 0)
3591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			hostdata->free_list = &hostdata->slots[j];
3601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		else
3611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			hostdata->slots[j-1].ITL_forw = &hostdata->slots[j];
3621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		hostdata->slots[j].state = NCR_700_SLOT_FREE;
3631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	}
3641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
3651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	for(j = 0; j < sizeof(SCRIPT)/sizeof(SCRIPT[0]); j++) {
3661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		script[j] = bS_to_host(SCRIPT[j]);
3671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	}
3681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
3691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	/* adjust all labels to be bus physical */
3701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	for(j = 0; j < PATCHES; j++) {
3711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		script[LABELPATCHES[j]] = bS_to_host(pScript + SCRIPT[LABELPATCHES[j]]);
3721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	}
3731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	/* now patch up fixed addresses. */
3741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	script_patch_32(script, MessageLocation,
3751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			pScript + MSGOUT_OFFSET);
3761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	script_patch_32(script, StatusAddress,
3771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			pScript + STATUS_OFFSET);
3781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	script_patch_32(script, ReceiveMsgAddress,
3791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			pScript + MSGIN_OFFSET);
3801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
3811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	hostdata->script = script;
3821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	hostdata->pScript = pScript;
3831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	dma_sync_single_for_device(hostdata->dev, pScript, sizeof(SCRIPT), DMA_TO_DEVICE);
3841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	hostdata->state = NCR_700_HOST_FREE;
3851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	hostdata->cmd = NULL;
3861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	host->max_id = 7;
3871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	host->max_lun = NCR_700_MAX_LUNS;
3881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	BUG_ON(NCR_700_transport_template == NULL);
3891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	host->transportt = NCR_700_transport_template;
39056fece20086ebe32bce2c0d74ceadd516b56baae<jejb@mulgrave.(none)>	host->unique_id = (unsigned long)hostdata->base;
3911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	hostdata->eh_complete = NULL;
3921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	host->hostdata[0] = (unsigned long)hostdata;
3931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	/* kick the chip */
3941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	NCR_700_writeb(0xff, host, CTEST9_REG);
3951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	if(hostdata->chip710)
3961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		hostdata->rev = (NCR_700_readb(host, CTEST8_REG)>>4) & 0x0f;
3971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	else
3981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		hostdata->rev = (NCR_700_readb(host, CTEST7_REG)>>4) & 0x0f;
3991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	hostdata->fast = (NCR_700_readb(host, CTEST9_REG) == 0);
4001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	if(banner == 0) {
4011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		printk(KERN_NOTICE "53c700: Version " NCR_700_VERSION " By James.Bottomley@HansenPartnership.com\n");
4021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		banner = 1;
4031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	}
4041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	printk(KERN_NOTICE "scsi%d: %s rev %d %s\n", host->host_no,
4051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	       hostdata->chip710 ? "53c710" :
4061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	       (hostdata->fast ? "53c700-66" : "53c700"),
4071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	       hostdata->rev, hostdata->differential ?
4081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	       "(Differential)" : "");
4091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	/* reset the chip */
4101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	NCR_700_chip_reset(host);
4111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
4121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	if (scsi_add_host(host, dev)) {
4131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		dev_printk(KERN_ERR, dev, "53c700: scsi_add_host failed\n");
4141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		scsi_host_put(host);
4151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		return NULL;
4161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	}
4171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
4181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	spi_signalling(host) = hostdata->differential ? SPI_SIGNAL_HVD :
4191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		SPI_SIGNAL_SE;
4201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
4211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	return host;
4221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds}
4231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
4241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsint
4251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsNCR_700_release(struct Scsi_Host *host)
4261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{
4271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	struct NCR_700_Host_Parameters *hostdata =
4281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		(struct NCR_700_Host_Parameters *)host->hostdata[0];
4291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
4301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	dma_free_noncoherent(hostdata->dev, TOTAL_MEM_SIZE,
4311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			       hostdata->script, hostdata->pScript);
4321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	return 1;
4331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds}
4341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
4351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic inline __u8
4361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsNCR_700_identify(int can_disconnect, __u8 lun)
4371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{
4381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	return IDENTIFY_BASE |
4391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		((can_disconnect) ? 0x40 : 0) |
4401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		(lun & NCR_700_LUN_MASK);
4411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds}
4421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
4431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/*
4441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Function : static int data_residual (Scsi_Host *host)
4451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds *
4461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Purpose : return residual data count of what's in the chip.  If you
4471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * really want to know what this function is doing, it's almost a
4481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * direct transcription of the algorithm described in the 53c710
4491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * guide, except that the DBC and DFIFO registers are only 6 bits
4501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * wide on a 53c700.
4511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds *
4521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Inputs : host - SCSI host */
4531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic inline int
4541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsNCR_700_data_residual (struct Scsi_Host *host) {
4551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	struct NCR_700_Host_Parameters *hostdata =
4561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		(struct NCR_700_Host_Parameters *)host->hostdata[0];
4571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	int count, synchronous = 0;
4581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	unsigned int ddir;
4591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
4601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	if(hostdata->chip710) {
4611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		count = ((NCR_700_readb(host, DFIFO_REG) & 0x7f) -
4621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			 (NCR_700_readl(host, DBC_REG) & 0x7f)) & 0x7f;
4631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	} else {
4641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		count = ((NCR_700_readb(host, DFIFO_REG) & 0x3f) -
4651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			 (NCR_700_readl(host, DBC_REG) & 0x3f)) & 0x3f;
4661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	}
4671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
4681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	if(hostdata->fast)
4691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		synchronous = NCR_700_readb(host, SXFER_REG) & 0x0f;
4701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
4711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	/* get the data direction */
4721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	ddir = NCR_700_readb(host, CTEST0_REG) & 0x01;
4731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
4741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	if (ddir) {
4751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		/* Receive */
4761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		if (synchronous)
4771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			count += (NCR_700_readb(host, SSTAT2_REG) & 0xf0) >> 4;
4781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		else
4791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			if (NCR_700_readb(host, SSTAT1_REG) & SIDL_REG_FULL)
4801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				++count;
4811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	} else {
4821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		/* Send */
4831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		__u8 sstat = NCR_700_readb(host, SSTAT1_REG);
4841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		if (sstat & SODL_REG_FULL)
4851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			++count;
4861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		if (synchronous && (sstat & SODR_REG_FULL))
4871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			++count;
4881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	}
4891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#ifdef NCR_700_DEBUG
4901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	if(count)
4911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		printk("RESIDUAL IS %d (ddir %d)\n", count, ddir);
4921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif
4931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	return count;
4941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds}
4951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
4961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* print out the SCSI wires and corresponding phase from the SBCL register
4971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * in the chip */
4981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic inline char *
4991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldssbcl_to_string(__u8 sbcl)
5001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{
5011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	int i;
5021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	static char ret[256];
5031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
5041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	ret[0]='\0';
5051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	for(i=0; i<8; i++) {
5061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		if((1<<i) & sbcl)
5071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			strcat(ret, NCR_700_SBCL_bits[i]);
5081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	}
5091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	strcat(ret, NCR_700_SBCL_to_phase[sbcl & 0x07]);
5101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	return ret;
5111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds}
5121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
5131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic inline __u8
5141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsbitmap_to_number(__u8 bitmap)
5151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{
5161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	__u8 i;
5171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
5181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	for(i=0; i<8 && !(bitmap &(1<<i)); i++)
5191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		;
5201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	return i;
5211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds}
5221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
5231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* Pull a slot off the free list */
5241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsSTATIC struct NCR_700_command_slot *
5251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsfind_empty_slot(struct NCR_700_Host_Parameters *hostdata)
5261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{
5271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	struct NCR_700_command_slot *slot = hostdata->free_list;
5281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
5291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	if(slot == NULL) {
5301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		/* sanity check */
5311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		if(hostdata->command_slot_count != NCR_700_COMMAND_SLOTS_PER_HOST)
5321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			printk(KERN_ERR "SLOTS FULL, but count is %d, should be %d\n", hostdata->command_slot_count, NCR_700_COMMAND_SLOTS_PER_HOST);
5331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		return NULL;
5341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	}
5351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
5361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	if(slot->state != NCR_700_SLOT_FREE)
5371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		/* should panic! */
5381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		printk(KERN_ERR "BUSY SLOT ON FREE LIST!!!\n");
5391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
5401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
5411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	hostdata->free_list = slot->ITL_forw;
5421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	slot->ITL_forw = NULL;
5431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
5441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
5451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	/* NOTE: set the state to busy here, not queued, since this
5461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	 * indicates the slot is in use and cannot be run by the IRQ
5471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	 * finish routine.  If we cannot queue the command when it
5481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	 * is properly build, we then change to NCR_700_SLOT_QUEUED */
5491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	slot->state = NCR_700_SLOT_BUSY;
5501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	hostdata->command_slot_count++;
5511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
5521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	return slot;
5531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds}
5541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
5551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsSTATIC void
5561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsfree_slot(struct NCR_700_command_slot *slot,
5571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	  struct NCR_700_Host_Parameters *hostdata)
5581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{
5591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	if((slot->state & NCR_700_SLOT_MASK) != NCR_700_SLOT_MAGIC) {
5601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		printk(KERN_ERR "53c700: SLOT %p is not MAGIC!!!\n", slot);
5611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	}
5621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	if(slot->state == NCR_700_SLOT_FREE) {
5631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		printk(KERN_ERR "53c700: SLOT %p is FREE!!!\n", slot);
5641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	}
5651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
5661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	slot->resume_offset = 0;
5671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	slot->cmnd = NULL;
5681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	slot->state = NCR_700_SLOT_FREE;
5691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	slot->ITL_forw = hostdata->free_list;
5701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	hostdata->free_list = slot;
5711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	hostdata->command_slot_count--;
5721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds}
5731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
5741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
5751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* This routine really does very little.  The command is indexed on
5761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds   the ITL and (if tagged) the ITLQ lists in _queuecommand */
5771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsSTATIC void
5781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldssave_for_reselection(struct NCR_700_Host_Parameters *hostdata,
5791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		     struct scsi_cmnd *SCp, __u32 dsp)
5801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{
5811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	/* Its just possible that this gets executed twice */
5821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	if(SCp != NULL) {
5831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		struct NCR_700_command_slot *slot =
5841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			(struct NCR_700_command_slot *)SCp->host_scribble;
5851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
5861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		slot->resume_offset = dsp;
5871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	}
5881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	hostdata->state = NCR_700_HOST_FREE;
5891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	hostdata->cmd = NULL;
5901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds}
5911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
5921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsSTATIC inline void
5931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsNCR_700_unmap(struct NCR_700_Host_Parameters *hostdata, struct scsi_cmnd *SCp,
5941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	      struct NCR_700_command_slot *slot)
5951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{
5961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	if(SCp->sc_data_direction != DMA_NONE &&
5971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	   SCp->sc_data_direction != DMA_BIDIRECTIONAL) {
5981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		if(SCp->use_sg) {
5991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			dma_unmap_sg(hostdata->dev, SCp->buffer,
6001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				     SCp->use_sg, SCp->sc_data_direction);
6011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		} else {
6021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			dma_unmap_single(hostdata->dev, slot->dma_handle,
6031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds					 SCp->request_bufflen,
6041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds					 SCp->sc_data_direction);
6051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		}
6061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	}
6071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds}
6081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
6091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsSTATIC inline void
6101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsNCR_700_scsi_done(struct NCR_700_Host_Parameters *hostdata,
6111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	       struct scsi_cmnd *SCp, int result)
6121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{
6131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	hostdata->state = NCR_700_HOST_FREE;
6141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	hostdata->cmd = NULL;
6151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
6161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	if(SCp != NULL) {
6171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		struct NCR_700_command_slot *slot =
6181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			(struct NCR_700_command_slot *)SCp->host_scribble;
6191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
6201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		NCR_700_unmap(hostdata, SCp, slot);
6211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		dma_unmap_single(hostdata->dev, slot->pCmd,
6221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				 sizeof(SCp->cmnd), DMA_TO_DEVICE);
6231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		if(SCp->cmnd[0] == REQUEST_SENSE && SCp->cmnd[6] == NCR_700_INTERNAL_SENSE_MAGIC) {
6241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#ifdef NCR_700_DEBUG
6251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			printk(" ORIGINAL CMD %p RETURNED %d, new return is %d sense is\n",
6261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			       SCp, SCp->cmnd[7], result);
6271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			scsi_print_sense("53c700", SCp);
6281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
6291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif
6301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			/* restore the old result if the request sense was
6311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			 * successful */
6321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			if(result == 0)
6331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				result = SCp->cmnd[7];
6341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			/* now restore the original command */
6351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			memcpy((void *) SCp->cmnd, (void *) SCp->data_cmnd,
6361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			       sizeof(SCp->data_cmnd));
6371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			SCp->request_buffer = SCp->buffer;
6381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			SCp->request_bufflen = SCp->bufflen;
6391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			SCp->use_sg = SCp->old_use_sg;
6401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			SCp->cmd_len = SCp->old_cmd_len;
6411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			SCp->sc_data_direction = SCp->sc_old_data_direction;
6421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			SCp->underflow = SCp->old_underflow;
6431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
6441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		}
6451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		free_slot(slot, hostdata);
6461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#ifdef NCR_700_DEBUG
6471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		if(NCR_700_get_depth(SCp->device) == 0 ||
6481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		   NCR_700_get_depth(SCp->device) > SCp->device->queue_depth)
6491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			printk(KERN_ERR "Invalid depth in NCR_700_scsi_done(): %d\n",
6501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			       NCR_700_get_depth(SCp->device));
6511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif /* NCR_700_DEBUG */
6521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		NCR_700_set_depth(SCp->device, NCR_700_get_depth(SCp->device) - 1);
6531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
6541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		SCp->host_scribble = NULL;
6551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		SCp->result = result;
6561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		SCp->scsi_done(SCp);
6571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	} else {
6581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		printk(KERN_ERR "53c700: SCSI DONE HAS NULL SCp\n");
6591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	}
6601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds}
6611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
6621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
6631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsSTATIC void
6641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsNCR_700_internal_bus_reset(struct Scsi_Host *host)
6651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{
6661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	/* Bus reset */
6671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	NCR_700_writeb(ASSERT_RST, host, SCNTL1_REG);
6681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	udelay(50);
6691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	NCR_700_writeb(0, host, SCNTL1_REG);
6701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
6711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds}
6721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
6731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsSTATIC void
6741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsNCR_700_chip_setup(struct Scsi_Host *host)
6751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{
6761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	struct NCR_700_Host_Parameters *hostdata =
6771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		(struct NCR_700_Host_Parameters *)host->hostdata[0];
6781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	__u32 dcntl_extra = 0;
6791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	__u8 min_period;
6801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	__u8 min_xferp = (hostdata->chip710 ? NCR_710_MIN_XFERP : NCR_700_MIN_XFERP);
6811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
6821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	if(hostdata->chip710) {
6831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		__u8 burst_disable = hostdata->burst_disable
6841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			? BURST_DISABLE : 0;
6851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		dcntl_extra = COMPAT_700_MODE;
6861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
6871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		NCR_700_writeb(dcntl_extra, host, DCNTL_REG);
6881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		NCR_700_writeb(BURST_LENGTH_8  | hostdata->dmode_extra,
6891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			       host, DMODE_710_REG);
6901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		NCR_700_writeb(burst_disable | (hostdata->differential ?
6911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds						DIFF : 0), host, CTEST7_REG);
6921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		NCR_700_writeb(BTB_TIMER_DISABLE, host, CTEST0_REG);
6931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		NCR_700_writeb(FULL_ARBITRATION | ENABLE_PARITY | PARITY
6941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			       | AUTO_ATN, host, SCNTL0_REG);
6951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	} else {
6961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		NCR_700_writeb(BURST_LENGTH_8 | hostdata->dmode_extra,
6971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			       host, DMODE_700_REG);
6981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		NCR_700_writeb(hostdata->differential ?
6991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			       DIFF : 0, host, CTEST7_REG);
7001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		if(hostdata->fast) {
7011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			/* this is for 700-66, does nothing on 700 */
7021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			NCR_700_writeb(LAST_DIS_ENBL | ENABLE_ACTIVE_NEGATION
7031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				       | GENERATE_RECEIVE_PARITY, host,
7041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				       CTEST8_REG);
7051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		} else {
7061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			NCR_700_writeb(FULL_ARBITRATION | ENABLE_PARITY
7071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				       | PARITY | AUTO_ATN, host, SCNTL0_REG);
7081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		}
7091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	}
7101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
7111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	NCR_700_writeb(1 << host->this_id, host, SCID_REG);
7121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	NCR_700_writeb(0, host, SBCL_REG);
7131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	NCR_700_writeb(ASYNC_OPERATION, host, SXFER_REG);
7141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
7151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	NCR_700_writeb(PHASE_MM_INT | SEL_TIMEOUT_INT | GROSS_ERR_INT | UX_DISC_INT
7161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	     | RST_INT | PAR_ERR_INT | SELECT_INT, host, SIEN_REG);
7171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
7181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	NCR_700_writeb(ABORT_INT | INT_INST_INT | ILGL_INST_INT, host, DIEN_REG);
7191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	NCR_700_writeb(ENABLE_SELECT, host, SCNTL1_REG);
7201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	if(hostdata->clock > 75) {
7211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		printk(KERN_ERR "53c700: Clock speed %dMHz is too high: 75Mhz is the maximum this chip can be driven at\n", hostdata->clock);
7221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		/* do the best we can, but the async clock will be out
7231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		 * of spec: sync divider 2, async divider 3 */
7241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		DEBUG(("53c700: sync 2 async 3\n"));
7251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		NCR_700_writeb(SYNC_DIV_2_0, host, SBCL_REG);
7261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		NCR_700_writeb(ASYNC_DIV_3_0 | dcntl_extra, host, DCNTL_REG);
7271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		hostdata->sync_clock = hostdata->clock/2;
7281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	} else	if(hostdata->clock > 50  && hostdata->clock <= 75) {
7291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		/* sync divider 1.5, async divider 3 */
7301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		DEBUG(("53c700: sync 1.5 async 3\n"));
7311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		NCR_700_writeb(SYNC_DIV_1_5, host, SBCL_REG);
7321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		NCR_700_writeb(ASYNC_DIV_3_0 | dcntl_extra, host, DCNTL_REG);
7331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		hostdata->sync_clock = hostdata->clock*2;
7341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		hostdata->sync_clock /= 3;
7351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
7361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	} else if(hostdata->clock > 37 && hostdata->clock <= 50) {
7371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		/* sync divider 1, async divider 2 */
7381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		DEBUG(("53c700: sync 1 async 2\n"));
7391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		NCR_700_writeb(SYNC_DIV_1_0, host, SBCL_REG);
7401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		NCR_700_writeb(ASYNC_DIV_2_0 | dcntl_extra, host, DCNTL_REG);
7411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		hostdata->sync_clock = hostdata->clock;
7421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	} else if(hostdata->clock > 25 && hostdata->clock <=37) {
7431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		/* sync divider 1, async divider 1.5 */
7441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		DEBUG(("53c700: sync 1 async 1.5\n"));
7451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		NCR_700_writeb(SYNC_DIV_1_0, host, SBCL_REG);
7461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		NCR_700_writeb(ASYNC_DIV_1_5 | dcntl_extra, host, DCNTL_REG);
7471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		hostdata->sync_clock = hostdata->clock;
7481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	} else {
7491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		DEBUG(("53c700: sync 1 async 1\n"));
7501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		NCR_700_writeb(SYNC_DIV_1_0, host, SBCL_REG);
7511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		NCR_700_writeb(ASYNC_DIV_1_0 | dcntl_extra, host, DCNTL_REG);
7521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		/* sync divider 1, async divider 1 */
7531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		hostdata->sync_clock = hostdata->clock;
7541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	}
7551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	/* Calculate the actual minimum period that can be supported
7561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	 * by our synchronous clock speed.  See the 710 manual for
7571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	 * exact details of this calculation which is based on a
7581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	 * setting of the SXFER register */
7591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	min_period = 1000*(4+min_xferp)/(4*hostdata->sync_clock);
7601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	hostdata->min_period = NCR_700_MIN_PERIOD;
7611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	if(min_period > NCR_700_MIN_PERIOD)
7621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		hostdata->min_period = min_period;
7631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds}
7641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
7651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsSTATIC void
7661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsNCR_700_chip_reset(struct Scsi_Host *host)
7671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{
7681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	struct NCR_700_Host_Parameters *hostdata =
7691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		(struct NCR_700_Host_Parameters *)host->hostdata[0];
7701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	if(hostdata->chip710) {
7711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		NCR_700_writeb(SOFTWARE_RESET_710, host, ISTAT_REG);
7721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		udelay(100);
7731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
7741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		NCR_700_writeb(0, host, ISTAT_REG);
7751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	} else {
7761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		NCR_700_writeb(SOFTWARE_RESET, host, DCNTL_REG);
7771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		udelay(100);
7781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
7791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		NCR_700_writeb(0, host, DCNTL_REG);
7801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	}
7811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
7821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	mdelay(1000);
7831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
7841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	NCR_700_chip_setup(host);
7851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds}
7861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
7871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* The heart of the message processing engine is that the instruction
7881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * immediately after the INT is the normal case (and so must be CLEAR
7891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * ACK).  If we want to do something else, we call that routine in
7901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * scripts and set temp to be the normal case + 8 (skipping the CLEAR
7911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * ACK) so that the routine returns correctly to resume its activity
7921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * */
7931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsSTATIC __u32
7941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsprocess_extended_message(struct Scsi_Host *host,
7951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			 struct NCR_700_Host_Parameters *hostdata,
7961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			 struct scsi_cmnd *SCp, __u32 dsp, __u32 dsps)
7971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{
7981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	__u32 resume_offset = dsp, temp = dsp + 8;
7991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	__u8 pun = 0xff, lun = 0xff;
8001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
8011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	if(SCp != NULL) {
8021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		pun = SCp->device->id;
8031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		lun = SCp->device->lun;
8041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	}
8051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
8061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	switch(hostdata->msgin[2]) {
8071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	case A_SDTR_MSG:
8081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		if(SCp != NULL && NCR_700_is_flag_set(SCp->device, NCR_700_DEV_BEGIN_SYNC_NEGOTIATION)) {
8091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			struct scsi_target *starget = SCp->device->sdev_target;
8101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			__u8 period = hostdata->msgin[3];
8111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			__u8 offset = hostdata->msgin[4];
8121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
8131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			if(offset == 0 || period == 0) {
8141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				offset = 0;
8151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				period = 0;
8161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			}
8171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
8181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			spi_offset(starget) = offset;
8191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			spi_period(starget) = period;
8201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
8211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			if(NCR_700_is_flag_set(SCp->device, NCR_700_DEV_PRINT_SYNC_NEGOTIATION)) {
8221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				spi_display_xfer_agreement(starget);
8231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				NCR_700_clear_flag(SCp->device, NCR_700_DEV_PRINT_SYNC_NEGOTIATION);
8241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			}
8251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
8261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			NCR_700_set_flag(SCp->device, NCR_700_DEV_NEGOTIATED_SYNC);
8271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			NCR_700_clear_flag(SCp->device, NCR_700_DEV_BEGIN_SYNC_NEGOTIATION);
8281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
8291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			NCR_700_writeb(NCR_700_get_SXFER(SCp->device),
8301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				       host, SXFER_REG);
8311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
8321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		} else {
8331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			/* SDTR message out of the blue, reject it */
8341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			printk(KERN_WARNING "scsi%d Unexpected SDTR msg\n",
8351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			       host->host_no);
8361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			hostdata->msgout[0] = A_REJECT_MSG;
8371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			dma_cache_sync(hostdata->msgout, 1, DMA_TO_DEVICE);
8381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			script_patch_16(hostdata->script, MessageCount, 1);
8391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			/* SendMsgOut returns, so set up the return
8401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			 * address */
8411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			resume_offset = hostdata->pScript + Ent_SendMessageWithATN;
8421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		}
8431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		break;
8441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
8451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	case A_WDTR_MSG:
8461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		printk(KERN_INFO "scsi%d: (%d:%d), Unsolicited WDTR after CMD, Rejecting\n",
8471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		       host->host_no, pun, lun);
8481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		hostdata->msgout[0] = A_REJECT_MSG;
8491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		dma_cache_sync(hostdata->msgout, 1, DMA_TO_DEVICE);
8501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		script_patch_16(hostdata->script, MessageCount, 1);
8511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		resume_offset = hostdata->pScript + Ent_SendMessageWithATN;
8521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
8531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		break;
8541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
8551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	default:
8561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		printk(KERN_INFO "scsi%d (%d:%d): Unexpected message %s: ",
8571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		       host->host_no, pun, lun,
8581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		       NCR_700_phase[(dsps & 0xf00) >> 8]);
8591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		scsi_print_msg(hostdata->msgin);
8601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		printk("\n");
8611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		/* just reject it */
8621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		hostdata->msgout[0] = A_REJECT_MSG;
8631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		dma_cache_sync(hostdata->msgout, 1, DMA_TO_DEVICE);
8641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		script_patch_16(hostdata->script, MessageCount, 1);
8651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		/* SendMsgOut returns, so set up the return
8661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		 * address */
8671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		resume_offset = hostdata->pScript + Ent_SendMessageWithATN;
8681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	}
8691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	NCR_700_writel(temp, host, TEMP_REG);
8701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	return resume_offset;
8711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds}
8721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
8731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsSTATIC __u32
8741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsprocess_message(struct Scsi_Host *host,	struct NCR_700_Host_Parameters *hostdata,
8751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		struct scsi_cmnd *SCp, __u32 dsp, __u32 dsps)
8761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{
8771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	/* work out where to return to */
8781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	__u32 temp = dsp + 8, resume_offset = dsp;
8791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	__u8 pun = 0xff, lun = 0xff;
8801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
8811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	if(SCp != NULL) {
8821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		pun = SCp->device->id;
8831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		lun = SCp->device->lun;
8841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	}
8851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
8861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#ifdef NCR_700_DEBUG
8871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	printk("scsi%d (%d:%d): message %s: ", host->host_no, pun, lun,
8881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	       NCR_700_phase[(dsps & 0xf00) >> 8]);
8891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	scsi_print_msg(hostdata->msgin);
8901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	printk("\n");
8911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif
8921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
8931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	switch(hostdata->msgin[0]) {
8941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
8951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	case A_EXTENDED_MSG:
8961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		resume_offset =  process_extended_message(host, hostdata, SCp,
8971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds							  dsp, dsps);
8981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		break;
8991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
9001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	case A_REJECT_MSG:
9011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		if(SCp != NULL && NCR_700_is_flag_set(SCp->device, NCR_700_DEV_BEGIN_SYNC_NEGOTIATION)) {
9021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			/* Rejected our sync negotiation attempt */
9031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			spi_period(SCp->device->sdev_target) =
9041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				spi_offset(SCp->device->sdev_target) = 0;
9051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			NCR_700_set_flag(SCp->device, NCR_700_DEV_NEGOTIATED_SYNC);
9061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			NCR_700_clear_flag(SCp->device, NCR_700_DEV_BEGIN_SYNC_NEGOTIATION);
9071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		} else if(SCp != NULL && NCR_700_get_tag_neg_state(SCp->device) == NCR_700_DURING_TAG_NEGOTIATION) {
9081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			/* rejected our first simple tag message */
9091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			printk(KERN_WARNING "scsi%d (%d:%d) Rejected first tag queue attempt, turning off tag queueing\n", host->host_no, pun, lun);
9101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			/* we're done negotiating */
9111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			NCR_700_set_tag_neg_state(SCp->device, NCR_700_FINISHED_TAG_NEGOTIATION);
9121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			hostdata->tag_negotiated &= ~(1<<SCp->device->id);
9131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			SCp->device->tagged_supported = 0;
9141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			scsi_deactivate_tcq(SCp->device, host->cmd_per_lun);
9151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		} else {
9161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			printk(KERN_WARNING "scsi%d (%d:%d) Unexpected REJECT Message %s\n",
9171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			       host->host_no, pun, lun,
9181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			       NCR_700_phase[(dsps & 0xf00) >> 8]);
9191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			/* however, just ignore it */
9201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		}
9211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		break;
9221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
9231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	case A_PARITY_ERROR_MSG:
9241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		printk(KERN_ERR "scsi%d (%d:%d) Parity Error!\n", host->host_no,
9251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		       pun, lun);
9261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		NCR_700_internal_bus_reset(host);
9271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		break;
9281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	case A_SIMPLE_TAG_MSG:
9291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		printk(KERN_INFO "scsi%d (%d:%d) SIMPLE TAG %d %s\n", host->host_no,
9301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		       pun, lun, hostdata->msgin[1],
9311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		       NCR_700_phase[(dsps & 0xf00) >> 8]);
9321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		/* just ignore it */
9331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		break;
9341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	default:
9351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		printk(KERN_INFO "scsi%d (%d:%d): Unexpected message %s: ",
9361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		       host->host_no, pun, lun,
9371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		       NCR_700_phase[(dsps & 0xf00) >> 8]);
9381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
9391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		scsi_print_msg(hostdata->msgin);
9401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		printk("\n");
9411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		/* just reject it */
9421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		hostdata->msgout[0] = A_REJECT_MSG;
9431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		dma_cache_sync(hostdata->msgout, 1, DMA_TO_DEVICE);
9441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		script_patch_16(hostdata->script, MessageCount, 1);
9451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		/* SendMsgOut returns, so set up the return
9461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		 * address */
9471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		resume_offset = hostdata->pScript + Ent_SendMessageWithATN;
9481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
9491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		break;
9501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	}
9511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	NCR_700_writel(temp, host, TEMP_REG);
9521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	/* set us up to receive another message */
9531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	dma_cache_sync(hostdata->msgin, MSG_ARRAY_SIZE, DMA_FROM_DEVICE);
9541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	return resume_offset;
9551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds}
9561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
9571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsSTATIC __u32
9581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsprocess_script_interrupt(__u32 dsps, __u32 dsp, struct scsi_cmnd *SCp,
9591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			 struct Scsi_Host *host,
9601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			 struct NCR_700_Host_Parameters *hostdata)
9611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{
9621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	__u32 resume_offset = 0;
9631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	__u8 pun = 0xff, lun=0xff;
9641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
9651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	if(SCp != NULL) {
9661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		pun = SCp->device->id;
9671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		lun = SCp->device->lun;
9681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	}
9691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
9701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	if(dsps == A_GOOD_STATUS_AFTER_STATUS) {
9711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		DEBUG(("  COMMAND COMPLETE, status=%02x\n",
9721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		       hostdata->status[0]));
9731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		/* OK, if TCQ still under negotiation, we now know it works */
9741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		if (NCR_700_get_tag_neg_state(SCp->device) == NCR_700_DURING_TAG_NEGOTIATION)
9751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			NCR_700_set_tag_neg_state(SCp->device,
9761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds						  NCR_700_FINISHED_TAG_NEGOTIATION);
9771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
9781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		/* check for contingent allegiance contitions */
9791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		if(status_byte(hostdata->status[0]) == CHECK_CONDITION ||
9801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		   status_byte(hostdata->status[0]) == COMMAND_TERMINATED) {
9811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			struct NCR_700_command_slot *slot =
9821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				(struct NCR_700_command_slot *)SCp->host_scribble;
9831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			if(SCp->cmnd[0] == REQUEST_SENSE) {
9841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				/* OOPS: bad device, returning another
9851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				 * contingent allegiance condition */
9861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				printk(KERN_ERR "scsi%d (%d:%d) broken device is looping in contingent allegiance: ignoring\n", host->host_no, pun, lun);
9871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				NCR_700_scsi_done(hostdata, SCp, hostdata->status[0]);
9881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			} else {
9891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#ifdef NCR_DEBUG
9901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				scsi_print_command(SCp);
9911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				printk("  cmd %p has status %d, requesting sense\n",
9921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				       SCp, hostdata->status[0]);
9931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif
9941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				/* we can destroy the command here
9951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				 * because the contingent allegiance
9961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				 * condition will cause a retry which
9971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				 * will re-copy the command from the
9981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				 * saved data_cmnd.  We also unmap any
9991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				 * data associated with the command
10001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				 * here */
10011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				NCR_700_unmap(hostdata, SCp, slot);
10021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
10031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				SCp->cmnd[0] = REQUEST_SENSE;
10041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				SCp->cmnd[1] = (SCp->device->lun & 0x7) << 5;
10051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				SCp->cmnd[2] = 0;
10061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				SCp->cmnd[3] = 0;
10071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				SCp->cmnd[4] = sizeof(SCp->sense_buffer);
10081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				SCp->cmnd[5] = 0;
10091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				SCp->cmd_len = 6;
10101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				/* Here's a quiet hack: the
10111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				 * REQUEST_SENSE command is six bytes,
10121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				 * so store a flag indicating that
10131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				 * this was an internal sense request
10141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				 * and the original status at the end
10151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				 * of the command */
10161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				SCp->cmnd[6] = NCR_700_INTERNAL_SENSE_MAGIC;
10171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				SCp->cmnd[7] = hostdata->status[0];
10181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				SCp->use_sg = 0;
10191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				SCp->sc_data_direction = DMA_FROM_DEVICE;
10201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				dma_sync_single_for_device(hostdata->dev, slot->pCmd,
10211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds							   SCp->cmd_len, DMA_TO_DEVICE);
10221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				SCp->request_bufflen = sizeof(SCp->sense_buffer);
10231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				slot->dma_handle = dma_map_single(hostdata->dev, SCp->sense_buffer, sizeof(SCp->sense_buffer), DMA_FROM_DEVICE);
10241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				slot->SG[0].ins = bS_to_host(SCRIPT_MOVE_DATA_IN | sizeof(SCp->sense_buffer));
10251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				slot->SG[0].pAddr = bS_to_host(slot->dma_handle);
10261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				slot->SG[1].ins = bS_to_host(SCRIPT_RETURN);
10271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				slot->SG[1].pAddr = 0;
10281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				slot->resume_offset = hostdata->pScript;
10291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				dma_cache_sync(slot->SG, sizeof(slot->SG[0])*2, DMA_TO_DEVICE);
10301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				dma_cache_sync(SCp->sense_buffer, sizeof(SCp->sense_buffer), DMA_FROM_DEVICE);
10311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
10321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				/* queue the command for reissue */
10331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				slot->state = NCR_700_SLOT_QUEUED;
10341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				hostdata->state = NCR_700_HOST_FREE;
10351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				hostdata->cmd = NULL;
10361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			}
10371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		} else {
10381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			// Currently rely on the mid layer evaluation
10391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			// of the tag queuing capability
10401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			//
10411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			//if(status_byte(hostdata->status[0]) == GOOD &&
10421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			//   SCp->cmnd[0] == INQUIRY && SCp->use_sg == 0) {
10431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			//	/* Piggy back the tag queueing support
10441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			//	 * on this command */
10451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			//	dma_sync_single_for_cpu(hostdata->dev,
10461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			//			    slot->dma_handle,
10471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			//			    SCp->request_bufflen,
10481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			//			    DMA_FROM_DEVICE);
10491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			//	if(((char *)SCp->request_buffer)[7] & 0x02) {
10501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			//		printk(KERN_INFO "scsi%d: (%d:%d) Enabling Tag Command Queuing\n", host->host_no, pun, lun);
10511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			//		hostdata->tag_negotiated |= (1<<SCp->device->id);
10521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			//		NCR_700_set_flag(SCp->device, NCR_700_DEV_BEGIN_TAG_QUEUEING);
10531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			//	} else {
10541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			//		NCR_700_clear_flag(SCp->device, NCR_700_DEV_BEGIN_TAG_QUEUEING);
10551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			//		hostdata->tag_negotiated &= ~(1<<SCp->device->id);
10561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			//	}
10571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			//}
10581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			NCR_700_scsi_done(hostdata, SCp, hostdata->status[0]);
10591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		}
10601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	} else if((dsps & 0xfffff0f0) == A_UNEXPECTED_PHASE) {
10611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		__u8 i = (dsps & 0xf00) >> 8;
10621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
10631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		printk(KERN_ERR "scsi%d: (%d:%d), UNEXPECTED PHASE %s (%s)\n",
10641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		       host->host_no, pun, lun,
10651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		       NCR_700_phase[i],
10661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		       sbcl_to_string(NCR_700_readb(host, SBCL_REG)));
10671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		printk(KERN_ERR "         len = %d, cmd =", SCp->cmd_len);
10681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		scsi_print_command(SCp);
10691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
10701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		NCR_700_internal_bus_reset(host);
10711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	} else if((dsps & 0xfffff000) == A_FATAL) {
10721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		int i = (dsps & 0xfff);
10731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
10741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		printk(KERN_ERR "scsi%d: (%d:%d) FATAL ERROR: %s\n",
10751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		       host->host_no, pun, lun, NCR_700_fatal_messages[i]);
10761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		if(dsps == A_FATAL_ILLEGAL_MSG_LENGTH) {
10771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			printk(KERN_ERR "     msg begins %02x %02x\n",
10781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			       hostdata->msgin[0], hostdata->msgin[1]);
10791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		}
10801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		NCR_700_internal_bus_reset(host);
10811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	} else if((dsps & 0xfffff0f0) == A_DISCONNECT) {
10821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#ifdef NCR_700_DEBUG
10831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		__u8 i = (dsps & 0xf00) >> 8;
10841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
10851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		printk("scsi%d: (%d:%d), DISCONNECTED (%d) %s\n",
10861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		       host->host_no, pun, lun,
10871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		       i, NCR_700_phase[i]);
10881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif
10891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		save_for_reselection(hostdata, SCp, dsp);
10901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
10911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	} else if(dsps == A_RESELECTION_IDENTIFIED) {
10921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		__u8 lun;
10931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		struct NCR_700_command_slot *slot;
10941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		__u8 reselection_id = hostdata->reselection_id;
10951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		struct scsi_device *SDp;
10961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
10971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		lun = hostdata->msgin[0] & 0x1f;
10981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
10991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		hostdata->reselection_id = 0xff;
11001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		DEBUG(("scsi%d: (%d:%d) RESELECTED!\n",
11011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		       host->host_no, reselection_id, lun));
11021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		/* clear the reselection indicator */
11031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		SDp = __scsi_device_lookup(host, 0, reselection_id, lun);
11041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		if(unlikely(SDp == NULL)) {
11051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			printk(KERN_ERR "scsi%d: (%d:%d) HAS NO device\n",
11061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			       host->host_no, reselection_id, lun);
11071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			BUG();
11081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		}
11091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		if(hostdata->msgin[1] == A_SIMPLE_TAG_MSG) {
11101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			struct scsi_cmnd *SCp = scsi_find_tag(SDp, hostdata->msgin[2]);
11111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			if(unlikely(SCp == NULL)) {
11121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				printk(KERN_ERR "scsi%d: (%d:%d) no saved request for tag %d\n",
11131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				       host->host_no, reselection_id, lun, hostdata->msgin[2]);
11141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				BUG();
11151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			}
11161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
11171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			slot = (struct NCR_700_command_slot *)SCp->host_scribble;
11181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			DEBUG(("53c700: %d:%d:%d, reselection is tag %d, slot %p(%d)\n",
11191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			       host->host_no, SDp->id, SDp->lun,
11201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			       hostdata->msgin[2], slot, slot->tag));
11211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		} else {
11221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			struct scsi_cmnd *SCp = scsi_find_tag(SDp, SCSI_NO_TAG);
11231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			if(unlikely(SCp == NULL)) {
11241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				printk(KERN_ERR "scsi%d: (%d:%d) no saved request for untagged cmd\n",
11251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				       host->host_no, reselection_id, lun);
11261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				BUG();
11271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			}
11281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			slot = (struct NCR_700_command_slot *)SCp->host_scribble;
11291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		}
11301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
11311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		if(slot == NULL) {
11321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			printk(KERN_ERR "scsi%d: (%d:%d) RESELECTED but no saved command (MSG = %02x %02x %02x)!!\n",
11331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			       host->host_no, reselection_id, lun,
11341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			       hostdata->msgin[0], hostdata->msgin[1],
11351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			       hostdata->msgin[2]);
11361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		} else {
11371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			if(hostdata->state != NCR_700_HOST_BUSY)
11381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				printk(KERN_ERR "scsi%d: FATAL, host not busy during valid reselection!\n",
11391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				       host->host_no);
11401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			resume_offset = slot->resume_offset;
11411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			hostdata->cmd = slot->cmnd;
11421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
11431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			/* re-patch for this command */
11441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			script_patch_32_abs(hostdata->script, CommandAddress,
11451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds					    slot->pCmd);
11461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			script_patch_16(hostdata->script,
11471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds					CommandCount, slot->cmnd->cmd_len);
11481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			script_patch_32_abs(hostdata->script, SGScriptStartAddress,
11491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds					    to32bit(&slot->pSG[0].ins));
11501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
11511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			/* Note: setting SXFER only works if we're
11521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			 * still in the MESSAGE phase, so it is vital
11531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			 * that ACK is still asserted when we process
11541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			 * the reselection message.  The resume offset
11551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			 * should therefore always clear ACK */
11561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			NCR_700_writeb(NCR_700_get_SXFER(hostdata->cmd->device),
11571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				       host, SXFER_REG);
11581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			dma_cache_sync(hostdata->msgin,
11591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				       MSG_ARRAY_SIZE, DMA_FROM_DEVICE);
11601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			dma_cache_sync(hostdata->msgout,
11611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				       MSG_ARRAY_SIZE, DMA_TO_DEVICE);
11621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			/* I'm just being paranoid here, the command should
11631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			 * already have been flushed from the cache */
11641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			dma_cache_sync(slot->cmnd->cmnd,
11651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				       slot->cmnd->cmd_len, DMA_TO_DEVICE);
11661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
11671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
11681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
11691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		}
11701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	} else if(dsps == A_RESELECTED_DURING_SELECTION) {
11711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
11721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		/* This section is full of debugging code because I've
11731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		 * never managed to reach it.  I think what happens is
11741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		 * that, because the 700 runs with selection
11751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		 * interrupts enabled the whole time that we take a
11761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		 * selection interrupt before we manage to get to the
11771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		 * reselected script interrupt */
11781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
11791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		__u8 reselection_id = NCR_700_readb(host, SFBR_REG);
11801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		struct NCR_700_command_slot *slot;
11811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
11821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		/* Take out our own ID */
11831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		reselection_id &= ~(1<<host->this_id);
11841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
11851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		/* I've never seen this happen, so keep this as a printk rather
11861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		 * than a debug */
11871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		printk(KERN_INFO "scsi%d: (%d:%d) RESELECTION DURING SELECTION, dsp=%08x[%04x] state=%d, count=%d\n",
11881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		       host->host_no, reselection_id, lun, dsp, dsp - hostdata->pScript, hostdata->state, hostdata->command_slot_count);
11891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
11901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		{
11911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			/* FIXME: DEBUGGING CODE */
11921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			__u32 SG = (__u32)bS_to_cpu(hostdata->script[A_SGScriptStartAddress_used[0]]);
11931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			int i;
11941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
11951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			for(i=0; i< NCR_700_COMMAND_SLOTS_PER_HOST; i++) {
11961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				if(SG >= to32bit(&hostdata->slots[i].pSG[0])
11971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				   && SG <= to32bit(&hostdata->slots[i].pSG[NCR_700_SG_SEGMENTS]))
11981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds					break;
11991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			}
12001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			printk(KERN_INFO "IDENTIFIED SG segment as being %08x in slot %p, cmd %p, slot->resume_offset=%08x\n", SG, &hostdata->slots[i], hostdata->slots[i].cmnd, hostdata->slots[i].resume_offset);
12011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			SCp =  hostdata->slots[i].cmnd;
12021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		}
12031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
12041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		if(SCp != NULL) {
12051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			slot = (struct NCR_700_command_slot *)SCp->host_scribble;
12061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			/* change slot from busy to queued to redo command */
12071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			slot->state = NCR_700_SLOT_QUEUED;
12081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		}
12091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		hostdata->cmd = NULL;
12101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
12111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		if(reselection_id == 0) {
12121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			if(hostdata->reselection_id == 0xff) {
12131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				printk(KERN_ERR "scsi%d: Invalid reselection during selection!!\n", host->host_no);
12141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				return 0;
12151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			} else {
12161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				printk(KERN_ERR "scsi%d: script reselected and we took a selection interrupt\n",
12171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				       host->host_no);
12181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				reselection_id = hostdata->reselection_id;
12191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			}
12201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		} else {
12211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
12221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			/* convert to real ID */
12231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			reselection_id = bitmap_to_number(reselection_id);
12241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		}
12251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		hostdata->reselection_id = reselection_id;
12261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		/* just in case we have a stale simple tag message, clear it */
12271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		hostdata->msgin[1] = 0;
12281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		dma_cache_sync(hostdata->msgin,
12291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			       MSG_ARRAY_SIZE, DMA_BIDIRECTIONAL);
12301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		if(hostdata->tag_negotiated & (1<<reselection_id)) {
12311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			resume_offset = hostdata->pScript + Ent_GetReselectionWithTag;
12321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		} else {
12331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			resume_offset = hostdata->pScript + Ent_GetReselectionData;
12341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		}
12351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	} else if(dsps == A_COMPLETED_SELECTION_AS_TARGET) {
12361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		/* we've just disconnected from the bus, do nothing since
12371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		 * a return here will re-run the queued command slot
12381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		 * that may have been interrupted by the initial selection */
12391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		DEBUG((" SELECTION COMPLETED\n"));
12401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	} else if((dsps & 0xfffff0f0) == A_MSG_IN) {
12411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		resume_offset = process_message(host, hostdata, SCp,
12421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds						dsp, dsps);
12431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	} else if((dsps &  0xfffff000) == 0) {
12441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		__u8 i = (dsps & 0xf0) >> 4, j = (dsps & 0xf00) >> 8;
12451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		printk(KERN_ERR "scsi%d: (%d:%d), unhandled script condition %s %s at %04x\n",
12461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		       host->host_no, pun, lun, NCR_700_condition[i],
12471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		       NCR_700_phase[j], dsp - hostdata->pScript);
12481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		if(SCp != NULL) {
12491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			scsi_print_command(SCp);
12501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
12511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			if(SCp->use_sg) {
12521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				for(i = 0; i < SCp->use_sg + 1; i++) {
12531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds					printk(KERN_INFO " SG[%d].length = %d, move_insn=%08x, addr %08x\n", i, ((struct scatterlist *)SCp->buffer)[i].length, ((struct NCR_700_command_slot *)SCp->host_scribble)->SG[i].ins, ((struct NCR_700_command_slot *)SCp->host_scribble)->SG[i].pAddr);
12541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				}
12551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			}
12561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		}
12571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		NCR_700_internal_bus_reset(host);
12581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	} else if((dsps & 0xfffff000) == A_DEBUG_INTERRUPT) {
12591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		printk(KERN_NOTICE "scsi%d (%d:%d) DEBUG INTERRUPT %d AT %08x[%04x], continuing\n",
12601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		       host->host_no, pun, lun, dsps & 0xfff, dsp, dsp - hostdata->pScript);
12611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		resume_offset = dsp;
12621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	} else {
12631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		printk(KERN_ERR "scsi%d: (%d:%d), unidentified script interrupt 0x%x at %04x\n",
12641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		       host->host_no, pun, lun, dsps, dsp - hostdata->pScript);
12651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		NCR_700_internal_bus_reset(host);
12661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	}
12671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	return resume_offset;
12681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds}
12691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
12701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* We run the 53c700 with selection interrupts always enabled.  This
12711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * means that the chip may be selected as soon as the bus frees.  On a
12721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * busy bus, this can be before the scripts engine finishes its
12731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * processing.  Therefore, part of the selection processing has to be
12741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * to find out what the scripts engine is doing and complete the
12751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * function if necessary (i.e. process the pending disconnect or save
12761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * the interrupted initial selection */
12771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsSTATIC inline __u32
12781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsprocess_selection(struct Scsi_Host *host, __u32 dsp)
12791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{
12801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	__u8 id = 0;	/* Squash compiler warning */
12811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	int count = 0;
12821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	__u32 resume_offset = 0;
12831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	struct NCR_700_Host_Parameters *hostdata =
12841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		(struct NCR_700_Host_Parameters *)host->hostdata[0];
12851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	struct scsi_cmnd *SCp = hostdata->cmd;
12861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	__u8 sbcl;
12871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
12881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	for(count = 0; count < 5; count++) {
12891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		id = NCR_700_readb(host, hostdata->chip710 ?
12901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				   CTEST9_REG : SFBR_REG);
12911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
12921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		/* Take out our own ID */
12931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		id &= ~(1<<host->this_id);
12941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		if(id != 0)
12951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			break;
12961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		udelay(5);
12971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	}
12981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	sbcl = NCR_700_readb(host, SBCL_REG);
12991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	if((sbcl & SBCL_IO) == 0) {
13001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		/* mark as having been selected rather than reselected */
13011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		id = 0xff;
13021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	} else {
13031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		/* convert to real ID */
13041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		hostdata->reselection_id = id = bitmap_to_number(id);
13051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		DEBUG(("scsi%d:  Reselected by %d\n",
13061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		       host->host_no, id));
13071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	}
13081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	if(hostdata->state == NCR_700_HOST_BUSY && SCp != NULL) {
13091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		struct NCR_700_command_slot *slot =
13101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			(struct NCR_700_command_slot *)SCp->host_scribble;
13111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		DEBUG(("  ID %d WARNING: RESELECTION OF BUSY HOST, saving cmd %p, slot %p, addr %x [%04x], resume %x!\n", id, hostdata->cmd, slot, dsp, dsp - hostdata->pScript, resume_offset));
13121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
13131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		switch(dsp - hostdata->pScript) {
13141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		case Ent_Disconnect1:
13151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		case Ent_Disconnect2:
13161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			save_for_reselection(hostdata, SCp, Ent_Disconnect2 + hostdata->pScript);
13171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			break;
13181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		case Ent_Disconnect3:
13191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		case Ent_Disconnect4:
13201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			save_for_reselection(hostdata, SCp, Ent_Disconnect4 + hostdata->pScript);
13211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			break;
13221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		case Ent_Disconnect5:
13231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		case Ent_Disconnect6:
13241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			save_for_reselection(hostdata, SCp, Ent_Disconnect6 + hostdata->pScript);
13251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			break;
13261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		case Ent_Disconnect7:
13271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		case Ent_Disconnect8:
13281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			save_for_reselection(hostdata, SCp, Ent_Disconnect8 + hostdata->pScript);
13291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			break;
13301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		case Ent_Finish1:
13311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		case Ent_Finish2:
13321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			process_script_interrupt(A_GOOD_STATUS_AFTER_STATUS, dsp, SCp, host, hostdata);
13331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			break;
13341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
13351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		default:
13361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			slot->state = NCR_700_SLOT_QUEUED;
13371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			break;
13381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			}
13391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	}
13401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	hostdata->state = NCR_700_HOST_BUSY;
13411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	hostdata->cmd = NULL;
13421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	/* clear any stale simple tag message */
13431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	hostdata->msgin[1] = 0;
13441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	dma_cache_sync(hostdata->msgin, MSG_ARRAY_SIZE,
13451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		       DMA_BIDIRECTIONAL);
13461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
13471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	if(id == 0xff) {
13481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		/* Selected as target, Ignore */
13491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		resume_offset = hostdata->pScript + Ent_SelectedAsTarget;
13501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	} else if(hostdata->tag_negotiated & (1<<id)) {
13511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		resume_offset = hostdata->pScript + Ent_GetReselectionWithTag;
13521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	} else {
13531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		resume_offset = hostdata->pScript + Ent_GetReselectionData;
13541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	}
13551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	return resume_offset;
13561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds}
13571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
13581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic inline void
13591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsNCR_700_clear_fifo(struct Scsi_Host *host) {
13601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	const struct NCR_700_Host_Parameters *hostdata
13611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		= (struct NCR_700_Host_Parameters *)host->hostdata[0];
13621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	if(hostdata->chip710) {
13631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		NCR_700_writeb(CLR_FIFO_710, host, CTEST8_REG);
13641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	} else {
13651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		NCR_700_writeb(CLR_FIFO, host, DFIFO_REG);
13661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	}
13671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds}
13681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
13691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic inline void
13701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsNCR_700_flush_fifo(struct Scsi_Host *host) {
13711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	const struct NCR_700_Host_Parameters *hostdata
13721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		= (struct NCR_700_Host_Parameters *)host->hostdata[0];
13731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	if(hostdata->chip710) {
13741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		NCR_700_writeb(FLUSH_DMA_FIFO_710, host, CTEST8_REG);
13751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		udelay(10);
13761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		NCR_700_writeb(0, host, CTEST8_REG);
13771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	} else {
13781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		NCR_700_writeb(FLUSH_DMA_FIFO, host, DFIFO_REG);
13791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		udelay(10);
13801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		NCR_700_writeb(0, host, DFIFO_REG);
13811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	}
13821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds}
13831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
13841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
13851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* The queue lock with interrupts disabled must be held on entry to
13861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * this function */
13871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsSTATIC int
13881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsNCR_700_start_command(struct scsi_cmnd *SCp)
13891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{
13901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	struct NCR_700_command_slot *slot =
13911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		(struct NCR_700_command_slot *)SCp->host_scribble;
13921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	struct NCR_700_Host_Parameters *hostdata =
13931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		(struct NCR_700_Host_Parameters *)SCp->device->host->hostdata[0];
13941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	__u16 count = 1;	/* for IDENTIFY message */
13951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
13961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	if(hostdata->state != NCR_700_HOST_FREE) {
13971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		/* keep this inside the lock to close the race window where
13981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		 * the running command finishes on another CPU while we don't
13991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		 * change the state to queued on this one */
14001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		slot->state = NCR_700_SLOT_QUEUED;
14011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
14021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		DEBUG(("scsi%d: host busy, queueing command %p, slot %p\n",
14031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		       SCp->device->host->host_no, slot->cmnd, slot));
14041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		return 0;
14051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	}
14061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	hostdata->state = NCR_700_HOST_BUSY;
14071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	hostdata->cmd = SCp;
14081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	slot->state = NCR_700_SLOT_BUSY;
14091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	/* keep interrupts disabled until we have the command correctly
14101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	 * set up so we cannot take a selection interrupt */
14111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
14121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	hostdata->msgout[0] = NCR_700_identify(SCp->cmnd[0] != REQUEST_SENSE,
14131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds					       SCp->device->lun);
14141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	/* for INQUIRY or REQUEST_SENSE commands, we cannot be sure
14151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	 * if the negotiated transfer parameters still hold, so
14161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	 * always renegotiate them */
14171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	if(SCp->cmnd[0] == INQUIRY || SCp->cmnd[0] == REQUEST_SENSE) {
14181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		NCR_700_clear_flag(SCp->device, NCR_700_DEV_NEGOTIATED_SYNC);
14191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	}
14201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
14211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	/* REQUEST_SENSE is asking for contingent I_T_L(_Q) status.
14221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	 * If a contingent allegiance condition exists, the device
14231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	 * will refuse all tags, so send the request sense as untagged
14241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	 * */
14251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	if((hostdata->tag_negotiated & (1<<SCp->device->id))
14261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	   && (slot->tag != SCSI_NO_TAG && SCp->cmnd[0] != REQUEST_SENSE)) {
14271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		count += scsi_populate_tag_msg(SCp, &hostdata->msgout[count]);
14281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	}
14291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
14301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	if(hostdata->fast &&
14311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	   NCR_700_is_flag_clear(SCp->device, NCR_700_DEV_NEGOTIATED_SYNC)) {
14321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		memcpy(&hostdata->msgout[count], NCR_700_SDTR_msg,
14331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		       sizeof(NCR_700_SDTR_msg));
14341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		hostdata->msgout[count+3] = spi_period(SCp->device->sdev_target);
14351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		hostdata->msgout[count+4] = spi_offset(SCp->device->sdev_target);
14361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		count += sizeof(NCR_700_SDTR_msg);
14371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		NCR_700_set_flag(SCp->device, NCR_700_DEV_BEGIN_SYNC_NEGOTIATION);
14381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	}
14391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
14401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	script_patch_16(hostdata->script, MessageCount, count);
14411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
14421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
14431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	script_patch_ID(hostdata->script,
14441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			Device_ID, 1<<SCp->device->id);
14451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
14461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	script_patch_32_abs(hostdata->script, CommandAddress,
14471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			    slot->pCmd);
14481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	script_patch_16(hostdata->script, CommandCount, SCp->cmd_len);
14491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	/* finally plumb the beginning of the SG list into the script
14501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	 * */
14511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	script_patch_32_abs(hostdata->script, SGScriptStartAddress,
14521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			    to32bit(&slot->pSG[0].ins));
14531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	NCR_700_clear_fifo(SCp->device->host);
14541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
14551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	if(slot->resume_offset == 0)
14561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		slot->resume_offset = hostdata->pScript;
14571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	/* now perform all the writebacks and invalidates */
14581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	dma_cache_sync(hostdata->msgout, count, DMA_TO_DEVICE);
14591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	dma_cache_sync(hostdata->msgin, MSG_ARRAY_SIZE,
14601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		       DMA_FROM_DEVICE);
14611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	dma_cache_sync(SCp->cmnd, SCp->cmd_len, DMA_TO_DEVICE);
14621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	dma_cache_sync(hostdata->status, 1, DMA_FROM_DEVICE);
14631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
14641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	/* set the synchronous period/offset */
14651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	NCR_700_writeb(NCR_700_get_SXFER(SCp->device),
14661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		       SCp->device->host, SXFER_REG);
14671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	NCR_700_writel(slot->temp, SCp->device->host, TEMP_REG);
14681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	NCR_700_writel(slot->resume_offset, SCp->device->host, DSP_REG);
14691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
14701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	return 1;
14711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds}
14721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
14731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsirqreturn_t
14741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsNCR_700_intr(int irq, void *dev_id, struct pt_regs *regs)
14751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{
14761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	struct Scsi_Host *host = (struct Scsi_Host *)dev_id;
14771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	struct NCR_700_Host_Parameters *hostdata =
14781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		(struct NCR_700_Host_Parameters *)host->hostdata[0];
14791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	__u8 istat;
14801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	__u32 resume_offset = 0;
14811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	__u8 pun = 0xff, lun = 0xff;
14821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	unsigned long flags;
14831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	int handled = 0;
14841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
14851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	/* Use the host lock to serialise acess to the 53c700
14861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	 * hardware.  Note: In future, we may need to take the queue
14871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	 * lock to enter the done routines.  When that happens, we
14881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	 * need to ensure that for this driver, the host lock and the
14891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	 * queue lock point to the same thing. */
14901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	spin_lock_irqsave(host->host_lock, flags);
14911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	if((istat = NCR_700_readb(host, ISTAT_REG))
14921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	      & (SCSI_INT_PENDING | DMA_INT_PENDING)) {
14931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		__u32 dsps;
14941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		__u8 sstat0 = 0, dstat = 0;
14951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		__u32 dsp;
14961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		struct scsi_cmnd *SCp = hostdata->cmd;
14971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		enum NCR_700_Host_State state;
14981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
14991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		handled = 1;
15001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		state = hostdata->state;
15011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		SCp = hostdata->cmd;
15021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
15031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		if(istat & SCSI_INT_PENDING) {
15041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			udelay(10);
15051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
15061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			sstat0 = NCR_700_readb(host, SSTAT0_REG);
15071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		}
15081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
15091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		if(istat & DMA_INT_PENDING) {
15101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			udelay(10);
15111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
15121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			dstat = NCR_700_readb(host, DSTAT_REG);
15131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		}
15141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
15151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		dsps = NCR_700_readl(host, DSPS_REG);
15161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		dsp = NCR_700_readl(host, DSP_REG);
15171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
15181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		DEBUG(("scsi%d: istat %02x sstat0 %02x dstat %02x dsp %04x[%08x] dsps 0x%x\n",
15191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		       host->host_no, istat, sstat0, dstat,
15201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		       (dsp - (__u32)(hostdata->pScript))/4,
15211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		       dsp, dsps));
15221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
15231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		if(SCp != NULL) {
15241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			pun = SCp->device->id;
15251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			lun = SCp->device->lun;
15261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		}
15271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
15281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		if(sstat0 & SCSI_RESET_DETECTED) {
15291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			struct scsi_device *SDp;
15301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			int i;
15311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
15321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			hostdata->state = NCR_700_HOST_BUSY;
15331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
15341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			printk(KERN_ERR "scsi%d: Bus Reset detected, executing command %p, slot %p, dsp %08x[%04x]\n",
15351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			       host->host_no, SCp, SCp == NULL ? NULL : SCp->host_scribble, dsp, dsp - hostdata->pScript);
15361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
15371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			scsi_report_bus_reset(host, 0);
15381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
15391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			/* clear all the negotiated parameters */
15401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			__shost_for_each_device(SDp, host)
15411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				SDp->hostdata = NULL;
15421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
15431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			/* clear all the slots and their pending commands */
15441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			for(i = 0; i < NCR_700_COMMAND_SLOTS_PER_HOST; i++) {
15451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				struct scsi_cmnd *SCp;
15461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				struct NCR_700_command_slot *slot =
15471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds					&hostdata->slots[i];
15481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
15491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				if(slot->state == NCR_700_SLOT_FREE)
15501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds					continue;
15511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
15521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				SCp = slot->cmnd;
15531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				printk(KERN_ERR " failing command because of reset, slot %p, cmnd %p\n",
15541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				       slot, SCp);
15551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				free_slot(slot, hostdata);
15561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				SCp->host_scribble = NULL;
15571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				NCR_700_set_depth(SCp->device, 0);
15581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				/* NOTE: deadlock potential here: we
15591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				 * rely on mid-layer guarantees that
15601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				 * scsi_done won't try to issue the
15611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				 * command again otherwise we'll
15621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				 * deadlock on the
15631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				 * hostdata->state_lock */
15641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				SCp->result = DID_RESET << 16;
15651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				SCp->scsi_done(SCp);
15661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			}
15671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			mdelay(25);
15681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			NCR_700_chip_setup(host);
15691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
15701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			hostdata->state = NCR_700_HOST_FREE;
15711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			hostdata->cmd = NULL;
15721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			/* signal back if this was an eh induced reset */
15731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			if(hostdata->eh_complete != NULL)
15741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				complete(hostdata->eh_complete);
15751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			goto out_unlock;
15761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		} else if(sstat0 & SELECTION_TIMEOUT) {
15771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			DEBUG(("scsi%d: (%d:%d) selection timeout\n",
15781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			       host->host_no, pun, lun));
15791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			NCR_700_scsi_done(hostdata, SCp, DID_NO_CONNECT<<16);
15801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		} else if(sstat0 & PHASE_MISMATCH) {
15811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			struct NCR_700_command_slot *slot = (SCp == NULL) ? NULL :
15821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				(struct NCR_700_command_slot *)SCp->host_scribble;
15831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
15841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			if(dsp == Ent_SendMessage + 8 + hostdata->pScript) {
15851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				/* It wants to reply to some part of
15861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				 * our message */
15871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#ifdef NCR_700_DEBUG
15881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				__u32 temp = NCR_700_readl(host, TEMP_REG);
15891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				int count = (hostdata->script[Ent_SendMessage/4] & 0xffffff) - ((NCR_700_readl(host, DBC_REG) & 0xffffff) + NCR_700_data_residual(host));
15901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				printk("scsi%d (%d:%d) PHASE MISMATCH IN SEND MESSAGE %d remain, return %p[%04x], phase %s\n", host->host_no, pun, lun, count, (void *)temp, temp - hostdata->pScript, sbcl_to_string(NCR_700_readb(host, SBCL_REG)));
15911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif
15921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				resume_offset = hostdata->pScript + Ent_SendMessagePhaseMismatch;
15931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			} else if(dsp >= to32bit(&slot->pSG[0].ins) &&
15941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				  dsp <= to32bit(&slot->pSG[NCR_700_SG_SEGMENTS].ins)) {
15951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				int data_transfer = NCR_700_readl(host, DBC_REG) & 0xffffff;
15961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				int SGcount = (dsp - to32bit(&slot->pSG[0].ins))/sizeof(struct NCR_700_SG_List);
15971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				int residual = NCR_700_data_residual(host);
15981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				int i;
15991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#ifdef NCR_700_DEBUG
16001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				__u32 naddr = NCR_700_readl(host, DNAD_REG);
16011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
16021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				printk("scsi%d: (%d:%d) Expected phase mismatch in slot->SG[%d], transferred 0x%x\n",
16031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				       host->host_no, pun, lun,
16041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				       SGcount, data_transfer);
16051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				scsi_print_command(SCp);
16061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				if(residual) {
16071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds					printk("scsi%d: (%d:%d) Expected phase mismatch in slot->SG[%d], transferred 0x%x, residual %d\n",
16081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				       host->host_no, pun, lun,
16091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				       SGcount, data_transfer, residual);
16101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				}
16111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif
16121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				data_transfer += residual;
16131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
16141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				if(data_transfer != 0) {
16151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds					int count;
16161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds					__u32 pAddr;
16171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
16181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds					SGcount--;
16191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
16201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds					count = (bS_to_cpu(slot->SG[SGcount].ins) & 0x00ffffff);
16211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds					DEBUG(("DATA TRANSFER MISMATCH, count = %d, transferred %d\n", count, count-data_transfer));
16221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds					slot->SG[SGcount].ins &= bS_to_host(0xff000000);
16231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds					slot->SG[SGcount].ins |= bS_to_host(data_transfer);
16241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds					pAddr = bS_to_cpu(slot->SG[SGcount].pAddr);
16251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds					pAddr += (count - data_transfer);
16261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#ifdef NCR_700_DEBUG
16271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds					if(pAddr != naddr) {
16281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds						printk("scsi%d (%d:%d) transfer mismatch pAddr=%lx, naddr=%lx, data_transfer=%d, residual=%d\n", host->host_no, pun, lun, (unsigned long)pAddr, (unsigned long)naddr, data_transfer, residual);
16291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds					}
16301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif
16311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds					slot->SG[SGcount].pAddr = bS_to_host(pAddr);
16321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				}
16331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				/* set the executed moves to nops */
16341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				for(i=0; i<SGcount; i++) {
16351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds					slot->SG[i].ins = bS_to_host(SCRIPT_NOP);
16361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds					slot->SG[i].pAddr = 0;
16371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				}
16381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				dma_cache_sync(slot->SG, sizeof(slot->SG), DMA_TO_DEVICE);
16391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				/* and pretend we disconnected after
16401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				 * the command phase */
16411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				resume_offset = hostdata->pScript + Ent_MsgInDuringData;
16421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				/* make sure all the data is flushed */
16431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				NCR_700_flush_fifo(host);
16441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			} else {
16451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				__u8 sbcl = NCR_700_readb(host, SBCL_REG);
16461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				printk(KERN_ERR "scsi%d: (%d:%d) phase mismatch at %04x, phase %s\n",
16471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				       host->host_no, pun, lun, dsp - hostdata->pScript, sbcl_to_string(sbcl));
16481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				NCR_700_internal_bus_reset(host);
16491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			}
16501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
16511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		} else if(sstat0 & SCSI_GROSS_ERROR) {
16521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			printk(KERN_ERR "scsi%d: (%d:%d) GROSS ERROR\n",
16531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			       host->host_no, pun, lun);
16541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			NCR_700_scsi_done(hostdata, SCp, DID_ERROR<<16);
16551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		} else if(sstat0 & PARITY_ERROR) {
16561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			printk(KERN_ERR "scsi%d: (%d:%d) PARITY ERROR\n",
16571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			       host->host_no, pun, lun);
16581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			NCR_700_scsi_done(hostdata, SCp, DID_ERROR<<16);
16591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		} else if(dstat & SCRIPT_INT_RECEIVED) {
16601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			DEBUG(("scsi%d: (%d:%d) ====>SCRIPT INTERRUPT<====\n",
16611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			       host->host_no, pun, lun));
16621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			resume_offset = process_script_interrupt(dsps, dsp, SCp, host, hostdata);
16631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		} else if(dstat & (ILGL_INST_DETECTED)) {
16641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			printk(KERN_ERR "scsi%d: (%d:%d) Illegal Instruction detected at 0x%08x[0x%x]!!!\n"
16651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			       "         Please email James.Bottomley@HansenPartnership.com with the details\n",
16661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			       host->host_no, pun, lun,
16671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			       dsp, dsp - hostdata->pScript);
16681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			NCR_700_scsi_done(hostdata, SCp, DID_ERROR<<16);
16691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		} else if(dstat & (WATCH_DOG_INTERRUPT|ABORTED)) {
16701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			printk(KERN_ERR "scsi%d: (%d:%d) serious DMA problem, dstat=%02x\n",
16711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			       host->host_no, pun, lun, dstat);
16721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			NCR_700_scsi_done(hostdata, SCp, DID_ERROR<<16);
16731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		}
16741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
16751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
16761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		/* NOTE: selection interrupt processing MUST occur
16771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		 * after script interrupt processing to correctly cope
16781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		 * with the case where we process a disconnect and
16791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		 * then get reselected before we process the
16801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		 * disconnection */
16811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		if(sstat0 & SELECTED) {
16821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			/* FIXME: It currently takes at least FOUR
16831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			 * interrupts to complete a command that
16841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			 * disconnects: one for the disconnect, one
16851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			 * for the reselection, one to get the
16861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			 * reselection data and one to complete the
16871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			 * command.  If we guess the reselected
16881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			 * command here and prepare it, we only need
16891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			 * to get a reselection data interrupt if we
16901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			 * guessed wrongly.  Since the interrupt
16911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			 * overhead is much greater than the command
16921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			 * setup, this would be an efficient
16931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			 * optimisation particularly as we probably
16941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			 * only have one outstanding command on a
16951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			 * target most of the time */
16961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
16971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			resume_offset = process_selection(host, dsp);
16981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
16991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		}
17001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
17011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	}
17021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
17031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	if(resume_offset) {
17041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		if(hostdata->state != NCR_700_HOST_BUSY) {
17051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			printk(KERN_ERR "scsi%d: Driver error: resume at 0x%08x [0x%04x] with non busy host!\n",
17061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			       host->host_no, resume_offset, resume_offset - hostdata->pScript);
17071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			hostdata->state = NCR_700_HOST_BUSY;
17081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		}
17091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
17101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		DEBUG(("Attempting to resume at %x\n", resume_offset));
17111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		NCR_700_clear_fifo(host);
17121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		NCR_700_writel(resume_offset, host, DSP_REG);
17131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	}
17141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	/* There is probably a technical no-no about this: If we're a
17151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	 * shared interrupt and we got this interrupt because the
17161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	 * other device needs servicing not us, we're still going to
17171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	 * check our queued commands here---of course, there shouldn't
17181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	 * be any outstanding.... */
17191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	if(hostdata->state == NCR_700_HOST_FREE) {
17201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		int i;
17211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
17221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		for(i = 0; i < NCR_700_COMMAND_SLOTS_PER_HOST; i++) {
17231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			/* fairness: always run the queue from the last
17241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			 * position we left off */
17251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			int j = (i + hostdata->saved_slot_position)
17261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				% NCR_700_COMMAND_SLOTS_PER_HOST;
17271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
17281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			if(hostdata->slots[j].state != NCR_700_SLOT_QUEUED)
17291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				continue;
17301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			if(NCR_700_start_command(hostdata->slots[j].cmnd)) {
17311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				DEBUG(("scsi%d: Issuing saved command slot %p, cmd %p\t\n",
17321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				       host->host_no, &hostdata->slots[j],
17331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				       hostdata->slots[j].cmnd));
17341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				hostdata->saved_slot_position = j + 1;
17351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			}
17361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
17371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			break;
17381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		}
17391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	}
17401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds out_unlock:
17411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	spin_unlock_irqrestore(host->host_lock, flags);
17421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	return IRQ_RETVAL(handled);
17431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds}
17441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
17451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsSTATIC int
17461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsNCR_700_queuecommand(struct scsi_cmnd *SCp, void (*done)(struct scsi_cmnd *))
17471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{
17481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	struct NCR_700_Host_Parameters *hostdata =
17491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		(struct NCR_700_Host_Parameters *)SCp->device->host->hostdata[0];
17501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	__u32 move_ins;
17511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	enum dma_data_direction direction;
17521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	struct NCR_700_command_slot *slot;
17531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
17541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	if(hostdata->command_slot_count >= NCR_700_COMMAND_SLOTS_PER_HOST) {
17551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		/* We're over our allocation, this should never happen
17561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		 * since we report the max allocation to the mid layer */
17571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		printk(KERN_WARNING "scsi%d: Command depth has gone over queue depth\n", SCp->device->host->host_no);
17581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		return 1;
17591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	}
17601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	/* check for untagged commands.  We cannot have any outstanding
17611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	 * commands if we accept them.  Commands could be untagged because:
17621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	 *
17631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	 * - The tag negotiated bitmap is clear
17641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	 * - The blk layer sent and untagged command
17651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	 */
17661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	if(NCR_700_get_depth(SCp->device) != 0
17671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	   && (!(hostdata->tag_negotiated & (1<<SCp->device->id))
17681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	       || !blk_rq_tagged(SCp->request))) {
17691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		DEBUG((KERN_ERR "scsi%d (%d:%d) has non zero depth %d\n",
17701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		       SCp->device->host->host_no, SCp->device->id, SCp->device->lun,
17711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		       NCR_700_get_depth(SCp->device)));
17721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		return SCSI_MLQUEUE_DEVICE_BUSY;
17731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	}
17741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	if(NCR_700_get_depth(SCp->device) >= SCp->device->queue_depth) {
17751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		DEBUG((KERN_ERR "scsi%d (%d:%d) has max tag depth %d\n",
17761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		       SCp->device->host->host_no, SCp->device->id, SCp->device->lun,
17771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		       NCR_700_get_depth(SCp->device)));
17781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		return SCSI_MLQUEUE_DEVICE_BUSY;
17791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	}
17801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	NCR_700_set_depth(SCp->device, NCR_700_get_depth(SCp->device) + 1);
17811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
17821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	/* begin the command here */
17831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	/* no need to check for NULL, test for command_slot_count above
17841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	 * ensures a slot is free */
17851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	slot = find_empty_slot(hostdata);
17861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
17871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	slot->cmnd = SCp;
17881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
17891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	SCp->scsi_done = done;
17901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	SCp->host_scribble = (unsigned char *)slot;
17911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	SCp->SCp.ptr = NULL;
17921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	SCp->SCp.buffer = NULL;
17931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
17941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#ifdef NCR_700_DEBUG
17951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	printk("53c700: scsi%d, command ", SCp->device->host->host_no);
17961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	scsi_print_command(SCp);
17971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif
17981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	if(blk_rq_tagged(SCp->request)
17991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	   && (hostdata->tag_negotiated &(1<<SCp->device->id)) == 0
18001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	   && NCR_700_get_tag_neg_state(SCp->device) == NCR_700_START_TAG_NEGOTIATION) {
18011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		printk(KERN_ERR "scsi%d: (%d:%d) Enabling Tag Command Queuing\n", SCp->device->host->host_no, SCp->device->id, SCp->device->lun);
18021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		hostdata->tag_negotiated |= (1<<SCp->device->id);
18031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		NCR_700_set_tag_neg_state(SCp->device, NCR_700_DURING_TAG_NEGOTIATION);
18041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	}
18051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
18061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	/* here we may have to process an untagged command.  The gate
18071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	 * above ensures that this will be the only one outstanding,
18081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	 * so clear the tag negotiated bit.
18091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	 *
18101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	 * FIXME: This will royally screw up on multiple LUN devices
18111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	 * */
18121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	if(!blk_rq_tagged(SCp->request)
18131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	   && (hostdata->tag_negotiated &(1<<SCp->device->id))) {
18141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		printk(KERN_INFO "scsi%d: (%d:%d) Disabling Tag Command Queuing\n", SCp->device->host->host_no, SCp->device->id, SCp->device->lun);
18151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		hostdata->tag_negotiated &= ~(1<<SCp->device->id);
18161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	}
18171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
18181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	if((hostdata->tag_negotiated &(1<<SCp->device->id))
18191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	   && scsi_get_tag_type(SCp->device)) {
18201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		slot->tag = SCp->request->tag;
18211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		DEBUG(("53c700 %d:%d:%d, sending out tag %d, slot %p\n",
18221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		       SCp->device->host->host_no, SCp->device->id, SCp->device->lun, slot->tag,
18231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		       slot));
18241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	} else {
18251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		slot->tag = SCSI_NO_TAG;
18261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		/* must populate current_cmnd for scsi_find_tag to work */
18271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		SCp->device->current_cmnd = SCp;
18281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	}
18291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	/* sanity check: some of the commands generated by the mid-layer
18301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	 * have an eccentric idea of their sc_data_direction */
18311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	if(!SCp->use_sg && !SCp->request_bufflen
18321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	   && SCp->sc_data_direction != DMA_NONE) {
18331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#ifdef NCR_700_DEBUG
18341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		printk("53c700: Command");
18351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		scsi_print_command(SCp);
18361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		printk("Has wrong data direction %d\n", SCp->sc_data_direction);
18371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif
18381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		SCp->sc_data_direction = DMA_NONE;
18391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	}
18401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
18411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	switch (SCp->cmnd[0]) {
18421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	case REQUEST_SENSE:
18431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		/* clear the internal sense magic */
18441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		SCp->cmnd[6] = 0;
18451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		/* fall through */
18461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	default:
18471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		/* OK, get it from the command */
18481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		switch(SCp->sc_data_direction) {
18491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		case DMA_BIDIRECTIONAL:
18501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		default:
18511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			printk(KERN_ERR "53c700: Unknown command for data direction ");
18521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			scsi_print_command(SCp);
18531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
18541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			move_ins = 0;
18551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			break;
18561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		case DMA_NONE:
18571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			move_ins = 0;
18581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			break;
18591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		case DMA_FROM_DEVICE:
18601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			move_ins = SCRIPT_MOVE_DATA_IN;
18611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			break;
18621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		case DMA_TO_DEVICE:
18631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			move_ins = SCRIPT_MOVE_DATA_OUT;
18641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			break;
18651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		}
18661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	}
18671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
18681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	/* now build the scatter gather list */
18691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	direction = SCp->sc_data_direction;
18701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	if(move_ins != 0) {
18711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		int i;
18721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		int sg_count;
18731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		dma_addr_t vPtr = 0;
18741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		__u32 count = 0;
18751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
18761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		if(SCp->use_sg) {
18771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			sg_count = dma_map_sg(hostdata->dev, SCp->buffer,
18781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds					      SCp->use_sg, direction);
18791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		} else {
18801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			vPtr = dma_map_single(hostdata->dev,
18811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds					      SCp->request_buffer,
18821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds					      SCp->request_bufflen,
18831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds					      direction);
18841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			count = SCp->request_bufflen;
18851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			slot->dma_handle = vPtr;
18861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			sg_count = 1;
18871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		}
18881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
18891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
18901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		for(i = 0; i < sg_count; i++) {
18911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
18921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			if(SCp->use_sg) {
18931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				struct scatterlist *sg = SCp->buffer;
18941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
18951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				vPtr = sg_dma_address(&sg[i]);
18961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				count = sg_dma_len(&sg[i]);
18971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			}
18981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
18991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			slot->SG[i].ins = bS_to_host(move_ins | count);
19001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			DEBUG((" scatter block %d: move %d[%08x] from 0x%lx\n",
19011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			       i, count, slot->SG[i].ins, (unsigned long)vPtr));
19021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			slot->SG[i].pAddr = bS_to_host(vPtr);
19031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		}
19041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		slot->SG[i].ins = bS_to_host(SCRIPT_RETURN);
19051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		slot->SG[i].pAddr = 0;
19061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		dma_cache_sync(slot->SG, sizeof(slot->SG), DMA_TO_DEVICE);
19071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		DEBUG((" SETTING %08lx to %x\n",
19081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		       (&slot->pSG[i].ins),
19091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		       slot->SG[i].ins));
19101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	}
19111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	slot->resume_offset = 0;
19121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	slot->pCmd = dma_map_single(hostdata->dev, SCp->cmnd,
19131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				    sizeof(SCp->cmnd), DMA_TO_DEVICE);
19141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	NCR_700_start_command(SCp);
19151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	return 0;
19161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds}
19171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
19181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsSTATIC int
19191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsNCR_700_abort(struct scsi_cmnd * SCp)
19201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{
19211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	struct NCR_700_command_slot *slot;
19221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
19231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	printk(KERN_INFO "scsi%d (%d:%d) New error handler wants to abort command\n\t",
19241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	       SCp->device->host->host_no, SCp->device->id, SCp->device->lun);
19251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	scsi_print_command(SCp);
19261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
19271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	slot = (struct NCR_700_command_slot *)SCp->host_scribble;
19281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
19291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	if(slot == NULL)
19301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		/* no outstanding command to abort */
19311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		return SUCCESS;
19321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	if(SCp->cmnd[0] == TEST_UNIT_READY) {
19331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		/* FIXME: This is because of a problem in the new
19341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		 * error handler.  When it is in error recovery, it
19351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		 * will send a TUR to a device it thinks may still be
19361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		 * showing a problem.  If the TUR isn't responded to,
19371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		 * it will abort it and mark the device off line.
19381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		 * Unfortunately, it does no other error recovery, so
19391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		 * this would leave us with an outstanding command
19401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		 * occupying a slot.  Rather than allow this to
19411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		 * happen, we issue a bus reset to force all
19421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		 * outstanding commands to terminate here. */
19431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		NCR_700_internal_bus_reset(SCp->device->host);
19441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		/* still drop through and return failed */
19451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	}
19461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	return FAILED;
19471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
19481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds}
19491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
19501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsSTATIC int
19511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsNCR_700_bus_reset(struct scsi_cmnd * SCp)
19521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{
19531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	DECLARE_COMPLETION(complete);
19541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	struct NCR_700_Host_Parameters *hostdata =
19551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		(struct NCR_700_Host_Parameters *)SCp->device->host->hostdata[0];
19561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
19571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	printk(KERN_INFO "scsi%d (%d:%d) New error handler wants BUS reset, cmd %p\n\t",
19581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	       SCp->device->host->host_no, SCp->device->id, SCp->device->lun, SCp);
19591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	scsi_print_command(SCp);
196068b3aa7c9805aee9005a8ca53c5e99177961fbb9Jeff Garzik
19611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	/* In theory, eh_complete should always be null because the
19621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	 * eh is single threaded, but just in case we're handling a
19631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	 * reset via sg or something */
196468b3aa7c9805aee9005a8ca53c5e99177961fbb9Jeff Garzik	spin_lock_irq(SCp->device->host->host_lock);
196568b3aa7c9805aee9005a8ca53c5e99177961fbb9Jeff Garzik	while (hostdata->eh_complete != NULL) {
19661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		spin_unlock_irq(SCp->device->host->host_lock);
19671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		msleep_interruptible(100);
19681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		spin_lock_irq(SCp->device->host->host_lock);
19691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	}
197068b3aa7c9805aee9005a8ca53c5e99177961fbb9Jeff Garzik
19711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	hostdata->eh_complete = &complete;
19721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	NCR_700_internal_bus_reset(SCp->device->host);
197368b3aa7c9805aee9005a8ca53c5e99177961fbb9Jeff Garzik
19741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	spin_unlock_irq(SCp->device->host->host_lock);
19751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	wait_for_completion(&complete);
19761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	spin_lock_irq(SCp->device->host->host_lock);
197768b3aa7c9805aee9005a8ca53c5e99177961fbb9Jeff Garzik
19781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	hostdata->eh_complete = NULL;
19791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	/* Revalidate the transport parameters of the failing device */
19801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	if(hostdata->fast)
19811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		spi_schedule_dv_device(SCp->device);
198268b3aa7c9805aee9005a8ca53c5e99177961fbb9Jeff Garzik
198368b3aa7c9805aee9005a8ca53c5e99177961fbb9Jeff Garzik	spin_unlock_irq(SCp->device->host->host_lock);
19841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	return SUCCESS;
19851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds}
19861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
19871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsSTATIC int
19881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsNCR_700_host_reset(struct scsi_cmnd * SCp)
19891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{
19901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	printk(KERN_INFO "scsi%d (%d:%d) New error handler wants HOST reset\n\t",
19911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	       SCp->device->host->host_no, SCp->device->id, SCp->device->lun);
19921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	scsi_print_command(SCp);
19931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
1994df0ae2497ddefd72a87f3a3b34ff32455d7d4ae0Jeff Garzik	spin_lock_irq(SCp->device->host->host_lock);
1995df0ae2497ddefd72a87f3a3b34ff32455d7d4ae0Jeff Garzik
19961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	NCR_700_internal_bus_reset(SCp->device->host);
19971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	NCR_700_chip_reset(SCp->device->host);
1998df0ae2497ddefd72a87f3a3b34ff32455d7d4ae0Jeff Garzik
1999df0ae2497ddefd72a87f3a3b34ff32455d7d4ae0Jeff Garzik	spin_unlock_irq(SCp->device->host->host_lock);
2000df0ae2497ddefd72a87f3a3b34ff32455d7d4ae0Jeff Garzik
20011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	return SUCCESS;
20021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds}
20031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
20041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsSTATIC void
20051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsNCR_700_set_period(struct scsi_target *STp, int period)
20061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{
20071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	struct Scsi_Host *SHp = dev_to_shost(STp->dev.parent);
20081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	struct NCR_700_Host_Parameters *hostdata =
20091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		(struct NCR_700_Host_Parameters *)SHp->hostdata[0];
20101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
20111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	if(!hostdata->fast)
20121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		return;
20131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
20141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	if(period < hostdata->min_period)
20151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		period = hostdata->min_period;
20161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
20171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	spi_period(STp) = period;
20181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	spi_flags(STp) &= ~(NCR_700_DEV_NEGOTIATED_SYNC |
20191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			    NCR_700_DEV_BEGIN_SYNC_NEGOTIATION);
20201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	spi_flags(STp) |= NCR_700_DEV_PRINT_SYNC_NEGOTIATION;
20211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds}
20221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
20231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsSTATIC void
20241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsNCR_700_set_offset(struct scsi_target *STp, int offset)
20251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{
20261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	struct Scsi_Host *SHp = dev_to_shost(STp->dev.parent);
20271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	struct NCR_700_Host_Parameters *hostdata =
20281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		(struct NCR_700_Host_Parameters *)SHp->hostdata[0];
20291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	int max_offset = hostdata->chip710
20301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		? NCR_710_MAX_OFFSET : NCR_700_MAX_OFFSET;
20311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
20321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	if(!hostdata->fast)
20331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		return;
20341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
20351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	if(offset > max_offset)
20361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		offset = max_offset;
20371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
20381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	/* if we're currently async, make sure the period is reasonable */
20391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	if(spi_offset(STp) == 0 && (spi_period(STp) < hostdata->min_period ||
20401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds				    spi_period(STp) > 0xff))
20411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		spi_period(STp) = hostdata->min_period;
20421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
20431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	spi_offset(STp) = offset;
20441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	spi_flags(STp) &= ~(NCR_700_DEV_NEGOTIATED_SYNC |
20451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			    NCR_700_DEV_BEGIN_SYNC_NEGOTIATION);
20461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	spi_flags(STp) |= NCR_700_DEV_PRINT_SYNC_NEGOTIATION;
20471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds}
20481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
20491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
20501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
20511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsSTATIC int
20521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsNCR_700_slave_configure(struct scsi_device *SDp)
20531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{
20541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	struct NCR_700_Host_Parameters *hostdata =
20551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		(struct NCR_700_Host_Parameters *)SDp->host->hostdata[0];
20561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
20571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	/* to do here: allocate memory; build a queue_full list */
20581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	if(SDp->tagged_supported) {
20591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		scsi_set_tag_type(SDp, MSG_ORDERED_TAG);
20601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		scsi_activate_tcq(SDp, NCR_700_DEFAULT_TAGS);
20611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		NCR_700_set_tag_neg_state(SDp, NCR_700_START_TAG_NEGOTIATION);
20621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	} else {
20631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		/* initialise to default depth */
20641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		scsi_adjust_queue_depth(SDp, 0, SDp->host->cmd_per_lun);
20651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	}
20661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	if(hostdata->fast) {
20671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		/* Find the correct offset and period via domain validation */
20681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		if (!spi_initial_dv(SDp->sdev_target))
20691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			spi_dv_device(SDp);
20701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	} else {
20711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		spi_offset(SDp->sdev_target) = 0;
20721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		spi_period(SDp->sdev_target) = 0;
20731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	}
20741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	return 0;
20751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds}
20761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
20771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsSTATIC void
20781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsNCR_700_slave_destroy(struct scsi_device *SDp)
20791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{
20801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	/* to do here: deallocate memory */
20811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds}
20821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
20831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int
20841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsNCR_700_change_queue_depth(struct scsi_device *SDp, int depth)
20851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{
20861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	if (depth > NCR_700_MAX_TAGS)
20871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		depth = NCR_700_MAX_TAGS;
20881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
20891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	scsi_adjust_queue_depth(SDp, scsi_get_tag_type(SDp), depth);
20901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	return depth;
20911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds}
20921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
20931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int NCR_700_change_queue_type(struct scsi_device *SDp, int tag_type)
20941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{
20951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	int change_tag = ((tag_type ==0 &&  scsi_get_tag_type(SDp) != 0)
20961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			  || (tag_type != 0 && scsi_get_tag_type(SDp) == 0));
20971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	struct NCR_700_Host_Parameters *hostdata =
20981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		(struct NCR_700_Host_Parameters *)SDp->host->hostdata[0];
20991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
21001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	scsi_set_tag_type(SDp, tag_type);
21011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
21021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	/* We have a global (per target) flag to track whether TCQ is
21031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	 * enabled, so we'll be turning it off for the entire target here.
21041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	 * our tag algorithm will fail if we mix tagged and untagged commands,
21051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	 * so quiesce the device before doing this */
21061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	if (change_tag)
21071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		scsi_target_quiesce(SDp->sdev_target);
21081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
21091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	if (!tag_type) {
21101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		/* shift back to the default unqueued number of commands
21111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		 * (the user can still raise this) */
21121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		scsi_deactivate_tcq(SDp, SDp->host->cmd_per_lun);
21131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		hostdata->tag_negotiated &= ~(1 << SDp->id);
21141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	} else {
21151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		/* Here, we cleared the negotiation flag above, so this
21161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		 * will force the driver to renegotiate */
21171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		scsi_activate_tcq(SDp, SDp->queue_depth);
21181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		if (change_tag)
21191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds			NCR_700_set_tag_neg_state(SDp, NCR_700_START_TAG_NEGOTIATION);
21201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	}
21211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	if (change_tag)
21221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		scsi_target_resume(SDp->sdev_target);
21231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
21241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	return tag_type;
21251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds}
21261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
21271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic ssize_t
21281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsNCR_700_show_active_tags(struct device *dev, char *buf)
21291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{
21301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	struct scsi_device *SDp = to_scsi_device(dev);
21311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
21321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	return snprintf(buf, 20, "%d\n", NCR_700_get_depth(SDp));
21331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds}
21341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
21351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic struct device_attribute NCR_700_active_tags_attr = {
21361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	.attr = {
21371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		.name =		"active_tags",
21381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		.mode =		S_IRUGO,
21391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	},
21401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	.show = NCR_700_show_active_tags,
21411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds};
21421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
21431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsSTATIC struct device_attribute *NCR_700_dev_attrs[] = {
21441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	&NCR_700_active_tags_attr,
21451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	NULL,
21461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds};
21471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
21481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsEXPORT_SYMBOL(NCR_700_detect);
21491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsEXPORT_SYMBOL(NCR_700_release);
21501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsEXPORT_SYMBOL(NCR_700_intr);
21511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
21521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic struct spi_function_template NCR_700_transport_functions =  {
21531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	.set_period	= NCR_700_set_period,
21541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	.show_period	= 1,
21551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	.set_offset	= NCR_700_set_offset,
21561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	.show_offset	= 1,
21571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds};
21581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
21591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int __init NCR_700_init(void)
21601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{
21611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	NCR_700_transport_template = spi_attach_transport(&NCR_700_transport_functions);
21621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	if(!NCR_700_transport_template)
21631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds		return -ENODEV;
21641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	return 0;
21651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds}
21661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
21671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void __exit NCR_700_exit(void)
21681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{
21691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds	spi_release_transport(NCR_700_transport_template);
21701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds}
21711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
21721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsmodule_init(NCR_700_init);
21731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsmodule_exit(NCR_700_exit);
21741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds
2175