// SPDX-License-Identifier: GPL-2.0-only
/*
 * QLogic Fibre Channel HBA Driver
 * Copyright (c)  2003-2014 QLogic Corporation
 */
#include "qla_def.h"
#include "qla_target.h"

#include <linux/kthread.h>
#include <linux/vmalloc.h>
#include <linux/slab.h>
#include <linux/delay.h>

static int qla24xx_vport_disable(struct fc_vport *, bool);

/* SYSFS attributes --------------------------------------------------------- */

static ssize_t
qla2x00_sysfs_read_fw_dump(struct file *filp, struct kobject *kobj,
                           struct bin_attribute *bin_attr,
                           char *buf, loff_t off, size_t count)
{
        struct scsi_qla_host *vha = shost_priv(dev_to_shost(container_of(kobj,
            struct device, kobj)));
        struct qla_hw_data *ha = vha->hw;
        int rval = 0;

        if (!(ha->fw_dump_reading || ha->mctp_dump_reading ||
              ha->mpi_fw_dump_reading))
                return 0;

        mutex_lock(&ha->optrom_mutex);
        if (IS_P3P_TYPE(ha)) {
                if (off < ha->md_template_size) {
                        rval = memory_read_from_buffer(buf, count,
                            &off, ha->md_tmplt_hdr, ha->md_template_size);
                } else {
                        off -= ha->md_template_size;
                        rval = memory_read_from_buffer(buf, count,
                            &off, ha->md_dump, ha->md_dump_size);
                }
        } else if (ha->mctp_dumped && ha->mctp_dump_reading) {
                rval = memory_read_from_buffer(buf, count, &off, ha->mctp_dump,
                    MCTP_DUMP_SIZE);
        } else if (ha->mpi_fw_dumped && ha->mpi_fw_dump_reading) {
                rval = memory_read_from_buffer(buf, count, &off,
                                               ha->mpi_fw_dump,
                                               ha->mpi_fw_dump_len);
        } else if (ha->fw_dump_reading) {
                rval = memory_read_from_buffer(buf, count, &off, ha->fw_dump,
                                        ha->fw_dump_len);
        } else {
                rval = 0;
        }
        mutex_unlock(&ha->optrom_mutex);
        return rval;
}

static ssize_t
qla2x00_sysfs_write_fw_dump(struct file *filp, struct kobject *kobj,
                            struct bin_attribute *bin_attr,
                            char *buf, loff_t off, size_t count)
{
        struct scsi_qla_host *vha = shost_priv(dev_to_shost(container_of(kobj,
            struct device, kobj)));
        struct qla_hw_data *ha = vha->hw;
        int reading;

        if (off != 0)
                return (0);

        reading = simple_strtol(buf, NULL, 10);
        switch (reading) {
        case 0:
                if (!ha->fw_dump_reading)
                        break;

                ql_log(ql_log_info, vha, 0x705d,
                    "Firmware dump cleared on (%ld).\n", vha->host_no);

                if (IS_P3P_TYPE(ha)) {
                        qla82xx_md_free(vha);
                        qla82xx_md_prep(vha);
                }
                ha->fw_dump_reading = 0;
                ha->fw_dumped = false;
                break;
        case 1:
                if (ha->fw_dumped && !ha->fw_dump_reading) {
                        ha->fw_dump_reading = 1;

                        ql_log(ql_log_info, vha, 0x705e,
                            "Raw firmware dump ready for read on (%ld).\n",
                            vha->host_no);
                }
                break;
        case 2:
                qla2x00_alloc_fw_dump(vha);
                break;
        case 3:
                if (IS_QLA82XX(ha)) {
                        qla82xx_idc_lock(ha);
                        qla82xx_set_reset_owner(vha);
                        qla82xx_idc_unlock(ha);
                } else if (IS_QLA8044(ha)) {
                        qla8044_idc_lock(ha);
                        qla82xx_set_reset_owner(vha);
                        qla8044_idc_unlock(ha);
                } else {
                        qla2x00_system_error(vha);
                }
                break;
        case 4:
                if (IS_P3P_TYPE(ha)) {
                        if (ha->md_tmplt_hdr)
                                ql_dbg(ql_dbg_user, vha, 0x705b,
                                    "MiniDump supported with this firmware.\n");
                        else
                                ql_dbg(ql_dbg_user, vha, 0x709d,
                                    "MiniDump not supported with this firmware.\n");
                }
                break;
        case 5:
                if (IS_P3P_TYPE(ha))
                        set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
                break;
        case 6:
                if (!ha->mctp_dump_reading)
                        break;
                ql_log(ql_log_info, vha, 0x70c1,
                    "MCTP dump cleared on (%ld).\n", vha->host_no);
                ha->mctp_dump_reading = 0;
                ha->mctp_dumped = 0;
                break;
        case 7:
                if (ha->mctp_dumped && !ha->mctp_dump_reading) {
                        ha->mctp_dump_reading = 1;
                        ql_log(ql_log_info, vha, 0x70c2,
                            "Raw mctp dump ready for read on (%ld).\n",
                            vha->host_no);
                }
                break;
        case 8:
                if (!ha->mpi_fw_dump_reading)
                        break;
                ql_log(ql_log_info, vha, 0x70e7,
                       "MPI firmware dump cleared on (%ld).\n", vha->host_no);
                ha->mpi_fw_dump_reading = 0;
                ha->mpi_fw_dumped = 0;
                break;
        case 9:
                if (ha->mpi_fw_dumped && !ha->mpi_fw_dump_reading) {
                        ha->mpi_fw_dump_reading = 1;
                        ql_log(ql_log_info, vha, 0x70e8,
                               "Raw MPI firmware dump ready for read on (%ld).\n",
                               vha->host_no);
                }
                break;
        case 10:
                if (IS_QLA27XX(ha) || IS_QLA28XX(ha)) {
                        ql_log(ql_log_info, vha, 0x70e9,
                               "Issuing MPI firmware dump on host#%ld.\n",
                               vha->host_no);
                        ha->isp_ops->mpi_fw_dump(vha, 0);
                }
                break;
        }
        return count;
}

static struct bin_attribute sysfs_fw_dump_attr = {
        .attr = {
                .name = "fw_dump",
                .mode = S_IRUSR | S_IWUSR,
        },
        .size = 0,
        .read = qla2x00_sysfs_read_fw_dump,
        .write = qla2x00_sysfs_write_fw_dump,
};

static ssize_t
qla2x00_sysfs_read_nvram(struct file *filp, struct kobject *kobj,
                         struct bin_attribute *bin_attr,
                         char *buf, loff_t off, size_t count)
{
        struct scsi_qla_host *vha = shost_priv(dev_to_shost(container_of(kobj,
            struct device, kobj)));
        struct qla_hw_data *ha = vha->hw;
        uint32_t faddr;
        struct active_regions active_regions = { };

        if (!capable(CAP_SYS_ADMIN))
                return 0;

        mutex_lock(&ha->optrom_mutex);
        if (qla2x00_chip_is_down(vha)) {
                mutex_unlock(&ha->optrom_mutex);
                return -EAGAIN;
        }

        if (!IS_NOCACHE_VPD_TYPE(ha)) {
                mutex_unlock(&ha->optrom_mutex);
                goto skip;
        }

        faddr = ha->flt_region_nvram;
        if (IS_QLA28XX(ha)) {
                qla28xx_get_aux_images(vha, &active_regions);
                if (active_regions.aux.vpd_nvram == QLA27XX_SECONDARY_IMAGE)
                        faddr = ha->flt_region_nvram_sec;
        }
        ha->isp_ops->read_optrom(vha, ha->nvram, faddr << 2, ha->nvram_size);

        mutex_unlock(&ha->optrom_mutex);

skip:
        return memory_read_from_buffer(buf, count, &off, ha->nvram,
                                        ha->nvram_size);
}

