2 * QLogic Fibre Channel HBA Driver
3 * Copyright (c) 2003-2008 QLogic Corporation
5 * See LICENSE.qla2xxx for copyright and licensing details.
9 #include <linux/kthread.h>
10 #include <linux/vmalloc.h>
12 static int qla24xx_vport_disable(struct fc_vport *, bool);
14 /* SYSFS attributes --------------------------------------------------------- */
17 qla2x00_sysfs_read_fw_dump(struct kobject *kobj,
18 struct bin_attribute *bin_attr,
19 char *buf, loff_t off, size_t count)
21 struct scsi_qla_host *ha = shost_priv(dev_to_shost(container_of(kobj,
22 struct device, kobj)));
23 char *rbuf = (char *)ha->fw_dump;
25 if (ha->fw_dump_reading == 0)
27 if (off > ha->fw_dump_len)
29 if (off + count > ha->fw_dump_len)
30 count = ha->fw_dump_len - off;
32 memcpy(buf, &rbuf[off], count);
38 qla2x00_sysfs_write_fw_dump(struct kobject *kobj,
39 struct bin_attribute *bin_attr,
40 char *buf, loff_t off, size_t count)
42 struct scsi_qla_host *ha = shost_priv(dev_to_shost(container_of(kobj,
43 struct device, kobj)));
49 reading = simple_strtol(buf, NULL, 10);
52 if (!ha->fw_dump_reading)
55 qla_printk(KERN_INFO, ha,
56 "Firmware dump cleared on (%ld).\n", ha->host_no);
58 ha->fw_dump_reading = 0;
62 if (ha->fw_dumped && !ha->fw_dump_reading) {
63 ha->fw_dump_reading = 1;
65 qla_printk(KERN_INFO, ha,
66 "Raw firmware dump ready for read on (%ld).\n",
71 qla2x00_alloc_fw_dump(ha);
74 qla2x00_system_error(ha);
80 static struct bin_attribute sysfs_fw_dump_attr = {
83 .mode = S_IRUSR | S_IWUSR,
86 .read = qla2x00_sysfs_read_fw_dump,
87 .write = qla2x00_sysfs_write_fw_dump,
91 qla2x00_sysfs_read_nvram(struct kobject *kobj,
92 struct bin_attribute *bin_attr,
93 char *buf, loff_t off, size_t count)
95 struct scsi_qla_host *ha = shost_priv(dev_to_shost(container_of(kobj,
96 struct device, kobj)));
97 int size = ha->nvram_size;
98 char *nvram_cache = ha->nvram;
100 if (!capable(CAP_SYS_ADMIN) || off > size || count == 0)
102 if (off + count > size) {
107 /* Read NVRAM data from cache. */
108 memcpy(buf, &nvram_cache[off], count);
114 qla2x00_sysfs_write_nvram(struct kobject *kobj,
115 struct bin_attribute *bin_attr,
116 char *buf, loff_t off, size_t count)
118 struct scsi_qla_host *ha = shost_priv(dev_to_shost(container_of(kobj,
119 struct device, kobj)));
122 if (!capable(CAP_SYS_ADMIN) || off != 0 || count != ha->nvram_size)
125 /* Checksum NVRAM. */
126 if (IS_FWI2_CAPABLE(ha)) {
130 iter = (uint32_t *)buf;
132 for (cnt = 0; cnt < ((count >> 2) - 1); cnt++)
133 chksum += le32_to_cpu(*iter++);
134 chksum = ~chksum + 1;
135 *iter = cpu_to_le32(chksum);
140 iter = (uint8_t *)buf;
142 for (cnt = 0; cnt < count - 1; cnt++)
144 chksum = ~chksum + 1;
149 ha->isp_ops->write_nvram(ha, (uint8_t *)buf, ha->nvram_base, count);
150 ha->isp_ops->read_nvram(ha, (uint8_t *)ha->nvram, ha->nvram_base,
153 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
158 static struct bin_attribute sysfs_nvram_attr = {
161 .mode = S_IRUSR | S_IWUSR,
164 .read = qla2x00_sysfs_read_nvram,
165 .write = qla2x00_sysfs_write_nvram,
169 qla2x00_sysfs_read_optrom(struct kobject *kobj,
170 struct bin_attribute *bin_attr,
171 char *buf, loff_t off, size_t count)
173 struct scsi_qla_host *ha = shost_priv(dev_to_shost(container_of(kobj,
174 struct device, kobj)));
176 if (ha->optrom_state != QLA_SREADING)
178 if (off > ha->optrom_region_size)
180 if (off + count > ha->optrom_region_size)
181 count = ha->optrom_region_size - off;
183 memcpy(buf, &ha->optrom_buffer[off], count);
189 qla2x00_sysfs_write_optrom(struct kobject *kobj,
190 struct bin_attribute *bin_attr,
191 char *buf, loff_t off, size_t count)
193 struct scsi_qla_host *ha = shost_priv(dev_to_shost(container_of(kobj,
194 struct device, kobj)));
196 if (ha->optrom_state != QLA_SWRITING)
198 if (off > ha->optrom_region_size)
200 if (off + count > ha->optrom_region_size)
201 count = ha->optrom_region_size - off;
203 memcpy(&ha->optrom_buffer[off], buf, count);
208 static struct bin_attribute sysfs_optrom_attr = {
211 .mode = S_IRUSR | S_IWUSR,
214 .read = qla2x00_sysfs_read_optrom,
215 .write = qla2x00_sysfs_write_optrom,
219 qla2x00_sysfs_write_optrom_ctl(struct kobject *kobj,
220 struct bin_attribute *bin_attr,
221 char *buf, loff_t off, size_t count)
223 struct scsi_qla_host *ha = shost_priv(dev_to_shost(container_of(kobj,
224 struct device, kobj)));
226 uint32_t size = ha->optrom_size;
232 if (sscanf(buf, "%d:%x:%x", &val, &start, &size) < 1)
234 if (start > ha->optrom_size)
239 if (ha->optrom_state != QLA_SREADING &&
240 ha->optrom_state != QLA_SWRITING)
243 ha->optrom_state = QLA_SWAITING;
245 DEBUG2(qla_printk(KERN_INFO, ha,
246 "Freeing flash region allocation -- 0x%x bytes.\n",
247 ha->optrom_region_size));
249 vfree(ha->optrom_buffer);
250 ha->optrom_buffer = NULL;
253 if (ha->optrom_state != QLA_SWAITING)
257 qla_printk(KERN_WARNING, ha,
258 "Invalid start region 0x%x/0x%x.\n", start, size);
262 ha->optrom_region_start = start;
263 ha->optrom_region_size = start + size > ha->optrom_size ?
264 ha->optrom_size - start : size;
266 ha->optrom_state = QLA_SREADING;
267 ha->optrom_buffer = vmalloc(ha->optrom_region_size);
268 if (ha->optrom_buffer == NULL) {
269 qla_printk(KERN_WARNING, ha,
270 "Unable to allocate memory for optrom retrieval "
271 "(%x).\n", ha->optrom_region_size);
273 ha->optrom_state = QLA_SWAITING;
277 DEBUG2(qla_printk(KERN_INFO, ha,
278 "Reading flash region -- 0x%x/0x%x.\n",
279 ha->optrom_region_start, ha->optrom_region_size));
281 memset(ha->optrom_buffer, 0, ha->optrom_region_size);
282 ha->isp_ops->read_optrom(ha, ha->optrom_buffer,
283 ha->optrom_region_start, ha->optrom_region_size);
286 if (ha->optrom_state != QLA_SWAITING)
290 * We need to be more restrictive on which FLASH regions are
291 * allowed to be updated via user-space. Regions accessible
292 * via this method include:
294 * ISP21xx/ISP22xx/ISP23xx type boards:
296 * 0x000000 -> 0x020000 -- Boot code.
298 * ISP2322/ISP24xx type boards:
300 * 0x000000 -> 0x07ffff -- Boot code.
301 * 0x080000 -> 0x0fffff -- Firmware.
303 * ISP25xx type boards:
305 * 0x000000 -> 0x07ffff -- Boot code.
306 * 0x080000 -> 0x0fffff -- Firmware.
307 * 0x120000 -> 0x12ffff -- VPD and HBA parameters.
310 if (ha->optrom_size == OPTROM_SIZE_2300 && start == 0)
312 else if (start == (FA_BOOT_CODE_ADDR*4) ||
313 start == (FA_RISC_CODE_ADDR*4))
315 else if (IS_QLA25XX(ha) && start == (FA_VPD_NVRAM_ADDR*4))
318 qla_printk(KERN_WARNING, ha,
319 "Invalid start region 0x%x/0x%x.\n", start, size);
323 ha->optrom_region_start = start;
324 ha->optrom_region_size = start + size > ha->optrom_size ?
325 ha->optrom_size - start : size;
327 ha->optrom_state = QLA_SWRITING;
328 ha->optrom_buffer = vmalloc(ha->optrom_region_size);
329 if (ha->optrom_buffer == NULL) {
330 qla_printk(KERN_WARNING, ha,
331 "Unable to allocate memory for optrom update "
332 "(%x).\n", ha->optrom_region_size);
334 ha->optrom_state = QLA_SWAITING;
338 DEBUG2(qla_printk(KERN_INFO, ha,
339 "Staging flash region write -- 0x%x/0x%x.\n",
340 ha->optrom_region_start, ha->optrom_region_size));
342 memset(ha->optrom_buffer, 0, ha->optrom_region_size);
345 if (ha->optrom_state != QLA_SWRITING)
348 DEBUG2(qla_printk(KERN_INFO, ha,
349 "Writing flash region -- 0x%x/0x%x.\n",
350 ha->optrom_region_start, ha->optrom_region_size));
352 ha->isp_ops->write_optrom(ha, ha->optrom_buffer,
353 ha->optrom_region_start, ha->optrom_region_size);
361 static struct bin_attribute sysfs_optrom_ctl_attr = {
363 .name = "optrom_ctl",
367 .write = qla2x00_sysfs_write_optrom_ctl,
371 qla2x00_sysfs_read_vpd(struct kobject *kobj,
372 struct bin_attribute *bin_attr,
373 char *buf, loff_t off, size_t count)
375 struct scsi_qla_host *ha = shost_priv(dev_to_shost(container_of(kobj,
376 struct device, kobj)));
377 int size = ha->vpd_size;
378 char *vpd_cache = ha->vpd;
380 if (!capable(CAP_SYS_ADMIN) || off > size || count == 0)
382 if (off + count > size) {
387 /* Read NVRAM data from cache. */
388 memcpy(buf, &vpd_cache[off], count);
394 qla2x00_sysfs_write_vpd(struct kobject *kobj,
395 struct bin_attribute *bin_attr,
396 char *buf, loff_t off, size_t count)
398 struct scsi_qla_host *ha = shost_priv(dev_to_shost(container_of(kobj,
399 struct device, kobj)));
401 if (!capable(CAP_SYS_ADMIN) || off != 0 || count != ha->vpd_size)
405 ha->isp_ops->write_nvram(ha, (uint8_t *)buf, ha->vpd_base, count);
406 ha->isp_ops->read_nvram(ha, (uint8_t *)ha->vpd, ha->vpd_base, count);
411 static struct bin_attribute sysfs_vpd_attr = {
414 .mode = S_IRUSR | S_IWUSR,
417 .read = qla2x00_sysfs_read_vpd,
418 .write = qla2x00_sysfs_write_vpd,
422 qla2x00_sysfs_read_sfp(struct kobject *kobj,
423 struct bin_attribute *bin_attr,
424 char *buf, loff_t off, size_t count)
426 struct scsi_qla_host *ha = shost_priv(dev_to_shost(container_of(kobj,
427 struct device, kobj)));
428 uint16_t iter, addr, offset;
431 if (!capable(CAP_SYS_ADMIN) || off != 0 || count != SFP_DEV_SIZE * 2)
437 ha->sfp_data = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL,
440 qla_printk(KERN_WARNING, ha,
441 "Unable to allocate memory for SFP read-data.\n");
446 memset(ha->sfp_data, 0, SFP_BLOCK_SIZE);
448 for (iter = 0, offset = 0; iter < (SFP_DEV_SIZE * 2) / SFP_BLOCK_SIZE;
449 iter++, offset += SFP_BLOCK_SIZE) {
451 /* Skip to next device address. */
456 rval = qla2x00_read_sfp(ha, ha->sfp_data_dma, addr, offset,
458 if (rval != QLA_SUCCESS) {
459 qla_printk(KERN_WARNING, ha,
460 "Unable to read SFP data (%x/%x/%x).\n", rval,
465 memcpy(buf, ha->sfp_data, SFP_BLOCK_SIZE);
466 buf += SFP_BLOCK_SIZE;
472 static struct bin_attribute sysfs_sfp_attr = {
475 .mode = S_IRUSR | S_IWUSR,
477 .size = SFP_DEV_SIZE * 2,
478 .read = qla2x00_sysfs_read_sfp,
481 static struct sysfs_entry {
483 struct bin_attribute *attr;
485 } bin_file_entries[] = {
486 { "fw_dump", &sysfs_fw_dump_attr, },
487 { "nvram", &sysfs_nvram_attr, },
488 { "optrom", &sysfs_optrom_attr, },
489 { "optrom_ctl", &sysfs_optrom_ctl_attr, },
490 { "vpd", &sysfs_vpd_attr, 1 },
491 { "sfp", &sysfs_sfp_attr, 1 },
496 qla2x00_alloc_sysfs_attr(scsi_qla_host_t *ha)
498 struct Scsi_Host *host = ha->host;
499 struct sysfs_entry *iter;
502 for (iter = bin_file_entries; iter->name; iter++) {
503 if (iter->is4GBp_only && !IS_FWI2_CAPABLE(ha))
506 ret = sysfs_create_bin_file(&host->shost_gendev.kobj,
509 qla_printk(KERN_INFO, ha,
510 "Unable to create sysfs %s binary attribute "
511 "(%d).\n", iter->name, ret);
516 qla2x00_free_sysfs_attr(scsi_qla_host_t *ha)
518 struct Scsi_Host *host = ha->host;
519 struct sysfs_entry *iter;
521 for (iter = bin_file_entries; iter->name; iter++) {
522 if (iter->is4GBp_only && !IS_FWI2_CAPABLE(ha))
525 sysfs_remove_bin_file(&host->shost_gendev.kobj,
529 if (ha->beacon_blink_led == 1)
530 ha->isp_ops->beacon_off(ha);
533 /* Scsi_Host attributes. */
536 qla2x00_drvr_version_show(struct device *dev,
537 struct device_attribute *attr, char *buf)
539 return snprintf(buf, PAGE_SIZE, "%s\n", qla2x00_version_str);
543 qla2x00_fw_version_show(struct device *dev,
544 struct device_attribute *attr, char *buf)
546 scsi_qla_host_t *ha = shost_priv(class_to_shost(dev));
549 return snprintf(buf, PAGE_SIZE, "%s\n",
550 ha->isp_ops->fw_version_str(ha, fw_str));
554 qla2x00_serial_num_show(struct device *dev, struct device_attribute *attr,
557 scsi_qla_host_t *ha = shost_priv(class_to_shost(dev));
560 if (IS_FWI2_CAPABLE(ha)) {
561 qla2xxx_get_vpd_field(ha, "SN", buf, PAGE_SIZE);
562 return snprintf(buf, PAGE_SIZE, "%s\n", buf);
565 sn = ((ha->serial0 & 0x1f) << 16) | (ha->serial2 << 8) | ha->serial1;
566 return snprintf(buf, PAGE_SIZE, "%c%05d\n", 'A' + sn / 100000,
571 qla2x00_isp_name_show(struct device *dev, struct device_attribute *attr,
574 scsi_qla_host_t *ha = shost_priv(class_to_shost(dev));
575 return snprintf(buf, PAGE_SIZE, "ISP%04X\n", ha->pdev->device);
579 qla2x00_isp_id_show(struct device *dev, struct device_attribute *attr,
582 scsi_qla_host_t *ha = shost_priv(class_to_shost(dev));
583 return snprintf(buf, PAGE_SIZE, "%04x %04x %04x %04x\n",
584 ha->product_id[0], ha->product_id[1], ha->product_id[2],
589 qla2x00_model_name_show(struct device *dev, struct device_attribute *attr,
592 scsi_qla_host_t *ha = shost_priv(class_to_shost(dev));
593 return snprintf(buf, PAGE_SIZE, "%s\n", ha->model_number);
597 qla2x00_model_desc_show(struct device *dev, struct device_attribute *attr,
600 scsi_qla_host_t *ha = shost_priv(class_to_shost(dev));
601 return snprintf(buf, PAGE_SIZE, "%s\n",
602 ha->model_desc ? ha->model_desc: "");
606 qla2x00_pci_info_show(struct device *dev, struct device_attribute *attr,
609 scsi_qla_host_t *ha = shost_priv(class_to_shost(dev));
612 return snprintf(buf, PAGE_SIZE, "%s\n",
613 ha->isp_ops->pci_info_str(ha, pci_info));
617 qla2x00_link_state_show(struct device *dev, struct device_attribute *attr,
620 scsi_qla_host_t *ha = shost_priv(class_to_shost(dev));
623 if (atomic_read(&ha->loop_state) == LOOP_DOWN ||
624 atomic_read(&ha->loop_state) == LOOP_DEAD)
625 len = snprintf(buf, PAGE_SIZE, "Link Down\n");
626 else if (atomic_read(&ha->loop_state) != LOOP_READY ||
627 test_bit(ABORT_ISP_ACTIVE, &ha->dpc_flags) ||
628 test_bit(ISP_ABORT_NEEDED, &ha->dpc_flags))
629 len = snprintf(buf, PAGE_SIZE, "Unknown Link State\n");
631 len = snprintf(buf, PAGE_SIZE, "Link Up - ");
633 switch (ha->current_topology) {
635 len += snprintf(buf + len, PAGE_SIZE-len, "Loop\n");
638 len += snprintf(buf + len, PAGE_SIZE-len, "FL_Port\n");
641 len += snprintf(buf + len, PAGE_SIZE-len,
642 "N_Port to N_Port\n");
645 len += snprintf(buf + len, PAGE_SIZE-len, "F_Port\n");
648 len += snprintf(buf + len, PAGE_SIZE-len, "Loop\n");
656 qla2x00_zio_show(struct device *dev, struct device_attribute *attr,
659 scsi_qla_host_t *ha = shost_priv(class_to_shost(dev));
662 switch (ha->zio_mode) {
664 len += snprintf(buf + len, PAGE_SIZE-len, "Mode 6\n");
666 case QLA_ZIO_DISABLED:
667 len += snprintf(buf + len, PAGE_SIZE-len, "Disabled\n");
674 qla2x00_zio_store(struct device *dev, struct device_attribute *attr,
675 const char *buf, size_t count)
677 scsi_qla_host_t *ha = shost_priv(class_to_shost(dev));
681 if (!IS_ZIO_SUPPORTED(ha))
684 if (sscanf(buf, "%d", &val) != 1)
688 zio_mode = QLA_ZIO_MODE_6;
690 zio_mode = QLA_ZIO_DISABLED;
692 /* Update per-hba values and queue a reset. */
693 if (zio_mode != QLA_ZIO_DISABLED || ha->zio_mode != QLA_ZIO_DISABLED) {
694 ha->zio_mode = zio_mode;
695 set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
701 qla2x00_zio_timer_show(struct device *dev, struct device_attribute *attr,
704 scsi_qla_host_t *ha = shost_priv(class_to_shost(dev));
706 return snprintf(buf, PAGE_SIZE, "%d us\n", ha->zio_timer * 100);
710 qla2x00_zio_timer_store(struct device *dev, struct device_attribute *attr,
711 const char *buf, size_t count)
713 scsi_qla_host_t *ha = shost_priv(class_to_shost(dev));
717 if (sscanf(buf, "%d", &val) != 1)
719 if (val > 25500 || val < 100)
722 zio_timer = (uint16_t)(val / 100);
723 ha->zio_timer = zio_timer;
729 qla2x00_beacon_show(struct device *dev, struct device_attribute *attr,
732 scsi_qla_host_t *ha = shost_priv(class_to_shost(dev));
735 if (ha->beacon_blink_led)
736 len += snprintf(buf + len, PAGE_SIZE-len, "Enabled\n");
738 len += snprintf(buf + len, PAGE_SIZE-len, "Disabled\n");
743 qla2x00_beacon_store(struct device *dev, struct device_attribute *attr,
744 const char *buf, size_t count)
746 scsi_qla_host_t *ha = shost_priv(class_to_shost(dev));
750 if (IS_QLA2100(ha) || IS_QLA2200(ha))
753 if (test_bit(ABORT_ISP_ACTIVE, &ha->dpc_flags)) {
754 qla_printk(KERN_WARNING, ha,
755 "Abort ISP active -- ignoring beacon request.\n");
759 if (sscanf(buf, "%d", &val) != 1)
763 rval = ha->isp_ops->beacon_on(ha);
765 rval = ha->isp_ops->beacon_off(ha);
767 if (rval != QLA_SUCCESS)
774 qla2x00_optrom_bios_version_show(struct device *dev,
775 struct device_attribute *attr, char *buf)
777 scsi_qla_host_t *ha = shost_priv(class_to_shost(dev));
779 return snprintf(buf, PAGE_SIZE, "%d.%02d\n", ha->bios_revision[1],
780 ha->bios_revision[0]);
784 qla2x00_optrom_efi_version_show(struct device *dev,
785 struct device_attribute *attr, char *buf)
787 scsi_qla_host_t *ha = shost_priv(class_to_shost(dev));
789 return snprintf(buf, PAGE_SIZE, "%d.%02d\n", ha->efi_revision[1],
790 ha->efi_revision[0]);
794 qla2x00_optrom_fcode_version_show(struct device *dev,
795 struct device_attribute *attr, char *buf)
797 scsi_qla_host_t *ha = shost_priv(class_to_shost(dev));
799 return snprintf(buf, PAGE_SIZE, "%d.%02d\n", ha->fcode_revision[1],
800 ha->fcode_revision[0]);
804 qla2x00_optrom_fw_version_show(struct device *dev,
805 struct device_attribute *attr, char *buf)
807 scsi_qla_host_t *ha = shost_priv(class_to_shost(dev));
809 return snprintf(buf, PAGE_SIZE, "%d.%02d.%02d %d\n",
810 ha->fw_revision[0], ha->fw_revision[1], ha->fw_revision[2],
815 qla2x00_total_isp_aborts_show(struct device *dev,
816 struct device_attribute *attr, char *buf)
818 scsi_qla_host_t *ha = shost_priv(class_to_shost(dev));
820 return snprintf(buf, PAGE_SIZE, "%d\n",
821 ha->qla_stats.total_isp_aborts);
824 static DEVICE_ATTR(driver_version, S_IRUGO, qla2x00_drvr_version_show, NULL);
825 static DEVICE_ATTR(fw_version, S_IRUGO, qla2x00_fw_version_show, NULL);
826 static DEVICE_ATTR(serial_num, S_IRUGO, qla2x00_serial_num_show, NULL);
827 static DEVICE_ATTR(isp_name, S_IRUGO, qla2x00_isp_name_show, NULL);
828 static DEVICE_ATTR(isp_id, S_IRUGO, qla2x00_isp_id_show, NULL);
829 static DEVICE_ATTR(model_name, S_IRUGO, qla2x00_model_name_show, NULL);
830 static DEVICE_ATTR(model_desc, S_IRUGO, qla2x00_model_desc_show, NULL);
831 static DEVICE_ATTR(pci_info, S_IRUGO, qla2x00_pci_info_show, NULL);
832 static DEVICE_ATTR(link_state, S_IRUGO, qla2x00_link_state_show, NULL);
833 static DEVICE_ATTR(zio, S_IRUGO | S_IWUSR, qla2x00_zio_show, qla2x00_zio_store);
834 static DEVICE_ATTR(zio_timer, S_IRUGO | S_IWUSR, qla2x00_zio_timer_show,
835 qla2x00_zio_timer_store);
836 static DEVICE_ATTR(beacon, S_IRUGO | S_IWUSR, qla2x00_beacon_show,
837 qla2x00_beacon_store);
838 static DEVICE_ATTR(optrom_bios_version, S_IRUGO,
839 qla2x00_optrom_bios_version_show, NULL);
840 static DEVICE_ATTR(optrom_efi_version, S_IRUGO,
841 qla2x00_optrom_efi_version_show, NULL);
842 static DEVICE_ATTR(optrom_fcode_version, S_IRUGO,
843 qla2x00_optrom_fcode_version_show, NULL);
844 static DEVICE_ATTR(optrom_fw_version, S_IRUGO, qla2x00_optrom_fw_version_show,
846 static DEVICE_ATTR(total_isp_aborts, S_IRUGO, qla2x00_total_isp_aborts_show,
849 struct device_attribute *qla2x00_host_attrs[] = {
850 &dev_attr_driver_version,
851 &dev_attr_fw_version,
852 &dev_attr_serial_num,
855 &dev_attr_model_name,
856 &dev_attr_model_desc,
858 &dev_attr_link_state,
862 &dev_attr_optrom_bios_version,
863 &dev_attr_optrom_efi_version,
864 &dev_attr_optrom_fcode_version,
865 &dev_attr_optrom_fw_version,
866 &dev_attr_total_isp_aborts,
870 /* Host attributes. */
873 qla2x00_get_host_port_id(struct Scsi_Host *shost)
875 scsi_qla_host_t *ha = shost_priv(shost);
877 fc_host_port_id(shost) = ha->d_id.b.domain << 16 |
878 ha->d_id.b.area << 8 | ha->d_id.b.al_pa;
882 qla2x00_get_host_speed(struct Scsi_Host *shost)
884 scsi_qla_host_t *ha = to_qla_parent(shost_priv(shost));
885 u32 speed = FC_PORTSPEED_UNKNOWN;
887 switch (ha->link_data_rate) {
889 speed = FC_PORTSPEED_1GBIT;
892 speed = FC_PORTSPEED_2GBIT;
895 speed = FC_PORTSPEED_4GBIT;
898 speed = FC_PORTSPEED_8GBIT;
901 fc_host_speed(shost) = speed;
905 qla2x00_get_host_port_type(struct Scsi_Host *shost)
907 scsi_qla_host_t *ha = shost_priv(shost);
908 uint32_t port_type = FC_PORTTYPE_UNKNOWN;
911 fc_host_port_type(shost) = FC_PORTTYPE_NPIV;
914 switch (ha->current_topology) {
916 port_type = FC_PORTTYPE_LPORT;
919 port_type = FC_PORTTYPE_NLPORT;
922 port_type = FC_PORTTYPE_PTP;
925 port_type = FC_PORTTYPE_NPORT;
928 fc_host_port_type(shost) = port_type;
932 qla2x00_get_starget_node_name(struct scsi_target *starget)
934 struct Scsi_Host *host = dev_to_shost(starget->dev.parent);
935 scsi_qla_host_t *ha = shost_priv(host);
939 list_for_each_entry(fcport, &ha->fcports, list) {
941 starget->id == fcport->rport->scsi_target_id) {
942 node_name = wwn_to_u64(fcport->node_name);
947 fc_starget_node_name(starget) = node_name;
951 qla2x00_get_starget_port_name(struct scsi_target *starget)
953 struct Scsi_Host *host = dev_to_shost(starget->dev.parent);
954 scsi_qla_host_t *ha = shost_priv(host);
958 list_for_each_entry(fcport, &ha->fcports, list) {
960 starget->id == fcport->rport->scsi_target_id) {
961 port_name = wwn_to_u64(fcport->port_name);
966 fc_starget_port_name(starget) = port_name;
970 qla2x00_get_starget_port_id(struct scsi_target *starget)
972 struct Scsi_Host *host = dev_to_shost(starget->dev.parent);
973 scsi_qla_host_t *ha = shost_priv(host);
975 uint32_t port_id = ~0U;
977 list_for_each_entry(fcport, &ha->fcports, list) {
979 starget->id == fcport->rport->scsi_target_id) {
980 port_id = fcport->d_id.b.domain << 16 |
981 fcport->d_id.b.area << 8 | fcport->d_id.b.al_pa;
986 fc_starget_port_id(starget) = port_id;
990 qla2x00_set_rport_loss_tmo(struct fc_rport *rport, uint32_t timeout)
993 rport->dev_loss_tmo = timeout;
995 rport->dev_loss_tmo = 1;
999 qla2x00_dev_loss_tmo_callbk(struct fc_rport *rport)
1001 struct Scsi_Host *host = rport_to_shost(rport);
1002 fc_port_t *fcport = *(fc_port_t **)rport->dd_data;
1004 qla2x00_abort_fcport_cmds(fcport);
1007 * Transport has effectively 'deleted' the rport, clear
1008 * all local references.
1010 spin_lock_irq(host->host_lock);
1011 fcport->rport = NULL;
1012 *((fc_port_t **)rport->dd_data) = NULL;
1013 spin_unlock_irq(host->host_lock);
1017 qla2x00_terminate_rport_io(struct fc_rport *rport)
1019 fc_port_t *fcport = *(fc_port_t **)rport->dd_data;
1021 qla2x00_abort_fcport_cmds(fcport);
1022 scsi_target_unblock(&rport->dev);
1026 qla2x00_issue_lip(struct Scsi_Host *shost)
1028 scsi_qla_host_t *ha = shost_priv(shost);
1030 qla2x00_loop_reset(ha);
1034 static struct fc_host_statistics *
1035 qla2x00_get_fc_host_stats(struct Scsi_Host *shost)
1037 scsi_qla_host_t *ha = to_qla_parent(shost_priv(shost));
1039 struct link_statistics *stats;
1040 dma_addr_t stats_dma;
1041 struct fc_host_statistics *pfc_host_stat;
1043 pfc_host_stat = &ha->fc_host_stat;
1044 memset(pfc_host_stat, -1, sizeof(struct fc_host_statistics));
1046 stats = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &stats_dma);
1047 if (stats == NULL) {
1048 DEBUG2_3_11(printk("%s(%ld): Failed to allocate memory.\n",
1049 __func__, ha->host_no));
1052 memset(stats, 0, DMA_POOL_SIZE);
1054 rval = QLA_FUNCTION_FAILED;
1055 if (IS_FWI2_CAPABLE(ha)) {
1056 rval = qla24xx_get_isp_stats(ha, stats, stats_dma);
1057 } else if (atomic_read(&ha->loop_state) == LOOP_READY &&
1058 !test_bit(ABORT_ISP_ACTIVE, &ha->dpc_flags) &&
1059 !test_bit(ISP_ABORT_NEEDED, &ha->dpc_flags) &&
1061 /* Must be in a 'READY' state for statistics retrieval. */
1062 rval = qla2x00_get_link_status(ha, ha->loop_id, stats,
1066 if (rval != QLA_SUCCESS)
1069 pfc_host_stat->link_failure_count = stats->link_fail_cnt;
1070 pfc_host_stat->loss_of_sync_count = stats->loss_sync_cnt;
1071 pfc_host_stat->loss_of_signal_count = stats->loss_sig_cnt;
1072 pfc_host_stat->prim_seq_protocol_err_count = stats->prim_seq_err_cnt;
1073 pfc_host_stat->invalid_tx_word_count = stats->inval_xmit_word_cnt;
1074 pfc_host_stat->invalid_crc_count = stats->inval_crc_cnt;
1075 if (IS_FWI2_CAPABLE(ha)) {
1076 pfc_host_stat->lip_count = stats->lip_cnt;
1077 pfc_host_stat->tx_frames = stats->tx_frames;
1078 pfc_host_stat->rx_frames = stats->rx_frames;
1079 pfc_host_stat->dumped_frames = stats->dumped_frames;
1080 pfc_host_stat->nos_count = stats->nos_rcvd;
1084 dma_pool_free(ha->s_dma_pool, stats, stats_dma);
1086 return pfc_host_stat;
1090 qla2x00_get_host_symbolic_name(struct Scsi_Host *shost)
1092 scsi_qla_host_t *ha = shost_priv(shost);
1094 qla2x00_get_sym_node_name(ha, fc_host_symbolic_name(shost));
1098 qla2x00_set_host_system_hostname(struct Scsi_Host *shost)
1100 scsi_qla_host_t *ha = shost_priv(shost);
1102 set_bit(REGISTER_FDMI_NEEDED, &ha->dpc_flags);
1106 qla2x00_get_host_fabric_name(struct Scsi_Host *shost)
1108 scsi_qla_host_t *ha = shost_priv(shost);
1111 if (ha->device_flags & SWITCH_FOUND)
1112 node_name = wwn_to_u64(ha->fabric_node_name);
1114 node_name = wwn_to_u64(ha->node_name);
1116 fc_host_fabric_name(shost) = node_name;
1120 qla2x00_get_host_port_state(struct Scsi_Host *shost)
1122 scsi_qla_host_t *ha = to_qla_parent(shost_priv(shost));
1124 if (!ha->flags.online)
1125 fc_host_port_state(shost) = FC_PORTSTATE_OFFLINE;
1126 else if (atomic_read(&ha->loop_state) == LOOP_TIMEOUT)
1127 fc_host_port_state(shost) = FC_PORTSTATE_UNKNOWN;
1129 fc_host_port_state(shost) = FC_PORTSTATE_ONLINE;
1133 qla24xx_vport_create(struct fc_vport *fc_vport, bool disable)
1136 scsi_qla_host_t *ha = shost_priv(fc_vport->shost);
1137 scsi_qla_host_t *vha;
1139 ret = qla24xx_vport_create_req_sanity_check(fc_vport);
1141 DEBUG15(printk("qla24xx_vport_create_req_sanity_check failed, "
1142 "status %x\n", ret));
1146 vha = qla24xx_create_vhost(fc_vport);
1148 DEBUG15(printk ("qla24xx_create_vhost failed, vha = %p\n",
1150 return FC_VPORT_FAILED;
1153 atomic_set(&vha->vp_state, VP_OFFLINE);
1154 fc_vport_set_state(fc_vport, FC_VPORT_DISABLED);
1156 atomic_set(&vha->vp_state, VP_FAILED);
1158 /* ready to create vport */
1159 qla_printk(KERN_INFO, vha, "VP entry id %d assigned.\n", vha->vp_idx);
1161 /* initialized vport states */
1162 atomic_set(&vha->loop_state, LOOP_DOWN);
1163 vha->vp_err_state= VP_ERR_PORTDWN;
1164 vha->vp_prev_err_state= VP_ERR_UNKWN;
1165 /* Check if physical ha port is Up */
1166 if (atomic_read(&ha->loop_state) == LOOP_DOWN ||
1167 atomic_read(&ha->loop_state) == LOOP_DEAD) {
1168 /* Don't retry or attempt login of this virtual port */
1169 DEBUG15(printk ("scsi(%ld): pport loop_state is not UP.\n",
1171 atomic_set(&vha->loop_state, LOOP_DEAD);
1173 fc_vport_set_state(fc_vport, FC_VPORT_LINKDOWN);
1176 if (scsi_add_host(vha->host, &fc_vport->dev)) {
1177 DEBUG15(printk("scsi(%ld): scsi_add_host failure for VP[%d].\n",
1178 vha->host_no, vha->vp_idx));
1179 goto vport_create_failed_2;
1182 /* initialize attributes */
1183 fc_host_node_name(vha->host) = wwn_to_u64(vha->node_name);
1184 fc_host_port_name(vha->host) = wwn_to_u64(vha->port_name);
1185 fc_host_supported_classes(vha->host) =
1186 fc_host_supported_classes(ha->host);
1187 fc_host_supported_speeds(vha->host) =
1188 fc_host_supported_speeds(ha->host);
1190 qla24xx_vport_disable(fc_vport, disable);
1193 vport_create_failed_2:
1194 qla24xx_disable_vp(vha);
1195 qla24xx_deallocate_vp_id(vha);
1196 kfree(vha->port_name);
1197 kfree(vha->node_name);
1198 scsi_host_put(vha->host);
1199 return FC_VPORT_FAILED;
1203 qla24xx_vport_delete(struct fc_vport *fc_vport)
1205 scsi_qla_host_t *vha = fc_vport->dd_data;
1207 qla24xx_disable_vp(vha);
1208 qla24xx_deallocate_vp_id(vha);
1210 kfree(vha->node_name);
1211 kfree(vha->port_name);
1213 if (vha->timer_active) {
1214 qla2x00_vp_stop_timer(vha);
1215 DEBUG15(printk ("scsi(%ld): timer for the vport[%d] = %p "
1217 vha->host_no, vha->vp_idx, vha));
1220 fc_remove_host(vha->host);
1222 scsi_remove_host(vha->host);
1224 scsi_host_put(vha->host);
1230 qla24xx_vport_disable(struct fc_vport *fc_vport, bool disable)
1232 scsi_qla_host_t *vha = fc_vport->dd_data;
1235 qla24xx_disable_vp(vha);
1237 qla24xx_enable_vp(vha);
1242 struct fc_function_template qla2xxx_transport_functions = {
1244 .show_host_node_name = 1,
1245 .show_host_port_name = 1,
1246 .show_host_supported_classes = 1,
1247 .show_host_supported_speeds = 1,
1249 .get_host_port_id = qla2x00_get_host_port_id,
1250 .show_host_port_id = 1,
1251 .get_host_speed = qla2x00_get_host_speed,
1252 .show_host_speed = 1,
1253 .get_host_port_type = qla2x00_get_host_port_type,
1254 .show_host_port_type = 1,
1255 .get_host_symbolic_name = qla2x00_get_host_symbolic_name,
1256 .show_host_symbolic_name = 1,
1257 .set_host_system_hostname = qla2x00_set_host_system_hostname,
1258 .show_host_system_hostname = 1,
1259 .get_host_fabric_name = qla2x00_get_host_fabric_name,
1260 .show_host_fabric_name = 1,
1261 .get_host_port_state = qla2x00_get_host_port_state,
1262 .show_host_port_state = 1,
1264 .dd_fcrport_size = sizeof(struct fc_port *),
1265 .show_rport_supported_classes = 1,
1267 .get_starget_node_name = qla2x00_get_starget_node_name,
1268 .show_starget_node_name = 1,
1269 .get_starget_port_name = qla2x00_get_starget_port_name,
1270 .show_starget_port_name = 1,
1271 .get_starget_port_id = qla2x00_get_starget_port_id,
1272 .show_starget_port_id = 1,
1274 .set_rport_dev_loss_tmo = qla2x00_set_rport_loss_tmo,
1275 .show_rport_dev_loss_tmo = 1,
1277 .issue_fc_host_lip = qla2x00_issue_lip,
1278 .dev_loss_tmo_callbk = qla2x00_dev_loss_tmo_callbk,
1279 .terminate_rport_io = qla2x00_terminate_rport_io,
1280 .get_fc_host_stats = qla2x00_get_fc_host_stats,
1282 .vport_create = qla24xx_vport_create,
1283 .vport_disable = qla24xx_vport_disable,
1284 .vport_delete = qla24xx_vport_delete,
1287 struct fc_function_template qla2xxx_transport_vport_functions = {
1289 .show_host_node_name = 1,
1290 .show_host_port_name = 1,
1291 .show_host_supported_classes = 1,
1293 .get_host_port_id = qla2x00_get_host_port_id,
1294 .show_host_port_id = 1,
1295 .get_host_speed = qla2x00_get_host_speed,
1296 .show_host_speed = 1,
1297 .get_host_port_type = qla2x00_get_host_port_type,
1298 .show_host_port_type = 1,
1299 .get_host_symbolic_name = qla2x00_get_host_symbolic_name,
1300 .show_host_symbolic_name = 1,
1301 .set_host_system_hostname = qla2x00_set_host_system_hostname,
1302 .show_host_system_hostname = 1,
1303 .get_host_fabric_name = qla2x00_get_host_fabric_name,
1304 .show_host_fabric_name = 1,
1305 .get_host_port_state = qla2x00_get_host_port_state,
1306 .show_host_port_state = 1,
1308 .dd_fcrport_size = sizeof(struct fc_port *),
1309 .show_rport_supported_classes = 1,
1311 .get_starget_node_name = qla2x00_get_starget_node_name,
1312 .show_starget_node_name = 1,
1313 .get_starget_port_name = qla2x00_get_starget_port_name,
1314 .show_starget_port_name = 1,
1315 .get_starget_port_id = qla2x00_get_starget_port_id,
1316 .show_starget_port_id = 1,
1318 .set_rport_dev_loss_tmo = qla2x00_set_rport_loss_tmo,
1319 .show_rport_dev_loss_tmo = 1,
1321 .issue_fc_host_lip = qla2x00_issue_lip,
1322 .dev_loss_tmo_callbk = qla2x00_dev_loss_tmo_callbk,
1323 .terminate_rport_io = qla2x00_terminate_rport_io,
1324 .get_fc_host_stats = qla2x00_get_fc_host_stats,
1328 qla2x00_init_host_attr(scsi_qla_host_t *ha)
1330 u32 speed = FC_PORTSPEED_UNKNOWN;
1332 fc_host_node_name(ha->host) = wwn_to_u64(ha->node_name);
1333 fc_host_port_name(ha->host) = wwn_to_u64(ha->port_name);
1334 fc_host_supported_classes(ha->host) = FC_COS_CLASS3;
1335 fc_host_max_npiv_vports(ha->host) = ha->max_npiv_vports;;
1336 fc_host_npiv_vports_inuse(ha->host) = ha->cur_vport_count;
1339 speed = FC_PORTSPEED_8GBIT | FC_PORTSPEED_4GBIT |
1340 FC_PORTSPEED_2GBIT | FC_PORTSPEED_1GBIT;
1341 else if (IS_QLA24XX_TYPE(ha))
1342 speed = FC_PORTSPEED_4GBIT | FC_PORTSPEED_2GBIT |
1344 else if (IS_QLA23XX(ha))
1345 speed = FC_PORTSPEED_2GBIT | FC_PORTSPEED_1GBIT;
1347 speed = FC_PORTSPEED_1GBIT;
1348 fc_host_supported_speeds(ha->host) = speed;