drivers/scsi/qla2xxx/qla_attr.c

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