1/*
   2 *  linux/drivers/message/fusion/mptspi.c
   3 *      For use with LSI PCI chip/adapter(s)
   4 *      running LSI Fusion MPT (Message Passing Technology) firmware.
   5 *
   6 *  Copyright (c) 1999-2008 LSI Corporation
   7 *  (mailto:DL-MPTFusionLinux@lsi.com)
   8 *
   9 */
  10/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
  11/*
  12    This program is free software; you can redistribute it and/or modify
  13    it under the terms of the GNU General Public License as published by
  14    the Free Software Foundation; version 2 of the License.
  15
  16    This program is distributed in the hope that it will be useful,
  17    but WITHOUT ANY WARRANTY; without even the implied warranty of
  18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19    GNU General Public License for more details.
  20
  21    NO WARRANTY
  22    THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR
  23    CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT
  24    LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
  25    MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
  26    solely responsible for determining the appropriateness of using and
  27    distributing the Program and assumes all risks associated with its
  28    exercise of rights under this Agreement, including but not limited to
  29    the risks and costs of program errors, damage to or loss of data,
  30    programs or equipment, and unavailability or interruption of operations.
  31
  32    DISCLAIMER OF LIABILITY
  33    NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY
  34    DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  35    DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND
  36    ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
  37    TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  38    USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
  39    HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
  40
  41    You should have received a copy of the GNU General Public License
  42    along with this program; if not, write to the Free Software
  43    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  44*/
  45/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
  46
  47#include <linux/module.h>
  48#include <linux/kernel.h>
  49#include <linux/slab.h>
  50#include <linux/init.h>
  51#include <linux/errno.h>
  52#include <linux/kdev_t.h>
  53#include <linux/blkdev.h>
  54#include <linux/delay.h>	/* for mdelay */
  55#include <linux/interrupt.h>
  56#include <linux/reboot.h>	/* notifier code */
  57#include <linux/workqueue.h>
  58#include <linux/raid_class.h>
  59
  60#include <scsi/scsi.h>
  61#include <scsi/scsi_cmnd.h>
  62#include <scsi/scsi_device.h>
  63#include <scsi/scsi_host.h>
  64#include <scsi/scsi_tcq.h>
  65#include <scsi/scsi_transport.h>
  66#include <scsi/scsi_transport_spi.h>
  67#include <scsi/scsi_dbg.h>
  68
  69#include "mptbase.h"
  70#include "mptscsih.h"
  71
  72/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
  73#define my_NAME		"Fusion MPT SPI Host driver"
  74#define my_VERSION	MPT_LINUX_VERSION_COMMON
  75#define MYNAM		"mptspi"
  76
  77MODULE_AUTHOR(MODULEAUTHOR);
  78MODULE_DESCRIPTION(my_NAME);
  79MODULE_LICENSE("GPL");
  80MODULE_VERSION(my_VERSION);
  81
  82/* Command line args */
  83static int mpt_saf_te = MPTSCSIH_SAF_TE;
  84module_param(mpt_saf_te, int, 0);
  85MODULE_PARM_DESC(mpt_saf_te, " Force enabling SEP Processor: enable=1  (default=MPTSCSIH_SAF_TE=0)");
  86
  87static void mptspi_write_offset(struct scsi_target *, int);
  88static void mptspi_write_width(struct scsi_target *, int);
  89static int mptspi_write_spi_device_pg1(struct scsi_target *,
  90				       struct _CONFIG_PAGE_SCSI_DEVICE_1 *);
  91
  92static struct scsi_transport_template *mptspi_transport_template = NULL;
  93
  94static u8	mptspiDoneCtx = MPT_MAX_PROTOCOL_DRIVERS;
  95static u8	mptspiTaskCtx = MPT_MAX_PROTOCOL_DRIVERS;
  96static u8	mptspiInternalCtx = MPT_MAX_PROTOCOL_DRIVERS; /* Used only for internal commands */
  97
  98/**
  99 * 	mptspi_setTargetNegoParms  - Update the target negotiation parameters
 100 *	@hd: Pointer to a SCSI Host Structure
 101 *	@target: per target private data
 102 *	@sdev: SCSI device
 103 *
 104 *	Update the target negotiation parameters based on the Inquiry
 105 *	data, adapter capabilities, and NVRAM settings.
 106 **/
 107static void
 108mptspi_setTargetNegoParms(MPT_SCSI_HOST *hd, VirtTarget *target,
 109			    struct scsi_device *sdev)
 110{
 111	MPT_ADAPTER *ioc = hd->ioc;
 112	SpiCfgData *pspi_data = &ioc->spi_data;
 113	int  id = (int) target->id;
 114	int  nvram;
 115	u8 width = MPT_NARROW;
 116	u8 factor = MPT_ASYNC;
 117	u8 offset = 0;
 118	u8 nfactor;
 119	u8 noQas = 1;
 120
 121	target->negoFlags = pspi_data->noQas;
 122
 123	if (sdev->scsi_level < SCSI_2) {
 124		width = 0;
 125		factor = MPT_ULTRA2;
 126		offset = pspi_data->maxSyncOffset;
 127		target->tflags &= ~MPT_TARGET_FLAGS_Q_YES;
 128	} else {
 129		if (scsi_device_wide(sdev))
 130			width = 1;
 131
 132		if (scsi_device_sync(sdev)) {
 133			factor = pspi_data->minSyncFactor;
 134			if (!scsi_device_dt(sdev))
 135					factor = MPT_ULTRA2;
 136			else {
 137				if (!scsi_device_ius(sdev) &&
 138				    !scsi_device_qas(sdev))
 139					factor = MPT_ULTRA160;
 140				else {
 141					factor = MPT_ULTRA320;
 142					if (scsi_device_qas(sdev)) {
 143						ddvprintk(ioc,
 144						printk(MYIOC_s_DEBUG_FMT "Enabling QAS due to "
 145						"byte56=%02x on id=%d!\n", ioc->name,
 146						scsi_device_qas(sdev), id));
 147						noQas = 0;
 148					}
 149					if (sdev->type == TYPE_TAPE &&
 150					    scsi_device_ius(sdev))
 151						target->negoFlags |= MPT_TAPE_NEGO_IDP;
 152				}
 153			}
 154			offset = pspi_data->maxSyncOffset;
 155
 156			/* If RAID, never disable QAS
 157			 * else if non RAID, do not disable
 158			 *   QAS if bit 1 is set
 159			 * bit 1 QAS support, non-raid only
 160			 * bit 0 IU support
 161			 */
 162			if (target->raidVolume == 1)
 163				noQas = 0;
 164		} else {
 165			factor = MPT_ASYNC;
 166			offset = 0;
 167		}
 168	}
 169
 170	if (!sdev->tagged_supported)
 171		target->tflags &= ~MPT_TARGET_FLAGS_Q_YES;
 172
 173	/* Update tflags based on NVRAM settings. (SCSI only)
 174	 */
 175	if (pspi_data->nvram && (pspi_data->nvram[id] != MPT_HOST_NVRAM_INVALID)) {
 176		nvram = pspi_data->nvram[id];
 177		nfactor = (nvram & MPT_NVRAM_SYNC_MASK) >> 8;
 178
 179		if (width)
 180			width = nvram & MPT_NVRAM_WIDE_DISABLE ? 0 : 1;
 181
 182		if (offset > 0) {
 183			/* Ensure factor is set to the
 184			 * maximum of: adapter, nvram, inquiry
 185			 */
 186			if (nfactor) {
 187				if (nfactor < pspi_data->minSyncFactor )
 188					nfactor = pspi_data->minSyncFactor;
 189
 190				factor = max(factor, nfactor);
 191				if (factor == MPT_ASYNC)
 192					offset = 0;
 193			} else {
 194				offset = 0;
 195				factor = MPT_ASYNC;
 196		}
 197		} else {
 198			factor = MPT_ASYNC;
 199		}
 200	}
 201
 202	/* Make sure data is consistent
 203	 */
 204	if ((!width) && (factor < MPT_ULTRA2))
 205		factor = MPT_ULTRA2;
 206
 207	/* Save the data to the target structure.
 208	 */
 209	target->minSyncFactor = factor;
 210	target->maxOffset = offset;
 211	target->maxWidth = width;
 212
 213	spi_min_period(scsi_target(sdev)) = factor;
 214	spi_max_offset(scsi_target(sdev)) = offset;
 215	spi_max_width(scsi_target(sdev)) = width;
 216
 217	target->tflags |= MPT_TARGET_FLAGS_VALID_NEGO;
 218
 219	/* Disable unused features.
 220	 */
 221	if (!width)
 222		target->negoFlags |= MPT_TARGET_NO_NEGO_WIDE;
 223
 224	if (!offset)
 225		target->negoFlags |= MPT_TARGET_NO_NEGO_SYNC;
 226
 227	if ( factor > MPT_ULTRA320 )
 228		noQas = 0;
 229
 230	if (noQas && (pspi_data->noQas == 0)) {
 231		pspi_data->noQas |= MPT_TARGET_NO_NEGO_QAS;
 232		target->negoFlags |= MPT_TARGET_NO_NEGO_QAS;
 233
 234		/* Disable QAS in a mixed configuration case
 235		 */
 236
 237		ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT
 238			"Disabling QAS due to noQas=%02x on id=%d!\n", ioc->name, noQas, id));
 239	}
 240}
 241
 242/**
 243 * 	mptspi_writeIOCPage4  - write IOC Page 4
 244 *	@hd: Pointer to a SCSI Host Structure
 245 *	@channel: channel number
 246 *	@id: write IOC Page4 for this ID & Bus
 247 *
 248 *	Return: -EAGAIN if unable to obtain a Message Frame
 249 *		or 0 if success.
 250 *
 251 *	Remark: We do not wait for a return, write pages sequentially.
 252 **/
 253static int
 254mptspi_writeIOCPage4(MPT_SCSI_HOST *hd, u8 channel , u8 id)
 255{
 256	MPT_ADAPTER		*ioc = hd->ioc;
 257	Config_t		*pReq;
 258	IOCPage4_t		*IOCPage4Ptr;
 259	MPT_FRAME_HDR		*mf;
 260	dma_addr_t		 dataDma;
 
 
 261	u32			 flagsLength;
 262	int			 ii;
 263
 264	/* Get a MF for this command.
 265	 */
 266	if ((mf = mpt_get_msg_frame(ioc->DoneCtx, ioc)) == NULL) {
 267		dfailprintk(ioc, printk(MYIOC_s_WARN_FMT
 268				"writeIOCPage4 : no msg frames!\n",ioc->name));
 269		return -EAGAIN;
 270	}
 271
 272	/* Set the request and the data pointers.
 273	 * Place data at end of MF.
 274	 */
 275	pReq = (Config_t *)mf;
 276
 
 
 
 277	/* Complete the request frame (same for all requests).
 278	 */
 279	pReq->Action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT;
 280	pReq->Reserved = 0;
 281	pReq->ChainOffset = 0;
 282	pReq->Function = MPI_FUNCTION_CONFIG;
 283	pReq->ExtPageLength = 0;
 284	pReq->ExtPageType = 0;
 285	pReq->MsgFlags = 0;
 286	for (ii=0; ii < 8; ii++) {
 287		pReq->Reserved2[ii] = 0;
 288	}
 289
 290	IOCPage4Ptr = ioc->spi_data.pIocPg4;
 291	dataDma = ioc->spi_data.IocPg4_dma;
 292	ii = IOCPage4Ptr->ActiveSEP++;
 293	IOCPage4Ptr->SEP[ii].SEPTargetID = id;
 294	IOCPage4Ptr->SEP[ii].SEPBus = channel;
 295	pReq->Header = IOCPage4Ptr->Header;
 296	pReq->PageAddress = cpu_to_le32(id | (channel << 8 ));
 297
 298	/* Add a SGE to the config request.
 299	 */
 300	flagsLength = MPT_SGE_FLAGS_SSIMPLE_WRITE |
 301		(IOCPage4Ptr->Header.PageLength + ii) * 4;
 302
 303	ioc->add_sge((char *)&pReq->PageBufferSGE, flagsLength, dataDma);
 304
 305	ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT
 306		"writeIOCPage4: MaxSEP=%d ActiveSEP=%d id=%d bus=%d\n",
 307		ioc->name, IOCPage4Ptr->MaxSEP, IOCPage4Ptr->ActiveSEP, id, channel));
 308
 309	mpt_put_msg_frame(ioc->DoneCtx, ioc, mf);
 310
 311	return 0;
 312}
 313
 314/**
 315 *	mptspi_initTarget - Target, LUN alloc/free functionality.
 316 *	@hd: Pointer to MPT_SCSI_HOST structure
 317 *	@vtarget: per target private data
 318 *	@sdev: SCSI device
 319 *
 320 *	NOTE: It's only SAFE to call this routine if data points to
 321 *	sane & valid STANDARD INQUIRY data!
 322 *
 323 *	Allocate and initialize memory for this target.
 324 *	Save inquiry data.
 325 *
 326 **/
 327static void
 328mptspi_initTarget(MPT_SCSI_HOST *hd, VirtTarget *vtarget,
 329		    struct scsi_device *sdev)
 330{
 331
 332	/* Is LUN supported? If so, upper 2 bits will be 0
 333	* in first byte of inquiry data.
 334	*/
 335	if (sdev->inq_periph_qual != 0)
 336		return;
 337
 338	if (vtarget == NULL)
 339		return;
 340
 341	vtarget->type = sdev->type;
 342
 343	if ((sdev->type == TYPE_PROCESSOR) && (hd->ioc->spi_data.Saf_Te)) {
 344		/* Treat all Processors as SAF-TE if
 345		 * command line option is set */
 346		vtarget->tflags |= MPT_TARGET_FLAGS_SAF_TE_ISSUED;
 347		mptspi_writeIOCPage4(hd, vtarget->channel, vtarget->id);
 348	}else if ((sdev->type == TYPE_PROCESSOR) &&
 349		!(vtarget->tflags & MPT_TARGET_FLAGS_SAF_TE_ISSUED )) {
 350		if (sdev->inquiry_len > 49 ) {
 351			if (sdev->inquiry[44] == 'S' &&
 352			    sdev->inquiry[45] == 'A' &&
 353			    sdev->inquiry[46] == 'F' &&
 354			    sdev->inquiry[47] == '-' &&
 355			    sdev->inquiry[48] == 'T' &&
 356			    sdev->inquiry[49] == 'E' ) {
 357				vtarget->tflags |= MPT_TARGET_FLAGS_SAF_TE_ISSUED;
 358				mptspi_writeIOCPage4(hd, vtarget->channel, vtarget->id);
 359			}
 360		}
 361	}
 362	mptspi_setTargetNegoParms(hd, vtarget, sdev);
 363}
 364
 365/**
 366 *	mptspi_is_raid - Determines whether target is belonging to volume
 367 *	@hd: Pointer to a SCSI HOST structure
 368 *	@id: target device id
 369 *
 370 *	Return:
 371 *		non-zero = true
 372 *		zero = false
 373 *
 374 */
 375static int
 376mptspi_is_raid(struct _MPT_SCSI_HOST *hd, u32 id)
 377{
 378	int i, rc = 0;
 379	MPT_ADAPTER *ioc = hd->ioc;
 380
 381	if (!ioc->raid_data.pIocPg2)
 382		goto out;
 383
 384	if (!ioc->raid_data.pIocPg2->NumActiveVolumes)
 385		goto out;
 386	for (i=0; i < ioc->raid_data.pIocPg2->NumActiveVolumes; i++) {
 387		if (ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID == id) {
 388			rc = 1;
 389			goto out;
 390		}
 391	}
 392
 393 out:
 394	return rc;
 395}
 396
 397static int mptspi_target_alloc(struct scsi_target *starget)
 398{
 399	struct Scsi_Host *shost = dev_to_shost(&starget->dev);
 400	struct _MPT_SCSI_HOST *hd = shost_priv(shost);
 401	VirtTarget		*vtarget;
 402	MPT_ADAPTER *ioc;
 403
 404	if (hd == NULL)
 405		return -ENODEV;
 406
 407	ioc = hd->ioc;
 408	vtarget = kzalloc(sizeof(VirtTarget), GFP_KERNEL);
 409	if (!vtarget)
 410		return -ENOMEM;
 411
 412	vtarget->ioc_id = ioc->id;
 413	vtarget->tflags = MPT_TARGET_FLAGS_Q_YES;
 414	vtarget->id = (u8)starget->id;
 415	vtarget->channel = (u8)starget->channel;
 416	vtarget->starget = starget;
 417	starget->hostdata = vtarget;
 418
 419	if (starget->channel == 1) {
 420		if (mptscsih_is_phys_disk(ioc, 0, starget->id) == 0)
 421			return 0;
 422		vtarget->tflags |= MPT_TARGET_FLAGS_RAID_COMPONENT;
 423		/* The real channel for this device is zero */
 424		vtarget->channel = 0;
 425		/* The actual physdisknum (for RAID passthrough) */
 426		vtarget->id = mptscsih_raid_id_to_num(ioc, 0,
 427		    starget->id);
 428	}
 429
 430	if (starget->channel == 0 &&
 431	    mptspi_is_raid(hd, starget->id)) {
 432		vtarget->raidVolume = 1;
 433		ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT
 434		    "RAID Volume @ channel=%d id=%d\n", ioc->name, starget->channel,
 435		    starget->id));
 436	}
 437
 438	if (ioc->spi_data.nvram &&
 439	    ioc->spi_data.nvram[starget->id] != MPT_HOST_NVRAM_INVALID) {
 440		u32 nvram = ioc->spi_data.nvram[starget->id];
 441		spi_min_period(starget) = (nvram & MPT_NVRAM_SYNC_MASK) >> MPT_NVRAM_SYNC_SHIFT;
 442		spi_max_width(starget) = nvram & MPT_NVRAM_WIDE_DISABLE ? 0 : 1;
 443	} else {
 444		spi_min_period(starget) = ioc->spi_data.minSyncFactor;
 445		spi_max_width(starget) = ioc->spi_data.maxBusWidth;
 446	}
 447	spi_max_offset(starget) = ioc->spi_data.maxSyncOffset;
 448
 449	spi_offset(starget) = 0;
 450	spi_period(starget) = 0xFF;
 451	mptspi_write_width(starget, 0);
 452
 453	return 0;
 454}
 455
 456static void
 457mptspi_target_destroy(struct scsi_target *starget)
 458{
 459	kfree(starget->hostdata);
 460	starget->hostdata = NULL;
 461}
 462
 463/**
 464 *	mptspi_print_write_nego - negotiation parameters debug info that is being sent
 465 *	@hd: Pointer to a SCSI HOST structure
 466 *	@starget: SCSI target
 467 *	@ii: negotiation parameters
 468 *
 469 */
 470static void
 471mptspi_print_write_nego(struct _MPT_SCSI_HOST *hd, struct scsi_target *starget, u32 ii)
 472{
 473	ddvprintk(hd->ioc, printk(MYIOC_s_DEBUG_FMT "id=%d Requested = 0x%08x"
 474	    " ( %s factor = 0x%02x @ offset = 0x%02x %s%s%s%s%s%s%s%s)\n",
 475	    hd->ioc->name, starget->id, ii,
 476	    ii & MPI_SCSIDEVPAGE0_NP_WIDE ? "Wide ": "",
 477	    ((ii >> 8) & 0xFF), ((ii >> 16) & 0xFF),
 478	    ii & MPI_SCSIDEVPAGE0_NP_IU ? "IU ": "",
 479	    ii & MPI_SCSIDEVPAGE0_NP_DT ? "DT ": "",
 480	    ii & MPI_SCSIDEVPAGE0_NP_QAS ? "QAS ": "",
 481	    ii & MPI_SCSIDEVPAGE0_NP_HOLD_MCS ? "HOLDMCS ": "",
 482	    ii & MPI_SCSIDEVPAGE0_NP_WR_FLOW ? "WRFLOW ": "",
 483	    ii & MPI_SCSIDEVPAGE0_NP_RD_STRM ? "RDSTRM ": "",
 484	    ii & MPI_SCSIDEVPAGE0_NP_RTI ? "RTI ": "",
 485	    ii & MPI_SCSIDEVPAGE0_NP_PCOMP_EN ? "PCOMP ": ""));
 486}
 487
 488/**
 489 *	mptspi_print_read_nego - negotiation parameters debug info that is being read
 490 *	@hd: Pointer to a SCSI HOST structure
 491 *	@starget: SCSI target
 492 *	@ii: negotiation parameters
 493 *
 494 */
 495static void
 496mptspi_print_read_nego(struct _MPT_SCSI_HOST *hd, struct scsi_target *starget, u32 ii)
 497{
 498	ddvprintk(hd->ioc, printk(MYIOC_s_DEBUG_FMT "id=%d Read = 0x%08x"
 499	    " ( %s factor = 0x%02x @ offset = 0x%02x %s%s%s%s%s%s%s%s)\n",
 500	    hd->ioc->name, starget->id, ii,
 501	    ii & MPI_SCSIDEVPAGE0_NP_WIDE ? "Wide ": "",
 502	    ((ii >> 8) & 0xFF), ((ii >> 16) & 0xFF),
 503	    ii & MPI_SCSIDEVPAGE0_NP_IU ? "IU ": "",
 504	    ii & MPI_SCSIDEVPAGE0_NP_DT ? "DT ": "",
 505	    ii & MPI_SCSIDEVPAGE0_NP_QAS ? "QAS ": "",
 506	    ii & MPI_SCSIDEVPAGE0_NP_HOLD_MCS ? "HOLDMCS ": "",
 507	    ii & MPI_SCSIDEVPAGE0_NP_WR_FLOW ? "WRFLOW ": "",
 508	    ii & MPI_SCSIDEVPAGE0_NP_RD_STRM ? "RDSTRM ": "",
 509	    ii & MPI_SCSIDEVPAGE0_NP_RTI ? "RTI ": "",
 510	    ii & MPI_SCSIDEVPAGE0_NP_PCOMP_EN ? "PCOMP ": ""));
 511}
 512
 513static int mptspi_read_spi_device_pg0(struct scsi_target *starget,
 514			     struct _CONFIG_PAGE_SCSI_DEVICE_0 *pass_pg0)
 515{
 516	struct Scsi_Host *shost = dev_to_shost(&starget->dev);
 517	struct _MPT_SCSI_HOST *hd = shost_priv(shost);
 518	struct _MPT_ADAPTER *ioc = hd->ioc;
 519	struct _CONFIG_PAGE_SCSI_DEVICE_0 *spi_dev_pg0;
 520	dma_addr_t spi_dev_pg0_dma;
 521	int size;
 522	struct _x_config_parms cfg;
 523	struct _CONFIG_PAGE_HEADER hdr;
 524	int err = -EBUSY;
 525
 526	/* No SPI parameters for RAID devices */
 527	if (starget->channel == 0 &&
 528	    mptspi_is_raid(hd, starget->id))
 529		return -1;
 530
 531	size = ioc->spi_data.sdp0length * 4;
 532	/*
 533	if (ioc->spi_data.sdp0length & 1)
 534		size += size + 4;
 535	size += 2048;
 536	*/
 537
 538	spi_dev_pg0 = dma_alloc_coherent(&ioc->pcidev->dev, size, &spi_dev_pg0_dma, GFP_KERNEL);
 539	if (spi_dev_pg0 == NULL) {
 540		starget_printk(KERN_ERR, starget, MYIOC_s_FMT
 541		    "dma_alloc_coherent for parameters failed\n", ioc->name);
 542		return -EINVAL;
 543	}
 544
 545	memset(&hdr, 0, sizeof(hdr));
 546
 547	hdr.PageVersion = ioc->spi_data.sdp0version;
 548	hdr.PageLength = ioc->spi_data.sdp0length;
 549	hdr.PageNumber = 0;
 550	hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
 551
 552	memset(&cfg, 0, sizeof(cfg));
 553
 554	cfg.cfghdr.hdr = &hdr;
 555	cfg.physAddr = spi_dev_pg0_dma;
 556	cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
 557	cfg.dir = 0;
 558	cfg.pageAddr = starget->id;
 559	cfg.timeout = 60;
 560
 561	if (mpt_config(ioc, &cfg)) {
 562		starget_printk(KERN_ERR, starget, MYIOC_s_FMT "mpt_config failed\n", ioc->name);
 563		goto out_free;
 564	}
 565	err = 0;
 566	memcpy(pass_pg0, spi_dev_pg0, size);
 567
 568	mptspi_print_read_nego(hd, starget, le32_to_cpu(spi_dev_pg0->NegotiatedParameters));
 569
 570 out_free:
 571	dma_free_coherent(&ioc->pcidev->dev, size, spi_dev_pg0, spi_dev_pg0_dma);
 572	return err;
 573}
 574
 575static u32 mptspi_getRP(struct scsi_target *starget)
 576{
 577	u32 nego = 0;
 578
 579	nego |= spi_iu(starget) ? MPI_SCSIDEVPAGE1_RP_IU : 0;
 580	nego |= spi_dt(starget) ? MPI_SCSIDEVPAGE1_RP_DT : 0;
 581	nego |= spi_qas(starget) ? MPI_SCSIDEVPAGE1_RP_QAS : 0;
 582	nego |= spi_hold_mcs(starget) ? MPI_SCSIDEVPAGE1_RP_HOLD_MCS : 0;
 583	nego |= spi_wr_flow(starget) ? MPI_SCSIDEVPAGE1_RP_WR_FLOW : 0;
 584	nego |= spi_rd_strm(starget) ? MPI_SCSIDEVPAGE1_RP_RD_STRM : 0;
 585	nego |= spi_rti(starget) ? MPI_SCSIDEVPAGE1_RP_RTI : 0;
 586	nego |= spi_pcomp_en(starget) ? MPI_SCSIDEVPAGE1_RP_PCOMP_EN : 0;
 587
 588	nego |= (spi_period(starget) <<  MPI_SCSIDEVPAGE1_RP_SHIFT_MIN_SYNC_PERIOD) & MPI_SCSIDEVPAGE1_RP_MIN_SYNC_PERIOD_MASK;
 589	nego |= (spi_offset(starget) << MPI_SCSIDEVPAGE1_RP_SHIFT_MAX_SYNC_OFFSET) & MPI_SCSIDEVPAGE1_RP_MAX_SYNC_OFFSET_MASK;
 590	nego |= spi_width(starget) ?  MPI_SCSIDEVPAGE1_RP_WIDE : 0;
 591
 592	return nego;
 593}
 594
 595static void mptspi_read_parameters(struct scsi_target *starget)
 596{
 597	int nego;
 598	struct _CONFIG_PAGE_SCSI_DEVICE_0 spi_dev_pg0;
 599
 600	mptspi_read_spi_device_pg0(starget, &spi_dev_pg0);
 601
 602	nego = le32_to_cpu(spi_dev_pg0.NegotiatedParameters);
 603
 604	spi_iu(starget) = (nego & MPI_SCSIDEVPAGE0_NP_IU) ? 1 : 0;
 605	spi_dt(starget) = (nego & MPI_SCSIDEVPAGE0_NP_DT) ? 1 : 0;
 606	spi_qas(starget) = (nego & MPI_SCSIDEVPAGE0_NP_QAS) ? 1 : 0;
 607	spi_wr_flow(starget) = (nego & MPI_SCSIDEVPAGE0_NP_WR_FLOW) ? 1 : 0;
 608	spi_rd_strm(starget) = (nego & MPI_SCSIDEVPAGE0_NP_RD_STRM) ? 1 : 0;
 609	spi_rti(starget) = (nego & MPI_SCSIDEVPAGE0_NP_RTI) ? 1 : 0;
 610	spi_pcomp_en(starget) = (nego & MPI_SCSIDEVPAGE0_NP_PCOMP_EN) ? 1 : 0;
 611	spi_hold_mcs(starget) = (nego & MPI_SCSIDEVPAGE0_NP_HOLD_MCS) ? 1 : 0;
 612	spi_period(starget) = (nego & MPI_SCSIDEVPAGE0_NP_NEG_SYNC_PERIOD_MASK) >> MPI_SCSIDEVPAGE0_NP_SHIFT_SYNC_PERIOD;
 613	spi_offset(starget) = (nego & MPI_SCSIDEVPAGE0_NP_NEG_SYNC_OFFSET_MASK) >> MPI_SCSIDEVPAGE0_NP_SHIFT_SYNC_OFFSET;
 614	spi_width(starget) = (nego & MPI_SCSIDEVPAGE0_NP_WIDE) ? 1 : 0;
 615}
 616
 617static int
 618mptscsih_quiesce_raid(MPT_SCSI_HOST *hd, int quiesce, u8 channel, u8 id)
 619{
 620	MPT_ADAPTER	*ioc = hd->ioc;
 621	MpiRaidActionRequest_t	*pReq;
 622	MPT_FRAME_HDR		*mf;
 623	int			ret;
 624	unsigned long 	 	timeleft;
 625
 626	mutex_lock(&ioc->internal_cmds.mutex);
 627
 628	/* Get and Populate a free Frame
 629	 */
 630	if ((mf = mpt_get_msg_frame(ioc->InternalCtx, ioc)) == NULL) {
 631		dfailprintk(hd->ioc, printk(MYIOC_s_WARN_FMT
 632			"%s: no msg frames!\n", ioc->name, __func__));
 633		ret = -EAGAIN;
 634		goto out;
 635	}
 636	pReq = (MpiRaidActionRequest_t *)mf;
 637	if (quiesce)
 638		pReq->Action = MPI_RAID_ACTION_QUIESCE_PHYS_IO;
 639	else
 640		pReq->Action = MPI_RAID_ACTION_ENABLE_PHYS_IO;
 641	pReq->Reserved1 = 0;
 642	pReq->ChainOffset = 0;
 643	pReq->Function = MPI_FUNCTION_RAID_ACTION;
 644	pReq->VolumeID = id;
 645	pReq->VolumeBus = channel;
 646	pReq->PhysDiskNum = 0;
 647	pReq->MsgFlags = 0;
 648	pReq->Reserved2 = 0;
 649	pReq->ActionDataWord = 0; /* Reserved for this action */
 650
 651	ioc->add_sge((char *)&pReq->ActionDataSGE,
 652		MPT_SGE_FLAGS_SSIMPLE_READ | 0, (dma_addr_t) -1);
 653
 654	ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT "RAID Volume action=%x channel=%d id=%d\n",
 655			ioc->name, pReq->Action, channel, id));
 656
 657	INITIALIZE_MGMT_STATUS(ioc->internal_cmds.status)
 658	mpt_put_msg_frame(ioc->InternalCtx, ioc, mf);
 659	timeleft = wait_for_completion_timeout(&ioc->internal_cmds.done, 10*HZ);
 660	if (!(ioc->internal_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
 661		ret = -ETIME;
 662		dfailprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: TIMED OUT!\n",
 663		    ioc->name, __func__));
 664		if (ioc->internal_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET)
 665			goto out;
 666		if (!timeleft) {
 667			printk(MYIOC_s_WARN_FMT "Issuing Reset from %s!!\n",
 668			    ioc->name, __func__);
 669			mpt_HardResetHandler(ioc, CAN_SLEEP);
 670			mpt_free_msg_frame(ioc, mf);
 671		}
 672		goto out;
 673	}
 674
 675	ret = ioc->internal_cmds.completion_code;
 676
 677 out:
 678	CLEAR_MGMT_STATUS(ioc->internal_cmds.status)
 679	mutex_unlock(&ioc->internal_cmds.mutex);
 680	return ret;
 681}
 682
 683static void mptspi_dv_device(struct _MPT_SCSI_HOST *hd,
 684			     struct scsi_device *sdev)
 685{
 686	VirtTarget *vtarget = scsi_target(sdev)->hostdata;
 687	MPT_ADAPTER *ioc = hd->ioc;
 688
 689	/* no DV on RAID devices */
 690	if (sdev->channel == 0 &&
 691	    mptspi_is_raid(hd, sdev->id))
 692		return;
 693
 694	/* If this is a piece of a RAID, then quiesce first */
 695	if (sdev->channel == 1 &&
 696	    mptscsih_quiesce_raid(hd, 1, vtarget->channel, vtarget->id) < 0) {
 697		starget_printk(KERN_ERR, scsi_target(sdev), MYIOC_s_FMT
 698		    "Integrated RAID quiesce failed\n", ioc->name);
 699		return;
 700	}
 701
 702	hd->spi_pending |= (1 << sdev->id);
 703	spi_dv_device(sdev);
 704	hd->spi_pending &= ~(1 << sdev->id);
 705
 706	if (sdev->channel == 1 &&
 707	    mptscsih_quiesce_raid(hd, 0, vtarget->channel, vtarget->id) < 0)
 708		starget_printk(KERN_ERR, scsi_target(sdev), MYIOC_s_FMT
 709		    "Integrated RAID resume failed\n", ioc->name);
 710
 711	mptspi_read_parameters(sdev->sdev_target);
 712	spi_display_xfer_agreement(sdev->sdev_target);
 713	mptspi_read_parameters(sdev->sdev_target);
 714}
 715
 716static int mptspi_slave_alloc(struct scsi_device *sdev)
 717{
 718	MPT_SCSI_HOST *hd = shost_priv(sdev->host);
 719	VirtTarget		*vtarget;
 720	VirtDevice		*vdevice;
 721	struct scsi_target 	*starget;
 722	MPT_ADAPTER *ioc = hd->ioc;
 723
 724	if (sdev->channel == 1 &&
 725		mptscsih_is_phys_disk(ioc, 0, sdev->id) == 0)
 726			return -ENXIO;
 727
 728	vdevice = kzalloc(sizeof(VirtDevice), GFP_KERNEL);
 729	if (!vdevice) {
 730		printk(MYIOC_s_ERR_FMT "slave_alloc kmalloc(%zd) FAILED!\n",
 731				ioc->name, sizeof(VirtDevice));
 732		return -ENOMEM;
 733	}
 734
 735	vdevice->lun = sdev->lun;
 736	sdev->hostdata = vdevice;
 737
 738	starget = scsi_target(sdev);
 739	vtarget = starget->hostdata;
 740	vdevice->vtarget = vtarget;
 741	vtarget->num_luns++;
 742
 743	if (sdev->channel == 1)
 744		sdev->no_uld_attach = 1;
 745
 746	return 0;
 747}
 748
 749static int mptspi_slave_configure(struct scsi_device *sdev)
 750{
 751	struct _MPT_SCSI_HOST *hd = shost_priv(sdev->host);
 752	VirtTarget *vtarget = scsi_target(sdev)->hostdata;
 753	int ret;
 754
 755	mptspi_initTarget(hd, vtarget, sdev);
 756
 757	ret = mptscsih_slave_configure(sdev);
 758
 759	if (ret)
 760		return ret;
 761
 762	ddvprintk(hd->ioc, printk(MYIOC_s_DEBUG_FMT "id=%d min_period=0x%02x"
 763		" max_offset=0x%02x max_width=%d\n", hd->ioc->name,
 764		sdev->id, spi_min_period(scsi_target(sdev)),
 765		spi_max_offset(scsi_target(sdev)),
 766		spi_max_width(scsi_target(sdev))));
 767
 768	if ((sdev->channel == 1 ||
 769	     !(mptspi_is_raid(hd, sdev->id))) &&
 770	    !spi_initial_dv(sdev->sdev_target))
 771		mptspi_dv_device(hd, sdev);
 772
 773	return 0;
 774}
 775
 776static int
 777mptspi_qcmd(struct Scsi_Host *shost, struct scsi_cmnd *SCpnt)
 778{
 779	struct _MPT_SCSI_HOST *hd = shost_priv(shost);
 780	VirtDevice	*vdevice = SCpnt->device->hostdata;
 781	MPT_ADAPTER *ioc = hd->ioc;
 782
 783	if (!vdevice || !vdevice->vtarget) {
 784		SCpnt->result = DID_NO_CONNECT << 16;
 785		scsi_done(SCpnt);
 786		return 0;
 787	}
 788
 789	if (SCpnt->device->channel == 1 &&
 790		mptscsih_is_phys_disk(ioc, 0, SCpnt->device->id) == 0) {
 791		SCpnt->result = DID_NO_CONNECT << 16;
 792		scsi_done(SCpnt);
 793		return 0;
 794	}
 795
 796	if (spi_dv_pending(scsi_target(SCpnt->device)))
 797		ddvprintk(ioc, scsi_print_command(SCpnt));
 798
 799	return mptscsih_qcmd(SCpnt);
 800}
 801
 802static void mptspi_slave_destroy(struct scsi_device *sdev)
 803{
 804	struct scsi_target *starget = scsi_target(sdev);
 805	VirtTarget *vtarget = starget->hostdata;
 806	VirtDevice *vdevice = sdev->hostdata;
 807
 808	/* Will this be the last lun on a non-raid device? */
 809	if (vtarget->num_luns == 1 && vdevice->configured_lun) {
 810		struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
 811
 812		/* Async Narrow */
 813		pg1.RequestedParameters = 0;
 814		pg1.Reserved = 0;
 815		pg1.Configuration = 0;
 816
 817		mptspi_write_spi_device_pg1(starget, &pg1);
 818	}
 819
 820	mptscsih_slave_destroy(sdev);
 821}
 822
 823static struct scsi_host_template mptspi_driver_template = {
 824	.module				= THIS_MODULE,
 825	.proc_name			= "mptspi",
 826	.show_info			= mptscsih_show_info,
 827	.name				= "MPT SPI Host",
 828	.info				= mptscsih_info,
 829	.queuecommand			= mptspi_qcmd,
 830	.target_alloc			= mptspi_target_alloc,
 831	.slave_alloc			= mptspi_slave_alloc,
 832	.slave_configure		= mptspi_slave_configure,
 833	.target_destroy			= mptspi_target_destroy,
 834	.slave_destroy			= mptspi_slave_destroy,
 835	.change_queue_depth 		= mptscsih_change_queue_depth,
 836	.eh_abort_handler		= mptscsih_abort,
 837	.eh_device_reset_handler	= mptscsih_dev_reset,
 838	.eh_bus_reset_handler		= mptscsih_bus_reset,
 839	.eh_host_reset_handler		= mptscsih_host_reset,
 840	.bios_param			= mptscsih_bios_param,
 841	.can_queue			= MPT_SCSI_CAN_QUEUE,
 842	.this_id			= -1,
 843	.sg_tablesize			= MPT_SCSI_SG_DEPTH,
 844	.max_sectors			= 8192,
 845	.cmd_per_lun			= 7,
 846	.shost_groups			= mptscsih_host_attr_groups,
 
 847};
 848
 849static int mptspi_write_spi_device_pg1(struct scsi_target *starget,
 850			       struct _CONFIG_PAGE_SCSI_DEVICE_1 *pass_pg1)
 851{
 852	struct Scsi_Host *shost = dev_to_shost(&starget->dev);
 853	struct _MPT_SCSI_HOST *hd = shost_priv(shost);
 854	struct _MPT_ADAPTER *ioc = hd->ioc;
 855	struct _CONFIG_PAGE_SCSI_DEVICE_1 *pg1;
 856	dma_addr_t pg1_dma;
 857	int size;
 858	struct _x_config_parms cfg;
 859	struct _CONFIG_PAGE_HEADER hdr;
 860	int err = -EBUSY;
 861	u32 nego_parms;
 862	u32 period;
 863	struct scsi_device *sdev;
 864	int i;
 865
 866	/* don't allow updating nego parameters on RAID devices */
 867	if (starget->channel == 0 &&
 868	    mptspi_is_raid(hd, starget->id))
 869		return -1;
 870
 871	size = ioc->spi_data.sdp1length * 4;
 872
 873	pg1 = dma_alloc_coherent(&ioc->pcidev->dev, size, &pg1_dma, GFP_KERNEL);
 874	if (pg1 == NULL) {
 875		starget_printk(KERN_ERR, starget, MYIOC_s_FMT
 876		    "dma_alloc_coherent for parameters failed\n", ioc->name);
 877		return -EINVAL;
 878	}
 879
 880	memset(&hdr, 0, sizeof(hdr));
 881
 882	hdr.PageVersion = ioc->spi_data.sdp1version;
 883	hdr.PageLength = ioc->spi_data.sdp1length;
 884	hdr.PageNumber = 1;
 885	hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
 886
 887	memset(&cfg, 0, sizeof(cfg));
 888
 889	cfg.cfghdr.hdr = &hdr;
 890	cfg.physAddr = pg1_dma;
 891	cfg.action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT;
 892	cfg.dir = 1;
 893	cfg.pageAddr = starget->id;
 894
 895	memcpy(pg1, pass_pg1, size);
 896
 897	pg1->Header.PageVersion = hdr.PageVersion;
 898	pg1->Header.PageLength = hdr.PageLength;
 899	pg1->Header.PageNumber = hdr.PageNumber;
 900	pg1->Header.PageType = hdr.PageType;
 901
 902	nego_parms = le32_to_cpu(pg1->RequestedParameters);
 903	period = (nego_parms & MPI_SCSIDEVPAGE1_RP_MIN_SYNC_PERIOD_MASK) >>
 904		MPI_SCSIDEVPAGE1_RP_SHIFT_MIN_SYNC_PERIOD;
 905	if (period == 8) {
 906		/* Turn on inline data padding for TAPE when running U320 */
 907		for (i = 0 ; i < 16; i++) {
 908			sdev = scsi_device_lookup_by_target(starget, i);
 909			if (sdev && sdev->type == TYPE_TAPE) {
 910				sdev_printk(KERN_DEBUG, sdev, MYIOC_s_FMT
 911					    "IDP:ON\n", ioc->name);
 912				nego_parms |= MPI_SCSIDEVPAGE1_RP_IDP;
 913				pg1->RequestedParameters =
 914				    cpu_to_le32(nego_parms);
 915				break;
 916			}
 917		}
 918	}
 919
 920	mptspi_print_write_nego(hd, starget, le32_to_cpu(pg1->RequestedParameters));
 921
 922	if (mpt_config(ioc, &cfg)) {
 923		starget_printk(KERN_ERR, starget, MYIOC_s_FMT
 924		    "mpt_config failed\n", ioc->name);
 925		goto out_free;
 926	}
 927	err = 0;
 928
 929 out_free:
 930	dma_free_coherent(&ioc->pcidev->dev, size, pg1, pg1_dma);
 931	return err;
 932}
 933
 934static void mptspi_write_offset(struct scsi_target *starget, int offset)
 935{
 936	struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
 937	u32 nego;
 938
 939	if (offset < 0)
 940		offset = 0;
 941
 942	if (offset > 255)
 943		offset = 255;
 944
 945	if (spi_offset(starget) == -1)
 946		mptspi_read_parameters(starget);
 947
 948	spi_offset(starget) = offset;
 949
 950	nego = mptspi_getRP(starget);
 951
 952	pg1.RequestedParameters = cpu_to_le32(nego);
 953	pg1.Reserved = 0;
 954	pg1.Configuration = 0;
 955
 956	mptspi_write_spi_device_pg1(starget, &pg1);
 957}
 958
 959static void mptspi_write_period(struct scsi_target *starget, int period)
 960{
 961	struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
 962	u32 nego;
 963
 964	if (period < 8)
 965		period = 8;
 966
 967	if (period > 255)
 968		period = 255;
 969
 970	if (spi_period(starget) == -1)
 971		mptspi_read_parameters(starget);
 972
 973	if (period == 8) {
 974		spi_iu(starget) = 1;
 975		spi_dt(starget) = 1;
 976	} else if (period == 9) {
 977		spi_dt(starget) = 1;
 978	}
 979
 980	spi_period(starget) = period;
 981
 982	nego = mptspi_getRP(starget);
 983
 984	pg1.RequestedParameters = cpu_to_le32(nego);
 985	pg1.Reserved = 0;
 986	pg1.Configuration = 0;
 987
 988	mptspi_write_spi_device_pg1(starget, &pg1);
 989}
 990
 991static void mptspi_write_dt(struct scsi_target *starget, int dt)
 992{
 993	struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
 994	u32 nego;
 995
 996	if (spi_period(starget) == -1)
 997		mptspi_read_parameters(starget);
 998
 999	if (!dt && spi_period(starget) < 10)
1000		spi_period(starget) = 10;
1001
1002	spi_dt(starget) = dt;
1003
1004	nego = mptspi_getRP(starget);
1005
1006
1007	pg1.RequestedParameters = cpu_to_le32(nego);
1008	pg1.Reserved = 0;
1009	pg1.Configuration = 0;
1010
1011	mptspi_write_spi_device_pg1(starget, &pg1);
1012}
1013
1014static void mptspi_write_iu(struct scsi_target *starget, int iu)
1015{
1016	struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1017	u32 nego;
1018
1019	if (spi_period(starget) == -1)
1020		mptspi_read_parameters(starget);
1021
1022	if (!iu && spi_period(starget) < 9)
1023		spi_period(starget) = 9;
1024
1025	spi_iu(starget) = iu;
1026
1027	nego = mptspi_getRP(starget);
1028
1029	pg1.RequestedParameters = cpu_to_le32(nego);
1030	pg1.Reserved = 0;
1031	pg1.Configuration = 0;
1032
1033	mptspi_write_spi_device_pg1(starget, &pg1);
1034}
1035
1036#define MPTSPI_SIMPLE_TRANSPORT_PARM(parm) 				\
1037static void mptspi_write_##parm(struct scsi_target *starget, int parm)\
1038{									\
1039	struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;				\
1040	u32 nego;							\
1041									\
1042	spi_##parm(starget) = parm;					\
1043									\
1044	nego = mptspi_getRP(starget);					\
1045									\
1046	pg1.RequestedParameters = cpu_to_le32(nego);			\
1047	pg1.Reserved = 0;						\
1048	pg1.Configuration = 0;						\
1049									\
1050	mptspi_write_spi_device_pg1(starget, &pg1);				\
1051}
1052
1053MPTSPI_SIMPLE_TRANSPORT_PARM(rd_strm)
1054MPTSPI_SIMPLE_TRANSPORT_PARM(wr_flow)
1055MPTSPI_SIMPLE_TRANSPORT_PARM(rti)
1056MPTSPI_SIMPLE_TRANSPORT_PARM(hold_mcs)
1057MPTSPI_SIMPLE_TRANSPORT_PARM(pcomp_en)
1058
1059static void mptspi_write_qas(struct scsi_target *starget, int qas)
1060{
1061	struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1062	struct Scsi_Host *shost = dev_to_shost(&starget->dev);
1063	struct _MPT_SCSI_HOST *hd = shost_priv(shost);
1064	VirtTarget *vtarget = starget->hostdata;
1065	u32 nego;
1066
1067	if ((vtarget->negoFlags & MPT_TARGET_NO_NEGO_QAS) ||
1068	    hd->ioc->spi_data.noQas)
1069		spi_qas(starget) = 0;
1070	else
1071		spi_qas(starget) = qas;
1072
1073	nego = mptspi_getRP(starget);
1074
1075	pg1.RequestedParameters = cpu_to_le32(nego);
1076	pg1.Reserved = 0;
1077	pg1.Configuration = 0;
1078
1079	mptspi_write_spi_device_pg1(starget, &pg1);
1080}
1081
1082static void mptspi_write_width(struct scsi_target *starget, int width)
1083{
1084	struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1085	u32 nego;
1086
1087	if (!width) {
1088		spi_dt(starget) = 0;
1089		if (spi_period(starget) < 10)
1090			spi_period(starget) = 10;
1091	}
1092
1093	spi_width(starget) = width;
1094
1095	nego = mptspi_getRP(starget);
1096
1097	pg1.RequestedParameters = cpu_to_le32(nego);
1098	pg1.Reserved = 0;
1099	pg1.Configuration = 0;
1100
1101	mptspi_write_spi_device_pg1(starget, &pg1);
1102}
1103
1104struct work_queue_wrapper {
1105	struct work_struct	work;
1106	struct _MPT_SCSI_HOST	*hd;
1107	int			disk;
1108};
1109
1110static void mpt_work_wrapper(struct work_struct *work)
1111{
1112	struct work_queue_wrapper *wqw =
1113		container_of(work, struct work_queue_wrapper, work);
1114	struct _MPT_SCSI_HOST *hd = wqw->hd;
1115	MPT_ADAPTER *ioc = hd->ioc;
1116	struct Scsi_Host *shost = ioc->sh;
1117	struct scsi_device *sdev;
1118	int disk = wqw->disk;
1119	struct _CONFIG_PAGE_IOC_3 *pg3;
1120
1121	kfree(wqw);
1122
1123	mpt_findImVolumes(ioc);
1124	pg3 = ioc->raid_data.pIocPg3;
1125	if (!pg3)
1126		return;
1127
1128	shost_for_each_device(sdev,shost) {
1129		struct scsi_target *starget = scsi_target(sdev);
1130		VirtTarget *vtarget = starget->hostdata;
1131
1132		/* only want to search RAID components */
1133		if (sdev->channel != 1)
1134			continue;
1135
1136		/* The id is the raid PhysDiskNum, even if
1137		 * starget->id is the actual target address */
1138		if(vtarget->id != disk)
1139			continue;
1140
1141		starget_printk(KERN_INFO, vtarget->starget, MYIOC_s_FMT
1142		    "Integrated RAID requests DV of new device\n", ioc->name);
1143		mptspi_dv_device(hd, sdev);
1144	}
1145	shost_printk(KERN_INFO, shost, MYIOC_s_FMT
1146	    "Integrated RAID detects new device %d\n", ioc->name, disk);
1147	scsi_scan_target(&ioc->sh->shost_gendev, 1, disk, 0, SCSI_SCAN_RESCAN);
1148}
1149
1150
1151static void mpt_dv_raid(struct _MPT_SCSI_HOST *hd, int disk)
1152{
1153	struct work_queue_wrapper *wqw = kmalloc(sizeof(*wqw), GFP_ATOMIC);
1154	MPT_ADAPTER *ioc = hd->ioc;
1155
1156	if (!wqw) {
1157		shost_printk(KERN_ERR, ioc->sh, MYIOC_s_FMT
1158		    "Failed to act on RAID event for physical disk %d\n",
1159		    ioc->name, disk);
1160		return;
1161	}
1162	INIT_WORK(&wqw->work, mpt_work_wrapper);
1163	wqw->hd = hd;
1164	wqw->disk = disk;
1165
1166	schedule_work(&wqw->work);
1167}
1168
1169static int
1170mptspi_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply)
1171{
1172	u8 event = le32_to_cpu(pEvReply->Event) & 0xFF;
1173	struct _MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
1174
1175	if (ioc->bus_type != SPI)
1176		return 0;
1177
1178	if (hd && event ==  MPI_EVENT_INTEGRATED_RAID) {
1179		int reason
1180			= (le32_to_cpu(pEvReply->Data[0]) & 0x00FF0000) >> 16;
1181
1182		if (reason == MPI_EVENT_RAID_RC_DOMAIN_VAL_NEEDED) {
1183			int disk = (le32_to_cpu(pEvReply->Data[0]) & 0xFF000000) >> 24;
1184			mpt_dv_raid(hd, disk);
1185		}
1186	}
1187	return mptscsih_event_process(ioc, pEvReply);
1188}
1189
1190static int
1191mptspi_deny_binding(struct scsi_target *starget)
1192{
1193	struct _MPT_SCSI_HOST *hd =
1194		(struct _MPT_SCSI_HOST *)dev_to_shost(starget->dev.parent)->hostdata;
1195	return ((mptspi_is_raid(hd, starget->id)) &&
1196		starget->channel == 0) ? 1 : 0;
1197}
1198
1199static struct spi_function_template mptspi_transport_functions = {
1200	.get_offset	= mptspi_read_parameters,
1201	.set_offset	= mptspi_write_offset,
1202	.show_offset	= 1,
1203	.get_period	= mptspi_read_parameters,
1204	.set_period	= mptspi_write_period,
1205	.show_period	= 1,
1206	.get_width	= mptspi_read_parameters,
1207	.set_width	= mptspi_write_width,
1208	.show_width	= 1,
1209	.get_iu		= mptspi_read_parameters,
1210	.set_iu		= mptspi_write_iu,
1211	.show_iu	= 1,
1212	.get_dt		= mptspi_read_parameters,
1213	.set_dt		= mptspi_write_dt,
1214	.show_dt	= 1,
1215	.get_qas	= mptspi_read_parameters,
1216	.set_qas	= mptspi_write_qas,
1217	.show_qas	= 1,
1218	.get_wr_flow	= mptspi_read_parameters,
1219	.set_wr_flow	= mptspi_write_wr_flow,
1220	.show_wr_flow	= 1,
1221	.get_rd_strm	= mptspi_read_parameters,
1222	.set_rd_strm	= mptspi_write_rd_strm,
1223	.show_rd_strm	= 1,
1224	.get_rti	= mptspi_read_parameters,
1225	.set_rti	= mptspi_write_rti,
1226	.show_rti	= 1,
1227	.get_pcomp_en	= mptspi_read_parameters,
1228	.set_pcomp_en	= mptspi_write_pcomp_en,
1229	.show_pcomp_en	= 1,
1230	.get_hold_mcs	= mptspi_read_parameters,
1231	.set_hold_mcs	= mptspi_write_hold_mcs,
1232	.show_hold_mcs	= 1,
1233	.deny_binding	= mptspi_deny_binding,
1234};
1235
1236/****************************************************************************
1237 * Supported hardware
1238 */
1239
1240static struct pci_device_id mptspi_pci_table[] = {
1241	{ PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_53C1030,
1242		PCI_ANY_ID, PCI_ANY_ID },
1243	{ PCI_VENDOR_ID_ATTO, MPI_MANUFACTPAGE_DEVID_53C1030,
1244		PCI_ANY_ID, PCI_ANY_ID },
1245	{ PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_53C1035,
1246		PCI_ANY_ID, PCI_ANY_ID },
1247	{0}	/* Terminating entry */
1248};
1249MODULE_DEVICE_TABLE(pci, mptspi_pci_table);
1250
1251
1252/*
1253 * renegotiate for a given target
1254 */
1255static void
1256mptspi_dv_renegotiate_work(struct work_struct *work)
1257{
1258	struct work_queue_wrapper *wqw =
1259		container_of(work, struct work_queue_wrapper, work);
1260	struct _MPT_SCSI_HOST *hd = wqw->hd;
1261	struct scsi_device *sdev;
1262	struct scsi_target *starget;
1263	struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1264	u32 nego;
1265	MPT_ADAPTER *ioc = hd->ioc;
1266
1267	kfree(wqw);
1268
1269	if (hd->spi_pending) {
1270		shost_for_each_device(sdev, ioc->sh) {
1271			if  (hd->spi_pending & (1 << sdev->id))
1272				continue;
1273			starget = scsi_target(sdev);
1274			nego = mptspi_getRP(starget);
1275			pg1.RequestedParameters = cpu_to_le32(nego);
1276			pg1.Reserved = 0;
1277			pg1.Configuration = 0;
1278			mptspi_write_spi_device_pg1(starget, &pg1);
1279		}
1280	} else {
1281		shost_for_each_device(sdev, ioc->sh)
1282			mptspi_dv_device(hd, sdev);
1283	}
1284}
1285
1286static void
1287mptspi_dv_renegotiate(struct _MPT_SCSI_HOST *hd)
1288{
1289	struct work_queue_wrapper *wqw = kmalloc(sizeof(*wqw), GFP_ATOMIC);
1290
1291	if (!wqw)
1292		return;
1293
1294	INIT_WORK(&wqw->work, mptspi_dv_renegotiate_work);
1295	wqw->hd = hd;
1296
1297	schedule_work(&wqw->work);
1298}
1299
1300/*
1301 * spi module reset handler
1302 */
1303static int
1304mptspi_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
1305{
1306	int rc;
1307
1308	rc = mptscsih_ioc_reset(ioc, reset_phase);
1309	if ((ioc->bus_type != SPI) || (!rc))
1310		return rc;
1311
1312	/* only try to do a renegotiation if we're properly set up
1313	 * if we get an ioc fault on bringup, ioc->sh will be NULL */
1314	if (reset_phase == MPT_IOC_POST_RESET &&
1315	    ioc->sh) {
1316		struct _MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
1317
1318		mptspi_dv_renegotiate(hd);
1319	}
1320
1321	return rc;
1322}
1323
1324#ifdef CONFIG_PM
1325/*
1326 * spi module resume handler
1327 */
1328static int
1329mptspi_resume(struct pci_dev *pdev)
1330{
1331	MPT_ADAPTER 	*ioc = pci_get_drvdata(pdev);
1332	struct _MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
1333	int rc;
1334
1335	rc = mptscsih_resume(pdev);
1336	mptspi_dv_renegotiate(hd);
1337
1338	return rc;
1339}
1340#endif
1341
1342/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1343/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1344/*
1345 *	mptspi_probe - Installs scsi devices per bus.
1346 *	@pdev: Pointer to pci_dev structure
1347 *
1348 *	Returns 0 for success, non-zero for failure.
1349 *
1350 */
1351static int
1352mptspi_probe(struct pci_dev *pdev, const struct pci_device_id *id)
1353{
1354	struct Scsi_Host	*sh;
1355	MPT_SCSI_HOST		*hd;
1356	MPT_ADAPTER 		*ioc;
1357	unsigned long		 flags;
1358	int			 ii;
1359	int			 numSGE = 0;
1360	int			 scale;
1361	int			 ioc_cap;
1362	int			error=0;
1363	int			r;
1364
1365	if ((r = mpt_attach(pdev,id)) != 0)
1366		return r;
1367
1368	ioc = pci_get_drvdata(pdev);
1369	ioc->DoneCtx = mptspiDoneCtx;
1370	ioc->TaskCtx = mptspiTaskCtx;
1371	ioc->InternalCtx = mptspiInternalCtx;
1372
1373	/*  Added sanity check on readiness of the MPT adapter.
1374	 */
1375	if (ioc->last_state != MPI_IOC_STATE_OPERATIONAL) {
1376		printk(MYIOC_s_WARN_FMT
1377		  "Skipping because it's not operational!\n",
1378		  ioc->name);
1379		error = -ENODEV;
1380		goto out_mptspi_probe;
1381	}
1382
1383	if (!ioc->active) {
1384		printk(MYIOC_s_WARN_FMT "Skipping because it's disabled!\n",
1385		  ioc->name);
1386		error = -ENODEV;
1387		goto out_mptspi_probe;
1388	}
1389
1390	/*  Sanity check - ensure at least 1 port is INITIATOR capable
1391	 */
1392	ioc_cap = 0;
1393	for (ii=0; ii < ioc->facts.NumberOfPorts; ii++) {
1394		if (ioc->pfacts[ii].ProtocolFlags &
1395		    MPI_PORTFACTS_PROTOCOL_INITIATOR)
1396			ioc_cap ++;
1397	}
1398
1399	if (!ioc_cap) {
1400		printk(MYIOC_s_WARN_FMT
1401			"Skipping ioc=%p because SCSI Initiator mode is NOT enabled!\n",
1402			ioc->name, ioc);
1403		return 0;
1404	}
1405
1406	sh = scsi_host_alloc(&mptspi_driver_template, sizeof(MPT_SCSI_HOST));
1407
1408	if (!sh) {
1409		printk(MYIOC_s_WARN_FMT
1410			"Unable to register controller with SCSI subsystem\n",
1411			ioc->name);
1412		error = -1;
1413		goto out_mptspi_probe;
1414        }
1415
1416	/* VMWare emulation doesn't properly implement WRITE_SAME
1417	 */
1418	if (pdev->subsystem_vendor == 0x15AD)
1419		sh->no_write_same = 1;
1420
1421	spin_lock_irqsave(&ioc->FreeQlock, flags);
1422
1423	/* Attach the SCSI Host to the IOC structure
1424	 */
1425	ioc->sh = sh;
1426
1427	sh->io_port = 0;
1428	sh->n_io_port = 0;
1429	sh->irq = 0;
1430
1431	/* set 16 byte cdb's */
1432	sh->max_cmd_len = 16;
1433
1434	/* Yikes!  This is important!
1435	 * Otherwise, by default, linux
1436	 * only scans target IDs 0-7!
1437	 * pfactsN->MaxDevices unreliable
1438	 * (not supported in early
1439	 *	versions of the FW).
1440	 * max_id = 1 + actual max id,
1441	 * max_lun = 1 + actual last lun,
1442	 *	see hosts.h :o(
1443	 */
1444	sh->max_id = ioc->devices_per_bus;
1445
1446	sh->max_lun = MPT_LAST_LUN + 1;
1447	/*
1448	 * If RAID Firmware Detected, setup virtual channel
1449	 */
1450	if (ioc->ir_firmware)
1451		sh->max_channel = 1;
1452	else
1453		sh->max_channel = 0;
1454	sh->this_id = ioc->pfacts[0].PortSCSIID;
1455
1456	/* Required entry.
1457	 */
1458	sh->unique_id = ioc->id;
1459
1460	/* Verify that we won't exceed the maximum
1461	 * number of chain buffers
1462	 * We can optimize:  ZZ = req_sz/sizeof(SGE)
1463	 * For 32bit SGE's:
1464	 *  numSGE = 1 + (ZZ-1)*(maxChain -1) + ZZ
1465	 *               + (req_sz - 64)/sizeof(SGE)
1466	 * A slightly different algorithm is required for
1467	 * 64bit SGEs.
1468	 */
1469	scale = ioc->req_sz/ioc->SGE_size;
1470	if (ioc->sg_addr_size == sizeof(u64)) {
1471		numSGE = (scale - 1) *
1472		  (ioc->facts.MaxChainDepth-1) + scale +
1473		  (ioc->req_sz - 60) / ioc->SGE_size;
1474	} else {
1475		numSGE = 1 + (scale - 1) *
1476		  (ioc->facts.MaxChainDepth-1) + scale +
1477		  (ioc->req_sz - 64) / ioc->SGE_size;
1478	}
1479
1480	if (numSGE < sh->sg_tablesize) {
1481		/* Reset this value */
1482		dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1483		  "Resetting sg_tablesize to %d from %d\n",
1484		  ioc->name, numSGE, sh->sg_tablesize));
1485		sh->sg_tablesize = numSGE;
1486	}
1487
1488	spin_unlock_irqrestore(&ioc->FreeQlock, flags);
1489
1490	hd = shost_priv(sh);
1491	hd->ioc = ioc;
1492
1493	/* SCSI needs scsi_cmnd lookup table!
1494	 * (with size equal to req_depth*PtrSz!)
1495	 */
1496	ioc->ScsiLookup = kcalloc(ioc->req_depth, sizeof(void *), GFP_KERNEL);
1497	if (!ioc->ScsiLookup) {
1498		error = -ENOMEM;
1499		goto out_mptspi_probe;
1500	}
1501	spin_lock_init(&ioc->scsi_lookup_lock);
1502
1503	dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ScsiLookup @ %p\n",
1504		 ioc->name, ioc->ScsiLookup));
1505
1506	ioc->spi_data.Saf_Te = mpt_saf_te;
1507	ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1508		"saf_te %x\n",
1509		ioc->name,
1510		mpt_saf_te));
1511	ioc->spi_data.noQas = 0;
1512
1513	hd->last_queue_full = 0;
1514	hd->spi_pending = 0;
1515
1516	/* Some versions of the firmware don't support page 0; without
1517	 * that we can't get the parameters */
1518	if (ioc->spi_data.sdp0length != 0)
1519		sh->transportt = mptspi_transport_template;
1520
1521	error = scsi_add_host (sh, &ioc->pcidev->dev);
1522	if(error) {
1523		dprintk(ioc, printk(MYIOC_s_ERR_FMT
1524		  "scsi_add_host failed\n", ioc->name));
1525		goto out_mptspi_probe;
1526	}
1527
1528	/*
1529	 * issue internal bus reset
1530	 */
1531	if (ioc->spi_data.bus_reset)
1532		mptscsih_IssueTaskMgmt(hd,
1533		    MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS,
1534		    0, 0, 0, 0, 5);
1535
1536	scsi_scan_host(sh);
1537	return 0;
1538
1539out_mptspi_probe:
1540
1541	mptscsih_remove(pdev);
1542	return error;
1543}
1544
1545static void mptspi_remove(struct pci_dev *pdev)
1546{
1547	MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
1548
1549	scsi_remove_host(ioc->sh);
1550	mptscsih_remove(pdev);
1551}
1552
1553static struct pci_driver mptspi_driver = {
1554	.name		= "mptspi",
1555	.id_table	= mptspi_pci_table,
1556	.probe		= mptspi_probe,
1557	.remove		= mptspi_remove,
1558	.shutdown	= mptscsih_shutdown,
1559#ifdef CONFIG_PM
1560	.suspend	= mptscsih_suspend,
1561	.resume		= mptspi_resume,
1562#endif
1563};
1564
1565/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1566/**
1567 *	mptspi_init - Register MPT adapter(s) as SCSI host(s) with SCSI mid-layer.
1568 *
1569 *	Returns 0 for success, non-zero for failure.
1570 */
1571static int __init
1572mptspi_init(void)
1573{
1574	int error;
1575
1576	show_mptmod_ver(my_NAME, my_VERSION);
1577
1578	mptspi_transport_template = spi_attach_transport(&mptspi_transport_functions);
1579	if (!mptspi_transport_template)
1580		return -ENODEV;
1581
1582	mptspiDoneCtx = mpt_register(mptscsih_io_done, MPTSPI_DRIVER,
1583	    "mptscsih_io_done");
1584	mptspiTaskCtx = mpt_register(mptscsih_taskmgmt_complete, MPTSPI_DRIVER,
1585	    "mptscsih_taskmgmt_complete");
1586	mptspiInternalCtx = mpt_register(mptscsih_scandv_complete,
1587	    MPTSPI_DRIVER, "mptscsih_scandv_complete");
1588
1589	mpt_event_register(mptspiDoneCtx, mptspi_event_process);
1590	mpt_reset_register(mptspiDoneCtx, mptspi_ioc_reset);
1591
1592	error = pci_register_driver(&mptspi_driver);
1593	if (error)
1594		spi_release_transport(mptspi_transport_template);
1595
1596	return error;
1597}
1598
1599/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1600/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1601/**
1602 *	mptspi_exit - Unregisters MPT adapter(s)
1603 */
1604static void __exit
1605mptspi_exit(void)
1606{
1607	pci_unregister_driver(&mptspi_driver);
1608
1609	mpt_reset_deregister(mptspiDoneCtx);
1610	mpt_event_deregister(mptspiDoneCtx);
1611
1612	mpt_deregister(mptspiInternalCtx);
1613	mpt_deregister(mptspiTaskCtx);
1614	mpt_deregister(mptspiDoneCtx);
1615	spi_release_transport(mptspi_transport_template);
1616}
1617
1618module_init(mptspi_init);
1619module_exit(mptspi_exit);