[linux-2.6-block.git] / drivers / scsi / qedf / qedf_attr.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 *  QLogic FCoE Offload Driver
 *  Copyright (c) 2016-2018 Cavium Inc.
 */
#include "qedf.h"

inline bool qedf_is_vport(struct qedf_ctx *qedf)
{
	return qedf->lport->vport != NULL;
}

/* Get base qedf for physical port from vport */
static struct qedf_ctx *qedf_get_base_qedf(struct qedf_ctx *qedf)
{
	struct fc_lport *lport;
	struct fc_lport *base_lport;

	if (!(qedf_is_vport(qedf)))
		return NULL;

	lport = qedf->lport;
	base_lport = shost_priv(vport_to_shost(lport->vport));
	return lport_priv(base_lport);
}

static ssize_t
qedf_fcoe_mac_show(struct device *dev,
	struct device_attribute *attr, char *buf)
{
	struct fc_lport *lport = shost_priv(class_to_shost(dev));
	u32 port_id;
	u8 lport_src_id[3];
	u8 fcoe_mac[6];

	port_id = fc_host_port_id(lport->host);
	lport_src_id[2] = (port_id & 0x000000FF);
	lport_src_id[1] = (port_id & 0x0000FF00) >> 8;
	lport_src_id[0] = (port_id & 0x00FF0000) >> 16;
	fc_fcoe_set_mac(fcoe_mac, lport_src_id);

	return scnprintf(buf, PAGE_SIZE, "%pM\n", fcoe_mac);
}

static ssize_t
qedf_fka_period_show(struct device *dev,
	struct device_attribute *attr, char *buf)
{
	struct fc_lport *lport = shost_priv(class_to_shost(dev));
	struct qedf_ctx *qedf = lport_priv(lport);
	int fka_period = -1;

	if (qedf_is_vport(qedf))
		qedf = qedf_get_base_qedf(qedf);

	if (qedf->ctlr.sel_fcf)
		fka_period = qedf->ctlr.sel_fcf->fka_period;

	return scnprintf(buf, PAGE_SIZE, "%d\n", fka_period);
}

static DEVICE_ATTR(fcoe_mac, S_IRUGO, qedf_fcoe_mac_show, NULL);
static DEVICE_ATTR(fka_period, S_IRUGO, qedf_fka_period_show, NULL);

struct device_attribute *qedf_host_attrs[] = {
	&dev_attr_fcoe_mac,
	&dev_attr_fka_period,
	NULL,
};

extern const struct qed_fcoe_ops *qed_ops;

void qedf_capture_grc_dump(struct qedf_ctx *qedf)
{
	struct qedf_ctx *base_qedf;

	/* Make sure we use the base qedf to take the GRC dump */
	if (qedf_is_vport(qedf))
		base_qedf = qedf_get_base_qedf(qedf);
	else
		base_qedf = qedf;

	if (test_bit(QEDF_GRCDUMP_CAPTURE, &base_qedf->flags)) {
		QEDF_INFO(&(base_qedf->dbg_ctx), QEDF_LOG_INFO,
		    "GRC Dump already captured.\n");
		return;
	}


	qedf_get_grc_dump(base_qedf->cdev, qed_ops->common,
	    &base_qedf->grcdump, &base_qedf->grcdump_size);
	QEDF_ERR(&(base_qedf->dbg_ctx), "GRC Dump captured.\n");
	set_bit(QEDF_GRCDUMP_CAPTURE, &base_qedf->flags);
	qedf_uevent_emit(base_qedf->lport->host, QEDF_UEVENT_CODE_GRCDUMP,
	    NULL);
}

static ssize_t
qedf_sysfs_read_grcdump(struct file *filep, struct kobject *kobj,
			struct bin_attribute *ba, char *buf, loff_t off,
			size_t count)
{
	ssize_t ret = 0;
	struct fc_lport *lport = shost_priv(dev_to_shost(container_of(kobj,
							struct device, kobj)));
	struct qedf_ctx *qedf = lport_priv(lport);

	if (test_bit(QEDF_GRCDUMP_CAPTURE, &qedf->flags)) {
		ret = memory_read_from_buffer(buf, count, &off,
		    qedf->grcdump, qedf->grcdump_size);
	} else {
		QEDF_ERR(&(qedf->dbg_ctx), "GRC Dump not captured!\n");
	}

	return ret;
}