static ssize_t
qla2x00_sysfs_write_nvram(struct file *filp, struct kobject *kobj,
                          struct bin_attribute *bin_attr,
                          char *buf, loff_t off, size_t count)
{
        struct scsi_qla_host *vha = shost_priv(dev_to_shost(container_of(kobj,
            struct device, kobj)));
        struct qla_hw_data *ha = vha->hw;
        uint16_t        cnt;

        if (!capable(CAP_SYS_ADMIN) || off != 0 || count != ha->nvram_size ||
            !ha->isp_ops->write_nvram)
                return -EINVAL;

        /* Checksum NVRAM. */
        if (IS_FWI2_CAPABLE(ha)) {
                __le32 *iter = (__force __le32 *)buf;
                uint32_t chksum;

                chksum = 0;
                for (cnt = 0; cnt < ((count >> 2) - 1); cnt++, iter++)
                        chksum += le32_to_cpu(*iter);
                chksum = ~chksum + 1;
                *iter = cpu_to_le32(chksum);
        } else {
                uint8_t *iter;
                uint8_t chksum;

                iter = (uint8_t *)buf;
                chksum = 0;
                for (cnt = 0; cnt < count - 1; cnt++)
                        chksum += *iter++;
                chksum = ~chksum + 1;
                *iter = chksum;
        }

        if (qla2x00_wait_for_hba_online(vha) != QLA_SUCCESS) {
                ql_log(ql_log_warn, vha, 0x705f,
                    "HBA not online, failing NVRAM update.\n");
                return -EAGAIN;
        }

        mutex_lock(&ha->optrom_mutex);
        if (qla2x00_chip_is_down(vha)) {
                mutex_unlock(&ha->optrom_mutex);
                return -EAGAIN;
        }

        /* Write NVRAM. */
        ha->isp_ops->write_nvram(vha, buf, ha->nvram_base, count);
        ha->isp_ops->read_nvram(vha, ha->nvram, ha->nvram_base,
            count);
        mutex_unlock(&ha->optrom_mutex);

        ql_dbg(ql_dbg_user, vha, 0x7060,
            "Setting ISP_ABORT_NEEDED\n");
        /* NVRAM settings take effect immediately. */
        set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
        qla2xxx_wake_dpc(vha);
        qla2x00_wait_for_chip_reset(vha);

        return count;
}

static struct bin_attribute sysfs_nvram_attr = {
        .attr = {
                .name = "nvram",
                .mode = S_IRUSR | S_IWUSR,
        },
        .size = 512,
        .read = qla2x00_sysfs_read_nvram,
        .write = qla2x00_sysfs_write_nvram,
};

static ssize_t
qla2x00_sysfs_read_optrom(struct file *filp, struct kobject *kobj,
                          struct bin_attribute *bin_attr,
                          char *buf, loff_t off, size_t count)
{
        struct scsi_qla_host *vha = shost_priv(dev_to_shost(container_of(kobj,
            struct device, kobj)));
        struct qla_hw_data *ha = vha->hw;
        ssize_t rval = 0;

        mutex_lock(&ha->optrom_mutex);

        if (ha->optrom_state != QLA_SREADING)
                goto out;

        rval = memory_read_from_buffer(buf, count, &off, ha->optrom_buffer,
            ha->optrom_region_size);

out:
        mutex_unlock(&ha->optrom_mutex);

        return rval;
}

static ssize_t
qla2x00_sysfs_write_optrom(struct file *filp, struct kobject *kobj,
                           struct bin_attribute *bin_attr,
                           char *buf, loff_t off, size_t count)
{
        struct scsi_qla_host *vha = shost_priv(dev_to_shost(container_of(kobj,
            struct device, kobj)));
        struct qla_hw_data *ha = vha->hw;

        mutex_lock(&ha->optrom_mutex);

        if (ha->optrom_state != QLA_SWRITING) {
                mutex_unlock(&ha->optrom_mutex);
                return -EINVAL;
        }
        if (off > ha->optrom_region_size) {
                mutex_unlock(&ha->optrom_mutex);
                return -ERANGE;
        }
        if (off + count > ha->optrom_region_size)
                count = ha->optrom_region_size - off;

        memcpy(&ha->optrom_buffer[off], buf, count);
        mutex_unlock(&ha->optrom_mutex);

        return count;
}

static struct bin_attribute sysfs_optrom_attr = {
        .attr = {
                .name = "optrom",
                .mode = S_IRUSR | S_IWUSR,
        },
        .size = 0,
        .read = qla2x00_sysfs_read_optrom,
        .write = qla2x00_sysfs_write_optrom,
};

static ssize_t
qla2x00_sysfs_write_optrom_ctl(struct file *filp, struct kobject *kobj,
                               struct bin_attribute *bin_attr,
                               char *buf, loff_t off, size_t count)
{
        struct scsi_qla_host *vha = shost_priv(dev_to_shost(container_of(kobj,
            struct device, kobj)));
        struct qla_hw_data *ha = vha->hw;
        uint32_t start = 0;
        uint32_t size = ha->optrom_size;
        int val, valid;
        ssize_t rval = count;

        if (off)
                return -EINVAL;

        if (unlikely(pci_channel_offline(ha->pdev)))
                return -EAGAIN;

        if (sscanf(buf, "%d:%x:%x", &val, &start, &size) < 1)
                return -EINVAL;
        if (start > ha->optrom_size)
                return -EINVAL;
        if (size > ha->optrom_size - start)
                size = ha->optrom_size - start;

        mutex_lock(&ha->optrom_mutex);
        if (qla2x00_chip_is_down(vha)) {
                mutex_unlock(&ha->optrom_mutex);
                return -EAGAIN;
        }
        switch (val) {
        case 0:
                if (ha->optrom_state != QLA_SREADING &&
                    ha->optrom_state != QLA_SWRITING) {
                        rval =  -EINVAL;
                        goto out;
                }
                ha->optrom_state = QLA_SWAITING;

                ql_dbg(ql_dbg_user, vha, 0x7061,
                    "Freeing flash region allocation -- 0x%x bytes.\n",
                    ha->optrom_region_size);

                vfree(ha->optrom_buffer);
                ha->optrom_buffer = NULL;
                break;
        case 1:
                if (ha->optrom_state != QLA_SWAITING) {
                        rval = -EINVAL;
                        goto out;
                }

                ha->optrom_region_start = start;
                ha->optrom_region_size = size;

                ha->optrom_state = QLA_SREADING;
                ha->optrom_buffer = vzalloc(ha->optrom_region_size);
                if (ha->optrom_buffer == NULL) {
                        ql_log(ql_log_warn, vha, 0x7062,
                            "Unable to allocate memory for optrom retrieval "
                            "(%x).\n", ha->optrom_region_size);

                        ha->optrom_state = QLA_SWAITING;
                        rval = -ENOMEM;
                        goto out;
                }

                if (qla2x00_wait_for_hba_online(vha) != QLA_SUCCESS) {
                        ql_log(ql_log_warn, vha, 0x7063,
                            "HBA not online, failing NVRAM update.\n");
                        rval = -EAGAIN;
                        goto out;
                }

                ql_dbg(ql_dbg_user, vha, 0x7064,
                    "Reading flash region -- 0x%x/0x%x.\n",
                    ha->optrom_region_start, ha->optrom_region_size);

                ha->isp_ops->read_optrom(vha, ha->optrom_buffer,
                    ha->optrom_region_start, ha->optrom_region_size);
                break;
        case 2:
                if (ha->optrom_state != QLA_SWAITING) {
                        rval = -EINVAL;
                        goto out;
                }

                /*
                 * We need to be more restrictive on which FLASH regions are
                 * allowed to be updated via user-space.  Regions accessible
                 * via this method include:
                 *
                 * ISP21xx/ISP22xx/ISP23xx type boards:
                 *
                 *      0x000000 -> 0x020000 -- Boot code.
                 *
                 * ISP2322/ISP24xx type boards:
                 *
                 *      0x000000 -> 0x07ffff -- Boot code.
                 *      0x080000 -> 0x0fffff -- Firmware.
                 *
                 * ISP25xx type boards:
                 *
                 *      0x000000 -> 0x07ffff -- Boot code.
                 *      0x080000 -> 0x0fffff -- Firmware.
                 *      0x120000 -> 0x12ffff -- VPD and HBA parameters.
                 *
                 * > ISP25xx type boards:
                 *
                 *      None -- should go through BSG.
                 */
                valid = 0;
                if (ha->optrom_size == OPTROM_SIZE_2300 && start == 0)
                        valid = 1;
                else if (IS_QLA24XX_TYPE(ha) || IS_QLA25XX(ha))
                        valid = 1;
                if (!valid) {
                        ql_log(ql_log_warn, vha, 0x7065,
                            "Invalid start region 0x%x/0x%x.\n", start, size);
                        rval = -EINVAL;
                        goto out;
                }

                ha->optrom_region_start = start;
                ha->optrom_region_size = size;

                ha->optrom_state = QLA_SWRITING;
                ha->optrom_buffer = vzalloc(ha->optrom_region_size);
                if (ha->optrom_buffer == NULL) {
                        ql_log(ql_log_warn, vha, 0x7066,
                            "Unable to allocate memory for optrom update "
                            "(%x)\n", ha->optrom_region_size);

                        ha->optrom_state = QLA_SWAITING;
                        rval = -ENOMEM;
                        goto out;
                }

                ql_dbg(ql_dbg_user, vha, 0x7067,
                    "Staging flash region write -- 0x%x/0x%x.\n",
                    ha->optrom_region_start, ha->optrom_region_size);

                break;
        case 3:
                if (ha->optrom_state != QLA_SWRITING) {
                        rval = -EINVAL;
                        goto out;
                }

                if (qla2x00_wait_for_hba_online(vha) != QLA_SUCCESS) {
                        ql_log(ql_log_warn, vha, 0x7068,
                            "HBA not online, failing flash update.\n");
                        rval = -EAGAIN;
                        goto out;
                }

                ql_dbg(ql_dbg_user, vha, 0x7069,
                    "Writing flash region -- 0x%x/0x%x.\n",
                    ha->optrom_region_start, ha->optrom_region_size);

                rval = ha->isp_ops->write_optrom(vha, ha->optrom_buffer,
                    ha->optrom_region_start, ha->optrom_region_size);
                if (rval)
                        rval = -EIO;
                break;
        default:
                rval = -EINVAL;
        }

out:
        mutex_unlock(&ha->optrom_mutex);
        return rval;
}

