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 if (IS_P3P_TYPE(ha)) { 33 if (off < ha->md_template_size) { 34 rval = memory_read_from_buffer(buf, count, 35 &off, ha->md_tmplt_hdr, ha->md_template_size); 36 return rval; 37 } 38 off -= ha->md_template_size; 39 rval = memory_read_from_buffer(buf, count, 40 &off, ha->md_dump, ha->md_dump_size); 41 return rval; 42 } else if (ha->mctp_dumped && ha->mctp_dump_reading) 43 return memory_read_from_buffer(buf, count, &off, ha->mctp_dump, 44 MCTP_DUMP_SIZE); 45 else if (ha->fw_dump_reading) 46 return memory_read_from_buffer(buf, count, &off, ha->fw_dump, 47 ha->fw_dump_len); 48 else 49 return 0; 50 } 51 52 static ssize_t 53 qla2x00_sysfs_write_fw_dump(struct file *filp, struct kobject *kobj, 54 struct bin_attribute *bin_attr, 55 char *buf, loff_t off, size_t count) 56 { 57 struct scsi_qla_host *vha = shost_priv(dev_to_shost(container_of(kobj, 58 struct device, kobj))); 59 struct qla_hw_data *ha = vha->hw; 60 int reading; 61 62 if (off != 0) 63 return (0); 64 65 reading = simple_strtol(buf, NULL, 10); 66 switch (reading) { 67 case 0: 68 if (!ha->fw_dump_reading) 69 break; 70 71 ql_log(ql_log_info, vha, 0x705d, 72 "Firmware dump cleared on (%ld).\n", vha->host_no); 73 74 if (IS_P3P_TYPE(ha)) { 75 qla82xx_md_free(vha); 76 qla82xx_md_prep(vha); 77 } 78 ha->fw_dump_reading = 0; 79 ha->fw_dumped = 0; 80 break; 81 case 1: 82 if (ha->fw_dumped && !ha->fw_dump_reading) { 83 ha->fw_dump_reading = 1; 84 85 ql_log(ql_log_info, vha, 0x705e, 86 "Raw firmware dump ready for read on (%ld).\n", 87 vha->host_no); 88 } 89 break; 90 case 2: 91 qla2x00_alloc_fw_dump(vha); 92 break; 93 case 3: 94 if (IS_QLA82XX(ha)) { 95 qla82xx_idc_lock(ha); 96 qla82xx_set_reset_owner(vha); 97 qla82xx_idc_unlock(ha); 98 } else if (IS_QLA8044(ha)) { 99 qla8044_idc_lock(ha); 100 qla82xx_set_reset_owner(vha); 101 qla8044_idc_unlock(ha); 102 } else 103 qla2x00_system_error(vha); 104 break; 105 case 4: 106 if (IS_P3P_TYPE(ha)) { 107 if (ha->md_tmplt_hdr) 108 ql_dbg(ql_dbg_user, vha, 0x705b, 109 "MiniDump supported with this firmware.\n"); 110 else 111 ql_dbg(ql_dbg_user, vha, 0x709d, 112 "MiniDump not supported with this firmware.\n"); 113 } 114 break; 115 case 5: 116 if (IS_P3P_TYPE(ha)) 117 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags); 118 break; 119 case 6: 120 if (!ha->mctp_dump_reading) 121 break; 122 ql_log(ql_log_info, vha, 0x70c1, 123 "MCTP dump cleared on (%ld).\n", vha->host_no); 124 ha->mctp_dump_reading = 0; 125 ha->mctp_dumped = 0; 126 break; 127 case 7: 128 if (ha->mctp_dumped && !ha->mctp_dump_reading) { 129 ha->mctp_dump_reading = 1; 130 ql_log(ql_log_info, vha, 0x70c2, 131 "Raw mctp dump ready for read on (%ld).\n", 132 vha->host_no); 133 } 134 break; 135 } 136 return count; 137 } 138 139 static struct bin_attribute sysfs_fw_dump_attr = { 140 .attr = { 141 .name = "fw_dump", 142 .mode = S_IRUSR | S_IWUSR, 143 }, 144 .size = 0, 145 .read = qla2x00_sysfs_read_fw_dump, 146 .write = qla2x00_sysfs_write_fw_dump, 147 }; 148 149 static ssize_t 150 qla2x00_sysfs_read_nvram(struct file *filp, struct kobject *kobj, 151 struct bin_attribute *bin_attr, 152 char *buf, loff_t off, size_t count) 153 { 154 struct scsi_qla_host *vha = shost_priv(dev_to_shost(container_of(kobj, 155 struct device, kobj))); 156 struct qla_hw_data *ha = vha->hw; 157 158 if (!capable(CAP_SYS_ADMIN)) 159 return 0; 160 161 if (IS_NOCACHE_VPD_TYPE(ha)) 162 ha->isp_ops->read_optrom(vha, ha->nvram, ha->flt_region_nvram << 2, 163 ha->nvram_size); 164 return memory_read_from_buffer(buf, count, &off, ha->nvram, 165 ha->nvram_size); 166 } 167 168 static ssize_t 169 qla2x00_sysfs_write_nvram(struct file *filp, struct kobject *kobj, 170 struct bin_attribute *bin_attr, 171 char *buf, loff_t off, size_t count) 172 { 173 struct scsi_qla_host *vha = shost_priv(dev_to_shost(container_of(kobj, 174 struct device, kobj))); 175 struct qla_hw_data *ha = vha->hw; 176 uint16_t cnt; 177 178 if (!capable(CAP_SYS_ADMIN) || off != 0 || count != ha->nvram_size || 179 !ha->isp_ops->write_nvram) 180 return -EINVAL; 181 182 /* Checksum NVRAM. */ 183 if (IS_FWI2_CAPABLE(ha)) { 184 uint32_t *iter; 185 uint32_t chksum; 186 187 iter = (uint32_t *)buf; 188 chksum = 0; 189 for (cnt = 0; cnt < ((count >> 2) - 1); cnt++, iter++) 190 chksum += le32_to_cpu(*iter); 191 chksum = ~chksum + 1; 192 *iter = cpu_to_le32(chksum); 193 } else { 194 uint8_t *iter; 195 uint8_t chksum; 196 197 iter = (uint8_t *)buf; 198 chksum = 0; 199 for (cnt = 0; cnt < count - 1; cnt++) 200 chksum += *iter++; 201 chksum = ~chksum + 1; 202 *iter = chksum; 203 } 204 205 if (qla2x00_wait_for_hba_online(vha) != QLA_SUCCESS) { 206 ql_log(ql_log_warn, vha, 0x705f, 207 "HBA not online, failing NVRAM update.\n"); 208 return -EAGAIN; 209 } 210 211 /* Write NVRAM. */ 212 ha->isp_ops->write_nvram(vha, (uint8_t *)buf, ha->nvram_base, count); 213 ha->isp_ops->read_nvram(vha, (uint8_t *)ha->nvram, ha->nvram_base, 214 count); 215 216 ql_dbg(ql_dbg_user, vha, 0x7060, 217 "Setting ISP_ABORT_NEEDED\n"); 218 /* NVRAM settings take effect immediately. */ 219 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags); 220 qla2xxx_wake_dpc(vha); 221 qla2x00_wait_for_chip_reset(vha); 222 223 return count; 224 } 225 226 static struct bin_attribute sysfs_nvram_attr = { 227 .attr = { 228 .name = "nvram", 229 .mode = S_IRUSR | S_IWUSR, 230 }, 231 .size = 512, 232 .read = qla2x00_sysfs_read_nvram, 233 .write = qla2x00_sysfs_write_nvram, 234 }; 235 236 static ssize_t 237 qla2x00_sysfs_read_optrom(struct file *filp, struct kobject *kobj, 238 struct bin_attribute *bin_attr, 239 char *buf, loff_t off, size_t count) 240 { 241 struct scsi_qla_host *vha = shost_priv(dev_to_shost(container_of(kobj, 242 struct device, kobj))); 243 struct qla_hw_data *ha = vha->hw; 244 ssize_t rval = 0; 245 246 mutex_lock(&ha->optrom_mutex); 247 248 if (ha->optrom_state != QLA_SREADING) 249 goto out; 250 251 rval = memory_read_from_buffer(buf, count, &off, ha->optrom_buffer, 252 ha->optrom_region_size); 253 254 out: 255 mutex_unlock(&ha->optrom_mutex); 256 257 return rval; 258 } 259 260 static ssize_t 261 qla2x00_sysfs_write_optrom(struct file *filp, struct kobject *kobj, 262 struct bin_attribute *bin_attr, 263 char *buf, loff_t off, size_t count) 264 { 265 struct scsi_qla_host *vha = shost_priv(dev_to_shost(container_of(kobj, 266 struct device, kobj))); 267 struct qla_hw_data *ha = vha->hw; 268 269 mutex_lock(&ha->optrom_mutex); 270 271 if (ha->optrom_state != QLA_SWRITING) { 272 mutex_unlock(&ha->optrom_mutex); 273 return -EINVAL; 274 } 275 if (off > ha->optrom_region_size) { 276 mutex_unlock(&ha->optrom_mutex); 277 return -ERANGE; 278 } 279 if (off + count > ha->optrom_region_size) 280 count = ha->optrom_region_size - off; 281 282 memcpy(&ha->optrom_buffer[off], buf, count); 283 mutex_unlock(&ha->optrom_mutex); 284 285 return count; 286 } 287 288 static struct bin_attribute sysfs_optrom_attr = { 289 .attr = { 290 .name = "optrom", 291 .mode = S_IRUSR | S_IWUSR, 292 }, 293 .size = 0, 294 .read = qla2x00_sysfs_read_optrom, 295 .write = qla2x00_sysfs_write_optrom, 296 }; 297 298 static ssize_t 299 qla2x00_sysfs_write_optrom_ctl(struct file *filp, struct kobject *kobj, 300 struct bin_attribute *bin_attr, 301 char *buf, loff_t off, size_t count) 302 { 303 struct scsi_qla_host *vha = shost_priv(dev_to_shost(container_of(kobj, 304 struct device, kobj))); 305 struct qla_hw_data *ha = vha->hw; 306 uint32_t start = 0; 307 uint32_t size = ha->optrom_size; 308 int val, valid; 309 ssize_t rval = count; 310 311 if (off) 312 return -EINVAL; 313 314 if (unlikely(pci_channel_offline(ha->pdev))) 315 return -EAGAIN; 316 317 if (sscanf(buf, "%d:%x:%x", &val, &start, &size) < 1) 318 return -EINVAL; 319 if (start > ha->optrom_size) 320 return -EINVAL; 321 if (size > ha->optrom_size - start) 322 size = ha->optrom_size - start; 323 324 mutex_lock(&ha->optrom_mutex); 325 switch (val) { 326 case 0: 327 if (ha->optrom_state != QLA_SREADING && 328 ha->optrom_state != QLA_SWRITING) { 329 rval = -EINVAL; 330 goto out; 331 } 332 ha->optrom_state = QLA_SWAITING; 333 334 ql_dbg(ql_dbg_user, vha, 0x7061, 335 "Freeing flash region allocation -- 0x%x bytes.\n", 336 ha->optrom_region_size); 337 338 vfree(ha->optrom_buffer); 339 ha->optrom_buffer = NULL; 340 break; 341 case 1: 342 if (ha->optrom_state != QLA_SWAITING) { 343 rval = -EINVAL; 344 goto out; 345 } 346 347 ha->optrom_region_start = start; 348 ha->optrom_region_size = start + size; 349 350 ha->optrom_state = QLA_SREADING; 351 ha->optrom_buffer = vmalloc(ha->optrom_region_size); 352 if (ha->optrom_buffer == NULL) { 353 ql_log(ql_log_warn, vha, 0x7062, 354 "Unable to allocate memory for optrom retrieval " 355 "(%x).\n", ha->optrom_region_size); 356 357 ha->optrom_state = QLA_SWAITING; 358 rval = -ENOMEM; 359 goto out; 360 } 361 362 if (qla2x00_wait_for_hba_online(vha) != QLA_SUCCESS) { 363 ql_log(ql_log_warn, vha, 0x7063, 364 "HBA not online, failing NVRAM update.\n"); 365 rval = -EAGAIN; 366 goto out; 367 } 368 369 ql_dbg(ql_dbg_user, vha, 0x7064, 370 "Reading flash region -- 0x%x/0x%x.\n", 371 ha->optrom_region_start, ha->optrom_region_size); 372 373 memset(ha->optrom_buffer, 0, ha->optrom_region_size); 374 ha->isp_ops->read_optrom(vha, ha->optrom_buffer, 375 ha->optrom_region_start, ha->optrom_region_size); 376 break; 377 case 2: 378 if (ha->optrom_state != QLA_SWAITING) { 379 rval = -EINVAL; 380 goto out; 381 } 382 383 /* 384 * We need to be more restrictive on which FLASH regions are 385 * allowed to be updated via user-space. Regions accessible 386 * via this method include: 387 * 388 * ISP21xx/ISP22xx/ISP23xx type boards: 389 * 390 * 0x000000 -> 0x020000 -- Boot code. 391 * 392 * ISP2322/ISP24xx type boards: 393 * 394 * 0x000000 -> 0x07ffff -- Boot code. 395 * 0x080000 -> 0x0fffff -- Firmware. 396 * 397 * ISP25xx type boards: 398 * 399 * 0x000000 -> 0x07ffff -- Boot code. 400 * 0x080000 -> 0x0fffff -- Firmware. 401 * 0x120000 -> 0x12ffff -- VPD and HBA parameters. 402 */ 403 valid = 0; 404 if (ha->optrom_size == OPTROM_SIZE_2300 && start == 0) 405 valid = 1; 406 else if (start == (ha->flt_region_boot * 4) || 407 start == (ha->flt_region_fw * 4)) 408 valid = 1; 409 else if (IS_QLA24XX_TYPE(ha) || IS_QLA25XX(ha) 410 || IS_CNA_CAPABLE(ha) || IS_QLA2031(ha) 411 || IS_QLA27XX(ha)) 412 valid = 1; 413 if (!valid) { 414 ql_log(ql_log_warn, vha, 0x7065, 415 "Invalid start region 0x%x/0x%x.\n", start, size); 416 rval = -EINVAL; 417 goto out; 418 } 419 420 ha->optrom_region_start = start; 421 ha->optrom_region_size = start + size; 422 423 ha->optrom_state = QLA_SWRITING; 424 ha->optrom_buffer = vmalloc(ha->optrom_region_size); 425 if (ha->optrom_buffer == NULL) { 426 ql_log(ql_log_warn, vha, 0x7066, 427 "Unable to allocate memory for optrom update " 428 "(%x)\n", ha->optrom_region_size); 429 430 ha->optrom_state = QLA_SWAITING; 431 rval = -ENOMEM; 432 goto out; 433 } 434 435 ql_dbg(ql_dbg_user, vha, 0x7067, 436 "Staging flash region write -- 0x%x/0x%x.\n", 437 ha->optrom_region_start, ha->optrom_region_size); 438 439 memset(ha->optrom_buffer, 0, ha->optrom_region_size); 440 break; 441 case 3: 442 if (ha->optrom_state != QLA_SWRITING) { 443 rval = -EINVAL; 444 goto out; 445 } 446 447 if (qla2x00_wait_for_hba_online(vha) != QLA_SUCCESS) { 448 ql_log(ql_log_warn, vha, 0x7068, 449 "HBA not online, failing flash update.\n"); 450 rval = -EAGAIN; 451 goto out; 452 } 453 454 ql_dbg(ql_dbg_user, vha, 0x7069, 455 "Writing flash region -- 0x%x/0x%x.\n", 456 ha->optrom_region_start, ha->optrom_region_size); 457 458 ha->isp_ops->write_optrom(vha, ha->optrom_buffer, 459 ha->optrom_region_start, ha->optrom_region_size); 460 break; 461 default: 462 rval = -EINVAL; 463 } 464 465 out: 466 mutex_unlock(&ha->optrom_mutex); 467 return rval; 468 } 469 470 static struct bin_attribute sysfs_optrom_ctl_attr = { 471 .attr = { 472 .name = "optrom_ctl", 473 .mode = S_IWUSR, 474 }, 475 .size = 0, 476 .write = qla2x00_sysfs_write_optrom_ctl, 477 }; 478 479 static ssize_t 480 qla2x00_sysfs_read_vpd(struct file *filp, struct kobject *kobj, 481 struct bin_attribute *bin_attr, 482 char *buf, loff_t off, size_t count) 483 { 484 struct scsi_qla_host *vha = shost_priv(dev_to_shost(container_of(kobj, 485 struct device, kobj))); 486 struct qla_hw_data *ha = vha->hw; 487 uint32_t faddr; 488 489 if (unlikely(pci_channel_offline(ha->pdev))) 490 return -EAGAIN; 491 492 if (!capable(CAP_SYS_ADMIN)) 493 return -EINVAL; 494 495 if (IS_NOCACHE_VPD_TYPE(ha)) { 496 faddr = ha->flt_region_vpd << 2; 497 498 if (IS_QLA27XX(ha) && 499 qla27xx_find_valid_image(vha) == QLA27XX_SECONDARY_IMAGE) 500 faddr = ha->flt_region_vpd_sec << 2; 501 502 ha->isp_ops->read_optrom(vha, ha->vpd, faddr, 503 ha->vpd_size); 504 } 505 return memory_read_from_buffer(buf, count, &off, ha->vpd, ha->vpd_size); 506 } 507 508 static ssize_t 509 qla2x00_sysfs_write_vpd(struct file *filp, struct kobject *kobj, 510 struct bin_attribute *bin_attr, 511 char *buf, loff_t off, size_t count) 512 { 513 struct scsi_qla_host *vha = shost_priv(dev_to_shost(container_of(kobj, 514 struct device, kobj))); 515 struct qla_hw_data *ha = vha->hw; 516 uint8_t *tmp_data; 517 518 if (unlikely(pci_channel_offline(ha->pdev))) 519 return 0; 520 521 if (!capable(CAP_SYS_ADMIN) || off != 0 || count != ha->vpd_size || 522 !ha->isp_ops->write_nvram) 523 return 0; 524 525 if (qla2x00_wait_for_hba_online(vha) != QLA_SUCCESS) { 526 ql_log(ql_log_warn, vha, 0x706a, 527 "HBA not online, failing VPD update.\n"); 528 return -EAGAIN; 529 } 530 531 /* Write NVRAM. */ 532 ha->isp_ops->write_nvram(vha, (uint8_t *)buf, ha->vpd_base, count); 533 ha->isp_ops->read_nvram(vha, (uint8_t *)ha->vpd, ha->vpd_base, count); 534 535 /* Update flash version information for 4Gb & above. */ 536 if (!IS_FWI2_CAPABLE(ha)) 537 return -EINVAL; 538 539 tmp_data = vmalloc(256); 540 if (!tmp_data) { 541 ql_log(ql_log_warn, vha, 0x706b, 542 "Unable to allocate memory for VPD information update.\n"); 543 return -ENOMEM; 544 } 545 ha->isp_ops->get_flash_version(vha, tmp_data); 546 vfree(tmp_data); 547 548 return count; 549 } 550 551 static struct bin_attribute sysfs_vpd_attr = { 552 .attr = { 553 .name = "vpd", 554 .mode = S_IRUSR | S_IWUSR, 555 }, 556 .size = 0, 557 .read = qla2x00_sysfs_read_vpd, 558 .write = qla2x00_sysfs_write_vpd, 559 }; 560 561 static ssize_t 562 qla2x00_sysfs_read_sfp(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 int rval; 569 570 if (!capable(CAP_SYS_ADMIN) || off != 0 || count < SFP_DEV_SIZE) 571 return 0; 572 573 if (qla2x00_reset_active(vha)) 574 return 0; 575 576 rval = qla2x00_read_sfp_dev(vha, buf, count); 577 if (rval) 578 return -EIO; 579 580 return count; 581 } 582 583 static struct bin_attribute sysfs_sfp_attr = { 584 .attr = { 585 .name = "sfp", 586 .mode = S_IRUSR | S_IWUSR, 587 }, 588 .size = SFP_DEV_SIZE, 589 .read = qla2x00_sysfs_read_sfp, 590 }; 591 592 static ssize_t 593 qla2x00_sysfs_write_reset(struct file *filp, struct kobject *kobj, 594 struct bin_attribute *bin_attr, 595 char *buf, loff_t off, size_t count) 596 { 597 struct scsi_qla_host *vha = shost_priv(dev_to_shost(container_of(kobj, 598 struct device, kobj))); 599 struct qla_hw_data *ha = vha->hw; 600 struct scsi_qla_host *base_vha = pci_get_drvdata(ha->pdev); 601 int type; 602 uint32_t idc_control; 603 uint8_t *tmp_data = NULL; 604 if (off != 0) 605 return -EINVAL; 606 607 type = simple_strtol(buf, NULL, 10); 608 switch (type) { 609 case 0x2025c: 610 ql_log(ql_log_info, vha, 0x706e, 611 "Issuing ISP reset.\n"); 612 613 scsi_block_requests(vha->host); 614 if (IS_QLA82XX(ha)) { 615 ha->flags.isp82xx_no_md_cap = 1; 616 qla82xx_idc_lock(ha); 617 qla82xx_set_reset_owner(vha); 618 qla82xx_idc_unlock(ha); 619 } else if (IS_QLA8044(ha)) { 620 qla8044_idc_lock(ha); 621 idc_control = qla8044_rd_reg(ha, 622 QLA8044_IDC_DRV_CTRL); 623 qla8044_wr_reg(ha, QLA8044_IDC_DRV_CTRL, 624 (idc_control | GRACEFUL_RESET_BIT1)); 625 qla82xx_set_reset_owner(vha); 626 qla8044_idc_unlock(ha); 627 } else { 628 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags); 629 qla2xxx_wake_dpc(vha); 630 } 631 qla2x00_wait_for_chip_reset(vha); 632 scsi_unblock_requests(vha->host); 633 break; 634 case 0x2025d: 635 if (!IS_QLA81XX(ha) && !IS_QLA83XX(ha)) 636 return -EPERM; 637 638 ql_log(ql_log_info, vha, 0x706f, 639 "Issuing MPI reset.\n"); 640 641 if (IS_QLA83XX(ha) || IS_QLA27XX(ha)) { 642 uint32_t idc_control; 643 644 qla83xx_idc_lock(vha, 0); 645 __qla83xx_get_idc_control(vha, &idc_control); 646 idc_control |= QLA83XX_IDC_GRACEFUL_RESET; 647 __qla83xx_set_idc_control(vha, idc_control); 648 qla83xx_wr_reg(vha, QLA83XX_IDC_DEV_STATE, 649 QLA8XXX_DEV_NEED_RESET); 650 qla83xx_idc_audit(vha, IDC_AUDIT_TIMESTAMP); 651 qla83xx_idc_unlock(vha, 0); 652 break; 653 } else { 654 /* Make sure FC side is not in reset */ 655 qla2x00_wait_for_hba_online(vha); 656 657 /* Issue MPI reset */ 658 scsi_block_requests(vha->host); 659 if (qla81xx_restart_mpi_firmware(vha) != QLA_SUCCESS) 660 ql_log(ql_log_warn, vha, 0x7070, 661 "MPI reset failed.\n"); 662 scsi_unblock_requests(vha->host); 663 break; 664 } 665 case 0x2025e: 666 if (!IS_P3P_TYPE(ha) || vha != base_vha) { 667 ql_log(ql_log_info, vha, 0x7071, 668 "FCoE ctx reset not supported.\n"); 669 return -EPERM; 670 } 671 672 ql_log(ql_log_info, vha, 0x7072, 673 "Issuing FCoE ctx reset.\n"); 674 set_bit(FCOE_CTX_RESET_NEEDED, &vha->dpc_flags); 675 qla2xxx_wake_dpc(vha); 676 qla2x00_wait_for_fcoe_ctx_reset(vha); 677 break; 678 case 0x2025f: 679 if (!IS_QLA8031(ha)) 680 return -EPERM; 681 ql_log(ql_log_info, vha, 0x70bc, 682 "Disabling Reset by IDC control\n"); 683 qla83xx_idc_lock(vha, 0); 684 __qla83xx_get_idc_control(vha, &idc_control); 685 idc_control |= QLA83XX_IDC_RESET_DISABLED; 686 __qla83xx_set_idc_control(vha, idc_control); 687 qla83xx_idc_unlock(vha, 0); 688 break; 689 case 0x20260: 690 if (!IS_QLA8031(ha)) 691 return -EPERM; 692 ql_log(ql_log_info, vha, 0x70bd, 693 "Enabling Reset by IDC control\n"); 694 qla83xx_idc_lock(vha, 0); 695 __qla83xx_get_idc_control(vha, &idc_control); 696 idc_control &= ~QLA83XX_IDC_RESET_DISABLED; 697 __qla83xx_set_idc_control(vha, idc_control); 698 qla83xx_idc_unlock(vha, 0); 699 break; 700 case 0x20261: 701 ql_dbg(ql_dbg_user, vha, 0x70e0, 702 "Updating cache versions without reset "); 703 704 tmp_data = vmalloc(256); 705 if (!tmp_data) { 706 ql_log(ql_log_warn, vha, 0x70e1, 707 "Unable to allocate memory for VPD information update.\n"); 708 return -ENOMEM; 709 } 710 ha->isp_ops->get_flash_version(vha, tmp_data); 711 vfree(tmp_data); 712 break; 713 } 714 return count; 715 } 716 717 static struct bin_attribute sysfs_reset_attr = { 718 .attr = { 719 .name = "reset", 720 .mode = S_IWUSR, 721 }, 722 .size = 0, 723 .write = qla2x00_sysfs_write_reset, 724 }; 725 726 static ssize_t 727 qla2x00_issue_logo(struct file *filp, struct kobject *kobj, 728 struct bin_attribute *bin_attr, 729 char *buf, loff_t off, size_t count) 730 { 731 struct scsi_qla_host *vha = shost_priv(dev_to_shost(container_of(kobj, 732 struct device, kobj))); 733 int type; 734 port_id_t did; 735 736 type = simple_strtol(buf, NULL, 10); 737 738 did.b.domain = (type & 0x00ff0000) >> 16; 739 did.b.area = (type & 0x0000ff00) >> 8; 740 did.b.al_pa = (type & 0x000000ff); 741 742 ql_log(ql_log_info, vha, 0xd04d, "portid=%02x%02x%02x done\n", 743 did.b.domain, did.b.area, did.b.al_pa); 744 745 ql_log(ql_log_info, vha, 0x70e4, "%s: %d\n", __func__, type); 746 747 qla24xx_els_dcmd_iocb(vha, ELS_DCMD_LOGO, did); 748 return count; 749 } 750 751 static struct bin_attribute sysfs_issue_logo_attr = { 752 .attr = { 753 .name = "issue_logo", 754 .mode = S_IWUSR, 755 }, 756 .size = 0, 757 .write = qla2x00_issue_logo, 758 }; 759 760 static ssize_t 761 qla2x00_sysfs_read_xgmac_stats(struct file *filp, struct kobject *kobj, 762 struct bin_attribute *bin_attr, 763 char *buf, loff_t off, size_t count) 764 { 765 struct scsi_qla_host *vha = shost_priv(dev_to_shost(container_of(kobj, 766 struct device, kobj))); 767 struct qla_hw_data *ha = vha->hw; 768 int rval; 769 uint16_t actual_size; 770 771 if (!capable(CAP_SYS_ADMIN) || off != 0 || count > XGMAC_DATA_SIZE) 772 return 0; 773 774 if (ha->xgmac_data) 775 goto do_read; 776 777 ha->xgmac_data = dma_alloc_coherent(&ha->pdev->dev, XGMAC_DATA_SIZE, 778 &ha->xgmac_data_dma, GFP_KERNEL); 779 if (!ha->xgmac_data) { 780 ql_log(ql_log_warn, vha, 0x7076, 781 "Unable to allocate memory for XGMAC read-data.\n"); 782 return 0; 783 } 784 785 do_read: 786 actual_size = 0; 787 memset(ha->xgmac_data, 0, XGMAC_DATA_SIZE); 788 789 rval = qla2x00_get_xgmac_stats(vha, ha->xgmac_data_dma, 790 XGMAC_DATA_SIZE, &actual_size); 791 if (rval != QLA_SUCCESS) { 792 ql_log(ql_log_warn, vha, 0x7077, 793 "Unable to read XGMAC data (%x).\n", rval); 794 count = 0; 795 } 796 797 count = actual_size > count ? count: actual_size; 798 memcpy(buf, ha->xgmac_data, count); 799 800 return count; 801 } 802 803 static struct bin_attribute sysfs_xgmac_stats_attr = { 804 .attr = { 805 .name = "xgmac_stats", 806 .mode = S_IRUSR, 807 }, 808 .size = 0, 809 .read = qla2x00_sysfs_read_xgmac_stats, 810 }; 811 812 static ssize_t 813 qla2x00_sysfs_read_dcbx_tlv(struct file *filp, struct kobject *kobj, 814 struct bin_attribute *bin_attr, 815 char *buf, loff_t off, size_t count) 816 { 817 struct scsi_qla_host *vha = shost_priv(dev_to_shost(container_of(kobj, 818 struct device, kobj))); 819 struct qla_hw_data *ha = vha->hw; 820 int rval; 821 822 if (!capable(CAP_SYS_ADMIN) || off != 0 || count > DCBX_TLV_DATA_SIZE) 823 return 0; 824 825 if (ha->dcbx_tlv) 826 goto do_read; 827 828 ha->dcbx_tlv = dma_alloc_coherent(&ha->pdev->dev, DCBX_TLV_DATA_SIZE, 829 &ha->dcbx_tlv_dma, GFP_KERNEL); 830 if (!ha->dcbx_tlv) { 831 ql_log(ql_log_warn, vha, 0x7078, 832 "Unable to allocate memory for DCBX TLV read-data.\n"); 833 return -ENOMEM; 834 } 835 836 do_read: 837 memset(ha->dcbx_tlv, 0, DCBX_TLV_DATA_SIZE); 838 839 rval = qla2x00_get_dcbx_params(vha, ha->dcbx_tlv_dma, 840 DCBX_TLV_DATA_SIZE); 841 if (rval != QLA_SUCCESS) { 842 ql_log(ql_log_warn, vha, 0x7079, 843 "Unable to read DCBX TLV (%x).\n", rval); 844 return -EIO; 845 } 846 847 memcpy(buf, ha->dcbx_tlv, count); 848 849 return count; 850 } 851 852 static struct bin_attribute sysfs_dcbx_tlv_attr = { 853 .attr = { 854 .name = "dcbx_tlv", 855 .mode = S_IRUSR, 856 }, 857 .size = 0, 858 .read = qla2x00_sysfs_read_dcbx_tlv, 859 }; 860 861 static struct sysfs_entry { 862 char *name; 863 struct bin_attribute *attr; 864 int is4GBp_only; 865 } bin_file_entries[] = { 866 { "fw_dump", &sysfs_fw_dump_attr, }, 867 { "nvram", &sysfs_nvram_attr, }, 868 { "optrom", &sysfs_optrom_attr, }, 869 { "optrom_ctl", &sysfs_optrom_ctl_attr, }, 870 { "vpd", &sysfs_vpd_attr, 1 }, 871 { "sfp", &sysfs_sfp_attr, 1 }, 872 { "reset", &sysfs_reset_attr, }, 873 { "issue_logo", &sysfs_issue_logo_attr, }, 874 { "xgmac_stats", &sysfs_xgmac_stats_attr, 3 }, 875 { "dcbx_tlv", &sysfs_dcbx_tlv_attr, 3 }, 876 { NULL }, 877 }; 878 879 void 880 qla2x00_alloc_sysfs_attr(scsi_qla_host_t *vha) 881 { 882 struct Scsi_Host *host = vha->host; 883 struct sysfs_entry *iter; 884 int ret; 885 886 for (iter = bin_file_entries; iter->name; iter++) { 887 if (iter->is4GBp_only && !IS_FWI2_CAPABLE(vha->hw)) 888 continue; 889 if (iter->is4GBp_only == 2 && !IS_QLA25XX(vha->hw)) 890 continue; 891 if (iter->is4GBp_only == 3 && !(IS_CNA_CAPABLE(vha->hw))) 892 continue; 893 894 ret = sysfs_create_bin_file(&host->shost_gendev.kobj, 895 iter->attr); 896 if (ret) 897 ql_log(ql_log_warn, vha, 0x00f3, 898 "Unable to create sysfs %s binary attribute (%d).\n", 899 iter->name, ret); 900 else 901 ql_dbg(ql_dbg_init, vha, 0x00f4, 902 "Successfully created sysfs %s binary attribute.\n", 903 iter->name); 904 } 905 } 906 907 void 908 qla2x00_free_sysfs_attr(scsi_qla_host_t *vha, bool stop_beacon) 909 { 910 struct Scsi_Host *host = vha->host; 911 struct sysfs_entry *iter; 912 struct qla_hw_data *ha = vha->hw; 913 914 for (iter = bin_file_entries; iter->name; iter++) { 915 if (iter->is4GBp_only && !IS_FWI2_CAPABLE(ha)) 916 continue; 917 if (iter->is4GBp_only == 2 && !IS_QLA25XX(ha)) 918 continue; 919 if (iter->is4GBp_only == 3 && !(IS_CNA_CAPABLE(vha->hw))) 920 continue; 921 if (iter->is4GBp_only == 0x27 && !IS_QLA27XX(vha->hw)) 922 continue; 923 924 sysfs_remove_bin_file(&host->shost_gendev.kobj, 925 iter->attr); 926 } 927 928 if (stop_beacon && ha->beacon_blink_led == 1) 929 ha->isp_ops->beacon_off(vha); 930 } 931 932 /* Scsi_Host attributes. */ 933 934 static ssize_t 935 qla2x00_drvr_version_show(struct device *dev, 936 struct device_attribute *attr, char *buf) 937 { 938 return scnprintf(buf, PAGE_SIZE, "%s\n", qla2x00_version_str); 939 } 940 941 static ssize_t 942 qla2x00_fw_version_show(struct device *dev, 943 struct device_attribute *attr, char *buf) 944 { 945 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev)); 946 struct qla_hw_data *ha = vha->hw; 947 char fw_str[128]; 948 949 return scnprintf(buf, PAGE_SIZE, "%s\n", 950 ha->isp_ops->fw_version_str(vha, fw_str, sizeof(fw_str))); 951 } 952 953 static ssize_t 954 qla2x00_serial_num_show(struct device *dev, struct device_attribute *attr, 955 char *buf) 956 { 957 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev)); 958 struct qla_hw_data *ha = vha->hw; 959 uint32_t sn; 960 961 if (IS_QLAFX00(vha->hw)) { 962 return scnprintf(buf, PAGE_SIZE, "%s\n", 963 vha->hw->mr.serial_num); 964 } else if (IS_FWI2_CAPABLE(ha)) { 965 qla2xxx_get_vpd_field(vha, "SN", buf, PAGE_SIZE - 1); 966 return strlen(strcat(buf, "\n")); 967 } 968 969 sn = ((ha->serial0 & 0x1f) << 16) | (ha->serial2 << 8) | ha->serial1; 970 return scnprintf(buf, PAGE_SIZE, "%c%05d\n", 'A' + sn / 100000, 971 sn % 100000); 972 } 973 974 static ssize_t 975 qla2x00_isp_name_show(struct device *dev, struct device_attribute *attr, 976 char *buf) 977 { 978 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev)); 979 return scnprintf(buf, PAGE_SIZE, "ISP%04X\n", vha->hw->pdev->device); 980 } 981 982 static ssize_t 983 qla2x00_isp_id_show(struct device *dev, struct device_attribute *attr, 984 char *buf) 985 { 986 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev)); 987 struct qla_hw_data *ha = vha->hw; 988 989 if (IS_QLAFX00(vha->hw)) 990 return scnprintf(buf, PAGE_SIZE, "%s\n", 991 vha->hw->mr.hw_version); 992 993 return scnprintf(buf, PAGE_SIZE, "%04x %04x %04x %04x\n", 994 ha->product_id[0], ha->product_id[1], ha->product_id[2], 995 ha->product_id[3]); 996 } 997 998 static ssize_t 999 qla2x00_model_name_show(struct device *dev, struct device_attribute *attr, 1000 char *buf) 1001 { 1002 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev)); 1003 1004 return scnprintf(buf, PAGE_SIZE, "%s\n", vha->hw->model_number); 1005 } 1006 1007 static ssize_t 1008 qla2x00_model_desc_show(struct device *dev, struct device_attribute *attr, 1009 char *buf) 1010 { 1011 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev)); 1012 return scnprintf(buf, PAGE_SIZE, "%s\n", vha->hw->model_desc); 1013 } 1014 1015 static ssize_t 1016 qla2x00_pci_info_show(struct device *dev, struct device_attribute *attr, 1017 char *buf) 1018 { 1019 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev)); 1020 char pci_info[30]; 1021 1022 return scnprintf(buf, PAGE_SIZE, "%s\n", 1023 vha->hw->isp_ops->pci_info_str(vha, pci_info)); 1024 } 1025 1026 static ssize_t 1027 qla2x00_link_state_show(struct device *dev, struct device_attribute *attr, 1028 char *buf) 1029 { 1030 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev)); 1031 struct qla_hw_data *ha = vha->hw; 1032 int len = 0; 1033 1034 if (atomic_read(&vha->loop_state) == LOOP_DOWN || 1035 atomic_read(&vha->loop_state) == LOOP_DEAD || 1036 vha->device_flags & DFLG_NO_CABLE) 1037 len = scnprintf(buf, PAGE_SIZE, "Link Down\n"); 1038 else if (atomic_read(&vha->loop_state) != LOOP_READY || 1039 qla2x00_reset_active(vha)) 1040 len = scnprintf(buf, PAGE_SIZE, "Unknown Link State\n"); 1041 else { 1042 len = scnprintf(buf, PAGE_SIZE, "Link Up - "); 1043 1044 switch (ha->current_topology) { 1045 case ISP_CFG_NL: 1046 len += scnprintf(buf + len, PAGE_SIZE-len, "Loop\n"); 1047 break; 1048 case ISP_CFG_FL: 1049 len += scnprintf(buf + len, PAGE_SIZE-len, "FL_Port\n"); 1050 break; 1051 case ISP_CFG_N: 1052 len += scnprintf(buf + len, PAGE_SIZE-len, 1053 "N_Port to N_Port\n"); 1054 break; 1055 case ISP_CFG_F: 1056 len += scnprintf(buf + len, PAGE_SIZE-len, "F_Port\n"); 1057 break; 1058 default: 1059 len += scnprintf(buf + len, PAGE_SIZE-len, "Loop\n"); 1060 break; 1061 } 1062 } 1063 return len; 1064 } 1065 1066 static ssize_t 1067 qla2x00_zio_show(struct device *dev, struct device_attribute *attr, 1068 char *buf) 1069 { 1070 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev)); 1071 int len = 0; 1072 1073 switch (vha->hw->zio_mode) { 1074 case QLA_ZIO_MODE_6: 1075 len += scnprintf(buf + len, PAGE_SIZE-len, "Mode 6\n"); 1076 break; 1077 case QLA_ZIO_DISABLED: 1078 len += scnprintf(buf + len, PAGE_SIZE-len, "Disabled\n"); 1079 break; 1080 } 1081 return len; 1082 } 1083 1084 static ssize_t 1085 qla2x00_zio_store(struct device *dev, struct device_attribute *attr, 1086 const char *buf, size_t count) 1087 { 1088 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev)); 1089 struct qla_hw_data *ha = vha->hw; 1090 int val = 0; 1091 uint16_t zio_mode; 1092 1093 if (!IS_ZIO_SUPPORTED(ha)) 1094 return -ENOTSUPP; 1095 1096 if (sscanf(buf, "%d", &val) != 1) 1097 return -EINVAL; 1098 1099 if (val) 1100 zio_mode = QLA_ZIO_MODE_6; 1101 else 1102 zio_mode = QLA_ZIO_DISABLED; 1103 1104 /* Update per-hba values and queue a reset. */ 1105 if (zio_mode != QLA_ZIO_DISABLED || ha->zio_mode != QLA_ZIO_DISABLED) { 1106 ha->zio_mode = zio_mode; 1107 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags); 1108 } 1109 return strlen(buf); 1110 } 1111 1112 static ssize_t 1113 qla2x00_zio_timer_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, "%d us\n", vha->hw->zio_timer * 100); 1119 } 1120 1121 static ssize_t 1122 qla2x00_zio_timer_store(struct device *dev, struct device_attribute *attr, 1123 const char *buf, size_t count) 1124 { 1125 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev)); 1126 int val = 0; 1127 uint16_t zio_timer; 1128 1129 if (sscanf(buf, "%d", &val) != 1) 1130 return -EINVAL; 1131 if (val > 25500 || val < 100) 1132 return -ERANGE; 1133 1134 zio_timer = (uint16_t)(val / 100); 1135 vha->hw->zio_timer = zio_timer; 1136 1137 return strlen(buf); 1138 } 1139 1140 static ssize_t 1141 qla2x00_beacon_show(struct device *dev, struct device_attribute *attr, 1142 char *buf) 1143 { 1144 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev)); 1145 int len = 0; 1146 1147 if (vha->hw->beacon_blink_led) 1148 len += scnprintf(buf + len, PAGE_SIZE-len, "Enabled\n"); 1149 else 1150 len += scnprintf(buf + len, PAGE_SIZE-len, "Disabled\n"); 1151 return len; 1152 } 1153 1154 static ssize_t 1155 qla2x00_beacon_store(struct device *dev, struct device_attribute *attr, 1156 const char *buf, size_t count) 1157 { 1158 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev)); 1159 struct qla_hw_data *ha = vha->hw; 1160 int val = 0; 1161 int rval; 1162 1163 if (IS_QLA2100(ha) || IS_QLA2200(ha)) 1164 return -EPERM; 1165 1166 if (test_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags)) { 1167 ql_log(ql_log_warn, vha, 0x707a, 1168 "Abort ISP active -- ignoring beacon request.\n"); 1169 return -EBUSY; 1170 } 1171 1172 if (sscanf(buf, "%d", &val) != 1) 1173 return -EINVAL; 1174 1175 if (val) 1176 rval = ha->isp_ops->beacon_on(vha); 1177 else 1178 rval = ha->isp_ops->beacon_off(vha); 1179 1180 if (rval != QLA_SUCCESS) 1181 count = 0; 1182 1183 return count; 1184 } 1185 1186 static ssize_t 1187 qla2x00_optrom_bios_version_show(struct device *dev, 1188 struct device_attribute *attr, char *buf) 1189 { 1190 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev)); 1191 struct qla_hw_data *ha = vha->hw; 1192 return scnprintf(buf, PAGE_SIZE, "%d.%02d\n", ha->bios_revision[1], 1193 ha->bios_revision[0]); 1194 } 1195 1196 static ssize_t 1197 qla2x00_optrom_efi_version_show(struct device *dev, 1198 struct device_attribute *attr, char *buf) 1199 { 1200 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev)); 1201 struct qla_hw_data *ha = vha->hw; 1202 return scnprintf(buf, PAGE_SIZE, "%d.%02d\n", ha->efi_revision[1], 1203 ha->efi_revision[0]); 1204 } 1205 1206 static ssize_t 1207 qla2x00_optrom_fcode_version_show(struct device *dev, 1208 struct device_attribute *attr, char *buf) 1209 { 1210 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev)); 1211 struct qla_hw_data *ha = vha->hw; 1212 return scnprintf(buf, PAGE_SIZE, "%d.%02d\n", ha->fcode_revision[1], 1213 ha->fcode_revision[0]); 1214 } 1215 1216 static ssize_t 1217 qla2x00_optrom_fw_version_show(struct device *dev, 1218 struct device_attribute *attr, char *buf) 1219 { 1220 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev)); 1221 struct qla_hw_data *ha = vha->hw; 1222 return scnprintf(buf, PAGE_SIZE, "%d.%02d.%02d %d\n", 1223 ha->fw_revision[0], ha->fw_revision[1], ha->fw_revision[2], 1224 ha->fw_revision[3]); 1225 } 1226 1227 static ssize_t 1228 qla2x00_optrom_gold_fw_version_show(struct device *dev, 1229 struct device_attribute *attr, char *buf) 1230 { 1231 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev)); 1232 struct qla_hw_data *ha = vha->hw; 1233 1234 if (!IS_QLA81XX(ha) && !IS_QLA83XX(ha) && !IS_QLA27XX(ha)) 1235 return scnprintf(buf, PAGE_SIZE, "\n"); 1236 1237 return scnprintf(buf, PAGE_SIZE, "%d.%02d.%02d (%d)\n", 1238 ha->gold_fw_version[0], ha->gold_fw_version[1], 1239 ha->gold_fw_version[2], ha->gold_fw_version[3]); 1240 } 1241 1242 static ssize_t 1243 qla2x00_total_isp_aborts_show(struct device *dev, 1244 struct device_attribute *attr, char *buf) 1245 { 1246 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev)); 1247 return scnprintf(buf, PAGE_SIZE, "%d\n", 1248 vha->qla_stats.total_isp_aborts); 1249 } 1250 1251 static ssize_t 1252 qla24xx_84xx_fw_version_show(struct device *dev, 1253 struct device_attribute *attr, char *buf) 1254 { 1255 int rval = QLA_SUCCESS; 1256 uint16_t status[2] = {0, 0}; 1257 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev)); 1258 struct qla_hw_data *ha = vha->hw; 1259 1260 if (!IS_QLA84XX(ha)) 1261 return scnprintf(buf, PAGE_SIZE, "\n"); 1262 1263 if (ha->cs84xx->op_fw_version == 0) 1264 rval = qla84xx_verify_chip(vha, status); 1265 1266 if ((rval == QLA_SUCCESS) && (status[0] == 0)) 1267 return scnprintf(buf, PAGE_SIZE, "%u\n", 1268 (uint32_t)ha->cs84xx->op_fw_version); 1269 1270 return scnprintf(buf, PAGE_SIZE, "\n"); 1271 } 1272 1273 static ssize_t 1274 qla2x00_mpi_version_show(struct device *dev, struct device_attribute *attr, 1275 char *buf) 1276 { 1277 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev)); 1278 struct qla_hw_data *ha = vha->hw; 1279 1280 if (!IS_QLA81XX(ha) && !IS_QLA8031(ha) && !IS_QLA8044(ha) && 1281 !IS_QLA27XX(ha)) 1282 return scnprintf(buf, PAGE_SIZE, "\n"); 1283 1284 return scnprintf(buf, PAGE_SIZE, "%d.%02d.%02d (%x)\n", 1285 ha->mpi_version[0], ha->mpi_version[1], ha->mpi_version[2], 1286 ha->mpi_capabilities); 1287 } 1288 1289 static ssize_t 1290 qla2x00_phy_version_show(struct device *dev, struct device_attribute *attr, 1291 char *buf) 1292 { 1293 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev)); 1294 struct qla_hw_data *ha = vha->hw; 1295 1296 if (!IS_QLA81XX(ha) && !IS_QLA8031(ha)) 1297 return scnprintf(buf, PAGE_SIZE, "\n"); 1298 1299 return scnprintf(buf, PAGE_SIZE, "%d.%02d.%02d\n", 1300 ha->phy_version[0], ha->phy_version[1], ha->phy_version[2]); 1301 } 1302 1303 static ssize_t 1304 qla2x00_flash_block_size_show(struct device *dev, 1305 struct device_attribute *attr, char *buf) 1306 { 1307 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev)); 1308 struct qla_hw_data *ha = vha->hw; 1309 1310 return scnprintf(buf, PAGE_SIZE, "0x%x\n", ha->fdt_block_size); 1311 } 1312 1313 static ssize_t 1314 qla2x00_vlan_id_show(struct device *dev, struct device_attribute *attr, 1315 char *buf) 1316 { 1317 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev)); 1318 1319 if (!IS_CNA_CAPABLE(vha->hw)) 1320 return scnprintf(buf, PAGE_SIZE, "\n"); 1321 1322 return scnprintf(buf, PAGE_SIZE, "%d\n", vha->fcoe_vlan_id); 1323 } 1324 1325 static ssize_t 1326 qla2x00_vn_port_mac_address_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 1331 if (!IS_CNA_CAPABLE(vha->hw)) 1332 return scnprintf(buf, PAGE_SIZE, "\n"); 1333 1334 return scnprintf(buf, PAGE_SIZE, "%pMR\n", vha->fcoe_vn_port_mac); 1335 } 1336 1337 static ssize_t 1338 qla2x00_fabric_param_show(struct device *dev, struct device_attribute *attr, 1339 char *buf) 1340 { 1341 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev)); 1342 1343 return scnprintf(buf, PAGE_SIZE, "%d\n", vha->hw->switch_cap); 1344 } 1345 1346 static ssize_t 1347 qla2x00_thermal_temp_show(struct device *dev, 1348 struct device_attribute *attr, char *buf) 1349 { 1350 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev)); 1351 uint16_t temp = 0; 1352 1353 if (qla2x00_reset_active(vha)) { 1354 ql_log(ql_log_warn, vha, 0x70dc, "ISP reset active.\n"); 1355 goto done; 1356 } 1357 1358 if (vha->hw->flags.eeh_busy) { 1359 ql_log(ql_log_warn, vha, 0x70dd, "PCI EEH busy.\n"); 1360 goto done; 1361 } 1362 1363 if (qla2x00_get_thermal_temp(vha, &temp) == QLA_SUCCESS) 1364 return scnprintf(buf, PAGE_SIZE, "%d\n", temp); 1365 1366 done: 1367 return scnprintf(buf, PAGE_SIZE, "\n"); 1368 } 1369 1370 static ssize_t 1371 qla2x00_fw_state_show(struct device *dev, struct device_attribute *attr, 1372 char *buf) 1373 { 1374 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev)); 1375 int rval = QLA_FUNCTION_FAILED; 1376 uint16_t state[6]; 1377 uint32_t pstate; 1378 1379 if (IS_QLAFX00(vha->hw)) { 1380 pstate = qlafx00_fw_state_show(dev, attr, buf); 1381 return scnprintf(buf, PAGE_SIZE, "0x%x\n", pstate); 1382 } 1383 1384 if (qla2x00_reset_active(vha)) 1385 ql_log(ql_log_warn, vha, 0x707c, 1386 "ISP reset active.\n"); 1387 else if (!vha->hw->flags.eeh_busy) 1388 rval = qla2x00_get_firmware_state(vha, state); 1389 if (rval != QLA_SUCCESS) 1390 memset(state, -1, sizeof(state)); 1391 1392 return scnprintf(buf, PAGE_SIZE, "0x%x 0x%x 0x%x 0x%x 0x%x 0x%x\n", 1393 state[0], state[1], state[2], state[3], state[4], state[5]); 1394 } 1395 1396 static ssize_t 1397 qla2x00_diag_requests_show(struct device *dev, 1398 struct device_attribute *attr, char *buf) 1399 { 1400 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev)); 1401 1402 if (!IS_BIDI_CAPABLE(vha->hw)) 1403 return scnprintf(buf, PAGE_SIZE, "\n"); 1404 1405 return scnprintf(buf, PAGE_SIZE, "%llu\n", vha->bidi_stats.io_count); 1406 } 1407 1408 static ssize_t 1409 qla2x00_diag_megabytes_show(struct device *dev, 1410 struct device_attribute *attr, char *buf) 1411 { 1412 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev)); 1413 1414 if (!IS_BIDI_CAPABLE(vha->hw)) 1415 return scnprintf(buf, PAGE_SIZE, "\n"); 1416 1417 return scnprintf(buf, PAGE_SIZE, "%llu\n", 1418 vha->bidi_stats.transfer_bytes >> 20); 1419 } 1420 1421 static ssize_t 1422 qla2x00_fw_dump_size_show(struct device *dev, struct device_attribute *attr, 1423 char *buf) 1424 { 1425 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev)); 1426 struct qla_hw_data *ha = vha->hw; 1427 uint32_t size; 1428 1429 if (!ha->fw_dumped) 1430 size = 0; 1431 else if (IS_P3P_TYPE(ha)) 1432 size = ha->md_template_size + ha->md_dump_size; 1433 else 1434 size = ha->fw_dump_len; 1435 1436 return scnprintf(buf, PAGE_SIZE, "%d\n", size); 1437 } 1438 1439 static ssize_t 1440 qla2x00_allow_cna_fw_dump_show(struct device *dev, 1441 struct device_attribute *attr, char *buf) 1442 { 1443 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev)); 1444 1445 if (!IS_P3P_TYPE(vha->hw)) 1446 return scnprintf(buf, PAGE_SIZE, "\n"); 1447 else 1448 return scnprintf(buf, PAGE_SIZE, "%s\n", 1449 vha->hw->allow_cna_fw_dump ? "true" : "false"); 1450 } 1451 1452 static ssize_t 1453 qla2x00_allow_cna_fw_dump_store(struct device *dev, 1454 struct device_attribute *attr, const char *buf, size_t count) 1455 { 1456 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev)); 1457 int val = 0; 1458 1459 if (!IS_P3P_TYPE(vha->hw)) 1460 return -EINVAL; 1461 1462 if (sscanf(buf, "%d", &val) != 1) 1463 return -EINVAL; 1464 1465 vha->hw->allow_cna_fw_dump = val != 0; 1466 1467 return strlen(buf); 1468 } 1469 1470 static ssize_t 1471 qla2x00_pep_version_show(struct device *dev, struct device_attribute *attr, 1472 char *buf) 1473 { 1474 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev)); 1475 struct qla_hw_data *ha = vha->hw; 1476 1477 if (!IS_QLA27XX(ha)) 1478 return scnprintf(buf, PAGE_SIZE, "\n"); 1479 1480 return scnprintf(buf, PAGE_SIZE, "%d.%02d.%02d\n", 1481 ha->pep_version[0], ha->pep_version[1], ha->pep_version[2]); 1482 } 1483 1484 static ssize_t 1485 qla2x00_min_link_speed_show(struct device *dev, struct device_attribute *attr, 1486 char *buf) 1487 { 1488 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev)); 1489 struct qla_hw_data *ha = vha->hw; 1490 1491 if (!IS_QLA27XX(ha)) 1492 return scnprintf(buf, PAGE_SIZE, "\n"); 1493 1494 return scnprintf(buf, PAGE_SIZE, "%s\n", 1495 ha->min_link_speed == 5 ? "32Gps" : 1496 ha->min_link_speed == 4 ? "16Gps" : 1497 ha->min_link_speed == 3 ? "8Gps" : 1498 ha->min_link_speed == 2 ? "4Gps" : 1499 ha->min_link_speed != 0 ? "unknown" : ""); 1500 } 1501 1502 static ssize_t 1503 qla2x00_max_speed_sup_show(struct device *dev, struct device_attribute *attr, 1504 char *buf) 1505 { 1506 scsi_qla_host_t *vha = shost_priv(class_to_shost(dev)); 1507 struct qla_hw_data *ha = vha->hw; 1508 1509 if (!IS_QLA27XX(ha)) 1510 return scnprintf(buf, PAGE_SIZE, "\n"); 1511 1512 return scnprintf(buf, PAGE_SIZE, "%s\n", 1513 ha->max_speed_sup ? "32Gps" : "16Gps"); 1514 } 1515 1516 static DEVICE_ATTR(driver_version, S_IRUGO, qla2x00_drvr_version_show, NULL); 1517 static DEVICE_ATTR(fw_version, S_IRUGO, qla2x00_fw_version_show, NULL); 1518 static DEVICE_ATTR(serial_num, S_IRUGO, qla2x00_serial_num_show, NULL); 1519 static DEVICE_ATTR(isp_name, S_IRUGO, qla2x00_isp_name_show, NULL); 1520 static DEVICE_ATTR(isp_id, S_IRUGO, qla2x00_isp_id_show, NULL); 1521 static DEVICE_ATTR(model_name, S_IRUGO, qla2x00_model_name_show, NULL); 1522 static DEVICE_ATTR(model_desc, S_IRUGO, qla2x00_model_desc_show, NULL); 1523 static DEVICE_ATTR(pci_info, S_IRUGO, qla2x00_pci_info_show, NULL); 1524 static DEVICE_ATTR(link_state, S_IRUGO, qla2x00_link_state_show, NULL); 1525 static DEVICE_ATTR(zio, S_IRUGO | S_IWUSR, qla2x00_zio_show, qla2x00_zio_store); 1526 static DEVICE_ATTR(zio_timer, S_IRUGO | S_IWUSR, qla2x00_zio_timer_show, 1527 qla2x00_zio_timer_store); 1528 static DEVICE_ATTR(beacon, S_IRUGO | S_IWUSR, qla2x00_beacon_show, 1529 qla2x00_beacon_store); 1530 static DEVICE_ATTR(optrom_bios_version, S_IRUGO, 1531 qla2x00_optrom_bios_version_show, NULL); 1532 static DEVICE_ATTR(optrom_efi_version, S_IRUGO, 1533 qla2x00_optrom_efi_version_show, NULL); 1534 static DEVICE_ATTR(optrom_fcode_version, S_IRUGO, 1535 qla2x00_optrom_fcode_version_show, NULL); 1536 static DEVICE_ATTR(optrom_fw_version, S_IRUGO, qla2x00_optrom_fw_version_show, 1537 NULL); 1538 static DEVICE_ATTR(optrom_gold_fw_version, S_IRUGO, 1539 qla2x00_optrom_gold_fw_version_show, NULL); 1540 static DEVICE_ATTR(84xx_fw_version, S_IRUGO, qla24xx_84xx_fw_version_show, 1541 NULL); 1542 static DEVICE_ATTR(total_isp_aborts, S_IRUGO, qla2x00_total_isp_aborts_show, 1543 NULL); 1544 static DEVICE_ATTR(mpi_version, S_IRUGO, qla2x00_mpi_version_show, NULL); 1545 static DEVICE_ATTR(phy_version, S_IRUGO, qla2x00_phy_version_show, NULL); 1546 static DEVICE_ATTR(flash_block_size, S_IRUGO, qla2x00_flash_block_size_show, 1547 NULL); 1548 static DEVICE_ATTR(vlan_id, S_IRUGO, qla2x00_vlan_id_show, NULL); 1549 static DEVICE_ATTR(vn_port_mac_address, S_IRUGO, 1550 qla2x00_vn_port_mac_address_show, NULL); 1551 static DEVICE_ATTR(fabric_param, S_IRUGO, qla2x00_fabric_param_show, NULL); 1552 static DEVICE_ATTR(fw_state, S_IRUGO, qla2x00_fw_state_show, NULL); 1553 static DEVICE_ATTR(thermal_temp, S_IRUGO, qla2x00_thermal_temp_show, NULL); 1554 static DEVICE_ATTR(diag_requests, S_IRUGO, qla2x00_diag_requests_show, NULL); 1555 static DEVICE_ATTR(diag_megabytes, S_IRUGO, qla2x00_diag_megabytes_show, NULL); 1556 static DEVICE_ATTR(fw_dump_size, S_IRUGO, qla2x00_fw_dump_size_show, NULL); 1557 static DEVICE_ATTR(allow_cna_fw_dump, S_IRUGO | S_IWUSR, 1558 qla2x00_allow_cna_fw_dump_show, 1559 qla2x00_allow_cna_fw_dump_store); 1560 static DEVICE_ATTR(pep_version, S_IRUGO, qla2x00_pep_version_show, NULL); 1561 static DEVICE_ATTR(min_link_speed, S_IRUGO, qla2x00_min_link_speed_show, NULL); 1562 static DEVICE_ATTR(max_speed_sup, S_IRUGO, qla2x00_max_speed_sup_show, NULL); 1563 1564 struct device_attribute *qla2x00_host_attrs[] = { 1565 &dev_attr_driver_version, 1566 &dev_attr_fw_version, 1567 &dev_attr_serial_num, 1568 &dev_attr_isp_name, 1569 &dev_attr_isp_id, 1570 &dev_attr_model_name, 1571 &dev_attr_model_desc, 1572 &dev_attr_pci_info, 1573 &dev_attr_link_state, 1574 &dev_attr_zio, 1575 &dev_attr_zio_timer, 1576 &dev_attr_beacon, 1577 &dev_attr_optrom_bios_version, 1578 &dev_attr_optrom_efi_version, 1579 &dev_attr_optrom_fcode_version, 1580 &dev_attr_optrom_fw_version, 1581 &dev_attr_84xx_fw_version, 1582 &dev_attr_total_isp_aborts, 1583 &dev_attr_mpi_version, 1584 &dev_attr_phy_version, 1585 &dev_attr_flash_block_size, 1586 &dev_attr_vlan_id, 1587 &dev_attr_vn_port_mac_address, 1588 &dev_attr_fabric_param, 1589 &dev_attr_fw_state, 1590 &dev_attr_optrom_gold_fw_version, 1591 &dev_attr_thermal_temp, 1592 &dev_attr_diag_requests, 1593 &dev_attr_diag_megabytes, 1594 &dev_attr_fw_dump_size, 1595 &dev_attr_allow_cna_fw_dump, 1596 &dev_attr_pep_version, 1597 &dev_attr_min_link_speed, 1598 &dev_attr_max_speed_sup, 1599 NULL, 1600 }; 1601 1602 /* Host attributes. */ 1603 1604 static void 1605 qla2x00_get_host_port_id(struct Scsi_Host *shost) 1606 { 1607 scsi_qla_host_t *vha = shost_priv(shost); 1608 1609 fc_host_port_id(shost) = vha->d_id.b.domain << 16 | 1610 vha->d_id.b.area << 8 | vha->d_id.b.al_pa; 1611 } 1612 1613 static void 1614 qla2x00_get_host_speed(struct Scsi_Host *shost) 1615 { 1616 struct qla_hw_data *ha = ((struct scsi_qla_host *) 1617 (shost_priv(shost)))->hw; 1618 u32 speed = FC_PORTSPEED_UNKNOWN; 1619 1620 if (IS_QLAFX00(ha)) { 1621 qlafx00_get_host_speed(shost); 1622 return; 1623 } 1624 1625 switch (ha->link_data_rate) { 1626 case PORT_SPEED_1GB: 1627 speed = FC_PORTSPEED_1GBIT; 1628 break; 1629 case PORT_SPEED_2GB: 1630 speed = FC_PORTSPEED_2GBIT; 1631 break; 1632 case PORT_SPEED_4GB: 1633 speed = FC_PORTSPEED_4GBIT; 1634 break; 1635 case PORT_SPEED_8GB: 1636 speed = FC_PORTSPEED_8GBIT; 1637 break; 1638 case PORT_SPEED_10GB: 1639 speed = FC_PORTSPEED_10GBIT; 1640 break; 1641 case PORT_SPEED_16GB: 1642 speed = FC_PORTSPEED_16GBIT; 1643 break; 1644 case PORT_SPEED_32GB: 1645 speed = FC_PORTSPEED_32GBIT; 1646 break; 1647 } 1648 fc_host_speed(shost) = speed; 1649 } 1650 1651 static void 1652 qla2x00_get_host_port_type(struct Scsi_Host *shost) 1653 { 1654 scsi_qla_host_t *vha = shost_priv(shost); 1655 uint32_t port_type = FC_PORTTYPE_UNKNOWN; 1656 1657 if (vha->vp_idx) { 1658 fc_host_port_type(shost) = FC_PORTTYPE_NPIV; 1659 return; 1660 } 1661 switch (vha->hw->current_topology) { 1662 case ISP_CFG_NL: 1663 port_type = FC_PORTTYPE_LPORT; 1664 break; 1665 case ISP_CFG_FL: 1666 port_type = FC_PORTTYPE_NLPORT; 1667 break; 1668 case ISP_CFG_N: 1669 port_type = FC_PORTTYPE_PTP; 1670 break; 1671 case ISP_CFG_F: 1672 port_type = FC_PORTTYPE_NPORT; 1673 break; 1674 } 1675 fc_host_port_type(shost) = port_type; 1676 } 1677 1678 static void 1679 qla2x00_get_starget_node_name(struct scsi_target *starget) 1680 { 1681 struct Scsi_Host *host = dev_to_shost(starget->dev.parent); 1682 scsi_qla_host_t *vha = shost_priv(host); 1683 fc_port_t *fcport; 1684 u64 node_name = 0; 1685 1686 list_for_each_entry(fcport, &vha->vp_fcports, list) { 1687 if (fcport->rport && 1688 starget->id == fcport->rport->scsi_target_id) { 1689 node_name = wwn_to_u64(fcport->node_name); 1690 break; 1691 } 1692 } 1693 1694 fc_starget_node_name(starget) = node_name; 1695 } 1696 1697 static void 1698 qla2x00_get_starget_port_name(struct scsi_target *starget) 1699 { 1700 struct Scsi_Host *host = dev_to_shost(starget->dev.parent); 1701 scsi_qla_host_t *vha = shost_priv(host); 1702 fc_port_t *fcport; 1703 u64 port_name = 0; 1704 1705 list_for_each_entry(fcport, &vha->vp_fcports, list) { 1706 if (fcport->rport && 1707 starget->id == fcport->rport->scsi_target_id) { 1708 port_name = wwn_to_u64(fcport->port_name); 1709 break; 1710 } 1711 } 1712 1713 fc_starget_port_name(starget) = port_name; 1714 } 1715 1716 static void 1717 qla2x00_get_starget_port_id(struct scsi_target *starget) 1718 { 1719 struct Scsi_Host *host = dev_to_shost(starget->dev.parent); 1720 scsi_qla_host_t *vha = shost_priv(host); 1721 fc_port_t *fcport; 1722 uint32_t port_id = ~0U; 1723 1724 list_for_each_entry(fcport, &vha->vp_fcports, list) { 1725 if (fcport->rport && 1726 starget->id == fcport->rport->scsi_target_id) { 1727 port_id = fcport->d_id.b.domain << 16 | 1728 fcport->d_id.b.area << 8 | fcport->d_id.b.al_pa; 1729 break; 1730 } 1731 } 1732 1733 fc_starget_port_id(starget) = port_id; 1734 } 1735 1736 static void 1737 qla2x00_set_rport_loss_tmo(struct fc_rport *rport, uint32_t timeout) 1738 { 1739 if (timeout) 1740 rport->dev_loss_tmo = timeout; 1741 else 1742 rport->dev_loss_tmo = 1; 1743 } 1744 1745 static void 1746 qla2x00_dev_loss_tmo_callbk(struct fc_rport *rport) 1747 { 1748 struct Scsi_Host *host = rport_to_shost(rport); 1749 fc_port_t *fcport = *(fc_port_t **)rport->dd_data; 1750 unsigned long flags; 1751 1752 if (!fcport) 1753 return; 1754 1755 /* Now that the rport has been deleted, set the fcport state to 1756 FCS_DEVICE_DEAD */ 1757 qla2x00_set_fcport_state(fcport, FCS_DEVICE_DEAD); 1758 1759 /* 1760 * Transport has effectively 'deleted' the rport, clear 1761 * all local references. 1762 */ 1763 spin_lock_irqsave(host->host_lock, flags); 1764 fcport->rport = fcport->drport = NULL; 1765 *((fc_port_t **)rport->dd_data) = NULL; 1766 spin_unlock_irqrestore(host->host_lock, flags); 1767 1768 if (test_bit(ABORT_ISP_ACTIVE, &fcport->vha->dpc_flags)) 1769 return; 1770 1771 if (unlikely(pci_channel_offline(fcport->vha->hw->pdev))) { 1772 qla2x00_abort_all_cmds(fcport->vha, DID_NO_CONNECT << 16); 1773 return; 1774 } 1775 } 1776 1777 static void 1778 qla2x00_terminate_rport_io(struct fc_rport *rport) 1779 { 1780 fc_port_t *fcport = *(fc_port_t **)rport->dd_data; 1781 1782 if (!fcport) 1783 return; 1784 1785 if (test_bit(UNLOADING, &fcport->vha->dpc_flags)) 1786 return; 1787 1788 if (test_bit(ABORT_ISP_ACTIVE, &fcport->vha->dpc_flags)) 1789 return; 1790 1791 if (unlikely(pci_channel_offline(fcport->vha->hw->pdev))) { 1792 qla2x00_abort_all_cmds(fcport->vha, DID_NO_CONNECT << 16); 1793 return; 1794 } 1795 /* 1796 * At this point all fcport's software-states are cleared. Perform any 1797 * final cleanup of firmware resources (PCBs and XCBs). 1798 */ 1799 if (fcport->loop_id != FC_NO_LOOP_ID) { 1800 if (IS_FWI2_CAPABLE(fcport->vha->hw)) 1801 fcport->vha->hw->isp_ops->fabric_logout(fcport->vha, 1802 fcport->loop_id, fcport->d_id.b.domain, 1803 fcport->d_id.b.area, fcport->d_id.b.al_pa); 1804 else 1805 qla2x00_port_logout(fcport->vha, fcport); 1806 } 1807 } 1808 1809 static int 1810 qla2x00_issue_lip(struct Scsi_Host *shost) 1811 { 1812 scsi_qla_host_t *vha = shost_priv(shost); 1813 1814 if (IS_QLAFX00(vha->hw)) 1815 return 0; 1816 1817 qla2x00_loop_reset(vha); 1818 return 0; 1819 } 1820 1821 static struct fc_host_statistics * 1822 qla2x00_get_fc_host_stats(struct Scsi_Host *shost) 1823 { 1824 scsi_qla_host_t *vha = shost_priv(shost); 1825 struct qla_hw_data *ha = vha->hw; 1826 struct scsi_qla_host *base_vha = pci_get_drvdata(ha->pdev); 1827 int rval; 1828 struct link_statistics *stats; 1829 dma_addr_t stats_dma; 1830 struct fc_host_statistics *p = &vha->fc_host_stat; 1831 1832 memset(p, -1, sizeof(*p)); 1833 1834 if (IS_QLAFX00(vha->hw)) 1835 goto done; 1836 1837 if (test_bit(UNLOADING, &vha->dpc_flags)) 1838 goto done; 1839 1840 if (unlikely(pci_channel_offline(ha->pdev))) 1841 goto done; 1842 1843 if (qla2x00_reset_active(vha)) 1844 goto done; 1845 1846 stats = dma_zalloc_coherent(&ha->pdev->dev, sizeof(*stats), 1847 &stats_dma, GFP_KERNEL); 1848 if (!stats) { 1849 ql_log(ql_log_warn, vha, 0x707d, 1850 "Failed to allocate memory for stats.\n"); 1851 goto done; 1852 } 1853 1854 rval = QLA_FUNCTION_FAILED; 1855 if (IS_FWI2_CAPABLE(ha)) { 1856 rval = qla24xx_get_isp_stats(base_vha, stats, stats_dma, 0); 1857 } else if (atomic_read(&base_vha->loop_state) == LOOP_READY && 1858 !ha->dpc_active) { 1859 /* Must be in a 'READY' state for statistics retrieval. */ 1860 rval = qla2x00_get_link_status(base_vha, base_vha->loop_id, 1861 stats, stats_dma); 1862 } 1863 1864 if (rval != QLA_SUCCESS) 1865 goto done_free; 1866 1867 p->link_failure_count = stats->link_fail_cnt; 1868 p->loss_of_sync_count = stats->loss_sync_cnt; 1869 p->loss_of_signal_count = stats->loss_sig_cnt; 1870 p->prim_seq_protocol_err_count = stats->prim_seq_err_cnt; 1871 p->invalid_tx_word_count = stats->inval_xmit_word_cnt; 1872 p->invalid_crc_count = stats->inval_crc_cnt; 1873 if (IS_FWI2_CAPABLE(ha)) { 1874 p->lip_count = stats->lip_cnt; 1875 p->tx_frames = stats->tx_frames; 1876 p->rx_frames = stats->rx_frames; 1877 p->dumped_frames = stats->discarded_frames; 1878 p->nos_count = stats->nos_rcvd; 1879 p->error_frames = 1880 stats->dropped_frames + stats->discarded_frames; 1881 p->rx_words = vha->qla_stats.input_bytes; 1882 p->tx_words = vha->qla_stats.output_bytes; 1883 } 1884 p->fcp_control_requests = vha->qla_stats.control_requests; 1885 p->fcp_input_requests = vha->qla_stats.input_requests; 1886 p->fcp_output_requests = vha->qla_stats.output_requests; 1887 p->fcp_input_megabytes = vha->qla_stats.input_bytes >> 20; 1888 p->fcp_output_megabytes = vha->qla_stats.output_bytes >> 20; 1889 p->seconds_since_last_reset = 1890 get_jiffies_64() - vha->qla_stats.jiffies_at_last_reset; 1891 do_div(p->seconds_since_last_reset, HZ); 1892 1893 done_free: 1894 dma_free_coherent(&ha->pdev->dev, sizeof(struct link_statistics), 1895 stats, stats_dma); 1896 done: 1897 return p; 1898 } 1899 1900 static void 1901 qla2x00_reset_host_stats(struct Scsi_Host *shost) 1902 { 1903 scsi_qla_host_t *vha = shost_priv(shost); 1904 struct qla_hw_data *ha = vha->hw; 1905 struct scsi_qla_host *base_vha = pci_get_drvdata(ha->pdev); 1906 struct link_statistics *stats; 1907 dma_addr_t stats_dma; 1908 1909 memset(&vha->qla_stats, 0, sizeof(vha->qla_stats)); 1910 memset(&vha->fc_host_stat, 0, sizeof(vha->fc_host_stat)); 1911 1912 vha->qla_stats.jiffies_at_last_reset = get_jiffies_64(); 1913 1914 if (IS_FWI2_CAPABLE(ha)) { 1915 stats = dma_alloc_coherent(&ha->pdev->dev, 1916 sizeof(*stats), &stats_dma, GFP_KERNEL); 1917 if (!stats) { 1918 ql_log(ql_log_warn, vha, 0x70d7, 1919 "Failed to allocate memory for stats.\n"); 1920 return; 1921 } 1922 1923 /* reset firmware statistics */ 1924 qla24xx_get_isp_stats(base_vha, stats, stats_dma, BIT_0); 1925 1926 dma_free_coherent(&ha->pdev->dev, sizeof(*stats), 1927 stats, stats_dma); 1928 } 1929 } 1930 1931 static void 1932 qla2x00_get_host_symbolic_name(struct Scsi_Host *shost) 1933 { 1934 scsi_qla_host_t *vha = shost_priv(shost); 1935 1936 qla2x00_get_sym_node_name(vha, fc_host_symbolic_name(shost), 1937 sizeof(fc_host_symbolic_name(shost))); 1938 } 1939 1940 static void 1941 qla2x00_set_host_system_hostname(struct Scsi_Host *shost) 1942 { 1943 scsi_qla_host_t *vha = shost_priv(shost); 1944 1945 set_bit(REGISTER_FDMI_NEEDED, &vha->dpc_flags); 1946 } 1947 1948 static void 1949 qla2x00_get_host_fabric_name(struct Scsi_Host *shost) 1950 { 1951 scsi_qla_host_t *vha = shost_priv(shost); 1952 uint8_t node_name[WWN_SIZE] = { 0xFF, 0xFF, 0xFF, 0xFF, \ 1953 0xFF, 0xFF, 0xFF, 0xFF}; 1954 u64 fabric_name = wwn_to_u64(node_name); 1955 1956 if (vha->device_flags & SWITCH_FOUND) 1957 fabric_name = wwn_to_u64(vha->fabric_node_name); 1958 1959 fc_host_fabric_name(shost) = fabric_name; 1960 } 1961 1962 static void 1963 qla2x00_get_host_port_state(struct Scsi_Host *shost) 1964 { 1965 scsi_qla_host_t *vha = shost_priv(shost); 1966 struct scsi_qla_host *base_vha = pci_get_drvdata(vha->hw->pdev); 1967 1968 if (!base_vha->flags.online) { 1969 fc_host_port_state(shost) = FC_PORTSTATE_OFFLINE; 1970 return; 1971 } 1972 1973 switch (atomic_read(&base_vha->loop_state)) { 1974 case LOOP_UPDATE: 1975 fc_host_port_state(shost) = FC_PORTSTATE_DIAGNOSTICS; 1976 break; 1977 case LOOP_DOWN: 1978 if (test_bit(LOOP_RESYNC_NEEDED, &base_vha->dpc_flags)) 1979 fc_host_port_state(shost) = FC_PORTSTATE_DIAGNOSTICS; 1980 else 1981 fc_host_port_state(shost) = FC_PORTSTATE_LINKDOWN; 1982 break; 1983 case LOOP_DEAD: 1984 fc_host_port_state(shost) = FC_PORTSTATE_LINKDOWN; 1985 break; 1986 case LOOP_READY: 1987 fc_host_port_state(shost) = FC_PORTSTATE_ONLINE; 1988 break; 1989 default: 1990 fc_host_port_state(shost) = FC_PORTSTATE_UNKNOWN; 1991 break; 1992 } 1993 } 1994 1995 static int 1996 qla24xx_vport_create(struct fc_vport *fc_vport, bool disable) 1997 { 1998 int ret = 0; 1999 uint8_t qos = 0; 2000 scsi_qla_host_t *base_vha = shost_priv(fc_vport->shost); 2001 scsi_qla_host_t *vha = NULL; 2002 struct qla_hw_data *ha = base_vha->hw; 2003 int cnt; 2004 struct req_que *req = ha->req_q_map[0]; 2005 struct qla_qpair *qpair; 2006 2007 ret = qla24xx_vport_create_req_sanity_check(fc_vport); 2008 if (ret) { 2009 ql_log(ql_log_warn, vha, 0x707e, 2010 "Vport sanity check failed, status %x\n", ret); 2011 return (ret); 2012 } 2013 2014 vha = qla24xx_create_vhost(fc_vport); 2015 if (vha == NULL) { 2016 ql_log(ql_log_warn, vha, 0x707f, "Vport create host failed.\n"); 2017 return FC_VPORT_FAILED; 2018 } 2019 if (disable) { 2020 atomic_set(&vha->vp_state, VP_OFFLINE); 2021 fc_vport_set_state(fc_vport, FC_VPORT_DISABLED); 2022 } else 2023 atomic_set(&vha->vp_state, VP_FAILED); 2024 2025 /* ready to create vport */ 2026 ql_log(ql_log_info, vha, 0x7080, 2027 "VP entry id %d assigned.\n", vha->vp_idx); 2028 2029 /* initialized vport states */ 2030 atomic_set(&vha->loop_state, LOOP_DOWN); 2031 vha->vp_err_state= VP_ERR_PORTDWN; 2032 vha->vp_prev_err_state= VP_ERR_UNKWN; 2033 /* Check if physical ha port is Up */ 2034 if (atomic_read(&base_vha->loop_state) == LOOP_DOWN || 2035 atomic_read(&base_vha->loop_state) == LOOP_DEAD) { 2036 /* Don't retry or attempt login of this virtual port */ 2037 ql_dbg(ql_dbg_user, vha, 0x7081, 2038 "Vport loop state is not UP.\n"); 2039 atomic_set(&vha->loop_state, LOOP_DEAD); 2040 if (!disable) 2041 fc_vport_set_state(fc_vport, FC_VPORT_LINKDOWN); 2042 } 2043 2044 if (IS_T10_PI_CAPABLE(ha) && ql2xenabledif) { 2045 if (ha->fw_attributes & BIT_4) { 2046 int prot = 0, guard; 2047 vha->flags.difdix_supported = 1; 2048 ql_dbg(ql_dbg_user, vha, 0x7082, 2049 "Registered for DIF/DIX type 1 and 3 protection.\n"); 2050 if (ql2xenabledif == 1) 2051 prot = SHOST_DIX_TYPE0_PROTECTION; 2052 scsi_host_set_prot(vha->host, 2053 prot | SHOST_DIF_TYPE1_PROTECTION 2054 | SHOST_DIF_TYPE2_PROTECTION 2055 | SHOST_DIF_TYPE3_PROTECTION 2056 | SHOST_DIX_TYPE1_PROTECTION 2057 | SHOST_DIX_TYPE2_PROTECTION 2058 | SHOST_DIX_TYPE3_PROTECTION); 2059 2060 guard = SHOST_DIX_GUARD_CRC; 2061 2062 if (IS_PI_IPGUARD_CAPABLE(ha) && 2063 (ql2xenabledif > 1 || IS_PI_DIFB_DIX0_CAPABLE(ha))) 2064 guard |= SHOST_DIX_GUARD_IP; 2065 2066 scsi_host_set_guard(vha->host, guard); 2067 } else 2068 vha->flags.difdix_supported = 0; 2069 } 2070 2071 if (scsi_add_host_with_dma(vha->host, &fc_vport->dev, 2072 &ha->pdev->dev)) { 2073 ql_dbg(ql_dbg_user, vha, 0x7083, 2074 "scsi_add_host failure for VP[%d].\n", vha->vp_idx); 2075 goto vport_create_failed_2; 2076 } 2077 2078 /* initialize attributes */ 2079 fc_host_dev_loss_tmo(vha->host) = ha->port_down_retry_count; 2080 fc_host_node_name(vha->host) = wwn_to_u64(vha->node_name); 2081 fc_host_port_name(vha->host) = wwn_to_u64(vha->port_name); 2082 fc_host_supported_classes(vha->host) = 2083 fc_host_supported_classes(base_vha->host); 2084 fc_host_supported_speeds(vha->host) = 2085 fc_host_supported_speeds(base_vha->host); 2086 2087 qlt_vport_create(vha, ha); 2088 qla24xx_vport_disable(fc_vport, disable); 2089 2090 if (!ql2xmqsupport || !ha->npiv_info) 2091 goto vport_queue; 2092 2093 /* Create a request queue in QoS mode for the vport */ 2094 for (cnt = 0; cnt < ha->nvram_npiv_size; cnt++) { 2095 if (memcmp(ha->npiv_info[cnt].port_name, vha->port_name, 8) == 0 2096 && memcmp(ha->npiv_info[cnt].node_name, vha->node_name, 2097 8) == 0) { 2098 qos = ha->npiv_info[cnt].q_qos; 2099 break; 2100 } 2101 } 2102 2103 if (qos) { 2104 qpair = qla2xxx_create_qpair(vha, qos, vha->vp_idx, true); 2105 if (!qpair) 2106 ql_log(ql_log_warn, vha, 0x7084, 2107 "Can't create qpair for VP[%d]\n", 2108 vha->vp_idx); 2109 else { 2110 ql_dbg(ql_dbg_multiq, vha, 0xc001, 2111 "Queue pair: %d Qos: %d) created for VP[%d]\n", 2112 qpair->id, qos, vha->vp_idx); 2113 ql_dbg(ql_dbg_user, vha, 0x7085, 2114 "Queue Pair: %d Qos: %d) created for VP[%d]\n", 2115 qpair->id, qos, vha->vp_idx); 2116 req = qpair->req; 2117 vha->qpair = qpair; 2118 } 2119 } 2120 2121 vport_queue: 2122 vha->req = req; 2123 return 0; 2124 2125 vport_create_failed_2: 2126 qla24xx_disable_vp(vha); 2127 qla24xx_deallocate_vp_id(vha); 2128 scsi_host_put(vha->host); 2129 return FC_VPORT_FAILED; 2130 } 2131 2132 static int 2133 qla24xx_vport_delete(struct fc_vport *fc_vport) 2134 { 2135 scsi_qla_host_t *vha = fc_vport->dd_data; 2136 struct qla_hw_data *ha = vha->hw; 2137 uint16_t id = vha->vp_idx; 2138 2139 while (test_bit(LOOP_RESYNC_ACTIVE, &vha->dpc_flags) || 2140 test_bit(FCPORT_UPDATE_NEEDED, &vha->dpc_flags)) 2141 msleep(1000); 2142 2143 qla24xx_disable_vp(vha); 2144 2145 vha->flags.delete_progress = 1; 2146 2147 qlt_remove_target(ha, vha); 2148 2149 fc_remove_host(vha->host); 2150 2151 scsi_remove_host(vha->host); 2152 2153 /* Allow timer to run to drain queued items, when removing vp */ 2154 qla24xx_deallocate_vp_id(vha); 2155 2156 if (vha->timer_active) { 2157 qla2x00_vp_stop_timer(vha); 2158 ql_dbg(ql_dbg_user, vha, 0x7086, 2159 "Timer for the VP[%d] has stopped\n", vha->vp_idx); 2160 } 2161 2162 qla2x00_free_fcports(vha); 2163 2164 mutex_lock(&ha->vport_lock); 2165 ha->cur_vport_count--; 2166 clear_bit(vha->vp_idx, ha->vp_idx_map); 2167 mutex_unlock(&ha->vport_lock); 2168 2169 dma_free_coherent(&ha->pdev->dev, vha->gnl.size, vha->gnl.l, 2170 vha->gnl.ldma); 2171 2172 vfree(vha->scan.l); 2173 2174 if (vha->qpair && vha->qpair->vp_idx == vha->vp_idx) { 2175 if (qla2xxx_delete_qpair(vha, vha->qpair) != QLA_SUCCESS) 2176 ql_log(ql_log_warn, vha, 0x7087, 2177 "Queue Pair delete failed.\n"); 2178 } 2179 2180 ql_log(ql_log_info, vha, 0x7088, "VP[%d] deleted.\n", id); 2181 scsi_host_put(vha->host); 2182 return 0; 2183 } 2184 2185 static int 2186 qla24xx_vport_disable(struct fc_vport *fc_vport, bool disable) 2187 { 2188 scsi_qla_host_t *vha = fc_vport->dd_data; 2189 2190 if (disable) 2191 qla24xx_disable_vp(vha); 2192 else 2193 qla24xx_enable_vp(vha); 2194 2195 return 0; 2196 } 2197 2198 struct fc_function_template qla2xxx_transport_functions = { 2199 2200 .show_host_node_name = 1, 2201 .show_host_port_name = 1, 2202 .show_host_supported_classes = 1, 2203 .show_host_supported_speeds = 1, 2204 2205 .get_host_port_id = qla2x00_get_host_port_id, 2206 .show_host_port_id = 1, 2207 .get_host_speed = qla2x00_get_host_speed, 2208 .show_host_speed = 1, 2209 .get_host_port_type = qla2x00_get_host_port_type, 2210 .show_host_port_type = 1, 2211 .get_host_symbolic_name = qla2x00_get_host_symbolic_name, 2212 .show_host_symbolic_name = 1, 2213 .set_host_system_hostname = qla2x00_set_host_system_hostname, 2214 .show_host_system_hostname = 1, 2215 .get_host_fabric_name = qla2x00_get_host_fabric_name, 2216 .show_host_fabric_name = 1, 2217 .get_host_port_state = qla2x00_get_host_port_state, 2218 .show_host_port_state = 1, 2219 2220 .dd_fcrport_size = sizeof(struct fc_port *), 2221 .show_rport_supported_classes = 1, 2222 2223 .get_starget_node_name = qla2x00_get_starget_node_name, 2224 .show_starget_node_name = 1, 2225 .get_starget_port_name = qla2x00_get_starget_port_name, 2226 .show_starget_port_name = 1, 2227 .get_starget_port_id = qla2x00_get_starget_port_id, 2228 .show_starget_port_id = 1, 2229 2230 .set_rport_dev_loss_tmo = qla2x00_set_rport_loss_tmo, 2231 .show_rport_dev_loss_tmo = 1, 2232 2233 .issue_fc_host_lip = qla2x00_issue_lip, 2234 .dev_loss_tmo_callbk = qla2x00_dev_loss_tmo_callbk, 2235 .terminate_rport_io = qla2x00_terminate_rport_io, 2236 .get_fc_host_stats = qla2x00_get_fc_host_stats, 2237 .reset_fc_host_stats = qla2x00_reset_host_stats, 2238 2239 .vport_create = qla24xx_vport_create, 2240 .vport_disable = qla24xx_vport_disable, 2241 .vport_delete = qla24xx_vport_delete, 2242 .bsg_request = qla24xx_bsg_request, 2243 .bsg_timeout = qla24xx_bsg_timeout, 2244 }; 2245 2246 struct fc_function_template qla2xxx_transport_vport_functions = { 2247 2248 .show_host_node_name = 1, 2249 .show_host_port_name = 1, 2250 .show_host_supported_classes = 1, 2251 2252 .get_host_port_id = qla2x00_get_host_port_id, 2253 .show_host_port_id = 1, 2254 .get_host_speed = qla2x00_get_host_speed, 2255 .show_host_speed = 1, 2256 .get_host_port_type = qla2x00_get_host_port_type, 2257 .show_host_port_type = 1, 2258 .get_host_symbolic_name = qla2x00_get_host_symbolic_name, 2259 .show_host_symbolic_name = 1, 2260 .set_host_system_hostname = qla2x00_set_host_system_hostname, 2261 .show_host_system_hostname = 1, 2262 .get_host_fabric_name = qla2x00_get_host_fabric_name, 2263 .show_host_fabric_name = 1, 2264 .get_host_port_state = qla2x00_get_host_port_state, 2265 .show_host_port_state = 1, 2266 2267 .dd_fcrport_size = sizeof(struct fc_port *), 2268 .show_rport_supported_classes = 1, 2269 2270 .get_starget_node_name = qla2x00_get_starget_node_name, 2271 .show_starget_node_name = 1, 2272 .get_starget_port_name = qla2x00_get_starget_port_name, 2273 .show_starget_port_name = 1, 2274 .get_starget_port_id = qla2x00_get_starget_port_id, 2275 .show_starget_port_id = 1, 2276 2277 .set_rport_dev_loss_tmo = qla2x00_set_rport_loss_tmo, 2278 .show_rport_dev_loss_tmo = 1, 2279 2280 .issue_fc_host_lip = qla2x00_issue_lip, 2281 .dev_loss_tmo_callbk = qla2x00_dev_loss_tmo_callbk, 2282 .terminate_rport_io = qla2x00_terminate_rport_io, 2283 .get_fc_host_stats = qla2x00_get_fc_host_stats, 2284 .reset_fc_host_stats = qla2x00_reset_host_stats, 2285 2286 .bsg_request = qla24xx_bsg_request, 2287 .bsg_timeout = qla24xx_bsg_timeout, 2288 }; 2289 2290 void 2291 qla2x00_init_host_attr(scsi_qla_host_t *vha) 2292 { 2293 struct qla_hw_data *ha = vha->hw; 2294 u32 speed = FC_PORTSPEED_UNKNOWN; 2295 2296 fc_host_dev_loss_tmo(vha->host) = ha->port_down_retry_count; 2297 fc_host_node_name(vha->host) = wwn_to_u64(vha->node_name); 2298 fc_host_port_name(vha->host) = wwn_to_u64(vha->port_name); 2299 fc_host_supported_classes(vha->host) = ha->base_qpair->enable_class_2 ? 2300 (FC_COS_CLASS2|FC_COS_CLASS3) : FC_COS_CLASS3; 2301 fc_host_max_npiv_vports(vha->host) = ha->max_npiv_vports; 2302 fc_host_npiv_vports_inuse(vha->host) = ha->cur_vport_count; 2303 2304 if (IS_CNA_CAPABLE(ha)) 2305 speed = FC_PORTSPEED_10GBIT; 2306 else if (IS_QLA2031(ha)) 2307 speed = FC_PORTSPEED_16GBIT | FC_PORTSPEED_8GBIT | 2308 FC_PORTSPEED_4GBIT; 2309 else if (IS_QLA25XX(ha)) 2310 speed = FC_PORTSPEED_8GBIT | FC_PORTSPEED_4GBIT | 2311 FC_PORTSPEED_2GBIT | FC_PORTSPEED_1GBIT; 2312 else if (IS_QLA24XX_TYPE(ha)) 2313 speed = FC_PORTSPEED_4GBIT | FC_PORTSPEED_2GBIT | 2314 FC_PORTSPEED_1GBIT; 2315 else if (IS_QLA23XX(ha)) 2316 speed = FC_PORTSPEED_2GBIT | FC_PORTSPEED_1GBIT; 2317 else if (IS_QLAFX00(ha)) 2318 speed = FC_PORTSPEED_8GBIT | FC_PORTSPEED_4GBIT | 2319 FC_PORTSPEED_2GBIT | FC_PORTSPEED_1GBIT; 2320 else if (IS_QLA27XX(ha)) 2321 speed = FC_PORTSPEED_32GBIT | FC_PORTSPEED_16GBIT | 2322 FC_PORTSPEED_8GBIT; 2323 else 2324 speed = FC_PORTSPEED_1GBIT; 2325 fc_host_supported_speeds(vha->host) = speed; 2326 } 2327