static ssize_t
qedf_sysfs_write_grcdump(struct file *filep, struct kobject *kobj,
			struct bin_attribute *ba, char *buf, loff_t off,
			size_t count)
{
	struct fc_lport *lport = NULL;
	struct qedf_ctx *qedf = NULL;
	long reading;
	int ret = 0;
	char msg[40];

	if (off != 0)
		return ret;


	lport = shost_priv(dev_to_shost(container_of(kobj,
	    struct device, kobj)));
	qedf = lport_priv(lport);

	buf[1] = 0;
	ret = kstrtol(buf, 10, &reading);
	if (ret) {
		QEDF_ERR(&(qedf->dbg_ctx), "Invalid input, err(%d)\n", ret);
		return ret;
	}

	memset(msg, 0, sizeof(msg));
	switch (reading) {
	case 0:
		memset(qedf->grcdump, 0, qedf->grcdump_size);
		clear_bit(QEDF_GRCDUMP_CAPTURE, &qedf->flags);
		break;
	case 1:
		qedf_capture_grc_dump(qedf);
		break;
	}

	return count;
}

static struct bin_attribute sysfs_grcdump_attr = {
	.attr = {
		.name = "grcdump",
		.mode = S_IRUSR | S_IWUSR,
	},
	.size = 0,
	.read = qedf_sysfs_read_grcdump,
	.write = qedf_sysfs_write_grcdump,
};

static struct sysfs_bin_attrs bin_file_entries[] = {
	{"grcdump", &sysfs_grcdump_attr},
	{NULL},
};

void qedf_create_sysfs_ctx_attr(struct qedf_ctx *qedf)
{
	qedf_create_sysfs_attr(qedf->lport->host, bin_file_entries);
}

void qedf_remove_sysfs_ctx_attr(struct qedf_ctx *qedf)
{
	qedf_remove_sysfs_attr(qedf->lport->host, bin_file_entries);
}
Commit	Line	Data
3287e96a	1	// SPDX-License-Identifier: GPL-2.0-only
61d8658b DC	2	/*
61d8658b DC	3	* QLogic FCoE Offload Driver
5d1c8b5b	4	* Copyright (c) 2016-2018 Cavium Inc.
61d8658b DC	5	*/
	6	#include "qedf.h"
	7
c07c54b0 CD	8	inline bool qedf_is_vport(struct qedf_ctx *qedf)
	9	{
	10	return qedf->lport->vport != NULL;
	11	}
	12
	13	/* Get base qedf for physical port from vport */
	14	static struct qedf_ctx qedf_get_base_qedf(struct qedf_ctx qedf)
	15	{
	16	struct fc_lport *lport;
	17	struct fc_lport *base_lport;
	18
	19	if (!(qedf_is_vport(qedf)))
	20	return NULL;
	21
	22	lport = qedf->lport;
	23	base_lport = shost_priv(vport_to_shost(lport->vport));
	24	return lport_priv(base_lport);
	25	}
	26
61d8658b DC	27	static ssize_t
	28	qedf_fcoe_mac_show(struct device *dev,
	29	struct device_attribute attr, char buf)
	30	{
	31	struct fc_lport *lport = shost_priv(class_to_shost(dev));
	32	u32 port_id;
	33	u8 lport_src_id[3];
	34	u8 fcoe_mac[6];
	35
	36	port_id = fc_host_port_id(lport->host);
	37	lport_src_id[2] = (port_id & 0x000000FF);
	38	lport_src_id[1] = (port_id & 0x0000FF00) >> 8;
	39	lport_src_id[0] = (port_id & 0x00FF0000) >> 16;
	40	fc_fcoe_set_mac(fcoe_mac, lport_src_id);
	41
	42	return scnprintf(buf, PAGE_SIZE, "%pM\n", fcoe_mac);
	43	}
	44
c07c54b0 CD	45	static ssize_t
	46	qedf_fka_period_show(struct device *dev,
	47	struct device_attribute attr, char buf)
	48	{
	49	struct fc_lport *lport = shost_priv(class_to_shost(dev));
	50	struct qedf_ctx *qedf = lport_priv(lport);
	51	int fka_period = -1;
	52
	53	if (qedf_is_vport(qedf))
	54	qedf = qedf_get_base_qedf(qedf);
	55
	56	if (qedf->ctlr.sel_fcf)
	57	fka_period = qedf->ctlr.sel_fcf->fka_period;
	58
	59	return scnprintf(buf, PAGE_SIZE, "%d\n", fka_period);
	60	}
	61