static struct bin_attribute sysfs_optrom_ctl_attr = {
        .attr = {
                .name = "optrom_ctl",
                .mode = S_IWUSR,
        },
        .size = 0,
        .write = qla2x00_sysfs_write_optrom_ctl,
};

static ssize_t
qla2x00_sysfs_read_vpd(struct file *filp, struct kobject *kobj,
                       struct bin_attribute *bin_attr,
                       char *buf, loff_t off, size_t count)
{
        struct scsi_qla_host *vha = shost_priv(dev_to_shost(container_of(kobj,
            struct device, kobj)));
        struct qla_hw_data *ha = vha->hw;
        uint32_t faddr;
        struct active_regions active_regions = { };

        if (unlikely(pci_channel_offline(ha->pdev)))
                return -EAGAIN;

        if (!capable(CAP_SYS_ADMIN))
                return -EINVAL;

        if (IS_NOCACHE_VPD_TYPE(ha))
                goto skip;

        faddr = ha->flt_region_vpd << 2;

        if (IS_QLA28XX(ha)) {
                qla28xx_get_aux_images(vha, &active_regions);
                if (active_regions.aux.vpd_nvram == QLA27XX_SECONDARY_IMAGE)
                        faddr = ha->flt_region_vpd_sec << 2;

                ql_dbg(ql_dbg_init, vha, 0x7070,
                    "Loading %s nvram image.\n",
                    active_regions.aux.vpd_nvram == QLA27XX_PRIMARY_IMAGE ?
                    "primary" : "secondary");
        }

        mutex_lock(&ha->optrom_mutex);
        if (qla2x00_chip_is_down(vha)) {
                mutex_unlock(&ha->optrom_mutex);
                return -EAGAIN;
        }

        ha->isp_ops->read_optrom(vha, ha->vpd, faddr, ha->vpd_size);
        mutex_unlock(&ha->optrom_mutex);

        ha->isp_ops->read_optrom(vha, ha->vpd, faddr, ha->vpd_size);
skip:
        return memory_read_from_buffer(buf, count, &off, ha->vpd, ha->vpd_size);
}

static ssize_t
qla2x00_sysfs_write_vpd(struct file *filp, struct kobject *kobj,
                        struct bin_attribute *bin_attr,
                        char *buf, loff_t off, size_t count)
{
        struct scsi_qla_host *vha = shost_priv(dev_to_shost(container_of(kobj,
            struct device, kobj)));
        struct qla_hw_data *ha = vha->hw;
        uint8_t *tmp_data;

        if (unlikely(pci_channel_offline(ha->pdev)))
                return 0;

        if (qla2x00_chip_is_down(vha))
                return 0;

        if (!capable(CAP_SYS_ADMIN) || off != 0 || count != ha->vpd_size ||
            !ha->isp_ops->write_nvram)
                return 0;

        if (qla2x00_wait_for_hba_online(vha) != QLA_SUCCESS) {
                ql_log(ql_log_warn, vha, 0x706a,
                    "HBA not online, failing VPD update.\n");
                return -EAGAIN;
        }

        mutex_lock(&ha->optrom_mutex);
        if (qla2x00_chip_is_down(vha)) {
                mutex_unlock(&ha->optrom_mutex);
                return -EAGAIN;
        }

        /* Write NVRAM. */
        ha->isp_ops->write_nvram(vha, buf, ha->vpd_base, count);
        ha->isp_ops->read_nvram(vha, ha->vpd, ha->vpd_base, count);

        /* Update flash version information for 4Gb & above. */
        if (!IS_FWI2_CAPABLE(ha)) {
                mutex_unlock(&ha->optrom_mutex);
                return -EINVAL;
        }

        tmp_data = vmalloc(256);
        if (!tmp_data) {
                mutex_unlock(&ha->optrom_mutex);
                ql_log(ql_log_warn, vha, 0x706b,
                    "Unable to allocate memory for VPD information update.\n");
                return -ENOMEM;
        }
        ha->isp_ops->get_flash_version(vha, tmp_data);
        vfree(tmp_data);

        mutex_unlock(&ha->optrom_mutex);

        return count;
}

static struct bin_attribute sysfs_vpd_attr = {
        .attr = {
                .name = "vpd",
                .mode = S_IRUSR | S_IWUSR,
        },
        .size = 0,
        .read = qla2x00_sysfs_read_vpd,
        .write = qla2x00_sysfs_write_vpd,
};

static ssize_t
qla2x00_sysfs_read_sfp(struct file *filp, struct kobject *kobj,
                       struct bin_attribute *bin_attr,
                       char *buf, loff_t off, size_t count)
{
        struct scsi_qla_host *vha = shost_priv(dev_to_shost(container_of(kobj,
            struct device, kobj)));
        int rval;

        if (!capable(CAP_SYS_ADMIN) || off != 0 || count < SFP_DEV_SIZE)
                return 0;

        mutex_lock(&vha->hw->optrom_mutex);
        if (qla2x00_chip_is_down(vha)) {
                mutex_unlock(&vha->hw->optrom_mutex);
                return 0;
        }

        rval = qla2x00_read_sfp_dev(vha, buf, count);
        mutex_unlock(&vha->hw->optrom_mutex);

        if (rval)
                return -EIO;

        return count;
}

static struct bin_attribute sysfs_sfp_attr = {
        .attr = {
                .name = "sfp",
                .mode = S_IRUSR | S_IWUSR,
        },
        .size = SFP_DEV_SIZE,
        .read = qla2x00_sysfs_read_sfp,
};

