[linux-2.6-block.git] / drivers / scsi / qla4xxx / ql4_attr.c

/*
 * QLogic iSCSI HBA Driver
 * Copyright (c)  2003-2013 QLogic Corporation
 *
 * See LICENSE.qla4xxx for copyright and licensing details.
 */

#include "ql4_def.h"
#include "ql4_glbl.h"
#include "ql4_dbg.h"

static ssize_t
qla4_8xxx_sysfs_read_fw_dump(struct file *filep, struct kobject *kobj,
			     struct bin_attribute *ba, char *buf, loff_t off,
			     size_t count)
{
	struct scsi_qla_host *ha = to_qla_host(dev_to_shost(container_of(kobj,
					       struct device, kobj)));

	if (is_qla40XX(ha))
		return -EINVAL;

	if (!test_bit(AF_82XX_DUMP_READING, &ha->flags))
		return 0;

	return memory_read_from_buffer(buf, count, &off, ha->fw_dump,
				       ha->fw_dump_size);
}

static ssize_t
qla4_8xxx_sysfs_write_fw_dump(struct file *filep, struct kobject *kobj,
			      struct bin_attribute *ba, char *buf, loff_t off,
			      size_t count)
{
	struct scsi_qla_host *ha = to_qla_host(dev_to_shost(container_of(kobj,
					       struct device, kobj)));
	uint32_t dev_state;
	long reading;
	int ret = 0;

	if (is_qla40XX(ha))
		return -EINVAL;

	if (off != 0)
		return ret;

	buf[1] = 0;
	ret = kstrtol(buf, 10, &reading);
	if (ret) {
		ql4_printk(KERN_ERR, ha, "%s: Invalid input. Return err %d\n",
			   __func__, ret);
		return ret;
	}

	switch (reading) {
	case 0:
		/* clear dump collection flags */
		if (test_and_clear_bit(AF_82XX_DUMP_READING, &ha->flags)) {
			clear_bit(AF_82XX_FW_DUMPED, &ha->flags);
			/* Reload minidump template */
			qla4xxx_alloc_fw_dump(ha);
			DEBUG2(ql4_printk(KERN_INFO, ha,
					  "Firmware template reloaded\n"));
		}
		break;
	case 1:
		/* Set flag to read dump */
		if (test_bit(AF_82XX_FW_DUMPED, &ha->flags) &&
		    !test_bit(AF_82XX_DUMP_READING, &ha->flags)) {
			set_bit(AF_82XX_DUMP_READING, &ha->flags);
			DEBUG2(ql4_printk(KERN_INFO, ha,
					  "Raw firmware dump ready for read on (%ld).\n",
					  ha->host_no));
		}
		break;
	case 2:
		/* Reset HBA and collect FW dump */
		ha->isp_ops->idc_lock(ha);
		dev_state = qla4_8xxx_rd_direct(ha, QLA8XXX_CRB_DEV_STATE);
		if (dev_state == QLA8XXX_DEV_READY) {
			ql4_printk(KERN_INFO, ha, "%s: Setting Need reset\n",
				   __func__);
			qla4_8xxx_wr_direct(ha, QLA8XXX_CRB_DEV_STATE,
					    QLA8XXX_DEV_NEED_RESET);
			if (is_qla8022(ha) ||
			    ((is_qla8032(ha) || is_qla8042(ha)) &&
			     qla4_83xx_can_perform_reset(ha))) {
				set_bit(AF_8XXX_RST_OWNER, &ha->flags);
				set_bit(AF_FW_RECOVERY, &ha->flags);
				ql4_printk(KERN_INFO, ha, "%s: Reset owner is 0x%x\n",
					   __func__, ha->func_num);
			}
		} else
			ql4_printk(KERN_INFO, ha,
				   "%s: Reset not performed as device state is 0x%x\n",
				   __func__, dev_state);

		ha->isp_ops->idc_unlock(ha);
		break;
	default:
		/* do nothing */
		break;
	}

	return count;
}

