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