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