static struct bin_attribute sysfs_fw_dump_attr = {
	.attr = {
		.name = "fw_dump",
		.mode = S_IRUSR | S_IWUSR,
	},
	.size = 0,
	.read = qla4_8xxx_sysfs_read_fw_dump,
	.write = qla4_8xxx_sysfs_write_fw_dump,
};

static struct sysfs_entry {
	char *name;
	struct bin_attribute *attr;
} bin_file_entries[] = {
	{ "fw_dump", &sysfs_fw_dump_attr },
	{ NULL },
};

void qla4_8xxx_alloc_sysfs_attr(struct scsi_qla_host *ha)
{
	struct Scsi_Host *host = ha->host;
	struct sysfs_entry *iter;
	int ret;

	for (iter = bin_file_entries; iter->name; iter++) {
		ret = sysfs_create_bin_file(&host->shost_gendev.kobj,
					    iter->attr);
		if (ret)
			ql4_printk(KERN_ERR, ha,
				   "Unable to create sysfs %s binary attribute (%d).\n",
				   iter->name, ret);
	}
}

void qla4_8xxx_free_sysfs_attr(struct scsi_qla_host *ha)
{
	struct Scsi_Host *host = ha->host;
	struct sysfs_entry *iter;

	for (iter = bin_file_entries; iter->name; iter++)
		sysfs_remove_bin_file(&host->shost_gendev.kobj,
				      iter->attr);
}

/* Scsi_Host attributes. */
static ssize_t
qla4xxx_fw_version_show(struct device *dev,
			struct device_attribute *attr, char *buf)
{
	struct scsi_qla_host *ha = to_qla_host(class_to_shost(dev));

	if (is_qla80XX(ha))
		return snprintf(buf, PAGE_SIZE, "%d.%02d.%02d (%x)\n",
				ha->fw_info.fw_major, ha->fw_info.fw_minor,
				ha->fw_info.fw_patch, ha->fw_info.fw_build);
	else
		return snprintf(buf, PAGE_SIZE, "%d.%02d.%02d.%02d\n",
				ha->fw_info.fw_major, ha->fw_info.fw_minor,
				ha->fw_info.fw_patch, ha->fw_info.fw_build);
}

static ssize_t
qla4xxx_serial_num_show(struct device *dev, struct device_attribute *attr,
			char *buf)
{
	struct scsi_qla_host *ha = to_qla_host(class_to_shost(dev));
	return snprintf(buf, PAGE_SIZE, "%s\n", ha->serial_number);
}

static ssize_t
qla4xxx_iscsi_version_show(struct device *dev, struct device_attribute *attr,
			   char *buf)
{
	struct scsi_qla_host *ha = to_qla_host(class_to_shost(dev));
	return snprintf(buf, PAGE_SIZE, "%d.%02d\n", ha->fw_info.iscsi_major,
			ha->fw_info.iscsi_minor);
}

static ssize_t
qla4xxx_optrom_version_show(struct device *dev, struct device_attribute *attr,
			    char *buf)
{
	struct scsi_qla_host *ha = to_qla_host(class_to_shost(dev));
	return snprintf(buf, PAGE_SIZE, "%d.%02d.%02d.%02d\n",
			ha->fw_info.bootload_major, ha->fw_info.bootload_minor,
			ha->fw_info.bootload_patch, ha->fw_info.bootload_build);
}

static ssize_t
qla4xxx_board_id_show(struct device *dev, struct device_attribute *attr,
		      char *buf)
{
	struct scsi_qla_host *ha = to_qla_host(class_to_shost(dev));
	return snprintf(buf, PAGE_SIZE, "0x%08X\n", ha->board_id);
}

