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