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