static ssize_t
qla2x00_sysfs_write_reset(struct file *filp, struct kobject *kobj,
                        struct bin_attribute *bin_attr,
                        char *buf, loff_t off, size_t count)
{
        struct scsi_qla_host *vha = shost_priv(dev_to_shost(container_of(kobj,
            struct device, kobj)));
        struct qla_hw_data *ha = vha->hw;
        struct scsi_qla_host *base_vha = pci_get_drvdata(ha->pdev);
        int type;
        uint32_t idc_control;
        uint8_t *tmp_data = NULL;

        if (off != 0)
                return -EINVAL;

        type = simple_strtol(buf, NULL, 10);
        switch (type) {
        case 0x2025c:
                ql_log(ql_log_info, vha, 0x706e,
                    "Issuing ISP reset.\n");

                if (vha->hw->flags.port_isolated) {
                        ql_log(ql_log_info, vha, 0x706e,
                               "Port is isolated, returning.\n");
                        return -EINVAL;
                }

                scsi_block_requests(vha->host);
                if (IS_QLA82XX(ha)) {
                        ha->flags.isp82xx_no_md_cap = 1;
                        qla82xx_idc_lock(ha);
                        qla82xx_set_reset_owner(vha);
                        qla82xx_idc_unlock(ha);
                } else if (IS_QLA8044(ha)) {
                        qla8044_idc_lock(ha);
                        idc_control = qla8044_rd_reg(ha,
                            QLA8044_IDC_DRV_CTRL);
                        qla8044_wr_reg(ha, QLA8044_IDC_DRV_CTRL,
                            (idc_control | GRACEFUL_RESET_BIT1));
                        qla82xx_set_reset_owner(vha);
                        qla8044_idc_unlock(ha);
                } else {
                        set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
                        qla2xxx_wake_dpc(vha);
                }
                qla2x00_wait_for_chip_reset(vha);
                scsi_unblock_requests(vha->host);
                break;
        case 0x2025d:
                if (!IS_QLA81XX(ha) && !IS_QLA83XX(ha) &&
                    !IS_QLA27XX(ha) && !IS_QLA28XX(ha))
                        return -EPERM;

                ql_log(ql_log_info, vha, 0x706f,
                    "Issuing MPI reset.\n");

                if (IS_QLA83XX(ha) || IS_QLA27XX(ha) || IS_QLA28XX(ha)) {
                        uint32_t idc_control;

                        qla83xx_idc_lock(vha, 0);
                        __qla83xx_get_idc_control(vha, &idc_control);
                        idc_control |= QLA83XX_IDC_GRACEFUL_RESET;
                        __qla83xx_set_idc_control(vha, idc_control);
                        qla83xx_wr_reg(vha, QLA83XX_IDC_DEV_STATE,
                            QLA8XXX_DEV_NEED_RESET);
                        qla83xx_idc_audit(vha, IDC_AUDIT_TIMESTAMP);
                        qla83xx_idc_unlock(vha, 0);
                        break;
                } else {
                        /* Make sure FC side is not in reset */
                        WARN_ON_ONCE(qla2x00_wait_for_hba_online(vha) !=
                                     QLA_SUCCESS);

                        /* Issue MPI reset */
                        scsi_block_requests(vha->host);
                        if (qla81xx_restart_mpi_firmware(vha) != QLA_SUCCESS)
                                ql_log(ql_log_warn, vha, 0x7070,
                                    "MPI reset failed.\n");
                        scsi_unblock_requests(vha->host);
                        break;
                }
                break;
        case 0x2025e:
                if (!IS_P3P_TYPE(ha) || vha != base_vha) {
                        ql_log(ql_log_info, vha, 0x7071,
                            "FCoE ctx reset not supported.\n");
                        return -EPERM;
                }

                ql_log(ql_log_info, vha, 0x7072,
                    "Issuing FCoE ctx reset.\n");
                set_bit(FCOE_CTX_RESET_NEEDED, &vha->dpc_flags);
                qla2xxx_wake_dpc(vha);
                qla2x00_wait_for_fcoe_ctx_reset(vha);
                break;
        case 0x2025f:
                if (!IS_QLA8031(ha))
                        return -EPERM;
                ql_log(ql_log_info, vha, 0x70bc,
                    "Disabling Reset by IDC control\n");
                qla83xx_idc_lock(vha, 0);
                __qla83xx_get_idc_control(vha, &idc_control);
                idc_control |= QLA83XX_IDC_RESET_DISABLED;
                __qla83xx_set_idc_control(vha, idc_control);
                qla83xx_idc_unlock(vha, 0);
                break;
        case 0x20260:
                if (!IS_QLA8031(ha))
                        return -EPERM;
                ql_log(ql_log_info, vha, 0x70bd,
                    "Enabling Reset by IDC control\n");
                qla83xx_idc_lock(vha, 0);
                __qla83xx_get_idc_control(vha, &idc_control);
                idc_control &= ~QLA83XX_IDC_RESET_DISABLED;
                __qla83xx_set_idc_control(vha, idc_control);
                qla83xx_idc_unlock(vha, 0);
                break;
        case 0x20261:
                ql_dbg(ql_dbg_user, vha, 0x70e0,
                    "Updating cache versions without reset ");

                tmp_data = vmalloc(256);
                if (!tmp_data) {
                        ql_log(ql_log_warn, vha, 0x70e1,
                            "Unable to allocate memory for VPD information update.\n");
                        return -ENOMEM;
                }
                ha->isp_ops->get_flash_version(vha, tmp_data);
                vfree(tmp_data);
                break;
        }
        return count;
}

static struct bin_attribute sysfs_reset_attr = {
        .attr = {
                .name = "reset",
                .mode = S_IWUSR,
        },
        .size = 0,
        .write = qla2x00_sysfs_write_reset,
};

static ssize_t
qla2x00_issue_logo(struct file *filp, struct kobject *kobj,
                        struct bin_attribute *bin_attr,
                        char *buf, loff_t off, size_t count)
{
        struct scsi_qla_host *vha = shost_priv(dev_to_shost(container_of(kobj,
            struct device, kobj)));
        int type;
        port_id_t did;

        if (!capable(CAP_SYS_ADMIN))
                return 0;

        if (unlikely(pci_channel_offline(vha->hw->pdev)))
                return 0;

        if (qla2x00_chip_is_down(vha))
                return 0;

        type = simple_strtol(buf, NULL, 10);

        did.b.domain = (type & 0x00ff0000) >> 16;
        did.b.area = (type & 0x0000ff00) >> 8;
        did.b.al_pa = (type & 0x000000ff);

        ql_log(ql_log_info, vha, 0xd04d, "portid=%02x%02x%02x done\n",
            did.b.domain, did.b.area, did.b.al_pa);

        ql_log(ql_log_info, vha, 0x70e4, "%s: %d\n", __func__, type);

        qla24xx_els_dcmd_iocb(vha, ELS_DCMD_LOGO, did);
        return count;
}

static struct bin_attribute sysfs_issue_logo_attr = {
        .attr = {
                .name = "issue_logo",
                .mode = S_IWUSR,
        },
        .size = 0,
        .write = qla2x00_issue_logo,
};

static ssize_t
qla2x00_sysfs_read_xgmac_stats(struct file *filp, struct kobject *kobj,
                       struct bin_attribute *bin_attr,
                       char *buf, loff_t off, size_t count)
{
        struct scsi_qla_host *vha = shost_priv(dev_to_shost(container_of(kobj,
            struct device, kobj)));
        struct qla_hw_data *ha = vha->hw;
        int rval;
        uint16_t actual_size;

        if (!capable(CAP_SYS_ADMIN) || off != 0 || count > XGMAC_DATA_SIZE)
                return 0;

        if (unlikely(pci_channel_offline(ha->pdev)))
                return 0;
        mutex_lock(&vha->hw->optrom_mutex);
        if (qla2x00_chip_is_down(vha)) {
                mutex_unlock(&vha->hw->optrom_mutex);
                return 0;
        }

        if (ha->xgmac_data)
                goto do_read;

        ha->xgmac_data = dma_alloc_coherent(&ha->pdev->dev, XGMAC_DATA_SIZE,
            &ha->xgmac_data_dma, GFP_KERNEL);
        if (!ha->xgmac_data) {
                mutex_unlock(&vha->hw->optrom_mutex);
                ql_log(ql_log_warn, vha, 0x7076,
                    "Unable to allocate memory for XGMAC read-data.\n");
                return 0;
        }

do_read:
        actual_size = 0;
        memset(ha->xgmac_data, 0, XGMAC_DATA_SIZE);

        rval = qla2x00_get_xgmac_stats(vha, ha->xgmac_data_dma,
            XGMAC_DATA_SIZE, &actual_size);

        mutex_unlock(&vha->hw->optrom_mutex);
        if (rval != QLA_SUCCESS) {
                ql_log(ql_log_warn, vha, 0x7077,
                    "Unable to read XGMAC data (%x).\n", rval);
                count = 0;
        }

        count = actual_size > count ? count : actual_size;
        memcpy(buf, ha->xgmac_data, count);

        return count;
}

static struct bin_attribute sysfs_xgmac_stats_attr = {
        .attr = {
                .name = "xgmac_stats",
                .mode = S_IRUSR,
        },
        .size = 0,
        .read = qla2x00_sysfs_read_xgmac_stats,
};

static ssize_t
qla2x00_sysfs_read_dcbx_tlv(struct file *filp, struct kobject *kobj,
                       struct bin_attribute *bin_attr,
                       char *buf, loff_t off, size_t count)
{
        struct scsi_qla_host *vha = shost_priv(dev_to_shost(container_of(kobj,
            struct device, kobj)));
        struct qla_hw_data *ha = vha->hw;
        int rval;

        if (!capable(CAP_SYS_ADMIN) || off != 0 || count > DCBX_TLV_DATA_SIZE)
                return 0;

        if (ha->dcbx_tlv)
                goto do_read;
        mutex_lock(&vha->hw->optrom_mutex);
        if (qla2x00_chip_is_down(vha)) {
                mutex_unlock(&vha->hw->optrom_mutex);
                return 0;
        }

        ha->dcbx_tlv = dma_alloc_coherent(&ha->pdev->dev, DCBX_TLV_DATA_SIZE,
            &ha->dcbx_tlv_dma, GFP_KERNEL);
        if (!ha->dcbx_tlv) {
                mutex_unlock(&vha->hw->optrom_mutex);
                ql_log(ql_log_warn, vha, 0x7078,
                    "Unable to allocate memory for DCBX TLV read-data.\n");
                return -ENOMEM;
        }

do_read:
        memset(ha->dcbx_tlv, 0, DCBX_TLV_DATA_SIZE);

        rval = qla2x00_get_dcbx_params(vha, ha->dcbx_tlv_dma,
            DCBX_TLV_DATA_SIZE);

        mutex_unlock(&vha->hw->optrom_mutex);

        if (rval != QLA_SUCCESS) {
                ql_log(ql_log_warn, vha, 0x7079,
                    "Unable to read DCBX TLV (%x).\n", rval);
                return -EIO;
        }

        memcpy(buf, ha->dcbx_tlv, count);

        return count;
}