static ssize_t
qla4xxx_fw_state_show(struct device *dev, struct device_attribute *attr,
		      char *buf)
{
	struct scsi_qla_host *ha = to_qla_host(class_to_shost(dev));

	qla4xxx_get_firmware_state(ha);
	return snprintf(buf, PAGE_SIZE, "0x%08X%8X\n", ha->firmware_state,
			ha->addl_fw_state);
}

static ssize_t
qla4xxx_phy_port_cnt_show(struct device *dev, struct device_attribute *attr,
		      char *buf)
{
	struct scsi_qla_host *ha = to_qla_host(class_to_shost(dev));

	if (is_qla40XX(ha))
		return -ENOSYS;

	return snprintf(buf, PAGE_SIZE, "0x%04X\n", ha->phy_port_cnt);
}

static ssize_t
qla4xxx_phy_port_num_show(struct device *dev, struct device_attribute *attr,
		      char *buf)
{
	struct scsi_qla_host *ha = to_qla_host(class_to_shost(dev));

	if (is_qla40XX(ha))
		return -ENOSYS;

	return snprintf(buf, PAGE_SIZE, "0x%04X\n", ha->phy_port_num);
}

static ssize_t
qla4xxx_iscsi_func_cnt_show(struct device *dev, struct device_attribute *attr,
		      char *buf)
{
	struct scsi_qla_host *ha = to_qla_host(class_to_shost(dev));

	if (is_qla40XX(ha))
		return -ENOSYS;

	return snprintf(buf, PAGE_SIZE, "0x%04X\n", ha->iscsi_pci_func_cnt);
}

static ssize_t
qla4xxx_hba_model_show(struct device *dev, struct device_attribute *attr,
		       char *buf)
{
	struct scsi_qla_host *ha = to_qla_host(class_to_shost(dev));

	return snprintf(buf, PAGE_SIZE, "%s\n", ha->model_name);
}

static ssize_t
qla4xxx_fw_timestamp_show(struct device *dev, struct device_attribute *attr,
			  char *buf)
{
	struct scsi_qla_host *ha = to_qla_host(class_to_shost(dev));
	return snprintf(buf, PAGE_SIZE, "%s %s\n", ha->fw_info.fw_build_date,
			ha->fw_info.fw_build_time);
}

static ssize_t
qla4xxx_fw_build_user_show(struct device *dev, struct device_attribute *attr,
			   char *buf)
{
	struct scsi_qla_host *ha = to_qla_host(class_to_shost(dev));
	return snprintf(buf, PAGE_SIZE, "%s\n", ha->fw_info.fw_build_user);
}

static ssize_t
qla4xxx_fw_ext_timestamp_show(struct device *dev, struct device_attribute *attr,
			      char *buf)
{
	struct scsi_qla_host *ha = to_qla_host(class_to_shost(dev));
	return snprintf(buf, PAGE_SIZE, "%s\n", ha->fw_info.extended_timestamp);
}

static ssize_t
qla4xxx_fw_load_src_show(struct device *dev, struct device_attribute *attr,
			 char *buf)
{
	struct scsi_qla_host *ha = to_qla_host(class_to_shost(dev));
	char *load_src = NULL;

	switch (ha->fw_info.fw_load_source) {
	case 1:
		load_src = "Flash Primary";
		break;
	case 2:
		load_src = "Flash Secondary";
		break;
	case 3:
		load_src = "Host Download";
		break;
	}

	return snprintf(buf, PAGE_SIZE, "%s\n", load_src);
}

static ssize_t
qla4xxx_fw_uptime_show(struct device *dev, struct device_attribute *attr,
		       char *buf)
{
	struct scsi_qla_host *ha = to_qla_host(class_to_shost(dev));
	qla4xxx_about_firmware(ha);
	return snprintf(buf, PAGE_SIZE, "%u.%u secs\n", ha->fw_uptime_secs,
			ha->fw_uptime_msecs);
}

