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