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