static DEVICE_ATTR(fw_version, S_IRUGO, qla4xxx_fw_version_show, NULL);
static DEVICE_ATTR(serial_num, S_IRUGO, qla4xxx_serial_num_show, NULL);
static DEVICE_ATTR(iscsi_version, S_IRUGO, qla4xxx_iscsi_version_show, NULL);
static DEVICE_ATTR(optrom_version, S_IRUGO, qla4xxx_optrom_version_show, NULL);
static DEVICE_ATTR(board_id, S_IRUGO, qla4xxx_board_id_show, NULL);
static DEVICE_ATTR(fw_state, S_IRUGO, qla4xxx_fw_state_show, NULL);
static DEVICE_ATTR(phy_port_cnt, S_IRUGO, qla4xxx_phy_port_cnt_show, NULL);
static DEVICE_ATTR(phy_port_num, S_IRUGO, qla4xxx_phy_port_num_show, NULL);
static DEVICE_ATTR(iscsi_func_cnt, S_IRUGO, qla4xxx_iscsi_func_cnt_show, NULL);
static DEVICE_ATTR(hba_model, S_IRUGO, qla4xxx_hba_model_show, NULL);
static DEVICE_ATTR(fw_timestamp, S_IRUGO, qla4xxx_fw_timestamp_show, NULL);
static DEVICE_ATTR(fw_build_user, S_IRUGO, qla4xxx_fw_build_user_show, NULL);
static DEVICE_ATTR(fw_ext_timestamp, S_IRUGO, qla4xxx_fw_ext_timestamp_show,
		   NULL);
static DEVICE_ATTR(fw_load_src, S_IRUGO, qla4xxx_fw_load_src_show, NULL);
static DEVICE_ATTR(fw_uptime, S_IRUGO, qla4xxx_fw_uptime_show, NULL);

struct device_attribute *qla4xxx_host_attrs[] = {
	&dev_attr_fw_version,
	&dev_attr_serial_num,
	&dev_attr_iscsi_version,
	&dev_attr_optrom_version,
	&dev_attr_board_id,
	&dev_attr_fw_state,
	&dev_attr_phy_port_cnt,
	&dev_attr_phy_port_num,
	&dev_attr_iscsi_func_cnt,
	&dev_attr_hba_model,
	&dev_attr_fw_timestamp,
	&dev_attr_fw_build_user,
	&dev_attr_fw_ext_timestamp,
	&dev_attr_fw_load_src,
	&dev_attr_fw_uptime,
	NULL,
};
Commit	Line	Data
7ad633c0 HZ	1	/*
7ad633c0 HZ	2	* QLogic iSCSI HBA Driver
4a4f51e9	3	* Copyright (c) 2003-2013 QLogic Corporation
7ad633c0 HZ	4	*
	5	* See LICENSE.qla4xxx for copyright and licensing details.
	6	*/
	7
	8	#include "ql4_def.h"
	9	#include "ql4_glbl.h"
	10	#include "ql4_dbg.h"
	11
