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