SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/scsi/qla2xxx/qla_attr.c

   1 /*
   2  * QLogic Fibre Channel HBA Driver
   3  * Copyright (c)  2003-2008 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/delay.h>
  12
  13 static int qla24xx_vport_disable(struct fc_vport *, bool);
  14
  15 /* SYSFS attributes --------------------------------------------------------- */
  16
  17 static ssize_t
  18 qla2x00_sysfs_read_fw_dump(struct kobject *kobj,
  19                            struct bin_attribute *bin_attr,
  20                            char *buf, loff_t off, size_t count)
  21 {
  22         struct scsi_qla_host *vha = shost_priv(dev_to_shost(container_of(kobj,
  23             struct device, kobj)));
  24         struct qla_hw_data *ha = vha->hw;
  25
  26         if (ha->fw_dump_reading == 0)
  27                 return 0;
  28
  29         return memory_read_from_buffer(buf, count, &off, ha->fw_dump,
  30                                         ha->fw_dump_len);
  31 }
  32
  33 static ssize_t
  34 qla2x00_sysfs_write_fw_dump(struct kobject *kobj,
  35                             struct bin_attribute *bin_attr,
  36                             char *buf, loff_t off, size_t count)
  37 {
  38         struct scsi_qla_host *vha = shost_priv(dev_to_shost(container_of(kobj,
  39             struct device, kobj)));
  40         struct qla_hw_data *ha = vha->hw;
  41         int reading;
  42
  43         if (off != 0)
  44                 return (0);
  45
  46         reading = simple_strtol(buf, NULL, 10);
  47         switch (reading) {
  48         case 0:
  49                 if (!ha->fw_dump_reading)
  50                         break;
  51
  52                 qla_printk(KERN_INFO, ha,
  53                     "Firmware dump cleared on (%ld).\n", vha->host_no);
  54
  55                 ha->fw_dump_reading = 0;
  56                 ha->fw_dumped = 0;
  57                 break;
  58         case 1:
  59                 if (ha->fw_dumped && !ha->fw_dump_reading) {
  60                         ha->fw_dump_reading = 1;
  61
  62                         qla_printk(KERN_INFO, ha,
  63                             "Raw firmware dump ready for read on (%ld).\n",
  64                             vha->host_no);
  65                 }
  66                 break;
  67         case 2:
  68                 qla2x00_alloc_fw_dump(vha);
  69                 break;
  70         case 3:
  71                 qla2x00_system_error(vha);
  72                 break;
  73         }
  74         return (count);
  75 }
  76
  77 static struct bin_attribute sysfs_fw_dump_attr = {
  78         .attr = {
  79                 .name = "fw_dump",
  80                 .mode = S_IRUSR | S_IWUSR,
  81         },
  82         .size = 0,
  83         .read = qla2x00_sysfs_read_fw_dump,
  84         .write = qla2x00_sysfs_write_fw_dump,
  85 };
  86
  87 static ssize_t
  88 qla2x00_sysfs_read_nvram(struct kobject *kobj,
  89                          struct bin_attribute *bin_attr,
  90                          char *buf, loff_t off, size_t count)
  91 {
  92         struct scsi_qla_host *vha = shost_priv(dev_to_shost(container_of(kobj,
  93             struct device, kobj)));
  94         struct qla_hw_data *ha = vha->hw;
  95
  96         if (!capable(CAP_SYS_ADMIN))
  97                 return 0;
  98
  99         /* Read NVRAM data from cache. */
 100         return memory_read_from_buffer(buf, count, &off, ha->nvram,
 101                                         ha->nvram_size);
 102 }
 103
 104 static ssize_t
 105 qla2x00_sysfs_write_nvram(struct kobject *kobj,
 106                           struct bin_attribute *bin_attr,
 107                           char *buf, loff_t off, size_t count)
 108 {
 109         struct scsi_qla_host *vha = shost_priv(dev_to_shost(container_of(kobj,
 110             struct device, kobj)));
 111         struct qla_hw_data *ha = vha->hw;
 112         uint16_t        cnt;
 113
 114         if (!capable(CAP_SYS_ADMIN) || off != 0 || count != ha->nvram_size ||
 115             !ha->isp_ops->write_nvram)
 116                 return 0;
 117
 118         /* Checksum NVRAM. */
 119         if (IS_FWI2_CAPABLE(ha)) {
 120                 uint32_t *iter;
 121                 uint32_t chksum;
 122
 123                 iter = (uint32_t *)buf;
 124                 chksum = 0;
 125                 for (cnt = 0; cnt < ((count >> 2) - 1); cnt++)
 126                         chksum += le32_to_cpu(*iter++);
 127                 chksum = ~chksum + 1;
 128                 *iter = cpu_to_le32(chksum);
 129         } else {
 130                 uint8_t *iter;
 131                 uint8_t chksum;
 132
 133                 iter = (uint8_t *)buf;
 134                 chksum = 0;
 135                 for (cnt = 0; cnt < count - 1; cnt++)
 136                         chksum += *iter++;
 137                 chksum = ~chksum + 1;
 138                 *iter = chksum;
 139         }
 140
 141         if (qla2x00_wait_for_hba_online(vha) != QLA_SUCCESS) {
 142                 qla_printk(KERN_WARNING, ha,
 143                     "HBA not online, failing NVRAM update.\n");
 144                 return -EAGAIN;
 145         }
 146
 147         /* Write NVRAM. */
 148         ha->isp_ops->write_nvram(vha, (uint8_t *)buf, ha->nvram_base, count);
 149         ha->isp_ops->read_nvram(vha, (uint8_t *)ha->nvram, ha->nvram_base,
 150             count);
 151
 152         /* NVRAM settings take effect immediately. */
 153         set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
 154         qla2xxx_wake_dpc(vha);
 155         qla2x00_wait_for_chip_reset(vha);
 156
 157         return (count);
 158 }
 159
 160 static struct bin_attribute sysfs_nvram_attr = {
 161         .attr = {
 162                 .name = "nvram",
 163                 .mode = S_IRUSR | S_IWUSR,
 164         },
 165         .size = 512,
 166         .read = qla2x00_sysfs_read_nvram,
 167         .write = qla2x00_sysfs_write_nvram,
 168 };
 169
 170 static ssize_t
 171 qla2x00_sysfs_read_optrom(struct kobject *kobj,
 172                           struct bin_attribute *bin_attr,
 173                           char *buf, loff_t off, size_t count)
 174 {
 175         struct scsi_qla_host *vha = shost_priv(dev_to_shost(container_of(kobj,
 176             struct device, kobj)));
 177         struct qla_hw_data *ha = vha->hw;
 178
 179         if (ha->optrom_state != QLA_SREADING)
 180                 return 0;
 181
 182         return memory_read_from_buffer(buf, count, &off, ha->optrom_buffer,
 183                                         ha->optrom_region_size);
 184 }
 185
 186 static ssize_t
 187 qla2x00_sysfs_write_optrom(struct kobject *kobj,
 188                            struct bin_attribute *bin_attr,
 189                            char *buf, loff_t off, size_t count)
 190 {
 191         struct scsi_qla_host *vha = shost_priv(dev_to_shost(container_of(kobj,
 192             struct device, kobj)));
 193         struct qla_hw_data *ha = vha->hw;
 194
 195         if (ha->optrom_state != QLA_SWRITING)
 196                 return -EINVAL;
 197         if (off > ha->optrom_region_size)
 198                 return -ERANGE;
 199         if (off + count > ha->optrom_region_size)
 200                 count = ha->optrom_region_size - off;
 201
 202         memcpy(&ha->optrom_buffer[off], buf, count);
 203
 204         return count;
 205 }
 206
 207 static struct bin_attribute sysfs_optrom_attr = {
 208         .attr = {
 209                 .name = "optrom",
 210                 .mode = S_IRUSR | S_IWUSR,
 211         },
 212         .size = 0,
 213         .read = qla2x00_sysfs_read_optrom,
 214         .write = qla2x00_sysfs_write_optrom,
 215 };
 216
 217 static ssize_t
 218 qla2x00_sysfs_write_optrom_ctl(struct kobject *kobj,
 219                                struct bin_attribute *bin_attr,
 220                                char *buf, loff_t off, size_t count)
 221 {
 222         struct scsi_qla_host *vha = shost_priv(dev_to_shost(container_of(kobj,
 223             struct device, kobj)));
 224         struct qla_hw_data *ha = vha->hw;
 225
 226         uint32_t start = 0;
 227         uint32_t size = ha->optrom_size;
 228         int val, valid;
 229
 230         if (off)
 231                 return 0;
 232
 233         if (sscanf(buf, "%d:%x:%x", &val, &start, &size) < 1)
 234                 return -EINVAL;
 235         if (start > ha->optrom_size)
 236                 return -EINVAL;
 237
 238         switch (val) {
 239         case 0:
 240                 if (ha->optrom_state != QLA_SREADING &&
 241                     ha->optrom_state != QLA_SWRITING)
 242                         break;
 243
 244                 ha->optrom_state = QLA_SWAITING;
 245
 246                 DEBUG2(qla_printk(KERN_INFO, ha,
 247                     "Freeing flash region allocation -- 0x%x bytes.\n",
 248                     ha->optrom_region_size));
 249
 250                 vfree(ha->optrom_buffer);
 251                 ha->optrom_buffer = NULL;
 252                 break;
 253         case 1:
 254                 if (ha->optrom_state != QLA_SWAITING)
 255                         break;
 256
 257                 ha->optrom_region_start = start;
 258                 ha->optrom_region_size = start + size > ha->optrom_size ?
 259                     ha->optrom_size - start : size;
 260
 261                 ha->optrom_state = QLA_SREADING;
 262                 ha->optrom_buffer = vmalloc(ha->optrom_region_size);
 263                 if (ha->optrom_buffer == NULL) {
 264                         qla_printk(KERN_WARNING, ha,
 265                             "Unable to allocate memory for optrom retrieval "
 266                             "(%x).\n", ha->optrom_region_size);
 267
 268                         ha->optrom_state = QLA_SWAITING;
 269                         return count;
 270                 }
 271
 272                 DEBUG2(qla_printk(KERN_INFO, ha,
 273                     "Reading flash region -- 0x%x/0x%x.\n",
 274                     ha->optrom_region_start, ha->optrom_region_size));
 275
 276                 memset(ha->optrom_buffer, 0, ha->optrom_region_size);
 277                 ha->isp_ops->read_optrom(vha, ha->optrom_buffer,
 278                     ha->optrom_region_start, ha->optrom_region_size);
 279                 break;
 280         case 2:
 281                 if (ha->optrom_state != QLA_SWAITING)
 282                         break;
 283
 284                 /*
 285                  * We need to be more restrictive on which FLASH regions are
 286                  * allowed to be updated via user-space.  Regions accessible
 287                  * via this method include:
 288                  *
 289                  * ISP21xx/ISP22xx/ISP23xx type boards:
 290                  *
 291                  *      0x000000 -> 0x020000 -- Boot code.
 292                  *
 293                  * ISP2322/ISP24xx type boards:
 294                  *
 295                  *      0x000000 -> 0x07ffff -- Boot code.
 296                  *      0x080000 -> 0x0fffff -- Firmware.
 297                  *
 298                  * ISP25xx type boards:
 299                  *
 300                  *      0x000000 -> 0x07ffff -- Boot code.
 301                  *      0x080000 -> 0x0fffff -- Firmware.
 302                  *      0x120000 -> 0x12ffff -- VPD and HBA parameters.
 303                  */
 304                 valid = 0;
 305                 if (ha->optrom_size == OPTROM_SIZE_2300 && start == 0)
 306                         valid = 1;
 307                 else if (start == (ha->flt_region_boot * 4) ||
 308                     start == (ha->flt_region_fw * 4))
 309                         valid = 1;
 310                 else if (IS_QLA25XX(ha) || IS_QLA81XX(ha))
 311                     valid = 1;
 312                 if (!valid) {
 313                         qla_printk(KERN_WARNING, ha,
 314                             "Invalid start region 0x%x/0x%x.\n", start, size);
 315                         return -EINVAL;
 316                 }
 317
 318                 ha->optrom_region_start = start;
 319                 ha->optrom_region_size = start + size > ha->optrom_size ?
 320                     ha->optrom_size - start : size;
 321
 322                 ha->optrom_state = QLA_SWRITING;
 323                 ha->optrom_buffer = vmalloc(ha->optrom_region_size);
 324                 if (ha->optrom_buffer == NULL) {
 325                         qla_printk(KERN_WARNING, ha,
 326                             "Unable to allocate memory for optrom update "
 327                             "(%x).\n", ha->optrom_region_size);
 328
 329                         ha->optrom_state = QLA_SWAITING;
 330                         return count;
 331                 }
 332
 333                 DEBUG2(qla_printk(KERN_INFO, ha,
 334                     "Staging flash region write -- 0x%x/0x%x.\n",
 335                     ha->optrom_region_start, ha->optrom_region_size));
 336
 337                 memset(ha->optrom_buffer, 0, ha->optrom_region_size);
 338                 break;
 339         case 3:
 340                 if (ha->optrom_state != QLA_SWRITING)
 341                         break;
 342
 343                 if (qla2x00_wait_for_hba_online(vha) != QLA_SUCCESS) {
 344                         qla_printk(KERN_WARNING, ha,
 345                             "HBA not online, failing flash update.\n");
 346                         return -EAGAIN;
 347                 }
 348
 349                 DEBUG2(qla_printk(KERN_INFO, ha,
 350                     "Writing flash region -- 0x%x/0x%x.\n",
 351                     ha->optrom_region_start, ha->optrom_region_size));
 352
 353                 ha->isp_ops->write_optrom(vha, ha->optrom_buffer,
 354                     ha->optrom_region_start, ha->optrom_region_size);
 355                 break;
 356         default:
 357                 count = -EINVAL;
 358         }
 359         return count;
 360 }
 361
 362 static struct bin_attribute sysfs_optrom_ctl_attr = {
 363         .attr = {
 364                 .name = "optrom_ctl",
 365                 .mode = S_IWUSR,
 366         },
 367         .size = 0,
 368         .write = qla2x00_sysfs_write_optrom_ctl,
 369 };
 370
 371 static ssize_t
 372 qla2x00_sysfs_read_vpd(struct kobject *kobj,
 373                        struct bin_attribute *bin_attr,
 374                        char *buf, loff_t off, size_t count)
 375 {
 376         struct scsi_qla_host *vha = shost_priv(dev_to_shost(container_of(kobj,
 377             struct device, kobj)));
 378         struct qla_hw_data *ha = vha->hw;
 379
 380         if (!capable(CAP_SYS_ADMIN))
 381                 return 0;
 382
 383         /* Read NVRAM data from cache. */
 384         return memory_read_from_buffer(buf, count, &off, ha->vpd, ha->vpd_size);
 385 }
 386
 387 static ssize_t
 388 qla2x00_sysfs_write_vpd(struct kobject *kobj,
 389                         struct bin_attribute *bin_attr,
 390                         char *buf, loff_t off, size_t count)
 391 {
 392         struct scsi_qla_host *vha = shost_priv(dev_to_shost(container_of(kobj,
 393             struct device, kobj)));
 394         struct qla_hw_data *ha = vha->hw;
 395         uint8_t *tmp_data;
 396
 397         if (!capable(CAP_SYS_ADMIN) || off != 0 || count != ha->vpd_size ||
 398             !ha->isp_ops->write_nvram)
 399                 return 0;
 400
 401         if (qla2x00_wait_for_hba_online(vha) != QLA_SUCCESS) {
 402                 qla_printk(KERN_WARNING, ha,
 403                     "HBA not online, failing VPD update.\n");
 404                 return -EAGAIN;
 405         }
 406
 407         /* Write NVRAM. */
 408         ha->isp_ops->write_nvram(vha, (uint8_t *)buf, ha->vpd_base, count);
 409         ha->isp_ops->read_nvram(vha, (uint8_t *)ha->vpd, ha->vpd_base, count);
 410
 411         /* Update flash version information for 4Gb & above. */
 412         if (!IS_FWI2_CAPABLE(ha))
 413                 goto done;
 414
 415         tmp_data = vmalloc(256);
 416         if (!tmp_data) {
 417                 qla_printk(KERN_WARNING, ha,
 418                     "Unable to allocate memory for VPD information update.\n");
 419                 goto done;
 420         }
 421         ha->isp_ops->get_flash_version(vha, tmp_data);
 422         vfree(tmp_data);
 423 done:
 424         return count;
 425 }
 426
 427 static struct bin_attribute sysfs_vpd_attr = {
 428         .attr = {
 429                 .name = "vpd",
 430                 .mode = S_IRUSR | S_IWUSR,
 431         },
 432         .size = 0,
 433         .read = qla2x00_sysfs_read_vpd,
 434         .write = qla2x00_sysfs_write_vpd,
 435 };
 436
 437 static ssize_t
 438 qla2x00_sysfs_read_sfp(struct kobject *kobj,
 439                        struct bin_attribute *bin_attr,
 440                        char *buf, loff_t off, size_t count)
 441 {
 442         struct scsi_qla_host *vha = shost_priv(dev_to_shost(container_of(kobj,
 443             struct device, kobj)));
 444         struct qla_hw_data *ha = vha->hw;
 445         uint16_t iter, addr, offset;
 446         int rval;
 447
 448         if (!capable(CAP_SYS_ADMIN) || off != 0 || count != SFP_DEV_SIZE * 2)
 449                 return 0;
 450
 451         if (ha->sfp_data)
 452                 goto do_read;
 453
 454         ha->sfp_data = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL,
 455             &ha->sfp_data_dma);
 456         if (!ha->sfp_data) {
 457                 qla_printk(KERN_WARNING, ha,
 458                     "Unable to allocate memory for SFP read-data.\n");
 459                 return 0;
 460         }
 461
 462 do_read:
 463         memset(ha->sfp_data, 0, SFP_BLOCK_SIZE);
 464         addr = 0xa0;
 465         for (iter = 0, offset = 0; iter < (SFP_DEV_SIZE * 2) / SFP_BLOCK_SIZE;
 466             iter++, offset += SFP_BLOCK_SIZE) {
 467                 if (iter == 4) {
 468                         /* Skip to next device address. */
 469                         addr = 0xa2;
 470                         offset = 0;
 471                 }
 472
 473                 rval = qla2x00_read_sfp(vha, ha->sfp_data_dma, addr, offset,
 474                     SFP_BLOCK_SIZE);
 475                 if (rval != QLA_SUCCESS) {
 476                         qla_printk(KERN_WARNING, ha,
 477                             "Unable to read SFP data (%x/%x/%x).\n", rval,
 478                             addr, offset);
 479                         count = 0;
 480                         break;
 481                 }
 482                 memcpy(buf, ha->sfp_data, SFP_BLOCK_SIZE);
 483                 buf += SFP_BLOCK_SIZE;
 484         }
 485
 486         return count;
 487 }
 488
 489 static struct bin_attribute sysfs_sfp_attr = {
 490         .attr = {
 491                 .name = "sfp",
 492                 .mode = S_IRUSR | S_IWUSR,
 493         },
 494         .size = SFP_DEV_SIZE * 2,
 495         .read = qla2x00_sysfs_read_sfp,
 496 };
 497
 498 static ssize_t
 499 qla2x00_sysfs_write_reset(struct kobject *kobj,
 500                         struct bin_attribute *bin_attr,
 501                         char *buf, loff_t off, size_t count)
 502 {
 503         struct scsi_qla_host *vha = shost_priv(dev_to_shost(container_of(kobj,
 504             struct device, kobj)));
 505         struct qla_hw_data *ha = vha->hw;
 506         int type;
 507
 508         if (off != 0)
 509                 return 0;
 510
 511         type = simple_strtol(buf, NULL, 10);
 512         switch (type) {
 513         case 0x2025c:
 514                 qla_printk(KERN_INFO, ha,
 515                     "Issuing ISP reset on (%ld).\n", vha->host_no);
 516
 517                 scsi_block_requests(vha->host);
 518                 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
 519                 qla2xxx_wake_dpc(vha);
 520                 qla2x00_wait_for_chip_reset(vha);
 521                 scsi_unblock_requests(vha->host);
 522                 break;
 523         case 0x2025d:
 524                 if (!IS_QLA81XX(ha))
 525                         break;
 526
 527                 qla_printk(KERN_INFO, ha,
 528                     "Issuing MPI reset on (%ld).\n", vha->host_no);
 529
 530                 /* Make sure FC side is not in reset */
 531                 qla2x00_wait_for_hba_online(vha);
 532
 533                 /* Issue MPI reset */
 534                 scsi_block_requests(vha->host);
 535                 if (qla81xx_restart_mpi_firmware(vha) != QLA_SUCCESS)
 536                         qla_printk(KERN_WARNING, ha,
 537                             "MPI reset failed on (%ld).\n", vha->host_no);
 538                 scsi_unblock_requests(vha->host);
 539                 break;
 540         }
 541         return count;
 542 }
 543
 544 static struct bin_attribute sysfs_reset_attr = {
 545         .attr = {
 546                 .name = "reset",
 547                 .mode = S_IWUSR,
 548         },
 549         .size = 0,
 550         .write = qla2x00_sysfs_write_reset,
 551 };
 552
 553 static ssize_t
 554 qla2x00_sysfs_write_edc(struct kobject *kobj,
 555                         struct bin_attribute *bin_attr,
 556                         char *buf, loff_t off, size_t count)
 557 {
 558         struct scsi_qla_host *vha = shost_priv(dev_to_shost(container_of(kobj,
 559             struct device, kobj)));
 560         struct qla_hw_data *ha = vha->hw;
 561         uint16_t dev, adr, opt, len;
 562         int rval;
 563
 564         ha->edc_data_len = 0;
 565
 566         if (!capable(CAP_SYS_ADMIN) || off != 0 || count < 8)
 567                 return 0;
 568
 569         if (!ha->edc_data) {
 570                 ha->edc_data = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL,
 571                     &ha->edc_data_dma);
 572                 if (!ha->edc_data) {
 573                         DEBUG2(qla_printk(KERN_INFO, ha,
 574                             "Unable to allocate memory for EDC write.\n"));
 575                         return 0;
 576                 }
 577         }
 578
 579         dev = le16_to_cpup((void *)&buf[0]);
 580         adr = le16_to_cpup((void *)&buf[2]);
 581         opt = le16_to_cpup((void *)&buf[4]);
 582         len = le16_to_cpup((void *)&buf[6]);
 583
 584         if (!(opt & BIT_0))
 585                 if (len == 0 || len > DMA_POOL_SIZE || len > count - 8)
 586                         return -EINVAL;
 587
 588         memcpy(ha->edc_data, &buf[8], len);
 589
 590         rval = qla2x00_write_edc(vha, dev, adr, ha->edc_data_dma,
 591             ha->edc_data, len, opt);
 592         if (rval != QLA_SUCCESS) {
 593                 DEBUG2(qla_printk(KERN_INFO, ha,
 594                     "Unable to write EDC (%x) %02x:%02x:%04x:%02x:%02x.\n",
 595                     rval, dev, adr, opt, len, *buf));
 596                 return 0;
 597         }
 598
 599         return count;
 600 }
 601
 602 static struct bin_attribute sysfs_edc_attr = {
 603         .attr = {
 604                 .name = "edc",
 605                 .mode = S_IWUSR,
 606         },
 607         .size = 0,
 608         .write = qla2x00_sysfs_write_edc,
 609 };
 610
 611 static ssize_t
 612 qla2x00_sysfs_write_edc_status(struct kobject *kobj,
 613                         struct bin_attribute *bin_attr,
 614                         char *buf, loff_t off, size_t count)
 615 {
 616         struct scsi_qla_host *vha = shost_priv(dev_to_shost(container_of(kobj,
 617             struct device, kobj)));
 618         struct qla_hw_data *ha = vha->hw;
 619         uint16_t dev, adr, opt, len;
 620         int rval;
 621
 622         ha->edc_data_len = 0;
 623
 624         if (!capable(CAP_SYS_ADMIN) || off != 0 || count < 8)
 625                 return 0;
 626
 627         if (!ha->edc_data) {
 628                 ha->edc_data = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL,
 629                     &ha->edc_data_dma);
 630                 if (!ha->edc_data) {
 631                         DEBUG2(qla_printk(KERN_INFO, ha,
 632                             "Unable to allocate memory for EDC status.\n"));
 633                         return 0;
 634                 }
 635         }
 636
 637         dev = le16_to_cpup((void *)&buf[0]);
 638         adr = le16_to_cpup((void *)&buf[2]);
 639         opt = le16_to_cpup((void *)&buf[4]);
 640         len = le16_to_cpup((void *)&buf[6]);
 641
 642         if (!(opt & BIT_0))
 643                 if (len == 0 || len > DMA_POOL_SIZE)
 644                         return -EINVAL;
 645
 646         memset(ha->edc_data, 0, len);
 647         rval = qla2x00_read_edc(vha, dev, adr, ha->edc_data_dma,
 648             ha->edc_data, len, opt);
 649         if (rval != QLA_SUCCESS) {
 650                 DEBUG2(qla_printk(KERN_INFO, ha,
 651                     "Unable to write EDC status (%x) %02x:%02x:%04x:%02x.\n",
 652                     rval, dev, adr, opt, len));
 653                 return 0;
 654         }
 655
 656         ha->edc_data_len = len;
 657
 658         return count;
 659 }
 660
 661 static ssize_t
 662 qla2x00_sysfs_read_edc_status(struct kobject *kobj,
 663                            struct bin_attribute *bin_attr,
 664                            char *buf, loff_t off, size_t count)
 665 {
 666         struct scsi_qla_host *vha = shost_priv(dev_to_shost(container_of(kobj,
 667             struct device, kobj)));
 668         struct qla_hw_data *ha = vha->hw;
 669
 670         if (!capable(CAP_SYS_ADMIN) || off != 0 || count == 0)
 671                 return 0;
 672
 673         if (!ha->edc_data || ha->edc_data_len == 0 || ha->edc_data_len > count)
 674                 return -EINVAL;
 675
 676         memcpy(buf, ha->edc_data, ha->edc_data_len);
 677
 678         return ha->edc_data_len;
 679 }
 680
 681 static struct bin_attribute sysfs_edc_status_attr = {
 682         .attr = {
 683                 .name = "edc_status",
 684                 .mode = S_IRUSR | S_IWUSR,
 685         },
 686         .size = 0,
 687         .write = qla2x00_sysfs_write_edc_status,
 688         .read = qla2x00_sysfs_read_edc_status,
 689 };
 690
 691 static struct sysfs_entry {
 692         char *name;
 693         struct bin_attribute *attr;
 694         int is4GBp_only;
 695 } bin_file_entries[] = {
 696         { "fw_dump", &sysfs_fw_dump_attr, },
 697         { "nvram", &sysfs_nvram_attr, },
 698         { "optrom", &sysfs_optrom_attr, },
 699         { "optrom_ctl", &sysfs_optrom_ctl_attr, },
 700         { "vpd", &sysfs_vpd_attr, 1 },
 701         { "sfp", &sysfs_sfp_attr, 1 },
 702         { "reset", &sysfs_reset_attr, },
 703         { "edc", &sysfs_edc_attr, 2 },
 704         { "edc_status", &sysfs_edc_status_attr, 2 },
 705         { NULL },
 706 };
 707
 708 void
 709 qla2x00_alloc_sysfs_attr(scsi_qla_host_t *vha)
 710 {
 711         struct Scsi_Host *host = vha->host;
 712         struct sysfs_entry *iter;
 713         int ret;
 714
 715         for (iter = bin_file_entries; iter->name; iter++) {
 716                 if (iter->is4GBp_only && !IS_FWI2_CAPABLE(vha->hw))
 717                         continue;
 718                 if (iter->is4GBp_only == 2 && !IS_QLA25XX(vha->hw))
 719                         continue;
 720
 721                 ret = sysfs_create_bin_file(&host->shost_gendev.kobj,
 722                     iter->attr);
 723                 if (ret)
 724                         qla_printk(KERN_INFO, vha->hw,
 725                             "Unable to create sysfs %s binary attribute "
 726                             "(%d).\n", iter->name, ret);
 727         }
 728 }
 729
 730 void
 731 qla2x00_free_sysfs_attr(scsi_qla_host_t *vha)
 732 {
 733         struct Scsi_Host *host = vha->host;
 734         struct sysfs_entry *iter;
 735         struct qla_hw_data *ha = vha->hw;
 736
 737         for (iter = bin_file_entries; iter->name; iter++) {
 738                 if (iter->is4GBp_only && !IS_FWI2_CAPABLE(ha))
 739                         continue;
 740                 if (iter->is4GBp_only == 2 && !IS_QLA25XX(ha))
 741                         continue;
 742
 743                 sysfs_remove_bin_file(&host->shost_gendev.kobj,
 744                     iter->attr);
 745         }
 746
 747         if (ha->beacon_blink_led == 1)
 748                 ha->isp_ops->beacon_off(vha);
 749 }
 750
 751 /* Scsi_Host attributes. */
 752
 753 static ssize_t
 754 qla2x00_drvr_version_show(struct device *dev,
 755                           struct device_attribute *attr, char *buf)
 756 {
 757         return snprintf(buf, PAGE_SIZE, "%s\n", qla2x00_version_str);
 758 }
 759
 760 static ssize_t
 761 qla2x00_fw_version_show(struct device *dev,
 762                         struct device_attribute *attr, char *buf)
 763 {
 764         scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
 765         struct qla_hw_data *ha = vha->hw;
 766         char fw_str[128];
 767
 768         return snprintf(buf, PAGE_SIZE, "%s\n",
 769             ha->isp_ops->fw_version_str(vha, fw_str));
 770 }
 771
 772 static ssize_t
 773 qla2x00_serial_num_show(struct device *dev, struct device_attribute *attr,
 774                         char *buf)
 775 {
 776         scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
 777         struct qla_hw_data *ha = vha->hw;
 778         uint32_t sn;
 779
 780         if (IS_FWI2_CAPABLE(ha)) {
 781                 qla2xxx_get_vpd_field(vha, "SN", buf, PAGE_SIZE);
 782                 return snprintf(buf, PAGE_SIZE, "%s\n", buf);
 783         }
 784
 785         sn = ((ha->serial0 & 0x1f) << 16) | (ha->serial2 << 8) | ha->serial1;
 786         return snprintf(buf, PAGE_SIZE, "%c%05d\n", 'A' + sn / 100000,
 787             sn % 100000);
 788 }
 789
 790 static ssize_t
 791 qla2x00_isp_name_show(struct device *dev, struct device_attribute *attr,
 792                       char *buf)
 793 {
 794         scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
 795         return snprintf(buf, PAGE_SIZE, "ISP%04X\n", vha->hw->pdev->device);
 796 }
 797
 798 static ssize_t
 799 qla2x00_isp_id_show(struct device *dev, struct device_attribute *attr,
 800                     char *buf)
 801 {
 802         scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
 803         struct qla_hw_data *ha = vha->hw;
 804         return snprintf(buf, PAGE_SIZE, "%04x %04x %04x %04x\n",
 805             ha->product_id[0], ha->product_id[1], ha->product_id[2],
 806             ha->product_id[3]);
 807 }
 808
 809 static ssize_t
 810 qla2x00_model_name_show(struct device *dev, struct device_attribute *attr,
 811                         char *buf)
 812 {
 813         scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
 814         return snprintf(buf, PAGE_SIZE, "%s\n", vha->hw->model_number);
 815 }
 816
 817 static ssize_t
 818 qla2x00_model_desc_show(struct device *dev, struct device_attribute *attr,
 819                         char *buf)
 820 {
 821         scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
 822         return snprintf(buf, PAGE_SIZE, "%s\n",
 823             vha->hw->model_desc ? vha->hw->model_desc : "");
 824 }
 825
 826 static ssize_t
 827 qla2x00_pci_info_show(struct device *dev, struct device_attribute *attr,
 828                       char *buf)
 829 {
 830         scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
 831         char pci_info[30];
 832
 833         return snprintf(buf, PAGE_SIZE, "%s\n",
 834             vha->hw->isp_ops->pci_info_str(vha, pci_info));
 835 }
 836
 837 static ssize_t
 838 qla2x00_link_state_show(struct device *dev, struct device_attribute *attr,
 839                         char *buf)
 840 {
 841         scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
 842         struct qla_hw_data *ha = vha->hw;
 843         int len = 0;
 844
 845         if (atomic_read(&vha->loop_state) == LOOP_DOWN ||
 846             atomic_read(&vha->loop_state) == LOOP_DEAD)
 847                 len = snprintf(buf, PAGE_SIZE, "Link Down\n");
 848         else if (atomic_read(&vha->loop_state) != LOOP_READY ||
 849             test_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags) ||
 850             test_bit(ISP_ABORT_NEEDED, &vha->dpc_flags))
 851                 len = snprintf(buf, PAGE_SIZE, "Unknown Link State\n");
 852         else {
 853                 len = snprintf(buf, PAGE_SIZE, "Link Up - ");
 854
 855                 switch (ha->current_topology) {
 856                 case ISP_CFG_NL:
 857                         len += snprintf(buf + len, PAGE_SIZE-len, "Loop\n");
 858                         break;
 859                 case ISP_CFG_FL:
 860                         len += snprintf(buf + len, PAGE_SIZE-len, "FL_Port\n");
 861                         break;
 862                 case ISP_CFG_N:
 863                         len += snprintf(buf + len, PAGE_SIZE-len,
 864                             "N_Port to N_Port\n");
 865                         break;
 866                 case ISP_CFG_F:
 867                         len += snprintf(buf + len, PAGE_SIZE-len, "F_Port\n");
 868                         break;
 869                 default:
 870                         len += snprintf(buf + len, PAGE_SIZE-len, "Loop\n");
 871                         break;
 872                 }
 873         }
 874         return len;
 875 }
 876
 877 static ssize_t
 878 qla2x00_zio_show(struct device *dev, struct device_attribute *attr,
 879                  char *buf)
 880 {
 881         scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
 882         int len = 0;
 883
 884         switch (vha->hw->zio_mode) {
 885         case QLA_ZIO_MODE_6:
 886                 len += snprintf(buf + len, PAGE_SIZE-len, "Mode 6\n");
 887                 break;
 888         case QLA_ZIO_DISABLED:
 889                 len += snprintf(buf + len, PAGE_SIZE-len, "Disabled\n");
 890                 break;
 891         }
 892         return len;
 893 }
 894
 895 static ssize_t
 896 qla2x00_zio_store(struct device *dev, struct device_attribute *attr,
 897                   const char *buf, size_t count)
 898 {
 899         scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
 900         struct qla_hw_data *ha = vha->hw;
 901         int val = 0;
 902         uint16_t zio_mode;
 903
 904         if (!IS_ZIO_SUPPORTED(ha))
 905                 return -ENOTSUPP;
 906
 907         if (sscanf(buf, "%d", &val) != 1)
 908                 return -EINVAL;
 909
 910         if (val)
 911                 zio_mode = QLA_ZIO_MODE_6;
 912         else
 913                 zio_mode = QLA_ZIO_DISABLED;
 914
 915         /* Update per-hba values and queue a reset. */
 916         if (zio_mode != QLA_ZIO_DISABLED || ha->zio_mode != QLA_ZIO_DISABLED) {
 917                 ha->zio_mode = zio_mode;
 918                 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
 919         }
 920         return strlen(buf);
 921 }
 922
 923 static ssize_t
 924 qla2x00_zio_timer_show(struct device *dev, struct device_attribute *attr,
 925                        char *buf)
 926 {
 927         scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
 928
 929         return snprintf(buf, PAGE_SIZE, "%d us\n", vha->hw->zio_timer * 100);
 930 }
 931
 932 static ssize_t
 933 qla2x00_zio_timer_store(struct device *dev, struct device_attribute *attr,
 934                         const char *buf, size_t count)
 935 {
 936         scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
 937         int val = 0;
 938         uint16_t zio_timer;
 939
 940         if (sscanf(buf, "%d", &val) != 1)
 941                 return -EINVAL;
 942         if (val > 25500 || val < 100)
 943                 return -ERANGE;
 944
 945         zio_timer = (uint16_t)(val / 100);
 946         vha->hw->zio_timer = zio_timer;
 947
 948         return strlen(buf);
 949 }
 950
 951 static ssize_t
 952 qla2x00_beacon_show(struct device *dev, struct device_attribute *attr,
 953                     char *buf)
 954 {
 955         scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
 956         int len = 0;
 957
 958         if (vha->hw->beacon_blink_led)
 959                 len += snprintf(buf + len, PAGE_SIZE-len, "Enabled\n");
 960         else
 961                 len += snprintf(buf + len, PAGE_SIZE-len, "Disabled\n");
 962         return len;
 963 }
 964
 965 static ssize_t
 966 qla2x00_beacon_store(struct device *dev, struct device_attribute *attr,
 967                      const char *buf, size_t count)
 968 {
 969         scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
 970         struct qla_hw_data *ha = vha->hw;
 971         int val = 0;
 972         int rval;
 973
 974         if (IS_QLA2100(ha) || IS_QLA2200(ha))
 975                 return -EPERM;
 976
 977         if (test_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags)) {
 978                 qla_printk(KERN_WARNING, ha,
 979                     "Abort ISP active -- ignoring beacon request.\n");
 980                 return -EBUSY;
 981         }
 982
 983         if (sscanf(buf, "%d", &val) != 1)
 984                 return -EINVAL;
 985
 986         if (val)
 987                 rval = ha->isp_ops->beacon_on(vha);
 988         else
 989                 rval = ha->isp_ops->beacon_off(vha);
 990
 991         if (rval != QLA_SUCCESS)
 992                 count = 0;
 993
 994         return count;
 995 }
 996
 997 static ssize_t
 998 qla2x00_optrom_bios_version_show(struct device *dev,
 999                                  struct device_attribute *attr, char *buf)