068237c8 TP	12	static ssize_t
	13	qla4_8xxx_sysfs_read_fw_dump(struct file filep, struct kobject kobj,
	14	struct bin_attribute ba, char buf, loff_t off,
	15	size_t count)
	16	{
	17	struct scsi_qla_host *ha = to_qla_host(dev_to_shost(container_of(kobj,
	18	struct device, kobj)));
	19
ee996a69	20	if (is_qla40XX(ha))
068237c8 TP	21	return -EINVAL;
	22
	23	if (!test_bit(AF_82XX_DUMP_READING, &ha->flags))
	24	return 0;
	25
	26	return memory_read_from_buffer(buf, count, &off, ha->fw_dump,
	27	ha->fw_dump_size);
	28	}
	29
	30	static ssize_t
	31	qla4_8xxx_sysfs_write_fw_dump(struct file filep, struct kobject kobj,
	32	struct bin_attribute ba, char buf, loff_t off,
	33	size_t count)
	34	{
	35	struct scsi_qla_host *ha = to_qla_host(dev_to_shost(container_of(kobj,
	36	struct device, kobj)));
	37	uint32_t dev_state;
	38	long reading;
	39	int ret = 0;
	40
ee996a69	41	if (is_qla40XX(ha))
068237c8 TP	42	return -EINVAL;
	43
	44	if (off != 0)
	45	return ret;
	46
	47	buf[1] = 0;
	48	ret = kstrtol(buf, 10, &reading);
	49	if (ret) {
	50	ql4_printk(KERN_ERR, ha, "%s: Invalid input. Return err %d\n",
	51	__func__, ret);
	52	return ret;
	53	}
	54
	55	switch (reading) {
	56	case 0:
	57	/* clear dump collection flags */
	58	if (test_and_clear_bit(AF_82XX_DUMP_READING, &ha->flags)) {
	59	clear_bit(AF_82XX_FW_DUMPED, &ha->flags);
	60	/* Reload minidump template */
	61	qla4xxx_alloc_fw_dump(ha);
	62	DEBUG2(ql4_printk(KERN_INFO, ha,
	63	"Firmware template reloaded\n"));
	64	}
	65	break;
	66	case 1:
	67	/* Set flag to read dump */
	68	if (test_bit(AF_82XX_FW_DUMPED, &ha->flags) &&
	69	!test_bit(AF_82XX_DUMP_READING, &ha->flags)) {
	70	set_bit(AF_82XX_DUMP_READING, &ha->flags);
	71	DEBUG2(ql4_printk(KERN_INFO, ha,
	72	"Raw firmware dump ready for read on (%ld).\n",
	73	ha->host_no));
	74	}
	75	break;
	76	case 2:
9661975f	77	/* Reset HBA and collect FW dump */
33693c7a VC	78	ha->isp_ops->idc_lock(ha);
33693c7a VC	79	dev_state = qla4_8xxx_rd_direct(ha, QLA8XXX_CRB_DEV_STATE);
de8c72da	80	if (dev_state == QLA8XXX_DEV_READY) {
9661975f VC	81	ql4_printk(KERN_INFO, ha, "%s: Setting Need reset\n",
9661975f VC	82	__func__);
33693c7a VC	83	qla4_8xxx_wr_direct(ha, QLA8XXX_CRB_DEV_STATE,
33693c7a VC	84	QLA8XXX_DEV_NEED_RESET);
9661975f	85	if (is_qla8022(ha) \|\|
b37ca418	86	((is_qla8032(ha) \|\| is_qla8042(ha)) &&
9661975f VC	87	qla4_83xx_can_perform_reset(ha))) {
	88	set_bit(AF_8XXX_RST_OWNER, &ha->flags);
	89	set_bit(AF_FW_RECOVERY, &ha->flags);
	90	ql4_printk(KERN_INFO, ha, "%s: Reset owner is 0x%x\n",
	91	__func__, ha->func_num);
	92	}
068237c8 TP	93	} else
	94	ql4_printk(KERN_INFO, ha,
	95	"%s: Reset not performed as device state is 0x%x\n",
	96	__func__, dev_state);
	97
33693c7a	98	ha->isp_ops->idc_unlock(ha);
068237c8 TP	99	break;
	100	default:
	101	/* do nothing */
	102	break;
	103	}
	104
	105	return count;
	106	}
	107
	108	static struct bin_attribute sysfs_fw_dump_attr = {
	109	.attr = {
	110	.name = "fw_dump",
	111	.mode = S_IRUSR \| S_IWUSR,
	112	},
	113	.size = 0,
	114	.read = qla4_8xxx_sysfs_read_fw_dump,
	115	.write = qla4_8xxx_sysfs_write_fw_dump,
	116	};
	117
	118	static struct sysfs_entry {
	119	char *name;
	120	struct bin_attribute *attr;
	121	} bin_file_entries[] = {
	122	{ "fw_dump", &sysfs_fw_dump_attr },
	123	{ NULL },
	124	};
	125
	126	void qla4_8xxx_alloc_sysfs_attr(struct scsi_qla_host *ha)
	127	{
	128	struct Scsi_Host *host = ha->host;
	129	struct sysfs_entry *iter;
	130	int ret;
	131
	132	for (iter = bin_file_entries; iter->name; iter++) {
	133	ret = sysfs_create_bin_file(&host->shost_gendev.kobj,
	134	iter->attr);
	135	if (ret)
	136	ql4_printk(KERN_ERR, ha,
	137	"Unable to create sysfs %s binary attribute (%d).\n",
	138	iter->name, ret);
	139	}
	140	}
	141
	142	void qla4_8xxx_free_sysfs_attr(struct scsi_qla_host *ha)
	143	{
	144	struct Scsi_Host *host = ha->host;
	145	struct sysfs_entry *iter;
	146
	147	for (iter = bin_file_entries; iter->name; iter++)
	148	sysfs_remove_bin_file(&host->shost_gendev.kobj,
	149	iter->attr);
	150	}
	151
