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