mptspi.c

   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_sdev_init(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 "sdev_init 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_sdev_configure(struct scsi_device *sdev,
 750				 struct queue_limits *lim)
 751{
 752	struct _MPT_SCSI_HOST *hd = shost_priv(sdev->host);
 753	VirtTarget *vtarget = scsi_target(sdev)->hostdata;
 754	int ret;
 755
 756	mptspi_initTarget(hd, vtarget, sdev);
 757
 758	ret = mptscsih_sdev_configure(sdev, lim);
 759
 760	if (ret)
 761		return ret;
 762
 763	ddvprintk(hd->ioc, printk(MYIOC_s_DEBUG_FMT "id=%d min_period=0x%02x"
 764		" max_offset=0x%02x max_width=%d\n", hd->ioc->name,
 765		sdev->id, spi_min_period(scsi_target(sdev)),
 766		spi_max_offset(scsi_target(sdev)),
 767		spi_max_width(scsi_target(sdev))));
 768
 769	if ((sdev->channel == 1 ||
 770	     !(mptspi_is_raid(hd, sdev->id))) &&
 771	    !spi_initial_dv(sdev->sdev_target))
 772		mptspi_dv_device(hd, sdev);
 773
 774	return 0;
 775}
 776
 777static int
 778mptspi_qcmd(struct Scsi_Host *shost, struct scsi_cmnd *SCpnt)
 779{
 780	struct _MPT_SCSI_HOST *hd = shost_priv(shost);
 781	VirtDevice	*vdevice = SCpnt->device->hostdata;
 782	MPT_ADAPTER *ioc = hd->ioc;
 783
 784	if (!vdevice || !vdevice->vtarget) {
 785		SCpnt->result = DID_NO_CONNECT << 16;
 786		scsi_done(SCpnt);
 787		return 0;
 788	}
 789
 790	if (SCpnt->device->channel == 1 &&
 791		mptscsih_is_phys_disk(ioc, 0, SCpnt->device->id) == 0) {
 792		SCpnt->result = DID_NO_CONNECT << 16;
 793		scsi_done(SCpnt);
 794		return 0;
 795	}
 796
 797	if (spi_dv_pending(scsi_target(SCpnt->device)))
 798		ddvprintk(ioc, scsi_print_command(SCpnt));
 799
 800	return mptscsih_qcmd(SCpnt);
 801}
 802
 803static void mptspi_sdev_destroy(struct scsi_device *sdev)
 804{
 805	struct scsi_target *starget = scsi_target(sdev);
 806	VirtTarget *vtarget = starget->hostdata;
 807	VirtDevice *vdevice = sdev->hostdata;
 808
 809	/* Will this be the last lun on a non-raid device? */
 810	if (vtarget->num_luns == 1 && vdevice->configured_lun) {
 811		struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
 812
 813		/* Async Narrow */
 814		pg1.RequestedParameters = 0;
 815		pg1.Reserved = 0;
 816		pg1.Configuration = 0;
 817
 818		mptspi_write_spi_device_pg1(starget, &pg1);
 819	}
 820
 821	mptscsih_sdev_destroy(sdev);
 822}
 823
 824static const struct scsi_host_template mptspi_driver_template = {
 825	.module				= THIS_MODULE,
 826	.proc_name			= "mptspi",
 827	.show_info			= mptscsih_show_info,
 828	.name				= "MPT SPI Host",
 829	.info				= mptscsih_info,
 830	.queuecommand			= mptspi_qcmd,
 831	.target_alloc			= mptspi_target_alloc,
 832	.sdev_init			= mptspi_sdev_init,
 833	.sdev_configure			= mptspi_sdev_configure,
 834	.target_destroy			= mptspi_target_destroy,
 835	.sdev_destroy			= mptspi_sdev_destroy,
 836	.change_queue_depth 		= mptscsih_change_queue_depth,
 837	.eh_abort_handler		= mptscsih_abort,
 838	.eh_device_reset_handler	= mptscsih_dev_reset,
 839	.eh_bus_reset_handler		= mptscsih_bus_reset,
 840	.eh_host_reset_handler		= mptscsih_host_reset,
 841	.bios_param			= mptscsih_bios_param,
 842	.can_queue			= MPT_SCSI_CAN_QUEUE,
 843	.this_id			= -1,
 844	.sg_tablesize			= MPT_SCSI_SG_DEPTH,
 845	.max_sectors			= 8192,
 846	.cmd_per_lun			= 7,
 847	.dma_alignment			= 511,
 848	.shost_groups			= mptscsih_host_attr_groups,
 849};
 850
 851static int mptspi_write_spi_device_pg1(struct scsi_target *starget,
 852			       struct _CONFIG_PAGE_SCSI_DEVICE_1 *pass_pg1)
 853{
 854	struct Scsi_Host *shost = dev_to_shost(&starget->dev);
 855	struct _MPT_SCSI_HOST *hd = shost_priv(shost);
 856	struct _MPT_ADAPTER *ioc = hd->ioc;
 857	struct _CONFIG_PAGE_SCSI_DEVICE_1 *pg1;
 858	dma_addr_t pg1_dma;
 859	int size;
 860	struct _x_config_parms cfg;
 861	struct _CONFIG_PAGE_HEADER hdr;
 862	int err = -EBUSY;
 863	u32 nego_parms;
 864	u32 period;
 865	struct scsi_device *sdev;
 866	int i;
 867
 868	/* don't allow updating nego parameters on RAID devices */
 869	if (starget->channel == 0 &&
 870	    mptspi_is_raid(hd, starget->id))
 871		return -1;
 872
 873	size = ioc->spi_data.sdp1length * 4;
 874
 875	pg1 = dma_alloc_coherent(&ioc->pcidev->dev, size, &pg1_dma, GFP_KERNEL);
 876	if (pg1 == NULL) {
 877		starget_printk(KERN_ERR, starget, MYIOC_s_FMT
 878		    "dma_alloc_coherent for parameters failed\n", ioc->name);
 879		return -EINVAL;
 880	}
 881
 882	memset(&hdr, 0, sizeof(hdr));
 883
 884	hdr.PageVersion = ioc->spi_data.sdp1version;
 885	hdr.PageLength = ioc->spi_data.sdp1length;
 886	hdr.PageNumber = 1;
 887	hdr.PageType = MPI_CONFIG_PAGETYPE_SCSI_DEVICE;
 888
 889	memset(&cfg, 0, sizeof(cfg));
 890
 891	cfg.cfghdr.hdr = &hdr;
 892	cfg.physAddr = pg1_dma;
 893	cfg.action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT;
 894	cfg.dir = 1;
 895	cfg.pageAddr = starget->id;
 896
 897	memcpy(pg1, pass_pg1, size);
 898
 899	pg1->Header.PageVersion = hdr.PageVersion;
 900	pg1->Header.PageLength = hdr.PageLength;
 901	pg1->Header.PageNumber = hdr.PageNumber;
 902	pg1->Header.PageType = hdr.PageType;
 903
 904	nego_parms = le32_to_cpu(pg1->RequestedParameters);
 905	period = (nego_parms & MPI_SCSIDEVPAGE1_RP_MIN_SYNC_PERIOD_MASK) >>
 906		MPI_SCSIDEVPAGE1_RP_SHIFT_MIN_SYNC_PERIOD;
 907	if (period == 8) {
 908		/* Turn on inline data padding for TAPE when running U320 */
 909		for (i = 0 ; i < 16; i++) {
 910			sdev = scsi_device_lookup_by_target(starget, i);
 911			if (sdev && sdev->type == TYPE_TAPE) {
 912				sdev_printk(KERN_DEBUG, sdev, MYIOC_s_FMT
 913					    "IDP:ON\n", ioc->name);
 914				nego_parms |= MPI_SCSIDEVPAGE1_RP_IDP;
 915				pg1->RequestedParameters =
 916				    cpu_to_le32(nego_parms);
 917				break;
 918			}
 919		}
 920	}
 921
 922	mptspi_print_write_nego(hd, starget, le32_to_cpu(pg1->RequestedParameters));
 923
 924	if (mpt_config(ioc, &cfg)) {
 925		starget_printk(KERN_ERR, starget, MYIOC_s_FMT
 926		    "mpt_config failed\n", ioc->name);
 927		goto out_free;
 928	}
 929	err = 0;
 930
 931 out_free:
 932	dma_free_coherent(&ioc->pcidev->dev, size, pg1, pg1_dma);
 933	return err;
 934}
 935
 936static void mptspi_write_offset(struct scsi_target *starget, int offset)
 937{
 938	struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
 939	u32 nego;
 940
 941	if (offset < 0)
 942		offset = 0;
 943
 944	if (offset > 255)
 945		offset = 255;
 946
 947	if (spi_offset(starget) == -1)
 948		mptspi_read_parameters(starget);
 949
 950	spi_offset(starget) = offset;
 951
 952	nego = mptspi_getRP(starget);
 953
 954	pg1.RequestedParameters = cpu_to_le32(nego);
 955	pg1.Reserved = 0;
 956	pg1.Configuration = 0;
 957
 958	mptspi_write_spi_device_pg1(starget, &pg1);
 959}
 960
 961static void mptspi_write_period(struct scsi_target *starget, int period)
 962{
 963	struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
 964	u32 nego;
 965
 966	if (period < 8)
 967		period = 8;
 968
 969	if (period > 255)
 970		period = 255;
 971
 972	if (spi_period(starget) == -1)
 973		mptspi_read_parameters(starget);
 974
 975	if (period == 8) {
 976		spi_iu(starget) = 1;
 977		spi_dt(starget) = 1;
 978	} else if (period == 9) {
 979		spi_dt(starget) = 1;
 980	}
 981
 982	spi_period(starget) = period;
 983
 984	nego = mptspi_getRP(starget);
 985
 986	pg1.RequestedParameters = cpu_to_le32(nego);
 987	pg1.Reserved = 0;
 988	pg1.Configuration = 0;
 989
 990	mptspi_write_spi_device_pg1(starget, &pg1);
 991}
 992
 993static void mptspi_write_dt(struct scsi_target *starget, int dt)
 994{
 995	struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
 996	u32 nego;
 997
 998	if (spi_period(starget) == -1)
 999		mptspi_read_parameters(starget);
1000
1001	if (!dt && spi_period(starget) < 10)
1002		spi_period(starget) = 10;
1003
1004	spi_dt(starget) = dt;
1005
1006	nego = mptspi_getRP(starget);
1007
1008
1009	pg1.RequestedParameters = cpu_to_le32(nego);
1010	pg1.Reserved = 0;
1011	pg1.Configuration = 0;
1012
1013	mptspi_write_spi_device_pg1(starget, &pg1);
1014}
1015
1016static void mptspi_write_iu(struct scsi_target *starget, int iu)
1017{
1018	struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1019	u32 nego;
1020
1021	if (spi_period(starget) == -1)
1022		mptspi_read_parameters(starget);
1023
1024	if (!iu && spi_period(starget) < 9)
1025		spi_period(starget) = 9;
1026
1027	spi_iu(starget) = iu;
1028
1029	nego = mptspi_getRP(starget);
1030
1031	pg1.RequestedParameters = cpu_to_le32(nego);
1032	pg1.Reserved = 0;
1033	pg1.Configuration = 0;
1034
1035	mptspi_write_spi_device_pg1(starget, &pg1);
1036}
1037
1038#define MPTSPI_SIMPLE_TRANSPORT_PARM(parm) 				\
1039static void mptspi_write_##parm(struct scsi_target *starget, int parm)\
1040{									\
1041	struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;				\
1042	u32 nego;							\
1043									\
1044	spi_##parm(starget) = parm;					\
1045									\
1046	nego = mptspi_getRP(starget);					\
1047									\
1048	pg1.RequestedParameters = cpu_to_le32(nego);			\
1049	pg1.Reserved = 0;						\
1050	pg1.Configuration = 0;						\
1051									\
1052	mptspi_write_spi_device_pg1(starget, &pg1);				\
1053}
1054
1055MPTSPI_SIMPLE_TRANSPORT_PARM(rd_strm)
1056MPTSPI_SIMPLE_TRANSPORT_PARM(wr_flow)
1057MPTSPI_SIMPLE_TRANSPORT_PARM(rti)
1058MPTSPI_SIMPLE_TRANSPORT_PARM(hold_mcs)
1059MPTSPI_SIMPLE_TRANSPORT_PARM(pcomp_en)
1060
1061static void mptspi_write_qas(struct scsi_target *starget, int qas)
1062{
1063	struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1064	struct Scsi_Host *shost = dev_to_shost(&starget->dev);
1065	struct _MPT_SCSI_HOST *hd = shost_priv(shost);
1066	VirtTarget *vtarget = starget->hostdata;
1067	u32 nego;
1068
1069	if ((vtarget->negoFlags & MPT_TARGET_NO_NEGO_QAS) ||
1070	    hd->ioc->spi_data.noQas)
1071		spi_qas(starget) = 0;
1072	else
1073		spi_qas(starget) = qas;
1074
1075	nego = mptspi_getRP(starget);
1076
1077	pg1.RequestedParameters = cpu_to_le32(nego);
1078	pg1.Reserved = 0;
1079	pg1.Configuration = 0;
1080
1081	mptspi_write_spi_device_pg1(starget, &pg1);
1082}
1083
1084static void mptspi_write_width(struct scsi_target *starget, int width)
1085{
1086	struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1087	u32 nego;
1088
1089	if (!width) {
1090		spi_dt(starget) = 0;
1091		if (spi_period(starget) < 10)
1092			spi_period(starget) = 10;
1093	}
1094
1095	spi_width(starget) = width;
1096
1097	nego = mptspi_getRP(starget);
1098
1099	pg1.RequestedParameters = cpu_to_le32(nego);
1100	pg1.Reserved = 0;
1101	pg1.Configuration = 0;
1102
1103	mptspi_write_spi_device_pg1(starget, &pg1);
1104}
1105
1106struct work_queue_wrapper {
1107	struct work_struct	work;
1108	struct _MPT_SCSI_HOST	*hd;
1109	int			disk;
1110};
1111
1112static void mpt_work_wrapper(struct work_struct *work)
1113{
1114	struct work_queue_wrapper *wqw =
1115		container_of(work, struct work_queue_wrapper, work);
1116	struct _MPT_SCSI_HOST *hd = wqw->hd;
1117	MPT_ADAPTER *ioc = hd->ioc;
1118	struct Scsi_Host *shost = ioc->sh;
1119	struct scsi_device *sdev;
1120	int disk = wqw->disk;
1121	struct _CONFIG_PAGE_IOC_3 *pg3;
1122
1123	kfree(wqw);
1124
1125	mpt_findImVolumes(ioc);
1126	pg3 = ioc->raid_data.pIocPg3;
1127	if (!pg3)
1128		return;
1129
1130	shost_for_each_device(sdev,shost) {
1131		struct scsi_target *starget = scsi_target(sdev);
1132		VirtTarget *vtarget = starget->hostdata;
1133
1134		/* only want to search RAID components */
1135		if (sdev->channel != 1)
1136			continue;
1137
1138		/* The id is the raid PhysDiskNum, even if
1139		 * starget->id is the actual target address */
1140		if(vtarget->id != disk)
1141			continue;
1142
1143		starget_printk(KERN_INFO, vtarget->starget, MYIOC_s_FMT
1144		    "Integrated RAID requests DV of new device\n", ioc->name);
1145		mptspi_dv_device(hd, sdev);
1146	}
1147	shost_printk(KERN_INFO, shost, MYIOC_s_FMT
1148	    "Integrated RAID detects new device %d\n", ioc->name, disk);
1149	scsi_scan_target(&ioc->sh->shost_gendev, 1, disk, 0, SCSI_SCAN_RESCAN);
1150}
1151
1152
1153static void mpt_dv_raid(struct _MPT_SCSI_HOST *hd, int disk)
1154{
1155	struct work_queue_wrapper *wqw = kmalloc(sizeof(*wqw), GFP_ATOMIC);
1156	MPT_ADAPTER *ioc = hd->ioc;
1157
1158	if (!wqw) {
1159		shost_printk(KERN_ERR, ioc->sh, MYIOC_s_FMT
1160		    "Failed to act on RAID event for physical disk %d\n",
1161		    ioc->name, disk);
1162		return;
1163	}
1164	INIT_WORK(&wqw->work, mpt_work_wrapper);
1165	wqw->hd = hd;
1166	wqw->disk = disk;
1167
1168	schedule_work(&wqw->work);
1169}
1170
1171static int
1172mptspi_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply)
1173{
1174	u8 event = le32_to_cpu(pEvReply->Event) & 0xFF;
1175	struct _MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
1176
1177	if (ioc->bus_type != SPI)
1178		return 0;
1179
1180	if (hd && event ==  MPI_EVENT_INTEGRATED_RAID) {
1181		int reason
1182			= (le32_to_cpu(pEvReply->Data[0]) & 0x00FF0000) >> 16;
1183
1184		if (reason == MPI_EVENT_RAID_RC_DOMAIN_VAL_NEEDED) {
1185			int disk = (le32_to_cpu(pEvReply->Data[0]) & 0xFF000000) >> 24;
1186			mpt_dv_raid(hd, disk);
1187		}
1188	}
1189	return mptscsih_event_process(ioc, pEvReply);
1190}
1191
1192static int
1193mptspi_deny_binding(struct scsi_target *starget)
1194{
1195	struct _MPT_SCSI_HOST *hd =
1196		(struct _MPT_SCSI_HOST *)dev_to_shost(starget->dev.parent)->hostdata;
1197	return ((mptspi_is_raid(hd, starget->id)) &&
1198		starget->channel == 0) ? 1 : 0;
1199}
1200
1201static struct spi_function_template mptspi_transport_functions = {
1202	.get_offset	= mptspi_read_parameters,
1203	.set_offset	= mptspi_write_offset,
1204	.show_offset	= 1,
1205	.get_period	= mptspi_read_parameters,
1206	.set_period	= mptspi_write_period,
1207	.show_period	= 1,
1208	.get_width	= mptspi_read_parameters,
1209	.set_width	= mptspi_write_width,
1210	.show_width	= 1,
1211	.get_iu		= mptspi_read_parameters,
1212	.set_iu		= mptspi_write_iu,
1213	.show_iu	= 1,
1214	.get_dt		= mptspi_read_parameters,
1215	.set_dt		= mptspi_write_dt,
1216	.show_dt	= 1,
1217	.get_qas	= mptspi_read_parameters,
1218	.set_qas	= mptspi_write_qas,
1219	.show_qas	= 1,
1220	.get_wr_flow	= mptspi_read_parameters,
1221	.set_wr_flow	= mptspi_write_wr_flow,
1222	.show_wr_flow	= 1,
1223	.get_rd_strm	= mptspi_read_parameters,
1224	.set_rd_strm	= mptspi_write_rd_strm,
1225	.show_rd_strm	= 1,
1226	.get_rti	= mptspi_read_parameters,
1227	.set_rti	= mptspi_write_rti,
1228	.show_rti	= 1,
1229	.get_pcomp_en	= mptspi_read_parameters,
1230	.set_pcomp_en	= mptspi_write_pcomp_en,
1231	.show_pcomp_en	= 1,
1232	.get_hold_mcs	= mptspi_read_parameters,
1233	.set_hold_mcs	= mptspi_write_hold_mcs,
1234	.show_hold_mcs	= 1,
1235	.deny_binding	= mptspi_deny_binding,
1236};
1237
1238/****************************************************************************
1239 * Supported hardware
1240 */
1241
1242static const struct pci_device_id mptspi_pci_table[] = {
1243	{ PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_53C1030,
1244		PCI_ANY_ID, PCI_ANY_ID },
1245	{ PCI_VENDOR_ID_ATTO, MPI_MANUFACTPAGE_DEVID_53C1030,
1246		PCI_ANY_ID, PCI_ANY_ID },
1247	{ PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_53C1035,
1248		PCI_ANY_ID, PCI_ANY_ID },
1249	{0}	/* Terminating entry */
1250};
1251MODULE_DEVICE_TABLE(pci, mptspi_pci_table);
1252
1253
1254/*
1255 * renegotiate for a given target
1256 */
1257static void
1258mptspi_dv_renegotiate_work(struct work_struct *work)
1259{
1260	struct work_queue_wrapper *wqw =
1261		container_of(work, struct work_queue_wrapper, work);
1262	struct _MPT_SCSI_HOST *hd = wqw->hd;
1263	struct scsi_device *sdev;
1264	struct scsi_target *starget;
1265	struct _CONFIG_PAGE_SCSI_DEVICE_1 pg1;
1266	u32 nego;
1267	MPT_ADAPTER *ioc = hd->ioc;
1268
1269	kfree(wqw);
1270
1271	if (hd->spi_pending) {
1272		shost_for_each_device(sdev, ioc->sh) {
1273			if  (hd->spi_pending & (1 << sdev->id))
1274				continue;
1275			starget = scsi_target(sdev);
1276			nego = mptspi_getRP(starget);
1277			pg1.RequestedParameters = cpu_to_le32(nego);
1278			pg1.Reserved = 0;
1279			pg1.Configuration = 0;
1280			mptspi_write_spi_device_pg1(starget, &pg1);
1281		}
1282	} else {
1283		shost_for_each_device(sdev, ioc->sh)
1284			mptspi_dv_device(hd, sdev);
1285	}
1286}
1287
1288static void
1289mptspi_dv_renegotiate(struct _MPT_SCSI_HOST *hd)
1290{
1291	struct work_queue_wrapper *wqw = kmalloc(sizeof(*wqw), GFP_ATOMIC);
1292
1293	if (!wqw)
1294		return;
1295
1296	INIT_WORK(&wqw->work, mptspi_dv_renegotiate_work);
1297	wqw->hd = hd;
1298
1299	schedule_work(&wqw->work);
1300}
1301
1302/*
1303 * spi module reset handler
1304 */
1305static int
1306mptspi_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
1307{
1308	int rc;
1309
1310	rc = mptscsih_ioc_reset(ioc, reset_phase);
1311	if ((ioc->bus_type != SPI) || (!rc))
1312		return rc;
1313
1314	/* only try to do a renegotiation if we're properly set up
1315	 * if we get an ioc fault on bringup, ioc->sh will be NULL */
1316	if (reset_phase == MPT_IOC_POST_RESET &&
1317	    ioc->sh) {
1318		struct _MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
1319
1320		mptspi_dv_renegotiate(hd);
1321	}
1322
1323	return rc;
1324}
1325
1326#ifdef CONFIG_PM
1327/*
1328 * spi module resume handler
1329 */
1330static int
1331mptspi_resume(struct pci_dev *pdev)
1332{
1333	MPT_ADAPTER 	*ioc = pci_get_drvdata(pdev);
1334	struct _MPT_SCSI_HOST *hd = shost_priv(ioc->sh);
1335	int rc;
1336
1337	rc = mptscsih_resume(pdev);
1338	mptspi_dv_renegotiate(hd);
1339
1340	return rc;
1341}
1342#endif
1343
1344/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1345/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1346/*
1347 *	mptspi_probe - Installs scsi devices per bus.
1348 *	@pdev: Pointer to pci_dev structure
1349 *
1350 *	Returns 0 for success, non-zero for failure.
1351 *
1352 */
1353static int
1354mptspi_probe(struct pci_dev *pdev, const struct pci_device_id *id)
1355{
1356	struct Scsi_Host	*sh;
1357	MPT_SCSI_HOST		*hd;
1358	MPT_ADAPTER 		*ioc;
1359	unsigned long		 flags;
1360	int			 ii;
1361	int			 numSGE = 0;
1362	int			 scale;
1363	int			 ioc_cap;
1364	int			error=0;
1365	int			r;
1366
1367	if ((r = mpt_attach(pdev,id)) != 0)
1368		return r;
1369
1370	ioc = pci_get_drvdata(pdev);
1371	ioc->DoneCtx = mptspiDoneCtx;
1372	ioc->TaskCtx = mptspiTaskCtx;
1373	ioc->InternalCtx = mptspiInternalCtx;
1374
1375	/*  Added sanity check on readiness of the MPT adapter.
1376	 */
1377	if (ioc->last_state != MPI_IOC_STATE_OPERATIONAL) {
1378		printk(MYIOC_s_WARN_FMT
1379		  "Skipping because it's not operational!\n",
1380		  ioc->name);
1381		error = -ENODEV;
1382		goto out_mptspi_probe;
1383	}
1384
1385	if (!ioc->active) {
1386		printk(MYIOC_s_WARN_FMT "Skipping because it's disabled!\n",
1387		  ioc->name);
1388		error = -ENODEV;
1389		goto out_mptspi_probe;
1390	}
1391
1392	/*  Sanity check - ensure at least 1 port is INITIATOR capable
1393	 */
1394	ioc_cap = 0;
1395	for (ii=0; ii < ioc->facts.NumberOfPorts; ii++) {
1396		if (ioc->pfacts[ii].ProtocolFlags &
1397		    MPI_PORTFACTS_PROTOCOL_INITIATOR)
1398			ioc_cap ++;
1399	}
1400
1401	if (!ioc_cap) {
1402		printk(MYIOC_s_WARN_FMT
1403			"Skipping ioc=%p because SCSI Initiator mode is NOT enabled!\n",
1404			ioc->name, ioc);
1405		return 0;
1406	}
1407
1408	sh = scsi_host_alloc(&mptspi_driver_template, sizeof(MPT_SCSI_HOST));
1409
1410	if (!sh) {
1411		printk(MYIOC_s_WARN_FMT
1412			"Unable to register controller with SCSI subsystem\n",
1413			ioc->name);
1414		error = -1;
1415		goto out_mptspi_probe;
1416        }
1417
1418	/* VMWare emulation doesn't properly implement WRITE_SAME
1419	 */
1420	if (pdev->subsystem_vendor == 0x15AD)
1421		sh->no_write_same = 1;
1422
1423	spin_lock_irqsave(&ioc->FreeQlock, flags);
1424
1425	/* Attach the SCSI Host to the IOC structure
1426	 */
1427	ioc->sh = sh;
1428
1429	sh->io_port = 0;
1430	sh->n_io_port = 0;
1431	sh->irq = 0;
1432
1433	/* set 16 byte cdb's */
1434	sh->max_cmd_len = 16;
1435
1436	/* Yikes!  This is important!
1437	 * Otherwise, by default, linux
1438	 * only scans target IDs 0-7!
1439	 * pfactsN->MaxDevices unreliable
1440	 * (not supported in early
1441	 *	versions of the FW).
1442	 * max_id = 1 + actual max id,
1443	 * max_lun = 1 + actual last lun,
1444	 *	see hosts.h :o(
1445	 */
1446	sh->max_id = ioc->devices_per_bus;
1447
1448	sh->max_lun = MPT_LAST_LUN + 1;
1449	/*
1450	 * If RAID Firmware Detected, setup virtual channel
1451	 */
1452	if (ioc->ir_firmware)
1453		sh->max_channel = 1;
1454	else
1455		sh->max_channel = 0;
1456	sh->this_id = ioc->pfacts[0].PortSCSIID;
1457
1458	/* Required entry.
1459	 */
1460	sh->unique_id = ioc->id;
1461
1462	/* Verify that we won't exceed the maximum
1463	 * number of chain buffers
1464	 * We can optimize:  ZZ = req_sz/sizeof(SGE)
1465	 * For 32bit SGE's:
1466	 *  numSGE = 1 + (ZZ-1)*(maxChain -1) + ZZ
1467	 *               + (req_sz - 64)/sizeof(SGE)
1468	 * A slightly different algorithm is required for
1469	 * 64bit SGEs.
1470	 */
1471	scale = ioc->req_sz/ioc->SGE_size;
1472	if (ioc->sg_addr_size == sizeof(u64)) {
1473		numSGE = (scale - 1) *
1474		  (ioc->facts.MaxChainDepth-1) + scale +
1475		  (ioc->req_sz - 60) / ioc->SGE_size;
1476	} else {
1477		numSGE = 1 + (scale - 1) *
1478		  (ioc->facts.MaxChainDepth-1) + scale +
1479		  (ioc->req_sz - 64) / ioc->SGE_size;
1480	}
1481
1482	if (numSGE < sh->sg_tablesize) {
1483		/* Reset this value */
1484		dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1485		  "Resetting sg_tablesize to %d from %d\n",
1486		  ioc->name, numSGE, sh->sg_tablesize));
1487		sh->sg_tablesize = numSGE;
1488	}
1489
1490	spin_unlock_irqrestore(&ioc->FreeQlock, flags);
1491
1492	hd = shost_priv(sh);
1493	hd->ioc = ioc;
1494
1495	/* SCSI needs scsi_cmnd lookup table!
1496	 * (with size equal to req_depth*PtrSz!)
1497	 */
1498	ioc->ScsiLookup = kcalloc(ioc->req_depth, sizeof(void *), GFP_KERNEL);
1499	if (!ioc->ScsiLookup) {
1500		error = -ENOMEM;
1501		goto out_mptspi_probe;
1502	}
1503	spin_lock_init(&ioc->scsi_lookup_lock);
1504
1505	dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ScsiLookup @ %p\n",
1506		 ioc->name, ioc->ScsiLookup));
1507
1508	ioc->spi_data.Saf_Te = mpt_saf_te;
1509	ddvprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1510		"saf_te %x\n",
1511		ioc->name,
1512		mpt_saf_te));
1513	ioc->spi_data.noQas = 0;
1514
1515	hd->last_queue_full = 0;
1516	hd->spi_pending = 0;
1517
1518	/* Some versions of the firmware don't support page 0; without
1519	 * that we can't get the parameters */
1520	if (ioc->spi_data.sdp0length != 0)
1521		sh->transportt = mptspi_transport_template;
1522
1523	error = scsi_add_host (sh, &ioc->pcidev->dev);
1524	if(error) {
1525		dprintk(ioc, printk(MYIOC_s_ERR_FMT
1526		  "scsi_add_host failed\n", ioc->name));
1527		goto out_mptspi_probe;
1528	}
1529
1530	/*
1531	 * issue internal bus reset
1532	 */
1533	if (ioc->spi_data.bus_reset)
1534		mptscsih_IssueTaskMgmt(hd,
1535		    MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS,
1536		    0, 0, 0, 0, 5);
1537
1538	scsi_scan_host(sh);
1539	return 0;
1540
1541out_mptspi_probe:
1542
1543	mptscsih_remove(pdev);
1544	return error;
1545}
1546
1547static void mptspi_remove(struct pci_dev *pdev)
1548{
1549	MPT_ADAPTER *ioc = pci_get_drvdata(pdev);
1550
1551	scsi_remove_host(ioc->sh);
1552	mptscsih_remove(pdev);
1553}
1554
1555static struct pci_driver mptspi_driver = {
1556	.name		= "mptspi",
1557	.id_table	= mptspi_pci_table,
1558	.probe		= mptspi_probe,
1559	.remove		= mptspi_remove,
1560	.shutdown	= mptscsih_shutdown,
1561#ifdef CONFIG_PM
1562	.suspend	= mptscsih_suspend,
1563	.resume		= mptspi_resume,
1564#endif
1565};
1566
1567/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1568/**
1569 *	mptspi_init - Register MPT adapter(s) as SCSI host(s) with SCSI mid-layer.
1570 *
1571 *	Returns 0 for success, non-zero for failure.
1572 */
1573static int __init
1574mptspi_init(void)
1575{
1576	int error;
1577
1578	show_mptmod_ver(my_NAME, my_VERSION);
1579
1580	mptspi_transport_template = spi_attach_transport(&mptspi_transport_functions);
1581	if (!mptspi_transport_template)
1582		return -ENODEV;
1583
1584	mptspiDoneCtx = mpt_register(mptscsih_io_done, MPTSPI_DRIVER,
1585	    "mptscsih_io_done");
1586	mptspiTaskCtx = mpt_register(mptscsih_taskmgmt_complete, MPTSPI_DRIVER,
1587	    "mptscsih_taskmgmt_complete");
1588	mptspiInternalCtx = mpt_register(mptscsih_scandv_complete,
1589	    MPTSPI_DRIVER, "mptscsih_scandv_complete");
1590
1591	mpt_event_register(mptspiDoneCtx, mptspi_event_process);
1592	mpt_reset_register(mptspiDoneCtx, mptspi_ioc_reset);
1593
1594	error = pci_register_driver(&mptspi_driver);
1595	if (error)
1596		spi_release_transport(mptspi_transport_template);
1597
1598	return error;
1599}
1600
1601/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1602/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1603/**
1604 *	mptspi_exit - Unregisters MPT adapter(s)
1605 */
1606static void __exit
1607mptspi_exit(void)
1608{
1609	pci_unregister_driver(&mptspi_driver);
1610
1611	mpt_reset_deregister(mptspiDoneCtx);
1612	mpt_event_deregister(mptspiDoneCtx);
1613
1614	mpt_deregister(mptspiInternalCtx);
1615	mpt_deregister(mptspiTaskCtx);
1616	mpt_deregister(mptspiDoneCtx);
1617	spi_release_transport(mptspi_transport_template);
1618}
1619
1620module_init(mptspi_init);
1621module_exit(mptspi_exit);