static struct bin_attribute sysfs_dcbx_tlv_attr = {
        .attr = {
                .name = "dcbx_tlv",
                .mode = S_IRUSR,
        },
        .size = 0,
        .read = qla2x00_sysfs_read_dcbx_tlv,
};

static struct sysfs_entry {
        char *name;

        struct bin_attribute *attr;
        int type;
} bin_file_entries[] = {
        { "fw_dump", &sysfs_fw_dump_attr, },
        { "nvram", &sysfs_nvram_attr, },
        { "optrom", &sysfs_optrom_attr, },
        { "optrom_ctl", &sysfs_optrom_ctl_attr, },
        { "vpd", &sysfs_vpd_attr, 1 },
        { "sfp", &sysfs_sfp_attr, 1 },
        { "reset", &sysfs_reset_attr, },
        { "issue_logo", &sysfs_issue_logo_attr, },
        { "xgmac_stats", &sysfs_xgmac_stats_attr, 3 },
        { "dcbx_tlv", &sysfs_dcbx_tlv_attr, 3 },
        { NULL },
};

void
qla2x00_alloc_sysfs_attr(scsi_qla_host_t *vha)
{
        struct Scsi_Host *host = vha->host;
        struct sysfs_entry *iter;
        int ret;

        for (iter = bin_file_entries; iter->name; iter++) {
                if (iter->type && !IS_FWI2_CAPABLE(vha->hw))
                        continue;
                if (iter->type == 2 && !IS_QLA25XX(vha->hw))
                        continue;
                if (iter->type == 3 && !(IS_CNA_CAPABLE(vha->hw)))
                        continue;

                ret = sysfs_create_bin_file(&host->shost_gendev.kobj,
                    iter->attr);
                if (ret)
                        ql_log(ql_log_warn, vha, 0x00f3,
                            "Unable to create sysfs %s binary attribute (%d).\n",
                            iter->name, ret);
                else
                        ql_dbg(ql_dbg_init, vha, 0x00f4,
                            "Successfully created sysfs %s binary attribute.\n",
                            iter->name);
        }
}

void
qla2x00_free_sysfs_attr(scsi_qla_host_t *vha, bool stop_beacon)
{
        struct Scsi_Host *host = vha->host;
        struct sysfs_entry *iter;
        struct qla_hw_data *ha = vha->hw;

        for (iter = bin_file_entries; iter->name; iter++) {
                if (iter->type && !IS_FWI2_CAPABLE(ha))
                        continue;
                if (iter->type == 2 && !IS_QLA25XX(ha))
                        continue;
                if (iter->type == 3 && !(IS_CNA_CAPABLE(ha)))
                        continue;
                if (iter->type == 0x27 &&
                    (!IS_QLA27XX(ha) || !IS_QLA28XX(ha)))
                        continue;

                sysfs_remove_bin_file(&host->shost_gendev.kobj,
                    iter->attr);
        }

        if (stop_beacon && ha->beacon_blink_led == 1)
                ha->isp_ops->beacon_off(vha);
}

/* Scsi_Host attributes. */

static ssize_t
qla2x00_driver_version_show(struct device *dev,
                          struct device_attribute *attr, char *buf)
{
        return scnprintf(buf, PAGE_SIZE, "%s\n", qla2x00_version_str);
}

static ssize_t
qla2x00_fw_version_show(struct device *dev,
                        struct device_attribute *attr, char *buf)
{
        scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
        struct qla_hw_data *ha = vha->hw;
        char fw_str[128];

        return scnprintf(buf, PAGE_SIZE, "%s\n",
            ha->isp_ops->fw_version_str(vha, fw_str, sizeof(fw_str)));
}

static ssize_t
qla2x00_serial_num_show(struct device *dev, struct device_attribute *attr,
                        char *buf)
{
        scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
        struct qla_hw_data *ha = vha->hw;
        uint32_t sn;

        if (IS_QLAFX00(vha->hw)) {
                return scnprintf(buf, PAGE_SIZE, "%s\n",
                    vha->hw->mr.serial_num);
        } else if (IS_FWI2_CAPABLE(ha)) {
                qla2xxx_get_vpd_field(vha, "SN", buf, PAGE_SIZE - 1);
                return strlen(strcat(buf, "\n"));
        }

        sn = ((ha->serial0 & 0x1f) << 16) | (ha->serial2 << 8) | ha->serial1;
        return scnprintf(buf, PAGE_SIZE, "%c%05d\n", 'A' + sn / 100000,
            sn % 100000);
}

static ssize_t
qla2x00_isp_name_show(struct device *dev, struct device_attribute *attr,
                      char *buf)
{
        scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));

        return scnprintf(buf, PAGE_SIZE, "ISP%04X\n", vha->hw->pdev->device);
}

static ssize_t
qla2x00_isp_id_show(struct device *dev, struct device_attribute *attr,
                    char *buf)
{
        scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
        struct qla_hw_data *ha = vha->hw;

        if (IS_QLAFX00(vha->hw))
                return scnprintf(buf, PAGE_SIZE, "%s\n",
                    vha->hw->mr.hw_version);

        return scnprintf(buf, PAGE_SIZE, "%04x %04x %04x %04x\n",
            ha->product_id[0], ha->product_id[1], ha->product_id[2],
            ha->product_id[3]);
}

static ssize_t
qla2x00_model_name_show(struct device *dev, struct device_attribute *attr,
                        char *buf)
{
        scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));

        return scnprintf(buf, PAGE_SIZE, "%s\n", vha->hw->model_number);
}

static ssize_t
qla2x00_model_desc_show(struct device *dev, struct device_attribute *attr,
                        char *buf)
{
        scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));

        return scnprintf(buf, PAGE_SIZE, "%s\n", vha->hw->model_desc);
}

static ssize_t
qla2x00_pci_info_show(struct device *dev, struct device_attribute *attr,
                      char *buf)
{
        scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
        char pci_info[30];

        return scnprintf(buf, PAGE_SIZE, "%s\n",
                         vha->hw->isp_ops->pci_info_str(vha, pci_info,
                                                        sizeof(pci_info)));
}

static ssize_t
qla2x00_link_state_show(struct device *dev, struct device_attribute *attr,
                        char *buf)
{
        scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
        struct qla_hw_data *ha = vha->hw;
        int len = 0;

        if (atomic_read(&vha->loop_state) == LOOP_DOWN ||
            atomic_read(&vha->loop_state) == LOOP_DEAD ||
            vha->device_flags & DFLG_NO_CABLE)
                len = scnprintf(buf, PAGE_SIZE, "Link Down\n");
        else if (atomic_read(&vha->loop_state) != LOOP_READY ||
            qla2x00_chip_is_down(vha))
                len = scnprintf(buf, PAGE_SIZE, "Unknown Link State\n");
        else {
                len = scnprintf(buf, PAGE_SIZE, "Link Up - ");

                switch (ha->current_topology) {
                case ISP_CFG_NL:
                        len += scnprintf(buf + len, PAGE_SIZE-len, "Loop\n");
                        break;
                case ISP_CFG_FL:
                        len += scnprintf(buf + len, PAGE_SIZE-len, "FL_Port\n");
                        break;
                case ISP_CFG_N:
                        len += scnprintf(buf + len, PAGE_SIZE-len,
                            "N_Port to N_Port\n");
                        break;
                case ISP_CFG_F:
                        len += scnprintf(buf + len, PAGE_SIZE-len, "F_Port\n");
                        break;
                default:
                        len += scnprintf(buf + len, PAGE_SIZE-len, "Loop\n");
                        break;
                }
        }
        return len;
}

