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/kthread.h> 10 #include <linux/vmalloc.h> 11 12 static int qla24xx_vport_disable(struct fc_vport *, bool); 13 14 /* SYSFS attributes --------------------------------------------------------- */ 15 16 static ssize_t 17 qla2x00_sysfs_read_fw_dump(struct kobject *kobj, 18 struct bin_attribute *bin_attr, 19 char *buf, loff_t off, size_t count) 20 { 21 struct scsi_qla_host *ha = shost_priv(dev_to_shost(container_of(kobj, 22 struct device, kobj))); 23 char *rbuf = (char *)ha->fw_dump; 24 25 if (ha->fw_dump_reading == 0) 26 return 0; 27 if (off > ha->fw_dump_len) 28 return 0; 29 if (off + count > ha->fw_dump_len) 30 count = ha->fw_dump_len - off; 31 32 memcpy(buf, &rbuf[off], count); 33 34 return (count); 35 } 36 37 static ssize_t 38 qla2x00_sysfs_write_fw_dump(struct kobject *kobj, 39 struct bin_attribute *bin_attr, 40 char *buf, loff_t off, size_t count) 41 { 42 struct scsi_qla_host *ha = shost_priv(dev_to_shost(container_of(kobj, 43 struct device, kobj))); 44 int reading; 45 46 if (off != 0) 47 return (0); 48 49 reading = simple_strtol(buf, NULL, 10); 50 switch (reading) { 51 case 0: 52 if (!ha->fw_dump_reading) 53 break; 54 55 qla_printk(KERN_INFO, ha, 56 "Firmware dump cleared on (%ld).\n", ha->host_no); 57 58 ha->fw_dump_reading = 0; 59 ha->fw_dumped = 0; 60 break; 61 case 1: 62 if (ha->fw_dumped && !ha->fw_dump_reading) { 63 ha->fw_dump_reading = 1; 64 65 qla_printk(KERN_INFO, ha, 66 "Raw firmware dump ready for read on (%ld).\n", 67 ha->host_no); 68 } 69 break; 70 case 2: 71 qla2x00_alloc_fw_dump(ha); 72 break; 73 } 74 return (count); 75 } 76 77 static struct bin_attribute sysfs_fw_dump_attr = { 78 .attr = { 79 .name = "fw_dump", 80 .mode = S_IRUSR | S_IWUSR, 81 }, 82 .size = 0, 83 .read = qla2x00_sysfs_read_fw_dump, 84 .write = qla2x00_sysfs_write_fw_dump, 85 }; 86 87 static ssize_t 88 qla2x00_sysfs_read_nvram(struct kobject *kobj, 89 struct bin_attribute *bin_attr, 90 char *buf, loff_t off, size_t count) 91 { 92 struct scsi_qla_host *ha = shost_priv(dev_to_shost(container_of(kobj, 93 struct device, kobj))); 94 int size = ha->nvram_size; 95 char *nvram_cache = ha->nvram; 96 97 if (!capable(CAP_SYS_ADMIN) || off > size || count == 0) 98 return 0; 99 if (off + count > size) { 100 size -= off; 101 count = size; 102 } 103 104 /* Read NVRAM data from cache. */ 105 memcpy(buf, &nvram_cache[off], count); 106 107 return count; 108 } 109 110 static ssize_t 111 qla2x00_sysfs_write_nvram(struct kobject *kobj, 112 struct bin_attribute *bin_attr, 113 char *buf, loff_t off, size_t count) 114 { 115 struct scsi_qla_host *ha = shost_priv(dev_to_shost(container_of(kobj, 116 struct device, kobj))); 117 uint16_t cnt; 118 119 if (!capable(CAP_SYS_ADMIN) || off != 0 || count != ha->nvram_size) 120 return 0; 121 122 /* Checksum NVRAM. */ 123 if (IS_FWI2_CAPABLE(ha)) { 124 uint32_t *iter; 125 uint32_t chksum; 126 127 iter = (uint32_t *)buf; 128 chksum = 0; 129 for (cnt = 0; cnt < ((count >> 2) - 1); cnt++) 130 chksum += le32_to_cpu(*iter++); 131 chksum = ~chksum + 1; 132 *iter = cpu_to_le32(chksum); 133 } else { 134 uint8_t *iter; 135 uint8_t chksum; 136 137 iter = (uint8_t *)buf; 138 chksum = 0; 139 for (cnt = 0; cnt < count - 1; cnt++) 140 chksum += *iter++; 141 chksum = ~chksum + 1; 142 *iter = chksum; 143 } 144 145 /* Write NVRAM. */ 146 ha->isp_ops->write_nvram(ha, (uint8_t *)buf, ha->nvram_base, count); 147 ha->isp_ops->read_nvram(ha, (uint8_t *)ha->nvram, ha->nvram_base, 148 count); 149 150 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags); 151 152 return (count); 153 } 154 155 static struct bin_attribute sysfs_nvram_attr = { 156 .attr = { 157 .name = "nvram", 158 .mode = S_IRUSR | S_IWUSR, 159 }, 160 .size = 512, 161 .read = qla2x00_sysfs_read_nvram, 162 .write = qla2x00_sysfs_write_nvram, 163 }; 164 165 static ssize_t 166 qla2x00_sysfs_read_optrom(struct kobject *kobj, 167 struct bin_attribute *bin_attr, 168 char *buf, loff_t off, size_t count) 169 { 170 struct scsi_qla_host *ha = shost_priv(dev_to_shost(container_of(kobj, 171 struct device, kobj))); 172 173 if (ha->optrom_state != QLA_SREADING) 174 return 0; 175 if (off > ha->optrom_region_size) 176 return 0; 177 if (off + count > ha->optrom_region_size) 178 count = ha->optrom_region_size - off; 179 180 memcpy(buf, &ha->optrom_buffer[off], count); 181 182 return count; 183 } 184 185 static ssize_t 186 qla2x00_sysfs_write_optrom(struct kobject *kobj, 187 struct bin_attribute *bin_attr, 188 char *buf, loff_t off, size_t count) 189 { 190 struct scsi_qla_host *ha = shost_priv(dev_to_shost(container_of(kobj, 191 struct device, kobj))); 192 193 if (ha->optrom_state != QLA_SWRITING) 194 return -EINVAL; 195 if (off > ha->optrom_region_size) 196 return -ERANGE; 197 if (off + count > ha->optrom_region_size) 198 count = ha->optrom_region_size - off; 199 200 memcpy(&ha->optrom_buffer[off], buf, count); 201 202 return count; 203 } 204 205 static struct bin_attribute sysfs_optrom_attr = { 206 .attr = { 207 .name = "optrom", 208 .mode = S_IRUSR | S_IWUSR, 209 }, 210 .size = 0, 211 .read = qla2x00_sysfs_read_optrom, 212 .write = qla2x00_sysfs_write_optrom, 213 }; 214 215 static ssize_t 216 qla2x00_sysfs_write_optrom_ctl(struct kobject *kobj, 217 struct bin_attribute *bin_attr, 218 char *buf, loff_t off, size_t count) 219 { 220 struct scsi_qla_host *ha = shost_priv(dev_to_shost(container_of(kobj, 221 struct device, kobj))); 222 uint32_t start = 0; 223 uint32_t size = ha->optrom_size; 224 int val, valid; 225 226 if (off) 227 return 0; 228 229 if (sscanf(buf, "%d:%x:%x", &val, &start, &size) < 1) 230 return -EINVAL; 231 if (start > ha->optrom_size) 232 return -EINVAL; 233 234 switch (val) { 235 case 0: 236 if (ha->optrom_state != QLA_SREADING && 237 ha->optrom_state != QLA_SWRITING) 238 break; 239 240 ha->optrom_state = QLA_SWAITING; 241 242 DEBUG2(qla_printk(KERN_INFO, ha, 243 "Freeing flash region allocation -- 0x%x bytes.\n", 244 ha->optrom_region_size)); 245 246 vfree(ha->optrom_buffer); 247 ha->optrom_buffer = NULL; 248 break; 249 case 1: 250 if (ha->optrom_state != QLA_SWAITING) 251 break; 252 253 if (start & 0xfff) { 254 qla_printk(KERN_WARNING, ha, 255 "Invalid start region 0x%x/0x%x.\n", start, size); 256 return -EINVAL; 257 } 258 259 ha->optrom_region_start = start; 260 ha->optrom_region_size = start + size > ha->optrom_size ? 261 ha->optrom_size - start : size; 262 263 ha->optrom_state = QLA_SREADING; 264 ha->optrom_buffer = vmalloc(ha->optrom_region_size); 265 if (ha->optrom_buffer == NULL) { 266 qla_printk(KERN_WARNING, ha, 267 "Unable to allocate memory for optrom retrieval " 268 "(%x).\n", ha->optrom_region_size); 269 270 ha->optrom_state = QLA_SWAITING; 271 return count; 272 } 273 274 DEBUG2(qla_printk(KERN_INFO, ha, 275 "Reading flash region -- 0x%x/0x%x.\n", 276 ha->optrom_region_start, ha->optrom_region_size)); 277 278 memset(ha->optrom_buffer, 0, ha->optrom_region_size); 279 ha->isp_ops->read_optrom(ha, ha->optrom_buffer, 280 ha->optrom_region_start, ha->optrom_region_size); 281 break; 282 case 2: 283 if (ha->optrom_state != QLA_SWAITING) 284 break; 285 286 /* 287 * We need to be more restrictive on which FLASH regions are 288 * allowed to be updated via user-space. Regions accessible 289 * via this method include: 290 * 291 * ISP21xx/ISP22xx/ISP23xx type boards: 292 * 293 * 0x000000 -> 0x020000 -- Boot code. 294 * 295 * ISP2322/ISP24xx type boards: 296 * 297 * 0x000000 -> 0x07ffff -- Boot code. 298 * 0x080000 -> 0x0fffff -- Firmware. 299 * 300 * ISP25xx type boards: 301 * 302 * 0x000000 -> 0x07ffff -- Boot code. 303 * 0x080000 -> 0x0fffff -- Firmware. 304 * 0x120000 -> 0x12ffff -- VPD and HBA parameters. 305 */ 306 valid = 0; 307 if (ha->optrom_size == OPTROM_SIZE_2300 && start == 0) 308 valid = 1; 309 else if (start == (FA_BOOT_CODE_ADDR*4) || 310 start == (FA_RISC_CODE_ADDR*4)) 311 valid = 1; 312 else if (IS_QLA25XX(ha) && start == (FA_VPD_NVRAM_ADDR*4)) 313 valid = 1; 314 if (!valid) { 315 qla_printk(KERN_WARNING, ha, 316 "Invalid start region 0x%x/0x%x.\n", start, size); 317 return -EINVAL; 318 } 319 320 ha->optrom_region_start = start; 321 ha->optrom_region_size = start + size > ha->optrom_size ? 322 ha->optrom_size - start : size; 323 324 ha->optrom_state = QLA_SWRITING; 325 ha->optrom_buffer = vmalloc(ha->optrom_region_size); 326 if (ha->optrom_buffer == NULL) { 327 qla_printk(KERN_WARNING, ha, 328 "Unable to allocate memory for optrom update " 329 "(%x).\n", ha->optrom_region_size); 330 331 ha->optrom_state = QLA_SWAITING; 332 return count; 333 } 334 335 DEBUG2(qla_printk(KERN_INFO, ha, 336 "Staging flash region write -- 0x%x/0x%x.\n", 337 ha->optrom_region_start, ha->optrom_region_size)); 338 339 memset(ha->optrom_buffer, 0, ha->optrom_region_size); 340 break; 341 case 3: 342 if (ha->optrom_state != QLA_SWRITING) 343 break; 344 345 DEBUG2(qla_printk(KERN_INFO, ha, 346 "Writing flash region -- 0x%x/0x%x.\n", 347 ha->optrom_region_start, ha->optrom_region_size)); 348 349 ha->isp_ops->write_optrom(ha, ha->optrom_buffer, 350 ha->optrom_region_start, ha->optrom_region_size); 351 break; 352 default: 353 count = -EINVAL; 354 } 355 return count; 356 } 357 358 static struct bin_attribute sysfs_optrom_ctl_attr = { 359 .attr = { 360 .name = "optrom_ctl", 361 .mode = S_IWUSR, 362 }, 363 .size = 0, 364 .write = qla2x00_sysfs_write_optrom_ctl, 365 }; 366 367 static ssize_t 368 qla2x00_sysfs_read_vpd(struct kobject *kobj, 369 struct bin_attribute *bin_attr, 370 char *buf, loff_t off, size_t count) 371 { 372 struct scsi_qla_host *ha = shost_priv(dev_to_shost(container_of(kobj, 373 struct device, kobj))); 374 int size = ha->vpd_size; 375 char *vpd_cache = ha->vpd; 376 377 if (!capable(CAP_SYS_ADMIN) || off > size || count == 0) 378 return 0; 379 if (off + count > size) { 380 size -= off; 381 count = size; 382 } 383 384 /* Read NVRAM data from cache. */ 385 memcpy(buf, &vpd_cache[off], count); 386 387 return count; 388 } 389 390 static ssize_t 391 qla2x00_sysfs_write_vpd(struct kobject *kobj, 392 struct bin_attribute *bin_attr, 393 char *buf, loff_t off, size_t count) 394 { 395 struct scsi_qla_host *ha = shost_priv(dev_to_shost(container_of(kobj, 396 struct device, kobj))); 397 398 if (!capable(CAP_SYS_ADMIN) || off != 0 || count != ha->vpd_size) 399 return 0; 400 401 /* Write NVRAM. */ 402 ha->isp_ops->write_nvram(ha, (uint8_t *)buf, ha->vpd_base, count); 403 ha->isp_ops->read_nvram(ha, (uint8_t *)ha->vpd, ha->vpd_base, count); 404 405 return count; 406 } 407 408 static struct bin_attribute sysfs_vpd_attr = { 409 .attr = { 410 .name = "vpd", 411 .mode = S_IRUSR | S_IWUSR, 412 }, 413 .size = 0, 414 .read = qla2x00_sysfs_read_vpd, 415 .write = qla2x00_sysfs_write_vpd, 416 }; 417 418 static ssize_t 419 qla2x00_sysfs_read_sfp(struct kobject *kobj, 420 struct bin_attribute *bin_attr, 421 char *buf, loff_t off, size_t count) 422 { 423 struct scsi_qla_host *ha = shost_priv(dev_to_shost(container_of(kobj, 424 struct device, kobj))); 425 uint16_t iter, addr, offset; 426 int rval; 427 428 if (!capable(CAP_SYS_ADMIN) || off != 0 || count != SFP_DEV_SIZE * 2) 429 return 0; 430 431 if (ha->sfp_data) 432 goto do_read; 433 434 ha->sfp_data = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, 435 &ha->sfp_data_dma); 436 if (!ha->sfp_data) { 437 qla_printk(KERN_WARNING, ha, 438 "Unable to allocate memory for SFP read-data.\n"); 439 return 0; 440 } 441 442 do_read: 443 memset(ha->sfp_data, 0, SFP_BLOCK_SIZE); 444 addr = 0xa0; 445 for (iter = 0, offset = 0; iter < (SFP_DEV_SIZE * 2) / SFP_BLOCK_SIZE; 446 iter++, offset += SFP_BLOCK_SIZE) { 447 if (iter == 4) { 448 /* Skip to next device address. */ 449 addr = 0xa2; 450 offset = 0; 451 } 452 453 rval = qla2x00_read_sfp(ha, ha->sfp_data_dma, addr, offset, 454 SFP_BLOCK_SIZE); 455 if (rval != QLA_SUCCESS) { 456 qla_printk(KERN_WARNING, ha, 457 "Unable to read SFP data (%x/%x/%x).\n", rval, 458 addr, offset); 459 count = 0; 460 break; 461 } 462 memcpy(buf, ha->sfp_data, SFP_BLOCK_SIZE); 463 buf += SFP_BLOCK_SIZE; 464 } 465 466 return count; 467 } 468 469 static struct bin_attribute sysfs_sfp_attr = { 470 .attr = { 471 .name = "sfp", 472 .mode = S_IRUSR | S_IWUSR, 473 }, 474 .size = SFP_DEV_SIZE * 2, 475 .read = qla2x00_sysfs_read_sfp, 476 }; 477 478 static struct sysfs_entry { 479 char *name; 480 struct bin_attribute *attr; 481 int is4GBp_only; 482 } bin_file_entries[] = { 483 { "fw_dump", &sysfs_fw_dump_attr, }, 484 { "nvram", &sysfs_nvram_attr, }, 485 { "optrom", &sysfs_optrom_attr, }, 486 { "optrom_ctl", &sysfs_optrom_ctl_attr, }, 487 { "vpd", &sysfs_vpd_attr, 1 }, 488 { "sfp", &sysfs_sfp_attr, 1 }, 489 { NULL }, 490 }; 491 492 void 493 qla2x00_alloc_sysfs_attr(scsi_qla_host_t *ha) 494 { 495 struct Scsi_Host *host = ha->host; 496 struct sysfs_entry *iter; 497 int ret; 498 499 for (iter = bin_file_entries; iter->name; iter++) { 500 if (iter->is4GBp_only && !IS_FWI2_CAPABLE(ha)) 501 continue; 502 503 ret = sysfs_create_bin_file(&host->shost_gendev.kobj, 504 iter->attr); 505 if (ret) 506 qla_printk(KERN_INFO, ha, 507 "Unable to create sysfs %s binary attribute " 508 "(%d).\n", iter->name, ret); 509 } 510 } 511 512 void 513 qla2x00_free_sysfs_attr(scsi_qla_host_t *ha) 514 { 515 struct Scsi_Host *host = ha->host; 516 struct sysfs_entry *iter; 517 518 for (iter = bin_file_entries; iter->name; iter++) { 519 if (iter->is4GBp_only && !IS_FWI2_CAPABLE(ha)) 520 continue; 521 522 sysfs_remove_bin_file(&host->shost_gendev.kobj, 523 iter->attr); 524 } 525 526 if (ha->beacon_blink_led == 1) 527 ha->isp_ops->beacon_off(ha); 528 } 529 530 /* Scsi_Host attributes. */ 531 532 static ssize_t 533 qla2x00_drvr_version_show(struct class_device *cdev, char *buf) 534 { 535 return snprintf(buf, PAGE_SIZE, "%s\n", qla2x00_version_str); 536 } 537 538 static ssize_t 539 qla2x00_fw_version_show(struct class_device *cdev, char *buf) 540 { 541 scsi_qla_host_t *ha = shost_priv(class_to_shost(cdev)); 542 char fw_str[30]; 543 544 return snprintf(buf, PAGE_SIZE, "%s\n", 545 ha->isp_ops->fw_version_str(ha, fw_str)); 546 } 547 548 static ssize_t 549 qla2x00_serial_num_show(struct class_device *cdev, char *buf) 550 { 551 scsi_qla_host_t *ha = shost_priv(class_to_shost(cdev)); 552 uint32_t sn; 553 554 if (IS_FWI2_CAPABLE(ha)) 555 return snprintf(buf, PAGE_SIZE, "\n"); 556 557 sn = ((ha->serial0 & 0x1f) << 16) | (ha->serial2 << 8) | ha->serial1; 558 return snprintf(buf, PAGE_SIZE, "%c%05d\n", 'A' + sn / 100000, 559 sn % 100000); 560 } 561 562 static ssize_t 563 qla2x00_isp_name_show(struct class_device *cdev, char *buf) 564 { 565 scsi_qla_host_t *ha = shost_priv(class_to_shost(cdev)); 566 return snprintf(buf, PAGE_SIZE, "ISP%04X\n", ha->pdev->device); 567 } 568 569 static ssize_t 570 qla2x00_isp_id_show(struct class_device *cdev, char *buf) 571 { 572 scsi_qla_host_t *ha = shost_priv(class_to_shost(cdev)); 573 return snprintf(buf, PAGE_SIZE, "%04x %04x %04x %04x\n", 574 ha->product_id[0], ha->product_id[1], ha->product_id[2], 575 ha->product_id[3]); 576 } 577 578 static ssize_t 579 qla2x00_model_name_show(struct class_device *cdev, char *buf) 580 { 581 scsi_qla_host_t *ha = shost_priv(class_to_shost(cdev)); 582 return snprintf(buf, PAGE_SIZE, "%s\n", ha->model_number); 583 } 584 585 static ssize_t 586 qla2x00_model_desc_show(struct class_device *cdev, char *buf) 587 { 588 scsi_qla_host_t *ha = shost_priv(class_to_shost(cdev)); 589 return snprintf(buf, PAGE_SIZE, "%s\n", 590 ha->model_desc ? ha->model_desc: ""); 591 } 592 593 static ssize_t 594 qla2x00_pci_info_show(struct class_device *cdev, char *buf) 595 { 596 scsi_qla_host_t *ha = shost_priv(class_to_shost(cdev)); 597 char pci_info[30]; 598 599 return snprintf(buf, PAGE_SIZE, "%s\n", 600 ha->isp_ops->pci_info_str(ha, pci_info)); 601 } 602 603 static ssize_t 604 qla2x00_state_show(struct class_device *cdev, char *buf) 605 { 606 scsi_qla_host_t *ha = shost_priv(class_to_shost(cdev)); 607 int len = 0; 608 609 if (atomic_read(&ha->loop_state) == LOOP_DOWN || 610 atomic_read(&ha->loop_state) == LOOP_DEAD) 611 len = snprintf(buf, PAGE_SIZE, "Link Down\n"); 612 else if (atomic_read(&ha->loop_state) != LOOP_READY || 613 test_bit(ABORT_ISP_ACTIVE, &ha->dpc_flags) || 614 test_bit(ISP_ABORT_NEEDED, &ha->dpc_flags)) 615 len = snprintf(buf, PAGE_SIZE, "Unknown Link State\n"); 616 else { 617 len = snprintf(buf, PAGE_SIZE, "Link Up - "); 618 619 switch (ha->current_topology) { 620 case ISP_CFG_NL: 621 len += snprintf(buf + len, PAGE_SIZE-len, "Loop\n"); 622 break; 623 case ISP_CFG_FL: 624 len += snprintf(buf + len, PAGE_SIZE-len, "FL_Port\n"); 625 break; 626 case ISP_CFG_N: 627 len += snprintf(buf + len, PAGE_SIZE-len, 628 "N_Port to N_Port\n"); 629 break; 630 case ISP_CFG_F: 631 len += snprintf(buf + len, PAGE_SIZE-len, "F_Port\n"); 632 break; 633 default: 634 len += snprintf(buf + len, PAGE_SIZE-len, "Loop\n"); 635 break; 636 } 637 } 638 return len; 639 } 640 641 static ssize_t 642 qla2x00_zio_show(struct class_device *cdev, char *buf) 643 { 644 scsi_qla_host_t *ha = shost_priv(class_to_shost(cdev)); 645 int len = 0; 646 647 switch (ha->zio_mode) { 648 case QLA_ZIO_MODE_6: 649 len += snprintf(buf + len, PAGE_SIZE-len, "Mode 6\n"); 650 break; 651 case QLA_ZIO_DISABLED: 652 len += snprintf(buf + len, PAGE_SIZE-len, "Disabled\n"); 653 break; 654 } 655 return len; 656 } 657 658 static ssize_t 659 qla2x00_zio_store(struct class_device *cdev, const char *buf, size_t count) 660 { 661 scsi_qla_host_t *ha = shost_priv(class_to_shost(cdev)); 662 int val = 0; 663 uint16_t zio_mode; 664 665 if (!IS_ZIO_SUPPORTED(ha)) 666 return -ENOTSUPP; 667 668 if (sscanf(buf, "%d", &val) != 1) 669 return -EINVAL; 670 671 if (val) 672 zio_mode = QLA_ZIO_MODE_6; 673 else 674 zio_mode = QLA_ZIO_DISABLED; 675 676 /* Update per-hba values and queue a reset. */ 677 if (zio_mode != QLA_ZIO_DISABLED || ha->zio_mode != QLA_ZIO_DISABLED) { 678 ha->zio_mode = zio_mode; 679 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags); 680 } 681 return strlen(buf); 682 } 683 684 static ssize_t 685 qla2x00_zio_timer_show(struct class_device *cdev, char *buf) 686 { 687 scsi_qla_host_t *ha = shost_priv(class_to_shost(cdev)); 688 689 return snprintf(buf, PAGE_SIZE, "%d us\n", ha->zio_timer * 100); 690 } 691 692 static ssize_t 693 qla2x00_zio_timer_store(struct class_device *cdev, const char *buf, 694 size_t count) 695 { 696 scsi_qla_host_t *ha = shost_priv(class_to_shost(cdev)); 697 int val = 0; 698 uint16_t zio_timer; 699 700 if (sscanf(buf, "%d", &val) != 1) 701 return -EINVAL; 702 if (val > 25500 || val < 100) 703 return -ERANGE; 704 705 zio_timer = (uint16_t)(val / 100); 706 ha->zio_timer = zio_timer; 707 708 return strlen(buf); 709 } 710 711 static ssize_t 712 qla2x00_beacon_show(struct class_device *cdev, char *buf) 713 { 714 scsi_qla_host_t *ha = shost_priv(class_to_shost(cdev)); 715 int len = 0; 716 717 if (ha->beacon_blink_led) 718 len += snprintf(buf + len, PAGE_SIZE-len, "Enabled\n"); 719 else 720 len += snprintf(buf + len, PAGE_SIZE-len, "Disabled\n"); 721 return len; 722 } 723 724 static ssize_t 725 qla2x00_beacon_store(struct class_device *cdev, const char *buf, 726 size_t count) 727 { 728 scsi_qla_host_t *ha = shost_priv(class_to_shost(cdev)); 729 int val = 0; 730 int rval; 731 732 if (IS_QLA2100(ha) || IS_QLA2200(ha)) 733 return -EPERM; 734 735 if (test_bit(ABORT_ISP_ACTIVE, &ha->dpc_flags)) { 736 qla_printk(KERN_WARNING, ha, 737 "Abort ISP active -- ignoring beacon request.\n"); 738 return -EBUSY; 739 } 740 741 if (sscanf(buf, "%d", &val) != 1) 742 return -EINVAL; 743 744 if (val) 745 rval = ha->isp_ops->beacon_on(ha); 746 else 747 rval = ha->isp_ops->beacon_off(ha); 748 749 if (rval != QLA_SUCCESS) 750 count = 0; 751 752 return count; 753 } 754 755 static ssize_t 756 qla2x00_optrom_bios_version_show(struct class_device *cdev, char *buf) 757 { 758 scsi_qla_host_t *ha = shost_priv(class_to_shost(cdev)); 759 760 return snprintf(buf, PAGE_SIZE, "%d.%02d\n", ha->bios_revision[1], 761 ha->bios_revision[0]); 762 } 763 764 static ssize_t 765 qla2x00_optrom_efi_version_show(struct class_device *cdev, char *buf) 766 { 767 scsi_qla_host_t *ha = shost_priv(class_to_shost(cdev)); 768 769 return snprintf(buf, PAGE_SIZE, "%d.%02d\n", ha->efi_revision[1], 770 ha->efi_revision[0]); 771 } 772 773 static ssize_t 774 qla2x00_optrom_fcode_version_show(struct class_device *cdev, char *buf) 775 { 776 scsi_qla_host_t *ha = shost_priv(class_to_shost(cdev)); 777 778 return snprintf(buf, PAGE_SIZE, "%d.%02d\n", ha->fcode_revision[1], 779 ha->fcode_revision[0]); 780 } 781 782 static ssize_t 783 qla2x00_optrom_fw_version_show(struct class_device *cdev, char *buf) 784 { 785 scsi_qla_host_t *ha = shost_priv(class_to_shost(cdev)); 786 787 return snprintf(buf, PAGE_SIZE, "%d.%02d.%02d %d\n", 788 ha->fw_revision[0], ha->fw_revision[1], ha->fw_revision[2], 789 ha->fw_revision[3]); 790 } 791 792 static CLASS_DEVICE_ATTR(driver_version, S_IRUGO, qla2x00_drvr_version_show, 793 NULL); 794 static CLASS_DEVICE_ATTR(fw_version, S_IRUGO, qla2x00_fw_version_show, NULL); 795 static CLASS_DEVICE_ATTR(serial_num, S_IRUGO, qla2x00_serial_num_show, NULL); 796 static CLASS_DEVICE_ATTR(isp_name, S_IRUGO, qla2x00_isp_name_show, NULL); 797 static CLASS_DEVICE_ATTR(isp_id, S_IRUGO, qla2x00_isp_id_show, NULL); 798 static CLASS_DEVICE_ATTR(model_name, S_IRUGO, qla2x00_model_name_show, NULL); 799 static CLASS_DEVICE_ATTR(model_desc, S_IRUGO, qla2x00_model_desc_show, NULL); 800 static CLASS_DEVICE_ATTR(pci_info, S_IRUGO, qla2x00_pci_info_show, NULL); 801 static CLASS_DEVICE_ATTR(state, S_IRUGO, qla2x00_state_show, NULL); 802 static CLASS_DEVICE_ATTR(zio, S_IRUGO | S_IWUSR, qla2x00_zio_show, 803 qla2x00_zio_store); 804 static CLASS_DEVICE_ATTR(zio_timer, S_IRUGO | S_IWUSR, qla2x00_zio_timer_show, 805 qla2x00_zio_timer_store); 806 static CLASS_DEVICE_ATTR(beacon, S_IRUGO | S_IWUSR, qla2x00_beacon_show, 807 qla2x00_beacon_store); 808 static CLASS_DEVICE_ATTR(optrom_bios_version, S_IRUGO, 809 qla2x00_optrom_bios_version_show, NULL); 810 static CLASS_DEVICE_ATTR(optrom_efi_version, S_IRUGO, 811 qla2x00_optrom_efi_version_show, NULL); 812 static CLASS_DEVICE_ATTR(optrom_fcode_version, S_IRUGO, 813 qla2x00_optrom_fcode_version_show, NULL); 814 static CLASS_DEVICE_ATTR(optrom_fw_version, S_IRUGO, 815 qla2x00_optrom_fw_version_show, NULL); 816 817 struct class_device_attribute *qla2x00_host_attrs[] = { 818 &class_device_attr_driver_version, 819 &class_device_attr_fw_version, 820 &class_device_attr_serial_num, 821 &class_device_attr_isp_name, 822 &class_device_attr_isp_id, 823 &class_device_attr_model_name, 824 &class_device_attr_model_desc, 825 &class_device_attr_pci_info, 826 &class_device_attr_state, 827 &class_device_attr_zio, 828 &class_device_attr_zio_timer, 829 &class_device_attr_beacon, 830 &class_device_attr_optrom_bios_version, 831 &class_device_attr_optrom_efi_version, 832 &class_device_attr_optrom_fcode_version, 833 &class_device_attr_optrom_fw_version, 834 NULL, 835 }; 836 837 /* Host attributes. */ 838 839 static void 840 qla2x00_get_host_port_id(struct Scsi_Host *shost) 841 { 842 scsi_qla_host_t *ha = shost_priv(shost); 843 844 fc_host_port_id(shost) = ha->d_id.b.domain << 16 | 845 ha->d_id.b.area << 8 | ha->d_id.b.al_pa; 846 } 847 848 static void 849 qla2x00_get_host_speed(struct Scsi_Host *shost) 850 { 851 scsi_qla_host_t *ha = to_qla_parent(shost_priv(shost)); 852 uint32_t speed = 0; 853 854 switch (ha->link_data_rate) { 855 case PORT_SPEED_1GB: 856 speed = 1; 857 break; 858 case PORT_SPEED_2GB: 859 speed = 2; 860 break; 861 case PORT_SPEED_4GB: 862 speed = 4; 863 break; 864 case PORT_SPEED_8GB: 865 speed = 8; 866 break; 867 } 868 fc_host_speed(shost) = speed; 869 } 870 871 static void 872 qla2x00_get_host_port_type(struct Scsi_Host *shost) 873 { 874 scsi_qla_host_t *ha = to_qla_parent(shost_priv(shost)); 875 uint32_t port_type = FC_PORTTYPE_UNKNOWN; 876 877 switch (ha->current_topology) { 878 case ISP_CFG_NL: 879 port_type = FC_PORTTYPE_LPORT; 880 break; 881 case ISP_CFG_FL: 882 port_type = FC_PORTTYPE_NLPORT; 883 break; 884 case ISP_CFG_N: 885 port_type = FC_PORTTYPE_PTP; 886 break; 887 case ISP_CFG_F: 888 port_type = FC_PORTTYPE_NPORT; 889 break; 890 } 891 fc_host_port_type(shost) = port_type; 892 } 893 894 static void 895 qla2x00_get_starget_node_name(struct scsi_target *starget) 896 { 897 struct Scsi_Host *host = dev_to_shost(starget->dev.parent); 898 scsi_qla_host_t *ha = shost_priv(host); 899 fc_port_t *fcport; 900 u64 node_name = 0; 901 902 list_for_each_entry(fcport, &ha->fcports, list) { 903 if (starget->id == fcport->os_target_id) { 904 node_name = wwn_to_u64(fcport->node_name); 905 break; 906 } 907 } 908 909 fc_starget_node_name(starget) = node_name; 910 } 911 912 static void 913 qla2x00_get_starget_port_name(struct scsi_target *starget) 914 { 915 struct Scsi_Host *host = dev_to_shost(starget->dev.parent); 916 scsi_qla_host_t *ha = shost_priv(host); 917 fc_port_t *fcport; 918 u64 port_name = 0; 919 920 list_for_each_entry(fcport, &ha->fcports, list) { 921 if (starget->id == fcport->os_target_id) { 922 port_name = wwn_to_u64(fcport->port_name); 923 break; 924 } 925 } 926 927 fc_starget_port_name(starget) = port_name; 928 } 929 930 static void 931 qla2x00_get_starget_port_id(struct scsi_target *starget) 932 { 933 struct Scsi_Host *host = dev_to_shost(starget->dev.parent); 934 scsi_qla_host_t *ha = shost_priv(host); 935 fc_port_t *fcport; 936 uint32_t port_id = ~0U; 937 938 list_for_each_entry(fcport, &ha->fcports, list) { 939 if (starget->id == fcport->os_target_id) { 940 port_id = fcport->d_id.b.domain << 16 | 941 fcport->d_id.b.area << 8 | fcport->d_id.b.al_pa; 942 break; 943 } 944 } 945 946 fc_starget_port_id(starget) = port_id; 947 } 948 949 static void 950 qla2x00_get_rport_loss_tmo(struct fc_rport *rport) 951 { 952 struct Scsi_Host *host = rport_to_shost(rport); 953 scsi_qla_host_t *ha = shost_priv(host); 954 955 rport->dev_loss_tmo = ha->port_down_retry_count + 5; 956 } 957 958 static void 959 qla2x00_set_rport_loss_tmo(struct fc_rport *rport, uint32_t timeout) 960 { 961 struct Scsi_Host *host = rport_to_shost(rport); 962 scsi_qla_host_t *ha = shost_priv(host); 963 964 if (timeout) 965 ha->port_down_retry_count = timeout; 966 else 967 ha->port_down_retry_count = 1; 968 969 rport->dev_loss_tmo = ha->port_down_retry_count + 5; 970 } 971 972 static int 973 qla2x00_issue_lip(struct Scsi_Host *shost) 974 { 975 scsi_qla_host_t *ha = shost_priv(shost); 976 977 qla2x00_loop_reset(ha); 978 return 0; 979 } 980 981 static struct fc_host_statistics * 982 qla2x00_get_fc_host_stats(struct Scsi_Host *shost) 983 { 984 scsi_qla_host_t *ha = to_qla_parent(shost_priv(shost)); 985 int rval; 986 struct link_statistics *stats; 987 dma_addr_t stats_dma; 988 struct fc_host_statistics *pfc_host_stat; 989 990 pfc_host_stat = &ha->fc_host_stat; 991 memset(pfc_host_stat, -1, sizeof(struct fc_host_statistics)); 992 993 stats = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &stats_dma); 994 if (stats == NULL) { 995 DEBUG2_3_11(printk("%s(%ld): Failed to allocate memory.\n", 996 __func__, ha->host_no)); 997 goto done; 998 } 999 memset(stats, 0, DMA_POOL_SIZE); 1000 1001 rval = QLA_FUNCTION_FAILED; 1002 if (IS_FWI2_CAPABLE(ha)) { 1003 rval = qla24xx_get_isp_stats(ha, stats, stats_dma); 1004 } else if (atomic_read(&ha->loop_state) == LOOP_READY && 1005 !test_bit(ABORT_ISP_ACTIVE, &ha->dpc_flags) && 1006 !test_bit(ISP_ABORT_NEEDED, &ha->dpc_flags) && 1007 !ha->dpc_active) { 1008 /* Must be in a 'READY' state for statistics retrieval. */ 1009 rval = qla2x00_get_link_status(ha, ha->loop_id, stats, 1010 stats_dma); 1011 } 1012 1013 if (rval != QLA_SUCCESS) 1014 goto done_free; 1015 1016 pfc_host_stat->link_failure_count = stats->link_fail_cnt; 1017 pfc_host_stat->loss_of_sync_count = stats->loss_sync_cnt; 1018 pfc_host_stat->loss_of_signal_count = stats->loss_sig_cnt; 1019 pfc_host_stat->prim_seq_protocol_err_count = stats->prim_seq_err_cnt; 1020 pfc_host_stat->invalid_tx_word_count = stats->inval_xmit_word_cnt; 1021 pfc_host_stat->invalid_crc_count = stats->inval_crc_cnt; 1022 if (IS_FWI2_CAPABLE(ha)) { 1023 pfc_host_stat->tx_frames = stats->tx_frames; 1024 pfc_host_stat->rx_frames = stats->rx_frames; 1025 pfc_host_stat->dumped_frames = stats->dumped_frames; 1026 pfc_host_stat->nos_count = stats->nos_rcvd; 1027 } 1028 1029 done_free: 1030 dma_pool_free(ha->s_dma_pool, stats, stats_dma); 1031 done: 1032 return pfc_host_stat; 1033 } 1034 1035 static void 1036 qla2x00_get_host_symbolic_name(struct Scsi_Host *shost) 1037 { 1038 scsi_qla_host_t *ha = shost_priv(shost); 1039 1040 qla2x00_get_sym_node_name(ha, fc_host_symbolic_name(shost)); 1041 } 1042 1043 static void 1044 qla2x00_set_host_system_hostname(struct Scsi_Host *shost) 1045 { 1046 scsi_qla_host_t *ha = shost_priv(shost); 1047 1048 set_bit(REGISTER_FDMI_NEEDED, &ha->dpc_flags); 1049 } 1050 1051 static void 1052 qla2x00_get_host_fabric_name(struct Scsi_Host *shost) 1053 { 1054 scsi_qla_host_t *ha = shost_priv(shost); 1055 u64 node_name; 1056 1057 if (ha->device_flags & SWITCH_FOUND) 1058 node_name = wwn_to_u64(ha->fabric_node_name); 1059 else 1060 node_name = wwn_to_u64(ha->node_name); 1061 1062 fc_host_fabric_name(shost) = node_name; 1063 } 1064 1065 static void 1066 qla2x00_get_host_port_state(struct Scsi_Host *shost) 1067 { 1068 scsi_qla_host_t *ha = to_qla_parent(shost_priv(shost)); 1069 1070 if (!ha->flags.online) 1071 fc_host_port_state(shost) = FC_PORTSTATE_OFFLINE; 1072 else if (atomic_read(&ha->loop_state) == LOOP_TIMEOUT) 1073 fc_host_port_state(shost) = FC_PORTSTATE_UNKNOWN; 1074 else 1075 fc_host_port_state(shost) = FC_PORTSTATE_ONLINE; 1076 } 1077 1078 static int 1079 qla24xx_vport_create(struct fc_vport *fc_vport, bool disable) 1080 { 1081 int ret = 0; 1082 scsi_qla_host_t *ha = shost_priv(fc_vport->shost); 1083 scsi_qla_host_t *vha; 1084 1085 ret = qla24xx_vport_create_req_sanity_check(fc_vport); 1086 if (ret) { 1087 DEBUG15(printk("qla24xx_vport_create_req_sanity_check failed, " 1088 "status %x\n", ret)); 1089 return (ret); 1090 } 1091 1092 vha = qla24xx_create_vhost(fc_vport); 1093 if (vha == NULL) { 1094 DEBUG15(printk ("qla24xx_create_vhost failed, vha = %p\n", 1095 vha)); 1096 return FC_VPORT_FAILED; 1097 } 1098 if (disable) { 1099 atomic_set(&vha->vp_state, VP_OFFLINE); 1100 fc_vport_set_state(fc_vport, FC_VPORT_DISABLED); 1101 } else 1102 atomic_set(&vha->vp_state, VP_FAILED); 1103 1104 /* ready to create vport */ 1105 qla_printk(KERN_INFO, vha, "VP entry id %d assigned.\n", vha->vp_idx); 1106 1107 /* initialized vport states */ 1108 atomic_set(&vha->loop_state, LOOP_DOWN); 1109 vha->vp_err_state= VP_ERR_PORTDWN; 1110 vha->vp_prev_err_state= VP_ERR_UNKWN; 1111 /* Check if physical ha port is Up */ 1112 if (atomic_read(&ha->loop_state) == LOOP_DOWN || 1113 atomic_read(&ha->loop_state) == LOOP_DEAD) { 1114 /* Don't retry or attempt login of this virtual port */ 1115 DEBUG15(printk ("scsi(%ld): pport loop_state is not UP.\n", 1116 vha->host_no)); 1117 atomic_set(&vha->loop_state, LOOP_DEAD); 1118 if (!disable) 1119 fc_vport_set_state(fc_vport, FC_VPORT_LINKDOWN); 1120 } 1121 1122 if (scsi_add_host(vha->host, &fc_vport->dev)) { 1123 DEBUG15(printk("scsi(%ld): scsi_add_host failure for VP[%d].\n", 1124 vha->host_no, vha->vp_idx)); 1125 goto vport_create_failed_2; 1126 } 1127 1128 /* initialize attributes */ 1129 fc_host_node_name(vha->host) = wwn_to_u64(vha->node_name); 1130 fc_host_port_name(vha->host) = wwn_to_u64(vha->port_name); 1131 fc_host_supported_classes(vha->host) = 1132 fc_host_supported_classes(ha->host); 1133 fc_host_supported_speeds(vha->host) = 1134 fc_host_supported_speeds(ha->host); 1135 1136 qla24xx_vport_disable(fc_vport, disable); 1137 1138 return 0; 1139 vport_create_failed_2: 1140 qla24xx_disable_vp(vha); 1141 qla24xx_deallocate_vp_id(vha); 1142 kfree(vha->port_name); 1143 kfree(vha->node_name); 1144 scsi_host_put(vha->host); 1145 return FC_VPORT_FAILED; 1146 } 1147 1148 static int 1149 qla24xx_vport_delete(struct fc_vport *fc_vport) 1150 { 1151 scsi_qla_host_t *ha = shost_priv(fc_vport->shost); 1152 scsi_qla_host_t *vha = fc_vport->dd_data; 1153 1154 qla24xx_disable_vp(vha); 1155 qla24xx_deallocate_vp_id(vha); 1156 1157 down(&ha->vport_sem); 1158 ha->cur_vport_count--; 1159 clear_bit(vha->vp_idx, ha->vp_idx_map); 1160 up(&ha->vport_sem); 1161 1162 kfree(vha->node_name); 1163 kfree(vha->port_name); 1164 1165 if (vha->timer_active) { 1166 qla2x00_vp_stop_timer(vha); 1167 DEBUG15(printk ("scsi(%ld): timer for the vport[%d] = %p " 1168 "has stopped\n", 1169 vha->host_no, vha->vp_idx, vha)); 1170 } 1171 1172 fc_remove_host(vha->host); 1173 1174 scsi_remove_host(vha->host); 1175 1176 scsi_host_put(vha->host); 1177 1178 return 0; 1179 } 1180 1181 static int 1182 qla24xx_vport_disable(struct fc_vport *fc_vport, bool disable) 1183 { 1184 scsi_qla_host_t *vha = fc_vport->dd_data; 1185 1186 if (disable) 1187 qla24xx_disable_vp(vha); 1188 else 1189 qla24xx_enable_vp(vha); 1190 1191 return 0; 1192 } 1193 1194 struct fc_function_template qla2xxx_transport_functions = { 1195 1196 .show_host_node_name = 1, 1197 .show_host_port_name = 1, 1198 .show_host_supported_classes = 1, 1199 1200 .get_host_port_id = qla2x00_get_host_port_id, 1201 .show_host_port_id = 1, 1202 .get_host_speed = qla2x00_get_host_speed, 1203 .show_host_speed = 1, 1204 .get_host_port_type = qla2x00_get_host_port_type, 1205 .show_host_port_type = 1, 1206 .get_host_symbolic_name = qla2x00_get_host_symbolic_name, 1207 .show_host_symbolic_name = 1, 1208 .set_host_system_hostname = qla2x00_set_host_system_hostname, 1209 .show_host_system_hostname = 1, 1210 .get_host_fabric_name = qla2x00_get_host_fabric_name, 1211 .show_host_fabric_name = 1, 1212 .get_host_port_state = qla2x00_get_host_port_state, 1213 .show_host_port_state = 1, 1214 1215 .dd_fcrport_size = sizeof(struct fc_port *), 1216 .show_rport_supported_classes = 1, 1217 1218 .get_starget_node_name = qla2x00_get_starget_node_name, 1219 .show_starget_node_name = 1, 1220 .get_starget_port_name = qla2x00_get_starget_port_name, 1221 .show_starget_port_name = 1, 1222 .get_starget_port_id = qla2x00_get_starget_port_id, 1223 .show_starget_port_id = 1, 1224 1225 .get_rport_dev_loss_tmo = qla2x00_get_rport_loss_tmo, 1226 .set_rport_dev_loss_tmo = qla2x00_set_rport_loss_tmo, 1227 .show_rport_dev_loss_tmo = 1, 1228 1229 .issue_fc_host_lip = qla2x00_issue_lip, 1230 .get_fc_host_stats = qla2x00_get_fc_host_stats, 1231 1232 .vport_create = qla24xx_vport_create, 1233 .vport_disable = qla24xx_vport_disable, 1234 .vport_delete = qla24xx_vport_delete, 1235 }; 1236 1237 struct fc_function_template qla2xxx_transport_vport_functions = { 1238 1239 .show_host_node_name = 1, 1240 .show_host_port_name = 1, 1241 .show_host_supported_classes = 1, 1242 1243 .get_host_port_id = qla2x00_get_host_port_id, 1244 .show_host_port_id = 1, 1245 .get_host_speed = qla2x00_get_host_speed, 1246 .show_host_speed = 1, 1247 .get_host_port_type = qla2x00_get_host_port_type, 1248 .show_host_port_type = 1, 1249 .get_host_symbolic_name = qla2x00_get_host_symbolic_name, 1250 .show_host_symbolic_name = 1, 1251 .set_host_system_hostname = qla2x00_set_host_system_hostname, 1252 .show_host_system_hostname = 1, 1253 .get_host_fabric_name = qla2x00_get_host_fabric_name, 1254 .show_host_fabric_name = 1, 1255 .get_host_port_state = qla2x00_get_host_port_state, 1256 .show_host_port_state = 1, 1257 1258 .dd_fcrport_size = sizeof(struct fc_port *), 1259 .show_rport_supported_classes = 1, 1260 1261 .get_starget_node_name = qla2x00_get_starget_node_name, 1262 .show_starget_node_name = 1, 1263 .get_starget_port_name = qla2x00_get_starget_port_name, 1264 .show_starget_port_name = 1, 1265 .get_starget_port_id = qla2x00_get_starget_port_id, 1266 .show_starget_port_id = 1, 1267 1268 .get_rport_dev_loss_tmo = qla2x00_get_rport_loss_tmo, 1269 .set_rport_dev_loss_tmo = qla2x00_set_rport_loss_tmo, 1270 .show_rport_dev_loss_tmo = 1, 1271 1272 .issue_fc_host_lip = qla2x00_issue_lip, 1273 .get_fc_host_stats = qla2x00_get_fc_host_stats, 1274 }; 1275 1276 void 1277 qla2x00_init_host_attr(scsi_qla_host_t *ha) 1278 { 1279 fc_host_node_name(ha->host) = wwn_to_u64(ha->node_name); 1280 fc_host_port_name(ha->host) = wwn_to_u64(ha->port_name); 1281 fc_host_supported_classes(ha->host) = FC_COS_CLASS3; 1282 fc_host_max_npiv_vports(ha->host) = ha->max_npiv_vports;; 1283 fc_host_npiv_vports_inuse(ha->host) = ha->cur_vport_count; 1284 } 1285