61d8658b	62	static DEVICE_ATTR(fcoe_mac, S_IRUGO, qedf_fcoe_mac_show, NULL);
c07c54b0	63	static DEVICE_ATTR(fka_period, S_IRUGO, qedf_fka_period_show, NULL);
61d8658b DC	64
	65	struct device_attribute *qedf_host_attrs[] = {
	66	&dev_attr_fcoe_mac,
c07c54b0	67	&dev_attr_fka_period,
61d8658b DC	68	NULL,
	69	};
	70
	71	extern const struct qed_fcoe_ops *qed_ops;
	72
61d8658b DC	73	void qedf_capture_grc_dump(struct qedf_ctx *qedf)
	74	{
	75	struct qedf_ctx *base_qedf;
	76
	77	/* Make sure we use the base qedf to take the GRC dump */
	78	if (qedf_is_vport(qedf))
	79	base_qedf = qedf_get_base_qedf(qedf);
	80	else
	81	base_qedf = qedf;
	82
	83	if (test_bit(QEDF_GRCDUMP_CAPTURE, &base_qedf->flags)) {
	84	QEDF_INFO(&(base_qedf->dbg_ctx), QEDF_LOG_INFO,
	85	"GRC Dump already captured.\n");
	86	return;
	87	}
	88
	89
	90	qedf_get_grc_dump(base_qedf->cdev, qed_ops->common,
	91	&base_qedf->grcdump, &base_qedf->grcdump_size);
	92	QEDF_ERR(&(base_qedf->dbg_ctx), "GRC Dump captured.\n");
	93	set_bit(QEDF_GRCDUMP_CAPTURE, &base_qedf->flags);
	94	qedf_uevent_emit(base_qedf->lport->host, QEDF_UEVENT_CODE_GRCDUMP,
	95	NULL);
	96	}
	97
	98	static ssize_t
	99	qedf_sysfs_read_grcdump(struct file filep, struct kobject kobj,
	100	struct bin_attribute ba, char buf, loff_t off,
	101	size_t count)
	102	{
	103	ssize_t ret = 0;
	104	struct fc_lport *lport = shost_priv(dev_to_shost(container_of(kobj,
	105	struct device, kobj)));
	106	struct qedf_ctx *qedf = lport_priv(lport);
	107
	108	if (test_bit(QEDF_GRCDUMP_CAPTURE, &qedf->flags)) {
	109	ret = memory_read_from_buffer(buf, count, &off,
	110	qedf->grcdump, qedf->grcdump_size);
	111	} else {
	112	QEDF_ERR(&(qedf->dbg_ctx), "GRC Dump not captured!\n");
	113	}
	114
	115	return ret;
	116	}
	117
	118	static ssize_t
	119	qedf_sysfs_write_grcdump(struct file filep, struct kobject kobj,
	120	struct bin_attribute ba, char buf, loff_t off,
	121	size_t count)
	122	{
	123	struct fc_lport *lport = NULL;
	124	struct qedf_ctx *qedf = NULL;
	125	long reading;
	126	int ret = 0;
	127	char msg[40];
	128
	129	if (off != 0)
	130	return ret;
	131
	132
	133	lport = shost_priv(dev_to_shost(container_of(kobj,
	134	struct device, kobj)));
	135	qedf = lport_priv(lport);
	136
137	buf[1] = 0;
138	ret = kstrtol(buf, 10, &reading);
139	if (ret) {
140	QEDF_ERR(&(qedf->dbg_ctx), "Invalid input, err(%d)\n", ret);
141	return ret;
142	}
143
144	memset(msg, 0, sizeof(msg));
145	switch (reading) {
146	case 0:
147	memset(qedf->grcdump, 0, qedf->grcdump_size);
148	clear_bit(QEDF_GRCDUMP_CAPTURE, &qedf->flags);
149	break;
150	case 1:
151	qedf_capture_grc_dump(qedf);
152	break;
153	}
154
155	return count;
156	}
157
158	static struct bin_attribute sysfs_grcdump_attr = {
159	.attr = {
160	.name = "grcdump",
161	.mode = S_IRUSR \| S_IWUSR,
162	},
163	.size = 0,
164	.read = qedf_sysfs_read_grcdump,
165	.write = qedf_sysfs_write_grcdump,
166	};
167
168	static struct sysfs_bin_attrs bin_file_entries[] = {
169	{"grcdump", &sysfs_grcdump_attr},
170	{NULL},
171	};
172
173	void qedf_create_sysfs_ctx_attr(struct qedf_ctx *qedf)
174	{
175	qedf_create_sysfs_attr(qedf->lport->host, bin_file_entries);
176	}
177
178	void qedf_remove_sysfs_ctx_attr(struct qedf_ctx *qedf)
179	{
180	qedf_remove_sysfs_attr(qedf->lport->host, bin_file_entries);
181	}