static ssize_t
qla2x00_zio_show(struct device *dev, struct device_attribute *attr,
                 char *buf)
{
        scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
        int len = 0;

        switch (vha->hw->zio_mode) {
        case QLA_ZIO_MODE_6:
                len += scnprintf(buf + len, PAGE_SIZE-len, "Mode 6\n");
                break;
        case QLA_ZIO_DISABLED:
                len += scnprintf(buf + len, PAGE_SIZE-len, "Disabled\n");
                break;
        }
        return len;
}

static ssize_t
qla2x00_zio_store(struct device *dev, struct device_attribute *attr,
                  const char *buf, size_t count)
{
        scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
        struct qla_hw_data *ha = vha->hw;
        int val = 0;
        uint16_t zio_mode;

        if (!IS_ZIO_SUPPORTED(ha))
                return -ENOTSUPP;

        if (sscanf(buf, "%d", &val) != 1)
                return -EINVAL;

        if (val)
                zio_mode = QLA_ZIO_MODE_6;
        else
                zio_mode = QLA_ZIO_DISABLED;

        /* Update per-hba values and queue a reset. */
        if (zio_mode != QLA_ZIO_DISABLED || ha->zio_mode != QLA_ZIO_DISABLED) {
                ha->zio_mode = zio_mode;
                set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
        }
        return strlen(buf);
}

static ssize_t
qla2x00_zio_timer_show(struct device *dev, struct device_attribute *attr,
                       char *buf)
{
        scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));

        return scnprintf(buf, PAGE_SIZE, "%d us\n", vha->hw->zio_timer * 100);
}

static ssize_t
qla2x00_zio_timer_store(struct device *dev, struct device_attribute *attr,
                        const char *buf, size_t count)
{
        scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
        int val = 0;
        uint16_t zio_timer;

        if (sscanf(buf, "%d", &val) != 1)
                return -EINVAL;
        if (val > 25500 || val < 100)
                return -ERANGE;

        zio_timer = (uint16_t)(val / 100);
        vha->hw->zio_timer = zio_timer;

        return strlen(buf);
}

static ssize_t
qla_zio_threshold_show(struct device *dev, struct device_attribute *attr,
                       char *buf)
{
        scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));

        return scnprintf(buf, PAGE_SIZE, "%d exchanges\n",
            vha->hw->last_zio_threshold);
}

static ssize_t
qla_zio_threshold_store(struct device *dev, struct device_attribute *attr,
    const char *buf, size_t count)
{
        scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
        int val = 0;

        if (vha->hw->zio_mode != QLA_ZIO_MODE_6)
                return -EINVAL;
        if (sscanf(buf, "%d", &val) != 1)
                return -EINVAL;
        if (val < 0 || val > 256)
                return -ERANGE;

        atomic_set(&vha->hw->zio_threshold, val);
        return strlen(buf);
}

static ssize_t
qla2x00_beacon_show(struct device *dev, struct device_attribute *attr,
                    char *buf)
{
        scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
        int len = 0;

        if (vha->hw->beacon_blink_led)
                len += scnprintf(buf + len, PAGE_SIZE-len, "Enabled\n");
        else
                len += scnprintf(buf + len, PAGE_SIZE-len, "Disabled\n");
        return len;
}

static ssize_t
qla2x00_beacon_store(struct device *dev, struct device_attribute *attr,
                     const char *buf, size_t count)
{
        scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
        struct qla_hw_data *ha = vha->hw;
        int val = 0;
        int rval;

        if (IS_QLA2100(ha) || IS_QLA2200(ha))
                return -EPERM;

        if (sscanf(buf, "%d", &val) != 1)
                return -EINVAL;

        mutex_lock(&vha->hw->optrom_mutex);
        if (qla2x00_chip_is_down(vha)) {
                mutex_unlock(&vha->hw->optrom_mutex);
                ql_log(ql_log_warn, vha, 0x707a,
                    "Abort ISP active -- ignoring beacon request.\n");
                return -EBUSY;
        }

        if (val)
                rval = ha->isp_ops->beacon_on(vha);
        else
                rval = ha->isp_ops->beacon_off(vha);

        if (rval != QLA_SUCCESS)
                count = 0;

        mutex_unlock(&vha->hw->optrom_mutex);

        return count;
}

static ssize_t
qla2x00_beacon_config_show(struct device *dev, struct device_attribute *attr,
        char *buf)
{
        scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
        struct qla_hw_data *ha = vha->hw;
        uint16_t led[3] = { 0 };

        if (!IS_QLA2031(ha) && !IS_QLA27XX(ha) && !IS_QLA28XX(ha))
                return -EPERM;

        if (ql26xx_led_config(vha, 0, led))
                return scnprintf(buf, PAGE_SIZE, "\n");

        return scnprintf(buf, PAGE_SIZE, "%#04hx %#04hx %#04hx\n",
            led[0], led[1], led[2]);
}

static ssize_t
qla2x00_beacon_config_store(struct device *dev, struct device_attribute *attr,
        const char *buf, size_t count)
{
        scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
        struct qla_hw_data *ha = vha->hw;
        uint16_t options = BIT_0;
        uint16_t led[3] = { 0 };
        uint16_t word[4];
        int n;

        if (!IS_QLA2031(ha) && !IS_QLA27XX(ha) && !IS_QLA28XX(ha))
                return -EPERM;

        n = sscanf(buf, "%hx %hx %hx %hx", word+0, word+1, word+2, word+3);
        if (n == 4) {
                if (word[0] == 3) {
                        options |= BIT_3|BIT_2|BIT_1;
                        led[0] = word[1];
                        led[1] = word[2];
                        led[2] = word[3];
                        goto write;
                }
                return -EINVAL;
        }

        if (n == 2) {
                /* check led index */
                if (word[0] == 0) {
                        options |= BIT_2;
                        led[0] = word[1];
                        goto write;
                }
                if (word[0] == 1) {
                        options |= BIT_3;
                        led[1] = word[1];
                        goto write;
                }
                if (word[0] == 2) {
                        options |= BIT_1;
                        led[2] = word[1];
                        goto write;
                }
                return -EINVAL;
        }

        return -EINVAL;

write:
        if (ql26xx_led_config(vha, options, led))
                return -EFAULT;

        return count;
}

static ssize_t
qla2x00_optrom_bios_version_show(struct device *dev,
                                 struct device_attribute *attr, char *buf)
{
        scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
        struct qla_hw_data *ha = vha->hw;

        return scnprintf(buf, PAGE_SIZE, "%d.%02d\n", ha->bios_revision[1],
            ha->bios_revision[0]);
}

static ssize_t
qla2x00_optrom_efi_version_show(struct device *dev,
                                struct device_attribute *attr, char *buf)
{
        scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
        struct qla_hw_data *ha = vha->hw;

        return scnprintf(buf, PAGE_SIZE, "%d.%02d\n", ha->efi_revision[1],
            ha->efi_revision[0]);
}

static ssize_t
qla2x00_optrom_fcode_version_show(struct device *dev,
                                  struct device_attribute *attr, char *buf)
{
        scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
        struct qla_hw_data *ha = vha->hw;

        return scnprintf(buf, PAGE_SIZE, "%d.%02d\n", ha->fcode_revision[1],
            ha->fcode_revision[0]);
}

static ssize_t
qla2x00_optrom_fw_version_show(struct device *dev,
                               struct device_attribute *attr, char *buf)
{
        scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
        struct qla_hw_data *ha = vha->hw;

        return scnprintf(buf, PAGE_SIZE, "%d.%02d.%02d %d\n",
            ha->fw_revision[0], ha->fw_revision[1], ha->fw_revision[2],
            ha->fw_revision[3]);
}

static ssize_t
qla2x00_optrom_gold_fw_version_show(struct device *dev,
    struct device_attribute *attr, char *buf)
{
        scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
        struct qla_hw_data *ha = vha->hw;

        if (!IS_QLA81XX(ha) && !IS_QLA83XX(ha) &&
            !IS_QLA27XX(ha) && !IS_QLA28XX(ha))
                return scnprintf(buf, PAGE_SIZE, "\n");

        return scnprintf(buf, PAGE_SIZE, "%d.%02d.%02d (%d)\n",
            ha->gold_fw_version[0], ha->gold_fw_version[1],
            ha->gold_fw_version[2], ha->gold_fw_version[3]);
}

static ssize_t
qla2x00_total_isp_aborts_show(struct device *dev,
                              struct device_attribute *attr, char *buf)
{
        scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));

        return scnprintf(buf, PAGE_SIZE, "%d\n",
            vha->qla_stats.total_isp_aborts);
}

