drivers/scsi/qla2xxx/qla_attr.c

   1 /*
   2  * QLogic Fibre Channel HBA Driver
   3  * Copyright (c)  2003-2014 QLogic Corporation
   4  *
   5  * See LICENSE.qla2xxx for copyright and licensing details.
   6  */
   7 #include "qla_def.h"
   8 #include "qla_target.h"
   9
  10 #include <linux/kthread.h>
  11 #include <linux/vmalloc.h>
  12 #include <linux/slab.h>
  13 #include <linux/delay.h>
  14
  15 static int qla24xx_vport_disable(struct fc_vport *, bool);
  16
  17 /* SYSFS attributes --------------------------------------------------------- */
  18
  19 static ssize_t
  20 qla2x00_sysfs_read_fw_dump(struct file *filp, struct kobject *kobj,
  21                            struct bin_attribute *bin_attr,
  22                            char *buf, loff_t off, size_t count)
  23 {
  24         struct scsi_qla_host *vha = shost_priv(dev_to_shost(container_of(kobj,
  25             struct device, kobj)));
  26         struct qla_hw_data *ha = vha->hw;
  27         int rval = 0;
  28
  29         if (!(ha->fw_dump_reading || ha->mctp_dump_reading))
  30                 return 0;
  31
  32         mutex_lock(&ha->optrom_mutex);
  33         if (IS_P3P_TYPE(ha)) {
  34                 if (off < ha->md_template_size) {
  35                         rval = memory_read_from_buffer(buf, count,
  36                             &off, ha->md_tmplt_hdr, ha->md_template_size);
  37                 } else {
  38                         off -= ha->md_template_size;
  39                         rval = memory_read_from_buffer(buf, count,
  40                             &off, ha->md_dump, ha->md_dump_size);
  41                 }
  42         } else if (ha->mctp_dumped && ha->mctp_dump_reading) {
  43                 rval = memory_read_from_buffer(buf, count, &off, ha->mctp_dump,
  44                     MCTP_DUMP_SIZE);
  45         } else if (ha->fw_dump_reading) {
  46                 rval = memory_read_from_buffer(buf, count, &off, ha->fw_dump,
  47                                         ha->fw_dump_len);
  48         } else {
  49                 rval = 0;
  50         }
  51         mutex_unlock(&ha->optrom_mutex);
  52         return rval;
  53 }
  54
  55 static ssize_t
  56 qla2x00_sysfs_write_fw_dump(struct file *filp, struct kobject *kobj,
  57                             struct bin_attribute *bin_attr,
  58                             char *buf, loff_t off, size_t count)
  59 {
  60         struct scsi_qla_host *vha = shost_priv(dev_to_shost(container_of(kobj,
  61             struct device, kobj)));
  62         struct qla_hw_data *ha = vha->hw;
  63         int reading;
  64
  65         if (off != 0)
  66                 return (0);
  67
  68         reading = simple_strtol(buf, NULL, 10);
  69         switch (reading) {
  70         case 0:
  71                 if (!ha->fw_dump_reading)
  72                         break;
  73
  74                 ql_log(ql_log_info, vha, 0x705d,
  75                     "Firmware dump cleared on (%ld).\n", vha->host_no);
  76
  77                 if (IS_P3P_TYPE(ha)) {
  78                         qla82xx_md_free(vha);
  79                         qla82xx_md_prep(vha);
  80                 }
  81                 ha->fw_dump_reading = 0;
  82                 ha->fw_dumped = 0;
  83                 break;
  84         case 1:
  85                 if (ha->fw_dumped && !ha->fw_dump_reading) {
  86                         ha->fw_dump_reading = 1;
  87
  88                         ql_log(ql_log_info, vha, 0x705e,
  89                             "Raw firmware dump ready for read on (%ld).\n",
  90                             vha->host_no);
  91                 }
  92                 break;
  93         case 2:
  94                 qla2x00_alloc_fw_dump(vha);
  95                 break;
  96         case 3:
  97                 if (IS_QLA82XX(ha)) {
  98                         qla82xx_idc_lock(ha);
  99                         qla82xx_set_reset_owner(vha);
 100                         qla82xx_idc_unlock(ha);
 101                 } else if (IS_QLA8044(ha)) {
 102                         qla8044_idc_lock(ha);
 103                         qla82xx_set_reset_owner(vha);
 104                         qla8044_idc_unlock(ha);
 105                 } else
 106                         qla2x00_system_error(vha);
 107                 break;
 108         case 4:
 109                 if (IS_P3P_TYPE(ha)) {
 110                         if (ha->md_tmplt_hdr)
 111                                 ql_dbg(ql_dbg_user, vha, 0x705b,
 112                                     "MiniDump supported with this firmware.\n");
 113                         else
 114                                 ql_dbg(ql_dbg_user, vha, 0x709d,
 115                                     "MiniDump not supported with this firmware.\n");
 116                 }
 117                 break;
 118         case 5:
 119                 if (IS_P3P_TYPE(ha))
 120                         set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
 121                 break;
 122         case 6:
 123                 if (!ha->mctp_dump_reading)
 124                         break;
 125                 ql_log(ql_log_info, vha, 0x70c1,
 126                     "MCTP dump cleared on (%ld).\n", vha->host_no);
 127                 ha->mctp_dump_reading = 0;
 128                 ha->mctp_dumped = 0;
 129                 break;
 130         case 7:
 131                 if (ha->mctp_dumped && !ha->mctp_dump_reading) {
 132                         ha->mctp_dump_reading = 1;
 133                         ql_log(ql_log_info, vha, 0x70c2,
 134                             "Raw mctp dump ready for read on (%ld).\n",
 135                             vha->host_no);
 136                 }
 137                 break;
 138         }
 139         return count;
 140 }
 141
 142 static struct bin_attribute sysfs_fw_dump_attr = {
 143         .attr = {
 144                 .name = "fw_dump",
 145                 .mode = S_IRUSR | S_IWUSR,
 146         },
 147         .size = 0,
 148         .read = qla2x00_sysfs_read_fw_dump,
 149         .write = qla2x00_sysfs_write_fw_dump,
 150 };
 151
 152 static ssize_t
 153 qla2x00_sysfs_read_nvram(struct file *filp, struct kobject *kobj,
 154                          struct bin_attribute *bin_attr,
 155                          char *buf, loff_t off, size_t count)
 156 {
 157         struct scsi_qla_host *vha = shost_priv(dev_to_shost(container_of(kobj,
 158             struct device, kobj)));
 159         struct qla_hw_data *ha = vha->hw;
 160         uint32_t faddr;
 161         struct active_regions active_regions = { };
 162
 163         if (!capable(CAP_SYS_ADMIN))
 164                 return 0;
 165
 166         mutex_lock(&ha->optrom_mutex);
 167         if (qla2x00_chip_is_down(vha)) {
 168                 mutex_unlock(&ha->optrom_mutex);
 169                 return -EAGAIN;
 170         }
 171
 172         if (!IS_NOCACHE_VPD_TYPE(ha)) {
 173                 mutex_unlock(&ha->optrom_mutex);
 174                 goto skip;
 175         }
 176
 177         faddr = ha->flt_region_nvram;
 178         if (IS_QLA28XX(ha)) {
 179                 if (active_regions.aux.vpd_nvram == QLA27XX_SECONDARY_IMAGE)
 180                         faddr = ha->flt_region_nvram_sec;
 181         }
 182         ha->isp_ops->read_optrom(vha, ha->nvram, faddr << 2, ha->nvram_size);
 183
 184         mutex_unlock(&ha->optrom_mutex);
 185
 186 skip:
 187         return memory_read_from_buffer(buf, count, &off, ha->nvram,
 188                                         ha->nvram_size);
 189 }
 190
 191 static ssize_t
 192 qla2x00_sysfs_write_nvram(struct file *filp, struct kobject *kobj,
 193                           struct bin_attribute *bin_attr,
 194                           char *buf, loff_t off, size_t count)
 195 {
 196         struct scsi_qla_host *vha = shost_priv(dev_to_shost(container_of(kobj,
 197             struct device, kobj)));
 198         struct qla_hw_data *ha = vha->hw;
 199         uint16_t        cnt;
 200
 201         if (!capable(CAP_SYS_ADMIN) || off != 0 || count != ha->nvram_size ||
 202             !ha->isp_ops->write_nvram)
 203                 return -EINVAL;
 204
 205         /* Checksum NVRAM. */
 206         if (IS_FWI2_CAPABLE(ha)) {
 207                 uint32_t *iter;
 208                 uint32_t chksum;
 209
 210                 iter = (uint32_t *)buf;
 211                 chksum = 0;
 212                 for (cnt = 0; cnt < ((count >> 2) - 1); cnt++, iter++)
 213                         chksum += le32_to_cpu(*iter);
 214                 chksum = ~chksum + 1;
 215                 *iter = cpu_to_le32(chksum);
 216         } else {
 217                 uint8_t *iter;
 218                 uint8_t chksum;
 219
 220                 iter = (uint8_t *)buf;
 221                 chksum = 0;
 222                 for (cnt = 0; cnt < count - 1; cnt++)
 223                         chksum += *iter++;
 224                 chksum = ~chksum + 1;
 225                 *iter = chksum;
 226         }
 227
 228         if (qla2x00_wait_for_hba_online(vha) != QLA_SUCCESS) {
 229                 ql_log(ql_log_warn, vha, 0x705f,
 230                     "HBA not online, failing NVRAM update.\n");
 231                 return -EAGAIN;
 232         }
 233
 234         mutex_lock(&ha->optrom_mutex);
 235         if (qla2x00_chip_is_down(vha)) {
 236                 mutex_unlock(&ha->optrom_mutex);
 237                 return -EAGAIN;
 238         }
 239
 240         /* Write NVRAM. */
 241         ha->isp_ops->write_nvram(vha, buf, ha->nvram_base, count);
 242         ha->isp_ops->read_nvram(vha, ha->nvram, ha->nvram_base,
 243             count);
 244         mutex_unlock(&ha->optrom_mutex);
 245
 246         ql_dbg(ql_dbg_user, vha, 0x7060,
 247             "Setting ISP_ABORT_NEEDED\n");
 248         /* NVRAM settings take effect immediately. */
 249         set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
 250         qla2xxx_wake_dpc(vha);
 251         qla2x00_wait_for_chip_reset(vha);
 252
 253         return count;
 254 }
 255
 256 static struct bin_attribute sysfs_nvram_attr = {
 257         .attr = {
 258                 .name = "nvram",
 259                 .mode = S_IRUSR | S_IWUSR,
 260         },
 261         .size = 512,
 262         .read = qla2x00_sysfs_read_nvram,
 263         .write = qla2x00_sysfs_write_nvram,
 264 };
 265
 266 static ssize_t
 267 qla2x00_sysfs_read_optrom(struct file *filp, struct kobject *kobj,
 268                           struct bin_attribute *bin_attr,
 269                           char *buf, loff_t off, size_t count)
 270 {
 271         struct scsi_qla_host *vha = shost_priv(dev_to_shost(container_of(kobj,
 272             struct device, kobj)));
 273         struct qla_hw_data *ha = vha->hw;
 274         ssize_t rval = 0;
 275
 276         mutex_lock(&ha->optrom_mutex);
 277
 278         if (ha->optrom_state != QLA_SREADING)
 279                 goto out;
 280
 281         rval = memory_read_from_buffer(buf, count, &off, ha->optrom_buffer,
 282             ha->optrom_region_size);
 283
 284 out:
 285         mutex_unlock(&ha->optrom_mutex);
 286
 287         return rval;
 288 }
 289
 290 static ssize_t
 291 qla2x00_sysfs_write_optrom(struct file *filp, struct kobject *kobj,
 292                            struct bin_attribute *bin_attr,
 293                            char *buf, loff_t off, size_t count)
 294 {
 295         struct scsi_qla_host *vha = shost_priv(dev_to_shost(container_of(kobj,
 296             struct device, kobj)));
 297         struct qla_hw_data *ha = vha->hw;
 298
 299         mutex_lock(&ha->optrom_mutex);
 300
 301         if (ha->optrom_state != QLA_SWRITING) {
 302                 mutex_unlock(&ha->optrom_mutex);
 303                 return -EINVAL;
 304         }
 305         if (off > ha->optrom_region_size) {
 306                 mutex_unlock(&ha->optrom_mutex);
 307                 return -ERANGE;
 308         }
 309         if (off + count > ha->optrom_region_size)
 310                 count = ha->optrom_region_size - off;
 311
 312         memcpy(&ha->optrom_buffer[off], buf, count);
 313         mutex_unlock(&ha->optrom_mutex);
 314
 315         return count;
 316 }
 317
 318 static struct bin_attribute sysfs_optrom_attr = {
 319         .attr = {
 320                 .name = "optrom",
 321                 .mode = S_IRUSR | S_IWUSR,
 322         },
 323         .size = 0,
 324         .read = qla2x00_sysfs_read_optrom,
 325         .write = qla2x00_sysfs_write_optrom,
 326 };
 327
 328 static ssize_t
 329 qla2x00_sysfs_write_optrom_ctl(struct file *filp, struct kobject *kobj,
 330                                struct bin_attribute *bin_attr,
 331                                char *buf, loff_t off, size_t count)
 332 {
 333         struct scsi_qla_host *vha = shost_priv(dev_to_shost(container_of(kobj,
 334             struct device, kobj)));
 335         struct qla_hw_data *ha = vha->hw;
 336         uint32_t start = 0;
 337         uint32_t size = ha->optrom_size;
 338         int val, valid;
 339         ssize_t rval = count;
 340
 341         if (off)
 342                 return -EINVAL;
 343
 344         if (unlikely(pci_channel_offline(ha->pdev)))
 345                 return -EAGAIN;
 346
 347         if (sscanf(buf, "%d:%x:%x", &val, &start, &size) < 1)
 348                 return -EINVAL;
 349         if (start > ha->optrom_size)
 350                 return -EINVAL;
 351         if (size > ha->optrom_size - start)
 352                 size = ha->optrom_size - start;
 353
 354         mutex_lock(&ha->optrom_mutex);
 355         if (qla2x00_chip_is_down(vha)) {
 356                 mutex_unlock(&ha->optrom_mutex);
 357                 return -EAGAIN;
 358         }
 359         switch (val) {
 360         case 0:
 361                 if (ha->optrom_state != QLA_SREADING &&
 362                     ha->optrom_state != QLA_SWRITING) {
 363                         rval =  -EINVAL;
 364                         goto out;
 365                 }
 366                 ha->optrom_state = QLA_SWAITING;
 367
 368                 ql_dbg(ql_dbg_user, vha, 0x7061,
 369                     "Freeing flash region allocation -- 0x%x bytes.\n",
 370                     ha->optrom_region_size);
 371
 372                 vfree(ha->optrom_buffer);
 373                 ha->optrom_buffer = NULL;
 374                 break;
 375         case 1:
 376                 if (ha->optrom_state != QLA_SWAITING) {
 377                         rval = -EINVAL;
 378                         goto out;
 379                 }
 380
 381                 ha->optrom_region_start = start;
 382                 ha->optrom_region_size = size;
 383
 384                 ha->optrom_state = QLA_SREADING;
 385                 ha->optrom_buffer = vzalloc(ha->optrom_region_size);
 386                 if (ha->optrom_buffer == NULL) {
 387                         ql_log(ql_log_warn, vha, 0x7062,
 388                             "Unable to allocate memory for optrom retrieval "
 389                             "(%x).\n", ha->optrom_region_size);
 390
 391                         ha->optrom_state = QLA_SWAITING;
 392                         rval = -ENOMEM;
 393                         goto out;
 394                 }
 395
 396                 if (qla2x00_wait_for_hba_online(vha) != QLA_SUCCESS) {
 397                         ql_log(ql_log_warn, vha, 0x7063,
 398                             "HBA not online, failing NVRAM update.\n");
 399                         rval = -EAGAIN;
 400                         goto out;
 401                 }
 402
 403                 ql_dbg(ql_dbg_user, vha, 0x7064,
 404                     "Reading flash region -- 0x%x/0x%x.\n",
 405                     ha->optrom_region_start, ha->optrom_region_size);
 406
 407                 ha->isp_ops->read_optrom(vha, ha->optrom_buffer,
 408                     ha->optrom_region_start, ha->optrom_region_size);
 409                 break;
 410         case 2:
 411                 if (ha->optrom_state != QLA_SWAITING) {
 412                         rval = -EINVAL;
 413                         goto out;
 414                 }
 415
 416                 /*
 417                  * We need to be more restrictive on which FLASH regions are
 418                  * allowed to be updated via user-space.  Regions accessible
 419                  * via this method include:
 420                  *
 421                  * ISP21xx/ISP22xx/ISP23xx type boards:
 422                  *
 423                  *      0x000000 -> 0x020000 -- Boot code.
 424                  *
 425                  * ISP2322/ISP24xx type boards:
 426                  *
 427                  *      0x000000 -> 0x07ffff -- Boot code.
 428                  *      0x080000 -> 0x0fffff -- Firmware.
 429                  *
 430                  * ISP25xx type boards:
 431                  *
 432                  *      0x000000 -> 0x07ffff -- Boot code.
 433                  *      0x080000 -> 0x0fffff -- Firmware.
 434                  *      0x120000 -> 0x12ffff -- VPD and HBA parameters.
 435                  *
 436                  * > ISP25xx type boards:
 437                  *
 438                  *      None -- should go through BSG.
 439                  */
 440                 valid = 0;
 441                 if (ha->optrom_size == OPTROM_SIZE_2300 && start == 0)
 442                         valid = 1;
 443                 else if (IS_QLA24XX_TYPE(ha) || IS_QLA25XX(ha))
 444                         valid = 1;
 445                 if (!valid) {
 446                         ql_log(ql_log_warn, vha, 0x7065,
 447                             "Invalid start region 0x%x/0x%x.\n", start, size);
 448                         rval = -EINVAL;
 449                         goto out;
 450                 }
 451
 452                 ha->optrom_region_start = start;
 453                 ha->optrom_region_size = size;
 454
 455                 ha->optrom_state = QLA_SWRITING;
 456                 ha->optrom_buffer = vzalloc(ha->optrom_region_size);
 457                 if (ha->optrom_buffer == NULL) {
 458                         ql_log(ql_log_warn, vha, 0x7066,
 459                             "Unable to allocate memory for optrom update "
 460                             "(%x)\n", ha->optrom_region_size);
 461
 462                         ha->optrom_state = QLA_SWAITING;
 463                         rval = -ENOMEM;
 464                         goto out;
 465                 }
 466
 467                 ql_dbg(ql_dbg_user, vha, 0x7067,
 468                     "Staging flash region write -- 0x%x/0x%x.\n",
 469                     ha->optrom_region_start, ha->optrom_region_size);
 470
 471                 break;
 472         case 3:
 473                 if (ha->optrom_state != QLA_SWRITING) {
 474                         rval = -EINVAL;
 475                         goto out;
 476                 }
 477
 478                 if (qla2x00_wait_for_hba_online(vha) != QLA_SUCCESS) {
 479                         ql_log(ql_log_warn, vha, 0x7068,
 480                             "HBA not online, failing flash update.\n");
 481                         rval = -EAGAIN;
 482                         goto out;
 483                 }
 484
 485                 ql_dbg(ql_dbg_user, vha, 0x7069,
 486                     "Writing flash region -- 0x%x/0x%x.\n",
 487                     ha->optrom_region_start, ha->optrom_region_size);
 488
 489                 rval = ha->isp_ops->write_optrom(vha, ha->optrom_buffer,
 490                     ha->optrom_region_start, ha->optrom_region_size);
 491                 if (rval)
 492                         rval = -EIO;
 493                 break;
 494         default:
 495                 rval = -EINVAL;
 496         }
 497
 498 out:
 499         mutex_unlock(&ha->optrom_mutex);
 500         return rval;
 501 }
 502
 503 static struct bin_attribute sysfs_optrom_ctl_attr = {
 504         .attr = {
 505                 .name = "optrom_ctl",
 506                 .mode = S_IWUSR,
 507         },
 508         .size = 0,
 509         .write = qla2x00_sysfs_write_optrom_ctl,
 510 };
 511
 512 static ssize_t
 513 qla2x00_sysfs_read_vpd(struct file *filp, struct kobject *kobj,
 514                        struct bin_attribute *bin_attr,
 515                        char *buf, loff_t off, size_t count)
 516 {
 517         struct scsi_qla_host *vha = shost_priv(dev_to_shost(container_of(kobj,
 518             struct device, kobj)));
 519         struct qla_hw_data *ha = vha->hw;
 520         uint32_t faddr;
 521         struct active_regions active_regions = { };
 522
 523         if (unlikely(pci_channel_offline(ha->pdev)))
 524                 return -EAGAIN;
 525
 526         if (!capable(CAP_SYS_ADMIN))
 527                 return -EINVAL;
 528
 529         if (IS_NOCACHE_VPD_TYPE(ha))
 530                 goto skip;
 531
 532         faddr = ha->flt_region_vpd << 2;
 533
 534         if (IS_QLA28XX(ha)) {
 535                 qla28xx_get_aux_images(vha, &active_regions);
 536                 if (active_regions.aux.vpd_nvram == QLA27XX_SECONDARY_IMAGE)
 537                         faddr = ha->flt_region_vpd_sec << 2;
 538
 539                 ql_dbg(ql_dbg_init, vha, 0x7070,
 540                     "Loading %s nvram image.\n",
 541                     active_regions.aux.vpd_nvram == QLA27XX_PRIMARY_IMAGE ?
 542                     "primary" : "secondary");
 543         }
 544
 545         mutex_lock(&ha->optrom_mutex);
 546         if (qla2x00_chip_is_down(vha)) {
 547                 mutex_unlock(&ha->optrom_mutex);
 548                 return -EAGAIN;
 549         }
 550
 551         ha->isp_ops->read_optrom(vha, ha->vpd, faddr, ha->vpd_size);
 552         mutex_unlock(&ha->optrom_mutex);
 553
 554         ha->isp_ops->read_optrom(vha, ha->vpd, faddr, ha->vpd_size);
 555 skip:
 556         return memory_read_from_buffer(buf, count, &off, ha->vpd, ha->vpd_size);
 557 }
 558
 559 static ssize_t
 560 qla2x00_sysfs_write_vpd(struct file *filp, struct kobject *kobj,
 561                         struct bin_attribute *bin_attr,
 562                         char *buf, loff_t off, size_t count)
 563 {
 564         struct scsi_qla_host *vha = shost_priv(dev_to_shost(container_of(kobj,
 565             struct device, kobj)));
 566         struct qla_hw_data *ha = vha->hw;
 567         uint8_t *tmp_data;
 568
 569         if (unlikely(pci_channel_offline(ha->pdev)))
 570                 return 0;
 571
 572         if (qla2x00_chip_is_down(vha))
 573                 return 0;
 574
 575         if (!capable(CAP_SYS_ADMIN) || off != 0 || count != ha->vpd_size ||
 576             !ha->isp_ops->write_nvram)
 577                 return 0;
 578
 579         if (qla2x00_wait_for_hba_online(vha) != QLA_SUCCESS) {
 580                 ql_log(ql_log_warn, vha, 0x706a,
 581                     "HBA not online, failing VPD update.\n");
 582                 return -EAGAIN;
 583         }
 584
 585         mutex_lock(&ha->optrom_mutex);
 586         if (qla2x00_chip_is_down(vha)) {
 587                 mutex_unlock(&ha->optrom_mutex);
 588                 return -EAGAIN;
 589         }
 590
 591         /* Write NVRAM. */
 592         ha->isp_ops->write_nvram(vha, buf, ha->vpd_base, count);
 593         ha->isp_ops->read_nvram(vha, ha->vpd, ha->vpd_base, count);
 594
 595         /* Update flash version information for 4Gb & above. */
 596         if (!IS_FWI2_CAPABLE(ha)) {
 597                 mutex_unlock(&ha->optrom_mutex);
 598                 return -EINVAL;
 599         }
 600
 601         tmp_data = vmalloc(256);
 602         if (!tmp_data) {
 603                 mutex_unlock(&ha->optrom_mutex);
 604                 ql_log(ql_log_warn, vha, 0x706b,
 605                     "Unable to allocate memory for VPD information update.\n");
 606                 return -ENOMEM;
 607         }
 608         ha->isp_ops->get_flash_version(vha, tmp_data);
 609         vfree(tmp_data);
 610
 611         mutex_unlock(&ha->optrom_mutex);
 612
 613         return count;
 614 }
 615
 616 static struct bin_attribute sysfs_vpd_attr = {
 617         .attr = {
 618                 .name = "vpd",
 619                 .mode = S_IRUSR | S_IWUSR,
 620         },
 621         .size = 0,
 622         .read = qla2x00_sysfs_read_vpd,
 623         .write = qla2x00_sysfs_write_vpd,
 624 };
 625
 626 static ssize_t
 627 qla2x00_sysfs_read_sfp(struct file *filp, struct kobject *kobj,
 628                        struct bin_attribute *bin_attr,
 629                        char *buf, loff_t off, size_t count)
 630 {
 631         struct scsi_qla_host *vha = shost_priv(dev_to_shost(container_of(kobj,
 632             struct device, kobj)));
 633         int rval;
 634
 635         if (!capable(CAP_SYS_ADMIN) || off != 0 || count < SFP_DEV_SIZE)
 636                 return 0;
 637
 638         mutex_lock(&vha->hw->optrom_mutex);
 639         if (qla2x00_chip_is_down(vha)) {
 640                 mutex_unlock(&vha->hw->optrom_mutex);
 641                 return 0;
 642         }
 643
 644         rval = qla2x00_read_sfp_dev(vha, buf, count);
 645         mutex_unlock(&vha->hw->optrom_mutex);
 646
 647         if (rval)
 648                 return -EIO;
 649
 650         return count;
 651 }
 652
 653 static struct bin_attribute sysfs_sfp_attr = {
 654         .attr = {
 655                 .name = "sfp",
 656                 .mode = S_IRUSR | S_IWUSR,
 657         },
 658         .size = SFP_DEV_SIZE,
 659         .read = qla2x00_sysfs_read_sfp,
 660 };
 661
 662 static ssize_t
 663 qla2x00_sysfs_write_reset(struct file *filp, struct kobject *kobj,
 664                         struct bin_attribute *bin_attr,
 665                         char *buf, loff_t off, size_t count)
 666 {
 667         struct scsi_qla_host *vha = shost_priv(dev_to_shost(container_of(kobj,
 668             struct device, kobj)));
 669         struct qla_hw_data *ha = vha->hw;
 670         struct scsi_qla_host *base_vha = pci_get_drvdata(ha->pdev);
 671         int type;
 672         uint32_t idc_control;
 673         uint8_t *tmp_data = NULL;
 674
 675         if (off != 0)
 676                 return -EINVAL;
 677
 678         type = simple_strtol(buf, NULL, 10);
 679         switch (type) {
 680         case 0x2025c:
 681                 ql_log(ql_log_info, vha, 0x706e,
 682                     "Issuing ISP reset.\n");
 683
 684                 scsi_block_requests(vha->host);
 685                 if (IS_QLA82XX(ha)) {
 686                         ha->flags.isp82xx_no_md_cap = 1;
 687                         qla82xx_idc_lock(ha);
 688                         qla82xx_set_reset_owner(vha);
 689                         qla82xx_idc_unlock(ha);
 690                 } else if (IS_QLA8044(ha)) {
 691                         qla8044_idc_lock(ha);
 692                         idc_control = qla8044_rd_reg(ha,
 693                             QLA8044_IDC_DRV_CTRL);
 694                         qla8044_wr_reg(ha, QLA8044_IDC_DRV_CTRL,
 695                             (idc_control | GRACEFUL_RESET_BIT1));
 696                         qla82xx_set_reset_owner(vha);
 697                         qla8044_idc_unlock(ha);
 698                 } else {
 699                         set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
 700                         qla2xxx_wake_dpc(vha);
 701                 }
 702                 qla2x00_wait_for_chip_reset(vha);
 703                 scsi_unblock_requests(vha->host);
 704                 break;
 705         case 0x2025d:
 706                 if (!IS_QLA81XX(ha) && !IS_QLA83XX(ha))
 707                         return -EPERM;
 708
 709                 ql_log(ql_log_info, vha, 0x706f,
 710                     "Issuing MPI reset.\n");
 711
 712                 if (IS_QLA83XX(ha) || IS_QLA27XX(ha) || IS_QLA28XX(ha)) {
 713                         uint32_t idc_control;
 714
 715                         qla83xx_idc_lock(vha, 0);
 716                         __qla83xx_get_idc_control(vha, &idc_control);
 717                         idc_control |= QLA83XX_IDC_GRACEFUL_RESET;
 718                         __qla83xx_set_idc_control(vha, idc_control);
 719                         qla83xx_wr_reg(vha, QLA83XX_IDC_DEV_STATE,
 720                             QLA8XXX_DEV_NEED_RESET);
 721                         qla83xx_idc_audit(vha, IDC_AUDIT_TIMESTAMP);
 722                         qla83xx_idc_unlock(vha, 0);
 723                         break;
 724                 } else {
 725                         /* Make sure FC side is not in reset */
 726                         WARN_ON_ONCE(qla2x00_wait_for_hba_online(vha) !=
 727                                      QLA_SUCCESS);
 728
 729                         /* Issue MPI reset */
 730                         scsi_block_requests(vha->host);
 731                         if (qla81xx_restart_mpi_firmware(vha) != QLA_SUCCESS)
 732                                 ql_log(ql_log_warn, vha, 0x7070,
 733                                     "MPI reset failed.\n");
 734                         scsi_unblock_requests(vha->host);
 735                         break;
 736                 }
 737         case 0x2025e:
 738                 if (!IS_P3P_TYPE(ha) || vha != base_vha) {
 739                         ql_log(ql_log_info, vha, 0x7071,
 740                             "FCoE ctx reset not supported.\n");
 741                         return -EPERM;
 742                 }
 743
 744                 ql_log(ql_log_info, vha, 0x7072,
 745                     "Issuing FCoE ctx reset.\n");
 746                 set_bit(FCOE_CTX_RESET_NEEDED, &vha->dpc_flags);
 747                 qla2xxx_wake_dpc(vha);
 748                 qla2x00_wait_for_fcoe_ctx_reset(vha);
 749                 break;
 750         case 0x2025f:
 751                 if (!IS_QLA8031(ha))
 752                         return -EPERM;
 753                 ql_log(ql_log_info, vha, 0x70bc,
 754                     "Disabling Reset by IDC control\n");
 755                 qla83xx_idc_lock(vha, 0);
 756                 __qla83xx_get_idc_control(vha, &idc_control);
 757                 idc_control |= QLA83XX_IDC_RESET_DISABLED;
 758                 __qla83xx_set_idc_control(vha, idc_control);
 759                 qla83xx_idc_unlock(vha, 0);
 760                 break;
 761         case 0x20260:
 762                 if (!IS_QLA8031(ha))
 763                         return -EPERM;
 764                 ql_log(ql_log_info, vha, 0x70bd,
 765                     "Enabling Reset by IDC control\n");
 766                 qla83xx_idc_lock(vha, 0);
 767                 __qla83xx_get_idc_control(vha, &idc_control);
 768                 idc_control &= ~QLA83XX_IDC_RESET_DISABLED;
 769                 __qla83xx_set_idc_control(vha, idc_control);
 770                 qla83xx_idc_unlock(vha, 0);
 771                 break;
 772         case 0x20261:
 773                 ql_dbg(ql_dbg_user, vha, 0x70e0,
 774                     "Updating cache versions without reset ");
 775
 776                 tmp_data = vmalloc(256);
 777                 if (!tmp_data) {
 778                         ql_log(ql_log_warn, vha, 0x70e1,
 779                             "Unable to allocate memory for VPD information update.\n");
 780                         return -ENOMEM;
 781                 }
 782                 ha->isp_ops->get_flash_version(vha, tmp_data);
 783                 vfree(tmp_data);
 784                 break;
 785         }
 786         return count;
 787 }
 788
 789 static struct bin_attribute sysfs_reset_attr = {
 790         .attr = {
 791                 .name = "reset",
 792                 .mode = S_IWUSR,
 793         },
 794         .size = 0,
 795         .write = qla2x00_sysfs_write_reset,
 796 };
 797
 798 static ssize_t
 799 qla2x00_issue_logo(struct file *filp, struct kobject *kobj,
 800                         struct bin_attribute *bin_attr,
 801                         char *buf, loff_t off, size_t count)
 802 {
 803         struct scsi_qla_host *vha = shost_priv(dev_to_shost(container_of(kobj,
 804             struct device, kobj)));
 805         int type;
 806         port_id_t did;
 807
 808         if (!capable(CAP_SYS_ADMIN))
 809                 return 0;
 810
 811         if (unlikely(pci_channel_offline(vha->hw->pdev)))
 812                 return 0;
 813
 814         if (qla2x00_chip_is_down(vha))
 815                 return 0;
 816
 817         type = simple_strtol(buf, NULL, 10);
 818
 819         did.b.domain = (type & 0x00ff0000) >> 16;
 820         did.b.area = (type & 0x0000ff00) >> 8;
 821         did.b.al_pa = (type & 0x000000ff);
 822
 823         ql_log(ql_log_info, vha, 0xd04d, "portid=%02x%02x%02x done\n",
 824             did.b.domain, did.b.area, did.b.al_pa);
 825
 826         ql_log(ql_log_info, vha, 0x70e4, "%s: %d\n", __func__, type);
 827
 828         qla24xx_els_dcmd_iocb(vha, ELS_DCMD_LOGO, did);
 829         return count;
 830 }
 831
 832 static struct bin_attribute sysfs_issue_logo_attr = {
 833         .attr = {
 834                 .name = "issue_logo",
 835                 .mode = S_IWUSR,
 836         },
 837         .size = 0,
 838         .write = qla2x00_issue_logo,
 839 };
 840
 841 static ssize_t
 842 qla2x00_sysfs_read_xgmac_stats(struct file *filp, struct kobject *kobj,
 843                        struct bin_attribute *bin_attr,
 844                        char *buf, loff_t off, size_t count)
 845 {
 846         struct scsi_qla_host *vha = shost_priv(dev_to_shost(container_of(kobj,
 847             struct device, kobj)));
 848         struct qla_hw_data *ha = vha->hw;
 849         int rval;
 850         uint16_t actual_size;
 851
 852         if (!capable(CAP_SYS_ADMIN) || off != 0 || count > XGMAC_DATA_SIZE)
 853                 return 0;
 854
 855         if (unlikely(pci_channel_offline(ha->pdev)))
 856                 return 0;
 857         mutex_lock(&vha->hw->optrom_mutex);
 858         if (qla2x00_chip_is_down(vha)) {
 859                 mutex_unlock(&vha->hw->optrom_mutex);
 860                 return 0;
 861         }
 862
 863         if (ha->xgmac_data)
 864                 goto do_read;
 865
 866         ha->xgmac_data = dma_alloc_coherent(&ha->pdev->dev, XGMAC_DATA_SIZE,
 867             &ha->xgmac_data_dma, GFP_KERNEL);
 868         if (!ha->xgmac_data) {
 869                 mutex_unlock(&vha->hw->optrom_mutex);
 870                 ql_log(ql_log_warn, vha, 0x7076,
 871                     "Unable to allocate memory for XGMAC read-data.\n");
 872                 return 0;
 873         }
 874
 875 do_read:
 876         actual_size = 0;
 877         memset(ha->xgmac_data, 0, XGMAC_DATA_SIZE);
 878
 879         rval = qla2x00_get_xgmac_stats(vha, ha->xgmac_data_dma,
 880             XGMAC_DATA_SIZE, &actual_size);
 881
 882         mutex_unlock(&vha->hw->optrom_mutex);
 883         if (rval != QLA_SUCCESS) {
 884                 ql_log(ql_log_warn, vha, 0x7077,
 885                     "Unable to read XGMAC data (%x).\n", rval);
 886                 count = 0;
 887         }
 888
 889         count = actual_size > count ? count : actual_size;
 890         memcpy(buf, ha->xgmac_data, count);
 891
 892         return count;
 893 }
 894
 895 static struct bin_attribute sysfs_xgmac_stats_attr = {
 896         .attr = {
 897                 .name = "xgmac_stats",
 898                 .mode = S_IRUSR,
 899         },
 900         .size = 0,
 901         .read = qla2x00_sysfs_read_xgmac_stats,
 902 };
 903
 904 static ssize_t
 905 qla2x00_sysfs_read_dcbx_tlv(struct file *filp, struct kobject *kobj,
 906                        struct bin_attribute *bin_attr,
 907                        char *buf, loff_t off, size_t count)
 908 {
 909         struct scsi_qla_host *vha = shost_priv(dev_to_shost(container_of(kobj,
 910             struct device, kobj)));
 911         struct qla_hw_data *ha = vha->hw;
 912         int rval;
 913
 914         if (!capable(CAP_SYS_ADMIN) || off != 0 || count > DCBX_TLV_DATA_SIZE)
 915                 return 0;
 916
 917         if (ha->dcbx_tlv)
 918                 goto do_read;
 919         mutex_lock(&vha->hw->optrom_mutex);
 920         if (qla2x00_chip_is_down(vha)) {
 921                 mutex_unlock(&vha->hw->optrom_mutex);
 922                 return 0;
 923         }
 924
 925         ha->dcbx_tlv = dma_alloc_coherent(&ha->pdev->dev, DCBX_TLV_DATA_SIZE,
 926             &ha->dcbx_tlv_dma, GFP_KERNEL);
 927         if (!ha->dcbx_tlv) {
 928                 mutex_unlock(&vha->hw->optrom_mutex);
 929                 ql_log(ql_log_warn, vha, 0x7078,
 930                     "Unable to allocate memory for DCBX TLV read-data.\n");
 931                 return -ENOMEM;
 932         }
 933
 934 do_read:
 935         memset(ha->dcbx_tlv, 0, DCBX_TLV_DATA_SIZE);
 936
 937         rval = qla2x00_get_dcbx_params(vha, ha->dcbx_tlv_dma,
 938             DCBX_TLV_DATA_SIZE);
 939
 940         mutex_unlock(&vha->hw->optrom_mutex);
 941
 942         if (rval != QLA_SUCCESS) {
 943                 ql_log(ql_log_warn, vha, 0x7079,
 944                     "Unable to read DCBX TLV (%x).\n", rval);
 945                 return -EIO;
 946         }
 947
 948         memcpy(buf, ha->dcbx_tlv, count);
 949
 950         return count;
 951 }
 952
 953 static struct bin_attribute sysfs_dcbx_tlv_attr = {
 954         .attr = {
 955                 .name = "dcbx_tlv",
 956                 .mode = S_IRUSR,
 957         },
 958         .size = 0,
 959         .read = qla2x00_sysfs_read_dcbx_tlv,
 960 };
 961
 962 static struct sysfs_entry {
 963         char *name;
 964         struct bin_attribute *attr;
 965         int type;
 966 } bin_file_entries[] = {
 967         { "fw_dump", &sysfs_fw_dump_attr, },
 968         { "nvram", &sysfs_nvram_attr, },
 969         { "optrom", &sysfs_optrom_attr, },
 970         { "optrom_ctl", &sysfs_optrom_ctl_attr, },
 971         { "vpd", &sysfs_vpd_attr, 1 },
 972         { "sfp", &sysfs_sfp_attr, 1 },
 973         { "reset", &sysfs_reset_attr, },
 974         { "issue_logo", &sysfs_issue_logo_attr, },
 975         { "xgmac_stats", &sysfs_xgmac_stats_attr, 3 },
 976         { "dcbx_tlv", &sysfs_dcbx_tlv_attr, 3 },
 977         { NULL },
 978 };
 979
 980 void
 981 qla2x00_alloc_sysfs_attr(scsi_qla_host_t *vha)
 982 {
 983         struct Scsi_Host *host = vha->host;
 984         struct sysfs_entry *iter;
 985         int ret;
 986
 987         for (iter = bin_file_entries; iter->name; iter++) {
 988                 if (iter->type && !IS_FWI2_CAPABLE(vha->hw))
 989                         continue;
 990                 if (iter->type == 2 && !IS_QLA25XX(vha->hw))
 991                         continue;
 992                 if (iter->type == 3 && !(IS_CNA_CAPABLE(vha->hw)))
 993                         continue;
 994
 995                 ret = sysfs_create_bin_file(&host->shost_gendev.kobj,
 996                     iter->attr);
 997                 if (ret)
 998                         ql_log(ql_log_warn, vha, 0x00f3,
 999                             "Unable to create sysfs %s binary attribute (%d).\n",
1000                             iter->name, ret);
1001                 else
1002                         ql_dbg(ql_dbg_init, vha, 0x00f4,
1003                             "Successfully created sysfs %s binary attribute.\n",
1004                             iter->name);
1005         }
1006 }
1007
1008 void
1009 qla2x00_free_sysfs_attr(scsi_qla_host_t *vha, bool stop_beacon)
1010 {
1011         struct Scsi_Host *host = vha->host;
1012         struct sysfs_entry *iter;
1013         struct qla_hw_data *ha = vha->hw;
1014
1015         for (iter = bin_file_entries; iter->name; iter++) {
1016                 if (iter->type && !IS_FWI2_CAPABLE(ha))
1017                         continue;
1018                 if (iter->type == 2 && !IS_QLA25XX(ha))
1019                         continue;
1020                 if (iter->type == 3 && !(IS_CNA_CAPABLE(ha)))
1021                         continue;
1022                 if (iter->type == 0x27 &&
1023                     (!IS_QLA27XX(ha) || !IS_QLA28XX(ha)))
1024                         continue;
1025
1026                 sysfs_remove_bin_file(&host->shost_gendev.kobj,
1027                     iter->attr);
1028         }
1029
1030         if (stop_beacon && ha->beacon_blink_led == 1)
1031                 ha->isp_ops->beacon_off(vha);
1032 }
1033
1034 /* Scsi_Host attributes. */
1035
1036 static ssize_t
1037 qla2x00_driver_version_show(struct device *dev,
1038                           struct device_attribute *attr, char *buf)
1039 {
1040         return scnprintf(buf, PAGE_SIZE, "%s\n", qla2x00_version_str);
1041 }
1042
1043 static ssize_t
1044 qla2x00_fw_version_show(struct device *dev,
1045                         struct device_attribute *attr, char *buf)
1046 {
1047         scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1048         struct qla_hw_data *ha = vha->hw;
1049         char fw_str[128];
1050
1051         return scnprintf(buf, PAGE_SIZE, "%s\n",
1052             ha->isp_ops->fw_version_str(vha, fw_str, sizeof(fw_str)));
1053 }
1054
1055 static ssize_t
1056 qla2x00_serial_num_show(struct device *dev, struct device_attribute *attr,
1057                         char *buf)
1058 {
1059         scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1060         struct qla_hw_data *ha = vha->hw;
1061         uint32_t sn;
1062
1063         if (IS_QLAFX00(vha->hw)) {
1064                 return scnprintf(buf, PAGE_SIZE, "%s\n",
1065                     vha->hw->mr.serial_num);
1066         } else if (IS_FWI2_CAPABLE(ha)) {
1067                 qla2xxx_get_vpd_field(vha, "SN", buf, PAGE_SIZE - 1);
1068                 return strlen(strcat(buf, "\n"));
1069         }
1070
1071         sn = ((ha->serial0 & 0x1f) << 16) | (ha->serial2 << 8) | ha->serial1;
1072         return scnprintf(buf, PAGE_SIZE, "%c%05d\n", 'A' + sn / 100000,
1073             sn % 100000);
1074 }
1075
1076 static ssize_t
1077 qla2x00_isp_name_show(struct device *dev, struct device_attribute *attr,
1078                       char *buf)
1079 {
1080         scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1081
1082         return scnprintf(buf, PAGE_SIZE, "ISP%04X\n", vha->hw->pdev->device);
1083 }
1084
1085 static ssize_t
1086 qla2x00_isp_id_show(struct device *dev, struct device_attribute *attr,
1087                     char *buf)
1088 {
1089         scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1090         struct qla_hw_data *ha = vha->hw;
1091
1092         if (IS_QLAFX00(vha->hw))
1093                 return scnprintf(buf, PAGE_SIZE, "%s\n",
1094                     vha->hw->mr.hw_version);
1095
1096         return scnprintf(buf, PAGE_SIZE, "%04x %04x %04x %04x\n",
1097             ha->product_id[0], ha->product_id[1], ha->product_id[2],
1098             ha->product_id[3]);
1099 }
1100
1101 static ssize_t
1102 qla2x00_model_name_show(struct device *dev, struct device_attribute *attr,
1103                         char *buf)
1104 {
1105         scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1106
1107         return scnprintf(buf, PAGE_SIZE, "%s\n", vha->hw->model_number);
1108 }
1109
1110 static ssize_t
1111 qla2x00_model_desc_show(struct device *dev, struct device_attribute *attr,
1112                         char *buf)
1113 {
1114         scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1115
1116         return scnprintf(buf, PAGE_SIZE, "%s\n", vha->hw->model_desc);
1117 }
1118
1119 static ssize_t
1120 qla2x00_pci_info_show(struct device *dev, struct device_attribute *attr,
1121                       char *buf)
1122 {
1123         scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1124         char pci_info[30];
1125
1126         return scnprintf(buf, PAGE_SIZE, "%s\n",
1127                          vha->hw->isp_ops->pci_info_str(vha, pci_info,
1128                                                         sizeof(pci_info)));
1129 }
1130
1131 static ssize_t
1132 qla2x00_link_state_show(struct device *dev, struct device_attribute *attr,
1133                         char *buf)
1134 {
1135         scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1136         struct qla_hw_data *ha = vha->hw;
1137         int len = 0;
1138
1139         if (atomic_read(&vha->loop_state) == LOOP_DOWN ||
1140             atomic_read(&vha->loop_state) == LOOP_DEAD ||
1141             vha->device_flags & DFLG_NO_CABLE)
1142                 len = scnprintf(buf, PAGE_SIZE, "Link Down\n");
1143         else if (atomic_read(&vha->loop_state) != LOOP_READY ||
1144             qla2x00_chip_is_down(vha))
1145                 len = scnprintf(buf, PAGE_SIZE, "Unknown Link State\n");
1146         else {
1147                 len = scnprintf(buf, PAGE_SIZE, "Link Up - ");
1148
1149                 switch (ha->current_topology) {
1150                 case ISP_CFG_NL:
1151                         len += scnprintf(buf + len, PAGE_SIZE-len, "Loop\n");
1152                         break;
1153                 case ISP_CFG_FL:
1154                         len += scnprintf(buf + len, PAGE_SIZE-len, "FL_Port\n");
1155                         break;
1156                 case ISP_CFG_N:
1157                         len += scnprintf(buf + len, PAGE_SIZE-len,
1158                             "N_Port to N_Port\n");
1159                         break;
1160                 case ISP_CFG_F:
1161                         len += scnprintf(buf + len, PAGE_SIZE-len, "F_Port\n");
1162                         break;
1163                 default:
1164                         len += scnprintf(buf + len, PAGE_SIZE-len, "Loop\n");
1165                         break;
1166                 }
1167         }
1168         return len;
1169 }
1170
1171 static ssize_t
1172 qla2x00_zio_show(struct device *dev, struct device_attribute *attr,
1173                  char *buf)
1174 {
1175         scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1176         int len = 0;
1177
1178         switch (vha->hw->zio_mode) {
1179         case QLA_ZIO_MODE_6:
1180                 len += scnprintf(buf + len, PAGE_SIZE-len, "Mode 6\n");
1181                 break;
1182         case QLA_ZIO_DISABLED:
1183                 len += scnprintf(buf + len, PAGE_SIZE-len, "Disabled\n");
1184                 break;
1185         }
1186         return len;
1187 }
1188
1189 static ssize_t
1190 qla2x00_zio_store(struct device *dev, struct device_attribute *attr,
1191                   const char *buf, size_t count)
1192 {
1193         scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1194         struct qla_hw_data *ha = vha->hw;
1195         int val = 0;
1196         uint16_t zio_mode;
1197
1198         if (!IS_ZIO_SUPPORTED(ha))
1199                 return -ENOTSUPP;
1200
1201         if (sscanf(buf, "%d", &val) != 1)
1202                 return -EINVAL;
1203
1204         if (val)
1205                 zio_mode = QLA_ZIO_MODE_6;
1206         else
1207                 zio_mode = QLA_ZIO_DISABLED;
1208
1209         /* Update per-hba values and queue a reset. */
1210         if (zio_mode != QLA_ZIO_DISABLED || ha->zio_mode != QLA_ZIO_DISABLED) {
1211                 ha->zio_mode = zio_mode;
1212                 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
1213         }
1214         return strlen(buf);
1215 }
1216
1217 static ssize_t
1218 qla2x00_zio_timer_show(struct device *dev, struct device_attribute *attr,
1219                        char *buf)
1220 {
1221         scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1222
1223         return scnprintf(buf, PAGE_SIZE, "%d us\n", vha->hw->zio_timer * 100);
1224 }
1225
1226 static ssize_t
1227 qla2x00_zio_timer_store(struct device *dev, struct device_attribute *attr,
1228                         const char *buf, size_t count)
1229 {
1230         scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1231         int val = 0;
1232         uint16_t zio_timer;
1233
1234         if (sscanf(buf, "%d", &val) != 1)
1235                 return -EINVAL;
1236         if (val > 25500 || val < 100)
1237                 return -ERANGE;
1238
1239         zio_timer = (uint16_t)(val / 100);
1240         vha->hw->zio_timer = zio_timer;
1241
1242         return strlen(buf);
1243 }
1244
1245 static ssize_t
1246 qla_zio_threshold_show(struct device *dev, struct device_attribute *attr,
1247                        char *buf)
1248 {
1249         scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1250
1251         return scnprintf(buf, PAGE_SIZE, "%d exchanges\n",
1252             vha->hw->last_zio_threshold);
1253 }
1254
1255 static ssize_t
1256 qla_zio_threshold_store(struct device *dev, struct device_attribute *attr,
1257     const char *buf, size_t count)
1258 {
1259         scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1260         int val = 0;
1261
1262         if (vha->hw->zio_mode != QLA_ZIO_MODE_6)
1263                 return -EINVAL;
1264         if (sscanf(buf, "%d", &val) != 1)
1265                 return -EINVAL;
1266         if (val < 0 || val > 256)
1267                 return -ERANGE;
1268
1269         atomic_set(&vha->hw->zio_threshold, val);
1270         return strlen(buf);
1271 }
1272
1273 static ssize_t
1274 qla2x00_beacon_show(struct device *dev, struct device_attribute *attr,
1275                     char *buf)
1276 {
1277         scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1278         int len = 0;
1279
1280         if (vha->hw->beacon_blink_led)
1281                 len += scnprintf(buf + len, PAGE_SIZE-len, "Enabled\n");
1282         else
1283                 len += scnprintf(buf + len, PAGE_SIZE-len, "Disabled\n");
1284         return len;
1285 }
1286
1287 static ssize_t
1288 qla2x00_beacon_store(struct device *dev, struct device_attribute *attr,
1289                      const char *buf, size_t count)
1290 {
1291         scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1292         struct qla_hw_data *ha = vha->hw;
1293         int val = 0;
1294         int rval;
1295
1296         if (IS_QLA2100(ha) || IS_QLA2200(ha))
1297                 return -EPERM;
1298
1299         if (sscanf(buf, "%d", &val) != 1)
1300                 return -EINVAL;
1301
1302         mutex_lock(&vha->hw->optrom_mutex);
1303         if (qla2x00_chip_is_down(vha)) {
1304                 mutex_unlock(&vha->hw->optrom_mutex);
1305                 ql_log(ql_log_warn, vha, 0x707a,
1306                     "Abort ISP active -- ignoring beacon request.\n");
1307                 return -EBUSY;
1308         }
1309
1310         if (val)
1311                 rval = ha->isp_ops->beacon_on(vha);
1312         else
1313                 rval = ha->isp_ops->beacon_off(vha);
1314
1315         if (rval != QLA_SUCCESS)
1316                 count = 0;
1317
1318         mutex_unlock(&vha->hw->optrom_mutex);
1319
1320         return count;
1321 }
1322
1323 static ssize_t
1324 qla2x00_optrom_bios_version_show(struct device *dev,
1325                                  struct device_attribute *attr, char *buf)
1326 {
1327         scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1328         struct qla_hw_data *ha = vha->hw;
1329
1330         return scnprintf(buf, PAGE_SIZE, "%d.%02d\n", ha->bios_revision[1],
1331             ha->bios_revision[0]);
1332 }
1333
1334 static ssize_t
1335 qla2x00_optrom_efi_version_show(struct device *dev,
1336                                 struct device_attribute *attr, char *buf)
1337 {
1338         scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1339         struct qla_hw_data *ha = vha->hw;
1340
1341         return scnprintf(buf, PAGE_SIZE, "%d.%02d\n", ha->efi_revision[1],
1342             ha->efi_revision[0]);
1343 }
1344
1345 static ssize_t
1346 qla2x00_optrom_fcode_version_show(struct device *dev,
1347                                   struct device_attribute *attr, char *buf)
1348 {
1349         scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1350         struct qla_hw_data *ha = vha->hw;
1351
1352         return scnprintf(buf, PAGE_SIZE, "%d.%02d\n", ha->fcode_revision[1],
1353             ha->fcode_revision[0]);
1354 }
1355
1356 static ssize_t
1357 qla2x00_optrom_fw_version_show(struct device *dev,
1358                                struct device_attribute *attr, char *buf)
1359 {
1360         scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1361         struct qla_hw_data *ha = vha->hw;
1362
1363         return scnprintf(buf, PAGE_SIZE, "%d.%02d.%02d %d\n",
1364             ha->fw_revision[0], ha->fw_revision[1], ha->fw_revision[2],
1365             ha->fw_revision[3]);
1366 }
1367
1368 static ssize_t
1369 qla2x00_optrom_gold_fw_version_show(struct device *dev,
1370     struct device_attribute *attr, char *buf)
1371 {
1372         scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1373         struct qla_hw_data *ha = vha->hw;
1374
1375         if (!IS_QLA81XX(ha) && !IS_QLA83XX(ha) &&
1376             !IS_QLA27XX(ha) && !IS_QLA28XX(ha))
1377                 return scnprintf(buf, PAGE_SIZE, "\n");
1378
1379         return scnprintf(buf, PAGE_SIZE, "%d.%02d.%02d (%d)\n",
1380             ha->gold_fw_version[0], ha->gold_fw_version[1],
1381             ha->gold_fw_version[2], ha->gold_fw_version[3]);
1382 }
1383
1384 static ssize_t
1385 qla2x00_total_isp_aborts_show(struct device *dev,
1386                               struct device_attribute *attr, char *buf)
1387 {
1388         scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1389
1390         return scnprintf(buf, PAGE_SIZE, "%d\n",
1391             vha->qla_stats.total_isp_aborts);
1392 }
1393
1394 static ssize_t
1395 qla24xx_84xx_fw_version_show(struct device *dev,
1396         struct device_attribute *attr, char *buf)
1397 {
1398         int rval = QLA_SUCCESS;
1399         uint16_t status[2] = { 0 };
1400         scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1401         struct qla_hw_data *ha = vha->hw;
1402
1403         if (!IS_QLA84XX(ha))
1404                 return scnprintf(buf, PAGE_SIZE, "\n");
1405
1406         if (!ha->cs84xx->op_fw_version) {
1407                 rval = qla84xx_verify_chip(vha, status);
1408
1409                 if (!rval && !status[0])
1410                         return scnprintf(buf, PAGE_SIZE, "%u\n",
1411                             (uint32_t)ha->cs84xx->op_fw_version);
1412         }
1413
1414         return scnprintf(buf, PAGE_SIZE, "\n");
1415 }
1416
1417 static ssize_t
1418 qla2x00_serdes_version_show(struct device *dev, struct device_attribute *attr,
1419     char *buf)
1420 {
1421         scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1422         struct qla_hw_data *ha = vha->hw;
1423
1424         if (!IS_QLA27XX(ha) && !IS_QLA28XX(ha))
1425                 return scnprintf(buf, PAGE_SIZE, "\n");
1426
1427         return scnprintf(buf, PAGE_SIZE, "%d.%02d.%02d\n",
1428             ha->serdes_version[0], ha->serdes_version[1],
1429             ha->serdes_version[2]);
1430 }
1431
1432 static ssize_t
1433 qla2x00_mpi_version_show(struct device *dev, struct device_attribute *attr,
1434     char *buf)
1435 {
1436         scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1437         struct qla_hw_data *ha = vha->hw;
1438
1439         if (!IS_QLA81XX(ha) && !IS_QLA8031(ha) && !IS_QLA8044(ha) &&
1440             !IS_QLA27XX(ha) && !IS_QLA28XX(ha))
1441                 return scnprintf(buf, PAGE_SIZE, "\n");
1442
1443         return scnprintf(buf, PAGE_SIZE, "%d.%02d.%02d (%x)\n",
1444             ha->mpi_version[0], ha->mpi_version[1], ha->mpi_version[2],
1445             ha->mpi_capabilities);
1446 }
1447
1448 static ssize_t
1449 qla2x00_phy_version_show(struct device *dev, struct device_attribute *attr,
1450     char *buf)
1451 {
1452         scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1453         struct qla_hw_data *ha = vha->hw;
1454
1455         if (!IS_QLA81XX(ha) && !IS_QLA8031(ha))
1456                 return scnprintf(buf, PAGE_SIZE, "\n");
1457
1458         return scnprintf(buf, PAGE_SIZE, "%d.%02d.%02d\n",
1459             ha->phy_version[0], ha->phy_version[1], ha->phy_version[2]);
1460 }
1461
1462 static ssize_t
1463 qla2x00_flash_block_size_show(struct device *dev,
1464                               struct device_attribute *attr, char *buf)
1465 {
1466         scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1467         struct qla_hw_data *ha = vha->hw;
1468
1469         return scnprintf(buf, PAGE_SIZE, "0x%x\n", ha->fdt_block_size);
1470 }
1471
1472 static ssize_t
1473 qla2x00_vlan_id_show(struct device *dev, struct device_attribute *attr,
1474     char *buf)
1475 {
1476         scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1477
1478         if (!IS_CNA_CAPABLE(vha->hw))
1479                 return scnprintf(buf, PAGE_SIZE, "\n");
1480
1481         return scnprintf(buf, PAGE_SIZE, "%d\n", vha->fcoe_vlan_id);
1482 }
1483
1484 static ssize_t
1485 qla2x00_vn_port_mac_address_show(struct device *dev,
1486     struct device_attribute *attr, char *buf)
1487 {
1488         scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1489
1490         if (!IS_CNA_CAPABLE(vha->hw))
1491                 return scnprintf(buf, PAGE_SIZE, "\n");
1492
1493         return scnprintf(buf, PAGE_SIZE, "%pMR\n", vha->fcoe_vn_port_mac);
1494 }
1495
1496 static ssize_t
1497 qla2x00_fabric_param_show(struct device *dev, struct device_attribute *attr,
1498     char *buf)
1499 {
1500         scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1501
1502         return scnprintf(buf, PAGE_SIZE, "%d\n", vha->hw->switch_cap);
1503 }
1504
1505 static ssize_t
1506 qla2x00_thermal_temp_show(struct device *dev,
1507         struct device_attribute *attr, char *buf)
1508 {
1509         scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1510         uint16_t temp = 0;
1511         int rc;
1512
1513         mutex_lock(&vha->hw->optrom_mutex);
1514         if (qla2x00_chip_is_down(vha)) {
1515                 mutex_unlock(&vha->hw->optrom_mutex);
1516                 ql_log(ql_log_warn, vha, 0x70dc, "ISP reset active.\n");
1517                 goto done;
1518         }
1519
1520         if (vha->hw->flags.eeh_busy) {
1521                 mutex_unlock(&vha->hw->optrom_mutex);
1522                 ql_log(ql_log_warn, vha, 0x70dd, "PCI EEH busy.\n");
1523                 goto done;
1524         }
1525
1526         rc = qla2x00_get_thermal_temp(vha, &temp);
1527         mutex_unlock(&vha->hw->optrom_mutex);
1528         if (rc == QLA_SUCCESS)
1529                 return scnprintf(buf, PAGE_SIZE, "%d\n", temp);
1530
1531 done:
1532         return scnprintf(buf, PAGE_SIZE, "\n");
1533 }
1534
1535 static ssize_t
1536 qla2x00_fw_state_show(struct device *dev, struct device_attribute *attr,
1537     char *buf)
1538 {
1539         scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1540         int rval = QLA_FUNCTION_FAILED;
1541         uint16_t state[6];
1542         uint32_t pstate;
1543
1544         if (IS_QLAFX00(vha->hw)) {
1545                 pstate = qlafx00_fw_state_show(dev, attr, buf);
1546                 return scnprintf(buf, PAGE_SIZE, "0x%x\n", pstate);
1547         }
1548
1549         mutex_lock(&vha->hw->optrom_mutex);
1550         if (qla2x00_chip_is_down(vha)) {
1551                 mutex_unlock(&vha->hw->optrom_mutex);
1552                 ql_log(ql_log_warn, vha, 0x707c,
1553                     "ISP reset active.\n");
1554                 goto out;
1555         } else if (vha->hw->flags.eeh_busy) {
1556                 mutex_unlock(&vha->hw->optrom_mutex);
1557                 goto out;
1558         }
1559
1560         rval = qla2x00_get_firmware_state(vha, state);
1561         mutex_unlock(&vha->hw->optrom_mutex);
1562 out:
1563         if (rval != QLA_SUCCESS) {
1564                 memset(state, -1, sizeof(state));
1565                 rval = qla2x00_get_firmware_state(vha, state);
1566         }
1567
1568         return scnprintf(buf, PAGE_SIZE, "0x%x 0x%x 0x%x 0x%x 0x%x 0x%x\n",
1569             state[0], state[1], state[2], state[3], state[4], state[5]);
1570 }
1571
1572 static ssize_t
1573 qla2x00_diag_requests_show(struct device *dev,
1574         struct device_attribute *attr, char *buf)
1575 {
1576         scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1577
1578         if (!IS_BIDI_CAPABLE(vha->hw))
1579                 return scnprintf(buf, PAGE_SIZE, "\n");
1580
1581         return scnprintf(buf, PAGE_SIZE, "%llu\n", vha->bidi_stats.io_count);
1582 }
1583
1584 static ssize_t
1585 qla2x00_diag_megabytes_show(struct device *dev,
1586         struct device_attribute *attr, char *buf)
1587 {
1588         scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1589
1590         if (!IS_BIDI_CAPABLE(vha->hw))
1591                 return scnprintf(buf, PAGE_SIZE, "\n");
1592
1593         return scnprintf(buf, PAGE_SIZE, "%llu\n",
1594             vha->bidi_stats.transfer_bytes >> 20);
1595 }
1596
1597 static ssize_t
1598 qla2x00_fw_dump_size_show(struct device *dev, struct device_attribute *attr,
1599         char *buf)
1600 {
1601         scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1602         struct qla_hw_data *ha = vha->hw;
1603         uint32_t size;
1604
1605         if (!ha->fw_dumped)
1606                 size = 0;
1607         else if (IS_P3P_TYPE(ha))
1608                 size = ha->md_template_size + ha->md_dump_size;
1609         else
1610                 size = ha->fw_dump_len;
1611
1612         return scnprintf(buf, PAGE_SIZE, "%d\n", size);
1613 }
1614
1615 static ssize_t
1616 qla2x00_allow_cna_fw_dump_show(struct device *dev,
1617         struct device_attribute *attr, char *buf)
1618 {
1619         scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1620
1621         if (!IS_P3P_TYPE(vha->hw))
1622                 return scnprintf(buf, PAGE_SIZE, "\n");
1623         else
1624                 return scnprintf(buf, PAGE_SIZE, "%s\n",
1625                     vha->hw->allow_cna_fw_dump ? "true" : "false");
1626 }
1627
1628 static ssize_t
1629 qla2x00_allow_cna_fw_dump_store(struct device *dev,
1630         struct device_attribute *attr, const char *buf, size_t count)
1631 {
1632         scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1633         int val = 0;
1634
1635         if (!IS_P3P_TYPE(vha->hw))
1636                 return -EINVAL;
1637
1638         if (sscanf(buf, "%d", &val) != 1)
1639                 return -EINVAL;
1640
1641         vha->hw->allow_cna_fw_dump = val != 0;
1642
1643         return strlen(buf);
1644 }
1645
1646 static ssize_t
1647 qla2x00_pep_version_show(struct device *dev, struct device_attribute *attr,
1648         char *buf)
1649 {
1650         scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1651         struct qla_hw_data *ha = vha->hw;
1652
1653         if (!IS_QLA27XX(ha) && !IS_QLA28XX(ha))
1654                 return scnprintf(buf, PAGE_SIZE, "\n");
1655
1656         return scnprintf(buf, PAGE_SIZE, "%d.%02d.%02d\n",
1657             ha->pep_version[0], ha->pep_version[1], ha->pep_version[2]);
1658 }
1659
1660 static ssize_t
1661 qla2x00_min_supported_speed_show(struct device *dev,
1662     struct device_attribute *attr, char *buf)
1663 {
1664         scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1665         struct qla_hw_data *ha = vha->hw;
1666
1667         if (!IS_QLA27XX(ha) && !IS_QLA28XX(ha))
1668                 return scnprintf(buf, PAGE_SIZE, "\n");
1669
1670         return scnprintf(buf, PAGE_SIZE, "%s\n",
1671             ha->min_supported_speed == 6 ? "64Gps" :
1672             ha->min_supported_speed == 5 ? "32Gps" :
1673             ha->min_supported_speed == 4 ? "16Gps" :
1674             ha->min_supported_speed == 3 ? "8Gps" :
1675             ha->min_supported_speed == 2 ? "4Gps" :
1676             ha->min_supported_speed != 0 ? "unknown" : "");
1677 }
1678
1679 static ssize_t
1680 qla2x00_max_supported_speed_show(struct device *dev,
1681     struct device_attribute *attr, char *buf)
1682 {
1683         scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1684         struct qla_hw_data *ha = vha->hw;
1685
1686         if (!IS_QLA27XX(ha) && !IS_QLA28XX(ha))
1687                 return scnprintf(buf, PAGE_SIZE, "\n");
1688
1689         return scnprintf(buf, PAGE_SIZE, "%s\n",
1690             ha->max_supported_speed  == 2 ? "64Gps" :
1691             ha->max_supported_speed  == 1 ? "32Gps" :
1692             ha->max_supported_speed  == 0 ? "16Gps" : "unknown");
1693 }
1694
1695 static ssize_t
1696 qla2x00_port_speed_store(struct device *dev, struct device_attribute *attr,
1697     const char *buf, size_t count)
1698 {
1699         struct scsi_qla_host *vha = shost_priv(dev_to_shost(dev));
1700         ulong type, speed;
1701         int oldspeed, rval;
1702         int mode = QLA_SET_DATA_RATE_LR;
1703         struct qla_hw_data *ha = vha->hw;
1704
1705         if (!IS_QLA27XX(ha) && !IS_QLA28XX(ha)) {
1706                 ql_log(ql_log_warn, vha, 0x70d8,
1707                     "Speed setting not supported \n");
1708                 return -EINVAL;
1709         }
1710
1711         rval = kstrtol(buf, 10, &type);
1712         if (rval)
1713                 return rval;
1714         speed = type;
1715         if (type == 40 || type == 80 || type == 160 ||
1716             type == 320) {
1717                 ql_dbg(ql_dbg_user, vha, 0x70d9,
1718                     "Setting will be affected after a loss of sync\n");
1719                 type = type/10;
1720                 mode = QLA_SET_DATA_RATE_NOLR;
1721         }
1722
1723         oldspeed = ha->set_data_rate;
1724
1725         switch (type) {
1726         case 0:
1727                 ha->set_data_rate = PORT_SPEED_AUTO;
1728                 break;
1729         case 4:
1730                 ha->set_data_rate = PORT_SPEED_4GB;
1731                 break;
1732         case 8:
1733                 ha->set_data_rate = PORT_SPEED_8GB;
1734                 break;
1735         case 16:
1736                 ha->set_data_rate = PORT_SPEED_16GB;
1737                 break;
1738         case 32:
1739                 ha->set_data_rate = PORT_SPEED_32GB;
1740                 break;
1741         default:
1742                 ql_log(ql_log_warn, vha, 0x1199,
1743                     "Unrecognized speed setting:%lx. Setting Autoneg\n",
1744                     speed);
1745                 ha->set_data_rate = PORT_SPEED_AUTO;
1746         }
1747
1748         if (qla2x00_chip_is_down(vha) || (oldspeed == ha->set_data_rate))
1749                 return -EINVAL;
1750
1751         ql_log(ql_log_info, vha, 0x70da,
1752             "Setting speed to %lx Gbps \n", type);
1753
1754         rval = qla2x00_set_data_rate(vha, mode);
1755         if (rval != QLA_SUCCESS)
1756                 return -EIO;
1757
1758         return strlen(buf);
1759 }
1760
1761 static ssize_t
1762 qla2x00_port_speed_show(struct device *dev, struct device_attribute *attr,
1763     char *buf)
1764 {
1765         struct scsi_qla_host *vha = shost_priv(dev_to_shost(dev));
1766         struct qla_hw_data *ha = vha->hw;
1767         ssize_t rval;
1768         char *spd[7] = {"0", "0", "0", "4", "8", "16", "32"};
1769
1770         rval = qla2x00_get_data_rate(vha);
1771         if (rval != QLA_SUCCESS) {
1772                 ql_log(ql_log_warn, vha, 0x70db,
1773                     "Unable to get port speed rval:%zd\n", rval);
1774                 return -EINVAL;
1775         }
1776
1777         ql_log(ql_log_info, vha, 0x70d6,
1778             "port speed:%d\n", ha->link_data_rate);
1779
1780         return scnprintf(buf, PAGE_SIZE, "%s\n", spd[ha->link_data_rate]);
1781 }
1782
1783 /* ----- */
1784
1785 static ssize_t
1786 qlini_mode_show(struct device *dev, struct device_attribute *attr, char *buf)
1787 {
1788         scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1789         int len = 0;
1790
1791         len += scnprintf(buf + len, PAGE_SIZE-len,
1792             "Supported options: enabled | disabled | dual | exclusive\n");
1793
1794         /* --- */
1795         len += scnprintf(buf + len, PAGE_SIZE-len, "Current selection: ");
1796
1797         switch (vha->qlini_mode) {
1798         case QLA2XXX_INI_MODE_EXCLUSIVE:
1799                 len += scnprintf(buf + len, PAGE_SIZE-len,
1800                     QLA2XXX_INI_MODE_STR_EXCLUSIVE);
1801                 break;
1802         case QLA2XXX_INI_MODE_DISABLED:
1803                 len += scnprintf(buf + len, PAGE_SIZE-len,
1804                     QLA2XXX_INI_MODE_STR_DISABLED);
1805                 break;
1806         case QLA2XXX_INI_MODE_ENABLED:
1807                 len += scnprintf(buf + len, PAGE_SIZE-len,
1808                     QLA2XXX_INI_MODE_STR_ENABLED);
1809                 break;
1810         case QLA2XXX_INI_MODE_DUAL:
1811                 len += scnprintf(buf + len, PAGE_SIZE-len,
1812                     QLA2XXX_INI_MODE_STR_DUAL);
1813                 break;
1814         }
1815         len += scnprintf(buf + len, PAGE_SIZE-len, "\n");
1816
1817         return len;
1818 }
1819
1820 static char *mode_to_str[] = {
1821         "exclusive",
1822         "disabled",
1823         "enabled",
1824         "dual",
1825 };
1826
1827 #define NEED_EXCH_OFFLOAD(_exchg) ((_exchg) > FW_DEF_EXCHANGES_CNT)
1828 static int qla_set_ini_mode(scsi_qla_host_t *vha, int op)
1829 {
1830         int rc = 0;
1831         enum {
1832                 NO_ACTION,
1833                 MODE_CHANGE_ACCEPT,
1834                 MODE_CHANGE_NO_ACTION,
1835                 TARGET_STILL_ACTIVE,
1836         };
1837         int action = NO_ACTION;
1838         int set_mode = 0;
1839         u8  eo_toggle = 0;      /* exchange offload flipped */
1840
1841         switch (vha->qlini_mode) {
1842         case QLA2XXX_INI_MODE_DISABLED:
1843                 switch (op) {
1844                 case QLA2XXX_INI_MODE_DISABLED:
1845                         if (qla_tgt_mode_enabled(vha)) {
1846                                 if (NEED_EXCH_OFFLOAD(vha->u_ql2xexchoffld) !=
1847                                     vha->hw->flags.exchoffld_enabled)
1848                                         eo_toggle = 1;
1849                                 if (((vha->ql2xexchoffld !=
1850                                     vha->u_ql2xexchoffld) &&
1851                                     NEED_EXCH_OFFLOAD(vha->u_ql2xexchoffld)) ||
1852                                     eo_toggle) {
1853                                         /*
1854                                          * The number of exchange to be offload
1855                                          * was tweaked or offload option was
1856                                          * flipped
1857                                          */
1858                                         action = MODE_CHANGE_ACCEPT;
1859                                 } else {
1860                                         action = MODE_CHANGE_NO_ACTION;
1861                                 }
1862                         } else {
1863                                 action = MODE_CHANGE_NO_ACTION;
1864                         }
1865                         break;
1866                 case QLA2XXX_INI_MODE_EXCLUSIVE:
1867                         if (qla_tgt_mode_enabled(vha)) {
1868                                 if (NEED_EXCH_OFFLOAD(vha->u_ql2xexchoffld) !=
1869                                     vha->hw->flags.exchoffld_enabled)
1870                                         eo_toggle = 1;
1871                                 if (((vha->ql2xexchoffld !=
1872                                     vha->u_ql2xexchoffld) &&
1873                                     NEED_EXCH_OFFLOAD(vha->u_ql2xexchoffld)) ||
1874                                     eo_toggle) {
1875                                         /*
1876                                          * The number of exchange to be offload
1877                                          * was tweaked or offload option was
1878                                          * flipped
1879                                          */
1880                                         action = MODE_CHANGE_ACCEPT;
1881                                 } else {
1882                                         action = MODE_CHANGE_NO_ACTION;
1883                                 }
1884                         } else {
1885                                 action = MODE_CHANGE_ACCEPT;
1886                         }
1887                         break;
1888                 case QLA2XXX_INI_MODE_DUAL:
1889                         action = MODE_CHANGE_ACCEPT;
1890                         /* active_mode is target only, reset it to dual */
1891                         if (qla_tgt_mode_enabled(vha)) {
1892                                 set_mode = 1;
1893                                 action = MODE_CHANGE_ACCEPT;
1894                         } else {
1895                                 action = MODE_CHANGE_NO_ACTION;
1896                         }
1897                         break;
1898
1899                 case QLA2XXX_INI_MODE_ENABLED:
1900                         if (qla_tgt_mode_enabled(vha))
1901                                 action = TARGET_STILL_ACTIVE;
1902                         else {
1903                                 action = MODE_CHANGE_ACCEPT;
1904                                 set_mode = 1;
1905                         }
1906                         break;
1907                 }
1908                 break;
1909
1910         case QLA2XXX_INI_MODE_EXCLUSIVE:
1911                 switch (op) {
1912                 case QLA2XXX_INI_MODE_EXCLUSIVE:
1913                         if (qla_tgt_mode_enabled(vha)) {
1914                                 if (NEED_EXCH_OFFLOAD(vha->u_ql2xexchoffld) !=
1915                                     vha->hw->flags.exchoffld_enabled)
1916                                         eo_toggle = 1;
1917                                 if (((vha->ql2xexchoffld !=
1918                                     vha->u_ql2xexchoffld) &&
1919                                     NEED_EXCH_OFFLOAD(vha->u_ql2xexchoffld)) ||
1920                                     eo_toggle)
1921                                         /*
1922                                          * The number of exchange to be offload
1923                                          * was tweaked or offload option was
1924                                          * flipped
1925                                          */
1926                                         action = MODE_CHANGE_ACCEPT;
1927                                 else
1928                                         action = NO_ACTION;
1929                         } else
1930                                 action = NO_ACTION;
1931
1932                         break;
1933
1934                 case QLA2XXX_INI_MODE_DISABLED:
1935                         if (qla_tgt_mode_enabled(vha)) {
1936                                 if (NEED_EXCH_OFFLOAD(vha->u_ql2xexchoffld) !=
1937                                     vha->hw->flags.exchoffld_enabled)
1938                                         eo_toggle = 1;
1939                                 if (((vha->ql2xexchoffld !=
1940                                       vha->u_ql2xexchoffld) &&
1941                                     NEED_EXCH_OFFLOAD(vha->u_ql2xexchoffld)) ||
1942                                     eo_toggle)
1943                                         action = MODE_CHANGE_ACCEPT;
1944                                 else
1945                                         action = MODE_CHANGE_NO_ACTION;
1946                         } else
1947                                 action = MODE_CHANGE_NO_ACTION;
1948                         break;
1949
1950                 case QLA2XXX_INI_MODE_DUAL: /* exclusive -> dual */
1951                         if (qla_tgt_mode_enabled(vha)) {
1952                                 action = MODE_CHANGE_ACCEPT;
1953                                 set_mode = 1;
1954                         } else
1955                                 action = MODE_CHANGE_ACCEPT;
1956                         break;
1957
1958                 case QLA2XXX_INI_MODE_ENABLED:
1959                         if (qla_tgt_mode_enabled(vha))
1960                                 action = TARGET_STILL_ACTIVE;
1961                         else {
1962                                 if (vha->hw->flags.fw_started)
1963                                         action = MODE_CHANGE_NO_ACTION;
1964                                 else
1965                                         action = MODE_CHANGE_ACCEPT;
1966                         }
1967                         break;
1968                 }
1969                 break;
1970
1971         case QLA2XXX_INI_MODE_ENABLED:
1972                 switch (op) {
1973                 case QLA2XXX_INI_MODE_ENABLED:
1974                         if (NEED_EXCH_OFFLOAD(vha->u_ql2xiniexchg) !=
1975                             vha->hw->flags.exchoffld_enabled)
1976                                 eo_toggle = 1;
1977                         if (((vha->ql2xiniexchg != vha->u_ql2xiniexchg) &&
1978                                 NEED_EXCH_OFFLOAD(vha->u_ql2xiniexchg)) ||
1979                             eo_toggle)
1980                                 action = MODE_CHANGE_ACCEPT;
1981                         else
1982                                 action = NO_ACTION;
1983                         break;
1984                 case QLA2XXX_INI_MODE_DUAL:
1985                 case QLA2XXX_INI_MODE_DISABLED:
1986                         action = MODE_CHANGE_ACCEPT;
1987                         break;
1988                 default:
1989                         action = MODE_CHANGE_NO_ACTION;
1990                         break;
1991                 }
1992                 break;
1993
1994         case QLA2XXX_INI_MODE_DUAL:
1995                 switch (op) {
1996                 case QLA2XXX_INI_MODE_DUAL:
1997                         if (qla_tgt_mode_enabled(vha) ||
1998                             qla_dual_mode_enabled(vha)) {
1999                                 if (NEED_EXCH_OFFLOAD(vha->u_ql2xexchoffld +
2000                                         vha->u_ql2xiniexchg) !=
2001                                     vha->hw->flags.exchoffld_enabled)
2002                                         eo_toggle = 1;
2003
2004                                 if ((((vha->ql2xexchoffld +
2005                                        vha->ql2xiniexchg) !=
2006                                     (vha->u_ql2xiniexchg +
2007                                      vha->u_ql2xexchoffld)) &&
2008                                     NEED_EXCH_OFFLOAD(vha->u_ql2xiniexchg +
2009                                         vha->u_ql2xexchoffld)) || eo_toggle)
2010                                         action = MODE_CHANGE_ACCEPT;
2011                                 else
2012                                         action = NO_ACTION;
2013                         } else {
2014                                 if (NEED_EXCH_OFFLOAD(vha->u_ql2xexchoffld +
2015                                         vha->u_ql2xiniexchg) !=
2016                                     vha->hw->flags.exchoffld_enabled)
2017                                         eo_toggle = 1;
2018
2019                                 if ((((vha->ql2xexchoffld + vha->ql2xiniexchg)
2020                                     != (vha->u_ql2xiniexchg +
2021                                         vha->u_ql2xexchoffld)) &&
2022                                     NEED_EXCH_OFFLOAD(vha->u_ql2xiniexchg +
2023                                         vha->u_ql2xexchoffld)) || eo_toggle)
2024                                         action = MODE_CHANGE_NO_ACTION;
2025                                 else
2026                                         action = NO_ACTION;
2027                         }
2028                         break;
2029
2030                 case QLA2XXX_INI_MODE_DISABLED:
2031                         if (qla_tgt_mode_enabled(vha) ||
2032                             qla_dual_mode_enabled(vha)) {
2033                                 /* turning off initiator mode */
2034                                 set_mode = 1;
2035                                 action = MODE_CHANGE_ACCEPT;
2036                         } else {
2037                                 action = MODE_CHANGE_NO_ACTION;
2038                         }
2039                         break;
2040
2041                 case QLA2XXX_INI_MODE_EXCLUSIVE:
2042                         if (qla_tgt_mode_enabled(vha) ||
2043                             qla_dual_mode_enabled(vha)) {
2044                                 set_mode = 1;
2045                                 action = MODE_CHANGE_ACCEPT;
2046                         } else {
2047                                 action = MODE_CHANGE_ACCEPT;
2048                         }
2049                         break;
2050
2051                 case QLA2XXX_INI_MODE_ENABLED:
2052                         if (qla_tgt_mode_enabled(vha) ||
2053                             qla_dual_mode_enabled(vha)) {
2054                                 action = TARGET_STILL_ACTIVE;
2055                         } else {
2056                                 action = MODE_CHANGE_ACCEPT;
2057                         }
2058                 }
2059                 break;
2060         }
2061
2062         switch (action) {
2063         case MODE_CHANGE_ACCEPT:
2064                 ql_log(ql_log_warn, vha, 0xffff,
2065                     "Mode change accepted. From %s to %s, Tgt exchg %d|%d. ini exchg %d|%d\n",
2066                     mode_to_str[vha->qlini_mode], mode_to_str[op],
2067                     vha->ql2xexchoffld, vha->u_ql2xexchoffld,
2068                     vha->ql2xiniexchg, vha->u_ql2xiniexchg);
2069
2070                 vha->qlini_mode = op;
2071                 vha->ql2xexchoffld = vha->u_ql2xexchoffld;
2072                 vha->ql2xiniexchg = vha->u_ql2xiniexchg;
2073                 if (set_mode)
2074                         qlt_set_mode(vha);
2075                 vha->flags.online = 1;
2076                 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
2077                 break;
2078
2079         case MODE_CHANGE_NO_ACTION:
2080                 ql_log(ql_log_warn, vha, 0xffff,
2081                     "Mode is set. No action taken. From %s to %s, Tgt exchg %d|%d. ini exchg %d|%d\n",
2082                     mode_to_str[vha->qlini_mode], mode_to_str[op],
2083                     vha->ql2xexchoffld, vha->u_ql2xexchoffld,
2084                     vha->ql2xiniexchg, vha->u_ql2xiniexchg);
2085                 vha->qlini_mode = op;
2086                 vha->ql2xexchoffld = vha->u_ql2xexchoffld;
2087                 vha->ql2xiniexchg = vha->u_ql2xiniexchg;
2088                 break;
2089
2090         case TARGET_STILL_ACTIVE:
2091                 ql_log(ql_log_warn, vha, 0xffff,
2092                     "Target Mode is active. Unable to change Mode.\n");
2093                 break;
2094
2095         case NO_ACTION:
2096         default:
2097                 ql_log(ql_log_warn, vha, 0xffff,
2098                     "Mode unchange. No action taken. %d|%d pct %d|%d.\n",
2099                     vha->qlini_mode, op,
2100                     vha->ql2xexchoffld, vha->u_ql2xexchoffld);
2101                 break;
2102         }
2103
2104         return rc;
2105 }
2106
2107 static ssize_t
2108 qlini_mode_store(struct device *dev, struct device_attribute *attr,
2109     const char *buf, size_t count)
2110 {
2111         scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
2112         int ini;
2113
2114         if (!buf)
2115                 return -EINVAL;
2116
2117         if (strncasecmp(QLA2XXX_INI_MODE_STR_EXCLUSIVE, buf,
2118                 strlen(QLA2XXX_INI_MODE_STR_EXCLUSIVE)) == 0)
2119                 ini = QLA2XXX_INI_MODE_EXCLUSIVE;
2120         else if (strncasecmp(QLA2XXX_INI_MODE_STR_DISABLED, buf,
2121                 strlen(QLA2XXX_INI_MODE_STR_DISABLED)) == 0)
2122                 ini = QLA2XXX_INI_MODE_DISABLED;
2123         else if (strncasecmp(QLA2XXX_INI_MODE_STR_ENABLED, buf,
2124                   strlen(QLA2XXX_INI_MODE_STR_ENABLED)) == 0)
2125                 ini = QLA2XXX_INI_MODE_ENABLED;
2126         else if (strncasecmp(QLA2XXX_INI_MODE_STR_DUAL, buf,
2127                 strlen(QLA2XXX_INI_MODE_STR_DUAL)) == 0)
2128                 ini = QLA2XXX_INI_MODE_DUAL;
2129         else
2130                 return -EINVAL;
2131
2132         qla_set_ini_mode(vha, ini);
2133         return strlen(buf);
2134 }
2135
2136 static ssize_t
2137 ql2xexchoffld_show(struct device *dev, struct device_attribute *attr,
2138     char *buf)
2139 {
2140         scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
2141         int len = 0;
2142
2143         len += scnprintf(buf + len, PAGE_SIZE-len,
2144                 "target exchange: new %d : current: %d\n\n",
2145                 vha->u_ql2xexchoffld, vha->ql2xexchoffld);
2146
2147         len += scnprintf(buf + len, PAGE_SIZE-len,
2148             "Please (re)set operating mode via \"/sys/class/scsi_host/host%ld/qlini_mode\" to load new setting.\n",
2149             vha->host_no);
2150
2151         return len;
2152 }
2153
2154 static ssize_t
2155 ql2xexchoffld_store(struct device *dev, struct device_attribute *attr,
2156     const char *buf, size_t count)
2157 {
2158         scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
2159         int val = 0;
2160
2161         if (sscanf(buf, "%d", &val) != 1)
2162                 return -EINVAL;
2163
2164         if (val > FW_MAX_EXCHANGES_CNT)
2165                 val = FW_MAX_EXCHANGES_CNT;
2166         else if (val < 0)
2167                 val = 0;
2168
2169         vha->u_ql2xexchoffld = val;
2170         return strlen(buf);
2171 }
2172
2173 static ssize_t
2174 ql2xiniexchg_show(struct device *dev, struct device_attribute *attr,
2175     char *buf)
2176 {
2177         scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
2178         int len = 0;
2179
2180         len += scnprintf(buf + len, PAGE_SIZE-len,
2181                 "target exchange: new %d : current: %d\n\n",
2182                 vha->u_ql2xiniexchg, vha->ql2xiniexchg);
2183
2184         len += scnprintf(buf + len, PAGE_SIZE-len,
2185             "Please (re)set operating mode via \"/sys/class/scsi_host/host%ld/qlini_mode\" to load new setting.\n",
2186             vha->host_no);
2187
2188         return len;
2189 }
2190
2191 static ssize_t
2192 ql2xiniexchg_store(struct device *dev, struct device_attribute *attr,
2193     const char *buf, size_t count)
2194 {
2195         scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
2196         int val = 0;
2197
2198         if (sscanf(buf, "%d", &val) != 1)
2199                 return -EINVAL;
2200
2201         if (val > FW_MAX_EXCHANGES_CNT)
2202                 val = FW_MAX_EXCHANGES_CNT;
2203         else if (val < 0)
2204                 val = 0;
2205
2206         vha->u_ql2xiniexchg = val;
2207         return strlen(buf);
2208 }
2209
2210 static ssize_t
2211 qla2x00_dif_bundle_statistics_show(struct device *dev,
2212     struct device_attribute *attr, char *buf)
2213 {
2214         scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
2215         struct qla_hw_data *ha = vha->hw;
2216
2217         return scnprintf(buf, PAGE_SIZE,
2218             "cross=%llu read=%llu write=%llu kalloc=%llu dma_alloc=%llu unusable=%u\n",
2219             ha->dif_bundle_crossed_pages, ha->dif_bundle_reads,
2220             ha->dif_bundle_writes, ha->dif_bundle_kallocs,
2221             ha->dif_bundle_dma_allocs, ha->pool.unusable.count);
2222 }
2223
2224 static ssize_t
2225 qla2x00_fw_attr_show(struct device *dev,
2226     struct device_attribute *attr, char *buf)
2227 {
2228         scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
2229         struct qla_hw_data *ha = vha->hw;
2230
2231         if (!IS_QLA27XX(ha) && !IS_QLA28XX(ha))
2232                 return scnprintf(buf, PAGE_SIZE, "\n");
2233
2234         return scnprintf(buf, PAGE_SIZE, "%llx\n",
2235             (uint64_t)ha->fw_attributes_ext[1] << 48 |
2236             (uint64_t)ha->fw_attributes_ext[0] << 32 |
2237             (uint64_t)ha->fw_attributes_h << 16 |
2238             (uint64_t)ha->fw_attributes);
2239 }
2240
2241 static ssize_t
2242 qla2x00_port_no_show(struct device *dev, struct device_attribute *attr,
2243     char *buf)
2244 {
2245         scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
2246
2247         return scnprintf(buf, PAGE_SIZE, "%u\n", vha->hw->port_no);
2248 }
2249
2250 static DEVICE_ATTR(driver_version, S_IRUGO, qla2x00_driver_version_show, NULL);
2251 static DEVICE_ATTR(fw_version, S_IRUGO, qla2x00_fw_version_show, NULL);
2252 static DEVICE_ATTR(serial_num, S_IRUGO, qla2x00_serial_num_show, NULL);
2253 static DEVICE_ATTR(isp_name, S_IRUGO, qla2x00_isp_name_show, NULL);
2254 static DEVICE_ATTR(isp_id, S_IRUGO, qla2x00_isp_id_show, NULL);
2255 static DEVICE_ATTR(model_name, S_IRUGO, qla2x00_model_name_show, NULL);
2256 static DEVICE_ATTR(model_desc, S_IRUGO, qla2x00_model_desc_show, NULL);
2257 static DEVICE_ATTR(pci_info, S_IRUGO, qla2x00_pci_info_show, NULL);
2258 static DEVICE_ATTR(link_state, S_IRUGO, qla2x00_link_state_show, NULL);
2259 static DEVICE_ATTR(zio, S_IRUGO | S_IWUSR, qla2x00_zio_show, qla2x00_zio_store);
2260 static DEVICE_ATTR(zio_timer, S_IRUGO | S_IWUSR, qla2x00_zio_timer_show,
2261                    qla2x00_zio_timer_store);
2262 static DEVICE_ATTR(beacon, S_IRUGO | S_IWUSR, qla2x00_beacon_show,
2263                    qla2x00_beacon_store);
2264 static DEVICE_ATTR(optrom_bios_version, S_IRUGO,
2265                    qla2x00_optrom_bios_version_show, NULL);
2266 static DEVICE_ATTR(optrom_efi_version, S_IRUGO,
2267                    qla2x00_optrom_efi_version_show, NULL);
2268 static DEVICE_ATTR(optrom_fcode_version, S_IRUGO,
2269                    qla2x00_optrom_fcode_version_show, NULL);
2270 static DEVICE_ATTR(optrom_fw_version, S_IRUGO, qla2x00_optrom_fw_version_show,
2271                    NULL);
2272 static DEVICE_ATTR(optrom_gold_fw_version, S_IRUGO,
2273     qla2x00_optrom_gold_fw_version_show, NULL);
2274 static DEVICE_ATTR(84xx_fw_version, S_IRUGO, qla24xx_84xx_fw_version_show,
2275                    NULL);
2276 static DEVICE_ATTR(total_isp_aborts, S_IRUGO, qla2x00_total_isp_aborts_show,
2277                    NULL);
2278 static DEVICE_ATTR(serdes_version, 0444, qla2x00_serdes_version_show, NULL);
2279 static DEVICE_ATTR(mpi_version, S_IRUGO, qla2x00_mpi_version_show, NULL);
2280 static DEVICE_ATTR(phy_version, S_IRUGO, qla2x00_phy_version_show, NULL);
2281 static DEVICE_ATTR(flash_block_size, S_IRUGO, qla2x00_flash_block_size_show,
2282                    NULL);
2283 static DEVICE_ATTR(vlan_id, S_IRUGO, qla2x00_vlan_id_show, NULL);
2284 static DEVICE_ATTR(vn_port_mac_address, S_IRUGO,
2285                    qla2x00_vn_port_mac_address_show, NULL);
2286 static DEVICE_ATTR(fabric_param, S_IRUGO, qla2x00_fabric_param_show, NULL);
2287 static DEVICE_ATTR(fw_state, S_IRUGO, qla2x00_fw_state_show, NULL);
2288 static DEVICE_ATTR(thermal_temp, S_IRUGO, qla2x00_thermal_temp_show, NULL);
2289 static DEVICE_ATTR(diag_requests, S_IRUGO, qla2x00_diag_requests_show, NULL);
2290 static DEVICE_ATTR(diag_megabytes, S_IRUGO, qla2x00_diag_megabytes_show, NULL);
2291 static DEVICE_ATTR(fw_dump_size, S_IRUGO, qla2x00_fw_dump_size_show, NULL);
2292 static DEVICE_ATTR(allow_cna_fw_dump, S_IRUGO | S_IWUSR,
2293                    qla2x00_allow_cna_fw_dump_show,
2294                    qla2x00_allow_cna_fw_dump_store);
2295 static DEVICE_ATTR(pep_version, S_IRUGO, qla2x00_pep_version_show, NULL);
2296 static DEVICE_ATTR(min_supported_speed, 0444,
2297                    qla2x00_min_supported_speed_show, NULL);
2298 static DEVICE_ATTR(max_supported_speed, 0444,
2299                    qla2x00_max_supported_speed_show, NULL);
2300 static DEVICE_ATTR(zio_threshold, 0644,
2301     qla_zio_threshold_show,
2302     qla_zio_threshold_store);
2303 static DEVICE_ATTR_RW(qlini_mode);
2304 static DEVICE_ATTR_RW(ql2xexchoffld);
2305 static DEVICE_ATTR_RW(ql2xiniexchg);
2306 static DEVICE_ATTR(dif_bundle_statistics, 0444,
2307     qla2x00_dif_bundle_statistics_show, NULL);
2308 static DEVICE_ATTR(port_speed, 0644, qla2x00_port_speed_show,
2309     qla2x00_port_speed_store);
2310 static DEVICE_ATTR(port_no, 0444, qla2x00_port_no_show, NULL);
2311 static DEVICE_ATTR(fw_attr, 0444, qla2x00_fw_attr_show, NULL);
2312
2313
2314 struct device_attribute *qla2x00_host_attrs[] = {
2315         &dev_attr_driver_version,
2316         &dev_attr_fw_version,
2317         &dev_attr_serial_num,
2318         &dev_attr_isp_name,
2319         &dev_attr_isp_id,
2320         &dev_attr_model_name,
2321         &dev_attr_model_desc,
2322         &dev_attr_pci_info,
2323         &dev_attr_link_state,
2324         &dev_attr_zio,
2325         &dev_attr_zio_timer,
2326         &dev_attr_beacon,
2327         &dev_attr_optrom_bios_version,
2328         &dev_attr_optrom_efi_version,
2329         &dev_attr_optrom_fcode_version,
2330         &dev_attr_optrom_fw_version,
2331         &dev_attr_84xx_fw_version,
2332         &dev_attr_total_isp_aborts,
2333         &dev_attr_serdes_version,
2334         &dev_attr_mpi_version,
2335         &dev_attr_phy_version,
2336         &dev_attr_flash_block_size,
2337         &dev_attr_vlan_id,
2338         &dev_attr_vn_port_mac_address,
2339         &dev_attr_fabric_param,
2340         &dev_attr_fw_state,
2341         &dev_attr_optrom_gold_fw_version,
2342         &dev_attr_thermal_temp,
2343         &dev_attr_diag_requests,
2344         &dev_attr_diag_megabytes,
2345         &dev_attr_fw_dump_size,
2346         &dev_attr_allow_cna_fw_dump,
2347         &dev_attr_pep_version,
2348         &dev_attr_min_supported_speed,
2349         &dev_attr_max_supported_speed,
2350         &dev_attr_zio_threshold,
2351         &dev_attr_dif_bundle_statistics,
2352         &dev_attr_port_speed,
2353         &dev_attr_port_no,
2354         &dev_attr_fw_attr,
2355         NULL, /* reserve for qlini_mode */
2356         NULL, /* reserve for ql2xiniexchg */
2357         NULL, /* reserve for ql2xexchoffld */
2358         NULL,
2359 };
2360
2361 void qla_insert_tgt_attrs(void)
2362 {
2363         struct device_attribute **attr;
2364
2365         /* advance to empty slot */
2366         for (attr = &qla2x00_host_attrs[0]; *attr; ++attr)
2367                 continue;
2368
2369         *attr = &dev_attr_qlini_mode;
2370         attr++;
2371         *attr = &dev_attr_ql2xiniexchg;
2372         attr++;
2373         *attr = &dev_attr_ql2xexchoffld;
2374 }
2375
2376 /* Host attributes. */
2377
2378 static void
2379 qla2x00_get_host_port_id(struct Scsi_Host *shost)
2380 {
2381         scsi_qla_host_t *vha = shost_priv(shost);
2382
2383         fc_host_port_id(shost) = vha->d_id.b.domain << 16 |
2384             vha->d_id.b.area << 8 | vha->d_id.b.al_pa;
2385 }
2386
2387 static void
2388 qla2x00_get_host_speed(struct Scsi_Host *shost)
2389 {
2390         scsi_qla_host_t *vha = shost_priv(shost);
2391         u32 speed;
2392
2393         if (IS_QLAFX00(vha->hw)) {
2394                 qlafx00_get_host_speed(shost);
2395                 return;
2396         }
2397
2398         switch (vha->hw->link_data_rate) {
2399         case PORT_SPEED_1GB:
2400                 speed = FC_PORTSPEED_1GBIT;
2401                 break;
2402         case PORT_SPEED_2GB:
2403                 speed = FC_PORTSPEED_2GBIT;
2404                 break;
2405         case PORT_SPEED_4GB:
2406                 speed = FC_PORTSPEED_4GBIT;
2407                 break;
2408         case PORT_SPEED_8GB:
2409                 speed = FC_PORTSPEED_8GBIT;
2410                 break;
2411         case PORT_SPEED_10GB:
2412                 speed = FC_PORTSPEED_10GBIT;
2413                 break;
2414         case PORT_SPEED_16GB:
2415                 speed = FC_PORTSPEED_16GBIT;
2416                 break;
2417         case PORT_SPEED_32GB:
2418                 speed = FC_PORTSPEED_32GBIT;
2419                 break;
2420         case PORT_SPEED_64GB:
2421                 speed = FC_PORTSPEED_64GBIT;
2422                 break;
2423         default:
2424                 speed = FC_PORTSPEED_UNKNOWN;
2425                 break;
2426         }
2427
2428         fc_host_speed(shost) = speed;
2429 }
2430
2431 static void
2432 qla2x00_get_host_port_type(struct Scsi_Host *shost)
2433 {
2434         scsi_qla_host_t *vha = shost_priv(shost);
2435         uint32_t port_type;
2436
2437         if (vha->vp_idx) {
2438                 fc_host_port_type(shost) = FC_PORTTYPE_NPIV;
2439                 return;
2440         }
2441         switch (vha->hw->current_topology) {
2442         case ISP_CFG_NL:
2443                 port_type = FC_PORTTYPE_LPORT;
2444                 break;
2445         case ISP_CFG_FL:
2446                 port_type = FC_PORTTYPE_NLPORT;
2447                 break;
2448         case ISP_CFG_N:
2449                 port_type = FC_PORTTYPE_PTP;
2450                 break;
2451         case ISP_CFG_F:
2452                 port_type = FC_PORTTYPE_NPORT;
2453                 break;
2454         default:
2455                 port_type = FC_PORTTYPE_UNKNOWN;
2456                 break;
2457         }
2458
2459         fc_host_port_type(shost) = port_type;
2460 }
2461
2462 static void
2463 qla2x00_get_starget_node_name(struct scsi_target *starget)
2464 {
2465         struct Scsi_Host *host = dev_to_shost(starget->dev.parent);
2466         scsi_qla_host_t *vha = shost_priv(host);
2467         fc_port_t *fcport;
2468         u64 node_name = 0;
2469
2470         list_for_each_entry(fcport, &vha->vp_fcports, list) {
2471                 if (fcport->rport &&
2472                     starget->id == fcport->rport->scsi_target_id) {
2473                         node_name = wwn_to_u64(fcport->node_name);
2474                         break;
2475                 }
2476         }
2477
2478         fc_starget_node_name(starget) = node_name;
2479 }
2480
2481 static void
2482 qla2x00_get_starget_port_name(struct scsi_target *starget)
2483 {
2484         struct Scsi_Host *host = dev_to_shost(starget->dev.parent);
2485         scsi_qla_host_t *vha = shost_priv(host);
2486         fc_port_t *fcport;
2487         u64 port_name = 0;
2488
2489         list_for_each_entry(fcport, &vha->vp_fcports, list) {
2490                 if (fcport->rport &&
2491                     starget->id == fcport->rport->scsi_target_id) {
2492                         port_name = wwn_to_u64(fcport->port_name);
2493                         break;
2494                 }
2495         }
2496
2497         fc_starget_port_name(starget) = port_name;
2498 }
2499
2500 static void
2501 qla2x00_get_starget_port_id(struct scsi_target *starget)
2502 {
2503         struct Scsi_Host *host = dev_to_shost(starget->dev.parent);
2504         scsi_qla_host_t *vha = shost_priv(host);
2505         fc_port_t *fcport;
2506         uint32_t port_id = ~0U;
2507
2508         list_for_each_entry(fcport, &vha->vp_fcports, list) {
2509                 if (fcport->rport &&
2510                     starget->id == fcport->rport->scsi_target_id) {
2511                         port_id = fcport->d_id.b.domain << 16 |
2512                             fcport->d_id.b.area << 8 | fcport->d_id.b.al_pa;
2513                         break;
2514                 }
2515         }
2516
2517         fc_starget_port_id(starget) = port_id;
2518 }
2519
2520 static inline void
2521 qla2x00_set_rport_loss_tmo(struct fc_rport *rport, uint32_t timeout)
2522 {
2523         rport->dev_loss_tmo = timeout ? timeout : 1;
2524 }
2525
2526 static void
2527 qla2x00_dev_loss_tmo_callbk(struct fc_rport *rport)
2528 {
2529         struct Scsi_Host *host = rport_to_shost(rport);
2530         fc_port_t *fcport = *(fc_port_t **)rport->dd_data;
2531         unsigned long flags;
2532
2533         if (!fcport)
2534                 return;
2535
2536         /* Now that the rport has been deleted, set the fcport state to
2537            FCS_DEVICE_DEAD */
2538         qla2x00_set_fcport_state(fcport, FCS_DEVICE_DEAD);
2539
2540         /*
2541          * Transport has effectively 'deleted' the rport, clear
2542          * all local references.
2543          */
2544         spin_lock_irqsave(host->host_lock, flags);
2545         fcport->rport = fcport->drport = NULL;
2546         *((fc_port_t **)rport->dd_data) = NULL;
2547         spin_unlock_irqrestore(host->host_lock, flags);
2548
2549         if (test_bit(ABORT_ISP_ACTIVE, &fcport->vha->dpc_flags))
2550                 return;
2551
2552         if (unlikely(pci_channel_offline(fcport->vha->hw->pdev))) {
2553                 qla2x00_abort_all_cmds(fcport->vha, DID_NO_CONNECT << 16);
2554                 return;
2555         }
2556 }
2557
2558 static void
2559 qla2x00_terminate_rport_io(struct fc_rport *rport)
2560 {
2561         fc_port_t *fcport = *(fc_port_t **)rport->dd_data;
2562
2563         if (!fcport)
2564                 return;
2565
2566         if (test_bit(UNLOADING, &fcport->vha->dpc_flags))
2567                 return;
2568
2569         if (test_bit(ABORT_ISP_ACTIVE, &fcport->vha->dpc_flags))
2570                 return;
2571
2572         if (unlikely(pci_channel_offline(fcport->vha->hw->pdev))) {
2573                 qla2x00_abort_all_cmds(fcport->vha, DID_NO_CONNECT << 16);
2574                 return;
2575         }
2576         /*
2577          * At this point all fcport's software-states are cleared.  Perform any
2578          * final cleanup of firmware resources (PCBs and XCBs).
2579          */
2580         if (fcport->loop_id != FC_NO_LOOP_ID) {
2581                 if (IS_FWI2_CAPABLE(fcport->vha->hw))
2582                         fcport->vha->hw->isp_ops->fabric_logout(fcport->vha,
2583                             fcport->loop_id, fcport->d_id.b.domain,
2584                             fcport->d_id.b.area, fcport->d_id.b.al_pa);
2585                 else
2586                         qla2x00_port_logout(fcport->vha, fcport);
2587         }
2588 }
2589
2590 static int
2591 qla2x00_issue_lip(struct Scsi_Host *shost)
2592 {
2593         scsi_qla_host_t *vha = shost_priv(shost);
2594
2595         if (IS_QLAFX00(vha->hw))
2596                 return 0;
2597
2598         qla2x00_loop_reset(vha);
2599         return 0;
2600 }
2601
2602 static struct fc_host_statistics *
2603 qla2x00_get_fc_host_stats(struct Scsi_Host *shost)
2604 {
2605         scsi_qla_host_t *vha = shost_priv(shost);
2606         struct qla_hw_data *ha = vha->hw;
2607         struct scsi_qla_host *base_vha = pci_get_drvdata(ha->pdev);
2608         int rval;
2609         struct link_statistics *stats;
2610         dma_addr_t stats_dma;
2611         struct fc_host_statistics *p = &vha->fc_host_stat;
2612
2613         memset(p, -1, sizeof(*p));
2614
2615         if (IS_QLAFX00(vha->hw))
2616                 goto done;
2617
2618         if (test_bit(UNLOADING, &vha->dpc_flags))
2619                 goto done;
2620
2621         if (unlikely(pci_channel_offline(ha->pdev)))
2622                 goto done;
2623
2624         if (qla2x00_chip_is_down(vha))
2625                 goto done;
2626
2627         stats = dma_alloc_coherent(&ha->pdev->dev, sizeof(*stats), &stats_dma,
2628                                    GFP_KERNEL);
2629         if (!stats) {
2630                 ql_log(ql_log_warn, vha, 0x707d,
2631                     "Failed to allocate memory for stats.\n");
2632                 goto done;
2633         }
2634
2635         rval = QLA_FUNCTION_FAILED;
2636         if (IS_FWI2_CAPABLE(ha)) {
2637                 rval = qla24xx_get_isp_stats(base_vha, stats, stats_dma, 0);
2638         } else if (atomic_read(&base_vha->loop_state) == LOOP_READY &&
2639             !ha->dpc_active) {
2640                 /* Must be in a 'READY' state for statistics retrieval. */
2641                 rval = qla2x00_get_link_status(base_vha, base_vha->loop_id,
2642                                                 stats, stats_dma);
2643         }
2644
2645         if (rval != QLA_SUCCESS)
2646                 goto done_free;
2647
2648         p->link_failure_count = stats->link_fail_cnt;
2649         p->loss_of_sync_count = stats->loss_sync_cnt;
2650         p->loss_of_signal_count = stats->loss_sig_cnt;
2651         p->prim_seq_protocol_err_count = stats->prim_seq_err_cnt;
2652         p->invalid_tx_word_count = stats->inval_xmit_word_cnt;
2653         p->invalid_crc_count = stats->inval_crc_cnt;
2654         if (IS_FWI2_CAPABLE(ha)) {
2655                 p->lip_count = stats->lip_cnt;
2656                 p->tx_frames = stats->tx_frames;
2657                 p->rx_frames = stats->rx_frames;
2658                 p->dumped_frames = stats->discarded_frames;
2659                 p->nos_count = stats->nos_rcvd;
2660                 p->error_frames =
2661                         stats->dropped_frames + stats->discarded_frames;
2662                 p->rx_words = vha->qla_stats.input_bytes;
2663                 p->tx_words = vha->qla_stats.output_bytes;
2664         }
2665         p->fcp_control_requests = vha->qla_stats.control_requests;
2666         p->fcp_input_requests = vha->qla_stats.input_requests;
2667         p->fcp_output_requests = vha->qla_stats.output_requests;
2668         p->fcp_input_megabytes = vha->qla_stats.input_bytes >> 20;
2669         p->fcp_output_megabytes = vha->qla_stats.output_bytes >> 20;
2670         p->seconds_since_last_reset =
2671                 get_jiffies_64() - vha->qla_stats.jiffies_at_last_reset;
2672         do_div(p->seconds_since_last_reset, HZ);
2673
2674 done_free:
2675         dma_free_coherent(&ha->pdev->dev, sizeof(struct link_statistics),
2676             stats, stats_dma);
2677 done:
2678         return p;
2679 }
2680
2681 static void
2682 qla2x00_reset_host_stats(struct Scsi_Host *shost)
2683 {
2684         scsi_qla_host_t *vha = shost_priv(shost);
2685         struct qla_hw_data *ha = vha->hw;
2686         struct scsi_qla_host *base_vha = pci_get_drvdata(ha->pdev);
2687         struct link_statistics *stats;
2688         dma_addr_t stats_dma;
2689
2690         memset(&vha->qla_stats, 0, sizeof(vha->qla_stats));
2691         memset(&vha->fc_host_stat, 0, sizeof(vha->fc_host_stat));
2692
2693         vha->qla_stats.jiffies_at_last_reset = get_jiffies_64();
2694
2695         if (IS_FWI2_CAPABLE(ha)) {
2696                 stats = dma_alloc_coherent(&ha->pdev->dev,
2697                     sizeof(*stats), &stats_dma, GFP_KERNEL);
2698                 if (!stats) {
2699                         ql_log(ql_log_warn, vha, 0x70d7,
2700                             "Failed to allocate memory for stats.\n");
2701                         return;
2702                 }
2703
2704                 /* reset firmware statistics */
2705                 qla24xx_get_isp_stats(base_vha, stats, stats_dma, BIT_0);
2706
2707                 dma_free_coherent(&ha->pdev->dev, sizeof(*stats),
2708                     stats, stats_dma);
2709         }
2710 }
2711
2712 static void
2713 qla2x00_get_host_symbolic_name(struct Scsi_Host *shost)
2714 {
2715         scsi_qla_host_t *vha = shost_priv(shost);
2716
2717         qla2x00_get_sym_node_name(vha, fc_host_symbolic_name(shost),
2718             sizeof(fc_host_symbolic_name(shost)));
2719 }
2720
2721 static void
2722 qla2x00_set_host_system_hostname(struct Scsi_Host *shost)
2723 {
2724         scsi_qla_host_t *vha = shost_priv(shost);
2725
2726         set_bit(REGISTER_FDMI_NEEDED, &vha->dpc_flags);
2727 }
2728
2729 static void
2730 qla2x00_get_host_fabric_name(struct Scsi_Host *shost)
2731 {
2732         scsi_qla_host_t *vha = shost_priv(shost);
2733         static const uint8_t node_name[WWN_SIZE] = {
2734                 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
2735         };
2736         u64 fabric_name = wwn_to_u64(node_name);
2737
2738         if (vha->device_flags & SWITCH_FOUND)
2739                 fabric_name = wwn_to_u64(vha->fabric_node_name);
2740
2741         fc_host_fabric_name(shost) = fabric_name;
2742 }
2743
2744 static void
2745 qla2x00_get_host_port_state(struct Scsi_Host *shost)
2746 {
2747         scsi_qla_host_t *vha = shost_priv(shost);
2748         struct scsi_qla_host *base_vha = pci_get_drvdata(vha->hw->pdev);
2749
2750         if (!base_vha->flags.online) {
2751                 fc_host_port_state(shost) = FC_PORTSTATE_OFFLINE;
2752                 return;
2753         }
2754
2755         switch (atomic_read(&base_vha->loop_state)) {
2756         case LOOP_UPDATE:
2757                 fc_host_port_state(shost) = FC_PORTSTATE_DIAGNOSTICS;
2758                 break;
2759         case LOOP_DOWN:
2760                 if (test_bit(LOOP_RESYNC_NEEDED, &base_vha->dpc_flags))
2761                         fc_host_port_state(shost) = FC_PORTSTATE_DIAGNOSTICS;
2762                 else
2763                         fc_host_port_state(shost) = FC_PORTSTATE_LINKDOWN;
2764                 break;
2765         case LOOP_DEAD:
2766                 fc_host_port_state(shost) = FC_PORTSTATE_LINKDOWN;
2767                 break;
2768         case LOOP_READY:
2769                 fc_host_port_state(shost) = FC_PORTSTATE_ONLINE;
2770                 break;
2771         default:
2772                 fc_host_port_state(shost) = FC_PORTSTATE_UNKNOWN;
2773                 break;
2774         }
2775 }
2776
2777 static int
2778 qla24xx_vport_create(struct fc_vport *fc_vport, bool disable)
2779 {
2780         int     ret = 0;
2781         uint8_t qos = 0;
2782         scsi_qla_host_t *base_vha = shost_priv(fc_vport->shost);
2783         scsi_qla_host_t *vha = NULL;
2784         struct qla_hw_data *ha = base_vha->hw;
2785         int     cnt;
2786         struct req_que *req = ha->req_q_map[0];
2787         struct qla_qpair *qpair;
2788
2789         ret = qla24xx_vport_create_req_sanity_check(fc_vport);
2790         if (ret) {
2791                 ql_log(ql_log_warn, vha, 0x707e,
2792                     "Vport sanity check failed, status %x\n", ret);
2793                 return (ret);
2794         }
2795
2796         vha = qla24xx_create_vhost(fc_vport);
2797         if (vha == NULL) {
2798                 ql_log(ql_log_warn, vha, 0x707f, "Vport create host failed.\n");
2799                 return FC_VPORT_FAILED;
2800         }
2801         if (disable) {
2802                 atomic_set(&vha->vp_state, VP_OFFLINE);
2803                 fc_vport_set_state(fc_vport, FC_VPORT_DISABLED);
2804         } else
2805                 atomic_set(&vha->vp_state, VP_FAILED);
2806
2807         /* ready to create vport */
2808         ql_log(ql_log_info, vha, 0x7080,
2809             "VP entry id %d assigned.\n", vha->vp_idx);
2810
2811         /* initialized vport states */
2812         atomic_set(&vha->loop_state, LOOP_DOWN);
2813         vha->vp_err_state = VP_ERR_PORTDWN;
2814         vha->vp_prev_err_state = VP_ERR_UNKWN;
2815         /* Check if physical ha port is Up */
2816         if (atomic_read(&base_vha->loop_state) == LOOP_DOWN ||
2817             atomic_read(&base_vha->loop_state) == LOOP_DEAD) {
2818                 /* Don't retry or attempt login of this virtual port */
2819                 ql_dbg(ql_dbg_user, vha, 0x7081,
2820                     "Vport loop state is not UP.\n");
2821                 atomic_set(&vha->loop_state, LOOP_DEAD);
2822                 if (!disable)
2823                         fc_vport_set_state(fc_vport, FC_VPORT_LINKDOWN);
2824         }
2825
2826         if (IS_T10_PI_CAPABLE(ha) && ql2xenabledif) {
2827                 if (ha->fw_attributes & BIT_4) {
2828                         int prot = 0, guard;
2829
2830                         vha->flags.difdix_supported = 1;
2831                         ql_dbg(ql_dbg_user, vha, 0x7082,
2832                             "Registered for DIF/DIX type 1 and 3 protection.\n");
2833                         if (ql2xenabledif == 1)
2834                                 prot = SHOST_DIX_TYPE0_PROTECTION;
2835                         scsi_host_set_prot(vha->host,
2836                             prot | SHOST_DIF_TYPE1_PROTECTION
2837                             | SHOST_DIF_TYPE2_PROTECTION
2838                             | SHOST_DIF_TYPE3_PROTECTION
2839                             | SHOST_DIX_TYPE1_PROTECTION
2840                             | SHOST_DIX_TYPE2_PROTECTION
2841                             | SHOST_DIX_TYPE3_PROTECTION);
2842
2843                         guard = SHOST_DIX_GUARD_CRC;
2844
2845                         if (IS_PI_IPGUARD_CAPABLE(ha) &&
2846                             (ql2xenabledif > 1 || IS_PI_DIFB_DIX0_CAPABLE(ha)))
2847                                 guard |= SHOST_DIX_GUARD_IP;
2848
2849                         scsi_host_set_guard(vha->host, guard);
2850                 } else
2851                         vha->flags.difdix_supported = 0;
2852         }
2853
2854         if (scsi_add_host_with_dma(vha->host, &fc_vport->dev,
2855                                    &ha->pdev->dev)) {
2856                 ql_dbg(ql_dbg_user, vha, 0x7083,
2857                     "scsi_add_host failure for VP[%d].\n", vha->vp_idx);
2858                 goto vport_create_failed_2;
2859         }
2860
2861         /* initialize attributes */
2862         fc_host_dev_loss_tmo(vha->host) = ha->port_down_retry_count;
2863         fc_host_node_name(vha->host) = wwn_to_u64(vha->node_name);
2864         fc_host_port_name(vha->host) = wwn_to_u64(vha->port_name);
2865         fc_host_supported_classes(vha->host) =
2866                 fc_host_supported_classes(base_vha->host);
2867         fc_host_supported_speeds(vha->host) =
2868                 fc_host_supported_speeds(base_vha->host);
2869
2870         qlt_vport_create(vha, ha);
2871         qla24xx_vport_disable(fc_vport, disable);
2872
2873         if (!ql2xmqsupport || !ha->npiv_info)
2874                 goto vport_queue;
2875
2876         /* Create a request queue in QoS mode for the vport */
2877         for (cnt = 0; cnt < ha->nvram_npiv_size; cnt++) {
2878                 if (memcmp(ha->npiv_info[cnt].port_name, vha->port_name, 8) == 0
2879                         && memcmp(ha->npiv_info[cnt].node_name, vha->node_name,
2880                                         8) == 0) {
2881                         qos = ha->npiv_info[cnt].q_qos;
2882                         break;
2883                 }
2884         }
2885
2886         if (qos) {
2887                 qpair = qla2xxx_create_qpair(vha, qos, vha->vp_idx, true);
2888                 if (!qpair)
2889                         ql_log(ql_log_warn, vha, 0x7084,
2890                             "Can't create qpair for VP[%d]\n",
2891                             vha->vp_idx);
2892                 else {
2893                         ql_dbg(ql_dbg_multiq, vha, 0xc001,
2894                             "Queue pair: %d Qos: %d) created for VP[%d]\n",
2895                             qpair->id, qos, vha->vp_idx);
2896                         ql_dbg(ql_dbg_user, vha, 0x7085,
2897                             "Queue Pair: %d Qos: %d) created for VP[%d]\n",
2898                             qpair->id, qos, vha->vp_idx);
2899                         req = qpair->req;
2900                         vha->qpair = qpair;
2901                 }
2902         }
2903
2904 vport_queue:
2905         vha->req = req;
2906         return 0;
2907
2908 vport_create_failed_2:
2909         qla24xx_disable_vp(vha);
2910         qla24xx_deallocate_vp_id(vha);
2911         scsi_host_put(vha->host);
2912         return FC_VPORT_FAILED;
2913 }
2914
2915 static int
2916 qla24xx_vport_delete(struct fc_vport *fc_vport)
2917 {
2918         scsi_qla_host_t *vha = fc_vport->dd_data;
2919         struct qla_hw_data *ha = vha->hw;
2920         uint16_t id = vha->vp_idx;
2921
2922         set_bit(VPORT_DELETE, &vha->dpc_flags);
2923
2924         while (test_bit(LOOP_RESYNC_ACTIVE, &vha->dpc_flags) ||
2925             test_bit(FCPORT_UPDATE_NEEDED, &vha->dpc_flags))
2926                 msleep(1000);
2927
2928         qla_nvme_delete(vha);
2929
2930         qla24xx_disable_vp(vha);
2931         qla2x00_wait_for_sess_deletion(vha);
2932
2933         vha->flags.delete_progress = 1;
2934
2935         qlt_remove_target(ha, vha);
2936
2937         fc_remove_host(vha->host);
2938
2939         scsi_remove_host(vha->host);
2940
2941         /* Allow timer to run to drain queued items, when removing vp */
2942         qla24xx_deallocate_vp_id(vha);
2943
2944         if (vha->timer_active) {
2945                 qla2x00_vp_stop_timer(vha);
2946                 ql_dbg(ql_dbg_user, vha, 0x7086,
2947                     "Timer for the VP[%d] has stopped\n", vha->vp_idx);
2948         }
2949
2950         qla2x00_free_fcports(vha);
2951
2952         mutex_lock(&ha->vport_lock);
2953         ha->cur_vport_count--;
2954         clear_bit(vha->vp_idx, ha->vp_idx_map);
2955         mutex_unlock(&ha->vport_lock);
2956
2957         dma_free_coherent(&ha->pdev->dev, vha->gnl.size, vha->gnl.l,
2958             vha->gnl.ldma);
2959
2960         vha->gnl.l = NULL;
2961
2962         vfree(vha->scan.l);
2963
2964         if (vha->qpair && vha->qpair->vp_idx == vha->vp_idx) {
2965                 if (qla2xxx_delete_qpair(vha, vha->qpair) != QLA_SUCCESS)
2966                         ql_log(ql_log_warn, vha, 0x7087,
2967                             "Queue Pair delete failed.\n");
2968         }
2969
2970         ql_log(ql_log_info, vha, 0x7088, "VP[%d] deleted.\n", id);
2971         scsi_host_put(vha->host);
2972         return 0;
2973 }
2974
2975 static int
2976 qla24xx_vport_disable(struct fc_vport *fc_vport, bool disable)
2977 {
2978         scsi_qla_host_t *vha = fc_vport->dd_data;
2979
2980         if (disable)
2981                 qla24xx_disable_vp(vha);
2982         else
2983                 qla24xx_enable_vp(vha);
2984
2985         return 0;
2986 }
2987
2988 struct fc_function_template qla2xxx_transport_functions = {
2989
2990         .show_host_node_name = 1,
2991         .show_host_port_name = 1,
2992         .show_host_supported_classes = 1,
2993         .show_host_supported_speeds = 1,
2994
2995         .get_host_port_id = qla2x00_get_host_port_id,
2996         .show_host_port_id = 1,
2997         .get_host_speed = qla2x00_get_host_speed,
2998         .show_host_speed = 1,
2999         .get_host_port_type = qla2x00_get_host_port_type,
3000         .show_host_port_type = 1,
3001         .get_host_symbolic_name = qla2x00_get_host_symbolic_name,
3002         .show_host_symbolic_name = 1,
3003         .set_host_system_hostname = qla2x00_set_host_system_hostname,
3004         .show_host_system_hostname = 1,
3005         .get_host_fabric_name = qla2x00_get_host_fabric_name,
3006         .show_host_fabric_name = 1,
3007         .get_host_port_state = qla2x00_get_host_port_state,
3008         .show_host_port_state = 1,
3009
3010         .dd_fcrport_size = sizeof(struct fc_port *),
3011         .show_rport_supported_classes = 1,
3012
3013         .get_starget_node_name = qla2x00_get_starget_node_name,
3014         .show_starget_node_name = 1,
3015         .get_starget_port_name = qla2x00_get_starget_port_name,
3016         .show_starget_port_name = 1,
3017         .get_starget_port_id  = qla2x00_get_starget_port_id,
3018         .show_starget_port_id = 1,
3019
3020         .set_rport_dev_loss_tmo = qla2x00_set_rport_loss_tmo,
3021         .show_rport_dev_loss_tmo = 1,
3022
3023         .issue_fc_host_lip = qla2x00_issue_lip,
3024         .dev_loss_tmo_callbk = qla2x00_dev_loss_tmo_callbk,
3025         .terminate_rport_io = qla2x00_terminate_rport_io,
3026         .get_fc_host_stats = qla2x00_get_fc_host_stats,
3027         .reset_fc_host_stats = qla2x00_reset_host_stats,
3028
3029         .vport_create = qla24xx_vport_create,
3030         .vport_disable = qla24xx_vport_disable,
3031         .vport_delete = qla24xx_vport_delete,
3032         .bsg_request = qla24xx_bsg_request,
3033         .bsg_timeout = qla24xx_bsg_timeout,
3034 };
3035
3036 struct fc_function_template qla2xxx_transport_vport_functions = {
3037
3038         .show_host_node_name = 1,
3039         .show_host_port_name = 1,
3040         .show_host_supported_classes = 1,
3041
3042         .get_host_port_id = qla2x00_get_host_port_id,
3043         .show_host_port_id = 1,
3044         .get_host_speed = qla2x00_get_host_speed,
3045         .show_host_speed = 1,
3046         .get_host_port_type = qla2x00_get_host_port_type,
3047         .show_host_port_type = 1,
3048         .get_host_symbolic_name = qla2x00_get_host_symbolic_name,
3049         .show_host_symbolic_name = 1,
3050         .set_host_system_hostname = qla2x00_set_host_system_hostname,
3051         .show_host_system_hostname = 1,
3052         .get_host_fabric_name = qla2x00_get_host_fabric_name,
3053         .show_host_fabric_name = 1,
3054         .get_host_port_state = qla2x00_get_host_port_state,
3055         .show_host_port_state = 1,
3056
3057         .dd_fcrport_size = sizeof(struct fc_port *),
3058         .show_rport_supported_classes = 1,
3059
3060         .get_starget_node_name = qla2x00_get_starget_node_name,
3061         .show_starget_node_name = 1,
3062         .get_starget_port_name = qla2x00_get_starget_port_name,
3063         .show_starget_port_name = 1,
3064         .get_starget_port_id  = qla2x00_get_starget_port_id,
3065         .show_starget_port_id = 1,
3066
3067         .set_rport_dev_loss_tmo = qla2x00_set_rport_loss_tmo,
3068         .show_rport_dev_loss_tmo = 1,
3069
3070         .issue_fc_host_lip = qla2x00_issue_lip,
3071         .dev_loss_tmo_callbk = qla2x00_dev_loss_tmo_callbk,
3072         .terminate_rport_io = qla2x00_terminate_rport_io,
3073         .get_fc_host_stats = qla2x00_get_fc_host_stats,
3074         .reset_fc_host_stats = qla2x00_reset_host_stats,
3075
3076         .bsg_request = qla24xx_bsg_request,
3077         .bsg_timeout = qla24xx_bsg_timeout,
3078 };
3079
3080 void
3081 qla2x00_init_host_attr(scsi_qla_host_t *vha)
3082 {
3083         struct qla_hw_data *ha = vha->hw;
3084         u32 speeds = FC_PORTSPEED_UNKNOWN;
3085
3086         fc_host_dev_loss_tmo(vha->host) = ha->port_down_retry_count;
3087         fc_host_node_name(vha->host) = wwn_to_u64(vha->node_name);
3088         fc_host_port_name(vha->host) = wwn_to_u64(vha->port_name);
3089         fc_host_supported_classes(vha->host) = ha->base_qpair->enable_class_2 ?
3090                         (FC_COS_CLASS2|FC_COS_CLASS3) : FC_COS_CLASS3;
3091         fc_host_max_npiv_vports(vha->host) = ha->max_npiv_vports;
3092         fc_host_npiv_vports_inuse(vha->host) = ha->cur_vport_count;
3093
3094         if (IS_CNA_CAPABLE(ha))
3095                 speeds = FC_PORTSPEED_10GBIT;
3096         else if (IS_QLA28XX(ha) || IS_QLA27XX(ha)) {
3097                 if (ha->max_supported_speed == 2) {
3098                         if (ha->min_supported_speed <= 6)
3099                                 speeds |= FC_PORTSPEED_64GBIT;
3100                 }
3101                 if (ha->max_supported_speed == 2 ||
3102                     ha->max_supported_speed == 1) {
3103                         if (ha->min_supported_speed <= 5)
3104                                 speeds |= FC_PORTSPEED_32GBIT;
3105                 }
3106                 if (ha->max_supported_speed == 2 ||
3107                     ha->max_supported_speed == 1 ||
3108                     ha->max_supported_speed == 0) {
3109                         if (ha->min_supported_speed <= 4)
3110                                 speeds |= FC_PORTSPEED_16GBIT;
3111                 }
3112                 if (ha->max_supported_speed == 1 ||
3113                     ha->max_supported_speed == 0) {
3114                         if (ha->min_supported_speed <= 3)
3115                                 speeds |= FC_PORTSPEED_8GBIT;
3116                 }
3117                 if (ha->max_supported_speed == 0) {
3118                         if (ha->min_supported_speed <= 2)
3119                                 speeds |= FC_PORTSPEED_4GBIT;
3120                 }
3121         } else if (IS_QLA2031(ha))
3122                 speeds = FC_PORTSPEED_16GBIT|FC_PORTSPEED_8GBIT|
3123                         FC_PORTSPEED_4GBIT;
3124         else if (IS_QLA25XX(ha) || IS_QLAFX00(ha))
3125                 speeds = FC_PORTSPEED_8GBIT|FC_PORTSPEED_4GBIT|
3126                         FC_PORTSPEED_2GBIT|FC_PORTSPEED_1GBIT;
3127         else if (IS_QLA24XX_TYPE(ha))
3128                 speeds = FC_PORTSPEED_4GBIT|FC_PORTSPEED_2GBIT|
3129                         FC_PORTSPEED_1GBIT;
3130         else if (IS_QLA23XX(ha))
3131                 speeds = FC_PORTSPEED_2GBIT|FC_PORTSPEED_1GBIT;
3132         else
3133                 speeds = FC_PORTSPEED_1GBIT;
3134
3135         fc_host_supported_speeds(vha->host) = speeds;
3136 }