7ad633c0 HZ	152	/* Scsi_Host attributes. */
	153	static ssize_t
	154	qla4xxx_fw_version_show(struct device *dev,
	155	struct device_attribute attr, char buf)
	156	{
	157	struct scsi_qla_host *ha = to_qla_host(class_to_shost(dev));
	158
6e7b4292	159	if (is_qla80XX(ha))
7ad633c0	160	return snprintf(buf, PAGE_SIZE, "%d.%02d.%02d (%x)\n",
eee06a0f AC	161	ha->fw_info.fw_major, ha->fw_info.fw_minor,
eee06a0f AC	162	ha->fw_info.fw_patch, ha->fw_info.fw_build);
7ad633c0 HZ	163	else
7ad633c0 HZ	164	return snprintf(buf, PAGE_SIZE, "%d.%02d.%02d.%02d\n",
eee06a0f AC	165	ha->fw_info.fw_major, ha->fw_info.fw_minor,
eee06a0f AC	166	ha->fw_info.fw_patch, ha->fw_info.fw_build);
7ad633c0 HZ	167	}
	168
	169	static ssize_t
	170	qla4xxx_serial_num_show(struct device dev, struct device_attribute attr,
	171	char *buf)
	172	{
	173	struct scsi_qla_host *ha = to_qla_host(class_to_shost(dev));
	174	return snprintf(buf, PAGE_SIZE, "%s\n", ha->serial_number);
	175	}
	176
	177	static ssize_t
	178	qla4xxx_iscsi_version_show(struct device dev, struct device_attribute attr,
	179	char *buf)
	180	{
	181	struct scsi_qla_host *ha = to_qla_host(class_to_shost(dev));
eee06a0f AC	182	return snprintf(buf, PAGE_SIZE, "%d.%02d\n", ha->fw_info.iscsi_major,
eee06a0f AC	183	ha->fw_info.iscsi_minor);
7ad633c0 HZ	184	}
	185
	186	static ssize_t
	187	qla4xxx_optrom_version_show(struct device dev, struct device_attribute attr,
	188	char *buf)
	189	{
	190	struct scsi_qla_host *ha = to_qla_host(class_to_shost(dev));
	191	return snprintf(buf, PAGE_SIZE, "%d.%02d.%02d.%02d\n",
eee06a0f AC	192	ha->fw_info.bootload_major, ha->fw_info.bootload_minor,
eee06a0f AC	193	ha->fw_info.bootload_patch, ha->fw_info.bootload_build);
7ad633c0 HZ	194	}
7ad633c0 HZ	195
91ec7cec VC	196	static ssize_t
	197	qla4xxx_board_id_show(struct device dev, struct device_attribute attr,
	198	char *buf)
	199	{
	200	struct scsi_qla_host *ha = to_qla_host(class_to_shost(dev));
	201	return snprintf(buf, PAGE_SIZE, "0x%08X\n", ha->board_id);
	202	}
	203
	204	static ssize_t
	205	qla4xxx_fw_state_show(struct device dev, struct device_attribute attr,
	206	char *buf)
	207	{
	208	struct scsi_qla_host *ha = to_qla_host(class_to_shost(dev));
	209
	210	qla4xxx_get_firmware_state(ha);
	211	return snprintf(buf, PAGE_SIZE, "0x%08X%8X\n", ha->firmware_state,
	212	ha->addl_fw_state);
	213	}
	214
	215	static ssize_t
	216	qla4xxx_phy_port_cnt_show(struct device dev, struct device_attribute attr,
	217	char *buf)
	218	{
	219	struct scsi_qla_host *ha = to_qla_host(class_to_shost(dev));
	220
ee996a69	221	if (is_qla40XX(ha))
91ec7cec VC	222	return -ENOSYS;
	223
	224	return snprintf(buf, PAGE_SIZE, "0x%04X\n", ha->phy_port_cnt);
	225	}
	226
	227	static ssize_t
	228	qla4xxx_phy_port_num_show(struct device dev, struct device_attribute attr,
	229	char *buf)
	230	{
	231	struct scsi_qla_host *ha = to_qla_host(class_to_shost(dev));
	232
ee996a69	233	if (is_qla40XX(ha))
91ec7cec VC	234	return -ENOSYS;
	235
	236	return snprintf(buf, PAGE_SIZE, "0x%04X\n", ha->phy_port_num);
	237	}
	238
	239	static ssize_t
	240	qla4xxx_iscsi_func_cnt_show(struct device dev, struct device_attribute attr,
	241	char *buf)
	242	{
	243	struct scsi_qla_host *ha = to_qla_host(class_to_shost(dev));
	244
ee996a69	245	if (is_qla40XX(ha))
91ec7cec VC	246	return -ENOSYS;
	247
	248	return snprintf(buf, PAGE_SIZE, "0x%04X\n", ha->iscsi_pci_func_cnt);
	249	}
	250
	251	static ssize_t
	252	qla4xxx_hba_model_show(struct device dev, struct device_attribute attr,
	253	char *buf)
	254	{
	255	struct scsi_qla_host *ha = to_qla_host(class_to_shost(dev));
	256
	257	return snprintf(buf, PAGE_SIZE, "%s\n", ha->model_name);
	258	}
	259
