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
qla2x00_sysfs_read_fw_dump(struct file * filp,struct kobject * kobj,struct bin_attribute * bin_attr,char * buf,loff_t off,size_t count)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(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(buf, count,
36 &off, ha->md_tmplt_hdr, ha->md_template_size);
37 } else {
38 off -= ha->md_template_size;
39 rval = memory_read_from_buffer(buf, count,
40 &off, ha->md_dump, ha->md_dump_size);
41 }
42 } else if (ha->mctp_dumped && ha->mctp_dump_reading) {
43 rval = memory_read_from_buffer(buf, count, &off, 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(buf, count, &off,
47 ha->mpi_fw_dump,
48 ha->mpi_fw_dump_len);
49 } else if (ha->fw_dump_reading) {
50 rval = memory_read_from_buffer(buf, count, &off, ha->fw_dump,
51 ha->fw_dump_len);
52 } else {
53 rval = 0;
54 }
55 mutex_unlock(&ha->optrom_mutex);
56 return rval;
57 }
58
59 static ssize_t
qla2x00_sysfs_write_fw_dump(struct file * filp,struct kobject * kobj,struct bin_attribute * bin_attr,char * buf,loff_t off,size_t count)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(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 "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 "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 "MiniDump supported with this firmware.\n");
118 else
119 ql_dbg(ql_dbg_user, vha, 0x709d,
120 "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, &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 "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 "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 "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 "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 "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
qla2x00_sysfs_read_nvram(struct file * filp,struct kobject * kobj,struct bin_attribute * bin_attr,char * buf,loff_t off,size_t count)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(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(&ha->optrom_mutex);
198 return -EAGAIN;
199 }
200
201 if (!IS_NOCACHE_VPD_TYPE(ha)) {
202 mutex_unlock(&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(&ha->optrom_mutex);
215
216 skip:
217 return memory_read_from_buffer(buf, count, &off, ha->nvram,
218 ha->nvram_size);
219 }
220
221 static ssize_t
qla2x00_sysfs_write_nvram(struct file * filp,struct kobject * kobj,struct bin_attribute * bin_attr,char * buf,loff_t off,size_t count)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(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 "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(&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(&ha->optrom_mutex);
274
275 ql_dbg(ql_dbg_user, vha, 0x7060,
276 "Setting ISP_ABORT_NEEDED\n");
277 /* NVRAM settings take effect immediately. */
278 set_bit(ISP_ABORT_NEEDED, &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
qla2x00_sysfs_read_optrom(struct file * filp,struct kobject * kobj,struct bin_attribute * bin_attr,char * buf,loff_t off,size_t count)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(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(buf, count, &off, ha->optrom_buffer,
311 ha->optrom_region_size);
312
313 out:
314 mutex_unlock(&ha->optrom_mutex);
315
316 return rval;
317 }
318
319 static ssize_t
qla2x00_sysfs_write_optrom(struct file * filp,struct kobject * kobj,struct bin_attribute * bin_attr,char * buf,loff_t off,size_t count)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(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(&ha->optrom_mutex);
332 return -EINVAL;
333 }
334 if (off > ha->optrom_region_size) {
335 mutex_unlock(&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(&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
qla2x00_sysfs_write_optrom_ctl(struct file * filp,struct kobject * kobj,struct bin_attribute * bin_attr,char * buf,loff_t off,size_t count)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(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(&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 "Freeing flash region allocation -- 0x%x bytes.\n",
399 ha->optrom_region_size);
400
401 vfree(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(ha->optrom_region_size);
415 if (ha->optrom_buffer == NULL) {
416 ql_log(ql_log_warn, vha, 0x7062,
417 "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 "HBA not online, failing NVRAM update.\n");
428 rval = -EAGAIN;
429 goto out;
430 }
431
432 ql_dbg(ql_dbg_user, vha, 0x7064,
433 "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 "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(ha->optrom_region_size);
486 if (ha->optrom_buffer == NULL) {
487 ql_log(ql_log_warn, vha, 0x7066,
488 "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 "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 "HBA not online, failing flash update.\n");
510 rval = -EAGAIN;
511 goto out;
512 }
513
514 ql_dbg(ql_dbg_user, vha, 0x7069,
515 "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(&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
qla2x00_sysfs_read_vpd(struct file * filp,struct kobject * kobj,struct bin_attribute * bin_attr,char * buf,loff_t off,size_t count)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(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 "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(&ha->optrom_mutex);
577 return -EAGAIN;
578 }
579
580 ha->isp_ops->read_optrom(vha, ha->vpd, faddr, ha->vpd_size);
581 mutex_unlock(&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(buf, count, &off, ha->vpd, ha->vpd_size);
586 }
587
588 static ssize_t
qla2x00_sysfs_write_vpd(struct file * filp,struct kobject * kobj,struct bin_attribute * bin_attr,char * buf,loff_t off,size_t count)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(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 "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(&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(&ha->optrom_mutex);
627 return -EINVAL;
628 }
629
630 tmp_data = vmalloc(256);
631 if (!tmp_data) {
632 mutex_unlock(&ha->optrom_mutex);
633 ql_log(ql_log_warn, vha, 0x706b,
634 "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(tmp_data);
639
640 mutex_unlock(&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
qla2x00_sysfs_read_sfp(struct file * filp,struct kobject * kobj,struct bin_attribute * bin_attr,char * buf,loff_t off,size_t count)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(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(&vha->hw->optrom_mutex);
670 return 0;
671 }
672
673 rval = qla2x00_read_sfp_dev(vha, buf, count);
674 mutex_unlock(&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
qla2x00_sysfs_write_reset(struct file * filp,struct kobject * kobj,struct bin_attribute * bin_attr,char * buf,loff_t off,size_t count)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(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(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 "Issuing ISP reset.\n");
712
713 if (vha->hw->flags.port_isolated) {
714 ql_log(ql_log_info, vha, 0x706e,
715 "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 (idc_control | GRACEFUL_RESET_BIT1));
731 qla82xx_set_reset_owner(vha);
732 qla8044_idc_unlock(ha);
733 } else {
734 set_bit(ISP_ABORT_NEEDED, &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 "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 "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 "FCoE ctx reset not supported.\n");
778 return -EPERM;
779 }
780
781 ql_log(ql_log_info, vha, 0x7072,
782 "Issuing FCoE ctx reset.\n");
783 set_bit(FCOE_CTX_RESET_NEEDED, &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 "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 "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 "Updating cache versions without reset ");
812
813 tmp_data = vmalloc(256);
814 if (!tmp_data) {
815 ql_log(ql_log_warn, vha, 0x70e1,
816 "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(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
qla2x00_issue_logo(struct file * filp,struct kobject * kobj,struct bin_attribute * bin_attr,char * buf,loff_t off,size_t count)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(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, "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, "%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
qla2x00_sysfs_read_xgmac_stats(struct file * filp,struct kobject * kobj,struct bin_attribute * bin_attr,char * buf,loff_t off,size_t count)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(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(&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(&ha->pdev->dev, XGMAC_DATA_SIZE,
904 &ha->xgmac_data_dma, GFP_KERNEL);
905 if (!ha->xgmac_data) {
906 mutex_unlock(&vha->hw->optrom_mutex);
907 ql_log(ql_log_warn, vha, 0x7076,
908 "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(&vha->hw->optrom_mutex);
920 if (rval != QLA_SUCCESS) {
921 ql_log(ql_log_warn, vha, 0x7077,
922 "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
qla2x00_sysfs_read_dcbx_tlv(struct file * filp,struct kobject * kobj,struct bin_attribute * bin_attr,char * buf,loff_t off,size_t count)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(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(&vha->hw->optrom_mutex);
959 return 0;
960 }
961
962 ha->dcbx_tlv = dma_alloc_coherent(&ha->pdev->dev, DCBX_TLV_DATA_SIZE,
963 &ha->dcbx_tlv_dma, GFP_KERNEL);
964 if (!ha->dcbx_tlv) {
965 mutex_unlock(&vha->hw->optrom_mutex);
966 ql_log(ql_log_warn, vha, 0x7078,
967 "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(&vha->hw->optrom_mutex);
978
979 if (rval != QLA_SUCCESS) {
980 ql_log(ql_log_warn, vha, 0x7079,
981 "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
qla2x00_alloc_sysfs_attr(scsi_qla_host_t * vha)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(&host->shost_gendev.kobj,
1033 iter->attr);
1034 if (ret)
1035 ql_log(ql_log_warn, vha, 0x00f3,
1036 "Unable to create sysfs %s binary attribute (%d).\n",
1037 iter->name, ret);
1038 else
1039 ql_dbg(ql_dbg_init, vha, 0x00f4,
1040 "Successfully created sysfs %s binary attribute.\n",
1041 iter->name);
1042 }
1043 }
1044
1045 void
qla2x00_free_sysfs_attr(scsi_qla_host_t * vha,bool stop_beacon)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(&host->shost_gendev.kobj,
1061 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
qla2x00_driver_version_show(struct device * dev,struct device_attribute * attr,char * buf)1071 qla2x00_driver_version_show(struct device *dev,
1072 struct device_attribute *attr, char *buf)
1073 {
1074 return scnprintf(buf, PAGE_SIZE, "%s\n", qla2x00_version_str);
1075 }
1076
1077 static ssize_t
qla2x00_fw_version_show(struct device * dev,struct device_attribute * attr,char * buf)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, "%s\n",
1086 ha->isp_ops->fw_version_str(vha, fw_str, sizeof(fw_str)));
1087 }
1088
1089 static ssize_t
qla2x00_serial_num_show(struct device * dev,struct device_attribute * attr,char * buf)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, "%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, "%c%05d\n", 'A' + sn / 100000,
1107 sn % 100000);
1108 }
1109
1110 static ssize_t
qla2x00_isp_name_show(struct device * dev,struct device_attribute * attr,char * buf)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, "ISP%04X\n", vha->hw->pdev->device);
1117 }
1118
1119 static ssize_t
qla2x00_isp_id_show(struct device * dev,struct device_attribute * attr,char * buf)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, "%s\n",
1128 vha->hw->mr.hw_version);
1129
1130 return scnprintf(buf, PAGE_SIZE, "%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
qla2x00_model_name_show(struct device * dev,struct device_attribute * attr,char * buf)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, "%s\n", vha->hw->model_number);
1142 }
1143
1144 static ssize_t
qla2x00_model_desc_show(struct device * dev,struct device_attribute * attr,char * buf)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, "%s\n", vha->hw->model_desc);
1151 }
1152
1153 static ssize_t
qla2x00_pci_info_show(struct device * dev,struct device_attribute * attr,char * buf)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, "%s\n",
1161 vha->hw->isp_ops->pci_info_str(vha, pci_info,
1162 sizeof(pci_info)));
1163 }
1164
1165 static ssize_t
qla2x00_link_state_show(struct device * dev,struct device_attribute * attr,char * buf)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(&vha->loop_state) == LOOP_DOWN ||
1174 atomic_read(&vha->loop_state) == LOOP_DEAD ||
1175 vha->device_flags & DFLG_NO_CABLE)
1176 len = scnprintf(buf, PAGE_SIZE, "Link Down\n");
1177 else if (atomic_read(&vha->loop_state) != LOOP_READY ||
1178 qla2x00_chip_is_down(vha))
1179 len = scnprintf(buf, PAGE_SIZE, "Unknown Link State\n");
1180 else {
1181 len = scnprintf(buf, PAGE_SIZE, "Link Up - ");
1182
1183 switch (ha->current_topology) {
1184 case ISP_CFG_NL:
1185 len += scnprintf(buf + len, PAGE_SIZE-len, "Loop\n");
1186 break;
1187 case ISP_CFG_FL:
1188 len += scnprintf(buf + len, PAGE_SIZE-len, "FL_Port\n");
1189 break;
1190 case ISP_CFG_N:
1191 len += scnprintf(buf + len, PAGE_SIZE-len,
1192 "N_Port to N_Port\n");
1193 break;
1194 case ISP_CFG_F:
1195 len += scnprintf(buf + len, PAGE_SIZE-len, "F_Port\n");
1196 break;
1197 default:
1198 len += scnprintf(buf + len, PAGE_SIZE-len, "Loop\n");
1199 break;
1200 }
1201 }
1202 return len;
1203 }
1204
1205 static ssize_t
qla2x00_zio_show(struct device * dev,struct device_attribute * attr,char * buf)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 + len, PAGE_SIZE-len, "Mode 6\n");
1215 break;
1216 case QLA_ZIO_DISABLED:
1217 len += scnprintf(buf + len, PAGE_SIZE-len, "Disabled\n");
1218 break;
1219 }
1220 return len;
1221 }
1222
1223 static ssize_t
qla2x00_zio_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)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, &vha->dpc_flags);
1247 }
1248 return strlen(buf);
1249 }
1250
1251 static ssize_t
qla2x00_zio_timer_show(struct device * dev,struct device_attribute * attr,char * buf)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, "%d us\n", vha->hw->zio_timer * 100);
1258 }
1259
1260 static ssize_t
qla2x00_zio_timer_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)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
qla_zio_threshold_show(struct device * dev,struct device_attribute * attr,char * buf)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, "%d exchanges\n",
1286 vha->hw->last_zio_threshold);
1287 }
1288
1289 static ssize_t
qla_zio_threshold_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)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(&vha->hw->zio_threshold, val);
1304 return strlen(buf);
1305 }
1306
1307 static ssize_t
qla2x00_beacon_show(struct device * dev,struct device_attribute * attr,char * buf)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 + len, PAGE_SIZE-len, "Enabled\n");
1316 else
1317 len += scnprintf(buf + len, PAGE_SIZE-len, "Disabled\n");
1318 return len;
1319 }
1320
1321 static ssize_t
qla2x00_beacon_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)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(&vha->hw->optrom_mutex);
1339 ql_log(ql_log_warn, vha, 0x707a,
1340 "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(&vha->hw->optrom_mutex);
1353
1354 return count;
1355 }
1356
1357 static ssize_t
qla2x00_beacon_config_show(struct device * dev,struct device_attribute * attr,char * buf)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, "\n");
1370
1371 return scnprintf(buf, PAGE_SIZE, "%#04hx %#04hx %#04hx\n",
1372 led[0], led[1], led[2]);
1373 }
1374
1375 static ssize_t
qla2x00_beacon_config_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)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
qla2x00_optrom_bios_version_show(struct device * dev,struct device_attribute * attr,char * buf)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, "%d.%02d\n", ha->bios_revision[1],
1438 ha->bios_revision[0]);
1439 }
1440
1441 static ssize_t
qla2x00_optrom_efi_version_show(struct device * dev,struct device_attribute * attr,char * buf)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, "%d.%02d\n", ha->efi_revision[1],
1449 ha->efi_revision[0]);
1450 }
1451
1452 static ssize_t
qla2x00_optrom_fcode_version_show(struct device * dev,struct device_attribute * attr,char * buf)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, "%d.%02d\n", ha->fcode_revision[1],
1460 ha->fcode_revision[0]);
1461 }
1462
1463 static ssize_t
qla2x00_optrom_fw_version_show(struct device * dev,struct device_attribute * attr,char * buf)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, "%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
qla2x00_optrom_gold_fw_version_show(struct device * dev,struct device_attribute * attr,char * buf)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, "\n");
1485
1486 return scnprintf(buf, PAGE_SIZE, "%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
qla2x00_total_isp_aborts_show(struct device * dev,struct device_attribute * attr,char * buf)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, "%d\n",
1498 vha->qla_stats.total_isp_aborts);
1499 }
1500
1501 static ssize_t
qla24xx_84xx_fw_version_show(struct device * dev,struct device_attribute * attr,char * buf)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, "\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, "%u\n",
1518 (uint32_t)ha->cs84xx->op_fw_version);
1519 }
1520
1521 return scnprintf(buf, PAGE_SIZE, "\n");
1522 }
1523
1524 static ssize_t
qla2x00_serdes_version_show(struct device * dev,struct device_attribute * attr,char * buf)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, "\n");
1533
1534 return scnprintf(buf, PAGE_SIZE, "%d.%02d.%02d\n",
1535 ha->serdes_version[0], ha->serdes_version[1],
1536 ha->serdes_version[2]);
1537 }
1538
1539 static ssize_t
qla2x00_mpi_version_show(struct device * dev,struct device_attribute * attr,char * buf)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, "\n");
1549
1550 return scnprintf(buf, PAGE_SIZE, "%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
qla2x00_phy_version_show(struct device * dev,struct device_attribute * attr,char * buf)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, "\n");
1564
1565 return scnprintf(buf, PAGE_SIZE, "%d.%02d.%02d\n",
1566 ha->phy_version[0], ha->phy_version[1], ha->phy_version[2]);
1567 }
1568
1569 static ssize_t
qla2x00_flash_block_size_show(struct device * dev,struct device_attribute * attr,char * buf)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, "0x%x\n", ha->fdt_block_size);
1577 }
1578
1579 static ssize_t
qla2x00_vlan_id_show(struct device * dev,struct device_attribute * attr,char * buf)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, "\n");
1587
1588 return scnprintf(buf, PAGE_SIZE, "%d\n", vha->fcoe_vlan_id);
1589 }
1590
1591 static ssize_t
qla2x00_vn_port_mac_address_show(struct device * dev,struct device_attribute * attr,char * buf)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, "\n");
1599
1600 return scnprintf(buf, PAGE_SIZE, "%pMR\n", vha->fcoe_vn_port_mac);
1601 }
1602
1603 static ssize_t
qla2x00_fabric_param_show(struct device * dev,struct device_attribute * attr,char * buf)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, "%d\n", vha->hw->switch_cap);
1610 }
1611
1612 static ssize_t
qla2x00_thermal_temp_show(struct device * dev,struct device_attribute * attr,char * buf)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(&vha->hw->optrom_mutex);
1623 ql_log(ql_log_warn, vha, 0x70dc, "ISP reset active.\n");
1624 goto done;
1625 }
1626
1627 if (vha->hw->flags.eeh_busy) {
1628 mutex_unlock(&vha->hw->optrom_mutex);
1629 ql_log(ql_log_warn, vha, 0x70dd, "PCI EEH busy.\n");
1630 goto done;
1631 }
1632
1633 rc = qla2x00_get_thermal_temp(vha, &temp);
1634 mutex_unlock(&vha->hw->optrom_mutex);
1635 if (rc == QLA_SUCCESS)
1636 return scnprintf(buf, PAGE_SIZE, "%d\n", temp);
1637
1638 done:
1639 return scnprintf(buf, PAGE_SIZE, "\n");
1640 }
1641
1642 static ssize_t
qla2x00_fw_state_show(struct device * dev,struct device_attribute * attr,char * buf)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, "0x%x\n", pstate);
1654 }
1655
1656 mutex_lock(&vha->hw->optrom_mutex);
1657 if (qla2x00_chip_is_down(vha)) {
1658 mutex_unlock(&vha->hw->optrom_mutex);
1659 ql_log(ql_log_warn, vha, 0x707c,
1660 "ISP reset active.\n");
1661 goto out;
1662 } else if (vha->hw->flags.eeh_busy) {
1663 mutex_unlock(&vha->hw->optrom_mutex);
1664 goto out;
1665 }
1666
1667 rval = qla2x00_get_firmware_state(vha, state);
1668 mutex_unlock(&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, "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
qla2x00_diag_requests_show(struct device * dev,struct device_attribute * attr,char * buf)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, "\n");
1687
1688 return scnprintf(buf, PAGE_SIZE, "%llu\n", vha->bidi_stats.io_count);
1689 }
1690
1691 static ssize_t
qla2x00_diag_megabytes_show(struct device * dev,struct device_attribute * attr,char * buf)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, "\n");
1699
1700 return scnprintf(buf, PAGE_SIZE, "%llu\n",
1701 vha->bidi_stats.transfer_bytes >> 20);
1702 }
1703
1704 static ssize_t
qla2x00_fw_dump_size_show(struct device * dev,struct device_attribute * attr,char * buf)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, "%d\n", size);
1720 }
1721
1722 static ssize_t
qla2x00_allow_cna_fw_dump_show(struct device * dev,struct device_attribute * attr,char * buf)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, "\n");
1730 else
1731 return scnprintf(buf, PAGE_SIZE, "%s\n",
1732 vha->hw->allow_cna_fw_dump ? "true" : "false");
1733 }
1734
1735 static ssize_t
qla2x00_allow_cna_fw_dump_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)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
qla2x00_pep_version_show(struct device * dev,struct device_attribute * attr,char * buf)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, "\n");
1762
1763 return scnprintf(buf, PAGE_SIZE, "%d.%02d.%02d\n",
1764 ha->pep_version[0], ha->pep_version[1], ha->pep_version[2]);
1765 }
1766
1767 static ssize_t
qla2x00_min_supported_speed_show(struct device * dev,struct device_attribute * attr,char * buf)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, "\n");
1776
1777 return scnprintf(buf, PAGE_SIZE, "%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
qla2x00_max_supported_speed_show(struct device * dev,struct device_attribute * attr,char * buf)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, "\n");
1795
1796 return scnprintf(buf, PAGE_SIZE, "%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
qla2x00_port_speed_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)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(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 "Speed setting not supported \n");
1815 return -EINVAL;
1816 }
1817
1818 rval = kstrtol(buf, 10, &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 "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 "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 "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
qla2x00_port_speed_show(struct device * dev,struct device_attribute * attr,char * buf)1881 qla2x00_port_speed_show(struct device *dev, struct device_attribute *attr,
1882 char *buf)
1883 {
1884 struct scsi_qla_host *vha = shost_priv(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 "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, "%s\n", speed);
1905 }
1906
1907 static ssize_t
qla2x00_mpi_pause_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)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, "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, "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
qlini_mode_show(struct device * dev,struct device_attribute * attr,char * buf)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 + len, PAGE_SIZE-len,
1940 "Supported options: enabled | disabled | dual | exclusive\n");
1941
1942 /* --- */
1943 len += scnprintf(buf + len, PAGE_SIZE-len, "Current selection: ");
1944
1945 switch (vha->qlini_mode) {
1946 case QLA2XXX_INI_MODE_EXCLUSIVE:
1947 len += scnprintf(buf + len, PAGE_SIZE-len,
1948 QLA2XXX_INI_MODE_STR_EXCLUSIVE);
1949 break;
1950 case QLA2XXX_INI_MODE_DISABLED:
1951 len += scnprintf(buf + len, PAGE_SIZE-len,
1952 QLA2XXX_INI_MODE_STR_DISABLED);
1953 break;
1954 case QLA2XXX_INI_MODE_ENABLED:
1955 len += scnprintf(buf + len, PAGE_SIZE-len,
1956 QLA2XXX_INI_MODE_STR_ENABLED);
1957 break;
1958 case QLA2XXX_INI_MODE_DUAL:
1959 len += scnprintf(buf + len, PAGE_SIZE-len,
1960 QLA2XXX_INI_MODE_STR_DUAL);
1961 break;
1962 }
1963 len += scnprintf(buf + len, PAGE_SIZE-len, "\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)
qla_set_ini_mode(scsi_qla_host_t * vha,int op)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(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(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(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(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(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(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(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(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(vha) ||
2145 qla_dual_mode_enabled(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(vha) ||
2179 qla_dual_mode_enabled(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(vha) ||
2190 qla_dual_mode_enabled(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(vha) ||
2200 qla_dual_mode_enabled(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 "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, &vha->dpc_flags);
2224 break;
2225
2226 case MODE_CHANGE_NO_ACTION:
2227 ql_log(ql_log_warn, vha, 0xffff,
2228 "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 "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 "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
qlini_mode_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)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, buf,
2263 strlen(QLA2XXX_INI_MODE_STR_EXCLUSIVE)) == 0)
2264 ini = QLA2XXX_INI_MODE_EXCLUSIVE;
2265 else if (strncasecmp(QLA2XXX_INI_MODE_STR_DISABLED, buf,
2266 strlen(QLA2XXX_INI_MODE_STR_DISABLED)) == 0)
2267 ini = QLA2XXX_INI_MODE_DISABLED;
2268 else if (strncasecmp(QLA2XXX_INI_MODE_STR_ENABLED, buf,
2269 strlen(QLA2XXX_INI_MODE_STR_ENABLED)) == 0)
2270 ini = QLA2XXX_INI_MODE_ENABLED;
2271 else if (strncasecmp(QLA2XXX_INI_MODE_STR_DUAL, 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, ini);
2278 return strlen(buf);
2279 }
2280
2281 static ssize_t
ql2xexchoffld_show(struct device * dev,struct device_attribute * attr,char * buf)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 + len, PAGE_SIZE-len,
2289 "target exchange: new %d : current: %d\n\n",
2290 vha->u_ql2xexchoffld, vha->ql2xexchoffld);
2291
2292 len += scnprintf(buf + len, PAGE_SIZE-len,
2293 "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
ql2xexchoffld_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)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
ql2xiniexchg_show(struct device * dev,struct device_attribute * attr,char * buf)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 + len, PAGE_SIZE-len,
2326 "target exchange: new %d : current: %d\n\n",
2327 vha->u_ql2xiniexchg, vha->ql2xiniexchg);
2328
2329 len += scnprintf(buf + len, PAGE_SIZE-len,
2330 "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
ql2xiniexchg_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)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
qla2x00_dif_bundle_statistics_show(struct device * dev,struct device_attribute * attr,char * buf)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 "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
qla2x00_fw_attr_show(struct device * dev,struct device_attribute * attr,char * buf)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, "\n");
2378
2379 return scnprintf(buf, PAGE_SIZE, "%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
qla2x00_port_no_show(struct device * dev,struct device_attribute * attr,char * buf)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, "%u\n", vha->hw->port_no);
2393 }
2394
2395 static ssize_t
qla2x00_dport_diagnostics_show(struct device * dev,struct device_attribute * attr,char * buf)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, "\n");
2404
2405 if (!*vha->dport_data)
2406 return scnprintf(buf, PAGE_SIZE, "\n");
2407
2408 return scnprintf(buf, PAGE_SIZE, "%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
qla_host_attr_is_visible(struct kobject * kobj,struct attribute * attr,int i)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
qla2x00_get_host_port_id(struct Scsi_Host * shost)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
qla2x00_get_host_speed(struct Scsi_Host * shost)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
qla2x00_get_host_port_type(struct Scsi_Host * shost)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
qla2x00_get_starget_node_name(struct scsi_target * starget)2638 qla2x00_get_starget_node_name(struct scsi_target *starget)
2639 {
2640 struct Scsi_Host *host = dev_to_shost(starget->dev.parent);
2641 scsi_qla_host_t *vha = shost_priv(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(fcport->node_name);
2649 break;
2650 }
2651 }
2652
2653 fc_starget_node_name(starget) = node_name;
2654 }
2655
2656 static void
qla2x00_get_starget_port_name(struct scsi_target * starget)2657 qla2x00_get_starget_port_name(struct scsi_target *starget)
2658 {
2659 struct Scsi_Host *host = dev_to_shost(starget->dev.parent);
2660 scsi_qla_host_t *vha = shost_priv(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(fcport->port_name);
2668 break;
2669 }
2670 }
2671
2672 fc_starget_port_name(starget) = port_name;
2673 }
2674
2675 static void
qla2x00_get_starget_port_id(struct scsi_target * starget)2676 qla2x00_get_starget_port_id(struct scsi_target *starget)
2677 {
2678 struct Scsi_Host *host = dev_to_shost(starget->dev.parent);
2679 scsi_qla_host_t *vha = shost_priv(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
qla2x00_set_rport_loss_tmo(struct fc_rport * rport,uint32_t timeout)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(fcport->nvme_remote_port,
2704 rport->dev_loss_tmo);
2705 }
2706
2707 static void
qla2x00_dev_loss_tmo_callbk(struct fc_rport * rport)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, 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, 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(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
qla2x00_terminate_rport_io(struct fc_rport * rport)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, fcport->vha, 0x911e,
2785 "%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 "IO not return. Resetting. \n");
2798 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
2799 qla2xxx_wake_dpc(vha);
2800 qla2x00_wait_for_chip_reset(vha);
2801 }
2802 }
2803
2804 static int
qla2x00_issue_lip(struct Scsi_Host * shost)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 *
qla2x00_get_fc_host_stats(struct Scsi_Host * shost)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(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(&ha->pdev->dev, sizeof(*stats), &stats_dma,
2848 GFP_KERNEL);
2849 if (!stats) {
2850 ql_log(ql_log_warn, vha, 0x707d,
2851 "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(&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(&ha->pdev->dev, sizeof(struct link_statistics),
2924 stats, stats_dma);
2925 done:
2926 return p;
2927 }
2928
2929 static void
qla2x00_reset_host_stats(struct Scsi_Host * shost)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(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(&ha->pdev->dev,
2956 sizeof(*stats), &stats_dma, GFP_KERNEL);
2957 if (!stats) {
2958 ql_log(ql_log_warn, vha, 0x70d7,
2959 "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 "Resetting ISP statistics failed: rval = %d\n",
2968 rval);
2969
2970 dma_free_coherent(&ha->pdev->dev, sizeof(*stats),
2971 stats, stats_dma);
2972 }
2973 }
2974
2975 static void
qla2x00_get_host_symbolic_name(struct Scsi_Host * shost)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
qla2x00_set_host_system_hostname(struct Scsi_Host * shost)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, &vha->dpc_flags);
2990 }
2991
2992 static void
qla2x00_get_host_fabric_name(struct Scsi_Host * shost)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(node_name);
3000
3001 if (vha->device_flags & SWITCH_FOUND)
3002 fabric_name = wwn_to_u64(vha->fabric_node_name);
3003
3004 fc_host_fabric_name(shost) = fabric_name;
3005 }
3006
3007 static void
qla2x00_get_host_port_state(struct Scsi_Host * shost)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(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(&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
qla24xx_vport_create(struct fc_vport * fc_vport,bool disable)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(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 "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, "Vport create host failed.\n");
3062 return FC_VPORT_FAILED;
3063 }
3064 if (disable) {
3065 atomic_set(&vha->vp_state, VP_OFFLINE);
3066 fc_vport_set_state(fc_vport, FC_VPORT_DISABLED);
3067 } else
3068 atomic_set(&vha->vp_state, VP_FAILED);
3069
3070 /* ready to create vport */
3071 ql_log(ql_log_info, vha, 0x7080,
3072 "VP entry id %d assigned.\n", vha->vp_idx);
3073
3074 /* initialized vport states */
3075 atomic_set(&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(&base_vha->loop_state) == LOOP_DOWN ||
3080 atomic_read(&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 "Vport loop state is not UP.\n");
3084 atomic_set(&vha->loop_state, LOOP_DEAD);
3085 if (!disable)
3086 fc_vport_set_state(fc_vport, 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 "Registered for DIF/DIX type 1 and 3 protection.\n");
3096 scsi_host_set_prot(vha->host,
3097 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(vha->host, 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 "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(vha->node_name);
3125 fc_host_port_name(vha->host) = wwn_to_u64(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(ha->npiv_info[cnt].port_name, vha->port_name, 8) == 0
3140 && memcmp(ha->npiv_info[cnt].node_name, vha->node_name,
3141 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 "Can't create qpair for VP[%d]\n",
3152 vha->vp_idx);
3153 else {
3154 ql_dbg(ql_dbg_multiq, vha, 0xc001,
3155 "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 "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(vha->host);
3173 return FC_VPORT_FAILED;
3174 }
3175
3176 static int
qla24xx_vport_delete(struct fc_vport * fc_vport)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, &vha->dpc_flags);
3184
3185 while (test_bit(LOOP_RESYNC_ACTIVE, &vha->dpc_flags))
3186 msleep(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 "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(vha->vp_idx, ha->vp_idx_map);
3218 mutex_unlock(&ha->vport_lock);
3219
3220 dma_free_coherent(&ha->pdev->dev, vha->gnl.size, vha->gnl.l,
3221 vha->gnl.ldma);
3222
3223 vha->gnl.l = NULL;
3224
3225 vfree(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 "Queue Pair delete failed.\n");
3231 }
3232
3233 ql_log(ql_log_info, vha, 0x7088, "VP[%d] deleted.\n", id);
3234 scsi_host_put(vha->host);
3235 return 0;
3236 }
3237
3238 static int
qla24xx_vport_disable(struct fc_vport * fc_vport,bool disable)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
qla2x00_get_host_supported_speeds(scsi_qla_host_t * vha,uint speeds)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
qla2x00_init_host_attr(scsi_qla_host_t * vha)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(vha->node_name);
3374 fc_host_port_name(vha->host) = wwn_to_u64(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, fdmi_speed);
3382
3383 fc_host_supported_speeds(vha->host) = speeds;
3384 }
3385