static ssize_t
qla24xx_84xx_fw_version_show(struct device *dev,
        struct device_attribute *attr, char *buf)
{
        int rval = QLA_SUCCESS;
        uint16_t status[2] = { 0 };
        scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
        struct qla_hw_data *ha = vha->hw;

        if (!IS_QLA84XX(ha))
                return scnprintf(buf, PAGE_SIZE, "\n");

        if (!ha->cs84xx->op_fw_version) {
                rval = qla84xx_verify_chip(vha, status);

                if (!rval && !status[0])
                        return scnprintf(buf, PAGE_SIZE, "%u\n",
                            (uint32_t)ha->cs84xx->op_fw_version);
        }

        return scnprintf(buf, PAGE_SIZE, "\n");
}

static ssize_t
qla2x00_serdes_version_show(struct device *dev, struct device_attribute *attr,
    char *buf)
{
        scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
        struct qla_hw_data *ha = vha->hw;

        if (!IS_QLA27XX(ha) && !IS_QLA28XX(ha))
                return scnprintf(buf, PAGE_SIZE, "\n");

        return scnprintf(buf, PAGE_SIZE, "%d.%02d.%02d\n",
            ha->serdes_version[0], ha->serdes_version[1],
            ha->serdes_version[2]);
}

static ssize_t
qla2x00_mpi_version_show(struct device *dev, struct device_attribute *attr,
    char *buf)
{
        scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
        struct qla_hw_data *ha = vha->hw;

        if (!IS_QLA81XX(ha) && !IS_QLA8031(ha) && !IS_QLA8044(ha) &&
            !IS_QLA27XX(ha) && !IS_QLA28XX(ha))
                return scnprintf(buf, PAGE_SIZE, "\n");

        return scnprintf(buf, PAGE_SIZE, "%d.%02d.%02d (%x)\n",
            ha->mpi_version[0], ha->mpi_version[1], ha->mpi_version[2],
            ha->mpi_capabilities);
}

static ssize_t
qla2x00_phy_version_show(struct device *dev, struct device_attribute *attr,
    char *buf)
{
        scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
        struct qla_hw_data *ha = vha->hw;

        if (!IS_QLA81XX(ha) && !IS_QLA8031(ha))
                return scnprintf(buf, PAGE_SIZE, "\n");

        return scnprintf(buf, PAGE_SIZE, "%d.%02d.%02d\n",
            ha->phy_version[0], ha->phy_version[1], ha->phy_version[2]);
}

static ssize_t
qla2x00_flash_block_size_show(struct device *dev,
                              struct device_attribute *attr, char *buf)
{
        scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
        struct qla_hw_data *ha = vha->hw;

        return scnprintf(buf, PAGE_SIZE, "0x%x\n", ha->fdt_block_size);
}

static ssize_t
qla2x00_vlan_id_show(struct device *dev, struct device_attribute *attr,
    char *buf)
{
        scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));

        if (!IS_CNA_CAPABLE(vha->hw))
                return scnprintf(buf, PAGE_SIZE, "\n");

        return scnprintf(buf, PAGE_SIZE, "%d\n", vha->fcoe_vlan_id);
}

static ssize_t
qla2x00_vn_port_mac_address_show(struct device *dev,
    struct device_attribute *attr, char *buf)
{
        scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));

        if (!IS_CNA_CAPABLE(vha->hw))
                return scnprintf(buf, PAGE_SIZE, "\n");

        return scnprintf(buf, PAGE_SIZE, "%pMR\n", vha->fcoe_vn_port_mac);
}

static ssize_t
qla2x00_fabric_param_show(struct device *dev, struct device_attribute *attr,
    char *buf)
{
        scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));

        return scnprintf(buf, PAGE_SIZE, "%d\n", vha->hw->switch_cap);
}

static ssize_t
qla2x00_thermal_temp_show(struct device *dev,
        struct device_attribute *attr, char *buf)
{
        scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
        uint16_t temp = 0;
        int rc;

        mutex_lock(&vha->hw->optrom_mutex);
        if (qla2x00_chip_is_down(vha)) {
                mutex_unlock(&vha->hw->optrom_mutex);
                ql_log(ql_log_warn, vha, 0x70dc, "ISP reset active.\n");
                goto done;
        }

        if (vha->hw->flags.eeh_busy) {
                mutex_unlock(&vha->hw->optrom_mutex);
                ql_log(ql_log_warn, vha, 0x70dd, "PCI EEH busy.\n");
                goto done;
        }

        rc = qla2x00_get_thermal_temp(vha, &temp);
        mutex_unlock(&vha->hw->optrom_mutex);
        if (rc == QLA_SUCCESS)
                return scnprintf(buf, PAGE_SIZE, "%d\n", temp);

done:
        return scnprintf(buf, PAGE_SIZE, "\n");
}

static ssize_t
qla2x00_fw_state_show(struct device *dev, struct device_attribute *attr,
    char *buf)
{
        scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
        int rval = QLA_FUNCTION_FAILED;
        uint16_t state[6];
        uint32_t pstate;

        if (IS_QLAFX00(vha->hw)) {
                pstate = qlafx00_fw_state_show(dev, attr, buf);
                return scnprintf(buf, PAGE_SIZE, "0x%x\n", pstate);
        }

        mutex_lock(&vha->hw->optrom_mutex);
        if (qla2x00_chip_is_down(vha)) {
                mutex_unlock(&vha->hw->optrom_mutex);
                ql_log(ql_log_warn, vha, 0x707c,
                    "ISP reset active.\n");
                goto out;
        } else if (vha->hw->flags.eeh_busy) {
                mutex_unlock(&vha->hw->optrom_mutex);
                goto out;
        }

        rval = qla2x00_get_firmware_state(vha, state);
        mutex_unlock(&vha->hw->optrom_mutex);
out:
        if (rval != QLA_SUCCESS) {
                memset(state, -1, sizeof(state));
                rval = qla2x00_get_firmware_state(vha, state);
        }

        return scnprintf(buf, PAGE_SIZE, "0x%x 0x%x 0x%x 0x%x 0x%x 0x%x\n",
            state[0], state[1], state[2], state[3], state[4], state[5]);
}

static ssize_t
qla2x00_diag_requests_show(struct device *dev,
        struct device_attribute *attr, char *buf)
{
        scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));

        if (!IS_BIDI_CAPABLE(vha->hw))
                return scnprintf(buf, PAGE_SIZE, "\n");

        return scnprintf(buf, PAGE_SIZE, "%llu\n", vha->bidi_stats.io_count);
}

static ssize_t
qla2x00_diag_megabytes_show(struct device *dev,
        struct device_attribute *attr, char *buf)
{
        scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));

        if (!IS_BIDI_CAPABLE(vha->hw))
                return scnprintf(buf, PAGE_SIZE, "\n");

        return scnprintf(buf, PAGE_SIZE, "%llu\n",
            vha->bidi_stats.transfer_bytes >> 20);
}

static ssize_t
qla2x00_fw_dump_size_show(struct device *dev, struct device_attribute *attr,
        char *buf)
{
        scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
        struct qla_hw_data *ha = vha->hw;
        uint32_t size;

        if (!ha->fw_dumped)
                size = 0;
        else if (IS_P3P_TYPE(ha))
                size = ha->md_template_size + ha->md_dump_size;
        else
                size = ha->fw_dump_len;

        return scnprintf(buf, PAGE_SIZE, "%d\n", size);
}

static ssize_t
qla2x00_allow_cna_fw_dump_show(struct device *dev,
        struct device_attribute *attr, char *buf)
{
        scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));

        if (!IS_P3P_TYPE(vha->hw))
                return scnprintf(buf, PAGE_SIZE, "\n");
        else
                return scnprintf(buf, PAGE_SIZE, "%s\n",
                    vha->hw->allow_cna_fw_dump ? "true" : "false");
}

static ssize_t
qla2x00_allow_cna_fw_dump_store(struct device *dev,
        struct device_attribute *attr, const char *buf, size_t count)
{
        scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
        int val = 0;

        if (!IS_P3P_TYPE(vha->hw))
                return -EINVAL;

        if (sscanf(buf, "%d", &val) != 1)
                return -EINVAL;

        vha->hw->allow_cna_fw_dump = val != 0;

        return strlen(buf);
}

static ssize_t
qla2x00_pep_version_show(struct device *dev, struct device_attribute *attr,
        char *buf)
{
        scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
        struct qla_hw_data *ha = vha->hw;

        if (!IS_QLA27XX(ha) && !IS_QLA28XX(ha))
                return scnprintf(buf, PAGE_SIZE, "\n");

        return scnprintf(buf, PAGE_SIZE, "%d.%02d.%02d\n",
            ha->pep_version[0], ha->pep_version[1], ha->pep_version[2]);
}

