xref: /openbmc/linux/drivers/message/fusion/mptfc.c (revision d2999e1b)
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 
74 MODULE_AUTHOR(MODULEAUTHOR);
75 MODULE_DESCRIPTION(my_NAME);
76 MODULE_LICENSE("GPL");
77 MODULE_VERSION(my_VERSION);
78 
79 /* Command line args */
80 #define MPTFC_DEV_LOSS_TMO (60)
81 static int mptfc_dev_loss_tmo = MPTFC_DEV_LOSS_TMO;	/* reasonable default */
82 module_param(mptfc_dev_loss_tmo, int, 0);
83 MODULE_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)
90 static int max_lun = MPTFC_MAX_LUN;
91 module_param(max_lun, int, 0);
92 MODULE_PARM_DESC(max_lun, " max lun, default=16895 ");
93 
94 static u8	mptfcDoneCtx = MPT_MAX_PROTOCOL_DRIVERS;
95 static u8	mptfcTaskCtx = MPT_MAX_PROTOCOL_DRIVERS;
96 static u8	mptfcInternalCtx = MPT_MAX_PROTOCOL_DRIVERS;
97 
98 static int mptfc_target_alloc(struct scsi_target *starget);
99 static int mptfc_slave_alloc(struct scsi_device *sdev);
100 static int mptfc_qcmd(struct Scsi_Host *shost, struct scsi_cmnd *SCpnt);
101 static void mptfc_target_destroy(struct scsi_target *starget);
102 static void mptfc_set_rport_loss_tmo(struct fc_rport *rport, uint32_t timeout);
103 static void mptfc_remove(struct pci_dev *pdev);
104 static int mptfc_abort(struct scsi_cmnd *SCpnt);
105 static int mptfc_dev_reset(struct scsi_cmnd *SCpnt);
106 static int mptfc_bus_reset(struct scsi_cmnd *SCpnt);
107 static int mptfc_host_reset(struct scsi_cmnd *SCpnt);
108 
109 static struct scsi_host_template mptfc_driver_template = {
110 	.module				= THIS_MODULE,
111 	.proc_name			= "mptfc",
112 	.show_info			= mptscsih_show_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 
140 static 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 };
161 MODULE_DEVICE_TABLE(pci, mptfc_pci_table);
162 
163 static struct scsi_transport_template *mptfc_transport_template = NULL;
164 
165 static 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 
186 static int
187 mptfc_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 
235 static int
236 mptfc_abort(struct scsi_cmnd *SCpnt)
237 {
238 	return
239 	    mptfc_block_error_handler(SCpnt, mptscsih_abort, __func__);
240 }
241 
242 static int
243 mptfc_dev_reset(struct scsi_cmnd *SCpnt)
244 {
245 	return
246 	    mptfc_block_error_handler(SCpnt, mptscsih_dev_reset, __func__);
247 }
248 
249 static int
250 mptfc_bus_reset(struct scsi_cmnd *SCpnt)
251 {
252 	return
253 	    mptfc_block_error_handler(SCpnt, mptscsih_bus_reset, __func__);
254 }
255 
256 static int
257 mptfc_host_reset(struct scsi_cmnd *SCpnt)
258 {
259 	return
260 	    mptfc_block_error_handler(SCpnt, mptscsih_host_reset, __func__);
261 }
262 
263 static void
264 mptfc_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 
272 static int
273 mptfc_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 
290 static int
291 mptfc_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 
403 static int
404 mptfc_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 
429 static void
430 mptfc_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  */
516 static void
517 mptfc_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  */
538 static int
539 mptfc_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  */
576 static void
577 mptfc_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  */
605 static int
606 mptfc_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 
651 static int
652 mptfc_qcmd(struct Scsi_Host *shost, struct scsi_cmnd *SCpnt)
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 		SCpnt->scsi_done(SCpnt);
662 		return 0;
663 	}
664 
665 	err = fc_remote_port_chkready(rport);
666 	if (unlikely(err)) {
667 		SCpnt->result = err;
668 		SCpnt->scsi_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 		SCpnt->scsi_done(SCpnt);
677 		return 0;
678 	}
679 
680 	return mptscsih_qcmd(SCpnt);
681 }
682 
683 /*
684  *	mptfc_display_port_link_speed - displaying link speed
685  *	@ioc: Pointer to MPT_ADAPTER structure
686  *	@portnum: IOC Port number
687  *	@pp0dest: port page0 data payload
688  *
689  */
690 static void
691 mptfc_display_port_link_speed(MPT_ADAPTER *ioc, int portnum, FCPortPage0_t *pp0dest)
692 {
693 	u8	old_speed, new_speed, state;
694 	char	*old, *new;
695 
696 	if (portnum >= 2)
697 		return;
698 
699 	old_speed = ioc->fc_link_speed[portnum];
700 	new_speed = pp0dest->CurrentSpeed;
701 	state = pp0dest->PortState;
702 
703 	if (state != MPI_FCPORTPAGE0_PORTSTATE_OFFLINE &&
704 	    new_speed != MPI_FCPORTPAGE0_CURRENT_SPEED_UKNOWN) {
705 
706 		old = old_speed == MPI_FCPORTPAGE0_CURRENT_SPEED_1GBIT ? "1 Gbps" :
707 		       old_speed == MPI_FCPORTPAGE0_CURRENT_SPEED_2GBIT ? "2 Gbps" :
708 			old_speed == MPI_FCPORTPAGE0_CURRENT_SPEED_4GBIT ? "4 Gbps" :
709 			 "Unknown";
710 		new = new_speed == MPI_FCPORTPAGE0_CURRENT_SPEED_1GBIT ? "1 Gbps" :
711 		       new_speed == MPI_FCPORTPAGE0_CURRENT_SPEED_2GBIT ? "2 Gbps" :
712 			new_speed == MPI_FCPORTPAGE0_CURRENT_SPEED_4GBIT ? "4 Gbps" :
713 			 "Unknown";
714 		if (old_speed == 0)
715 			printk(MYIOC_s_NOTE_FMT
716 				"FC Link Established, Speed = %s\n",
717 				ioc->name, new);
718 		else if (old_speed != new_speed)
719 			printk(MYIOC_s_WARN_FMT
720 				"FC Link Speed Change, Old Speed = %s, New Speed = %s\n",
721 				ioc->name, old, new);
722 
723 		ioc->fc_link_speed[portnum] = new_speed;
724 	}
725 }
726 
727 /*
728  *	mptfc_GetFcPortPage0 - Fetch FCPort config Page0.
729  *	@ioc: Pointer to MPT_ADAPTER structure
730  *	@portnum: IOC Port number
731  *
732  *	Return: 0 for success
733  *	-ENOMEM if no memory available
734  *		-EPERM if not allowed due to ISR context
735  *		-EAGAIN if no msg frames currently available
736  *		-EFAULT for non-successful reply or no reply (timeout)
737  *		-EINVAL portnum arg out of range (hardwired to two elements)
738  */
739 static int
740 mptfc_GetFcPortPage0(MPT_ADAPTER *ioc, int portnum)
741 {
742 	ConfigPageHeader_t	 hdr;
743 	CONFIGPARMS		 cfg;
744 	FCPortPage0_t		*ppage0_alloc;
745 	FCPortPage0_t		*pp0dest;
746 	dma_addr_t		 page0_dma;
747 	int			 data_sz;
748 	int			 copy_sz;
749 	int			 rc;
750 	int			 count = 400;
751 
752 	if (portnum > 1)
753 		return -EINVAL;
754 
755 	/* Get FCPort Page 0 header */
756 	hdr.PageVersion = 0;
757 	hdr.PageLength = 0;
758 	hdr.PageNumber = 0;
759 	hdr.PageType = MPI_CONFIG_PAGETYPE_FC_PORT;
760 	cfg.cfghdr.hdr = &hdr;
761 	cfg.physAddr = -1;
762 	cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
763 	cfg.dir = 0;
764 	cfg.pageAddr = portnum;
765 	cfg.timeout = 0;
766 
767 	if ((rc = mpt_config(ioc, &cfg)) != 0)
768 		return rc;
769 
770 	if (hdr.PageLength == 0)
771 		return 0;
772 
773 	data_sz = hdr.PageLength * 4;
774 	rc = -ENOMEM;
775 	ppage0_alloc = (FCPortPage0_t *) pci_alloc_consistent(ioc->pcidev, data_sz, &page0_dma);
776 	if (ppage0_alloc) {
777 
778  try_again:
779 		memset((u8 *)ppage0_alloc, 0, data_sz);
780 		cfg.physAddr = page0_dma;
781 		cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
782 
783 		if ((rc = mpt_config(ioc, &cfg)) == 0) {
784 			/* save the data */
785 			pp0dest = &ioc->fc_port_page0[portnum];
786 			copy_sz = min_t(int, sizeof(FCPortPage0_t), data_sz);
787 			memcpy(pp0dest, ppage0_alloc, copy_sz);
788 
789 			/*
790 			 *	Normalize endianness of structure data,
791 			 *	by byte-swapping all > 1 byte fields!
792 			 */
793 			pp0dest->Flags = le32_to_cpu(pp0dest->Flags);
794 			pp0dest->PortIdentifier = le32_to_cpu(pp0dest->PortIdentifier);
795 			pp0dest->WWNN.Low = le32_to_cpu(pp0dest->WWNN.Low);
796 			pp0dest->WWNN.High = le32_to_cpu(pp0dest->WWNN.High);
797 			pp0dest->WWPN.Low = le32_to_cpu(pp0dest->WWPN.Low);
798 			pp0dest->WWPN.High = le32_to_cpu(pp0dest->WWPN.High);
799 			pp0dest->SupportedServiceClass = le32_to_cpu(pp0dest->SupportedServiceClass);
800 			pp0dest->SupportedSpeeds = le32_to_cpu(pp0dest->SupportedSpeeds);
801 			pp0dest->CurrentSpeed = le32_to_cpu(pp0dest->CurrentSpeed);
802 			pp0dest->MaxFrameSize = le32_to_cpu(pp0dest->MaxFrameSize);
803 			pp0dest->FabricWWNN.Low = le32_to_cpu(pp0dest->FabricWWNN.Low);
804 			pp0dest->FabricWWNN.High = le32_to_cpu(pp0dest->FabricWWNN.High);
805 			pp0dest->FabricWWPN.Low = le32_to_cpu(pp0dest->FabricWWPN.Low);
806 			pp0dest->FabricWWPN.High = le32_to_cpu(pp0dest->FabricWWPN.High);
807 			pp0dest->DiscoveredPortsCount = le32_to_cpu(pp0dest->DiscoveredPortsCount);
808 			pp0dest->MaxInitiators = le32_to_cpu(pp0dest->MaxInitiators);
809 
810 			/*
811 			 * if still doing discovery,
812 			 * hang loose a while until finished
813 			 */
814 			if ((pp0dest->PortState == MPI_FCPORTPAGE0_PORTSTATE_UNKNOWN) ||
815 			    (pp0dest->PortState == MPI_FCPORTPAGE0_PORTSTATE_ONLINE &&
816 			     (pp0dest->Flags & MPI_FCPORTPAGE0_FLAGS_ATTACH_TYPE_MASK)
817 			      == MPI_FCPORTPAGE0_FLAGS_ATTACH_NO_INIT)) {
818 				if (count-- > 0) {
819 					msleep(100);
820 					goto try_again;
821 				}
822 				printk(MYIOC_s_INFO_FMT "Firmware discovery not"
823 							" complete.\n",
824 						ioc->name);
825 			}
826 			mptfc_display_port_link_speed(ioc, portnum, pp0dest);
827 		}
828 
829 		pci_free_consistent(ioc->pcidev, data_sz, (u8 *) ppage0_alloc, page0_dma);
830 	}
831 
832 	return rc;
833 }
834 
835 static int
836 mptfc_WriteFcPortPage1(MPT_ADAPTER *ioc, int portnum)
837 {
838 	ConfigPageHeader_t	 hdr;
839 	CONFIGPARMS		 cfg;
840 	int			 rc;
841 
842 	if (portnum > 1)
843 		return -EINVAL;
844 
845 	if (!(ioc->fc_data.fc_port_page1[portnum].data))
846 		return -EINVAL;
847 
848 	/* get fcport page 1 header */
849 	hdr.PageVersion = 0;
850 	hdr.PageLength = 0;
851 	hdr.PageNumber = 1;
852 	hdr.PageType = MPI_CONFIG_PAGETYPE_FC_PORT;
853 	cfg.cfghdr.hdr = &hdr;
854 	cfg.physAddr = -1;
855 	cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
856 	cfg.dir = 0;
857 	cfg.pageAddr = portnum;
858 	cfg.timeout = 0;
859 
860 	if ((rc = mpt_config(ioc, &cfg)) != 0)
861 		return rc;
862 
863 	if (hdr.PageLength == 0)
864 		return -ENODEV;
865 
866 	if (hdr.PageLength*4 != ioc->fc_data.fc_port_page1[portnum].pg_sz)
867 		return -EINVAL;
868 
869 	cfg.physAddr = ioc->fc_data.fc_port_page1[portnum].dma;
870 	cfg.action = MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT;
871 	cfg.dir = 1;
872 
873 	rc = mpt_config(ioc, &cfg);
874 
875 	return rc;
876 }
877 
878 static int
879 mptfc_GetFcPortPage1(MPT_ADAPTER *ioc, int portnum)
880 {
881 	ConfigPageHeader_t	 hdr;
882 	CONFIGPARMS		 cfg;
883 	FCPortPage1_t		*page1_alloc;
884 	dma_addr_t		 page1_dma;
885 	int			 data_sz;
886 	int			 rc;
887 
888 	if (portnum > 1)
889 		return -EINVAL;
890 
891 	/* get fcport page 1 header */
892 	hdr.PageVersion = 0;
893 	hdr.PageLength = 0;
894 	hdr.PageNumber = 1;
895 	hdr.PageType = MPI_CONFIG_PAGETYPE_FC_PORT;
896 	cfg.cfghdr.hdr = &hdr;
897 	cfg.physAddr = -1;
898 	cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER;
899 	cfg.dir = 0;
900 	cfg.pageAddr = portnum;
901 	cfg.timeout = 0;
902 
903 	if ((rc = mpt_config(ioc, &cfg)) != 0)
904 		return rc;
905 
906 	if (hdr.PageLength == 0)
907 		return -ENODEV;
908 
909 start_over:
910 
911 	if (ioc->fc_data.fc_port_page1[portnum].data == NULL) {
912 		data_sz = hdr.PageLength * 4;
913 		if (data_sz < sizeof(FCPortPage1_t))
914 			data_sz = sizeof(FCPortPage1_t);
915 
916 		page1_alloc = (FCPortPage1_t *) pci_alloc_consistent(ioc->pcidev,
917 						data_sz,
918 						&page1_dma);
919 		if (!page1_alloc)
920 			return -ENOMEM;
921 	}
922 	else {
923 		page1_alloc = ioc->fc_data.fc_port_page1[portnum].data;
924 		page1_dma = ioc->fc_data.fc_port_page1[portnum].dma;
925 		data_sz = ioc->fc_data.fc_port_page1[portnum].pg_sz;
926 		if (hdr.PageLength * 4 > data_sz) {
927 			ioc->fc_data.fc_port_page1[portnum].data = NULL;
928 			pci_free_consistent(ioc->pcidev, data_sz, (u8 *)
929 				page1_alloc, page1_dma);
930 			goto start_over;
931 		}
932 	}
933 
934 	memset(page1_alloc,0,data_sz);
935 
936 	cfg.physAddr = page1_dma;
937 	cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT;
938 
939 	if ((rc = mpt_config(ioc, &cfg)) == 0) {
940 		ioc->fc_data.fc_port_page1[portnum].data = page1_alloc;
941 		ioc->fc_data.fc_port_page1[portnum].pg_sz = data_sz;
942 		ioc->fc_data.fc_port_page1[portnum].dma = page1_dma;
943 	}
944 	else {
945 		ioc->fc_data.fc_port_page1[portnum].data = NULL;
946 		pci_free_consistent(ioc->pcidev, data_sz, (u8 *)
947 			page1_alloc, page1_dma);
948 	}
949 
950 	return rc;
951 }
952 
953 static void
954 mptfc_SetFcPortPage1_defaults(MPT_ADAPTER *ioc)
955 {
956 	int		ii;
957 	FCPortPage1_t	*pp1;
958 
959 	#define MPTFC_FW_DEVICE_TIMEOUT	(1)
960 	#define MPTFC_FW_IO_PEND_TIMEOUT (1)
961 	#define ON_FLAGS  (MPI_FCPORTPAGE1_FLAGS_IMMEDIATE_ERROR_REPLY)
962 	#define OFF_FLAGS (MPI_FCPORTPAGE1_FLAGS_VERBOSE_RESCAN_EVENTS)
963 
964 	for (ii=0; ii<ioc->facts.NumberOfPorts; ii++) {
965 		if (mptfc_GetFcPortPage1(ioc, ii) != 0)
966 			continue;
967 		pp1 = ioc->fc_data.fc_port_page1[ii].data;
968 		if ((pp1->InitiatorDeviceTimeout == MPTFC_FW_DEVICE_TIMEOUT)
969 		 && (pp1->InitiatorIoPendTimeout == MPTFC_FW_IO_PEND_TIMEOUT)
970 		 && ((pp1->Flags & ON_FLAGS) == ON_FLAGS)
971 		 && ((pp1->Flags & OFF_FLAGS) == 0))
972 			continue;
973 		pp1->InitiatorDeviceTimeout = MPTFC_FW_DEVICE_TIMEOUT;
974 		pp1->InitiatorIoPendTimeout = MPTFC_FW_IO_PEND_TIMEOUT;
975 		pp1->Flags &= ~OFF_FLAGS;
976 		pp1->Flags |= ON_FLAGS;
977 		mptfc_WriteFcPortPage1(ioc, ii);
978 	}
979 }
980 
981 
982 static void
983 mptfc_init_host_attr(MPT_ADAPTER *ioc,int portnum)
984 {
985 	unsigned	class = 0;
986 	unsigned	cos = 0;
987 	unsigned	speed;
988 	unsigned	port_type;
989 	unsigned	port_state;
990 	FCPortPage0_t	*pp0;
991 	struct Scsi_Host *sh;
992 	char		*sn;
993 
994 	/* don't know what to do as only one scsi (fc) host was allocated */
995 	if (portnum != 0)
996 		return;
997 
998 	pp0 = &ioc->fc_port_page0[portnum];
999 	sh = ioc->sh;
1000 
1001 	sn = fc_host_symbolic_name(sh);
1002 	snprintf(sn, FC_SYMBOLIC_NAME_SIZE, "%s %s%08xh",
1003 	    ioc->prod_name,
1004 	    MPT_FW_REV_MAGIC_ID_STRING,
1005 	    ioc->facts.FWVersion.Word);
1006 
1007 	fc_host_tgtid_bind_type(sh) = FC_TGTID_BIND_BY_WWPN;
1008 
1009 	fc_host_maxframe_size(sh) = pp0->MaxFrameSize;
1010 
1011 	fc_host_node_name(sh) =
1012 	    	(u64)pp0->WWNN.High << 32 | (u64)pp0->WWNN.Low;
1013 
1014 	fc_host_port_name(sh) =
1015 	    	(u64)pp0->WWPN.High << 32 | (u64)pp0->WWPN.Low;
1016 
1017 	fc_host_port_id(sh) = pp0->PortIdentifier;
1018 
1019 	class = pp0->SupportedServiceClass;
1020 	if (class & MPI_FCPORTPAGE0_SUPPORT_CLASS_1)
1021 		cos |= FC_COS_CLASS1;
1022 	if (class & MPI_FCPORTPAGE0_SUPPORT_CLASS_2)
1023 		cos |= FC_COS_CLASS2;
1024 	if (class & MPI_FCPORTPAGE0_SUPPORT_CLASS_3)
1025 		cos |= FC_COS_CLASS3;
1026 	fc_host_supported_classes(sh) = cos;
1027 
1028 	if (pp0->CurrentSpeed == MPI_FCPORTPAGE0_CURRENT_SPEED_1GBIT)
1029 		speed = FC_PORTSPEED_1GBIT;
1030 	else if (pp0->CurrentSpeed == MPI_FCPORTPAGE0_CURRENT_SPEED_2GBIT)
1031 		speed = FC_PORTSPEED_2GBIT;
1032 	else if (pp0->CurrentSpeed == MPI_FCPORTPAGE0_CURRENT_SPEED_4GBIT)
1033 		speed = FC_PORTSPEED_4GBIT;
1034 	else if (pp0->CurrentSpeed == MPI_FCPORTPAGE0_CURRENT_SPEED_10GBIT)
1035 		speed = FC_PORTSPEED_10GBIT;
1036 	else
1037 		speed = FC_PORTSPEED_UNKNOWN;
1038 	fc_host_speed(sh) = speed;
1039 
1040 	speed = 0;
1041 	if (pp0->SupportedSpeeds & MPI_FCPORTPAGE0_SUPPORT_1GBIT_SPEED)
1042 		speed |= FC_PORTSPEED_1GBIT;
1043 	if (pp0->SupportedSpeeds & MPI_FCPORTPAGE0_SUPPORT_2GBIT_SPEED)
1044 		speed |= FC_PORTSPEED_2GBIT;
1045 	if (pp0->SupportedSpeeds & MPI_FCPORTPAGE0_SUPPORT_4GBIT_SPEED)
1046 		speed |= FC_PORTSPEED_4GBIT;
1047 	if (pp0->SupportedSpeeds & MPI_FCPORTPAGE0_SUPPORT_10GBIT_SPEED)
1048 		speed |= FC_PORTSPEED_10GBIT;
1049 	fc_host_supported_speeds(sh) = speed;
1050 
1051 	port_state = FC_PORTSTATE_UNKNOWN;
1052 	if (pp0->PortState == MPI_FCPORTPAGE0_PORTSTATE_ONLINE)
1053 		port_state = FC_PORTSTATE_ONLINE;
1054 	else if (pp0->PortState == MPI_FCPORTPAGE0_PORTSTATE_OFFLINE)
1055 		port_state = FC_PORTSTATE_LINKDOWN;
1056 	fc_host_port_state(sh) = port_state;
1057 
1058 	port_type = FC_PORTTYPE_UNKNOWN;
1059 	if (pp0->Flags & MPI_FCPORTPAGE0_FLAGS_ATTACH_POINT_TO_POINT)
1060 		port_type = FC_PORTTYPE_PTP;
1061 	else if (pp0->Flags & MPI_FCPORTPAGE0_FLAGS_ATTACH_PRIVATE_LOOP)
1062 		port_type = FC_PORTTYPE_LPORT;
1063 	else if (pp0->Flags & MPI_FCPORTPAGE0_FLAGS_ATTACH_PUBLIC_LOOP)
1064 		port_type = FC_PORTTYPE_NLPORT;
1065 	else if (pp0->Flags & MPI_FCPORTPAGE0_FLAGS_ATTACH_FABRIC_DIRECT)
1066 		port_type = FC_PORTTYPE_NPORT;
1067 	fc_host_port_type(sh) = port_type;
1068 
1069 	fc_host_fabric_name(sh) =
1070 	    (pp0->Flags & MPI_FCPORTPAGE0_FLAGS_FABRIC_WWN_VALID) ?
1071 		(u64) pp0->FabricWWNN.High << 32 | (u64) pp0->FabricWWPN.Low :
1072 		(u64)pp0->WWNN.High << 32 | (u64)pp0->WWNN.Low;
1073 
1074 }
1075 
1076 static void
1077 mptfc_link_status_change(struct work_struct *work)
1078 {
1079 	MPT_ADAPTER             *ioc =
1080 		container_of(work, MPT_ADAPTER, fc_rescan_work);
1081 	int ii;
1082 
1083 	for (ii=0; ii < ioc->facts.NumberOfPorts; ii++)
1084 		(void) mptfc_GetFcPortPage0(ioc, ii);
1085 
1086 }
1087 
1088 static void
1089 mptfc_setup_reset(struct work_struct *work)
1090 {
1091 	MPT_ADAPTER		*ioc =
1092 		container_of(work, MPT_ADAPTER, fc_setup_reset_work);
1093 	u64			pn;
1094 	struct mptfc_rport_info *ri;
1095 	struct scsi_target      *starget;
1096 	VirtTarget              *vtarget;
1097 
1098 	/* reset about to happen, delete (block) all rports */
1099 	list_for_each_entry(ri, &ioc->fc_rports, list) {
1100 		if (ri->flags & MPT_RPORT_INFO_FLAGS_REGISTERED) {
1101 			ri->flags &= ~MPT_RPORT_INFO_FLAGS_REGISTERED;
1102 			fc_remote_port_delete(ri->rport);	/* won't sleep */
1103 			ri->rport = NULL;
1104 			starget = ri->starget;
1105 			if (starget) {
1106 				vtarget = starget->hostdata;
1107 				if (vtarget)
1108 					vtarget->deleted = 1;
1109 			}
1110 
1111 			pn = (u64)ri->pg0.WWPN.High << 32 |
1112 			     (u64)ri->pg0.WWPN.Low;
1113 			dfcprintk (ioc, printk(MYIOC_s_DEBUG_FMT
1114 				"mptfc_setup_reset.%d: %llx deleted\n",
1115 				ioc->name,
1116 				ioc->sh->host_no,
1117 				(unsigned long long)pn));
1118 		}
1119 	}
1120 }
1121 
1122 static void
1123 mptfc_rescan_devices(struct work_struct *work)
1124 {
1125 	MPT_ADAPTER		*ioc =
1126 		container_of(work, MPT_ADAPTER, fc_rescan_work);
1127 	int			ii;
1128 	u64			pn;
1129 	struct mptfc_rport_info *ri;
1130 	struct scsi_target      *starget;
1131 	VirtTarget              *vtarget;
1132 
1133 	/* start by tagging all ports as missing */
1134 	list_for_each_entry(ri, &ioc->fc_rports, list) {
1135 		if (ri->flags & MPT_RPORT_INFO_FLAGS_REGISTERED) {
1136 			ri->flags |= MPT_RPORT_INFO_FLAGS_MISSING;
1137 		}
1138 	}
1139 
1140 	/*
1141 	 * now rescan devices known to adapter,
1142 	 * will reregister existing rports
1143 	 */
1144 	for (ii=0; ii < ioc->facts.NumberOfPorts; ii++) {
1145 		(void) mptfc_GetFcPortPage0(ioc, ii);
1146 		mptfc_init_host_attr(ioc, ii);	/* refresh */
1147 		mptfc_GetFcDevPage0(ioc, ii, mptfc_register_dev);
1148 	}
1149 
1150 	/* delete devices still missing */
1151 	list_for_each_entry(ri, &ioc->fc_rports, list) {
1152 		/* if newly missing, delete it */
1153 		if (ri->flags & MPT_RPORT_INFO_FLAGS_MISSING) {
1154 
1155 			ri->flags &= ~(MPT_RPORT_INFO_FLAGS_REGISTERED|
1156 				       MPT_RPORT_INFO_FLAGS_MISSING);
1157 			fc_remote_port_delete(ri->rport);	/* won't sleep */
1158 			ri->rport = NULL;
1159 			starget = ri->starget;
1160 			if (starget) {
1161 				vtarget = starget->hostdata;
1162 				if (vtarget)
1163 					vtarget->deleted = 1;
1164 			}
1165 
1166 			pn = (u64)ri->pg0.WWPN.High << 32 |
1167 			     (u64)ri->pg0.WWPN.Low;
1168 			dfcprintk (ioc, printk(MYIOC_s_DEBUG_FMT
1169 				"mptfc_rescan.%d: %llx deleted\n",
1170 				ioc->name,
1171 				ioc->sh->host_no,
1172 				(unsigned long long)pn));
1173 		}
1174 	}
1175 }
1176 
1177 static int
1178 mptfc_probe(struct pci_dev *pdev, const struct pci_device_id *id)
1179 {
1180 	struct Scsi_Host	*sh;
1181 	MPT_SCSI_HOST		*hd;
1182 	MPT_ADAPTER 		*ioc;
1183 	unsigned long		 flags;
1184 	int			 ii;
1185 	int			 numSGE = 0;
1186 	int			 scale;
1187 	int			 ioc_cap;
1188 	int			error=0;
1189 	int			r;
1190 
1191 	if ((r = mpt_attach(pdev,id)) != 0)
1192 		return r;
1193 
1194 	ioc = pci_get_drvdata(pdev);
1195 	ioc->DoneCtx = mptfcDoneCtx;
1196 	ioc->TaskCtx = mptfcTaskCtx;
1197 	ioc->InternalCtx = mptfcInternalCtx;
1198 
1199 	/*  Added sanity check on readiness of the MPT adapter.
1200 	 */
1201 	if (ioc->last_state != MPI_IOC_STATE_OPERATIONAL) {
1202 		printk(MYIOC_s_WARN_FMT
1203 		  "Skipping because it's not operational!\n",
1204 		  ioc->name);
1205 		error = -ENODEV;
1206 		goto out_mptfc_probe;
1207 	}
1208 
1209 	if (!ioc->active) {
1210 		printk(MYIOC_s_WARN_FMT "Skipping because it's disabled!\n",
1211 		  ioc->name);
1212 		error = -ENODEV;
1213 		goto out_mptfc_probe;
1214 	}
1215 
1216 	/*  Sanity check - ensure at least 1 port is INITIATOR capable
1217 	 */
1218 	ioc_cap = 0;
1219 	for (ii=0; ii < ioc->facts.NumberOfPorts; ii++) {
1220 		if (ioc->pfacts[ii].ProtocolFlags &
1221 		    MPI_PORTFACTS_PROTOCOL_INITIATOR)
1222 			ioc_cap ++;
1223 	}
1224 
1225 	if (!ioc_cap) {
1226 		printk(MYIOC_s_WARN_FMT
1227 			"Skipping ioc=%p because SCSI Initiator mode is NOT enabled!\n",
1228 			ioc->name, ioc);
1229 		return 0;
1230 	}
1231 
1232 	sh = scsi_host_alloc(&mptfc_driver_template, sizeof(MPT_SCSI_HOST));
1233 
1234 	if (!sh) {
1235 		printk(MYIOC_s_WARN_FMT
1236 			"Unable to register controller with SCSI subsystem\n",
1237 			ioc->name);
1238 		error = -1;
1239 		goto out_mptfc_probe;
1240         }
1241 
1242 	spin_lock_init(&ioc->fc_rescan_work_lock);
1243 	INIT_WORK(&ioc->fc_rescan_work, mptfc_rescan_devices);
1244 	INIT_WORK(&ioc->fc_setup_reset_work, mptfc_setup_reset);
1245 	INIT_WORK(&ioc->fc_lsc_work, mptfc_link_status_change);
1246 
1247 	spin_lock_irqsave(&ioc->FreeQlock, flags);
1248 
1249 	/* Attach the SCSI Host to the IOC structure
1250 	 */
1251 	ioc->sh = sh;
1252 
1253 	sh->io_port = 0;
1254 	sh->n_io_port = 0;
1255 	sh->irq = 0;
1256 
1257 	/* set 16 byte cdb's */
1258 	sh->max_cmd_len = 16;
1259 
1260 	sh->max_id = ioc->pfacts->MaxDevices;
1261 	sh->max_lun = max_lun;
1262 
1263 	/* Required entry.
1264 	 */
1265 	sh->unique_id = ioc->id;
1266 
1267 	/* Verify that we won't exceed the maximum
1268 	 * number of chain buffers
1269 	 * We can optimize:  ZZ = req_sz/sizeof(SGE)
1270 	 * For 32bit SGE's:
1271 	 *  numSGE = 1 + (ZZ-1)*(maxChain -1) + ZZ
1272 	 *               + (req_sz - 64)/sizeof(SGE)
1273 	 * A slightly different algorithm is required for
1274 	 * 64bit SGEs.
1275 	 */
1276 	scale = ioc->req_sz/ioc->SGE_size;
1277 	if (ioc->sg_addr_size == sizeof(u64)) {
1278 		numSGE = (scale - 1) *
1279 		  (ioc->facts.MaxChainDepth-1) + scale +
1280 		  (ioc->req_sz - 60) / ioc->SGE_size;
1281 	} else {
1282 		numSGE = 1 + (scale - 1) *
1283 		  (ioc->facts.MaxChainDepth-1) + scale +
1284 		  (ioc->req_sz - 64) / ioc->SGE_size;
1285 	}
1286 
1287 	if (numSGE < sh->sg_tablesize) {
1288 		/* Reset this value */
1289 		dprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1290 		  "Resetting sg_tablesize to %d from %d\n",
1291 		  ioc->name, numSGE, sh->sg_tablesize));
1292 		sh->sg_tablesize = numSGE;
1293 	}
1294 
1295 	spin_unlock_irqrestore(&ioc->FreeQlock, flags);
1296 
1297 	hd = shost_priv(sh);
1298 	hd->ioc = ioc;
1299 
1300 	/* SCSI needs scsi_cmnd lookup table!
1301 	 * (with size equal to req_depth*PtrSz!)
1302 	 */
1303 	ioc->ScsiLookup = kcalloc(ioc->req_depth, sizeof(void *), GFP_ATOMIC);
1304 	if (!ioc->ScsiLookup) {
1305 		error = -ENOMEM;
1306 		goto out_mptfc_probe;
1307 	}
1308 	spin_lock_init(&ioc->scsi_lookup_lock);
1309 
1310 	dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ScsiLookup @ %p\n",
1311 		 ioc->name, ioc->ScsiLookup));
1312 
1313 	hd->last_queue_full = 0;
1314 
1315 	sh->transportt = mptfc_transport_template;
1316 	error = scsi_add_host (sh, &ioc->pcidev->dev);
1317 	if(error) {
1318 		dprintk(ioc, printk(MYIOC_s_ERR_FMT
1319 		  "scsi_add_host failed\n", ioc->name));
1320 		goto out_mptfc_probe;
1321 	}
1322 
1323 	/* initialize workqueue */
1324 
1325 	snprintf(ioc->fc_rescan_work_q_name, sizeof(ioc->fc_rescan_work_q_name),
1326 		 "mptfc_wq_%d", sh->host_no);
1327 	ioc->fc_rescan_work_q =
1328 		create_singlethread_workqueue(ioc->fc_rescan_work_q_name);
1329 	if (!ioc->fc_rescan_work_q)
1330 		goto out_mptfc_probe;
1331 
1332 	/*
1333 	 *  Pre-fetch FC port WWN and stuff...
1334 	 *  (FCPortPage0_t stuff)
1335 	 */
1336 	for (ii=0; ii < ioc->facts.NumberOfPorts; ii++) {
1337 		(void) mptfc_GetFcPortPage0(ioc, ii);
1338 	}
1339 	mptfc_SetFcPortPage1_defaults(ioc);
1340 
1341 	/*
1342 	 * scan for rports -
1343 	 *	by doing it via the workqueue, some locking is eliminated
1344 	 */
1345 
1346 	queue_work(ioc->fc_rescan_work_q, &ioc->fc_rescan_work);
1347 	flush_workqueue(ioc->fc_rescan_work_q);
1348 
1349 	return 0;
1350 
1351 out_mptfc_probe:
1352 
1353 	mptscsih_remove(pdev);
1354 	return error;
1355 }
1356 
1357 static struct pci_driver mptfc_driver = {
1358 	.name		= "mptfc",
1359 	.id_table	= mptfc_pci_table,
1360 	.probe		= mptfc_probe,
1361 	.remove		= mptfc_remove,
1362 	.shutdown	= mptscsih_shutdown,
1363 #ifdef CONFIG_PM
1364 	.suspend	= mptscsih_suspend,
1365 	.resume		= mptscsih_resume,
1366 #endif
1367 };
1368 
1369 static int
1370 mptfc_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *pEvReply)
1371 {
1372 	MPT_SCSI_HOST *hd;
1373 	u8 event = le32_to_cpu(pEvReply->Event) & 0xFF;
1374 	unsigned long flags;
1375 	int rc=1;
1376 
1377 	if (ioc->bus_type != FC)
1378 		return 0;
1379 
1380 	devtverboseprintk(ioc, printk(MYIOC_s_DEBUG_FMT "MPT event (=%02Xh) routed to SCSI host driver!\n",
1381 			ioc->name, event));
1382 
1383 	if (ioc->sh == NULL ||
1384 		((hd = shost_priv(ioc->sh)) == NULL))
1385 		return 1;
1386 
1387 	switch (event) {
1388 	case MPI_EVENT_RESCAN:
1389 		spin_lock_irqsave(&ioc->fc_rescan_work_lock, flags);
1390 		if (ioc->fc_rescan_work_q) {
1391 			queue_work(ioc->fc_rescan_work_q,
1392 				   &ioc->fc_rescan_work);
1393 		}
1394 		spin_unlock_irqrestore(&ioc->fc_rescan_work_lock, flags);
1395 		break;
1396 	case MPI_EVENT_LINK_STATUS_CHANGE:
1397 		spin_lock_irqsave(&ioc->fc_rescan_work_lock, flags);
1398 		if (ioc->fc_rescan_work_q) {
1399 			queue_work(ioc->fc_rescan_work_q,
1400 				   &ioc->fc_lsc_work);
1401 		}
1402 		spin_unlock_irqrestore(&ioc->fc_rescan_work_lock, flags);
1403 		break;
1404 	default:
1405 		rc = mptscsih_event_process(ioc,pEvReply);
1406 		break;
1407 	}
1408 	return rc;
1409 }
1410 
1411 static int
1412 mptfc_ioc_reset(MPT_ADAPTER *ioc, int reset_phase)
1413 {
1414 	int		rc;
1415 	unsigned long	flags;
1416 
1417 	rc = mptscsih_ioc_reset(ioc,reset_phase);
1418 	if ((ioc->bus_type != FC) || (!rc))
1419 		return rc;
1420 
1421 
1422 	dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
1423 		": IOC %s_reset routed to FC host driver!\n",ioc->name,
1424 		reset_phase==MPT_IOC_SETUP_RESET ? "setup" : (
1425 		reset_phase==MPT_IOC_PRE_RESET ? "pre" : "post")));
1426 
1427 	if (reset_phase == MPT_IOC_SETUP_RESET) {
1428 		spin_lock_irqsave(&ioc->fc_rescan_work_lock, flags);
1429 		if (ioc->fc_rescan_work_q) {
1430 			queue_work(ioc->fc_rescan_work_q,
1431 				   &ioc->fc_setup_reset_work);
1432 		}
1433 		spin_unlock_irqrestore(&ioc->fc_rescan_work_lock, flags);
1434 	}
1435 
1436 	else if (reset_phase == MPT_IOC_PRE_RESET) {
1437 	}
1438 
1439 	else {	/* MPT_IOC_POST_RESET */
1440 		mptfc_SetFcPortPage1_defaults(ioc);
1441 		spin_lock_irqsave(&ioc->fc_rescan_work_lock, flags);
1442 		if (ioc->fc_rescan_work_q) {
1443 			queue_work(ioc->fc_rescan_work_q,
1444 				   &ioc->fc_rescan_work);
1445 		}
1446 		spin_unlock_irqrestore(&ioc->fc_rescan_work_lock, flags);
1447 	}
1448 	return 1;
1449 }
1450 
1451 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1452 /**
1453  *	mptfc_init - Register MPT adapter(s) as SCSI host(s) with SCSI mid-layer.
1454  *
1455  *	Returns 0 for success, non-zero for failure.
1456  */
1457 static int __init
1458 mptfc_init(void)
1459 {
1460 	int error;
1461 
1462 	show_mptmod_ver(my_NAME, my_VERSION);
1463 
1464 	/* sanity check module parameters */
1465 	if (mptfc_dev_loss_tmo <= 0)
1466 		mptfc_dev_loss_tmo = MPTFC_DEV_LOSS_TMO;
1467 
1468 	mptfc_transport_template =
1469 		fc_attach_transport(&mptfc_transport_functions);
1470 
1471 	if (!mptfc_transport_template)
1472 		return -ENODEV;
1473 
1474 	mptfcDoneCtx = mpt_register(mptscsih_io_done, MPTFC_DRIVER,
1475 	    "mptscsih_scandv_complete");
1476 	mptfcTaskCtx = mpt_register(mptscsih_taskmgmt_complete, MPTFC_DRIVER,
1477 	    "mptscsih_scandv_complete");
1478 	mptfcInternalCtx = mpt_register(mptscsih_scandv_complete, MPTFC_DRIVER,
1479 	    "mptscsih_scandv_complete");
1480 
1481 	mpt_event_register(mptfcDoneCtx, mptfc_event_process);
1482 	mpt_reset_register(mptfcDoneCtx, mptfc_ioc_reset);
1483 
1484 	error = pci_register_driver(&mptfc_driver);
1485 	if (error)
1486 		fc_release_transport(mptfc_transport_template);
1487 
1488 	return error;
1489 }
1490 
1491 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1492 /**
1493  *	mptfc_remove - Remove fc infrastructure for devices
1494  *	@pdev: Pointer to pci_dev structure
1495  *
1496  */
1497 static void mptfc_remove(struct pci_dev *pdev)
1498 {
1499 	MPT_ADAPTER		*ioc = pci_get_drvdata(pdev);
1500 	struct mptfc_rport_info	*p, *n;
1501 	struct workqueue_struct *work_q;
1502 	unsigned long		flags;
1503 	int			ii;
1504 
1505 	/* destroy workqueue */
1506 	if ((work_q=ioc->fc_rescan_work_q)) {
1507 		spin_lock_irqsave(&ioc->fc_rescan_work_lock, flags);
1508 		ioc->fc_rescan_work_q = NULL;
1509 		spin_unlock_irqrestore(&ioc->fc_rescan_work_lock, flags);
1510 		destroy_workqueue(work_q);
1511 	}
1512 
1513 	fc_remove_host(ioc->sh);
1514 
1515 	list_for_each_entry_safe(p, n, &ioc->fc_rports, list) {
1516 		list_del(&p->list);
1517 		kfree(p);
1518 	}
1519 
1520 	for (ii=0; ii<ioc->facts.NumberOfPorts; ii++) {
1521 		if (ioc->fc_data.fc_port_page1[ii].data) {
1522 			pci_free_consistent(ioc->pcidev,
1523 				ioc->fc_data.fc_port_page1[ii].pg_sz,
1524 				(u8 *) ioc->fc_data.fc_port_page1[ii].data,
1525 				ioc->fc_data.fc_port_page1[ii].dma);
1526 			ioc->fc_data.fc_port_page1[ii].data = NULL;
1527 		}
1528 	}
1529 
1530 	mptscsih_remove(pdev);
1531 }
1532 
1533 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1534 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
1535 /**
1536  *	mptfc_exit - Unregisters MPT adapter(s)
1537  *
1538  */
1539 static void __exit
1540 mptfc_exit(void)
1541 {
1542 	pci_unregister_driver(&mptfc_driver);
1543 	fc_release_transport(mptfc_transport_template);
1544 
1545 	mpt_reset_deregister(mptfcDoneCtx);
1546 	mpt_event_deregister(mptfcDoneCtx);
1547 
1548 	mpt_deregister(mptfcInternalCtx);
1549 	mpt_deregister(mptfcTaskCtx);
1550 	mpt_deregister(mptfcDoneCtx);
1551 }
1552 
1553 module_init(mptfc_init);
1554 module_exit(mptfc_exit);
1555