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