eee06a0f AC	260	static ssize_t
	261	qla4xxx_fw_timestamp_show(struct device dev, struct device_attribute attr,
	262	char *buf)
	263	{
	264	struct scsi_qla_host *ha = to_qla_host(class_to_shost(dev));
	265	return snprintf(buf, PAGE_SIZE, "%s %s\n", ha->fw_info.fw_build_date,
	266	ha->fw_info.fw_build_time);
	267	}
	268
	269	static ssize_t
	270	qla4xxx_fw_build_user_show(struct device dev, struct device_attribute attr,
	271	char *buf)
	272	{
	273	struct scsi_qla_host *ha = to_qla_host(class_to_shost(dev));
	274	return snprintf(buf, PAGE_SIZE, "%s\n", ha->fw_info.fw_build_user);
	275	}
	276
	277	static ssize_t
	278	qla4xxx_fw_ext_timestamp_show(struct device dev, struct device_attribute attr,
	279	char *buf)
	280	{
	281	struct scsi_qla_host *ha = to_qla_host(class_to_shost(dev));
	282	return snprintf(buf, PAGE_SIZE, "%s\n", ha->fw_info.extended_timestamp);
	283	}
	284
	285	static ssize_t
	286	qla4xxx_fw_load_src_show(struct device dev, struct device_attribute attr,
	287	char *buf)
	288	{
	289	struct scsi_qla_host *ha = to_qla_host(class_to_shost(dev));
	290	char *load_src = NULL;
	291
	292	switch (ha->fw_info.fw_load_source) {
	293	case 1:
	294	load_src = "Flash Primary";
	295	break;
	296	case 2:
	297	load_src = "Flash Secondary";
	298	break;
	299	case 3:
	300	load_src = "Host Download";
	301	break;
	302	}
	303
	304	return snprintf(buf, PAGE_SIZE, "%s\n", load_src);
	305	}
	306
	307	static ssize_t
	308	qla4xxx_fw_uptime_show(struct device dev, struct device_attribute attr,
	309	char *buf)
	310	{
	311	struct scsi_qla_host *ha = to_qla_host(class_to_shost(dev));
	312	qla4xxx_about_firmware(ha);
	313	return snprintf(buf, PAGE_SIZE, "%u.%u secs\n", ha->fw_uptime_secs,
	314	ha->fw_uptime_msecs);
	315	}
	316
