1 /* 2 * QLogic Fibre Channel HBA Driver 3 * Copyright (c) 2003-2005 QLogic Corporation 4 * 5 * See LICENSE.qla2xxx for copyright and licensing details. 6 */ 7 #include "qla_def.h" 8 9 #include <linux/vmalloc.h> 10 11 /* SYSFS attributes --------------------------------------------------------- */ 12 13 static ssize_t 14 qla2x00_sysfs_read_fw_dump(struct kobject *kobj, char *buf, loff_t off, 15 size_t count) 16 { 17 struct scsi_qla_host *ha = to_qla_host(dev_to_shost(container_of(kobj, 18 struct device, kobj))); 19 char *rbuf = (char *)ha->fw_dump; 20 21 if (ha->fw_dump_reading == 0) 22 return 0; 23 if (off > ha->fw_dump_len) 24 return 0; 25 if (off + count > ha->fw_dump_len) 26 count = ha->fw_dump_len - off; 27 28 memcpy(buf, &rbuf[off], count); 29 30 return (count); 31 } 32 33 static ssize_t 34 qla2x00_sysfs_write_fw_dump(struct kobject *kobj, char *buf, loff_t off, 35 size_t count) 36 { 37 struct scsi_qla_host *ha = to_qla_host(dev_to_shost(container_of(kobj, 38 struct device, kobj))); 39 int reading; 40 41 if (off != 0) 42 return (0); 43 44 reading = simple_strtol(buf, NULL, 10); 45 switch (reading) { 46 case 0: 47 if (!ha->fw_dump_reading) 48 break; 49 50 qla_printk(KERN_INFO, ha, 51 "Firmware dump cleared on (%ld).\n", ha->host_no); 52 53 ha->fw_dump_reading = 0; 54 ha->fw_dumped = 0; 55 break; 56 case 1: 57 if (ha->fw_dumped && !ha->fw_dump_reading) { 58 ha->fw_dump_reading = 1; 59 60 qla_printk(KERN_INFO, ha, 61 "Raw firmware dump ready for read on (%ld).\n", 62 ha->host_no); 63 } 64 break; 65 case 2: 66 qla2x00_alloc_fw_dump(ha); 67 break; 68 } 69 return (count); 70 } 71 72 static struct bin_attribute sysfs_fw_dump_attr = { 73 .attr = { 74 .name = "fw_dump", 75 .mode = S_IRUSR | S_IWUSR, 76 .owner = THIS_MODULE, 77 }, 78 .size = 0, 79 .read = qla2x00_sysfs_read_fw_dump, 80 .write = qla2x00_sysfs_write_fw_dump, 81 }; 82 83 static ssize_t 84 qla2x00_sysfs_read_nvram(struct kobject *kobj, char *buf, loff_t off, 85 size_t count) 86 { 87 struct scsi_qla_host *ha = to_qla_host(dev_to_shost(container_of(kobj, 88 struct device, kobj))); 89 unsigned long flags; 90 91 if (!capable(CAP_SYS_ADMIN) || off != 0) 92 return 0; 93 94 /* Read NVRAM. */ 95 spin_lock_irqsave(&ha->hardware_lock, flags); 96 ha->isp_ops.read_nvram(ha, (uint8_t *)buf, ha->nvram_base, 97 ha->nvram_size); 98 spin_unlock_irqrestore(&ha->hardware_lock, flags); 99 100 return ha->nvram_size; 101 } 102 103 static ssize_t 104 qla2x00_sysfs_write_nvram(struct kobject *kobj, char *buf, loff_t off, 105 size_t count) 106 { 107 struct scsi_qla_host *ha = to_qla_host(dev_to_shost(container_of(kobj, 108 struct device, kobj))); 109 unsigned long flags; 110 uint16_t cnt; 111 112 if (!capable(CAP_SYS_ADMIN) || off != 0 || count != ha->nvram_size) 113 return 0; 114 115 /* Checksum NVRAM. */ 116 if (IS_QLA24XX(ha) || IS_QLA54XX(ha)) { 117 uint32_t *iter; 118 uint32_t chksum; 119 120 iter = (uint32_t *)buf; 121 chksum = 0; 122 for (cnt = 0; cnt < ((count >> 2) - 1); cnt++) 123 chksum += le32_to_cpu(*iter++); 124 chksum = ~chksum + 1; 125 *iter = cpu_to_le32(chksum); 126 } else { 127 uint8_t *iter; 128 uint8_t chksum; 129 130 iter = (uint8_t *)buf; 131 chksum = 0; 132 for (cnt = 0; cnt < count - 1; cnt++) 133 chksum += *iter++; 134 chksum = ~chksum + 1; 135 *iter = chksum; 136 } 137 138 /* Write NVRAM. */ 139 spin_lock_irqsave(&ha->hardware_lock, flags); 140 ha->isp_ops.write_nvram(ha, (uint8_t *)buf, ha->nvram_base, count); 141 spin_unlock_irqrestore(&ha->hardware_lock, flags); 142 143 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags); 144 145 return (count); 146 } 147 148 static struct bin_attribute sysfs_nvram_attr = { 149 .attr = { 150 .name = "nvram", 151 .mode = S_IRUSR | S_IWUSR, 152 .owner = THIS_MODULE, 153 }, 154 .size = 512, 155 .read = qla2x00_sysfs_read_nvram, 156 .write = qla2x00_sysfs_write_nvram, 157 }; 158 159 static ssize_t 160 qla2x00_sysfs_read_optrom(struct kobject *kobj, char *buf, loff_t off, 161 size_t count) 162 { 163 struct scsi_qla_host *ha = to_qla_host(dev_to_shost(container_of(kobj, 164 struct device, kobj))); 165 166 if (ha->optrom_state != QLA_SREADING) 167 return 0; 168 if (off > ha->optrom_size) 169 return 0; 170 if (off + count > ha->optrom_size) 171 count = ha->optrom_size - off; 172 173 memcpy(buf, &ha->optrom_buffer[off], count); 174 175 return count; 176 } 177 178 static ssize_t 179 qla2x00_sysfs_write_optrom(struct kobject *kobj, char *buf, loff_t off, 180 size_t count) 181 { 182 struct scsi_qla_host *ha = to_qla_host(dev_to_shost(container_of(kobj, 183 struct device, kobj))); 184 185 if (ha->optrom_state != QLA_SWRITING) 186 return -EINVAL; 187 if (off > ha->optrom_size) 188 return -ERANGE; 189 if (off + count > ha->optrom_size) 190 count = ha->optrom_size - off; 191 192 memcpy(&ha->optrom_buffer[off], buf, count); 193 194 return count; 195 } 196 197 static struct bin_attribute sysfs_optrom_attr = { 198 .attr = { 199 .name = "optrom", 200 .mode = S_IRUSR | S_IWUSR, 201 .owner = THIS_MODULE, 202 }, 203 .size = OPTROM_SIZE_24XX, 204 .read = qla2x00_sysfs_read_optrom, 205 .write = qla2x00_sysfs_write_optrom, 206 }; 207 208 static ssize_t 209 qla2x00_sysfs_write_optrom_ctl(struct kobject *kobj, char *buf, loff_t off, 210 size_t count) 211 { 212 struct scsi_qla_host *ha = to_qla_host(dev_to_shost(container_of(kobj, 213 struct device, kobj))); 214 int val; 215 216 if (off) 217 return 0; 218 219 if (sscanf(buf, "%d", &val) != 1) 220 return -EINVAL; 221 222 switch (val) { 223 case 0: 224 if (ha->optrom_state != QLA_SREADING && 225 ha->optrom_state != QLA_SWRITING) 226 break; 227 228 ha->optrom_state = QLA_SWAITING; 229 vfree(ha->optrom_buffer); 230 ha->optrom_buffer = NULL; 231 break; 232 case 1: 233 if (ha->optrom_state != QLA_SWAITING) 234 break; 235 236 ha->optrom_state = QLA_SREADING; 237 ha->optrom_buffer = (uint8_t *)vmalloc(ha->optrom_size); 238 if (ha->optrom_buffer == NULL) { 239 qla_printk(KERN_WARNING, ha, 240 "Unable to allocate memory for optrom retrieval " 241 "(%x).\n", ha->optrom_size); 242 243 ha->optrom_state = QLA_SWAITING; 244 return count; 245 } 246 247 memset(ha->optrom_buffer, 0, ha->optrom_size); 248 ha->isp_ops.read_optrom(ha, ha->optrom_buffer, 0, 249 ha->optrom_size); 250 break; 251 case 2: 252 if (ha->optrom_state != QLA_SWAITING) 253 break; 254 255 ha->optrom_state = QLA_SWRITING; 256 ha->optrom_buffer = (uint8_t *)vmalloc(ha->optrom_size); 257 if (ha->optrom_buffer == NULL) { 258 qla_printk(KERN_WARNING, ha, 259 "Unable to allocate memory for optrom update " 260 "(%x).\n", ha->optrom_size); 261 262 ha->optrom_state = QLA_SWAITING; 263 return count; 264 } 265 memset(ha->optrom_buffer, 0, ha->optrom_size); 266 break; 267 case 3: 268 if (ha->optrom_state != QLA_SWRITING) 269 break; 270 271 ha->isp_ops.write_optrom(ha, ha->optrom_buffer, 0, 272 ha->optrom_size); 273 break; 274 } 275 return count; 276 } 277 278 static struct bin_attribute sysfs_optrom_ctl_attr = { 279 .attr = { 280 .name = "optrom_ctl", 281 .mode = S_IWUSR, 282 .owner = THIS_MODULE, 283 }, 284 .size = 0, 285 .write = qla2x00_sysfs_write_optrom_ctl, 286 }; 287 288 static ssize_t 289 qla2x00_sysfs_read_vpd(struct kobject *kobj, char *buf, loff_t off, 290 size_t count) 291 { 292 struct scsi_qla_host *ha = to_qla_host(dev_to_shost(container_of(kobj, 293 struct device, kobj))); 294 unsigned long flags; 295 296 if (!capable(CAP_SYS_ADMIN) || off != 0) 297 return 0; 298 299 /* Read NVRAM. */ 300 spin_lock_irqsave(&ha->hardware_lock, flags); 301 ha->isp_ops.read_nvram(ha, (uint8_t *)buf, ha->vpd_base, ha->vpd_size); 302 spin_unlock_irqrestore(&ha->hardware_lock, flags); 303 304 return ha->vpd_size; 305 } 306 307 static ssize_t 308 qla2x00_sysfs_write_vpd(struct kobject *kobj, char *buf, loff_t off, 309 size_t count) 310 { 311 struct scsi_qla_host *ha = to_qla_host(dev_to_shost(container_of(kobj, 312 struct device, kobj))); 313 unsigned long flags; 314 315 if (!capable(CAP_SYS_ADMIN) || off != 0 || count != ha->vpd_size) 316 return 0; 317 318 /* Write NVRAM. */ 319 spin_lock_irqsave(&ha->hardware_lock, flags); 320 ha->isp_ops.write_nvram(ha, (uint8_t *)buf, ha->vpd_base, count); 321 spin_unlock_irqrestore(&ha->hardware_lock, flags); 322 323 return count; 324 } 325 326 static struct bin_attribute sysfs_vpd_attr = { 327 .attr = { 328 .name = "vpd", 329 .mode = S_IRUSR | S_IWUSR, 330 .owner = THIS_MODULE, 331 }, 332 .size = 0, 333 .read = qla2x00_sysfs_read_vpd, 334 .write = qla2x00_sysfs_write_vpd, 335 }; 336 337 static ssize_t 338 qla2x00_sysfs_read_sfp(struct kobject *kobj, char *buf, loff_t off, 339 size_t count) 340 { 341 struct scsi_qla_host *ha = to_qla_host(dev_to_shost(container_of(kobj, 342 struct device, kobj))); 343 uint16_t iter, addr, offset; 344 int rval; 345 346 if (!capable(CAP_SYS_ADMIN) || off != 0 || count != SFP_DEV_SIZE * 2) 347 return 0; 348 349 addr = 0xa0; 350 for (iter = 0, offset = 0; iter < (SFP_DEV_SIZE * 2) / SFP_BLOCK_SIZE; 351 iter++, offset += SFP_BLOCK_SIZE) { 352 if (iter == 4) { 353 /* Skip to next device address. */ 354 addr = 0xa2; 355 offset = 0; 356 } 357 358 rval = qla2x00_read_sfp(ha, ha->sfp_data_dma, addr, offset, 359 SFP_BLOCK_SIZE); 360 if (rval != QLA_SUCCESS) { 361 qla_printk(KERN_WARNING, ha, 362 "Unable to read SFP data (%x/%x/%x).\n", rval, 363 addr, offset); 364 count = 0; 365 break; 366 } 367 memcpy(buf, ha->sfp_data, SFP_BLOCK_SIZE); 368 buf += SFP_BLOCK_SIZE; 369 } 370 371 return count; 372 } 373 374 static struct bin_attribute sysfs_sfp_attr = { 375 .attr = { 376 .name = "sfp", 377 .mode = S_IRUSR | S_IWUSR, 378 .owner = THIS_MODULE, 379 }, 380 .size = SFP_DEV_SIZE * 2, 381 .read = qla2x00_sysfs_read_sfp, 382 }; 383 384 static struct sysfs_entry { 385 char *name; 386 struct bin_attribute *attr; 387 int is4GBp_only; 388 } bin_file_entries[] = { 389 { "fw_dump", &sysfs_fw_dump_attr, }, 390 { "nvram", &sysfs_nvram_attr, }, 391 { "optrom", &sysfs_optrom_attr, }, 392 { "optrom_ctl", &sysfs_optrom_ctl_attr, }, 393 { "vpd", &sysfs_vpd_attr, 1 }, 394 { "sfp", &sysfs_sfp_attr, 1 }, 395 { NULL }, 396 }; 397 398 void 399 qla2x00_alloc_sysfs_attr(scsi_qla_host_t *ha) 400 { 401 struct Scsi_Host *host = ha->host; 402 struct sysfs_entry *iter; 403 int ret; 404 405 for (iter = bin_file_entries; iter->name; iter++) { 406 if (iter->is4GBp_only && (!IS_QLA24XX(ha) && !IS_QLA54XX(ha))) 407 continue; 408 409 ret = sysfs_create_bin_file(&host->shost_gendev.kobj, 410 iter->attr); 411 if (ret) 412 qla_printk(KERN_INFO, ha, 413 "Unable to create sysfs %s binary attribute " 414 "(%d).\n", iter->name, ret); 415 } 416 } 417 418 void 419 qla2x00_free_sysfs_attr(scsi_qla_host_t *ha) 420 { 421 struct Scsi_Host *host = ha->host; 422 struct sysfs_entry *iter; 423 424 for (iter = bin_file_entries; iter->name; iter++) { 425 if (iter->is4GBp_only && (!IS_QLA24XX(ha) && !IS_QLA54XX(ha))) 426 continue; 427 428 sysfs_remove_bin_file(&host->shost_gendev.kobj, 429 iter->attr); 430 } 431 432 if (ha->beacon_blink_led == 1) 433 ha->isp_ops.beacon_off(ha); 434 } 435 436 /* Scsi_Host attributes. */ 437 438 static ssize_t 439 qla2x00_drvr_version_show(struct class_device *cdev, char *buf) 440 { 441 return snprintf(buf, PAGE_SIZE, "%s\n", qla2x00_version_str); 442 } 443 444 static ssize_t 445 qla2x00_fw_version_show(struct class_device *cdev, char *buf) 446 { 447 scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev)); 448 char fw_str[30]; 449 450 return snprintf(buf, PAGE_SIZE, "%s\n", 451 ha->isp_ops.fw_version_str(ha, fw_str)); 452 } 453 454 static ssize_t 455 qla2x00_serial_num_show(struct class_device *cdev, char *buf) 456 { 457 scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev)); 458 uint32_t sn; 459 460 sn = ((ha->serial0 & 0x1f) << 16) | (ha->serial2 << 8) | ha->serial1; 461 return snprintf(buf, PAGE_SIZE, "%c%05d\n", 'A' + sn / 100000, 462 sn % 100000); 463 } 464 465 static ssize_t 466 qla2x00_isp_name_show(struct class_device *cdev, char *buf) 467 { 468 scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev)); 469 return snprintf(buf, PAGE_SIZE, "ISP%04X\n", ha->pdev->device); 470 } 471 472 static ssize_t 473 qla2x00_isp_id_show(struct class_device *cdev, char *buf) 474 { 475 scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev)); 476 return snprintf(buf, PAGE_SIZE, "%04x %04x %04x %04x\n", 477 ha->product_id[0], ha->product_id[1], ha->product_id[2], 478 ha->product_id[3]); 479 } 480 481 static ssize_t 482 qla2x00_model_name_show(struct class_device *cdev, char *buf) 483 { 484 scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev)); 485 return snprintf(buf, PAGE_SIZE, "%s\n", ha->model_number); 486 } 487 488 static ssize_t 489 qla2x00_model_desc_show(struct class_device *cdev, char *buf) 490 { 491 scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev)); 492 return snprintf(buf, PAGE_SIZE, "%s\n", 493 ha->model_desc ? ha->model_desc: ""); 494 } 495 496 static ssize_t 497 qla2x00_pci_info_show(struct class_device *cdev, char *buf) 498 { 499 scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev)); 500 char pci_info[30]; 501 502 return snprintf(buf, PAGE_SIZE, "%s\n", 503 ha->isp_ops.pci_info_str(ha, pci_info)); 504 } 505 506 static ssize_t 507 qla2x00_state_show(struct class_device *cdev, char *buf) 508 { 509 scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev)); 510 int len = 0; 511 512 if (atomic_read(&ha->loop_state) == LOOP_DOWN || 513 atomic_read(&ha->loop_state) == LOOP_DEAD) 514 len = snprintf(buf, PAGE_SIZE, "Link Down\n"); 515 else if (atomic_read(&ha->loop_state) != LOOP_READY || 516 test_bit(ABORT_ISP_ACTIVE, &ha->dpc_flags) || 517 test_bit(ISP_ABORT_NEEDED, &ha->dpc_flags)) 518 len = snprintf(buf, PAGE_SIZE, "Unknown Link State\n"); 519 else { 520 len = snprintf(buf, PAGE_SIZE, "Link Up - "); 521 522 switch (ha->current_topology) { 523 case ISP_CFG_NL: 524 len += snprintf(buf + len, PAGE_SIZE-len, "Loop\n"); 525 break; 526 case ISP_CFG_FL: 527 len += snprintf(buf + len, PAGE_SIZE-len, "FL_Port\n"); 528 break; 529 case ISP_CFG_N: 530 len += snprintf(buf + len, PAGE_SIZE-len, 531 "N_Port to N_Port\n"); 532 break; 533 case ISP_CFG_F: 534 len += snprintf(buf + len, PAGE_SIZE-len, "F_Port\n"); 535 break; 536 default: 537 len += snprintf(buf + len, PAGE_SIZE-len, "Loop\n"); 538 break; 539 } 540 } 541 return len; 542 } 543 544 static ssize_t 545 qla2x00_zio_show(struct class_device *cdev, char *buf) 546 { 547 scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev)); 548 int len = 0; 549 550 switch (ha->zio_mode) { 551 case QLA_ZIO_MODE_6: 552 len += snprintf(buf + len, PAGE_SIZE-len, "Mode 6\n"); 553 break; 554 case QLA_ZIO_DISABLED: 555 len += snprintf(buf + len, PAGE_SIZE-len, "Disabled\n"); 556 break; 557 } 558 return len; 559 } 560 561 static ssize_t 562 qla2x00_zio_store(struct class_device *cdev, const char *buf, size_t count) 563 { 564 scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev)); 565 int val = 0; 566 uint16_t zio_mode; 567 568 if (!IS_ZIO_SUPPORTED(ha)) 569 return -ENOTSUPP; 570 571 if (sscanf(buf, "%d", &val) != 1) 572 return -EINVAL; 573 574 if (val) 575 zio_mode = QLA_ZIO_MODE_6; 576 else 577 zio_mode = QLA_ZIO_DISABLED; 578 579 /* Update per-hba values and queue a reset. */ 580 if (zio_mode != QLA_ZIO_DISABLED || ha->zio_mode != QLA_ZIO_DISABLED) { 581 ha->zio_mode = zio_mode; 582 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags); 583 } 584 return strlen(buf); 585 } 586 587 static ssize_t 588 qla2x00_zio_timer_show(struct class_device *cdev, char *buf) 589 { 590 scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev)); 591 592 return snprintf(buf, PAGE_SIZE, "%d us\n", ha->zio_timer * 100); 593 } 594 595 static ssize_t 596 qla2x00_zio_timer_store(struct class_device *cdev, const char *buf, 597 size_t count) 598 { 599 scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev)); 600 int val = 0; 601 uint16_t zio_timer; 602 603 if (sscanf(buf, "%d", &val) != 1) 604 return -EINVAL; 605 if (val > 25500 || val < 100) 606 return -ERANGE; 607 608 zio_timer = (uint16_t)(val / 100); 609 ha->zio_timer = zio_timer; 610 611 return strlen(buf); 612 } 613 614 static ssize_t 615 qla2x00_beacon_show(struct class_device *cdev, char *buf) 616 { 617 scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev)); 618 int len = 0; 619 620 if (ha->beacon_blink_led) 621 len += snprintf(buf + len, PAGE_SIZE-len, "Enabled\n"); 622 else 623 len += snprintf(buf + len, PAGE_SIZE-len, "Disabled\n"); 624 return len; 625 } 626 627 static ssize_t 628 qla2x00_beacon_store(struct class_device *cdev, const char *buf, 629 size_t count) 630 { 631 scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev)); 632 int val = 0; 633 int rval; 634 635 if (IS_QLA2100(ha) || IS_QLA2200(ha)) 636 return -EPERM; 637 638 if (test_bit(ABORT_ISP_ACTIVE, &ha->dpc_flags)) { 639 qla_printk(KERN_WARNING, ha, 640 "Abort ISP active -- ignoring beacon request.\n"); 641 return -EBUSY; 642 } 643 644 if (sscanf(buf, "%d", &val) != 1) 645 return -EINVAL; 646 647 if (val) 648 rval = ha->isp_ops.beacon_on(ha); 649 else 650 rval = ha->isp_ops.beacon_off(ha); 651 652 if (rval != QLA_SUCCESS) 653 count = 0; 654 655 return count; 656 } 657 658 static ssize_t 659 qla2x00_optrom_bios_version_show(struct class_device *cdev, char *buf) 660 { 661 scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev)); 662 663 return snprintf(buf, PAGE_SIZE, "%d.%02d\n", ha->bios_revision[1], 664 ha->bios_revision[0]); 665 } 666 667 static ssize_t 668 qla2x00_optrom_efi_version_show(struct class_device *cdev, char *buf) 669 { 670 scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev)); 671 672 return snprintf(buf, PAGE_SIZE, "%d.%02d\n", ha->efi_revision[1], 673 ha->efi_revision[0]); 674 } 675 676 static ssize_t 677 qla2x00_optrom_fcode_version_show(struct class_device *cdev, char *buf) 678 { 679 scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev)); 680 681 return snprintf(buf, PAGE_SIZE, "%d.%02d\n", ha->fcode_revision[1], 682 ha->fcode_revision[0]); 683 } 684 685 static ssize_t 686 qla2x00_optrom_fw_version_show(struct class_device *cdev, char *buf) 687 { 688 scsi_qla_host_t *ha = to_qla_host(class_to_shost(cdev)); 689 690 return snprintf(buf, PAGE_SIZE, "%d.%02d.%02d %d\n", 691 ha->fw_revision[0], ha->fw_revision[1], ha->fw_revision[2], 692 ha->fw_revision[3]); 693 } 694 695 static CLASS_DEVICE_ATTR(driver_version, S_IRUGO, qla2x00_drvr_version_show, 696 NULL); 697 static CLASS_DEVICE_ATTR(fw_version, S_IRUGO, qla2x00_fw_version_show, NULL); 698 static CLASS_DEVICE_ATTR(serial_num, S_IRUGO, qla2x00_serial_num_show, NULL); 699 static CLASS_DEVICE_ATTR(isp_name, S_IRUGO, qla2x00_isp_name_show, NULL); 700 static CLASS_DEVICE_ATTR(isp_id, S_IRUGO, qla2x00_isp_id_show, NULL); 701 static CLASS_DEVICE_ATTR(model_name, S_IRUGO, qla2x00_model_name_show, NULL); 702 static CLASS_DEVICE_ATTR(model_desc, S_IRUGO, qla2x00_model_desc_show, NULL); 703 static CLASS_DEVICE_ATTR(pci_info, S_IRUGO, qla2x00_pci_info_show, NULL); 704 static CLASS_DEVICE_ATTR(state, S_IRUGO, qla2x00_state_show, NULL); 705 static CLASS_DEVICE_ATTR(zio, S_IRUGO | S_IWUSR, qla2x00_zio_show, 706 qla2x00_zio_store); 707 static CLASS_DEVICE_ATTR(zio_timer, S_IRUGO | S_IWUSR, qla2x00_zio_timer_show, 708 qla2x00_zio_timer_store); 709 static CLASS_DEVICE_ATTR(beacon, S_IRUGO | S_IWUSR, qla2x00_beacon_show, 710 qla2x00_beacon_store); 711 static CLASS_DEVICE_ATTR(optrom_bios_version, S_IRUGO, 712 qla2x00_optrom_bios_version_show, NULL); 713 static CLASS_DEVICE_ATTR(optrom_efi_version, S_IRUGO, 714 qla2x00_optrom_efi_version_show, NULL); 715 static CLASS_DEVICE_ATTR(optrom_fcode_version, S_IRUGO, 716 qla2x00_optrom_fcode_version_show, NULL); 717 static CLASS_DEVICE_ATTR(optrom_fw_version, S_IRUGO, 718 qla2x00_optrom_fw_version_show, NULL); 719 720 struct class_device_attribute *qla2x00_host_attrs[] = { 721 &class_device_attr_driver_version, 722 &class_device_attr_fw_version, 723 &class_device_attr_serial_num, 724 &class_device_attr_isp_name, 725 &class_device_attr_isp_id, 726 &class_device_attr_model_name, 727 &class_device_attr_model_desc, 728 &class_device_attr_pci_info, 729 &class_device_attr_state, 730 &class_device_attr_zio, 731 &class_device_attr_zio_timer, 732 &class_device_attr_beacon, 733 &class_device_attr_optrom_bios_version, 734 &class_device_attr_optrom_efi_version, 735 &class_device_attr_optrom_fcode_version, 736 &class_device_attr_optrom_fw_version, 737 NULL, 738 }; 739 740 /* Host attributes. */ 741 742 static void 743 qla2x00_get_host_port_id(struct Scsi_Host *shost) 744 { 745 scsi_qla_host_t *ha = to_qla_host(shost); 746 747 fc_host_port_id(shost) = ha->d_id.b.domain << 16 | 748 ha->d_id.b.area << 8 | ha->d_id.b.al_pa; 749 } 750 751 static void 752 qla2x00_get_host_speed(struct Scsi_Host *shost) 753 { 754 scsi_qla_host_t *ha = to_qla_host(shost); 755 uint32_t speed = 0; 756 757 switch (ha->link_data_rate) { 758 case PORT_SPEED_1GB: 759 speed = 1; 760 break; 761 case PORT_SPEED_2GB: 762 speed = 2; 763 break; 764 case PORT_SPEED_4GB: 765 speed = 4; 766 break; 767 } 768 fc_host_speed(shost) = speed; 769 } 770 771 static void 772 qla2x00_get_host_port_type(struct Scsi_Host *shost) 773 { 774 scsi_qla_host_t *ha = to_qla_host(shost); 775 uint32_t port_type = FC_PORTTYPE_UNKNOWN; 776 777 switch (ha->current_topology) { 778 case ISP_CFG_NL: 779 port_type = FC_PORTTYPE_LPORT; 780 break; 781 case ISP_CFG_FL: 782 port_type = FC_PORTTYPE_NLPORT; 783 break; 784 case ISP_CFG_N: 785 port_type = FC_PORTTYPE_PTP; 786 break; 787 case ISP_CFG_F: 788 port_type = FC_PORTTYPE_NPORT; 789 break; 790 } 791 fc_host_port_type(shost) = port_type; 792 } 793 794 static void 795 qla2x00_get_starget_node_name(struct scsi_target *starget) 796 { 797 struct Scsi_Host *host = dev_to_shost(starget->dev.parent); 798 scsi_qla_host_t *ha = to_qla_host(host); 799 fc_port_t *fcport; 800 u64 node_name = 0; 801 802 list_for_each_entry(fcport, &ha->fcports, list) { 803 if (starget->id == fcport->os_target_id) { 804 node_name = wwn_to_u64(fcport->node_name); 805 break; 806 } 807 } 808 809 fc_starget_node_name(starget) = node_name; 810 } 811 812 static void 813 qla2x00_get_starget_port_name(struct scsi_target *starget) 814 { 815 struct Scsi_Host *host = dev_to_shost(starget->dev.parent); 816 scsi_qla_host_t *ha = to_qla_host(host); 817 fc_port_t *fcport; 818 u64 port_name = 0; 819 820 list_for_each_entry(fcport, &ha->fcports, list) { 821 if (starget->id == fcport->os_target_id) { 822 port_name = wwn_to_u64(fcport->port_name); 823 break; 824 } 825 } 826 827 fc_starget_port_name(starget) = port_name; 828 } 829 830 static void 831 qla2x00_get_starget_port_id(struct scsi_target *starget) 832 { 833 struct Scsi_Host *host = dev_to_shost(starget->dev.parent); 834 scsi_qla_host_t *ha = to_qla_host(host); 835 fc_port_t *fcport; 836 uint32_t port_id = ~0U; 837 838 list_for_each_entry(fcport, &ha->fcports, list) { 839 if (starget->id == fcport->os_target_id) { 840 port_id = fcport->d_id.b.domain << 16 | 841 fcport->d_id.b.area << 8 | fcport->d_id.b.al_pa; 842 break; 843 } 844 } 845 846 fc_starget_port_id(starget) = port_id; 847 } 848 849 static void 850 qla2x00_get_rport_loss_tmo(struct fc_rport *rport) 851 { 852 struct Scsi_Host *host = rport_to_shost(rport); 853 scsi_qla_host_t *ha = to_qla_host(host); 854 855 rport->dev_loss_tmo = ha->port_down_retry_count + 5; 856 } 857 858 static void 859 qla2x00_set_rport_loss_tmo(struct fc_rport *rport, uint32_t timeout) 860 { 861 struct Scsi_Host *host = rport_to_shost(rport); 862 scsi_qla_host_t *ha = to_qla_host(host); 863 864 if (timeout) 865 ha->port_down_retry_count = timeout; 866 else 867 ha->port_down_retry_count = 1; 868 869 rport->dev_loss_tmo = ha->port_down_retry_count + 5; 870 } 871 872 static int 873 qla2x00_issue_lip(struct Scsi_Host *shost) 874 { 875 scsi_qla_host_t *ha = to_qla_host(shost); 876 877 set_bit(LOOP_RESET_NEEDED, &ha->dpc_flags); 878 return 0; 879 } 880 881 static struct fc_host_statistics * 882 qla2x00_get_fc_host_stats(struct Scsi_Host *shost) 883 { 884 scsi_qla_host_t *ha = to_qla_host(shost); 885 int rval; 886 uint16_t mb_stat[1]; 887 link_stat_t stat_buf; 888 struct fc_host_statistics *pfc_host_stat; 889 890 rval = QLA_FUNCTION_FAILED; 891 pfc_host_stat = &ha->fc_host_stat; 892 memset(pfc_host_stat, -1, sizeof(struct fc_host_statistics)); 893 894 if (IS_QLA24XX(ha) || IS_QLA54XX(ha)) { 895 rval = qla24xx_get_isp_stats(ha, (uint32_t *)&stat_buf, 896 sizeof(stat_buf) / 4, mb_stat); 897 } else if (atomic_read(&ha->loop_state) == LOOP_READY && 898 !test_bit(ABORT_ISP_ACTIVE, &ha->dpc_flags) && 899 !test_bit(ISP_ABORT_NEEDED, &ha->dpc_flags) && 900 !ha->dpc_active) { 901 /* Must be in a 'READY' state for statistics retrieval. */ 902 rval = qla2x00_get_link_status(ha, ha->loop_id, &stat_buf, 903 mb_stat); 904 } 905 906 if (rval != QLA_SUCCESS) 907 goto done; 908 909 pfc_host_stat->link_failure_count = stat_buf.link_fail_cnt; 910 pfc_host_stat->loss_of_sync_count = stat_buf.loss_sync_cnt; 911 pfc_host_stat->loss_of_signal_count = stat_buf.loss_sig_cnt; 912 pfc_host_stat->prim_seq_protocol_err_count = stat_buf.prim_seq_err_cnt; 913 pfc_host_stat->invalid_tx_word_count = stat_buf.inval_xmit_word_cnt; 914 pfc_host_stat->invalid_crc_count = stat_buf.inval_crc_cnt; 915 done: 916 return pfc_host_stat; 917 } 918 919 static void 920 qla2x00_get_host_symbolic_name(struct Scsi_Host *shost) 921 { 922 scsi_qla_host_t *ha = to_qla_host(shost); 923 924 qla2x00_get_sym_node_name(ha, fc_host_symbolic_name(shost)); 925 } 926 927 static void 928 qla2x00_set_host_system_hostname(struct Scsi_Host *shost) 929 { 930 scsi_qla_host_t *ha = to_qla_host(shost); 931 932 set_bit(REGISTER_FDMI_NEEDED, &ha->dpc_flags); 933 } 934 935 static void 936 qla2x00_get_host_fabric_name(struct Scsi_Host *shost) 937 { 938 scsi_qla_host_t *ha = to_qla_host(shost); 939 u64 node_name; 940 941 if (ha->device_flags & SWITCH_FOUND) 942 node_name = wwn_to_u64(ha->fabric_node_name); 943 else 944 node_name = wwn_to_u64(ha->node_name); 945 946 fc_host_fabric_name(shost) = node_name; 947 } 948 949 static void 950 qla2x00_get_host_port_state(struct Scsi_Host *shost) 951 { 952 scsi_qla_host_t *ha = to_qla_host(shost); 953 954 if (!ha->flags.online) 955 fc_host_port_state(shost) = FC_PORTSTATE_OFFLINE; 956 else if (atomic_read(&ha->loop_state) == LOOP_TIMEOUT) 957 fc_host_port_state(shost) = FC_PORTSTATE_UNKNOWN; 958 else 959 fc_host_port_state(shost) = FC_PORTSTATE_ONLINE; 960 } 961 962 struct fc_function_template qla2xxx_transport_functions = { 963 964 .show_host_node_name = 1, 965 .show_host_port_name = 1, 966 .show_host_supported_classes = 1, 967 968 .get_host_port_id = qla2x00_get_host_port_id, 969 .show_host_port_id = 1, 970 .get_host_speed = qla2x00_get_host_speed, 971 .show_host_speed = 1, 972 .get_host_port_type = qla2x00_get_host_port_type, 973 .show_host_port_type = 1, 974 .get_host_symbolic_name = qla2x00_get_host_symbolic_name, 975 .show_host_symbolic_name = 1, 976 .set_host_system_hostname = qla2x00_set_host_system_hostname, 977 .show_host_system_hostname = 1, 978 .get_host_fabric_name = qla2x00_get_host_fabric_name, 979 .show_host_fabric_name = 1, 980 .get_host_port_state = qla2x00_get_host_port_state, 981 .show_host_port_state = 1, 982 983 .dd_fcrport_size = sizeof(struct fc_port *), 984 .show_rport_supported_classes = 1, 985 986 .get_starget_node_name = qla2x00_get_starget_node_name, 987 .show_starget_node_name = 1, 988 .get_starget_port_name = qla2x00_get_starget_port_name, 989 .show_starget_port_name = 1, 990 .get_starget_port_id = qla2x00_get_starget_port_id, 991 .show_starget_port_id = 1, 992 993 .get_rport_dev_loss_tmo = qla2x00_get_rport_loss_tmo, 994 .set_rport_dev_loss_tmo = qla2x00_set_rport_loss_tmo, 995 .show_rport_dev_loss_tmo = 1, 996 997 .issue_fc_host_lip = qla2x00_issue_lip, 998 .get_fc_host_stats = qla2x00_get_fc_host_stats, 999 }; 1000 1001 void 1002 qla2x00_init_host_attr(scsi_qla_host_t *ha) 1003 { 1004 fc_host_node_name(ha->host) = wwn_to_u64(ha->node_name); 1005 fc_host_port_name(ha->host) = wwn_to_u64(ha->port_name); 1006 fc_host_supported_classes(ha->host) = FC_COS_CLASS3; 1007 } 1008