xref: /linux/drivers/scsi/lpfc/lpfc_attr.c (revision a1ff5a7d78a036d6c2178ee5acd6ba4946243800)
1 /*******************************************************************
2  * This file is part of the Emulex Linux Device Driver for         *
3  * Fibre Channel Host Bus Adapters.                                *
4  * Copyright (C) 2017-2024 Broadcom. All Rights Reserved. The term *
5  * “Broadcom” refers to Broadcom Inc. and/or its subsidiaries.  *
6  * Copyright (C) 2004-2016 Emulex.  All rights reserved.           *
7  * EMULEX and SLI are trademarks of Emulex.                        *
8  * www.broadcom.com                                                *
9  * Portions Copyright (C) 2004-2005 Christoph Hellwig              *
10  *                                                                 *
11  * This program is free software; you can redistribute it and/or   *
12  * modify it under the terms of version 2 of the GNU General       *
13  * Public License as published by the Free Software Foundation.    *
14  * This program is distributed in the hope that it will be useful. *
15  * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND          *
16  * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY,  *
17  * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE      *
18  * DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD *
19  * TO BE LEGALLY INVALID.  See the GNU General Public License for  *
20  * more details, a copy of which can be found in the file COPYING  *
21  * included with this package.                                     *
22  *******************************************************************/
23 
24 #include <linux/ctype.h>
25 #include <linux/delay.h>
26 #include <linux/pci.h>
27 #include <linux/interrupt.h>
28 #include <linux/module.h>
29 #include <linux/aer.h>
30 #include <linux/gfp.h>
31 #include <linux/kernel.h>
32 
33 #include <scsi/scsi.h>
34 #include <scsi/scsi_device.h>
35 #include <scsi/scsi_host.h>
36 #include <scsi/scsi_tcq.h>
37 #include <scsi/scsi_transport_fc.h>
38 #include <scsi/fc/fc_fs.h>
39 
40 #include "lpfc_hw4.h"
41 #include "lpfc_hw.h"
42 #include "lpfc_sli.h"
43 #include "lpfc_sli4.h"
44 #include "lpfc_nl.h"
45 #include "lpfc_disc.h"
46 #include "lpfc.h"
47 #include "lpfc_scsi.h"
48 #include "lpfc_nvme.h"
49 #include "lpfc_logmsg.h"
50 #include "lpfc_version.h"
51 #include "lpfc_compat.h"
52 #include "lpfc_crtn.h"
53 #include "lpfc_vport.h"
54 #include "lpfc_attr.h"
55 
56 #define LPFC_DEF_DEVLOSS_TMO	30
57 #define LPFC_MIN_DEVLOSS_TMO	1
58 #define LPFC_MAX_DEVLOSS_TMO	255
59 
60 #define LPFC_MAX_INFO_TMP_LEN	100
61 #define LPFC_INFO_MORE_STR	"\nCould be more info...\n"
62 /*
63  * Write key size should be multiple of 4. If write key is changed
64  * make sure that library write key is also changed.
65  */
66 #define LPFC_REG_WRITE_KEY_SIZE	4
67 #define LPFC_REG_WRITE_KEY	"EMLX"
68 
69 const char *const trunk_errmsg[] = {	/* map errcode */
70 	"",	/* There is no such error code at index 0*/
71 	"link negotiated speed does not match existing"
72 		" trunk - link was \"low\" speed",
73 	"link negotiated speed does not match"
74 		" existing trunk - link was \"middle\" speed",
75 	"link negotiated speed does not match existing"
76 		" trunk - link was \"high\" speed",
77 	"Attached to non-trunking port - F_Port",
78 	"Attached to non-trunking port - N_Port",
79 	"FLOGI response timeout",
80 	"non-FLOGI frame received",
81 	"Invalid FLOGI response",
82 	"Trunking initialization protocol",
83 	"Trunk peer device mismatch",
84 };
85 
86 /**
87  * lpfc_jedec_to_ascii - Hex to ascii convertor according to JEDEC rules
88  * @incr: integer to convert.
89  * @hdw: ascii string holding converted integer plus a string terminator.
90  *
91  * Description:
92  * JEDEC Joint Electron Device Engineering Council.
93  * Convert a 32 bit integer composed of 8 nibbles into an 8 byte ascii
94  * character string. The string is then terminated with a NULL in byte 9.
95  * Hex 0-9 becomes ascii '0' to '9'.
96  * Hex a-f becomes ascii '=' to 'B' capital B.
97  *
98  * Notes:
99  * Coded for 32 bit integers only.
100  **/
101 static void
lpfc_jedec_to_ascii(int incr,char hdw[])102 lpfc_jedec_to_ascii(int incr, char hdw[])
103 {
104 	int i, j;
105 	for (i = 0; i < 8; i++) {
106 		j = (incr & 0xf);
107 		if (j <= 9)
108 			hdw[7 - i] = 0x30 +  j;
109 		 else
110 			hdw[7 - i] = 0x61 + j - 10;
111 		incr = (incr >> 4);
112 	}
113 	hdw[8] = 0;
114 	return;
115 }
116 
117 static ssize_t
lpfc_cmf_info_show(struct device * dev,struct device_attribute * attr,char * buf)118 lpfc_cmf_info_show(struct device *dev, struct device_attribute *attr,
119 		   char *buf)
120 {
121 	struct Scsi_Host  *shost = class_to_shost(dev);
122 	struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
123 	struct lpfc_hba   *phba = vport->phba;
124 	struct lpfc_cgn_info *cp = NULL;
125 	struct lpfc_cgn_stat *cgs;
126 	int  len = 0;
127 	int cpu;
128 	u64 rcv, total;
129 	char tmp[LPFC_MAX_INFO_TMP_LEN] = {0};
130 
131 	if (phba->cgn_i)
132 		cp = (struct lpfc_cgn_info *)phba->cgn_i->virt;
133 
134 	scnprintf(tmp, sizeof(tmp),
135 		  "Congestion Mgmt Info: E2Eattr %d Ver %d "
136 		  "CMF %d cnt %d\n",
137 		  phba->sli4_hba.pc_sli4_params.mi_cap,
138 		  cp ? cp->cgn_info_version : 0,
139 		  phba->sli4_hba.pc_sli4_params.cmf, phba->cmf_timer_cnt);
140 
141 	if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
142 		goto buffer_done;
143 
144 	if (!phba->sli4_hba.pc_sli4_params.cmf)
145 		goto buffer_done;
146 
147 	switch (phba->cgn_init_reg_signal) {
148 	case EDC_CG_SIG_WARN_ONLY:
149 		scnprintf(tmp, sizeof(tmp),
150 			  "Register: Init:  Signal:WARN  ");
151 		break;
152 	case EDC_CG_SIG_WARN_ALARM:
153 		scnprintf(tmp, sizeof(tmp),
154 			  "Register: Init:  Signal:WARN|ALARM  ");
155 		break;
156 	default:
157 		scnprintf(tmp, sizeof(tmp),
158 			  "Register: Init:  Signal:NONE  ");
159 		break;
160 	}
161 	if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
162 		goto buffer_done;
163 
164 	switch (phba->cgn_init_reg_fpin) {
165 	case LPFC_CGN_FPIN_WARN:
166 		scnprintf(tmp, sizeof(tmp),
167 			  "FPIN:WARN\n");
168 		break;
169 	case LPFC_CGN_FPIN_ALARM:
170 		scnprintf(tmp, sizeof(tmp),
171 			  "FPIN:ALARM\n");
172 		break;
173 	case LPFC_CGN_FPIN_BOTH:
174 		scnprintf(tmp, sizeof(tmp),
175 			  "FPIN:WARN|ALARM\n");
176 		break;
177 	default:
178 		scnprintf(tmp, sizeof(tmp),
179 			  "FPIN:NONE\n");
180 		break;
181 	}
182 	if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
183 		goto buffer_done;
184 
185 	switch (phba->cgn_reg_signal) {
186 	case EDC_CG_SIG_WARN_ONLY:
187 		scnprintf(tmp, sizeof(tmp),
188 			  "       Current:  Signal:WARN  ");
189 		break;
190 	case EDC_CG_SIG_WARN_ALARM:
191 		scnprintf(tmp, sizeof(tmp),
192 			  "       Current:  Signal:WARN|ALARM  ");
193 		break;
194 	default:
195 		scnprintf(tmp, sizeof(tmp),
196 			  "       Current:  Signal:NONE  ");
197 		break;
198 	}
199 	if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
200 		goto buffer_done;
201 
202 	switch (phba->cgn_reg_fpin) {
203 	case LPFC_CGN_FPIN_WARN:
204 		scnprintf(tmp, sizeof(tmp),
205 			  "FPIN:WARN  ACQEcnt:%d\n", phba->cgn_acqe_cnt);
206 		break;
207 	case LPFC_CGN_FPIN_ALARM:
208 		scnprintf(tmp, sizeof(tmp),
209 			  "FPIN:ALARM  ACQEcnt:%d\n", phba->cgn_acqe_cnt);
210 		break;
211 	case LPFC_CGN_FPIN_BOTH:
212 		scnprintf(tmp, sizeof(tmp),
213 			  "FPIN:WARN|ALARM  ACQEcnt:%d\n", phba->cgn_acqe_cnt);
214 		break;
215 	default:
216 		scnprintf(tmp, sizeof(tmp),
217 			  "FPIN:NONE  ACQEcnt:%d\n", phba->cgn_acqe_cnt);
218 		break;
219 	}
220 	if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
221 		goto buffer_done;
222 
223 	if (phba->cmf_active_mode != phba->cgn_p.cgn_param_mode) {
224 		switch (phba->cmf_active_mode) {
225 		case LPFC_CFG_OFF:
226 			scnprintf(tmp, sizeof(tmp), "Active: Mode:Off\n");
227 			break;
228 		case LPFC_CFG_MANAGED:
229 			scnprintf(tmp, sizeof(tmp), "Active: Mode:Managed\n");
230 			break;
231 		case LPFC_CFG_MONITOR:
232 			scnprintf(tmp, sizeof(tmp), "Active: Mode:Monitor\n");
233 			break;
234 		default:
235 			scnprintf(tmp, sizeof(tmp), "Active: Mode:Unknown\n");
236 		}
237 		if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
238 			goto buffer_done;
239 	}
240 
241 	switch (phba->cgn_p.cgn_param_mode) {
242 	case LPFC_CFG_OFF:
243 		scnprintf(tmp, sizeof(tmp), "Config: Mode:Off  ");
244 		break;
245 	case LPFC_CFG_MANAGED:
246 		scnprintf(tmp, sizeof(tmp), "Config: Mode:Managed ");
247 		break;
248 	case LPFC_CFG_MONITOR:
249 		scnprintf(tmp, sizeof(tmp), "Config: Mode:Monitor ");
250 		break;
251 	default:
252 		scnprintf(tmp, sizeof(tmp), "Config: Mode:Unknown ");
253 	}
254 	if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
255 		goto buffer_done;
256 
257 	total = 0;
258 	rcv = 0;
259 	for_each_present_cpu(cpu) {
260 		cgs = per_cpu_ptr(phba->cmf_stat, cpu);
261 		total += atomic64_read(&cgs->total_bytes);
262 		rcv += atomic64_read(&cgs->rcv_bytes);
263 	}
264 
265 	scnprintf(tmp, sizeof(tmp),
266 		  "IObusy:%d Info:%d Bytes: Rcv:x%llx Total:x%llx\n",
267 		  atomic_read(&phba->cmf_busy),
268 		  phba->cmf_active_info, rcv, total);
269 	if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
270 		goto buffer_done;
271 
272 	scnprintf(tmp, sizeof(tmp),
273 		  "Port_speed:%d  Link_byte_cnt:%ld  "
274 		  "Max_byte_per_interval:%ld\n",
275 		  lpfc_sli_port_speed_get(phba),
276 		  (unsigned long)phba->cmf_link_byte_count,
277 		  (unsigned long)phba->cmf_max_bytes_per_interval);
278 	strlcat(buf, tmp, PAGE_SIZE);
279 
280 buffer_done:
281 	len = strnlen(buf, PAGE_SIZE);
282 
283 	if (unlikely(len >= (PAGE_SIZE - 1))) {
284 		lpfc_printf_log(phba, KERN_INFO, LOG_CGN_MGMT,
285 				"6312 Catching potential buffer "
286 				"overflow > PAGE_SIZE = %lu bytes\n",
287 				PAGE_SIZE);
288 		strscpy(buf + PAGE_SIZE - 1 - sizeof(LPFC_INFO_MORE_STR),
289 			LPFC_INFO_MORE_STR, sizeof(LPFC_INFO_MORE_STR) + 1);
290 	}
291 	return len;
292 }
293 
294 /**
295  * lpfc_drvr_version_show - Return the Emulex driver string with version number
296  * @dev: class unused variable.
297  * @attr: device attribute, not used.
298  * @buf: on return contains the module description text.
299  *
300  * Returns: size of formatted string.
301  **/
302 static ssize_t
lpfc_drvr_version_show(struct device * dev,struct device_attribute * attr,char * buf)303 lpfc_drvr_version_show(struct device *dev, struct device_attribute *attr,
304 		       char *buf)
305 {
306 	return scnprintf(buf, PAGE_SIZE, LPFC_MODULE_DESC "\n");
307 }
308 
309 /**
310  * lpfc_enable_fip_show - Return the fip mode of the HBA
311  * @dev: class unused variable.
312  * @attr: device attribute, not used.
313  * @buf: on return contains the module description text.
314  *
315  * Returns: size of formatted string.
316  **/
317 static ssize_t
lpfc_enable_fip_show(struct device * dev,struct device_attribute * attr,char * buf)318 lpfc_enable_fip_show(struct device *dev, struct device_attribute *attr,
319 		       char *buf)
320 {
321 	struct Scsi_Host *shost = class_to_shost(dev);
322 	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
323 	struct lpfc_hba   *phba = vport->phba;
324 
325 	if (test_bit(HBA_FIP_SUPPORT, &phba->hba_flag))
326 		return scnprintf(buf, PAGE_SIZE, "1\n");
327 	else
328 		return scnprintf(buf, PAGE_SIZE, "0\n");
329 }
330 
331 static ssize_t
lpfc_nvme_info_show(struct device * dev,struct device_attribute * attr,char * buf)332 lpfc_nvme_info_show(struct device *dev, struct device_attribute *attr,
333 		    char *buf)
334 {
335 	struct Scsi_Host *shost = class_to_shost(dev);
336 	struct lpfc_vport *vport = shost_priv(shost);
337 	struct lpfc_hba   *phba = vport->phba;
338 	struct lpfc_nvmet_tgtport *tgtp;
339 	struct nvme_fc_local_port *localport;
340 	struct lpfc_nvme_lport *lport;
341 	struct lpfc_nvme_rport *rport;
342 	struct lpfc_nodelist *ndlp;
343 	struct nvme_fc_remote_port *nrport;
344 	struct lpfc_fc4_ctrl_stat *cstat;
345 	uint64_t data1, data2, data3;
346 	uint64_t totin, totout, tot;
347 	unsigned long iflags;
348 	char *statep;
349 	int i;
350 	int len = 0;
351 	char tmp[LPFC_MAX_INFO_TMP_LEN] = {0};
352 
353 	if (!(vport->cfg_enable_fc4_type & LPFC_ENABLE_NVME)) {
354 		len = scnprintf(buf, PAGE_SIZE, "NVME Disabled\n");
355 		return len;
356 	}
357 	if (phba->nvmet_support) {
358 		if (!phba->targetport) {
359 			len = scnprintf(buf, PAGE_SIZE,
360 					"NVME Target: x%llx is not allocated\n",
361 					wwn_to_u64(vport->fc_portname.u.wwn));
362 			return len;
363 		}
364 		/* Port state is only one of two values for now. */
365 		if (phba->targetport->port_id)
366 			statep = "REGISTERED";
367 		else
368 			statep = "INIT";
369 		scnprintf(tmp, sizeof(tmp),
370 			  "NVME Target Enabled  State %s\n",
371 			  statep);
372 		if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
373 			goto buffer_done;
374 
375 		scnprintf(tmp, sizeof(tmp),
376 			  "%s%d WWPN x%llx WWNN x%llx DID x%06x\n",
377 			  "NVME Target: lpfc",
378 			  phba->brd_no,
379 			  wwn_to_u64(vport->fc_portname.u.wwn),
380 			  wwn_to_u64(vport->fc_nodename.u.wwn),
381 			  phba->targetport->port_id);
382 		if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
383 			goto buffer_done;
384 
385 		if (strlcat(buf, "\nNVME Target: Statistics\n", PAGE_SIZE)
386 		    >= PAGE_SIZE)
387 			goto buffer_done;
388 
389 		tgtp = (struct lpfc_nvmet_tgtport *)phba->targetport->private;
390 		scnprintf(tmp, sizeof(tmp),
391 			  "LS: Rcv %08x Drop %08x Abort %08x\n",
392 			  atomic_read(&tgtp->rcv_ls_req_in),
393 			  atomic_read(&tgtp->rcv_ls_req_drop),
394 			  atomic_read(&tgtp->xmt_ls_abort));
395 		if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
396 			goto buffer_done;
397 
398 		if (atomic_read(&tgtp->rcv_ls_req_in) !=
399 		    atomic_read(&tgtp->rcv_ls_req_out)) {
400 			scnprintf(tmp, sizeof(tmp),
401 				  "Rcv LS: in %08x != out %08x\n",
402 				  atomic_read(&tgtp->rcv_ls_req_in),
403 				  atomic_read(&tgtp->rcv_ls_req_out));
404 			if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
405 				goto buffer_done;
406 		}
407 
408 		scnprintf(tmp, sizeof(tmp),
409 			  "LS: Xmt %08x Drop %08x Cmpl %08x\n",
410 			  atomic_read(&tgtp->xmt_ls_rsp),
411 			  atomic_read(&tgtp->xmt_ls_drop),
412 			  atomic_read(&tgtp->xmt_ls_rsp_cmpl));
413 		if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
414 			goto buffer_done;
415 
416 		scnprintf(tmp, sizeof(tmp),
417 			  "LS: RSP Abort %08x xb %08x Err %08x\n",
418 			  atomic_read(&tgtp->xmt_ls_rsp_aborted),
419 			  atomic_read(&tgtp->xmt_ls_rsp_xb_set),
420 			  atomic_read(&tgtp->xmt_ls_rsp_error));
421 		if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
422 			goto buffer_done;
423 
424 		scnprintf(tmp, sizeof(tmp),
425 			  "FCP: Rcv %08x Defer %08x Release %08x "
426 			  "Drop %08x\n",
427 			  atomic_read(&tgtp->rcv_fcp_cmd_in),
428 			  atomic_read(&tgtp->rcv_fcp_cmd_defer),
429 			  atomic_read(&tgtp->xmt_fcp_release),
430 			  atomic_read(&tgtp->rcv_fcp_cmd_drop));
431 		if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
432 			goto buffer_done;
433 
434 		if (atomic_read(&tgtp->rcv_fcp_cmd_in) !=
435 		    atomic_read(&tgtp->rcv_fcp_cmd_out)) {
436 			scnprintf(tmp, sizeof(tmp),
437 				  "Rcv FCP: in %08x != out %08x\n",
438 				  atomic_read(&tgtp->rcv_fcp_cmd_in),
439 				  atomic_read(&tgtp->rcv_fcp_cmd_out));
440 			if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
441 				goto buffer_done;
442 		}
443 
444 		scnprintf(tmp, sizeof(tmp),
445 			  "FCP Rsp: RD %08x rsp %08x WR %08x rsp %08x "
446 			  "drop %08x\n",
447 			  atomic_read(&tgtp->xmt_fcp_read),
448 			  atomic_read(&tgtp->xmt_fcp_read_rsp),
449 			  atomic_read(&tgtp->xmt_fcp_write),
450 			  atomic_read(&tgtp->xmt_fcp_rsp),
451 			  atomic_read(&tgtp->xmt_fcp_drop));
452 		if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
453 			goto buffer_done;
454 
455 		scnprintf(tmp, sizeof(tmp),
456 			  "FCP Rsp Cmpl: %08x err %08x drop %08x\n",
457 			  atomic_read(&tgtp->xmt_fcp_rsp_cmpl),
458 			  atomic_read(&tgtp->xmt_fcp_rsp_error),
459 			  atomic_read(&tgtp->xmt_fcp_rsp_drop));
460 		if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
461 			goto buffer_done;
462 
463 		scnprintf(tmp, sizeof(tmp),
464 			  "FCP Rsp Abort: %08x xb %08x xricqe  %08x\n",
465 			  atomic_read(&tgtp->xmt_fcp_rsp_aborted),
466 			  atomic_read(&tgtp->xmt_fcp_rsp_xb_set),
467 			  atomic_read(&tgtp->xmt_fcp_xri_abort_cqe));
468 		if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
469 			goto buffer_done;
470 
471 		scnprintf(tmp, sizeof(tmp),
472 			  "ABORT: Xmt %08x Cmpl %08x\n",
473 			  atomic_read(&tgtp->xmt_fcp_abort),
474 			  atomic_read(&tgtp->xmt_fcp_abort_cmpl));
475 		if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
476 			goto buffer_done;
477 
478 		scnprintf(tmp, sizeof(tmp),
479 			  "ABORT: Sol %08x  Usol %08x Err %08x Cmpl %08x\n",
480 			  atomic_read(&tgtp->xmt_abort_sol),
481 			  atomic_read(&tgtp->xmt_abort_unsol),
482 			  atomic_read(&tgtp->xmt_abort_rsp),
483 			  atomic_read(&tgtp->xmt_abort_rsp_error));
484 		if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
485 			goto buffer_done;
486 
487 		scnprintf(tmp, sizeof(tmp),
488 			  "DELAY: ctx %08x  fod %08x wqfull %08x\n",
489 			  atomic_read(&tgtp->defer_ctx),
490 			  atomic_read(&tgtp->defer_fod),
491 			  atomic_read(&tgtp->defer_wqfull));
492 		if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
493 			goto buffer_done;
494 
495 		/* Calculate outstanding IOs */
496 		tot = atomic_read(&tgtp->rcv_fcp_cmd_drop);
497 		tot += atomic_read(&tgtp->xmt_fcp_release);
498 		tot = atomic_read(&tgtp->rcv_fcp_cmd_in) - tot;
499 
500 		scnprintf(tmp, sizeof(tmp),
501 			  "IO_CTX: %08x  WAIT: cur %08x tot %08x\n"
502 			  "CTX Outstanding %08llx\n\n",
503 			  phba->sli4_hba.nvmet_xri_cnt,
504 			  phba->sli4_hba.nvmet_io_wait_cnt,
505 			  phba->sli4_hba.nvmet_io_wait_total,
506 			  tot);
507 		strlcat(buf, tmp, PAGE_SIZE);
508 		goto buffer_done;
509 	}
510 
511 	localport = vport->localport;
512 	if (!localport) {
513 		len = scnprintf(buf, PAGE_SIZE,
514 				"NVME Initiator x%llx is not allocated\n",
515 				wwn_to_u64(vport->fc_portname.u.wwn));
516 		return len;
517 	}
518 	lport = (struct lpfc_nvme_lport *)localport->private;
519 	if (strlcat(buf, "\nNVME Initiator Enabled\n", PAGE_SIZE) >= PAGE_SIZE)
520 		goto buffer_done;
521 
522 	scnprintf(tmp, sizeof(tmp),
523 		  "XRI Dist lpfc%d Total %d IO %d ELS %d\n",
524 		  phba->brd_no,
525 		  phba->sli4_hba.max_cfg_param.max_xri,
526 		  phba->sli4_hba.io_xri_max,
527 		  lpfc_sli4_get_els_iocb_cnt(phba));
528 	if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
529 		goto buffer_done;
530 
531 	/* Port state is only one of two values for now. */
532 	if (localport->port_id)
533 		statep = "ONLINE";
534 	else
535 		statep = "UNKNOWN ";
536 
537 	scnprintf(tmp, sizeof(tmp),
538 		  "%s%d WWPN x%llx WWNN x%llx DID x%06x %s\n",
539 		  "NVME LPORT lpfc",
540 		  phba->brd_no,
541 		  wwn_to_u64(vport->fc_portname.u.wwn),
542 		  wwn_to_u64(vport->fc_nodename.u.wwn),
543 		  localport->port_id, statep);
544 	if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
545 		goto buffer_done;
546 
547 	spin_lock_irqsave(&vport->fc_nodes_list_lock, iflags);
548 
549 	list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) {
550 		nrport = NULL;
551 		spin_lock(&ndlp->lock);
552 		rport = lpfc_ndlp_get_nrport(ndlp);
553 		if (rport)
554 			nrport = rport->remoteport;
555 		spin_unlock(&ndlp->lock);
556 		if (!nrport)
557 			continue;
558 
559 		/* Port state is only one of two values for now. */
560 		switch (nrport->port_state) {
561 		case FC_OBJSTATE_ONLINE:
562 			statep = "ONLINE";
563 			break;
564 		case FC_OBJSTATE_UNKNOWN:
565 			statep = "UNKNOWN ";
566 			break;
567 		default:
568 			statep = "UNSUPPORTED";
569 			break;
570 		}
571 
572 		/* Tab in to show lport ownership. */
573 		if (strlcat(buf, "NVME RPORT       ", PAGE_SIZE) >= PAGE_SIZE)
574 			goto unlock_buf_done;
575 		if (phba->brd_no >= 10) {
576 			if (strlcat(buf, " ", PAGE_SIZE) >= PAGE_SIZE)
577 				goto unlock_buf_done;
578 		}
579 
580 		scnprintf(tmp, sizeof(tmp), "WWPN x%llx ",
581 			  nrport->port_name);
582 		if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
583 			goto unlock_buf_done;
584 
585 		scnprintf(tmp, sizeof(tmp), "WWNN x%llx ",
586 			  nrport->node_name);
587 		if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
588 			goto unlock_buf_done;
589 
590 		scnprintf(tmp, sizeof(tmp), "DID x%06x ",
591 			  nrport->port_id);
592 		if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
593 			goto unlock_buf_done;
594 
595 		/* An NVME rport can have multiple roles. */
596 		if (nrport->port_role & FC_PORT_ROLE_NVME_INITIATOR) {
597 			if (strlcat(buf, "INITIATOR ", PAGE_SIZE) >= PAGE_SIZE)
598 				goto unlock_buf_done;
599 		}
600 		if (nrport->port_role & FC_PORT_ROLE_NVME_TARGET) {
601 			if (strlcat(buf, "TARGET ", PAGE_SIZE) >= PAGE_SIZE)
602 				goto unlock_buf_done;
603 		}
604 		if (nrport->port_role & FC_PORT_ROLE_NVME_DISCOVERY) {
605 			if (strlcat(buf, "DISCSRVC ", PAGE_SIZE) >= PAGE_SIZE)
606 				goto unlock_buf_done;
607 		}
608 		if (nrport->port_role & ~(FC_PORT_ROLE_NVME_INITIATOR |
609 					  FC_PORT_ROLE_NVME_TARGET |
610 					  FC_PORT_ROLE_NVME_DISCOVERY)) {
611 			scnprintf(tmp, sizeof(tmp), "UNKNOWN ROLE x%x",
612 				  nrport->port_role);
613 			if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
614 				goto unlock_buf_done;
615 		}
616 
617 		scnprintf(tmp, sizeof(tmp), "%s\n", statep);
618 		if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
619 			goto unlock_buf_done;
620 	}
621 	spin_unlock_irqrestore(&vport->fc_nodes_list_lock, iflags);
622 
623 	if (!lport)
624 		goto buffer_done;
625 
626 	if (strlcat(buf, "\nNVME Statistics\n", PAGE_SIZE) >= PAGE_SIZE)
627 		goto buffer_done;
628 
629 	scnprintf(tmp, sizeof(tmp),
630 		  "LS: Xmt %010x Cmpl %010x Abort %08x\n",
631 		  atomic_read(&lport->fc4NvmeLsRequests),
632 		  atomic_read(&lport->fc4NvmeLsCmpls),
633 		  atomic_read(&lport->xmt_ls_abort));
634 	if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
635 		goto buffer_done;
636 
637 	scnprintf(tmp, sizeof(tmp),
638 		  "LS XMIT: Err %08x  CMPL: xb %08x Err %08x\n",
639 		  atomic_read(&lport->xmt_ls_err),
640 		  atomic_read(&lport->cmpl_ls_xb),
641 		  atomic_read(&lport->cmpl_ls_err));
642 	if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
643 		goto buffer_done;
644 
645 	totin = 0;
646 	totout = 0;
647 	for (i = 0; i < phba->cfg_hdw_queue; i++) {
648 		cstat = &phba->sli4_hba.hdwq[i].nvme_cstat;
649 		tot = cstat->io_cmpls;
650 		totin += tot;
651 		data1 = cstat->input_requests;
652 		data2 = cstat->output_requests;
653 		data3 = cstat->control_requests;
654 		totout += (data1 + data2 + data3);
655 	}
656 	scnprintf(tmp, sizeof(tmp),
657 		  "Total FCP Cmpl %016llx Issue %016llx "
658 		  "OutIO %016llx\n",
659 		  totin, totout, totout - totin);
660 	if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
661 		goto buffer_done;
662 
663 	scnprintf(tmp, sizeof(tmp),
664 		  "\tabort %08x noxri %08x nondlp %08x qdepth %08x "
665 		  "wqerr %08x err %08x\n",
666 		  atomic_read(&lport->xmt_fcp_abort),
667 		  atomic_read(&lport->xmt_fcp_noxri),
668 		  atomic_read(&lport->xmt_fcp_bad_ndlp),
669 		  atomic_read(&lport->xmt_fcp_qdepth),
670 		  atomic_read(&lport->xmt_fcp_wqerr),
671 		  atomic_read(&lport->xmt_fcp_err));
672 	if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
673 		goto buffer_done;
674 
675 	scnprintf(tmp, sizeof(tmp),
676 		  "FCP CMPL: xb %08x Err %08x\n",
677 		  atomic_read(&lport->cmpl_fcp_xb),
678 		  atomic_read(&lport->cmpl_fcp_err));
679 	strlcat(buf, tmp, PAGE_SIZE);
680 
681 	/* host_lock is already unlocked. */
682 	goto buffer_done;
683 
684  unlock_buf_done:
685 	spin_unlock_irqrestore(&vport->fc_nodes_list_lock, iflags);
686 
687  buffer_done:
688 	len = strnlen(buf, PAGE_SIZE);
689 
690 	if (unlikely(len >= (PAGE_SIZE - 1))) {
691 		lpfc_printf_log(phba, KERN_INFO, LOG_NVME,
692 				"6314 Catching potential buffer "
693 				"overflow > PAGE_SIZE = %lu bytes\n",
694 				PAGE_SIZE);
695 		strscpy(buf + PAGE_SIZE - 1 - sizeof(LPFC_INFO_MORE_STR),
696 			LPFC_INFO_MORE_STR,
697 			sizeof(LPFC_INFO_MORE_STR) + 1);
698 	}
699 
700 	return len;
701 }
702 
703 static ssize_t
lpfc_scsi_stat_show(struct device * dev,struct device_attribute * attr,char * buf)704 lpfc_scsi_stat_show(struct device *dev, struct device_attribute *attr,
705 		    char *buf)
706 {
707 	struct Scsi_Host *shost = class_to_shost(dev);
708 	struct lpfc_vport *vport = shost_priv(shost);
709 	struct lpfc_hba *phba = vport->phba;
710 	int len;
711 	struct lpfc_fc4_ctrl_stat *cstat;
712 	u64 data1, data2, data3;
713 	u64 tot, totin, totout;
714 	int i;
715 	char tmp[LPFC_MAX_SCSI_INFO_TMP_LEN] = {0};
716 
717 	if (!(vport->cfg_enable_fc4_type & LPFC_ENABLE_FCP) ||
718 	    (phba->sli_rev != LPFC_SLI_REV4))
719 		return 0;
720 
721 	scnprintf(buf, PAGE_SIZE, "SCSI HDWQ Statistics\n");
722 
723 	totin = 0;
724 	totout = 0;
725 	for (i = 0; i < phba->cfg_hdw_queue; i++) {
726 		cstat = &phba->sli4_hba.hdwq[i].scsi_cstat;
727 		tot = cstat->io_cmpls;
728 		totin += tot;
729 		data1 = cstat->input_requests;
730 		data2 = cstat->output_requests;
731 		data3 = cstat->control_requests;
732 		totout += (data1 + data2 + data3);
733 
734 		scnprintf(tmp, sizeof(tmp), "HDWQ (%d): Rd %016llx Wr %016llx "
735 			  "IO %016llx ", i, data1, data2, data3);
736 		if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
737 			goto buffer_done;
738 
739 		scnprintf(tmp, sizeof(tmp), "Cmpl %016llx OutIO %016llx\n",
740 			  tot, ((data1 + data2 + data3) - tot));
741 		if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
742 			goto buffer_done;
743 	}
744 	scnprintf(tmp, sizeof(tmp), "Total FCP Cmpl %016llx Issue %016llx "
745 		  "OutIO %016llx\n", totin, totout, totout - totin);
746 	strlcat(buf, tmp, PAGE_SIZE);
747 
748 buffer_done:
749 	len = strnlen(buf, PAGE_SIZE);
750 
751 	return len;
752 }
753 
754 static ssize_t
lpfc_bg_info_show(struct device * dev,struct device_attribute * attr,char * buf)755 lpfc_bg_info_show(struct device *dev, struct device_attribute *attr,
756 		  char *buf)
757 {
758 	struct Scsi_Host *shost = class_to_shost(dev);
759 	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
760 	struct lpfc_hba   *phba = vport->phba;
761 
762 	if (phba->cfg_enable_bg) {
763 		if (phba->sli3_options & LPFC_SLI3_BG_ENABLED)
764 			return scnprintf(buf, PAGE_SIZE,
765 					"BlockGuard Enabled\n");
766 		else
767 			return scnprintf(buf, PAGE_SIZE,
768 					"BlockGuard Not Supported\n");
769 	} else
770 		return scnprintf(buf, PAGE_SIZE,
771 					"BlockGuard Disabled\n");
772 }
773 
774 static ssize_t
lpfc_bg_guard_err_show(struct device * dev,struct device_attribute * attr,char * buf)775 lpfc_bg_guard_err_show(struct device *dev, struct device_attribute *attr,
776 		       char *buf)
777 {
778 	struct Scsi_Host *shost = class_to_shost(dev);
779 	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
780 	struct lpfc_hba   *phba = vport->phba;
781 
782 	return scnprintf(buf, PAGE_SIZE, "%llu\n",
783 			(unsigned long long)phba->bg_guard_err_cnt);
784 }
785 
786 static ssize_t
lpfc_bg_apptag_err_show(struct device * dev,struct device_attribute * attr,char * buf)787 lpfc_bg_apptag_err_show(struct device *dev, struct device_attribute *attr,
788 			char *buf)
789 {
790 	struct Scsi_Host *shost = class_to_shost(dev);
791 	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
792 	struct lpfc_hba   *phba = vport->phba;
793 
794 	return scnprintf(buf, PAGE_SIZE, "%llu\n",
795 			(unsigned long long)phba->bg_apptag_err_cnt);
796 }
797 
798 static ssize_t
lpfc_bg_reftag_err_show(struct device * dev,struct device_attribute * attr,char * buf)799 lpfc_bg_reftag_err_show(struct device *dev, struct device_attribute *attr,
800 			char *buf)
801 {
802 	struct Scsi_Host *shost = class_to_shost(dev);
803 	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
804 	struct lpfc_hba   *phba = vport->phba;
805 
806 	return scnprintf(buf, PAGE_SIZE, "%llu\n",
807 			(unsigned long long)phba->bg_reftag_err_cnt);
808 }
809 
810 /**
811  * lpfc_info_show - Return some pci info about the host in ascii
812  * @dev: class converted to a Scsi_host structure.
813  * @attr: device attribute, not used.
814  * @buf: on return contains the formatted text from lpfc_info().
815  *
816  * Returns: size of formatted string.
817  **/
818 static ssize_t
lpfc_info_show(struct device * dev,struct device_attribute * attr,char * buf)819 lpfc_info_show(struct device *dev, struct device_attribute *attr,
820 	       char *buf)
821 {
822 	struct Scsi_Host *host = class_to_shost(dev);
823 
824 	return scnprintf(buf, PAGE_SIZE, "%s\n", lpfc_info(host));
825 }
826 
827 /**
828  * lpfc_serialnum_show - Return the hba serial number in ascii
829  * @dev: class converted to a Scsi_host structure.
830  * @attr: device attribute, not used.
831  * @buf: on return contains the formatted text serial number.
832  *
833  * Returns: size of formatted string.
834  **/
835 static ssize_t
lpfc_serialnum_show(struct device * dev,struct device_attribute * attr,char * buf)836 lpfc_serialnum_show(struct device *dev, struct device_attribute *attr,
837 		    char *buf)
838 {
839 	struct Scsi_Host  *shost = class_to_shost(dev);
840 	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
841 	struct lpfc_hba   *phba = vport->phba;
842 
843 	return scnprintf(buf, PAGE_SIZE, "%s\n", phba->SerialNumber);
844 }
845 
846 /**
847  * lpfc_temp_sensor_show - Return the temperature sensor level
848  * @dev: class converted to a Scsi_host structure.
849  * @attr: device attribute, not used.
850  * @buf: on return contains the formatted support level.
851  *
852  * Description:
853  * Returns a number indicating the temperature sensor level currently
854  * supported, zero or one in ascii.
855  *
856  * Returns: size of formatted string.
857  **/
858 static ssize_t
lpfc_temp_sensor_show(struct device * dev,struct device_attribute * attr,char * buf)859 lpfc_temp_sensor_show(struct device *dev, struct device_attribute *attr,
860 		      char *buf)
861 {
862 	struct Scsi_Host *shost = class_to_shost(dev);
863 	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
864 	struct lpfc_hba   *phba = vport->phba;
865 	return scnprintf(buf, PAGE_SIZE, "%d\n", phba->temp_sensor_support);
866 }
867 
868 /**
869  * lpfc_modeldesc_show - Return the model description of the hba
870  * @dev: class converted to a Scsi_host structure.
871  * @attr: device attribute, not used.
872  * @buf: on return contains the scsi vpd model description.
873  *
874  * Returns: size of formatted string.
875  **/
876 static ssize_t
lpfc_modeldesc_show(struct device * dev,struct device_attribute * attr,char * buf)877 lpfc_modeldesc_show(struct device *dev, struct device_attribute *attr,
878 		    char *buf)
879 {
880 	struct Scsi_Host  *shost = class_to_shost(dev);
881 	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
882 	struct lpfc_hba   *phba = vport->phba;
883 
884 	return scnprintf(buf, PAGE_SIZE, "%s\n", phba->ModelDesc);
885 }
886 
887 /**
888  * lpfc_modelname_show - Return the model name of the hba
889  * @dev: class converted to a Scsi_host structure.
890  * @attr: device attribute, not used.
891  * @buf: on return contains the scsi vpd model name.
892  *
893  * Returns: size of formatted string.
894  **/
895 static ssize_t
lpfc_modelname_show(struct device * dev,struct device_attribute * attr,char * buf)896 lpfc_modelname_show(struct device *dev, struct device_attribute *attr,
897 		    char *buf)
898 {
899 	struct Scsi_Host  *shost = class_to_shost(dev);
900 	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
901 	struct lpfc_hba   *phba = vport->phba;
902 
903 	return scnprintf(buf, PAGE_SIZE, "%s\n", phba->ModelName);
904 }
905 
906 /**
907  * lpfc_programtype_show - Return the program type of the hba
908  * @dev: class converted to a Scsi_host structure.
909  * @attr: device attribute, not used.
910  * @buf: on return contains the scsi vpd program type.
911  *
912  * Returns: size of formatted string.
913  **/
914 static ssize_t
lpfc_programtype_show(struct device * dev,struct device_attribute * attr,char * buf)915 lpfc_programtype_show(struct device *dev, struct device_attribute *attr,
916 		      char *buf)
917 {
918 	struct Scsi_Host  *shost = class_to_shost(dev);
919 	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
920 	struct lpfc_hba   *phba = vport->phba;
921 
922 	return scnprintf(buf, PAGE_SIZE, "%s\n", phba->ProgramType);
923 }
924 
925 /**
926  * lpfc_vportnum_show - Return the port number in ascii of the hba
927  * @dev: class converted to a Scsi_host structure.
928  * @attr: device attribute, not used.
929  * @buf: on return contains scsi vpd program type.
930  *
931  * Returns: size of formatted string.
932  **/
933 static ssize_t
lpfc_vportnum_show(struct device * dev,struct device_attribute * attr,char * buf)934 lpfc_vportnum_show(struct device *dev, struct device_attribute *attr,
935 		   char *buf)
936 {
937 	struct Scsi_Host  *shost = class_to_shost(dev);
938 	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
939 	struct lpfc_hba   *phba = vport->phba;
940 
941 	return scnprintf(buf, PAGE_SIZE, "%s\n", phba->Port);
942 }
943 
944 /**
945  * lpfc_fwrev_show - Return the firmware rev running in the hba
946  * @dev: class converted to a Scsi_host structure.
947  * @attr: device attribute, not used.
948  * @buf: on return contains the scsi vpd program type.
949  *
950  * Returns: size of formatted string.
951  **/
952 static ssize_t
lpfc_fwrev_show(struct device * dev,struct device_attribute * attr,char * buf)953 lpfc_fwrev_show(struct device *dev, struct device_attribute *attr,
954 		char *buf)
955 {
956 	struct Scsi_Host  *shost = class_to_shost(dev);
957 	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
958 	struct lpfc_hba   *phba = vport->phba;
959 	uint32_t if_type;
960 	uint8_t sli_family;
961 	char fwrev[FW_REV_STR_SIZE];
962 	int len;
963 
964 	lpfc_decode_firmware_rev(phba, fwrev, 1);
965 	if_type = phba->sli4_hba.pc_sli4_params.if_type;
966 	sli_family = phba->sli4_hba.pc_sli4_params.sli_family;
967 
968 	if (phba->sli_rev < LPFC_SLI_REV4)
969 		len = scnprintf(buf, PAGE_SIZE, "%s, sli-%d\n",
970 			       fwrev, phba->sli_rev);
971 	else
972 		len = scnprintf(buf, PAGE_SIZE, "%s, sli-%d:%d:%x\n",
973 			       fwrev, phba->sli_rev, if_type, sli_family);
974 
975 	return len;
976 }
977 
978 /**
979  * lpfc_hdw_show - Return the jedec information about the hba
980  * @dev: class converted to a Scsi_host structure.
981  * @attr: device attribute, not used.
982  * @buf: on return contains the scsi vpd program type.
983  *
984  * Returns: size of formatted string.
985  **/
986 static ssize_t
lpfc_hdw_show(struct device * dev,struct device_attribute * attr,char * buf)987 lpfc_hdw_show(struct device *dev, struct device_attribute *attr, char *buf)
988 {
989 	char hdw[9];
990 	struct Scsi_Host  *shost = class_to_shost(dev);
991 	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
992 	struct lpfc_hba   *phba = vport->phba;
993 	lpfc_vpd_t *vp = &phba->vpd;
994 
995 	lpfc_jedec_to_ascii(vp->rev.biuRev, hdw);
996 	return scnprintf(buf, PAGE_SIZE, "%s %08x %08x\n", hdw,
997 			 vp->rev.smRev, vp->rev.smFwRev);
998 }
999 
1000 /**
1001  * lpfc_option_rom_version_show - Return the adapter ROM FCode version
1002  * @dev: class converted to a Scsi_host structure.
1003  * @attr: device attribute, not used.
1004  * @buf: on return contains the ROM and FCode ascii strings.
1005  *
1006  * Returns: size of formatted string.
1007  **/
1008 static ssize_t
lpfc_option_rom_version_show(struct device * dev,struct device_attribute * attr,char * buf)1009 lpfc_option_rom_version_show(struct device *dev, struct device_attribute *attr,
1010 			     char *buf)
1011 {
1012 	struct Scsi_Host  *shost = class_to_shost(dev);
1013 	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1014 	struct lpfc_hba   *phba = vport->phba;
1015 	char fwrev[FW_REV_STR_SIZE];
1016 
1017 	if (phba->sli_rev < LPFC_SLI_REV4)
1018 		return scnprintf(buf, PAGE_SIZE, "%s\n",
1019 				phba->OptionROMVersion);
1020 
1021 	lpfc_decode_firmware_rev(phba, fwrev, 1);
1022 	return scnprintf(buf, PAGE_SIZE, "%s\n", fwrev);
1023 }
1024 
1025 /**
1026  * lpfc_link_state_show - Return the link state of the port
1027  * @dev: class converted to a Scsi_host structure.
1028  * @attr: device attribute, not used.
1029  * @buf: on return contains text describing the state of the link.
1030  *
1031  * Notes:
1032  * The switch statement has no default so zero will be returned.
1033  *
1034  * Returns: size of formatted string.
1035  **/
1036 static ssize_t
lpfc_link_state_show(struct device * dev,struct device_attribute * attr,char * buf)1037 lpfc_link_state_show(struct device *dev, struct device_attribute *attr,
1038 		     char *buf)
1039 {
1040 	struct Scsi_Host  *shost = class_to_shost(dev);
1041 	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1042 	struct lpfc_hba   *phba = vport->phba;
1043 	int  len = 0;
1044 
1045 	switch (phba->link_state) {
1046 	case LPFC_LINK_UNKNOWN:
1047 	case LPFC_WARM_START:
1048 	case LPFC_INIT_START:
1049 	case LPFC_INIT_MBX_CMDS:
1050 	case LPFC_LINK_DOWN:
1051 	case LPFC_HBA_ERROR:
1052 		if (test_bit(LINK_DISABLED, &phba->hba_flag))
1053 			len += scnprintf(buf + len, PAGE_SIZE-len,
1054 				"Link Down - User disabled\n");
1055 		else
1056 			len += scnprintf(buf + len, PAGE_SIZE-len,
1057 				"Link Down\n");
1058 		break;
1059 	case LPFC_LINK_UP:
1060 	case LPFC_CLEAR_LA:
1061 	case LPFC_HBA_READY:
1062 		len += scnprintf(buf + len, PAGE_SIZE-len, "Link Up - ");
1063 
1064 		switch (vport->port_state) {
1065 		case LPFC_LOCAL_CFG_LINK:
1066 			len += scnprintf(buf + len, PAGE_SIZE-len,
1067 					"Configuring Link\n");
1068 			break;
1069 		case LPFC_FDISC:
1070 		case LPFC_FLOGI:
1071 		case LPFC_FABRIC_CFG_LINK:
1072 		case LPFC_NS_REG:
1073 		case LPFC_NS_QRY:
1074 		case LPFC_BUILD_DISC_LIST:
1075 		case LPFC_DISC_AUTH:
1076 			len += scnprintf(buf + len, PAGE_SIZE - len,
1077 					"Discovery\n");
1078 			break;
1079 		case LPFC_VPORT_READY:
1080 			len += scnprintf(buf + len, PAGE_SIZE - len,
1081 					"Ready\n");
1082 			break;
1083 
1084 		case LPFC_VPORT_FAILED:
1085 			len += scnprintf(buf + len, PAGE_SIZE - len,
1086 					"Failed\n");
1087 			break;
1088 
1089 		case LPFC_VPORT_UNKNOWN:
1090 			len += scnprintf(buf + len, PAGE_SIZE - len,
1091 					"Unknown\n");
1092 			break;
1093 		}
1094 		if (phba->fc_topology == LPFC_TOPOLOGY_LOOP) {
1095 			if (test_bit(FC_PUBLIC_LOOP, &vport->fc_flag))
1096 				len += scnprintf(buf + len, PAGE_SIZE-len,
1097 						"   Public Loop\n");
1098 			else
1099 				len += scnprintf(buf + len, PAGE_SIZE-len,
1100 						"   Private Loop\n");
1101 		} else {
1102 			if (test_bit(FC_FABRIC, &vport->fc_flag)) {
1103 				if (phba->sli_rev == LPFC_SLI_REV4 &&
1104 				    vport->port_type == LPFC_PHYSICAL_PORT &&
1105 				    phba->sli4_hba.fawwpn_flag &
1106 					LPFC_FAWWPN_FABRIC)
1107 					len += scnprintf(buf + len,
1108 							 PAGE_SIZE - len,
1109 							 "   Fabric FA-PWWN\n");
1110 				else
1111 					len += scnprintf(buf + len,
1112 							 PAGE_SIZE - len,
1113 							 "   Fabric\n");
1114 			} else {
1115 				len += scnprintf(buf + len, PAGE_SIZE-len,
1116 						"   Point-2-Point\n");
1117 			}
1118 		}
1119 	}
1120 
1121 	if ((phba->sli_rev == LPFC_SLI_REV4) &&
1122 	    ((bf_get(lpfc_sli_intf_if_type,
1123 	     &phba->sli4_hba.sli_intf) ==
1124 	     LPFC_SLI_INTF_IF_TYPE_6))) {
1125 		struct lpfc_trunk_link link = phba->trunk_link;
1126 
1127 		if (bf_get(lpfc_conf_trunk_port0, &phba->sli4_hba))
1128 			len += scnprintf(buf + len, PAGE_SIZE - len,
1129 				"Trunk port 0: Link %s %s\n",
1130 				(link.link0.state == LPFC_LINK_UP) ?
1131 				 "Up" : "Down. ",
1132 				trunk_errmsg[link.link0.fault]);
1133 
1134 		if (bf_get(lpfc_conf_trunk_port1, &phba->sli4_hba))
1135 			len += scnprintf(buf + len, PAGE_SIZE - len,
1136 				"Trunk port 1: Link %s %s\n",
1137 				(link.link1.state == LPFC_LINK_UP) ?
1138 				 "Up" : "Down. ",
1139 				trunk_errmsg[link.link1.fault]);
1140 
1141 		if (bf_get(lpfc_conf_trunk_port2, &phba->sli4_hba))
1142 			len += scnprintf(buf + len, PAGE_SIZE - len,
1143 				"Trunk port 2: Link %s %s\n",
1144 				(link.link2.state == LPFC_LINK_UP) ?
1145 				 "Up" : "Down. ",
1146 				trunk_errmsg[link.link2.fault]);
1147 
1148 		if (bf_get(lpfc_conf_trunk_port3, &phba->sli4_hba))
1149 			len += scnprintf(buf + len, PAGE_SIZE - len,
1150 				"Trunk port 3: Link %s %s\n",
1151 				(link.link3.state == LPFC_LINK_UP) ?
1152 				 "Up" : "Down. ",
1153 				trunk_errmsg[link.link3.fault]);
1154 
1155 	}
1156 
1157 	return len;
1158 }
1159 
1160 /**
1161  * lpfc_sli4_protocol_show - Return the fip mode of the HBA
1162  * @dev: class unused variable.
1163  * @attr: device attribute, not used.
1164  * @buf: on return contains the module description text.
1165  *
1166  * Returns: size of formatted string.
1167  **/
1168 static ssize_t
lpfc_sli4_protocol_show(struct device * dev,struct device_attribute * attr,char * buf)1169 lpfc_sli4_protocol_show(struct device *dev, struct device_attribute *attr,
1170 			char *buf)
1171 {
1172 	struct Scsi_Host *shost = class_to_shost(dev);
1173 	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1174 	struct lpfc_hba *phba = vport->phba;
1175 
1176 	if (phba->sli_rev < LPFC_SLI_REV4)
1177 		return scnprintf(buf, PAGE_SIZE, "fc\n");
1178 
1179 	if (phba->sli4_hba.lnk_info.lnk_dv == LPFC_LNK_DAT_VAL) {
1180 		if (phba->sli4_hba.lnk_info.lnk_tp == LPFC_LNK_TYPE_GE)
1181 			return scnprintf(buf, PAGE_SIZE, "fcoe\n");
1182 		if (phba->sli4_hba.lnk_info.lnk_tp == LPFC_LNK_TYPE_FC)
1183 			return scnprintf(buf, PAGE_SIZE, "fc\n");
1184 	}
1185 	return scnprintf(buf, PAGE_SIZE, "unknown\n");
1186 }
1187 
1188 /**
1189  * lpfc_oas_supported_show - Return whether or not Optimized Access Storage
1190  *			    (OAS) is supported.
1191  * @dev: class unused variable.
1192  * @attr: device attribute, not used.
1193  * @buf: on return contains the module description text.
1194  *
1195  * Returns: size of formatted string.
1196  **/
1197 static ssize_t
lpfc_oas_supported_show(struct device * dev,struct device_attribute * attr,char * buf)1198 lpfc_oas_supported_show(struct device *dev, struct device_attribute *attr,
1199 			char *buf)
1200 {
1201 	struct Scsi_Host *shost = class_to_shost(dev);
1202 	struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
1203 	struct lpfc_hba *phba = vport->phba;
1204 
1205 	return scnprintf(buf, PAGE_SIZE, "%d\n",
1206 			phba->sli4_hba.pc_sli4_params.oas_supported);
1207 }
1208 
1209 /**
1210  * lpfc_link_state_store - Transition the link_state on an HBA port
1211  * @dev: class device that is converted into a Scsi_host.
1212  * @attr: device attribute, not used.
1213  * @buf: one or more lpfc_polling_flags values.
1214  * @count: not used.
1215  *
1216  * Returns:
1217  * -EINVAL if the buffer is not "up" or "down"
1218  * return from link state change function if non-zero
1219  * length of the buf on success
1220  **/
1221 static ssize_t
lpfc_link_state_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)1222 lpfc_link_state_store(struct device *dev, struct device_attribute *attr,
1223 		const char *buf, size_t count)
1224 {
1225 	struct Scsi_Host  *shost = class_to_shost(dev);
1226 	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1227 	struct lpfc_hba   *phba = vport->phba;
1228 
1229 	int status = -EINVAL;
1230 
1231 	if ((strncmp(buf, "up", sizeof("up") - 1) == 0) &&
1232 			(phba->link_state == LPFC_LINK_DOWN))
1233 		status = phba->lpfc_hba_init_link(phba, MBX_NOWAIT);
1234 	else if ((strncmp(buf, "down", sizeof("down") - 1) == 0) &&
1235 			(phba->link_state >= LPFC_LINK_UP))
1236 		status = phba->lpfc_hba_down_link(phba, MBX_NOWAIT);
1237 
1238 	if (status == 0)
1239 		return strlen(buf);
1240 	else
1241 		return status;
1242 }
1243 
1244 /**
1245  * lpfc_num_discovered_ports_show - Return sum of mapped and unmapped vports
1246  * @dev: class device that is converted into a Scsi_host.
1247  * @attr: device attribute, not used.
1248  * @buf: on return contains the sum of fc mapped and unmapped.
1249  *
1250  * Description:
1251  * Returns the ascii text number of the sum of the fc mapped and unmapped
1252  * vport counts.
1253  *
1254  * Returns: size of formatted string.
1255  **/
1256 static ssize_t
lpfc_num_discovered_ports_show(struct device * dev,struct device_attribute * attr,char * buf)1257 lpfc_num_discovered_ports_show(struct device *dev,
1258 			       struct device_attribute *attr, char *buf)
1259 {
1260 	struct Scsi_Host  *shost = class_to_shost(dev);
1261 	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1262 
1263 	return scnprintf(buf, PAGE_SIZE, "%d\n",
1264 			 atomic_read(&vport->fc_map_cnt) +
1265 			 atomic_read(&vport->fc_unmap_cnt));
1266 }
1267 
1268 /**
1269  * lpfc_issue_lip - Misnomer, name carried over from long ago
1270  * @shost: Scsi_Host pointer.
1271  *
1272  * Description:
1273  * Bring the link down gracefully then re-init the link. The firmware will
1274  * re-init the fiber channel interface as required. Does not issue a LIP.
1275  *
1276  * Returns:
1277  * -EPERM port offline or management commands are being blocked
1278  * -ENOMEM cannot allocate memory for the mailbox command
1279  * -EIO error sending the mailbox command
1280  * zero for success
1281  **/
1282 static int
lpfc_issue_lip(struct Scsi_Host * shost)1283 lpfc_issue_lip(struct Scsi_Host *shost)
1284 {
1285 	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1286 	struct lpfc_hba   *phba = vport->phba;
1287 	LPFC_MBOXQ_t *pmboxq;
1288 	int mbxstatus = MBXERR_ERROR;
1289 
1290 	/*
1291 	 * If the link is offline, disabled or BLOCK_MGMT_IO
1292 	 * it doesn't make any sense to allow issue_lip
1293 	 */
1294 	if (test_bit(FC_OFFLINE_MODE, &vport->fc_flag) ||
1295 	    test_bit(LINK_DISABLED, &phba->hba_flag) ||
1296 	    (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO))
1297 		return -EPERM;
1298 
1299 	pmboxq = mempool_alloc(phba->mbox_mem_pool,GFP_KERNEL);
1300 
1301 	if (!pmboxq)
1302 		return -ENOMEM;
1303 
1304 	memset((void *)pmboxq, 0, sizeof (LPFC_MBOXQ_t));
1305 	pmboxq->u.mb.mbxCommand = MBX_DOWN_LINK;
1306 	pmboxq->u.mb.mbxOwner = OWN_HOST;
1307 
1308 	if (test_bit(FC_PT2PT, &vport->fc_flag))
1309 		clear_bit(FC_PT2PT_NO_NVME, &vport->fc_flag);
1310 
1311 	mbxstatus = lpfc_sli_issue_mbox_wait(phba, pmboxq, LPFC_MBOX_TMO * 2);
1312 
1313 	if ((mbxstatus == MBX_SUCCESS) &&
1314 	    (pmboxq->u.mb.mbxStatus == 0 ||
1315 	     pmboxq->u.mb.mbxStatus == MBXERR_LINK_DOWN)) {
1316 		memset((void *)pmboxq, 0, sizeof (LPFC_MBOXQ_t));
1317 		lpfc_init_link(phba, pmboxq, phba->cfg_topology,
1318 			       phba->cfg_link_speed);
1319 		mbxstatus = lpfc_sli_issue_mbox_wait(phba, pmboxq,
1320 						     phba->fc_ratov * 2);
1321 		if ((mbxstatus == MBX_SUCCESS) &&
1322 		    (pmboxq->u.mb.mbxStatus == MBXERR_SEC_NO_PERMISSION))
1323 			lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
1324 					"2859 SLI authentication is required "
1325 					"for INIT_LINK but has not done yet\n");
1326 	}
1327 
1328 	lpfc_set_loopback_flag(phba);
1329 	if (mbxstatus != MBX_TIMEOUT)
1330 		mempool_free(pmboxq, phba->mbox_mem_pool);
1331 
1332 	if (mbxstatus == MBXERR_ERROR)
1333 		return -EIO;
1334 
1335 	return 0;
1336 }
1337 
1338 int
lpfc_emptyq_wait(struct lpfc_hba * phba,struct list_head * q,spinlock_t * lock)1339 lpfc_emptyq_wait(struct lpfc_hba *phba, struct list_head *q, spinlock_t *lock)
1340 {
1341 	int cnt = 0;
1342 
1343 	spin_lock_irq(lock);
1344 	while (!list_empty(q)) {
1345 		spin_unlock_irq(lock);
1346 		msleep(20);
1347 		if (cnt++ > 250) {  /* 5 secs */
1348 			lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
1349 					"0466 Outstanding IO when "
1350 					"bringing Adapter offline\n");
1351 				return 0;
1352 		}
1353 		spin_lock_irq(lock);
1354 	}
1355 	spin_unlock_irq(lock);
1356 	return 1;
1357 }
1358 
1359 /**
1360  * lpfc_do_offline - Issues a mailbox command to bring the link down
1361  * @phba: lpfc_hba pointer.
1362  * @type: LPFC_EVT_OFFLINE, LPFC_EVT_WARM_START, LPFC_EVT_KILL.
1363  *
1364  * Notes:
1365  * Assumes any error from lpfc_do_offline() will be negative.
1366  * Can wait up to 5 seconds for the port ring buffers count
1367  * to reach zero, prints a warning if it is not zero and continues.
1368  * lpfc_workq_post_event() returns a non-zero return code if call fails.
1369  *
1370  * Returns:
1371  * -EIO error posting the event
1372  * zero for success
1373  **/
1374 static int
lpfc_do_offline(struct lpfc_hba * phba,uint32_t type)1375 lpfc_do_offline(struct lpfc_hba *phba, uint32_t type)
1376 {
1377 	struct completion online_compl;
1378 	struct lpfc_queue *qp = NULL;
1379 	struct lpfc_sli_ring *pring;
1380 	struct lpfc_sli *psli;
1381 	int status = 0;
1382 	int i;
1383 	int rc;
1384 
1385 	init_completion(&online_compl);
1386 	rc = lpfc_workq_post_event(phba, &status, &online_compl,
1387 			      LPFC_EVT_OFFLINE_PREP);
1388 	if (rc == 0)
1389 		return -ENOMEM;
1390 
1391 	wait_for_completion(&online_compl);
1392 
1393 	if (status != 0)
1394 		return -EIO;
1395 
1396 	psli = &phba->sli;
1397 
1398 	/*
1399 	 * If freeing the queues have already started, don't access them.
1400 	 * Otherwise set FREE_WAIT to indicate that queues are being used
1401 	 * to hold the freeing process until we finish.
1402 	 */
1403 	spin_lock_irq(&phba->hbalock);
1404 	if (!(psli->sli_flag & LPFC_QUEUE_FREE_INIT)) {
1405 		psli->sli_flag |= LPFC_QUEUE_FREE_WAIT;
1406 	} else {
1407 		spin_unlock_irq(&phba->hbalock);
1408 		goto skip_wait;
1409 	}
1410 	spin_unlock_irq(&phba->hbalock);
1411 
1412 	/* Wait a little for things to settle down, but not
1413 	 * long enough for dev loss timeout to expire.
1414 	 */
1415 	if (phba->sli_rev != LPFC_SLI_REV4) {
1416 		for (i = 0; i < psli->num_rings; i++) {
1417 			pring = &psli->sli3_ring[i];
1418 			if (!lpfc_emptyq_wait(phba, &pring->txcmplq,
1419 					      &phba->hbalock))
1420 				goto out;
1421 		}
1422 	} else {
1423 		list_for_each_entry(qp, &phba->sli4_hba.lpfc_wq_list, wq_list) {
1424 			pring = qp->pring;
1425 			if (!pring)
1426 				continue;
1427 			if (!lpfc_emptyq_wait(phba, &pring->txcmplq,
1428 					      &pring->ring_lock))
1429 				goto out;
1430 		}
1431 	}
1432 out:
1433 	spin_lock_irq(&phba->hbalock);
1434 	psli->sli_flag &= ~LPFC_QUEUE_FREE_WAIT;
1435 	spin_unlock_irq(&phba->hbalock);
1436 
1437 skip_wait:
1438 	init_completion(&online_compl);
1439 	rc = lpfc_workq_post_event(phba, &status, &online_compl, type);
1440 	if (rc == 0)
1441 		return -ENOMEM;
1442 
1443 	wait_for_completion(&online_compl);
1444 
1445 	if (status != 0)
1446 		return -EIO;
1447 
1448 	return 0;
1449 }
1450 
1451 /**
1452  * lpfc_reset_pci_bus - resets PCI bridge controller's secondary bus of an HBA
1453  * @phba: lpfc_hba pointer.
1454  *
1455  * Description:
1456  * Issues a PCI secondary bus reset for the phba->pcidev.
1457  *
1458  * Notes:
1459  * First walks the bus_list to ensure only PCI devices with Emulex
1460  * vendor id, device ids that support hot reset, only one occurrence
1461  * of function 0, and all ports on the bus are in offline mode to ensure the
1462  * hot reset only affects one valid HBA.
1463  *
1464  * Returns:
1465  * -ENOTSUPP, cfg_enable_hba_reset must be of value 2
1466  * -ENODEV,   NULL ptr to pcidev
1467  * -EBADSLT,  detected invalid device
1468  * -EBUSY,    port is not in offline state
1469  *      0,    successful
1470  */
1471 static int
lpfc_reset_pci_bus(struct lpfc_hba * phba)1472 lpfc_reset_pci_bus(struct lpfc_hba *phba)
1473 {
1474 	struct pci_dev *pdev = phba->pcidev;
1475 	struct Scsi_Host *shost = NULL;
1476 	struct lpfc_hba *phba_other = NULL;
1477 	struct pci_dev *ptr = NULL;
1478 	int res;
1479 
1480 	if (phba->cfg_enable_hba_reset != 2)
1481 		return -ENOTSUPP;
1482 
1483 	if (!pdev) {
1484 		lpfc_printf_log(phba, KERN_INFO, LOG_INIT, "8345 pdev NULL!\n");
1485 		return -ENODEV;
1486 	}
1487 
1488 	res = lpfc_check_pci_resettable(phba);
1489 	if (res)
1490 		return res;
1491 
1492 	/* Walk the list of devices on the pci_dev's bus */
1493 	list_for_each_entry(ptr, &pdev->bus->devices, bus_list) {
1494 		/* Check port is offline */
1495 		shost = pci_get_drvdata(ptr);
1496 		if (shost) {
1497 			phba_other =
1498 				((struct lpfc_vport *)shost->hostdata)->phba;
1499 			if (!test_bit(FC_OFFLINE_MODE,
1500 				      &phba_other->pport->fc_flag)) {
1501 				lpfc_printf_log(phba_other, KERN_INFO, LOG_INIT,
1502 						"8349 WWPN = 0x%02x%02x%02x%02x"
1503 						"%02x%02x%02x%02x is not "
1504 						"offline!\n",
1505 						phba_other->wwpn[0],
1506 						phba_other->wwpn[1],
1507 						phba_other->wwpn[2],
1508 						phba_other->wwpn[3],
1509 						phba_other->wwpn[4],
1510 						phba_other->wwpn[5],
1511 						phba_other->wwpn[6],
1512 						phba_other->wwpn[7]);
1513 				return -EBUSY;
1514 			}
1515 		}
1516 	}
1517 
1518 	/* Issue PCI bus reset */
1519 	res = pci_reset_bus(pdev);
1520 	if (res) {
1521 		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
1522 				"8350 PCI reset bus failed: %d\n", res);
1523 	}
1524 
1525 	return res;
1526 }
1527 
1528 /**
1529  * lpfc_selective_reset - Offline then onlines the port
1530  * @phba: lpfc_hba pointer.
1531  *
1532  * Description:
1533  * If the port is configured to allow a reset then the hba is brought
1534  * offline then online.
1535  *
1536  * Notes:
1537  * Assumes any error from lpfc_do_offline() will be negative.
1538  * Do not make this function static.
1539  *
1540  * Returns:
1541  * lpfc_do_offline() return code if not zero
1542  * -EIO reset not configured or error posting the event
1543  * zero for success
1544  **/
1545 int
lpfc_selective_reset(struct lpfc_hba * phba)1546 lpfc_selective_reset(struct lpfc_hba *phba)
1547 {
1548 	struct completion online_compl;
1549 	int status = 0;
1550 	int rc;
1551 
1552 	if (!phba->cfg_enable_hba_reset)
1553 		return -EACCES;
1554 
1555 	if (!test_bit(FC_OFFLINE_MODE, &phba->pport->fc_flag)) {
1556 		status = lpfc_do_offline(phba, LPFC_EVT_OFFLINE);
1557 
1558 		if (status != 0)
1559 			return status;
1560 	}
1561 
1562 	init_completion(&online_compl);
1563 	rc = lpfc_workq_post_event(phba, &status, &online_compl,
1564 			      LPFC_EVT_ONLINE);
1565 	if (rc == 0)
1566 		return -ENOMEM;
1567 
1568 	wait_for_completion(&online_compl);
1569 
1570 	if (status != 0)
1571 		return -EIO;
1572 
1573 	return 0;
1574 }
1575 
1576 /**
1577  * lpfc_issue_reset - Selectively resets an adapter
1578  * @dev: class device that is converted into a Scsi_host.
1579  * @attr: device attribute, not used.
1580  * @buf: containing the string "selective".
1581  * @count: unused variable.
1582  *
1583  * Description:
1584  * If the buf contains the string "selective" then lpfc_selective_reset()
1585  * is called to perform the reset.
1586  *
1587  * Notes:
1588  * Assumes any error from lpfc_selective_reset() will be negative.
1589  * If lpfc_selective_reset() returns zero then the length of the buffer
1590  * is returned which indicates success
1591  *
1592  * Returns:
1593  * -EINVAL if the buffer does not contain the string "selective"
1594  * length of buf if lpfc-selective_reset() if the call succeeds
1595  * return value of lpfc_selective_reset() if the call fails
1596 **/
1597 static ssize_t
lpfc_issue_reset(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)1598 lpfc_issue_reset(struct device *dev, struct device_attribute *attr,
1599 		 const char *buf, size_t count)
1600 {
1601 	struct Scsi_Host  *shost = class_to_shost(dev);
1602 	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1603 	struct lpfc_hba   *phba = vport->phba;
1604 	int status = -EINVAL;
1605 
1606 	if (!phba->cfg_enable_hba_reset)
1607 		return -EACCES;
1608 
1609 	if (strncmp(buf, "selective", sizeof("selective") - 1) == 0)
1610 		status = phba->lpfc_selective_reset(phba);
1611 
1612 	if (status == 0)
1613 		return strlen(buf);
1614 	else
1615 		return status;
1616 }
1617 
1618 /**
1619  * lpfc_sli4_pdev_status_reg_wait - Wait for pdev status register for readyness
1620  * @phba: lpfc_hba pointer.
1621  *
1622  * Description:
1623  * SLI4 interface type-2 device to wait on the sliport status register for
1624  * the readyness after performing a firmware reset.
1625  *
1626  * Returns:
1627  * zero for success, -EPERM when port does not have privilege to perform the
1628  * reset, -EIO when port timeout from recovering from the reset.
1629  *
1630  * Note:
1631  * As the caller will interpret the return code by value, be careful in making
1632  * change or addition to return codes.
1633  **/
1634 int
lpfc_sli4_pdev_status_reg_wait(struct lpfc_hba * phba)1635 lpfc_sli4_pdev_status_reg_wait(struct lpfc_hba *phba)
1636 {
1637 	struct lpfc_register portstat_reg = {0};
1638 	int i;
1639 
1640 	msleep(100);
1641 	if (lpfc_readl(phba->sli4_hba.u.if_type2.STATUSregaddr,
1642 		       &portstat_reg.word0))
1643 		return -EIO;
1644 
1645 	/* verify if privileged for the request operation */
1646 	if (!bf_get(lpfc_sliport_status_rn, &portstat_reg) &&
1647 	    !bf_get(lpfc_sliport_status_err, &portstat_reg))
1648 		return -EPERM;
1649 
1650 	/* There is no point to wait if the port is in an unrecoverable
1651 	 * state.
1652 	 */
1653 	if (lpfc_sli4_unrecoverable_port(&portstat_reg))
1654 		return -EIO;
1655 
1656 	/* wait for the SLI port firmware ready after firmware reset */
1657 	for (i = 0; i < LPFC_FW_RESET_MAXIMUM_WAIT_10MS_CNT; i++) {
1658 		msleep(10);
1659 		if (lpfc_readl(phba->sli4_hba.u.if_type2.STATUSregaddr,
1660 			       &portstat_reg.word0))
1661 			continue;
1662 		if (!bf_get(lpfc_sliport_status_err, &portstat_reg))
1663 			continue;
1664 		if (!bf_get(lpfc_sliport_status_rn, &portstat_reg))
1665 			continue;
1666 		if (!bf_get(lpfc_sliport_status_rdy, &portstat_reg))
1667 			continue;
1668 		break;
1669 	}
1670 
1671 	if (i < LPFC_FW_RESET_MAXIMUM_WAIT_10MS_CNT)
1672 		return 0;
1673 	else
1674 		return -EIO;
1675 }
1676 
1677 /**
1678  * lpfc_sli4_pdev_reg_request - Request physical dev to perform a register acc
1679  * @phba: lpfc_hba pointer.
1680  * @opcode: The sli4 config command opcode.
1681  *
1682  * Description:
1683  * Request SLI4 interface type-2 device to perform a physical register set
1684  * access.
1685  *
1686  * Returns:
1687  * zero for success
1688  **/
1689 static ssize_t
lpfc_sli4_pdev_reg_request(struct lpfc_hba * phba,uint32_t opcode)1690 lpfc_sli4_pdev_reg_request(struct lpfc_hba *phba, uint32_t opcode)
1691 {
1692 	struct completion online_compl;
1693 	struct pci_dev *pdev = phba->pcidev;
1694 	unsigned long before_fc_flag;
1695 	uint32_t sriov_nr_virtfn;
1696 	uint32_t reg_val;
1697 	int status = 0, rc = 0;
1698 	int job_posted = 1, sriov_err;
1699 
1700 	if (!phba->cfg_enable_hba_reset)
1701 		return -EACCES;
1702 
1703 	if ((phba->sli_rev < LPFC_SLI_REV4) ||
1704 	    (bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf) <
1705 	     LPFC_SLI_INTF_IF_TYPE_2))
1706 		return -EPERM;
1707 
1708 	/* Keep state if we need to restore back */
1709 	before_fc_flag = phba->pport->fc_flag;
1710 	sriov_nr_virtfn = phba->cfg_sriov_nr_virtfn;
1711 
1712 	if (opcode == LPFC_FW_DUMP) {
1713 		init_completion(&online_compl);
1714 		phba->fw_dump_cmpl = &online_compl;
1715 	} else {
1716 		/* Disable SR-IOV virtual functions if enabled */
1717 		if (phba->cfg_sriov_nr_virtfn) {
1718 			pci_disable_sriov(pdev);
1719 			phba->cfg_sriov_nr_virtfn = 0;
1720 		}
1721 
1722 		status = lpfc_do_offline(phba, LPFC_EVT_OFFLINE);
1723 
1724 		if (status != 0)
1725 			return status;
1726 
1727 		/* wait for the device to be quiesced before firmware reset */
1728 		msleep(100);
1729 	}
1730 
1731 	reg_val = readl(phba->sli4_hba.conf_regs_memmap_p +
1732 			LPFC_CTL_PDEV_CTL_OFFSET);
1733 
1734 	if (opcode == LPFC_FW_DUMP)
1735 		reg_val |= LPFC_FW_DUMP_REQUEST;
1736 	else if (opcode == LPFC_FW_RESET)
1737 		reg_val |= LPFC_CTL_PDEV_CTL_FRST;
1738 	else if (opcode == LPFC_DV_RESET)
1739 		reg_val |= LPFC_CTL_PDEV_CTL_DRST;
1740 
1741 	writel(reg_val, phba->sli4_hba.conf_regs_memmap_p +
1742 	       LPFC_CTL_PDEV_CTL_OFFSET);
1743 	/* flush */
1744 	readl(phba->sli4_hba.conf_regs_memmap_p + LPFC_CTL_PDEV_CTL_OFFSET);
1745 
1746 	/* delay driver action following IF_TYPE_2 reset */
1747 	rc = lpfc_sli4_pdev_status_reg_wait(phba);
1748 
1749 	if (rc == -EPERM) {
1750 		/* no privilege for reset */
1751 		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
1752 				"3150 No privilege to perform the requested "
1753 				"access: x%x\n", reg_val);
1754 	} else if (rc == -EIO) {
1755 		/* reset failed, there is nothing more we can do */
1756 		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
1757 				"3153 Fail to perform the requested "
1758 				"access: x%x\n", reg_val);
1759 		if (phba->fw_dump_cmpl)
1760 			phba->fw_dump_cmpl = NULL;
1761 		return rc;
1762 	}
1763 
1764 	/* keep the original port state */
1765 	if (test_bit(FC_OFFLINE_MODE, &before_fc_flag)) {
1766 		if (phba->fw_dump_cmpl)
1767 			phba->fw_dump_cmpl = NULL;
1768 		goto out;
1769 	}
1770 
1771 	/* Firmware dump will trigger an HA_ERATT event, and
1772 	 * lpfc_handle_eratt_s4 routine already handles bringing the port back
1773 	 * online.
1774 	 */
1775 	if (opcode == LPFC_FW_DUMP) {
1776 		wait_for_completion(phba->fw_dump_cmpl);
1777 	} else  {
1778 		init_completion(&online_compl);
1779 		job_posted = lpfc_workq_post_event(phba, &status, &online_compl,
1780 						   LPFC_EVT_ONLINE);
1781 		if (!job_posted)
1782 			goto out;
1783 
1784 		wait_for_completion(&online_compl);
1785 	}
1786 out:
1787 	/* in any case, restore the virtual functions enabled as before */
1788 	if (sriov_nr_virtfn) {
1789 		/* If fw_dump was performed, first disable to clean up */
1790 		if (opcode == LPFC_FW_DUMP) {
1791 			pci_disable_sriov(pdev);
1792 			phba->cfg_sriov_nr_virtfn = 0;
1793 		}
1794 
1795 		sriov_err =
1796 			lpfc_sli_probe_sriov_nr_virtfn(phba, sriov_nr_virtfn);
1797 		if (!sriov_err)
1798 			phba->cfg_sriov_nr_virtfn = sriov_nr_virtfn;
1799 	}
1800 
1801 	/* return proper error code */
1802 	if (!rc) {
1803 		if (!job_posted)
1804 			rc = -ENOMEM;
1805 		else if (status)
1806 			rc = -EIO;
1807 	}
1808 	return rc;
1809 }
1810 
1811 /**
1812  * lpfc_nport_evt_cnt_show - Return the number of nport events
1813  * @dev: class device that is converted into a Scsi_host.
1814  * @attr: device attribute, not used.
1815  * @buf: on return contains the ascii number of nport events.
1816  *
1817  * Returns: size of formatted string.
1818  **/
1819 static ssize_t
lpfc_nport_evt_cnt_show(struct device * dev,struct device_attribute * attr,char * buf)1820 lpfc_nport_evt_cnt_show(struct device *dev, struct device_attribute *attr,
1821 			char *buf)
1822 {
1823 	struct Scsi_Host  *shost = class_to_shost(dev);
1824 	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1825 	struct lpfc_hba   *phba = vport->phba;
1826 
1827 	return scnprintf(buf, PAGE_SIZE, "%d\n", phba->nport_event_cnt);
1828 }
1829 
1830 static int
lpfc_set_trunking(struct lpfc_hba * phba,char * buff_out)1831 lpfc_set_trunking(struct lpfc_hba *phba, char *buff_out)
1832 {
1833 	LPFC_MBOXQ_t *mbox = NULL;
1834 	u32 payload_len;
1835 	unsigned long val = 0;
1836 	char *pval = NULL;
1837 	int rc = 0;
1838 
1839 	if (!strncmp("enable", buff_out,
1840 				 strlen("enable"))) {
1841 		pval = buff_out + strlen("enable") + 1;
1842 		rc = kstrtoul(pval, 0, &val);
1843 		if (rc)
1844 			return rc; /* Invalid  number */
1845 	} else if (!strncmp("disable", buff_out,
1846 				 strlen("disable"))) {
1847 		val = 0;
1848 	} else {
1849 		return -EINVAL;  /* Invalid command */
1850 	}
1851 
1852 	switch (val) {
1853 	case 0:
1854 		val = 0x0; /* Disable */
1855 		break;
1856 	case 2:
1857 		val = 0x1; /* Enable two port trunk */
1858 		break;
1859 	case 4:
1860 		val = 0x2; /* Enable four port trunk */
1861 		break;
1862 	default:
1863 		return -EINVAL;
1864 	}
1865 
1866 	lpfc_printf_log(phba, KERN_ERR, LOG_MBOX,
1867 			"0070 Set trunk mode with val %ld ", val);
1868 
1869 	mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
1870 	if (!mbox)
1871 		return -ENOMEM;
1872 
1873 	payload_len = sizeof(struct lpfc_mbx_set_trunk_mode) -
1874 		      sizeof(struct lpfc_sli4_cfg_mhdr);
1875 	lpfc_sli4_config(phba, mbox, LPFC_MBOX_SUBSYSTEM_FCOE,
1876 			 LPFC_MBOX_OPCODE_FCOE_FC_SET_TRUNK_MODE,
1877 			 payload_len, LPFC_SLI4_MBX_EMBED);
1878 
1879 	bf_set(lpfc_mbx_set_trunk_mode,
1880 	       &mbox->u.mqe.un.set_trunk_mode,
1881 	       val);
1882 	rc = lpfc_sli_issue_mbox(phba, mbox, MBX_POLL);
1883 	if (rc)
1884 		lpfc_printf_log(phba, KERN_ERR, LOG_MBOX,
1885 				"0071 Set trunk mode failed with status: %d",
1886 				rc);
1887 	mempool_free(mbox, phba->mbox_mem_pool);
1888 
1889 	return 0;
1890 }
1891 
1892 static ssize_t
lpfc_xcvr_data_show(struct device * dev,struct device_attribute * attr,char * buf)1893 lpfc_xcvr_data_show(struct device *dev, struct device_attribute *attr,
1894 		    char *buf)
1895 {
1896 	struct Scsi_Host  *shost = class_to_shost(dev);
1897 	struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
1898 	struct lpfc_hba   *phba = vport->phba;
1899 	int rc;
1900 	int len = 0;
1901 	struct lpfc_rdp_context	*rdp_context;
1902 	u16 temperature;
1903 	u16 rx_power;
1904 	u16 tx_bias;
1905 	u16 tx_power;
1906 	u16 vcc;
1907 	char chbuf[128];
1908 	u16 wavelength = 0;
1909 	struct sff_trasnceiver_codes_byte7 *trasn_code_byte7;
1910 
1911 	/* Get transceiver information */
1912 	rdp_context = kmalloc(sizeof(*rdp_context), GFP_KERNEL);
1913 	if (!rdp_context) {
1914 		len = scnprintf(buf, PAGE_SIZE - len,
1915 				"SPF info NA: alloc failure\n");
1916 		return len;
1917 	}
1918 
1919 	rc = lpfc_get_sfp_info_wait(phba, rdp_context);
1920 	if (rc) {
1921 		len = scnprintf(buf, PAGE_SIZE - len, "SFP info NA:\n");
1922 		goto out_free_rdp;
1923 	}
1924 
1925 	strscpy(chbuf, &rdp_context->page_a0[SSF_VENDOR_NAME], 16);
1926 
1927 	len = scnprintf(buf, PAGE_SIZE - len, "VendorName:\t%s\n", chbuf);
1928 	len += scnprintf(buf + len, PAGE_SIZE - len,
1929 			 "VendorOUI:\t%02x-%02x-%02x\n",
1930 			 (uint8_t)rdp_context->page_a0[SSF_VENDOR_OUI],
1931 			 (uint8_t)rdp_context->page_a0[SSF_VENDOR_OUI + 1],
1932 			 (uint8_t)rdp_context->page_a0[SSF_VENDOR_OUI + 2]);
1933 	strscpy(chbuf, &rdp_context->page_a0[SSF_VENDOR_PN], 16);
1934 	len += scnprintf(buf + len, PAGE_SIZE - len, "VendorPN:\t%s\n", chbuf);
1935 	strscpy(chbuf, &rdp_context->page_a0[SSF_VENDOR_SN], 16);
1936 	len += scnprintf(buf + len, PAGE_SIZE - len, "VendorSN:\t%s\n", chbuf);
1937 	strscpy(chbuf, &rdp_context->page_a0[SSF_VENDOR_REV], 4);
1938 	len += scnprintf(buf + len, PAGE_SIZE - len, "VendorRev:\t%s\n", chbuf);
1939 	strscpy(chbuf, &rdp_context->page_a0[SSF_DATE_CODE], 8);
1940 	len += scnprintf(buf + len, PAGE_SIZE - len, "DateCode:\t%s\n", chbuf);
1941 	len += scnprintf(buf + len, PAGE_SIZE - len, "Identifier:\t%xh\n",
1942 			 (uint8_t)rdp_context->page_a0[SSF_IDENTIFIER]);
1943 	len += scnprintf(buf + len, PAGE_SIZE - len, "ExtIdentifier:\t%xh\n",
1944 			 (uint8_t)rdp_context->page_a0[SSF_EXT_IDENTIFIER]);
1945 	len += scnprintf(buf + len, PAGE_SIZE - len, "Connector:\t%xh\n",
1946 			 (uint8_t)rdp_context->page_a0[SSF_CONNECTOR]);
1947 	wavelength = (rdp_context->page_a0[SSF_WAVELENGTH_B1] << 8) |
1948 		      rdp_context->page_a0[SSF_WAVELENGTH_B0];
1949 
1950 	len += scnprintf(buf + len, PAGE_SIZE - len, "Wavelength:\t%d nm\n",
1951 			 wavelength);
1952 	trasn_code_byte7 = (struct sff_trasnceiver_codes_byte7 *)
1953 			&rdp_context->page_a0[SSF_TRANSCEIVER_CODE_B7];
1954 
1955 	len += scnprintf(buf + len, PAGE_SIZE - len, "Speeds: \t");
1956 	if (*(uint8_t *)trasn_code_byte7 == 0) {
1957 		len += scnprintf(buf + len, PAGE_SIZE - len, "Unknown\n");
1958 	} else {
1959 		if (trasn_code_byte7->fc_sp_100MB)
1960 			len += scnprintf(buf + len, PAGE_SIZE - len, "1 ");
1961 		if (trasn_code_byte7->fc_sp_200mb)
1962 			len += scnprintf(buf + len, PAGE_SIZE - len, "2 ");
1963 		if (trasn_code_byte7->fc_sp_400MB)
1964 			len += scnprintf(buf + len, PAGE_SIZE - len, "4 ");
1965 		if (trasn_code_byte7->fc_sp_800MB)
1966 			len += scnprintf(buf + len, PAGE_SIZE - len, "8 ");
1967 		if (trasn_code_byte7->fc_sp_1600MB)
1968 			len += scnprintf(buf + len, PAGE_SIZE - len, "16 ");
1969 		if (trasn_code_byte7->fc_sp_3200MB)
1970 			len += scnprintf(buf + len, PAGE_SIZE - len, "32 ");
1971 		if (trasn_code_byte7->speed_chk_ecc)
1972 			len += scnprintf(buf + len, PAGE_SIZE - len, "64 ");
1973 		len += scnprintf(buf + len, PAGE_SIZE - len, "GB\n");
1974 	}
1975 	temperature = (rdp_context->page_a2[SFF_TEMPERATURE_B1] << 8 |
1976 		       rdp_context->page_a2[SFF_TEMPERATURE_B0]);
1977 	vcc = (rdp_context->page_a2[SFF_VCC_B1] << 8 |
1978 	       rdp_context->page_a2[SFF_VCC_B0]);
1979 	tx_power = (rdp_context->page_a2[SFF_TXPOWER_B1] << 8 |
1980 		    rdp_context->page_a2[SFF_TXPOWER_B0]);
1981 	tx_bias = (rdp_context->page_a2[SFF_TX_BIAS_CURRENT_B1] << 8 |
1982 		   rdp_context->page_a2[SFF_TX_BIAS_CURRENT_B0]);
1983 	rx_power = (rdp_context->page_a2[SFF_RXPOWER_B1] << 8 |
1984 		    rdp_context->page_a2[SFF_RXPOWER_B0]);
1985 
1986 	len += scnprintf(buf + len, PAGE_SIZE - len,
1987 			 "Temperature:\tx%04x C\n", temperature);
1988 	len += scnprintf(buf + len, PAGE_SIZE - len, "Vcc:\t\tx%04x V\n", vcc);
1989 	len += scnprintf(buf + len, PAGE_SIZE - len,
1990 			 "TxBiasCurrent:\tx%04x mA\n", tx_bias);
1991 	len += scnprintf(buf + len, PAGE_SIZE - len, "TxPower:\tx%04x mW\n",
1992 			 tx_power);
1993 	len += scnprintf(buf + len, PAGE_SIZE - len, "RxPower:\tx%04x mW\n",
1994 			 rx_power);
1995 out_free_rdp:
1996 	kfree(rdp_context);
1997 	return len;
1998 }
1999 
2000 /**
2001  * lpfc_board_mode_show - Return the state of the board
2002  * @dev: class device that is converted into a Scsi_host.
2003  * @attr: device attribute, not used.
2004  * @buf: on return contains the state of the adapter.
2005  *
2006  * Returns: size of formatted string.
2007  **/
2008 static ssize_t
lpfc_board_mode_show(struct device * dev,struct device_attribute * attr,char * buf)2009 lpfc_board_mode_show(struct device *dev, struct device_attribute *attr,
2010 		     char *buf)
2011 {
2012 	struct Scsi_Host  *shost = class_to_shost(dev);
2013 	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2014 	struct lpfc_hba   *phba = vport->phba;
2015 	char  * state;
2016 
2017 	if (phba->link_state == LPFC_HBA_ERROR)
2018 		state = "error";
2019 	else if (phba->link_state == LPFC_WARM_START)
2020 		state = "warm start";
2021 	else if (phba->link_state == LPFC_INIT_START)
2022 		state = "offline";
2023 	else
2024 		state = "online";
2025 
2026 	return scnprintf(buf, PAGE_SIZE, "%s\n", state);
2027 }
2028 
2029 /**
2030  * lpfc_board_mode_store - Puts the hba in online, offline, warm or error state
2031  * @dev: class device that is converted into a Scsi_host.
2032  * @attr: device attribute, not used.
2033  * @buf: containing one of the strings "online", "offline", "warm" or "error".
2034  * @count: unused variable.
2035  *
2036  * Returns:
2037  * -EACCES if enable hba reset not enabled
2038  * -EINVAL if the buffer does not contain a valid string (see above)
2039  * -EIO if lpfc_workq_post_event() or lpfc_do_offline() fails
2040  * buf length greater than zero indicates success
2041  **/
2042 static ssize_t
lpfc_board_mode_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)2043 lpfc_board_mode_store(struct device *dev, struct device_attribute *attr,
2044 		      const char *buf, size_t count)
2045 {
2046 	struct Scsi_Host  *shost = class_to_shost(dev);
2047 	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2048 	struct lpfc_hba   *phba = vport->phba;
2049 	struct completion online_compl;
2050 	char *board_mode_str = NULL;
2051 	int status = 0;
2052 	int rc;
2053 
2054 	if (!phba->cfg_enable_hba_reset) {
2055 		status = -EACCES;
2056 		goto board_mode_out;
2057 	}
2058 
2059 	lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
2060 			 "3050 lpfc_board_mode set to %s\n", buf);
2061 
2062 	init_completion(&online_compl);
2063 
2064 	if(strncmp(buf, "online", sizeof("online") - 1) == 0) {
2065 		rc = lpfc_workq_post_event(phba, &status, &online_compl,
2066 				      LPFC_EVT_ONLINE);
2067 		if (rc == 0) {
2068 			status = -ENOMEM;
2069 			goto board_mode_out;
2070 		}
2071 		wait_for_completion(&online_compl);
2072 		if (status)
2073 			status = -EIO;
2074 	} else if (strncmp(buf, "offline", sizeof("offline") - 1) == 0)
2075 		status = lpfc_do_offline(phba, LPFC_EVT_OFFLINE);
2076 	else if (strncmp(buf, "warm", sizeof("warm") - 1) == 0)
2077 		if (phba->sli_rev == LPFC_SLI_REV4)
2078 			status = -EINVAL;
2079 		else
2080 			status = lpfc_do_offline(phba, LPFC_EVT_WARM_START);
2081 	else if (strncmp(buf, "error", sizeof("error") - 1) == 0)
2082 		if (phba->sli_rev == LPFC_SLI_REV4)
2083 			status = -EINVAL;
2084 		else
2085 			status = lpfc_do_offline(phba, LPFC_EVT_KILL);
2086 	else if (strncmp(buf, "dump", sizeof("dump") - 1) == 0)
2087 		status = lpfc_sli4_pdev_reg_request(phba, LPFC_FW_DUMP);
2088 	else if (strncmp(buf, "fw_reset", sizeof("fw_reset") - 1) == 0)
2089 		status = lpfc_sli4_pdev_reg_request(phba, LPFC_FW_RESET);
2090 	else if (strncmp(buf, "dv_reset", sizeof("dv_reset") - 1) == 0)
2091 		status = lpfc_sli4_pdev_reg_request(phba, LPFC_DV_RESET);
2092 	else if (strncmp(buf, "pci_bus_reset", sizeof("pci_bus_reset") - 1)
2093 		 == 0)
2094 		status = lpfc_reset_pci_bus(phba);
2095 	else if (strncmp(buf, "heartbeat", sizeof("heartbeat") - 1) == 0)
2096 		lpfc_issue_hb_tmo(phba);
2097 	else if (strncmp(buf, "trunk", sizeof("trunk") - 1) == 0)
2098 		status = lpfc_set_trunking(phba, (char *)buf + sizeof("trunk"));
2099 	else
2100 		status = -EINVAL;
2101 
2102 board_mode_out:
2103 	if (!status)
2104 		return strlen(buf);
2105 	else {
2106 		board_mode_str = strchr(buf, '\n');
2107 		if (board_mode_str)
2108 			*board_mode_str = '\0';
2109 		lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
2110 				 "3097 Failed \"%s\", status(%d), "
2111 				 "fc_flag(x%lx)\n",
2112 				 buf, status, phba->pport->fc_flag);
2113 		return status;
2114 	}
2115 }
2116 
2117 /**
2118  * lpfc_get_hba_info - Return various bits of informaton about the adapter
2119  * @phba: pointer to the adapter structure.
2120  * @mxri: max xri count.
2121  * @axri: available xri count.
2122  * @mrpi: max rpi count.
2123  * @arpi: available rpi count.
2124  * @mvpi: max vpi count.
2125  * @avpi: available vpi count.
2126  *
2127  * Description:
2128  * If an integer pointer for an count is not null then the value for the
2129  * count is returned.
2130  *
2131  * Returns:
2132  * zero on error
2133  * one for success
2134  **/
2135 static int
lpfc_get_hba_info(struct lpfc_hba * phba,uint32_t * mxri,uint32_t * axri,uint32_t * mrpi,uint32_t * arpi,uint32_t * mvpi,uint32_t * avpi)2136 lpfc_get_hba_info(struct lpfc_hba *phba,
2137 		  uint32_t *mxri, uint32_t *axri,
2138 		  uint32_t *mrpi, uint32_t *arpi,
2139 		  uint32_t *mvpi, uint32_t *avpi)
2140 {
2141 	LPFC_MBOXQ_t *pmboxq;
2142 	MAILBOX_t *pmb;
2143 	int rc = 0;
2144 	struct lpfc_sli4_hba *sli4_hba;
2145 	struct lpfc_max_cfg_param *max_cfg_param;
2146 	u16 rsrc_ext_cnt, rsrc_ext_size, max_vpi;
2147 
2148 	/*
2149 	 * prevent udev from issuing mailbox commands until the port is
2150 	 * configured.
2151 	 */
2152 	if (phba->link_state < LPFC_LINK_DOWN ||
2153 	    !phba->mbox_mem_pool ||
2154 	    (phba->sli.sli_flag & LPFC_SLI_ACTIVE) == 0)
2155 		return 0;
2156 
2157 	if (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO)
2158 		return 0;
2159 
2160 	pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
2161 	if (!pmboxq)
2162 		return 0;
2163 	memset(pmboxq, 0, sizeof (LPFC_MBOXQ_t));
2164 
2165 	pmb = &pmboxq->u.mb;
2166 	pmb->mbxCommand = MBX_READ_CONFIG;
2167 	pmb->mbxOwner = OWN_HOST;
2168 	pmboxq->ctx_buf = NULL;
2169 
2170 	if (test_bit(FC_OFFLINE_MODE, &phba->pport->fc_flag))
2171 		rc = MBX_NOT_FINISHED;
2172 	else
2173 		rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2);
2174 
2175 	if (rc != MBX_SUCCESS) {
2176 		if (rc != MBX_TIMEOUT)
2177 			mempool_free(pmboxq, phba->mbox_mem_pool);
2178 		return 0;
2179 	}
2180 
2181 	if (phba->sli_rev == LPFC_SLI_REV4) {
2182 		sli4_hba = &phba->sli4_hba;
2183 		max_cfg_param = &sli4_hba->max_cfg_param;
2184 
2185 		/* Normally, extents are not used */
2186 		if (!phba->sli4_hba.extents_in_use) {
2187 			if (mrpi)
2188 				*mrpi = max_cfg_param->max_rpi;
2189 			if (mxri)
2190 				*mxri = max_cfg_param->max_xri;
2191 			if (mvpi) {
2192 				max_vpi = max_cfg_param->max_vpi;
2193 
2194 				/* Limit the max we support */
2195 				if (max_vpi > LPFC_MAX_VPI)
2196 					max_vpi = LPFC_MAX_VPI;
2197 				*mvpi = max_vpi;
2198 			}
2199 		} else { /* Extents in use */
2200 			if (mrpi) {
2201 				if (lpfc_sli4_get_avail_extnt_rsrc(phba,
2202 								   LPFC_RSC_TYPE_FCOE_RPI,
2203 								   &rsrc_ext_cnt,
2204 								   &rsrc_ext_size)) {
2205 					rc = 0;
2206 					goto free_pmboxq;
2207 				}
2208 
2209 				*mrpi = rsrc_ext_cnt * rsrc_ext_size;
2210 			}
2211 
2212 			if (mxri) {
2213 				if (lpfc_sli4_get_avail_extnt_rsrc(phba,
2214 								   LPFC_RSC_TYPE_FCOE_XRI,
2215 								   &rsrc_ext_cnt,
2216 								   &rsrc_ext_size)) {
2217 					rc = 0;
2218 					goto free_pmboxq;
2219 				}
2220 
2221 				*mxri = rsrc_ext_cnt * rsrc_ext_size;
2222 			}
2223 
2224 			if (mvpi) {
2225 				if (lpfc_sli4_get_avail_extnt_rsrc(phba,
2226 								   LPFC_RSC_TYPE_FCOE_VPI,
2227 								   &rsrc_ext_cnt,
2228 								   &rsrc_ext_size)) {
2229 					rc = 0;
2230 					goto free_pmboxq;
2231 				}
2232 
2233 				max_vpi = rsrc_ext_cnt * rsrc_ext_size;
2234 
2235 				/* Limit the max we support */
2236 				if (max_vpi > LPFC_MAX_VPI)
2237 					max_vpi = LPFC_MAX_VPI;
2238 				*mvpi = max_vpi;
2239 			}
2240 		}
2241 	} else {
2242 		if (mrpi)
2243 			*mrpi = pmb->un.varRdConfig.max_rpi;
2244 		if (arpi)
2245 			*arpi = pmb->un.varRdConfig.avail_rpi;
2246 		if (mxri)
2247 			*mxri = pmb->un.varRdConfig.max_xri;
2248 		if (axri)
2249 			*axri = pmb->un.varRdConfig.avail_xri;
2250 		if (mvpi)
2251 			*mvpi = pmb->un.varRdConfig.max_vpi;
2252 		if (avpi) {
2253 			/* avail_vpi is only valid if link is up and ready */
2254 			if (phba->link_state == LPFC_HBA_READY)
2255 				*avpi = pmb->un.varRdConfig.avail_vpi;
2256 			else
2257 				*avpi = pmb->un.varRdConfig.max_vpi;
2258 		}
2259 	}
2260 
2261 	/* Success */
2262 	rc = 1;
2263 
2264 free_pmboxq:
2265 	mempool_free(pmboxq, phba->mbox_mem_pool);
2266 	return rc;
2267 }
2268 
2269 /**
2270  * lpfc_max_rpi_show - Return maximum rpi
2271  * @dev: class device that is converted into a Scsi_host.
2272  * @attr: device attribute, not used.
2273  * @buf: on return contains the maximum rpi count in decimal or "Unknown".
2274  *
2275  * Description:
2276  * Calls lpfc_get_hba_info() asking for just the mrpi count.
2277  * If lpfc_get_hba_info() returns zero (failure) the buffer text is set
2278  * to "Unknown" and the buffer length is returned, therefore the caller
2279  * must check for "Unknown" in the buffer to detect a failure.
2280  *
2281  * Returns: size of formatted string.
2282  **/
2283 static ssize_t
lpfc_max_rpi_show(struct device * dev,struct device_attribute * attr,char * buf)2284 lpfc_max_rpi_show(struct device *dev, struct device_attribute *attr,
2285 		  char *buf)
2286 {
2287 	struct Scsi_Host  *shost = class_to_shost(dev);
2288 	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2289 	struct lpfc_hba   *phba = vport->phba;
2290 	uint32_t cnt;
2291 
2292 	if (lpfc_get_hba_info(phba, NULL, NULL, &cnt, NULL, NULL, NULL))
2293 		return scnprintf(buf, PAGE_SIZE, "%d\n", cnt);
2294 	return scnprintf(buf, PAGE_SIZE, "Unknown\n");
2295 }
2296 
2297 /**
2298  * lpfc_used_rpi_show - Return maximum rpi minus available rpi
2299  * @dev: class device that is converted into a Scsi_host.
2300  * @attr: device attribute, not used.
2301  * @buf: containing the used rpi count in decimal or "Unknown".
2302  *
2303  * Description:
2304  * Calls lpfc_get_hba_info() asking for just the mrpi and arpi counts.
2305  * If lpfc_get_hba_info() returns zero (failure) the buffer text is set
2306  * to "Unknown" and the buffer length is returned, therefore the caller
2307  * must check for "Unknown" in the buffer to detect a failure.
2308  *
2309  * Returns: size of formatted string.
2310  **/
2311 static ssize_t
lpfc_used_rpi_show(struct device * dev,struct device_attribute * attr,char * buf)2312 lpfc_used_rpi_show(struct device *dev, struct device_attribute *attr,
2313 		   char *buf)
2314 {
2315 	struct Scsi_Host  *shost = class_to_shost(dev);
2316 	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2317 	struct lpfc_hba   *phba = vport->phba;
2318 	struct lpfc_sli4_hba *sli4_hba;
2319 	struct lpfc_max_cfg_param *max_cfg_param;
2320 	u32 cnt = 0, acnt = 0;
2321 
2322 	if (phba->sli_rev == LPFC_SLI_REV4) {
2323 		sli4_hba = &phba->sli4_hba;
2324 		max_cfg_param = &sli4_hba->max_cfg_param;
2325 		return scnprintf(buf, PAGE_SIZE, "%d\n",
2326 				 max_cfg_param->rpi_used);
2327 	} else {
2328 		if (lpfc_get_hba_info(phba, NULL, NULL, &cnt, &acnt, NULL, NULL))
2329 			return scnprintf(buf, PAGE_SIZE, "%d\n", (cnt - acnt));
2330 	}
2331 	return scnprintf(buf, PAGE_SIZE, "Unknown\n");
2332 }
2333 
2334 /**
2335  * lpfc_max_xri_show - Return maximum xri
2336  * @dev: class device that is converted into a Scsi_host.
2337  * @attr: device attribute, not used.
2338  * @buf: on return contains the maximum xri count in decimal or "Unknown".
2339  *
2340  * Description:
2341  * Calls lpfc_get_hba_info() asking for just the mrpi count.
2342  * If lpfc_get_hba_info() returns zero (failure) the buffer text is set
2343  * to "Unknown" and the buffer length is returned, therefore the caller
2344  * must check for "Unknown" in the buffer to detect a failure.
2345  *
2346  * Returns: size of formatted string.
2347  **/
2348 static ssize_t
lpfc_max_xri_show(struct device * dev,struct device_attribute * attr,char * buf)2349 lpfc_max_xri_show(struct device *dev, struct device_attribute *attr,
2350 		  char *buf)
2351 {
2352 	struct Scsi_Host  *shost = class_to_shost(dev);
2353 	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2354 	struct lpfc_hba   *phba = vport->phba;
2355 	uint32_t cnt;
2356 
2357 	if (lpfc_get_hba_info(phba, &cnt, NULL, NULL, NULL, NULL, NULL))
2358 		return scnprintf(buf, PAGE_SIZE, "%d\n", cnt);
2359 	return scnprintf(buf, PAGE_SIZE, "Unknown\n");
2360 }
2361 
2362 /**
2363  * lpfc_used_xri_show - Return maximum xpi minus the available xpi
2364  * @dev: class device that is converted into a Scsi_host.
2365  * @attr: device attribute, not used.
2366  * @buf: on return contains the used xri count in decimal or "Unknown".
2367  *
2368  * Description:
2369  * Calls lpfc_get_hba_info() asking for just the mxri and axri counts.
2370  * If lpfc_get_hba_info() returns zero (failure) the buffer text is set
2371  * to "Unknown" and the buffer length is returned, therefore the caller
2372  * must check for "Unknown" in the buffer to detect a failure.
2373  *
2374  * Returns: size of formatted string.
2375  **/
2376 static ssize_t
lpfc_used_xri_show(struct device * dev,struct device_attribute * attr,char * buf)2377 lpfc_used_xri_show(struct device *dev, struct device_attribute *attr,
2378 		   char *buf)
2379 {
2380 	struct Scsi_Host  *shost = class_to_shost(dev);
2381 	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2382 	struct lpfc_hba   *phba = vport->phba;
2383 	struct lpfc_sli4_hba *sli4_hba;
2384 	struct lpfc_max_cfg_param *max_cfg_param;
2385 	u32 cnt = 0, acnt = 0;
2386 
2387 	if (phba->sli_rev == LPFC_SLI_REV4) {
2388 		sli4_hba = &phba->sli4_hba;
2389 		max_cfg_param = &sli4_hba->max_cfg_param;
2390 		return scnprintf(buf, PAGE_SIZE, "%d\n",
2391 				 max_cfg_param->xri_used);
2392 	} else {
2393 		if (lpfc_get_hba_info(phba, &cnt, &acnt, NULL, NULL, NULL, NULL))
2394 			return scnprintf(buf, PAGE_SIZE, "%d\n", (cnt - acnt));
2395 	}
2396 	return scnprintf(buf, PAGE_SIZE, "Unknown\n");
2397 }
2398 
2399 /**
2400  * lpfc_max_vpi_show - Return maximum vpi
2401  * @dev: class device that is converted into a Scsi_host.
2402  * @attr: device attribute, not used.
2403  * @buf: on return contains the maximum vpi count in decimal or "Unknown".
2404  *
2405  * Description:
2406  * Calls lpfc_get_hba_info() asking for just the mvpi count.
2407  * If lpfc_get_hba_info() returns zero (failure) the buffer text is set
2408  * to "Unknown" and the buffer length is returned, therefore the caller
2409  * must check for "Unknown" in the buffer to detect a failure.
2410  *
2411  * Returns: size of formatted string.
2412  **/
2413 static ssize_t
lpfc_max_vpi_show(struct device * dev,struct device_attribute * attr,char * buf)2414 lpfc_max_vpi_show(struct device *dev, struct device_attribute *attr,
2415 		  char *buf)
2416 {
2417 	struct Scsi_Host  *shost = class_to_shost(dev);
2418 	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2419 	struct lpfc_hba   *phba = vport->phba;
2420 	uint32_t cnt;
2421 
2422 	if (lpfc_get_hba_info(phba, NULL, NULL, NULL, NULL, &cnt, NULL))
2423 		return scnprintf(buf, PAGE_SIZE, "%d\n", cnt);
2424 	return scnprintf(buf, PAGE_SIZE, "Unknown\n");
2425 }
2426 
2427 /**
2428  * lpfc_used_vpi_show - Return maximum vpi minus the available vpi
2429  * @dev: class device that is converted into a Scsi_host.
2430  * @attr: device attribute, not used.
2431  * @buf: on return contains the used vpi count in decimal or "Unknown".
2432  *
2433  * Description:
2434  * Calls lpfc_get_hba_info() asking for just the mvpi and avpi counts.
2435  * If lpfc_get_hba_info() returns zero (failure) the buffer text is set
2436  * to "Unknown" and the buffer length is returned, therefore the caller
2437  * must check for "Unknown" in the buffer to detect a failure.
2438  *
2439  * Returns: size of formatted string.
2440  **/
2441 static ssize_t
lpfc_used_vpi_show(struct device * dev,struct device_attribute * attr,char * buf)2442 lpfc_used_vpi_show(struct device *dev, struct device_attribute *attr,
2443 		   char *buf)
2444 {
2445 	struct Scsi_Host  *shost = class_to_shost(dev);
2446 	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2447 	struct lpfc_hba   *phba = vport->phba;
2448 	struct lpfc_sli4_hba *sli4_hba;
2449 	struct lpfc_max_cfg_param *max_cfg_param;
2450 	u32 cnt = 0, acnt = 0;
2451 
2452 	if (phba->sli_rev == LPFC_SLI_REV4) {
2453 		sli4_hba = &phba->sli4_hba;
2454 		max_cfg_param = &sli4_hba->max_cfg_param;
2455 		return scnprintf(buf, PAGE_SIZE, "%d\n",
2456 				 max_cfg_param->vpi_used);
2457 	} else {
2458 		if (lpfc_get_hba_info(phba, NULL, NULL, NULL, NULL, &cnt, &acnt))
2459 			return scnprintf(buf, PAGE_SIZE, "%d\n", (cnt - acnt));
2460 	}
2461 	return scnprintf(buf, PAGE_SIZE, "Unknown\n");
2462 }
2463 
2464 /**
2465  * lpfc_npiv_info_show - Return text about NPIV support for the adapter
2466  * @dev: class device that is converted into a Scsi_host.
2467  * @attr: device attribute, not used.
2468  * @buf: text that must be interpreted to determine if npiv is supported.
2469  *
2470  * Description:
2471  * Buffer will contain text indicating npiv is not suppoerted on the port,
2472  * the port is an NPIV physical port, or it is an npiv virtual port with
2473  * the id of the vport.
2474  *
2475  * Returns: size of formatted string.
2476  **/
2477 static ssize_t
lpfc_npiv_info_show(struct device * dev,struct device_attribute * attr,char * buf)2478 lpfc_npiv_info_show(struct device *dev, struct device_attribute *attr,
2479 		    char *buf)
2480 {
2481 	struct Scsi_Host  *shost = class_to_shost(dev);
2482 	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2483 	struct lpfc_hba   *phba = vport->phba;
2484 
2485 	if (!(phba->max_vpi))
2486 		return scnprintf(buf, PAGE_SIZE, "NPIV Not Supported\n");
2487 	if (vport->port_type == LPFC_PHYSICAL_PORT)
2488 		return scnprintf(buf, PAGE_SIZE, "NPIV Physical\n");
2489 	return scnprintf(buf, PAGE_SIZE, "NPIV Virtual (VPI %d)\n", vport->vpi);
2490 }
2491 
2492 /**
2493  * lpfc_poll_show - Return text about poll support for the adapter
2494  * @dev: class device that is converted into a Scsi_host.
2495  * @attr: device attribute, not used.
2496  * @buf: on return contains the cfg_poll in hex.
2497  *
2498  * Notes:
2499  * cfg_poll should be a lpfc_polling_flags type.
2500  *
2501  * Returns: size of formatted string.
2502  **/
2503 static ssize_t
lpfc_poll_show(struct device * dev,struct device_attribute * attr,char * buf)2504 lpfc_poll_show(struct device *dev, struct device_attribute *attr,
2505 	       char *buf)
2506 {
2507 	struct Scsi_Host  *shost = class_to_shost(dev);
2508 	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2509 	struct lpfc_hba   *phba = vport->phba;
2510 
2511 	return scnprintf(buf, PAGE_SIZE, "%#x\n", phba->cfg_poll);
2512 }
2513 
2514 /**
2515  * lpfc_poll_store - Set the value of cfg_poll for the adapter
2516  * @dev: class device that is converted into a Scsi_host.
2517  * @attr: device attribute, not used.
2518  * @buf: one or more lpfc_polling_flags values.
2519  * @count: not used.
2520  *
2521  * Notes:
2522  * buf contents converted to integer and checked for a valid value.
2523  *
2524  * Returns:
2525  * -EINVAL if the buffer connot be converted or is out of range
2526  * length of the buf on success
2527  **/
2528 static ssize_t
lpfc_poll_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)2529 lpfc_poll_store(struct device *dev, struct device_attribute *attr,
2530 		const char *buf, size_t count)
2531 {
2532 	struct Scsi_Host  *shost = class_to_shost(dev);
2533 	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2534 	struct lpfc_hba   *phba = vport->phba;
2535 	uint32_t creg_val;
2536 	uint32_t old_val;
2537 	int val=0;
2538 
2539 	if (!isdigit(buf[0]))
2540 		return -EINVAL;
2541 
2542 	if (sscanf(buf, "%i", &val) != 1)
2543 		return -EINVAL;
2544 
2545 	if ((val & 0x3) != val)
2546 		return -EINVAL;
2547 
2548 	if (phba->sli_rev == LPFC_SLI_REV4)
2549 		val = 0;
2550 
2551 	lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
2552 		"3051 lpfc_poll changed from %d to %d\n",
2553 		phba->cfg_poll, val);
2554 
2555 	spin_lock_irq(&phba->hbalock);
2556 
2557 	old_val = phba->cfg_poll;
2558 
2559 	if (val & ENABLE_FCP_RING_POLLING) {
2560 		if ((val & DISABLE_FCP_RING_INT) &&
2561 		    !(old_val & DISABLE_FCP_RING_INT)) {
2562 			if (lpfc_readl(phba->HCregaddr, &creg_val)) {
2563 				spin_unlock_irq(&phba->hbalock);
2564 				return -EINVAL;
2565 			}
2566 			creg_val &= ~(HC_R0INT_ENA << LPFC_FCP_RING);
2567 			writel(creg_val, phba->HCregaddr);
2568 			readl(phba->HCregaddr); /* flush */
2569 
2570 			lpfc_poll_start_timer(phba);
2571 		}
2572 	} else if (val != 0x0) {
2573 		spin_unlock_irq(&phba->hbalock);
2574 		return -EINVAL;
2575 	}
2576 
2577 	if (!(val & DISABLE_FCP_RING_INT) &&
2578 	    (old_val & DISABLE_FCP_RING_INT))
2579 	{
2580 		spin_unlock_irq(&phba->hbalock);
2581 		del_timer(&phba->fcp_poll_timer);
2582 		spin_lock_irq(&phba->hbalock);
2583 		if (lpfc_readl(phba->HCregaddr, &creg_val)) {
2584 			spin_unlock_irq(&phba->hbalock);
2585 			return -EINVAL;
2586 		}
2587 		creg_val |= (HC_R0INT_ENA << LPFC_FCP_RING);
2588 		writel(creg_val, phba->HCregaddr);
2589 		readl(phba->HCregaddr); /* flush */
2590 	}
2591 
2592 	phba->cfg_poll = val;
2593 
2594 	spin_unlock_irq(&phba->hbalock);
2595 
2596 	return strlen(buf);
2597 }
2598 
2599 /**
2600  * lpfc_sriov_hw_max_virtfn_show - Return maximum number of virtual functions
2601  * @dev: class converted to a Scsi_host structure.
2602  * @attr: device attribute, not used.
2603  * @buf: on return contains the formatted support level.
2604  *
2605  * Description:
2606  * Returns the maximum number of virtual functions a physical function can
2607  * support, 0 will be returned if called on virtual function.
2608  *
2609  * Returns: size of formatted string.
2610  **/
2611 static ssize_t
lpfc_sriov_hw_max_virtfn_show(struct device * dev,struct device_attribute * attr,char * buf)2612 lpfc_sriov_hw_max_virtfn_show(struct device *dev,
2613 			      struct device_attribute *attr,
2614 			      char *buf)
2615 {
2616 	struct Scsi_Host *shost = class_to_shost(dev);
2617 	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2618 	struct lpfc_hba *phba = vport->phba;
2619 	uint16_t max_nr_virtfn;
2620 
2621 	max_nr_virtfn = lpfc_sli_sriov_nr_virtfn_get(phba);
2622 	return scnprintf(buf, PAGE_SIZE, "%d\n", max_nr_virtfn);
2623 }
2624 
2625 /**
2626  * lpfc_enable_bbcr_set: Sets an attribute value.
2627  * @phba: pointer to the adapter structure.
2628  * @val: integer attribute value.
2629  *
2630  * Description:
2631  * Validates the min and max values then sets the
2632  * adapter config field if in the valid range. prints error message
2633  * and does not set the parameter if invalid.
2634  *
2635  * Returns:
2636  * zero on success
2637  * -EINVAL if val is invalid
2638  */
2639 static ssize_t
lpfc_enable_bbcr_set(struct lpfc_hba * phba,uint val)2640 lpfc_enable_bbcr_set(struct lpfc_hba *phba, uint val)
2641 {
2642 	if (lpfc_rangecheck(val, 0, 1) && phba->sli_rev == LPFC_SLI_REV4) {
2643 		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2644 				"3068 lpfc_enable_bbcr changed from %d to "
2645 				"%d\n", phba->cfg_enable_bbcr, val);
2646 		phba->cfg_enable_bbcr = val;
2647 		return 0;
2648 	}
2649 	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2650 			"0451 lpfc_enable_bbcr cannot set to %d, range is 0, "
2651 			"1\n", val);
2652 	return -EINVAL;
2653 }
2654 
2655 /*
2656  * lpfc_param_show - Return a cfg attribute value in decimal
2657  *
2658  * Description:
2659  * Macro that given an attr e.g. hba_queue_depth expands
2660  * into a function with the name lpfc_hba_queue_depth_show.
2661  *
2662  * lpfc_##attr##_show: Return the decimal value of an adapters cfg_xxx field.
2663  * @dev: class device that is converted into a Scsi_host.
2664  * @attr: device attribute, not used.
2665  * @buf: on return contains the attribute value in decimal.
2666  *
2667  * Returns: size of formatted string.
2668  **/
2669 #define lpfc_param_show(attr)	\
2670 static ssize_t \
2671 lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \
2672 		   char *buf) \
2673 { \
2674 	struct Scsi_Host  *shost = class_to_shost(dev);\
2675 	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
2676 	struct lpfc_hba   *phba = vport->phba;\
2677 	return scnprintf(buf, PAGE_SIZE, "%d\n",\
2678 			phba->cfg_##attr);\
2679 }
2680 
2681 /*
2682  * lpfc_param_hex_show - Return a cfg attribute value in hex
2683  *
2684  * Description:
2685  * Macro that given an attr e.g. hba_queue_depth expands
2686  * into a function with the name lpfc_hba_queue_depth_show
2687  *
2688  * lpfc_##attr##_show: Return the hex value of an adapters cfg_xxx field.
2689  * @dev: class device that is converted into a Scsi_host.
2690  * @attr: device attribute, not used.
2691  * @buf: on return contains the attribute value in hexadecimal.
2692  *
2693  * Returns: size of formatted string.
2694  **/
2695 #define lpfc_param_hex_show(attr)	\
2696 static ssize_t \
2697 lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \
2698 		   char *buf) \
2699 { \
2700 	struct Scsi_Host  *shost = class_to_shost(dev);\
2701 	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
2702 	struct lpfc_hba   *phba = vport->phba;\
2703 	uint val = 0;\
2704 	val = phba->cfg_##attr;\
2705 	return scnprintf(buf, PAGE_SIZE, "%#x\n",\
2706 			phba->cfg_##attr);\
2707 }
2708 
2709 /*
2710  * lpfc_param_init - Initializes a cfg attribute
2711  *
2712  * Description:
2713  * Macro that given an attr e.g. hba_queue_depth expands
2714  * into a function with the name lpfc_hba_queue_depth_init. The macro also
2715  * takes a default argument, a minimum and maximum argument.
2716  *
2717  * lpfc_##attr##_init: Initializes an attribute.
2718  * @phba: pointer to the adapter structure.
2719  * @val: integer attribute value.
2720  *
2721  * Validates the min and max values then sets the adapter config field
2722  * accordingly, or uses the default if out of range and prints an error message.
2723  *
2724  * Returns:
2725  * zero on success
2726  * -EINVAL if default used
2727  **/
2728 #define lpfc_param_init(attr, default, minval, maxval)	\
2729 static int \
2730 lpfc_##attr##_init(struct lpfc_hba *phba, uint val) \
2731 { \
2732 	if (lpfc_rangecheck(val, minval, maxval)) {\
2733 		phba->cfg_##attr = val;\
2734 		return 0;\
2735 	}\
2736 	lpfc_printf_log(phba, KERN_ERR, LOG_INIT, \
2737 			"0449 lpfc_"#attr" attribute cannot be set to %d, "\
2738 			"allowed range is ["#minval", "#maxval"]\n", val); \
2739 	phba->cfg_##attr = default;\
2740 	return -EINVAL;\
2741 }
2742 
2743 /*
2744  * lpfc_param_set - Set a cfg attribute value
2745  *
2746  * Description:
2747  * Macro that given an attr e.g. hba_queue_depth expands
2748  * into a function with the name lpfc_hba_queue_depth_set
2749  *
2750  * lpfc_##attr##_set: Sets an attribute value.
2751  * @phba: pointer to the adapter structure.
2752  * @val: integer attribute value.
2753  *
2754  * Description:
2755  * Validates the min and max values then sets the
2756  * adapter config field if in the valid range. prints error message
2757  * and does not set the parameter if invalid.
2758  *
2759  * Returns:
2760  * zero on success
2761  * -EINVAL if val is invalid
2762  **/
2763 #define lpfc_param_set(attr, default, minval, maxval)	\
2764 static int \
2765 lpfc_##attr##_set(struct lpfc_hba *phba, uint val) \
2766 { \
2767 	if (lpfc_rangecheck(val, minval, maxval)) {\
2768 		lpfc_printf_log(phba, KERN_ERR, LOG_INIT, \
2769 			"3052 lpfc_" #attr " changed from %d to %d\n", \
2770 			phba->cfg_##attr, val); \
2771 		phba->cfg_##attr = val;\
2772 		return 0;\
2773 	}\
2774 	lpfc_printf_log(phba, KERN_ERR, LOG_INIT, \
2775 			"0450 lpfc_"#attr" attribute cannot be set to %d, "\
2776 			"allowed range is ["#minval", "#maxval"]\n", val); \
2777 	return -EINVAL;\
2778 }
2779 
2780 /*
2781  * lpfc_param_store - Set a vport attribute value
2782  *
2783  * Description:
2784  * Macro that given an attr e.g. hba_queue_depth expands
2785  * into a function with the name lpfc_hba_queue_depth_store.
2786  *
2787  * lpfc_##attr##_store: Set an sttribute value.
2788  * @dev: class device that is converted into a Scsi_host.
2789  * @attr: device attribute, not used.
2790  * @buf: contains the attribute value in ascii.
2791  * @count: not used.
2792  *
2793  * Description:
2794  * Convert the ascii text number to an integer, then
2795  * use the lpfc_##attr##_set function to set the value.
2796  *
2797  * Returns:
2798  * -EINVAL if val is invalid or lpfc_##attr##_set() fails
2799  * length of buffer upon success.
2800  **/
2801 #define lpfc_param_store(attr)	\
2802 static ssize_t \
2803 lpfc_##attr##_store(struct device *dev, struct device_attribute *attr, \
2804 		    const char *buf, size_t count) \
2805 { \
2806 	struct Scsi_Host  *shost = class_to_shost(dev);\
2807 	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
2808 	struct lpfc_hba   *phba = vport->phba;\
2809 	uint val = 0;\
2810 	if (!isdigit(buf[0]))\
2811 		return -EINVAL;\
2812 	if (sscanf(buf, "%i", &val) != 1)\
2813 		return -EINVAL;\
2814 	if (lpfc_##attr##_set(phba, val) == 0) \
2815 		return strlen(buf);\
2816 	else \
2817 		return -EINVAL;\
2818 }
2819 
2820 /*
2821  * lpfc_vport_param_show - Return decimal formatted cfg attribute value
2822  *
2823  * Description:
2824  * Macro that given an attr e.g. hba_queue_depth expands
2825  * into a function with the name lpfc_hba_queue_depth_show
2826  *
2827  * lpfc_##attr##_show: prints the attribute value in decimal.
2828  * @dev: class device that is converted into a Scsi_host.
2829  * @attr: device attribute, not used.
2830  * @buf: on return contains the attribute value in decimal.
2831  *
2832  * Returns: length of formatted string.
2833  **/
2834 #define lpfc_vport_param_show(attr)	\
2835 static ssize_t \
2836 lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \
2837 		   char *buf) \
2838 { \
2839 	struct Scsi_Host  *shost = class_to_shost(dev);\
2840 	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
2841 	return scnprintf(buf, PAGE_SIZE, "%d\n", vport->cfg_##attr);\
2842 }
2843 
2844 /*
2845  * lpfc_vport_param_hex_show - Return hex formatted attribute value
2846  *
2847  * Description:
2848  * Macro that given an attr e.g.
2849  * hba_queue_depth expands into a function with the name
2850  * lpfc_hba_queue_depth_show
2851  *
2852  * lpfc_##attr##_show: prints the attribute value in hexadecimal.
2853  * @dev: class device that is converted into a Scsi_host.
2854  * @attr: device attribute, not used.
2855  * @buf: on return contains the attribute value in hexadecimal.
2856  *
2857  * Returns: length of formatted string.
2858  **/
2859 #define lpfc_vport_param_hex_show(attr)	\
2860 static ssize_t \
2861 lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \
2862 		   char *buf) \
2863 { \
2864 	struct Scsi_Host  *shost = class_to_shost(dev);\
2865 	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
2866 	return scnprintf(buf, PAGE_SIZE, "%#x\n", vport->cfg_##attr);\
2867 }
2868 
2869 /*
2870  * lpfc_vport_param_init - Initialize a vport cfg attribute
2871  *
2872  * Description:
2873  * Macro that given an attr e.g. hba_queue_depth expands
2874  * into a function with the name lpfc_hba_queue_depth_init. The macro also
2875  * takes a default argument, a minimum and maximum argument.
2876  *
2877  * lpfc_##attr##_init: validates the min and max values then sets the
2878  * adapter config field accordingly, or uses the default if out of range
2879  * and prints an error message.
2880  * @phba: pointer to the adapter structure.
2881  * @val: integer attribute value.
2882  *
2883  * Returns:
2884  * zero on success
2885  * -EINVAL if default used
2886  **/
2887 #define lpfc_vport_param_init(attr, default, minval, maxval)	\
2888 static int \
2889 lpfc_##attr##_init(struct lpfc_vport *vport, uint val) \
2890 { \
2891 	if (lpfc_rangecheck(val, minval, maxval)) {\
2892 		vport->cfg_##attr = val;\
2893 		return 0;\
2894 	}\
2895 	lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, \
2896 			 "0423 lpfc_"#attr" attribute cannot be set to %d, "\
2897 			 "allowed range is ["#minval", "#maxval"]\n", val); \
2898 	vport->cfg_##attr = default;\
2899 	return -EINVAL;\
2900 }
2901 
2902 /*
2903  * lpfc_vport_param_set - Set a vport cfg attribute
2904  *
2905  * Description:
2906  * Macro that given an attr e.g. hba_queue_depth expands
2907  * into a function with the name lpfc_hba_queue_depth_set
2908  *
2909  * lpfc_##attr##_set: validates the min and max values then sets the
2910  * adapter config field if in the valid range. prints error message
2911  * and does not set the parameter if invalid.
2912  * @phba: pointer to the adapter structure.
2913  * @val:	integer attribute value.
2914  *
2915  * Returns:
2916  * zero on success
2917  * -EINVAL if val is invalid
2918  **/
2919 #define lpfc_vport_param_set(attr, default, minval, maxval)	\
2920 static int \
2921 lpfc_##attr##_set(struct lpfc_vport *vport, uint val) \
2922 { \
2923 	if (lpfc_rangecheck(val, minval, maxval)) {\
2924 		lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, \
2925 			"3053 lpfc_" #attr \
2926 			" changed from %d (x%x) to %d (x%x)\n", \
2927 			vport->cfg_##attr, vport->cfg_##attr, \
2928 			val, val); \
2929 		vport->cfg_##attr = val;\
2930 		return 0;\
2931 	}\
2932 	lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, \
2933 			 "0424 lpfc_"#attr" attribute cannot be set to %d, "\
2934 			 "allowed range is ["#minval", "#maxval"]\n", val); \
2935 	return -EINVAL;\
2936 }
2937 
2938 /*
2939  * lpfc_vport_param_store - Set a vport attribute
2940  *
2941  * Description:
2942  * Macro that given an attr e.g. hba_queue_depth
2943  * expands into a function with the name lpfc_hba_queue_depth_store
2944  *
2945  * lpfc_##attr##_store: convert the ascii text number to an integer, then
2946  * use the lpfc_##attr##_set function to set the value.
2947  * @cdev: class device that is converted into a Scsi_host.
2948  * @buf:	contains the attribute value in decimal.
2949  * @count: not used.
2950  *
2951  * Returns:
2952  * -EINVAL if val is invalid or lpfc_##attr##_set() fails
2953  * length of buffer upon success.
2954  **/
2955 #define lpfc_vport_param_store(attr)	\
2956 static ssize_t \
2957 lpfc_##attr##_store(struct device *dev, struct device_attribute *attr, \
2958 		    const char *buf, size_t count) \
2959 { \
2960 	struct Scsi_Host  *shost = class_to_shost(dev);\
2961 	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
2962 	uint val = 0;\
2963 	if (!isdigit(buf[0]))\
2964 		return -EINVAL;\
2965 	if (sscanf(buf, "%i", &val) != 1)\
2966 		return -EINVAL;\
2967 	if (lpfc_##attr##_set(vport, val) == 0) \
2968 		return strlen(buf);\
2969 	else \
2970 		return -EINVAL;\
2971 }
2972 
2973 
2974 static DEVICE_ATTR(nvme_info, 0444, lpfc_nvme_info_show, NULL);
2975 static DEVICE_ATTR(scsi_stat, 0444, lpfc_scsi_stat_show, NULL);
2976 static DEVICE_ATTR(bg_info, S_IRUGO, lpfc_bg_info_show, NULL);
2977 static DEVICE_ATTR(bg_guard_err, S_IRUGO, lpfc_bg_guard_err_show, NULL);
2978 static DEVICE_ATTR(bg_apptag_err, S_IRUGO, lpfc_bg_apptag_err_show, NULL);
2979 static DEVICE_ATTR(bg_reftag_err, S_IRUGO, lpfc_bg_reftag_err_show, NULL);
2980 static DEVICE_ATTR(info, S_IRUGO, lpfc_info_show, NULL);
2981 static DEVICE_ATTR(serialnum, S_IRUGO, lpfc_serialnum_show, NULL);
2982 static DEVICE_ATTR(modeldesc, S_IRUGO, lpfc_modeldesc_show, NULL);
2983 static DEVICE_ATTR(modelname, S_IRUGO, lpfc_modelname_show, NULL);
2984 static DEVICE_ATTR(programtype, S_IRUGO, lpfc_programtype_show, NULL);
2985 static DEVICE_ATTR(portnum, S_IRUGO, lpfc_vportnum_show, NULL);
2986 static DEVICE_ATTR(fwrev, S_IRUGO, lpfc_fwrev_show, NULL);
2987 static DEVICE_ATTR(hdw, S_IRUGO, lpfc_hdw_show, NULL);
2988 static DEVICE_ATTR(link_state, S_IRUGO | S_IWUSR, lpfc_link_state_show,
2989 		lpfc_link_state_store);
2990 static DEVICE_ATTR(option_rom_version, S_IRUGO,
2991 		   lpfc_option_rom_version_show, NULL);
2992 static DEVICE_ATTR(num_discovered_ports, S_IRUGO,
2993 		   lpfc_num_discovered_ports_show, NULL);
2994 static DEVICE_ATTR(nport_evt_cnt, S_IRUGO, lpfc_nport_evt_cnt_show, NULL);
2995 static DEVICE_ATTR_RO(lpfc_drvr_version);
2996 static DEVICE_ATTR_RO(lpfc_enable_fip);
2997 static DEVICE_ATTR(board_mode, S_IRUGO | S_IWUSR,
2998 		   lpfc_board_mode_show, lpfc_board_mode_store);
2999 static DEVICE_ATTR_RO(lpfc_xcvr_data);
3000 static DEVICE_ATTR(issue_reset, S_IWUSR, NULL, lpfc_issue_reset);
3001 static DEVICE_ATTR(max_vpi, S_IRUGO, lpfc_max_vpi_show, NULL);
3002 static DEVICE_ATTR(used_vpi, S_IRUGO, lpfc_used_vpi_show, NULL);
3003 static DEVICE_ATTR(max_rpi, S_IRUGO, lpfc_max_rpi_show, NULL);
3004 static DEVICE_ATTR(used_rpi, S_IRUGO, lpfc_used_rpi_show, NULL);
3005 static DEVICE_ATTR(max_xri, S_IRUGO, lpfc_max_xri_show, NULL);
3006 static DEVICE_ATTR(used_xri, S_IRUGO, lpfc_used_xri_show, NULL);
3007 static DEVICE_ATTR(npiv_info, S_IRUGO, lpfc_npiv_info_show, NULL);
3008 static DEVICE_ATTR_RO(lpfc_temp_sensor);
3009 static DEVICE_ATTR_RO(lpfc_sriov_hw_max_virtfn);
3010 static DEVICE_ATTR(protocol, S_IRUGO, lpfc_sli4_protocol_show, NULL);
3011 static DEVICE_ATTR(lpfc_xlane_supported, S_IRUGO, lpfc_oas_supported_show,
3012 		   NULL);
3013 static DEVICE_ATTR(cmf_info, 0444, lpfc_cmf_info_show, NULL);
3014 
3015 #define WWN_SZ 8
3016 /**
3017  * lpfc_wwn_set - Convert string to the 8 byte WWN value.
3018  * @buf: WWN string.
3019  * @cnt: Length of string.
3020  * @wwn: Array to receive converted wwn value.
3021  *
3022  * Returns:
3023  * -EINVAL if the buffer does not contain a valid wwn
3024  * 0 success
3025  **/
3026 static size_t
lpfc_wwn_set(const char * buf,size_t cnt,char wwn[])3027 lpfc_wwn_set(const char *buf, size_t cnt, char wwn[])
3028 {
3029 	unsigned int i, j;
3030 
3031 	/* Count may include a LF at end of string */
3032 	if (buf[cnt-1] == '\n')
3033 		cnt--;
3034 
3035 	if ((cnt < 16) || (cnt > 18) || ((cnt == 17) && (*buf++ != 'x')) ||
3036 	    ((cnt == 18) && ((*buf++ != '0') || (*buf++ != 'x'))))
3037 		return -EINVAL;
3038 
3039 	memset(wwn, 0, WWN_SZ);
3040 
3041 	/* Validate and store the new name */
3042 	for (i = 0, j = 0; i < 16; i++) {
3043 		if ((*buf >= 'a') && (*buf <= 'f'))
3044 			j = ((j << 4) | ((*buf++ - 'a') + 10));
3045 		else if ((*buf >= 'A') && (*buf <= 'F'))
3046 			j = ((j << 4) | ((*buf++ - 'A') + 10));
3047 		else if ((*buf >= '0') && (*buf <= '9'))
3048 			j = ((j << 4) | (*buf++ - '0'));
3049 		else
3050 			return -EINVAL;
3051 		if (i % 2) {
3052 			wwn[i/2] = j & 0xff;
3053 			j = 0;
3054 		}
3055 	}
3056 	return 0;
3057 }
3058 
3059 
3060 /**
3061  * lpfc_oas_tgt_show - Return wwpn of target whose luns maybe enabled for
3062  *		      Optimized Access Storage (OAS) operations.
3063  * @dev: class device that is converted into a Scsi_host.
3064  * @attr: device attribute, not used.
3065  * @buf: buffer for passing information.
3066  *
3067  * Returns:
3068  * value of count
3069  **/
3070 static ssize_t
lpfc_oas_tgt_show(struct device * dev,struct device_attribute * attr,char * buf)3071 lpfc_oas_tgt_show(struct device *dev, struct device_attribute *attr,
3072 		  char *buf)
3073 {
3074 	struct Scsi_Host *shost = class_to_shost(dev);
3075 	struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
3076 
3077 	return scnprintf(buf, PAGE_SIZE, "0x%llx\n",
3078 			wwn_to_u64(phba->cfg_oas_tgt_wwpn));
3079 }
3080 
3081 /**
3082  * lpfc_oas_tgt_store - Store wwpn of target whose luns maybe enabled for
3083  *		      Optimized Access Storage (OAS) operations.
3084  * @dev: class device that is converted into a Scsi_host.
3085  * @attr: device attribute, not used.
3086  * @buf: buffer for passing information.
3087  * @count: Size of the data buffer.
3088  *
3089  * Returns:
3090  * -EINVAL count is invalid, invalid wwpn byte invalid
3091  * -EPERM oas is not supported by hba
3092  * value of count on success
3093  **/
3094 static ssize_t
lpfc_oas_tgt_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)3095 lpfc_oas_tgt_store(struct device *dev, struct device_attribute *attr,
3096 		   const char *buf, size_t count)
3097 {
3098 	struct Scsi_Host *shost = class_to_shost(dev);
3099 	struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
3100 	unsigned int cnt = count;
3101 	uint8_t wwpn[WWN_SZ];
3102 	int rc;
3103 
3104 	if (!phba->cfg_fof)
3105 		return -EPERM;
3106 
3107 	/* count may include a LF at end of string */
3108 	if (buf[cnt-1] == '\n')
3109 		cnt--;
3110 
3111 	rc = lpfc_wwn_set(buf, cnt, wwpn);
3112 	if (rc)
3113 		return rc;
3114 
3115 	memcpy(phba->cfg_oas_tgt_wwpn, wwpn, (8 * sizeof(uint8_t)));
3116 	memcpy(phba->sli4_hba.oas_next_tgt_wwpn, wwpn, (8 * sizeof(uint8_t)));
3117 	if (wwn_to_u64(wwpn) == 0)
3118 		phba->cfg_oas_flags |= OAS_FIND_ANY_TARGET;
3119 	else
3120 		phba->cfg_oas_flags &= ~OAS_FIND_ANY_TARGET;
3121 	phba->cfg_oas_flags &= ~OAS_LUN_VALID;
3122 	phba->sli4_hba.oas_next_lun = FIND_FIRST_OAS_LUN;
3123 	return count;
3124 }
3125 static DEVICE_ATTR(lpfc_xlane_tgt, S_IRUGO | S_IWUSR,
3126 		   lpfc_oas_tgt_show, lpfc_oas_tgt_store);
3127 
3128 /**
3129  * lpfc_oas_priority_show - Return wwpn of target whose luns maybe enabled for
3130  *		      Optimized Access Storage (OAS) operations.
3131  * @dev: class device that is converted into a Scsi_host.
3132  * @attr: device attribute, not used.
3133  * @buf: buffer for passing information.
3134  *
3135  * Returns:
3136  * value of count
3137  **/
3138 static ssize_t
lpfc_oas_priority_show(struct device * dev,struct device_attribute * attr,char * buf)3139 lpfc_oas_priority_show(struct device *dev, struct device_attribute *attr,
3140 		       char *buf)
3141 {
3142 	struct Scsi_Host *shost = class_to_shost(dev);
3143 	struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
3144 
3145 	return scnprintf(buf, PAGE_SIZE, "%d\n", phba->cfg_oas_priority);
3146 }
3147 
3148 /**
3149  * lpfc_oas_priority_store - Store wwpn of target whose luns maybe enabled for
3150  *		      Optimized Access Storage (OAS) operations.
3151  * @dev: class device that is converted into a Scsi_host.
3152  * @attr: device attribute, not used.
3153  * @buf: buffer for passing information.
3154  * @count: Size of the data buffer.
3155  *
3156  * Returns:
3157  * -EINVAL count is invalid, invalid wwpn byte invalid
3158  * -EPERM oas is not supported by hba
3159  * value of count on success
3160  **/
3161 static ssize_t
lpfc_oas_priority_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)3162 lpfc_oas_priority_store(struct device *dev, struct device_attribute *attr,
3163 			const char *buf, size_t count)
3164 {
3165 	struct Scsi_Host *shost = class_to_shost(dev);
3166 	struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
3167 	unsigned int cnt = count;
3168 	unsigned long val;
3169 	int ret;
3170 
3171 	if (!phba->cfg_fof)
3172 		return -EPERM;
3173 
3174 	/* count may include a LF at end of string */
3175 	if (buf[cnt-1] == '\n')
3176 		cnt--;
3177 
3178 	ret = kstrtoul(buf, 0, &val);
3179 	if (ret || (val > 0x7f))
3180 		return -EINVAL;
3181 
3182 	if (val)
3183 		phba->cfg_oas_priority = (uint8_t)val;
3184 	else
3185 		phba->cfg_oas_priority = phba->cfg_XLanePriority;
3186 	return count;
3187 }
3188 static DEVICE_ATTR(lpfc_xlane_priority, S_IRUGO | S_IWUSR,
3189 		   lpfc_oas_priority_show, lpfc_oas_priority_store);
3190 
3191 /**
3192  * lpfc_oas_vpt_show - Return wwpn of vport whose targets maybe enabled
3193  *		      for Optimized Access Storage (OAS) operations.
3194  * @dev: class device that is converted into a Scsi_host.
3195  * @attr: device attribute, not used.
3196  * @buf: buffer for passing information.
3197  *
3198  * Returns:
3199  * value of count on success
3200  **/
3201 static ssize_t
lpfc_oas_vpt_show(struct device * dev,struct device_attribute * attr,char * buf)3202 lpfc_oas_vpt_show(struct device *dev, struct device_attribute *attr,
3203 		  char *buf)
3204 {
3205 	struct Scsi_Host *shost = class_to_shost(dev);
3206 	struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
3207 
3208 	return scnprintf(buf, PAGE_SIZE, "0x%llx\n",
3209 			wwn_to_u64(phba->cfg_oas_vpt_wwpn));
3210 }
3211 
3212 /**
3213  * lpfc_oas_vpt_store - Store wwpn of vport whose targets maybe enabled
3214  *		      for Optimized Access Storage (OAS) operations.
3215  * @dev: class device that is converted into a Scsi_host.
3216  * @attr: device attribute, not used.
3217  * @buf: buffer for passing information.
3218  * @count: Size of the data buffer.
3219  *
3220  * Returns:
3221  * -EINVAL count is invalid, invalid wwpn byte invalid
3222  * -EPERM oas is not supported by hba
3223  * value of count on success
3224  **/
3225 static ssize_t
lpfc_oas_vpt_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)3226 lpfc_oas_vpt_store(struct device *dev, struct device_attribute *attr,
3227 		   const char *buf, size_t count)
3228 {
3229 	struct Scsi_Host *shost = class_to_shost(dev);
3230 	struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
3231 	unsigned int cnt = count;
3232 	uint8_t wwpn[WWN_SZ];
3233 	int rc;
3234 
3235 	if (!phba->cfg_fof)
3236 		return -EPERM;
3237 
3238 	/* count may include a LF at end of string */
3239 	if (buf[cnt-1] == '\n')
3240 		cnt--;
3241 
3242 	rc = lpfc_wwn_set(buf, cnt, wwpn);
3243 	if (rc)
3244 		return rc;
3245 
3246 	memcpy(phba->cfg_oas_vpt_wwpn, wwpn, (8 * sizeof(uint8_t)));
3247 	memcpy(phba->sli4_hba.oas_next_vpt_wwpn, wwpn, (8 * sizeof(uint8_t)));
3248 	if (wwn_to_u64(wwpn) == 0)
3249 		phba->cfg_oas_flags |= OAS_FIND_ANY_VPORT;
3250 	else
3251 		phba->cfg_oas_flags &= ~OAS_FIND_ANY_VPORT;
3252 	phba->cfg_oas_flags &= ~OAS_LUN_VALID;
3253 	if (phba->cfg_oas_priority == 0)
3254 		phba->cfg_oas_priority = phba->cfg_XLanePriority;
3255 	phba->sli4_hba.oas_next_lun = FIND_FIRST_OAS_LUN;
3256 	return count;
3257 }
3258 static DEVICE_ATTR(lpfc_xlane_vpt, S_IRUGO | S_IWUSR,
3259 		   lpfc_oas_vpt_show, lpfc_oas_vpt_store);
3260 
3261 /**
3262  * lpfc_oas_lun_state_show - Return the current state (enabled or disabled)
3263  *			    of whether luns will be enabled or disabled
3264  *			    for Optimized Access Storage (OAS) operations.
3265  * @dev: class device that is converted into a Scsi_host.
3266  * @attr: device attribute, not used.
3267  * @buf: buffer for passing information.
3268  *
3269  * Returns:
3270  * size of formatted string.
3271  **/
3272 static ssize_t
lpfc_oas_lun_state_show(struct device * dev,struct device_attribute * attr,char * buf)3273 lpfc_oas_lun_state_show(struct device *dev, struct device_attribute *attr,
3274 			char *buf)
3275 {
3276 	struct Scsi_Host *shost = class_to_shost(dev);
3277 	struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
3278 
3279 	return scnprintf(buf, PAGE_SIZE, "%d\n", phba->cfg_oas_lun_state);
3280 }
3281 
3282 /**
3283  * lpfc_oas_lun_state_store - Store the state (enabled or disabled)
3284  *			    of whether luns will be enabled or disabled
3285  *			    for Optimized Access Storage (OAS) operations.
3286  * @dev: class device that is converted into a Scsi_host.
3287  * @attr: device attribute, not used.
3288  * @buf: buffer for passing information.
3289  * @count: Size of the data buffer.
3290  *
3291  * Returns:
3292  * -EINVAL count is invalid, invalid wwpn byte invalid
3293  * -EPERM oas is not supported by hba
3294  * value of count on success
3295  **/
3296 static ssize_t
lpfc_oas_lun_state_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)3297 lpfc_oas_lun_state_store(struct device *dev, struct device_attribute *attr,
3298 			 const char *buf, size_t count)
3299 {
3300 	struct Scsi_Host *shost = class_to_shost(dev);
3301 	struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
3302 	int val = 0;
3303 
3304 	if (!phba->cfg_fof)
3305 		return -EPERM;
3306 
3307 	if (!isdigit(buf[0]))
3308 		return -EINVAL;
3309 
3310 	if (sscanf(buf, "%i", &val) != 1)
3311 		return -EINVAL;
3312 
3313 	if ((val != 0) && (val != 1))
3314 		return -EINVAL;
3315 
3316 	phba->cfg_oas_lun_state = val;
3317 	return strlen(buf);
3318 }
3319 static DEVICE_ATTR(lpfc_xlane_lun_state, S_IRUGO | S_IWUSR,
3320 		   lpfc_oas_lun_state_show, lpfc_oas_lun_state_store);
3321 
3322 /**
3323  * lpfc_oas_lun_status_show - Return the status of the Optimized Access
3324  *                          Storage (OAS) lun returned by the
3325  *                          lpfc_oas_lun_show function.
3326  * @dev: class device that is converted into a Scsi_host.
3327  * @attr: device attribute, not used.
3328  * @buf: buffer for passing information.
3329  *
3330  * Returns:
3331  * size of formatted string.
3332  **/
3333 static ssize_t
lpfc_oas_lun_status_show(struct device * dev,struct device_attribute * attr,char * buf)3334 lpfc_oas_lun_status_show(struct device *dev, struct device_attribute *attr,
3335 			 char *buf)
3336 {
3337 	struct Scsi_Host *shost = class_to_shost(dev);
3338 	struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
3339 
3340 	if (!(phba->cfg_oas_flags & OAS_LUN_VALID))
3341 		return -EFAULT;
3342 
3343 	return scnprintf(buf, PAGE_SIZE, "%d\n", phba->cfg_oas_lun_status);
3344 }
3345 static DEVICE_ATTR(lpfc_xlane_lun_status, S_IRUGO,
3346 		   lpfc_oas_lun_status_show, NULL);
3347 
3348 
3349 /**
3350  * lpfc_oas_lun_state_set - enable or disable a lun for Optimized Access Storage
3351  *			   (OAS) operations.
3352  * @phba: lpfc_hba pointer.
3353  * @vpt_wwpn: wwpn of the vport associated with the returned lun
3354  * @tgt_wwpn: wwpn of the target associated with the returned lun
3355  * @lun: the fc lun for setting oas state.
3356  * @oas_state: the oas state to be set to the lun.
3357  * @pri: priority
3358  *
3359  * Returns:
3360  * SUCCESS : 0
3361  * -EPERM OAS is not enabled or not supported by this port.
3362  *
3363  */
3364 static size_t
lpfc_oas_lun_state_set(struct lpfc_hba * phba,uint8_t vpt_wwpn[],uint8_t tgt_wwpn[],uint64_t lun,uint32_t oas_state,uint8_t pri)3365 lpfc_oas_lun_state_set(struct lpfc_hba *phba, uint8_t vpt_wwpn[],
3366 		       uint8_t tgt_wwpn[], uint64_t lun,
3367 		       uint32_t oas_state, uint8_t pri)
3368 {
3369 
3370 	int rc = 0;
3371 
3372 	if (!phba->cfg_fof)
3373 		return -EPERM;
3374 
3375 	if (oas_state) {
3376 		if (!lpfc_enable_oas_lun(phba, (struct lpfc_name *)vpt_wwpn,
3377 					 (struct lpfc_name *)tgt_wwpn,
3378 					 lun, pri))
3379 			rc = -ENOMEM;
3380 	} else {
3381 		lpfc_disable_oas_lun(phba, (struct lpfc_name *)vpt_wwpn,
3382 				     (struct lpfc_name *)tgt_wwpn, lun, pri);
3383 	}
3384 	return rc;
3385 
3386 }
3387 
3388 /**
3389  * lpfc_oas_lun_get_next - get the next lun that has been enabled for Optimized
3390  *			  Access Storage (OAS) operations.
3391  * @phba: lpfc_hba pointer.
3392  * @vpt_wwpn: wwpn of the vport associated with the returned lun
3393  * @tgt_wwpn: wwpn of the target associated with the returned lun
3394  * @lun_status: status of the lun returned lun
3395  * @lun_pri: priority of the lun returned lun
3396  *
3397  * Returns the first or next lun enabled for OAS operations for the vport/target
3398  * specified.  If a lun is found, its vport wwpn, target wwpn and status is
3399  * returned.  If the lun is not found, NOT_OAS_ENABLED_LUN is returned.
3400  *
3401  * Return:
3402  * lun that is OAS enabled for the vport/target
3403  * NOT_OAS_ENABLED_LUN when no oas enabled lun found.
3404  */
3405 static uint64_t
lpfc_oas_lun_get_next(struct lpfc_hba * phba,uint8_t vpt_wwpn[],uint8_t tgt_wwpn[],uint32_t * lun_status,uint32_t * lun_pri)3406 lpfc_oas_lun_get_next(struct lpfc_hba *phba, uint8_t vpt_wwpn[],
3407 		      uint8_t tgt_wwpn[], uint32_t *lun_status,
3408 		      uint32_t *lun_pri)
3409 {
3410 	uint64_t found_lun;
3411 
3412 	if (unlikely(!phba) || !vpt_wwpn || !tgt_wwpn)
3413 		return NOT_OAS_ENABLED_LUN;
3414 	if (lpfc_find_next_oas_lun(phba, (struct lpfc_name *)
3415 				   phba->sli4_hba.oas_next_vpt_wwpn,
3416 				   (struct lpfc_name *)
3417 				   phba->sli4_hba.oas_next_tgt_wwpn,
3418 				   &phba->sli4_hba.oas_next_lun,
3419 				   (struct lpfc_name *)vpt_wwpn,
3420 				   (struct lpfc_name *)tgt_wwpn,
3421 				   &found_lun, lun_status, lun_pri))
3422 		return found_lun;
3423 	else
3424 		return NOT_OAS_ENABLED_LUN;
3425 }
3426 
3427 /**
3428  * lpfc_oas_lun_state_change - enable/disable a lun for OAS operations
3429  * @phba: lpfc_hba pointer.
3430  * @vpt_wwpn: vport wwpn by reference.
3431  * @tgt_wwpn: target wwpn by reference.
3432  * @lun: the fc lun for setting oas state.
3433  * @oas_state: the oas state to be set to the oas_lun.
3434  * @pri: priority
3435  *
3436  * This routine enables (OAS_LUN_ENABLE) or disables (OAS_LUN_DISABLE)
3437  * a lun for OAS operations.
3438  *
3439  * Return:
3440  * SUCCESS: 0
3441  * -ENOMEM: failed to enable an lun for OAS operations
3442  * -EPERM: OAS is not enabled
3443  */
3444 static ssize_t
lpfc_oas_lun_state_change(struct lpfc_hba * phba,uint8_t vpt_wwpn[],uint8_t tgt_wwpn[],uint64_t lun,uint32_t oas_state,uint8_t pri)3445 lpfc_oas_lun_state_change(struct lpfc_hba *phba, uint8_t vpt_wwpn[],
3446 			  uint8_t tgt_wwpn[], uint64_t lun,
3447 			  uint32_t oas_state, uint8_t pri)
3448 {
3449 
3450 	int rc;
3451 
3452 	rc = lpfc_oas_lun_state_set(phba, vpt_wwpn, tgt_wwpn, lun,
3453 				    oas_state, pri);
3454 	return rc;
3455 }
3456 
3457 /**
3458  * lpfc_oas_lun_show - Return oas enabled luns from a chosen target
3459  * @dev: class device that is converted into a Scsi_host.
3460  * @attr: device attribute, not used.
3461  * @buf: buffer for passing information.
3462  *
3463  * This routine returns a lun enabled for OAS each time the function
3464  * is called.
3465  *
3466  * Returns:
3467  * SUCCESS: size of formatted string.
3468  * -EFAULT: target or vport wwpn was not set properly.
3469  * -EPERM: oas is not enabled.
3470  **/
3471 static ssize_t
lpfc_oas_lun_show(struct device * dev,struct device_attribute * attr,char * buf)3472 lpfc_oas_lun_show(struct device *dev, struct device_attribute *attr,
3473 		  char *buf)
3474 {
3475 	struct Scsi_Host *shost = class_to_shost(dev);
3476 	struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
3477 
3478 	uint64_t oas_lun;
3479 	int len = 0;
3480 
3481 	if (!phba->cfg_fof)
3482 		return -EPERM;
3483 
3484 	if (wwn_to_u64(phba->cfg_oas_vpt_wwpn) == 0)
3485 		if (!(phba->cfg_oas_flags & OAS_FIND_ANY_VPORT))
3486 			return -EFAULT;
3487 
3488 	if (wwn_to_u64(phba->cfg_oas_tgt_wwpn) == 0)
3489 		if (!(phba->cfg_oas_flags & OAS_FIND_ANY_TARGET))
3490 			return -EFAULT;
3491 
3492 	oas_lun = lpfc_oas_lun_get_next(phba, phba->cfg_oas_vpt_wwpn,
3493 					phba->cfg_oas_tgt_wwpn,
3494 					&phba->cfg_oas_lun_status,
3495 					&phba->cfg_oas_priority);
3496 	if (oas_lun != NOT_OAS_ENABLED_LUN)
3497 		phba->cfg_oas_flags |= OAS_LUN_VALID;
3498 
3499 	len += scnprintf(buf + len, PAGE_SIZE-len, "0x%llx", oas_lun);
3500 
3501 	return len;
3502 }
3503 
3504 /**
3505  * lpfc_oas_lun_store - Sets the OAS state for lun
3506  * @dev: class device that is converted into a Scsi_host.
3507  * @attr: device attribute, not used.
3508  * @buf: buffer for passing information.
3509  * @count: size of the formatting string
3510  *
3511  * This function sets the OAS state for lun.  Before this function is called,
3512  * the vport wwpn, target wwpn, and oas state need to be set.
3513  *
3514  * Returns:
3515  * SUCCESS: size of formatted string.
3516  * -EFAULT: target or vport wwpn was not set properly.
3517  * -EPERM: oas is not enabled.
3518  * size of formatted string.
3519  **/
3520 static ssize_t
lpfc_oas_lun_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)3521 lpfc_oas_lun_store(struct device *dev, struct device_attribute *attr,
3522 		   const char *buf, size_t count)
3523 {
3524 	struct Scsi_Host *shost = class_to_shost(dev);
3525 	struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
3526 	uint64_t scsi_lun;
3527 	uint32_t pri;
3528 	ssize_t rc;
3529 
3530 	if (!phba->cfg_fof)
3531 		return -EPERM;
3532 
3533 	if (wwn_to_u64(phba->cfg_oas_vpt_wwpn) == 0)
3534 		return -EFAULT;
3535 
3536 	if (wwn_to_u64(phba->cfg_oas_tgt_wwpn) == 0)
3537 		return -EFAULT;
3538 
3539 	if (!isdigit(buf[0]))
3540 		return -EINVAL;
3541 
3542 	if (sscanf(buf, "0x%llx", &scsi_lun) != 1)
3543 		return -EINVAL;
3544 
3545 	pri = phba->cfg_oas_priority;
3546 	if (pri == 0)
3547 		pri = phba->cfg_XLanePriority;
3548 
3549 	lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
3550 			"3372 Try to set vport 0x%llx target 0x%llx lun:0x%llx "
3551 			"priority 0x%x with oas state %d\n",
3552 			wwn_to_u64(phba->cfg_oas_vpt_wwpn),
3553 			wwn_to_u64(phba->cfg_oas_tgt_wwpn), scsi_lun,
3554 			pri, phba->cfg_oas_lun_state);
3555 
3556 	rc = lpfc_oas_lun_state_change(phba, phba->cfg_oas_vpt_wwpn,
3557 				       phba->cfg_oas_tgt_wwpn, scsi_lun,
3558 				       phba->cfg_oas_lun_state, pri);
3559 	if (rc)
3560 		return rc;
3561 
3562 	return count;
3563 }
3564 static DEVICE_ATTR(lpfc_xlane_lun, S_IRUGO | S_IWUSR,
3565 		   lpfc_oas_lun_show, lpfc_oas_lun_store);
3566 
3567 int lpfc_enable_nvmet_cnt;
3568 unsigned long long lpfc_enable_nvmet[LPFC_NVMET_MAX_PORTS] = {
3569 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3570 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
3571 module_param_array(lpfc_enable_nvmet, ullong, &lpfc_enable_nvmet_cnt, 0444);
3572 MODULE_PARM_DESC(lpfc_enable_nvmet, "Enable HBA port(s) WWPN as a NVME Target");
3573 
3574 static int lpfc_poll = 0;
3575 module_param(lpfc_poll, int, S_IRUGO);
3576 MODULE_PARM_DESC(lpfc_poll, "FCP ring polling mode control:"
3577 		 " 0 - none,"
3578 		 " 1 - poll with interrupts enabled"
3579 		 " 3 - poll and disable FCP ring interrupts");
3580 
3581 static DEVICE_ATTR_RW(lpfc_poll);
3582 
3583 int lpfc_no_hba_reset_cnt;
3584 unsigned long lpfc_no_hba_reset[MAX_HBAS_NO_RESET] = {
3585 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
3586 module_param_array(lpfc_no_hba_reset, ulong, &lpfc_no_hba_reset_cnt, 0444);
3587 MODULE_PARM_DESC(lpfc_no_hba_reset, "WWPN of HBAs that should not be reset");
3588 
3589 LPFC_ATTR(sli_mode, 3, 3, 3,
3590 	"SLI mode selector: 3 - select SLI-3");
3591 
3592 LPFC_ATTR_R(enable_npiv, 1, 0, 1,
3593 	"Enable NPIV functionality");
3594 
3595 LPFC_ATTR_R(fcf_failover_policy, 1, 1, 2,
3596 	"FCF Fast failover=1 Priority failover=2");
3597 
3598 /*
3599  * lpfc_fcp_wait_abts_rsp: Modifies criteria for reporting completion of
3600  * aborted IO.
3601  * The range is [0,1]. Default value is 0
3602  *      0, IO completes after ABTS issued (default).
3603  *      1, IO completes after receipt of ABTS response or timeout.
3604  */
3605 LPFC_ATTR_R(fcp_wait_abts_rsp, 0, 0, 1, "Wait for FCP ABTS completion");
3606 
3607 /*
3608 # lpfc_enable_rrq: Track XRI/OXID reuse after IO failures
3609 #	0x0 = disabled, XRI/OXID use not tracked.
3610 #	0x1 = XRI/OXID reuse is timed with ratov, RRQ sent.
3611 #	0x2 = XRI/OXID reuse is timed with ratov, No RRQ sent.
3612 */
3613 LPFC_ATTR_R(enable_rrq, 2, 0, 2,
3614 	"Enable RRQ functionality");
3615 
3616 /*
3617 # lpfc_suppress_link_up:  Bring link up at initialization
3618 #            0x0  = bring link up (issue MBX_INIT_LINK)
3619 #            0x1  = do NOT bring link up at initialization(MBX_INIT_LINK)
3620 #            0x2  = never bring up link
3621 # Default value is 0.
3622 */
3623 LPFC_ATTR_R(suppress_link_up, LPFC_INITIALIZE_LINK, LPFC_INITIALIZE_LINK,
3624 		LPFC_DELAY_INIT_LINK_INDEFINITELY,
3625 		"Suppress Link Up at initialization");
3626 
3627 static ssize_t
lpfc_pls_show(struct device * dev,struct device_attribute * attr,char * buf)3628 lpfc_pls_show(struct device *dev, struct device_attribute *attr, char *buf)
3629 {
3630 	struct Scsi_Host  *shost = class_to_shost(dev);
3631 	struct lpfc_hba   *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
3632 
3633 	return scnprintf(buf, PAGE_SIZE, "%d\n",
3634 			 phba->sli4_hba.pc_sli4_params.pls);
3635 }
3636 static DEVICE_ATTR(pls, 0444,
3637 			 lpfc_pls_show, NULL);
3638 
3639 static ssize_t
lpfc_pt_show(struct device * dev,struct device_attribute * attr,char * buf)3640 lpfc_pt_show(struct device *dev, struct device_attribute *attr, char *buf)
3641 {
3642 	struct Scsi_Host  *shost = class_to_shost(dev);
3643 	struct lpfc_hba   *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
3644 
3645 	return scnprintf(buf, PAGE_SIZE, "%d\n",
3646 			 test_bit(HBA_PERSISTENT_TOPO,
3647 				  &phba->hba_flag) ? 1 : 0);
3648 }
3649 static DEVICE_ATTR(pt, 0444,
3650 			 lpfc_pt_show, NULL);
3651 
3652 /*
3653 # lpfc_cnt: Number of IOCBs allocated for ELS, CT, and ABTS
3654 #       1 - (1024)
3655 #       2 - (2048)
3656 #       3 - (3072)
3657 #       4 - (4096)
3658 #       5 - (5120)
3659 */
3660 static ssize_t
lpfc_iocb_hw_show(struct device * dev,struct device_attribute * attr,char * buf)3661 lpfc_iocb_hw_show(struct device *dev, struct device_attribute *attr, char *buf)
3662 {
3663 	struct Scsi_Host  *shost = class_to_shost(dev);
3664 	struct lpfc_hba   *phba = ((struct lpfc_vport *) shost->hostdata)->phba;
3665 
3666 	return scnprintf(buf, PAGE_SIZE, "%d\n", phba->iocb_max);
3667 }
3668 
3669 static DEVICE_ATTR(iocb_hw, S_IRUGO,
3670 			 lpfc_iocb_hw_show, NULL);
3671 static ssize_t
lpfc_txq_hw_show(struct device * dev,struct device_attribute * attr,char * buf)3672 lpfc_txq_hw_show(struct device *dev, struct device_attribute *attr, char *buf)
3673 {
3674 	struct Scsi_Host  *shost = class_to_shost(dev);
3675 	struct lpfc_hba   *phba = ((struct lpfc_vport *) shost->hostdata)->phba;
3676 	struct lpfc_sli_ring *pring = lpfc_phba_elsring(phba);
3677 
3678 	return scnprintf(buf, PAGE_SIZE, "%d\n",
3679 			pring ? pring->txq_max : 0);
3680 }
3681 
3682 static DEVICE_ATTR(txq_hw, S_IRUGO,
3683 			 lpfc_txq_hw_show, NULL);
3684 static ssize_t
lpfc_txcmplq_hw_show(struct device * dev,struct device_attribute * attr,char * buf)3685 lpfc_txcmplq_hw_show(struct device *dev, struct device_attribute *attr,
3686  char *buf)
3687 {
3688 	struct Scsi_Host  *shost = class_to_shost(dev);
3689 	struct lpfc_hba   *phba = ((struct lpfc_vport *) shost->hostdata)->phba;
3690 	struct lpfc_sli_ring *pring = lpfc_phba_elsring(phba);
3691 
3692 	return scnprintf(buf, PAGE_SIZE, "%d\n",
3693 			pring ? pring->txcmplq_max : 0);
3694 }
3695 
3696 static DEVICE_ATTR(txcmplq_hw, S_IRUGO,
3697 			 lpfc_txcmplq_hw_show, NULL);
3698 
3699 /*
3700 # lpfc_nodev_tmo: If set, it will hold all I/O errors on devices that disappear
3701 # until the timer expires. Value range is [0,255]. Default value is 30.
3702 */
3703 static int lpfc_nodev_tmo = LPFC_DEF_DEVLOSS_TMO;
3704 static int lpfc_devloss_tmo = LPFC_DEF_DEVLOSS_TMO;
3705 module_param(lpfc_nodev_tmo, int, 0);
3706 MODULE_PARM_DESC(lpfc_nodev_tmo,
3707 		 "Seconds driver will hold I/O waiting "
3708 		 "for a device to come back");
3709 
3710 /**
3711  * lpfc_nodev_tmo_show - Return the hba dev loss timeout value
3712  * @dev: class converted to a Scsi_host structure.
3713  * @attr: device attribute, not used.
3714  * @buf: on return contains the dev loss timeout in decimal.
3715  *
3716  * Returns: size of formatted string.
3717  **/
3718 static ssize_t
lpfc_nodev_tmo_show(struct device * dev,struct device_attribute * attr,char * buf)3719 lpfc_nodev_tmo_show(struct device *dev, struct device_attribute *attr,
3720 		    char *buf)
3721 {
3722 	struct Scsi_Host  *shost = class_to_shost(dev);
3723 	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
3724 
3725 	return scnprintf(buf, PAGE_SIZE, "%d\n",	vport->cfg_devloss_tmo);
3726 }
3727 
3728 /**
3729  * lpfc_nodev_tmo_init - Set the hba nodev timeout value
3730  * @vport: lpfc vport structure pointer.
3731  * @val: contains the nodev timeout value.
3732  *
3733  * Description:
3734  * If the devloss tmo is already set then nodev tmo is set to devloss tmo,
3735  * a kernel error message is printed and zero is returned.
3736  * Else if val is in range then nodev tmo and devloss tmo are set to val.
3737  * Otherwise nodev tmo is set to the default value.
3738  *
3739  * Returns:
3740  * zero if already set or if val is in range
3741  * -EINVAL val out of range
3742  **/
3743 static int
lpfc_nodev_tmo_init(struct lpfc_vport * vport,int val)3744 lpfc_nodev_tmo_init(struct lpfc_vport *vport, int val)
3745 {
3746 	if (vport->cfg_devloss_tmo != LPFC_DEF_DEVLOSS_TMO) {
3747 		vport->cfg_nodev_tmo = vport->cfg_devloss_tmo;
3748 		if (val != LPFC_DEF_DEVLOSS_TMO)
3749 			lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
3750 					 "0407 Ignoring lpfc_nodev_tmo module "
3751 					 "parameter because lpfc_devloss_tmo "
3752 					 "is set.\n");
3753 		return 0;
3754 	}
3755 
3756 	if (val >= LPFC_MIN_DEVLOSS_TMO && val <= LPFC_MAX_DEVLOSS_TMO) {
3757 		vport->cfg_nodev_tmo = val;
3758 		vport->cfg_devloss_tmo = val;
3759 		return 0;
3760 	}
3761 	lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
3762 			 "0400 lpfc_nodev_tmo attribute cannot be set to"
3763 			 " %d, allowed range is [%d, %d]\n",
3764 			 val, LPFC_MIN_DEVLOSS_TMO, LPFC_MAX_DEVLOSS_TMO);
3765 	vport->cfg_nodev_tmo = LPFC_DEF_DEVLOSS_TMO;
3766 	return -EINVAL;
3767 }
3768 
3769 /**
3770  * lpfc_update_rport_devloss_tmo - Update dev loss tmo value
3771  * @vport: lpfc vport structure pointer.
3772  *
3773  * Description:
3774  * Update all the ndlp's dev loss tmo with the vport devloss tmo value.
3775  **/
3776 static void
lpfc_update_rport_devloss_tmo(struct lpfc_vport * vport)3777 lpfc_update_rport_devloss_tmo(struct lpfc_vport *vport)
3778 {
3779 	struct lpfc_nodelist  *ndlp;
3780 	unsigned long iflags;
3781 #if (IS_ENABLED(CONFIG_NVME_FC))
3782 	struct lpfc_nvme_rport *rport;
3783 	struct nvme_fc_remote_port *remoteport = NULL;
3784 #endif
3785 
3786 	spin_lock_irqsave(&vport->fc_nodes_list_lock, iflags);
3787 	list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) {
3788 		if (ndlp->rport)
3789 			ndlp->rport->dev_loss_tmo = vport->cfg_devloss_tmo;
3790 #if (IS_ENABLED(CONFIG_NVME_FC))
3791 		spin_lock(&ndlp->lock);
3792 		rport = lpfc_ndlp_get_nrport(ndlp);
3793 		if (rport)
3794 			remoteport = rport->remoteport;
3795 		spin_unlock(&ndlp->lock);
3796 		if (rport && remoteport)
3797 			nvme_fc_set_remoteport_devloss(remoteport,
3798 						       vport->cfg_devloss_tmo);
3799 #endif
3800 	}
3801 	spin_unlock_irqrestore(&vport->fc_nodes_list_lock, iflags);
3802 }
3803 
3804 /**
3805  * lpfc_nodev_tmo_set - Set the vport nodev tmo and devloss tmo values
3806  * @vport: lpfc vport structure pointer.
3807  * @val: contains the tmo value.
3808  *
3809  * Description:
3810  * If the devloss tmo is already set or the vport dev loss tmo has changed
3811  * then a kernel error message is printed and zero is returned.
3812  * Else if val is in range then nodev tmo and devloss tmo are set to val.
3813  * Otherwise nodev tmo is set to the default value.
3814  *
3815  * Returns:
3816  * zero if already set or if val is in range
3817  * -EINVAL val out of range
3818  **/
3819 static int
lpfc_nodev_tmo_set(struct lpfc_vport * vport,int val)3820 lpfc_nodev_tmo_set(struct lpfc_vport *vport, int val)
3821 {
3822 	if (vport->dev_loss_tmo_changed ||
3823 	    (lpfc_devloss_tmo != LPFC_DEF_DEVLOSS_TMO)) {
3824 		lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
3825 				 "0401 Ignoring change to lpfc_nodev_tmo "
3826 				 "because lpfc_devloss_tmo is set.\n");
3827 		return 0;
3828 	}
3829 	if (val >= LPFC_MIN_DEVLOSS_TMO && val <= LPFC_MAX_DEVLOSS_TMO) {
3830 		vport->cfg_nodev_tmo = val;
3831 		vport->cfg_devloss_tmo = val;
3832 		/*
3833 		 * For compat: set the fc_host dev loss so new rports
3834 		 * will get the value.
3835 		 */
3836 		fc_host_dev_loss_tmo(lpfc_shost_from_vport(vport)) = val;
3837 		lpfc_update_rport_devloss_tmo(vport);
3838 		return 0;
3839 	}
3840 	lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
3841 			 "0403 lpfc_nodev_tmo attribute cannot be set to "
3842 			 "%d, allowed range is [%d, %d]\n",
3843 			 val, LPFC_MIN_DEVLOSS_TMO, LPFC_MAX_DEVLOSS_TMO);
3844 	return -EINVAL;
3845 }
3846 
3847 lpfc_vport_param_store(nodev_tmo)
3848 
3849 static DEVICE_ATTR_RW(lpfc_nodev_tmo);
3850 
3851 /*
3852 # lpfc_devloss_tmo: If set, it will hold all I/O errors on devices that
3853 # disappear until the timer expires. Value range is [0,255]. Default
3854 # value is 30.
3855 */
3856 module_param(lpfc_devloss_tmo, int, S_IRUGO);
3857 MODULE_PARM_DESC(lpfc_devloss_tmo,
3858 		 "Seconds driver will hold I/O waiting "
3859 		 "for a device to come back");
lpfc_vport_param_init(devloss_tmo,LPFC_DEF_DEVLOSS_TMO,LPFC_MIN_DEVLOSS_TMO,LPFC_MAX_DEVLOSS_TMO)3860 lpfc_vport_param_init(devloss_tmo, LPFC_DEF_DEVLOSS_TMO,
3861 		      LPFC_MIN_DEVLOSS_TMO, LPFC_MAX_DEVLOSS_TMO)
3862 lpfc_vport_param_show(devloss_tmo)
3863 
3864 /**
3865  * lpfc_devloss_tmo_set - Sets vport nodev tmo, devloss tmo values, changed bit
3866  * @vport: lpfc vport structure pointer.
3867  * @val: contains the tmo value.
3868  *
3869  * Description:
3870  * If val is in a valid range then set the vport nodev tmo,
3871  * devloss tmo, also set the vport dev loss tmo changed flag.
3872  * Else a kernel error message is printed.
3873  *
3874  * Returns:
3875  * zero if val is in range
3876  * -EINVAL val out of range
3877  **/
3878 static int
3879 lpfc_devloss_tmo_set(struct lpfc_vport *vport, int val)
3880 {
3881 	if (val >= LPFC_MIN_DEVLOSS_TMO && val <= LPFC_MAX_DEVLOSS_TMO) {
3882 		vport->cfg_nodev_tmo = val;
3883 		vport->cfg_devloss_tmo = val;
3884 		vport->dev_loss_tmo_changed = 1;
3885 		fc_host_dev_loss_tmo(lpfc_shost_from_vport(vport)) = val;
3886 		lpfc_update_rport_devloss_tmo(vport);
3887 		return 0;
3888 	}
3889 
3890 	lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
3891 			 "0404 lpfc_devloss_tmo attribute cannot be set to "
3892 			 "%d, allowed range is [%d, %d]\n",
3893 			 val, LPFC_MIN_DEVLOSS_TMO, LPFC_MAX_DEVLOSS_TMO);
3894 	return -EINVAL;
3895 }
3896 
3897 lpfc_vport_param_store(devloss_tmo)
3898 static DEVICE_ATTR_RW(lpfc_devloss_tmo);
3899 
3900 /*
3901  * lpfc_suppress_rsp: Enable suppress rsp feature is firmware supports it
3902  * lpfc_suppress_rsp = 0  Disable
3903  * lpfc_suppress_rsp = 1  Enable (default)
3904  *
3905  */
3906 LPFC_ATTR_R(suppress_rsp, 1, 0, 1,
3907 	    "Enable suppress rsp feature is firmware supports it");
3908 
3909 /*
3910  * lpfc_nvmet_mrq: Specify number of RQ pairs for processing NVMET cmds
3911  * lpfc_nvmet_mrq = 0  driver will calcualte optimal number of RQ pairs
3912  * lpfc_nvmet_mrq = 1  use a single RQ pair
3913  * lpfc_nvmet_mrq >= 2  use specified RQ pairs for MRQ
3914  *
3915  */
3916 LPFC_ATTR_R(nvmet_mrq,
3917 	    LPFC_NVMET_MRQ_AUTO, LPFC_NVMET_MRQ_AUTO, LPFC_NVMET_MRQ_MAX,
3918 	    "Specify number of RQ pairs for processing NVMET cmds");
3919 
3920 /*
3921  * lpfc_nvmet_mrq_post: Specify number of RQ buffer to initially post
3922  * to each NVMET RQ. Range 64 to 2048, default is 512.
3923  */
3924 LPFC_ATTR_R(nvmet_mrq_post,
3925 	    LPFC_NVMET_RQE_DEF_POST, LPFC_NVMET_RQE_MIN_POST,
3926 	    LPFC_NVMET_RQE_DEF_COUNT,
3927 	    "Specify number of RQ buffers to initially post");
3928 
3929 /*
3930  * lpfc_enable_fc4_type: Defines what FC4 types are supported.
3931  * Supported Values:  1 - register just FCP
3932  *                    3 - register both FCP and NVME
3933  * Supported values are [1,3]. Default value is 3
3934  */
3935 LPFC_ATTR_R(enable_fc4_type, LPFC_DEF_ENBL_FC4_TYPE,
3936 	    LPFC_ENABLE_FCP, LPFC_MAX_ENBL_FC4_TYPE,
3937 	    "Enable FC4 Protocol support - FCP / NVME");
3938 
3939 /*
3940 # lpfc_log_verbose: Only turn this flag on if you are willing to risk being
3941 # deluged with LOTS of information.
3942 # You can set a bit mask to record specific types of verbose messages:
3943 # See lpfc_logmsh.h for definitions.
3944 */
3945 LPFC_VPORT_ATTR_HEX_RW(log_verbose, 0x0, 0x0, 0xffffffff,
3946 		       "Verbose logging bit-mask");
3947 
3948 /*
3949 # lpfc_enable_da_id: This turns on the DA_ID CT command that deregisters
3950 # objects that have been registered with the nameserver after login.
3951 */
3952 LPFC_VPORT_ATTR_R(enable_da_id, 1, 0, 1,
3953 		  "Deregister nameserver objects before LOGO");
3954 
3955 /*
3956 # lun_queue_depth:  This parameter is used to limit the number of outstanding
3957 # commands per FCP LUN.
3958 */
3959 LPFC_VPORT_ATTR_R(lun_queue_depth, 64, 1, 512,
3960 		  "Max number of FCP commands we can queue to a specific LUN");
3961 
3962 /*
3963 # tgt_queue_depth:  This parameter is used to limit the number of outstanding
3964 # commands per target port. Value range is [10,65535]. Default value is 65535.
3965 */
3966 static uint lpfc_tgt_queue_depth = LPFC_MAX_TGT_QDEPTH;
3967 module_param(lpfc_tgt_queue_depth, uint, 0444);
3968 MODULE_PARM_DESC(lpfc_tgt_queue_depth, "Set max Target queue depth");
3969 lpfc_vport_param_show(tgt_queue_depth);
3970 lpfc_vport_param_init(tgt_queue_depth, LPFC_MAX_TGT_QDEPTH,
3971 		      LPFC_MIN_TGT_QDEPTH, LPFC_MAX_TGT_QDEPTH);
3972 
3973 /**
3974  * lpfc_tgt_queue_depth_set: Sets an attribute value.
3975  * @vport: lpfc vport structure pointer.
3976  * @val: integer attribute value.
3977  *
3978  * Description: Sets the parameter to the new value.
3979  *
3980  * Returns:
3981  * zero on success
3982  * -EINVAL if val is invalid
3983  */
3984 static int
lpfc_tgt_queue_depth_set(struct lpfc_vport * vport,uint val)3985 lpfc_tgt_queue_depth_set(struct lpfc_vport *vport, uint val)
3986 {
3987 	struct lpfc_nodelist *ndlp;
3988 	unsigned long iflags;
3989 
3990 	if (!lpfc_rangecheck(val, LPFC_MIN_TGT_QDEPTH, LPFC_MAX_TGT_QDEPTH))
3991 		return -EINVAL;
3992 
3993 	if (val == vport->cfg_tgt_queue_depth)
3994 		return 0;
3995 
3996 	vport->cfg_tgt_queue_depth = val;
3997 
3998 	/* Next loop thru nodelist and change cmd_qdepth */
3999 	spin_lock_irqsave(&vport->fc_nodes_list_lock, iflags);
4000 	list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp)
4001 		ndlp->cmd_qdepth = vport->cfg_tgt_queue_depth;
4002 	spin_unlock_irqrestore(&vport->fc_nodes_list_lock, iflags);
4003 	return 0;
4004 }
4005 
4006 lpfc_vport_param_store(tgt_queue_depth);
4007 static DEVICE_ATTR_RW(lpfc_tgt_queue_depth);
4008 
4009 /*
4010 # hba_queue_depth:  This parameter is used to limit the number of outstanding
4011 # commands per lpfc HBA. Value range is [32,8192]. If this parameter
4012 # value is greater than the maximum number of exchanges supported by the HBA,
4013 # then maximum number of exchanges supported by the HBA is used to determine
4014 # the hba_queue_depth.
4015 */
4016 LPFC_ATTR_R(hba_queue_depth, 8192, 32, 8192,
4017 	    "Max number of FCP commands we can queue to a lpfc HBA");
4018 
4019 /*
4020 # peer_port_login:  This parameter allows/prevents logins
4021 # between peer ports hosted on the same physical port.
4022 # When this parameter is set 0 peer ports of same physical port
4023 # are not allowed to login to each other.
4024 # When this parameter is set 1 peer ports of same physical port
4025 # are allowed to login to each other.
4026 # Default value of this parameter is 0.
4027 */
4028 LPFC_VPORT_ATTR_R(peer_port_login, 0, 0, 1,
4029 		  "Allow peer ports on the same physical port to login to each "
4030 		  "other.");
4031 
4032 /*
4033 # restrict_login:  This parameter allows/prevents logins
4034 # between Virtual Ports and remote initiators.
4035 # When this parameter is not set (0) Virtual Ports will accept PLOGIs from
4036 # other initiators and will attempt to PLOGI all remote ports.
4037 # When this parameter is set (1) Virtual Ports will reject PLOGIs from
4038 # remote ports and will not attempt to PLOGI to other initiators.
4039 # This parameter does not restrict to the physical port.
4040 # This parameter does not restrict logins to Fabric resident remote ports.
4041 # Default value of this parameter is 1.
4042 */
4043 static int lpfc_restrict_login = 1;
4044 module_param(lpfc_restrict_login, int, S_IRUGO);
4045 MODULE_PARM_DESC(lpfc_restrict_login,
4046 		 "Restrict virtual ports login to remote initiators.");
4047 lpfc_vport_param_show(restrict_login);
4048 
4049 /**
4050  * lpfc_restrict_login_init - Set the vport restrict login flag
4051  * @vport: lpfc vport structure pointer.
4052  * @val: contains the restrict login value.
4053  *
4054  * Description:
4055  * If val is not in a valid range then log a kernel error message and set
4056  * the vport restrict login to one.
4057  * If the port type is physical clear the restrict login flag and return.
4058  * Else set the restrict login flag to val.
4059  *
4060  * Returns:
4061  * zero if val is in range
4062  * -EINVAL val out of range
4063  **/
4064 static int
lpfc_restrict_login_init(struct lpfc_vport * vport,int val)4065 lpfc_restrict_login_init(struct lpfc_vport *vport, int val)
4066 {
4067 	if (val < 0 || val > 1) {
4068 		lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
4069 				 "0422 lpfc_restrict_login attribute cannot "
4070 				 "be set to %d, allowed range is [0, 1]\n",
4071 				 val);
4072 		vport->cfg_restrict_login = 1;
4073 		return -EINVAL;
4074 	}
4075 	if (vport->port_type == LPFC_PHYSICAL_PORT) {
4076 		vport->cfg_restrict_login = 0;
4077 		return 0;
4078 	}
4079 	vport->cfg_restrict_login = val;
4080 	return 0;
4081 }
4082 
4083 /**
4084  * lpfc_restrict_login_set - Set the vport restrict login flag
4085  * @vport: lpfc vport structure pointer.
4086  * @val: contains the restrict login value.
4087  *
4088  * Description:
4089  * If val is not in a valid range then log a kernel error message and set
4090  * the vport restrict login to one.
4091  * If the port type is physical and the val is not zero log a kernel
4092  * error message, clear the restrict login flag and return zero.
4093  * Else set the restrict login flag to val.
4094  *
4095  * Returns:
4096  * zero if val is in range
4097  * -EINVAL val out of range
4098  **/
4099 static int
lpfc_restrict_login_set(struct lpfc_vport * vport,int val)4100 lpfc_restrict_login_set(struct lpfc_vport *vport, int val)
4101 {
4102 	if (val < 0 || val > 1) {
4103 		lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
4104 				 "0425 lpfc_restrict_login attribute cannot "
4105 				 "be set to %d, allowed range is [0, 1]\n",
4106 				 val);
4107 		vport->cfg_restrict_login = 1;
4108 		return -EINVAL;
4109 	}
4110 	if (vport->port_type == LPFC_PHYSICAL_PORT && val != 0) {
4111 		lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
4112 				 "0468 lpfc_restrict_login must be 0 for "
4113 				 "Physical ports.\n");
4114 		vport->cfg_restrict_login = 0;
4115 		return 0;
4116 	}
4117 	vport->cfg_restrict_login = val;
4118 	return 0;
4119 }
4120 lpfc_vport_param_store(restrict_login);
4121 static DEVICE_ATTR_RW(lpfc_restrict_login);
4122 
4123 /*
4124 # Some disk devices have a "select ID" or "select Target" capability.
4125 # From a protocol standpoint "select ID" usually means select the
4126 # Fibre channel "ALPA".  In the FC-AL Profile there is an "informative
4127 # annex" which contains a table that maps a "select ID" (a number
4128 # between 0 and 7F) to an ALPA.  By default, for compatibility with
4129 # older drivers, the lpfc driver scans this table from low ALPA to high
4130 # ALPA.
4131 #
4132 # Turning on the scan-down variable (on  = 1, off = 0) will
4133 # cause the lpfc driver to use an inverted table, effectively
4134 # scanning ALPAs from high to low. Value range is [0,1]. Default value is 1.
4135 #
4136 # (Note: This "select ID" functionality is a LOOP ONLY characteristic
4137 # and will not work across a fabric. Also this parameter will take
4138 # effect only in the case when ALPA map is not available.)
4139 */
4140 LPFC_VPORT_ATTR_R(scan_down, 1, 0, 1,
4141 		  "Start scanning for devices from highest ALPA to lowest");
4142 
4143 /*
4144 # lpfc_topology:  link topology for init link
4145 #            0x0  = attempt loop mode then point-to-point
4146 #            0x01 = internal loopback mode
4147 #            0x02 = attempt point-to-point mode only
4148 #            0x04 = attempt loop mode only
4149 #            0x06 = attempt point-to-point mode then loop
4150 # Set point-to-point mode if you want to run as an N_Port.
4151 # Set loop mode if you want to run as an NL_Port. Value range is [0,0x6].
4152 # Default value is 0.
4153 */
4154 LPFC_ATTR(topology, 0, 0, 6,
4155 	"Select Fibre Channel topology");
4156 
4157 /**
4158  * lpfc_topology_store - Set the adapters topology field
4159  * @dev: class device that is converted into a scsi_host.
4160  * @attr:device attribute, not used.
4161  * @buf: buffer for passing information.
4162  * @count: size of the data buffer.
4163  *
4164  * Description:
4165  * If val is in a valid range then set the adapter's topology field and
4166  * issue a lip; if the lip fails reset the topology to the old value.
4167  *
4168  * If the value is not in range log a kernel error message and return an error.
4169  *
4170  * Returns:
4171  * zero if val is in range and lip okay
4172  * non-zero return value from lpfc_issue_lip()
4173  * -EINVAL val out of range
4174  **/
4175 static ssize_t
lpfc_topology_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)4176 lpfc_topology_store(struct device *dev, struct device_attribute *attr,
4177 			const char *buf, size_t count)
4178 {
4179 	struct Scsi_Host  *shost = class_to_shost(dev);
4180 	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
4181 	struct lpfc_hba   *phba = vport->phba;
4182 	int val = 0;
4183 	int nolip = 0;
4184 	const char *val_buf = buf;
4185 	int err;
4186 	uint32_t prev_val;
4187 	u8 sli_family, if_type;
4188 
4189 	if (!strncmp(buf, "nolip ", strlen("nolip "))) {
4190 		nolip = 1;
4191 		val_buf = &buf[strlen("nolip ")];
4192 	}
4193 
4194 	if (!isdigit(val_buf[0]))
4195 		return -EINVAL;
4196 	if (sscanf(val_buf, "%i", &val) != 1)
4197 		return -EINVAL;
4198 
4199 	if (val >= 0 && val <= 6) {
4200 		prev_val = phba->cfg_topology;
4201 		if (phba->cfg_link_speed == LPFC_USER_LINK_SPEED_16G &&
4202 			val == 4) {
4203 			lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
4204 				"3113 Loop mode not supported at speed %d\n",
4205 				val);
4206 			return -EINVAL;
4207 		}
4208 		/*
4209 		 * The 'topology' is not a configurable parameter if :
4210 		 *   - persistent topology enabled
4211 		 *   - ASIC_GEN_NUM >= 0xC, with no private loop support
4212 		 */
4213 		sli_family = bf_get(lpfc_sli_intf_sli_family,
4214 				    &phba->sli4_hba.sli_intf);
4215 		if_type = bf_get(lpfc_sli_intf_if_type,
4216 				 &phba->sli4_hba.sli_intf);
4217 		if ((test_bit(HBA_PERSISTENT_TOPO, &phba->hba_flag) ||
4218 		     (!phba->sli4_hba.pc_sli4_params.pls &&
4219 		     (sli_family == LPFC_SLI_INTF_FAMILY_G6 ||
4220 		      if_type == LPFC_SLI_INTF_IF_TYPE_6))) &&
4221 		    val == 4) {
4222 			lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
4223 				"3114 Loop mode not supported\n");
4224 			return -EINVAL;
4225 		}
4226 		phba->cfg_topology = val;
4227 		if (nolip)
4228 			return strlen(buf);
4229 
4230 		lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
4231 			"3054 lpfc_topology changed from %d to %d\n",
4232 			prev_val, val);
4233 		if (prev_val != val && phba->sli_rev == LPFC_SLI_REV4)
4234 			phba->fc_topology_changed = 1;
4235 		err = lpfc_issue_lip(lpfc_shost_from_vport(phba->pport));
4236 		if (err) {
4237 			phba->cfg_topology = prev_val;
4238 			return -EINVAL;
4239 		} else
4240 			return strlen(buf);
4241 	}
4242 	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4243 		"%d:0467 lpfc_topology attribute cannot be set to %d, "
4244 		"allowed range is [0, 6]\n",
4245 		phba->brd_no, val);
4246 	return -EINVAL;
4247 }
4248 
4249 lpfc_param_show(topology)
4250 static DEVICE_ATTR_RW(lpfc_topology);
4251 
4252 /**
4253  * lpfc_static_vport_show: Read callback function for
4254  *   lpfc_static_vport sysfs file.
4255  * @dev: Pointer to class device object.
4256  * @attr: device attribute structure.
4257  * @buf: Data buffer.
4258  *
4259  * This function is the read call back function for
4260  * lpfc_static_vport sysfs file. The lpfc_static_vport
4261  * sysfs file report the mageability of the vport.
4262  **/
4263 static ssize_t
lpfc_static_vport_show(struct device * dev,struct device_attribute * attr,char * buf)4264 lpfc_static_vport_show(struct device *dev, struct device_attribute *attr,
4265 			 char *buf)
4266 {
4267 	struct Scsi_Host  *shost = class_to_shost(dev);
4268 	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
4269 	if (vport->vport_flag & STATIC_VPORT)
4270 		sprintf(buf, "1\n");
4271 	else
4272 		sprintf(buf, "0\n");
4273 
4274 	return strlen(buf);
4275 }
4276 
4277 /*
4278  * Sysfs attribute to control the statistical data collection.
4279  */
4280 static DEVICE_ATTR_RO(lpfc_static_vport);
4281 
4282 /*
4283 # lpfc_link_speed: Link speed selection for initializing the Fibre Channel
4284 # connection.
4285 # Value range is [0,16]. Default value is 0.
4286 */
4287 /**
4288  * lpfc_link_speed_store - Set the adapters link speed
4289  * @dev: Pointer to class device.
4290  * @attr: Unused.
4291  * @buf: Data buffer.
4292  * @count: Size of the data buffer.
4293  *
4294  * Description:
4295  * If val is in a valid range then set the adapter's link speed field and
4296  * issue a lip; if the lip fails reset the link speed to the old value.
4297  *
4298  * Notes:
4299  * If the value is not in range log a kernel error message and return an error.
4300  *
4301  * Returns:
4302  * zero if val is in range and lip okay.
4303  * non-zero return value from lpfc_issue_lip()
4304  * -EINVAL val out of range
4305  **/
4306 static ssize_t
lpfc_link_speed_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)4307 lpfc_link_speed_store(struct device *dev, struct device_attribute *attr,
4308 		const char *buf, size_t count)
4309 {
4310 	struct Scsi_Host  *shost = class_to_shost(dev);
4311 	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
4312 	struct lpfc_hba   *phba = vport->phba;
4313 	int val = LPFC_USER_LINK_SPEED_AUTO;
4314 	int nolip = 0;
4315 	const char *val_buf = buf;
4316 	int err;
4317 	uint32_t prev_val, if_type;
4318 
4319 	if_type = bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf);
4320 	if (if_type >= LPFC_SLI_INTF_IF_TYPE_2 &&
4321 	    test_bit(HBA_FORCED_LINK_SPEED, &phba->hba_flag))
4322 		return -EPERM;
4323 
4324 	if (!strncmp(buf, "nolip ", strlen("nolip "))) {
4325 		nolip = 1;
4326 		val_buf = &buf[strlen("nolip ")];
4327 	}
4328 
4329 	if (!isdigit(val_buf[0]))
4330 		return -EINVAL;
4331 	if (sscanf(val_buf, "%i", &val) != 1)
4332 		return -EINVAL;
4333 
4334 	lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
4335 		"3055 lpfc_link_speed changed from %d to %d %s\n",
4336 		phba->cfg_link_speed, val, nolip ? "(nolip)" : "(lip)");
4337 
4338 	if (((val == LPFC_USER_LINK_SPEED_1G) && !(phba->lmt & LMT_1Gb)) ||
4339 	    ((val == LPFC_USER_LINK_SPEED_2G) && !(phba->lmt & LMT_2Gb)) ||
4340 	    ((val == LPFC_USER_LINK_SPEED_4G) && !(phba->lmt & LMT_4Gb)) ||
4341 	    ((val == LPFC_USER_LINK_SPEED_8G) && !(phba->lmt & LMT_8Gb)) ||
4342 	    ((val == LPFC_USER_LINK_SPEED_10G) && !(phba->lmt & LMT_10Gb)) ||
4343 	    ((val == LPFC_USER_LINK_SPEED_16G) && !(phba->lmt & LMT_16Gb)) ||
4344 	    ((val == LPFC_USER_LINK_SPEED_32G) && !(phba->lmt & LMT_32Gb)) ||
4345 	    ((val == LPFC_USER_LINK_SPEED_64G) && !(phba->lmt & LMT_64Gb))) {
4346 		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4347 				"2879 lpfc_link_speed attribute cannot be set "
4348 				"to %d. Speed is not supported by this port.\n",
4349 				val);
4350 		return -EINVAL;
4351 	}
4352 	if (val >= LPFC_USER_LINK_SPEED_16G &&
4353 	    phba->fc_topology == LPFC_TOPOLOGY_LOOP) {
4354 		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4355 				"3112 lpfc_link_speed attribute cannot be set "
4356 				"to %d. Speed is not supported in loop mode.\n",
4357 				val);
4358 		return -EINVAL;
4359 	}
4360 
4361 	switch (val) {
4362 	case LPFC_USER_LINK_SPEED_AUTO:
4363 	case LPFC_USER_LINK_SPEED_1G:
4364 	case LPFC_USER_LINK_SPEED_2G:
4365 	case LPFC_USER_LINK_SPEED_4G:
4366 	case LPFC_USER_LINK_SPEED_8G:
4367 	case LPFC_USER_LINK_SPEED_16G:
4368 	case LPFC_USER_LINK_SPEED_32G:
4369 	case LPFC_USER_LINK_SPEED_64G:
4370 		prev_val = phba->cfg_link_speed;
4371 		phba->cfg_link_speed = val;
4372 		if (nolip)
4373 			return strlen(buf);
4374 
4375 		err = lpfc_issue_lip(lpfc_shost_from_vport(phba->pport));
4376 		if (err) {
4377 			phba->cfg_link_speed = prev_val;
4378 			return -EINVAL;
4379 		}
4380 		return strlen(buf);
4381 	default:
4382 		break;
4383 	}
4384 
4385 	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4386 			"0469 lpfc_link_speed attribute cannot be set to %d, "
4387 			"allowed values are [%s]\n",
4388 			val, LPFC_LINK_SPEED_STRING);
4389 	return -EINVAL;
4390 
4391 }
4392 
4393 static int lpfc_link_speed = 0;
4394 module_param(lpfc_link_speed, int, S_IRUGO);
4395 MODULE_PARM_DESC(lpfc_link_speed, "Select link speed");
lpfc_param_show(link_speed)4396 lpfc_param_show(link_speed)
4397 
4398 /**
4399  * lpfc_link_speed_init - Set the adapters link speed
4400  * @phba: lpfc_hba pointer.
4401  * @val: link speed value.
4402  *
4403  * Description:
4404  * If val is in a valid range then set the adapter's link speed field.
4405  *
4406  * Notes:
4407  * If the value is not in range log a kernel error message, clear the link
4408  * speed and return an error.
4409  *
4410  * Returns:
4411  * zero if val saved.
4412  * -EINVAL val out of range
4413  **/
4414 static int
4415 lpfc_link_speed_init(struct lpfc_hba *phba, int val)
4416 {
4417 	if (val >= LPFC_USER_LINK_SPEED_16G && phba->cfg_topology == 4) {
4418 		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4419 			"3111 lpfc_link_speed of %d cannot "
4420 			"support loop mode, setting topology to default.\n",
4421 			 val);
4422 		phba->cfg_topology = 0;
4423 	}
4424 
4425 	switch (val) {
4426 	case LPFC_USER_LINK_SPEED_AUTO:
4427 	case LPFC_USER_LINK_SPEED_1G:
4428 	case LPFC_USER_LINK_SPEED_2G:
4429 	case LPFC_USER_LINK_SPEED_4G:
4430 	case LPFC_USER_LINK_SPEED_8G:
4431 	case LPFC_USER_LINK_SPEED_16G:
4432 	case LPFC_USER_LINK_SPEED_32G:
4433 	case LPFC_USER_LINK_SPEED_64G:
4434 		phba->cfg_link_speed = val;
4435 		return 0;
4436 	default:
4437 		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4438 				"0405 lpfc_link_speed attribute cannot "
4439 				"be set to %d, allowed values are "
4440 				"["LPFC_LINK_SPEED_STRING"]\n", val);
4441 		phba->cfg_link_speed = LPFC_USER_LINK_SPEED_AUTO;
4442 		return -EINVAL;
4443 	}
4444 }
4445 
4446 static DEVICE_ATTR_RW(lpfc_link_speed);
4447 
4448 /*
4449 # lpfc_aer_support: Support PCIe device Advanced Error Reporting (AER)
4450 #       1  = aer supported and enabled (default)
4451 # PCIe error reporting is always enabled by the PCI core, so this always
4452 # shows 1.
4453 #
4454 # N.B. Parts of LPFC_ATTR open-coded since some of the underlying
4455 # infrastructure (phba->cfg_aer_support) is gone.
4456 */
4457 static uint lpfc_aer_support = 1;
4458 module_param(lpfc_aer_support, uint, S_IRUGO);
4459 MODULE_PARM_DESC(lpfc_aer_support, "Enable PCIe device AER support");
4460 static ssize_t
lpfc_aer_support_show(struct device * dev,struct device_attribute * attr,char * buf)4461 lpfc_aer_support_show(struct device *dev, struct device_attribute *attr,
4462 		      char *buf)
4463 {
4464 	return scnprintf(buf, PAGE_SIZE, "%d\n", lpfc_aer_support);
4465 }
4466 
4467 /**
4468  * lpfc_aer_support_store - Set the adapter for aer support
4469  *
4470  * @dev: class device that is converted into a Scsi_host.
4471  * @attr: device attribute, not used.
4472  * @buf: containing enable or disable aer flag.
4473  * @count: unused variable.
4474  *
4475  * Description:
4476  * PCIe error reporting is enabled by the PCI core, so drivers don't need
4477  * to do anything.  Retain this interface for backwards compatibility,
4478  * but do nothing.
4479  *
4480  * Returns:
4481  * length of the buf on success
4482  * -EINVAL if val out of range
4483  **/
4484 static ssize_t
lpfc_aer_support_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)4485 lpfc_aer_support_store(struct device *dev, struct device_attribute *attr,
4486 		       const char *buf, size_t count)
4487 {
4488 	int val = 0;
4489 
4490 	if (!isdigit(buf[0]))
4491 		return -EINVAL;
4492 	if (sscanf(buf, "%i", &val) != 1)
4493 		return -EINVAL;
4494 
4495 	dev_info_once(dev, "PCIe error reporting automatically enabled by the PCI core; sysfs write ignored\n");
4496 	return strlen(buf);
4497 }
4498 
4499 static DEVICE_ATTR_RW(lpfc_aer_support);
4500 
4501 /**
4502  * lpfc_aer_cleanup_state - Clean up aer state to the aer enabled device
4503  * @dev: class device that is converted into a Scsi_host.
4504  * @attr: device attribute, not used.
4505  * @buf: containing flag 1 for aer cleanup state.
4506  * @count: unused variable.
4507  *
4508  * Description:
4509  * If the @buf contains 1, invokes the kernel AER helper routine
4510  * pci_aer_clear_nonfatal_status() to clean up the uncorrectable
4511  * error status register.
4512  *
4513  * Notes:
4514  *
4515  * Returns:
4516  * -EINVAL if the buf does not contain 1
4517  * -EPERM if the OS cannot clear AER error status, i.e., when platform
4518  * firmware owns the AER Capability
4519  **/
4520 static ssize_t
lpfc_aer_cleanup_state(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)4521 lpfc_aer_cleanup_state(struct device *dev, struct device_attribute *attr,
4522 		       const char *buf, size_t count)
4523 {
4524 	struct Scsi_Host  *shost = class_to_shost(dev);
4525 	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
4526 	struct lpfc_hba   *phba = vport->phba;
4527 	int val, rc = -1;
4528 
4529 	if (!isdigit(buf[0]))
4530 		return -EINVAL;
4531 	if (sscanf(buf, "%i", &val) != 1)
4532 		return -EINVAL;
4533 	if (val != 1)
4534 		return -EINVAL;
4535 
4536 	rc = pci_aer_clear_nonfatal_status(phba->pcidev);
4537 
4538 	if (rc == 0)
4539 		return strlen(buf);
4540 	else
4541 		return -EPERM;
4542 }
4543 
4544 static DEVICE_ATTR(lpfc_aer_state_cleanup, S_IWUSR, NULL,
4545 		   lpfc_aer_cleanup_state);
4546 
4547 /**
4548  * lpfc_sriov_nr_virtfn_store - Enable the adapter for sr-iov virtual functions
4549  *
4550  * @dev: class device that is converted into a Scsi_host.
4551  * @attr: device attribute, not used.
4552  * @buf: containing the string the number of vfs to be enabled.
4553  * @count: unused variable.
4554  *
4555  * Description:
4556  * When this api is called either through user sysfs, the driver shall
4557  * try to enable or disable SR-IOV virtual functions according to the
4558  * following:
4559  *
4560  * If zero virtual function has been enabled to the physical function,
4561  * the driver shall invoke the pci enable virtual function api trying
4562  * to enable the virtual functions. If the nr_vfn provided is greater
4563  * than the maximum supported, the maximum virtual function number will
4564  * be used for invoking the api; otherwise, the nr_vfn provided shall
4565  * be used for invoking the api. If the api call returned success, the
4566  * actual number of virtual functions enabled will be set to the driver
4567  * cfg_sriov_nr_virtfn; otherwise, -EINVAL shall be returned and driver
4568  * cfg_sriov_nr_virtfn remains zero.
4569  *
4570  * If none-zero virtual functions have already been enabled to the
4571  * physical function, as reflected by the driver's cfg_sriov_nr_virtfn,
4572  * -EINVAL will be returned and the driver does nothing;
4573  *
4574  * If the nr_vfn provided is zero and none-zero virtual functions have
4575  * been enabled, as indicated by the driver's cfg_sriov_nr_virtfn, the
4576  * disabling virtual function api shall be invoded to disable all the
4577  * virtual functions and driver's cfg_sriov_nr_virtfn shall be set to
4578  * zero. Otherwise, if zero virtual function has been enabled, do
4579  * nothing.
4580  *
4581  * Returns:
4582  * length of the buf on success if val is in range the intended mode
4583  * is supported.
4584  * -EINVAL if val out of range or intended mode is not supported.
4585  **/
4586 static ssize_t
lpfc_sriov_nr_virtfn_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)4587 lpfc_sriov_nr_virtfn_store(struct device *dev, struct device_attribute *attr,
4588 			 const char *buf, size_t count)
4589 {
4590 	struct Scsi_Host *shost = class_to_shost(dev);
4591 	struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
4592 	struct lpfc_hba *phba = vport->phba;
4593 	struct pci_dev *pdev = phba->pcidev;
4594 	int val = 0, rc = -EINVAL;
4595 
4596 	/* Sanity check on user data */
4597 	if (!isdigit(buf[0]))
4598 		return -EINVAL;
4599 	if (sscanf(buf, "%i", &val) != 1)
4600 		return -EINVAL;
4601 	if (val < 0)
4602 		return -EINVAL;
4603 
4604 	/* Request disabling virtual functions */
4605 	if (val == 0) {
4606 		if (phba->cfg_sriov_nr_virtfn > 0) {
4607 			pci_disable_sriov(pdev);
4608 			phba->cfg_sriov_nr_virtfn = 0;
4609 		}
4610 		return strlen(buf);
4611 	}
4612 
4613 	/* Request enabling virtual functions */
4614 	if (phba->cfg_sriov_nr_virtfn > 0) {
4615 		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4616 				"3018 There are %d virtual functions "
4617 				"enabled on physical function.\n",
4618 				phba->cfg_sriov_nr_virtfn);
4619 		return -EEXIST;
4620 	}
4621 
4622 	if (val <= LPFC_MAX_VFN_PER_PFN)
4623 		phba->cfg_sriov_nr_virtfn = val;
4624 	else {
4625 		lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4626 				"3019 Enabling %d virtual functions is not "
4627 				"allowed.\n", val);
4628 		return -EINVAL;
4629 	}
4630 
4631 	rc = lpfc_sli_probe_sriov_nr_virtfn(phba, phba->cfg_sriov_nr_virtfn);
4632 	if (rc) {
4633 		phba->cfg_sriov_nr_virtfn = 0;
4634 		rc = -EPERM;
4635 	} else
4636 		rc = strlen(buf);
4637 
4638 	return rc;
4639 }
4640 
4641 LPFC_ATTR(sriov_nr_virtfn, LPFC_DEF_VFN_PER_PFN, 0, LPFC_MAX_VFN_PER_PFN,
4642 	"Enable PCIe device SR-IOV virtual fn");
4643 
4644 lpfc_param_show(sriov_nr_virtfn)
4645 static DEVICE_ATTR_RW(lpfc_sriov_nr_virtfn);
4646 
4647 /**
4648  * lpfc_request_firmware_upgrade_store - Request for Linux generic firmware upgrade
4649  *
4650  * @dev: class device that is converted into a Scsi_host.
4651  * @attr: device attribute, not used.
4652  * @buf: containing the string the number of vfs to be enabled.
4653  * @count: unused variable.
4654  *
4655  * Description:
4656  *
4657  * Returns:
4658  * length of the buf on success if val is in range the intended mode
4659  * is supported.
4660  * -EINVAL if val out of range or intended mode is not supported.
4661  **/
4662 static ssize_t
lpfc_request_firmware_upgrade_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)4663 lpfc_request_firmware_upgrade_store(struct device *dev,
4664 				    struct device_attribute *attr,
4665 				    const char *buf, size_t count)
4666 {
4667 	struct Scsi_Host *shost = class_to_shost(dev);
4668 	struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
4669 	struct lpfc_hba *phba = vport->phba;
4670 	int val = 0, rc;
4671 
4672 	/* Sanity check on user data */
4673 	if (!isdigit(buf[0]))
4674 		return -EINVAL;
4675 	if (sscanf(buf, "%i", &val) != 1)
4676 		return -EINVAL;
4677 	if (val != 1)
4678 		return -EINVAL;
4679 
4680 	rc = lpfc_sli4_request_firmware_update(phba, RUN_FW_UPGRADE);
4681 	if (rc)
4682 		rc = -EPERM;
4683 	else
4684 		rc = strlen(buf);
4685 	return rc;
4686 }
4687 
4688 static int lpfc_req_fw_upgrade;
4689 module_param(lpfc_req_fw_upgrade, int, S_IRUGO|S_IWUSR);
4690 MODULE_PARM_DESC(lpfc_req_fw_upgrade, "Enable Linux generic firmware upgrade");
lpfc_param_show(request_firmware_upgrade)4691 lpfc_param_show(request_firmware_upgrade)
4692 
4693 /**
4694  * lpfc_request_firmware_upgrade_init - Enable initial linux generic fw upgrade
4695  * @phba: lpfc_hba pointer.
4696  * @val: 0 or 1.
4697  *
4698  * Description:
4699  * Set the initial Linux generic firmware upgrade enable or disable flag.
4700  *
4701  * Returns:
4702  * zero if val saved.
4703  * -EINVAL val out of range
4704  **/
4705 static int
4706 lpfc_request_firmware_upgrade_init(struct lpfc_hba *phba, int val)
4707 {
4708 	if (val >= 0 && val <= 1) {
4709 		phba->cfg_request_firmware_upgrade = val;
4710 		return 0;
4711 	}
4712 	return -EINVAL;
4713 }
4714 static DEVICE_ATTR(lpfc_req_fw_upgrade, S_IRUGO | S_IWUSR,
4715 		   lpfc_request_firmware_upgrade_show,
4716 		   lpfc_request_firmware_upgrade_store);
4717 
4718 /**
4719  * lpfc_force_rscn_store
4720  *
4721  * @dev: class device that is converted into a Scsi_host.
4722  * @attr: device attribute, not used.
4723  * @buf: unused string
4724  * @count: unused variable.
4725  *
4726  * Description:
4727  * Force the switch to send a RSCN to all other NPorts in our zone
4728  * If we are direct connect pt2pt, build the RSCN command ourself
4729  * and send to the other NPort. Not supported for private loop.
4730  *
4731  * Returns:
4732  * 0      - on success
4733  * -EIO   - if command is not sent
4734  **/
4735 static ssize_t
lpfc_force_rscn_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)4736 lpfc_force_rscn_store(struct device *dev, struct device_attribute *attr,
4737 		      const char *buf, size_t count)
4738 {
4739 	struct Scsi_Host *shost = class_to_shost(dev);
4740 	struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
4741 	int i;
4742 
4743 	i = lpfc_issue_els_rscn(vport, 0);
4744 	if (i)
4745 		return -EIO;
4746 	return strlen(buf);
4747 }
4748 
4749 /*
4750  * lpfc_force_rscn: Force an RSCN to be sent to all remote NPorts
4751  * connected to  the HBA.
4752  *
4753  * Value range is any ascii value
4754  */
4755 static int lpfc_force_rscn;
4756 module_param(lpfc_force_rscn, int, 0644);
4757 MODULE_PARM_DESC(lpfc_force_rscn,
4758 		 "Force an RSCN to be sent to all remote NPorts");
lpfc_param_show(force_rscn)4759 lpfc_param_show(force_rscn)
4760 
4761 /**
4762  * lpfc_force_rscn_init - Force an RSCN to be sent to all remote NPorts
4763  * @phba: lpfc_hba pointer.
4764  * @val: unused value.
4765  *
4766  * Returns:
4767  * zero if val saved.
4768  **/
4769 static int
4770 lpfc_force_rscn_init(struct lpfc_hba *phba, int val)
4771 {
4772 	return 0;
4773 }
4774 static DEVICE_ATTR_RW(lpfc_force_rscn);
4775 
4776 /**
4777  * lpfc_fcp_imax_store
4778  *
4779  * @dev: class device that is converted into a Scsi_host.
4780  * @attr: device attribute, not used.
4781  * @buf: string with the number of fast-path FCP interrupts per second.
4782  * @count: unused variable.
4783  *
4784  * Description:
4785  * If val is in a valid range [636,651042], then set the adapter's
4786  * maximum number of fast-path FCP interrupts per second.
4787  *
4788  * Returns:
4789  * length of the buf on success if val is in range the intended mode
4790  * is supported.
4791  * -EINVAL if val out of range or intended mode is not supported.
4792  **/
4793 static ssize_t
lpfc_fcp_imax_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)4794 lpfc_fcp_imax_store(struct device *dev, struct device_attribute *attr,
4795 			 const char *buf, size_t count)
4796 {
4797 	struct Scsi_Host *shost = class_to_shost(dev);
4798 	struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
4799 	struct lpfc_hba *phba = vport->phba;
4800 	struct lpfc_eq_intr_info *eqi;
4801 	uint32_t usdelay;
4802 	int val = 0, i;
4803 
4804 	/* fcp_imax is only valid for SLI4 */
4805 	if (phba->sli_rev != LPFC_SLI_REV4)
4806 		return -EINVAL;
4807 
4808 	/* Sanity check on user data */
4809 	if (!isdigit(buf[0]))
4810 		return -EINVAL;
4811 	if (sscanf(buf, "%i", &val) != 1)
4812 		return -EINVAL;
4813 
4814 	/*
4815 	 * Value range for the HBA is [5000,5000000]
4816 	 * The value for each EQ depends on how many EQs are configured.
4817 	 * Allow value == 0
4818 	 */
4819 	if (val && (val < LPFC_MIN_IMAX || val > LPFC_MAX_IMAX))
4820 		return -EINVAL;
4821 
4822 	phba->cfg_auto_imax = (val) ? 0 : 1;
4823 	if (phba->cfg_fcp_imax && !val) {
4824 		queue_delayed_work(phba->wq, &phba->eq_delay_work,
4825 				   msecs_to_jiffies(LPFC_EQ_DELAY_MSECS));
4826 
4827 		for_each_present_cpu(i) {
4828 			eqi = per_cpu_ptr(phba->sli4_hba.eq_info, i);
4829 			eqi->icnt = 0;
4830 		}
4831 	}
4832 
4833 	phba->cfg_fcp_imax = (uint32_t)val;
4834 
4835 	if (phba->cfg_fcp_imax)
4836 		usdelay = LPFC_SEC_TO_USEC / phba->cfg_fcp_imax;
4837 	else
4838 		usdelay = 0;
4839 
4840 	for (i = 0; i < phba->cfg_irq_chann; i += LPFC_MAX_EQ_DELAY_EQID_CNT)
4841 		lpfc_modify_hba_eq_delay(phba, i, LPFC_MAX_EQ_DELAY_EQID_CNT,
4842 					 usdelay);
4843 
4844 	return strlen(buf);
4845 }
4846 
4847 /*
4848 # lpfc_fcp_imax: The maximum number of fast-path FCP interrupts per second
4849 # for the HBA.
4850 #
4851 # Value range is [5,000 to 5,000,000]. Default value is 50,000.
4852 */
4853 static int lpfc_fcp_imax = LPFC_DEF_IMAX;
4854 module_param(lpfc_fcp_imax, int, S_IRUGO|S_IWUSR);
4855 MODULE_PARM_DESC(lpfc_fcp_imax,
4856 	    "Set the maximum number of FCP interrupts per second per HBA");
lpfc_param_show(fcp_imax)4857 lpfc_param_show(fcp_imax)
4858 
4859 /**
4860  * lpfc_fcp_imax_init - Set the initial sr-iov virtual function enable
4861  * @phba: lpfc_hba pointer.
4862  * @val: link speed value.
4863  *
4864  * Description:
4865  * If val is in a valid range [636,651042], then initialize the adapter's
4866  * maximum number of fast-path FCP interrupts per second.
4867  *
4868  * Returns:
4869  * zero if val saved.
4870  * -EINVAL val out of range
4871  **/
4872 static int
4873 lpfc_fcp_imax_init(struct lpfc_hba *phba, int val)
4874 {
4875 	if (phba->sli_rev != LPFC_SLI_REV4) {
4876 		phba->cfg_fcp_imax = 0;
4877 		return 0;
4878 	}
4879 
4880 	if ((val >= LPFC_MIN_IMAX && val <= LPFC_MAX_IMAX) ||
4881 	    (val == 0)) {
4882 		phba->cfg_fcp_imax = val;
4883 		return 0;
4884 	}
4885 
4886 	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4887 			"3016 lpfc_fcp_imax: %d out of range, using default\n",
4888 			val);
4889 	phba->cfg_fcp_imax = LPFC_DEF_IMAX;
4890 
4891 	return 0;
4892 }
4893 
4894 static DEVICE_ATTR_RW(lpfc_fcp_imax);
4895 
4896 /**
4897  * lpfc_cq_max_proc_limit_store
4898  *
4899  * @dev: class device that is converted into a Scsi_host.
4900  * @attr: device attribute, not used.
4901  * @buf: string with the cq max processing limit of cqes
4902  * @count: unused variable.
4903  *
4904  * Description:
4905  * If val is in a valid range, then set value on each cq
4906  *
4907  * Returns:
4908  * The length of the buf: if successful
4909  * -ERANGE: if val is not in the valid range
4910  * -EINVAL: if bad value format or intended mode is not supported.
4911  **/
4912 static ssize_t
lpfc_cq_max_proc_limit_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)4913 lpfc_cq_max_proc_limit_store(struct device *dev, struct device_attribute *attr,
4914 			 const char *buf, size_t count)
4915 {
4916 	struct Scsi_Host *shost = class_to_shost(dev);
4917 	struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
4918 	struct lpfc_hba *phba = vport->phba;
4919 	struct lpfc_queue *eq, *cq;
4920 	unsigned long val;
4921 	int i;
4922 
4923 	/* cq_max_proc_limit is only valid for SLI4 */
4924 	if (phba->sli_rev != LPFC_SLI_REV4)
4925 		return -EINVAL;
4926 
4927 	/* Sanity check on user data */
4928 	if (!isdigit(buf[0]))
4929 		return -EINVAL;
4930 	if (kstrtoul(buf, 0, &val))
4931 		return -EINVAL;
4932 
4933 	if (val < LPFC_CQ_MIN_PROC_LIMIT || val > LPFC_CQ_MAX_PROC_LIMIT)
4934 		return -ERANGE;
4935 
4936 	phba->cfg_cq_max_proc_limit = (uint32_t)val;
4937 
4938 	/* set the values on the cq's */
4939 	for (i = 0; i < phba->cfg_irq_chann; i++) {
4940 		/* Get the EQ corresponding to the IRQ vector */
4941 		eq = phba->sli4_hba.hba_eq_hdl[i].eq;
4942 		if (!eq)
4943 			continue;
4944 
4945 		list_for_each_entry(cq, &eq->child_list, list)
4946 			cq->max_proc_limit = min(phba->cfg_cq_max_proc_limit,
4947 						 cq->entry_count);
4948 	}
4949 
4950 	return strlen(buf);
4951 }
4952 
4953 /*
4954  * lpfc_cq_max_proc_limit: The maximum number CQE entries processed in an
4955  *   itteration of CQ processing.
4956  */
4957 static int lpfc_cq_max_proc_limit = LPFC_CQ_DEF_MAX_PROC_LIMIT;
4958 module_param(lpfc_cq_max_proc_limit, int, 0644);
4959 MODULE_PARM_DESC(lpfc_cq_max_proc_limit,
4960 	    "Set the maximum number CQEs processed in an iteration of "
4961 	    "CQ processing");
4962 lpfc_param_show(cq_max_proc_limit)
4963 
4964 /*
4965  * lpfc_cq_poll_threshold: Set the threshold of CQE completions in a
4966  *   single handler call which should request a polled completion rather
4967  *   than re-enabling interrupts.
4968  */
4969 LPFC_ATTR_RW(cq_poll_threshold, LPFC_CQ_DEF_THRESHOLD_TO_POLL,
4970 	     LPFC_CQ_MIN_THRESHOLD_TO_POLL,
4971 	     LPFC_CQ_MAX_THRESHOLD_TO_POLL,
4972 	     "CQE Processing Threshold to enable Polling");
4973 
4974 /**
4975  * lpfc_cq_max_proc_limit_init - Set the initial cq max_proc_limit
4976  * @phba: lpfc_hba pointer.
4977  * @val: entry limit
4978  *
4979  * Description:
4980  * If val is in a valid range, then initialize the adapter's maximum
4981  * value.
4982  *
4983  * Returns:
4984  *  Always returns 0 for success, even if value not always set to
4985  *  requested value. If value out of range or not supported, will fall
4986  *  back to default.
4987  **/
4988 static int
lpfc_cq_max_proc_limit_init(struct lpfc_hba * phba,int val)4989 lpfc_cq_max_proc_limit_init(struct lpfc_hba *phba, int val)
4990 {
4991 	phba->cfg_cq_max_proc_limit = LPFC_CQ_DEF_MAX_PROC_LIMIT;
4992 
4993 	if (phba->sli_rev != LPFC_SLI_REV4)
4994 		return 0;
4995 
4996 	if (val >= LPFC_CQ_MIN_PROC_LIMIT && val <= LPFC_CQ_MAX_PROC_LIMIT) {
4997 		phba->cfg_cq_max_proc_limit = val;
4998 		return 0;
4999 	}
5000 
5001 	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5002 			"0371 lpfc_cq_max_proc_limit: %d out of range, using "
5003 			"default\n",
5004 			phba->cfg_cq_max_proc_limit);
5005 
5006 	return 0;
5007 }
5008 
5009 static DEVICE_ATTR_RW(lpfc_cq_max_proc_limit);
5010 
5011 /**
5012  * lpfc_fcp_cpu_map_show - Display current driver CPU affinity
5013  * @dev: class converted to a Scsi_host structure.
5014  * @attr: device attribute, not used.
5015  * @buf: on return contains text describing the state of the link.
5016  *
5017  * Returns: size of formatted string.
5018  **/
5019 static ssize_t
lpfc_fcp_cpu_map_show(struct device * dev,struct device_attribute * attr,char * buf)5020 lpfc_fcp_cpu_map_show(struct device *dev, struct device_attribute *attr,
5021 		      char *buf)
5022 {
5023 	struct Scsi_Host  *shost = class_to_shost(dev);
5024 	struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
5025 	struct lpfc_hba   *phba = vport->phba;
5026 	struct lpfc_vector_map_info *cpup;
5027 	int  len = 0;
5028 
5029 	if ((phba->sli_rev != LPFC_SLI_REV4) ||
5030 	    (phba->intr_type != MSIX))
5031 		return len;
5032 
5033 	switch (phba->cfg_fcp_cpu_map) {
5034 	case 0:
5035 		len += scnprintf(buf + len, PAGE_SIZE-len,
5036 				"fcp_cpu_map: No mapping (%d)\n",
5037 				phba->cfg_fcp_cpu_map);
5038 		return len;
5039 	case 1:
5040 		len += scnprintf(buf + len, PAGE_SIZE-len,
5041 				"fcp_cpu_map: HBA centric mapping (%d): "
5042 				"%d of %d CPUs online from %d possible CPUs\n",
5043 				phba->cfg_fcp_cpu_map, num_online_cpus(),
5044 				num_present_cpus(),
5045 				phba->sli4_hba.num_possible_cpu);
5046 		break;
5047 	}
5048 
5049 	while (phba->sli4_hba.curr_disp_cpu <
5050 	       phba->sli4_hba.num_possible_cpu) {
5051 		cpup = &phba->sli4_hba.cpu_map[phba->sli4_hba.curr_disp_cpu];
5052 
5053 		if (!cpu_present(phba->sli4_hba.curr_disp_cpu))
5054 			len += scnprintf(buf + len, PAGE_SIZE - len,
5055 					"CPU %02d not present\n",
5056 					phba->sli4_hba.curr_disp_cpu);
5057 		else if (cpup->eq == LPFC_VECTOR_MAP_EMPTY) {
5058 			if (cpup->hdwq == LPFC_VECTOR_MAP_EMPTY)
5059 				len += scnprintf(
5060 					buf + len, PAGE_SIZE - len,
5061 					"CPU %02d hdwq None "
5062 					"physid %d coreid %d ht %d ua %d\n",
5063 					phba->sli4_hba.curr_disp_cpu,
5064 					cpup->phys_id, cpup->core_id,
5065 					(cpup->flag & LPFC_CPU_MAP_HYPER),
5066 					(cpup->flag & LPFC_CPU_MAP_UNASSIGN));
5067 			else
5068 				len += scnprintf(
5069 					buf + len, PAGE_SIZE - len,
5070 					"CPU %02d EQ None hdwq %04d "
5071 					"physid %d coreid %d ht %d ua %d\n",
5072 					phba->sli4_hba.curr_disp_cpu,
5073 					cpup->hdwq, cpup->phys_id,
5074 					cpup->core_id,
5075 					(cpup->flag & LPFC_CPU_MAP_HYPER),
5076 					(cpup->flag & LPFC_CPU_MAP_UNASSIGN));
5077 		} else {
5078 			if (cpup->hdwq == LPFC_VECTOR_MAP_EMPTY)
5079 				len += scnprintf(
5080 					buf + len, PAGE_SIZE - len,
5081 					"CPU %02d hdwq None "
5082 					"physid %d coreid %d ht %d ua %d IRQ %d\n",
5083 					phba->sli4_hba.curr_disp_cpu,
5084 					cpup->phys_id,
5085 					cpup->core_id,
5086 					(cpup->flag & LPFC_CPU_MAP_HYPER),
5087 					(cpup->flag & LPFC_CPU_MAP_UNASSIGN),
5088 					lpfc_get_irq(cpup->eq));
5089 			else
5090 				len += scnprintf(
5091 					buf + len, PAGE_SIZE - len,
5092 					"CPU %02d EQ %04d hdwq %04d "
5093 					"physid %d coreid %d ht %d ua %d IRQ %d\n",
5094 					phba->sli4_hba.curr_disp_cpu,
5095 					cpup->eq, cpup->hdwq, cpup->phys_id,
5096 					cpup->core_id,
5097 					(cpup->flag & LPFC_CPU_MAP_HYPER),
5098 					(cpup->flag & LPFC_CPU_MAP_UNASSIGN),
5099 					lpfc_get_irq(cpup->eq));
5100 		}
5101 
5102 		phba->sli4_hba.curr_disp_cpu++;
5103 
5104 		/* display max number of CPUs keeping some margin */
5105 		if (phba->sli4_hba.curr_disp_cpu <
5106 				phba->sli4_hba.num_possible_cpu &&
5107 				(len >= (PAGE_SIZE - 64))) {
5108 			len += scnprintf(buf + len,
5109 					PAGE_SIZE - len, "more...\n");
5110 			break;
5111 		}
5112 	}
5113 
5114 	if (phba->sli4_hba.curr_disp_cpu == phba->sli4_hba.num_possible_cpu)
5115 		phba->sli4_hba.curr_disp_cpu = 0;
5116 
5117 	return len;
5118 }
5119 
5120 /**
5121  * lpfc_fcp_cpu_map_store - Change CPU affinity of driver vectors
5122  * @dev: class device that is converted into a Scsi_host.
5123  * @attr: device attribute, not used.
5124  * @buf: one or more lpfc_polling_flags values.
5125  * @count: not used.
5126  *
5127  * Returns:
5128  * -EINVAL  - Not implemented yet.
5129  **/
5130 static ssize_t
lpfc_fcp_cpu_map_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)5131 lpfc_fcp_cpu_map_store(struct device *dev, struct device_attribute *attr,
5132 		       const char *buf, size_t count)
5133 {
5134 	return -EINVAL;
5135 }
5136 
5137 /*
5138 # lpfc_fcp_cpu_map: Defines how to map CPUs to IRQ vectors
5139 # for the HBA.
5140 #
5141 # Value range is [0 to 1]. Default value is LPFC_HBA_CPU_MAP (1).
5142 #	0 - Do not affinitze IRQ vectors
5143 #	1 - Affintize HBA vectors with respect to each HBA
5144 #	    (start with CPU0 for each HBA)
5145 # This also defines how Hardware Queues are mapped to specific CPUs.
5146 */
5147 static int lpfc_fcp_cpu_map = LPFC_HBA_CPU_MAP;
5148 module_param(lpfc_fcp_cpu_map, int, S_IRUGO|S_IWUSR);
5149 MODULE_PARM_DESC(lpfc_fcp_cpu_map,
5150 		 "Defines how to map CPUs to IRQ vectors per HBA");
5151 
5152 /**
5153  * lpfc_fcp_cpu_map_init - Set the initial sr-iov virtual function enable
5154  * @phba: lpfc_hba pointer.
5155  * @val: link speed value.
5156  *
5157  * Description:
5158  * If val is in a valid range [0-2], then affinitze the adapter's
5159  * MSIX vectors.
5160  *
5161  * Returns:
5162  * zero if val saved.
5163  * -EINVAL val out of range
5164  **/
5165 static int
lpfc_fcp_cpu_map_init(struct lpfc_hba * phba,int val)5166 lpfc_fcp_cpu_map_init(struct lpfc_hba *phba, int val)
5167 {
5168 	if (phba->sli_rev != LPFC_SLI_REV4) {
5169 		phba->cfg_fcp_cpu_map = 0;
5170 		return 0;
5171 	}
5172 
5173 	if (val >= LPFC_MIN_CPU_MAP && val <= LPFC_MAX_CPU_MAP) {
5174 		phba->cfg_fcp_cpu_map = val;
5175 		return 0;
5176 	}
5177 
5178 	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5179 			"3326 lpfc_fcp_cpu_map: %d out of range, using "
5180 			"default\n", val);
5181 	phba->cfg_fcp_cpu_map = LPFC_HBA_CPU_MAP;
5182 
5183 	return 0;
5184 }
5185 
5186 static DEVICE_ATTR_RW(lpfc_fcp_cpu_map);
5187 
5188 /*
5189 # lpfc_fcp_class:  Determines FC class to use for the FCP protocol.
5190 # Value range is [2,3]. Default value is 3.
5191 */
5192 LPFC_VPORT_ATTR_R(fcp_class, 3, 2, 3,
5193 		  "Select Fibre Channel class of service for FCP sequences");
5194 
5195 /*
5196 # lpfc_use_adisc: Use ADISC for FCP rediscovery instead of PLOGI. Value range
5197 # is [0,1]. Default value is 1.
5198 */
5199 LPFC_VPORT_ATTR_RW(use_adisc, 1, 0, 1,
5200 		   "Use ADISC on rediscovery to authenticate FCP devices");
5201 
5202 /*
5203 # lpfc_first_burst_size: First burst size to use on the NPorts
5204 # that support first burst.
5205 # Value range is [0,65536]. Default value is 0.
5206 */
5207 LPFC_VPORT_ATTR_RW(first_burst_size, 0, 0, 65536,
5208 		   "First burst size for Targets that support first burst");
5209 
5210 /*
5211 * lpfc_nvmet_fb_size: NVME Target mode supported first burst size.
5212 * When the driver is configured as an NVME target, this value is
5213 * communicated to the NVME initiator in the PRLI response.  It is
5214 * used only when the lpfc_nvme_enable_fb and lpfc_nvmet_support
5215 * parameters are set and the target is sending the PRLI RSP.
5216 * Parameter supported on physical port only - no NPIV support.
5217 * Value range is [0,65536]. Default value is 0.
5218 */
5219 LPFC_ATTR_RW(nvmet_fb_size, 0, 0, 65536,
5220 	     "NVME Target mode first burst size in 512B increments.");
5221 
5222 /*
5223  * lpfc_nvme_enable_fb: Enable NVME first burst on I and T functions.
5224  * For the Initiator (I), enabling this parameter means that an NVMET
5225  * PRLI response with FBA enabled and an FB_SIZE set to a nonzero value will be
5226  * processed by the initiator for subsequent NVME FCP IO.
5227  * Currently, this feature is not supported on the NVME target
5228  * Value range is [0,1]. Default value is 0 (disabled).
5229  */
5230 LPFC_ATTR_RW(nvme_enable_fb, 0, 0, 1,
5231 	     "Enable First Burst feature for NVME Initiator.");
5232 
5233 /*
5234 # lpfc_max_scsicmpl_time: Use scsi command completion time to control I/O queue
5235 # depth. Default value is 0. When the value of this parameter is zero the
5236 # SCSI command completion time is not used for controlling I/O queue depth. When
5237 # the parameter is set to a non-zero value, the I/O queue depth is controlled
5238 # to limit the I/O completion time to the parameter value.
5239 # The value is set in milliseconds.
5240 */
5241 LPFC_VPORT_ATTR(max_scsicmpl_time, 0, 0, 60000,
5242 	"Use command completion time to control queue depth");
5243 
5244 lpfc_vport_param_show(max_scsicmpl_time);
5245 static int
lpfc_max_scsicmpl_time_set(struct lpfc_vport * vport,int val)5246 lpfc_max_scsicmpl_time_set(struct lpfc_vport *vport, int val)
5247 {
5248 	struct lpfc_nodelist *ndlp, *next_ndlp;
5249 	unsigned long iflags;
5250 
5251 	if (val == vport->cfg_max_scsicmpl_time)
5252 		return 0;
5253 	if ((val < 0) || (val > 60000))
5254 		return -EINVAL;
5255 	vport->cfg_max_scsicmpl_time = val;
5256 
5257 	spin_lock_irqsave(&vport->fc_nodes_list_lock, iflags);
5258 	list_for_each_entry_safe(ndlp, next_ndlp, &vport->fc_nodes, nlp_listp) {
5259 		if (ndlp->nlp_state == NLP_STE_UNUSED_NODE)
5260 			continue;
5261 		ndlp->cmd_qdepth = vport->cfg_tgt_queue_depth;
5262 	}
5263 	spin_unlock_irqrestore(&vport->fc_nodes_list_lock, iflags);
5264 	return 0;
5265 }
5266 lpfc_vport_param_store(max_scsicmpl_time);
5267 static DEVICE_ATTR_RW(lpfc_max_scsicmpl_time);
5268 
5269 /*
5270 # lpfc_ack0: Use ACK0, instead of ACK1 for class 2 acknowledgement. Value
5271 # range is [0,1]. Default value is 0.
5272 */
5273 LPFC_ATTR_R(ack0, 0, 0, 1, "Enable ACK0 support");
5274 
5275 /*
5276 # lpfc_xri_rebalancing: enable or disable XRI rebalancing feature
5277 # range is [0,1]. Default value is 1.
5278 */
5279 LPFC_ATTR_R(xri_rebalancing, 1, 0, 1, "Enable/Disable XRI rebalancing");
5280 
5281 /*
5282  * lpfc_io_sched: Determine scheduling algrithmn for issuing FCP cmds
5283  * range is [0,1]. Default value is 0.
5284  * For [0], FCP commands are issued to Work Queues based on upper layer
5285  * hardware queue index.
5286  * For [1], FCP commands are issued to a Work Queue associated with the
5287  *          current CPU.
5288  *
5289  * LPFC_FCP_SCHED_BY_HDWQ == 0
5290  * LPFC_FCP_SCHED_BY_CPU == 1
5291  *
5292  * The driver dynamically sets this to 1 (BY_CPU) if it's able to set up cpu
5293  * affinity for FCP/NVME I/Os through Work Queues associated with the current
5294  * CPU. Otherwise, the default 0 (Round Robin) scheduling of FCP/NVME I/Os
5295  * through WQs will be used.
5296  */
5297 LPFC_ATTR_RW(fcp_io_sched, LPFC_FCP_SCHED_BY_CPU,
5298 	     LPFC_FCP_SCHED_BY_HDWQ,
5299 	     LPFC_FCP_SCHED_BY_CPU,
5300 	     "Determine scheduling algorithm for "
5301 	     "issuing commands [0] - Hardware Queue, [1] - Current CPU");
5302 
5303 /*
5304  * lpfc_ns_query: Determine algrithmn for NameServer queries after RSCN
5305  * range is [0,1]. Default value is 0.
5306  * For [0], GID_FT is used for NameServer queries after RSCN (default)
5307  * For [1], GID_PT is used for NameServer queries after RSCN
5308  *
5309  */
5310 LPFC_ATTR_RW(ns_query, LPFC_NS_QUERY_GID_FT,
5311 	     LPFC_NS_QUERY_GID_FT, LPFC_NS_QUERY_GID_PT,
5312 	     "Determine algorithm NameServer queries after RSCN "
5313 	     "[0] - GID_FT, [1] - GID_PT");
5314 
5315 /*
5316 # lpfc_fcp2_no_tgt_reset: Determine bus reset behavior
5317 # range is [0,1]. Default value is 0.
5318 # For [0], bus reset issues target reset to ALL devices
5319 # For [1], bus reset issues target reset to non-FCP2 devices
5320 */
5321 LPFC_ATTR_RW(fcp2_no_tgt_reset, 0, 0, 1, "Determine bus reset behavior for "
5322 	     "FCP2 devices [0] - issue tgt reset, [1] - no tgt reset");
5323 
5324 
5325 /*
5326 # lpfc_cr_delay & lpfc_cr_count: Default values for I/O colaesing
5327 # cr_delay (msec) or cr_count outstanding commands. cr_delay can take
5328 # value [0,63]. cr_count can take value [1,255]. Default value of cr_delay
5329 # is 0. Default value of cr_count is 1. The cr_count feature is disabled if
5330 # cr_delay is set to 0.
5331 */
5332 LPFC_ATTR_RW(cr_delay, 0, 0, 63, "A count of milliseconds after which an "
5333 		"interrupt response is generated");
5334 
5335 LPFC_ATTR_RW(cr_count, 1, 1, 255, "A count of I/O completions after which an "
5336 		"interrupt response is generated");
5337 
5338 /*
5339 # lpfc_multi_ring_support:  Determines how many rings to spread available
5340 # cmd/rsp IOCB entries across.
5341 # Value range is [1,2]. Default value is 1.
5342 */
5343 LPFC_ATTR_R(multi_ring_support, 1, 1, 2, "Determines number of primary "
5344 		"SLI rings to spread IOCB entries across");
5345 
5346 /*
5347 # lpfc_multi_ring_rctl:  If lpfc_multi_ring_support is enabled, this
5348 # identifies what rctl value to configure the additional ring for.
5349 # Value range is [1,0xff]. Default value is 4 (Unsolicated Data).
5350 */
5351 LPFC_ATTR_R(multi_ring_rctl, FC_RCTL_DD_UNSOL_DATA, 1,
5352 	     255, "Identifies RCTL for additional ring configuration");
5353 
5354 /*
5355 # lpfc_multi_ring_type:  If lpfc_multi_ring_support is enabled, this
5356 # identifies what type value to configure the additional ring for.
5357 # Value range is [1,0xff]. Default value is 5 (LLC/SNAP).
5358 */
5359 LPFC_ATTR_R(multi_ring_type, FC_TYPE_IP, 1,
5360 	     255, "Identifies TYPE for additional ring configuration");
5361 
5362 /*
5363 # lpfc_enable_SmartSAN: Sets up FDMI support for SmartSAN
5364 #       0  = SmartSAN functionality disabled (default)
5365 #       1  = SmartSAN functionality enabled
5366 # This parameter will override the value of lpfc_fdmi_on module parameter.
5367 # Value range is [0,1]. Default value is 0.
5368 */
5369 LPFC_ATTR_R(enable_SmartSAN, 0, 0, 1, "Enable SmartSAN functionality");
5370 
5371 /*
5372 # lpfc_fdmi_on: Controls FDMI support.
5373 #       0       No FDMI support
5374 #       1       Traditional FDMI support (default)
5375 # Traditional FDMI support means the driver will assume FDMI-2 support;
5376 # however, if that fails, it will fallback to FDMI-1.
5377 # If lpfc_enable_SmartSAN is set to 1, the driver ignores lpfc_fdmi_on.
5378 # If lpfc_enable_SmartSAN is set 0, the driver uses the current value of
5379 # lpfc_fdmi_on.
5380 # Value range [0,1]. Default value is 1.
5381 */
5382 LPFC_ATTR_R(fdmi_on, 1, 0, 1, "Enable FDMI support");
5383 
5384 /*
5385 # Specifies the maximum number of ELS cmds we can have outstanding (for
5386 # discovery). Value range is [1,64]. Default value = 32.
5387 */
5388 LPFC_VPORT_ATTR(discovery_threads, 32, 1, 64, "Maximum number of ELS commands "
5389 		 "during discovery");
5390 
5391 /*
5392 # lpfc_max_luns: maximum allowed LUN ID. This is the highest LUN ID that
5393 #    will be scanned by the SCSI midlayer when sequential scanning is
5394 #    used; and is also the highest LUN ID allowed when the SCSI midlayer
5395 #    parses REPORT_LUN responses. The lpfc driver has no LUN count or
5396 #    LUN ID limit, but the SCSI midlayer requires this field for the uses
5397 #    above. The lpfc driver limits the default value to 255 for two reasons.
5398 #    As it bounds the sequential scan loop, scanning for thousands of luns
5399 #    on a target can take minutes of wall clock time.  Additionally,
5400 #    there are FC targets, such as JBODs, that only recognize 8-bits of
5401 #    LUN ID. When they receive a value greater than 8 bits, they chop off
5402 #    the high order bits. In other words, they see LUN IDs 0, 256, 512,
5403 #    and so on all as LUN ID 0. This causes the linux kernel, which sees
5404 #    valid responses at each of the LUN IDs, to believe there are multiple
5405 #    devices present, when in fact, there is only 1.
5406 #    A customer that is aware of their target behaviors, and the results as
5407 #    indicated above, is welcome to increase the lpfc_max_luns value.
5408 #    As mentioned, this value is not used by the lpfc driver, only the
5409 #    SCSI midlayer.
5410 # Value range is [0,65535]. Default value is 255.
5411 # NOTE: The SCSI layer might probe all allowed LUN on some old targets.
5412 */
5413 LPFC_VPORT_ULL_ATTR_R(max_luns, 255, 0, 65535, "Maximum allowed LUN ID");
5414 
5415 /*
5416 # lpfc_poll_tmo: .Milliseconds driver will wait between polling FCP ring.
5417 # Value range is [1,255], default value is 10.
5418 */
5419 LPFC_ATTR_RW(poll_tmo, 10, 1, 255,
5420 	     "Milliseconds driver will wait between polling FCP ring");
5421 
5422 /*
5423 # lpfc_task_mgmt_tmo: Maximum time to wait for task management commands
5424 # to complete in seconds. Value range is [5,180], default value is 60.
5425 */
5426 LPFC_ATTR_RW(task_mgmt_tmo, 60, 5, 180,
5427 	     "Maximum time to wait for task management commands to complete");
5428 /*
5429 # lpfc_use_msi: Use MSI (Message Signaled Interrupts) in systems that
5430 #		support this feature
5431 #       0  = MSI disabled
5432 #       1  = MSI enabled
5433 #       2  = MSI-X enabled (default)
5434 # Value range is [0,2]. Default value is 2.
5435 */
5436 LPFC_ATTR_R(use_msi, 2, 0, 2, "Use Message Signaled Interrupts (1) or "
5437 	    "MSI-X (2), if possible");
5438 
5439 /*
5440  * lpfc_nvme_oas: Use the oas bit when sending NVME/NVMET IOs
5441  *
5442  *      0  = NVME OAS disabled
5443  *      1  = NVME OAS enabled
5444  *
5445  * Value range is [0,1]. Default value is 0.
5446  */
5447 LPFC_ATTR_RW(nvme_oas, 0, 0, 1,
5448 	     "Use OAS bit on NVME IOs");
5449 
5450 /*
5451  * lpfc_nvme_embed_cmd: Use the oas bit when sending NVME/NVMET IOs
5452  *
5453  *      0  = Put NVME Command in SGL
5454  *      1  = Embed NVME Command in WQE (unless G7)
5455  *      2 =  Embed NVME Command in WQE (force)
5456  *
5457  * Value range is [0,2]. Default value is 1.
5458  */
5459 LPFC_ATTR_RW(nvme_embed_cmd, 1, 0, 2,
5460 	     "Embed NVME Command in WQE");
5461 
5462 /*
5463  * lpfc_fcp_mq_threshold: Set the maximum number of Hardware Queues
5464  * the driver will advertise it supports to the SCSI layer.
5465  *
5466  *      0    = Set nr_hw_queues by the number of CPUs or HW queues.
5467  *      1,256 = Manually specify nr_hw_queue value to be advertised,
5468  *
5469  * Value range is [0,256]. Default value is 8.
5470  */
5471 LPFC_ATTR_R(fcp_mq_threshold, LPFC_FCP_MQ_THRESHOLD_DEF,
5472 	    LPFC_FCP_MQ_THRESHOLD_MIN, LPFC_FCP_MQ_THRESHOLD_MAX,
5473 	    "Set the number of SCSI Queues advertised");
5474 
5475 /*
5476  * lpfc_hdw_queue: Set the number of Hardware Queues the driver
5477  * will advertise it supports to the NVME and  SCSI layers. This also
5478  * will map to the number of CQ/WQ pairs the driver will create.
5479  *
5480  * The NVME Layer will try to create this many, plus 1 administrative
5481  * hardware queue. The administrative queue will always map to WQ 0
5482  * A hardware IO queue maps (qidx) to a specific driver CQ/WQ.
5483  *
5484  *      0    = Configure the number of hdw queues to the number of active CPUs.
5485  *      1,256 = Manually specify how many hdw queues to use.
5486  *
5487  * Value range is [0,256]. Default value is 0.
5488  */
5489 LPFC_ATTR_R(hdw_queue,
5490 	    LPFC_HBA_HDWQ_DEF,
5491 	    LPFC_HBA_HDWQ_MIN, LPFC_HBA_HDWQ_MAX,
5492 	    "Set the number of I/O Hardware Queues");
5493 
5494 #if IS_ENABLED(CONFIG_X86)
5495 /**
5496  * lpfc_cpumask_irq_mode_init - initalizes cpumask of phba based on
5497  *				irq_chann_mode
5498  * @phba: Pointer to HBA context object.
5499  **/
5500 static void
lpfc_cpumask_irq_mode_init(struct lpfc_hba * phba)5501 lpfc_cpumask_irq_mode_init(struct lpfc_hba *phba)
5502 {
5503 	unsigned int cpu, first_cpu, numa_node = NUMA_NO_NODE;
5504 	const struct cpumask *sibling_mask;
5505 	struct cpumask *aff_mask = &phba->sli4_hba.irq_aff_mask;
5506 
5507 	cpumask_clear(aff_mask);
5508 
5509 	if (phba->irq_chann_mode == NUMA_MODE) {
5510 		/* Check if we're a NUMA architecture */
5511 		numa_node = dev_to_node(&phba->pcidev->dev);
5512 		if (numa_node == NUMA_NO_NODE) {
5513 			phba->irq_chann_mode = NORMAL_MODE;
5514 			return;
5515 		}
5516 	}
5517 
5518 	for_each_possible_cpu(cpu) {
5519 		switch (phba->irq_chann_mode) {
5520 		case NUMA_MODE:
5521 			if (cpu_to_node(cpu) == numa_node)
5522 				cpumask_set_cpu(cpu, aff_mask);
5523 			break;
5524 		case NHT_MODE:
5525 			sibling_mask = topology_sibling_cpumask(cpu);
5526 			first_cpu = cpumask_first(sibling_mask);
5527 			if (first_cpu < nr_cpu_ids)
5528 				cpumask_set_cpu(first_cpu, aff_mask);
5529 			break;
5530 		default:
5531 			break;
5532 		}
5533 	}
5534 }
5535 #endif
5536 
5537 static void
lpfc_assign_default_irq_chann(struct lpfc_hba * phba)5538 lpfc_assign_default_irq_chann(struct lpfc_hba *phba)
5539 {
5540 #if IS_ENABLED(CONFIG_X86)
5541 	switch (boot_cpu_data.x86_vendor) {
5542 	case X86_VENDOR_AMD:
5543 		/* If AMD architecture, then default is NUMA_MODE */
5544 		phba->irq_chann_mode = NUMA_MODE;
5545 		break;
5546 	case X86_VENDOR_INTEL:
5547 		/* If Intel architecture, then default is no hyperthread mode */
5548 		phba->irq_chann_mode = NHT_MODE;
5549 		break;
5550 	default:
5551 		phba->irq_chann_mode = NORMAL_MODE;
5552 		break;
5553 	}
5554 	lpfc_cpumask_irq_mode_init(phba);
5555 #else
5556 	phba->irq_chann_mode = NORMAL_MODE;
5557 #endif
5558 }
5559 
5560 /*
5561  * lpfc_irq_chann: Set the number of IRQ vectors that are available
5562  * for Hardware Queues to utilize.  This also will map to the number
5563  * of EQ / MSI-X vectors the driver will create. This should never be
5564  * more than the number of Hardware Queues
5565  *
5566  *	0		= Configure number of IRQ Channels to:
5567  *			  if AMD architecture, number of CPUs on HBA's NUMA node
5568  *			  if Intel architecture, number of physical CPUs.
5569  *			  otherwise, number of active CPUs.
5570  *	[1,256]		= Manually specify how many IRQ Channels to use.
5571  *
5572  * Value range is [0,256]. Default value is [0].
5573  */
5574 static uint lpfc_irq_chann = LPFC_IRQ_CHANN_DEF;
5575 module_param(lpfc_irq_chann, uint, 0444);
5576 MODULE_PARM_DESC(lpfc_irq_chann, "Set number of interrupt vectors to allocate");
5577 
5578 /* lpfc_irq_chann_init - Set the hba irq_chann initial value
5579  * @phba: lpfc_hba pointer.
5580  * @val: contains the initial value
5581  *
5582  * Description:
5583  * Validates the initial value is within range and assigns it to the
5584  * adapter. If not in range, an error message is posted and the
5585  * default value is assigned.
5586  *
5587  * Returns:
5588  * zero if value is in range and is set
5589  * -EINVAL if value was out of range
5590  **/
5591 static int
lpfc_irq_chann_init(struct lpfc_hba * phba,uint32_t val)5592 lpfc_irq_chann_init(struct lpfc_hba *phba, uint32_t val)
5593 {
5594 	const struct cpumask *aff_mask;
5595 
5596 	if (phba->cfg_use_msi != 2) {
5597 		lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
5598 				"8532 use_msi = %u ignoring cfg_irq_numa\n",
5599 				phba->cfg_use_msi);
5600 		phba->irq_chann_mode = NORMAL_MODE;
5601 		phba->cfg_irq_chann = LPFC_IRQ_CHANN_DEF;
5602 		return 0;
5603 	}
5604 
5605 	/* Check if default setting was passed */
5606 	if (val == LPFC_IRQ_CHANN_DEF &&
5607 	    phba->cfg_hdw_queue == LPFC_HBA_HDWQ_DEF &&
5608 	    phba->sli_rev == LPFC_SLI_REV4)
5609 		lpfc_assign_default_irq_chann(phba);
5610 
5611 	if (phba->irq_chann_mode != NORMAL_MODE) {
5612 		aff_mask = &phba->sli4_hba.irq_aff_mask;
5613 
5614 		if (cpumask_empty(aff_mask)) {
5615 			lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
5616 					"8533 Could not identify CPUS for "
5617 					"mode %d, ignoring\n",
5618 					phba->irq_chann_mode);
5619 			phba->irq_chann_mode = NORMAL_MODE;
5620 			phba->cfg_irq_chann = LPFC_IRQ_CHANN_DEF;
5621 		} else {
5622 			phba->cfg_irq_chann = cpumask_weight(aff_mask);
5623 
5624 			/* If no hyperthread mode, then set hdwq count to
5625 			 * aff_mask weight as well
5626 			 */
5627 			if (phba->irq_chann_mode == NHT_MODE)
5628 				phba->cfg_hdw_queue = phba->cfg_irq_chann;
5629 
5630 			lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
5631 					"8543 lpfc_irq_chann set to %u "
5632 					"(mode: %d)\n", phba->cfg_irq_chann,
5633 					phba->irq_chann_mode);
5634 		}
5635 	} else {
5636 		if (val > LPFC_IRQ_CHANN_MAX) {
5637 			lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
5638 					"8545 lpfc_irq_chann attribute cannot "
5639 					"be set to %u, allowed range is "
5640 					"[%u,%u]\n",
5641 					val,
5642 					LPFC_IRQ_CHANN_MIN,
5643 					LPFC_IRQ_CHANN_MAX);
5644 			phba->cfg_irq_chann = LPFC_IRQ_CHANN_DEF;
5645 			return -EINVAL;
5646 		}
5647 		if (phba->sli_rev == LPFC_SLI_REV4) {
5648 			phba->cfg_irq_chann = val;
5649 		} else {
5650 			phba->cfg_irq_chann = 2;
5651 			phba->cfg_hdw_queue = 1;
5652 		}
5653 	}
5654 
5655 	return 0;
5656 }
5657 
5658 /**
5659  * lpfc_irq_chann_show - Display value of irq_chann
5660  * @dev: class converted to a Scsi_host structure.
5661  * @attr: device attribute, not used.
5662  * @buf: on return contains a string with the list sizes
5663  *
5664  * Returns: size of formatted string.
5665  **/
5666 static ssize_t
lpfc_irq_chann_show(struct device * dev,struct device_attribute * attr,char * buf)5667 lpfc_irq_chann_show(struct device *dev, struct device_attribute *attr,
5668 		    char *buf)
5669 {
5670 	struct Scsi_Host *shost = class_to_shost(dev);
5671 	struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
5672 	struct lpfc_hba *phba = vport->phba;
5673 
5674 	return scnprintf(buf, PAGE_SIZE, "%u\n", phba->cfg_irq_chann);
5675 }
5676 
5677 static DEVICE_ATTR_RO(lpfc_irq_chann);
5678 
5679 /*
5680 # lpfc_enable_hba_reset: Allow or prevent HBA resets to the hardware.
5681 #       0  = HBA resets disabled
5682 #       1  = HBA resets enabled (default)
5683 #       2  = HBA reset via PCI bus reset enabled
5684 # Value range is [0,2]. Default value is 1.
5685 */
5686 LPFC_ATTR_RW(enable_hba_reset, 1, 0, 2, "Enable HBA resets from the driver.");
5687 
5688 /*
5689 # lpfc_enable_hba_heartbeat: Disable HBA heartbeat timer..
5690 #       0  = HBA Heartbeat disabled
5691 #       1  = HBA Heartbeat enabled (default)
5692 # Value range is [0,1]. Default value is 1.
5693 */
5694 LPFC_ATTR_R(enable_hba_heartbeat, 0, 0, 1, "Enable HBA Heartbeat.");
5695 
5696 /*
5697 # lpfc_EnableXLane: Enable Express Lane Feature
5698 #      0x0   Express Lane Feature disabled
5699 #      0x1   Express Lane Feature enabled
5700 # Value range is [0,1]. Default value is 0.
5701 */
5702 LPFC_ATTR_R(EnableXLane, 0, 0, 1, "Enable Express Lane Feature.");
5703 
5704 /*
5705 # lpfc_XLanePriority:  Define CS_CTL priority for Express Lane Feature
5706 #       0x0 - 0x7f  = CS_CTL field in FC header (high 7 bits)
5707 # Value range is [0x0,0x7f]. Default value is 0
5708 */
5709 LPFC_ATTR_RW(XLanePriority, 0, 0x0, 0x7f, "CS_CTL for Express Lane Feature.");
5710 
5711 /*
5712 # lpfc_enable_bg: Enable BlockGuard (Emulex's Implementation of T10-DIF)
5713 #       0  = BlockGuard disabled (default)
5714 #       1  = BlockGuard enabled
5715 # Value range is [0,1]. Default value is 0.
5716 */
5717 LPFC_ATTR_R(enable_bg, 0, 0, 1, "Enable BlockGuard Support");
5718 
5719 /*
5720 # lpfc_prot_mask:
5721 #	- Bit mask of host protection capabilities used to register with the
5722 #	  SCSI mid-layer
5723 # 	- Only meaningful if BG is turned on (lpfc_enable_bg=1).
5724 #	- Allows you to ultimately specify which profiles to use
5725 #	- Default will result in registering capabilities for all profiles.
5726 #	- SHOST_DIF_TYPE1_PROTECTION	1
5727 #		HBA supports T10 DIF Type 1: HBA to Target Type 1 Protection
5728 #	- SHOST_DIX_TYPE0_PROTECTION	8
5729 #		HBA supports DIX Type 0: Host to HBA protection only
5730 #	- SHOST_DIX_TYPE1_PROTECTION	16
5731 #		HBA supports DIX Type 1: Host to HBA  Type 1 protection
5732 #
5733 */
5734 LPFC_ATTR(prot_mask,
5735 	(SHOST_DIF_TYPE1_PROTECTION |
5736 	SHOST_DIX_TYPE0_PROTECTION |
5737 	SHOST_DIX_TYPE1_PROTECTION),
5738 	0,
5739 	(SHOST_DIF_TYPE1_PROTECTION |
5740 	SHOST_DIX_TYPE0_PROTECTION |
5741 	SHOST_DIX_TYPE1_PROTECTION),
5742 	"T10-DIF host protection capabilities mask");
5743 
5744 /*
5745 # lpfc_prot_guard:
5746 #	- Bit mask of protection guard types to register with the SCSI mid-layer
5747 #	- Guard types are currently either 1) T10-DIF CRC 2) IP checksum
5748 #	- Allows you to ultimately specify which profiles to use
5749 #	- Default will result in registering capabilities for all guard types
5750 #
5751 */
5752 LPFC_ATTR(prot_guard,
5753 	SHOST_DIX_GUARD_IP, SHOST_DIX_GUARD_CRC, SHOST_DIX_GUARD_IP,
5754 	"T10-DIF host protection guard type");
5755 
5756 /*
5757  * Delay initial NPort discovery when Clean Address bit is cleared in
5758  * FLOGI/FDISC accept and FCID/Fabric name/Fabric portname is changed.
5759  * This parameter can have value 0 or 1.
5760  * When this parameter is set to 0, no delay is added to the initial
5761  * discovery.
5762  * When this parameter is set to non-zero value, initial Nport discovery is
5763  * delayed by ra_tov seconds when Clean Address bit is cleared in FLOGI/FDISC
5764  * accept and FCID/Fabric name/Fabric portname is changed.
5765  * Driver always delay Nport discovery for subsequent FLOGI/FDISC completion
5766  * when Clean Address bit is cleared in FLOGI/FDISC
5767  * accept and FCID/Fabric name/Fabric portname is changed.
5768  * Default value is 0.
5769  */
5770 LPFC_ATTR(delay_discovery, 0, 0, 1,
5771 	"Delay NPort discovery when Clean Address bit is cleared.");
5772 
5773 /*
5774  * lpfc_sg_seg_cnt - Initial Maximum DMA Segment Count
5775  * This value can be set to values between 64 and 4096. The default value
5776  * is 64, but may be increased to allow for larger Max I/O sizes. The scsi
5777  * and nvme layers will allow I/O sizes up to (MAX_SEG_COUNT * SEG_SIZE).
5778  * Because of the additional overhead involved in setting up T10-DIF,
5779  * this parameter will be limited to 128 if BlockGuard is enabled under SLI4
5780  * and will be limited to 512 if BlockGuard is enabled under SLI3.
5781  */
5782 static uint lpfc_sg_seg_cnt = LPFC_DEFAULT_SG_SEG_CNT;
5783 module_param(lpfc_sg_seg_cnt, uint, 0444);
5784 MODULE_PARM_DESC(lpfc_sg_seg_cnt, "Max Scatter Gather Segment Count");
5785 
5786 /**
5787  * lpfc_sg_seg_cnt_show - Display the scatter/gather list sizes
5788  *    configured for the adapter
5789  * @dev: class converted to a Scsi_host structure.
5790  * @attr: device attribute, not used.
5791  * @buf: on return contains a string with the list sizes
5792  *
5793  * Returns: size of formatted string.
5794  **/
5795 static ssize_t
lpfc_sg_seg_cnt_show(struct device * dev,struct device_attribute * attr,char * buf)5796 lpfc_sg_seg_cnt_show(struct device *dev, struct device_attribute *attr,
5797 		     char *buf)
5798 {
5799 	struct Scsi_Host  *shost = class_to_shost(dev);
5800 	struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
5801 	struct lpfc_hba   *phba = vport->phba;
5802 	int len;
5803 
5804 	len = scnprintf(buf, PAGE_SIZE, "SGL sz: %d  total SGEs: %d\n",
5805 		       phba->cfg_sg_dma_buf_size, phba->cfg_total_seg_cnt);
5806 
5807 	len += scnprintf(buf + len, PAGE_SIZE - len,
5808 			"Cfg: %d  SCSI: %d  NVME: %d\n",
5809 			phba->cfg_sg_seg_cnt, phba->cfg_scsi_seg_cnt,
5810 			phba->cfg_nvme_seg_cnt);
5811 	return len;
5812 }
5813 
5814 static DEVICE_ATTR_RO(lpfc_sg_seg_cnt);
5815 
5816 /**
5817  * lpfc_sg_seg_cnt_init - Set the hba sg_seg_cnt initial value
5818  * @phba: lpfc_hba pointer.
5819  * @val: contains the initial value
5820  *
5821  * Description:
5822  * Validates the initial value is within range and assigns it to the
5823  * adapter. If not in range, an error message is posted and the
5824  * default value is assigned.
5825  *
5826  * Returns:
5827  * zero if value is in range and is set
5828  * -EINVAL if value was out of range
5829  **/
5830 static int
lpfc_sg_seg_cnt_init(struct lpfc_hba * phba,int val)5831 lpfc_sg_seg_cnt_init(struct lpfc_hba *phba, int val)
5832 {
5833 	if (val >= LPFC_MIN_SG_SEG_CNT && val <= LPFC_MAX_SG_SEG_CNT) {
5834 		phba->cfg_sg_seg_cnt = val;
5835 		return 0;
5836 	}
5837 	lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5838 			"0409 lpfc_sg_seg_cnt attribute cannot be set to %d, "
5839 			"allowed range is [%d, %d]\n",
5840 			val, LPFC_MIN_SG_SEG_CNT, LPFC_MAX_SG_SEG_CNT);
5841 	phba->cfg_sg_seg_cnt = LPFC_DEFAULT_SG_SEG_CNT;
5842 	return -EINVAL;
5843 }
5844 
5845 /*
5846  * lpfc_enable_mds_diags: Enable MDS Diagnostics
5847  *       0  = MDS Diagnostics disabled (default)
5848  *       1  = MDS Diagnostics enabled
5849  * Value range is [0,1]. Default value is 0.
5850  */
5851 LPFC_ATTR_RW(enable_mds_diags, 0, 0, 1, "Enable MDS Diagnostics");
5852 
5853 /*
5854  * lpfc_ras_fwlog_buffsize: Firmware logging host buffer size
5855  *	0 = Disable firmware logging (default)
5856  *	[1-4] = Multiple of 1/4th Mb of host memory for FW logging
5857  * Value range [0..4]. Default value is 0
5858  */
5859 LPFC_ATTR(ras_fwlog_buffsize, 0, 0, 4, "Host memory for FW logging");
5860 lpfc_param_show(ras_fwlog_buffsize);
5861 
5862 static ssize_t
lpfc_ras_fwlog_buffsize_set(struct lpfc_hba * phba,uint val)5863 lpfc_ras_fwlog_buffsize_set(struct lpfc_hba  *phba, uint val)
5864 {
5865 	int ret = 0;
5866 	enum ras_state state;
5867 
5868 	if (!lpfc_rangecheck(val, 0, 4))
5869 		return -EINVAL;
5870 
5871 	if (phba->cfg_ras_fwlog_buffsize == val)
5872 		return 0;
5873 
5874 	if (phba->cfg_ras_fwlog_func != PCI_FUNC(phba->pcidev->devfn))
5875 		return -EINVAL;
5876 
5877 	spin_lock_irq(&phba->ras_fwlog_lock);
5878 	state = phba->ras_fwlog.state;
5879 	spin_unlock_irq(&phba->ras_fwlog_lock);
5880 
5881 	if (state == REG_INPROGRESS) {
5882 		lpfc_printf_log(phba, KERN_ERR, LOG_SLI, "6147 RAS Logging "
5883 				"registration is in progress\n");
5884 		return -EBUSY;
5885 	}
5886 
5887 	/* For disable logging: stop the logs and free the DMA.
5888 	 * For ras_fwlog_buffsize size change we still need to free and
5889 	 * reallocate the DMA in lpfc_sli4_ras_fwlog_init.
5890 	 */
5891 	phba->cfg_ras_fwlog_buffsize = val;
5892 	if (state == ACTIVE) {
5893 		lpfc_ras_stop_fwlog(phba);
5894 		lpfc_sli4_ras_dma_free(phba);
5895 	}
5896 
5897 	lpfc_sli4_ras_init(phba);
5898 	if (phba->ras_fwlog.ras_enabled)
5899 		ret = lpfc_sli4_ras_fwlog_init(phba, phba->cfg_ras_fwlog_level,
5900 					       LPFC_RAS_ENABLE_LOGGING);
5901 	return ret;
5902 }
5903 
5904 lpfc_param_store(ras_fwlog_buffsize);
5905 static DEVICE_ATTR_RW(lpfc_ras_fwlog_buffsize);
5906 
5907 /*
5908  * lpfc_ras_fwlog_level: Firmware logging verbosity level
5909  * Valid only if firmware logging is enabled
5910  * 0(Least Verbosity) 4 (most verbosity)
5911  * Value range is [0..4]. Default value is 0
5912  */
5913 LPFC_ATTR_RW(ras_fwlog_level, 0, 0, 4, "Firmware Logging Level");
5914 
5915 /*
5916  * lpfc_ras_fwlog_func: Firmware logging enabled on function number
5917  * Default function which has RAS support : 0
5918  * Value Range is [0..3].
5919  * FW logging is a global action and enablement is via a specific
5920  * port.
5921  */
5922 LPFC_ATTR_RW(ras_fwlog_func, 0, 0, 3, "Firmware Logging Enabled on Function");
5923 
5924 /*
5925  * lpfc_enable_bbcr: Enable BB Credit Recovery
5926  *       0  = BB Credit Recovery disabled
5927  *       1  = BB Credit Recovery enabled (default)
5928  * Value range is [0,1]. Default value is 1.
5929  */
5930 LPFC_BBCR_ATTR_RW(enable_bbcr, 1, 0, 1, "Enable BBC Recovery");
5931 
5932 /* Signaling module parameters */
5933 int lpfc_fabric_cgn_frequency = 100; /* 100 ms default */
5934 module_param(lpfc_fabric_cgn_frequency, int, 0444);
5935 MODULE_PARM_DESC(lpfc_fabric_cgn_frequency, "Congestion signaling fabric freq");
5936 
5937 unsigned char lpfc_acqe_cgn_frequency = 10; /* 10 sec default */
5938 module_param(lpfc_acqe_cgn_frequency, byte, 0444);
5939 MODULE_PARM_DESC(lpfc_acqe_cgn_frequency, "Congestion signaling ACQE freq");
5940 
5941 int lpfc_use_cgn_signal = 1; /* 0 - only use FPINs, 1 - Use signals if avail  */
5942 module_param(lpfc_use_cgn_signal, int, 0444);
5943 MODULE_PARM_DESC(lpfc_use_cgn_signal, "Use Congestion signaling if available");
5944 
5945 /*
5946  * lpfc_enable_dpp: Enable DPP on G7
5947  *       0  = DPP on G7 disabled
5948  *       1  = DPP on G7 enabled (default)
5949  * Value range is [0,1]. Default value is 1.
5950  */
5951 LPFC_ATTR_RW(enable_dpp, 1, 0, 1, "Enable Direct Packet Push");
5952 
5953 /*
5954  * lpfc_enable_mi: Enable FDMI MIB
5955  *       0  = disabled
5956  *       1  = enabled (default)
5957  * Value range is [0,1].
5958  */
5959 LPFC_ATTR_R(enable_mi, 1, 0, 1, "Enable MI");
5960 
5961 /*
5962  * lpfc_max_vmid: Maximum number of VMs to be tagged. This is valid only if
5963  * either vmid_app_header or vmid_priority_tagging is enabled.
5964  *       4 - 255  = vmid support enabled for 4-255 VMs
5965  *       Value range is [4,255].
5966  */
5967 LPFC_ATTR_R(max_vmid, LPFC_MIN_VMID, LPFC_MIN_VMID, LPFC_MAX_VMID,
5968 	     "Maximum number of VMs supported");
5969 
5970 /*
5971  * lpfc_vmid_inactivity_timeout: Inactivity timeout duration in hours
5972  *       0  = Timeout is disabled
5973  * Value range is [0,24].
5974  */
5975 LPFC_ATTR_R(vmid_inactivity_timeout, 4, 0, 24,
5976 	     "Inactivity timeout in hours");
5977 
5978 /*
5979  * lpfc_vmid_app_header: Enable App Header VMID support
5980  *       0  = Support is disabled (default)
5981  *       1  = Support is enabled
5982  * Value range is [0,1].
5983  */
5984 LPFC_ATTR_R(vmid_app_header, LPFC_VMID_APP_HEADER_DISABLE,
5985 	     LPFC_VMID_APP_HEADER_DISABLE, LPFC_VMID_APP_HEADER_ENABLE,
5986 	     "Enable App Header VMID support");
5987 
5988 /*
5989  * lpfc_vmid_priority_tagging: Enable Priority Tagging VMID support
5990  *       0  = Support is disabled (default)
5991  *       1  = Allow supported targets only
5992  *       2  = Allow all targets
5993  * Value range is [0,2].
5994  */
5995 LPFC_ATTR_R(vmid_priority_tagging, LPFC_VMID_PRIO_TAG_DISABLE,
5996 	     LPFC_VMID_PRIO_TAG_DISABLE,
5997 	     LPFC_VMID_PRIO_TAG_ALL_TARGETS,
5998 	     "Enable Priority Tagging VMID support");
5999 
6000 static struct attribute *lpfc_hba_attrs[] = {
6001 	&dev_attr_nvme_info.attr,
6002 	&dev_attr_scsi_stat.attr,
6003 	&dev_attr_bg_info.attr,
6004 	&dev_attr_bg_guard_err.attr,
6005 	&dev_attr_bg_apptag_err.attr,
6006 	&dev_attr_bg_reftag_err.attr,
6007 	&dev_attr_info.attr,
6008 	&dev_attr_serialnum.attr,
6009 	&dev_attr_modeldesc.attr,
6010 	&dev_attr_modelname.attr,
6011 	&dev_attr_programtype.attr,
6012 	&dev_attr_portnum.attr,
6013 	&dev_attr_fwrev.attr,
6014 	&dev_attr_hdw.attr,
6015 	&dev_attr_option_rom_version.attr,
6016 	&dev_attr_link_state.attr,
6017 	&dev_attr_num_discovered_ports.attr,
6018 	&dev_attr_lpfc_drvr_version.attr,
6019 	&dev_attr_lpfc_enable_fip.attr,
6020 	&dev_attr_lpfc_temp_sensor.attr,
6021 	&dev_attr_lpfc_log_verbose.attr,
6022 	&dev_attr_lpfc_lun_queue_depth.attr,
6023 	&dev_attr_lpfc_tgt_queue_depth.attr,
6024 	&dev_attr_lpfc_hba_queue_depth.attr,
6025 	&dev_attr_lpfc_peer_port_login.attr,
6026 	&dev_attr_lpfc_nodev_tmo.attr,
6027 	&dev_attr_lpfc_devloss_tmo.attr,
6028 	&dev_attr_lpfc_enable_fc4_type.attr,
6029 	&dev_attr_lpfc_fcp_class.attr,
6030 	&dev_attr_lpfc_use_adisc.attr,
6031 	&dev_attr_lpfc_first_burst_size.attr,
6032 	&dev_attr_lpfc_ack0.attr,
6033 	&dev_attr_lpfc_xri_rebalancing.attr,
6034 	&dev_attr_lpfc_topology.attr,
6035 	&dev_attr_lpfc_scan_down.attr,
6036 	&dev_attr_lpfc_link_speed.attr,
6037 	&dev_attr_lpfc_fcp_io_sched.attr,
6038 	&dev_attr_lpfc_ns_query.attr,
6039 	&dev_attr_lpfc_fcp2_no_tgt_reset.attr,
6040 	&dev_attr_lpfc_cr_delay.attr,
6041 	&dev_attr_lpfc_cr_count.attr,
6042 	&dev_attr_lpfc_multi_ring_support.attr,
6043 	&dev_attr_lpfc_multi_ring_rctl.attr,
6044 	&dev_attr_lpfc_multi_ring_type.attr,
6045 	&dev_attr_lpfc_fdmi_on.attr,
6046 	&dev_attr_lpfc_enable_SmartSAN.attr,
6047 	&dev_attr_lpfc_max_luns.attr,
6048 	&dev_attr_lpfc_enable_npiv.attr,
6049 	&dev_attr_lpfc_fcf_failover_policy.attr,
6050 	&dev_attr_lpfc_enable_rrq.attr,
6051 	&dev_attr_lpfc_fcp_wait_abts_rsp.attr,
6052 	&dev_attr_nport_evt_cnt.attr,
6053 	&dev_attr_board_mode.attr,
6054 	&dev_attr_lpfc_xcvr_data.attr,
6055 	&dev_attr_max_vpi.attr,
6056 	&dev_attr_used_vpi.attr,
6057 	&dev_attr_max_rpi.attr,
6058 	&dev_attr_used_rpi.attr,
6059 	&dev_attr_max_xri.attr,
6060 	&dev_attr_used_xri.attr,
6061 	&dev_attr_npiv_info.attr,
6062 	&dev_attr_issue_reset.attr,
6063 	&dev_attr_lpfc_poll.attr,
6064 	&dev_attr_lpfc_poll_tmo.attr,
6065 	&dev_attr_lpfc_task_mgmt_tmo.attr,
6066 	&dev_attr_lpfc_use_msi.attr,
6067 	&dev_attr_lpfc_nvme_oas.attr,
6068 	&dev_attr_lpfc_nvme_embed_cmd.attr,
6069 	&dev_attr_lpfc_fcp_imax.attr,
6070 	&dev_attr_lpfc_force_rscn.attr,
6071 	&dev_attr_lpfc_cq_poll_threshold.attr,
6072 	&dev_attr_lpfc_cq_max_proc_limit.attr,
6073 	&dev_attr_lpfc_fcp_cpu_map.attr,
6074 	&dev_attr_lpfc_fcp_mq_threshold.attr,
6075 	&dev_attr_lpfc_hdw_queue.attr,
6076 	&dev_attr_lpfc_irq_chann.attr,
6077 	&dev_attr_lpfc_suppress_rsp.attr,
6078 	&dev_attr_lpfc_nvmet_mrq.attr,
6079 	&dev_attr_lpfc_nvmet_mrq_post.attr,
6080 	&dev_attr_lpfc_nvme_enable_fb.attr,
6081 	&dev_attr_lpfc_nvmet_fb_size.attr,
6082 	&dev_attr_lpfc_enable_bg.attr,
6083 	&dev_attr_lpfc_enable_hba_reset.attr,
6084 	&dev_attr_lpfc_enable_hba_heartbeat.attr,
6085 	&dev_attr_lpfc_EnableXLane.attr,
6086 	&dev_attr_lpfc_XLanePriority.attr,
6087 	&dev_attr_lpfc_xlane_lun.attr,
6088 	&dev_attr_lpfc_xlane_tgt.attr,
6089 	&dev_attr_lpfc_xlane_vpt.attr,
6090 	&dev_attr_lpfc_xlane_lun_state.attr,
6091 	&dev_attr_lpfc_xlane_lun_status.attr,
6092 	&dev_attr_lpfc_xlane_priority.attr,
6093 	&dev_attr_lpfc_sg_seg_cnt.attr,
6094 	&dev_attr_lpfc_max_scsicmpl_time.attr,
6095 	&dev_attr_lpfc_aer_support.attr,
6096 	&dev_attr_lpfc_aer_state_cleanup.attr,
6097 	&dev_attr_lpfc_sriov_nr_virtfn.attr,
6098 	&dev_attr_lpfc_req_fw_upgrade.attr,
6099 	&dev_attr_lpfc_suppress_link_up.attr,
6100 	&dev_attr_iocb_hw.attr,
6101 	&dev_attr_pls.attr,
6102 	&dev_attr_pt.attr,
6103 	&dev_attr_txq_hw.attr,
6104 	&dev_attr_txcmplq_hw.attr,
6105 	&dev_attr_lpfc_sriov_hw_max_virtfn.attr,
6106 	&dev_attr_protocol.attr,
6107 	&dev_attr_lpfc_xlane_supported.attr,
6108 	&dev_attr_lpfc_enable_mds_diags.attr,
6109 	&dev_attr_lpfc_ras_fwlog_buffsize.attr,
6110 	&dev_attr_lpfc_ras_fwlog_level.attr,
6111 	&dev_attr_lpfc_ras_fwlog_func.attr,
6112 	&dev_attr_lpfc_enable_bbcr.attr,
6113 	&dev_attr_lpfc_enable_dpp.attr,
6114 	&dev_attr_lpfc_enable_mi.attr,
6115 	&dev_attr_cmf_info.attr,
6116 	&dev_attr_lpfc_max_vmid.attr,
6117 	&dev_attr_lpfc_vmid_inactivity_timeout.attr,
6118 	&dev_attr_lpfc_vmid_app_header.attr,
6119 	&dev_attr_lpfc_vmid_priority_tagging.attr,
6120 	NULL,
6121 };
6122 
6123 static const struct attribute_group lpfc_hba_attr_group = {
6124 	.attrs = lpfc_hba_attrs
6125 };
6126 
6127 const struct attribute_group *lpfc_hba_groups[] = {
6128 	&lpfc_hba_attr_group,
6129 	NULL
6130 };
6131 
6132 static struct attribute *lpfc_vport_attrs[] = {
6133 	&dev_attr_info.attr,
6134 	&dev_attr_link_state.attr,
6135 	&dev_attr_num_discovered_ports.attr,
6136 	&dev_attr_lpfc_drvr_version.attr,
6137 	&dev_attr_lpfc_log_verbose.attr,
6138 	&dev_attr_lpfc_lun_queue_depth.attr,
6139 	&dev_attr_lpfc_tgt_queue_depth.attr,
6140 	&dev_attr_lpfc_nodev_tmo.attr,
6141 	&dev_attr_lpfc_devloss_tmo.attr,
6142 	&dev_attr_lpfc_hba_queue_depth.attr,
6143 	&dev_attr_lpfc_peer_port_login.attr,
6144 	&dev_attr_lpfc_restrict_login.attr,
6145 	&dev_attr_lpfc_fcp_class.attr,
6146 	&dev_attr_lpfc_use_adisc.attr,
6147 	&dev_attr_lpfc_first_burst_size.attr,
6148 	&dev_attr_lpfc_max_luns.attr,
6149 	&dev_attr_nport_evt_cnt.attr,
6150 	&dev_attr_npiv_info.attr,
6151 	&dev_attr_lpfc_enable_da_id.attr,
6152 	&dev_attr_lpfc_max_scsicmpl_time.attr,
6153 	&dev_attr_lpfc_static_vport.attr,
6154 	&dev_attr_cmf_info.attr,
6155 	NULL,
6156 };
6157 
6158 static const struct attribute_group lpfc_vport_attr_group = {
6159 	.attrs = lpfc_vport_attrs
6160 };
6161 
6162 const struct attribute_group *lpfc_vport_groups[] = {
6163 	&lpfc_vport_attr_group,
6164 	NULL
6165 };
6166 
6167 /**
6168  * sysfs_ctlreg_write - Write method for writing to ctlreg
6169  * @filp: open sysfs file
6170  * @kobj: kernel kobject that contains the kernel class device.
6171  * @bin_attr: kernel attributes passed to us.
6172  * @buf: contains the data to be written to the adapter IOREG space.
6173  * @off: offset into buffer to beginning of data.
6174  * @count: bytes to transfer.
6175  *
6176  * Description:
6177  * Accessed via /sys/class/scsi_host/hostxxx/ctlreg.
6178  * Uses the adapter io control registers to send buf contents to the adapter.
6179  *
6180  * Returns:
6181  * -ERANGE off and count combo out of range
6182  * -EINVAL off, count or buff address invalid
6183  * -EPERM adapter is offline
6184  * value of count, buf contents written
6185  **/
6186 static ssize_t
sysfs_ctlreg_write(struct file * filp,struct kobject * kobj,struct bin_attribute * bin_attr,char * buf,loff_t off,size_t count)6187 sysfs_ctlreg_write(struct file *filp, struct kobject *kobj,
6188 		   struct bin_attribute *bin_attr,
6189 		   char *buf, loff_t off, size_t count)
6190 {
6191 	size_t buf_off;
6192 	struct device *dev = container_of(kobj, struct device, kobj);
6193 	struct Scsi_Host  *shost = class_to_shost(dev);
6194 	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
6195 	struct lpfc_hba   *phba = vport->phba;
6196 
6197 	if (phba->sli_rev >= LPFC_SLI_REV4)
6198 		return -EPERM;
6199 
6200 	if ((off + count) > FF_REG_AREA_SIZE)
6201 		return -ERANGE;
6202 
6203 	if (count <= LPFC_REG_WRITE_KEY_SIZE)
6204 		return 0;
6205 
6206 	if (off % 4 || count % 4 || (unsigned long)buf % 4)
6207 		return -EINVAL;
6208 
6209 	/* This is to protect HBA registers from accidental writes. */
6210 	if (memcmp(buf, LPFC_REG_WRITE_KEY, LPFC_REG_WRITE_KEY_SIZE))
6211 		return -EINVAL;
6212 
6213 	if (!test_bit(FC_OFFLINE_MODE, &vport->fc_flag))
6214 		return -EPERM;
6215 
6216 	spin_lock_irq(&phba->hbalock);
6217 	for (buf_off = 0; buf_off < count - LPFC_REG_WRITE_KEY_SIZE;
6218 			buf_off += sizeof(uint32_t))
6219 		writel(*((uint32_t *)(buf + buf_off + LPFC_REG_WRITE_KEY_SIZE)),
6220 		       phba->ctrl_regs_memmap_p + off + buf_off);
6221 
6222 	spin_unlock_irq(&phba->hbalock);
6223 
6224 	return count;
6225 }
6226 
6227 /**
6228  * sysfs_ctlreg_read - Read method for reading from ctlreg
6229  * @filp: open sysfs file
6230  * @kobj: kernel kobject that contains the kernel class device.
6231  * @bin_attr: kernel attributes passed to us.
6232  * @buf: if successful contains the data from the adapter IOREG space.
6233  * @off: offset into buffer to beginning of data.
6234  * @count: bytes to transfer.
6235  *
6236  * Description:
6237  * Accessed via /sys/class/scsi_host/hostxxx/ctlreg.
6238  * Uses the adapter io control registers to read data into buf.
6239  *
6240  * Returns:
6241  * -ERANGE off and count combo out of range
6242  * -EINVAL off, count or buff address invalid
6243  * value of count, buf contents read
6244  **/
6245 static ssize_t
sysfs_ctlreg_read(struct file * filp,struct kobject * kobj,struct bin_attribute * bin_attr,char * buf,loff_t off,size_t count)6246 sysfs_ctlreg_read(struct file *filp, struct kobject *kobj,
6247 		  struct bin_attribute *bin_attr,
6248 		  char *buf, loff_t off, size_t count)
6249 {
6250 	size_t buf_off;
6251 	uint32_t * tmp_ptr;
6252 	struct device *dev = container_of(kobj, struct device, kobj);
6253 	struct Scsi_Host  *shost = class_to_shost(dev);
6254 	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
6255 	struct lpfc_hba   *phba = vport->phba;
6256 
6257 	if (phba->sli_rev >= LPFC_SLI_REV4)
6258 		return -EPERM;
6259 
6260 	if (off > FF_REG_AREA_SIZE)
6261 		return -ERANGE;
6262 
6263 	if ((off + count) > FF_REG_AREA_SIZE)
6264 		count = FF_REG_AREA_SIZE - off;
6265 
6266 	if (count == 0) return 0;
6267 
6268 	if (off % 4 || count % 4 || (unsigned long)buf % 4)
6269 		return -EINVAL;
6270 
6271 	spin_lock_irq(&phba->hbalock);
6272 
6273 	for (buf_off = 0; buf_off < count; buf_off += sizeof(uint32_t)) {
6274 		tmp_ptr = (uint32_t *)(buf + buf_off);
6275 		*tmp_ptr = readl(phba->ctrl_regs_memmap_p + off + buf_off);
6276 	}
6277 
6278 	spin_unlock_irq(&phba->hbalock);
6279 
6280 	return count;
6281 }
6282 
6283 static struct bin_attribute sysfs_ctlreg_attr = {
6284 	.attr = {
6285 		.name = "ctlreg",
6286 		.mode = S_IRUSR | S_IWUSR,
6287 	},
6288 	.size = 256,
6289 	.read = sysfs_ctlreg_read,
6290 	.write = sysfs_ctlreg_write,
6291 };
6292 
6293 /**
6294  * sysfs_mbox_write - Write method for writing information via mbox
6295  * @filp: open sysfs file
6296  * @kobj: kernel kobject that contains the kernel class device.
6297  * @bin_attr: kernel attributes passed to us.
6298  * @buf: contains the data to be written to sysfs mbox.
6299  * @off: offset into buffer to beginning of data.
6300  * @count: bytes to transfer.
6301  *
6302  * Description:
6303  * Deprecated function. All mailbox access from user space is performed via the
6304  * bsg interface.
6305  *
6306  * Returns:
6307  * -EPERM operation not permitted
6308  **/
6309 static ssize_t
sysfs_mbox_write(struct file * filp,struct kobject * kobj,struct bin_attribute * bin_attr,char * buf,loff_t off,size_t count)6310 sysfs_mbox_write(struct file *filp, struct kobject *kobj,
6311 		 struct bin_attribute *bin_attr,
6312 		 char *buf, loff_t off, size_t count)
6313 {
6314 	return -EPERM;
6315 }
6316 
6317 /**
6318  * sysfs_mbox_read - Read method for reading information via mbox
6319  * @filp: open sysfs file
6320  * @kobj: kernel kobject that contains the kernel class device.
6321  * @bin_attr: kernel attributes passed to us.
6322  * @buf: contains the data to be read from sysfs mbox.
6323  * @off: offset into buffer to beginning of data.
6324  * @count: bytes to transfer.
6325  *
6326  * Description:
6327  * Deprecated function. All mailbox access from user space is performed via the
6328  * bsg interface.
6329  *
6330  * Returns:
6331  * -EPERM operation not permitted
6332  **/
6333 static ssize_t
sysfs_mbox_read(struct file * filp,struct kobject * kobj,struct bin_attribute * bin_attr,char * buf,loff_t off,size_t count)6334 sysfs_mbox_read(struct file *filp, struct kobject *kobj,
6335 		struct bin_attribute *bin_attr,
6336 		char *buf, loff_t off, size_t count)
6337 {
6338 	return -EPERM;
6339 }
6340 
6341 static struct bin_attribute sysfs_mbox_attr = {
6342 	.attr = {
6343 		.name = "mbox",
6344 		.mode = S_IRUSR | S_IWUSR,
6345 	},
6346 	.size = MAILBOX_SYSFS_MAX,
6347 	.read = sysfs_mbox_read,
6348 	.write = sysfs_mbox_write,
6349 };
6350 
6351 /**
6352  * lpfc_alloc_sysfs_attr - Creates the ctlreg and mbox entries
6353  * @vport: address of lpfc vport structure.
6354  *
6355  * Return codes:
6356  * zero on success
6357  * error return code from sysfs_create_bin_file()
6358  **/
6359 int
lpfc_alloc_sysfs_attr(struct lpfc_vport * vport)6360 lpfc_alloc_sysfs_attr(struct lpfc_vport *vport)
6361 {
6362 	struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
6363 	int error;
6364 
6365 	/* Virtual ports do not need ctrl_reg and mbox */
6366 	if (vport->port_type == LPFC_NPIV_PORT)
6367 		return 0;
6368 
6369 	error = sysfs_create_bin_file(&shost->shost_dev.kobj,
6370 				      &sysfs_ctlreg_attr);
6371 	if (error)
6372 		goto out;
6373 
6374 	error = sysfs_create_bin_file(&shost->shost_dev.kobj,
6375 				      &sysfs_mbox_attr);
6376 	if (error)
6377 		goto out_remove_ctlreg_attr;
6378 
6379 	return 0;
6380 out_remove_ctlreg_attr:
6381 	sysfs_remove_bin_file(&shost->shost_dev.kobj, &sysfs_ctlreg_attr);
6382 out:
6383 	return error;
6384 }
6385 
6386 /**
6387  * lpfc_free_sysfs_attr - Removes the ctlreg and mbox entries
6388  * @vport: address of lpfc vport structure.
6389  **/
6390 void
lpfc_free_sysfs_attr(struct lpfc_vport * vport)6391 lpfc_free_sysfs_attr(struct lpfc_vport *vport)
6392 {
6393 	struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
6394 
6395 	/* Virtual ports do not need ctrl_reg and mbox */
6396 	if (vport->port_type == LPFC_NPIV_PORT)
6397 		return;
6398 	sysfs_remove_bin_file(&shost->shost_dev.kobj, &sysfs_mbox_attr);
6399 	sysfs_remove_bin_file(&shost->shost_dev.kobj, &sysfs_ctlreg_attr);
6400 }
6401 
6402 /*
6403  * Dynamic FC Host Attributes Support
6404  */
6405 
6406 /**
6407  * lpfc_get_host_symbolic_name - Copy symbolic name into the scsi host
6408  * @shost: kernel scsi host pointer.
6409  **/
6410 static void
lpfc_get_host_symbolic_name(struct Scsi_Host * shost)6411 lpfc_get_host_symbolic_name(struct Scsi_Host *shost)
6412 {
6413 	struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
6414 
6415 	lpfc_vport_symbolic_node_name(vport, fc_host_symbolic_name(shost),
6416 				      sizeof fc_host_symbolic_name(shost));
6417 }
6418 
6419 /**
6420  * lpfc_get_host_port_id - Copy the vport DID into the scsi host port id
6421  * @shost: kernel scsi host pointer.
6422  **/
6423 static void
lpfc_get_host_port_id(struct Scsi_Host * shost)6424 lpfc_get_host_port_id(struct Scsi_Host *shost)
6425 {
6426 	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
6427 
6428 	/* note: fc_myDID already in cpu endianness */
6429 	fc_host_port_id(shost) = vport->fc_myDID;
6430 }
6431 
6432 /**
6433  * lpfc_get_host_port_type - Set the value of the scsi host port type
6434  * @shost: kernel scsi host pointer.
6435  **/
6436 static void
lpfc_get_host_port_type(struct Scsi_Host * shost)6437 lpfc_get_host_port_type(struct Scsi_Host *shost)
6438 {
6439 	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
6440 	struct lpfc_hba   *phba = vport->phba;
6441 
6442 	if (vport->port_type == LPFC_NPIV_PORT) {
6443 		fc_host_port_type(shost) = FC_PORTTYPE_NPIV;
6444 	} else if (lpfc_is_link_up(phba)) {
6445 		if (phba->fc_topology == LPFC_TOPOLOGY_LOOP) {
6446 			if (test_bit(FC_PUBLIC_LOOP, &vport->fc_flag))
6447 				fc_host_port_type(shost) = FC_PORTTYPE_NLPORT;
6448 			else
6449 				fc_host_port_type(shost) = FC_PORTTYPE_LPORT;
6450 		} else {
6451 			if (test_bit(FC_FABRIC, &vport->fc_flag))
6452 				fc_host_port_type(shost) = FC_PORTTYPE_NPORT;
6453 			else
6454 				fc_host_port_type(shost) = FC_PORTTYPE_PTP;
6455 		}
6456 	} else
6457 		fc_host_port_type(shost) = FC_PORTTYPE_UNKNOWN;
6458 }
6459 
6460 /**
6461  * lpfc_get_host_port_state - Set the value of the scsi host port state
6462  * @shost: kernel scsi host pointer.
6463  **/
6464 static void
lpfc_get_host_port_state(struct Scsi_Host * shost)6465 lpfc_get_host_port_state(struct Scsi_Host *shost)
6466 {
6467 	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
6468 	struct lpfc_hba   *phba = vport->phba;
6469 
6470 	if (test_bit(FC_OFFLINE_MODE, &vport->fc_flag))
6471 		fc_host_port_state(shost) = FC_PORTSTATE_OFFLINE;
6472 	else {
6473 		switch (phba->link_state) {
6474 		case LPFC_LINK_UNKNOWN:
6475 		case LPFC_LINK_DOWN:
6476 			fc_host_port_state(shost) = FC_PORTSTATE_LINKDOWN;
6477 			break;
6478 		case LPFC_LINK_UP:
6479 		case LPFC_CLEAR_LA:
6480 		case LPFC_HBA_READY:
6481 			/* Links up, reports port state accordingly */
6482 			if (vport->port_state < LPFC_VPORT_READY)
6483 				fc_host_port_state(shost) =
6484 							FC_PORTSTATE_BYPASSED;
6485 			else
6486 				fc_host_port_state(shost) =
6487 							FC_PORTSTATE_ONLINE;
6488 			break;
6489 		case LPFC_HBA_ERROR:
6490 			fc_host_port_state(shost) = FC_PORTSTATE_ERROR;
6491 			break;
6492 		default:
6493 			fc_host_port_state(shost) = FC_PORTSTATE_UNKNOWN;
6494 			break;
6495 		}
6496 	}
6497 }
6498 
6499 /**
6500  * lpfc_get_host_speed - Set the value of the scsi host speed
6501  * @shost: kernel scsi host pointer.
6502  **/
6503 static void
lpfc_get_host_speed(struct Scsi_Host * shost)6504 lpfc_get_host_speed(struct Scsi_Host *shost)
6505 {
6506 	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
6507 	struct lpfc_hba   *phba = vport->phba;
6508 
6509 	if ((lpfc_is_link_up(phba)) &&
6510 	    !test_bit(HBA_FCOE_MODE, &phba->hba_flag)) {
6511 		switch(phba->fc_linkspeed) {
6512 		case LPFC_LINK_SPEED_1GHZ:
6513 			fc_host_speed(shost) = FC_PORTSPEED_1GBIT;
6514 			break;
6515 		case LPFC_LINK_SPEED_2GHZ:
6516 			fc_host_speed(shost) = FC_PORTSPEED_2GBIT;
6517 			break;
6518 		case LPFC_LINK_SPEED_4GHZ:
6519 			fc_host_speed(shost) = FC_PORTSPEED_4GBIT;
6520 			break;
6521 		case LPFC_LINK_SPEED_8GHZ:
6522 			fc_host_speed(shost) = FC_PORTSPEED_8GBIT;
6523 			break;
6524 		case LPFC_LINK_SPEED_10GHZ:
6525 			fc_host_speed(shost) = FC_PORTSPEED_10GBIT;
6526 			break;
6527 		case LPFC_LINK_SPEED_16GHZ:
6528 			fc_host_speed(shost) = FC_PORTSPEED_16GBIT;
6529 			break;
6530 		case LPFC_LINK_SPEED_32GHZ:
6531 			fc_host_speed(shost) = FC_PORTSPEED_32GBIT;
6532 			break;
6533 		case LPFC_LINK_SPEED_64GHZ:
6534 			fc_host_speed(shost) = FC_PORTSPEED_64GBIT;
6535 			break;
6536 		case LPFC_LINK_SPEED_128GHZ:
6537 			fc_host_speed(shost) = FC_PORTSPEED_128GBIT;
6538 			break;
6539 		case LPFC_LINK_SPEED_256GHZ:
6540 			fc_host_speed(shost) = FC_PORTSPEED_256GBIT;
6541 			break;
6542 		default:
6543 			fc_host_speed(shost) = FC_PORTSPEED_UNKNOWN;
6544 			break;
6545 		}
6546 	} else if (lpfc_is_link_up(phba) &&
6547 		   test_bit(HBA_FCOE_MODE, &phba->hba_flag)) {
6548 		switch (phba->fc_linkspeed) {
6549 		case LPFC_ASYNC_LINK_SPEED_1GBPS:
6550 			fc_host_speed(shost) = FC_PORTSPEED_1GBIT;
6551 			break;
6552 		case LPFC_ASYNC_LINK_SPEED_10GBPS:
6553 			fc_host_speed(shost) = FC_PORTSPEED_10GBIT;
6554 			break;
6555 		case LPFC_ASYNC_LINK_SPEED_20GBPS:
6556 			fc_host_speed(shost) = FC_PORTSPEED_20GBIT;
6557 			break;
6558 		case LPFC_ASYNC_LINK_SPEED_25GBPS:
6559 			fc_host_speed(shost) = FC_PORTSPEED_25GBIT;
6560 			break;
6561 		case LPFC_ASYNC_LINK_SPEED_40GBPS:
6562 			fc_host_speed(shost) = FC_PORTSPEED_40GBIT;
6563 			break;
6564 		case LPFC_ASYNC_LINK_SPEED_100GBPS:
6565 			fc_host_speed(shost) = FC_PORTSPEED_100GBIT;
6566 			break;
6567 		default:
6568 			fc_host_speed(shost) = FC_PORTSPEED_UNKNOWN;
6569 			break;
6570 		}
6571 	} else
6572 		fc_host_speed(shost) = FC_PORTSPEED_UNKNOWN;
6573 }
6574 
6575 /**
6576  * lpfc_get_host_fabric_name - Set the value of the scsi host fabric name
6577  * @shost: kernel scsi host pointer.
6578  **/
6579 static void
lpfc_get_host_fabric_name(struct Scsi_Host * shost)6580 lpfc_get_host_fabric_name (struct Scsi_Host *shost)
6581 {
6582 	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
6583 	struct lpfc_hba   *phba = vport->phba;
6584 	u64 node_name;
6585 
6586 	if (vport->port_state > LPFC_FLOGI &&
6587 	    (test_bit(FC_FABRIC, &vport->fc_flag) ||
6588 	     (phba->fc_topology == LPFC_TOPOLOGY_LOOP &&
6589 	      test_bit(FC_PUBLIC_LOOP, &vport->fc_flag))))
6590 		node_name = wwn_to_u64(phba->fc_fabparam.nodeName.u.wwn);
6591 	else
6592 		/* fabric is local port if there is no F/FL_Port */
6593 		node_name = 0;
6594 
6595 	fc_host_fabric_name(shost) = node_name;
6596 }
6597 
6598 /**
6599  * lpfc_get_stats - Return statistical information about the adapter
6600  * @shost: kernel scsi host pointer.
6601  *
6602  * Notes:
6603  * NULL on error for link down, no mbox pool, sli2 active,
6604  * management not allowed, memory allocation error, or mbox error.
6605  *
6606  * Returns:
6607  * NULL for error
6608  * address of the adapter host statistics
6609  **/
6610 static struct fc_host_statistics *
lpfc_get_stats(struct Scsi_Host * shost)6611 lpfc_get_stats(struct Scsi_Host *shost)
6612 {
6613 	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
6614 	struct lpfc_hba   *phba = vport->phba;
6615 	struct lpfc_sli   *psli = &phba->sli;
6616 	struct fc_host_statistics *hs = &phba->link_stats;
6617 	struct lpfc_lnk_stat * lso = &psli->lnk_stat_offsets;
6618 	LPFC_MBOXQ_t *pmboxq;
6619 	MAILBOX_t *pmb;
6620 	int rc = 0;
6621 
6622 	/*
6623 	 * prevent udev from issuing mailbox commands until the port is
6624 	 * configured.
6625 	 */
6626 	if (phba->link_state < LPFC_LINK_DOWN ||
6627 	    !phba->mbox_mem_pool ||
6628 	    (phba->sli.sli_flag & LPFC_SLI_ACTIVE) == 0)
6629 		return NULL;
6630 
6631 	if (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO)
6632 		return NULL;
6633 
6634 	pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
6635 	if (!pmboxq)
6636 		return NULL;
6637 	memset(pmboxq, 0, sizeof (LPFC_MBOXQ_t));
6638 
6639 	pmb = &pmboxq->u.mb;
6640 	pmb->mbxCommand = MBX_READ_STATUS;
6641 	pmb->mbxOwner = OWN_HOST;
6642 	pmboxq->ctx_buf = NULL;
6643 	pmboxq->vport = vport;
6644 
6645 	if (test_bit(FC_OFFLINE_MODE, &vport->fc_flag)) {
6646 		rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL);
6647 		if (rc != MBX_SUCCESS) {
6648 			mempool_free(pmboxq, phba->mbox_mem_pool);
6649 			return NULL;
6650 		}
6651 	} else {
6652 		rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2);
6653 		if (rc != MBX_SUCCESS) {
6654 			if (rc != MBX_TIMEOUT)
6655 				mempool_free(pmboxq, phba->mbox_mem_pool);
6656 			return NULL;
6657 		}
6658 	}
6659 
6660 	memset(hs, 0, sizeof (struct fc_host_statistics));
6661 
6662 	hs->tx_frames = pmb->un.varRdStatus.xmitFrameCnt;
6663 	hs->rx_frames = pmb->un.varRdStatus.rcvFrameCnt;
6664 
6665 	/*
6666 	 * The MBX_READ_STATUS returns tx_k_bytes which has to be
6667 	 * converted to words.
6668 	 *
6669 	 * Check if extended byte flag is set, to know when to collect upper
6670 	 * bits of 64 bit wide statistics counter.
6671 	 */
6672 	if (pmb->un.varRdStatus.xkb & RD_ST_XKB) {
6673 		hs->tx_words = (u64)
6674 			       ((((u64)(pmb->un.varRdStatus.xmit_xkb &
6675 					RD_ST_XMIT_XKB_MASK) << 32) |
6676 				(u64)pmb->un.varRdStatus.xmitByteCnt) *
6677 				(u64)256);
6678 		hs->rx_words = (u64)
6679 			       ((((u64)(pmb->un.varRdStatus.rcv_xkb &
6680 					RD_ST_RCV_XKB_MASK) << 32) |
6681 				(u64)pmb->un.varRdStatus.rcvByteCnt) *
6682 				(u64)256);
6683 	} else {
6684 		hs->tx_words = (uint64_t)
6685 				((uint64_t)pmb->un.varRdStatus.xmitByteCnt
6686 				* (uint64_t)256);
6687 		hs->rx_words = (uint64_t)
6688 				((uint64_t)pmb->un.varRdStatus.rcvByteCnt
6689 				 * (uint64_t)256);
6690 	}
6691 
6692 	memset(pmboxq, 0, sizeof (LPFC_MBOXQ_t));
6693 	pmb->mbxCommand = MBX_READ_LNK_STAT;
6694 	pmb->mbxOwner = OWN_HOST;
6695 	pmboxq->ctx_buf = NULL;
6696 	pmboxq->vport = vport;
6697 
6698 	if (test_bit(FC_OFFLINE_MODE, &vport->fc_flag)) {
6699 		rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL);
6700 		if (rc != MBX_SUCCESS) {
6701 			mempool_free(pmboxq, phba->mbox_mem_pool);
6702 			return NULL;
6703 		}
6704 	} else {
6705 		rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2);
6706 		if (rc != MBX_SUCCESS) {
6707 			if (rc != MBX_TIMEOUT)
6708 				mempool_free(pmboxq, phba->mbox_mem_pool);
6709 			return NULL;
6710 		}
6711 	}
6712 
6713 	hs->link_failure_count = pmb->un.varRdLnk.linkFailureCnt;
6714 	hs->loss_of_sync_count = pmb->un.varRdLnk.lossSyncCnt;
6715 	hs->loss_of_signal_count = pmb->un.varRdLnk.lossSignalCnt;
6716 	hs->prim_seq_protocol_err_count = pmb->un.varRdLnk.primSeqErrCnt;
6717 	hs->invalid_tx_word_count = pmb->un.varRdLnk.invalidXmitWord;
6718 	hs->invalid_crc_count = pmb->un.varRdLnk.crcCnt;
6719 	hs->error_frames = pmb->un.varRdLnk.crcCnt;
6720 
6721 	hs->cn_sig_warn = atomic64_read(&phba->cgn_acqe_stat.warn);
6722 	hs->cn_sig_alarm = atomic64_read(&phba->cgn_acqe_stat.alarm);
6723 
6724 	hs->link_failure_count -= lso->link_failure_count;
6725 	hs->loss_of_sync_count -= lso->loss_of_sync_count;
6726 	hs->loss_of_signal_count -= lso->loss_of_signal_count;
6727 	hs->prim_seq_protocol_err_count -= lso->prim_seq_protocol_err_count;
6728 	hs->invalid_tx_word_count -= lso->invalid_tx_word_count;
6729 	hs->invalid_crc_count -= lso->invalid_crc_count;
6730 	hs->error_frames -= lso->error_frames;
6731 
6732 	if (test_bit(HBA_FCOE_MODE, &phba->hba_flag)) {
6733 		hs->lip_count = -1;
6734 		hs->nos_count = (phba->link_events >> 1);
6735 		hs->nos_count -= lso->link_events;
6736 	} else if (phba->fc_topology == LPFC_TOPOLOGY_LOOP) {
6737 		hs->lip_count = (phba->fc_eventTag >> 1);
6738 		hs->lip_count -= lso->link_events;
6739 		hs->nos_count = -1;
6740 	} else {
6741 		hs->lip_count = -1;
6742 		hs->nos_count = (phba->fc_eventTag >> 1);
6743 		hs->nos_count -= lso->link_events;
6744 	}
6745 
6746 	hs->dumped_frames = -1;
6747 
6748 	hs->seconds_since_last_reset = ktime_get_seconds() - psli->stats_start;
6749 
6750 	mempool_free(pmboxq, phba->mbox_mem_pool);
6751 
6752 	return hs;
6753 }
6754 
6755 /**
6756  * lpfc_reset_stats - Copy the adapter link stats information
6757  * @shost: kernel scsi host pointer.
6758  **/
6759 static void
lpfc_reset_stats(struct Scsi_Host * shost)6760 lpfc_reset_stats(struct Scsi_Host *shost)
6761 {
6762 	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
6763 	struct lpfc_hba   *phba = vport->phba;
6764 	struct lpfc_sli   *psli = &phba->sli;
6765 	struct lpfc_lnk_stat *lso = &psli->lnk_stat_offsets;
6766 	LPFC_MBOXQ_t *pmboxq;
6767 	MAILBOX_t *pmb;
6768 	int rc = 0;
6769 
6770 	if (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO)
6771 		return;
6772 
6773 	pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
6774 	if (!pmboxq)
6775 		return;
6776 	memset(pmboxq, 0, sizeof(LPFC_MBOXQ_t));
6777 
6778 	pmb = &pmboxq->u.mb;
6779 	pmb->mbxCommand = MBX_READ_STATUS;
6780 	pmb->mbxOwner = OWN_HOST;
6781 	pmb->un.varWords[0] = 0x1; /* reset request */
6782 	pmboxq->ctx_buf = NULL;
6783 	pmboxq->vport = vport;
6784 
6785 	if (test_bit(FC_OFFLINE_MODE, &vport->fc_flag) ||
6786 	    !(psli->sli_flag & LPFC_SLI_ACTIVE)) {
6787 		rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL);
6788 		if (rc != MBX_SUCCESS) {
6789 			mempool_free(pmboxq, phba->mbox_mem_pool);
6790 			return;
6791 		}
6792 	} else {
6793 		rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2);
6794 		if (rc != MBX_SUCCESS) {
6795 			if (rc != MBX_TIMEOUT)
6796 				mempool_free(pmboxq, phba->mbox_mem_pool);
6797 			return;
6798 		}
6799 	}
6800 
6801 	memset(pmboxq, 0, sizeof(LPFC_MBOXQ_t));
6802 	pmb->mbxCommand = MBX_READ_LNK_STAT;
6803 	pmb->mbxOwner = OWN_HOST;
6804 	pmboxq->ctx_buf = NULL;
6805 	pmboxq->vport = vport;
6806 
6807 	if (test_bit(FC_OFFLINE_MODE, &vport->fc_flag) ||
6808 	    !(psli->sli_flag & LPFC_SLI_ACTIVE)) {
6809 		rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL);
6810 		if (rc != MBX_SUCCESS) {
6811 			mempool_free(pmboxq, phba->mbox_mem_pool);
6812 			return;
6813 		}
6814 	} else {
6815 		rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2);
6816 		if (rc != MBX_SUCCESS) {
6817 			if (rc != MBX_TIMEOUT)
6818 				mempool_free(pmboxq, phba->mbox_mem_pool);
6819 			return;
6820 		}
6821 	}
6822 
6823 	lso->link_failure_count = pmb->un.varRdLnk.linkFailureCnt;
6824 	lso->loss_of_sync_count = pmb->un.varRdLnk.lossSyncCnt;
6825 	lso->loss_of_signal_count = pmb->un.varRdLnk.lossSignalCnt;
6826 	lso->prim_seq_protocol_err_count = pmb->un.varRdLnk.primSeqErrCnt;
6827 	lso->invalid_tx_word_count = pmb->un.varRdLnk.invalidXmitWord;
6828 	lso->invalid_crc_count = pmb->un.varRdLnk.crcCnt;
6829 	lso->error_frames = pmb->un.varRdLnk.crcCnt;
6830 	if (test_bit(HBA_FCOE_MODE, &phba->hba_flag))
6831 		lso->link_events = (phba->link_events >> 1);
6832 	else
6833 		lso->link_events = (phba->fc_eventTag >> 1);
6834 
6835 	atomic64_set(&phba->cgn_acqe_stat.warn, 0);
6836 	atomic64_set(&phba->cgn_acqe_stat.alarm, 0);
6837 
6838 	memset(&shost_to_fc_host(shost)->fpin_stats, 0,
6839 	       sizeof(shost_to_fc_host(shost)->fpin_stats));
6840 
6841 	psli->stats_start = ktime_get_seconds();
6842 
6843 	mempool_free(pmboxq, phba->mbox_mem_pool);
6844 
6845 	return;
6846 }
6847 
6848 /*
6849  * The LPFC driver treats linkdown handling as target loss events so there
6850  * are no sysfs handlers for link_down_tmo.
6851  */
6852 
6853 /**
6854  * lpfc_get_node_by_target - Return the nodelist for a target
6855  * @starget: kernel scsi target pointer.
6856  *
6857  * Returns:
6858  * address of the node list if found
6859  * NULL target not found
6860  **/
6861 static struct lpfc_nodelist *
lpfc_get_node_by_target(struct scsi_target * starget)6862 lpfc_get_node_by_target(struct scsi_target *starget)
6863 {
6864 	struct Scsi_Host  *shost = dev_to_shost(starget->dev.parent);
6865 	struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
6866 	struct lpfc_nodelist *ndlp;
6867 	unsigned long iflags;
6868 
6869 	spin_lock_irqsave(&vport->fc_nodes_list_lock, iflags);
6870 	/* Search for this, mapped, target ID */
6871 	list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) {
6872 		if (ndlp->nlp_state == NLP_STE_MAPPED_NODE &&
6873 		    starget->id == ndlp->nlp_sid) {
6874 			spin_unlock_irqrestore(&vport->fc_nodes_list_lock,
6875 					       iflags);
6876 			return ndlp;
6877 		}
6878 	}
6879 	spin_unlock_irqrestore(&vport->fc_nodes_list_lock, iflags);
6880 	return NULL;
6881 }
6882 
6883 /**
6884  * lpfc_get_starget_port_id - Set the target port id to the ndlp DID or -1
6885  * @starget: kernel scsi target pointer.
6886  **/
6887 static void
lpfc_get_starget_port_id(struct scsi_target * starget)6888 lpfc_get_starget_port_id(struct scsi_target *starget)
6889 {
6890 	struct lpfc_nodelist *ndlp = lpfc_get_node_by_target(starget);
6891 
6892 	fc_starget_port_id(starget) = ndlp ? ndlp->nlp_DID : -1;
6893 }
6894 
6895 /**
6896  * lpfc_get_starget_node_name - Set the target node name
6897  * @starget: kernel scsi target pointer.
6898  *
6899  * Description: Set the target node name to the ndlp node name wwn or zero.
6900  **/
6901 static void
lpfc_get_starget_node_name(struct scsi_target * starget)6902 lpfc_get_starget_node_name(struct scsi_target *starget)
6903 {
6904 	struct lpfc_nodelist *ndlp = lpfc_get_node_by_target(starget);
6905 
6906 	fc_starget_node_name(starget) =
6907 		ndlp ? wwn_to_u64(ndlp->nlp_nodename.u.wwn) : 0;
6908 }
6909 
6910 /**
6911  * lpfc_get_starget_port_name - Set the target port name
6912  * @starget: kernel scsi target pointer.
6913  *
6914  * Description:  set the target port name to the ndlp port name wwn or zero.
6915  **/
6916 static void
lpfc_get_starget_port_name(struct scsi_target * starget)6917 lpfc_get_starget_port_name(struct scsi_target *starget)
6918 {
6919 	struct lpfc_nodelist *ndlp = lpfc_get_node_by_target(starget);
6920 
6921 	fc_starget_port_name(starget) =
6922 		ndlp ? wwn_to_u64(ndlp->nlp_portname.u.wwn) : 0;
6923 }
6924 
6925 /**
6926  * lpfc_set_rport_loss_tmo - Set the rport dev loss tmo
6927  * @rport: fc rport address.
6928  * @timeout: new value for dev loss tmo.
6929  *
6930  * Description:
6931  * If timeout is non zero set the dev_loss_tmo to timeout, else set
6932  * dev_loss_tmo to one.
6933  **/
6934 static void
lpfc_set_rport_loss_tmo(struct fc_rport * rport,uint32_t timeout)6935 lpfc_set_rport_loss_tmo(struct fc_rport *rport, uint32_t timeout)
6936 {
6937 	struct lpfc_rport_data *rdata = rport->dd_data;
6938 	struct lpfc_nodelist *ndlp = rdata->pnode;
6939 #if (IS_ENABLED(CONFIG_NVME_FC))
6940 	struct lpfc_nvme_rport *nrport = NULL;
6941 #endif
6942 
6943 	if (timeout)
6944 		rport->dev_loss_tmo = timeout;
6945 	else
6946 		rport->dev_loss_tmo = 1;
6947 
6948 	if (!ndlp) {
6949 		dev_info(&rport->dev, "Cannot find remote node to "
6950 				      "set rport dev loss tmo, port_id x%x\n",
6951 				      rport->port_id);
6952 		return;
6953 	}
6954 
6955 #if (IS_ENABLED(CONFIG_NVME_FC))
6956 	nrport = lpfc_ndlp_get_nrport(ndlp);
6957 
6958 	if (nrport && nrport->remoteport)
6959 		nvme_fc_set_remoteport_devloss(nrport->remoteport,
6960 					       rport->dev_loss_tmo);
6961 #endif
6962 }
6963 
6964 /*
6965  * lpfc_rport_show_function - Return rport target information
6966  *
6967  * Description:
6968  * Macro that uses field to generate a function with the name lpfc_show_rport_
6969  *
6970  * lpfc_show_rport_##field: returns the bytes formatted in buf
6971  * @cdev: class converted to an fc_rport.
6972  * @buf: on return contains the target_field or zero.
6973  *
6974  * Returns: size of formatted string.
6975  **/
6976 #define lpfc_rport_show_function(field, format_string, sz, cast)	\
6977 static ssize_t								\
6978 lpfc_show_rport_##field (struct device *dev,				\
6979 			 struct device_attribute *attr,			\
6980 			 char *buf)					\
6981 {									\
6982 	struct fc_rport *rport = transport_class_to_rport(dev);		\
6983 	struct lpfc_rport_data *rdata = rport->hostdata;		\
6984 	return scnprintf(buf, sz, format_string,			\
6985 		(rdata->target) ? cast rdata->target->field : 0);	\
6986 }
6987 
6988 #define lpfc_rport_rd_attr(field, format_string, sz)			\
6989 	lpfc_rport_show_function(field, format_string, sz, )		\
6990 static FC_RPORT_ATTR(field, S_IRUGO, lpfc_show_rport_##field, NULL)
6991 
6992 /**
6993  * lpfc_set_vport_symbolic_name - Set the vport's symbolic name
6994  * @fc_vport: The fc_vport who's symbolic name has been changed.
6995  *
6996  * Description:
6997  * This function is called by the transport after the @fc_vport's symbolic name
6998  * has been changed. This function re-registers the symbolic name with the
6999  * switch to propagate the change into the fabric if the vport is active.
7000  **/
7001 static void
lpfc_set_vport_symbolic_name(struct fc_vport * fc_vport)7002 lpfc_set_vport_symbolic_name(struct fc_vport *fc_vport)
7003 {
7004 	struct lpfc_vport *vport = *(struct lpfc_vport **)fc_vport->dd_data;
7005 
7006 	if (vport->port_state == LPFC_VPORT_READY)
7007 		lpfc_ns_cmd(vport, SLI_CTNS_RSPN_ID, 0, 0);
7008 }
7009 
7010 /**
7011  * lpfc_hba_log_verbose_init - Set hba's log verbose level
7012  * @phba: Pointer to lpfc_hba struct.
7013  * @verbose: Verbose level to set.
7014  *
7015  * This function is called by the lpfc_get_cfgparam() routine to set the
7016  * module lpfc_log_verbose into the @phba cfg_log_verbose for use with
7017  * log message according to the module's lpfc_log_verbose parameter setting
7018  * before hba port or vport created.
7019  **/
7020 static void
lpfc_hba_log_verbose_init(struct lpfc_hba * phba,uint32_t verbose)7021 lpfc_hba_log_verbose_init(struct lpfc_hba *phba, uint32_t verbose)
7022 {
7023 	phba->cfg_log_verbose = verbose;
7024 }
7025 
7026 struct fc_function_template lpfc_transport_functions = {
7027 	/* fixed attributes the driver supports */
7028 	.show_host_node_name = 1,
7029 	.show_host_port_name = 1,
7030 	.show_host_supported_classes = 1,
7031 	.show_host_supported_fc4s = 1,
7032 	.show_host_supported_speeds = 1,
7033 	.show_host_maxframe_size = 1,
7034 
7035 	.get_host_symbolic_name = lpfc_get_host_symbolic_name,
7036 	.show_host_symbolic_name = 1,
7037 
7038 	/* dynamic attributes the driver supports */
7039 	.get_host_port_id = lpfc_get_host_port_id,
7040 	.show_host_port_id = 1,
7041 
7042 	.get_host_port_type = lpfc_get_host_port_type,
7043 	.show_host_port_type = 1,
7044 
7045 	.get_host_port_state = lpfc_get_host_port_state,
7046 	.show_host_port_state = 1,
7047 
7048 	/* active_fc4s is shown but doesn't change (thus no get function) */
7049 	.show_host_active_fc4s = 1,
7050 
7051 	.get_host_speed = lpfc_get_host_speed,
7052 	.show_host_speed = 1,
7053 
7054 	.get_host_fabric_name = lpfc_get_host_fabric_name,
7055 	.show_host_fabric_name = 1,
7056 
7057 	/*
7058 	 * The LPFC driver treats linkdown handling as target loss events
7059 	 * so there are no sysfs handlers for link_down_tmo.
7060 	 */
7061 
7062 	.get_fc_host_stats = lpfc_get_stats,
7063 	.reset_fc_host_stats = lpfc_reset_stats,
7064 
7065 	.dd_fcrport_size = sizeof(struct lpfc_rport_data),
7066 	.show_rport_maxframe_size = 1,
7067 	.show_rport_supported_classes = 1,
7068 
7069 	.set_rport_dev_loss_tmo = lpfc_set_rport_loss_tmo,
7070 	.show_rport_dev_loss_tmo = 1,
7071 
7072 	.get_starget_port_id  = lpfc_get_starget_port_id,
7073 	.show_starget_port_id = 1,
7074 
7075 	.get_starget_node_name = lpfc_get_starget_node_name,
7076 	.show_starget_node_name = 1,
7077 
7078 	.get_starget_port_name = lpfc_get_starget_port_name,
7079 	.show_starget_port_name = 1,
7080 
7081 	.issue_fc_host_lip = lpfc_issue_lip,
7082 	.dev_loss_tmo_callbk = lpfc_dev_loss_tmo_callbk,
7083 	.terminate_rport_io = lpfc_terminate_rport_io,
7084 
7085 	.dd_fcvport_size = sizeof(struct lpfc_vport *),
7086 
7087 	.vport_disable = lpfc_vport_disable,
7088 
7089 	.set_vport_symbolic_name = lpfc_set_vport_symbolic_name,
7090 
7091 	.bsg_request = lpfc_bsg_request,
7092 	.bsg_timeout = lpfc_bsg_timeout,
7093 };
7094 
7095 struct fc_function_template lpfc_vport_transport_functions = {
7096 	/* fixed attributes the driver supports */
7097 	.show_host_node_name = 1,
7098 	.show_host_port_name = 1,
7099 	.show_host_supported_classes = 1,
7100 	.show_host_supported_fc4s = 1,
7101 	.show_host_supported_speeds = 1,
7102 	.show_host_maxframe_size = 1,
7103 
7104 	.get_host_symbolic_name = lpfc_get_host_symbolic_name,
7105 	.show_host_symbolic_name = 1,
7106 
7107 	/* dynamic attributes the driver supports */
7108 	.get_host_port_id = lpfc_get_host_port_id,
7109 	.show_host_port_id = 1,
7110 
7111 	.get_host_port_type = lpfc_get_host_port_type,
7112 	.show_host_port_type = 1,
7113 
7114 	.get_host_port_state = lpfc_get_host_port_state,
7115 	.show_host_port_state = 1,
7116 
7117 	/* active_fc4s is shown but doesn't change (thus no get function) */
7118 	.show_host_active_fc4s = 1,
7119 
7120 	.get_host_speed = lpfc_get_host_speed,
7121 	.show_host_speed = 1,
7122 
7123 	.get_host_fabric_name = lpfc_get_host_fabric_name,
7124 	.show_host_fabric_name = 1,
7125 
7126 	/*
7127 	 * The LPFC driver treats linkdown handling as target loss events
7128 	 * so there are no sysfs handlers for link_down_tmo.
7129 	 */
7130 
7131 	.get_fc_host_stats = lpfc_get_stats,
7132 	.reset_fc_host_stats = lpfc_reset_stats,
7133 
7134 	.dd_fcrport_size = sizeof(struct lpfc_rport_data),
7135 	.show_rport_maxframe_size = 1,
7136 	.show_rport_supported_classes = 1,
7137 
7138 	.set_rport_dev_loss_tmo = lpfc_set_rport_loss_tmo,
7139 	.show_rport_dev_loss_tmo = 1,
7140 
7141 	.get_starget_port_id  = lpfc_get_starget_port_id,
7142 	.show_starget_port_id = 1,
7143 
7144 	.get_starget_node_name = lpfc_get_starget_node_name,
7145 	.show_starget_node_name = 1,
7146 
7147 	.get_starget_port_name = lpfc_get_starget_port_name,
7148 	.show_starget_port_name = 1,
7149 
7150 	.dev_loss_tmo_callbk = lpfc_dev_loss_tmo_callbk,
7151 	.terminate_rport_io = lpfc_terminate_rport_io,
7152 
7153 	.vport_disable = lpfc_vport_disable,
7154 
7155 	.set_vport_symbolic_name = lpfc_set_vport_symbolic_name,
7156 };
7157 
7158 /**
7159  * lpfc_get_hba_function_mode - Used to determine the HBA function in FCoE
7160  * Mode
7161  * @phba: lpfc_hba pointer.
7162  **/
7163 static void
lpfc_get_hba_function_mode(struct lpfc_hba * phba)7164 lpfc_get_hba_function_mode(struct lpfc_hba *phba)
7165 {
7166 	/* If the adapter supports FCoE mode */
7167 	switch (phba->pcidev->device) {
7168 	case PCI_DEVICE_ID_SKYHAWK:
7169 	case PCI_DEVICE_ID_SKYHAWK_VF:
7170 	case PCI_DEVICE_ID_LANCER_FCOE:
7171 	case PCI_DEVICE_ID_LANCER_FCOE_VF:
7172 	case PCI_DEVICE_ID_ZEPHYR_DCSP:
7173 	case PCI_DEVICE_ID_TIGERSHARK:
7174 	case PCI_DEVICE_ID_TOMCAT:
7175 		set_bit(HBA_FCOE_MODE, &phba->hba_flag);
7176 		break;
7177 	default:
7178 	/* for others, clear the flag */
7179 		clear_bit(HBA_FCOE_MODE, &phba->hba_flag);
7180 	}
7181 }
7182 
7183 /**
7184  * lpfc_get_cfgparam - Used during probe_one to init the adapter structure
7185  * @phba: lpfc_hba pointer.
7186  **/
7187 void
lpfc_get_cfgparam(struct lpfc_hba * phba)7188 lpfc_get_cfgparam(struct lpfc_hba *phba)
7189 {
7190 	lpfc_hba_log_verbose_init(phba, lpfc_log_verbose);
7191 	lpfc_fcp_io_sched_init(phba, lpfc_fcp_io_sched);
7192 	lpfc_ns_query_init(phba, lpfc_ns_query);
7193 	lpfc_fcp2_no_tgt_reset_init(phba, lpfc_fcp2_no_tgt_reset);
7194 	lpfc_cr_delay_init(phba, lpfc_cr_delay);
7195 	lpfc_cr_count_init(phba, lpfc_cr_count);
7196 	lpfc_multi_ring_support_init(phba, lpfc_multi_ring_support);
7197 	lpfc_multi_ring_rctl_init(phba, lpfc_multi_ring_rctl);
7198 	lpfc_multi_ring_type_init(phba, lpfc_multi_ring_type);
7199 	lpfc_ack0_init(phba, lpfc_ack0);
7200 	lpfc_xri_rebalancing_init(phba, lpfc_xri_rebalancing);
7201 	lpfc_topology_init(phba, lpfc_topology);
7202 	lpfc_link_speed_init(phba, lpfc_link_speed);
7203 	lpfc_poll_tmo_init(phba, lpfc_poll_tmo);
7204 	lpfc_task_mgmt_tmo_init(phba, lpfc_task_mgmt_tmo);
7205 	lpfc_enable_npiv_init(phba, lpfc_enable_npiv);
7206 	lpfc_fcf_failover_policy_init(phba, lpfc_fcf_failover_policy);
7207 	lpfc_enable_rrq_init(phba, lpfc_enable_rrq);
7208 	lpfc_fcp_wait_abts_rsp_init(phba, lpfc_fcp_wait_abts_rsp);
7209 	lpfc_fdmi_on_init(phba, lpfc_fdmi_on);
7210 	lpfc_enable_SmartSAN_init(phba, lpfc_enable_SmartSAN);
7211 	lpfc_use_msi_init(phba, lpfc_use_msi);
7212 	lpfc_nvme_oas_init(phba, lpfc_nvme_oas);
7213 	lpfc_nvme_embed_cmd_init(phba, lpfc_nvme_embed_cmd);
7214 	lpfc_fcp_imax_init(phba, lpfc_fcp_imax);
7215 	lpfc_force_rscn_init(phba, lpfc_force_rscn);
7216 	lpfc_cq_poll_threshold_init(phba, lpfc_cq_poll_threshold);
7217 	lpfc_cq_max_proc_limit_init(phba, lpfc_cq_max_proc_limit);
7218 	lpfc_fcp_cpu_map_init(phba, lpfc_fcp_cpu_map);
7219 	lpfc_enable_hba_reset_init(phba, lpfc_enable_hba_reset);
7220 	lpfc_enable_hba_heartbeat_init(phba, lpfc_enable_hba_heartbeat);
7221 
7222 	lpfc_EnableXLane_init(phba, lpfc_EnableXLane);
7223 	/* VMID Inits */
7224 	lpfc_max_vmid_init(phba, lpfc_max_vmid);
7225 	lpfc_vmid_inactivity_timeout_init(phba, lpfc_vmid_inactivity_timeout);
7226 	lpfc_vmid_app_header_init(phba, lpfc_vmid_app_header);
7227 	lpfc_vmid_priority_tagging_init(phba, lpfc_vmid_priority_tagging);
7228 	if (phba->sli_rev != LPFC_SLI_REV4)
7229 		phba->cfg_EnableXLane = 0;
7230 	lpfc_XLanePriority_init(phba, lpfc_XLanePriority);
7231 
7232 	memset(phba->cfg_oas_tgt_wwpn, 0, (8 * sizeof(uint8_t)));
7233 	memset(phba->cfg_oas_vpt_wwpn, 0, (8 * sizeof(uint8_t)));
7234 	phba->cfg_oas_lun_state = 0;
7235 	phba->cfg_oas_lun_status = 0;
7236 	phba->cfg_oas_flags = 0;
7237 	phba->cfg_oas_priority = 0;
7238 	lpfc_enable_bg_init(phba, lpfc_enable_bg);
7239 	lpfc_prot_mask_init(phba, lpfc_prot_mask);
7240 	lpfc_prot_guard_init(phba, lpfc_prot_guard);
7241 	if (phba->sli_rev == LPFC_SLI_REV4)
7242 		phba->cfg_poll = 0;
7243 	else
7244 		phba->cfg_poll = lpfc_poll;
7245 
7246 	/* Get the function mode */
7247 	lpfc_get_hba_function_mode(phba);
7248 
7249 	/* BlockGuard allowed for FC only. */
7250 	if (phba->cfg_enable_bg && test_bit(HBA_FCOE_MODE, &phba->hba_flag)) {
7251 		lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
7252 				"0581 BlockGuard feature not supported\n");
7253 		/* If set, clear the BlockGuard support param */
7254 		phba->cfg_enable_bg = 0;
7255 	} else if (phba->cfg_enable_bg) {
7256 		phba->sli3_options |= LPFC_SLI3_BG_ENABLED;
7257 	}
7258 
7259 	lpfc_suppress_rsp_init(phba, lpfc_suppress_rsp);
7260 
7261 	lpfc_enable_fc4_type_init(phba, lpfc_enable_fc4_type);
7262 	lpfc_nvmet_mrq_init(phba, lpfc_nvmet_mrq);
7263 	lpfc_nvmet_mrq_post_init(phba, lpfc_nvmet_mrq_post);
7264 
7265 	/* Initialize first burst. Target vs Initiator are different. */
7266 	lpfc_nvme_enable_fb_init(phba, lpfc_nvme_enable_fb);
7267 	lpfc_nvmet_fb_size_init(phba, lpfc_nvmet_fb_size);
7268 	lpfc_fcp_mq_threshold_init(phba, lpfc_fcp_mq_threshold);
7269 	lpfc_hdw_queue_init(phba, lpfc_hdw_queue);
7270 	lpfc_irq_chann_init(phba, lpfc_irq_chann);
7271 	lpfc_enable_bbcr_init(phba, lpfc_enable_bbcr);
7272 	lpfc_enable_dpp_init(phba, lpfc_enable_dpp);
7273 	lpfc_enable_mi_init(phba, lpfc_enable_mi);
7274 
7275 	phba->cgn_p.cgn_param_mode = LPFC_CFG_OFF;
7276 	phba->cmf_active_mode = LPFC_CFG_OFF;
7277 	if (lpfc_fabric_cgn_frequency > EDC_CG_SIGFREQ_CNT_MAX ||
7278 	   lpfc_fabric_cgn_frequency < EDC_CG_SIGFREQ_CNT_MIN)
7279 		lpfc_fabric_cgn_frequency = 100; /* 100 ms default */
7280 
7281 	if (phba->sli_rev != LPFC_SLI_REV4) {
7282 		/* NVME only supported on SLI4 */
7283 		phba->nvmet_support = 0;
7284 		phba->cfg_nvmet_mrq = 0;
7285 		phba->cfg_enable_fc4_type = LPFC_ENABLE_FCP;
7286 		phba->cfg_enable_bbcr = 0;
7287 		phba->cfg_xri_rebalancing = 0;
7288 	} else {
7289 		/* We MUST have FCP support */
7290 		if (!(phba->cfg_enable_fc4_type & LPFC_ENABLE_FCP))
7291 			phba->cfg_enable_fc4_type |= LPFC_ENABLE_FCP;
7292 	}
7293 
7294 	phba->cfg_auto_imax = (phba->cfg_fcp_imax) ? 0 : 1;
7295 
7296 	phba->cfg_enable_pbde = 0;
7297 
7298 	/* A value of 0 means use the number of CPUs found in the system */
7299 	if (phba->cfg_hdw_queue == 0)
7300 		phba->cfg_hdw_queue = phba->sli4_hba.num_present_cpu;
7301 	if (phba->cfg_irq_chann == 0)
7302 		phba->cfg_irq_chann = phba->sli4_hba.num_present_cpu;
7303 	if (phba->cfg_irq_chann > phba->cfg_hdw_queue &&
7304 	    phba->sli_rev == LPFC_SLI_REV4)
7305 		phba->cfg_irq_chann = phba->cfg_hdw_queue;
7306 
7307 	lpfc_sg_seg_cnt_init(phba, lpfc_sg_seg_cnt);
7308 	lpfc_hba_queue_depth_init(phba, lpfc_hba_queue_depth);
7309 	lpfc_sriov_nr_virtfn_init(phba, lpfc_sriov_nr_virtfn);
7310 	lpfc_request_firmware_upgrade_init(phba, lpfc_req_fw_upgrade);
7311 	lpfc_suppress_link_up_init(phba, lpfc_suppress_link_up);
7312 	lpfc_delay_discovery_init(phba, lpfc_delay_discovery);
7313 	lpfc_sli_mode_init(phba, lpfc_sli_mode);
7314 	lpfc_enable_mds_diags_init(phba, lpfc_enable_mds_diags);
7315 	lpfc_ras_fwlog_buffsize_init(phba, lpfc_ras_fwlog_buffsize);
7316 	lpfc_ras_fwlog_level_init(phba, lpfc_ras_fwlog_level);
7317 	lpfc_ras_fwlog_func_init(phba, lpfc_ras_fwlog_func);
7318 
7319 	return;
7320 }
7321 
7322 /**
7323  * lpfc_nvme_mod_param_dep - Adjust module parameter value based on
7324  * dependencies between protocols and roles.
7325  * @phba: lpfc_hba pointer.
7326  **/
7327 void
lpfc_nvme_mod_param_dep(struct lpfc_hba * phba)7328 lpfc_nvme_mod_param_dep(struct lpfc_hba *phba)
7329 {
7330 	int  logit = 0;
7331 
7332 	if (phba->cfg_hdw_queue > phba->sli4_hba.num_present_cpu) {
7333 		phba->cfg_hdw_queue = phba->sli4_hba.num_present_cpu;
7334 		logit = 1;
7335 	}
7336 	if (phba->cfg_irq_chann > phba->sli4_hba.num_present_cpu) {
7337 		phba->cfg_irq_chann = phba->sli4_hba.num_present_cpu;
7338 		logit = 1;
7339 	}
7340 	if (phba->cfg_irq_chann > phba->cfg_hdw_queue) {
7341 		phba->cfg_irq_chann = phba->cfg_hdw_queue;
7342 		logit = 1;
7343 	}
7344 	if (logit)
7345 		lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
7346 				"2006 Reducing Queues - CPU limitation: "
7347 				"IRQ %d HDWQ %d\n",
7348 				phba->cfg_irq_chann,
7349 				phba->cfg_hdw_queue);
7350 
7351 	if (phba->cfg_enable_fc4_type & LPFC_ENABLE_NVME &&
7352 	    phba->nvmet_support) {
7353 		phba->cfg_enable_fc4_type &= ~LPFC_ENABLE_FCP;
7354 
7355 		lpfc_printf_log(phba, KERN_INFO, LOG_NVME_DISC,
7356 				"6013 %s x%x fb_size x%x, fb_max x%x\n",
7357 				"NVME Target PRLI ACC enable_fb ",
7358 				phba->cfg_nvme_enable_fb,
7359 				phba->cfg_nvmet_fb_size,
7360 				LPFC_NVMET_FB_SZ_MAX);
7361 
7362 		if (phba->cfg_nvme_enable_fb == 0)
7363 			phba->cfg_nvmet_fb_size = 0;
7364 		else {
7365 			if (phba->cfg_nvmet_fb_size > LPFC_NVMET_FB_SZ_MAX)
7366 				phba->cfg_nvmet_fb_size = LPFC_NVMET_FB_SZ_MAX;
7367 		}
7368 
7369 		if (!phba->cfg_nvmet_mrq)
7370 			phba->cfg_nvmet_mrq = phba->cfg_hdw_queue;
7371 
7372 		/* Adjust lpfc_nvmet_mrq to avoid running out of WQE slots */
7373 		if (phba->cfg_nvmet_mrq > phba->cfg_hdw_queue) {
7374 			phba->cfg_nvmet_mrq = phba->cfg_hdw_queue;
7375 			lpfc_printf_log(phba, KERN_ERR, LOG_NVME_DISC,
7376 					"6018 Adjust lpfc_nvmet_mrq to %d\n",
7377 					phba->cfg_nvmet_mrq);
7378 		}
7379 		if (phba->cfg_nvmet_mrq > LPFC_NVMET_MRQ_MAX)
7380 			phba->cfg_nvmet_mrq = LPFC_NVMET_MRQ_MAX;
7381 
7382 	} else {
7383 		/* Not NVME Target mode.  Turn off Target parameters. */
7384 		phba->nvmet_support = 0;
7385 		phba->cfg_nvmet_mrq = 0;
7386 		phba->cfg_nvmet_fb_size = 0;
7387 	}
7388 }
7389 
7390 /**
7391  * lpfc_get_vport_cfgparam - Used during port create, init the vport structure
7392  * @vport: lpfc_vport pointer.
7393  **/
7394 void
lpfc_get_vport_cfgparam(struct lpfc_vport * vport)7395 lpfc_get_vport_cfgparam(struct lpfc_vport *vport)
7396 {
7397 	lpfc_log_verbose_init(vport, lpfc_log_verbose);
7398 	lpfc_lun_queue_depth_init(vport, lpfc_lun_queue_depth);
7399 	lpfc_tgt_queue_depth_init(vport, lpfc_tgt_queue_depth);
7400 	lpfc_devloss_tmo_init(vport, lpfc_devloss_tmo);
7401 	lpfc_nodev_tmo_init(vport, lpfc_nodev_tmo);
7402 	lpfc_peer_port_login_init(vport, lpfc_peer_port_login);
7403 	lpfc_restrict_login_init(vport, lpfc_restrict_login);
7404 	lpfc_fcp_class_init(vport, lpfc_fcp_class);
7405 	lpfc_use_adisc_init(vport, lpfc_use_adisc);
7406 	lpfc_first_burst_size_init(vport, lpfc_first_burst_size);
7407 	lpfc_max_scsicmpl_time_init(vport, lpfc_max_scsicmpl_time);
7408 	lpfc_discovery_threads_init(vport, lpfc_discovery_threads);
7409 	lpfc_max_luns_init(vport, lpfc_max_luns);
7410 	lpfc_scan_down_init(vport, lpfc_scan_down);
7411 	lpfc_enable_da_id_init(vport, lpfc_enable_da_id);
7412 	return;
7413 }
7414