1	// SPDX-License-Identifier: GPL-2.0-only
2	/*
3	* QLogic Fibre Channel HBA Driver
4	* Copyright (c) 2003-2014 QLogic Corporation
5	*/
6	#include "qla_def.h"
7	#include "qla_target.h"
8
9	#include <linux/kthread.h>
10	#include <linux/vmalloc.h>
11	#include <linux/slab.h>
12	#include <linux/delay.h>
13
14	static int qla24xx_vport_disable(struct fc_vport *, bool);
15
16	/* SYSFS attributes --------------------------------------------------------- */
17
18	static ssize_t
19	qla2x00_sysfs_read_fw_dump(struct file *filp, struct kobject *kobj,
20	struct bin_attribute *bin_attr,
21	char *buf, loff_t off, size_t count)
22	{
23	struct scsi_qla_host *vha = shost_priv(shost: dev_to_shost(container_of(kobj,
24	struct device, kobj)));
25	struct qla_hw_data *ha = vha->hw;
26	int rval = 0;
27
28	if (!(ha->fw_dump_reading || ha->mctp_dump_reading ||
29	ha->mpi_fw_dump_reading))
30	return 0;
31
32	mutex_lock(&ha->optrom_mutex);
33	if (IS_P3P_TYPE(ha)) {
34	if (off < ha->md_template_size) {
35	rval = memory_read_from_buffer(to: buf, count,
36	ppos: &off, from: ha->md_tmplt_hdr, available: ha->md_template_size);
37	} else {
38	off -= ha->md_template_size;
39	rval = memory_read_from_buffer(to: buf, count,
40	ppos: &off, from: ha->md_dump, available: ha->md_dump_size);
41	}
42	} else if (ha->mctp_dumped && ha->mctp_dump_reading) {
43	rval = memory_read_from_buffer(to: buf, count, ppos: &off, from: ha->mctp_dump,
44	MCTP_DUMP_SIZE);
45	} else if (ha->mpi_fw_dumped && ha->mpi_fw_dump_reading) {
46	rval = memory_read_from_buffer(to: buf, count, ppos: &off,
47	from: ha->mpi_fw_dump,
48	available: ha->mpi_fw_dump_len);
49	} else if (ha->fw_dump_reading) {
50	rval = memory_read_from_buffer(to: buf, count, ppos: &off, from: ha->fw_dump,
51	available: ha->fw_dump_len);
52	} else {
53	rval = 0;
54	}
55	mutex_unlock(lock: &ha->optrom_mutex);
56	return rval;
57	}
58
59	static ssize_t
60	qla2x00_sysfs_write_fw_dump(struct file *filp, struct kobject *kobj,
61	struct bin_attribute *bin_attr,
62	char *buf, loff_t off, size_t count)
63	{
64	struct scsi_qla_host *vha = shost_priv(shost: dev_to_shost(container_of(kobj,
65	struct device, kobj)));
66	struct qla_hw_data *ha = vha->hw;
67	int reading;
68
69	if (off != 0)
70	return (0);
71
72	reading = simple_strtol(buf, NULL, 10);
73	switch (reading) {
74	case 0:
75	if (!ha->fw_dump_reading)
76	break;
77
78	ql_log(ql_log_info, vha, 0x705d,
79	fmt: "Firmware dump cleared on (%ld).\n", vha->host_no);
80
81	if (IS_P3P_TYPE(ha)) {
82	qla82xx_md_free(vha);
83	qla82xx_md_prep(vha);
84	}
85	ha->fw_dump_reading = 0;
86	ha->fw_dumped = false;
87	break;
88	case 1:
89	if (ha->fw_dumped && !ha->fw_dump_reading) {
90	ha->fw_dump_reading = 1;
91
92	ql_log(ql_log_info, vha, 0x705e,
93	fmt: "Raw firmware dump ready for read on (%ld).\n",
94	vha->host_no);
95	}
96	break;
97	case 2:
98	qla2x00_alloc_fw_dump(vha);
99	break;
100	case 3:
101	if (IS_QLA82XX(ha)) {
102	qla82xx_idc_lock(ha);
103	qla82xx_set_reset_owner(vha);
104	qla82xx_idc_unlock(ha);
105	} else if (IS_QLA8044(ha)) {
106	qla8044_idc_lock(ha);
107	qla82xx_set_reset_owner(vha);
108	qla8044_idc_unlock(ha);
109	} else {
110	qla2x00_system_error(vha);
111	}
112	break;
113	case 4:
114	if (IS_P3P_TYPE(ha)) {
115	if (ha->md_tmplt_hdr)
116	ql_dbg(ql_dbg_user, vha, 0x705b,
117	fmt: "MiniDump supported with this firmware.\n");
118	else
119	ql_dbg(ql_dbg_user, vha, 0x709d,
120	fmt: "MiniDump not supported with this firmware.\n");
121	}
122	break;
123	case 5:
124	if (IS_P3P_TYPE(ha))
125	set_bit(ISP_ABORT_NEEDED, addr: &vha->dpc_flags);
126	break;
127	case 6:
128	if (!ha->mctp_dump_reading)
129	break;
130	ql_log(ql_log_info, vha, 0x70c1,
131	fmt: "MCTP dump cleared on (%ld).\n", vha->host_no);
132	ha->mctp_dump_reading = 0;
133	ha->mctp_dumped = 0;
134	break;
135	case 7:
136	if (ha->mctp_dumped && !ha->mctp_dump_reading) {
137	ha->mctp_dump_reading = 1;
138	ql_log(ql_log_info, vha, 0x70c2,
139	fmt: "Raw mctp dump ready for read on (%ld).\n",
140	vha->host_no);
141	}
142	break;
143	case 8:
144	if (!ha->mpi_fw_dump_reading)
145	break;
146	ql_log(ql_log_info, vha, 0x70e7,
147	fmt: "MPI firmware dump cleared on (%ld).\n", vha->host_no);
148	ha->mpi_fw_dump_reading = 0;
149	ha->mpi_fw_dumped = 0;
150	break;
151	case 9:
152	if (ha->mpi_fw_dumped && !ha->mpi_fw_dump_reading) {
153	ha->mpi_fw_dump_reading = 1;
154	ql_log(ql_log_info, vha, 0x70e8,
155	fmt: "Raw MPI firmware dump ready for read on (%ld).\n",
156	vha->host_no);
157	}
158	break;
159	case 10:
160	if (IS_QLA27XX(ha) || IS_QLA28XX(ha)) {
161	ql_log(ql_log_info, vha, 0x70e9,
162	fmt: "Issuing MPI firmware dump on host#%ld.\n",
163	vha->host_no);
164	ha->isp_ops->mpi_fw_dump(vha, 0);
165	}
166	break;
167	}
168	return count;
169	}
170
171	static struct bin_attribute sysfs_fw_dump_attr = {
172	.attr = {
173	.name = "fw_dump",
174	.mode = S_IRUSR | S_IWUSR,
175	},
176	.size = 0,
177	.read = qla2x00_sysfs_read_fw_dump,
178	.write = qla2x00_sysfs_write_fw_dump,
179	};
180
181	static ssize_t
182	qla2x00_sysfs_read_nvram(struct file *filp, struct kobject *kobj,
183	struct bin_attribute *bin_attr,
184	char *buf, loff_t off, size_t count)
185	{
186	struct scsi_qla_host *vha = shost_priv(shost: dev_to_shost(container_of(kobj,
187	struct device, kobj)));
188	struct qla_hw_data *ha = vha->hw;
189	uint32_t faddr;
190	struct active_regions active_regions = { };
191
192	if (!capable(CAP_SYS_ADMIN))
193	return 0;
194
195	mutex_lock(&ha->optrom_mutex);
196	if (qla2x00_chip_is_down(vha)) {
197	mutex_unlock(lock: &ha->optrom_mutex);
198	return -EAGAIN;
199	}
200
201	if (!IS_NOCACHE_VPD_TYPE(ha)) {
202	mutex_unlock(lock: &ha->optrom_mutex);
203	goto skip;
204	}
205
206	faddr = ha->flt_region_nvram;
207	if (IS_QLA28XX(ha)) {
208	qla28xx_get_aux_images(vha, &active_regions);
209	if (active_regions.aux.vpd_nvram == QLA27XX_SECONDARY_IMAGE)
210	faddr = ha->flt_region_nvram_sec;
211	}
212	ha->isp_ops->read_optrom(vha, ha->nvram, faddr << 2, ha->nvram_size);
213
214	mutex_unlock(lock: &ha->optrom_mutex);
215
216	skip:
217	return memory_read_from_buffer(to: buf, count, ppos: &off, from: ha->nvram,
218	available: ha->nvram_size);
219	}
220
221	static ssize_t
222	qla2x00_sysfs_write_nvram(struct file *filp, struct kobject *kobj,
223	struct bin_attribute *bin_attr,
224	char *buf, loff_t off, size_t count)
225	{
226	struct scsi_qla_host *vha = shost_priv(shost: dev_to_shost(container_of(kobj,
227	struct device, kobj)));
228	struct qla_hw_data *ha = vha->hw;
229	uint16_t cnt;
230
231	if (!capable(CAP_SYS_ADMIN) || off != 0 || count != ha->nvram_size ||
232	!ha->isp_ops->write_nvram)
233	return -EINVAL;
234
235	/* Checksum NVRAM. */
236	if (IS_FWI2_CAPABLE(ha)) {
237	__le32 *iter = (__force __le32 *)buf;
238	uint32_t chksum;
239
240	chksum = 0;
241	for (cnt = 0; cnt < ((count >> 2) - 1); cnt++, iter++)
242	chksum += le32_to_cpu(*iter);
243	chksum = ~chksum + 1;
244	*iter = cpu_to_le32(chksum);
245	} else {
246	uint8_t *iter;
247	uint8_t chksum;
248
249	iter = (uint8_t *)buf;
250	chksum = 0;
251	for (cnt = 0; cnt < count - 1; cnt++)
252	chksum += *iter++;
253	chksum = ~chksum + 1;
254	*iter = chksum;
255	}
256
257	if (qla2x00_wait_for_hba_online(vha) != QLA_SUCCESS) {
258	ql_log(ql_log_warn, vha, 0x705f,
259	fmt: "HBA not online, failing NVRAM update.\n");
260	return -EAGAIN;
261	}
262
263	mutex_lock(&ha->optrom_mutex);
264	if (qla2x00_chip_is_down(vha)) {
265	mutex_unlock(lock: &ha->optrom_mutex);
266	return -EAGAIN;
267	}
268
269	/* Write NVRAM. */
270	ha->isp_ops->write_nvram(vha, buf, ha->nvram_base, count);
271	ha->isp_ops->read_nvram(vha, ha->nvram, ha->nvram_base,
272	count);
273	mutex_unlock(lock: &ha->optrom_mutex);
274
275	ql_dbg(ql_dbg_user, vha, 0x7060,
276	fmt: "Setting ISP_ABORT_NEEDED\n");
277	/* NVRAM settings take effect immediately. */
278	set_bit(ISP_ABORT_NEEDED, addr: &vha->dpc_flags);
279	qla2xxx_wake_dpc(vha);
280	qla2x00_wait_for_chip_reset(vha);
281
282	return count;
283	}
284
285	static struct bin_attribute sysfs_nvram_attr = {
286	.attr = {
287	.name = "nvram",
288	.mode = S_IRUSR | S_IWUSR,
289	},
290	.size = 512,
291	.read = qla2x00_sysfs_read_nvram,
292	.write = qla2x00_sysfs_write_nvram,
293	};
294
295	static ssize_t
296	qla2x00_sysfs_read_optrom(struct file *filp, struct kobject *kobj,
297	struct bin_attribute *bin_attr,
298	char *buf, loff_t off, size_t count)
299	{
300	struct scsi_qla_host *vha = shost_priv(shost: dev_to_shost(container_of(kobj,
301	struct device, kobj)));
302	struct qla_hw_data *ha = vha->hw;
303	ssize_t rval = 0;
304
305	mutex_lock(&ha->optrom_mutex);
306
307	if (ha->optrom_state != QLA_SREADING)
308	goto out;
309
310	rval = memory_read_from_buffer(to: buf, count, ppos: &off, from: ha->optrom_buffer,
311	available: ha->optrom_region_size);
312
313	out:
314	mutex_unlock(lock: &ha->optrom_mutex);
315
316	return rval;
317	}
318
319	static ssize_t
320	qla2x00_sysfs_write_optrom(struct file *filp, struct kobject *kobj,
321	struct bin_attribute *bin_attr,
322	char *buf, loff_t off, size_t count)
323	{
324	struct scsi_qla_host *vha = shost_priv(shost: dev_to_shost(container_of(kobj,
325	struct device, kobj)));
326	struct qla_hw_data *ha = vha->hw;
327
328	mutex_lock(&ha->optrom_mutex);
329
330	if (ha->optrom_state != QLA_SWRITING) {
331	mutex_unlock(lock: &ha->optrom_mutex);
332	return -EINVAL;
333	}
334	if (off > ha->optrom_region_size) {
335	mutex_unlock(lock: &ha->optrom_mutex);
336	return -ERANGE;
337	}
338	if (off + count > ha->optrom_region_size)
339	count = ha->optrom_region_size - off;
340
341	memcpy(&ha->optrom_buffer[off], buf, count);
342	mutex_unlock(lock: &ha->optrom_mutex);
343
344	return count;
345	}
346
347	static struct bin_attribute sysfs_optrom_attr = {
348	.attr = {
349	.name = "optrom",
350	.mode = S_IRUSR | S_IWUSR,
351	},
352	.size = 0,
353	.read = qla2x00_sysfs_read_optrom,
354	.write = qla2x00_sysfs_write_optrom,
355	};
356
357	static ssize_t
358	qla2x00_sysfs_write_optrom_ctl(struct file *filp, struct kobject *kobj,
359	struct bin_attribute *bin_attr,
360	char *buf, loff_t off, size_t count)
361	{
362	struct scsi_qla_host *vha = shost_priv(shost: dev_to_shost(container_of(kobj,
363	struct device, kobj)));
364	struct qla_hw_data *ha = vha->hw;
365	uint32_t start = 0;
366	uint32_t size = ha->optrom_size;
367	int val, valid;
368	ssize_t rval = count;
369
370	if (off)
371	return -EINVAL;
372
373	if (unlikely(pci_channel_offline(ha->pdev)))
374	return -EAGAIN;
375
376	if (sscanf(buf, "%d:%x:%x", &val, &start, &size) < 1)
377	return -EINVAL;
378	if (start > ha->optrom_size)
379	return -EINVAL;
380	if (size > ha->optrom_size - start)
381	size = ha->optrom_size - start;
382
383	mutex_lock(&ha->optrom_mutex);
384	if (qla2x00_chip_is_down(vha)) {
385	mutex_unlock(lock: &ha->optrom_mutex);
386	return -EAGAIN;
387	}
388	switch (val) {
389	case 0:
390	if (ha->optrom_state != QLA_SREADING &&
391	ha->optrom_state != QLA_SWRITING) {
392	rval = -EINVAL;
393	goto out;
394	}
395	ha->optrom_state = QLA_SWAITING;
396
397	ql_dbg(ql_dbg_user, vha, 0x7061,
398	fmt: "Freeing flash region allocation -- 0x%x bytes.\n",
399	ha->optrom_region_size);
400
401	vfree(addr: ha->optrom_buffer);
402	ha->optrom_buffer = NULL;
403	break;
404	case 1:
405	if (ha->optrom_state != QLA_SWAITING) {
406	rval = -EINVAL;
407	goto out;
408	}
409
410	ha->optrom_region_start = start;
411	ha->optrom_region_size = size;
412
413	ha->optrom_state = QLA_SREADING;
414	ha->optrom_buffer = vzalloc(size: ha->optrom_region_size);
415	if (ha->optrom_buffer == NULL) {
416	ql_log(ql_log_warn, vha, 0x7062,
417	fmt: "Unable to allocate memory for optrom retrieval "
418	"(%x).\n", ha->optrom_region_size);
419
420	ha->optrom_state = QLA_SWAITING;
421	rval = -ENOMEM;
422	goto out;
423	}
424
425	if (qla2x00_wait_for_hba_online(vha) != QLA_SUCCESS) {
426	ql_log(ql_log_warn, vha, 0x7063,
427	fmt: "HBA not online, failing NVRAM update.\n");
428	rval = -EAGAIN;
429	goto out;
430	}
431
432	ql_dbg(ql_dbg_user, vha, 0x7064,
433	fmt: "Reading flash region -- 0x%x/0x%x.\n",
434	ha->optrom_region_start, ha->optrom_region_size);
435
436	ha->isp_ops->read_optrom(vha, ha->optrom_buffer,
437	ha->optrom_region_start, ha->optrom_region_size);
438	break;
439	case 2:
440	if (ha->optrom_state != QLA_SWAITING) {
441	rval = -EINVAL;
442	goto out;
443	}
444
445	/*
446	* We need to be more restrictive on which FLASH regions are
447	* allowed to be updated via user-space. Regions accessible
448	* via this method include:
449	*
450	* ISP21xx/ISP22xx/ISP23xx type boards:
451	*
452	* 0x000000 -> 0x020000 -- Boot code.
453	*
454	* ISP2322/ISP24xx type boards:
455	*
456	* 0x000000 -> 0x07ffff -- Boot code.
457	* 0x080000 -> 0x0fffff -- Firmware.
458	*
459	* ISP25xx type boards:
460	*
461	* 0x000000 -> 0x07ffff -- Boot code.
462	* 0x080000 -> 0x0fffff -- Firmware.
463	* 0x120000 -> 0x12ffff -- VPD and HBA parameters.
464	*
465	* > ISP25xx type boards:
466	*
467	* None -- should go through BSG.
468	*/
469	valid = 0;
470	if (ha->optrom_size == OPTROM_SIZE_2300 && start == 0)
471	valid = 1;
472	else if (IS_QLA24XX_TYPE(ha) || IS_QLA25XX(ha))
473	valid = 1;
474	if (!valid) {
475	ql_log(ql_log_warn, vha, 0x7065,
476	fmt: "Invalid start region 0x%x/0x%x.\n", start, size);
477	rval = -EINVAL;
478	goto out;
479	}
480
481	ha->optrom_region_start = start;
482	ha->optrom_region_size = size;
483
484	ha->optrom_state = QLA_SWRITING;
485	ha->optrom_buffer = vzalloc(size: ha->optrom_region_size);
486	if (ha->optrom_buffer == NULL) {
487	ql_log(ql_log_warn, vha, 0x7066,
488	fmt: "Unable to allocate memory for optrom update "
489	"(%x)\n", ha->optrom_region_size);
490
491	ha->optrom_state = QLA_SWAITING;
492	rval = -ENOMEM;
493	goto out;
494	}
495
496	ql_dbg(ql_dbg_user, vha, 0x7067,
497	fmt: "Staging flash region write -- 0x%x/0x%x.\n",
498	ha->optrom_region_start, ha->optrom_region_size);
499
500	break;
501	case 3:
502	if (ha->optrom_state != QLA_SWRITING) {
503	rval = -EINVAL;
504	goto out;
505	}
506
507	if (qla2x00_wait_for_hba_online(vha) != QLA_SUCCESS) {
508	ql_log(ql_log_warn, vha, 0x7068,
509	fmt: "HBA not online, failing flash update.\n");
510	rval = -EAGAIN;
511	goto out;
512	}
513
514	ql_dbg(ql_dbg_user, vha, 0x7069,
515	fmt: "Writing flash region -- 0x%x/0x%x.\n",
516	ha->optrom_region_start, ha->optrom_region_size);
517
518	rval = ha->isp_ops->write_optrom(vha, ha->optrom_buffer,
519	ha->optrom_region_start, ha->optrom_region_size);
520	if (rval)
521	rval = -EIO;
522	break;
523	default:
524	rval = -EINVAL;
525	}
526
527	out:
528	mutex_unlock(lock: &ha->optrom_mutex);
529	return rval;
530	}
531
532	static struct bin_attribute sysfs_optrom_ctl_attr = {
533	.attr = {
534	.name = "optrom_ctl",
535	.mode = S_IWUSR,
536	},
537	.size = 0,
538	.write = qla2x00_sysfs_write_optrom_ctl,
539	};
540
541	static ssize_t
542	qla2x00_sysfs_read_vpd(struct file *filp, struct kobject *kobj,
543	struct bin_attribute *bin_attr,
544	char *buf, loff_t off, size_t count)
545	{
546	struct scsi_qla_host *vha = shost_priv(shost: dev_to_shost(container_of(kobj,
547	struct device, kobj)));
548	struct qla_hw_data *ha = vha->hw;
549	uint32_t faddr;
550	struct active_regions active_regions = { };
551
552	if (unlikely(pci_channel_offline(ha->pdev)))
553	return -EAGAIN;
554
555	if (!capable(CAP_SYS_ADMIN))
556	return -EINVAL;
557
558	if (!IS_NOCACHE_VPD_TYPE(ha))
559	goto skip;
560
561	faddr = ha->flt_region_vpd << 2;
562
563	if (IS_QLA28XX(ha)) {
564	qla28xx_get_aux_images(vha, &active_regions);
565	if (active_regions.aux.vpd_nvram == QLA27XX_SECONDARY_IMAGE)
566	faddr = ha->flt_region_vpd_sec << 2;
567
568	ql_dbg(ql_dbg_init, vha, 0x7070,
569	fmt: "Loading %s nvram image.\n",
570	active_regions.aux.vpd_nvram == QLA27XX_PRIMARY_IMAGE ?
571	"primary" : "secondary");
572	}
573
574	mutex_lock(&ha->optrom_mutex);
575	if (qla2x00_chip_is_down(vha)) {
576	mutex_unlock(lock: &ha->optrom_mutex);
577	return -EAGAIN;
578	}
579
580	ha->isp_ops->read_optrom(vha, ha->vpd, faddr, ha->vpd_size);
581	mutex_unlock(lock: &ha->optrom_mutex);
582
583	ha->isp_ops->read_optrom(vha, ha->vpd, faddr, ha->vpd_size);
584	skip:
585	return memory_read_from_buffer(to: buf, count, ppos: &off, from: ha->vpd, available: ha->vpd_size);
586	}
587
588	static ssize_t
589	qla2x00_sysfs_write_vpd(struct file *filp, struct kobject *kobj,
590	struct bin_attribute *bin_attr,
591	char *buf, loff_t off, size_t count)
592	{
593	struct scsi_qla_host *vha = shost_priv(shost: dev_to_shost(container_of(kobj,
594	struct device, kobj)));
595	struct qla_hw_data *ha = vha->hw;
596	uint8_t *tmp_data;
597
598	if (unlikely(pci_channel_offline(ha->pdev)))
599	return 0;
600
601	if (qla2x00_chip_is_down(vha))
602	return 0;
603
604	if (!capable(CAP_SYS_ADMIN) || off != 0 || count != ha->vpd_size ||
605	!ha->isp_ops->write_nvram)
606	return 0;
607
608	if (qla2x00_wait_for_hba_online(vha) != QLA_SUCCESS) {
609	ql_log(ql_log_warn, vha, 0x706a,
610	fmt: "HBA not online, failing VPD update.\n");
611	return -EAGAIN;
612	}
613
614	mutex_lock(&ha->optrom_mutex);
615	if (qla2x00_chip_is_down(vha)) {
616	mutex_unlock(lock: &ha->optrom_mutex);
617	return -EAGAIN;
618	}
619
620	/* Write NVRAM. */
621	ha->isp_ops->write_nvram(vha, buf, ha->vpd_base, count);
622	ha->isp_ops->read_nvram(vha, ha->vpd, ha->vpd_base, count);
623
624	/* Update flash version information for 4Gb & above. */
625	if (!IS_FWI2_CAPABLE(ha)) {
626	mutex_unlock(lock: &ha->optrom_mutex);
627	return -EINVAL;
628	}
629
630	tmp_data = vmalloc(size: 256);
631	if (!tmp_data) {
632	mutex_unlock(lock: &ha->optrom_mutex);
633	ql_log(ql_log_warn, vha, 0x706b,
634	fmt: "Unable to allocate memory for VPD information update.\n");
635	return -ENOMEM;
636	}
637	ha->isp_ops->get_flash_version(vha, tmp_data);
638	vfree(addr: tmp_data);
639
640	mutex_unlock(lock: &ha->optrom_mutex);
641
642	return count;
643	}
644
645	static struct bin_attribute sysfs_vpd_attr = {
646	.attr = {
647	.name = "vpd",
648	.mode = S_IRUSR | S_IWUSR,
649	},
650	.size = 0,
651	.read = qla2x00_sysfs_read_vpd,
652	.write = qla2x00_sysfs_write_vpd,
653	};
654
655	static ssize_t
656	qla2x00_sysfs_read_sfp(struct file *filp, struct kobject *kobj,
657	struct bin_attribute *bin_attr,
658	char *buf, loff_t off, size_t count)
659	{
660	struct scsi_qla_host *vha = shost_priv(shost: dev_to_shost(container_of(kobj,
661	struct device, kobj)));
662	int rval;
663
664	if (!capable(CAP_SYS_ADMIN) || off != 0 || count < SFP_DEV_SIZE)
665	return 0;
666
667	mutex_lock(&vha->hw->optrom_mutex);
668	if (qla2x00_chip_is_down(vha)) {
669	mutex_unlock(lock: &vha->hw->optrom_mutex);
670	return 0;
671	}
672
673	rval = qla2x00_read_sfp_dev(vha, buf, count);
674	mutex_unlock(lock: &vha->hw->optrom_mutex);
675
676	if (rval)
677	return -EIO;
678
679	return count;
680	}
681
682	static struct bin_attribute sysfs_sfp_attr = {
683	.attr = {
684	.name = "sfp",
685	.mode = S_IRUSR | S_IWUSR,
686	},
687	.size = SFP_DEV_SIZE,
688	.read = qla2x00_sysfs_read_sfp,
689	};
690
691	static ssize_t
692	qla2x00_sysfs_write_reset(struct file *filp, struct kobject *kobj,
693	struct bin_attribute *bin_attr,
694	char *buf, loff_t off, size_t count)
695	{
696	struct scsi_qla_host *vha = shost_priv(shost: dev_to_shost(container_of(kobj,
697	struct device, kobj)));
698	struct qla_hw_data *ha = vha->hw;
699	struct scsi_qla_host *base_vha = pci_get_drvdata(pdev: ha->pdev);
700	int type;
701	uint32_t idc_control;
702	uint8_t *tmp_data = NULL;
703
704	if (off != 0)
705	return -EINVAL;
706
707	type = simple_strtol(buf, NULL, 10);
708	switch (type) {
709	case 0x2025c:
710	ql_log(ql_log_info, vha, 0x706e,
711	fmt: "Issuing ISP reset.\n");
712
713	if (vha->hw->flags.port_isolated) {
714	ql_log(ql_log_info, vha, 0x706e,
715	fmt: "Port is isolated, returning.\n");
716	return -EINVAL;
717	}
718
719	scsi_block_requests(vha->host);
720	if (IS_QLA82XX(ha)) {
721	ha->flags.isp82xx_no_md_cap = 1;
722	qla82xx_idc_lock(ha);
723	qla82xx_set_reset_owner(vha);
724	qla82xx_idc_unlock(ha);
725	} else if (IS_QLA8044(ha)) {
726	qla8044_idc_lock(ha);
727	idc_control = qla8044_rd_reg(ha,
728	QLA8044_IDC_DRV_CTRL);
729	qla8044_wr_reg(ha, QLA8044_IDC_DRV_CTRL,
730	val: (idc_control | GRACEFUL_RESET_BIT1));
731	qla82xx_set_reset_owner(vha);
732	qla8044_idc_unlock(ha);
733	} else {
734	set_bit(ISP_ABORT_NEEDED, addr: &vha->dpc_flags);
735	qla2xxx_wake_dpc(vha);
736	}
737	qla2x00_wait_for_chip_reset(vha);
738	scsi_unblock_requests(vha->host);
739	break;
740	case 0x2025d:
741	if (!IS_QLA81XX(ha) && !IS_QLA83XX(ha) &&
742	!IS_QLA27XX(ha) && !IS_QLA28XX(ha))
743	return -EPERM;
744
745	ql_log(ql_log_info, vha, 0x706f,
746	fmt: "Issuing MPI reset.\n");
747
748	if (IS_QLA83XX(ha)) {
749	uint32_t idc_control;
750
751	qla83xx_idc_lock(vha, 0);
752	__qla83xx_get_idc_control(vha, &idc_control);
753	idc_control |= QLA83XX_IDC_GRACEFUL_RESET;
754	__qla83xx_set_idc_control(vha, idc_control);
755	qla83xx_wr_reg(vha, QLA83XX_IDC_DEV_STATE,
756	QLA8XXX_DEV_NEED_RESET);
757	qla83xx_idc_audit(vha, IDC_AUDIT_TIMESTAMP);
758	qla83xx_idc_unlock(vha, 0);
759	break;
760	} else {
761	/* Make sure FC side is not in reset */
762	WARN_ON_ONCE(qla2x00_wait_for_hba_online(vha) !=
763	QLA_SUCCESS);
764
765	/* Issue MPI reset */
766	scsi_block_requests(vha->host);
767	if (qla81xx_restart_mpi_firmware(vha) != QLA_SUCCESS)
768	ql_log(ql_log_warn, vha, 0x7070,
769	fmt: "MPI reset failed.\n");
770	scsi_unblock_requests(vha->host);
771	break;
772	}
773	break;
774	case 0x2025e:
775	if (!IS_P3P_TYPE(ha) || vha != base_vha) {
776	ql_log(ql_log_info, vha, 0x7071,
777	fmt: "FCoE ctx reset not supported.\n");
778	return -EPERM;
779	}
780
781	ql_log(ql_log_info, vha, 0x7072,
782	fmt: "Issuing FCoE ctx reset.\n");
783	set_bit(FCOE_CTX_RESET_NEEDED, addr: &vha->dpc_flags);
784	qla2xxx_wake_dpc(vha);
785	qla2x00_wait_for_fcoe_ctx_reset(vha);
786	break;
787	case 0x2025f:
788	if (!IS_QLA8031(ha))
789	return -EPERM;
790	ql_log(ql_log_info, vha, 0x70bc,
791	fmt: "Disabling Reset by IDC control\n");
792	qla83xx_idc_lock(vha, 0);
793	__qla83xx_get_idc_control(vha, &idc_control);
794	idc_control |= QLA83XX_IDC_RESET_DISABLED;
795	__qla83xx_set_idc_control(vha, idc_control);
796	qla83xx_idc_unlock(vha, 0);
797	break;
798	case 0x20260:
799	if (!IS_QLA8031(ha))
800	return -EPERM;
801	ql_log(ql_log_info, vha, 0x70bd,
802	fmt: "Enabling Reset by IDC control\n");
803	qla83xx_idc_lock(vha, 0);
804	__qla83xx_get_idc_control(vha, &idc_control);
805	idc_control &= ~QLA83XX_IDC_RESET_DISABLED;
806	__qla83xx_set_idc_control(vha, idc_control);
807	qla83xx_idc_unlock(vha, 0);
808	break;
809	case 0x20261:
810	ql_dbg(ql_dbg_user, vha, 0x70e0,
811	fmt: "Updating cache versions without reset ");
812
813	tmp_data = vmalloc(size: 256);
814	if (!tmp_data) {
815	ql_log(ql_log_warn, vha, 0x70e1,
816	fmt: "Unable to allocate memory for VPD information update.\n");
817	return -ENOMEM;
818	}
819	ha->isp_ops->get_flash_version(vha, tmp_data);
820	vfree(addr: tmp_data);
821	break;
822	}
823	return count;
824	}
825
826	static struct bin_attribute sysfs_reset_attr = {
827	.attr = {
828	.name = "reset",
829	.mode = S_IWUSR,
830	},
831	.size = 0,
832	.write = qla2x00_sysfs_write_reset,
833	};
834
835	static ssize_t
836	qla2x00_issue_logo(struct file *filp, struct kobject *kobj,
837	struct bin_attribute *bin_attr,
838	char *buf, loff_t off, size_t count)
839	{
840	struct scsi_qla_host *vha = shost_priv(shost: dev_to_shost(container_of(kobj,
841	struct device, kobj)));
842	int type;
843	port_id_t did;
844
845	if (!capable(CAP_SYS_ADMIN))
846	return 0;
847
848	if (unlikely(pci_channel_offline(vha->hw->pdev)))
849	return 0;
850
851	if (qla2x00_chip_is_down(vha))
852	return 0;
853
854	type = simple_strtol(buf, NULL, 10);
855
856	did.b.domain = (type & 0x00ff0000) >> 16;
857	did.b.area = (type & 0x0000ff00) >> 8;
858	did.b.al_pa = (type & 0x000000ff);
859
860	ql_log(ql_log_info, vha, 0xd04d, fmt: "portid=%02x%02x%02x done\n",
861	did.b.domain, did.b.area, did.b.al_pa);
862
863	ql_log(ql_log_info, vha, 0x70e4, fmt: "%s: %d\n", __func__, type);
864
865	qla24xx_els_dcmd_iocb(vha, ELS_DCMD_LOGO, did);
866	return count;
867	}
868
869	static struct bin_attribute sysfs_issue_logo_attr = {
870	.attr = {
871	.name = "issue_logo",
872	.mode = S_IWUSR,
873	},
874	.size = 0,
875	.write = qla2x00_issue_logo,
876	};
877
878	static ssize_t
879	qla2x00_sysfs_read_xgmac_stats(struct file *filp, struct kobject *kobj,
880	struct bin_attribute *bin_attr,
881	char *buf, loff_t off, size_t count)
882	{
883	struct scsi_qla_host *vha = shost_priv(shost: dev_to_shost(container_of(kobj,
884	struct device, kobj)));
885	struct qla_hw_data *ha = vha->hw;
886	int rval;
887	uint16_t actual_size;
888
889	if (!capable(CAP_SYS_ADMIN) || off != 0 || count > XGMAC_DATA_SIZE)
890	return 0;
891
892	if (unlikely(pci_channel_offline(ha->pdev)))
893	return 0;
894	mutex_lock(&vha->hw->optrom_mutex);
895	if (qla2x00_chip_is_down(vha)) {
896	mutex_unlock(lock: &vha->hw->optrom_mutex);
897	return 0;
898	}
899
900	if (ha->xgmac_data)
901	goto do_read;
902
903	ha->xgmac_data = dma_alloc_coherent(dev: &ha->pdev->dev, XGMAC_DATA_SIZE,
904	dma_handle: &ha->xgmac_data_dma, GFP_KERNEL);
905	if (!ha->xgmac_data) {
906	mutex_unlock(lock: &vha->hw->optrom_mutex);
907	ql_log(ql_log_warn, vha, 0x7076,
908	fmt: "Unable to allocate memory for XGMAC read-data.\n");
909	return 0;
910	}
911
912	do_read:
913	actual_size = 0;
914	memset(ha->xgmac_data, 0, XGMAC_DATA_SIZE);
915
916	rval = qla2x00_get_xgmac_stats(vha, ha->xgmac_data_dma,
917	XGMAC_DATA_SIZE, &actual_size);
918
919	mutex_unlock(lock: &vha->hw->optrom_mutex);
920	if (rval != QLA_SUCCESS) {
921	ql_log(ql_log_warn, vha, 0x7077,
922	fmt: "Unable to read XGMAC data (%x).\n", rval);
923	count = 0;
924	}
925
926	count = actual_size > count ? count : actual_size;
927	memcpy(buf, ha->xgmac_data, count);
928
929	return count;
930	}
931
932	static struct bin_attribute sysfs_xgmac_stats_attr = {
933	.attr = {
934	.name = "xgmac_stats",
935	.mode = S_IRUSR,
936	},
937	.size = 0,
938	.read = qla2x00_sysfs_read_xgmac_stats,
939	};
940
941	static ssize_t
942	qla2x00_sysfs_read_dcbx_tlv(struct file *filp, struct kobject *kobj,
943	struct bin_attribute *bin_attr,
944	char *buf, loff_t off, size_t count)
945	{
946	struct scsi_qla_host *vha = shost_priv(shost: dev_to_shost(container_of(kobj,
947	struct device, kobj)));
948	struct qla_hw_data *ha = vha->hw;
949	int rval;
950
951	if (!capable(CAP_SYS_ADMIN) || off != 0 || count > DCBX_TLV_DATA_SIZE)
952	return 0;
953
954	mutex_lock(&vha->hw->optrom_mutex);
955	if (ha->dcbx_tlv)
956	goto do_read;
957	if (qla2x00_chip_is_down(vha)) {
958	mutex_unlock(lock: &vha->hw->optrom_mutex);
959	return 0;
960	}
961
962	ha->dcbx_tlv = dma_alloc_coherent(dev: &ha->pdev->dev, DCBX_TLV_DATA_SIZE,
963	dma_handle: &ha->dcbx_tlv_dma, GFP_KERNEL);
964	if (!ha->dcbx_tlv) {
965	mutex_unlock(lock: &vha->hw->optrom_mutex);
966	ql_log(ql_log_warn, vha, 0x7078,
967	fmt: "Unable to allocate memory for DCBX TLV read-data.\n");
968	return -ENOMEM;
969	}
970
971	do_read:
972	memset(ha->dcbx_tlv, 0, DCBX_TLV_DATA_SIZE);
973
974	rval = qla2x00_get_dcbx_params(vha, ha->dcbx_tlv_dma,
975	DCBX_TLV_DATA_SIZE);
976
977	mutex_unlock(lock: &vha->hw->optrom_mutex);
978
979	if (rval != QLA_SUCCESS) {
980	ql_log(ql_log_warn, vha, 0x7079,
981	fmt: "Unable to read DCBX TLV (%x).\n", rval);
982	return -EIO;
983	}
984
985	memcpy(buf, ha->dcbx_tlv, count);
986
987	return count;
988	}
989
990	static struct bin_attribute sysfs_dcbx_tlv_attr = {
991	.attr = {
992	.name = "dcbx_tlv",
993	.mode = S_IRUSR,
994	},
995	.size = 0,
996	.read = qla2x00_sysfs_read_dcbx_tlv,
997	};
998
999	static struct sysfs_entry {
1000	char *name;
1001	struct bin_attribute *attr;
1002	int type;
1003	} bin_file_entries[] = {
1004	{ "fw_dump", &sysfs_fw_dump_attr, },
1005	{ "nvram", &sysfs_nvram_attr, },
1006	{ "optrom", &sysfs_optrom_attr, },
1007	{ "optrom_ctl", &sysfs_optrom_ctl_attr, },
1008	{ "vpd", &sysfs_vpd_attr, 1 },
1009	{ "sfp", &sysfs_sfp_attr, 1 },
1010	{ "reset", &sysfs_reset_attr, },
1011	{ "issue_logo", &sysfs_issue_logo_attr, },
1012	{ "xgmac_stats", &sysfs_xgmac_stats_attr, 3 },
1013	{ "dcbx_tlv", &sysfs_dcbx_tlv_attr, 3 },
1014	{ NULL },
1015	};
1016
1017	void
1018	qla2x00_alloc_sysfs_attr(scsi_qla_host_t *vha)
1019	{
1020	struct Scsi_Host *host = vha->host;
1021	struct sysfs_entry *iter;
1022	int ret;
1023
1024	for (iter = bin_file_entries; iter->name; iter++) {
1025	if (iter->type && !IS_FWI2_CAPABLE(vha->hw))
1026	continue;
1027	if (iter->type == 2 && !IS_QLA25XX(vha->hw))
1028	continue;
1029	if (iter->type == 3 && !(IS_CNA_CAPABLE(vha->hw)))
1030	continue;
1031
1032	ret = sysfs_create_bin_file(kobj: &host->shost_gendev.kobj,
1033	attr: iter->attr);
1034	if (ret)
1035	ql_log(ql_log_warn, vha, 0x00f3,
1036	fmt: "Unable to create sysfs %s binary attribute (%d).\n",
1037	iter->name, ret);
1038	else
1039	ql_dbg(ql_dbg_init, vha, 0x00f4,
1040	fmt: "Successfully created sysfs %s binary attribute.\n",
1041	iter->name);
1042	}
1043	}
1044
1045	void
1046	qla2x00_free_sysfs_attr(scsi_qla_host_t *vha, bool stop_beacon)
1047	{
1048	struct Scsi_Host *host = vha->host;
1049	struct sysfs_entry *iter;
1050	struct qla_hw_data *ha = vha->hw;
1051
1052	for (iter = bin_file_entries; iter->name; iter++) {
1053	if (iter->type && !IS_FWI2_CAPABLE(ha))
1054	continue;
1055	if (iter->type == 2 && !IS_QLA25XX(ha))
1056	continue;
1057	if (iter->type == 3 && !(IS_CNA_CAPABLE(ha)))
1058	continue;
1059
1060	sysfs_remove_bin_file(kobj: &host->shost_gendev.kobj,
1061	attr: iter->attr);
1062	}
1063
1064	if (stop_beacon && ha->beacon_blink_led == 1)
1065	ha->isp_ops->beacon_off(vha);
1066	}
1067
1068	/* Scsi_Host attributes. */
1069
1070	static ssize_t
1071	qla2x00_driver_version_show(struct device *dev,
1072	struct device_attribute *attr, char *buf)
1073	{
1074	return scnprintf(buf, PAGE_SIZE, fmt: "%s\n", qla2x00_version_str);
1075	}
1076
1077	static ssize_t
1078	qla2x00_fw_version_show(struct device *dev,
1079	struct device_attribute *attr, char *buf)
1080	{
1081	scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1082	struct qla_hw_data *ha = vha->hw;
1083	char fw_str[128];
1084
1085	return scnprintf(buf, PAGE_SIZE, fmt: "%s\n",
1086	ha->isp_ops->fw_version_str(vha, fw_str, sizeof(fw_str)));
1087	}
1088
1089	static ssize_t
1090	qla2x00_serial_num_show(struct device *dev, struct device_attribute *attr,
1091	char *buf)
1092	{
1093	scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1094	struct qla_hw_data *ha = vha->hw;
1095	uint32_t sn;
1096
1097	if (IS_QLAFX00(vha->hw)) {
1098	return scnprintf(buf, PAGE_SIZE, fmt: "%s\n",
1099	vha->hw->mr.serial_num);
1100	} else if (IS_FWI2_CAPABLE(ha)) {
1101	qla2xxx_get_vpd_field(vha, "SN", buf, PAGE_SIZE - 1);
1102	return strlen(strcat(buf, "\n"));
1103	}
1104
1105	sn = ((ha->serial0 & 0x1f) << 16) | (ha->serial2 << 8) | ha->serial1;
1106	return scnprintf(buf, PAGE_SIZE, fmt: "%c%05d\n", 'A' + sn / 100000,
1107	sn % 100000);
1108	}
1109
1110	static ssize_t
1111	qla2x00_isp_name_show(struct device *dev, struct device_attribute *attr,
1112	char *buf)
1113	{
1114	scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1115
1116	return scnprintf(buf, PAGE_SIZE, fmt: "ISP%04X\n", vha->hw->pdev->device);
1117	}
1118
1119	static ssize_t
1120	qla2x00_isp_id_show(struct device *dev, struct device_attribute *attr,
1121	char *buf)
1122	{
1123	scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1124	struct qla_hw_data *ha = vha->hw;
1125
1126	if (IS_QLAFX00(vha->hw))
1127	return scnprintf(buf, PAGE_SIZE, fmt: "%s\n",
1128	vha->hw->mr.hw_version);
1129
1130	return scnprintf(buf, PAGE_SIZE, fmt: "%04x %04x %04x %04x\n",
1131	ha->product_id[0], ha->product_id[1], ha->product_id[2],
1132	ha->product_id[3]);
1133	}
1134
1135	static ssize_t
1136	qla2x00_model_name_show(struct device *dev, struct device_attribute *attr,
1137	char *buf)
1138	{
1139	scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1140
1141	return scnprintf(buf, PAGE_SIZE, fmt: "%s\n", vha->hw->model_number);
1142	}
1143
1144	static ssize_t
1145	qla2x00_model_desc_show(struct device *dev, struct device_attribute *attr,
1146	char *buf)
1147	{
1148	scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1149
1150	return scnprintf(buf, PAGE_SIZE, fmt: "%s\n", vha->hw->model_desc);
1151	}
1152
1153	static ssize_t
1154	qla2x00_pci_info_show(struct device *dev, struct device_attribute *attr,
1155	char *buf)
1156	{
1157	scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1158	char pci_info[30];
1159
1160	return scnprintf(buf, PAGE_SIZE, fmt: "%s\n",
1161	vha->hw->isp_ops->pci_info_str(vha, pci_info,
1162	sizeof(pci_info)));
1163	}
1164
1165	static ssize_t
1166	qla2x00_link_state_show(struct device *dev, struct device_attribute *attr,
1167	char *buf)
1168	{
1169	scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1170	struct qla_hw_data *ha = vha->hw;
1171	int len = 0;
1172
1173	if (atomic_read(v: &vha->loop_state) == LOOP_DOWN ||
1174	atomic_read(v: &vha->loop_state) == LOOP_DEAD ||
1175	vha->device_flags & DFLG_NO_CABLE)
1176	len = scnprintf(buf, PAGE_SIZE, fmt: "Link Down\n");
1177	else if (atomic_read(v: &vha->loop_state) != LOOP_READY ||
1178	qla2x00_chip_is_down(vha))
1179	len = scnprintf(buf, PAGE_SIZE, fmt: "Unknown Link State\n");
1180	else {
1181	len = scnprintf(buf, PAGE_SIZE, fmt: "Link Up - ");
1182
1183	switch (ha->current_topology) {
1184	case ISP_CFG_NL:
1185	len += scnprintf(buf: buf + len, PAGE_SIZE-len, fmt: "Loop\n");
1186	break;
1187	case ISP_CFG_FL:
1188	len += scnprintf(buf: buf + len, PAGE_SIZE-len, fmt: "FL_Port\n");
1189	break;
1190	case ISP_CFG_N:
1191	len += scnprintf(buf: buf + len, PAGE_SIZE-len,
1192	fmt: "N_Port to N_Port\n");
1193	break;
1194	case ISP_CFG_F:
1195	len += scnprintf(buf: buf + len, PAGE_SIZE-len, fmt: "F_Port\n");
1196	break;
1197	default:
1198	len += scnprintf(buf: buf + len, PAGE_SIZE-len, fmt: "Loop\n");
1199	break;
1200	}
1201	}
1202	return len;
1203	}
1204
1205	static ssize_t
1206	qla2x00_zio_show(struct device *dev, struct device_attribute *attr,
1207	char *buf)
1208	{
1209	scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1210	int len = 0;
1211
1212	switch (vha->hw->zio_mode) {
1213	case QLA_ZIO_MODE_6:
1214	len += scnprintf(buf: buf + len, PAGE_SIZE-len, fmt: "Mode 6\n");
1215	break;
1216	case QLA_ZIO_DISABLED:
1217	len += scnprintf(buf: buf + len, PAGE_SIZE-len, fmt: "Disabled\n");
1218	break;
1219	}
1220	return len;
1221	}
1222
1223	static ssize_t
1224	qla2x00_zio_store(struct device *dev, struct device_attribute *attr,
1225	const char *buf, size_t count)
1226	{
1227	scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1228	struct qla_hw_data *ha = vha->hw;
1229	int val = 0;
1230	uint16_t zio_mode;
1231
1232	if (!IS_ZIO_SUPPORTED(ha))
1233	return -ENOTSUPP;
1234
1235	if (sscanf(buf, "%d", &val) != 1)
1236	return -EINVAL;
1237
1238	if (val)
1239	zio_mode = QLA_ZIO_MODE_6;
1240	else
1241	zio_mode = QLA_ZIO_DISABLED;
1242
1243	/* Update per-hba values and queue a reset. */
1244	if (zio_mode != QLA_ZIO_DISABLED || ha->zio_mode != QLA_ZIO_DISABLED) {
1245	ha->zio_mode = zio_mode;
1246	set_bit(ISP_ABORT_NEEDED, addr: &vha->dpc_flags);
1247	}
1248	return strlen(buf);
1249	}
1250
1251	static ssize_t
1252	qla2x00_zio_timer_show(struct device *dev, struct device_attribute *attr,
1253	char *buf)
1254	{
1255	scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1256
1257	return scnprintf(buf, PAGE_SIZE, fmt: "%d us\n", vha->hw->zio_timer * 100);
1258	}
1259
1260	static ssize_t
1261	qla2x00_zio_timer_store(struct device *dev, struct device_attribute *attr,
1262	const char *buf, size_t count)
1263	{
1264	scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1265	int val = 0;
1266	uint16_t zio_timer;
1267
1268	if (sscanf(buf, "%d", &val) != 1)
1269	return -EINVAL;
1270	if (val > 25500 || val < 100)
1271	return -ERANGE;
1272
1273	zio_timer = (uint16_t)(val / 100);
1274	vha->hw->zio_timer = zio_timer;
1275
1276	return strlen(buf);
1277	}
1278
1279	static ssize_t
1280	qla_zio_threshold_show(struct device *dev, struct device_attribute *attr,
1281	char *buf)
1282	{
1283	scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1284
1285	return scnprintf(buf, PAGE_SIZE, fmt: "%d exchanges\n",
1286	vha->hw->last_zio_threshold);
1287	}
1288
1289	static ssize_t
1290	qla_zio_threshold_store(struct device *dev, struct device_attribute *attr,
1291	const char *buf, size_t count)
1292	{
1293	scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1294	int val = 0;
1295
1296	if (vha->hw->zio_mode != QLA_ZIO_MODE_6)
1297	return -EINVAL;
1298	if (sscanf(buf, "%d", &val) != 1)
1299	return -EINVAL;
1300	if (val < 0 || val > 256)
1301	return -ERANGE;
1302
1303	atomic_set(v: &vha->hw->zio_threshold, i: val);
1304	return strlen(buf);
1305	}
1306
1307	static ssize_t
1308	qla2x00_beacon_show(struct device *dev, struct device_attribute *attr,
1309	char *buf)
1310	{
1311	scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1312	int len = 0;
1313
1314	if (vha->hw->beacon_blink_led)
1315	len += scnprintf(buf: buf + len, PAGE_SIZE-len, fmt: "Enabled\n");
1316	else
1317	len += scnprintf(buf: buf + len, PAGE_SIZE-len, fmt: "Disabled\n");
1318	return len;
1319	}
1320
1321	static ssize_t
1322	qla2x00_beacon_store(struct device *dev, struct device_attribute *attr,
1323	const char *buf, size_t count)
1324	{
1325	scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1326	struct qla_hw_data *ha = vha->hw;
1327	int val = 0;
1328	int rval;
1329
1330	if (IS_QLA2100(ha) || IS_QLA2200(ha))
1331	return -EPERM;
1332
1333	if (sscanf(buf, "%d", &val) != 1)
1334	return -EINVAL;
1335
1336	mutex_lock(&vha->hw->optrom_mutex);
1337	if (qla2x00_chip_is_down(vha)) {
1338	mutex_unlock(lock: &vha->hw->optrom_mutex);
1339	ql_log(ql_log_warn, vha, 0x707a,
1340	fmt: "Abort ISP active -- ignoring beacon request.\n");
1341	return -EBUSY;
1342	}
1343
1344	if (val)
1345	rval = ha->isp_ops->beacon_on(vha);
1346	else
1347	rval = ha->isp_ops->beacon_off(vha);
1348
1349	if (rval != QLA_SUCCESS)
1350	count = 0;
1351
1352	mutex_unlock(lock: &vha->hw->optrom_mutex);
1353
1354	return count;
1355	}
1356
1357	static ssize_t
1358	qla2x00_beacon_config_show(struct device *dev, struct device_attribute *attr,
1359	char *buf)
1360	{
1361	scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1362	struct qla_hw_data *ha = vha->hw;
1363	uint16_t led[3] = { 0 };
1364
1365	if (!IS_QLA2031(ha) && !IS_QLA27XX(ha) && !IS_QLA28XX(ha))
1366	return -EPERM;
1367
1368	if (ql26xx_led_config(vha, 0, led))
1369	return scnprintf(buf, PAGE_SIZE, fmt: "\n");
1370
1371	return scnprintf(buf, PAGE_SIZE, fmt: "%#04hx %#04hx %#04hx\n",
1372	led[0], led[1], led[2]);
1373	}
1374
1375	static ssize_t
1376	qla2x00_beacon_config_store(struct device *dev, struct device_attribute *attr,
1377	const char *buf, size_t count)
1378	{
1379	scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1380	struct qla_hw_data *ha = vha->hw;
1381	uint16_t options = BIT_0;
1382	uint16_t led[3] = { 0 };
1383	uint16_t word[4];
1384	int n;
1385
1386	if (!IS_QLA2031(ha) && !IS_QLA27XX(ha) && !IS_QLA28XX(ha))
1387	return -EPERM;
1388
1389	n = sscanf(buf, "%hx %hx %hx %hx", word+0, word+1, word+2, word+3);
1390	if (n == 4) {
1391	if (word[0] == 3) {
1392	options |= BIT_3|BIT_2|BIT_1;
1393	led[0] = word[1];
1394	led[1] = word[2];
1395	led[2] = word[3];
1396	goto write;
1397	}
1398	return -EINVAL;
1399	}
1400
1401	if (n == 2) {
1402	/* check led index */
1403	if (word[0] == 0) {
1404	options |= BIT_2;
1405	led[0] = word[1];
1406	goto write;
1407	}
1408	if (word[0] == 1) {
1409	options |= BIT_3;
1410	led[1] = word[1];
1411	goto write;
1412	}
1413	if (word[0] == 2) {
1414	options |= BIT_1;
1415	led[2] = word[1];
1416	goto write;
1417	}
1418	return -EINVAL;
1419	}
1420
1421	return -EINVAL;
1422
1423	write:
1424	if (ql26xx_led_config(vha, options, led))
1425	return -EFAULT;
1426
1427	return count;
1428	}
1429
1430	static ssize_t
1431	qla2x00_optrom_bios_version_show(struct device *dev,
1432	struct device_attribute *attr, char *buf)
1433	{
1434	scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1435	struct qla_hw_data *ha = vha->hw;
1436
1437	return scnprintf(buf, PAGE_SIZE, fmt: "%d.%02d\n", ha->bios_revision[1],
1438	ha->bios_revision[0]);
1439	}
1440
1441	static ssize_t
1442	qla2x00_optrom_efi_version_show(struct device *dev,
1443	struct device_attribute *attr, char *buf)
1444	{
1445	scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1446	struct qla_hw_data *ha = vha->hw;
1447
1448	return scnprintf(buf, PAGE_SIZE, fmt: "%d.%02d\n", ha->efi_revision[1],
1449	ha->efi_revision[0]);
1450	}
1451
1452	static ssize_t
1453	qla2x00_optrom_fcode_version_show(struct device *dev,
1454	struct device_attribute *attr, char *buf)
1455	{
1456	scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1457	struct qla_hw_data *ha = vha->hw;
1458
1459	return scnprintf(buf, PAGE_SIZE, fmt: "%d.%02d\n", ha->fcode_revision[1],
1460	ha->fcode_revision[0]);
1461	}
1462
1463	static ssize_t
1464	qla2x00_optrom_fw_version_show(struct device *dev,
1465	struct device_attribute *attr, char *buf)
1466	{
1467	scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1468	struct qla_hw_data *ha = vha->hw;
1469
1470	return scnprintf(buf, PAGE_SIZE, fmt: "%d.%02d.%02d %d\n",
1471	ha->fw_revision[0], ha->fw_revision[1], ha->fw_revision[2],
1472	ha->fw_revision[3]);
1473	}
1474
1475	static ssize_t
1476	qla2x00_optrom_gold_fw_version_show(struct device *dev,
1477	struct device_attribute *attr, char *buf)
1478	{
1479	scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1480	struct qla_hw_data *ha = vha->hw;
1481
1482	if (!IS_QLA81XX(ha) && !IS_QLA83XX(ha) &&
1483	!IS_QLA27XX(ha) && !IS_QLA28XX(ha))
1484	return scnprintf(buf, PAGE_SIZE, fmt: "\n");
1485
1486	return scnprintf(buf, PAGE_SIZE, fmt: "%d.%02d.%02d (%d)\n",
1487	ha->gold_fw_version[0], ha->gold_fw_version[1],
1488	ha->gold_fw_version[2], ha->gold_fw_version[3]);
1489	}
1490
1491	static ssize_t
1492	qla2x00_total_isp_aborts_show(struct device *dev,
1493	struct device_attribute *attr, char *buf)
1494	{
1495	scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1496
1497	return scnprintf(buf, PAGE_SIZE, fmt: "%d\n",
1498	vha->qla_stats.total_isp_aborts);
1499	}
1500
1501	static ssize_t
1502	qla24xx_84xx_fw_version_show(struct device *dev,
1503	struct device_attribute *attr, char *buf)
1504	{
1505	int rval = QLA_SUCCESS;
1506	uint16_t status[2] = { 0 };
1507	scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1508	struct qla_hw_data *ha = vha->hw;
1509
1510	if (!IS_QLA84XX(ha))
1511	return scnprintf(buf, PAGE_SIZE, fmt: "\n");
1512
1513	if (!ha->cs84xx->op_fw_version) {
1514	rval = qla84xx_verify_chip(vha, status);
1515
1516	if (!rval && !status[0])
1517	return scnprintf(buf, PAGE_SIZE, fmt: "%u\n",
1518	(uint32_t)ha->cs84xx->op_fw_version);
1519	}
1520
1521	return scnprintf(buf, PAGE_SIZE, fmt: "\n");
1522	}
1523
1524	static ssize_t
1525	qla2x00_serdes_version_show(struct device *dev, struct device_attribute *attr,
1526	char *buf)
1527	{
1528	scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1529	struct qla_hw_data *ha = vha->hw;
1530
1531	if (!IS_QLA27XX(ha) && !IS_QLA28XX(ha))
1532	return scnprintf(buf, PAGE_SIZE, fmt: "\n");
1533
1534	return scnprintf(buf, PAGE_SIZE, fmt: "%d.%02d.%02d\n",
1535	ha->serdes_version[0], ha->serdes_version[1],
1536	ha->serdes_version[2]);
1537	}
1538
1539	static ssize_t
1540	qla2x00_mpi_version_show(struct device *dev, struct device_attribute *attr,
1541	char *buf)
1542	{
1543	scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1544	struct qla_hw_data *ha = vha->hw;
1545
1546	if (!IS_QLA81XX(ha) && !IS_QLA8031(ha) && !IS_QLA8044(ha) &&
1547	!IS_QLA27XX(ha) && !IS_QLA28XX(ha))
1548	return scnprintf(buf, PAGE_SIZE, fmt: "\n");
1549
1550	return scnprintf(buf, PAGE_SIZE, fmt: "%d.%02d.%02d (%x)\n",
1551	ha->mpi_version[0], ha->mpi_version[1], ha->mpi_version[2],
1552	ha->mpi_capabilities);
1553	}
1554
1555	static ssize_t
1556	qla2x00_phy_version_show(struct device *dev, struct device_attribute *attr,
1557	char *buf)
1558	{
1559	scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1560	struct qla_hw_data *ha = vha->hw;
1561
1562	if (!IS_QLA81XX(ha) && !IS_QLA8031(ha))
1563	return scnprintf(buf, PAGE_SIZE, fmt: "\n");
1564
1565	return scnprintf(buf, PAGE_SIZE, fmt: "%d.%02d.%02d\n",
1566	ha->phy_version[0], ha->phy_version[1], ha->phy_version[2]);
1567	}
1568
1569	static ssize_t
1570	qla2x00_flash_block_size_show(struct device *dev,
1571	struct device_attribute *attr, char *buf)
1572	{
1573	scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1574	struct qla_hw_data *ha = vha->hw;
1575
1576	return scnprintf(buf, PAGE_SIZE, fmt: "0x%x\n", ha->fdt_block_size);
1577	}
1578
1579	static ssize_t
1580	qla2x00_vlan_id_show(struct device *dev, struct device_attribute *attr,
1581	char *buf)
1582	{
1583	scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1584
1585	if (!IS_CNA_CAPABLE(vha->hw))
1586	return scnprintf(buf, PAGE_SIZE, fmt: "\n");
1587
1588	return scnprintf(buf, PAGE_SIZE, fmt: "%d\n", vha->fcoe_vlan_id);
1589	}
1590
1591	static ssize_t
1592	qla2x00_vn_port_mac_address_show(struct device *dev,
1593	struct device_attribute *attr, char *buf)
1594	{
1595	scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1596
1597	if (!IS_CNA_CAPABLE(vha->hw))
1598	return scnprintf(buf, PAGE_SIZE, fmt: "\n");
1599
1600	return scnprintf(buf, PAGE_SIZE, fmt: "%pMR\n", vha->fcoe_vn_port_mac);
1601	}
1602
1603	static ssize_t
1604	qla2x00_fabric_param_show(struct device *dev, struct device_attribute *attr,
1605	char *buf)
1606	{
1607	scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1608
1609	return scnprintf(buf, PAGE_SIZE, fmt: "%d\n", vha->hw->switch_cap);
1610	}
1611
1612	static ssize_t
1613	qla2x00_thermal_temp_show(struct device *dev,
1614	struct device_attribute *attr, char *buf)
1615	{
1616	scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1617	uint16_t temp = 0;
1618	int rc;
1619
1620	mutex_lock(&vha->hw->optrom_mutex);
1621	if (qla2x00_chip_is_down(vha)) {
1622	mutex_unlock(lock: &vha->hw->optrom_mutex);
1623	ql_log(ql_log_warn, vha, 0x70dc, fmt: "ISP reset active.\n");
1624	goto done;
1625	}
1626
1627	if (vha->hw->flags.eeh_busy) {
1628	mutex_unlock(lock: &vha->hw->optrom_mutex);
1629	ql_log(ql_log_warn, vha, 0x70dd, fmt: "PCI EEH busy.\n");
1630	goto done;
1631	}
1632
1633	rc = qla2x00_get_thermal_temp(vha, &temp);
1634	mutex_unlock(lock: &vha->hw->optrom_mutex);
1635	if (rc == QLA_SUCCESS)
1636	return scnprintf(buf, PAGE_SIZE, fmt: "%d\n", temp);
1637
1638	done:
1639	return scnprintf(buf, PAGE_SIZE, fmt: "\n");
1640	}
1641
1642	static ssize_t
1643	qla2x00_fw_state_show(struct device *dev, struct device_attribute *attr,
1644	char *buf)
1645	{
1646	scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1647	int rval = QLA_FUNCTION_FAILED;
1648	uint16_t state[6];
1649	uint32_t pstate;
1650
1651	if (IS_QLAFX00(vha->hw)) {
1652	pstate = qlafx00_fw_state_show(dev, attr, buf);
1653	return scnprintf(buf, PAGE_SIZE, fmt: "0x%x\n", pstate);
1654	}
1655
1656	mutex_lock(&vha->hw->optrom_mutex);
1657	if (qla2x00_chip_is_down(vha)) {
1658	mutex_unlock(lock: &vha->hw->optrom_mutex);
1659	ql_log(ql_log_warn, vha, 0x707c,
1660	fmt: "ISP reset active.\n");
1661	goto out;
1662	} else if (vha->hw->flags.eeh_busy) {
1663	mutex_unlock(lock: &vha->hw->optrom_mutex);
1664	goto out;
1665	}
1666
1667	rval = qla2x00_get_firmware_state(vha, state);
1668	mutex_unlock(lock: &vha->hw->optrom_mutex);
1669	out:
1670	if (rval != QLA_SUCCESS) {
1671	memset(state, -1, sizeof(state));
1672	rval = qla2x00_get_firmware_state(vha, state);
1673	}
1674
1675	return scnprintf(buf, PAGE_SIZE, fmt: "0x%x 0x%x 0x%x 0x%x 0x%x 0x%x\n",
1676	state[0], state[1], state[2], state[3], state[4], state[5]);
1677	}
1678
1679	static ssize_t
1680	qla2x00_diag_requests_show(struct device *dev,
1681	struct device_attribute *attr, char *buf)
1682	{
1683	scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1684
1685	if (!IS_BIDI_CAPABLE(vha->hw))
1686	return scnprintf(buf, PAGE_SIZE, fmt: "\n");
1687
1688	return scnprintf(buf, PAGE_SIZE, fmt: "%llu\n", vha->bidi_stats.io_count);
1689	}
1690
1691	static ssize_t
1692	qla2x00_diag_megabytes_show(struct device *dev,
1693	struct device_attribute *attr, char *buf)
1694	{
1695	scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1696
1697	if (!IS_BIDI_CAPABLE(vha->hw))
1698	return scnprintf(buf, PAGE_SIZE, fmt: "\n");
1699
1700	return scnprintf(buf, PAGE_SIZE, fmt: "%llu\n",
1701	vha->bidi_stats.transfer_bytes >> 20);
1702	}
1703
1704	static ssize_t
1705	qla2x00_fw_dump_size_show(struct device *dev, struct device_attribute *attr,
1706	char *buf)
1707	{
1708	scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1709	struct qla_hw_data *ha = vha->hw;
1710	uint32_t size;
1711
1712	if (!ha->fw_dumped)
1713	size = 0;
1714	else if (IS_P3P_TYPE(ha))
1715	size = ha->md_template_size + ha->md_dump_size;
1716	else
1717	size = ha->fw_dump_len;
1718
1719	return scnprintf(buf, PAGE_SIZE, fmt: "%d\n", size);
1720	}
1721
1722	static ssize_t
1723	qla2x00_allow_cna_fw_dump_show(struct device *dev,
1724	struct device_attribute *attr, char *buf)
1725	{
1726	scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1727
1728	if (!IS_P3P_TYPE(vha->hw))
1729	return scnprintf(buf, PAGE_SIZE, fmt: "\n");
1730	else
1731	return scnprintf(buf, PAGE_SIZE, fmt: "%s\n",
1732	vha->hw->allow_cna_fw_dump ? "true" : "false");
1733	}
1734
1735	static ssize_t
1736	qla2x00_allow_cna_fw_dump_store(struct device *dev,
1737	struct device_attribute *attr, const char *buf, size_t count)
1738	{
1739	scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1740	int val = 0;
1741
1742	if (!IS_P3P_TYPE(vha->hw))
1743	return -EINVAL;
1744
1745	if (sscanf(buf, "%d", &val) != 1)
1746	return -EINVAL;
1747
1748	vha->hw->allow_cna_fw_dump = val != 0;
1749
1750	return strlen(buf);
1751	}
1752
1753	static ssize_t
1754	qla2x00_pep_version_show(struct device *dev, struct device_attribute *attr,
1755	char *buf)
1756	{
1757	scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1758	struct qla_hw_data *ha = vha->hw;
1759
1760	if (!IS_QLA27XX(ha) && !IS_QLA28XX(ha))
1761	return scnprintf(buf, PAGE_SIZE, fmt: "\n");
1762
1763	return scnprintf(buf, PAGE_SIZE, fmt: "%d.%02d.%02d\n",
1764	ha->pep_version[0], ha->pep_version[1], ha->pep_version[2]);
1765	}
1766
1767	static ssize_t
1768	qla2x00_min_supported_speed_show(struct device *dev,
1769	struct device_attribute *attr, char *buf)
1770	{
1771	scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1772	struct qla_hw_data *ha = vha->hw;
1773
1774	if (!IS_QLA27XX(ha) && !IS_QLA28XX(ha))
1775	return scnprintf(buf, PAGE_SIZE, fmt: "\n");
1776
1777	return scnprintf(buf, PAGE_SIZE, fmt: "%s\n",
1778	ha->min_supported_speed == 6 ? "64Gps" :
1779	ha->min_supported_speed == 5 ? "32Gps" :
1780	ha->min_supported_speed == 4 ? "16Gps" :
1781	ha->min_supported_speed == 3 ? "8Gps" :
1782	ha->min_supported_speed == 2 ? "4Gps" :
1783	ha->min_supported_speed != 0 ? "unknown" : "");
1784	}
1785
1786	static ssize_t
1787	qla2x00_max_supported_speed_show(struct device *dev,
1788	struct device_attribute *attr, char *buf)
1789	{
1790	scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1791	struct qla_hw_data *ha = vha->hw;
1792
1793	if (!IS_QLA27XX(ha) && !IS_QLA28XX(ha))
1794	return scnprintf(buf, PAGE_SIZE, fmt: "\n");
1795
1796	return scnprintf(buf, PAGE_SIZE, fmt: "%s\n",
1797	ha->max_supported_speed == 2 ? "64Gps" :
1798	ha->max_supported_speed == 1 ? "32Gps" :
1799	ha->max_supported_speed == 0 ? "16Gps" : "unknown");
1800	}
1801
1802	static ssize_t
1803	qla2x00_port_speed_store(struct device *dev, struct device_attribute *attr,
1804	const char *buf, size_t count)
1805	{
1806	struct scsi_qla_host *vha = shost_priv(shost: dev_to_shost(dev));
1807	ulong type, speed;
1808	int oldspeed, rval;
1809	int mode = QLA_SET_DATA_RATE_LR;
1810	struct qla_hw_data *ha = vha->hw;
1811
1812	if (!IS_QLA27XX(ha) && !IS_QLA28XX(ha)) {
1813	ql_log(ql_log_warn, vha, 0x70d8,
1814	fmt: "Speed setting not supported \n");
1815	return -EINVAL;
1816	}
1817
1818	rval = kstrtol(s: buf, base: 10, res: &type);
1819	if (rval)
1820	return rval;
1821	speed = type;
1822	if (type == 40 || type == 80 || type == 160 ||
1823	type == 320) {
1824	ql_dbg(ql_dbg_user, vha, 0x70d9,
1825	fmt: "Setting will be affected after a loss of sync\n");
1826	type = type/10;
1827	mode = QLA_SET_DATA_RATE_NOLR;
1828	}
1829
1830	oldspeed = ha->set_data_rate;
1831
1832	switch (type) {
1833	case 0:
1834	ha->set_data_rate = PORT_SPEED_AUTO;
1835	break;
1836	case 4:
1837	ha->set_data_rate = PORT_SPEED_4GB;
1838	break;
1839	case 8:
1840	ha->set_data_rate = PORT_SPEED_8GB;
1841	break;
1842	case 16:
1843	ha->set_data_rate = PORT_SPEED_16GB;
1844	break;
1845	case 32:
1846	ha->set_data_rate = PORT_SPEED_32GB;
1847	break;
1848	default:
1849	ql_log(ql_log_warn, vha, 0x1199,
1850	fmt: "Unrecognized speed setting:%lx. Setting Autoneg\n",
1851	speed);
1852	ha->set_data_rate = PORT_SPEED_AUTO;
1853	}
1854
1855	if (qla2x00_chip_is_down(vha) || (oldspeed == ha->set_data_rate))
1856	return -EINVAL;
1857
1858	ql_log(ql_log_info, vha, 0x70da,
1859	fmt: "Setting speed to %lx Gbps \n", type);
1860
1861	rval = qla2x00_set_data_rate(vha, mode);
1862	if (rval != QLA_SUCCESS)
1863	return -EIO;
1864
1865	return strlen(buf);
1866	}
1867
1868	static const struct {
1869	u16 rate;
1870	char *str;
1871	} port_speed_str[] = {
1872	{ PORT_SPEED_4GB, "4" },
1873	{ PORT_SPEED_8GB, "8" },
1874	{ PORT_SPEED_16GB, "16" },
1875	{ PORT_SPEED_32GB, "32" },
1876	{ PORT_SPEED_64GB, "64" },
1877	{ PORT_SPEED_10GB, "10" },
1878	};
1879
1880	static ssize_t
1881	qla2x00_port_speed_show(struct device *dev, struct device_attribute *attr,
1882	char *buf)
1883	{
1884	struct scsi_qla_host *vha = shost_priv(shost: dev_to_shost(dev));
1885	struct qla_hw_data *ha = vha->hw;
1886	ssize_t rval;
1887	u16 i;
1888	char *speed = "Unknown";
1889
1890	rval = qla2x00_get_data_rate(vha);
1891	if (rval != QLA_SUCCESS) {
1892	ql_log(ql_log_warn, vha, 0x70db,
1893	fmt: "Unable to get port speed rval:%zd\n", rval);
1894	return -EINVAL;
1895	}
1896
1897	for (i = 0; i < ARRAY_SIZE(port_speed_str); i++) {
1898	if (port_speed_str[i].rate != ha->link_data_rate)
1899	continue;
1900	speed = port_speed_str[i].str;
1901	break;
1902	}
1903
1904	return scnprintf(buf, PAGE_SIZE, fmt: "%s\n", speed);
1905	}
1906
1907	static ssize_t
1908	qla2x00_mpi_pause_store(struct device *dev,
1909	struct device_attribute *attr, const char *buf, size_t count)
1910	{
1911	scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1912	int rval = 0;
1913
1914	if (sscanf(buf, "%d", &rval) != 1)
1915	return -EINVAL;
1916
1917	ql_log(ql_log_warn, vha, 0x7089, fmt: "Pausing MPI...\n");
1918
1919	rval = qla83xx_wr_reg(vha, 0x002012d4, 0x30000001);
1920
1921	if (rval != QLA_SUCCESS) {
1922	ql_log(ql_log_warn, vha, 0x708a, fmt: "Unable to pause MPI.\n");
1923	count = 0;
1924	}
1925
1926	return count;
1927	}
1928
1929	static DEVICE_ATTR(mpi_pause, S_IWUSR, NULL, qla2x00_mpi_pause_store);
1930
1931	/* ----- */
1932
1933	static ssize_t
1934	qlini_mode_show(struct device *dev, struct device_attribute *attr, char *buf)
1935	{
1936	scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1937	int len = 0;
1938
1939	len += scnprintf(buf: buf + len, PAGE_SIZE-len,
1940	fmt: "Supported options: enabled | disabled | dual | exclusive\n");
1941
1942	/* --- */
1943	len += scnprintf(buf: buf + len, PAGE_SIZE-len, fmt: "Current selection: ");
1944
1945	switch (vha->qlini_mode) {
1946	case QLA2XXX_INI_MODE_EXCLUSIVE:
1947	len += scnprintf(buf: buf + len, PAGE_SIZE-len,
1948	QLA2XXX_INI_MODE_STR_EXCLUSIVE);
1949	break;
1950	case QLA2XXX_INI_MODE_DISABLED:
1951	len += scnprintf(buf: buf + len, PAGE_SIZE-len,
1952	QLA2XXX_INI_MODE_STR_DISABLED);
1953	break;
1954	case QLA2XXX_INI_MODE_ENABLED:
1955	len += scnprintf(buf: buf + len, PAGE_SIZE-len,
1956	QLA2XXX_INI_MODE_STR_ENABLED);
1957	break;
1958	case QLA2XXX_INI_MODE_DUAL:
1959	len += scnprintf(buf: buf + len, PAGE_SIZE-len,
1960	QLA2XXX_INI_MODE_STR_DUAL);
1961	break;
1962	}
1963	len += scnprintf(buf: buf + len, PAGE_SIZE-len, fmt: "\n");
1964
1965	return len;
1966	}
1967
1968	static char *mode_to_str[] = {
1969	"exclusive",
1970	"disabled",
1971	"enabled",
1972	"dual",
1973	};
1974
1975	#define NEED_EXCH_OFFLOAD(_exchg) ((_exchg) > FW_DEF_EXCHANGES_CNT)
1976	static void qla_set_ini_mode(scsi_qla_host_t *vha, int op)
1977	{
1978	enum {
1979	NO_ACTION,
1980	MODE_CHANGE_ACCEPT,
1981	MODE_CHANGE_NO_ACTION,
1982	TARGET_STILL_ACTIVE,
1983	};
1984	int action = NO_ACTION;
1985	int set_mode = 0;
1986	u8 eo_toggle = 0; /* exchange offload flipped */
1987
1988	switch (vha->qlini_mode) {
1989	case QLA2XXX_INI_MODE_DISABLED:
1990	switch (op) {
1991	case QLA2XXX_INI_MODE_DISABLED:
1992	if (qla_tgt_mode_enabled(ha: vha)) {
1993	if (NEED_EXCH_OFFLOAD(vha->u_ql2xexchoffld) !=
1994	vha->hw->flags.exchoffld_enabled)
1995	eo_toggle = 1;
1996	if (((vha->ql2xexchoffld !=
1997	vha->u_ql2xexchoffld) &&
1998	NEED_EXCH_OFFLOAD(vha->u_ql2xexchoffld)) ||
1999	eo_toggle) {
2000	/*
2001	* The number of exchange to be offload
2002	* was tweaked or offload option was
2003	* flipped
2004	*/
2005	action = MODE_CHANGE_ACCEPT;
2006	} else {
2007	action = MODE_CHANGE_NO_ACTION;
2008	}
2009	} else {
2010	action = MODE_CHANGE_NO_ACTION;
2011	}
2012	break;
2013	case QLA2XXX_INI_MODE_EXCLUSIVE:
2014	if (qla_tgt_mode_enabled(ha: vha)) {
2015	if (NEED_EXCH_OFFLOAD(vha->u_ql2xexchoffld) !=
2016	vha->hw->flags.exchoffld_enabled)
2017	eo_toggle = 1;
2018	if (((vha->ql2xexchoffld !=
2019	vha->u_ql2xexchoffld) &&
2020	NEED_EXCH_OFFLOAD(vha->u_ql2xexchoffld)) ||
2021	eo_toggle) {
2022	/*
2023	* The number of exchange to be offload
2024	* was tweaked or offload option was
2025	* flipped
2026	*/
2027	action = MODE_CHANGE_ACCEPT;
2028	} else {
2029	action = MODE_CHANGE_NO_ACTION;
2030	}
2031	} else {
2032	action = MODE_CHANGE_ACCEPT;
2033	}
2034	break;
2035	case QLA2XXX_INI_MODE_DUAL:
2036	action = MODE_CHANGE_ACCEPT;
2037	/* active_mode is target only, reset it to dual */
2038	if (qla_tgt_mode_enabled(ha: vha)) {
2039	set_mode = 1;
2040	action = MODE_CHANGE_ACCEPT;
2041	} else {
2042	action = MODE_CHANGE_NO_ACTION;
2043	}
2044	break;
2045
2046	case QLA2XXX_INI_MODE_ENABLED:
2047	if (qla_tgt_mode_enabled(ha: vha))
2048	action = TARGET_STILL_ACTIVE;
2049	else {
2050	action = MODE_CHANGE_ACCEPT;
2051	set_mode = 1;
2052	}
2053	break;
2054	}
2055	break;
2056
2057	case QLA2XXX_INI_MODE_EXCLUSIVE:
2058	switch (op) {
2059	case QLA2XXX_INI_MODE_EXCLUSIVE:
2060	if (qla_tgt_mode_enabled(ha: vha)) {
2061	if (NEED_EXCH_OFFLOAD(vha->u_ql2xexchoffld) !=
2062	vha->hw->flags.exchoffld_enabled)
2063	eo_toggle = 1;
2064	if (((vha->ql2xexchoffld !=
2065	vha->u_ql2xexchoffld) &&
2066	NEED_EXCH_OFFLOAD(vha->u_ql2xexchoffld)) ||
2067	eo_toggle)
2068	/*
2069	* The number of exchange to be offload
2070	* was tweaked or offload option was
2071	* flipped
2072	*/
2073	action = MODE_CHANGE_ACCEPT;
2074	else
2075	action = NO_ACTION;
2076	} else
2077	action = NO_ACTION;
2078
2079	break;
2080
2081	case QLA2XXX_INI_MODE_DISABLED:
2082	if (qla_tgt_mode_enabled(ha: vha)) {
2083	if (NEED_EXCH_OFFLOAD(vha->u_ql2xexchoffld) !=
2084	vha->hw->flags.exchoffld_enabled)
2085	eo_toggle = 1;
2086	if (((vha->ql2xexchoffld !=
2087	vha->u_ql2xexchoffld) &&
2088	NEED_EXCH_OFFLOAD(vha->u_ql2xexchoffld)) ||
2089	eo_toggle)
2090	action = MODE_CHANGE_ACCEPT;
2091	else
2092	action = MODE_CHANGE_NO_ACTION;
2093	} else
2094	action = MODE_CHANGE_NO_ACTION;
2095	break;
2096
2097	case QLA2XXX_INI_MODE_DUAL: /* exclusive -> dual */
2098	if (qla_tgt_mode_enabled(ha: vha)) {
2099	action = MODE_CHANGE_ACCEPT;
2100	set_mode = 1;
2101	} else
2102	action = MODE_CHANGE_ACCEPT;
2103	break;
2104
2105	case QLA2XXX_INI_MODE_ENABLED:
2106	if (qla_tgt_mode_enabled(ha: vha))
2107	action = TARGET_STILL_ACTIVE;
2108	else {
2109	if (vha->hw->flags.fw_started)
2110	action = MODE_CHANGE_NO_ACTION;
2111	else
2112	action = MODE_CHANGE_ACCEPT;
2113	}
2114	break;
2115	}
2116	break;
2117
2118	case QLA2XXX_INI_MODE_ENABLED:
2119	switch (op) {
2120	case QLA2XXX_INI_MODE_ENABLED:
2121	if (NEED_EXCH_OFFLOAD(vha->u_ql2xiniexchg) !=
2122	vha->hw->flags.exchoffld_enabled)
2123	eo_toggle = 1;
2124	if (((vha->ql2xiniexchg != vha->u_ql2xiniexchg) &&
2125	NEED_EXCH_OFFLOAD(vha->u_ql2xiniexchg)) ||
2126	eo_toggle)
2127	action = MODE_CHANGE_ACCEPT;
2128	else
2129	action = NO_ACTION;
2130	break;
2131	case QLA2XXX_INI_MODE_DUAL:
2132	case QLA2XXX_INI_MODE_DISABLED:
2133	action = MODE_CHANGE_ACCEPT;
2134	break;
2135	default:
2136	action = MODE_CHANGE_NO_ACTION;
2137	break;
2138	}
2139	break;
2140
2141	case QLA2XXX_INI_MODE_DUAL:
2142	switch (op) {
2143	case QLA2XXX_INI_MODE_DUAL:
2144	if (qla_tgt_mode_enabled(ha: vha) ||
2145	qla_dual_mode_enabled(ha: vha)) {
2146	if (NEED_EXCH_OFFLOAD(vha->u_ql2xexchoffld +
2147	vha->u_ql2xiniexchg) !=
2148	vha->hw->flags.exchoffld_enabled)
2149	eo_toggle = 1;
2150
2151	if ((((vha->ql2xexchoffld +
2152	vha->ql2xiniexchg) !=
2153	(vha->u_ql2xiniexchg +
2154	vha->u_ql2xexchoffld)) &&
2155	NEED_EXCH_OFFLOAD(vha->u_ql2xiniexchg +
2156	vha->u_ql2xexchoffld)) || eo_toggle)
2157	action = MODE_CHANGE_ACCEPT;
2158	else
2159	action = NO_ACTION;
2160	} else {
2161	if (NEED_EXCH_OFFLOAD(vha->u_ql2xexchoffld +
2162	vha->u_ql2xiniexchg) !=
2163	vha->hw->flags.exchoffld_enabled)
2164	eo_toggle = 1;
2165
2166	if ((((vha->ql2xexchoffld + vha->ql2xiniexchg)
2167	!= (vha->u_ql2xiniexchg +
2168	vha->u_ql2xexchoffld)) &&
2169	NEED_EXCH_OFFLOAD(vha->u_ql2xiniexchg +
2170	vha->u_ql2xexchoffld)) || eo_toggle)
2171	action = MODE_CHANGE_NO_ACTION;
2172	else
2173	action = NO_ACTION;
2174	}
2175	break;
2176
2177	case QLA2XXX_INI_MODE_DISABLED:
2178	if (qla_tgt_mode_enabled(ha: vha) ||
2179	qla_dual_mode_enabled(ha: vha)) {
2180	/* turning off initiator mode */
2181	set_mode = 1;
2182	action = MODE_CHANGE_ACCEPT;
2183	} else {
2184	action = MODE_CHANGE_NO_ACTION;
2185	}
2186	break;
2187
2188	case QLA2XXX_INI_MODE_EXCLUSIVE:
2189	if (qla_tgt_mode_enabled(ha: vha) ||
2190	qla_dual_mode_enabled(ha: vha)) {
2191	set_mode = 1;
2192	action = MODE_CHANGE_ACCEPT;
2193	} else {
2194	action = MODE_CHANGE_ACCEPT;
2195	}
2196	break;
2197
2198	case QLA2XXX_INI_MODE_ENABLED:
2199	if (qla_tgt_mode_enabled(ha: vha) ||
2200	qla_dual_mode_enabled(ha: vha)) {
2201	action = TARGET_STILL_ACTIVE;
2202	} else {
2203	action = MODE_CHANGE_ACCEPT;
2204	}
2205	}
2206	break;
2207	}
2208
2209	switch (action) {
2210	case MODE_CHANGE_ACCEPT:
2211	ql_log(ql_log_warn, vha, 0xffff,
2212	fmt: "Mode change accepted. From %s to %s, Tgt exchg %d|%d. ini exchg %d|%d\n",
2213	mode_to_str[vha->qlini_mode], mode_to_str[op],
2214	vha->ql2xexchoffld, vha->u_ql2xexchoffld,
2215	vha->ql2xiniexchg, vha->u_ql2xiniexchg);
2216
2217	vha->qlini_mode = op;
2218	vha->ql2xexchoffld = vha->u_ql2xexchoffld;
2219	vha->ql2xiniexchg = vha->u_ql2xiniexchg;
2220	if (set_mode)
2221	qlt_set_mode(vha);
2222	vha->flags.online = 1;
2223	set_bit(ISP_ABORT_NEEDED, addr: &vha->dpc_flags);
2224	break;
2225
2226	case MODE_CHANGE_NO_ACTION:
2227	ql_log(ql_log_warn, vha, 0xffff,
2228	fmt: "Mode is set. No action taken. From %s to %s, Tgt exchg %d|%d. ini exchg %d|%d\n",
2229	mode_to_str[vha->qlini_mode], mode_to_str[op],
2230	vha->ql2xexchoffld, vha->u_ql2xexchoffld,
2231	vha->ql2xiniexchg, vha->u_ql2xiniexchg);
2232	vha->qlini_mode = op;
2233	vha->ql2xexchoffld = vha->u_ql2xexchoffld;
2234	vha->ql2xiniexchg = vha->u_ql2xiniexchg;
2235	break;
2236
2237	case TARGET_STILL_ACTIVE:
2238	ql_log(ql_log_warn, vha, 0xffff,
2239	fmt: "Target Mode is active. Unable to change Mode.\n");
2240	break;
2241
2242	case NO_ACTION:
2243	default:
2244	ql_log(ql_log_warn, vha, 0xffff,
2245	fmt: "Mode unchange. No action taken. %d|%d pct %d|%d.\n",
2246	vha->qlini_mode, op,
2247	vha->ql2xexchoffld, vha->u_ql2xexchoffld);
2248	break;
2249	}
2250	}
2251
2252	static ssize_t
2253	qlini_mode_store(struct device *dev, struct device_attribute *attr,
2254	const char *buf, size_t count)
2255	{
2256	scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
2257	int ini;
2258
2259	if (!buf)
2260	return -EINVAL;
2261
2262	if (strncasecmp(QLA2XXX_INI_MODE_STR_EXCLUSIVE, s2: buf,
2263	strlen(QLA2XXX_INI_MODE_STR_EXCLUSIVE)) == 0)
2264	ini = QLA2XXX_INI_MODE_EXCLUSIVE;
2265	else if (strncasecmp(QLA2XXX_INI_MODE_STR_DISABLED, s2: buf,
2266	strlen(QLA2XXX_INI_MODE_STR_DISABLED)) == 0)
2267	ini = QLA2XXX_INI_MODE_DISABLED;
2268	else if (strncasecmp(QLA2XXX_INI_MODE_STR_ENABLED, s2: buf,
2269	strlen(QLA2XXX_INI_MODE_STR_ENABLED)) == 0)
2270	ini = QLA2XXX_INI_MODE_ENABLED;
2271	else if (strncasecmp(QLA2XXX_INI_MODE_STR_DUAL, s2: buf,
2272	strlen(QLA2XXX_INI_MODE_STR_DUAL)) == 0)
2273	ini = QLA2XXX_INI_MODE_DUAL;
2274	else
2275	return -EINVAL;
2276
2277	qla_set_ini_mode(vha, op: ini);
2278	return strlen(buf);
2279	}
2280
2281	static ssize_t
2282	ql2xexchoffld_show(struct device *dev, struct device_attribute *attr,
2283	char *buf)
2284	{
2285	scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
2286	int len = 0;
2287
2288	len += scnprintf(buf: buf + len, PAGE_SIZE-len,
2289	fmt: "target exchange: new %d : current: %d\n\n",
2290	vha->u_ql2xexchoffld, vha->ql2xexchoffld);
2291
2292	len += scnprintf(buf: buf + len, PAGE_SIZE-len,
2293	fmt: "Please (re)set operating mode via \"/sys/class/scsi_host/host%ld/qlini_mode\" to load new setting.\n",
2294	vha->host_no);
2295
2296	return len;
2297	}
2298
2299	static ssize_t
2300	ql2xexchoffld_store(struct device *dev, struct device_attribute *attr,
2301	const char *buf, size_t count)
2302	{
2303	scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
2304	int val = 0;
2305
2306	if (sscanf(buf, "%d", &val) != 1)
2307	return -EINVAL;
2308
2309	if (val > FW_MAX_EXCHANGES_CNT)
2310	val = FW_MAX_EXCHANGES_CNT;
2311	else if (val < 0)
2312	val = 0;
2313
2314	vha->u_ql2xexchoffld = val;
2315	return strlen(buf);
2316	}
2317
2318	static ssize_t
2319	ql2xiniexchg_show(struct device *dev, struct device_attribute *attr,
2320	char *buf)
2321	{
2322	scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
2323	int len = 0;
2324
2325	len += scnprintf(buf: buf + len, PAGE_SIZE-len,
2326	fmt: "target exchange: new %d : current: %d\n\n",
2327	vha->u_ql2xiniexchg, vha->ql2xiniexchg);
2328
2329	len += scnprintf(buf: buf + len, PAGE_SIZE-len,
2330	fmt: "Please (re)set operating mode via \"/sys/class/scsi_host/host%ld/qlini_mode\" to load new setting.\n",
2331	vha->host_no);
2332
2333	return len;
2334	}
2335
2336	static ssize_t
2337	ql2xiniexchg_store(struct device *dev, struct device_attribute *attr,
2338	const char *buf, size_t count)
2339	{
2340	scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
2341	int val = 0;
2342
2343	if (sscanf(buf, "%d", &val) != 1)
2344	return -EINVAL;
2345
2346	if (val > FW_MAX_EXCHANGES_CNT)
2347	val = FW_MAX_EXCHANGES_CNT;
2348	else if (val < 0)
2349	val = 0;
2350
2351	vha->u_ql2xiniexchg = val;
2352	return strlen(buf);
2353	}
2354
2355	static ssize_t
2356	qla2x00_dif_bundle_statistics_show(struct device *dev,
2357	struct device_attribute *attr, char *buf)
2358	{
2359	scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
2360	struct qla_hw_data *ha = vha->hw;
2361
2362	return scnprintf(buf, PAGE_SIZE,
2363	fmt: "cross=%llu read=%llu write=%llu kalloc=%llu dma_alloc=%llu unusable=%u\n",
2364	ha->dif_bundle_crossed_pages, ha->dif_bundle_reads,
2365	ha->dif_bundle_writes, ha->dif_bundle_kallocs,
2366	ha->dif_bundle_dma_allocs, ha->pool.unusable.count);
2367	}
2368
2369	static ssize_t
2370	qla2x00_fw_attr_show(struct device *dev,
2371	struct device_attribute *attr, char *buf)
2372	{
2373	scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
2374	struct qla_hw_data *ha = vha->hw;
2375
2376	if (!IS_QLA27XX(ha) && !IS_QLA28XX(ha))
2377	return scnprintf(buf, PAGE_SIZE, fmt: "\n");
2378
2379	return scnprintf(buf, PAGE_SIZE, fmt: "%llx\n",
2380	(uint64_t)ha->fw_attributes_ext[1] << 48 |
2381	(uint64_t)ha->fw_attributes_ext[0] << 32 |
2382	(uint64_t)ha->fw_attributes_h << 16 |
2383	(uint64_t)ha->fw_attributes);
2384	}
2385
2386	static ssize_t
2387	qla2x00_port_no_show(struct device *dev, struct device_attribute *attr,
2388	char *buf)
2389	{
2390	scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
2391
2392	return scnprintf(buf, PAGE_SIZE, fmt: "%u\n", vha->hw->port_no);
2393	}
2394
2395	static ssize_t
2396	qla2x00_dport_diagnostics_show(struct device *dev,
2397	struct device_attribute *attr, char *buf)
2398	{
2399	scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
2400
2401	if (!IS_QLA83XX(vha->hw) && !IS_QLA27XX(vha->hw) &&
2402	!IS_QLA28XX(vha->hw))
2403	return scnprintf(buf, PAGE_SIZE, fmt: "\n");
2404
2405	if (!*vha->dport_data)
2406	return scnprintf(buf, PAGE_SIZE, fmt: "\n");
2407
2408	return scnprintf(buf, PAGE_SIZE, fmt: "%04x %04x %04x %04x\n",
2409	vha->dport_data[0], vha->dport_data[1],
2410	vha->dport_data[2], vha->dport_data[3]);
2411	}
2412	static DEVICE_ATTR(dport_diagnostics, 0444,
2413	qla2x00_dport_diagnostics_show, NULL);
2414
2415	static DEVICE_ATTR(driver_version, S_IRUGO, qla2x00_driver_version_show, NULL);
2416	static DEVICE_ATTR(fw_version, S_IRUGO, qla2x00_fw_version_show, NULL);
2417	static DEVICE_ATTR(serial_num, S_IRUGO, qla2x00_serial_num_show, NULL);
2418	static DEVICE_ATTR(isp_name, S_IRUGO, qla2x00_isp_name_show, NULL);
2419	static DEVICE_ATTR(isp_id, S_IRUGO, qla2x00_isp_id_show, NULL);
2420	static DEVICE_ATTR(model_name, S_IRUGO, qla2x00_model_name_show, NULL);
2421	static DEVICE_ATTR(model_desc, S_IRUGO, qla2x00_model_desc_show, NULL);
2422	static DEVICE_ATTR(pci_info, S_IRUGO, qla2x00_pci_info_show, NULL);
2423	static DEVICE_ATTR(link_state, S_IRUGO, qla2x00_link_state_show, NULL);
2424	static DEVICE_ATTR(zio, S_IRUGO | S_IWUSR, qla2x00_zio_show, qla2x00_zio_store);
2425	static DEVICE_ATTR(zio_timer, S_IRUGO | S_IWUSR, qla2x00_zio_timer_show,
2426	qla2x00_zio_timer_store);
2427	static DEVICE_ATTR(beacon, S_IRUGO | S_IWUSR, qla2x00_beacon_show,
2428	qla2x00_beacon_store);
2429	static DEVICE_ATTR(beacon_config, 0644, qla2x00_beacon_config_show,
2430	qla2x00_beacon_config_store);
2431	static DEVICE_ATTR(optrom_bios_version, S_IRUGO,
2432	qla2x00_optrom_bios_version_show, NULL);
2433	static DEVICE_ATTR(optrom_efi_version, S_IRUGO,
2434	qla2x00_optrom_efi_version_show, NULL);
2435	static DEVICE_ATTR(optrom_fcode_version, S_IRUGO,
2436	qla2x00_optrom_fcode_version_show, NULL);
2437	static DEVICE_ATTR(optrom_fw_version, S_IRUGO, qla2x00_optrom_fw_version_show,
2438	NULL);
2439	static DEVICE_ATTR(optrom_gold_fw_version, S_IRUGO,
2440	qla2x00_optrom_gold_fw_version_show, NULL);
2441	static DEVICE_ATTR(84xx_fw_version, S_IRUGO, qla24xx_84xx_fw_version_show,
2442	NULL);
2443	static DEVICE_ATTR(total_isp_aborts, S_IRUGO, qla2x00_total_isp_aborts_show,
2444	NULL);
2445	static DEVICE_ATTR(serdes_version, 0444, qla2x00_serdes_version_show, NULL);
2446	static DEVICE_ATTR(mpi_version, S_IRUGO, qla2x00_mpi_version_show, NULL);
2447	static DEVICE_ATTR(phy_version, S_IRUGO, qla2x00_phy_version_show, NULL);
2448	static DEVICE_ATTR(flash_block_size, S_IRUGO, qla2x00_flash_block_size_show,
2449	NULL);
2450	static DEVICE_ATTR(vlan_id, S_IRUGO, qla2x00_vlan_id_show, NULL);
2451	static DEVICE_ATTR(vn_port_mac_address, S_IRUGO,
2452	qla2x00_vn_port_mac_address_show, NULL);
2453	static DEVICE_ATTR(fabric_param, S_IRUGO, qla2x00_fabric_param_show, NULL);
2454	static DEVICE_ATTR(fw_state, S_IRUGO, qla2x00_fw_state_show, NULL);
2455	static DEVICE_ATTR(thermal_temp, S_IRUGO, qla2x00_thermal_temp_show, NULL);
2456	static DEVICE_ATTR(diag_requests, S_IRUGO, qla2x00_diag_requests_show, NULL);
2457	static DEVICE_ATTR(diag_megabytes, S_IRUGO, qla2x00_diag_megabytes_show, NULL);
2458	static DEVICE_ATTR(fw_dump_size, S_IRUGO, qla2x00_fw_dump_size_show, NULL);
2459	static DEVICE_ATTR(allow_cna_fw_dump, S_IRUGO | S_IWUSR,
2460	qla2x00_allow_cna_fw_dump_show,
2461	qla2x00_allow_cna_fw_dump_store);
2462	static DEVICE_ATTR(pep_version, S_IRUGO, qla2x00_pep_version_show, NULL);
2463	static DEVICE_ATTR(min_supported_speed, 0444,
2464	qla2x00_min_supported_speed_show, NULL);
2465	static DEVICE_ATTR(max_supported_speed, 0444,
2466	qla2x00_max_supported_speed_show, NULL);
2467	static DEVICE_ATTR(zio_threshold, 0644,
2468	qla_zio_threshold_show,
2469	qla_zio_threshold_store);
2470	static DEVICE_ATTR_RW(qlini_mode);
2471	static DEVICE_ATTR_RW(ql2xexchoffld);
2472	static DEVICE_ATTR_RW(ql2xiniexchg);
2473	static DEVICE_ATTR(dif_bundle_statistics, 0444,
2474	qla2x00_dif_bundle_statistics_show, NULL);
2475	static DEVICE_ATTR(port_speed, 0644, qla2x00_port_speed_show,
2476	qla2x00_port_speed_store);
2477	static DEVICE_ATTR(port_no, 0444, qla2x00_port_no_show, NULL);
2478	static DEVICE_ATTR(fw_attr, 0444, qla2x00_fw_attr_show, NULL);
2479
2480	static struct attribute *qla2x00_host_attrs[] = {
2481	&dev_attr_driver_version.attr,
2482	&dev_attr_fw_version.attr,
2483	&dev_attr_serial_num.attr,
2484	&dev_attr_isp_name.attr,
2485	&dev_attr_isp_id.attr,
2486	&dev_attr_model_name.attr,
2487	&dev_attr_model_desc.attr,
2488	&dev_attr_pci_info.attr,
2489	&dev_attr_link_state.attr,
2490	&dev_attr_zio.attr,
2491	&dev_attr_zio_timer.attr,
2492	&dev_attr_beacon.attr,
2493	&dev_attr_beacon_config.attr,
2494	&dev_attr_optrom_bios_version.attr,
2495	&dev_attr_optrom_efi_version.attr,
2496	&dev_attr_optrom_fcode_version.attr,
2497	&dev_attr_optrom_fw_version.attr,
2498	&dev_attr_84xx_fw_version.attr,
2499	&dev_attr_total_isp_aborts.attr,
2500	&dev_attr_serdes_version.attr,
2501	&dev_attr_mpi_version.attr,
2502	&dev_attr_phy_version.attr,
2503	&dev_attr_flash_block_size.attr,
2504	&dev_attr_vlan_id.attr,
2505	&dev_attr_vn_port_mac_address.attr,
2506	&dev_attr_fabric_param.attr,
2507	&dev_attr_fw_state.attr,
2508	&dev_attr_optrom_gold_fw_version.attr,
2509	&dev_attr_thermal_temp.attr,
2510	&dev_attr_diag_requests.attr,
2511	&dev_attr_diag_megabytes.attr,
2512	&dev_attr_fw_dump_size.attr,
2513	&dev_attr_allow_cna_fw_dump.attr,
2514	&dev_attr_pep_version.attr,
2515	&dev_attr_min_supported_speed.attr,
2516	&dev_attr_max_supported_speed.attr,
2517	&dev_attr_zio_threshold.attr,
2518	&dev_attr_dif_bundle_statistics.attr,
2519	&dev_attr_port_speed.attr,
2520	&dev_attr_port_no.attr,
2521	&dev_attr_fw_attr.attr,
2522	&dev_attr_dport_diagnostics.attr,
2523	&dev_attr_mpi_pause.attr,
2524	&dev_attr_qlini_mode.attr,
2525	&dev_attr_ql2xiniexchg.attr,
2526	&dev_attr_ql2xexchoffld.attr,
2527	NULL,
2528	};
2529
2530	static umode_t qla_host_attr_is_visible(struct kobject *kobj,
2531	struct attribute *attr, int i)
2532	{
2533	if (ql2x_ini_mode != QLA2XXX_INI_MODE_DUAL &&
2534	(attr == &dev_attr_qlini_mode.attr ||
2535	attr == &dev_attr_ql2xiniexchg.attr ||
2536	attr == &dev_attr_ql2xexchoffld.attr))
2537	return 0;
2538	return attr->mode;
2539	}
2540
2541	static const struct attribute_group qla2x00_host_attr_group = {
2542	.is_visible = qla_host_attr_is_visible,
2543	.attrs = qla2x00_host_attrs
2544	};
2545
2546	const struct attribute_group *qla2x00_host_groups[] = {
2547	&qla2x00_host_attr_group,
2548	NULL
2549	};
2550
2551	/* Host attributes. */
2552
2553	static void
2554	qla2x00_get_host_port_id(struct Scsi_Host *shost)
2555	{
2556	scsi_qla_host_t *vha = shost_priv(shost);
2557
2558	fc_host_port_id(shost) = vha->d_id.b.domain << 16 |
2559	vha->d_id.b.area << 8 | vha->d_id.b.al_pa;
2560	}
2561
2562	static void
2563	qla2x00_get_host_speed(struct Scsi_Host *shost)
2564	{
2565	scsi_qla_host_t *vha = shost_priv(shost);
2566	u32 speed;
2567
2568	if (IS_QLAFX00(vha->hw)) {
2569	qlafx00_get_host_speed(shost);
2570	return;
2571	}
2572
2573	switch (vha->hw->link_data_rate) {
2574	case PORT_SPEED_1GB:
2575	speed = FC_PORTSPEED_1GBIT;
2576	break;
2577	case PORT_SPEED_2GB:
2578	speed = FC_PORTSPEED_2GBIT;
2579	break;
2580	case PORT_SPEED_4GB:
2581	speed = FC_PORTSPEED_4GBIT;
2582	break;
2583	case PORT_SPEED_8GB:
2584	speed = FC_PORTSPEED_8GBIT;
2585	break;
2586	case PORT_SPEED_10GB:
2587	speed = FC_PORTSPEED_10GBIT;
2588	break;
2589	case PORT_SPEED_16GB:
2590	speed = FC_PORTSPEED_16GBIT;
2591	break;
2592	case PORT_SPEED_32GB:
2593	speed = FC_PORTSPEED_32GBIT;
2594	break;
2595	case PORT_SPEED_64GB:
2596	speed = FC_PORTSPEED_64GBIT;
2597	break;
2598	default:
2599	speed = FC_PORTSPEED_UNKNOWN;
2600	break;
2601	}
2602
2603	fc_host_speed(shost) = speed;
2604	}
2605
2606	static void
2607	qla2x00_get_host_port_type(struct Scsi_Host *shost)
2608	{
2609	scsi_qla_host_t *vha = shost_priv(shost);
2610	uint32_t port_type;
2611
2612	if (vha->vp_idx) {
2613	fc_host_port_type(shost) = FC_PORTTYPE_NPIV;
2614	return;
2615	}
2616	switch (vha->hw->current_topology) {
2617	case ISP_CFG_NL:
2618	port_type = FC_PORTTYPE_LPORT;
2619	break;
2620	case ISP_CFG_FL:
2621	port_type = FC_PORTTYPE_NLPORT;
2622	break;
2623	case ISP_CFG_N:
2624	port_type = FC_PORTTYPE_PTP;
2625	break;
2626	case ISP_CFG_F:
2627	port_type = FC_PORTTYPE_NPORT;
2628	break;
2629	default:
2630	port_type = FC_PORTTYPE_UNKNOWN;
2631	break;
2632	}
2633
2634	fc_host_port_type(shost) = port_type;
2635	}
2636
2637	static void
2638	qla2x00_get_starget_node_name(struct scsi_target *starget)
2639	{
2640	struct Scsi_Host *host = dev_to_shost(dev: starget->dev.parent);
2641	scsi_qla_host_t *vha = shost_priv(shost: host);
2642	fc_port_t *fcport;
2643	u64 node_name = 0;
2644
2645	list_for_each_entry(fcport, &vha->vp_fcports, list) {
2646	if (fcport->rport &&
2647	starget->id == fcport->rport->scsi_target_id) {
2648	node_name = wwn_to_u64(wwn: fcport->node_name);
2649	break;
2650	}
2651	}
2652
2653	fc_starget_node_name(starget) = node_name;
2654	}
2655
2656	static void
2657	qla2x00_get_starget_port_name(struct scsi_target *starget)
2658	{
2659	struct Scsi_Host *host = dev_to_shost(dev: starget->dev.parent);
2660	scsi_qla_host_t *vha = shost_priv(shost: host);
2661	fc_port_t *fcport;
2662	u64 port_name = 0;
2663
2664	list_for_each_entry(fcport, &vha->vp_fcports, list) {
2665	if (fcport->rport &&
2666	starget->id == fcport->rport->scsi_target_id) {
2667	port_name = wwn_to_u64(wwn: fcport->port_name);
2668	break;
2669	}
2670	}
2671
2672	fc_starget_port_name(starget) = port_name;
2673	}
2674
2675	static void
2676	qla2x00_get_starget_port_id(struct scsi_target *starget)
2677	{
2678	struct Scsi_Host *host = dev_to_shost(dev: starget->dev.parent);
2679	scsi_qla_host_t *vha = shost_priv(shost: host);
2680	fc_port_t *fcport;
2681	uint32_t port_id = ~0U;
2682
2683	list_for_each_entry(fcport, &vha->vp_fcports, list) {
2684	if (fcport->rport &&
2685	starget->id == fcport->rport->scsi_target_id) {
2686	port_id = fcport->d_id.b.domain << 16 |
2687	fcport->d_id.b.area << 8 | fcport->d_id.b.al_pa;
2688	break;
2689	}
2690	}
2691
2692	fc_starget_port_id(starget) = port_id;
2693	}
2694
2695	static inline void
2696	qla2x00_set_rport_loss_tmo(struct fc_rport *rport, uint32_t timeout)
2697	{
2698	fc_port_t *fcport = *(fc_port_t **)rport->dd_data;
2699
2700	rport->dev_loss_tmo = timeout ? timeout : 1;
2701
2702	if (IS_ENABLED(CONFIG_NVME_FC) && fcport && fcport->nvme_remote_port)
2703	nvme_fc_set_remoteport_devloss(remoteport: fcport->nvme_remote_port,
2704	dev_loss_tmo: rport->dev_loss_tmo);
2705	}
2706
2707	static void
2708	qla2x00_dev_loss_tmo_callbk(struct fc_rport *rport)
2709	{
2710	struct Scsi_Host *host = rport_to_shost(rport);
2711	fc_port_t *fcport = *(fc_port_t **)rport->dd_data;
2712	unsigned long flags;
2713
2714	if (!fcport)
2715	return;
2716
2717	ql_dbg(ql_dbg_async, vha: fcport->vha, 0x5101,
2718	DBG_FCPORT_PRFMT(fcport, "dev_loss_tmo expiry, rport_state=%d",
2719	rport->port_state));
2720
2721	/*
2722	* Now that the rport has been deleted, set the fcport state to
2723	* FCS_DEVICE_DEAD, if the fcport is still lost.
2724	*/
2725	if (fcport->scan_state != QLA_FCPORT_FOUND)
2726	qla2x00_set_fcport_state(fcport, state: FCS_DEVICE_DEAD);
2727
2728	/*
2729	* Transport has effectively 'deleted' the rport, clear
2730	* all local references.
2731	*/
2732	spin_lock_irqsave(host->host_lock, flags);
2733	/* Confirm port has not reappeared before clearing pointers. */
2734	if (rport->port_state != FC_PORTSTATE_ONLINE) {
2735	fcport->rport = NULL;
2736	*((fc_port_t **)rport->dd_data) = NULL;
2737	}
2738	spin_unlock_irqrestore(lock: host->host_lock, flags);
2739
2740	if (test_bit(ABORT_ISP_ACTIVE, &fcport->vha->dpc_flags))
2741	return;
2742
2743	if (unlikely(pci_channel_offline(fcport->vha->hw->pdev))) {
2744	qla2x00_abort_all_cmds(fcport->vha, DID_NO_CONNECT << 16);
2745	return;
2746	}
2747	}
2748
2749	static void
2750	qla2x00_terminate_rport_io(struct fc_rport *rport)
2751	{
2752	fc_port_t *fcport = *(fc_port_t **)rport->dd_data;
2753	scsi_qla_host_t *vha;
2754
2755	if (!fcport)
2756	return;
2757
2758	if (test_bit(UNLOADING, &fcport->vha->dpc_flags))
2759	return;
2760
2761	if (test_bit(ABORT_ISP_ACTIVE, &fcport->vha->dpc_flags))
2762	return;
2763	vha = fcport->vha;
2764
2765	if (unlikely(pci_channel_offline(fcport->vha->hw->pdev))) {
2766	qla2x00_abort_all_cmds(fcport->vha, DID_NO_CONNECT << 16);
2767	qla2x00_eh_wait_for_pending_commands(fcport->vha, fcport->d_id.b24,
2768	0, WAIT_TARGET);
2769	return;
2770	}
2771	/*
2772	* At this point all fcport's software-states are cleared. Perform any
2773	* final cleanup of firmware resources (PCBs and XCBs).
2774	*
2775	* Attempt to cleanup only lost devices.
2776	*/
2777	if (fcport->loop_id != FC_NO_LOOP_ID) {
2778	if (IS_FWI2_CAPABLE(fcport->vha->hw) &&
2779	fcport->scan_state != QLA_FCPORT_FOUND) {
2780	if (fcport->loop_id != FC_NO_LOOP_ID)
2781	fcport->logout_on_delete = 1;
2782
2783	if (!EDIF_NEGOTIATION_PENDING(fcport)) {
2784	ql_dbg(ql_dbg_disc, vha: fcport->vha, 0x911e,
2785	fmt: "%s %d schedule session deletion\n", __func__,
2786	__LINE__);
2787	qlt_schedule_sess_for_deletion(fcport);
2788	}
2789	} else if (!IS_FWI2_CAPABLE(fcport->vha->hw)) {
2790	qla2x00_port_logout(fcport->vha, fcport);
2791	}
2792	}
2793
2794	/* check for any straggling io left behind */
2795	if (qla2x00_eh_wait_for_pending_commands(fcport->vha, fcport->d_id.b24, 0, WAIT_TARGET)) {
2796	ql_log(ql_log_warn, vha, 0x300b,
2797	fmt: "IO not return. Resetting. \n");
2798	set_bit(ISP_ABORT_NEEDED, addr: &vha->dpc_flags);
2799	qla2xxx_wake_dpc(vha);
2800	qla2x00_wait_for_chip_reset(vha);
2801	}
2802	}
2803
2804	static int
2805	qla2x00_issue_lip(struct Scsi_Host *shost)
2806	{
2807	scsi_qla_host_t *vha = shost_priv(shost);
2808
2809	if (IS_QLAFX00(vha->hw))
2810	return 0;
2811
2812	if (vha->hw->flags.port_isolated)
2813	return 0;
2814
2815	qla2x00_loop_reset(vha);
2816	return 0;
2817	}
2818
2819	static struct fc_host_statistics *
2820	qla2x00_get_fc_host_stats(struct Scsi_Host *shost)
2821	{
2822	scsi_qla_host_t *vha = shost_priv(shost);
2823	struct qla_hw_data *ha = vha->hw;
2824	struct scsi_qla_host *base_vha = pci_get_drvdata(pdev: ha->pdev);
2825	int rval;
2826	struct link_statistics *stats;
2827	dma_addr_t stats_dma;
2828	struct fc_host_statistics *p = &vha->fc_host_stat;
2829	struct qla_qpair *qpair;
2830	int i;
2831	u64 ib = 0, ob = 0, ir = 0, or = 0;
2832
2833	memset(p, -1, sizeof(*p));
2834
2835	if (IS_QLAFX00(vha->hw))
2836	goto done;
2837
2838	if (test_bit(UNLOADING, &vha->dpc_flags))
2839	goto done;
2840
2841	if (unlikely(pci_channel_offline(ha->pdev)))
2842	goto done;
2843
2844	if (qla2x00_chip_is_down(vha))
2845	goto done;
2846
2847	stats = dma_alloc_coherent(dev: &ha->pdev->dev, size: sizeof(*stats), dma_handle: &stats_dma,
2848	GFP_KERNEL);
2849	if (!stats) {
2850	ql_log(ql_log_warn, vha, 0x707d,
2851	fmt: "Failed to allocate memory for stats.\n");
2852	goto done;
2853	}
2854
2855	rval = QLA_FUNCTION_FAILED;
2856	if (IS_FWI2_CAPABLE(ha)) {
2857	rval = qla24xx_get_isp_stats(base_vha, stats, stats_dma, 0);
2858	} else if (atomic_read(v: &base_vha->loop_state) == LOOP_READY &&
2859	!ha->dpc_active) {
2860	/* Must be in a 'READY' state for statistics retrieval. */
2861	rval = qla2x00_get_link_status(base_vha, base_vha->loop_id,
2862	stats, stats_dma);
2863	}
2864
2865	if (rval != QLA_SUCCESS)
2866	goto done_free;
2867
2868	/* --- */
2869	for (i = 0; i < vha->hw->max_qpairs; i++) {
2870	qpair = vha->hw->queue_pair_map[i];
2871	if (!qpair)
2872	continue;
2873	ir += qpair->counters.input_requests;
2874	or += qpair->counters.output_requests;
2875	ib += qpair->counters.input_bytes;
2876	ob += qpair->counters.output_bytes;
2877	}
2878	ir += ha->base_qpair->counters.input_requests;
2879	or += ha->base_qpair->counters.output_requests;
2880	ib += ha->base_qpair->counters.input_bytes;
2881	ob += ha->base_qpair->counters.output_bytes;
2882
2883	ir += vha->qla_stats.input_requests;
2884	or += vha->qla_stats.output_requests;
2885	ib += vha->qla_stats.input_bytes;
2886	ob += vha->qla_stats.output_bytes;
2887	/* --- */
2888
2889	p->link_failure_count = le32_to_cpu(stats->link_fail_cnt);
2890	p->loss_of_sync_count = le32_to_cpu(stats->loss_sync_cnt);
2891	p->loss_of_signal_count = le32_to_cpu(stats->loss_sig_cnt);
2892	p->prim_seq_protocol_err_count = le32_to_cpu(stats->prim_seq_err_cnt);
2893	p->invalid_tx_word_count = le32_to_cpu(stats->inval_xmit_word_cnt);
2894	p->invalid_crc_count = le32_to_cpu(stats->inval_crc_cnt);
2895	if (IS_FWI2_CAPABLE(ha)) {
2896	p->lip_count = le32_to_cpu(stats->lip_cnt);
2897	p->tx_frames = le32_to_cpu(stats->tx_frames);
2898	p->rx_frames = le32_to_cpu(stats->rx_frames);
2899	p->dumped_frames = le32_to_cpu(stats->discarded_frames);
2900	p->nos_count = le32_to_cpu(stats->nos_rcvd);
2901	p->error_frames =
2902	le32_to_cpu(stats->dropped_frames) +
2903	le32_to_cpu(stats->discarded_frames);
2904	if (IS_QLA83XX(ha) || IS_QLA27XX(ha) || IS_QLA28XX(ha)) {
2905	p->rx_words = le64_to_cpu(stats->fpm_recv_word_cnt);
2906	p->tx_words = le64_to_cpu(stats->fpm_xmit_word_cnt);
2907	} else {
2908	p->rx_words = ib >> 2;
2909	p->tx_words = ob >> 2;
2910	}
2911	}
2912
2913	p->fcp_control_requests = vha->qla_stats.control_requests;
2914	p->fcp_input_requests = ir;
2915	p->fcp_output_requests = or;
2916	p->fcp_input_megabytes = ib >> 20;
2917	p->fcp_output_megabytes = ob >> 20;
2918	p->seconds_since_last_reset =
2919	get_jiffies_64() - vha->qla_stats.jiffies_at_last_reset;
2920	do_div(p->seconds_since_last_reset, HZ);
2921
2922	done_free:
2923	dma_free_coherent(dev: &ha->pdev->dev, size: sizeof(struct link_statistics),
2924	cpu_addr: stats, dma_handle: stats_dma);
2925	done:
2926	return p;
2927	}
2928
2929	static void
2930	qla2x00_reset_host_stats(struct Scsi_Host *shost)
2931	{
2932	scsi_qla_host_t *vha = shost_priv(shost);
2933	struct qla_hw_data *ha = vha->hw;
2934	struct scsi_qla_host *base_vha = pci_get_drvdata(pdev: ha->pdev);
2935	struct link_statistics *stats;
2936	dma_addr_t stats_dma;
2937	int i;
2938	struct qla_qpair *qpair;
2939
2940	memset(&vha->qla_stats, 0, sizeof(vha->qla_stats));
2941	memset(&vha->fc_host_stat, 0, sizeof(vha->fc_host_stat));
2942	for (i = 0; i < vha->hw->max_qpairs; i++) {
2943	qpair = vha->hw->queue_pair_map[i];
2944	if (!qpair)
2945	continue;
2946	memset(&qpair->counters, 0, sizeof(qpair->counters));
2947	}
2948	memset(&ha->base_qpair->counters, 0, sizeof(qpair->counters));
2949
2950	vha->qla_stats.jiffies_at_last_reset = get_jiffies_64();
2951
2952	if (IS_FWI2_CAPABLE(ha)) {
2953	int rval;
2954
2955	stats = dma_alloc_coherent(dev: &ha->pdev->dev,
2956	size: sizeof(*stats), dma_handle: &stats_dma, GFP_KERNEL);
2957	if (!stats) {
2958	ql_log(ql_log_warn, vha, 0x70d7,
2959	fmt: "Failed to allocate memory for stats.\n");
2960	return;
2961	}
2962
2963	/* reset firmware statistics */
2964	rval = qla24xx_get_isp_stats(base_vha, stats, stats_dma, BIT_0);
2965	if (rval != QLA_SUCCESS)
2966	ql_log(ql_log_warn, vha, 0x70de,
2967	fmt: "Resetting ISP statistics failed: rval = %d\n",
2968	rval);
2969
2970	dma_free_coherent(dev: &ha->pdev->dev, size: sizeof(*stats),
2971	cpu_addr: stats, dma_handle: stats_dma);
2972	}
2973	}
2974
2975	static void
2976	qla2x00_get_host_symbolic_name(struct Scsi_Host *shost)
2977	{
2978	scsi_qla_host_t *vha = shost_priv(shost);
2979
2980	qla2x00_get_sym_node_name(vha, fc_host_symbolic_name(shost),
2981	sizeof(fc_host_symbolic_name(shost)));
2982	}
2983
2984	static void
2985	qla2x00_set_host_system_hostname(struct Scsi_Host *shost)
2986	{
2987	scsi_qla_host_t *vha = shost_priv(shost);
2988
2989	set_bit(REGISTER_FDMI_NEEDED, addr: &vha->dpc_flags);
2990	}
2991
2992	static void
2993	qla2x00_get_host_fabric_name(struct Scsi_Host *shost)
2994	{
2995	scsi_qla_host_t *vha = shost_priv(shost);
2996	static const uint8_t node_name[WWN_SIZE] = {
2997	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
2998	};
2999	u64 fabric_name = wwn_to_u64(wwn: node_name);
3000
3001	if (vha->device_flags & SWITCH_FOUND)
3002	fabric_name = wwn_to_u64(wwn: vha->fabric_node_name);
3003
3004	fc_host_fabric_name(shost) = fabric_name;
3005	}
3006
3007	static void
3008	qla2x00_get_host_port_state(struct Scsi_Host *shost)
3009	{
3010	scsi_qla_host_t *vha = shost_priv(shost);
3011	struct scsi_qla_host *base_vha = pci_get_drvdata(pdev: vha->hw->pdev);
3012
3013	if (!base_vha->flags.online) {
3014	fc_host_port_state(shost) = FC_PORTSTATE_OFFLINE;
3015	return;
3016	}
3017
3018	switch (atomic_read(v: &base_vha->loop_state)) {
3019	case LOOP_UPDATE:
3020	fc_host_port_state(shost) = FC_PORTSTATE_DIAGNOSTICS;
3021	break;
3022	case LOOP_DOWN:
3023	if (test_bit(LOOP_RESYNC_NEEDED, &base_vha->dpc_flags))
3024	fc_host_port_state(shost) = FC_PORTSTATE_DIAGNOSTICS;
3025	else
3026	fc_host_port_state(shost) = FC_PORTSTATE_LINKDOWN;
3027	break;
3028	case LOOP_DEAD:
3029	fc_host_port_state(shost) = FC_PORTSTATE_LINKDOWN;
3030	break;
3031	case LOOP_READY:
3032	fc_host_port_state(shost) = FC_PORTSTATE_ONLINE;
3033	break;
3034	default:
3035	fc_host_port_state(shost) = FC_PORTSTATE_UNKNOWN;
3036	break;
3037	}
3038	}
3039
3040	static int
3041	qla24xx_vport_create(struct fc_vport *fc_vport, bool disable)
3042	{
3043	int ret = 0;
3044	uint8_t qos = 0;
3045	scsi_qla_host_t *base_vha = shost_priv(shost: fc_vport->shost);
3046	scsi_qla_host_t *vha = NULL;
3047	struct qla_hw_data *ha = base_vha->hw;
3048	int cnt;
3049	struct req_que *req = ha->req_q_map[0];
3050	struct qla_qpair *qpair;
3051
3052	ret = qla24xx_vport_create_req_sanity_check(fc_vport);
3053	if (ret) {
3054	ql_log(ql_log_warn, vha, 0x707e,
3055	fmt: "Vport sanity check failed, status %x\n", ret);
3056	return (ret);
3057	}
3058
3059	vha = qla24xx_create_vhost(fc_vport);
3060	if (vha == NULL) {
3061	ql_log(ql_log_warn, vha, 0x707f, fmt: "Vport create host failed.\n");
3062	return FC_VPORT_FAILED;
3063	}
3064	if (disable) {
3065	atomic_set(v: &vha->vp_state, VP_OFFLINE);
3066	fc_vport_set_state(vport: fc_vport, new_state: FC_VPORT_DISABLED);
3067	} else
3068	atomic_set(v: &vha->vp_state, VP_FAILED);
3069
3070	/* ready to create vport */
3071	ql_log(ql_log_info, vha, 0x7080,
3072	fmt: "VP entry id %d assigned.\n", vha->vp_idx);
3073
3074	/* initialized vport states */
3075	atomic_set(v: &vha->loop_state, LOOP_DOWN);
3076	vha->vp_err_state = VP_ERR_PORTDWN;
3077	vha->vp_prev_err_state = VP_ERR_UNKWN;
3078	/* Check if physical ha port is Up */
3079	if (atomic_read(v: &base_vha->loop_state) == LOOP_DOWN ||
3080	atomic_read(v: &base_vha->loop_state) == LOOP_DEAD) {
3081	/* Don't retry or attempt login of this virtual port */
3082	ql_dbg(ql_dbg_user, vha, 0x7081,
3083	fmt: "Vport loop state is not UP.\n");
3084	atomic_set(v: &vha->loop_state, LOOP_DEAD);
3085	if (!disable)
3086	fc_vport_set_state(vport: fc_vport, new_state: FC_VPORT_LINKDOWN);
3087	}
3088
3089	if (IS_T10_PI_CAPABLE(ha) && ql2xenabledif) {
3090	if (ha->fw_attributes & BIT_4) {
3091	int prot = 0, guard;
3092
3093	vha->flags.difdix_supported = 1;
3094	ql_dbg(ql_dbg_user, vha, 0x7082,
3095	fmt: "Registered for DIF/DIX type 1 and 3 protection.\n");
3096	scsi_host_set_prot(shost: vha->host,
3097	mask: prot | SHOST_DIF_TYPE1_PROTECTION
3098	| SHOST_DIF_TYPE2_PROTECTION
3099	| SHOST_DIF_TYPE3_PROTECTION
3100	| SHOST_DIX_TYPE1_PROTECTION
3101	| SHOST_DIX_TYPE2_PROTECTION
3102	| SHOST_DIX_TYPE3_PROTECTION);
3103
3104	guard = SHOST_DIX_GUARD_CRC;
3105
3106	if (IS_PI_IPGUARD_CAPABLE(ha) &&
3107	(ql2xenabledif > 1 || IS_PI_DIFB_DIX0_CAPABLE(ha)))
3108	guard |= SHOST_DIX_GUARD_IP;
3109
3110	scsi_host_set_guard(shost: vha->host, type: guard);
3111	} else
3112	vha->flags.difdix_supported = 0;
3113	}
3114
3115	if (scsi_add_host_with_dma(vha->host, &fc_vport->dev,
3116	&ha->pdev->dev)) {
3117	ql_dbg(ql_dbg_user, vha, 0x7083,
3118	fmt: "scsi_add_host failure for VP[%d].\n", vha->vp_idx);
3119	goto vport_create_failed_2;
3120	}
3121
3122	/* initialize attributes */
3123	fc_host_dev_loss_tmo(vha->host) = ha->port_down_retry_count;
3124	fc_host_node_name(vha->host) = wwn_to_u64(wwn: vha->node_name);
3125	fc_host_port_name(vha->host) = wwn_to_u64(wwn: vha->port_name);
3126	fc_host_supported_classes(vha->host) =
3127	fc_host_supported_classes(base_vha->host);
3128	fc_host_supported_speeds(vha->host) =
3129	fc_host_supported_speeds(base_vha->host);
3130
3131	qlt_vport_create(vha, ha);
3132	qla24xx_vport_disable(fc_vport, disable);
3133
3134	if (!ql2xmqsupport || !ha->npiv_info)
3135	goto vport_queue;
3136
3137	/* Create a request queue in QoS mode for the vport */
3138	for (cnt = 0; cnt < ha->nvram_npiv_size; cnt++) {
3139	if (memcmp(p: ha->npiv_info[cnt].port_name, q: vha->port_name, size: 8) == 0
3140	&& memcmp(p: ha->npiv_info[cnt].node_name, q: vha->node_name,
3141	size: 8) == 0) {
3142	qos = ha->npiv_info[cnt].q_qos;
3143	break;
3144	}
3145	}
3146
3147	if (qos) {
3148	qpair = qla2xxx_create_qpair(vha, qos, vha->vp_idx, true);
3149	if (!qpair)
3150	ql_log(ql_log_warn, vha, 0x7084,
3151	fmt: "Can't create qpair for VP[%d]\n",
3152	vha->vp_idx);
3153	else {
3154	ql_dbg(ql_dbg_multiq, vha, 0xc001,
3155	fmt: "Queue pair: %d Qos: %d) created for VP[%d]\n",
3156	qpair->id, qos, vha->vp_idx);
3157	ql_dbg(ql_dbg_user, vha, 0x7085,
3158	fmt: "Queue Pair: %d Qos: %d) created for VP[%d]\n",
3159	qpair->id, qos, vha->vp_idx);
3160	req = qpair->req;
3161	vha->qpair = qpair;
3162	}
3163	}
3164
3165	vport_queue:
3166	vha->req = req;
3167	return 0;
3168
3169	vport_create_failed_2:
3170	qla24xx_disable_vp(vha);
3171	qla24xx_deallocate_vp_id(vha);
3172	scsi_host_put(t: vha->host);
3173	return FC_VPORT_FAILED;
3174	}
3175
3176	static int
3177	qla24xx_vport_delete(struct fc_vport *fc_vport)
3178	{
3179	scsi_qla_host_t *vha = fc_vport->dd_data;
3180	struct qla_hw_data *ha = vha->hw;
3181	uint16_t id = vha->vp_idx;
3182
3183	set_bit(VPORT_DELETE, addr: &vha->dpc_flags);
3184
3185	while (test_bit(LOOP_RESYNC_ACTIVE, &vha->dpc_flags))
3186	msleep(msecs: 1000);
3187
3188
3189	qla24xx_disable_vp(vha);
3190	qla2x00_wait_for_sess_deletion(vha);
3191
3192	qla_nvme_delete(vha);
3193	qla_enode_stop(vha);
3194	qla_edb_stop(vha);
3195
3196	vha->flags.delete_progress = 1;
3197
3198	qlt_remove_target(ha, vha);
3199
3200	fc_remove_host(vha->host);
3201
3202	scsi_remove_host(vha->host);
3203
3204	/* Allow timer to run to drain queued items, when removing vp */
3205	qla24xx_deallocate_vp_id(vha);
3206
3207	if (vha->timer_active) {
3208	qla2x00_vp_stop_timer(vha);
3209	ql_dbg(ql_dbg_user, vha, 0x7086,
3210	fmt: "Timer for the VP[%d] has stopped\n", vha->vp_idx);
3211	}
3212
3213	qla2x00_free_fcports(vha);
3214
3215	mutex_lock(&ha->vport_lock);
3216	ha->cur_vport_count--;
3217	clear_bit(nr: vha->vp_idx, addr: ha->vp_idx_map);
3218	mutex_unlock(lock: &ha->vport_lock);
3219
3220	dma_free_coherent(dev: &ha->pdev->dev, size: vha->gnl.size, cpu_addr: vha->gnl.l,
3221	dma_handle: vha->gnl.ldma);
3222
3223	vha->gnl.l = NULL;
3224
3225	vfree(addr: vha->scan.l);
3226
3227	if (vha->qpair && vha->qpair->vp_idx == vha->vp_idx) {
3228	if (qla2xxx_delete_qpair(vha, vha->qpair) != QLA_SUCCESS)
3229	ql_log(ql_log_warn, vha, 0x7087,
3230	fmt: "Queue Pair delete failed.\n");
3231	}
3232
3233	ql_log(ql_log_info, vha, 0x7088, fmt: "VP[%d] deleted.\n", id);
3234	scsi_host_put(t: vha->host);
3235	return 0;
3236	}
3237
3238	static int
3239	qla24xx_vport_disable(struct fc_vport *fc_vport, bool disable)
3240	{
3241	scsi_qla_host_t *vha = fc_vport->dd_data;
3242
3243	if (disable)
3244	qla24xx_disable_vp(vha);
3245	else
3246	qla24xx_enable_vp(vha);
3247
3248	return 0;
3249	}
3250
3251	struct fc_function_template qla2xxx_transport_functions = {
3252
3253	.show_host_node_name = 1,
3254	.show_host_port_name = 1,
3255	.show_host_supported_classes = 1,
3256	.show_host_supported_speeds = 1,
3257
3258	.get_host_port_id = qla2x00_get_host_port_id,
3259	.show_host_port_id = 1,
3260	.get_host_speed = qla2x00_get_host_speed,
3261	.show_host_speed = 1,
3262	.get_host_port_type = qla2x00_get_host_port_type,
3263	.show_host_port_type = 1,
3264	.get_host_symbolic_name = qla2x00_get_host_symbolic_name,
3265	.show_host_symbolic_name = 1,
3266	.set_host_system_hostname = qla2x00_set_host_system_hostname,
3267	.show_host_system_hostname = 1,
3268	.get_host_fabric_name = qla2x00_get_host_fabric_name,
3269	.show_host_fabric_name = 1,
3270	.get_host_port_state = qla2x00_get_host_port_state,
3271	.show_host_port_state = 1,
3272
3273	.dd_fcrport_size = sizeof(struct fc_port *),
3274	.show_rport_supported_classes = 1,
3275
3276	.get_starget_node_name = qla2x00_get_starget_node_name,
3277	.show_starget_node_name = 1,
3278	.get_starget_port_name = qla2x00_get_starget_port_name,
3279	.show_starget_port_name = 1,
3280	.get_starget_port_id = qla2x00_get_starget_port_id,
3281	.show_starget_port_id = 1,
3282
3283	.set_rport_dev_loss_tmo = qla2x00_set_rport_loss_tmo,
3284	.show_rport_dev_loss_tmo = 1,
3285
3286	.issue_fc_host_lip = qla2x00_issue_lip,
3287	.dev_loss_tmo_callbk = qla2x00_dev_loss_tmo_callbk,
3288	.terminate_rport_io = qla2x00_terminate_rport_io,
3289	.get_fc_host_stats = qla2x00_get_fc_host_stats,
3290	.reset_fc_host_stats = qla2x00_reset_host_stats,
3291
3292	.vport_create = qla24xx_vport_create,
3293	.vport_disable = qla24xx_vport_disable,
3294	.vport_delete = qla24xx_vport_delete,
3295	.bsg_request = qla24xx_bsg_request,
3296	.bsg_timeout = qla24xx_bsg_timeout,
3297	};
3298
3299	struct fc_function_template qla2xxx_transport_vport_functions = {
3300
3301	.show_host_node_name = 1,
3302	.show_host_port_name = 1,
3303	.show_host_supported_classes = 1,
3304
3305	.get_host_port_id = qla2x00_get_host_port_id,
3306	.show_host_port_id = 1,
3307	.get_host_speed = qla2x00_get_host_speed,
3308	.show_host_speed = 1,
3309	.get_host_port_type = qla2x00_get_host_port_type,
3310	.show_host_port_type = 1,
3311	.get_host_symbolic_name = qla2x00_get_host_symbolic_name,
3312	.show_host_symbolic_name = 1,
3313	.set_host_system_hostname = qla2x00_set_host_system_hostname,
3314	.show_host_system_hostname = 1,
3315	.get_host_fabric_name = qla2x00_get_host_fabric_name,
3316	.show_host_fabric_name = 1,
3317	.get_host_port_state = qla2x00_get_host_port_state,
3318	.show_host_port_state = 1,
3319
3320	.dd_fcrport_size = sizeof(struct fc_port *),
3321	.show_rport_supported_classes = 1,
3322
3323	.get_starget_node_name = qla2x00_get_starget_node_name,
3324	.show_starget_node_name = 1,
3325	.get_starget_port_name = qla2x00_get_starget_port_name,
3326	.show_starget_port_name = 1,
3327	.get_starget_port_id = qla2x00_get_starget_port_id,
3328	.show_starget_port_id = 1,
3329
3330	.set_rport_dev_loss_tmo = qla2x00_set_rport_loss_tmo,
3331	.show_rport_dev_loss_tmo = 1,
3332
3333	.issue_fc_host_lip = qla2x00_issue_lip,
3334	.dev_loss_tmo_callbk = qla2x00_dev_loss_tmo_callbk,
3335	.terminate_rport_io = qla2x00_terminate_rport_io,
3336	.get_fc_host_stats = qla2x00_get_fc_host_stats,
3337	.reset_fc_host_stats = qla2x00_reset_host_stats,
3338
3339	.bsg_request = qla24xx_bsg_request,
3340	.bsg_timeout = qla24xx_bsg_timeout,
3341	};
3342
3343	static uint
3344	qla2x00_get_host_supported_speeds(scsi_qla_host_t *vha, uint speeds)
3345	{
3346	uint supported_speeds = FC_PORTSPEED_UNKNOWN;
3347
3348	if (speeds & FDMI_PORT_SPEED_64GB)
3349	supported_speeds |= FC_PORTSPEED_64GBIT;
3350	if (speeds & FDMI_PORT_SPEED_32GB)
3351	supported_speeds |= FC_PORTSPEED_32GBIT;
3352	if (speeds & FDMI_PORT_SPEED_16GB)
3353	supported_speeds |= FC_PORTSPEED_16GBIT;
3354	if (speeds & FDMI_PORT_SPEED_8GB)
3355	supported_speeds |= FC_PORTSPEED_8GBIT;
3356	if (speeds & FDMI_PORT_SPEED_4GB)
3357	supported_speeds |= FC_PORTSPEED_4GBIT;
3358	if (speeds & FDMI_PORT_SPEED_2GB)
3359	supported_speeds |= FC_PORTSPEED_2GBIT;
3360	if (speeds & FDMI_PORT_SPEED_1GB)
3361	supported_speeds |= FC_PORTSPEED_1GBIT;
3362
3363	return supported_speeds;
3364	}
3365
3366	void
3367	qla2x00_init_host_attr(scsi_qla_host_t *vha)
3368	{
3369	struct qla_hw_data *ha = vha->hw;
3370	u32 speeds = 0, fdmi_speed = 0;
3371
3372	fc_host_dev_loss_tmo(vha->host) = ha->port_down_retry_count;
3373	fc_host_node_name(vha->host) = wwn_to_u64(wwn: vha->node_name);
3374	fc_host_port_name(vha->host) = wwn_to_u64(wwn: vha->port_name);
3375	fc_host_supported_classes(vha->host) = ha->base_qpair->enable_class_2 ?
3376	(FC_COS_CLASS2|FC_COS_CLASS3) : FC_COS_CLASS3;
3377	fc_host_max_npiv_vports(vha->host) = ha->max_npiv_vports;
3378	fc_host_npiv_vports_inuse(vha->host) = ha->cur_vport_count;
3379
3380	fdmi_speed = qla25xx_fdmi_port_speed_capability(ha);
3381	speeds = qla2x00_get_host_supported_speeds(vha, speeds: fdmi_speed);
3382
3383	fc_host_supported_speeds(vha->host) = speeds;
3384	}
3385