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