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