PageRenderTime 288ms CodeModel.GetById 37ms app.highlight 222ms RepoModel.GetById 3ms app.codeStats 0ms

/drivers/message/fusion/mptfc.c

https://bitbucket.org/ndreys/linux-sunxi
C | 1557 lines | 1156 code | 220 blank | 181 comment | 208 complexity | 767a9c927a1e4c13725fd28af21ea52c MD5 | raw file
Possible License(s): GPL-2.0, LGPL-2.0, AGPL-1.0
   1/*
   2 *  linux/drivers/message/fusion/mptfc.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#include <linux/module.h>
  47#include <linux/kernel.h>
  48#include <linux/init.h>
  49#include <linux/errno.h>
  50#include <linux/kdev_t.h>
  51#include <linux/blkdev.h>
  52#include <linux/delay.h>	/* for mdelay */
  53#include <linux/interrupt.h>	/* needed for in_interrupt() proto */
  54#include <linux/reboot.h>	/* notifier code */
  55#include <linux/workqueue.h>
  56#include <linux/sort.h>
  57#include <linux/slab.h>
  58
  59#include <scsi/scsi.h>
  60#include <scsi/scsi_cmnd.h>
  61#include <scsi/scsi_device.h>
  62#include <scsi/scsi_host.h>
  63#include <scsi/scsi_tcq.h>
  64#include <scsi/scsi_transport_fc.h>
  65
  66#include "mptbase.h"
  67#include "mptscsih.h"
  68
  69/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
  70#define my_NAME		"Fusion MPT FC Host driver"
  71#define my_VERSION	MPT_LINUX_VERSION_COMMON
  72#define MYNAM		"mptfc"
  73
  74MODULE_AUTHOR(MODULEAUTHOR);
  75MODULE_DESCRIPTION(my_NAME);
  76MODULE_LICENSE("GPL");
  77MODULE_VERSION(my_VERSION);
  78
  79/* Command line args */
  80#define MPTFC_DEV_LOSS_TMO (60)
  81static int mptfc_dev_loss_tmo = MPTFC_DEV_LOSS_TMO;	/* reasonable default */
  82module_param(mptfc_dev_loss_tmo, int, 0);
  83MODULE_PARM_DESC(mptfc_dev_loss_tmo, " Initial time the driver programs the "
  84    				     " transport to wait for an rport to "
  85				     " return following a device loss event."
  86				     "  Default=60.");
  87
  88/* scsi-mid layer global parmeter is max_report_luns, which is 511 */
  89#define MPTFC_MAX_LUN (16895)
  90static int max_lun = MPTFC_MAX_LUN;
  91module_param(max_lun, int, 0);
  92MODULE_PARM_DESC(max_lun, " max lun, default=16895 ");
  93
  94static u8	mptfcDoneCtx = MPT_MAX_PROTOCOL_DRIVERS;
  95static u8	mptfcTaskCtx = MPT_MAX_PROTOCOL_DRIVERS;
  96static u8	mptfcInternalCtx = MPT_MAX_PROTOCOL_DRIVERS;
  97
  98static int mptfc_target_alloc(struct scsi_target *starget);
  99static int mptfc_slave_alloc(struct scsi_device *sdev);
 100static int mptfc_qcmd(struct Scsi_Host *shost, struct scsi_cmnd *SCpnt);
 101static void mptfc_target_destroy(struct scsi_target *starget);
 102static void mptfc_set_rport_loss_tmo(struct fc_rport *rport, uint32_t timeout);
 103static void __devexit mptfc_remove(struct pci_dev *pdev);
 104static int mptfc_abort(struct scsi_cmnd *SCpnt);
 105static int mptfc_dev_reset(struct scsi_cmnd *SCpnt);
 106static int mptfc_bus_reset(struct scsi_cmnd *SCpnt);
 107static int mptfc_host_reset(struct scsi_cmnd *SCpnt);
 108
 109static struct scsi_host_template mptfc_driver_template = {
 110	.module				= THIS_MODULE,
 111	.proc_name			= "mptfc",
 112	.proc_info			= mptscsih_proc_info,
 113	.name				= "MPT FC Host",
 114	.info				= mptscsih_info,
 115	.queuecommand			= mptfc_qcmd,
 116	.target_alloc			= mptfc_target_alloc,
 117	.slave_alloc			= mptfc_slave_alloc,
 118	.slave_configure		= mptscsih_slave_configure,
 119	.target_destroy			= mptfc_target_destroy,
 120	.slave_destroy			= mptscsih_slave_destroy,
 121	.change_queue_depth 		= mptscsih_change_queue_depth,
 122	.eh_abort_handler		= mptfc_abort,
 123	.eh_device_reset_handler	= mptfc_dev_reset,
 124	.eh_bus_reset_handler		= mptfc_bus_reset,
 125	.eh_host_reset_handler		= mptfc_host_reset,
 126	.bios_param			= mptscsih_bios_param,
 127	.can_queue			= MPT_FC_CAN_QUEUE,
 128	.this_id			= -1,
 129	.sg_tablesize			= MPT_SCSI_SG_DEPTH,
 130	.max_sectors			= 8192,
 131	.cmd_per_lun			= 7,
 132	.use_clustering			= ENABLE_CLUSTERING,
 133	.shost_attrs			= mptscsih_host_attrs,
 134};
 135
 136/****************************************************************************
 137 * Supported hardware
 138 */
 139
 140static struct pci_device_id mptfc_pci_table[] = {
 141	{ PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVICEID_FC909,
 142		PCI_ANY_ID, PCI_ANY_ID },
 143	{ PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVICEID_FC919,
 144		PCI_ANY_ID, PCI_ANY_ID },
 145	{ PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVICEID_FC929,
 146		PCI_ANY_ID, PCI_ANY_ID },
 147	{ PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVICEID_FC919X,
 148		PCI_ANY_ID, PCI_ANY_ID },
 149	{ PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVICEID_FC929X,
 150		PCI_ANY_ID, PCI_ANY_ID },
 151	{ PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVICEID_FC939X,
 152		PCI_ANY_ID, PCI_ANY_ID },
 153	{ PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVICEID_FC949X,
 154		PCI_ANY_ID, PCI_ANY_ID },
 155	{ PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVICEID_FC949E,
 156		PCI_ANY_ID, PCI_ANY_ID },
 157	{ PCI_VENDOR_ID_BROCADE, MPI_MANUFACTPAGE_DEVICEID_FC949E,
 158		PCI_ANY_ID, PCI_ANY_ID },
 159	{0}	/* Terminating entry */
 160};
 161MODULE_DEVICE_TABLE(pci, mptfc_pci_table);
 162
 163static struct scsi_transport_template *mptfc_transport_template = NULL;
 164
 165static struct fc_function_template mptfc_transport_functions = {
 166	.dd_fcrport_size = 8,
 167	.show_host_node_name = 1,
 168	.show_host_port_name = 1,
 169	.show_host_supported_classes = 1,
 170	.show_host_port_id = 1,
 171	.show_rport_supported_classes = 1,
 172	.show_starget_node_name = 1,
 173	.show_starget_port_name = 1,
 174	.show_starget_port_id = 1,
 175	.set_rport_dev_loss_tmo = mptfc_set_rport_loss_tmo,
 176	.show_rport_dev_loss_tmo = 1,
 177	.show_host_supported_speeds = 1,
 178	.show_host_maxframe_size = 1,
 179	.show_host_speed = 1,
 180	.show_host_fabric_name = 1,
 181	.show_host_port_type = 1,
 182	.show_host_port_state = 1,
 183	.show_host_symbolic_name = 1,
 184};
 185
 186static int
 187mptfc_block_error_handler(struct scsi_cmnd *SCpnt,
 188			  int (*func)(struct scsi_cmnd *SCpnt),
 189			  const char *caller)
 190{
 191	MPT_SCSI_HOST		*hd;
 192	struct scsi_device	*sdev = SCpnt->device;
 193	struct Scsi_Host	*shost = sdev->host;
 194	struct fc_rport		*rport = starget_to_rport(scsi_target(sdev));
 195	unsigned long		flags;
 196	int			ready;
 197	MPT_ADAPTER 		*ioc;
 198	int			loops = 40;	/* seconds */
 199
 200	hd = shost_priv(SCpnt->device->host);
 201	ioc = hd->ioc;
 202	spin_lock_irqsave(shost->host_lock, flags);
 203	while ((ready = fc_remote_port_chkready(rport) >> 16) == DID_IMM_RETRY
 204	 || (loops > 0 && ioc->active == 0)) {
 205		spin_unlock_irqrestore(shost->host_lock, flags);
 206		dfcprintk (ioc, printk(MYIOC_s_DEBUG_FMT
 207			"mptfc_block_error_handler.%d: %d:%d, port status is "
 208			"%x, active flag %d, deferring %s recovery.\n",
 209			ioc->name, ioc->sh->host_no,
 210			SCpnt->device->id, SCpnt->device->lun,
 211			ready, ioc->active, caller));
 212		msleep(1000);
 213		spin_lock_irqsave(shost->host_lock, flags);
 214		loops --;
 215	}
 216	spin_unlock_irqrestore(shost->host_lock, flags);
 217
 218	if (ready == DID_NO_CONNECT || !SCpnt->device->hostdata
 219	 || ioc->active == 0) {
 220		dfcprintk (ioc, printk(MYIOC_s_DEBUG_FMT
 221			"%s.%d: %d:%d, failing recovery, "
 222			"port state %x, active %d, vdevice %p.\n", caller,
 223			ioc->name, ioc->sh->host_no,
 224			SCpnt->device->id, SCpnt->device->lun, ready,
 225			ioc->active, SCpnt->device->hostdata));
 226		return FAILED;
 227	}
 228	dfcprintk (ioc, printk(MYIOC_s_DEBUG_FMT
 229		"%s.%d: %d:%d, executing recovery.\n", caller,
 230		ioc->name, ioc->sh->host_no,
 231		SCpnt->device->id, SCpnt->device->lun));
 232	return (*func)(SCpnt);
 233}
 234
 235static int
 236mptfc_abort(struct scsi_cmnd *SCpnt)
 237{
 238	return
 239	    mptfc_block_error_handler(SCpnt, mptscsih_abort, __func__);
 240}
 241
 242static int
 243mptfc_dev_reset(struct scsi_cmnd *SCpnt)
 244{
 245	return
 246	    mptfc_block_error_handler(SCpnt, mptscsih_dev_reset, __func__);
 247}
 248
 249static int
 250mptfc_bus_reset(struct scsi_cmnd *SCpnt)
 251{
 252	return
 253	    mptfc_block_error_handler(SCpnt, mptscsih_bus_reset, __func__);
 254}
 255
 256static int
 257mptfc_host_reset(struct scsi_cmnd *SCpnt)
 258{
 259	return
 260	    mptfc_block_error_handler(SCpnt, mptscsih_host_reset, __func__);
 261}
 262
 263static void
 264mptfc_set_rport_loss_tmo(struct fc_rport *rport, uint32_t timeout)
 265{
 266	if (timeout > 0)
 267		rport->dev_loss_tmo = timeout;
 268	else
 269		rport->dev_loss_tmo = mptfc_dev_loss_tmo;
 270}
 271
 272static int
 273mptfc_FcDevPage0_cmp_func(const void *a, const void *b)
 274{
 275	FCDevicePage0_t **aa = (FCDevicePage0_t **)a;
 276	FCDevicePage0_t **bb = (FCDevicePage0_t **)b;
 277
 278	if ((*aa)->CurrentBus == (*bb)->CurrentBus) {
 279		if ((*aa)->CurrentTargetID == (*bb)->CurrentTargetID)
 280			return 0;
 281		if ((*aa)->CurrentTargetID < (*bb)->CurrentTargetID)
 282			return -1;
 283		return 1;
 284	}
 285	if ((*aa)->CurrentBus < (*bb)->CurrentBus)
 286		return -1;
 287	return 1;
 288}
 289
 290static int
 291mptfc_GetFcDevPage0(MPT_ADAPTER *ioc, int ioc_port,
 292	void(*func)(MPT_ADAPTER *ioc,int channel, FCDevicePage0_t *arg))
 293{
 294	ConfigPageHeader_t	 hdr;
 295	CONFIGPARMS		 cfg;
 296	FCDevicePage0_t		*ppage0_alloc, *fc;
 297	dma_addr_t		 page0_dma;
 298	int			 data_sz;
 299	int			 ii;
 300
 301	FCDevicePage0_t		*p0_array=NULL, *p_p0;
 302	FCDevicePage0_t		**pp0_array=NULL, **p_pp0;
 303
 304	int			 rc = -ENOMEM;
 305	U32			 port_id = 0xffffff;
 306	int			 num_targ = 0;
 307	int			 max_bus = ioc->facts.MaxBuses;
 308	int			 max_targ;
 309
 310	max_targ = (ioc->facts.MaxDevices == 0) ? 256 : ioc->facts.MaxDevices;
 311
 312	data_sz = sizeof(FCDevicePage0_t) * max_bus * max_targ;
 313	p_p0 = p0_array =  kzalloc(data_sz, GFP_KERNEL);
 314	if (!p0_array)
 315		goto out;
 316
 317	data_sz = sizeof(FCDevicePage0_t *) * max_bus * max_targ;
 318	p_pp0 = pp0_array = kzalloc(data_sz, GFP_KERNEL);
 319	if (!pp0_array)
 320		goto out;
 321
 322	do {
 323		/* Get FC Device Page 0 header */
 324		hdr.PageVersion = 0;
 325		hdr.PageLength = 0;
 326		hdr.PageNumber = 0;
 327		hdr.PageType = MPI_CONFIG_PAGETYPE_FC_DEVICE;
 328		cfg.cfghdr.hdr = &hdr;
 329		cfg.physAddr = -1;
 330		cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
 331		cfg.dir = 0;
 332		cfg.pageAddr = port_id;
 333		cfg.timeout = 0;
 334
 335		if ((rc = mpt_config(ioc, &cfg)) != 0)
 336			break;
 337
 338		if (hdr.PageLength <= 0)
 339			break;
 340
 341		data_sz = hdr.PageLength * 4;
 342		ppage0_alloc = pci_alloc_consistent(ioc->pcidev, data_sz,
 343		    					&page0_dma);
 344		rc = -ENOMEM;
 345		if (!ppage0_alloc)
 346			break;
 347
 348		cfg.physAddr = page0_dma;
 349		cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
 350
 351		if ((rc = mpt_config(ioc, &cfg)) == 0) {
 352			ppage0_alloc->PortIdentifier =
 353				le32_to_cpu(ppage0_alloc->PortIdentifier);
 354
 355			ppage0_alloc->WWNN.Low =
 356				le32_to_cpu(ppage0_alloc->WWNN.Low);
 357
 358			ppage0_alloc->WWNN.High =
 359				le32_to_cpu(ppage0_alloc->WWNN.High);
 360
 361			ppage0_alloc->WWPN.Low =
 362				le32_to_cpu(ppage0_alloc->WWPN.Low);
 363
 364			ppage0_alloc->WWPN.High =
 365				le32_to_cpu(ppage0_alloc->WWPN.High);
 366
 367			ppage0_alloc->BBCredit =
 368				le16_to_cpu(ppage0_alloc->BBCredit);
 369
 370			ppage0_alloc->MaxRxFrameSize =
 371				le16_to_cpu(ppage0_alloc->MaxRxFrameSize);
 372
 373			port_id = ppage0_alloc->PortIdentifier;
 374			num_targ++;
 375			*p_p0 = *ppage0_alloc;	/* save data */
 376			*p_pp0++ = p_p0++;	/* save addr */
 377		}
 378		pci_free_consistent(ioc->pcidev, data_sz,
 379		    			(u8 *) ppage0_alloc, page0_dma);
 380		if (rc != 0)
 381			break;
 382
 383	} while (port_id <= 0xff0000);
 384
 385	if (num_targ) {
 386		/* sort array */
 387		if (num_targ > 1)
 388			sort (pp0_array, num_targ, sizeof(FCDevicePage0_t *),
 389				mptfc_FcDevPage0_cmp_func, NULL);
 390		/* call caller's func for each targ */
 391		for (ii = 0; ii < num_targ;  ii++) {
 392			fc = *(pp0_array+ii);
 393			func(ioc, ioc_port, fc);
 394		}
 395	}
 396
 397 out:
 398	kfree(pp0_array);
 399	kfree(p0_array);
 400	return rc;
 401}
 402
 403static int
 404mptfc_generate_rport_ids(FCDevicePage0_t *pg0, struct fc_rport_identifiers *rid)
 405{
 406	/* not currently usable */
 407	if (pg0->Flags & (MPI_FC_DEVICE_PAGE0_FLAGS_PLOGI_INVALID |
 408			  MPI_FC_DEVICE_PAGE0_FLAGS_PRLI_INVALID))
 409		return -1;
 410
 411	if (!(pg0->Flags & MPI_FC_DEVICE_PAGE0_FLAGS_TARGETID_BUS_VALID))
 412		return -1;
 413
 414	if (!(pg0->Protocol & MPI_FC_DEVICE_PAGE0_PROT_FCP_TARGET))
 415		return -1;
 416
 417	/*
 418	 * board data structure already normalized to platform endianness
 419	 * shifted to avoid unaligned access on 64 bit architecture
 420	 */
 421	rid->node_name = ((u64)pg0->WWNN.High) << 32 | (u64)pg0->WWNN.Low;
 422	rid->port_name = ((u64)pg0->WWPN.High) << 32 | (u64)pg0->WWPN.Low;
 423	rid->port_id =   pg0->PortIdentifier;
 424	rid->roles = FC_RPORT_ROLE_UNKNOWN;
 425
 426	return 0;
 427}
 428
 429static void
 430mptfc_register_dev(MPT_ADAPTER *ioc, int channel, FCDevicePage0_t *pg0)
 431{
 432	struct fc_rport_identifiers rport_ids;
 433	struct fc_rport		*rport;
 434	struct mptfc_rport_info	*ri;
 435	int			new_ri = 1;
 436	u64			pn, nn;
 437	VirtTarget		*vtarget;
 438	u32			roles = FC_RPORT_ROLE_UNKNOWN;
 439
 440	if (mptfc_generate_rport_ids(pg0, &rport_ids) < 0)
 441		return;
 442
 443	roles |= FC_RPORT_ROLE_FCP_TARGET;
 444	if (pg0->Protocol & MPI_FC_DEVICE_PAGE0_PROT_FCP_INITIATOR)
 445		roles |= FC_RPORT_ROLE_FCP_INITIATOR;
 446
 447	/* scan list looking for a match */
 448	list_for_each_entry(ri, &ioc->fc_rports, list) {
 449		pn = (u64)ri->pg0.WWPN.High << 32 | (u64)ri->pg0.WWPN.Low;
 450		if (pn == rport_ids.port_name) {	/* match */
 451			list_move_tail(&ri->list, &ioc->fc_rports);
 452			new_ri = 0;
 453			break;
 454		}
 455	}
 456	if (new_ri) {	/* allocate one */
 457		ri = kzalloc(sizeof(struct mptfc_rport_info), GFP_KERNEL);
 458		if (!ri)
 459			return;
 460		list_add_tail(&ri->list, &ioc->fc_rports);
 461	}
 462
 463	ri->pg0 = *pg0;	/* add/update pg0 data */
 464	ri->flags &= ~MPT_RPORT_INFO_FLAGS_MISSING;
 465
 466	/* MPT_RPORT_INFO_FLAGS_REGISTERED - rport not previously deleted */
 467	if (!(ri->flags & MPT_RPORT_INFO_FLAGS_REGISTERED)) {
 468		ri->flags |= MPT_RPORT_INFO_FLAGS_REGISTERED;
 469		rport = fc_remote_port_add(ioc->sh, channel, &rport_ids);
 470		if (rport) {
 471			ri->rport = rport;
 472			if (new_ri) /* may have been reset by user */
 473				rport->dev_loss_tmo = mptfc_dev_loss_tmo;
 474			/*
 475			 * if already mapped, remap here.  If not mapped,
 476			 * target_alloc will allocate vtarget and map,
 477			 * slave_alloc will fill in vdevice from vtarget.
 478			 */
 479			if (ri->starget) {
 480				vtarget = ri->starget->hostdata;
 481				if (vtarget) {
 482					vtarget->id = pg0->CurrentTargetID;
 483					vtarget->channel = pg0->CurrentBus;
 484					vtarget->deleted = 0;
 485				}
 486			}
 487			*((struct mptfc_rport_info **)rport->dd_data) = ri;
 488			/* scan will be scheduled once rport becomes a target */
 489			fc_remote_port_rolechg(rport,roles);
 490
 491			pn = (u64)ri->pg0.WWPN.High << 32 | (u64)ri->pg0.WWPN.Low;
 492			nn = (u64)ri->pg0.WWNN.High << 32 | (u64)ri->pg0.WWNN.Low;
 493			dfcprintk (ioc, printk(MYIOC_s_DEBUG_FMT
 494				"mptfc_reg_dev.%d: %x, %llx / %llx, tid %d, "
 495				"rport tid %d, tmo %d\n",
 496					ioc->name,
 497					ioc->sh->host_no,
 498					pg0->PortIdentifier,
 499					(unsigned long long)nn,
 500					(unsigned long long)pn,
 501					pg0->CurrentTargetID,
 502					ri->rport->scsi_target_id,
 503					ri->rport->dev_loss_tmo));
 504		} else {
 505			list_del(&ri->list);
 506			kfree(ri);
 507			ri = NULL;
 508		}
 509	}
 510}
 511
 512/*
 513 *	OS entry point to allow for host driver to free allocated memory
 514 *	Called if no device present or device being unloaded
 515 */
 516static void
 517mptfc_target_destroy(struct scsi_target *starget)
 518{
 519	struct fc_rport		*rport;
 520	struct mptfc_rport_info *ri;
 521
 522	rport = starget_to_rport(starget);
 523	if (rport) {
 524		ri = *((struct mptfc_rport_info **)rport->dd_data);
 525		if (ri)	/* better be! */
 526			ri->starget = NULL;
 527	}
 528	if (starget->hostdata)
 529		kfree(starget->hostdata);
 530	starget->hostdata = NULL;
 531}
 532
 533/*
 534 *	OS entry point to allow host driver to alloc memory
 535 *	for each scsi target. Called once per device the bus scan.
 536 *	Return non-zero if allocation fails.
 537 */
 538static int
 539mptfc_target_alloc(struct scsi_target *starget)
 540{
 541	VirtTarget		*vtarget;
 542	struct fc_rport		*rport;
 543	struct mptfc_rport_info *ri;
 544	int			rc;
 545
 546	vtarget = kzalloc(sizeof(VirtTarget), GFP_KERNEL);
 547	if (!vtarget)
 548		return -ENOMEM;
 549	starget->hostdata = vtarget;
 550
 551	rc = -ENODEV;
 552	rport = starget_to_rport(starget);
 553	if (rport) {
 554		ri = *((struct mptfc_rport_info **)rport->dd_data);
 555		if (ri) {	/* better be! */
 556			vtarget->id = ri->pg0.CurrentTargetID;
 557			vtarget->channel = ri->pg0.CurrentBus;
 558			ri->starget = starget;
 559			rc = 0;
 560		}
 561	}
 562	if (rc != 0) {
 563		kfree(vtarget);
 564		starget->hostdata = NULL;
 565	}
 566
 567	return rc;
 568}
 569/*
 570 *	mptfc_dump_lun_info
 571 *	@ioc
 572 *	@rport
 573 *	@sdev
 574 *
 575 */
 576static void
 577mptfc_dump_lun_info(MPT_ADAPTER *ioc, struct fc_rport *rport, struct scsi_device *sdev,
 578		VirtTarget *vtarget)
 579{
 580	u64 nn, pn;
 581	struct mptfc_rport_info *ri;
 582
 583	ri = *((struct mptfc_rport_info **)rport->dd_data);
 584	pn = (u64)ri->pg0.WWPN.High << 32 | (u64)ri->pg0.WWPN.Low;
 585	nn = (u64)ri->pg0.WWNN.High << 32 | (u64)ri->pg0.WWNN.Low;
 586	dfcprintk (ioc, printk(MYIOC_s_DEBUG_FMT
 587		"mptfc_slv_alloc.%d: num_luns %d, sdev.id %d, "
 588		"CurrentTargetID %d, %x %llx %llx\n",
 589		ioc->name,
 590		sdev->host->host_no,
 591		vtarget->num_luns,
 592		sdev->id, ri->pg0.CurrentTargetID,
 593		ri->pg0.PortIdentifier,
 594		(unsigned long long)pn,
 595		(unsigned long long)nn));
 596}
 597
 598
 599/*
 600 *	OS entry point to allow host driver to alloc memory
 601 *	for each scsi device. Called once per device the bus scan.
 602 *	Return non-zero if allocation fails.
 603 *	Init memory once per LUN.
 604 */
 605static int
 606mptfc_slave_alloc(struct scsi_device *sdev)
 607{
 608	MPT_SCSI_HOST		*hd;
 609	VirtTarget		*vtarget;
 610	VirtDevice		*vdevice;
 611	struct scsi_target	*starget;
 612	struct fc_rport		*rport;
 613	MPT_ADAPTER 		*ioc;
 614
 615	starget = scsi_target(sdev);
 616	rport = starget_to_rport(starget);
 617
 618	if (!rport || fc_remote_port_chkready(rport))
 619		return -ENXIO;
 620
 621	hd = shost_priv(sdev->host);
 622	ioc = hd->ioc;
 623
 624	vdevice = kzalloc(sizeof(VirtDevice), GFP_KERNEL);
 625	if (!vdevice) {
 626		printk(MYIOC_s_ERR_FMT "slave_alloc kmalloc(%zd) FAILED!\n",
 627				ioc->name, sizeof(VirtDevice));
 628		return -ENOMEM;
 629	}
 630
 631
 632	sdev->hostdata = vdevice;
 633	vtarget = starget->hostdata;
 634
 635	if (vtarget->num_luns == 0) {
 636		vtarget->ioc_id = ioc->id;
 637		vtarget->tflags = MPT_TARGET_FLAGS_Q_YES;
 638	}
 639
 640	vdevice->vtarget = vtarget;
 641	vdevice->lun = sdev->lun;
 642
 643	vtarget->num_luns++;
 644
 645
 646	mptfc_dump_lun_info(ioc, rport, sdev, vtarget);
 647
 648	return 0;
 649}
 650
 651static int
 652mptfc_qcmd_lck(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *))
 653{
 654	struct mptfc_rport_info	*ri;
 655	struct fc_rport	*rport = starget_to_rport(scsi_target(SCpnt->device));
 656	int		err;
 657	VirtDevice	*vdevice = SCpnt->device->hostdata;
 658
 659	if (!vdevice || !vdevice->vtarget) {
 660		SCpnt->result = DID_NO_CONNECT << 16;
 661		done(SCpnt);
 662		return 0;
 663	}
 664
 665	err = fc_remote_port_chkready(rport);
 666	if (unlikely(err)) {
 667		SCpnt->result = err;
 668		done(SCpnt);
 669		return 0;
 670	}
 671
 672	/* dd_data is null until finished adding target */
 673	ri = *((struct mptfc_rport_info **)rport->dd_data);
 674	if (unlikely(!ri)) {
 675		SCpnt->result = DID_IMM_RETRY << 16;
 676		done(SCpnt);
 677		return 0;
 678	}
 679
 680	return mptscsih_qcmd(SCpnt,done);
 681}
 682
 683static DEF_SCSI_QCMD(mptfc_qcmd)
 684
 685/*
 686 *	mptfc_display_port_link_speed - displaying link speed
 687 *	@ioc: Pointer to MPT_ADAPTER structure
 688 *	@portnum: IOC Port number
 689 *	@pp0dest: port page0 data payload
 690 *
 691 */
 692static void
 693mptfc_display_port_link_speed(MPT_ADAPTER *ioc, int portnum, FCPortPage0_t *pp0dest)
 694{
 695	u8	old_speed, new_speed, state;
 696	char	*old, *new;
 697
 698	if (portnum >= 2)
 699		return;
 700
 701	old_speed = ioc->fc_link_speed[portnum];
 702	new_speed = pp0dest->CurrentSpeed;
 703	state = pp0dest->PortState;
 704
 705	if (state != MPI_FCPORTPAGE0_PORTSTATE_OFFLINE &&
 706	    new_speed != MPI_FCPORTPAGE0_CURRENT_SPEED_UKNOWN) {
 707
 708		old = old_speed == MPI_FCPORTPAGE0_CURRENT_SPEED_1GBIT ? "1 Gbps" :
 709		       old_speed == MPI_FCPORTPAGE0_CURRENT_SPEED_2GBIT ? "2 Gbps" :
 710			old_speed == MPI_FCPORTPAGE0_CURRENT_SPEED_4GBIT ? "4 Gbps" :
 711			 "Unknown";
 712		new = new_speed == MPI_FCPORTPAGE0_CURRENT_SPEED_1GBIT ? "1 Gbps" :
 713		       new_speed == MPI_FCPORTPAGE0_CURRENT_SPEED_2GBIT ? "2 Gbps" :
 714			new_speed == MPI_FCPORTPAGE0_CURRENT_SPEED_4GBIT ? "4 Gbps" :
 715			 "Unknown";
 716		if (old_speed == 0)
 717			printk(MYIOC_s_NOTE_FMT
 718				"FC Link Established, Speed = %s\n",
 719				ioc->name, new);
 720		else if (old_speed != new_speed)
 721			printk(MYIOC_s_WARN_FMT
 722				"FC Link Speed Change, Old Speed = %s, New Speed = %s\n",
 723				ioc->name, old, new);
 724
 725		ioc->fc_link_speed[portnum] = new_speed;
 726	}
 727}
 728
 729/*
 730 *	mptfc_GetFcPortPage0 - Fetch FCPort config Page0.
 731 *	@ioc: Pointer to MPT_ADAPTER structure
 732 *	@portnum: IOC Port number
 733 *
 734 *	Return: 0 for success
 735 *	-ENOMEM if no memory available
 736 *		-EPERM if not allowed due to ISR context
 737 *		-EAGAIN if no msg frames currently available
 738 *		-EFAULT for non-successful reply or no reply (timeout)
 739 *		-EINVAL portnum arg out of range (hardwired to two elements)
 740 */
 741static int
 742mptfc_GetFcPortPage0(MPT_ADAPTER *ioc, int portnum)
 743{
 744	ConfigPageHeader_t	 hdr;
 745	CONFIGPARMS		 cfg;
 746	FCPortPage0_t		*ppage0_alloc;
 747	FCPortPage0_t		*pp0dest;
 748	dma_addr_t		 page0_dma;
 749	int			 data_sz;
 750	int			 copy_sz;
 751	int			 rc;
 752	int			 count = 400;
 753
 754	if (portnum > 1)
 755		return -EINVAL;
 756
 757	/* Get FCPort Page 0 header */
 758	hdr.PageVersion = 0;
 759	hdr.PageLength = 0;
 760	hdr.PageNumber = 0;
 761	hdr.PageType = MPI_CONFIG_PAGETYPE_FC_PORT;
 762	cfg.cfghdr.hdr = &hdr;
 763	cfg.physAddr = -1;
 764	cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
 765	cfg.dir = 0;
 766	cfg.pageAddr = portnum;
 767	cfg.timeout = 0;
 768
 769	if ((rc = mpt_config(ioc, &cfg)) != 0)
 770		return rc;
 771
 772	if (hdr.PageLength == 0)
 773		return 0;
 774
 775	data_sz = hdr.PageLength * 4;
 776	rc = -ENOMEM;
 777	ppage0_alloc = (FCPortPage0_t *) pci_alloc_consistent(ioc->pcidev, data_sz, &page0_dma);
 778	if (ppage0_alloc) {
 779
 780 try_again:
 781		memset((u8 *)ppage0_alloc, 0, data_sz);
 782		cfg.physAddr = page0_dma;
 783		cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
 784
 785		if ((rc = mpt_config(ioc, &cfg)) == 0) {
 786			/* save the data */
 787			pp0dest = &ioc->fc_port_page0[portnum];
 788			copy_sz = min_t(int, sizeof(FCPortPage0_t), data_sz);
 789			memcpy(pp0dest, ppage0_alloc, copy_sz);
 790
 791			/*
 792			 *	Normalize endianness of structure data,
 793			 *	by byte-swapping all > 1 byte fields!
 794			 */
 795			pp0dest->Flags = le32_to_cpu(pp0dest->Flags);
 796			pp0dest->PortIdentifier = le32_to_cpu(pp0dest->PortIdentifier);
 797			pp0dest->WWNN.Low = le32_to_cpu(pp0dest->WWNN.Low);
 798			pp0dest->WWNN.High = le32_to_cpu(pp0dest->WWNN.High);
 799			pp0dest->WWPN.Low = le32_to_cpu(pp0dest->WWPN.Low);
 800			pp0dest->WWPN.High = le32_to_cpu(pp0dest->WWPN.High);
 801			pp0dest->SupportedServiceClass = le32_to_cpu(pp0dest->SupportedServiceClass);
 802			pp0dest->SupportedSpeeds = le32_to_cpu(pp0dest->SupportedSpeeds);
 803			pp0dest->CurrentSpeed = le32_to_cpu(pp0dest->CurrentSpeed);
 804			pp0dest->MaxFrameSize = le32_to_cpu(pp0dest->MaxFrameSize);
 805			pp0dest->FabricWWNN.Low = le32_to_cpu(pp0dest->FabricWWNN.Low);
 806			pp0dest->FabricWWNN.High = le32_to_cpu(pp0dest->FabricWWNN.High);
 807			pp0dest->FabricWWPN.Low = le32_to_cpu(pp0dest->FabricWWPN.Low);
 808			pp0dest->FabricWWPN.High = le32_to_cpu(pp0dest->FabricWWPN.High);
 809			pp0dest->DiscoveredPortsCount = le32_to_cpu(pp0dest->DiscoveredPortsCount);
 810			pp0dest->MaxInitiators = le32_to_cpu(pp0dest->MaxInitiators);
 811
 812			/*
 813			 * if still doing discovery,
 814			 * hang loose a while until finished
 815			 */
 816			if ((pp0dest->PortState == MPI_FCPORTPAGE0_PORTSTATE_UNKNOWN) ||
 817			    (pp0dest->PortState == MPI_FCPORTPAGE0_PORTSTATE_ONLINE &&
 818			     (pp0dest->Flags & MPI_FCPORTPAGE0_FLAGS_ATTACH_TYPE_MASK)
 819			      == MPI_FCPORTPAGE0_FLAGS_ATTACH_NO_INIT)) {
 820				if (count-- > 0) {
 821					msleep(100);
 822					goto try_again;
 823				}
 824				printk(MYIOC_s_INFO_FMT "Firmware discovery not"
 825							" complete.\n",
 826						ioc->name);
 827			}
 828			mptfc_display_port_link_speed(ioc, portnum, pp0dest);
 829		}
 830
 831		pci_free_consistent(ioc->pcidev, data_sz, (u8 *) ppage0_alloc, page0_dma);
 832	}
 833
 834	return rc;
 835}
 836
 837static int
 838mptfc_WriteFcPortPage1(MPT_ADAPTER *ioc, int portnum)
 839{
 840	ConfigPageHeader_t	 hdr;
 841	CONFIGPARMS		 cfg;
 842	int			 rc;
 843
 844	if (portnum > 1)
 845		return -EINVAL;
 846
 847	if (!(ioc->fc_data.fc_port_page1[portnum].data))
 848		return -EINVAL;
 849
 850	/* get fcport page 1 header */
 851	hdr.PageVersion = 0;
 852	hdr.PageLength = 0;
 853	hdr.PageNumber = 1;
 854	hdr.PageType = MPI_CONFIG_PAGETYPE_FC_PORT;
 855	cfg.cfghdr.hdr = &hdr;
 856	cfg.physAddr = -1;
 857	cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
 858	cfg.dir = 0;
 859	cfg.pageAddr = portnum;
 860	cfg.timeout = 0;
 861
 862	if ((rc = mpt_config(ioc, &cfg)) != 0)
 863		return rc;
 864
 865	if (hdr.PageLength == 0)
 866		return -ENODEV;
 867
 868	if (hdr.PageLength*4 != ioc->fc_data.fc_port_page1[portnum].pg_sz)
 869		return -EINVAL;
 870
 871	cfg.physAddr = ioc->fc_data.fc_port_page1[portnum].dma;
 872	cfg.action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT;
 873	cfg.dir = 1;
 874
 875	rc = mpt_config(ioc, &cfg);
 876
 877	return rc;
 878}
 879
 880static int
 881mptfc_GetFcPortPage1(MPT_ADAPTER *ioc, int portnum)
 882{
 883	ConfigPageHeader_t	 hdr;
 884	CONFIGPARMS		 cfg;
 885	FCPortPage1_t		*page1_alloc;
 886	dma_addr_t		 page1_dma;
 887	int			 data_sz;
 888	int			 rc;
 889
 890	if (portnum > 1)
 891		return -EINVAL;
 892
 893	/* get fcport page 1 header */
 894	hdr.PageVersion = 0;
 895	hdr.PageLength = 0;
 896	hdr.PageNumber = 1;
 897	hdr.PageType = MPI_CONFIG_PAGETYPE_FC_PORT;
 898	cfg.cfghdr.hdr = &hdr;
 899	cfg.physAddr = -1;
 900	cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
 901	cfg.dir = 0;
 902	cfg.pageAddr = portnum;
 903	cfg.timeout = 0;
 904
 905	if ((rc = mpt_config(ioc, &cfg)) != 0)
 906		return rc;
 907
 908	if (hdr.PageLength == 0)
 909		return -ENODEV;
 910
 911start_over:
 912
 913	if (ioc->fc_data.fc_port_page1[portnum].data == NULL) {
 914		data_sz = hdr.PageLength * 4;
 915		if (data_sz < sizeof(FCPortPage1_t))
 916			data_sz = sizeof(FCPortPage1_t);
 917
 918		page1_alloc = (FCPortPage1_t *) pci_alloc_consistent(ioc->pcidev,
 919						data_sz,
 920						&page1_dma);
 921		if (!page1_alloc)
 922			return -ENOMEM;
 923	}
 924	else {
 925		page1_alloc = ioc->fc_data.fc_port_page1[portnum].data;
 926		page1_dma = ioc->fc_data.fc_port_page1[portnum].dma;
 927		data_sz = ioc->fc_data.fc_port_page1[portnum].pg_sz;
 928		if (hdr.PageLength * 4 > data_sz) {
 929			ioc->fc_data.fc_port_page1[portnum].data = NULL;
 930			pci_free_consistent(ioc->pcidev, data_sz, (u8 *)
 931				page1_alloc, page1_dma);
 932			goto start_over;
 933		}
 934	}
 935
 936	memset(page1_alloc,0,data_sz);
 937
 938	cfg.physAddr = page1_dma;
 939	cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
 940
 941	if ((rc = mpt_config(ioc, &cfg)) == 0) {
 942		ioc->fc_data.fc_port_page1[portnum].data = page1_alloc;
 943		ioc->fc_data.fc_port_page1[portnum].pg_sz = data_sz;
 944		ioc->fc_data.fc_port_page1[portnum].dma = page1_dma;
 945	}
 946	else {
 947		ioc->fc_data.fc_port_page1[portnum].data = NULL;
 948		pci_free_consistent(ioc->pcidev, data_sz, (u8 *)
 949			page1_alloc, page1_dma);
 950	}
 951
 952	return rc;
 953}
 954
 955static void
 956mptfc_SetFcPortPage1_defaults(MPT_ADAPTER *ioc)
 957{
 958	int		ii;
 959	FCPortPage1_t	*pp1;
 960
 961	#define MPTFC_FW_DEVICE_TIMEOUT	(1)
 962	#define MPTFC_FW_IO_PEND_TIMEOUT (1)
 963	#define ON_FLAGS  (MPI_FCPORTPAGE1_FLAGS_IMMEDIATE_ERROR_REPLY)
 964	#define OFF_FLAGS (MPI_FCPORTPAGE1_FLAGS_VERBOSE_RESCAN_EVENTS)
 965
 966	for (ii=0; ii<ioc->facts.NumberOfPorts; ii++) {
 967		if (mptfc_GetFcPortPage1(ioc, ii) != 0)
 968			continue;
 969		pp1 = ioc->fc_data.fc_port_page1[ii].data;
 970		if ((pp1->InitiatorDeviceTimeout == MPTFC_FW_DEVICE_TIMEOUT)
 971		 && (pp1->InitiatorIoPendTimeout == MPTFC_FW_IO_PEND_TIMEOUT)
 972		 && ((pp1->Flags & ON_FLAGS) == ON_FLAGS)
 973		 && ((pp1->Flags & OFF_FLAGS) == 0))
 974			continue;
 975		pp1->InitiatorDeviceTimeout = MPTFC_FW_DEVICE_TIMEOUT;
 976		pp1->InitiatorIoPendTimeout = MPTFC_FW_IO_PEND_TIMEOUT;
 977		pp1->Flags &= ~OFF_FLAGS;
 978		pp1->Flags |= ON_FLAGS;
 979		mptfc_WriteFcPortPage1(ioc, ii);
 980	}
 981}
 982
 983
 984static void
 985mptfc_init_host_attr(MPT_ADAPTER *ioc,int portnum)
 986{
 987	unsigned	class = 0;
 988	unsigned	cos = 0;
 989	unsigned	speed;
 990	unsigned	port_type;
 991	unsigned	port_state;
 992	FCPortPage0_t	*pp0;
 993	struct Scsi_Host *sh;
 994	char		*sn;
 995
 996	/* don't know what to do as only one scsi (fc) host was allocated */
 997	if (portnum != 0)
 998		return;
 999
1000	pp0 = &ioc->fc_port_page0[portnum];
1001	sh = ioc->sh;
1002
1003	sn = fc_host_symbolic_name(sh);
1004	snprintf(sn, FC_SYMBOLIC_NAME_SIZE, "%s %s%08xh",
1005	    ioc->prod_name,
1006	    MPT_FW_REV_MAGIC_ID_STRING,
1007	    ioc->facts.FWVersion.Word);
1008
1009	fc_host_tgtid_bind_type(sh) = FC_TGTID_BIND_BY_WWPN;
1010
1011	fc_host_maxframe_size(sh) = pp0->MaxFrameSize;
1012
1013	fc_host_node_name(sh) =
1014	    	(u64)pp0->WWNN.High << 32 | (u64)pp0->WWNN.Low;
1015
1016	fc_host_port_name(sh) =
1017	    	(u64)pp0->WWPN.High << 32 | (u64)pp0->WWPN.Low;
1018
1019	fc_host_port_id(sh) = pp0->PortIdentifier;
1020
1021	class = pp0->SupportedServiceClass;
1022	if (class & MPI_FCPORTPAGE0_SUPPORT_CLASS_1)
1023		cos |= FC_COS_CLASS1;
1024	if (class & MPI_FCPORTPAGE0_SUPPORT_CLASS_2)
1025		cos |= FC_COS_CLASS2;
1026	if (class & MPI_FCPORTPAGE0_SUPPORT_CLASS_3)
1027		cos |= FC_COS_CLASS3;
1028	fc_host_supported_classes(sh) = cos;
1029
1030	if (pp0->CurrentSpeed == MPI_FCPORTPAGE0_CURRENT_SPEED_1GBIT)
1031		speed = FC_PORTSPEED_1GBIT;
1032	else if (pp0->CurrentSpeed == MPI_FCPORTPAGE0_CURRENT_SPEED_2GBIT)
1033		speed = FC_PORTSPEED_2GBIT;
1034	else if (pp0->CurrentSpeed == MPI_FCPORTPAGE0_CURRENT_SPEED_4GBIT)
1035		speed = FC_PORTSPEED_4GBIT;
1036	else if (pp0->CurrentSpeed == MPI_FCPORTPAGE0_CURRENT_SPEED_10GBIT)
1037		speed = FC_PORTSPEED_10GBIT;
1038	else
1039		speed = FC_PORTSPEED_UNKNOWN;
1040	fc_host_speed(sh) = speed;
1041
1042	speed = 0;
1043	if (pp0->SupportedSpeeds & MPI_FCPORTPAGE0_SUPPORT_1GBIT_SPEED)
1044		speed |= FC_PORTSPEED_1GBIT;
1045	if (pp0->SupportedSpeeds & MPI_FCPORTPAGE0_SUPPORT_2GBIT_SPEED)
1046		speed |= FC_PORTSPEED_2GBIT;
1047	if (pp0->SupportedSpeeds & MPI_FCPORTPAGE0_SUPPORT_4GBIT_SPEED)
1048		speed |= FC_PORTSPEED_4GBIT;
1049	if (pp0->SupportedSpeeds & MPI_FCPORTPAGE0_SUPPORT_10GBIT_SPEED)
1050		speed |= FC_PORTSPEED_10GBIT;
1051	fc_host_supported_speeds(sh) = speed;
1052
1053	port_state = FC_PORTSTATE_UNKNOWN;
1054	if (pp0->PortState == MPI_FCPORTPAGE0_PORTSTATE_ONLINE)
1055		port_state = FC_PORTSTATE_ONLINE;
1056	else if (pp0->PortState == MPI_FCPORTPAGE0_PORTSTATE_OFFLINE)
1057		port_state = FC_PORTSTATE_LINKDOWN;
1058	fc_host_port_state(sh) = port_state;
1059
1060	port_type = FC_PORTTYPE_UNKNOWN;
1061	if (pp0->Flags & MPI_FCPORTPAGE0_FLAGS_ATTACH_POINT_TO_POINT)
1062		port_type = FC_PORTTYPE_PTP;
1063	else if (pp0->Flags & MPI_FCPORTPAGE0_FLAGS_ATTACH_PRIVATE_LOOP)
1064		port_type = FC_PORTTYPE_LPORT;
1065	else if (pp0->Flags & MPI_FCPORTPAGE0_FLAGS_ATTACH_PUBLIC_LOOP)
1066		port_type = FC_PORTTYPE_NLPORT;
1067	else if (pp0->Flags & MPI_FCPORTPAGE0_FLAGS_ATTACH_FABRIC_DIRECT)
1068		port_type = FC_PORTTYPE_NPORT;
1069	fc_host_port_type(sh) = port_type;
1070
1071	fc_host_fabric_name(sh) =
1072	    (pp0->Flags & MPI_FCPORTPAGE0_FLAGS_FABRIC_WWN_VALID) ?
1073		(u64) pp0->FabricWWNN.High << 32 | (u64) pp0->FabricWWPN.Low :
1074		(u64)pp0->WWNN.High << 32 | (u64)pp0->WWNN.Low;
1075
1076}
1077
1078static void
1079mptfc_link_status_change(struct work_struct *work)
1080{
1081	MPT_ADAPTER             *ioc =
1082		container_of(work, MPT_ADAPTER, fc_rescan_work);
1083	int ii;
1084
1085	for (ii=0; ii < ioc->facts.NumberOfPorts; ii++)
1086		(void) mptfc_GetFcPortPage0(ioc, ii);
1087
1088}
1089
1090static void
1091mptfc_setup_reset(struct work_struct *work)
1092{
1093	MPT_ADAPTER		*ioc =
1094		container_of(work, MPT_ADAPTER, fc_setup_reset_work);
1095	u64			pn;
1096	struct mptfc_rport_info *ri;
1097	struct scsi_target      *starget;
1098	VirtTarget              *vtarget;
1099
1100	/* reset about to happen, delete (block) all rports */
1101	list_for_each_entry(ri, &ioc->fc_rports, list) {
1102		if (ri->flags & MPT_RPORT_INFO_FLAGS_REGISTERED) {
1103			ri->flags &= ~MPT_RPORT_INFO_FLAGS_REGISTERED;
1104			fc_remote_port_delete(ri->rport);	/* won't sleep */
1105			ri->rport = NULL;
1106			starget = ri->starget;
1107			if (starget) {
1108				vtarget = starget->hostdata;
1109				if (vtarget)
1110					vtarget->deleted = 1;
1111			}
1112
1113			pn = (u64)ri->pg0.WWPN.High << 32 |
1114			     (u64)ri->pg0.WWPN.Low;
1115			dfcprintk (ioc, printk(MYIOC_s_DEBUG_FMT
1116				"mptfc_setup_reset.%d: %llx deleted\n",
1117				ioc->name,
1118				ioc->sh->host_no,
1119				(unsigned long long)pn));
1120		}
1121	}
1122}
1123
1124static void
1125mptfc_rescan_devices(struct work_struct *work)
1126{
1127	MPT_ADAPTER		*ioc =
1128		container_of(work, MPT_ADAPTER, fc_rescan_work);
1129	int			ii;
1130	u64			pn;
1131	struct mptfc_rport_info *ri;
1132	struct scsi_target      *starget;
1133	VirtTarget              *vtarget;
1134
1135	/* start by tagging all ports as missing */
1136	list_for_each_entry(ri, &ioc->fc_rports, list) {
1137		if (ri->flags & MPT_RPORT_INFO_FLAGS_REGISTERED) {
1138			ri->flags |= MPT_RPORT_INFO_FLAGS_MISSING;
1139		}
1140	}
1141
1142	/*
1143	 * now rescan devices known to adapter,
1144	 * will reregister existing rports
1145	 */
1146	for (ii=0; ii < ioc->facts.NumberOfPorts; ii++) {
1147		(void) mptfc_GetFcPortPage0(ioc, ii);
1148		mptfc_init_host_attr(ioc, ii);	/* refresh */
1149		mptfc_GetFcDevPage0(ioc, ii, mptfc_register_dev);
1150	}
1151
1152	/* delete devices still missing */
1153	list_for_each_entry(ri, &ioc->fc_rports, list) {
1154		/* if newly missing, delete it */
1155		if (ri->flags & MPT_RPORT_INFO_FLAGS_MISSING) {
1156
1157			ri->flags &= ~(MPT_RPORT_INFO_FLAGS_REGISTERED|
1158				       MPT_RPORT_INFO_FLAGS_MISSING);
1159			fc_remote_port_delete(ri->rport);	/* won't sleep */
1160			ri->rport = NULL;
1161			starget = ri->starget;
1162			if (starget) {
1163				vtarget = starget->hostdata;
1164				if (vtarget)
1165					vtarget->deleted = 1;
1166			}
1167
1168			pn = (u64)ri->pg0.WWPN.High << 32 |
1169			     (u64)ri->pg0.WWPN.Low;
1170			dfcprintk (ioc, printk(MYIOC_s_DEBUG_FMT
1171				"mptfc_rescan.%d: %llx deleted\n",
1172				ioc->name,
1173				ioc->sh->host_no,
1174				(unsigned long long)pn));
1175		}
1176	}
1177}
1178
1179static int
1180mptfc_probe(struct pci_dev *pdev, const struct pci_device_id *id)
1181{
1182	struct Scsi_Host	*sh;
1183	MPT_SCSI_HOST		*hd;
1184	MPT_ADAPTER 		*ioc;
1185	unsigned long		 flags;
1186	int			 ii;
1187	int			 numSGE = 0;
1188	int			 scale;
1189	int			 ioc_cap;
1190	int			error=0;
1191	int			r;
1192
1193	if ((r = mpt_attach(pdev,id)) != 0)
1194		return r;
1195
1196	ioc = pci_get_drvdata(pdev);
1197	ioc->DoneCtx = mptfcDoneCtx;
1198	ioc->TaskCtx = mptfcTaskCtx;
1199	ioc->InternalCtx = mptfcInternalCtx;
1200
1201	/*  Added sanity check on readiness of the MPT adapter.
1202	 */
1203	if (ioc->last_state != MPI_IOC_STATE_OPERATIONAL) {
1204		printk(MYIOC_s_WARN_FMT
1205		  "Skipping because it's not operational!\n",
1206		  ioc->name);
1207		error = -ENODEV;
1208		goto out_mptfc_probe;
1209	}
1210
1211	if (!ioc->active) {
1212		printk(MYIOC_s_WARN_FMT "Skipping because it's disabled!\n",
1213		  ioc->name);
1214		error = -ENODEV;
1215		goto out_mptfc_probe;
1216	}
1217
1218	/*  Sanity check - ensure at least 1 port is INITIATOR capable
1219	 */
1220	ioc_cap = 0;
1221	for (ii=0; ii < ioc->facts.NumberOfPorts; ii++) {
1222		if (ioc->pfacts[ii].ProtocolFlags &
1223		    MPI_PORTFACTS_PROTOCOL_INITIATOR)
1224			ioc_cap ++;
1225	}
1226
1227	if (!ioc_cap) {
1228		printk(MYIOC_s_WARN_FMT
1229			"Skipping ioc=%p because SCSI Initiator mode is NOT enabled!\n",
1230			ioc->name, ioc);
1231		return 0;
1232	}
1233
1234	sh = scsi_host_alloc(&mptfc_driver_template, sizeof(MPT_SCSI_HOST));
1235
1236	if (!sh) {
1237		printk(MYIOC_s_WARN_FMT
1238			"Unable to register controller with SCSI subsystem\n",
1239			ioc->name);
1240		error = -1;
1241		goto out_mptfc_probe;
1242        }
1243
1244	spin_lock_init(&ioc->fc_rescan_work_lock);
1245	INIT_WORK(&ioc->fc_rescan_work, mptfc_rescan_devices);
1246	INIT_WORK(&ioc->fc_setup_reset_work, mptfc_setup_reset);
1247	INIT_WORK(&ioc->fc_lsc_work, mptfc_link_status_change);
1248
1249	spin_lock_irqsave(&ioc->FreeQlock, flags);
1250
1251	/* Attach the SCSI Host to the IOC structure
1252	 */
1253	ioc->sh = sh;
1254
1255	sh->io_port = 0;
1256	sh->n_io_port = 0;
1257	sh->irq = 0;
1258
1259	/* set 16 byte cdb's */
1260	sh->max_cmd_len = 16;
1261
1262	sh->max_id = ioc->pfacts->MaxDevices;
1263	sh->max_lun = max_lun;
1264
1265	/* Required entry.
1266	 */
1267	sh->unique_id = ioc->id;
1268
1269	/* Verify that we won't exceed the maximum
1270	 * number of chain buffers
1271	 * We can optimize:  ZZ = req_sz/sizeof(SGE)
1272	 * For 32bit SGE's:
1273	 *  numSGE = 1 + (ZZ-1)*(maxChain -1) + ZZ
1274	 *               + (req_sz - 64)/sizeof(SGE)
1275	 * A slightly different algorithm is required for
1276	 * 64bit SGEs.
1277	 */
1278	scale = ioc->req_sz/ioc->SGE_size;
1279	if (ioc->sg_addr_size == sizeof(u64)) {
1280		numSGE = (scale - 1) *
1281		  (ioc->facts.MaxChainDepth-1) + scale +
1282		  (ioc->req_sz - 60) / ioc->SGE_size;
1283	} else {
1284		numSGE = 1 + (scale - 1) *
1285		  (ioc->facts.MaxChainDepth-1) + scale +
1286		  (ioc->req_sz - 64) / ioc->SGE_size;
1287	}
1288
1289	if (numSGE < sh->sg_tablesize) {
1290		/* Reset this value */
1291		dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1292		  "Resetting sg_tablesize to %d from %d\n",
1293		  ioc->name, numSGE, sh->sg_tablesize));
1294		sh->sg_tablesize = numSGE;
1295	}
1296
1297	spin_unlock_irqrestore(&ioc->FreeQlock, flags);
1298
1299	hd = shost_priv(sh);
1300	hd->ioc = ioc;
1301
1302	/* SCSI needs scsi_cmnd lookup table!
1303	 * (with size equal to req_depth*PtrSz!)
1304	 */
1305	ioc->ScsiLookup = kcalloc(ioc->req_depth, sizeof(void *), GFP_ATOMIC);
1306	if (!ioc->ScsiLookup) {
1307		error = -ENOMEM;
1308		goto out_mptfc_probe;
1309	}
1310	spin_lock_init(&ioc->scsi_lookup_lock);
1311
1312	dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ScsiLookup @ %p\n",
1313		 ioc->name, ioc->ScsiLookup));
1314
1315	hd->last_queue_full = 0;
1316
1317	sh->transportt = mptfc_transport_template;
1318	error = scsi_add_host (sh, &ioc->pcidev->dev);
1319	if(error) {
1320		dprintk(ioc, printk(MYIOC_s_ERR_FMT
1321		  "scsi_add_host failed\n", ioc->name));
1322		goto out_mptfc_probe;
1323	}
1324
1325	/* initialize workqueue */
1326
1327	snprintf(ioc->fc_rescan_work_q_name, sizeof(ioc->fc_rescan_work_q_name),
1328		 "mptfc_wq_%d", sh->host_no);
1329	ioc->fc_rescan_work_q =
1330		create_singlethread_workqueue(ioc->fc_rescan_work_q_name);
1331	if (!ioc->fc_rescan_work_q)
1332		goto out_mptfc_probe;
1333
1334	/*
1335	 *  Pre-fetch FC port WWN and stuff...
1336	 *  (FCPortPage0_t stuff)
1337	 */
1338	for (ii=0; ii < ioc->facts.NumberOfPorts; ii++) {
1339		(void) mptfc_GetFcPortPage0(ioc, ii);
1340	}
1341	mptfc_SetFcPortPage1_defaults(ioc);
1342
1343	/*
1344	 * scan for rports -
1345	 *	by doing it via the workqueue, some locking is eliminated
1346	 */
1347
1348	queue_work(ioc->fc_rescan_work_q, &ioc->fc_rescan_work);
1349	flush_workqueue(ioc->fc_rescan_work_q);
1350
1351	return 0;
1352
1353out_mptfc_probe:
1354
1355	mptscsih_remove(pdev);
1356	return error;
1357}
1358
1359static struct pci_driver mptfc_driver = {
1360	.name		= "mptfc",
1361	.id_table	= mptfc_pci_table,
1362	.probe		= mptfc_probe,
1363	.remove		= __devexit_p(mptfc_remove),
1364	.shutdown	= mptscsih_shutdown,
1365#ifdef CONFIG_PM
1366	.suspend	= mptscsih_suspend,
1367	.resume		= mptscsih_resume,
1368#endif
1369};
1370
1371static int
1372mptfc_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply)
1373{
1374	MPT_SCSI_HOST *hd;
1375	u8 event = le32_to_cpu(pEvReply->Event) & 0xFF;
1376	unsigned long flags;
1377	int rc=1;
1378
1379	if (ioc->bus_type != FC)
1380		return 0;
1381
1382	devtverboseprintk(ioc, printk(MYIOC_s_DEBUG_FMT "MPT event (=%02Xh) routed to SCSI host driver!\n",
1383			ioc->name, event));
1384
1385	if (ioc->sh == NULL ||
1386		((hd = shost_priv(ioc->sh)) == NULL))
1387		return 1;
1388
1389	switch (event) {
1390	case MPI_EVENT_RESCAN:
1391		spin_lock_irqsave(&ioc->fc_rescan_work_lock, flags);
1392		if (ioc->fc_rescan_work_q) {
1393			queue_work(ioc->fc_rescan_work_q,
1394				   &ioc->fc_rescan_work);
1395		}
1396		spin_unlock_irqrestore(&ioc->fc_rescan_work_lock, flags);
1397		break;
1398	case MPI_EVENT_LINK_STATUS_CHANGE:
1399		spin_lock_irqsave(&ioc->fc_rescan_work_lock, flags);
1400		if (ioc->fc_rescan_work_q) {
1401			queue_work(ioc->fc_rescan_work_q,
1402				   &ioc->fc_lsc_work);
1403		}
1404		spin_unlock_irqrestore(&ioc->fc_rescan_work_lock, flags);
1405		break;
1406	default:
1407		rc = mptscsih_event_process(ioc,pEvReply);
1408		break;
1409	}
1410	return rc;
1411}
1412
1413static int
1414mptfc_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
1415{
1416	int		rc;
1417	unsigned long	flags;
1418
1419	rc = mptscsih_ioc_reset(ioc,reset_phase);
1420	if ((ioc->bus_type != FC) || (!rc))
1421		return rc;
1422
1423
1424	dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1425		": IOC %s_reset routed to FC host driver!\n",ioc->name,
1426		reset_phase==MPT_IOC_SETUP_RESET ? "setup" : (
1427		reset_phase==MPT_IOC_PRE_RESET ? "pre" : "post")));
1428
1429	if (reset_phase == MPT_IOC_SETUP_RESET) {
1430		spin_lock_irqsave(&ioc->fc_rescan_work_lock, flags);
1431		if (ioc->fc_rescan_work_q) {
1432			queue_work(ioc->fc_rescan_work_q,
1433				   &ioc->fc_setup_reset_work);
1434		}
1435		spin_unlock_irqrestore(&ioc->fc_rescan_work_lock, flags);
1436	}
1437
1438	else if (reset_phase == MPT_IOC_PRE_RESET) {
1439	}
1440
1441	else {	/* MPT_IOC_POST_RESET */
1442		mptfc_SetFcPortPage1_defaults(ioc);
1443		spin_lock_irqsave(&ioc->fc_rescan_work_lock, flags);
1444		if (ioc->fc_rescan_work_q) {
1445			queue_work(ioc->fc_rescan_work_q,
1446				   &ioc->fc_rescan_work);
1447		}
1448		spin_unlock_irqrestore(&ioc->fc_rescan_work_lock, flags);
1449	}
1450	return 1;
1451}
1452
1453/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1454/**
1455 *	mptfc_init - Register MPT adapter(s) as SCSI host(s) with SCSI mid-layer.
1456 *
1457 *	Returns 0 for success, non-zero for failure.
1458 */
1459static int __init
1460mptfc_init(void)
1461{
1462	int error;
1463
1464	show_mptmod_ver(my_NAME, my_VERSION);
1465
1466	/* sanity check module parameters */
1467	if (mptfc_dev_loss_tmo <= 0)
1468		mptfc_dev_loss_tmo = MPTFC_DEV_LOSS_TMO;
1469
1470	mptfc_transport_template =
1471		fc_attach_transport(&mptfc_transport_functions);
1472
1473	if (!mptfc_transport_template)
1474		return -ENODEV;
1475
1476	mptfcDoneCtx = mpt_register(mptscsih_io_done, MPTFC_DRIVER,
1477	    "mptscsih_scandv_complete");
1478	mptfcTaskCtx = mpt_register(mptscsih_taskmgmt_complete, MPTFC_DRIVER,
1479	    "mptscsih_scandv_complete");
1480	mptfcInternalCtx = mpt_register(mptscsih_scandv_complete, MPTFC_DRIVER,
1481	    "mptscsih_scandv_complete");
1482
1483	mpt_event_register(mptfcDoneCtx, mptfc_event_process);
1484	mpt_reset_register(mptfcDoneCtx, mptfc_ioc_reset);
1485
1486	error = pci_register_driver(&mptfc_driver);
1487	if (error)
1488		fc_release_transport(mptfc_transport_template);
1489
1490	return error;
1491}
1492
1493/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1494/**
1495 *	mptfc_remove - Remove fc infrastructure for devices
1496 *	@pdev: Pointer to pci_dev structure
1497 *
1498 */
1499static void __devexit
1500mptfc_remove(struct pci_dev *pdev)
1501{
1502	MPT_ADAPTER		*ioc = pci_get_drvdata(pdev);
1503	struct mptfc_rport_info	*p, *n;
1504	struct workqueue_struct *work_q;
1505	unsigned long		flags;
1506	int			ii;
1507
1508	/* destroy workqueue */
1509	if ((work_q=ioc->fc_rescan_work_q)) {
1510		spin_lock_irqsave(&ioc->fc_rescan_work_lock, flags);
1511		ioc->fc_rescan_work_q = NULL;
1512		spin_unlock_irqrestore(&ioc->fc_rescan_work_lock, flags);
1513		destroy_workqueue(work_q);
1514	}
1515
1516	fc_remove_host(ioc->sh);
1517
1518	list_for_each_entry_safe(p, n, &ioc->fc_rports, list) {
1519		list_del(&p->list);
1520		kfree(p);
1521	}
1522
1523	for (ii=0; ii<ioc->facts.NumberOfPorts; ii++) {
1524		if (ioc->fc_data.fc_port_page1[ii].data) {
1525			pci_free_consistent(ioc->pcidev,
1526				ioc->fc_data.fc_port_page1[ii].pg_sz,
1527				(u8 *) ioc->fc_data.fc_port_page1[ii].data,
1528				ioc->fc_data.fc_port_page1[ii].dma);
1529			ioc->fc_data.fc_port_page1[ii].data = NULL;
1530		}
1531	}
1532
1533	mptscsih_remove(pdev);
1534}
1535
1536/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1537/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1538/**
1539 *	mptfc_exit - Unregisters MPT adapter(s)
1540 *
1541 */
1542static void __exit
1543mptfc_exit(void)
1544{
1545	pci_unregister_driver(&mptfc_driver);
1546	fc_release_transport(mptfc_transport_template);
1547
1548	mpt_reset_deregister(mptfcDoneCtx);
1549	mpt_event_deregister(mptfcDoneCtx);
1550
1551	mpt_deregister(mptfcInternalCtx);
1552	mpt_deregister(mptfcTaskCtx);
1553	mpt_deregister(mptfcDoneCtx);
1554}
1555
1556module_init(mptfc_init);
1557module_exit(mptfc_exit);