53c700.c revision 5a0e3ad6af8660be21ca98a971cd00f331318c05
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/kernel.h> 1181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/types.h> 1191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/string.h> 1205a0e3ad6af8660be21ca98a971cd00f331318c05Tejun Heo#include <linux/slab.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/init.h> 1261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/proc_fs.h> 1271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/blkdev.h> 1281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/module.h> 1291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/interrupt.h> 130017560fca496f72ed9dd734ffde63ce39dfe0411Jeff Garzik#include <linux/device.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); 1760f13fc09db68de92585558984bff1c51b87db72fJames BottomleySTATIC int NCR_700_slave_alloc(struct scsi_device *SDpnt); 1771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsSTATIC int NCR_700_slave_configure(struct scsi_device *SDpnt); 1781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsSTATIC void NCR_700_slave_destroy(struct scsi_device *SDpnt); 179e881a172dac4d9ea3b2a1540041d872963c269bdMike Christiestatic int NCR_700_change_queue_depth(struct scsi_device *SDpnt, int depth, int reason); 1801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int NCR_700_change_queue_type(struct scsi_device *SDpnt, int depth); 1811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsSTATIC struct device_attribute *NCR_700_dev_attrs[]; 1831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsSTATIC struct scsi_transport_template *NCR_700_transport_template = NULL; 1851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic char *NCR_700_phase[] = { 1871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds "", 1881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds "after selection", 1891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds "before command phase", 1901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds "after command phase", 1911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds "after status phase", 1921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds "after data in phase", 1931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds "after data out phase", 1941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds "during data phase", 1951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds}; 1961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic char *NCR_700_condition[] = { 1981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds "", 1991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds "NOT MSG_OUT", 2001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds "UNEXPECTED PHASE", 2011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds "NOT MSG_IN", 2021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds "UNEXPECTED MSG", 2031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds "MSG_IN", 2041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds "SDTR_MSG RECEIVED", 2051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds "REJECT_MSG RECEIVED", 2061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds "DISCONNECT_MSG RECEIVED", 2071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds "MSG_OUT", 2081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds "DATA_IN", 2091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds}; 2111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic char *NCR_700_fatal_messages[] = { 2131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds "unexpected message after reselection", 2141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds "still MSG_OUT after message injection", 2151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds "not MSG_IN after selection", 2161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds "Illegal message length received", 2171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds}; 2181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic char *NCR_700_SBCL_bits[] = { 2201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds "IO ", 2211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds "CD ", 2221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds "MSG ", 2231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds "ATN ", 2241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds "SEL ", 2251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds "BSY ", 2261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds "ACK ", 2271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds "REQ ", 2281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds}; 2291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic char *NCR_700_SBCL_to_phase[] = { 2311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds "DATA_OUT", 2321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds "DATA_IN", 2331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds "CMD_OUT", 2341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds "STATE", 2351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds "ILLEGAL PHASE", 2361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds "ILLEGAL PHASE", 2371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds "MSG OUT", 2381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds "MSG IN", 2391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds}; 2401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* This translates the SDTR message offset and period to a value 2421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * which can be loaded into the SXFER_REG. 2431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 2441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * NOTE: According to SCSI-2, the true transfer period (in ns) is 2451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * actually four times this period value */ 2461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic inline __u8 2471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsNCR_700_offset_period_to_sxfer(struct NCR_700_Host_Parameters *hostdata, 2481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds __u8 offset, __u8 period) 2491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 2501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int XFERP; 2511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds __u8 min_xferp = (hostdata->chip710 2531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ? NCR_710_MIN_XFERP : NCR_700_MIN_XFERP); 2541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds __u8 max_offset = (hostdata->chip710 2551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ? NCR_710_MAX_OFFSET : NCR_700_MAX_OFFSET); 2561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(offset == 0) 2581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 0; 2591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(period < hostdata->min_period) { 2616ea3c0b2dac0d6a857d6bc010e544f4c901fff78Matthew Wilcox printk(KERN_WARNING "53c700: Period %dns is less than this chip's minimum, setting to %d\n", period*4, NCR_700_MIN_PERIOD*4); 2621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds period = hostdata->min_period; 2631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 2641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds XFERP = (period*4 * hostdata->sync_clock)/1000 - 4; 2651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(offset > max_offset) { 2661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk(KERN_WARNING "53c700: Offset %d exceeds chip maximum, setting to %d\n", 2671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds offset, max_offset); 2681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds offset = max_offset; 2691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 2701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(XFERP < min_xferp) { 2711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds XFERP = min_xferp; 2721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 2731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return (offset & 0x0f) | (XFERP & 0x07)<<4; 2741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 2751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic inline __u8 2771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsNCR_700_get_SXFER(struct scsi_device *SDp) 2781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 2791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct NCR_700_Host_Parameters *hostdata = 2801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (struct NCR_700_Host_Parameters *)SDp->host->hostdata[0]; 2811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return NCR_700_offset_period_to_sxfer(hostdata, 2831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spi_offset(SDp->sdev_target), 2841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spi_period(SDp->sdev_target)); 2851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 2861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstruct Scsi_Host * 2881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsNCR_700_detect(struct scsi_host_template *tpnt, 2891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct NCR_700_Host_Parameters *hostdata, struct device *dev) 2901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 2911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dma_addr_t pScript, pSlots; 2921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds __u8 *memory; 2931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds __u32 *script; 2941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct Scsi_Host *host; 2951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds static int banner = 0; 2961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int j; 2971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(tpnt->sdev_attrs == NULL) 2991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds tpnt->sdev_attrs = NCR_700_dev_attrs; 3001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds memory = dma_alloc_noncoherent(hostdata->dev, TOTAL_MEM_SIZE, 3021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds &pScript, GFP_KERNEL); 3031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(memory == NULL) { 3041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk(KERN_ERR "53c700: Failed to allocate memory for driver, detatching\n"); 3051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return NULL; 3061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 3071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds script = (__u32 *)memory; 3091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hostdata->msgin = memory + MSGIN_OFFSET; 3101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hostdata->msgout = memory + MSGOUT_OFFSET; 3111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hostdata->status = memory + STATUS_OFFSET; 3121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* all of these offsets are L1_CACHE_BYTES separated. It is fatal 3131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * if this isn't sufficient separation to avoid dma flushing issues */ 314f67637ee4b5d90d41160d755b9a8cca18c394586Ralf Baechle BUG_ON(!dma_is_consistent(hostdata->dev, pScript) && L1_CACHE_BYTES < dma_get_cache_alignment()); 3151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hostdata->slots = (struct NCR_700_command_slot *)(memory + SLOTS_OFFSET); 3161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hostdata->dev = dev; 3176391a11375de5e2bb1eb8481e54619761dc65d9fTobias Klauser 3181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pSlots = pScript + SLOTS_OFFSET; 3191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Fill in the missing routines from the host template */ 3211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds tpnt->queuecommand = NCR_700_queuecommand; 3221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds tpnt->eh_abort_handler = NCR_700_abort; 3231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds tpnt->eh_bus_reset_handler = NCR_700_bus_reset; 3241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds tpnt->eh_host_reset_handler = NCR_700_host_reset; 3251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds tpnt->can_queue = NCR_700_COMMAND_SLOTS_PER_HOST; 3261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds tpnt->sg_tablesize = NCR_700_SG_SEGMENTS; 3271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds tpnt->cmd_per_lun = NCR_700_CMD_PER_LUN; 3281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds tpnt->use_clustering = ENABLE_CLUSTERING; 3291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds tpnt->slave_configure = NCR_700_slave_configure; 3301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds tpnt->slave_destroy = NCR_700_slave_destroy; 3310f13fc09db68de92585558984bff1c51b87db72fJames Bottomley tpnt->slave_alloc = NCR_700_slave_alloc; 3321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds tpnt->change_queue_depth = NCR_700_change_queue_depth; 3331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds tpnt->change_queue_type = NCR_700_change_queue_type; 3346391a11375de5e2bb1eb8481e54619761dc65d9fTobias Klauser 3351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(tpnt->name == NULL) 3361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds tpnt->name = "53c700"; 3371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(tpnt->proc_name == NULL) 3381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds tpnt->proc_name = "53c700"; 3391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds host = scsi_host_alloc(tpnt, 4); 3411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!host) 3421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return NULL; 3431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds memset(hostdata->slots, 0, sizeof(struct NCR_700_command_slot) 3441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * NCR_700_COMMAND_SLOTS_PER_HOST); 3456391a11375de5e2bb1eb8481e54619761dc65d9fTobias Klauser for (j = 0; j < NCR_700_COMMAND_SLOTS_PER_HOST; j++) { 3461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dma_addr_t offset = (dma_addr_t)((unsigned long)&hostdata->slots[j].SG[0] 3471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds - (unsigned long)&hostdata->slots[0].SG[0]); 3481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hostdata->slots[j].pSG = (struct NCR_700_SG_List *)((unsigned long)(pSlots + offset)); 3491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(j == 0) 3501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hostdata->free_list = &hostdata->slots[j]; 3511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else 3521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hostdata->slots[j-1].ITL_forw = &hostdata->slots[j]; 3531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hostdata->slots[j].state = NCR_700_SLOT_FREE; 3541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 3551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3566391a11375de5e2bb1eb8481e54619761dc65d9fTobias Klauser for (j = 0; j < ARRAY_SIZE(SCRIPT); j++) 3571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds script[j] = bS_to_host(SCRIPT[j]); 3581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* adjust all labels to be bus physical */ 3606391a11375de5e2bb1eb8481e54619761dc65d9fTobias Klauser for (j = 0; j < PATCHES; j++) 3611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds script[LABELPATCHES[j]] = bS_to_host(pScript + SCRIPT[LABELPATCHES[j]]); 3621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* now patch up fixed addresses. */ 363d3fa72e4556ec1f04e46a0d561d9e785ecaa173dRalf Baechle script_patch_32(hostdata->dev, script, MessageLocation, 3641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pScript + MSGOUT_OFFSET); 365d3fa72e4556ec1f04e46a0d561d9e785ecaa173dRalf Baechle script_patch_32(hostdata->dev, script, StatusAddress, 3661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pScript + STATUS_OFFSET); 367d3fa72e4556ec1f04e46a0d561d9e785ecaa173dRalf Baechle script_patch_32(hostdata->dev, script, ReceiveMsgAddress, 3681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pScript + MSGIN_OFFSET); 3691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hostdata->script = script; 3711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hostdata->pScript = pScript; 3721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dma_sync_single_for_device(hostdata->dev, pScript, sizeof(SCRIPT), DMA_TO_DEVICE); 3731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hostdata->state = NCR_700_HOST_FREE; 3741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hostdata->cmd = NULL; 3752b89dad0c7e3b03d45d9674ee9a7b49670df098eHannes Reinecke host->max_id = 8; 3761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds host->max_lun = NCR_700_MAX_LUNS; 3771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds BUG_ON(NCR_700_transport_template == NULL); 3781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds host->transportt = NCR_700_transport_template; 37956fece20086ebe32bce2c0d74ceadd516b56baae<jejb@mulgrave.(none)> host->unique_id = (unsigned long)hostdata->base; 3801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hostdata->eh_complete = NULL; 3811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds host->hostdata[0] = (unsigned long)hostdata; 3821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* kick the chip */ 3831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_writeb(0xff, host, CTEST9_REG); 3846391a11375de5e2bb1eb8481e54619761dc65d9fTobias Klauser if (hostdata->chip710) 3851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hostdata->rev = (NCR_700_readb(host, CTEST8_REG)>>4) & 0x0f; 3861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else 3871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hostdata->rev = (NCR_700_readb(host, CTEST7_REG)>>4) & 0x0f; 3881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hostdata->fast = (NCR_700_readb(host, CTEST9_REG) == 0); 3896391a11375de5e2bb1eb8481e54619761dc65d9fTobias Klauser if (banner == 0) { 3901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk(KERN_NOTICE "53c700: Version " NCR_700_VERSION " By James.Bottomley@HansenPartnership.com\n"); 3911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds banner = 1; 3921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 3931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk(KERN_NOTICE "scsi%d: %s rev %d %s\n", host->host_no, 3946391a11375de5e2bb1eb8481e54619761dc65d9fTobias Klauser hostdata->chip710 ? "53c710" : 3951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (hostdata->fast ? "53c700-66" : "53c700"), 3961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hostdata->rev, hostdata->differential ? 3971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds "(Differential)" : ""); 3981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* reset the chip */ 3991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_chip_reset(host); 4001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (scsi_add_host(host, dev)) { 4021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dev_printk(KERN_ERR, dev, "53c700: scsi_add_host failed\n"); 4031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds scsi_host_put(host); 4041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return NULL; 4051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 4061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spi_signalling(host) = hostdata->differential ? SPI_SIGNAL_HVD : 4081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SPI_SIGNAL_SE; 4091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return host; 4111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 4121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsint 4141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsNCR_700_release(struct Scsi_Host *host) 4151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 4161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct NCR_700_Host_Parameters *hostdata = 4171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (struct NCR_700_Host_Parameters *)host->hostdata[0]; 4181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dma_free_noncoherent(hostdata->dev, TOTAL_MEM_SIZE, 4201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hostdata->script, hostdata->pScript); 4211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 1; 4221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 4231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic inline __u8 4251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsNCR_700_identify(int can_disconnect, __u8 lun) 4261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 4271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return IDENTIFY_BASE | 4281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ((can_disconnect) ? 0x40 : 0) | 4291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (lun & NCR_700_LUN_MASK); 4301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 4311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* 4331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Function : static int data_residual (Scsi_Host *host) 4341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 4351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Purpose : return residual data count of what's in the chip. If you 4361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * really want to know what this function is doing, it's almost a 4371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * direct transcription of the algorithm described in the 53c710 4381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * guide, except that the DBC and DFIFO registers are only 6 bits 4391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * wide on a 53c700. 4401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 4411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Inputs : host - SCSI host */ 4421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic inline int 4431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsNCR_700_data_residual (struct Scsi_Host *host) { 4441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct NCR_700_Host_Parameters *hostdata = 4451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (struct NCR_700_Host_Parameters *)host->hostdata[0]; 4461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int count, synchronous = 0; 4471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned int ddir; 4481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(hostdata->chip710) { 4501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds count = ((NCR_700_readb(host, DFIFO_REG) & 0x7f) - 4511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (NCR_700_readl(host, DBC_REG) & 0x7f)) & 0x7f; 4521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 4531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds count = ((NCR_700_readb(host, DFIFO_REG) & 0x3f) - 4541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (NCR_700_readl(host, DBC_REG) & 0x3f)) & 0x3f; 4551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 4561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(hostdata->fast) 4581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds synchronous = NCR_700_readb(host, SXFER_REG) & 0x0f; 4591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* get the data direction */ 4611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ddir = NCR_700_readb(host, CTEST0_REG) & 0x01; 4621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (ddir) { 4641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Receive */ 4651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (synchronous) 4661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds count += (NCR_700_readb(host, SSTAT2_REG) & 0xf0) >> 4; 4671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds else 4681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (NCR_700_readb(host, SSTAT1_REG) & SIDL_REG_FULL) 4691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ++count; 4701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 4711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Send */ 4721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds __u8 sstat = NCR_700_readb(host, SSTAT1_REG); 4731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (sstat & SODL_REG_FULL) 4741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ++count; 4751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (synchronous && (sstat & SODR_REG_FULL)) 4761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ++count; 4771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 4781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#ifdef NCR_700_DEBUG 4791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(count) 4801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("RESIDUAL IS %d (ddir %d)\n", count, ddir); 4811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif 4821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return count; 4831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 4841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* print out the SCSI wires and corresponding phase from the SBCL register 4861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * in the chip */ 4871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic inline char * 4881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldssbcl_to_string(__u8 sbcl) 4891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 4901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int i; 4911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds static char ret[256]; 4921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 4931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ret[0]='\0'; 4941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for(i=0; i<8; i++) { 4951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if((1<<i) & sbcl) 4961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds strcat(ret, NCR_700_SBCL_bits[i]); 4971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 4981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds strcat(ret, NCR_700_SBCL_to_phase[sbcl & 0x07]); 4991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return ret; 5001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 5011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic inline __u8 5031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsbitmap_to_number(__u8 bitmap) 5041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 5051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds __u8 i; 5061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for(i=0; i<8 && !(bitmap &(1<<i)); i++) 5081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ; 5091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return i; 5101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 5111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* Pull a slot off the free list */ 5131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsSTATIC struct NCR_700_command_slot * 5141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsfind_empty_slot(struct NCR_700_Host_Parameters *hostdata) 5151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 5161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct NCR_700_command_slot *slot = hostdata->free_list; 5171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(slot == NULL) { 5191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* sanity check */ 5201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(hostdata->command_slot_count != NCR_700_COMMAND_SLOTS_PER_HOST) 5211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk(KERN_ERR "SLOTS FULL, but count is %d, should be %d\n", hostdata->command_slot_count, NCR_700_COMMAND_SLOTS_PER_HOST); 5221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return NULL; 5231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 5241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(slot->state != NCR_700_SLOT_FREE) 5261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* should panic! */ 5271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk(KERN_ERR "BUSY SLOT ON FREE LIST!!!\n"); 5281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hostdata->free_list = slot->ITL_forw; 5311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds slot->ITL_forw = NULL; 5321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* NOTE: set the state to busy here, not queued, since this 5351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * indicates the slot is in use and cannot be run by the IRQ 5361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * finish routine. If we cannot queue the command when it 5371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * is properly build, we then change to NCR_700_SLOT_QUEUED */ 5381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds slot->state = NCR_700_SLOT_BUSY; 53967d59dfdeb21df2c16dcd478b66177e91178ecd0James Bottomley slot->flags = 0; 5401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hostdata->command_slot_count++; 5411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return slot; 5431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 5441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsSTATIC void 5461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsfree_slot(struct NCR_700_command_slot *slot, 5471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct NCR_700_Host_Parameters *hostdata) 5481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 5491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if((slot->state & NCR_700_SLOT_MASK) != NCR_700_SLOT_MAGIC) { 5501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk(KERN_ERR "53c700: SLOT %p is not MAGIC!!!\n", slot); 5511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 5521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(slot->state == NCR_700_SLOT_FREE) { 5531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk(KERN_ERR "53c700: SLOT %p is FREE!!!\n", slot); 5541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 5551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds slot->resume_offset = 0; 5571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds slot->cmnd = NULL; 5581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds slot->state = NCR_700_SLOT_FREE; 5591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds slot->ITL_forw = hostdata->free_list; 5601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hostdata->free_list = slot; 5611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hostdata->command_slot_count--; 5621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 5631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* This routine really does very little. The command is indexed on 5661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds the ITL and (if tagged) the ITLQ lists in _queuecommand */ 5671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsSTATIC void 5681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldssave_for_reselection(struct NCR_700_Host_Parameters *hostdata, 5691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct scsi_cmnd *SCp, __u32 dsp) 5701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 5711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Its just possible that this gets executed twice */ 5721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(SCp != NULL) { 5731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct NCR_700_command_slot *slot = 5741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (struct NCR_700_command_slot *)SCp->host_scribble; 5751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds slot->resume_offset = dsp; 5771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 5781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hostdata->state = NCR_700_HOST_FREE; 5791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hostdata->cmd = NULL; 5801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 5811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsSTATIC inline void 5831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsNCR_700_unmap(struct NCR_700_Host_Parameters *hostdata, struct scsi_cmnd *SCp, 5841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct NCR_700_command_slot *slot) 5851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 5861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(SCp->sc_data_direction != DMA_NONE && 5873258a4d5690880a62121553b604893ecaca7d042FUJITA Tomonori SCp->sc_data_direction != DMA_BIDIRECTIONAL) 5883258a4d5690880a62121553b604893ecaca7d042FUJITA Tomonori scsi_dma_unmap(SCp); 5891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 5901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsSTATIC inline void 5921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsNCR_700_scsi_done(struct NCR_700_Host_Parameters *hostdata, 5931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct scsi_cmnd *SCp, int result) 5941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 5951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hostdata->state = NCR_700_HOST_FREE; 5961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hostdata->cmd = NULL; 5971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(SCp != NULL) { 5991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct NCR_700_command_slot *slot = 6001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (struct NCR_700_command_slot *)SCp->host_scribble; 6011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6020f13fc09db68de92585558984bff1c51b87db72fJames Bottomley dma_unmap_single(hostdata->dev, slot->pCmd, 60364a87b244b9297667ca80264aab849a36f494884Boaz Harrosh MAX_COMMAND_SIZE, DMA_TO_DEVICE); 60467d59dfdeb21df2c16dcd478b66177e91178ecd0James Bottomley if (slot->flags == NCR_700_FLAG_AUTOSENSE) { 6050f13fc09db68de92585558984bff1c51b87db72fJames Bottomley char *cmnd = NCR_700_get_sense_cmnd(SCp->device); 6061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#ifdef NCR_700_DEBUG 6071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk(" ORIGINAL CMD %p RETURNED %d, new return is %d sense is\n", 6081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCp, SCp->cmnd[7], result); 6091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds scsi_print_sense("53c700", SCp); 6101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif 612b80ca4f7ee36c26d300c5a8f429e73372d153379FUJITA Tomonori dma_unmap_single(hostdata->dev, slot->dma_handle, 613b80ca4f7ee36c26d300c5a8f429e73372d153379FUJITA Tomonori SCSI_SENSE_BUFFERSIZE, DMA_FROM_DEVICE); 6141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* restore the old result if the request sense was 6151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * successful */ 616c603d04ef6826a29f50cb151cb992f256d0cf19dJames Bottomley if (result == 0) 6170f13fc09db68de92585558984bff1c51b87db72fJames Bottomley result = cmnd[7]; 618c603d04ef6826a29f50cb151cb992f256d0cf19dJames Bottomley /* restore the original length */ 619c603d04ef6826a29f50cb151cb992f256d0cf19dJames Bottomley SCp->cmd_len = cmnd[8]; 62067d59dfdeb21df2c16dcd478b66177e91178ecd0James Bottomley } else 6210f13fc09db68de92585558984bff1c51b87db72fJames Bottomley NCR_700_unmap(hostdata, SCp, slot); 62267d59dfdeb21df2c16dcd478b66177e91178ecd0James Bottomley 6231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds free_slot(slot, hostdata); 6241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#ifdef NCR_700_DEBUG 6251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(NCR_700_get_depth(SCp->device) == 0 || 6261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_get_depth(SCp->device) > SCp->device->queue_depth) 6271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk(KERN_ERR "Invalid depth in NCR_700_scsi_done(): %d\n", 6281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_get_depth(SCp->device)); 6291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif /* NCR_700_DEBUG */ 6301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_set_depth(SCp->device, NCR_700_get_depth(SCp->device) - 1); 6311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCp->host_scribble = NULL; 6331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCp->result = result; 6341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCp->scsi_done(SCp); 6351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 6361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk(KERN_ERR "53c700: SCSI DONE HAS NULL SCp\n"); 6371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 6381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 6391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsSTATIC void 6421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsNCR_700_internal_bus_reset(struct Scsi_Host *host) 6431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 6441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Bus reset */ 6451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_writeb(ASSERT_RST, host, SCNTL1_REG); 6461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds udelay(50); 6471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_writeb(0, host, SCNTL1_REG); 6481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 6501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsSTATIC void 6521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsNCR_700_chip_setup(struct Scsi_Host *host) 6531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 6541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct NCR_700_Host_Parameters *hostdata = 6551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (struct NCR_700_Host_Parameters *)host->hostdata[0]; 6561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds __u8 min_period; 6571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds __u8 min_xferp = (hostdata->chip710 ? NCR_710_MIN_XFERP : NCR_700_MIN_XFERP); 6581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(hostdata->chip710) { 660f67a9c1592b3a0292376bdcbdcc34cbe353967a8Thomas Bogendoerfer __u8 burst_disable = 0; 661f67a9c1592b3a0292376bdcbdcc34cbe353967a8Thomas Bogendoerfer __u8 burst_length = 0; 662f67a9c1592b3a0292376bdcbdcc34cbe353967a8Thomas Bogendoerfer 663f67a9c1592b3a0292376bdcbdcc34cbe353967a8Thomas Bogendoerfer switch (hostdata->burst_length) { 664f67a9c1592b3a0292376bdcbdcc34cbe353967a8Thomas Bogendoerfer case 1: 665f67a9c1592b3a0292376bdcbdcc34cbe353967a8Thomas Bogendoerfer burst_length = BURST_LENGTH_1; 666f67a9c1592b3a0292376bdcbdcc34cbe353967a8Thomas Bogendoerfer break; 667f67a9c1592b3a0292376bdcbdcc34cbe353967a8Thomas Bogendoerfer case 2: 668f67a9c1592b3a0292376bdcbdcc34cbe353967a8Thomas Bogendoerfer burst_length = BURST_LENGTH_2; 669f67a9c1592b3a0292376bdcbdcc34cbe353967a8Thomas Bogendoerfer break; 670f67a9c1592b3a0292376bdcbdcc34cbe353967a8Thomas Bogendoerfer case 4: 671f67a9c1592b3a0292376bdcbdcc34cbe353967a8Thomas Bogendoerfer burst_length = BURST_LENGTH_4; 672f67a9c1592b3a0292376bdcbdcc34cbe353967a8Thomas Bogendoerfer break; 673f67a9c1592b3a0292376bdcbdcc34cbe353967a8Thomas Bogendoerfer case 8: 674f67a9c1592b3a0292376bdcbdcc34cbe353967a8Thomas Bogendoerfer burst_length = BURST_LENGTH_8; 675f67a9c1592b3a0292376bdcbdcc34cbe353967a8Thomas Bogendoerfer break; 676f67a9c1592b3a0292376bdcbdcc34cbe353967a8Thomas Bogendoerfer default: 677f67a9c1592b3a0292376bdcbdcc34cbe353967a8Thomas Bogendoerfer burst_disable = BURST_DISABLE; 678f67a9c1592b3a0292376bdcbdcc34cbe353967a8Thomas Bogendoerfer break; 679f67a9c1592b3a0292376bdcbdcc34cbe353967a8Thomas Bogendoerfer } 680632731345bfb87fd1f4dc509928cc4a7efc12a89Kars de Jong hostdata->dcntl_extra |= COMPAT_700_MODE; 6811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 682632731345bfb87fd1f4dc509928cc4a7efc12a89Kars de Jong NCR_700_writeb(hostdata->dcntl_extra, host, DCNTL_REG); 683f67a9c1592b3a0292376bdcbdcc34cbe353967a8Thomas Bogendoerfer NCR_700_writeb(burst_length | hostdata->dmode_extra, 6841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds host, DMODE_710_REG); 685632731345bfb87fd1f4dc509928cc4a7efc12a89Kars de Jong NCR_700_writeb(burst_disable | hostdata->ctest7_extra | 686632731345bfb87fd1f4dc509928cc4a7efc12a89Kars de Jong (hostdata->differential ? DIFF : 0), 687632731345bfb87fd1f4dc509928cc4a7efc12a89Kars de Jong host, CTEST7_REG); 6881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_writeb(BTB_TIMER_DISABLE, host, CTEST0_REG); 6891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_writeb(FULL_ARBITRATION | ENABLE_PARITY | PARITY 6901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds | AUTO_ATN, host, SCNTL0_REG); 6911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 6921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_writeb(BURST_LENGTH_8 | hostdata->dmode_extra, 6931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds host, DMODE_700_REG); 6941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_writeb(hostdata->differential ? 6951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds DIFF : 0, host, CTEST7_REG); 6961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(hostdata->fast) { 6971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* this is for 700-66, does nothing on 700 */ 6981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_writeb(LAST_DIS_ENBL | ENABLE_ACTIVE_NEGATION 6991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds | GENERATE_RECEIVE_PARITY, host, 7001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds CTEST8_REG); 7011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 7021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_writeb(FULL_ARBITRATION | ENABLE_PARITY 7031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds | PARITY | AUTO_ATN, host, SCNTL0_REG); 7041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 7051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 7061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_writeb(1 << host->this_id, host, SCID_REG); 7081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_writeb(0, host, SBCL_REG); 7091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_writeb(ASYNC_OPERATION, host, SXFER_REG); 7101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_writeb(PHASE_MM_INT | SEL_TIMEOUT_INT | GROSS_ERR_INT | UX_DISC_INT 7121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds | RST_INT | PAR_ERR_INT | SELECT_INT, host, SIEN_REG); 7131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_writeb(ABORT_INT | INT_INST_INT | ILGL_INST_INT, host, DIEN_REG); 7151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_writeb(ENABLE_SELECT, host, SCNTL1_REG); 7161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(hostdata->clock > 75) { 7171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk(KERN_ERR "53c700: Clock speed %dMHz is too high: 75Mhz is the maximum this chip can be driven at\n", hostdata->clock); 7181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* do the best we can, but the async clock will be out 7191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * of spec: sync divider 2, async divider 3 */ 7201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds DEBUG(("53c700: sync 2 async 3\n")); 7211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_writeb(SYNC_DIV_2_0, host, SBCL_REG); 722632731345bfb87fd1f4dc509928cc4a7efc12a89Kars de Jong NCR_700_writeb(ASYNC_DIV_3_0 | hostdata->dcntl_extra, host, DCNTL_REG); 7231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hostdata->sync_clock = hostdata->clock/2; 7241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else if(hostdata->clock > 50 && hostdata->clock <= 75) { 7251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* sync divider 1.5, async divider 3 */ 7261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds DEBUG(("53c700: sync 1.5 async 3\n")); 7271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_writeb(SYNC_DIV_1_5, host, SBCL_REG); 728632731345bfb87fd1f4dc509928cc4a7efc12a89Kars de Jong NCR_700_writeb(ASYNC_DIV_3_0 | hostdata->dcntl_extra, host, DCNTL_REG); 7291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hostdata->sync_clock = hostdata->clock*2; 7301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hostdata->sync_clock /= 3; 7311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else if(hostdata->clock > 37 && hostdata->clock <= 50) { 7331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* sync divider 1, async divider 2 */ 7341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds DEBUG(("53c700: sync 1 async 2\n")); 7351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_writeb(SYNC_DIV_1_0, host, SBCL_REG); 736632731345bfb87fd1f4dc509928cc4a7efc12a89Kars de Jong NCR_700_writeb(ASYNC_DIV_2_0 | hostdata->dcntl_extra, host, DCNTL_REG); 7371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hostdata->sync_clock = hostdata->clock; 7381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else if(hostdata->clock > 25 && hostdata->clock <=37) { 7391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* sync divider 1, async divider 1.5 */ 7401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds DEBUG(("53c700: sync 1 async 1.5\n")); 7411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_writeb(SYNC_DIV_1_0, host, SBCL_REG); 742632731345bfb87fd1f4dc509928cc4a7efc12a89Kars de Jong NCR_700_writeb(ASYNC_DIV_1_5 | hostdata->dcntl_extra, host, DCNTL_REG); 7431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hostdata->sync_clock = hostdata->clock; 7441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 7451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds DEBUG(("53c700: sync 1 async 1\n")); 7461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_writeb(SYNC_DIV_1_0, host, SBCL_REG); 747632731345bfb87fd1f4dc509928cc4a7efc12a89Kars de Jong NCR_700_writeb(ASYNC_DIV_1_0 | hostdata->dcntl_extra, host, DCNTL_REG); 7481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* sync divider 1, async divider 1 */ 7491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hostdata->sync_clock = hostdata->clock; 7501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 7511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Calculate the actual minimum period that can be supported 7521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * by our synchronous clock speed. See the 710 manual for 7531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * exact details of this calculation which is based on a 7541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * setting of the SXFER register */ 7551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds min_period = 1000*(4+min_xferp)/(4*hostdata->sync_clock); 7561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hostdata->min_period = NCR_700_MIN_PERIOD; 7571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(min_period > NCR_700_MIN_PERIOD) 7581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hostdata->min_period = min_period; 7591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 7601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsSTATIC void 7621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsNCR_700_chip_reset(struct Scsi_Host *host) 7631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 7641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct NCR_700_Host_Parameters *hostdata = 7651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (struct NCR_700_Host_Parameters *)host->hostdata[0]; 7661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(hostdata->chip710) { 7671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_writeb(SOFTWARE_RESET_710, host, ISTAT_REG); 7681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds udelay(100); 7691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_writeb(0, host, ISTAT_REG); 7711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 7721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_writeb(SOFTWARE_RESET, host, DCNTL_REG); 7731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds udelay(100); 7741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_writeb(0, host, DCNTL_REG); 7761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 7771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mdelay(1000); 7791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_chip_setup(host); 7811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 7821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* The heart of the message processing engine is that the instruction 7841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * immediately after the INT is the normal case (and so must be CLEAR 7851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * ACK). If we want to do something else, we call that routine in 7861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * scripts and set temp to be the normal case + 8 (skipping the CLEAR 7871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * ACK) so that the routine returns correctly to resume its activity 7881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * */ 7891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsSTATIC __u32 7901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsprocess_extended_message(struct Scsi_Host *host, 7911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct NCR_700_Host_Parameters *hostdata, 7921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct scsi_cmnd *SCp, __u32 dsp, __u32 dsps) 7931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 7941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds __u32 resume_offset = dsp, temp = dsp + 8; 7951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds __u8 pun = 0xff, lun = 0xff; 7961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(SCp != NULL) { 7981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pun = SCp->device->id; 7991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds lun = SCp->device->lun; 8001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 8011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds switch(hostdata->msgin[2]) { 8031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case A_SDTR_MSG: 8041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(SCp != NULL && NCR_700_is_flag_set(SCp->device, NCR_700_DEV_BEGIN_SYNC_NEGOTIATION)) { 8051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct scsi_target *starget = SCp->device->sdev_target; 8061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds __u8 period = hostdata->msgin[3]; 8071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds __u8 offset = hostdata->msgin[4]; 8081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(offset == 0 || period == 0) { 8101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds offset = 0; 8111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds period = 0; 8121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 8131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spi_offset(starget) = offset; 8151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spi_period(starget) = period; 8161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(NCR_700_is_flag_set(SCp->device, NCR_700_DEV_PRINT_SYNC_NEGOTIATION)) { 8181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spi_display_xfer_agreement(starget); 8191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_clear_flag(SCp->device, NCR_700_DEV_PRINT_SYNC_NEGOTIATION); 8201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 8211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_set_flag(SCp->device, NCR_700_DEV_NEGOTIATED_SYNC); 8231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_clear_flag(SCp->device, NCR_700_DEV_BEGIN_SYNC_NEGOTIATION); 8241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_writeb(NCR_700_get_SXFER(SCp->device), 8261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds host, SXFER_REG); 8271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 8291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* SDTR message out of the blue, reject it */ 830017560fca496f72ed9dd734ffde63ce39dfe0411Jeff Garzik shost_printk(KERN_WARNING, host, 831017560fca496f72ed9dd734ffde63ce39dfe0411Jeff Garzik "Unexpected SDTR msg\n"); 8321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hostdata->msgout[0] = A_REJECT_MSG; 833d3fa72e4556ec1f04e46a0d561d9e785ecaa173dRalf Baechle dma_cache_sync(hostdata->dev, hostdata->msgout, 1, DMA_TO_DEVICE); 834d3fa72e4556ec1f04e46a0d561d9e785ecaa173dRalf Baechle script_patch_16(hostdata->dev, hostdata->script, 835d3fa72e4556ec1f04e46a0d561d9e785ecaa173dRalf Baechle MessageCount, 1); 8361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* SendMsgOut returns, so set up the return 8371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * address */ 8381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds resume_offset = hostdata->pScript + Ent_SendMessageWithATN; 8391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 8401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds break; 8411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case A_WDTR_MSG: 8431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk(KERN_INFO "scsi%d: (%d:%d), Unsolicited WDTR after CMD, Rejecting\n", 8441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds host->host_no, pun, lun); 8451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hostdata->msgout[0] = A_REJECT_MSG; 846d3fa72e4556ec1f04e46a0d561d9e785ecaa173dRalf Baechle dma_cache_sync(hostdata->dev, hostdata->msgout, 1, DMA_TO_DEVICE); 847d3fa72e4556ec1f04e46a0d561d9e785ecaa173dRalf Baechle script_patch_16(hostdata->dev, hostdata->script, MessageCount, 848d3fa72e4556ec1f04e46a0d561d9e785ecaa173dRalf Baechle 1); 8491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds resume_offset = hostdata->pScript + Ent_SendMessageWithATN; 8501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds break; 8521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds default: 8541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk(KERN_INFO "scsi%d (%d:%d): Unexpected message %s: ", 8551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds host->host_no, pun, lun, 8561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_phase[(dsps & 0xf00) >> 8]); 8571abfd370134553f3b47e3e40a0526e05001409c2Matthew Wilcox spi_print_msg(hostdata->msgin); 8581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("\n"); 8591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* just reject it */ 8601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hostdata->msgout[0] = A_REJECT_MSG; 861d3fa72e4556ec1f04e46a0d561d9e785ecaa173dRalf Baechle dma_cache_sync(hostdata->dev, hostdata->msgout, 1, DMA_TO_DEVICE); 862d3fa72e4556ec1f04e46a0d561d9e785ecaa173dRalf Baechle script_patch_16(hostdata->dev, hostdata->script, MessageCount, 863d3fa72e4556ec1f04e46a0d561d9e785ecaa173dRalf Baechle 1); 8641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* SendMsgOut returns, so set up the return 8651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * address */ 8661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds resume_offset = hostdata->pScript + Ent_SendMessageWithATN; 8671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 8681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_writel(temp, host, TEMP_REG); 8691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return resume_offset; 8701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 8711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsSTATIC __u32 8731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsprocess_message(struct Scsi_Host *host, struct NCR_700_Host_Parameters *hostdata, 8741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct scsi_cmnd *SCp, __u32 dsp, __u32 dsps) 8751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 8761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* work out where to return to */ 8771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds __u32 temp = dsp + 8, resume_offset = dsp; 8781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds __u8 pun = 0xff, lun = 0xff; 8791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(SCp != NULL) { 8811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pun = SCp->device->id; 8821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds lun = SCp->device->lun; 8831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 8841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#ifdef NCR_700_DEBUG 8861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("scsi%d (%d:%d): message %s: ", host->host_no, pun, lun, 8871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_phase[(dsps & 0xf00) >> 8]); 8881abfd370134553f3b47e3e40a0526e05001409c2Matthew Wilcox spi_print_msg(hostdata->msgin); 8891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("\n"); 8901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif 8911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds switch(hostdata->msgin[0]) { 8931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case A_EXTENDED_MSG: 8951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds resume_offset = process_extended_message(host, hostdata, SCp, 8961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dsp, dsps); 8971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds break; 8981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case A_REJECT_MSG: 9001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(SCp != NULL && NCR_700_is_flag_set(SCp->device, NCR_700_DEV_BEGIN_SYNC_NEGOTIATION)) { 9011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Rejected our sync negotiation attempt */ 9021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spi_period(SCp->device->sdev_target) = 9031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spi_offset(SCp->device->sdev_target) = 0; 9041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_set_flag(SCp->device, NCR_700_DEV_NEGOTIATED_SYNC); 9051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_clear_flag(SCp->device, NCR_700_DEV_BEGIN_SYNC_NEGOTIATION); 9061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else if(SCp != NULL && NCR_700_get_tag_neg_state(SCp->device) == NCR_700_DURING_TAG_NEGOTIATION) { 9071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* rejected our first simple tag message */ 908017560fca496f72ed9dd734ffde63ce39dfe0411Jeff Garzik scmd_printk(KERN_WARNING, SCp, 909017560fca496f72ed9dd734ffde63ce39dfe0411Jeff Garzik "Rejected first tag queue attempt, turning off tag queueing\n"); 9101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* we're done negotiating */ 9111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_set_tag_neg_state(SCp->device, NCR_700_FINISHED_TAG_NEGOTIATION); 912017560fca496f72ed9dd734ffde63ce39dfe0411Jeff Garzik hostdata->tag_negotiated &= ~(1<<scmd_id(SCp)); 9131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCp->device->tagged_supported = 0; 9141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds scsi_deactivate_tcq(SCp->device, host->cmd_per_lun); 9151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 916017560fca496f72ed9dd734ffde63ce39dfe0411Jeff Garzik shost_printk(KERN_WARNING, host, 917017560fca496f72ed9dd734ffde63ce39dfe0411Jeff Garzik "(%d:%d) Unexpected REJECT Message %s\n", 918017560fca496f72ed9dd734ffde63ce39dfe0411Jeff Garzik pun, lun, 9191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_phase[(dsps & 0xf00) >> 8]); 9201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* however, just ignore it */ 9211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 9221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds break; 9231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case A_PARITY_ERROR_MSG: 9251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk(KERN_ERR "scsi%d (%d:%d) Parity Error!\n", host->host_no, 9261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pun, lun); 9271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_internal_bus_reset(host); 9281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds break; 9291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case A_SIMPLE_TAG_MSG: 9301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk(KERN_INFO "scsi%d (%d:%d) SIMPLE TAG %d %s\n", host->host_no, 9311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pun, lun, hostdata->msgin[1], 9321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_phase[(dsps & 0xf00) >> 8]); 9331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* just ignore it */ 9341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds break; 9351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds default: 9361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk(KERN_INFO "scsi%d (%d:%d): Unexpected message %s: ", 9371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds host->host_no, pun, lun, 9381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_phase[(dsps & 0xf00) >> 8]); 9391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9401abfd370134553f3b47e3e40a0526e05001409c2Matthew Wilcox spi_print_msg(hostdata->msgin); 9411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("\n"); 9421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* just reject it */ 9431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hostdata->msgout[0] = A_REJECT_MSG; 944d3fa72e4556ec1f04e46a0d561d9e785ecaa173dRalf Baechle dma_cache_sync(hostdata->dev, hostdata->msgout, 1, DMA_TO_DEVICE); 945d3fa72e4556ec1f04e46a0d561d9e785ecaa173dRalf Baechle script_patch_16(hostdata->dev, hostdata->script, MessageCount, 946d3fa72e4556ec1f04e46a0d561d9e785ecaa173dRalf Baechle 1); 9471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* SendMsgOut returns, so set up the return 9481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * address */ 9491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds resume_offset = hostdata->pScript + Ent_SendMessageWithATN; 9501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds break; 9521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 9531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_writel(temp, host, TEMP_REG); 9541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* set us up to receive another message */ 955d3fa72e4556ec1f04e46a0d561d9e785ecaa173dRalf Baechle dma_cache_sync(hostdata->dev, hostdata->msgin, MSG_ARRAY_SIZE, DMA_FROM_DEVICE); 9561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return resume_offset; 9571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 9581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsSTATIC __u32 9601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsprocess_script_interrupt(__u32 dsps, __u32 dsp, struct scsi_cmnd *SCp, 9611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct Scsi_Host *host, 9621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct NCR_700_Host_Parameters *hostdata) 9631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 9641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds __u32 resume_offset = 0; 9651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds __u8 pun = 0xff, lun=0xff; 9661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(SCp != NULL) { 9681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pun = SCp->device->id; 9691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds lun = SCp->device->lun; 9701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 9711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(dsps == A_GOOD_STATUS_AFTER_STATUS) { 9731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds DEBUG((" COMMAND COMPLETE, status=%02x\n", 9741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hostdata->status[0])); 9751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* OK, if TCQ still under negotiation, we now know it works */ 9761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (NCR_700_get_tag_neg_state(SCp->device) == NCR_700_DURING_TAG_NEGOTIATION) 9771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_set_tag_neg_state(SCp->device, 9781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_FINISHED_TAG_NEGOTIATION); 9791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* check for contingent allegiance contitions */ 9811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(status_byte(hostdata->status[0]) == CHECK_CONDITION || 9821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds status_byte(hostdata->status[0]) == COMMAND_TERMINATED) { 9831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct NCR_700_command_slot *slot = 9841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (struct NCR_700_command_slot *)SCp->host_scribble; 9850f13fc09db68de92585558984bff1c51b87db72fJames Bottomley if(slot->flags == NCR_700_FLAG_AUTOSENSE) { 9861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* OOPS: bad device, returning another 9871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * contingent allegiance condition */ 988017560fca496f72ed9dd734ffde63ce39dfe0411Jeff Garzik scmd_printk(KERN_ERR, SCp, 989017560fca496f72ed9dd734ffde63ce39dfe0411Jeff Garzik "broken device is looping in contingent allegiance: ignoring\n"); 9901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_scsi_done(hostdata, SCp, hostdata->status[0]); 9911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 9920f13fc09db68de92585558984bff1c51b87db72fJames Bottomley char *cmnd = 9930f13fc09db68de92585558984bff1c51b87db72fJames Bottomley NCR_700_get_sense_cmnd(SCp->device); 9941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#ifdef NCR_DEBUG 9951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds scsi_print_command(SCp); 9961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk(" cmd %p has status %d, requesting sense\n", 9971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCp, hostdata->status[0]); 9981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif 9991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* we can destroy the command here 10001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * because the contingent allegiance 10011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * condition will cause a retry which 10021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * will re-copy the command from the 10031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * saved data_cmnd. We also unmap any 10041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * data associated with the command 10051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * here */ 10061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_unmap(hostdata, SCp, slot); 100767d59dfdeb21df2c16dcd478b66177e91178ecd0James Bottomley dma_unmap_single(hostdata->dev, slot->pCmd, 100864a87b244b9297667ca80264aab849a36f494884Boaz Harrosh MAX_COMMAND_SIZE, 100967d59dfdeb21df2c16dcd478b66177e91178ecd0James Bottomley DMA_TO_DEVICE); 101067d59dfdeb21df2c16dcd478b66177e91178ecd0James Bottomley 10110f13fc09db68de92585558984bff1c51b87db72fJames Bottomley cmnd[0] = REQUEST_SENSE; 10120f13fc09db68de92585558984bff1c51b87db72fJames Bottomley cmnd[1] = (SCp->device->lun & 0x7) << 5; 10130f13fc09db68de92585558984bff1c51b87db72fJames Bottomley cmnd[2] = 0; 10140f13fc09db68de92585558984bff1c51b87db72fJames Bottomley cmnd[3] = 0; 1015b80ca4f7ee36c26d300c5a8f429e73372d153379FUJITA Tomonori cmnd[4] = SCSI_SENSE_BUFFERSIZE; 10160f13fc09db68de92585558984bff1c51b87db72fJames Bottomley cmnd[5] = 0; 10171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Here's a quiet hack: the 10181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * REQUEST_SENSE command is six bytes, 10191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * so store a flag indicating that 10201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * this was an internal sense request 10211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * and the original status at the end 10221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * of the command */ 10230f13fc09db68de92585558984bff1c51b87db72fJames Bottomley cmnd[6] = NCR_700_INTERNAL_SENSE_MAGIC; 10240f13fc09db68de92585558984bff1c51b87db72fJames Bottomley cmnd[7] = hostdata->status[0]; 1025c603d04ef6826a29f50cb151cb992f256d0cf19dJames Bottomley cmnd[8] = SCp->cmd_len; 1026c603d04ef6826a29f50cb151cb992f256d0cf19dJames Bottomley SCp->cmd_len = 6; /* command length for 1027c603d04ef6826a29f50cb151cb992f256d0cf19dJames Bottomley * REQUEST_SENSE */ 10280f13fc09db68de92585558984bff1c51b87db72fJames Bottomley slot->pCmd = dma_map_single(hostdata->dev, cmnd, MAX_COMMAND_SIZE, DMA_TO_DEVICE); 1029b80ca4f7ee36c26d300c5a8f429e73372d153379FUJITA Tomonori slot->dma_handle = dma_map_single(hostdata->dev, SCp->sense_buffer, SCSI_SENSE_BUFFERSIZE, DMA_FROM_DEVICE); 1030b80ca4f7ee36c26d300c5a8f429e73372d153379FUJITA Tomonori slot->SG[0].ins = bS_to_host(SCRIPT_MOVE_DATA_IN | SCSI_SENSE_BUFFERSIZE); 10311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds slot->SG[0].pAddr = bS_to_host(slot->dma_handle); 10321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds slot->SG[1].ins = bS_to_host(SCRIPT_RETURN); 10331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds slot->SG[1].pAddr = 0; 10341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds slot->resume_offset = hostdata->pScript; 1035d3fa72e4556ec1f04e46a0d561d9e785ecaa173dRalf Baechle dma_cache_sync(hostdata->dev, slot->SG, sizeof(slot->SG[0])*2, DMA_TO_DEVICE); 1036b80ca4f7ee36c26d300c5a8f429e73372d153379FUJITA Tomonori dma_cache_sync(hostdata->dev, SCp->sense_buffer, SCSI_SENSE_BUFFERSIZE, DMA_FROM_DEVICE); 1037d3fa72e4556ec1f04e46a0d561d9e785ecaa173dRalf Baechle 10381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* queue the command for reissue */ 10391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds slot->state = NCR_700_SLOT_QUEUED; 104067d59dfdeb21df2c16dcd478b66177e91178ecd0James Bottomley slot->flags = NCR_700_FLAG_AUTOSENSE; 10411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hostdata->state = NCR_700_HOST_FREE; 10421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hostdata->cmd = NULL; 10431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 10441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 10451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds // Currently rely on the mid layer evaluation 10461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds // of the tag queuing capability 10471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds // 10481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds //if(status_byte(hostdata->status[0]) == GOOD && 10491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds // SCp->cmnd[0] == INQUIRY && SCp->use_sg == 0) { 10501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds // /* Piggy back the tag queueing support 10511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds // * on this command */ 10521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds // dma_sync_single_for_cpu(hostdata->dev, 10531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds // slot->dma_handle, 10541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds // SCp->request_bufflen, 10551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds // DMA_FROM_DEVICE); 10561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds // if(((char *)SCp->request_buffer)[7] & 0x02) { 1057017560fca496f72ed9dd734ffde63ce39dfe0411Jeff Garzik // scmd_printk(KERN_INFO, SCp, 1058017560fca496f72ed9dd734ffde63ce39dfe0411Jeff Garzik // "Enabling Tag Command Queuing\n"); 1059017560fca496f72ed9dd734ffde63ce39dfe0411Jeff Garzik // hostdata->tag_negotiated |= (1<<scmd_id(SCp)); 10601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds // NCR_700_set_flag(SCp->device, NCR_700_DEV_BEGIN_TAG_QUEUEING); 10611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds // } else { 10621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds // NCR_700_clear_flag(SCp->device, NCR_700_DEV_BEGIN_TAG_QUEUEING); 1063017560fca496f72ed9dd734ffde63ce39dfe0411Jeff Garzik // hostdata->tag_negotiated &= ~(1<<scmd_id(SCp)); 10641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds // } 10651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds //} 10661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_scsi_done(hostdata, SCp, hostdata->status[0]); 10671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 10681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else if((dsps & 0xfffff0f0) == A_UNEXPECTED_PHASE) { 10691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds __u8 i = (dsps & 0xf00) >> 8; 10701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1071017560fca496f72ed9dd734ffde63ce39dfe0411Jeff Garzik scmd_printk(KERN_ERR, SCp, "UNEXPECTED PHASE %s (%s)\n", 10721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_phase[i], 10731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds sbcl_to_string(NCR_700_readb(host, SBCL_REG))); 1074017560fca496f72ed9dd734ffde63ce39dfe0411Jeff Garzik scmd_printk(KERN_ERR, SCp, " len = %d, cmd =", 1075017560fca496f72ed9dd734ffde63ce39dfe0411Jeff Garzik SCp->cmd_len); 10761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds scsi_print_command(SCp); 10771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_internal_bus_reset(host); 10791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else if((dsps & 0xfffff000) == A_FATAL) { 10801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int i = (dsps & 0xfff); 10811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk(KERN_ERR "scsi%d: (%d:%d) FATAL ERROR: %s\n", 10831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds host->host_no, pun, lun, NCR_700_fatal_messages[i]); 10841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(dsps == A_FATAL_ILLEGAL_MSG_LENGTH) { 10851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk(KERN_ERR " msg begins %02x %02x\n", 10861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hostdata->msgin[0], hostdata->msgin[1]); 10871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 10881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_internal_bus_reset(host); 10891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else if((dsps & 0xfffff0f0) == A_DISCONNECT) { 10901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#ifdef NCR_700_DEBUG 10911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds __u8 i = (dsps & 0xf00) >> 8; 10921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("scsi%d: (%d:%d), DISCONNECTED (%d) %s\n", 10941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds host->host_no, pun, lun, 10951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds i, NCR_700_phase[i]); 10961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif 10971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds save_for_reselection(hostdata, SCp, dsp); 10981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else if(dsps == A_RESELECTION_IDENTIFIED) { 11001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds __u8 lun; 11011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct NCR_700_command_slot *slot; 11021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds __u8 reselection_id = hostdata->reselection_id; 11031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct scsi_device *SDp; 11041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds lun = hostdata->msgin[0] & 0x1f; 11061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hostdata->reselection_id = 0xff; 11081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds DEBUG(("scsi%d: (%d:%d) RESELECTED!\n", 11091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds host->host_no, reselection_id, lun)); 11101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* clear the reselection indicator */ 11111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SDp = __scsi_device_lookup(host, 0, reselection_id, lun); 11121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(unlikely(SDp == NULL)) { 11131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk(KERN_ERR "scsi%d: (%d:%d) HAS NO device\n", 11141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds host->host_no, reselection_id, lun); 11151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds BUG(); 11161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 11171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(hostdata->msgin[1] == A_SIMPLE_TAG_MSG) { 11181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct scsi_cmnd *SCp = scsi_find_tag(SDp, hostdata->msgin[2]); 11191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(unlikely(SCp == NULL)) { 11201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk(KERN_ERR "scsi%d: (%d:%d) no saved request for tag %d\n", 11211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds host->host_no, reselection_id, lun, hostdata->msgin[2]); 11221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds BUG(); 11231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 11241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds slot = (struct NCR_700_command_slot *)SCp->host_scribble; 1126017560fca496f72ed9dd734ffde63ce39dfe0411Jeff Garzik DDEBUG(KERN_DEBUG, SDp, 1127017560fca496f72ed9dd734ffde63ce39dfe0411Jeff Garzik "reselection is tag %d, slot %p(%d)\n", 1128017560fca496f72ed9dd734ffde63ce39dfe0411Jeff Garzik hostdata->msgin[2], slot, slot->tag); 11291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 11301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct scsi_cmnd *SCp = scsi_find_tag(SDp, SCSI_NO_TAG); 11311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(unlikely(SCp == NULL)) { 1132017560fca496f72ed9dd734ffde63ce39dfe0411Jeff Garzik sdev_printk(KERN_ERR, SDp, 1133017560fca496f72ed9dd734ffde63ce39dfe0411Jeff Garzik "no saved request for untagged cmd\n"); 11341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds BUG(); 11351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 11361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds slot = (struct NCR_700_command_slot *)SCp->host_scribble; 11371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 11381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(slot == NULL) { 11401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk(KERN_ERR "scsi%d: (%d:%d) RESELECTED but no saved command (MSG = %02x %02x %02x)!!\n", 11411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds host->host_no, reselection_id, lun, 11421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hostdata->msgin[0], hostdata->msgin[1], 11431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hostdata->msgin[2]); 11441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 11451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(hostdata->state != NCR_700_HOST_BUSY) 11461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk(KERN_ERR "scsi%d: FATAL, host not busy during valid reselection!\n", 11471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds host->host_no); 11481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds resume_offset = slot->resume_offset; 11491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hostdata->cmd = slot->cmnd; 11501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* re-patch for this command */ 1152d3fa72e4556ec1f04e46a0d561d9e785ecaa173dRalf Baechle script_patch_32_abs(hostdata->dev, hostdata->script, 1153d3fa72e4556ec1f04e46a0d561d9e785ecaa173dRalf Baechle CommandAddress, slot->pCmd); 1154d3fa72e4556ec1f04e46a0d561d9e785ecaa173dRalf Baechle script_patch_16(hostdata->dev, hostdata->script, 11551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds CommandCount, slot->cmnd->cmd_len); 1156d3fa72e4556ec1f04e46a0d561d9e785ecaa173dRalf Baechle script_patch_32_abs(hostdata->dev, hostdata->script, 1157d3fa72e4556ec1f04e46a0d561d9e785ecaa173dRalf Baechle SGScriptStartAddress, 11581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds to32bit(&slot->pSG[0].ins)); 11591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Note: setting SXFER only works if we're 11611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * still in the MESSAGE phase, so it is vital 11621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * that ACK is still asserted when we process 11631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * the reselection message. The resume offset 11641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * should therefore always clear ACK */ 11651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_writeb(NCR_700_get_SXFER(hostdata->cmd->device), 11661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds host, SXFER_REG); 1167d3fa72e4556ec1f04e46a0d561d9e785ecaa173dRalf Baechle dma_cache_sync(hostdata->dev, hostdata->msgin, 11681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds MSG_ARRAY_SIZE, DMA_FROM_DEVICE); 1169d3fa72e4556ec1f04e46a0d561d9e785ecaa173dRalf Baechle dma_cache_sync(hostdata->dev, hostdata->msgout, 11701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds MSG_ARRAY_SIZE, DMA_TO_DEVICE); 11711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* I'm just being paranoid here, the command should 11721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * already have been flushed from the cache */ 1173d3fa72e4556ec1f04e46a0d561d9e785ecaa173dRalf Baechle dma_cache_sync(hostdata->dev, slot->cmnd->cmnd, 11741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds slot->cmnd->cmd_len, DMA_TO_DEVICE); 11751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 11791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else if(dsps == A_RESELECTED_DURING_SELECTION) { 11801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* This section is full of debugging code because I've 11821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * never managed to reach it. I think what happens is 11831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * that, because the 700 runs with selection 11841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * interrupts enabled the whole time that we take a 11851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * selection interrupt before we manage to get to the 11861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * reselected script interrupt */ 11871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds __u8 reselection_id = NCR_700_readb(host, SFBR_REG); 11891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct NCR_700_command_slot *slot; 11901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Take out our own ID */ 11921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds reselection_id &= ~(1<<host->this_id); 11931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* I've never seen this happen, so keep this as a printk rather 11951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * than a debug */ 11961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk(KERN_INFO "scsi%d: (%d:%d) RESELECTION DURING SELECTION, dsp=%08x[%04x] state=%d, count=%d\n", 11971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds host->host_no, reselection_id, lun, dsp, dsp - hostdata->pScript, hostdata->state, hostdata->command_slot_count); 11981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds { 12001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* FIXME: DEBUGGING CODE */ 12011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds __u32 SG = (__u32)bS_to_cpu(hostdata->script[A_SGScriptStartAddress_used[0]]); 12021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int i; 12031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for(i=0; i< NCR_700_COMMAND_SLOTS_PER_HOST; i++) { 12051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(SG >= to32bit(&hostdata->slots[i].pSG[0]) 12061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds && SG <= to32bit(&hostdata->slots[i].pSG[NCR_700_SG_SEGMENTS])) 12071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds break; 12081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 12091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus 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); 12101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCp = hostdata->slots[i].cmnd; 12111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 12121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(SCp != NULL) { 12141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds slot = (struct NCR_700_command_slot *)SCp->host_scribble; 12151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* change slot from busy to queued to redo command */ 12161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds slot->state = NCR_700_SLOT_QUEUED; 12171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 12181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hostdata->cmd = NULL; 12191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(reselection_id == 0) { 12211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(hostdata->reselection_id == 0xff) { 12221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk(KERN_ERR "scsi%d: Invalid reselection during selection!!\n", host->host_no); 12231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 0; 12241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 12251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk(KERN_ERR "scsi%d: script reselected and we took a selection interrupt\n", 12261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds host->host_no); 12271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds reselection_id = hostdata->reselection_id; 12281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 12291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 12301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* convert to real ID */ 12321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds reselection_id = bitmap_to_number(reselection_id); 12331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 12341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hostdata->reselection_id = reselection_id; 12351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* just in case we have a stale simple tag message, clear it */ 12361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hostdata->msgin[1] = 0; 1237d3fa72e4556ec1f04e46a0d561d9e785ecaa173dRalf Baechle dma_cache_sync(hostdata->dev, hostdata->msgin, 12381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds MSG_ARRAY_SIZE, DMA_BIDIRECTIONAL); 12391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(hostdata->tag_negotiated & (1<<reselection_id)) { 12401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds resume_offset = hostdata->pScript + Ent_GetReselectionWithTag; 12411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 12421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds resume_offset = hostdata->pScript + Ent_GetReselectionData; 12431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 12441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else if(dsps == A_COMPLETED_SELECTION_AS_TARGET) { 12451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* we've just disconnected from the bus, do nothing since 12461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * a return here will re-run the queued command slot 12471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * that may have been interrupted by the initial selection */ 12481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds DEBUG((" SELECTION COMPLETED\n")); 12491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else if((dsps & 0xfffff0f0) == A_MSG_IN) { 12501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds resume_offset = process_message(host, hostdata, SCp, 12511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dsp, dsps); 12521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else if((dsps & 0xfffff000) == 0) { 12531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds __u8 i = (dsps & 0xf0) >> 4, j = (dsps & 0xf00) >> 8; 12541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk(KERN_ERR "scsi%d: (%d:%d), unhandled script condition %s %s at %04x\n", 12551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds host->host_no, pun, lun, NCR_700_condition[i], 12561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_phase[j], dsp - hostdata->pScript); 12571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(SCp != NULL) { 12583258a4d5690880a62121553b604893ecaca7d042FUJITA Tomonori struct scatterlist *sg; 12591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12603258a4d5690880a62121553b604893ecaca7d042FUJITA Tomonori scsi_print_command(SCp); 12613258a4d5690880a62121553b604893ecaca7d042FUJITA Tomonori scsi_for_each_sg(SCp, sg, scsi_sg_count(SCp) + 1, i) { 12623258a4d5690880a62121553b604893ecaca7d042FUJITA Tomonori printk(KERN_INFO " SG[%d].length = %d, move_insn=%08x, addr %08x\n", i, sg->length, ((struct NCR_700_command_slot *)SCp->host_scribble)->SG[i].ins, ((struct NCR_700_command_slot *)SCp->host_scribble)->SG[i].pAddr); 12631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 12643258a4d5690880a62121553b604893ecaca7d042FUJITA Tomonori } 12651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_internal_bus_reset(host); 12661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else if((dsps & 0xfffff000) == A_DEBUG_INTERRUPT) { 12671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk(KERN_NOTICE "scsi%d (%d:%d) DEBUG INTERRUPT %d AT %08x[%04x], continuing\n", 12681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds host->host_no, pun, lun, dsps & 0xfff, dsp, dsp - hostdata->pScript); 12691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds resume_offset = dsp; 12701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 12711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk(KERN_ERR "scsi%d: (%d:%d), unidentified script interrupt 0x%x at %04x\n", 12721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds host->host_no, pun, lun, dsps, dsp - hostdata->pScript); 12731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_internal_bus_reset(host); 12741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 12751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return resume_offset; 12761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 12771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* We run the 53c700 with selection interrupts always enabled. This 12791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * means that the chip may be selected as soon as the bus frees. On a 12801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * busy bus, this can be before the scripts engine finishes its 12811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * processing. Therefore, part of the selection processing has to be 12821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * to find out what the scripts engine is doing and complete the 12831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * function if necessary (i.e. process the pending disconnect or save 12841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * the interrupted initial selection */ 12851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsSTATIC inline __u32 12861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsprocess_selection(struct Scsi_Host *host, __u32 dsp) 12871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 12881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds __u8 id = 0; /* Squash compiler warning */ 12891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int count = 0; 12901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds __u32 resume_offset = 0; 12911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct NCR_700_Host_Parameters *hostdata = 12921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (struct NCR_700_Host_Parameters *)host->hostdata[0]; 12931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct scsi_cmnd *SCp = hostdata->cmd; 12941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds __u8 sbcl; 12951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for(count = 0; count < 5; count++) { 12971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds id = NCR_700_readb(host, hostdata->chip710 ? 12981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds CTEST9_REG : SFBR_REG); 12991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Take out our own ID */ 13011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds id &= ~(1<<host->this_id); 13021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(id != 0) 13031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds break; 13041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds udelay(5); 13051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 13061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds sbcl = NCR_700_readb(host, SBCL_REG); 13071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if((sbcl & SBCL_IO) == 0) { 13081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* mark as having been selected rather than reselected */ 13091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds id = 0xff; 13101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 13111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* convert to real ID */ 13121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hostdata->reselection_id = id = bitmap_to_number(id); 13131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds DEBUG(("scsi%d: Reselected by %d\n", 13141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds host->host_no, id)); 13151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 13161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(hostdata->state == NCR_700_HOST_BUSY && SCp != NULL) { 13171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct NCR_700_command_slot *slot = 13181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (struct NCR_700_command_slot *)SCp->host_scribble; 13191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus 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)); 13201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds switch(dsp - hostdata->pScript) { 13221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case Ent_Disconnect1: 13231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case Ent_Disconnect2: 13241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds save_for_reselection(hostdata, SCp, Ent_Disconnect2 + hostdata->pScript); 13251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds break; 13261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case Ent_Disconnect3: 13271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case Ent_Disconnect4: 13281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds save_for_reselection(hostdata, SCp, Ent_Disconnect4 + hostdata->pScript); 13291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds break; 13301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case Ent_Disconnect5: 13311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case Ent_Disconnect6: 13321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds save_for_reselection(hostdata, SCp, Ent_Disconnect6 + hostdata->pScript); 13331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds break; 13341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case Ent_Disconnect7: 13351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case Ent_Disconnect8: 13361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds save_for_reselection(hostdata, SCp, Ent_Disconnect8 + hostdata->pScript); 13371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds break; 13381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case Ent_Finish1: 13391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case Ent_Finish2: 13401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds process_script_interrupt(A_GOOD_STATUS_AFTER_STATUS, dsp, SCp, host, hostdata); 13411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds break; 13421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds default: 13441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds slot->state = NCR_700_SLOT_QUEUED; 13451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds break; 13461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 13471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 13481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hostdata->state = NCR_700_HOST_BUSY; 13491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hostdata->cmd = NULL; 13501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* clear any stale simple tag message */ 13511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hostdata->msgin[1] = 0; 1352d3fa72e4556ec1f04e46a0d561d9e785ecaa173dRalf Baechle dma_cache_sync(hostdata->dev, hostdata->msgin, MSG_ARRAY_SIZE, 13531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds DMA_BIDIRECTIONAL); 13541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(id == 0xff) { 13561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Selected as target, Ignore */ 13571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds resume_offset = hostdata->pScript + Ent_SelectedAsTarget; 13581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else if(hostdata->tag_negotiated & (1<<id)) { 13591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds resume_offset = hostdata->pScript + Ent_GetReselectionWithTag; 13601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 13611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds resume_offset = hostdata->pScript + Ent_GetReselectionData; 13621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 13631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return resume_offset; 13641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 13651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic inline void 13671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsNCR_700_clear_fifo(struct Scsi_Host *host) { 13681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds const struct NCR_700_Host_Parameters *hostdata 13691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds = (struct NCR_700_Host_Parameters *)host->hostdata[0]; 13701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(hostdata->chip710) { 13711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_writeb(CLR_FIFO_710, host, CTEST8_REG); 13721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 13731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_writeb(CLR_FIFO, host, DFIFO_REG); 13741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 13751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 13761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic inline void 13781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsNCR_700_flush_fifo(struct Scsi_Host *host) { 13791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds const struct NCR_700_Host_Parameters *hostdata 13801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds = (struct NCR_700_Host_Parameters *)host->hostdata[0]; 13811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(hostdata->chip710) { 13821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_writeb(FLUSH_DMA_FIFO_710, host, CTEST8_REG); 13831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds udelay(10); 13841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_writeb(0, host, CTEST8_REG); 13851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 13861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_writeb(FLUSH_DMA_FIFO, host, DFIFO_REG); 13871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds udelay(10); 13881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_writeb(0, host, DFIFO_REG); 13891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 13901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 13911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* The queue lock with interrupts disabled must be held on entry to 13941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * this function */ 13951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsSTATIC int 13961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsNCR_700_start_command(struct scsi_cmnd *SCp) 13971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 13981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct NCR_700_command_slot *slot = 13991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (struct NCR_700_command_slot *)SCp->host_scribble; 14001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct NCR_700_Host_Parameters *hostdata = 14011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (struct NCR_700_Host_Parameters *)SCp->device->host->hostdata[0]; 14021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds __u16 count = 1; /* for IDENTIFY message */ 14031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(hostdata->state != NCR_700_HOST_FREE) { 14051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* keep this inside the lock to close the race window where 14061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * the running command finishes on another CPU while we don't 14071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * change the state to queued on this one */ 14081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds slot->state = NCR_700_SLOT_QUEUED; 14091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds DEBUG(("scsi%d: host busy, queueing command %p, slot %p\n", 14111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCp->device->host->host_no, slot->cmnd, slot)); 14121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 0; 14131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 14141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hostdata->state = NCR_700_HOST_BUSY; 14151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hostdata->cmd = SCp; 14161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds slot->state = NCR_700_SLOT_BUSY; 14171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* keep interrupts disabled until we have the command correctly 14181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * set up so we cannot take a selection interrupt */ 14191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 142067d59dfdeb21df2c16dcd478b66177e91178ecd0James Bottomley hostdata->msgout[0] = NCR_700_identify((SCp->cmnd[0] != REQUEST_SENSE && 142167d59dfdeb21df2c16dcd478b66177e91178ecd0James Bottomley slot->flags != NCR_700_FLAG_AUTOSENSE), 14221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCp->device->lun); 14231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* for INQUIRY or REQUEST_SENSE commands, we cannot be sure 14241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * if the negotiated transfer parameters still hold, so 14251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * always renegotiate them */ 142667d59dfdeb21df2c16dcd478b66177e91178ecd0James Bottomley if(SCp->cmnd[0] == INQUIRY || SCp->cmnd[0] == REQUEST_SENSE || 142767d59dfdeb21df2c16dcd478b66177e91178ecd0James Bottomley slot->flags == NCR_700_FLAG_AUTOSENSE) { 14281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_clear_flag(SCp->device, NCR_700_DEV_NEGOTIATED_SYNC); 14291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 14301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* REQUEST_SENSE is asking for contingent I_T_L(_Q) status. 14321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * If a contingent allegiance condition exists, the device 14331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * will refuse all tags, so send the request sense as untagged 14341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * */ 1435422c0d61d591cbfb70f029e13505fb437e169d68Jeff Garzik if((hostdata->tag_negotiated & (1<<scmd_id(SCp))) 143667d59dfdeb21df2c16dcd478b66177e91178ecd0James Bottomley && (slot->tag != SCSI_NO_TAG && SCp->cmnd[0] != REQUEST_SENSE && 143767d59dfdeb21df2c16dcd478b66177e91178ecd0James Bottomley slot->flags != NCR_700_FLAG_AUTOSENSE)) { 14381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds count += scsi_populate_tag_msg(SCp, &hostdata->msgout[count]); 14391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 14401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(hostdata->fast && 14421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_is_flag_clear(SCp->device, NCR_700_DEV_NEGOTIATED_SYNC)) { 14436ea3c0b2dac0d6a857d6bc010e544f4c901fff78Matthew Wilcox count += spi_populate_sync_msg(&hostdata->msgout[count], 14446ea3c0b2dac0d6a857d6bc010e544f4c901fff78Matthew Wilcox spi_period(SCp->device->sdev_target), 14456ea3c0b2dac0d6a857d6bc010e544f4c901fff78Matthew Wilcox spi_offset(SCp->device->sdev_target)); 14461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_set_flag(SCp->device, NCR_700_DEV_BEGIN_SYNC_NEGOTIATION); 14471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 14481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1449d3fa72e4556ec1f04e46a0d561d9e785ecaa173dRalf Baechle script_patch_16(hostdata->dev, hostdata->script, MessageCount, count); 14501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1452d3fa72e4556ec1f04e46a0d561d9e785ecaa173dRalf Baechle script_patch_ID(hostdata->dev, hostdata->script, 1453422c0d61d591cbfb70f029e13505fb437e169d68Jeff Garzik Device_ID, 1<<scmd_id(SCp)); 14541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1455d3fa72e4556ec1f04e46a0d561d9e785ecaa173dRalf Baechle script_patch_32_abs(hostdata->dev, hostdata->script, CommandAddress, 14561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds slot->pCmd); 1457d3fa72e4556ec1f04e46a0d561d9e785ecaa173dRalf Baechle script_patch_16(hostdata->dev, hostdata->script, CommandCount, 1458d3fa72e4556ec1f04e46a0d561d9e785ecaa173dRalf Baechle SCp->cmd_len); 14591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* finally plumb the beginning of the SG list into the script 14601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * */ 1461d3fa72e4556ec1f04e46a0d561d9e785ecaa173dRalf Baechle script_patch_32_abs(hostdata->dev, hostdata->script, 1462d3fa72e4556ec1f04e46a0d561d9e785ecaa173dRalf Baechle SGScriptStartAddress, to32bit(&slot->pSG[0].ins)); 14631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_clear_fifo(SCp->device->host); 14641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(slot->resume_offset == 0) 14661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds slot->resume_offset = hostdata->pScript; 14671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* now perform all the writebacks and invalidates */ 1468d3fa72e4556ec1f04e46a0d561d9e785ecaa173dRalf Baechle dma_cache_sync(hostdata->dev, hostdata->msgout, count, DMA_TO_DEVICE); 1469d3fa72e4556ec1f04e46a0d561d9e785ecaa173dRalf Baechle dma_cache_sync(hostdata->dev, hostdata->msgin, MSG_ARRAY_SIZE, 14701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds DMA_FROM_DEVICE); 1471d3fa72e4556ec1f04e46a0d561d9e785ecaa173dRalf Baechle dma_cache_sync(hostdata->dev, SCp->cmnd, SCp->cmd_len, DMA_TO_DEVICE); 1472d3fa72e4556ec1f04e46a0d561d9e785ecaa173dRalf Baechle dma_cache_sync(hostdata->dev, hostdata->status, 1, DMA_FROM_DEVICE); 14731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* set the synchronous period/offset */ 14751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_writeb(NCR_700_get_SXFER(SCp->device), 14761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCp->device->host, SXFER_REG); 14771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_writel(slot->temp, SCp->device->host, TEMP_REG); 14781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_writel(slot->resume_offset, SCp->device->host, DSP_REG); 14791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 1; 14811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 14821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsirqreturn_t 14847d12e780e003f93433d49ce78cfedf4b4c52adc5David HowellsNCR_700_intr(int irq, void *dev_id) 14851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 14861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct Scsi_Host *host = (struct Scsi_Host *)dev_id; 14871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct NCR_700_Host_Parameters *hostdata = 14881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (struct NCR_700_Host_Parameters *)host->hostdata[0]; 14891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds __u8 istat; 14901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds __u32 resume_offset = 0; 14911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds __u8 pun = 0xff, lun = 0xff; 14921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned long flags; 14931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int handled = 0; 14941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1495af901ca181d92aac3a7dc265144a9081a86d8f39André Goddard Rosa /* Use the host lock to serialise access to the 53c700 14961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * hardware. Note: In future, we may need to take the queue 14971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * lock to enter the done routines. When that happens, we 14981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * need to ensure that for this driver, the host lock and the 14991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * queue lock point to the same thing. */ 15001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spin_lock_irqsave(host->host_lock, flags); 15011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if((istat = NCR_700_readb(host, ISTAT_REG)) 15021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds & (SCSI_INT_PENDING | DMA_INT_PENDING)) { 15031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds __u32 dsps; 15041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds __u8 sstat0 = 0, dstat = 0; 15051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds __u32 dsp; 15061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct scsi_cmnd *SCp = hostdata->cmd; 15071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds enum NCR_700_Host_State state; 15081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds handled = 1; 15101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds state = hostdata->state; 15111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCp = hostdata->cmd; 15121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(istat & SCSI_INT_PENDING) { 15141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds udelay(10); 15151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds sstat0 = NCR_700_readb(host, SSTAT0_REG); 15171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 15181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(istat & DMA_INT_PENDING) { 15201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds udelay(10); 15211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dstat = NCR_700_readb(host, DSTAT_REG); 15231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 15241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dsps = NCR_700_readl(host, DSPS_REG); 15261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dsp = NCR_700_readl(host, DSP_REG); 15271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds DEBUG(("scsi%d: istat %02x sstat0 %02x dstat %02x dsp %04x[%08x] dsps 0x%x\n", 15291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds host->host_no, istat, sstat0, dstat, 15301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (dsp - (__u32)(hostdata->pScript))/4, 15311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dsp, dsps)); 15321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(SCp != NULL) { 15341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pun = SCp->device->id; 15351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds lun = SCp->device->lun; 15361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 15371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(sstat0 & SCSI_RESET_DETECTED) { 15391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct scsi_device *SDp; 15401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int i; 15411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hostdata->state = NCR_700_HOST_BUSY; 15431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk(KERN_ERR "scsi%d: Bus Reset detected, executing command %p, slot %p, dsp %08x[%04x]\n", 15451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds host->host_no, SCp, SCp == NULL ? NULL : SCp->host_scribble, dsp, dsp - hostdata->pScript); 15461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds scsi_report_bus_reset(host, 0); 15481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* clear all the negotiated parameters */ 15501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds __shost_for_each_device(SDp, host) 15510f13fc09db68de92585558984bff1c51b87db72fJames Bottomley NCR_700_clear_flag(SDp, ~0); 15521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* clear all the slots and their pending commands */ 15541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for(i = 0; i < NCR_700_COMMAND_SLOTS_PER_HOST; i++) { 15551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct scsi_cmnd *SCp; 15561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct NCR_700_command_slot *slot = 15571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds &hostdata->slots[i]; 15581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(slot->state == NCR_700_SLOT_FREE) 15601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds continue; 15611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCp = slot->cmnd; 15631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk(KERN_ERR " failing command because of reset, slot %p, cmnd %p\n", 15641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds slot, SCp); 15651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds free_slot(slot, hostdata); 15661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCp->host_scribble = NULL; 15671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_set_depth(SCp->device, 0); 15681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* NOTE: deadlock potential here: we 15691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * rely on mid-layer guarantees that 15701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * scsi_done won't try to issue the 15711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * command again otherwise we'll 15721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * deadlock on the 15731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * hostdata->state_lock */ 15741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCp->result = DID_RESET << 16; 15751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCp->scsi_done(SCp); 15761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 15771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mdelay(25); 15781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_chip_setup(host); 15791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hostdata->state = NCR_700_HOST_FREE; 15811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hostdata->cmd = NULL; 15821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* signal back if this was an eh induced reset */ 15831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(hostdata->eh_complete != NULL) 15841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds complete(hostdata->eh_complete); 15851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds goto out_unlock; 15861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else if(sstat0 & SELECTION_TIMEOUT) { 15871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds DEBUG(("scsi%d: (%d:%d) selection timeout\n", 15881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds host->host_no, pun, lun)); 15891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_scsi_done(hostdata, SCp, DID_NO_CONNECT<<16); 15901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else if(sstat0 & PHASE_MISMATCH) { 15911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct NCR_700_command_slot *slot = (SCp == NULL) ? NULL : 15921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (struct NCR_700_command_slot *)SCp->host_scribble; 15931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(dsp == Ent_SendMessage + 8 + hostdata->pScript) { 15951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* It wants to reply to some part of 15961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * our message */ 15971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#ifdef NCR_700_DEBUG 15981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds __u32 temp = NCR_700_readl(host, TEMP_REG); 15991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int count = (hostdata->script[Ent_SendMessage/4] & 0xffffff) - ((NCR_700_readl(host, DBC_REG) & 0xffffff) + NCR_700_data_residual(host)); 16001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus 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))); 16011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif 16021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds resume_offset = hostdata->pScript + Ent_SendMessagePhaseMismatch; 16031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else if(dsp >= to32bit(&slot->pSG[0].ins) && 16041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dsp <= to32bit(&slot->pSG[NCR_700_SG_SEGMENTS].ins)) { 16051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int data_transfer = NCR_700_readl(host, DBC_REG) & 0xffffff; 16061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int SGcount = (dsp - to32bit(&slot->pSG[0].ins))/sizeof(struct NCR_700_SG_List); 16071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int residual = NCR_700_data_residual(host); 16081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int i; 16091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#ifdef NCR_700_DEBUG 16101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds __u32 naddr = NCR_700_readl(host, DNAD_REG); 16111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("scsi%d: (%d:%d) Expected phase mismatch in slot->SG[%d], transferred 0x%x\n", 16131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds host->host_no, pun, lun, 16141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SGcount, data_transfer); 16151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds scsi_print_command(SCp); 16161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(residual) { 16171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("scsi%d: (%d:%d) Expected phase mismatch in slot->SG[%d], transferred 0x%x, residual %d\n", 16181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds host->host_no, pun, lun, 16191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SGcount, data_transfer, residual); 16201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 16211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif 16221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds data_transfer += residual; 16231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(data_transfer != 0) { 16251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int count; 16261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds __u32 pAddr; 16271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SGcount--; 16291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds count = (bS_to_cpu(slot->SG[SGcount].ins) & 0x00ffffff); 16311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds DEBUG(("DATA TRANSFER MISMATCH, count = %d, transferred %d\n", count, count-data_transfer)); 16321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds slot->SG[SGcount].ins &= bS_to_host(0xff000000); 16331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds slot->SG[SGcount].ins |= bS_to_host(data_transfer); 16341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pAddr = bS_to_cpu(slot->SG[SGcount].pAddr); 16351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds pAddr += (count - data_transfer); 16361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#ifdef NCR_700_DEBUG 16371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(pAddr != naddr) { 16381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus 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); 16391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 16401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif 16411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds slot->SG[SGcount].pAddr = bS_to_host(pAddr); 16421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 16431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* set the executed moves to nops */ 16441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for(i=0; i<SGcount; i++) { 16451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds slot->SG[i].ins = bS_to_host(SCRIPT_NOP); 16461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds slot->SG[i].pAddr = 0; 16471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 1648d3fa72e4556ec1f04e46a0d561d9e785ecaa173dRalf Baechle dma_cache_sync(hostdata->dev, slot->SG, sizeof(slot->SG), DMA_TO_DEVICE); 16491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* and pretend we disconnected after 16501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * the command phase */ 16511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds resume_offset = hostdata->pScript + Ent_MsgInDuringData; 16521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* make sure all the data is flushed */ 16531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_flush_fifo(host); 16541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 16551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds __u8 sbcl = NCR_700_readb(host, SBCL_REG); 16561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk(KERN_ERR "scsi%d: (%d:%d) phase mismatch at %04x, phase %s\n", 16571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds host->host_no, pun, lun, dsp - hostdata->pScript, sbcl_to_string(sbcl)); 16581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_internal_bus_reset(host); 16591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 16601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else if(sstat0 & SCSI_GROSS_ERROR) { 16621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk(KERN_ERR "scsi%d: (%d:%d) GROSS ERROR\n", 16631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds host->host_no, pun, lun); 16641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_scsi_done(hostdata, SCp, DID_ERROR<<16); 16651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else if(sstat0 & PARITY_ERROR) { 16661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk(KERN_ERR "scsi%d: (%d:%d) PARITY ERROR\n", 16671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds host->host_no, pun, lun); 16681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_scsi_done(hostdata, SCp, DID_ERROR<<16); 16691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else if(dstat & SCRIPT_INT_RECEIVED) { 16701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds DEBUG(("scsi%d: (%d:%d) ====>SCRIPT INTERRUPT<====\n", 16711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds host->host_no, pun, lun)); 16721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds resume_offset = process_script_interrupt(dsps, dsp, SCp, host, hostdata); 16731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else if(dstat & (ILGL_INST_DETECTED)) { 16741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk(KERN_ERR "scsi%d: (%d:%d) Illegal Instruction detected at 0x%08x[0x%x]!!!\n" 16751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds " Please email James.Bottomley@HansenPartnership.com with the details\n", 16761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds host->host_no, pun, lun, 16771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dsp, dsp - hostdata->pScript); 16781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_scsi_done(hostdata, SCp, DID_ERROR<<16); 16791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else if(dstat & (WATCH_DOG_INTERRUPT|ABORTED)) { 16801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk(KERN_ERR "scsi%d: (%d:%d) serious DMA problem, dstat=%02x\n", 16811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds host->host_no, pun, lun, dstat); 16821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_scsi_done(hostdata, SCp, DID_ERROR<<16); 16831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 16841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* NOTE: selection interrupt processing MUST occur 16871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * after script interrupt processing to correctly cope 16881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * with the case where we process a disconnect and 16891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * then get reselected before we process the 16901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * disconnection */ 16911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(sstat0 & SELECTED) { 16921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* FIXME: It currently takes at least FOUR 16931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * interrupts to complete a command that 16941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * disconnects: one for the disconnect, one 16951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * for the reselection, one to get the 16961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * reselection data and one to complete the 16971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * command. If we guess the reselected 16981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * command here and prepare it, we only need 16991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * to get a reselection data interrupt if we 17001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * guessed wrongly. Since the interrupt 17011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * overhead is much greater than the command 17021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * setup, this would be an efficient 17031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * optimisation particularly as we probably 17041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * only have one outstanding command on a 17051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * target most of the time */ 17061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds resume_offset = process_selection(host, dsp); 17081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 17101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 17121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(resume_offset) { 17141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(hostdata->state != NCR_700_HOST_BUSY) { 17151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk(KERN_ERR "scsi%d: Driver error: resume at 0x%08x [0x%04x] with non busy host!\n", 17161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds host->host_no, resume_offset, resume_offset - hostdata->pScript); 17171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hostdata->state = NCR_700_HOST_BUSY; 17181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 17191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds DEBUG(("Attempting to resume at %x\n", resume_offset)); 17211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_clear_fifo(host); 17221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_writel(resume_offset, host, DSP_REG); 17231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 17241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* There is probably a technical no-no about this: If we're a 17251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * shared interrupt and we got this interrupt because the 17261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * other device needs servicing not us, we're still going to 17271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * check our queued commands here---of course, there shouldn't 17281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * be any outstanding.... */ 17291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(hostdata->state == NCR_700_HOST_FREE) { 17301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int i; 17311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds for(i = 0; i < NCR_700_COMMAND_SLOTS_PER_HOST; i++) { 17331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* fairness: always run the queue from the last 17341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * position we left off */ 17351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int j = (i + hostdata->saved_slot_position) 17361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds % NCR_700_COMMAND_SLOTS_PER_HOST; 17371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(hostdata->slots[j].state != NCR_700_SLOT_QUEUED) 17391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds continue; 17401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(NCR_700_start_command(hostdata->slots[j].cmnd)) { 17411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds DEBUG(("scsi%d: Issuing saved command slot %p, cmd %p\t\n", 17421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds host->host_no, &hostdata->slots[j], 17431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hostdata->slots[j].cmnd)); 17441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hostdata->saved_slot_position = j + 1; 17451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 17461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds break; 17481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 17491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 17501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds out_unlock: 17511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spin_unlock_irqrestore(host->host_lock, flags); 17521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return IRQ_RETVAL(handled); 17531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 17541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsSTATIC int 17561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsNCR_700_queuecommand(struct scsi_cmnd *SCp, void (*done)(struct scsi_cmnd *)) 17571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 17581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct NCR_700_Host_Parameters *hostdata = 17591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (struct NCR_700_Host_Parameters *)SCp->device->host->hostdata[0]; 17601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds __u32 move_ins; 17611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds enum dma_data_direction direction; 17621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct NCR_700_command_slot *slot; 17631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(hostdata->command_slot_count >= NCR_700_COMMAND_SLOTS_PER_HOST) { 17651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* We're over our allocation, this should never happen 17661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * since we report the max allocation to the mid layer */ 17671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk(KERN_WARNING "scsi%d: Command depth has gone over queue depth\n", SCp->device->host->host_no); 17681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 1; 17691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 17701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* check for untagged commands. We cannot have any outstanding 17711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * commands if we accept them. Commands could be untagged because: 17721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 17731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * - The tag negotiated bitmap is clear 17741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * - The blk layer sent and untagged command 17751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 17761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(NCR_700_get_depth(SCp->device) != 0 1777017560fca496f72ed9dd734ffde63ce39dfe0411Jeff Garzik && (!(hostdata->tag_negotiated & (1<<scmd_id(SCp))) 17781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds || !blk_rq_tagged(SCp->request))) { 1779017560fca496f72ed9dd734ffde63ce39dfe0411Jeff Garzik CDEBUG(KERN_ERR, SCp, "has non zero depth %d\n", 1780017560fca496f72ed9dd734ffde63ce39dfe0411Jeff Garzik NCR_700_get_depth(SCp->device)); 17811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return SCSI_MLQUEUE_DEVICE_BUSY; 17821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 17831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(NCR_700_get_depth(SCp->device) >= SCp->device->queue_depth) { 1784017560fca496f72ed9dd734ffde63ce39dfe0411Jeff Garzik CDEBUG(KERN_ERR, SCp, "has max tag depth %d\n", 1785017560fca496f72ed9dd734ffde63ce39dfe0411Jeff Garzik NCR_700_get_depth(SCp->device)); 17861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return SCSI_MLQUEUE_DEVICE_BUSY; 17871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 17881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_set_depth(SCp->device, NCR_700_get_depth(SCp->device) + 1); 17891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* begin the command here */ 17911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* no need to check for NULL, test for command_slot_count above 17921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * ensures a slot is free */ 17931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds slot = find_empty_slot(hostdata); 17941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds slot->cmnd = SCp; 17961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCp->scsi_done = done; 17981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCp->host_scribble = (unsigned char *)slot; 17991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCp->SCp.ptr = NULL; 18001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCp->SCp.buffer = NULL; 18011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#ifdef NCR_700_DEBUG 18031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("53c700: scsi%d, command ", SCp->device->host->host_no); 18041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds scsi_print_command(SCp); 18051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif 18061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(blk_rq_tagged(SCp->request) 1807017560fca496f72ed9dd734ffde63ce39dfe0411Jeff Garzik && (hostdata->tag_negotiated &(1<<scmd_id(SCp))) == 0 18081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds && NCR_700_get_tag_neg_state(SCp->device) == NCR_700_START_TAG_NEGOTIATION) { 1809017560fca496f72ed9dd734ffde63ce39dfe0411Jeff Garzik scmd_printk(KERN_ERR, SCp, "Enabling Tag Command Queuing\n"); 1810017560fca496f72ed9dd734ffde63ce39dfe0411Jeff Garzik hostdata->tag_negotiated |= (1<<scmd_id(SCp)); 18111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_set_tag_neg_state(SCp->device, NCR_700_DURING_TAG_NEGOTIATION); 18121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 18131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* here we may have to process an untagged command. The gate 18151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * above ensures that this will be the only one outstanding, 18161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * so clear the tag negotiated bit. 18171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 18181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * FIXME: This will royally screw up on multiple LUN devices 18191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * */ 18201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(!blk_rq_tagged(SCp->request) 1821017560fca496f72ed9dd734ffde63ce39dfe0411Jeff Garzik && (hostdata->tag_negotiated &(1<<scmd_id(SCp)))) { 1822017560fca496f72ed9dd734ffde63ce39dfe0411Jeff Garzik scmd_printk(KERN_INFO, SCp, "Disabling Tag Command Queuing\n"); 1823017560fca496f72ed9dd734ffde63ce39dfe0411Jeff Garzik hostdata->tag_negotiated &= ~(1<<scmd_id(SCp)); 18241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 18251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1826017560fca496f72ed9dd734ffde63ce39dfe0411Jeff Garzik if((hostdata->tag_negotiated &(1<<scmd_id(SCp))) 18271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds && scsi_get_tag_type(SCp->device)) { 18281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds slot->tag = SCp->request->tag; 1829017560fca496f72ed9dd734ffde63ce39dfe0411Jeff Garzik CDEBUG(KERN_DEBUG, SCp, "sending out tag %d, slot %p\n", 1830017560fca496f72ed9dd734ffde63ce39dfe0411Jeff Garzik slot->tag, slot); 18311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 18321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds slot->tag = SCSI_NO_TAG; 18331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* must populate current_cmnd for scsi_find_tag to work */ 18341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCp->device->current_cmnd = SCp; 18351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 18361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* sanity check: some of the commands generated by the mid-layer 18371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * have an eccentric idea of their sc_data_direction */ 18383258a4d5690880a62121553b604893ecaca7d042FUJITA Tomonori if(!scsi_sg_count(SCp) && !scsi_bufflen(SCp) && 18393258a4d5690880a62121553b604893ecaca7d042FUJITA Tomonori SCp->sc_data_direction != DMA_NONE) { 18401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#ifdef NCR_700_DEBUG 18411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("53c700: Command"); 18421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds scsi_print_command(SCp); 18431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk("Has wrong data direction %d\n", SCp->sc_data_direction); 18441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif 18451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCp->sc_data_direction = DMA_NONE; 18461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 18471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds switch (SCp->cmnd[0]) { 18491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case REQUEST_SENSE: 18501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* clear the internal sense magic */ 18511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds SCp->cmnd[6] = 0; 18521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* fall through */ 18531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds default: 18541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* OK, get it from the command */ 18551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds switch(SCp->sc_data_direction) { 18561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case DMA_BIDIRECTIONAL: 18571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds default: 18581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds printk(KERN_ERR "53c700: Unknown command for data direction "); 18591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds scsi_print_command(SCp); 18601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds move_ins = 0; 18621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds break; 18631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case DMA_NONE: 18641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds move_ins = 0; 18651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds break; 18661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case DMA_FROM_DEVICE: 18671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds move_ins = SCRIPT_MOVE_DATA_IN; 18681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds break; 18691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds case DMA_TO_DEVICE: 18701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds move_ins = SCRIPT_MOVE_DATA_OUT; 18711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds break; 18721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 18731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 18741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* now build the scatter gather list */ 18761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds direction = SCp->sc_data_direction; 18771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(move_ins != 0) { 18781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int i; 18791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int sg_count; 18801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds dma_addr_t vPtr = 0; 18813258a4d5690880a62121553b604893ecaca7d042FUJITA Tomonori struct scatterlist *sg; 18821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds __u32 count = 0; 18831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18843258a4d5690880a62121553b604893ecaca7d042FUJITA Tomonori sg_count = scsi_dma_map(SCp); 18853258a4d5690880a62121553b604893ecaca7d042FUJITA Tomonori BUG_ON(sg_count < 0); 18861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18873258a4d5690880a62121553b604893ecaca7d042FUJITA Tomonori scsi_for_each_sg(SCp, sg, sg_count, i) { 18883258a4d5690880a62121553b604893ecaca7d042FUJITA Tomonori vPtr = sg_dma_address(sg); 18893258a4d5690880a62121553b604893ecaca7d042FUJITA Tomonori count = sg_dma_len(sg); 18901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds slot->SG[i].ins = bS_to_host(move_ins | count); 18921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds DEBUG((" scatter block %d: move %d[%08x] from 0x%lx\n", 18931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds i, count, slot->SG[i].ins, (unsigned long)vPtr)); 18941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds slot->SG[i].pAddr = bS_to_host(vPtr); 18951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 18961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds slot->SG[i].ins = bS_to_host(SCRIPT_RETURN); 18971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds slot->SG[i].pAddr = 0; 1898d3fa72e4556ec1f04e46a0d561d9e785ecaa173dRalf Baechle dma_cache_sync(hostdata->dev, slot->SG, sizeof(slot->SG), DMA_TO_DEVICE); 18991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds DEBUG((" SETTING %08lx to %x\n", 1900d3fa72e4556ec1f04e46a0d561d9e785ecaa173dRalf Baechle (&slot->pSG[i].ins), 19011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds slot->SG[i].ins)); 19021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 19031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds slot->resume_offset = 0; 19041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds slot->pCmd = dma_map_single(hostdata->dev, SCp->cmnd, 190564a87b244b9297667ca80264aab849a36f494884Boaz Harrosh MAX_COMMAND_SIZE, DMA_TO_DEVICE); 19061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_start_command(SCp); 19071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 0; 19081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 19091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsSTATIC int 19111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsNCR_700_abort(struct scsi_cmnd * SCp) 19121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 19131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct NCR_700_command_slot *slot; 19141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1915017560fca496f72ed9dd734ffde63ce39dfe0411Jeff Garzik scmd_printk(KERN_INFO, SCp, 1916017560fca496f72ed9dd734ffde63ce39dfe0411Jeff Garzik "New error handler wants to abort command\n\t"); 19171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds scsi_print_command(SCp); 19181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds slot = (struct NCR_700_command_slot *)SCp->host_scribble; 19201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(slot == NULL) 19221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* no outstanding command to abort */ 19231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return SUCCESS; 19241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(SCp->cmnd[0] == TEST_UNIT_READY) { 19251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* FIXME: This is because of a problem in the new 19261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * error handler. When it is in error recovery, it 19271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * will send a TUR to a device it thinks may still be 19281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * showing a problem. If the TUR isn't responded to, 19291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * it will abort it and mark the device off line. 19301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Unfortunately, it does no other error recovery, so 19311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * this would leave us with an outstanding command 19321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * occupying a slot. Rather than allow this to 19331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * happen, we issue a bus reset to force all 19341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * outstanding commands to terminate here. */ 19351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_internal_bus_reset(SCp->device->host); 19361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* still drop through and return failed */ 19371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 19381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return FAILED; 19391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 19411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsSTATIC int 19431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsNCR_700_bus_reset(struct scsi_cmnd * SCp) 19441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 19456e9a4738c9fadb7cbdcabc1e3b415159f3741ed9Peter Zijlstra DECLARE_COMPLETION_ONSTACK(complete); 19461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct NCR_700_Host_Parameters *hostdata = 19471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (struct NCR_700_Host_Parameters *)SCp->device->host->hostdata[0]; 19481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1949017560fca496f72ed9dd734ffde63ce39dfe0411Jeff Garzik scmd_printk(KERN_INFO, SCp, 1950017560fca496f72ed9dd734ffde63ce39dfe0411Jeff Garzik "New error handler wants BUS reset, cmd %p\n\t", SCp); 19511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds scsi_print_command(SCp); 195268b3aa7c9805aee9005a8ca53c5e99177961fbb9Jeff Garzik 19531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* In theory, eh_complete should always be null because the 19541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * eh is single threaded, but just in case we're handling a 19551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * reset via sg or something */ 195668b3aa7c9805aee9005a8ca53c5e99177961fbb9Jeff Garzik spin_lock_irq(SCp->device->host->host_lock); 195768b3aa7c9805aee9005a8ca53c5e99177961fbb9Jeff Garzik while (hostdata->eh_complete != NULL) { 19581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spin_unlock_irq(SCp->device->host->host_lock); 19591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds msleep_interruptible(100); 19601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spin_lock_irq(SCp->device->host->host_lock); 19611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 196268b3aa7c9805aee9005a8ca53c5e99177961fbb9Jeff Garzik 19631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hostdata->eh_complete = &complete; 19641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_internal_bus_reset(SCp->device->host); 196568b3aa7c9805aee9005a8ca53c5e99177961fbb9Jeff Garzik 19661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spin_unlock_irq(SCp->device->host->host_lock); 19671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds wait_for_completion(&complete); 19681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spin_lock_irq(SCp->device->host->host_lock); 196968b3aa7c9805aee9005a8ca53c5e99177961fbb9Jeff Garzik 19701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds hostdata->eh_complete = NULL; 19711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Revalidate the transport parameters of the failing device */ 19721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(hostdata->fast) 19731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spi_schedule_dv_device(SCp->device); 197468b3aa7c9805aee9005a8ca53c5e99177961fbb9Jeff Garzik 197568b3aa7c9805aee9005a8ca53c5e99177961fbb9Jeff Garzik spin_unlock_irq(SCp->device->host->host_lock); 19761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return SUCCESS; 19771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 19781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsSTATIC int 19801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsNCR_700_host_reset(struct scsi_cmnd * SCp) 19811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 1982017560fca496f72ed9dd734ffde63ce39dfe0411Jeff Garzik scmd_printk(KERN_INFO, SCp, "New error handler wants HOST reset\n\t"); 19831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds scsi_print_command(SCp); 19841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1985df0ae2497ddefd72a87f3a3b34ff32455d7d4ae0Jeff Garzik spin_lock_irq(SCp->device->host->host_lock); 1986df0ae2497ddefd72a87f3a3b34ff32455d7d4ae0Jeff Garzik 19871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_internal_bus_reset(SCp->device->host); 19881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_chip_reset(SCp->device->host); 1989df0ae2497ddefd72a87f3a3b34ff32455d7d4ae0Jeff Garzik 1990df0ae2497ddefd72a87f3a3b34ff32455d7d4ae0Jeff Garzik spin_unlock_irq(SCp->device->host->host_lock); 1991df0ae2497ddefd72a87f3a3b34ff32455d7d4ae0Jeff Garzik 19921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return SUCCESS; 19931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 19941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsSTATIC void 19961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsNCR_700_set_period(struct scsi_target *STp, int period) 19971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 19981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct Scsi_Host *SHp = dev_to_shost(STp->dev.parent); 19991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct NCR_700_Host_Parameters *hostdata = 20001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (struct NCR_700_Host_Parameters *)SHp->hostdata[0]; 20011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 20021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(!hostdata->fast) 20031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return; 20041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 20051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(period < hostdata->min_period) 20061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds period = hostdata->min_period; 20071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 20081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spi_period(STp) = period; 20091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spi_flags(STp) &= ~(NCR_700_DEV_NEGOTIATED_SYNC | 20101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_DEV_BEGIN_SYNC_NEGOTIATION); 20111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spi_flags(STp) |= NCR_700_DEV_PRINT_SYNC_NEGOTIATION; 20121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 20131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 20141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsSTATIC void 20151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsNCR_700_set_offset(struct scsi_target *STp, int offset) 20161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 20171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct Scsi_Host *SHp = dev_to_shost(STp->dev.parent); 20181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct NCR_700_Host_Parameters *hostdata = 20191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (struct NCR_700_Host_Parameters *)SHp->hostdata[0]; 20201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int max_offset = hostdata->chip710 20211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ? NCR_710_MAX_OFFSET : NCR_700_MAX_OFFSET; 20221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 20231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(!hostdata->fast) 20241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return; 20251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 20261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(offset > max_offset) 20271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds offset = max_offset; 20281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 20291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* if we're currently async, make sure the period is reasonable */ 20301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(spi_offset(STp) == 0 && (spi_period(STp) < hostdata->min_period || 20311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spi_period(STp) > 0xff)) 20321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spi_period(STp) = hostdata->min_period; 20331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 20341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spi_offset(STp) = offset; 20351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spi_flags(STp) &= ~(NCR_700_DEV_NEGOTIATED_SYNC | 20361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_DEV_BEGIN_SYNC_NEGOTIATION); 20371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spi_flags(STp) |= NCR_700_DEV_PRINT_SYNC_NEGOTIATION; 20381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 20391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 20400f13fc09db68de92585558984bff1c51b87db72fJames BottomleySTATIC int 20410f13fc09db68de92585558984bff1c51b87db72fJames BottomleyNCR_700_slave_alloc(struct scsi_device *SDp) 20420f13fc09db68de92585558984bff1c51b87db72fJames Bottomley{ 20430f13fc09db68de92585558984bff1c51b87db72fJames Bottomley SDp->hostdata = kzalloc(sizeof(struct NCR_700_Device_Parameters), 20440f13fc09db68de92585558984bff1c51b87db72fJames Bottomley GFP_KERNEL); 20451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 20460f13fc09db68de92585558984bff1c51b87db72fJames Bottomley if (!SDp->hostdata) 20470f13fc09db68de92585558984bff1c51b87db72fJames Bottomley return -ENOMEM; 20480f13fc09db68de92585558984bff1c51b87db72fJames Bottomley 20490f13fc09db68de92585558984bff1c51b87db72fJames Bottomley return 0; 20500f13fc09db68de92585558984bff1c51b87db72fJames Bottomley} 20511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 20521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsSTATIC int 20531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsNCR_700_slave_configure(struct scsi_device *SDp) 20541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 20551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct NCR_700_Host_Parameters *hostdata = 20561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (struct NCR_700_Host_Parameters *)SDp->host->hostdata[0]; 20571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 20581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* to do here: allocate memory; build a queue_full list */ 20591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(SDp->tagged_supported) { 20601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds scsi_set_tag_type(SDp, MSG_ORDERED_TAG); 20611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds scsi_activate_tcq(SDp, NCR_700_DEFAULT_TAGS); 20621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_set_tag_neg_state(SDp, NCR_700_START_TAG_NEGOTIATION); 20631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 20641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* initialise to default depth */ 20651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds scsi_adjust_queue_depth(SDp, 0, SDp->host->cmd_per_lun); 20661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 20671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(hostdata->fast) { 20681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Find the correct offset and period via domain validation */ 20691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!spi_initial_dv(SDp->sdev_target)) 20701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spi_dv_device(SDp); 20711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 20721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spi_offset(SDp->sdev_target) = 0; 20731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spi_period(SDp->sdev_target) = 0; 20741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 20751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 0; 20761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 20771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 20781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsSTATIC void 20791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsNCR_700_slave_destroy(struct scsi_device *SDp) 20801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 208167d59dfdeb21df2c16dcd478b66177e91178ecd0James Bottomley kfree(SDp->hostdata); 208267d59dfdeb21df2c16dcd478b66177e91178ecd0James Bottomley SDp->hostdata = NULL; 20831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 20841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 20851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int 2086e881a172dac4d9ea3b2a1540041d872963c269bdMike ChristieNCR_700_change_queue_depth(struct scsi_device *SDp, int depth, int reason) 20871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 2088e881a172dac4d9ea3b2a1540041d872963c269bdMike Christie if (reason != SCSI_QDEPTH_DEFAULT) 2089e881a172dac4d9ea3b2a1540041d872963c269bdMike Christie return -EOPNOTSUPP; 2090e881a172dac4d9ea3b2a1540041d872963c269bdMike Christie 20911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (depth > NCR_700_MAX_TAGS) 20921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds depth = NCR_700_MAX_TAGS; 20931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 20941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds scsi_adjust_queue_depth(SDp, scsi_get_tag_type(SDp), depth); 20951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return depth; 20961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 20971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 20981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int NCR_700_change_queue_type(struct scsi_device *SDp, int tag_type) 20991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 21001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int change_tag = ((tag_type ==0 && scsi_get_tag_type(SDp) != 0) 21011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds || (tag_type != 0 && scsi_get_tag_type(SDp) == 0)); 21021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct NCR_700_Host_Parameters *hostdata = 21031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds (struct NCR_700_Host_Parameters *)SDp->host->hostdata[0]; 21041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 21051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds scsi_set_tag_type(SDp, tag_type); 21061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 21071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* We have a global (per target) flag to track whether TCQ is 21081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * enabled, so we'll be turning it off for the entire target here. 21091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * our tag algorithm will fail if we mix tagged and untagged commands, 21101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * so quiesce the device before doing this */ 21111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (change_tag) 21121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds scsi_target_quiesce(SDp->sdev_target); 21131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 21141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (!tag_type) { 21151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* shift back to the default unqueued number of commands 21161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * (the user can still raise this) */ 21171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds scsi_deactivate_tcq(SDp, SDp->host->cmd_per_lun); 2118422c0d61d591cbfb70f029e13505fb437e169d68Jeff Garzik hostdata->tag_negotiated &= ~(1 << sdev_id(SDp)); 21191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 21201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds /* Here, we cleared the negotiation flag above, so this 21211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * will force the driver to renegotiate */ 21221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds scsi_activate_tcq(SDp, SDp->queue_depth); 21231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (change_tag) 21241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_set_tag_neg_state(SDp, NCR_700_START_TAG_NEGOTIATION); 21251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 21261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (change_tag) 21271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds scsi_target_resume(SDp->sdev_target); 21281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 21291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return tag_type; 21301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 21311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 21321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic ssize_t 213310523b3b82456e416cbaffcc24ea2246980aa746Yani IoannouNCR_700_show_active_tags(struct device *dev, struct device_attribute *attr, char *buf) 21341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 21351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct scsi_device *SDp = to_scsi_device(dev); 21361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 21371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return snprintf(buf, 20, "%d\n", NCR_700_get_depth(SDp)); 21381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 21391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 21401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic struct device_attribute NCR_700_active_tags_attr = { 21411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .attr = { 21421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .name = "active_tags", 21431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .mode = S_IRUGO, 21441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds }, 21451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .show = NCR_700_show_active_tags, 21461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds}; 21471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 21481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsSTATIC struct device_attribute *NCR_700_dev_attrs[] = { 21491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds &NCR_700_active_tags_attr, 21501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NULL, 21511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds}; 21521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 21531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsEXPORT_SYMBOL(NCR_700_detect); 21541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsEXPORT_SYMBOL(NCR_700_release); 21551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsEXPORT_SYMBOL(NCR_700_intr); 21561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 21571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic struct spi_function_template NCR_700_transport_functions = { 21581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .set_period = NCR_700_set_period, 21591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .show_period = 1, 21601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .set_offset = NCR_700_set_offset, 21611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds .show_offset = 1, 21621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds}; 21631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 21641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic int __init NCR_700_init(void) 21651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 21661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds NCR_700_transport_template = spi_attach_transport(&NCR_700_transport_functions); 21671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if(!NCR_700_transport_template) 21681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return -ENODEV; 21691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return 0; 21701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 21711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 21721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void __exit NCR_700_exit(void) 21731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 21741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spi_release_transport(NCR_700_transport_template); 21751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 21761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 21771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsmodule_init(NCR_700_init); 21781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsmodule_exit(NCR_700_exit); 21791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2180