drivers/scsi/qla2xxx/qla_attr.c

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