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