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         qla2x00_abort_fcport_cmds(fcport);
1020
1021         /*
1022          * Transport has effectively 'deleted' the rport, clear
1023          * all local references.
1024          */
1025         spin_lock_irq(host->host_lock);
1026         fcport->rport = NULL;
1027         *((fc_port_t **)rport->dd_data) = NULL;
1028         spin_unlock_irq(host->host_lock);
1029 }
1030
1031 static void
1032 qla2x00_terminate_rport_io(struct fc_rport *rport)
1033 {
1034         fc_port_t *fcport = *(fc_port_t **)rport->dd_data;
1035
1036         /*
1037          * At this point all fcport's software-states are cleared.  Perform any
1038          * final cleanup of firmware resources (PCBs and XCBs).
1039          */
1040         if (fcport->loop_id != FC_NO_LOOP_ID) {
1041                 fcport->vha->hw->isp_ops->fabric_logout(fcport->vha,
1042                         fcport->loop_id, fcport->d_id.b.domain,
1043                         fcport->d_id.b.area, fcport->d_id.b.al_pa);
1044                 fcport->loop_id = FC_NO_LOOP_ID;
1045         }
1046
1047         qla2x00_abort_fcport_cmds(fcport);
1048 }
1049
1050 static int
1051 qla2x00_issue_lip(struct Scsi_Host *shost)
1052 {
1053         scsi_qla_host_t *vha = shost_priv(shost);
1054
1055         qla2x00_loop_reset(vha);
1056         return 0;
1057 }
1058
1059 static struct fc_host_statistics *
1060 qla2x00_get_fc_host_stats(struct Scsi_Host *shost)
1061 {
1062         scsi_qla_host_t *vha = shost_priv(shost);
1063         struct qla_hw_data *ha = vha->hw;
1064         struct scsi_qla_host *base_vha = pci_get_drvdata(ha->pdev);
1065         int rval;
1066         struct link_statistics *stats;
1067         dma_addr_t stats_dma;
1068         struct fc_host_statistics *pfc_host_stat;
1069
1070         pfc_host_stat = &ha->fc_host_stat;
1071         memset(pfc_host_stat, -1, sizeof(struct fc_host_statistics));
1072
1073         stats = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &stats_dma);
1074         if (stats == NULL) {
1075                 DEBUG2_3_11(printk("%s(%ld): Failed to allocate memory.\n",
1076                     __func__, base_vha->host_no));
1077                 goto done;
1078         }
1079         memset(stats, 0, DMA_POOL_SIZE);
1080
1081         rval = QLA_FUNCTION_FAILED;
1082         if (IS_FWI2_CAPABLE(ha)) {
1083                 rval = qla24xx_get_isp_stats(base_vha, stats, stats_dma);
1084         } else if (atomic_read(&base_vha->loop_state) == LOOP_READY &&
1085                     !test_bit(ABORT_ISP_ACTIVE, &base_vha->dpc_flags) &&
1086                     !test_bit(ISP_ABORT_NEEDED, &base_vha->dpc_flags) &&
1087                     !ha->dpc_active) {
1088                 /* Must be in a 'READY' state for statistics retrieval. */
1089                 rval = qla2x00_get_link_status(base_vha, base_vha->loop_id,
1090                                                 stats, stats_dma);
1091         }
1092
1093         if (rval != QLA_SUCCESS)
1094                 goto done_free;
1095
1096         pfc_host_stat->link_failure_count = stats->link_fail_cnt;
1097         pfc_host_stat->loss_of_sync_count = stats->loss_sync_cnt;
1098         pfc_host_stat->loss_of_signal_count = stats->loss_sig_cnt;
1099         pfc_host_stat->prim_seq_protocol_err_count = stats->prim_seq_err_cnt;
1100         pfc_host_stat->invalid_tx_word_count = stats->inval_xmit_word_cnt;
1101         pfc_host_stat->invalid_crc_count = stats->inval_crc_cnt;
1102         if (IS_FWI2_CAPABLE(ha)) {
1103                 pfc_host_stat->lip_count = stats->lip_cnt;
1104                 pfc_host_stat->tx_frames = stats->tx_frames;
1105                 pfc_host_stat->rx_frames = stats->rx_frames;
1106                 pfc_host_stat->dumped_frames = stats->dumped_frames;
1107                 pfc_host_stat->nos_count = stats->nos_rcvd;
1108         }
1109         pfc_host_stat->fcp_input_megabytes = ha->qla_stats.input_bytes >> 20;
1110         pfc_host_stat->fcp_output_megabytes = ha->qla_stats.output_bytes >> 20;
1111
1112 done_free:
1113         dma_pool_free(ha->s_dma_pool, stats, stats_dma);
1114 done:
1115         return pfc_host_stat;
1116 }
1117
1118 static void
1119 qla2x00_get_host_symbolic_name(struct Scsi_Host *shost)
1120 {
1121         scsi_qla_host_t *vha = shost_priv(shost);
1122
1123         qla2x00_get_sym_node_name(vha, fc_host_symbolic_name(shost));
1124 }
1125
1126 static void
1127 qla2x00_set_host_system_hostname(struct Scsi_Host *shost)
1128 {
1129         scsi_qla_host_t *vha = shost_priv(shost);
1130
1131         set_bit(REGISTER_FDMI_NEEDED, &vha->dpc_flags);
1132 }
1133
1134 static void
1135 qla2x00_get_host_fabric_name(struct Scsi_Host *shost)
1136 {
1137         scsi_qla_host_t *vha = shost_priv(shost);
1138         u64 node_name;
1139
1140         if (vha->device_flags & SWITCH_FOUND)
1141                 node_name = wwn_to_u64(vha->fabric_node_name);
1142         else
1143                 node_name = wwn_to_u64(vha->node_name);
1144
1145         fc_host_fabric_name(shost) = node_name;
1146 }
1147
1148 static void
1149 qla2x00_get_host_port_state(struct Scsi_Host *shost)
1150 {
1151         scsi_qla_host_t *vha = shost_priv(shost);
1152         struct scsi_qla_host *base_vha = pci_get_drvdata(vha->hw->pdev);
1153
1154         if (!base_vha->flags.online)
1155                 fc_host_port_state(shost) = FC_PORTSTATE_OFFLINE;
1156         else if (atomic_read(&base_vha->loop_state) == LOOP_TIMEOUT)
1157                 fc_host_port_state(shost) = FC_PORTSTATE_UNKNOWN;
1158         else
1159                 fc_host_port_state(shost) = FC_PORTSTATE_ONLINE;
1160 }
1161
1162 static int
1163 qla24xx_vport_create(struct fc_vport *fc_vport, bool disable)
1164 {
1165         int     ret = 0;
1166         int     cnt = 0;
1167         uint8_t qos = QLA_DEFAULT_QUE_QOS;
1168         scsi_qla_host_t *base_vha = shost_priv(fc_vport->shost);
1169         scsi_qla_host_t *vha = NULL;
1170         struct qla_hw_data *ha = base_vha->hw;
1171
1172         ret = qla24xx_vport_create_req_sanity_check(fc_vport);
1173         if (ret) {
1174                 DEBUG15(printk("qla24xx_vport_create_req_sanity_check failed, "
1175                     "status %x\n", ret));
1176                 return (ret);
1177         }
1178
1179         vha = qla24xx_create_vhost(fc_vport);
1180         if (vha == NULL) {
1181                 DEBUG15(printk ("qla24xx_create_vhost failed, vha = %p\n",
1182                     vha));
1183                 return FC_VPORT_FAILED;
1184         }
1185         if (disable) {
1186                 atomic_set(&vha->vp_state, VP_OFFLINE);
1187                 fc_vport_set_state(fc_vport, FC_VPORT_DISABLED);
1188         } else
1189                 atomic_set(&vha->vp_state, VP_FAILED);
1190
1191         /* ready to create vport */
1192         qla_printk(KERN_INFO, vha->hw, "VP entry id %d assigned.\n",
1193                                                         vha->vp_idx);
1194
1195         /* initialized vport states */
1196         atomic_set(&vha->loop_state, LOOP_DOWN);
1197         vha->vp_err_state=  VP_ERR_PORTDWN;
1198         vha->vp_prev_err_state=  VP_ERR_UNKWN;
1199         /* Check if physical ha port is Up */
1200         if (atomic_read(&base_vha->loop_state) == LOOP_DOWN ||
1201             atomic_read(&base_vha->loop_state) == LOOP_DEAD) {
1202                 /* Don't retry or attempt login of this virtual port */
1203                 DEBUG15(printk ("scsi(%ld): pport loop_state is not UP.\n",
1204                     base_vha->host_no));
1205                 atomic_set(&vha->loop_state, LOOP_DEAD);
1206                 if (!disable)
1207                         fc_vport_set_state(fc_vport, FC_VPORT_LINKDOWN);
1208         }
1209
1210         if (scsi_add_host(vha->host, &fc_vport->dev)) {
1211                 DEBUG15(printk("scsi(%ld): scsi_add_host failure for VP[%d].\n",
1212                         vha->host_no, vha->vp_idx));
1213                 goto vport_create_failed_2;
1214         }
1215
1216         /* initialize attributes */
1217         fc_host_node_name(vha->host) = wwn_to_u64(vha->node_name);
1218         fc_host_port_name(vha->host) = wwn_to_u64(vha->port_name);
1219         fc_host_supported_classes(vha->host) =
1220                 fc_host_supported_classes(base_vha->host);
1221         fc_host_supported_speeds(vha->host) =
1222                 fc_host_supported_speeds(base_vha->host);
1223
1224         qla24xx_vport_disable(fc_vport, disable);
1225
1226         /* Create a queue pair for the vport */
1227         if (ha->mqenable) {
1228                 if (ha->npiv_info) {
1229                         for (; cnt < ha->nvram_npiv_size; cnt++) {
1230                                 if (ha->npiv_info[cnt].port_name ==
1231                                         vha->port_name &&
1232                                         ha->npiv_info[cnt].node_name ==
1233                                         vha->node_name) {
1234                                         qos = ha->npiv_info[cnt].q_qos;
1235                                         break;
1236                                 }
1237                         }
1238                 }
1239                 qla25xx_create_queues(vha, qos);
1240         }
1241
1242         return 0;
1243 vport_create_failed_2:
1244         qla24xx_disable_vp(vha);
1245         qla24xx_deallocate_vp_id(vha);
1246         scsi_host_put(vha->host);
1247         return FC_VPORT_FAILED;
1248 }
1249
1250 static int
1251 qla24xx_vport_delete(struct fc_vport *fc_vport)
1252 {
1253         scsi_qla_host_t *vha = fc_vport->dd_data;
1254         fc_port_t *fcport, *tfcport;
1255         struct qla_hw_data *ha = vha->hw;
1256         uint16_t id = vha->vp_idx;
1257
1258         while (test_bit(LOOP_RESYNC_ACTIVE, &vha->dpc_flags) ||
1259             test_bit(FCPORT_UPDATE_NEEDED, &vha->dpc_flags))
1260                 msleep(1000);
1261
1262         if (ha->mqenable) {
1263                 if (qla25xx_delete_queues(vha, 0) != QLA_SUCCESS)
1264                         qla_printk(KERN_WARNING, ha,
1265                                 "Queue delete failed.\n");
1266                 vha->req_ques[0] = ha->req_q_map[0]->id;
1267         }
1268
1269         qla24xx_disable_vp(vha);
1270
1271         fc_remove_host(vha->host);
1272
1273         scsi_remove_host(vha->host);
1274
1275         list_for_each_entry_safe(fcport, tfcport, &vha->vp_fcports, list) {
1276                 list_del(&fcport->list);
1277                 kfree(fcport);
1278                 fcport = NULL;
1279         }
1280
1281         qla24xx_deallocate_vp_id(vha);
1282
1283         if (vha->timer_active) {
1284                 qla2x00_vp_stop_timer(vha);
1285                 DEBUG15(printk ("scsi(%ld): timer for the vport[%d] = %p "
1286                     "has stopped\n",
1287                     vha->host_no, vha->vp_idx, vha));
1288         }
1289
1290         scsi_host_put(vha->host);
1291         qla_printk(KERN_INFO, ha, "vport %d deleted\n", id);
1292         return 0;
1293 }
1294
1295 static int
1296 qla24xx_vport_disable(struct fc_vport *fc_vport, bool disable)
1297 {
1298         scsi_qla_host_t *vha = fc_vport->dd_data;
1299
1300         if (disable)
1301                 qla24xx_disable_vp(vha);
1302         else
1303                 qla24xx_enable_vp(vha);
1304
1305         return 0;
1306 }
1307
1308 struct fc_function_template qla2xxx_transport_functions = {
1309
1310         .show_host_node_name = 1,
1311         .show_host_port_name = 1,
1312         .show_host_supported_classes = 1,
1313         .show_host_supported_speeds = 1,
1314
1315         .get_host_port_id = qla2x00_get_host_port_id,
1316         .show_host_port_id = 1,
1317         .get_host_speed = qla2x00_get_host_speed,
1318         .show_host_speed = 1,
1319         .get_host_port_type = qla2x00_get_host_port_type,
1320         .show_host_port_type = 1,
1321         .get_host_symbolic_name = qla2x00_get_host_symbolic_name,
1322         .show_host_symbolic_name = 1,
1323         .set_host_system_hostname = qla2x00_set_host_system_hostname,
1324         .show_host_system_hostname = 1,
1325         .get_host_fabric_name = qla2x00_get_host_fabric_name,
1326         .show_host_fabric_name = 1,
1327         .get_host_port_state = qla2x00_get_host_port_state,
1328         .show_host_port_state = 1,
1329
1330         .dd_fcrport_size = sizeof(struct fc_port *),
1331         .show_rport_supported_classes = 1,
1332
1333         .get_starget_node_name = qla2x00_get_starget_node_name,
1334         .show_starget_node_name = 1,
1335         .get_starget_port_name = qla2x00_get_starget_port_name,
1336         .show_starget_port_name = 1,
1337         .get_starget_port_id  = qla2x00_get_starget_port_id,
1338         .show_starget_port_id = 1,
1339
1340         .set_rport_dev_loss_tmo = qla2x00_set_rport_loss_tmo,
1341         .show_rport_dev_loss_tmo = 1,
1342
1343         .issue_fc_host_lip = qla2x00_issue_lip,
1344         .dev_loss_tmo_callbk = qla2x00_dev_loss_tmo_callbk,
1345         .terminate_rport_io = qla2x00_terminate_rport_io,
1346         .get_fc_host_stats = qla2x00_get_fc_host_stats,
1347
1348         .vport_create = qla24xx_vport_create,
1349         .vport_disable = qla24xx_vport_disable,
1350         .vport_delete = qla24xx_vport_delete,
1351 };
1352
1353 struct fc_function_template qla2xxx_transport_vport_functions = {
1354
1355         .show_host_node_name = 1,
1356         .show_host_port_name = 1,
1357         .show_host_supported_classes = 1,
1358
1359         .get_host_port_id = qla2x00_get_host_port_id,
1360         .show_host_port_id = 1,
1361         .get_host_speed = qla2x00_get_host_speed,
1362         .show_host_speed = 1,
1363         .get_host_port_type = qla2x00_get_host_port_type,
1364         .show_host_port_type = 1,
1365         .get_host_symbolic_name = qla2x00_get_host_symbolic_name,
1366         .show_host_symbolic_name = 1,
1367         .set_host_system_hostname = qla2x00_set_host_system_hostname,
1368         .show_host_system_hostname = 1,
1369         .get_host_fabric_name = qla2x00_get_host_fabric_name,
1370         .show_host_fabric_name = 1,
1371         .get_host_port_state = qla2x00_get_host_port_state,
1372         .show_host_port_state = 1,
1373
1374         .dd_fcrport_size = sizeof(struct fc_port *),
1375         .show_rport_supported_classes = 1,
1376
1377         .get_starget_node_name = qla2x00_get_starget_node_name,
1378         .show_starget_node_name = 1,
1379         .get_starget_port_name = qla2x00_get_starget_port_name,
1380         .show_starget_port_name = 1,
1381         .get_starget_port_id  = qla2x00_get_starget_port_id,
1382         .show_starget_port_id = 1,
1383
1384         .set_rport_dev_loss_tmo = qla2x00_set_rport_loss_tmo,
1385         .show_rport_dev_loss_tmo = 1,
1386
1387         .issue_fc_host_lip = qla2x00_issue_lip,
1388         .dev_loss_tmo_callbk = qla2x00_dev_loss_tmo_callbk,
1389         .terminate_rport_io = qla2x00_terminate_rport_io,
1390         .get_fc_host_stats = qla2x00_get_fc_host_stats,
1391 };
1392
1393 void
1394 qla2x00_init_host_attr(scsi_qla_host_t *vha)
1395 {
1396         struct qla_hw_data *ha = vha->hw;
1397         u32 speed = FC_PORTSPEED_UNKNOWN;
1398
1399         fc_host_node_name(vha->host) = wwn_to_u64(vha->node_name);
1400         fc_host_port_name(vha->host) = wwn_to_u64(vha->port_name);
1401         fc_host_supported_classes(vha->host) = FC_COS_CLASS3;
1402         fc_host_max_npiv_vports(vha->host) = ha->max_npiv_vports;
1403         fc_host_npiv_vports_inuse(vha->host) = ha->cur_vport_count;
1404
1405         if (IS_QLA81XX(ha))
1406                 speed = FC_PORTSPEED_10GBIT;
1407         else if (IS_QLA25XX(ha))
1408                 speed = FC_PORTSPEED_8GBIT | FC_PORTSPEED_4GBIT |
1409                     FC_PORTSPEED_2GBIT | FC_PORTSPEED_1GBIT;
1410         else if (IS_QLA24XX_TYPE(ha))
1411                 speed = FC_PORTSPEED_4GBIT | FC_PORTSPEED_2GBIT |
1412                     FC_PORTSPEED_1GBIT;
1413         else if (IS_QLA23XX(ha))
1414                 speed = FC_PORTSPEED_2GBIT | FC_PORTSPEED_1GBIT;
1415         else
1416                 speed = FC_PORTSPEED_1GBIT;
1417         fc_host_supported_speeds(vha->host) = speed;
1418 }