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) &&
 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 DEVICE_ATTR(driver_version, S_IRUGO, qla2x00_drvr_version_show, NULL);
 819 static DEVICE_ATTR(fw_version, S_IRUGO, qla2x00_fw_version_show, NULL);
 820 static DEVICE_ATTR(serial_num, S_IRUGO, qla2x00_serial_num_show, NULL);
 821 static DEVICE_ATTR(isp_name, S_IRUGO, qla2x00_isp_name_show, NULL);
 822 static DEVICE_ATTR(isp_id, S_IRUGO, qla2x00_isp_id_show, NULL);
 823 static DEVICE_ATTR(model_name, S_IRUGO, qla2x00_model_name_show, NULL);
 824 static DEVICE_ATTR(model_desc, S_IRUGO, qla2x00_model_desc_show, NULL);
 825 static DEVICE_ATTR(pci_info, S_IRUGO, qla2x00_pci_info_show, NULL);
 826 static DEVICE_ATTR(link_state, S_IRUGO, qla2x00_link_state_show, NULL);
 827 static DEVICE_ATTR(zio, S_IRUGO | S_IWUSR, qla2x00_zio_show, qla2x00_zio_store);
 828 static DEVICE_ATTR(zio_timer, S_IRUGO | S_IWUSR, qla2x00_zio_timer_show,
 829                    qla2x00_zio_timer_store);
 830 static DEVICE_ATTR(beacon, S_IRUGO | S_IWUSR, qla2x00_beacon_show,
 831                    qla2x00_beacon_store);
 832 static DEVICE_ATTR(optrom_bios_version, S_IRUGO,
 833                    qla2x00_optrom_bios_version_show, NULL);
 834 static DEVICE_ATTR(optrom_efi_version, S_IRUGO,
 835                    qla2x00_optrom_efi_version_show, NULL);
 836 static DEVICE_ATTR(optrom_fcode_version, S_IRUGO,
 837                    qla2x00_optrom_fcode_version_show, NULL);
 838 static DEVICE_ATTR(optrom_fw_version, S_IRUGO, qla2x00_optrom_fw_version_show,
 839                    NULL);
 840 static DEVICE_ATTR(total_isp_aborts, S_IRUGO, qla2x00_total_isp_aborts_show,
 841                    NULL);
 842
 843 struct device_attribute *qla2x00_host_attrs[] = {
 844         &dev_attr_driver_version,
 845         &dev_attr_fw_version,
 846         &dev_attr_serial_num,
 847         &dev_attr_isp_name,
 848         &dev_attr_isp_id,
 849         &dev_attr_model_name,
 850         &dev_attr_model_desc,
 851         &dev_attr_pci_info,
 852         &dev_attr_link_state,
 853         &dev_attr_zio,
 854         &dev_attr_zio_timer,
 855         &dev_attr_beacon,
 856         &dev_attr_optrom_bios_version,
 857         &dev_attr_optrom_efi_version,
 858         &dev_attr_optrom_fcode_version,
 859         &dev_attr_optrom_fw_version,
 860         &dev_attr_total_isp_aborts,
 861         NULL,
 862 };
 863
 864 /* Host attributes. */
 865
 866 static void
 867 qla2x00_get_host_port_id(struct Scsi_Host *shost)
 868 {
 869         scsi_qla_host_t *vha = shost_priv(shost);
 870
 871         fc_host_port_id(shost) = vha->d_id.b.domain << 16 |
 872             vha->d_id.b.area << 8 | vha->d_id.b.al_pa;
 873 }
 874
 875 static void
 876 qla2x00_get_host_speed(struct Scsi_Host *shost)
 877 {
 878         struct qla_hw_data *ha = ((struct scsi_qla_host *)
 879                                         (shost_priv(shost)))->hw;
 880         u32 speed = FC_PORTSPEED_UNKNOWN;
 881
 882         switch (ha->link_data_rate) {
 883         case PORT_SPEED_1GB:
 884                 speed = FC_PORTSPEED_1GBIT;
 885                 break;
 886         case PORT_SPEED_2GB:
 887                 speed = FC_PORTSPEED_2GBIT;
 888                 break;
 889         case PORT_SPEED_4GB:
 890                 speed = FC_PORTSPEED_4GBIT;
 891                 break;
 892         case PORT_SPEED_8GB:
 893                 speed = FC_PORTSPEED_8GBIT;
 894                 break;
 895         }
 896         fc_host_speed(shost) = speed;
 897 }
 898
 899 static void
 900 qla2x00_get_host_port_type(struct Scsi_Host *shost)
 901 {
 902         scsi_qla_host_t *vha = shost_priv(shost);
 903         uint32_t port_type = FC_PORTTYPE_UNKNOWN;
 904
 905         if (vha->vp_idx) {
 906                 fc_host_port_type(shost) = FC_PORTTYPE_NPIV;
 907                 return;
 908         }
 909         switch (vha->hw->current_topology) {
 910         case ISP_CFG_NL:
 911                 port_type = FC_PORTTYPE_LPORT;
 912                 break;
 913         case ISP_CFG_FL:
 914                 port_type = FC_PORTTYPE_NLPORT;
 915                 break;
 916         case ISP_CFG_N:
 917                 port_type = FC_PORTTYPE_PTP;
 918                 break;
 919         case ISP_CFG_F:
 920                 port_type = FC_PORTTYPE_NPORT;
 921                 break;
 922         }
 923         fc_host_port_type(shost) = port_type;
 924 }
 925
 926 static void
 927 qla2x00_get_starget_node_name(struct scsi_target *starget)
 928 {
 929         struct Scsi_Host *host = dev_to_shost(starget->dev.parent);
 930         scsi_qla_host_t *vha = shost_priv(host);
 931         fc_port_t *fcport;
 932         u64 node_name = 0;
 933
 934         list_for_each_entry(fcport, &vha->vp_fcports, list) {
 935                 if (fcport->rport &&
 936                     starget->id == fcport->rport->scsi_target_id) {
 937                         node_name = wwn_to_u64(fcport->node_name);
 938                         break;
 939                 }
 940         }
 941
 942         fc_starget_node_name(starget) = node_name;
 943 }
 944
 945 static void
 946 qla2x00_get_starget_port_name(struct scsi_target *starget)
 947 {
 948         struct Scsi_Host *host = dev_to_shost(starget->dev.parent);
 949         scsi_qla_host_t *vha = shost_priv(host);
 950         fc_port_t *fcport;
 951         u64 port_name = 0;
 952
 953         list_for_each_entry(fcport, &vha->vp_fcports, list) {
 954                 if (fcport->rport &&
 955                     starget->id == fcport->rport->scsi_target_id) {
 956                         port_name = wwn_to_u64(fcport->port_name);
 957                         break;
 958                 }
 959         }
 960
 961         fc_starget_port_name(starget) = port_name;
 962 }
 963
 964 static void
 965 qla2x00_get_starget_port_id(struct scsi_target *starget)
 966 {
 967         struct Scsi_Host *host = dev_to_shost(starget->dev.parent);
 968         scsi_qla_host_t *vha = shost_priv(host);
 969         fc_port_t *fcport;
 970         uint32_t port_id = ~0U;
 971
 972         list_for_each_entry(fcport, &vha->vp_fcports, list) {
 973                 if (fcport->rport &&
 974                     starget->id == fcport->rport->scsi_target_id) {
 975                         port_id = fcport->d_id.b.domain << 16 |
 976                             fcport->d_id.b.area << 8 | fcport->d_id.b.al_pa;
 977                         break;
 978                 }
 979         }
 980
 981         fc_starget_port_id(starget) = port_id;
 982 }
 983
 984 static void
 985 qla2x00_set_rport_loss_tmo(struct fc_rport *rport, uint32_t timeout)
 986 {
 987         if (timeout)
 988                 rport->dev_loss_tmo = timeout;
 989         else
 990                 rport->dev_loss_tmo = 1;
 991 }
 992
 993 static void
 994 qla2x00_dev_loss_tmo_callbk(struct fc_rport *rport)
 995 {
 996         struct Scsi_Host *host = rport_to_shost(rport);
 997         fc_port_t *fcport = *(fc_port_t **)rport->dd_data;
 998
 999         qla2x00_abort_fcport_cmds(fcport);
1000
1001         /*
1002          * Transport has effectively 'deleted' the rport, clear
1003          * all local references.
1004          */
1005         spin_lock_irq(host->host_lock);
1006         fcport->rport = NULL;
1007         *((fc_port_t **)rport->dd_data) = NULL;
1008         spin_unlock_irq(host->host_lock);
1009 }
1010
1011 static void
1012 qla2x00_terminate_rport_io(struct fc_rport *rport)
1013 {
1014         fc_port_t *fcport = *(fc_port_t **)rport->dd_data;
1015
1016         /*
1017          * At this point all fcport's software-states are cleared.  Perform any
1018          * final cleanup of firmware resources (PCBs and XCBs).
1019          */
1020         if (fcport->loop_id != FC_NO_LOOP_ID) {
1021                 fcport->vha->hw->isp_ops->fabric_logout(fcport->vha,
1022                         fcport->loop_id, fcport->d_id.b.domain,
1023                         fcport->d_id.b.area, fcport->d_id.b.al_pa);
1024                 fcport->loop_id = FC_NO_LOOP_ID;
1025         }
1026
1027         qla2x00_abort_fcport_cmds(fcport);
1028 }
1029
1030 static int
1031 qla2x00_issue_lip(struct Scsi_Host *shost)
1032 {
1033         scsi_qla_host_t *vha = shost_priv(shost);
1034
1035         qla2x00_loop_reset(vha);
1036         return 0;
1037 }
1038
1039 static struct fc_host_statistics *
1040 qla2x00_get_fc_host_stats(struct Scsi_Host *shost)
1041 {
1042         scsi_qla_host_t *vha = shost_priv(shost);
1043         struct qla_hw_data *ha = vha->hw;
1044         struct scsi_qla_host *base_vha = pci_get_drvdata(ha->pdev);
1045         int rval;
1046         struct link_statistics *stats;
1047         dma_addr_t stats_dma;
1048         struct fc_host_statistics *pfc_host_stat;
1049
1050         pfc_host_stat = &ha->fc_host_stat;
1051         memset(pfc_host_stat, -1, sizeof(struct fc_host_statistics));
1052
1053         stats = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &stats_dma);
1054         if (stats == NULL) {
1055                 DEBUG2_3_11(printk("%s(%ld): Failed to allocate memory.\n",
1056                     __func__, base_vha->host_no));
1057                 goto done;
1058         }
1059         memset(stats, 0, DMA_POOL_SIZE);
1060
1061         rval = QLA_FUNCTION_FAILED;
1062         if (IS_FWI2_CAPABLE(ha)) {
1063                 rval = qla24xx_get_isp_stats(base_vha, stats, stats_dma);
1064         } else if (atomic_read(&base_vha->loop_state) == LOOP_READY &&
1065                     !test_bit(ABORT_ISP_ACTIVE, &base_vha->dpc_flags) &&
1066                     !test_bit(ISP_ABORT_NEEDED, &base_vha->dpc_flags) &&
1067                     !ha->dpc_active) {
1068                 /* Must be in a 'READY' state for statistics retrieval. */
1069                 rval = qla2x00_get_link_status(base_vha, base_vha->loop_id,
1070                                                 stats, stats_dma);
1071         }
1072
1073         if (rval != QLA_SUCCESS)
1074                 goto done_free;
1075
1076         pfc_host_stat->link_failure_count = stats->link_fail_cnt;
1077         pfc_host_stat->loss_of_sync_count = stats->loss_sync_cnt;
1078         pfc_host_stat->loss_of_signal_count = stats->loss_sig_cnt;
1079         pfc_host_stat->prim_seq_protocol_err_count = stats->prim_seq_err_cnt;
1080         pfc_host_stat->invalid_tx_word_count = stats->inval_xmit_word_cnt;
1081         pfc_host_stat->invalid_crc_count = stats->inval_crc_cnt;
1082         if (IS_FWI2_CAPABLE(ha)) {
1083                 pfc_host_stat->lip_count = stats->lip_cnt;
1084                 pfc_host_stat->tx_frames = stats->tx_frames;
1085                 pfc_host_stat->rx_frames = stats->rx_frames;
1086                 pfc_host_stat->dumped_frames = stats->dumped_frames;
1087                 pfc_host_stat->nos_count = stats->nos_rcvd;
1088         }
1089         pfc_host_stat->fcp_input_megabytes = ha->qla_stats.input_bytes >> 20;
1090         pfc_host_stat->fcp_output_megabytes = ha->qla_stats.output_bytes >> 20;
1091
1092 done_free:
1093         dma_pool_free(ha->s_dma_pool, stats, stats_dma);
1094 done:
1095         return pfc_host_stat;
1096 }
1097
1098 static void
1099 qla2x00_get_host_symbolic_name(struct Scsi_Host *shost)
1100 {
1101         scsi_qla_host_t *vha = shost_priv(shost);
1102
1103         qla2x00_get_sym_node_name(vha, fc_host_symbolic_name(shost));
1104 }
1105
1106 static void
1107 qla2x00_set_host_system_hostname(struct Scsi_Host *shost)
1108 {
1109         scsi_qla_host_t *vha = shost_priv(shost);
1110
1111         set_bit(REGISTER_FDMI_NEEDED, &vha->dpc_flags);
1112 }
1113
1114 static void
1115 qla2x00_get_host_fabric_name(struct Scsi_Host *shost)
1116 {
1117         scsi_qla_host_t *vha = shost_priv(shost);
1118         u64 node_name;
1119
1120         if (vha->device_flags & SWITCH_FOUND)
1121                 node_name = wwn_to_u64(vha->fabric_node_name);
1122         else
1123                 node_name = wwn_to_u64(vha->node_name);
1124
1125         fc_host_fabric_name(shost) = node_name;
1126 }
1127
1128 static void
1129 qla2x00_get_host_port_state(struct Scsi_Host *shost)
1130 {
1131         scsi_qla_host_t *vha = shost_priv(shost);
1132         struct scsi_qla_host *base_vha = pci_get_drvdata(vha->hw->pdev);
1133
1134         if (!base_vha->flags.online)
1135                 fc_host_port_state(shost) = FC_PORTSTATE_OFFLINE;
1136         else if (atomic_read(&base_vha->loop_state) == LOOP_TIMEOUT)
1137                 fc_host_port_state(shost) = FC_PORTSTATE_UNKNOWN;
1138         else
1139                 fc_host_port_state(shost) = FC_PORTSTATE_ONLINE;
1140 }
1141
1142 static int
1143 qla24xx_vport_create(struct fc_vport *fc_vport, bool disable)
1144 {
1145         int     ret = 0;
1146         scsi_qla_host_t *base_vha = shost_priv(fc_vport->shost);
1147         scsi_qla_host_t *vha = NULL;
1148
1149         ret = qla24xx_vport_create_req_sanity_check(fc_vport);
1150         if (ret) {
1151                 DEBUG15(printk("qla24xx_vport_create_req_sanity_check failed, "
1152                     "status %x\n", ret));
1153                 return (ret);
1154         }
1155
1156         vha = qla24xx_create_vhost(fc_vport);
1157         if (vha == NULL) {
1158                 DEBUG15(printk ("qla24xx_create_vhost failed, vha = %p\n",
1159                     vha));
1160                 return FC_VPORT_FAILED;
1161         }
1162         if (disable) {
1163                 atomic_set(&vha->vp_state, VP_OFFLINE);
1164                 fc_vport_set_state(fc_vport, FC_VPORT_DISABLED);
1165         } else
1166                 atomic_set(&vha->vp_state, VP_FAILED);
1167
1168         /* ready to create vport */
1169         qla_printk(KERN_INFO, vha->hw, "VP entry id %d assigned.\n",
1170                                                         vha->vp_idx);
1171
1172         /* initialized vport states */
1173         atomic_set(&vha->loop_state, LOOP_DOWN);
1174         vha->vp_err_state=  VP_ERR_PORTDWN;
1175         vha->vp_prev_err_state=  VP_ERR_UNKWN;
1176         /* Check if physical ha port is Up */
1177         if (atomic_read(&base_vha->loop_state) == LOOP_DOWN ||
1178             atomic_read(&base_vha->loop_state) == LOOP_DEAD) {
1179                 /* Don't retry or attempt login of this virtual port */
1180                 DEBUG15(printk ("scsi(%ld): pport loop_state is not UP.\n",
1181                     base_vha->host_no));
1182                 atomic_set(&vha->loop_state, LOOP_DEAD);
1183                 if (!disable)
1184                         fc_vport_set_state(fc_vport, FC_VPORT_LINKDOWN);
1185         }
1186
1187         if (scsi_add_host(vha->host, &fc_vport->dev)) {
1188                 DEBUG15(printk("scsi(%ld): scsi_add_host failure for VP[%d].\n",
1189                         vha->host_no, vha->vp_idx));
1190                 goto vport_create_failed_2;
1191         }
1192
1193         /* initialize attributes */
1194         fc_host_node_name(vha->host) = wwn_to_u64(vha->node_name);
1195         fc_host_port_name(vha->host) = wwn_to_u64(vha->port_name);
1196         fc_host_supported_classes(vha->host) =
1197                 fc_host_supported_classes(base_vha->host);
1198         fc_host_supported_speeds(vha->host) =
1199                 fc_host_supported_speeds(base_vha->host);
1200
1201         qla24xx_vport_disable(fc_vport, disable);
1202
1203         return 0;
1204 vport_create_failed_2:
1205         qla24xx_disable_vp(vha);
1206         qla24xx_deallocate_vp_id(vha);
1207         scsi_host_put(vha->host);
1208         return FC_VPORT_FAILED;
1209 }
1210
1211 static int
1212 qla24xx_vport_delete(struct fc_vport *fc_vport)
1213 {
1214         scsi_qla_host_t *vha = fc_vport->dd_data;
1215         fc_port_t *fcport, *tfcport;
1216
1217         while (test_bit(LOOP_RESYNC_ACTIVE, &vha->dpc_flags) ||
1218             test_bit(FCPORT_UPDATE_NEEDED, &vha->dpc_flags))
1219                 msleep(1000);
1220
1221         qla24xx_disable_vp(vha);
1222
1223         fc_remove_host(vha->host);
1224
1225         scsi_remove_host(vha->host);
1226
1227         list_for_each_entry_safe(fcport, tfcport, &vha->vp_fcports, list) {
1228                 list_del(&fcport->list);
1229                 kfree(fcport);
1230                 fcport = NULL;
1231         }
1232
1233         qla24xx_deallocate_vp_id(vha);
1234
1235         if (vha->timer_active) {
1236                 qla2x00_vp_stop_timer(vha);
1237                 DEBUG15(printk ("scsi(%ld): timer for the vport[%d] = %p "
1238                     "has stopped\n",
1239                     vha->host_no, vha->vp_idx, vha));
1240         }
1241
1242         scsi_host_put(vha->host);
1243
1244         return 0;
1245 }
1246
1247 static int
1248 qla24xx_vport_disable(struct fc_vport *fc_vport, bool disable)
1249 {
1250         scsi_qla_host_t *vha = fc_vport->dd_data;
1251
1252         if (disable)
1253                 qla24xx_disable_vp(vha);
1254         else
1255                 qla24xx_enable_vp(vha);
1256
1257         return 0;
1258 }
1259
1260 struct fc_function_template qla2xxx_transport_functions = {
1261
1262         .show_host_node_name = 1,
1263         .show_host_port_name = 1,
1264         .show_host_supported_classes = 1,
1265         .show_host_supported_speeds = 1,
1266
1267         .get_host_port_id = qla2x00_get_host_port_id,
1268         .show_host_port_id = 1,
1269         .get_host_speed = qla2x00_get_host_speed,
1270         .show_host_speed = 1,
1271         .get_host_port_type = qla2x00_get_host_port_type,
1272         .show_host_port_type = 1,
1273         .get_host_symbolic_name = qla2x00_get_host_symbolic_name,
1274         .show_host_symbolic_name = 1,
1275         .set_host_system_hostname = qla2x00_set_host_system_hostname,
1276         .show_host_system_hostname = 1,
1277         .get_host_fabric_name = qla2x00_get_host_fabric_name,
1278         .show_host_fabric_name = 1,
1279         .get_host_port_state = qla2x00_get_host_port_state,
1280         .show_host_port_state = 1,
1281
1282         .dd_fcrport_size = sizeof(struct fc_port *),
1283         .show_rport_supported_classes = 1,
1284
1285         .get_starget_node_name = qla2x00_get_starget_node_name,
1286         .show_starget_node_name = 1,
1287         .get_starget_port_name = qla2x00_get_starget_port_name,
1288         .show_starget_port_name = 1,
1289         .get_starget_port_id  = qla2x00_get_starget_port_id,
1290         .show_starget_port_id = 1,
1291
1292         .set_rport_dev_loss_tmo = qla2x00_set_rport_loss_tmo,
1293         .show_rport_dev_loss_tmo = 1,
1294
1295         .issue_fc_host_lip = qla2x00_issue_lip,
1296         .dev_loss_tmo_callbk = qla2x00_dev_loss_tmo_callbk,
1297         .terminate_rport_io = qla2x00_terminate_rport_io,
1298         .get_fc_host_stats = qla2x00_get_fc_host_stats,
1299
1300         .vport_create = qla24xx_vport_create,
1301         .vport_disable = qla24xx_vport_disable,
1302         .vport_delete = qla24xx_vport_delete,
1303 };
1304
1305 struct fc_function_template qla2xxx_transport_vport_functions = {
1306
1307         .show_host_node_name = 1,
1308         .show_host_port_name = 1,
1309         .show_host_supported_classes = 1,
1310
1311         .get_host_port_id = qla2x00_get_host_port_id,
1312         .show_host_port_id = 1,
1313         .get_host_speed = qla2x00_get_host_speed,
1314         .show_host_speed = 1,
1315         .get_host_port_type = qla2x00_get_host_port_type,
1316         .show_host_port_type = 1,
1317         .get_host_symbolic_name = qla2x00_get_host_symbolic_name,
1318         .show_host_symbolic_name = 1,
1319         .set_host_system_hostname = qla2x00_set_host_system_hostname,
1320         .show_host_system_hostname = 1,
1321         .get_host_fabric_name = qla2x00_get_host_fabric_name,
1322         .show_host_fabric_name = 1,
1323         .get_host_port_state = qla2x00_get_host_port_state,
1324         .show_host_port_state = 1,
1325
1326         .dd_fcrport_size = sizeof(struct fc_port *),
1327         .show_rport_supported_classes = 1,
1328
1329         .get_starget_node_name = qla2x00_get_starget_node_name,
1330         .show_starget_node_name = 1,
1331         .get_starget_port_name = qla2x00_get_starget_port_name,
1332         .show_starget_port_name = 1,
1333         .get_starget_port_id  = qla2x00_get_starget_port_id,
1334         .show_starget_port_id = 1,
1335
1336         .set_rport_dev_loss_tmo = qla2x00_set_rport_loss_tmo,
1337         .show_rport_dev_loss_tmo = 1,
1338
1339         .issue_fc_host_lip = qla2x00_issue_lip,
1340         .dev_loss_tmo_callbk = qla2x00_dev_loss_tmo_callbk,
1341         .terminate_rport_io = qla2x00_terminate_rport_io,
1342         .get_fc_host_stats = qla2x00_get_fc_host_stats,
1343 };
1344
1345 void
1346 qla2x00_init_host_attr(scsi_qla_host_t *vha)
1347 {
1348         struct qla_hw_data *ha = vha->hw;
1349         u32 speed = FC_PORTSPEED_UNKNOWN;
1350
1351         fc_host_node_name(vha->host) = wwn_to_u64(vha->node_name);
1352         fc_host_port_name(vha->host) = wwn_to_u64(vha->port_name);
1353         fc_host_supported_classes(vha->host) = FC_COS_CLASS3;
1354         fc_host_max_npiv_vports(vha->host) = ha->max_npiv_vports;
1355         fc_host_npiv_vports_inuse(vha->host) = ha->cur_vport_count;
1356
1357         if (IS_QLA25XX(ha))
1358                 speed = FC_PORTSPEED_8GBIT | FC_PORTSPEED_4GBIT |
1359                     FC_PORTSPEED_2GBIT | FC_PORTSPEED_1GBIT;
1360         else if (IS_QLA24XX_TYPE(ha))
1361                 speed = FC_PORTSPEED_4GBIT | FC_PORTSPEED_2GBIT |
1362                     FC_PORTSPEED_1GBIT;
1363         else if (IS_QLA23XX(ha))
1364                 speed = FC_PORTSPEED_2GBIT | FC_PORTSPEED_1GBIT;
1365         else
1366                 speed = FC_PORTSPEED_1GBIT;
1367         fc_host_supported_speeds(vha->host) = speed;
1368 }