static ssize_t
qla2x00_min_supported_speed_show(struct device *dev,
    struct device_attribute *attr, char *buf)
{
        scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
        struct qla_hw_data *ha = vha->hw;

        if (!IS_QLA27XX(ha) && !IS_QLA28XX(ha))
                return scnprintf(buf, PAGE_SIZE, "\n");

        return scnprintf(buf, PAGE_SIZE, "%s\n",
            ha->min_supported_speed == 6 ? "64Gps" :
            ha->min_supported_speed == 5 ? "32Gps" :
            ha->min_supported_speed == 4 ? "16Gps" :
            ha->min_supported_speed == 3 ? "8Gps" :
            ha->min_supported_speed == 2 ? "4Gps" :
            ha->min_supported_speed != 0 ? "unknown" : "");
}

static ssize_t
qla2x00_max_supported_speed_show(struct device *dev,
    struct device_attribute *attr, char *buf)
{
        scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
        struct qla_hw_data *ha = vha->hw;

        if (!IS_QLA27XX(ha) && !IS_QLA28XX(ha))
                return scnprintf(buf, PAGE_SIZE, "\n");

        return scnprintf(buf, PAGE_SIZE, "%s\n",
            ha->max_supported_speed  == 2 ? "64Gps" :
            ha->max_supported_speed  == 1 ? "32Gps" :
            ha->max_supported_speed  == 0 ? "16Gps" : "unknown");
}

static ssize_t
qla2x00_port_speed_store(struct device *dev, struct device_attribute *attr,
    const char *buf, size_t count)
{
        struct scsi_qla_host *vha = shost_priv(dev_to_shost(dev));
        ulong type, speed;
        int oldspeed, rval;
        int mode = QLA_SET_DATA_RATE_LR;
        struct qla_hw_data *ha = vha->hw;

        if (!IS_QLA27XX(ha) && !IS_QLA28XX(ha)) {
                ql_log(ql_log_warn, vha, 0x70d8,
                    "Speed setting not supported \n");
                return -EINVAL;
        }

        rval = kstrtol(buf, 10, &type);
        if (rval)
                return rval;
        speed = type;
        if (type == 40 || type == 80 || type == 160 ||
            type == 320) {
                ql_dbg(ql_dbg_user, vha, 0x70d9,
                    "Setting will be affected after a loss of sync\n");
                type = type/10;
                mode = QLA_SET_DATA_RATE_NOLR;
        }

        oldspeed = ha->set_data_rate;

        switch (type) {
        case 0:
                ha->set_data_rate = PORT_SPEED_AUTO;
                break;
        case 4:
                ha->set_data_rate = PORT_SPEED_4GB;
                break;
        case 8:
                ha->set_data_rate = PORT_SPEED_8GB;
                break;
        case 16:
                ha->set_data_rate = PORT_SPEED_16GB;
                break;
        case 32:
                ha->set_data_rate = PORT_SPEED_32GB;
                break;
        default:
                ql_log(ql_log_warn, vha, 0x1199,
                    "Unrecognized speed setting:%lx. Setting Autoneg\n",
                    speed);
                ha->set_data_rate = PORT_SPEED_AUTO;
        }

        if (qla2x00_chip_is_down(vha) || (oldspeed == ha->set_data_rate))
                return -EINVAL;

        ql_log(ql_log_info, vha, 0x70da,
            "Setting speed to %lx Gbps \n", type);

        rval = qla2x00_set_data_rate(vha, mode);
        if (rval != QLA_SUCCESS)
                return -EIO;

        return strlen(buf);
}

static ssize_t
qla2x00_port_speed_show(struct device *dev, struct device_attribute *attr,
    char *buf)
{
        struct scsi_qla_host *vha = shost_priv(dev_to_shost(dev));
        struct qla_hw_data *ha = vha->hw;
        ssize_t rval;
        char *spd[7] = {"0", "0", "0", "4", "8", "16", "32"};

        rval = qla2x00_get_data_rate(vha);
        if (rval != QLA_SUCCESS) {
                ql_log(ql_log_warn, vha, 0x70db,
                    "Unable to get port speed rval:%zd\n", rval);
                return -EINVAL;
        }

        return scnprintf(buf, PAGE_SIZE, "%s\n", spd[ha->link_data_rate]);
}

/* ----- */

static ssize_t
qlini_mode_show(struct device *dev, struct device_attribute *attr, char *buf)
{
        scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
        int len = 0;

        len += scnprintf(buf + len, PAGE_SIZE-len,
            "Supported options: enabled | disabled | dual | exclusive\n");

        /* --- */
        len += scnprintf(buf + len, PAGE_SIZE-len, "Current selection: ");

        switch (vha->qlini_mode) {
        case QLA2XXX_INI_MODE_EXCLUSIVE:
                len += scnprintf(buf + len, PAGE_SIZE-len,
                    QLA2XXX_INI_MODE_STR_EXCLUSIVE);
                break;
        case QLA2XXX_INI_MODE_DISABLED:
                len += scnprintf(buf + len, PAGE_SIZE-len,
                    QLA2XXX_INI_MODE_STR_DISABLED);
                break;
        case QLA2XXX_INI_MODE_ENABLED:
                len += scnprintf(buf + len, PAGE_SIZE-len,
                    QLA2XXX_INI_MODE_STR_ENABLED);
                break;
        case QLA2XXX_INI_MODE_DUAL:
                len += scnprintf(buf + len, PAGE_SIZE-len,
                    QLA2XXX_INI_MODE_STR_DUAL);
                break;
        }
        len += scnprintf(buf + len, PAGE_SIZE-len, "\n");

        return len;
}

static char *mode_to_str[] = {
        "exclusive",
        "disabled",
        "enabled",
        "dual",
};

#define NEED_EXCH_OFFLOAD(_exchg) ((_exchg) > FW_DEF_EXCHANGES_CNT)
static void qla_set_ini_mode(scsi_qla_host_t *vha, int op)
{
        enum {
                NO_ACTION,
                MODE_CHANGE_ACCEPT,
                MODE_CHANGE_NO_ACTION,
                TARGET_STILL_ACTIVE,
        };
        int action = NO_ACTION;
        int set_mode = 0;
        u8  eo_toggle = 0;      /* exchange offload flipped */

        switch (vha->qlini_mode) {
        case QLA2XXX_INI_MODE_DISABLED:
                switch (op) {
                case QLA2XXX_INI_MODE_DISABLED:
                        if (qla_tgt_mode_enabled(vha)) {
                                if (NEED_EXCH_OFFLOAD(vha->u_ql2xexchoffld) !=
                                    vha->hw->flags.exchoffld_enabled)
                                        eo_toggle = 1;
                                if (((vha->ql2xexchoffld !=
                                    vha->u_ql2xexchoffld) &&
                                    NEED_EXCH_OFFLOAD(vha->u_ql2xexchoffld)) ||
                                    eo_toggle) {
                                        /*
                                         * The number of exchange to be offload
                                         * was tweaked or offload option was
                                         * flipped
                                         */
                                        action = MODE_CHANGE_ACCEPT;
                                } else {
                                        action = MODE_CHANGE_NO_ACTION;
                                }
                        } else {
                                action = MODE_CHANGE_NO_ACTION;
                        }
                        break;
                case QLA2XXX_INI_MODE_EXCLUSIVE:
                        if (qla_tgt_mode_enabled(vha)) {
                                if (NEED_EXCH_OFFLOAD(vha->u_ql2xexchoffld) !=
                                    vha->hw->flags.exchoffld_enabled)
                                        eo_toggle = 1;
                                if (((vha->ql2xexchoffld !=
                                    vha->u_ql2xexchoffld) &&
                                    NEED_EXCH_OFFLOAD(vha->u_ql2xexchoffld)) ||
                                    eo_toggle) {
                                        /*
                                         * The number of exchange to be offload
                                         * was tweaked or offload option was
                                         * flipped
                                         */
                                        action = MODE_CHANGE_ACCEPT;
                                } else {
                                        action = MODE_CHANGE_NO_ACTION;
                                }
                        } else {
                                action = MODE_CHANGE_ACCEPT;
                        }
                        break;
                case QLA2XXX_INI_MODE_DUAL:
                        action = MODE_CHANGE_ACCEPT;
                        /* active_mode is target only, reset it to dual */
                        if (qla_tgt_mode_enabled(vha)) {
                                set_mode = 1;
                                action = MODE_CHANGE_ACCEPT;
                        } else {