drivers/scsi/qla2xxx/qla_attr.c

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