7ad633c0 HZ	317	static DEVICE_ATTR(fw_version, S_IRUGO, qla4xxx_fw_version_show, NULL);
	318	static DEVICE_ATTR(serial_num, S_IRUGO, qla4xxx_serial_num_show, NULL);
	319	static DEVICE_ATTR(iscsi_version, S_IRUGO, qla4xxx_iscsi_version_show, NULL);
	320	static DEVICE_ATTR(optrom_version, S_IRUGO, qla4xxx_optrom_version_show, NULL);
91ec7cec VC	321	static DEVICE_ATTR(board_id, S_IRUGO, qla4xxx_board_id_show, NULL);
	322	static DEVICE_ATTR(fw_state, S_IRUGO, qla4xxx_fw_state_show, NULL);
	323	static DEVICE_ATTR(phy_port_cnt, S_IRUGO, qla4xxx_phy_port_cnt_show, NULL);
	324	static DEVICE_ATTR(phy_port_num, S_IRUGO, qla4xxx_phy_port_num_show, NULL);
	325	static DEVICE_ATTR(iscsi_func_cnt, S_IRUGO, qla4xxx_iscsi_func_cnt_show, NULL);
	326	static DEVICE_ATTR(hba_model, S_IRUGO, qla4xxx_hba_model_show, NULL);
eee06a0f AC	327	static DEVICE_ATTR(fw_timestamp, S_IRUGO, qla4xxx_fw_timestamp_show, NULL);
	328	static DEVICE_ATTR(fw_build_user, S_IRUGO, qla4xxx_fw_build_user_show, NULL);
	329	static DEVICE_ATTR(fw_ext_timestamp, S_IRUGO, qla4xxx_fw_ext_timestamp_show,
	330	NULL);
	331	static DEVICE_ATTR(fw_load_src, S_IRUGO, qla4xxx_fw_load_src_show, NULL);
	332	static DEVICE_ATTR(fw_uptime, S_IRUGO, qla4xxx_fw_uptime_show, NULL);
7ad633c0 HZ	333
	334	struct device_attribute *qla4xxx_host_attrs[] = {
	335	&dev_attr_fw_version,
	336	&dev_attr_serial_num,
	337	&dev_attr_iscsi_version,
	338	&dev_attr_optrom_version,
91ec7cec VC	339	&dev_attr_board_id,
	340	&dev_attr_fw_state,
	341	&dev_attr_phy_port_cnt,
	342	&dev_attr_phy_port_num,
	343	&dev_attr_iscsi_func_cnt,
	344	&dev_attr_hba_model,
eee06a0f AC	345	&dev_attr_fw_timestamp,
	346	&dev_attr_fw_build_user,
	347	&dev_attr_fw_ext_timestamp,
	348	&dev_attr_fw_load_src,
	349	&dev_attr_fw_uptime,
7ad633c0 HZ	350	NULL,
7ad633c0 HZ	351	};