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