1000 {
1001         scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1002         struct qla_hw_data *ha = vha->hw;
1003         return snprintf(buf, PAGE_SIZE, "%d.%02d\n", ha->bios_revision[1],
1004             ha->bios_revision[0]);
1005 }
1006
1007 static ssize_t
1008 qla2x00_optrom_efi_version_show(struct device *dev,
1009                                 struct device_attribute *attr, char *buf)
1010 {
1011         scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1012         struct qla_hw_data *ha = vha->hw;
1013         return snprintf(buf, PAGE_SIZE, "%d.%02d\n", ha->efi_revision[1],
1014             ha->efi_revision[0]);
1015 }
1016
1017 static ssize_t
1018 qla2x00_optrom_fcode_version_show(struct device *dev,
1019                                   struct device_attribute *attr, char *buf)
1020 {
1021         scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1022         struct qla_hw_data *ha = vha->hw;
1023         return snprintf(buf, PAGE_SIZE, "%d.%02d\n", ha->fcode_revision[1],
1024             ha->fcode_revision[0]);
1025 }
1026
1027 static ssize_t
1028 qla2x00_optrom_fw_version_show(struct device *dev,
1029                                struct device_attribute *attr, char *buf)
1030 {
1031         scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1032         struct qla_hw_data *ha = vha->hw;
1033         return snprintf(buf, PAGE_SIZE, "%d.%02d.%02d %d\n",
1034             ha->fw_revision[0], ha->fw_revision[1], ha->fw_revision[2],
1035             ha->fw_revision[3]);
1036 }
1037
1038 static ssize_t
1039 qla2x00_total_isp_aborts_show(struct device *dev,
1040                               struct device_attribute *attr, char *buf)
1041 {
1042         scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1043         struct qla_hw_data *ha = vha->hw;
1044         return snprintf(buf, PAGE_SIZE, "%d\n",
1045             ha->qla_stats.total_isp_aborts);
1046 }
1047
1048 static ssize_t
1049 qla2x00_mpi_version_show(struct device *dev, struct device_attribute *attr,
1050     char *buf)
1051 {
1052         scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1053         struct qla_hw_data *ha = vha->hw;
1054
1055         if (!IS_QLA81XX(ha))
1056                 return snprintf(buf, PAGE_SIZE, "\n");
1057
1058         return snprintf(buf, PAGE_SIZE, "%d.%02d.%02d (%x)\n",
1059             ha->mpi_version[0], ha->mpi_version[1], ha->mpi_version[2],
1060             ha->mpi_capabilities);
1061 }
1062
1063 static ssize_t
1064 qla2x00_phy_version_show(struct device *dev, struct device_attribute *attr,
1065     char *buf)
1066 {
1067         scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1068         struct qla_hw_data *ha = vha->hw;
1069
1070         if (!IS_QLA81XX(ha))
1071                 return snprintf(buf, PAGE_SIZE, "\n");
1072
1073         return snprintf(buf, PAGE_SIZE, "%d.%02d.%02d\n",
1074             ha->phy_version[0], ha->phy_version[1], ha->phy_version[2]);
1075 }
1076
1077 static ssize_t
1078 qla2x00_flash_block_size_show(struct device *dev,
1079                               struct device_attribute *attr, char *buf)
1080 {
1081         scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
1082         struct qla_hw_data *ha = vha->hw;
1083
1084         return snprintf(buf, PAGE_SIZE, "0x%x\n", ha->fdt_block_size);
1085 }
1086
1087 static DEVICE_ATTR(driver_version, S_IRUGO, qla2x00_drvr_version_show, NULL);
1088 static DEVICE_ATTR(fw_version, S_IRUGO, qla2x00_fw_version_show, NULL);
1089 static DEVICE_ATTR(serial_num, S_IRUGO, qla2x00_serial_num_show, NULL);
1090 static DEVICE_ATTR(isp_name, S_IRUGO, qla2x00_isp_name_show, NULL);
1091 static DEVICE_ATTR(isp_id, S_IRUGO, qla2x00_isp_id_show, NULL);
1092 static DEVICE_ATTR(model_name, S_IRUGO, qla2x00_model_name_show, NULL);
1093 static DEVICE_ATTR(model_desc, S_IRUGO, qla2x00_model_desc_show, NULL);
1094 static DEVICE_ATTR(pci_info, S_IRUGO, qla2x00_pci_info_show, NULL);
1095 static DEVICE_ATTR(link_state, S_IRUGO, qla2x00_link_state_show, NULL);
1096 static DEVICE_ATTR(zio, S_IRUGO | S_IWUSR, qla2x00_zio_show, qla2x00_zio_store);
1097 static DEVICE_ATTR(zio_timer, S_IRUGO | S_IWUSR, qla2x00_zio_timer_show,
1098                    qla2x00_zio_timer_store);
1099 static DEVICE_ATTR(beacon, S_IRUGO | S_IWUSR, qla2x00_beacon_show,
1100                    qla2x00_beacon_store);
1101 static DEVICE_ATTR(optrom_bios_version, S_IRUGO,
1102                    qla2x00_optrom_bios_version_show, NULL);
1103 static DEVICE_ATTR(optrom_efi_version, S_IRUGO,
1104                    qla2x00_optrom_efi_version_show, NULL);
1105 static DEVICE_ATTR(optrom_fcode_version, S_IRUGO,
1106                    qla2x00_optrom_fcode_version_show, NULL);
1107 static DEVICE_ATTR(optrom_fw_version, S_IRUGO, qla2x00_optrom_fw_version_show,
1108                    NULL);
1109 static DEVICE_ATTR(total_isp_aborts, S_IRUGO, qla2x00_total_isp_aborts_show,
1110                    NULL);
1111 static DEVICE_ATTR(mpi_version, S_IRUGO, qla2x00_mpi_version_show, NULL);
1112 static DEVICE_ATTR(phy_version, S_IRUGO, qla2x00_phy_version_show, NULL);
1113 static DEVICE_ATTR(flash_block_size, S_IRUGO, qla2x00_flash_block_size_show,
1114                    NULL);
1115
1116 struct device_attribute *qla2x00_host_attrs[] = {
1117         &dev_attr_driver_version,
1118         &dev_attr_fw_version,
1119         &dev_attr_serial_num,
1120         &dev_attr_isp_name,
1121         &dev_attr_isp_id,
1122         &dev_attr_model_name,
1123         &dev_attr_model_desc,
1124         &dev_attr_pci_info,
1125         &dev_attr_link_state,
1126         &dev_attr_zio,
1127         &dev_attr_zio_timer,
1128         &dev_attr_beacon,
1129         &dev_attr_optrom_bios_version,
1130         &dev_attr_optrom_efi_version,
1131         &dev_attr_optrom_fcode_version,
1132         &dev_attr_optrom_fw_version,
1133         &dev_attr_total_isp_aborts,
1134         &dev_attr_mpi_version,
1135         &dev_attr_phy_version,
1136         &dev_attr_flash_block_size,
1137         NULL,
1138 };
1139
1140 /* Host attributes. */
1141
1142 static void
1143 qla2x00_get_host_port_id(struct Scsi_Host *shost)
1144 {
1145         scsi_qla_host_t *vha = shost_priv(shost);
1146
1147         fc_host_port_id(shost) = vha->d_id.b.domain << 16 |
1148             vha->d_id.b.area << 8 | vha->d_id.b.al_pa;
1149 }
1150
1151 static void
1152 qla2x00_get_host_speed(struct Scsi_Host *shost)
1153 {
1154         struct qla_hw_data *ha = ((struct scsi_qla_host *)
1155                                         (shost_priv(shost)))->hw;
1156         u32 speed = FC_PORTSPEED_UNKNOWN;
1157
1158         switch (ha->link_data_rate) {
1159         case PORT_SPEED_1GB:
1160                 speed = FC_PORTSPEED_1GBIT;
1161                 break;
1162         case PORT_SPEED_2GB:
1163                 speed = FC_PORTSPEED_2GBIT;
1164                 break;
1165         case PORT_SPEED_4GB:
1166                 speed = FC_PORTSPEED_4GBIT;
1167                 break;
1168         case PORT_SPEED_8GB:
1169                 speed = FC_PORTSPEED_8GBIT;
1170                 break;
1171         case PORT_SPEED_10GB:
1172                 speed = FC_PORTSPEED_10GBIT;
1173                 break;
1174         }
1175         fc_host_speed(shost) = speed;
1176 }
1177
1178 static void
1179 qla2x00_get_host_port_type(struct Scsi_Host *shost)
1180 {
1181         scsi_qla_host_t *vha = shost_priv(shost);
1182         uint32_t port_type = FC_PORTTYPE_UNKNOWN;
1183
1184         if (vha->vp_idx) {
1185                 fc_host_port_type(shost) = FC_PORTTYPE_NPIV;
1186                 return;
1187         }
1188         switch (vha->hw->current_topology) {
1189         case ISP_CFG_NL:
1190                 port_type = FC_PORTTYPE_LPORT;
1191                 break;
1192         case ISP_CFG_FL:
1193                 port_type = FC_PORTTYPE_NLPORT;
1194                 break;
1195         case ISP_CFG_N:
1196                 port_type = FC_PORTTYPE_PTP;
1197                 break;
1198         case ISP_CFG_F:
1199                 port_type = FC_PORTTYPE_NPORT;
1200                 break;
1201         }
1202         fc_host_port_type(shost) = port_type;
1203 }
1204
1205 static void
1206 qla2x00_get_starget_node_name(struct scsi_target *starget)
1207 {
1208         struct Scsi_Host *host = dev_to_shost(starget->dev.parent);
1209         scsi_qla_host_t *vha = shost_priv(host);
1210         fc_port_t *fcport;
1211         u64 node_name = 0;
1212
1213         list_for_each_entry(fcport, &vha->vp_fcports, list) {
1214                 if (fcport->rport &&
1215                     starget->id == fcport->rport->scsi_target_id) {
1216                         node_name = wwn_to_u64(fcport->node_name);
1217                         break;
1218                 }
1219         }
1220
1221         fc_starget_node_name(starget) = node_name;
1222 }
1223
1224 static void
1225 qla2x00_get_starget_port_name(struct scsi_target *starget)
1226 {
1227         struct Scsi_Host *host = dev_to_shost(starget->dev.parent);
1228         scsi_qla_host_t *vha = shost_priv(host);
1229         fc_port_t *fcport;
1230         u64 port_name = 0;
1231
1232         list_for_each_entry(fcport, &vha->vp_fcports, list) {
1233                 if (fcport->rport &&
1234                     starget->id == fcport->rport->scsi_target_id) {
1235                         port_name = wwn_to_u64(fcport->port_name);
1236                         break;
1237                 }
1238         }
1239
1240         fc_starget_port_name(starget) = port_name;
1241 }
1242
1243 static void
1244 qla2x00_get_starget_port_id(struct scsi_target *starget)
1245 {
1246         struct Scsi_Host *host = dev_to_shost(starget->dev.parent);
1247         scsi_qla_host_t *vha = shost_priv(host);
1248         fc_port_t *fcport;
1249         uint32_t port_id = ~0U;
1250
1251         list_for_each_entry(fcport, &vha->vp_fcports, list) {
1252                 if (fcport->rport &&
1253                     starget->id == fcport->rport->scsi_target_id) {
1254                         port_id = fcport->d_id.b.domain << 16 |
1255                             fcport->d_id.b.area << 8 | fcport->d_id.b.al_pa;
1256                         break;
1257                 }
1258         }
1259
1260         fc_starget_port_id(starget) = port_id;
1261 }
1262
1263 static void
1264 qla2x00_set_rport_loss_tmo(struct fc_rport *rport, uint32_t timeout)
1265 {
1266         if (timeout)
1267                 rport->dev_loss_tmo = timeout;
1268         else
1269                 rport->dev_loss_tmo = 1;
1270 }
1271
1272 static void
1273 qla2x00_dev_loss_tmo_callbk(struct fc_rport *rport)
1274 {
1275         struct Scsi_Host *host = rport_to_shost(rport);
1276         fc_port_t *fcport = *(fc_port_t **)rport->dd_data;
1277
1278         if (!fcport)
1279                 return;
1280
1281         qla2x00_abort_fcport_cmds(fcport);
1282
1283         /*
1284          * Transport has effectively 'deleted' the rport, clear
1285          * all local references.
1286          */
1287         spin_lock_irq(host->host_lock);
1288         fcport->rport = NULL;
1289         *((fc_port_t **)rport->dd_data) = NULL;
1290         spin_unlock_irq(host->host_lock);
1291 }
1292
1293 static void
1294 qla2x00_terminate_rport_io(struct fc_rport *rport)
1295 {
1296         fc_port_t *fcport = *(fc_port_t **)rport->dd_data;
1297
1298         if (!fcport)
1299                 return;
1300
1301         /*
1302          * At this point all fcport's software-states are cleared.  Perform any
1303          * final cleanup of firmware resources (PCBs and XCBs).
1304          */
1305         if (fcport->loop_id != FC_NO_LOOP_ID)
1306                 fcport->vha->hw->isp_ops->fabric_logout(fcport->vha,
1307                         fcport->loop_id, fcport->d_id.b.domain,
1308                         fcport->d_id.b.area, fcport->d_id.b.al_pa);
1309
1310         qla2x00_abort_fcport_cmds(fcport);
1311 }
1312
1313 static int
1314 qla2x00_issue_lip(struct Scsi_Host *shost)
1315 {
1316         scsi_qla_host_t *vha = shost_priv(shost);
1317
1318         qla2x00_loop_reset(vha);
1319         return 0;
1320 }
1321
1322 static struct fc_host_statistics *
1323 qla2x00_get_fc_host_stats(struct Scsi_Host *shost)
1324 {
1325         scsi_qla_host_t *vha = shost_priv(shost);
1326         struct qla_hw_data *ha = vha->hw;
1327         struct scsi_qla_host *base_vha = pci_get_drvdata(ha->pdev);
1328         int rval;
1329         struct link_statistics *stats;
1330         dma_addr_t stats_dma;
1331         struct fc_host_statistics *pfc_host_stat;
1332
1333         pfc_host_stat = &ha->fc_host_stat;
1334         memset(pfc_host_stat, -1, sizeof(struct fc_host_statistics));
1335
1336         stats = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &stats_dma);
1337         if (stats == NULL) {
1338                 DEBUG2_3_11(printk("%s(%ld): Failed to allocate memory.\n",
1339                     __func__, base_vha->host_no));
1340                 goto done;
1341         }
1342         memset(stats, 0, DMA_POOL_SIZE);
1343
1344         rval = QLA_FUNCTION_FAILED;
1345         if (IS_FWI2_CAPABLE(ha)) {
1346                 rval = qla24xx_get_isp_stats(base_vha, stats, stats_dma);
1347         } else if (atomic_read(&base_vha->loop_state) == LOOP_READY &&
1348                     !test_bit(ABORT_ISP_ACTIVE, &base_vha->dpc_flags) &&
1349                     !test_bit(ISP_ABORT_NEEDED, &base_vha->dpc_flags) &&
1350                     !ha->dpc_active) {
1351                 /* Must be in a 'READY' state for statistics retrieval. */
1352                 rval = qla2x00_get_link_status(base_vha, base_vha->loop_id,
1353                                                 stats, stats_dma);
1354         }
1355
1356         if (rval != QLA_SUCCESS)
1357                 goto done_free;
1358
1359         pfc_host_stat->link_failure_count = stats->link_fail_cnt;
1360         pfc_host_stat->loss_of_sync_count = stats->loss_sync_cnt;
1361         pfc_host_stat->loss_of_signal_count = stats->loss_sig_cnt;
1362         pfc_host_stat->prim_seq_protocol_err_count = stats->prim_seq_err_cnt;
1363         pfc_host_stat->invalid_tx_word_count = stats->inval_xmit_word_cnt;
1364         pfc_host_stat->invalid_crc_count = stats->inval_crc_cnt;
1365         if (IS_FWI2_CAPABLE(ha)) {
1366                 pfc_host_stat->lip_count = stats->lip_cnt;
1367                 pfc_host_stat->tx_frames = stats->tx_frames;
1368                 pfc_host_stat->rx_frames = stats->rx_frames;
1369                 pfc_host_stat->dumped_frames = stats->dumped_frames;
1370                 pfc_host_stat->nos_count = stats->nos_rcvd;
1371         }
1372         pfc_host_stat->fcp_input_megabytes = ha->qla_stats.input_bytes >> 20;
1373         pfc_host_stat->fcp_output_megabytes = ha->qla_stats.output_bytes >> 20;
1374
1375 done_free:
1376         dma_pool_free(ha->s_dma_pool, stats, stats_dma);
1377 done:
1378         return pfc_host_stat;
1379 }
1380
1381 static void
1382 qla2x00_get_host_symbolic_name(struct Scsi_Host *shost)
1383 {
1384         scsi_qla_host_t *vha = shost_priv(shost);
1385
1386         qla2x00_get_sym_node_name(vha, fc_host_symbolic_name(shost));
1387 }
1388
1389 static void
1390 qla2x00_set_host_system_hostname(struct Scsi_Host *shost)
1391 {
1392         scsi_qla_host_t *vha = shost_priv(shost);
1393
1394         set_bit(REGISTER_FDMI_NEEDED, &vha->dpc_flags);
1395 }
1396
1397 static void
1398 qla2x00_get_host_fabric_name(struct Scsi_Host *shost)
1399 {
1400         scsi_qla_host_t *vha = shost_priv(shost);
1401         u64 node_name;
1402
1403         if (vha->device_flags & SWITCH_FOUND)
1404                 node_name = wwn_to_u64(vha->fabric_node_name);
1405         else
1406                 node_name = wwn_to_u64(vha->node_name);
1407
1408         fc_host_fabric_name(shost) = node_name;
1409 }
1410
1411 static void
1412 qla2x00_get_host_port_state(struct Scsi_Host *shost)
1413 {
1414         scsi_qla_host_t *vha = shost_priv(shost);
1415         struct scsi_qla_host *base_vha = pci_get_drvdata(vha->hw->pdev);
1416
1417         if (!base_vha->flags.online)
1418                 fc_host_port_state(shost) = FC_PORTSTATE_OFFLINE;
1419         else if (atomic_read(&base_vha->loop_state) == LOOP_TIMEOUT)
1420                 fc_host_port_state(shost) = FC_PORTSTATE_UNKNOWN;
1421         else
1422                 fc_host_port_state(shost) = FC_PORTSTATE_ONLINE;
1423 }
1424
1425 static int
1426 qla24xx_vport_create(struct fc_vport *fc_vport, bool disable)
1427 {
1428         int     ret = 0;
1429         int     cnt = 0;
1430         uint8_t qos = QLA_DEFAULT_QUE_QOS;
1431         scsi_qla_host_t *base_vha = shost_priv(fc_vport->shost);
1432         scsi_qla_host_t *vha = NULL;
1433         struct qla_hw_data *ha = base_vha->hw;
1434
1435         ret = qla24xx_vport_create_req_sanity_check(fc_vport);
1436         if (ret) {
1437                 DEBUG15(printk("qla24xx_vport_create_req_sanity_check failed, "
1438                     "status %x\n", ret));
1439                 return (ret);
1440         }
1441
1442         vha = qla24xx_create_vhost(fc_vport);
1443         if (vha == NULL) {
1444                 DEBUG15(printk ("qla24xx_create_vhost failed, vha = %p\n",
1445                     vha));
1446                 return FC_VPORT_FAILED;
1447         }
1448         if (disable) {
1449                 atomic_set(&vha->vp_state, VP_OFFLINE);
1450                 fc_vport_set_state(fc_vport, FC_VPORT_DISABLED);
1451         } else
1452                 atomic_set(&vha->vp_state, VP_FAILED);
1453
1454         /* ready to create vport */
1455         qla_printk(KERN_INFO, vha->hw, "VP entry id %d assigned.\n",
1456                                                         vha->vp_idx);
1457
1458         /* initialized vport states */
1459         atomic_set(&vha->loop_state, LOOP_DOWN);
1460         vha->vp_err_state=  VP_ERR_PORTDWN;
1461         vha->vp_prev_err_state=  VP_ERR_UNKWN;
1462         /* Check if physical ha port is Up */
1463         if (atomic_read(&base_vha->loop_state) == LOOP_DOWN ||
1464             atomic_read(&base_vha->loop_state) == LOOP_DEAD) {
1465                 /* Don't retry or attempt login of this virtual port */
1466                 DEBUG15(printk ("scsi(%ld): pport loop_state is not UP.\n",
1467                     base_vha->host_no));
1468                 atomic_set(&vha->loop_state, LOOP_DEAD);
1469                 if (!disable)
1470                         fc_vport_set_state(fc_vport, FC_VPORT_LINKDOWN);
1471         }
1472
1473         if (scsi_add_host(vha->host, &fc_vport->dev)) {
1474                 DEBUG15(printk("scsi(%ld): scsi_add_host failure for VP[%d].\n",
1475                         vha->host_no, vha->vp_idx));
1476                 goto vport_create_failed_2;
1477         }
1478
1479         /* initialize attributes */
1480         fc_host_node_name(vha->host) = wwn_to_u64(vha->node_name);
1481         fc_host_port_name(vha->host) = wwn_to_u64(vha->port_name);
1482         fc_host_supported_classes(vha->host) =
1483                 fc_host_supported_classes(base_vha->host);
1484         fc_host_supported_speeds(vha->host) =
1485                 fc_host_supported_speeds(base_vha->host);
1486
1487         qla24xx_vport_disable(fc_vport, disable);
1488
1489         /* Create a queue pair for the vport */
1490         if (ha->mqenable) {
1491                 if (ha->npiv_info) {
1492                         for (; cnt < ha->nvram_npiv_size; cnt++) {
1493                                 if (ha->npiv_info[cnt].port_name ==
1494                                         vha->port_name &&
1495                                         ha->npiv_info[cnt].node_name ==
1496                                         vha->node_name) {
1497                                         qos = ha->npiv_info[cnt].q_qos;
1498                                         break;
1499                                 }
1500                         }
1501                 }
1502                 qla25xx_create_queues(vha, qos);
1503         }
1504
1505         return 0;
1506 vport_create_failed_2:
1507         qla24xx_disable_vp(vha);
1508         qla24xx_deallocate_vp_id(vha);
1509         scsi_host_put(vha->host);
1510         return FC_VPORT_FAILED;
1511 }
1512
1513 static int
1514 qla24xx_vport_delete(struct fc_vport *fc_vport)
1515 {
1516         scsi_qla_host_t *vha = fc_vport->dd_data;
1517         fc_port_t *fcport, *tfcport;
1518         struct qla_hw_data *ha = vha->hw;
1519         uint16_t id = vha->vp_idx;
1520
1521         while (test_bit(LOOP_RESYNC_ACTIVE, &vha->dpc_flags) ||
1522             test_bit(FCPORT_UPDATE_NEEDED, &vha->dpc_flags))
1523                 msleep(1000);
1524
1525         qla24xx_disable_vp(vha);
1526
1527         fc_remove_host(vha->host);
1528
1529         scsi_remove_host(vha->host);
1530
1531         list_for_each_entry_safe(fcport, tfcport, &vha->vp_fcports, list) {
1532                 list_del(&fcport->list);
1533                 kfree(fcport);
1534                 fcport = NULL;
1535         }
1536
1537         qla24xx_deallocate_vp_id(vha);
1538
1539         if (vha->timer_active) {
1540                 qla2x00_vp_stop_timer(vha);
1541                 DEBUG15(printk ("scsi(%ld): timer for the vport[%d] = %p "
1542                     "has stopped\n",
1543                     vha->host_no, vha->vp_idx, vha));
1544         }
1545
1546         if (ha->mqenable) {
1547                 if (qla25xx_delete_queues(vha, 0) != QLA_SUCCESS)
1548                         qla_printk(KERN_WARNING, ha,
1549                                 "Queue delete failed.\n");
1550         }
1551
1552         scsi_host_put(vha->host);
1553         qla_printk(KERN_INFO, ha, "vport %d deleted\n", id);
1554         return 0;
1555 }
1556
1557 static int
1558 qla24xx_vport_disable(struct fc_vport *fc_vport, bool disable)
1559 {
1560         scsi_qla_host_t *vha = fc_vport->dd_data;
1561
1562         if (disable)
1563                 qla24xx_disable_vp(vha);
1564         else
1565                 qla24xx_enable_vp(vha);
1566
1567         return 0;
1568 }
1569
1570 struct fc_function_template qla2xxx_transport_functions = {
1571
1572         .show_host_node_name = 1,
1573         .show_host_port_name = 1,
1574         .show_host_supported_classes = 1,
1575         .show_host_supported_speeds = 1,
1576
1577         .get_host_port_id = qla2x00_get_host_port_id,
1578         .show_host_port_id = 1,
1579         .get_host_speed = qla2x00_get_host_speed,
1580         .show_host_speed = 1,
1581         .get_host_port_type = qla2x00_get_host_port_type,
1582         .show_host_port_type = 1,
1583         .get_host_symbolic_name = qla2x00_get_host_symbolic_name,
1584         .show_host_symbolic_name = 1,
1585         .set_host_system_hostname = qla2x00_set_host_system_hostname,
1586         .show_host_system_hostname = 1,
1587         .get_host_fabric_name = qla2x00_get_host_fabric_name,
1588         .show_host_fabric_name = 1,
1589         .get_host_port_state = qla2x00_get_host_port_state,
1590         .show_host_port_state = 1,
1591
1592         .dd_fcrport_size = sizeof(struct fc_port *),
1593         .show_rport_supported_classes = 1,
1594
1595         .get_starget_node_name = qla2x00_get_starget_node_name,
1596         .show_starget_node_name = 1,
1597         .get_starget_port_name = qla2x00_get_starget_port_name,
1598         .show_starget_port_name = 1,
1599         .get_starget_port_id  = qla2x00_get_starget_port_id,
1600         .show_starget_port_id = 1,
1601
1602         .set_rport_dev_loss_tmo = qla2x00_set_rport_loss_tmo,
1603         .show_rport_dev_loss_tmo = 1,
1604
1605         .issue_fc_host_lip = qla2x00_issue_lip,
1606         .dev_loss_tmo_callbk = qla2x00_dev_loss_tmo_callbk,
1607         .terminate_rport_io = qla2x00_terminate_rport_io,
1608         .get_fc_host_stats = qla2x00_get_fc_host_stats,
1609
1610         .vport_create = qla24xx_vport_create,
1611         .vport_disable = qla24xx_vport_disable,
1612         .vport_delete = qla24xx_vport_delete,
1613 };
1614
1615 struct fc_function_template qla2xxx_transport_vport_functions = {
1616
1617         .show_host_node_name = 1,
1618         .show_host_port_name = 1,
1619         .show_host_supported_classes = 1,
1620
1621         .get_host_port_id = qla2x00_get_host_port_id,
1622         .show_host_port_id = 1,
1623         .get_host_speed = qla2x00_get_host_speed,
1624         .show_host_speed = 1,
1625         .get_host_port_type = qla2x00_get_host_port_type,
1626         .show_host_port_type = 1,
1627         .get_host_symbolic_name = qla2x00_get_host_symbolic_name,
1628         .show_host_symbolic_name = 1,
1629         .set_host_system_hostname = qla2x00_set_host_system_hostname,
1630         .show_host_system_hostname = 1,
1631         .get_host_fabric_name = qla2x00_get_host_fabric_name,
1632         .show_host_fabric_name = 1,
1633         .get_host_port_state = qla2x00_get_host_port_state,
1634         .show_host_port_state = 1,
1635
1636         .dd_fcrport_size = sizeof(struct fc_port *),
1637         .show_rport_supported_classes = 1,
1638
1639         .get_starget_node_name = qla2x00_get_starget_node_name,
1640         .show_starget_node_name = 1,
1641         .get_starget_port_name = qla2x00_get_starget_port_name,
1642         .show_starget_port_name = 1,
1643         .get_starget_port_id  = qla2x00_get_starget_port_id,
1644         .show_starget_port_id = 1,
1645
1646         .set_rport_dev_loss_tmo = qla2x00_set_rport_loss_tmo,
1647         .show_rport_dev_loss_tmo = 1,
1648
1649         .issue_fc_host_lip = qla2x00_issue_lip,
1650         .dev_loss_tmo_callbk = qla2x00_dev_loss_tmo_callbk,
1651         .terminate_rport_io = qla2x00_terminate_rport_io,
1652         .get_fc_host_stats = qla2x00_get_fc_host_stats,
1653 };
1654
1655 void
1656 qla2x00_init_host_attr(scsi_qla_host_t *vha)
1657 {
1658         struct qla_hw_data *ha = vha->hw;
1659         u32 speed = FC_PORTSPEED_UNKNOWN;
1660
1661         fc_host_node_name(vha->host) = wwn_to_u64(vha->node_name);
1662         fc_host_port_name(vha->host) = wwn_to_u64(vha->port_name);
1663         fc_host_supported_classes(vha->host) = FC_COS_CLASS3;
1664         fc_host_max_npiv_vports(vha->host) = ha->max_npiv_vports;
1665         fc_host_npiv_vports_inuse(vha->host) = ha->cur_vport_count;
1666
1667         if (IS_QLA81XX(ha))
1668                 speed = FC_PORTSPEED_10GBIT;
1669         else if (IS_QLA25XX(ha))
1670                 speed = FC_PORTSPEED_8GBIT | FC_PORTSPEED_4GBIT |
1671                     FC_PORTSPEED_2GBIT | FC_PORTSPEED_1GBIT;
1672         else if (IS_QLA24XX_TYPE(ha))
1673                 speed = FC_PORTSPEED_4GBIT | FC_PORTSPEED_2GBIT |
1674                     FC_PORTSPEED_1GBIT;
1675         else if (IS_QLA23XX(ha))
1676                 speed = FC_PORTSPEED_2GBIT | FC_PORTSPEED_1GBIT;
1677         else
1678                 speed = FC_PORTSPEED_1GBIT;
1679         fc_host_supported_speeds(vha->host) = speed;
1680 }