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 scsi_block_requests(vha->host);
714 if (IS_QLA82XX(ha)) {
715 ha->flags.isp82xx_no_md_cap = 1;
716 qla82xx_idc_lock(ha);
717 qla82xx_set_reset_owner(vha);
718 qla82xx_idc_unlock(ha);
719 } else if (IS_QLA8044(ha)) {
720 qla8044_idc_lock(ha);
721 idc_control = qla8044_rd_reg(ha,
722 QLA8044_IDC_DRV_CTRL);
723 qla8044_wr_reg(ha, QLA8044_IDC_DRV_CTRL,
724 (idc_control | GRACEFUL_RESET_BIT1));
725 qla82xx_set_reset_owner(vha);
726 qla8044_idc_unlock(ha);
727 } else {
728 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
729 qla2xxx_wake_dpc(vha);
730 }
731 qla2x00_wait_for_chip_reset(vha);
732 scsi_unblock_requests(vha->host);
733 break;
734 case 0x2025d:
735 if (!IS_QLA81XX(ha) && !IS_QLA83XX(ha) &&
736 !IS_QLA27XX(ha) && !IS_QLA28XX(ha))
737 return -EPERM;
738
739 ql_log(ql_log_info, vha, 0x706f,
740 "Issuing MPI reset.\n");
741
742 if (IS_QLA83XX(ha)) {
743 uint32_t idc_control;
744
745 qla83xx_idc_lock(vha, 0);
746 __qla83xx_get_idc_control(vha, &idc_control);
747 idc_control |= QLA83XX_IDC_GRACEFUL_RESET;
748 __qla83xx_set_idc_control(vha, idc_control);
749 qla83xx_wr_reg(vha, QLA83XX_IDC_DEV_STATE,
750 QLA8XXX_DEV_NEED_RESET);
751 qla83xx_idc_audit(vha, IDC_AUDIT_TIMESTAMP);
752 qla83xx_idc_unlock(vha, 0);
753 break;
754 } else {
755 /* Make sure FC side is not in reset */
756 WARN_ON_ONCE(qla2x00_wait_for_hba_online(vha) !=
757 QLA_SUCCESS);
758
759 /* Issue MPI reset */
760 scsi_block_requests(vha->host);
761 if (qla81xx_restart_mpi_firmware(vha) != QLA_SUCCESS)
762 ql_log(ql_log_warn, vha, 0x7070,
763 "MPI reset failed.\n");
764 scsi_unblock_requests(vha->host);
765 break;
766 }
767 break;
768 case 0x2025e:
769 if (!IS_P3P_TYPE(ha) || vha != base_vha) {
770 ql_log(ql_log_info, vha, 0x7071,
771 "FCoE ctx reset not supported.\n");
772 return -EPERM;
773 }
774
775 ql_log(ql_log_info, vha, 0x7072,
776 "Issuing FCoE ctx reset.\n");
777 set_bit(FCOE_CTX_RESET_NEEDED, &vha->dpc_flags);
778 qla2xxx_wake_dpc(vha);
779 qla2x00_wait_for_fcoe_ctx_reset(vha);
780 break;
781 case 0x2025f:
782 if (!IS_QLA8031(ha))
783 return -EPERM;
784 ql_log(ql_log_info, vha, 0x70bc,
785 "Disabling Reset by IDC control\n");
786 qla83xx_idc_lock(vha, 0);
787 __qla83xx_get_idc_control(vha, &idc_control);
788 idc_control |= QLA83XX_IDC_RESET_DISABLED;
789 __qla83xx_set_idc_control(vha, idc_control);
790 qla83xx_idc_unlock(vha, 0);
791 break;
792 case 0x20260:
793 if (!IS_QLA8031(ha))
794 return -EPERM;
795 ql_log(ql_log_info, vha, 0x70bd,
796 "Enabling Reset by IDC control\n");
797 qla83xx_idc_lock(vha, 0);
798 __qla83xx_get_idc_control(vha, &idc_control);
799 idc_control &= ~QLA83XX_IDC_RESET_DISABLED;
800 __qla83xx_set_idc_control(vha, idc_control);
801 qla83xx_idc_unlock(vha, 0);
802 break;
803 case 0x20261:
804 ql_dbg(ql_dbg_user, vha, 0x70e0,
805 "Updating cache versions without reset ");
806
807 tmp_data = vmalloc(256);
808 if (!tmp_data) {
809 ql_log(ql_log_warn, vha, 0x70e1,
810 "Unable to allocate memory for VPD information update.\n");
811 return -ENOMEM;
812 }
813 ha->isp_ops->get_flash_version(vha, tmp_data);
814 vfree(tmp_data);
815 break;
816 }
817 return count;
818 }
819
820 static struct bin_attribute sysfs_reset_attr = {
821 .attr = {
822 .name = "reset",
823 .mode = S_IWUSR,
824 },
825 .size = 0,
826 .write = qla2x00_sysfs_write_reset,
827 };
828
829 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)830 qla2x00_issue_logo(struct file *filp, struct kobject *kobj,
831 struct bin_attribute *bin_attr,
832 char *buf, loff_t off, size_t count)
833 {
834 struct scsi_qla_host *vha = shost_priv(dev_to_shost(container_of(kobj,
835 struct device, kobj)));
836 int type;
837 port_id_t did;
838
839 if (!capable(CAP_SYS_ADMIN))
840 return 0;
841
842 if (unlikely(pci_channel_offline(vha->hw->pdev)))
843 return 0;
844
845 if (qla2x00_chip_is_down(vha))
846 return 0;
847
848 type = simple_strtol(buf, NULL, 10);
849
850 did.b.domain = (type & 0x00ff0000) >> 16;
851 did.b.area = (type & 0x0000ff00) >> 8;
852 did.b.al_pa = (type & 0x000000ff);
853
854 ql_log(ql_log_info, vha, 0xd04d, "portid=%02x%02x%02x done\n",
855 did.b.domain, did.b.area, did.b.al_pa);
856
857 ql_log(ql_log_info, vha, 0x70e4, "%s: %d\n", __func__, type);
858
859 qla24xx_els_dcmd_iocb(vha, ELS_DCMD_LOGO, did);
860 return count;
861 }
862
863 static struct bin_attribute sysfs_issue_logo_attr = {
864 .attr = {
865 .name = "issue_logo",
866 .mode = S_IWUSR,
867 },
868 .size = 0,
869 .write = qla2x00_issue_logo,
870 };
871
872 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)873 qla2x00_sysfs_read_xgmac_stats(struct file *filp, struct kobject *kobj,
874 struct bin_attribute *bin_attr,
875 char *buf, loff_t off, size_t count)
876 {
877 struct scsi_qla_host *vha = shost_priv(dev_to_shost(container_of(kobj,
878 struct device, kobj)));
879 struct qla_hw_data *ha = vha->hw;
880 int rval;
881 uint16_t actual_size;
882
883 if (!capable(CAP_SYS_ADMIN) || off != 0 || count > XGMAC_DATA_SIZE)
884 return 0;
885
886 if (unlikely(pci_channel_offline(ha->pdev)))
887 return 0;
888 mutex_lock(&vha->hw->optrom_mutex);
889 if (qla2x00_chip_is_down(vha)) {
890 mutex_unlock(&vha->hw->optrom_mutex);
891 return 0;
892 }
893
894 if (ha->xgmac_data)
895 goto do_read;
896
897 ha->xgmac_data = dma_alloc_coherent(&ha->pdev->dev, XGMAC_DATA_SIZE,
898 &ha->xgmac_data_dma, GFP_KERNEL);
899 if (!ha->xgmac_data) {
900 mutex_unlock(&vha->hw->optrom_mutex);
901 ql_log(ql_log_warn, vha, 0x7076,
902 "Unable to allocate memory for XGMAC read-data.\n");
903 return 0;
904 }
905
906 do_read:
907 actual_size = 0;
908 memset(ha->xgmac_data, 0, XGMAC_DATA_SIZE);
909
910 rval = qla2x00_get_xgmac_stats(vha, ha->xgmac_data_dma,
911 XGMAC_DATA_SIZE, &actual_size);
912
913 mutex_unlock(&vha->hw->optrom_mutex);
914 if (rval != QLA_SUCCESS) {
915 ql_log(ql_log_warn, vha, 0x7077,
916 "Unable to read XGMAC data (%x).\n", rval);
917 count = 0;
918 }
919
920 count = actual_size > count ? count : actual_size;
921 memcpy(buf, ha->xgmac_data, count);
922
923 return count;
924 }
925
926 static struct bin_attribute sysfs_xgmac_stats_attr = {
927 .attr = {
928 .name = "xgmac_stats",
929 .mode = S_IRUSR,
930 },
931 .size = 0,
932 .read = qla2x00_sysfs_read_xgmac_stats,
933 };
934
935 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)936 qla2x00_sysfs_read_dcbx_tlv(struct file *filp, struct kobject *kobj,
937 struct bin_attribute *bin_attr,
938 char *buf, loff_t off, size_t count)
939 {
940 struct scsi_qla_host *vha = shost_priv(dev_to_shost(container_of(kobj,
941 struct device, kobj)));
942 struct qla_hw_data *ha = vha->hw;
943 int rval;
944
945 if (!capable(CAP_SYS_ADMIN) || off != 0 || count > DCBX_TLV_DATA_SIZE)
946 return 0;
947
948 if (ha->dcbx_tlv)
949 goto do_read;
950 mutex_lock(&vha->hw->optrom_mutex);
951 if (qla2x00_chip_is_down(vha)) {
952 mutex_unlock(&vha->hw->optrom_mutex);
953 return 0;
954 }
955
956 ha->dcbx_tlv = dma_alloc_coherent(&ha->pdev->dev, DCBX_TLV_DATA_SIZE,
957 &ha->dcbx_tlv_dma, GFP_KERNEL);
958 if (!ha->dcbx_tlv) {
959 mutex_unlock(&vha->hw->optrom_mutex);
960 ql_log(ql_log_warn, vha, 0x7078,
961 "Unable to allocate memory for DCBX TLV read-data.\n");
962 return -ENOMEM;
963 }
964
965 do_read:
966 memset(ha->dcbx_tlv, 0, DCBX_TLV_DATA_SIZE);
967
968 rval = qla2x00_get_dcbx_params(vha, ha->dcbx_tlv_dma,
969 DCBX_TLV_DATA_SIZE);
970
971 mutex_unlock(&vha->hw->optrom_mutex);
972
973 if (rval != QLA_SUCCESS) {
974 ql_log(ql_log_warn, vha, 0x7079,
975 "Unable to read DCBX TLV (%x).\n", rval);
976 return -EIO;
977 }
978
979 memcpy(buf, ha->dcbx_tlv, count);
980
981 return count;
982 }
983
984 static struct bin_attribute sysfs_dcbx_tlv_attr = {
985 .attr = {
986 .name = "dcbx_tlv",
987 .mode = S_IRUSR,
988 },
989 .size = 0,
990 .read = qla2x00_sysfs_read_dcbx_tlv,
991 };
992
993 static struct sysfs_entry {
994 char *name;
995 struct bin_attribute *attr;
996 int type;
997 } bin_file_entries[] = {
998 { "fw_dump", &sysfs_fw_dump_attr, },
999 { "nvram", &sysfs_nvram_attr, },
1000 { "optrom", &sysfs_optrom_attr, },
1001 { "optrom_ctl", &sysfs_optrom_ctl_attr, },
1002 { "vpd", &sysfs_vpd_attr, 1 },
1003 { "sfp", &sysfs_sfp_attr, 1 },
1004 { "reset", &sysfs_reset_attr, },
1005 { "issue_logo", &sysfs_issue_logo_attr, },
1006 { "xgmac_stats", &sysfs_xgmac_stats_attr, 3 },
1007 { "dcbx_tlv", &sysfs_dcbx_tlv_attr, 3 },
1008 { NULL },
1009 };
1010
1011 void
qla2x00_alloc_sysfs_attr(scsi_qla_host_t * vha)1012 qla2x00_alloc_sysfs_attr(scsi_qla_host_t *vha)
1013 {
1014 struct Scsi_Host *host = vha->host;
1015 struct sysfs_entry *iter;
1016 int ret;
1017
1018 for (iter = bin_file_entries; iter->name; iter++) {
1019 if (iter->type && !IS_FWI2_CAPABLE(vha->hw))
1020 continue;
1021 if (iter->type == 2 && !IS_QLA25XX(vha->hw))
1022 continue;
1023 if (iter->type == 3 && !(IS_CNA_CAPABLE(vha->hw)))
1024 continue;
1025
1026 ret = sysfs_create_bin_file(&host->shost_gendev.kobj,
1027 iter->attr);
1028 if (ret)
1029 ql_log(ql_log_warn, vha, 0x00f3,
1030 "Unable to create sysfs %s binary attribute (%d).\n",
1031 iter->name, ret);
1032 else
1033 ql_dbg(ql_dbg_init, vha, 0x00f4,
1034 "Successfully created sysfs %s binary attribute.\n",
1035 iter->name);
1036 }
1037 }
1038
1039 void
qla2x00_free_sysfs_attr(scsi_qla_host_t * vha,bool stop_beacon)1040 qla2x00_free_sysfs_attr(scsi_qla_host_t *vha, bool stop_beacon)
1041 {
1042 struct Scsi_Host *host = vha->host;
1043 struct sysfs_entry *iter;
1044 struct qla_hw_data *ha = vha->hw;
1045
1046 for (iter = bin_file_entries; iter->name; iter++) {
1047 if (iter->type && !IS_FWI2_CAPABLE(ha))
1048 continue;
1049 if (iter->type == 2 && !IS_QLA25XX(ha))
1050 continue;
1051 if (iter->type == 3 && !(IS_CNA_CAPABLE(ha)))
1052 continue;
1053
1054 sysfs_remove_bin_file(&host->shost_gendev.kobj,
1055 iter->attr);
1056 }
1057
1058 if (stop_beacon && ha->beacon_blink_led == 1)
1059 ha->isp_ops->beacon_off(vha);
1060 }
1061
1062 /* Scsi_Host attributes. */
1063
1064 static ssize_t
qla2x00_driver_version_show(struct device * dev,struct device_attribute * attr,char * buf)1065 qla2x00_driver_version_show(struct device *dev,
1066 struct device_attribute *attr, char *buf)
1067 {
1068 return scnprintf(buf, PAGE_SIZE, "%s\n", qla2x00_version_str);
1069 }
1070
1071 static ssize_t
qla2x00_fw_version_show(struct device * dev,struct device_attribute * attr,char * buf)1072 qla2x00_fw_version_show(struct device *dev,
1073 struct device_attribute *attr, char *buf)
1074 {
1075 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1076 struct qla_hw_data *ha = vha->hw;
1077 char fw_str[128];
1078
1079 return scnprintf(buf, PAGE_SIZE, "%s\n",
1080 ha->isp_ops->fw_version_str(vha, fw_str, sizeof(fw_str)));
1081 }
1082
1083 static ssize_t
qla2x00_serial_num_show(struct device * dev,struct device_attribute * attr,char * buf)1084 qla2x00_serial_num_show(struct device *dev, struct device_attribute *attr,
1085 char *buf)
1086 {
1087 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1088 struct qla_hw_data *ha = vha->hw;
1089 uint32_t sn;
1090
1091 if (IS_QLAFX00(vha->hw)) {
1092 return scnprintf(buf, PAGE_SIZE, "%s\n",
1093 vha->hw->mr.serial_num);
1094 } else if (IS_FWI2_CAPABLE(ha)) {
1095 qla2xxx_get_vpd_field(vha, "SN", buf, PAGE_SIZE - 1);
1096 return strlen(strcat(buf, "\n"));
1097 }
1098
1099 sn = ((ha->serial0 & 0x1f) << 16) | (ha->serial2 << 8) | ha->serial1;
1100 return scnprintf(buf, PAGE_SIZE, "%c%05d\n", 'A' + sn / 100000,
1101 sn % 100000);
1102 }
1103
1104 static ssize_t
qla2x00_isp_name_show(struct device * dev,struct device_attribute * attr,char * buf)1105 qla2x00_isp_name_show(struct device *dev, struct device_attribute *attr,
1106 char *buf)
1107 {
1108 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1109
1110 return scnprintf(buf, PAGE_SIZE, "ISP%04X\n", vha->hw->pdev->device);
1111 }
1112
1113 static ssize_t
qla2x00_isp_id_show(struct device * dev,struct device_attribute * attr,char * buf)1114 qla2x00_isp_id_show(struct device *dev, struct device_attribute *attr,
1115 char *buf)
1116 {
1117 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1118 struct qla_hw_data *ha = vha->hw;
1119
1120 if (IS_QLAFX00(vha->hw))
1121 return scnprintf(buf, PAGE_SIZE, "%s\n",
1122 vha->hw->mr.hw_version);
1123
1124 return scnprintf(buf, PAGE_SIZE, "%04x %04x %04x %04x\n",
1125 ha->product_id[0], ha->product_id[1], ha->product_id[2],
1126 ha->product_id[3]);
1127 }
1128
1129 static ssize_t
qla2x00_model_name_show(struct device * dev,struct device_attribute * attr,char * buf)1130 qla2x00_model_name_show(struct device *dev, struct device_attribute *attr,
1131 char *buf)
1132 {
1133 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1134
1135 return scnprintf(buf, PAGE_SIZE, "%s\n", vha->hw->model_number);
1136 }
1137
1138 static ssize_t
qla2x00_model_desc_show(struct device * dev,struct device_attribute * attr,char * buf)1139 qla2x00_model_desc_show(struct device *dev, struct device_attribute *attr,
1140 char *buf)
1141 {
1142 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1143
1144 return scnprintf(buf, PAGE_SIZE, "%s\n", vha->hw->model_desc);
1145 }
1146
1147 static ssize_t
qla2x00_pci_info_show(struct device * dev,struct device_attribute * attr,char * buf)1148 qla2x00_pci_info_show(struct device *dev, struct device_attribute *attr,
1149 char *buf)
1150 {
1151 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1152 char pci_info[30];
1153
1154 return scnprintf(buf, PAGE_SIZE, "%s\n",
1155 vha->hw->isp_ops->pci_info_str(vha, pci_info,
1156 sizeof(pci_info)));
1157 }
1158
1159 static ssize_t
qla2x00_link_state_show(struct device * dev,struct device_attribute * attr,char * buf)1160 qla2x00_link_state_show(struct device *dev, struct device_attribute *attr,
1161 char *buf)
1162 {
1163 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1164 struct qla_hw_data *ha = vha->hw;
1165 int len = 0;
1166
1167 if (atomic_read(&vha->loop_state) == LOOP_DOWN ||
1168 atomic_read(&vha->loop_state) == LOOP_DEAD ||
1169 vha->device_flags & DFLG_NO_CABLE)
1170 len = scnprintf(buf, PAGE_SIZE, "Link Down\n");
1171 else if (atomic_read(&vha->loop_state) != LOOP_READY ||
1172 qla2x00_chip_is_down(vha))
1173 len = scnprintf(buf, PAGE_SIZE, "Unknown Link State\n");
1174 else {
1175 len = scnprintf(buf, PAGE_SIZE, "Link Up - ");
1176
1177 switch (ha->current_topology) {
1178 case ISP_CFG_NL:
1179 len += scnprintf(buf + len, PAGE_SIZE-len, "Loop\n");
1180 break;
1181 case ISP_CFG_FL:
1182 len += scnprintf(buf + len, PAGE_SIZE-len, "FL_Port\n");
1183 break;
1184 case ISP_CFG_N:
1185 len += scnprintf(buf + len, PAGE_SIZE-len,
1186 "N_Port to N_Port\n");
1187 break;
1188 case ISP_CFG_F:
1189 len += scnprintf(buf + len, PAGE_SIZE-len, "F_Port\n");
1190 break;
1191 default:
1192 len += scnprintf(buf + len, PAGE_SIZE-len, "Loop\n");
1193 break;
1194 }
1195 }
1196 return len;
1197 }
1198
1199 static ssize_t
qla2x00_zio_show(struct device * dev,struct device_attribute * attr,char * buf)1200 qla2x00_zio_show(struct device *dev, struct device_attribute *attr,
1201 char *buf)
1202 {
1203 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1204 int len = 0;
1205
1206 switch (vha->hw->zio_mode) {
1207 case QLA_ZIO_MODE_6:
1208 len += scnprintf(buf + len, PAGE_SIZE-len, "Mode 6\n");
1209 break;
1210 case QLA_ZIO_DISABLED:
1211 len += scnprintf(buf + len, PAGE_SIZE-len, "Disabled\n");
1212 break;
1213 }
1214 return len;
1215 }
1216
1217 static ssize_t
qla2x00_zio_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)1218 qla2x00_zio_store(struct device *dev, struct device_attribute *attr,
1219 const char *buf, size_t count)
1220 {
1221 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1222 struct qla_hw_data *ha = vha->hw;
1223 int val = 0;
1224 uint16_t zio_mode;
1225
1226 if (!IS_ZIO_SUPPORTED(ha))
1227 return -ENOTSUPP;
1228
1229 if (sscanf(buf, "%d", &val) != 1)
1230 return -EINVAL;
1231
1232 if (val)
1233 zio_mode = QLA_ZIO_MODE_6;
1234 else
1235 zio_mode = QLA_ZIO_DISABLED;
1236
1237 /* Update per-hba values and queue a reset. */
1238 if (zio_mode != QLA_ZIO_DISABLED || ha->zio_mode != QLA_ZIO_DISABLED) {
1239 ha->zio_mode = zio_mode;
1240 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
1241 }
1242 return strlen(buf);
1243 }
1244
1245 static ssize_t
qla2x00_zio_timer_show(struct device * dev,struct device_attribute * attr,char * buf)1246 qla2x00_zio_timer_show(struct device *dev, struct device_attribute *attr,
1247 char *buf)
1248 {
1249 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1250
1251 return scnprintf(buf, PAGE_SIZE, "%d us\n", vha->hw->zio_timer * 100);
1252 }
1253
1254 static ssize_t
qla2x00_zio_timer_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)1255 qla2x00_zio_timer_store(struct device *dev, struct device_attribute *attr,
1256 const char *buf, size_t count)
1257 {
1258 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1259 int val = 0;
1260 uint16_t zio_timer;
1261
1262 if (sscanf(buf, "%d", &val) != 1)
1263 return -EINVAL;
1264 if (val > 25500 || val < 100)
1265 return -ERANGE;
1266
1267 zio_timer = (uint16_t)(val / 100);
1268 vha->hw->zio_timer = zio_timer;
1269
1270 return strlen(buf);
1271 }
1272
1273 static ssize_t
qla_zio_threshold_show(struct device * dev,struct device_attribute * attr,char * buf)1274 qla_zio_threshold_show(struct device *dev, struct device_attribute *attr,
1275 char *buf)
1276 {
1277 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1278
1279 return scnprintf(buf, PAGE_SIZE, "%d exchanges\n",
1280 vha->hw->last_zio_threshold);
1281 }
1282
1283 static ssize_t
qla_zio_threshold_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)1284 qla_zio_threshold_store(struct device *dev, struct device_attribute *attr,
1285 const char *buf, size_t count)
1286 {
1287 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1288 int val = 0;
1289
1290 if (vha->hw->zio_mode != QLA_ZIO_MODE_6)
1291 return -EINVAL;
1292 if (sscanf(buf, "%d", &val) != 1)
1293 return -EINVAL;
1294 if (val < 0 || val > 256)
1295 return -ERANGE;
1296
1297 atomic_set(&vha->hw->zio_threshold, val);
1298 return strlen(buf);
1299 }
1300
1301 static ssize_t
qla2x00_beacon_show(struct device * dev,struct device_attribute * attr,char * buf)1302 qla2x00_beacon_show(struct device *dev, struct device_attribute *attr,
1303 char *buf)
1304 {
1305 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1306 int len = 0;
1307
1308 if (vha->hw->beacon_blink_led)
1309 len += scnprintf(buf + len, PAGE_SIZE-len, "Enabled\n");
1310 else
1311 len += scnprintf(buf + len, PAGE_SIZE-len, "Disabled\n");
1312 return len;
1313 }
1314
1315 static ssize_t
qla2x00_beacon_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)1316 qla2x00_beacon_store(struct device *dev, struct device_attribute *attr,
1317 const char *buf, size_t count)
1318 {
1319 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1320 struct qla_hw_data *ha = vha->hw;
1321 int val = 0;
1322 int rval;
1323
1324 if (IS_QLA2100(ha) || IS_QLA2200(ha))
1325 return -EPERM;
1326
1327 if (sscanf(buf, "%d", &val) != 1)
1328 return -EINVAL;
1329
1330 mutex_lock(&vha->hw->optrom_mutex);
1331 if (qla2x00_chip_is_down(vha)) {
1332 mutex_unlock(&vha->hw->optrom_mutex);
1333 ql_log(ql_log_warn, vha, 0x707a,
1334 "Abort ISP active -- ignoring beacon request.\n");
1335 return -EBUSY;
1336 }
1337
1338 if (val)
1339 rval = ha->isp_ops->beacon_on(vha);
1340 else
1341 rval = ha->isp_ops->beacon_off(vha);
1342
1343 if (rval != QLA_SUCCESS)
1344 count = 0;
1345
1346 mutex_unlock(&vha->hw->optrom_mutex);
1347
1348 return count;
1349 }
1350
1351 static ssize_t
qla2x00_beacon_config_show(struct device * dev,struct device_attribute * attr,char * buf)1352 qla2x00_beacon_config_show(struct device *dev, struct device_attribute *attr,
1353 char *buf)
1354 {
1355 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1356 struct qla_hw_data *ha = vha->hw;
1357 uint16_t led[3] = { 0 };
1358
1359 if (!IS_QLA2031(ha) && !IS_QLA27XX(ha) && !IS_QLA28XX(ha))
1360 return -EPERM;
1361
1362 if (ql26xx_led_config(vha, 0, led))
1363 return scnprintf(buf, PAGE_SIZE, "\n");
1364
1365 return scnprintf(buf, PAGE_SIZE, "%#04hx %#04hx %#04hx\n",
1366 led[0], led[1], led[2]);
1367 }
1368
1369 static ssize_t
qla2x00_beacon_config_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)1370 qla2x00_beacon_config_store(struct device *dev, struct device_attribute *attr,
1371 const char *buf, size_t count)
1372 {
1373 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1374 struct qla_hw_data *ha = vha->hw;
1375 uint16_t options = BIT_0;
1376 uint16_t led[3] = { 0 };
1377 uint16_t word[4];
1378 int n;
1379
1380 if (!IS_QLA2031(ha) && !IS_QLA27XX(ha) && !IS_QLA28XX(ha))
1381 return -EPERM;
1382
1383 n = sscanf(buf, "%hx %hx %hx %hx", word+0, word+1, word+2, word+3);
1384 if (n == 4) {
1385 if (word[0] == 3) {
1386 options |= BIT_3|BIT_2|BIT_1;
1387 led[0] = word[1];
1388 led[1] = word[2];
1389 led[2] = word[3];
1390 goto write;
1391 }
1392 return -EINVAL;
1393 }
1394
1395 if (n == 2) {
1396 /* check led index */
1397 if (word[0] == 0) {
1398 options |= BIT_2;
1399 led[0] = word[1];
1400 goto write;
1401 }
1402 if (word[0] == 1) {
1403 options |= BIT_3;
1404 led[1] = word[1];
1405 goto write;
1406 }
1407 if (word[0] == 2) {
1408 options |= BIT_1;
1409 led[2] = word[1];
1410 goto write;
1411 }
1412 return -EINVAL;
1413 }
1414
1415 return -EINVAL;
1416
1417 write:
1418 if (ql26xx_led_config(vha, options, led))
1419 return -EFAULT;
1420
1421 return count;
1422 }
1423
1424 static ssize_t
qla2x00_optrom_bios_version_show(struct device * dev,struct device_attribute * attr,char * buf)1425 qla2x00_optrom_bios_version_show(struct device *dev,
1426 struct device_attribute *attr, char *buf)
1427 {
1428 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1429 struct qla_hw_data *ha = vha->hw;
1430
1431 return scnprintf(buf, PAGE_SIZE, "%d.%02d\n", ha->bios_revision[1],
1432 ha->bios_revision[0]);
1433 }
1434
1435 static ssize_t
qla2x00_optrom_efi_version_show(struct device * dev,struct device_attribute * attr,char * buf)1436 qla2x00_optrom_efi_version_show(struct device *dev,
1437 struct device_attribute *attr, char *buf)
1438 {
1439 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1440 struct qla_hw_data *ha = vha->hw;
1441
1442 return scnprintf(buf, PAGE_SIZE, "%d.%02d\n", ha->efi_revision[1],
1443 ha->efi_revision[0]);
1444 }
1445
1446 static ssize_t
qla2x00_optrom_fcode_version_show(struct device * dev,struct device_attribute * attr,char * buf)1447 qla2x00_optrom_fcode_version_show(struct device *dev,
1448 struct device_attribute *attr, char *buf)
1449 {
1450 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1451 struct qla_hw_data *ha = vha->hw;
1452
1453 return scnprintf(buf, PAGE_SIZE, "%d.%02d\n", ha->fcode_revision[1],
1454 ha->fcode_revision[0]);
1455 }
1456
1457 static ssize_t
qla2x00_optrom_fw_version_show(struct device * dev,struct device_attribute * attr,char * buf)1458 qla2x00_optrom_fw_version_show(struct device *dev,
1459 struct device_attribute *attr, char *buf)
1460 {
1461 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1462 struct qla_hw_data *ha = vha->hw;
1463
1464 return scnprintf(buf, PAGE_SIZE, "%d.%02d.%02d %d\n",
1465 ha->fw_revision[0], ha->fw_revision[1], ha->fw_revision[2],
1466 ha->fw_revision[3]);
1467 }
1468
1469 static ssize_t
qla2x00_optrom_gold_fw_version_show(struct device * dev,struct device_attribute * attr,char * buf)1470 qla2x00_optrom_gold_fw_version_show(struct device *dev,
1471 struct device_attribute *attr, char *buf)
1472 {
1473 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1474 struct qla_hw_data *ha = vha->hw;
1475
1476 if (!IS_QLA81XX(ha) && !IS_QLA83XX(ha) &&
1477 !IS_QLA27XX(ha) && !IS_QLA28XX(ha))
1478 return scnprintf(buf, PAGE_SIZE, "\n");
1479
1480 return scnprintf(buf, PAGE_SIZE, "%d.%02d.%02d (%d)\n",
1481 ha->gold_fw_version[0], ha->gold_fw_version[1],
1482 ha->gold_fw_version[2], ha->gold_fw_version[3]);
1483 }
1484
1485 static ssize_t
qla2x00_total_isp_aborts_show(struct device * dev,struct device_attribute * attr,char * buf)1486 qla2x00_total_isp_aborts_show(struct device *dev,
1487 struct device_attribute *attr, char *buf)
1488 {
1489 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1490
1491 return scnprintf(buf, PAGE_SIZE, "%d\n",
1492 vha->qla_stats.total_isp_aborts);
1493 }
1494
1495 static ssize_t
qla24xx_84xx_fw_version_show(struct device * dev,struct device_attribute * attr,char * buf)1496 qla24xx_84xx_fw_version_show(struct device *dev,
1497 struct device_attribute *attr, char *buf)
1498 {
1499 int rval = QLA_SUCCESS;
1500 uint16_t status[2] = { 0 };
1501 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1502 struct qla_hw_data *ha = vha->hw;
1503
1504 if (!IS_QLA84XX(ha))
1505 return scnprintf(buf, PAGE_SIZE, "\n");
1506
1507 if (!ha->cs84xx->op_fw_version) {
1508 rval = qla84xx_verify_chip(vha, status);
1509
1510 if (!rval && !status[0])
1511 return scnprintf(buf, PAGE_SIZE, "%u\n",
1512 (uint32_t)ha->cs84xx->op_fw_version);
1513 }
1514
1515 return scnprintf(buf, PAGE_SIZE, "\n");
1516 }
1517
1518 static ssize_t
qla2x00_serdes_version_show(struct device * dev,struct device_attribute * attr,char * buf)1519 qla2x00_serdes_version_show(struct device *dev, struct device_attribute *attr,
1520 char *buf)
1521 {
1522 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1523 struct qla_hw_data *ha = vha->hw;
1524
1525 if (!IS_QLA27XX(ha) && !IS_QLA28XX(ha))
1526 return scnprintf(buf, PAGE_SIZE, "\n");
1527
1528 return scnprintf(buf, PAGE_SIZE, "%d.%02d.%02d\n",
1529 ha->serdes_version[0], ha->serdes_version[1],
1530 ha->serdes_version[2]);
1531 }
1532
1533 static ssize_t
qla2x00_mpi_version_show(struct device * dev,struct device_attribute * attr,char * buf)1534 qla2x00_mpi_version_show(struct device *dev, struct device_attribute *attr,
1535 char *buf)
1536 {
1537 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1538 struct qla_hw_data *ha = vha->hw;
1539
1540 if (!IS_QLA81XX(ha) && !IS_QLA8031(ha) && !IS_QLA8044(ha) &&
1541 !IS_QLA27XX(ha) && !IS_QLA28XX(ha))
1542 return scnprintf(buf, PAGE_SIZE, "\n");
1543
1544 return scnprintf(buf, PAGE_SIZE, "%d.%02d.%02d (%x)\n",
1545 ha->mpi_version[0], ha->mpi_version[1], ha->mpi_version[2],
1546 ha->mpi_capabilities);
1547 }
1548
1549 static ssize_t
qla2x00_phy_version_show(struct device * dev,struct device_attribute * attr,char * buf)1550 qla2x00_phy_version_show(struct device *dev, struct device_attribute *attr,
1551 char *buf)
1552 {
1553 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1554 struct qla_hw_data *ha = vha->hw;
1555
1556 if (!IS_QLA81XX(ha) && !IS_QLA8031(ha))
1557 return scnprintf(buf, PAGE_SIZE, "\n");
1558
1559 return scnprintf(buf, PAGE_SIZE, "%d.%02d.%02d\n",
1560 ha->phy_version[0], ha->phy_version[1], ha->phy_version[2]);
1561 }
1562
1563 static ssize_t
qla2x00_flash_block_size_show(struct device * dev,struct device_attribute * attr,char * buf)1564 qla2x00_flash_block_size_show(struct device *dev,
1565 struct device_attribute *attr, char *buf)
1566 {
1567 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1568 struct qla_hw_data *ha = vha->hw;
1569
1570 return scnprintf(buf, PAGE_SIZE, "0x%x\n", ha->fdt_block_size);
1571 }
1572
1573 static ssize_t
qla2x00_vlan_id_show(struct device * dev,struct device_attribute * attr,char * buf)1574 qla2x00_vlan_id_show(struct device *dev, struct device_attribute *attr,
1575 char *buf)
1576 {
1577 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1578
1579 if (!IS_CNA_CAPABLE(vha->hw))
1580 return scnprintf(buf, PAGE_SIZE, "\n");
1581
1582 return scnprintf(buf, PAGE_SIZE, "%d\n", vha->fcoe_vlan_id);
1583 }
1584
1585 static ssize_t
qla2x00_vn_port_mac_address_show(struct device * dev,struct device_attribute * attr,char * buf)1586 qla2x00_vn_port_mac_address_show(struct device *dev,
1587 struct device_attribute *attr, char *buf)
1588 {
1589 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1590
1591 if (!IS_CNA_CAPABLE(vha->hw))
1592 return scnprintf(buf, PAGE_SIZE, "\n");
1593
1594 return scnprintf(buf, PAGE_SIZE, "%pMR\n", vha->fcoe_vn_port_mac);
1595 }
1596
1597 static ssize_t
qla2x00_fabric_param_show(struct device * dev,struct device_attribute * attr,char * buf)1598 qla2x00_fabric_param_show(struct device *dev, struct device_attribute *attr,
1599 char *buf)
1600 {
1601 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1602
1603 return scnprintf(buf, PAGE_SIZE, "%d\n", vha->hw->switch_cap);
1604 }
1605
1606 static ssize_t
qla2x00_thermal_temp_show(struct device * dev,struct device_attribute * attr,char * buf)1607 qla2x00_thermal_temp_show(struct device *dev,
1608 struct device_attribute *attr, char *buf)
1609 {
1610 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1611 uint16_t temp = 0;
1612 int rc;
1613
1614 mutex_lock(&vha->hw->optrom_mutex);
1615 if (qla2x00_chip_is_down(vha)) {
1616 mutex_unlock(&vha->hw->optrom_mutex);
1617 ql_log(ql_log_warn, vha, 0x70dc, "ISP reset active.\n");
1618 goto done;
1619 }
1620
1621 if (vha->hw->flags.eeh_busy) {
1622 mutex_unlock(&vha->hw->optrom_mutex);
1623 ql_log(ql_log_warn, vha, 0x70dd, "PCI EEH busy.\n");
1624 goto done;
1625 }
1626
1627 rc = qla2x00_get_thermal_temp(vha, &temp);
1628 mutex_unlock(&vha->hw->optrom_mutex);
1629 if (rc == QLA_SUCCESS)
1630 return scnprintf(buf, PAGE_SIZE, "%d\n", temp);
1631
1632 done:
1633 return scnprintf(buf, PAGE_SIZE, "\n");
1634 }
1635
1636 static ssize_t
qla2x00_fw_state_show(struct device * dev,struct device_attribute * attr,char * buf)1637 qla2x00_fw_state_show(struct device *dev, struct device_attribute *attr,
1638 char *buf)
1639 {
1640 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1641 int rval = QLA_FUNCTION_FAILED;
1642 uint16_t state[6];
1643 uint32_t pstate;
1644
1645 if (IS_QLAFX00(vha->hw)) {
1646 pstate = qlafx00_fw_state_show(dev, attr, buf);
1647 return scnprintf(buf, PAGE_SIZE, "0x%x\n", pstate);
1648 }
1649
1650 mutex_lock(&vha->hw->optrom_mutex);
1651 if (qla2x00_chip_is_down(vha)) {
1652 mutex_unlock(&vha->hw->optrom_mutex);
1653 ql_log(ql_log_warn, vha, 0x707c,
1654 "ISP reset active.\n");
1655 goto out;
1656 } else if (vha->hw->flags.eeh_busy) {
1657 mutex_unlock(&vha->hw->optrom_mutex);
1658 goto out;
1659 }
1660
1661 rval = qla2x00_get_firmware_state(vha, state);
1662 mutex_unlock(&vha->hw->optrom_mutex);
1663 out:
1664 if (rval != QLA_SUCCESS) {
1665 memset(state, -1, sizeof(state));
1666 rval = qla2x00_get_firmware_state(vha, state);
1667 }
1668
1669 return scnprintf(buf, PAGE_SIZE, "0x%x 0x%x 0x%x 0x%x 0x%x 0x%x\n",
1670 state[0], state[1], state[2], state[3], state[4], state[5]);
1671 }
1672
1673 static ssize_t
qla2x00_diag_requests_show(struct device * dev,struct device_attribute * attr,char * buf)1674 qla2x00_diag_requests_show(struct device *dev,
1675 struct device_attribute *attr, char *buf)
1676 {
1677 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1678
1679 if (!IS_BIDI_CAPABLE(vha->hw))
1680 return scnprintf(buf, PAGE_SIZE, "\n");
1681
1682 return scnprintf(buf, PAGE_SIZE, "%llu\n", vha->bidi_stats.io_count);
1683 }
1684
1685 static ssize_t
qla2x00_diag_megabytes_show(struct device * dev,struct device_attribute * attr,char * buf)1686 qla2x00_diag_megabytes_show(struct device *dev,
1687 struct device_attribute *attr, char *buf)
1688 {
1689 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1690
1691 if (!IS_BIDI_CAPABLE(vha->hw))
1692 return scnprintf(buf, PAGE_SIZE, "\n");
1693
1694 return scnprintf(buf, PAGE_SIZE, "%llu\n",
1695 vha->bidi_stats.transfer_bytes >> 20);
1696 }
1697
1698 static ssize_t
qla2x00_fw_dump_size_show(struct device * dev,struct device_attribute * attr,char * buf)1699 qla2x00_fw_dump_size_show(struct device *dev, struct device_attribute *attr,
1700 char *buf)
1701 {
1702 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1703 struct qla_hw_data *ha = vha->hw;
1704 uint32_t size;
1705
1706 if (!ha->fw_dumped)
1707 size = 0;
1708 else if (IS_P3P_TYPE(ha))
1709 size = ha->md_template_size + ha->md_dump_size;
1710 else
1711 size = ha->fw_dump_len;
1712
1713 return scnprintf(buf, PAGE_SIZE, "%d\n", size);
1714 }
1715
1716 static ssize_t
qla2x00_allow_cna_fw_dump_show(struct device * dev,struct device_attribute * attr,char * buf)1717 qla2x00_allow_cna_fw_dump_show(struct device *dev,
1718 struct device_attribute *attr, char *buf)
1719 {
1720 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1721
1722 if (!IS_P3P_TYPE(vha->hw))
1723 return scnprintf(buf, PAGE_SIZE, "\n");
1724 else
1725 return scnprintf(buf, PAGE_SIZE, "%s\n",
1726 vha->hw->allow_cna_fw_dump ? "true" : "false");
1727 }
1728
1729 static ssize_t
qla2x00_allow_cna_fw_dump_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)1730 qla2x00_allow_cna_fw_dump_store(struct device *dev,
1731 struct device_attribute *attr, const char *buf, size_t count)
1732 {
1733 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1734 int val = 0;
1735
1736 if (!IS_P3P_TYPE(vha->hw))
1737 return -EINVAL;
1738
1739 if (sscanf(buf, "%d", &val) != 1)
1740 return -EINVAL;
1741
1742 vha->hw->allow_cna_fw_dump = val != 0;
1743
1744 return strlen(buf);
1745 }
1746
1747 static ssize_t
qla2x00_pep_version_show(struct device * dev,struct device_attribute * attr,char * buf)1748 qla2x00_pep_version_show(struct device *dev, struct device_attribute *attr,
1749 char *buf)
1750 {
1751 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1752 struct qla_hw_data *ha = vha->hw;
1753
1754 if (!IS_QLA27XX(ha) && !IS_QLA28XX(ha))
1755 return scnprintf(buf, PAGE_SIZE, "\n");
1756
1757 return scnprintf(buf, PAGE_SIZE, "%d.%02d.%02d\n",
1758 ha->pep_version[0], ha->pep_version[1], ha->pep_version[2]);
1759 }
1760
1761 static ssize_t
qla2x00_min_supported_speed_show(struct device * dev,struct device_attribute * attr,char * buf)1762 qla2x00_min_supported_speed_show(struct device *dev,
1763 struct device_attribute *attr, char *buf)
1764 {
1765 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1766 struct qla_hw_data *ha = vha->hw;
1767
1768 if (!IS_QLA27XX(ha) && !IS_QLA28XX(ha))
1769 return scnprintf(buf, PAGE_SIZE, "\n");
1770
1771 return scnprintf(buf, PAGE_SIZE, "%s\n",
1772 ha->min_supported_speed == 6 ? "64Gps" :
1773 ha->min_supported_speed == 5 ? "32Gps" :
1774 ha->min_supported_speed == 4 ? "16Gps" :
1775 ha->min_supported_speed == 3 ? "8Gps" :
1776 ha->min_supported_speed == 2 ? "4Gps" :
1777 ha->min_supported_speed != 0 ? "unknown" : "");
1778 }
1779
1780 static ssize_t
qla2x00_max_supported_speed_show(struct device * dev,struct device_attribute * attr,char * buf)1781 qla2x00_max_supported_speed_show(struct device *dev,
1782 struct device_attribute *attr, char *buf)
1783 {
1784 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1785 struct qla_hw_data *ha = vha->hw;
1786
1787 if (!IS_QLA27XX(ha) && !IS_QLA28XX(ha))
1788 return scnprintf(buf, PAGE_SIZE, "\n");
1789
1790 return scnprintf(buf, PAGE_SIZE, "%s\n",
1791 ha->max_supported_speed == 2 ? "64Gps" :
1792 ha->max_supported_speed == 1 ? "32Gps" :
1793 ha->max_supported_speed == 0 ? "16Gps" : "unknown");
1794 }
1795
1796 static ssize_t
qla2x00_port_speed_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)1797 qla2x00_port_speed_store(struct device *dev, struct device_attribute *attr,
1798 const char *buf, size_t count)
1799 {
1800 struct scsi_qla_host *vha = shost_priv(dev_to_shost(dev));
1801 ulong type, speed;
1802 int oldspeed, rval;
1803 int mode = QLA_SET_DATA_RATE_LR;
1804 struct qla_hw_data *ha = vha->hw;
1805
1806 if (!IS_QLA27XX(ha) && !IS_QLA28XX(ha)) {
1807 ql_log(ql_log_warn, vha, 0x70d8,
1808 "Speed setting not supported \n");
1809 return -EINVAL;
1810 }
1811
1812 rval = kstrtol(buf, 10, &type);
1813 if (rval)
1814 return rval;
1815 speed = type;
1816 if (type == 40 || type == 80 || type == 160 ||
1817 type == 320) {
1818 ql_dbg(ql_dbg_user, vha, 0x70d9,
1819 "Setting will be affected after a loss of sync\n");
1820 type = type/10;
1821 mode = QLA_SET_DATA_RATE_NOLR;
1822 }
1823
1824 oldspeed = ha->set_data_rate;
1825
1826 switch (type) {
1827 case 0:
1828 ha->set_data_rate = PORT_SPEED_AUTO;
1829 break;
1830 case 4:
1831 ha->set_data_rate = PORT_SPEED_4GB;
1832 break;
1833 case 8:
1834 ha->set_data_rate = PORT_SPEED_8GB;
1835 break;
1836 case 16:
1837 ha->set_data_rate = PORT_SPEED_16GB;
1838 break;
1839 case 32:
1840 ha->set_data_rate = PORT_SPEED_32GB;
1841 break;
1842 default:
1843 ql_log(ql_log_warn, vha, 0x1199,
1844 "Unrecognized speed setting:%lx. Setting Autoneg\n",
1845 speed);
1846 ha->set_data_rate = PORT_SPEED_AUTO;
1847 }
1848
1849 if (qla2x00_chip_is_down(vha) || (oldspeed == ha->set_data_rate))
1850 return -EINVAL;
1851
1852 ql_log(ql_log_info, vha, 0x70da,
1853 "Setting speed to %lx Gbps \n", type);
1854
1855 rval = qla2x00_set_data_rate(vha, mode);
1856 if (rval != QLA_SUCCESS)
1857 return -EIO;
1858
1859 return strlen(buf);
1860 }
1861
1862 static const struct {
1863 u16 rate;
1864 char *str;
1865 } port_speed_str[] = {
1866 { PORT_SPEED_4GB, "4" },
1867 { PORT_SPEED_8GB, "8" },
1868 { PORT_SPEED_16GB, "16" },
1869 { PORT_SPEED_32GB, "32" },
1870 { PORT_SPEED_64GB, "64" },
1871 { PORT_SPEED_10GB, "10" },
1872 };
1873
1874 static ssize_t
qla2x00_port_speed_show(struct device * dev,struct device_attribute * attr,char * buf)1875 qla2x00_port_speed_show(struct device *dev, struct device_attribute *attr,
1876 char *buf)
1877 {
1878 struct scsi_qla_host *vha = shost_priv(dev_to_shost(dev));
1879 struct qla_hw_data *ha = vha->hw;
1880 ssize_t rval;
1881 u16 i;
1882 char *speed = "Unknown";
1883
1884 rval = qla2x00_get_data_rate(vha);
1885 if (rval != QLA_SUCCESS) {
1886 ql_log(ql_log_warn, vha, 0x70db,
1887 "Unable to get port speed rval:%zd\n", rval);
1888 return -EINVAL;
1889 }
1890
1891 for (i = 0; i < ARRAY_SIZE(port_speed_str); i++) {
1892 if (port_speed_str[i].rate != ha->link_data_rate)
1893 continue;
1894 speed = port_speed_str[i].str;
1895 break;
1896 }
1897
1898 return scnprintf(buf, PAGE_SIZE, "%s\n", speed);
1899 }
1900
1901 /* ----- */
1902
1903 static ssize_t
qlini_mode_show(struct device * dev,struct device_attribute * attr,char * buf)1904 qlini_mode_show(struct device *dev, struct device_attribute *attr, char *buf)
1905 {
1906 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1907 int len = 0;
1908
1909 len += scnprintf(buf + len, PAGE_SIZE-len,
1910 "Supported options: enabled | disabled | dual | exclusive\n");
1911
1912 /* --- */
1913 len += scnprintf(buf + len, PAGE_SIZE-len, "Current selection: ");
1914
1915 switch (vha->qlini_mode) {
1916 case QLA2XXX_INI_MODE_EXCLUSIVE:
1917 len += scnprintf(buf + len, PAGE_SIZE-len,
1918 QLA2XXX_INI_MODE_STR_EXCLUSIVE);
1919 break;
1920 case QLA2XXX_INI_MODE_DISABLED:
1921 len += scnprintf(buf + len, PAGE_SIZE-len,
1922 QLA2XXX_INI_MODE_STR_DISABLED);
1923 break;
1924 case QLA2XXX_INI_MODE_ENABLED:
1925 len += scnprintf(buf + len, PAGE_SIZE-len,
1926 QLA2XXX_INI_MODE_STR_ENABLED);
1927 break;
1928 case QLA2XXX_INI_MODE_DUAL:
1929 len += scnprintf(buf + len, PAGE_SIZE-len,
1930 QLA2XXX_INI_MODE_STR_DUAL);
1931 break;
1932 }
1933 len += scnprintf(buf + len, PAGE_SIZE-len, "\n");
1934
1935 return len;
1936 }
1937
1938 static char *mode_to_str[] = {
1939 "exclusive",
1940 "disabled",
1941 "enabled",
1942 "dual",
1943 };
1944
1945 #define NEED_EXCH_OFFLOAD(_exchg) ((_exchg) > FW_DEF_EXCHANGES_CNT)
qla_set_ini_mode(scsi_qla_host_t * vha,int op)1946 static void qla_set_ini_mode(scsi_qla_host_t *vha, int op)
1947 {
1948 enum {
1949 NO_ACTION,
1950 MODE_CHANGE_ACCEPT,
1951 MODE_CHANGE_NO_ACTION,
1952 TARGET_STILL_ACTIVE,
1953 };
1954 int action = NO_ACTION;
1955 int set_mode = 0;
1956 u8 eo_toggle = 0; /* exchange offload flipped */
1957
1958 switch (vha->qlini_mode) {
1959 case QLA2XXX_INI_MODE_DISABLED:
1960 switch (op) {
1961 case QLA2XXX_INI_MODE_DISABLED:
1962 if (qla_tgt_mode_enabled(vha)) {
1963 if (NEED_EXCH_OFFLOAD(vha->u_ql2xexchoffld) !=
1964 vha->hw->flags.exchoffld_enabled)
1965 eo_toggle = 1;
1966 if (((vha->ql2xexchoffld !=
1967 vha->u_ql2xexchoffld) &&
1968 NEED_EXCH_OFFLOAD(vha->u_ql2xexchoffld)) ||
1969 eo_toggle) {
1970 /*
1971 * The number of exchange to be offload
1972 * was tweaked or offload option was
1973 * flipped
1974 */
1975 action = MODE_CHANGE_ACCEPT;
1976 } else {
1977 action = MODE_CHANGE_NO_ACTION;
1978 }
1979 } else {
1980 action = MODE_CHANGE_NO_ACTION;
1981 }
1982 break;
1983 case QLA2XXX_INI_MODE_EXCLUSIVE:
1984 if (qla_tgt_mode_enabled(vha)) {
1985 if (NEED_EXCH_OFFLOAD(vha->u_ql2xexchoffld) !=
1986 vha->hw->flags.exchoffld_enabled)
1987 eo_toggle = 1;
1988 if (((vha->ql2xexchoffld !=
1989 vha->u_ql2xexchoffld) &&
1990 NEED_EXCH_OFFLOAD(vha->u_ql2xexchoffld)) ||
1991 eo_toggle) {
1992 /*
1993 * The number of exchange to be offload
1994 * was tweaked or offload option was
1995 * flipped
1996 */
1997 action = MODE_CHANGE_ACCEPT;
1998 } else {
1999 action = MODE_CHANGE_NO_ACTION;
2000 }
2001 } else {
2002 action = MODE_CHANGE_ACCEPT;
2003 }
2004 break;
2005 case QLA2XXX_INI_MODE_DUAL:
2006 action = MODE_CHANGE_ACCEPT;
2007 /* active_mode is target only, reset it to dual */
2008 if (qla_tgt_mode_enabled(vha)) {
2009 set_mode = 1;
2010 action = MODE_CHANGE_ACCEPT;
2011 } else {
2012 action = MODE_CHANGE_NO_ACTION;
2013 }
2014 break;
2015
2016 case QLA2XXX_INI_MODE_ENABLED:
2017 if (qla_tgt_mode_enabled(vha))
2018 action = TARGET_STILL_ACTIVE;
2019 else {
2020 action = MODE_CHANGE_ACCEPT;
2021 set_mode = 1;
2022 }
2023 break;
2024 }
2025 break;
2026
2027 case QLA2XXX_INI_MODE_EXCLUSIVE:
2028 switch (op) {
2029 case QLA2XXX_INI_MODE_EXCLUSIVE:
2030 if (qla_tgt_mode_enabled(vha)) {
2031 if (NEED_EXCH_OFFLOAD(vha->u_ql2xexchoffld) !=
2032 vha->hw->flags.exchoffld_enabled)
2033 eo_toggle = 1;
2034 if (((vha->ql2xexchoffld !=
2035 vha->u_ql2xexchoffld) &&
2036 NEED_EXCH_OFFLOAD(vha->u_ql2xexchoffld)) ||
2037 eo_toggle)
2038 /*
2039 * The number of exchange to be offload
2040 * was tweaked or offload option was
2041 * flipped
2042 */
2043 action = MODE_CHANGE_ACCEPT;
2044 else
2045 action = NO_ACTION;
2046 } else
2047 action = NO_ACTION;
2048
2049 break;
2050
2051 case QLA2XXX_INI_MODE_DISABLED:
2052 if (qla_tgt_mode_enabled(vha)) {
2053 if (NEED_EXCH_OFFLOAD(vha->u_ql2xexchoffld) !=
2054 vha->hw->flags.exchoffld_enabled)
2055 eo_toggle = 1;
2056 if (((vha->ql2xexchoffld !=
2057 vha->u_ql2xexchoffld) &&
2058 NEED_EXCH_OFFLOAD(vha->u_ql2xexchoffld)) ||
2059 eo_toggle)
2060 action = MODE_CHANGE_ACCEPT;
2061 else
2062 action = MODE_CHANGE_NO_ACTION;
2063 } else
2064 action = MODE_CHANGE_NO_ACTION;
2065 break;
2066
2067 case QLA2XXX_INI_MODE_DUAL: /* exclusive -> dual */
2068 if (qla_tgt_mode_enabled(vha)) {
2069 action = MODE_CHANGE_ACCEPT;
2070 set_mode = 1;
2071 } else
2072 action = MODE_CHANGE_ACCEPT;
2073 break;
2074
2075 case QLA2XXX_INI_MODE_ENABLED:
2076 if (qla_tgt_mode_enabled(vha))
2077 action = TARGET_STILL_ACTIVE;
2078 else {
2079 if (vha->hw->flags.fw_started)
2080 action = MODE_CHANGE_NO_ACTION;
2081 else
2082 action = MODE_CHANGE_ACCEPT;
2083 }
2084 break;
2085 }
2086 break;
2087
2088 case QLA2XXX_INI_MODE_ENABLED:
2089 switch (op) {
2090 case QLA2XXX_INI_MODE_ENABLED:
2091 if (NEED_EXCH_OFFLOAD(vha->u_ql2xiniexchg) !=
2092 vha->hw->flags.exchoffld_enabled)
2093 eo_toggle = 1;
2094 if (((vha->ql2xiniexchg != vha->u_ql2xiniexchg) &&
2095 NEED_EXCH_OFFLOAD(vha->u_ql2xiniexchg)) ||
2096 eo_toggle)
2097 action = MODE_CHANGE_ACCEPT;
2098 else
2099 action = NO_ACTION;
2100 break;
2101 case QLA2XXX_INI_MODE_DUAL:
2102 case QLA2XXX_INI_MODE_DISABLED:
2103 action = MODE_CHANGE_ACCEPT;
2104 break;
2105 default:
2106 action = MODE_CHANGE_NO_ACTION;
2107 break;
2108 }
2109 break;
2110
2111 case QLA2XXX_INI_MODE_DUAL:
2112 switch (op) {
2113 case QLA2XXX_INI_MODE_DUAL:
2114 if (qla_tgt_mode_enabled(vha) ||
2115 qla_dual_mode_enabled(vha)) {
2116 if (NEED_EXCH_OFFLOAD(vha->u_ql2xexchoffld +
2117 vha->u_ql2xiniexchg) !=
2118 vha->hw->flags.exchoffld_enabled)
2119 eo_toggle = 1;
2120
2121 if ((((vha->ql2xexchoffld +
2122 vha->ql2xiniexchg) !=
2123 (vha->u_ql2xiniexchg +
2124 vha->u_ql2xexchoffld)) &&
2125 NEED_EXCH_OFFLOAD(vha->u_ql2xiniexchg +
2126 vha->u_ql2xexchoffld)) || eo_toggle)
2127 action = MODE_CHANGE_ACCEPT;
2128 else
2129 action = NO_ACTION;
2130 } else {
2131 if (NEED_EXCH_OFFLOAD(vha->u_ql2xexchoffld +
2132 vha->u_ql2xiniexchg) !=
2133 vha->hw->flags.exchoffld_enabled)
2134 eo_toggle = 1;
2135
2136 if ((((vha->ql2xexchoffld + vha->ql2xiniexchg)
2137 != (vha->u_ql2xiniexchg +
2138 vha->u_ql2xexchoffld)) &&
2139 NEED_EXCH_OFFLOAD(vha->u_ql2xiniexchg +
2140 vha->u_ql2xexchoffld)) || eo_toggle)
2141 action = MODE_CHANGE_NO_ACTION;
2142 else
2143 action = NO_ACTION;
2144 }
2145 break;
2146
2147 case QLA2XXX_INI_MODE_DISABLED:
2148 if (qla_tgt_mode_enabled(vha) ||
2149 qla_dual_mode_enabled(vha)) {
2150 /* turning off initiator mode */
2151 set_mode = 1;
2152 action = MODE_CHANGE_ACCEPT;
2153 } else {
2154 action = MODE_CHANGE_NO_ACTION;
2155 }
2156 break;
2157
2158 case QLA2XXX_INI_MODE_EXCLUSIVE:
2159 if (qla_tgt_mode_enabled(vha) ||
2160 qla_dual_mode_enabled(vha)) {
2161 set_mode = 1;
2162 action = MODE_CHANGE_ACCEPT;
2163 } else {
2164 action = MODE_CHANGE_ACCEPT;
2165 }
2166 break;
2167
2168 case QLA2XXX_INI_MODE_ENABLED:
2169 if (qla_tgt_mode_enabled(vha) ||
2170 qla_dual_mode_enabled(vha)) {
2171 action = TARGET_STILL_ACTIVE;
2172 } else {
2173 action = MODE_CHANGE_ACCEPT;
2174 }
2175 }
2176 break;
2177 }
2178
2179 switch (action) {
2180 case MODE_CHANGE_ACCEPT:
2181 ql_log(ql_log_warn, vha, 0xffff,
2182 "Mode change accepted. From %s to %s, Tgt exchg %d|%d. ini exchg %d|%d\n",
2183 mode_to_str[vha->qlini_mode], mode_to_str[op],
2184 vha->ql2xexchoffld, vha->u_ql2xexchoffld,
2185 vha->ql2xiniexchg, vha->u_ql2xiniexchg);
2186
2187 vha->qlini_mode = op;
2188 vha->ql2xexchoffld = vha->u_ql2xexchoffld;
2189 vha->ql2xiniexchg = vha->u_ql2xiniexchg;
2190 if (set_mode)
2191 qlt_set_mode(vha);
2192 vha->flags.online = 1;
2193 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
2194 break;
2195
2196 case MODE_CHANGE_NO_ACTION:
2197 ql_log(ql_log_warn, vha, 0xffff,
2198 "Mode is set. No action taken. From %s to %s, Tgt exchg %d|%d. ini exchg %d|%d\n",
2199 mode_to_str[vha->qlini_mode], mode_to_str[op],
2200 vha->ql2xexchoffld, vha->u_ql2xexchoffld,
2201 vha->ql2xiniexchg, vha->u_ql2xiniexchg);
2202 vha->qlini_mode = op;
2203 vha->ql2xexchoffld = vha->u_ql2xexchoffld;
2204 vha->ql2xiniexchg = vha->u_ql2xiniexchg;
2205 break;
2206
2207 case TARGET_STILL_ACTIVE:
2208 ql_log(ql_log_warn, vha, 0xffff,
2209 "Target Mode is active. Unable to change Mode.\n");
2210 break;
2211
2212 case NO_ACTION:
2213 default:
2214 ql_log(ql_log_warn, vha, 0xffff,
2215 "Mode unchange. No action taken. %d|%d pct %d|%d.\n",
2216 vha->qlini_mode, op,
2217 vha->ql2xexchoffld, vha->u_ql2xexchoffld);
2218 break;
2219 }
2220 }
2221
2222 static ssize_t
qlini_mode_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)2223 qlini_mode_store(struct device *dev, struct device_attribute *attr,
2224 const char *buf, size_t count)
2225 {
2226 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
2227 int ini;
2228
2229 if (!buf)
2230 return -EINVAL;
2231
2232 if (strncasecmp(QLA2XXX_INI_MODE_STR_EXCLUSIVE, buf,
2233 strlen(QLA2XXX_INI_MODE_STR_EXCLUSIVE)) == 0)
2234 ini = QLA2XXX_INI_MODE_EXCLUSIVE;
2235 else if (strncasecmp(QLA2XXX_INI_MODE_STR_DISABLED, buf,
2236 strlen(QLA2XXX_INI_MODE_STR_DISABLED)) == 0)
2237 ini = QLA2XXX_INI_MODE_DISABLED;
2238 else if (strncasecmp(QLA2XXX_INI_MODE_STR_ENABLED, buf,
2239 strlen(QLA2XXX_INI_MODE_STR_ENABLED)) == 0)
2240 ini = QLA2XXX_INI_MODE_ENABLED;
2241 else if (strncasecmp(QLA2XXX_INI_MODE_STR_DUAL, buf,
2242 strlen(QLA2XXX_INI_MODE_STR_DUAL)) == 0)
2243 ini = QLA2XXX_INI_MODE_DUAL;
2244 else
2245 return -EINVAL;
2246
2247 qla_set_ini_mode(vha, ini);
2248 return strlen(buf);
2249 }
2250
2251 static ssize_t
ql2xexchoffld_show(struct device * dev,struct device_attribute * attr,char * buf)2252 ql2xexchoffld_show(struct device *dev, struct device_attribute *attr,
2253 char *buf)
2254 {
2255 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
2256 int len = 0;
2257
2258 len += scnprintf(buf + len, PAGE_SIZE-len,
2259 "target exchange: new %d : current: %d\n\n",
2260 vha->u_ql2xexchoffld, vha->ql2xexchoffld);
2261
2262 len += scnprintf(buf + len, PAGE_SIZE-len,
2263 "Please (re)set operating mode via \"/sys/class/scsi_host/host%ld/qlini_mode\" to load new setting.\n",
2264 vha->host_no);
2265
2266 return len;
2267 }
2268
2269 static ssize_t
ql2xexchoffld_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)2270 ql2xexchoffld_store(struct device *dev, struct device_attribute *attr,
2271 const char *buf, size_t count)
2272 {
2273 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
2274 int val = 0;
2275
2276 if (sscanf(buf, "%d", &val) != 1)
2277 return -EINVAL;
2278
2279 if (val > FW_MAX_EXCHANGES_CNT)
2280 val = FW_MAX_EXCHANGES_CNT;
2281 else if (val < 0)
2282 val = 0;
2283
2284 vha->u_ql2xexchoffld = val;
2285 return strlen(buf);
2286 }
2287
2288 static ssize_t
ql2xiniexchg_show(struct device * dev,struct device_attribute * attr,char * buf)2289 ql2xiniexchg_show(struct device *dev, struct device_attribute *attr,
2290 char *buf)
2291 {
2292 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
2293 int len = 0;
2294
2295 len += scnprintf(buf + len, PAGE_SIZE-len,
2296 "target exchange: new %d : current: %d\n\n",
2297 vha->u_ql2xiniexchg, vha->ql2xiniexchg);
2298
2299 len += scnprintf(buf + len, PAGE_SIZE-len,
2300 "Please (re)set operating mode via \"/sys/class/scsi_host/host%ld/qlini_mode\" to load new setting.\n",
2301 vha->host_no);
2302
2303 return len;
2304 }
2305
2306 static ssize_t
ql2xiniexchg_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)2307 ql2xiniexchg_store(struct device *dev, struct device_attribute *attr,
2308 const char *buf, size_t count)
2309 {
2310 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
2311 int val = 0;
2312
2313 if (sscanf(buf, "%d", &val) != 1)
2314 return -EINVAL;
2315
2316 if (val > FW_MAX_EXCHANGES_CNT)
2317 val = FW_MAX_EXCHANGES_CNT;
2318 else if (val < 0)
2319 val = 0;
2320
2321 vha->u_ql2xiniexchg = val;
2322 return strlen(buf);
2323 }
2324
2325 static ssize_t
qla2x00_dif_bundle_statistics_show(struct device * dev,struct device_attribute * attr,char * buf)2326 qla2x00_dif_bundle_statistics_show(struct device *dev,
2327 struct device_attribute *attr, char *buf)
2328 {
2329 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
2330 struct qla_hw_data *ha = vha->hw;
2331
2332 return scnprintf(buf, PAGE_SIZE,
2333 "cross=%llu read=%llu write=%llu kalloc=%llu dma_alloc=%llu unusable=%u\n",
2334 ha->dif_bundle_crossed_pages, ha->dif_bundle_reads,
2335 ha->dif_bundle_writes, ha->dif_bundle_kallocs,
2336 ha->dif_bundle_dma_allocs, ha->pool.unusable.count);
2337 }
2338
2339 static ssize_t
qla2x00_fw_attr_show(struct device * dev,struct device_attribute * attr,char * buf)2340 qla2x00_fw_attr_show(struct device *dev,
2341 struct device_attribute *attr, char *buf)
2342 {
2343 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
2344 struct qla_hw_data *ha = vha->hw;
2345
2346 if (!IS_QLA27XX(ha) && !IS_QLA28XX(ha))
2347 return scnprintf(buf, PAGE_SIZE, "\n");
2348
2349 return scnprintf(buf, PAGE_SIZE, "%llx\n",
2350 (uint64_t)ha->fw_attributes_ext[1] << 48 |
2351 (uint64_t)ha->fw_attributes_ext[0] << 32 |
2352 (uint64_t)ha->fw_attributes_h << 16 |
2353 (uint64_t)ha->fw_attributes);
2354 }
2355
2356 static ssize_t
qla2x00_port_no_show(struct device * dev,struct device_attribute * attr,char * buf)2357 qla2x00_port_no_show(struct device *dev, struct device_attribute *attr,
2358 char *buf)
2359 {
2360 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
2361
2362 return scnprintf(buf, PAGE_SIZE, "%u\n", vha->hw->port_no);
2363 }
2364
2365 static ssize_t
qla2x00_dport_diagnostics_show(struct device * dev,struct device_attribute * attr,char * buf)2366 qla2x00_dport_diagnostics_show(struct device *dev,
2367 struct device_attribute *attr, char *buf)
2368 {
2369 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
2370
2371 if (!IS_QLA83XX(vha->hw) && !IS_QLA27XX(vha->hw) &&
2372 !IS_QLA28XX(vha->hw))
2373 return scnprintf(buf, PAGE_SIZE, "\n");
2374
2375 if (!*vha->dport_data)
2376 return scnprintf(buf, PAGE_SIZE, "\n");
2377
2378 return scnprintf(buf, PAGE_SIZE, "%04x %04x %04x %04x\n",
2379 vha->dport_data[0], vha->dport_data[1],
2380 vha->dport_data[2], vha->dport_data[3]);
2381 }
2382 static DEVICE_ATTR(dport_diagnostics, 0444,
2383 qla2x00_dport_diagnostics_show, NULL);
2384
2385 static DEVICE_ATTR(driver_version, S_IRUGO, qla2x00_driver_version_show, NULL);
2386 static DEVICE_ATTR(fw_version, S_IRUGO, qla2x00_fw_version_show, NULL);
2387 static DEVICE_ATTR(serial_num, S_IRUGO, qla2x00_serial_num_show, NULL);
2388 static DEVICE_ATTR(isp_name, S_IRUGO, qla2x00_isp_name_show, NULL);
2389 static DEVICE_ATTR(isp_id, S_IRUGO, qla2x00_isp_id_show, NULL);
2390 static DEVICE_ATTR(model_name, S_IRUGO, qla2x00_model_name_show, NULL);
2391 static DEVICE_ATTR(model_desc, S_IRUGO, qla2x00_model_desc_show, NULL);
2392 static DEVICE_ATTR(pci_info, S_IRUGO, qla2x00_pci_info_show, NULL);
2393 static DEVICE_ATTR(link_state, S_IRUGO, qla2x00_link_state_show, NULL);
2394 static DEVICE_ATTR(zio, S_IRUGO | S_IWUSR, qla2x00_zio_show, qla2x00_zio_store);
2395 static DEVICE_ATTR(zio_timer, S_IRUGO | S_IWUSR, qla2x00_zio_timer_show,
2396 qla2x00_zio_timer_store);
2397 static DEVICE_ATTR(beacon, S_IRUGO | S_IWUSR, qla2x00_beacon_show,
2398 qla2x00_beacon_store);
2399 static DEVICE_ATTR(beacon_config, 0644, qla2x00_beacon_config_show,
2400 qla2x00_beacon_config_store);
2401 static DEVICE_ATTR(optrom_bios_version, S_IRUGO,
2402 qla2x00_optrom_bios_version_show, NULL);
2403 static DEVICE_ATTR(optrom_efi_version, S_IRUGO,
2404 qla2x00_optrom_efi_version_show, NULL);
2405 static DEVICE_ATTR(optrom_fcode_version, S_IRUGO,
2406 qla2x00_optrom_fcode_version_show, NULL);
2407 static DEVICE_ATTR(optrom_fw_version, S_IRUGO, qla2x00_optrom_fw_version_show,
2408 NULL);
2409 static DEVICE_ATTR(optrom_gold_fw_version, S_IRUGO,
2410 qla2x00_optrom_gold_fw_version_show, NULL);
2411 static DEVICE_ATTR(84xx_fw_version, S_IRUGO, qla24xx_84xx_fw_version_show,
2412 NULL);
2413 static DEVICE_ATTR(total_isp_aborts, S_IRUGO, qla2x00_total_isp_aborts_show,
2414 NULL);
2415 static DEVICE_ATTR(serdes_version, 0444, qla2x00_serdes_version_show, NULL);
2416 static DEVICE_ATTR(mpi_version, S_IRUGO, qla2x00_mpi_version_show, NULL);
2417 static DEVICE_ATTR(phy_version, S_IRUGO, qla2x00_phy_version_show, NULL);
2418 static DEVICE_ATTR(flash_block_size, S_IRUGO, qla2x00_flash_block_size_show,
2419 NULL);
2420 static DEVICE_ATTR(vlan_id, S_IRUGO, qla2x00_vlan_id_show, NULL);
2421 static DEVICE_ATTR(vn_port_mac_address, S_IRUGO,
2422 qla2x00_vn_port_mac_address_show, NULL);
2423 static DEVICE_ATTR(fabric_param, S_IRUGO, qla2x00_fabric_param_show, NULL);
2424 static DEVICE_ATTR(fw_state, S_IRUGO, qla2x00_fw_state_show, NULL);
2425 static DEVICE_ATTR(thermal_temp, S_IRUGO, qla2x00_thermal_temp_show, NULL);
2426 static DEVICE_ATTR(diag_requests, S_IRUGO, qla2x00_diag_requests_show, NULL);
2427 static DEVICE_ATTR(diag_megabytes, S_IRUGO, qla2x00_diag_megabytes_show, NULL);
2428 static DEVICE_ATTR(fw_dump_size, S_IRUGO, qla2x00_fw_dump_size_show, NULL);
2429 static DEVICE_ATTR(allow_cna_fw_dump, S_IRUGO | S_IWUSR,
2430 qla2x00_allow_cna_fw_dump_show,
2431 qla2x00_allow_cna_fw_dump_store);
2432 static DEVICE_ATTR(pep_version, S_IRUGO, qla2x00_pep_version_show, NULL);
2433 static DEVICE_ATTR(min_supported_speed, 0444,
2434 qla2x00_min_supported_speed_show, NULL);
2435 static DEVICE_ATTR(max_supported_speed, 0444,
2436 qla2x00_max_supported_speed_show, NULL);
2437 static DEVICE_ATTR(zio_threshold, 0644,
2438 qla_zio_threshold_show,
2439 qla_zio_threshold_store);
2440 static DEVICE_ATTR_RW(qlini_mode);
2441 static DEVICE_ATTR_RW(ql2xexchoffld);
2442 static DEVICE_ATTR_RW(ql2xiniexchg);
2443 static DEVICE_ATTR(dif_bundle_statistics, 0444,
2444 qla2x00_dif_bundle_statistics_show, NULL);
2445 static DEVICE_ATTR(port_speed, 0644, qla2x00_port_speed_show,
2446 qla2x00_port_speed_store);
2447 static DEVICE_ATTR(port_no, 0444, qla2x00_port_no_show, NULL);
2448 static DEVICE_ATTR(fw_attr, 0444, qla2x00_fw_attr_show, NULL);
2449
2450
2451 struct device_attribute *qla2x00_host_attrs[] = {
2452 &dev_attr_driver_version,
2453 &dev_attr_fw_version,
2454 &dev_attr_serial_num,
2455 &dev_attr_isp_name,
2456 &dev_attr_isp_id,
2457 &dev_attr_model_name,
2458 &dev_attr_model_desc,
2459 &dev_attr_pci_info,
2460 &dev_attr_link_state,
2461 &dev_attr_zio,
2462 &dev_attr_zio_timer,
2463 &dev_attr_beacon,
2464 &dev_attr_beacon_config,
2465 &dev_attr_optrom_bios_version,
2466 &dev_attr_optrom_efi_version,
2467 &dev_attr_optrom_fcode_version,
2468 &dev_attr_optrom_fw_version,
2469 &dev_attr_84xx_fw_version,
2470 &dev_attr_total_isp_aborts,
2471 &dev_attr_serdes_version,
2472 &dev_attr_mpi_version,
2473 &dev_attr_phy_version,
2474 &dev_attr_flash_block_size,
2475 &dev_attr_vlan_id,
2476 &dev_attr_vn_port_mac_address,
2477 &dev_attr_fabric_param,
2478 &dev_attr_fw_state,
2479 &dev_attr_optrom_gold_fw_version,
2480 &dev_attr_thermal_temp,
2481 &dev_attr_diag_requests,
2482 &dev_attr_diag_megabytes,
2483 &dev_attr_fw_dump_size,
2484 &dev_attr_allow_cna_fw_dump,
2485 &dev_attr_pep_version,
2486 &dev_attr_min_supported_speed,
2487 &dev_attr_max_supported_speed,
2488 &dev_attr_zio_threshold,
2489 &dev_attr_dif_bundle_statistics,
2490 &dev_attr_port_speed,
2491 &dev_attr_port_no,
2492 &dev_attr_fw_attr,
2493 &dev_attr_dport_diagnostics,
2494 NULL, /* reserve for qlini_mode */
2495 NULL, /* reserve for ql2xiniexchg */
2496 NULL, /* reserve for ql2xexchoffld */
2497 NULL,
2498 };
2499
qla_insert_tgt_attrs(void)2500 void qla_insert_tgt_attrs(void)
2501 {
2502 struct device_attribute **attr;
2503
2504 /* advance to empty slot */
2505 for (attr = &qla2x00_host_attrs[0]; *attr; ++attr)
2506 continue;
2507
2508 *attr = &dev_attr_qlini_mode;
2509 attr++;
2510 *attr = &dev_attr_ql2xiniexchg;
2511 attr++;
2512 *attr = &dev_attr_ql2xexchoffld;
2513 }
2514
2515 /* Host attributes. */
2516
2517 static void
qla2x00_get_host_port_id(struct Scsi_Host * shost)2518 qla2x00_get_host_port_id(struct Scsi_Host *shost)
2519 {
2520 scsi_qla_host_t *vha = shost_priv(shost);
2521
2522 fc_host_port_id(shost) = vha->d_id.b.domain << 16 |
2523 vha->d_id.b.area << 8 | vha->d_id.b.al_pa;
2524 }
2525
2526 static void
qla2x00_get_host_speed(struct Scsi_Host * shost)2527 qla2x00_get_host_speed(struct Scsi_Host *shost)
2528 {
2529 scsi_qla_host_t *vha = shost_priv(shost);
2530 u32 speed;
2531
2532 if (IS_QLAFX00(vha->hw)) {
2533 qlafx00_get_host_speed(shost);
2534 return;
2535 }
2536
2537 switch (vha->hw->link_data_rate) {
2538 case PORT_SPEED_1GB:
2539 speed = FC_PORTSPEED_1GBIT;
2540 break;
2541 case PORT_SPEED_2GB:
2542 speed = FC_PORTSPEED_2GBIT;
2543 break;
2544 case PORT_SPEED_4GB:
2545 speed = FC_PORTSPEED_4GBIT;
2546 break;
2547 case PORT_SPEED_8GB:
2548 speed = FC_PORTSPEED_8GBIT;
2549 break;
2550 case PORT_SPEED_10GB:
2551 speed = FC_PORTSPEED_10GBIT;
2552 break;
2553 case PORT_SPEED_16GB:
2554 speed = FC_PORTSPEED_16GBIT;
2555 break;
2556 case PORT_SPEED_32GB:
2557 speed = FC_PORTSPEED_32GBIT;
2558 break;
2559 case PORT_SPEED_64GB:
2560 speed = FC_PORTSPEED_64GBIT;
2561 break;
2562 default:
2563 speed = FC_PORTSPEED_UNKNOWN;
2564 break;
2565 }
2566
2567 fc_host_speed(shost) = speed;
2568 }
2569
2570 static void
qla2x00_get_host_port_type(struct Scsi_Host * shost)2571 qla2x00_get_host_port_type(struct Scsi_Host *shost)
2572 {
2573 scsi_qla_host_t *vha = shost_priv(shost);
2574 uint32_t port_type;
2575
2576 if (vha->vp_idx) {
2577 fc_host_port_type(shost) = FC_PORTTYPE_NPIV;
2578 return;
2579 }
2580 switch (vha->hw->current_topology) {
2581 case ISP_CFG_NL:
2582 port_type = FC_PORTTYPE_LPORT;
2583 break;
2584 case ISP_CFG_FL:
2585 port_type = FC_PORTTYPE_NLPORT;
2586 break;
2587 case ISP_CFG_N:
2588 port_type = FC_PORTTYPE_PTP;
2589 break;
2590 case ISP_CFG_F:
2591 port_type = FC_PORTTYPE_NPORT;
2592 break;
2593 default:
2594 port_type = FC_PORTTYPE_UNKNOWN;
2595 break;
2596 }
2597
2598 fc_host_port_type(shost) = port_type;
2599 }
2600
2601 static void
qla2x00_get_starget_node_name(struct scsi_target * starget)2602 qla2x00_get_starget_node_name(struct scsi_target *starget)
2603 {
2604 struct Scsi_Host *host = dev_to_shost(starget->dev.parent);
2605 scsi_qla_host_t *vha = shost_priv(host);
2606 fc_port_t *fcport;
2607 u64 node_name = 0;
2608
2609 list_for_each_entry(fcport, &vha->vp_fcports, list) {
2610 if (fcport->rport &&
2611 starget->id == fcport->rport->scsi_target_id) {
2612 node_name = wwn_to_u64(fcport->node_name);
2613 break;
2614 }
2615 }
2616
2617 fc_starget_node_name(starget) = node_name;
2618 }
2619
2620 static void
qla2x00_get_starget_port_name(struct scsi_target * starget)2621 qla2x00_get_starget_port_name(struct scsi_target *starget)
2622 {
2623 struct Scsi_Host *host = dev_to_shost(starget->dev.parent);
2624 scsi_qla_host_t *vha = shost_priv(host);
2625 fc_port_t *fcport;
2626 u64 port_name = 0;
2627
2628 list_for_each_entry(fcport, &vha->vp_fcports, list) {
2629 if (fcport->rport &&
2630 starget->id == fcport->rport->scsi_target_id) {
2631 port_name = wwn_to_u64(fcport->port_name);
2632 break;
2633 }
2634 }
2635
2636 fc_starget_port_name(starget) = port_name;
2637 }
2638
2639 static void
qla2x00_get_starget_port_id(struct scsi_target * starget)2640 qla2x00_get_starget_port_id(struct scsi_target *starget)
2641 {
2642 struct Scsi_Host *host = dev_to_shost(starget->dev.parent);
2643 scsi_qla_host_t *vha = shost_priv(host);
2644 fc_port_t *fcport;
2645 uint32_t port_id = ~0U;
2646
2647 list_for_each_entry(fcport, &vha->vp_fcports, list) {
2648 if (fcport->rport &&
2649 starget->id == fcport->rport->scsi_target_id) {
2650 port_id = fcport->d_id.b.domain << 16 |
2651 fcport->d_id.b.area << 8 | fcport->d_id.b.al_pa;
2652 break;
2653 }
2654 }
2655
2656 fc_starget_port_id(starget) = port_id;
2657 }
2658
2659 static inline void
qla2x00_set_rport_loss_tmo(struct fc_rport * rport,uint32_t timeout)2660 qla2x00_set_rport_loss_tmo(struct fc_rport *rport, uint32_t timeout)
2661 {
2662 rport->dev_loss_tmo = timeout ? timeout : 1;
2663 }
2664
2665 static void
qla2x00_dev_loss_tmo_callbk(struct fc_rport * rport)2666 qla2x00_dev_loss_tmo_callbk(struct fc_rport *rport)
2667 {
2668 struct Scsi_Host *host = rport_to_shost(rport);
2669 fc_port_t *fcport = *(fc_port_t **)rport->dd_data;
2670 unsigned long flags;
2671
2672 if (!fcport)
2673 return;
2674
2675 /* Now that the rport has been deleted, set the fcport state to
2676 FCS_DEVICE_DEAD */
2677 qla2x00_set_fcport_state(fcport, FCS_DEVICE_DEAD);
2678
2679 /*
2680 * Transport has effectively 'deleted' the rport, clear
2681 * all local references.
2682 */
2683 spin_lock_irqsave(host->host_lock, flags);
2684 fcport->rport = fcport->drport = NULL;
2685 *((fc_port_t **)rport->dd_data) = NULL;
2686 spin_unlock_irqrestore(host->host_lock, flags);
2687
2688 if (test_bit(ABORT_ISP_ACTIVE, &fcport->vha->dpc_flags))
2689 return;
2690
2691 if (unlikely(pci_channel_offline(fcport->vha->hw->pdev))) {
2692 qla2x00_abort_all_cmds(fcport->vha, DID_NO_CONNECT << 16);
2693 return;
2694 }
2695 }
2696
2697 static void
qla2x00_terminate_rport_io(struct fc_rport * rport)2698 qla2x00_terminate_rport_io(struct fc_rport *rport)
2699 {
2700 fc_port_t *fcport = *(fc_port_t **)rport->dd_data;
2701
2702 if (!fcport)
2703 return;
2704
2705 if (test_bit(UNLOADING, &fcport->vha->dpc_flags))
2706 return;
2707
2708 if (test_bit(ABORT_ISP_ACTIVE, &fcport->vha->dpc_flags))
2709 return;
2710
2711 if (unlikely(pci_channel_offline(fcport->vha->hw->pdev))) {
2712 qla2x00_abort_all_cmds(fcport->vha, DID_NO_CONNECT << 16);
2713 return;
2714 }
2715 /*
2716 * At this point all fcport's software-states are cleared. Perform any
2717 * final cleanup of firmware resources (PCBs and XCBs).
2718 */
2719 if (fcport->loop_id != FC_NO_LOOP_ID) {
2720 if (IS_FWI2_CAPABLE(fcport->vha->hw))
2721 fcport->vha->hw->isp_ops->fabric_logout(fcport->vha,
2722 fcport->loop_id, fcport->d_id.b.domain,
2723 fcport->d_id.b.area, fcport->d_id.b.al_pa);
2724 else
2725 qla2x00_port_logout(fcport->vha, fcport);
2726 }
2727 }
2728
2729 static int
qla2x00_issue_lip(struct Scsi_Host * shost)2730 qla2x00_issue_lip(struct Scsi_Host *shost)
2731 {
2732 scsi_qla_host_t *vha = shost_priv(shost);
2733
2734 if (IS_QLAFX00(vha->hw))
2735 return 0;
2736
2737 qla2x00_loop_reset(vha);
2738 return 0;
2739 }
2740
2741 static struct fc_host_statistics *
qla2x00_get_fc_host_stats(struct Scsi_Host * shost)2742 qla2x00_get_fc_host_stats(struct Scsi_Host *shost)
2743 {
2744 scsi_qla_host_t *vha = shost_priv(shost);
2745 struct qla_hw_data *ha = vha->hw;
2746 struct scsi_qla_host *base_vha = pci_get_drvdata(ha->pdev);
2747 int rval;
2748 struct link_statistics *stats;
2749 dma_addr_t stats_dma;
2750 struct fc_host_statistics *p = &vha->fc_host_stat;
2751 struct qla_qpair *qpair;
2752 int i;
2753 u64 ib = 0, ob = 0, ir = 0, or = 0;
2754
2755 memset(p, -1, sizeof(*p));
2756
2757 if (IS_QLAFX00(vha->hw))
2758 goto done;
2759
2760 if (test_bit(UNLOADING, &vha->dpc_flags))
2761 goto done;
2762
2763 if (unlikely(pci_channel_offline(ha->pdev)))
2764 goto done;
2765
2766 if (qla2x00_chip_is_down(vha))
2767 goto done;
2768
2769 stats = dma_alloc_coherent(&ha->pdev->dev, sizeof(*stats), &stats_dma,
2770 GFP_KERNEL);
2771 if (!stats) {
2772 ql_log(ql_log_warn, vha, 0x707d,
2773 "Failed to allocate memory for stats.\n");
2774 goto done;
2775 }
2776
2777 rval = QLA_FUNCTION_FAILED;
2778 if (IS_FWI2_CAPABLE(ha)) {
2779 rval = qla24xx_get_isp_stats(base_vha, stats, stats_dma, 0);
2780 } else if (atomic_read(&base_vha->loop_state) == LOOP_READY &&
2781 !ha->dpc_active) {
2782 /* Must be in a 'READY' state for statistics retrieval. */
2783 rval = qla2x00_get_link_status(base_vha, base_vha->loop_id,
2784 stats, stats_dma);
2785 }
2786
2787 if (rval != QLA_SUCCESS)
2788 goto done_free;
2789
2790 /* --- */
2791 for (i = 0; i < vha->hw->max_qpairs; i++) {
2792 qpair = vha->hw->queue_pair_map[i];
2793 if (!qpair)
2794 continue;
2795 ir += qpair->counters.input_requests;
2796 or += qpair->counters.output_requests;
2797 ib += qpair->counters.input_bytes;
2798 ob += qpair->counters.output_bytes;
2799 }
2800 ir += ha->base_qpair->counters.input_requests;
2801 or += ha->base_qpair->counters.output_requests;
2802 ib += ha->base_qpair->counters.input_bytes;
2803 ob += ha->base_qpair->counters.output_bytes;
2804
2805 ir += vha->qla_stats.input_requests;
2806 or += vha->qla_stats.output_requests;
2807 ib += vha->qla_stats.input_bytes;
2808 ob += vha->qla_stats.output_bytes;
2809 /* --- */
2810
2811 p->link_failure_count = le32_to_cpu(stats->link_fail_cnt);
2812 p->loss_of_sync_count = le32_to_cpu(stats->loss_sync_cnt);
2813 p->loss_of_signal_count = le32_to_cpu(stats->loss_sig_cnt);
2814 p->prim_seq_protocol_err_count = le32_to_cpu(stats->prim_seq_err_cnt);
2815 p->invalid_tx_word_count = le32_to_cpu(stats->inval_xmit_word_cnt);
2816 p->invalid_crc_count = le32_to_cpu(stats->inval_crc_cnt);
2817 if (IS_FWI2_CAPABLE(ha)) {
2818 p->lip_count = le32_to_cpu(stats->lip_cnt);
2819 p->tx_frames = le32_to_cpu(stats->tx_frames);
2820 p->rx_frames = le32_to_cpu(stats->rx_frames);
2821 p->dumped_frames = le32_to_cpu(stats->discarded_frames);
2822 p->nos_count = le32_to_cpu(stats->nos_rcvd);
2823 p->error_frames =
2824 le32_to_cpu(stats->dropped_frames) +
2825 le32_to_cpu(stats->discarded_frames);
2826 if (IS_QLA83XX(ha) || IS_QLA27XX(ha) || IS_QLA28XX(ha)) {
2827 p->rx_words = le64_to_cpu(stats->fpm_recv_word_cnt);
2828 p->tx_words = le64_to_cpu(stats->fpm_xmit_word_cnt);
2829 } else {
2830 p->rx_words = ib >> 2;
2831 p->tx_words = ob >> 2;
2832 }
2833 }
2834
2835 p->fcp_control_requests = vha->qla_stats.control_requests;
2836 p->fcp_input_requests = ir;
2837 p->fcp_output_requests = or;
2838 p->fcp_input_megabytes = ib >> 20;
2839 p->fcp_output_megabytes = ob >> 20;
2840 p->seconds_since_last_reset =
2841 get_jiffies_64() - vha->qla_stats.jiffies_at_last_reset;
2842 do_div(p->seconds_since_last_reset, HZ);
2843
2844 done_free:
2845 dma_free_coherent(&ha->pdev->dev, sizeof(struct link_statistics),
2846 stats, stats_dma);
2847 done:
2848 return p;
2849 }
2850
2851 static void
qla2x00_reset_host_stats(struct Scsi_Host * shost)2852 qla2x00_reset_host_stats(struct Scsi_Host *shost)
2853 {
2854 scsi_qla_host_t *vha = shost_priv(shost);
2855 struct qla_hw_data *ha = vha->hw;
2856 struct scsi_qla_host *base_vha = pci_get_drvdata(ha->pdev);
2857 struct link_statistics *stats;
2858 dma_addr_t stats_dma;
2859 int i;
2860 struct qla_qpair *qpair;
2861
2862 memset(&vha->qla_stats, 0, sizeof(vha->qla_stats));
2863 memset(&vha->fc_host_stat, 0, sizeof(vha->fc_host_stat));
2864 for (i = 0; i < vha->hw->max_qpairs; i++) {
2865 qpair = vha->hw->queue_pair_map[i];
2866 if (!qpair)
2867 continue;
2868 memset(&qpair->counters, 0, sizeof(qpair->counters));
2869 }
2870 memset(&ha->base_qpair->counters, 0, sizeof(qpair->counters));
2871
2872 vha->qla_stats.jiffies_at_last_reset = get_jiffies_64();
2873
2874 if (IS_FWI2_CAPABLE(ha)) {
2875 int rval;
2876
2877 stats = dma_alloc_coherent(&ha->pdev->dev,
2878 sizeof(*stats), &stats_dma, GFP_KERNEL);
2879 if (!stats) {
2880 ql_log(ql_log_warn, vha, 0x70d7,
2881 "Failed to allocate memory for stats.\n");
2882 return;
2883 }
2884
2885 /* reset firmware statistics */
2886 rval = qla24xx_get_isp_stats(base_vha, stats, stats_dma, BIT_0);
2887 if (rval != QLA_SUCCESS)
2888 ql_log(ql_log_warn, vha, 0x70de,
2889 "Resetting ISP statistics failed: rval = %d\n",
2890 rval);
2891
2892 dma_free_coherent(&ha->pdev->dev, sizeof(*stats),
2893 stats, stats_dma);
2894 }
2895 }
2896
2897 static void
qla2x00_get_host_symbolic_name(struct Scsi_Host * shost)2898 qla2x00_get_host_symbolic_name(struct Scsi_Host *shost)
2899 {
2900 scsi_qla_host_t *vha = shost_priv(shost);
2901
2902 qla2x00_get_sym_node_name(vha, fc_host_symbolic_name(shost),
2903 sizeof(fc_host_symbolic_name(shost)));
2904 }
2905
2906 static void
qla2x00_set_host_system_hostname(struct Scsi_Host * shost)2907 qla2x00_set_host_system_hostname(struct Scsi_Host *shost)
2908 {
2909 scsi_qla_host_t *vha = shost_priv(shost);
2910
2911 set_bit(REGISTER_FDMI_NEEDED, &vha->dpc_flags);
2912 }
2913
2914 static void
qla2x00_get_host_fabric_name(struct Scsi_Host * shost)2915 qla2x00_get_host_fabric_name(struct Scsi_Host *shost)
2916 {
2917 scsi_qla_host_t *vha = shost_priv(shost);
2918 static const uint8_t node_name[WWN_SIZE] = {
2919 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
2920 };
2921 u64 fabric_name = wwn_to_u64(node_name);
2922
2923 if (vha->device_flags & SWITCH_FOUND)
2924 fabric_name = wwn_to_u64(vha->fabric_node_name);
2925
2926 fc_host_fabric_name(shost) = fabric_name;
2927 }
2928
2929 static void
qla2x00_get_host_port_state(struct Scsi_Host * shost)2930 qla2x00_get_host_port_state(struct Scsi_Host *shost)
2931 {
2932 scsi_qla_host_t *vha = shost_priv(shost);
2933 struct scsi_qla_host *base_vha = pci_get_drvdata(vha->hw->pdev);
2934
2935 if (!base_vha->flags.online) {
2936 fc_host_port_state(shost) = FC_PORTSTATE_OFFLINE;
2937 return;
2938 }
2939
2940 switch (atomic_read(&base_vha->loop_state)) {
2941 case LOOP_UPDATE:
2942 fc_host_port_state(shost) = FC_PORTSTATE_DIAGNOSTICS;
2943 break;
2944 case LOOP_DOWN:
2945 if (test_bit(LOOP_RESYNC_NEEDED, &base_vha->dpc_flags))
2946 fc_host_port_state(shost) = FC_PORTSTATE_DIAGNOSTICS;
2947 else
2948 fc_host_port_state(shost) = FC_PORTSTATE_LINKDOWN;
2949 break;
2950 case LOOP_DEAD:
2951 fc_host_port_state(shost) = FC_PORTSTATE_LINKDOWN;
2952 break;
2953 case LOOP_READY:
2954 fc_host_port_state(shost) = FC_PORTSTATE_ONLINE;
2955 break;
2956 default:
2957 fc_host_port_state(shost) = FC_PORTSTATE_UNKNOWN;
2958 break;
2959 }
2960 }
2961
2962 static int
qla24xx_vport_create(struct fc_vport * fc_vport,bool disable)2963 qla24xx_vport_create(struct fc_vport *fc_vport, bool disable)
2964 {
2965 int ret = 0;
2966 uint8_t qos = 0;
2967 scsi_qla_host_t *base_vha = shost_priv(fc_vport->shost);
2968 scsi_qla_host_t *vha = NULL;
2969 struct qla_hw_data *ha = base_vha->hw;
2970 int cnt;
2971 struct req_que *req = ha->req_q_map[0];
2972 struct qla_qpair *qpair;
2973
2974 ret = qla24xx_vport_create_req_sanity_check(fc_vport);
2975 if (ret) {
2976 ql_log(ql_log_warn, vha, 0x707e,
2977 "Vport sanity check failed, status %x\n", ret);
2978 return (ret);
2979 }
2980
2981 vha = qla24xx_create_vhost(fc_vport);
2982 if (vha == NULL) {
2983 ql_log(ql_log_warn, vha, 0x707f, "Vport create host failed.\n");
2984 return FC_VPORT_FAILED;
2985 }
2986 if (disable) {
2987 atomic_set(&vha->vp_state, VP_OFFLINE);
2988 fc_vport_set_state(fc_vport, FC_VPORT_DISABLED);
2989 } else
2990 atomic_set(&vha->vp_state, VP_FAILED);
2991
2992 /* ready to create vport */
2993 ql_log(ql_log_info, vha, 0x7080,
2994 "VP entry id %d assigned.\n", vha->vp_idx);
2995
2996 /* initialized vport states */
2997 atomic_set(&vha->loop_state, LOOP_DOWN);
2998 vha->vp_err_state = VP_ERR_PORTDWN;
2999 vha->vp_prev_err_state = VP_ERR_UNKWN;
3000 /* Check if physical ha port is Up */
3001 if (atomic_read(&base_vha->loop_state) == LOOP_DOWN ||
3002 atomic_read(&base_vha->loop_state) == LOOP_DEAD) {
3003 /* Don't retry or attempt login of this virtual port */
3004 ql_dbg(ql_dbg_user, vha, 0x7081,
3005 "Vport loop state is not UP.\n");
3006 atomic_set(&vha->loop_state, LOOP_DEAD);
3007 if (!disable)
3008 fc_vport_set_state(fc_vport, FC_VPORT_LINKDOWN);
3009 }
3010
3011 if (IS_T10_PI_CAPABLE(ha) && ql2xenabledif) {
3012 if (ha->fw_attributes & BIT_4) {
3013 int prot = 0, guard;
3014
3015 vha->flags.difdix_supported = 1;
3016 ql_dbg(ql_dbg_user, vha, 0x7082,
3017 "Registered for DIF/DIX type 1 and 3 protection.\n");
3018 if (ql2xenabledif == 1)
3019 prot = SHOST_DIX_TYPE0_PROTECTION;
3020 scsi_host_set_prot(vha->host,
3021 prot | SHOST_DIF_TYPE1_PROTECTION
3022 | SHOST_DIF_TYPE2_PROTECTION
3023 | SHOST_DIF_TYPE3_PROTECTION
3024 | SHOST_DIX_TYPE1_PROTECTION
3025 | SHOST_DIX_TYPE2_PROTECTION
3026 | SHOST_DIX_TYPE3_PROTECTION);
3027
3028 guard = SHOST_DIX_GUARD_CRC;
3029
3030 if (IS_PI_IPGUARD_CAPABLE(ha) &&
3031 (ql2xenabledif > 1 || IS_PI_DIFB_DIX0_CAPABLE(ha)))
3032 guard |= SHOST_DIX_GUARD_IP;
3033
3034 scsi_host_set_guard(vha->host, guard);
3035 } else
3036 vha->flags.difdix_supported = 0;
3037 }
3038
3039 if (scsi_add_host_with_dma(vha->host, &fc_vport->dev,
3040 &ha->pdev->dev)) {
3041 ql_dbg(ql_dbg_user, vha, 0x7083,
3042 "scsi_add_host failure for VP[%d].\n", vha->vp_idx);
3043 goto vport_create_failed_2;
3044 }
3045
3046 /* initialize attributes */
3047 fc_host_dev_loss_tmo(vha->host) = ha->port_down_retry_count;
3048 fc_host_node_name(vha->host) = wwn_to_u64(vha->node_name);
3049 fc_host_port_name(vha->host) = wwn_to_u64(vha->port_name);
3050 fc_host_supported_classes(vha->host) =
3051 fc_host_supported_classes(base_vha->host);
3052 fc_host_supported_speeds(vha->host) =
3053 fc_host_supported_speeds(base_vha->host);
3054
3055 qlt_vport_create(vha, ha);
3056 qla24xx_vport_disable(fc_vport, disable);
3057
3058 if (!ql2xmqsupport || !ha->npiv_info)
3059 goto vport_queue;
3060
3061 /* Create a request queue in QoS mode for the vport */
3062 for (cnt = 0; cnt < ha->nvram_npiv_size; cnt++) {
3063 if (memcmp(ha->npiv_info[cnt].port_name, vha->port_name, 8) == 0
3064 && memcmp(ha->npiv_info[cnt].node_name, vha->node_name,
3065 8) == 0) {
3066 qos = ha->npiv_info[cnt].q_qos;
3067 break;
3068 }
3069 }
3070
3071 if (qos) {
3072 qpair = qla2xxx_create_qpair(vha, qos, vha->vp_idx, true);
3073 if (!qpair)
3074 ql_log(ql_log_warn, vha, 0x7084,
3075 "Can't create qpair for VP[%d]\n",
3076 vha->vp_idx);
3077 else {
3078 ql_dbg(ql_dbg_multiq, vha, 0xc001,
3079 "Queue pair: %d Qos: %d) created for VP[%d]\n",
3080 qpair->id, qos, vha->vp_idx);
3081 ql_dbg(ql_dbg_user, vha, 0x7085,
3082 "Queue Pair: %d Qos: %d) created for VP[%d]\n",
3083 qpair->id, qos, vha->vp_idx);
3084 req = qpair->req;
3085 vha->qpair = qpair;
3086 }
3087 }
3088
3089 vport_queue:
3090 vha->req = req;
3091 return 0;
3092
3093 vport_create_failed_2:
3094 qla24xx_disable_vp(vha);
3095 qla24xx_deallocate_vp_id(vha);
3096 scsi_host_put(vha->host);
3097 return FC_VPORT_FAILED;
3098 }
3099
3100 static int
qla24xx_vport_delete(struct fc_vport * fc_vport)3101 qla24xx_vport_delete(struct fc_vport *fc_vport)
3102 {
3103 scsi_qla_host_t *vha = fc_vport->dd_data;
3104 struct qla_hw_data *ha = vha->hw;
3105 uint16_t id = vha->vp_idx;
3106
3107 set_bit(VPORT_DELETE, &vha->dpc_flags);
3108
3109 while (test_bit(LOOP_RESYNC_ACTIVE, &vha->dpc_flags) ||
3110 test_bit(FCPORT_UPDATE_NEEDED, &vha->dpc_flags))
3111 msleep(1000);
3112
3113
3114 qla24xx_disable_vp(vha);
3115 qla2x00_wait_for_sess_deletion(vha);
3116
3117 qla_nvme_delete(vha);
3118 vha->flags.delete_progress = 1;
3119
3120 qlt_remove_target(ha, vha);
3121
3122 fc_remove_host(vha->host);
3123
3124 scsi_remove_host(vha->host);
3125
3126 /* Allow timer to run to drain queued items, when removing vp */
3127 qla24xx_deallocate_vp_id(vha);
3128
3129 if (vha->timer_active) {
3130 qla2x00_vp_stop_timer(vha);
3131 ql_dbg(ql_dbg_user, vha, 0x7086,
3132 "Timer for the VP[%d] has stopped\n", vha->vp_idx);
3133 }
3134
3135 qla2x00_free_fcports(vha);
3136
3137 mutex_lock(&ha->vport_lock);
3138 ha->cur_vport_count--;
3139 clear_bit(vha->vp_idx, ha->vp_idx_map);
3140 mutex_unlock(&ha->vport_lock);
3141
3142 dma_free_coherent(&ha->pdev->dev, vha->gnl.size, vha->gnl.l,
3143 vha->gnl.ldma);
3144
3145 vha->gnl.l = NULL;
3146
3147 vfree(vha->scan.l);
3148
3149 if (vha->qpair && vha->qpair->vp_idx == vha->vp_idx) {
3150 if (qla2xxx_delete_qpair(vha, vha->qpair) != QLA_SUCCESS)
3151 ql_log(ql_log_warn, vha, 0x7087,
3152 "Queue Pair delete failed.\n");
3153 }
3154
3155 ql_log(ql_log_info, vha, 0x7088, "VP[%d] deleted.\n", id);
3156 scsi_host_put(vha->host);
3157 return 0;
3158 }
3159
3160 static int
qla24xx_vport_disable(struct fc_vport * fc_vport,bool disable)3161 qla24xx_vport_disable(struct fc_vport *fc_vport, bool disable)
3162 {
3163 scsi_qla_host_t *vha = fc_vport->dd_data;
3164
3165 if (disable)
3166 qla24xx_disable_vp(vha);
3167 else
3168 qla24xx_enable_vp(vha);
3169
3170 return 0;
3171 }
3172
3173 struct fc_function_template qla2xxx_transport_functions = {
3174
3175 .show_host_node_name = 1,
3176 .show_host_port_name = 1,
3177 .show_host_supported_classes = 1,
3178 .show_host_supported_speeds = 1,
3179
3180 .get_host_port_id = qla2x00_get_host_port_id,
3181 .show_host_port_id = 1,
3182 .get_host_speed = qla2x00_get_host_speed,
3183 .show_host_speed = 1,
3184 .get_host_port_type = qla2x00_get_host_port_type,
3185 .show_host_port_type = 1,
3186 .get_host_symbolic_name = qla2x00_get_host_symbolic_name,
3187 .show_host_symbolic_name = 1,
3188 .set_host_system_hostname = qla2x00_set_host_system_hostname,
3189 .show_host_system_hostname = 1,
3190 .get_host_fabric_name = qla2x00_get_host_fabric_name,
3191 .show_host_fabric_name = 1,
3192 .get_host_port_state = qla2x00_get_host_port_state,
3193 .show_host_port_state = 1,
3194
3195 .dd_fcrport_size = sizeof(struct fc_port *),
3196 .show_rport_supported_classes = 1,
3197
3198 .get_starget_node_name = qla2x00_get_starget_node_name,
3199 .show_starget_node_name = 1,
3200 .get_starget_port_name = qla2x00_get_starget_port_name,
3201 .show_starget_port_name = 1,
3202 .get_starget_port_id = qla2x00_get_starget_port_id,
3203 .show_starget_port_id = 1,
3204
3205 .set_rport_dev_loss_tmo = qla2x00_set_rport_loss_tmo,
3206 .show_rport_dev_loss_tmo = 1,
3207
3208 .issue_fc_host_lip = qla2x00_issue_lip,
3209 .dev_loss_tmo_callbk = qla2x00_dev_loss_tmo_callbk,
3210 .terminate_rport_io = qla2x00_terminate_rport_io,
3211 .get_fc_host_stats = qla2x00_get_fc_host_stats,
3212 .reset_fc_host_stats = qla2x00_reset_host_stats,
3213
3214 .vport_create = qla24xx_vport_create,
3215 .vport_disable = qla24xx_vport_disable,
3216 .vport_delete = qla24xx_vport_delete,
3217 .bsg_request = qla24xx_bsg_request,
3218 .bsg_timeout = qla24xx_bsg_timeout,
3219 };
3220
3221 struct fc_function_template qla2xxx_transport_vport_functions = {
3222
3223 .show_host_node_name = 1,
3224 .show_host_port_name = 1,
3225 .show_host_supported_classes = 1,
3226
3227 .get_host_port_id = qla2x00_get_host_port_id,
3228 .show_host_port_id = 1,
3229 .get_host_speed = qla2x00_get_host_speed,
3230 .show_host_speed = 1,
3231 .get_host_port_type = qla2x00_get_host_port_type,
3232 .show_host_port_type = 1,
3233 .get_host_symbolic_name = qla2x00_get_host_symbolic_name,
3234 .show_host_symbolic_name = 1,
3235 .set_host_system_hostname = qla2x00_set_host_system_hostname,
3236 .show_host_system_hostname = 1,
3237 .get_host_fabric_name = qla2x00_get_host_fabric_name,
3238 .show_host_fabric_name = 1,
3239 .get_host_port_state = qla2x00_get_host_port_state,
3240 .show_host_port_state = 1,
3241
3242 .dd_fcrport_size = sizeof(struct fc_port *),
3243 .show_rport_supported_classes = 1,
3244
3245 .get_starget_node_name = qla2x00_get_starget_node_name,
3246 .show_starget_node_name = 1,
3247 .get_starget_port_name = qla2x00_get_starget_port_name,
3248 .show_starget_port_name = 1,
3249 .get_starget_port_id = qla2x00_get_starget_port_id,
3250 .show_starget_port_id = 1,
3251
3252 .set_rport_dev_loss_tmo = qla2x00_set_rport_loss_tmo,
3253 .show_rport_dev_loss_tmo = 1,
3254
3255 .issue_fc_host_lip = qla2x00_issue_lip,
3256 .dev_loss_tmo_callbk = qla2x00_dev_loss_tmo_callbk,
3257 .terminate_rport_io = qla2x00_terminate_rport_io,
3258 .get_fc_host_stats = qla2x00_get_fc_host_stats,
3259 .reset_fc_host_stats = qla2x00_reset_host_stats,
3260
3261 .bsg_request = qla24xx_bsg_request,
3262 .bsg_timeout = qla24xx_bsg_timeout,
3263 };
3264
3265 static uint
qla2x00_get_host_supported_speeds(scsi_qla_host_t * vha,uint speeds)3266 qla2x00_get_host_supported_speeds(scsi_qla_host_t *vha, uint speeds)
3267 {
3268 uint supported_speeds = FC_PORTSPEED_UNKNOWN;
3269
3270 if (speeds & FDMI_PORT_SPEED_64GB)
3271 supported_speeds |= FC_PORTSPEED_64GBIT;
3272 if (speeds & FDMI_PORT_SPEED_32GB)
3273 supported_speeds |= FC_PORTSPEED_32GBIT;
3274 if (speeds & FDMI_PORT_SPEED_16GB)
3275 supported_speeds |= FC_PORTSPEED_16GBIT;
3276 if (speeds & FDMI_PORT_SPEED_8GB)
3277 supported_speeds |= FC_PORTSPEED_8GBIT;
3278 if (speeds & FDMI_PORT_SPEED_4GB)
3279 supported_speeds |= FC_PORTSPEED_4GBIT;
3280 if (speeds & FDMI_PORT_SPEED_2GB)
3281 supported_speeds |= FC_PORTSPEED_2GBIT;
3282 if (speeds & FDMI_PORT_SPEED_1GB)
3283 supported_speeds |= FC_PORTSPEED_1GBIT;
3284
3285 return supported_speeds;
3286 }
3287
3288 void
qla2x00_init_host_attr(scsi_qla_host_t * vha)3289 qla2x00_init_host_attr(scsi_qla_host_t *vha)
3290 {
3291 struct qla_hw_data *ha = vha->hw;
3292 u32 speeds = 0, fdmi_speed = 0;
3293
3294 fc_host_dev_loss_tmo(vha->host) = ha->port_down_retry_count;
3295 fc_host_node_name(vha->host) = wwn_to_u64(vha->node_name);
3296 fc_host_port_name(vha->host) = wwn_to_u64(vha->port_name);
3297 fc_host_supported_classes(vha->host) = ha->base_qpair->enable_class_2 ?
3298 (FC_COS_CLASS2|FC_COS_CLASS3) : FC_COS_CLASS3;
3299 fc_host_max_npiv_vports(vha->host) = ha->max_npiv_vports;
3300 fc_host_npiv_vports_inuse(vha->host) = ha->cur_vport_count;
3301
3302 fdmi_speed = qla25xx_fdmi_port_speed_capability(ha);
3303 speeds = qla2x00_get_host_supported_speeds(vha, fdmi_speed);
3304
3305 fc_host_supported_speeds(vha->host) = speeds;
3306 }
3307