[linux-block.git] / net / ethtool / eeprom.c

// SPDX-License-Identifier: GPL-2.0-only

#include <linux/ethtool.h>
#include <linux/sfp.h>
#include "netlink.h"
#include "common.h"

struct eeprom_req_info {
	struct ethnl_req_info	base;
	u32			offset;
	u32			length;
	u8			page;
	u8			bank;
	u8			i2c_address;
};

struct eeprom_reply_data {
	struct ethnl_reply_data base;
	u32			length;
	u8			*data;
};

#define MODULE_EEPROM_REQINFO(__req_base) \
	container_of(__req_base, struct eeprom_req_info, base)

#define MODULE_EEPROM_REPDATA(__reply_base) \
	container_of(__reply_base, struct eeprom_reply_data, base)

static int fallback_set_params(struct eeprom_req_info *request,
			       struct ethtool_modinfo *modinfo,
			       struct ethtool_eeprom *eeprom)
{
	u32 offset = request->offset;
	u32 length = request->length;

	if (request->page)
		offset = request->page * ETH_MODULE_EEPROM_PAGE_LEN + offset;

	if (modinfo->type == ETH_MODULE_SFF_8472 &&
	    request->i2c_address == 0x51)
		offset += ETH_MODULE_EEPROM_PAGE_LEN * 2;

	if (offset >= modinfo->eeprom_len)
		return -EINVAL;

	eeprom->cmd = ETHTOOL_GMODULEEEPROM;
	eeprom->len = length;
	eeprom->offset = offset;

	return 0;
}

static int eeprom_fallback(struct eeprom_req_info *request,
			   struct eeprom_reply_data *reply,
			   struct genl_info *info)
{
	struct net_device *dev = reply->base.dev;
	struct ethtool_modinfo modinfo = {0};
	struct ethtool_eeprom eeprom = {0};
	u8 *data;
	int err;

	modinfo.cmd = ETHTOOL_GMODULEINFO;
	err = ethtool_get_module_info_call(dev, &modinfo);
	if (err < 0)
		return err;

	err = fallback_set_params(request, &modinfo, &eeprom);
	if (err < 0)
		return err;

	data = kmalloc(eeprom.len, GFP_KERNEL);
	if (!data)
		return -ENOMEM;
	err = ethtool_get_module_eeprom_call(dev, &eeprom, data);
	if (err < 0)
		goto err_out;

	reply->data = data;
	reply->length = eeprom.len;

	return 0;

err_out:
	kfree(data);
	return err;
}

static int get_module_eeprom_by_page(struct net_device *dev,
				     struct ethtool_module_eeprom *page_data,
				     struct netlink_ext_ack *extack)
{
	const struct ethtool_ops *ops = dev->ethtool_ops;

	if (dev->sfp_bus)
		return sfp_get_module_eeprom_by_page(dev->sfp_bus, page_data, extack);

	if (ops->get_module_eeprom_by_page)
		return ops->get_module_eeprom_by_page(dev, page_data, extack);

	return -EOPNOTSUPP;
}

static int eeprom_prepare_data(const struct ethnl_req_info *req_base,
			       struct ethnl_reply_data *reply_base,
			       struct genl_info *info)
{
	struct eeprom_reply_data *reply = MODULE_EEPROM_REPDATA(reply_base);
	struct eeprom_req_info *request = MODULE_EEPROM_REQINFO(req_base);
	struct ethtool_module_eeprom page_data = {0};
	struct net_device *dev = reply_base->dev;
	int ret;

	page_data.offset = request->offset;
	page_data.length = request->length;
	page_data.i2c_address = request->i2c_address;
	page_data.page = request->page;
	page_data.bank = request->bank;
	page_data.data = kmalloc(page_data.length, GFP_KERNEL);
	if (!page_data.data)
		return -ENOMEM;

	ret = ethnl_ops_begin(dev);
	if (ret)
		goto err_free;

	ret = get_module_eeprom_by_page(dev, &page_data, info ? info->extack : NULL);
	if (ret < 0)
		goto err_ops;

	reply->length = ret;
	reply->data = page_data.data;

	ethnl_ops_complete(dev);
	return 0;

err_ops:
	ethnl_ops_complete(dev);
err_free:
	kfree(page_data.data);

	if (ret == -EOPNOTSUPP)
		return eeprom_fallback(request, reply, info);
	return ret;
}

static int eeprom_parse_request(struct ethnl_req_info *req_info, struct nlattr **tb,
				struct netlink_ext_ack *extack)
{
	struct eeprom_req_info *request = MODULE_EEPROM_REQINFO(req_info);

	if (!tb[ETHTOOL_A_MODULE_EEPROM_OFFSET] ||
	    !tb[ETHTOOL_A_MODULE_EEPROM_LENGTH] ||
	    !tb[ETHTOOL_A_MODULE_EEPROM_PAGE] ||
	    !tb[ETHTOOL_A_MODULE_EEPROM_I2C_ADDRESS])
		return -EINVAL;

	request->i2c_address = nla_get_u8(tb[ETHTOOL_A_MODULE_EEPROM_I2C_ADDRESS]);
	request->offset = nla_get_u32(tb[ETHTOOL_A_MODULE_EEPROM_OFFSET]);
	request->length = nla_get_u32(tb[ETHTOOL_A_MODULE_EEPROM_LENGTH]);

	/* The following set of conditions limit the API to only dump 1/2
	 * EEPROM page without crossing low page boundary located at offset 128.
	 * This means user may only request dumps of length limited to 128 from
	 * either low 128 bytes or high 128 bytes.
	 * For pages higher than 0 only high 128 bytes are accessible.
	 */
	request->page = nla_get_u8(tb[ETHTOOL_A_MODULE_EEPROM_PAGE]);
	if (request->page && request->offset < ETH_MODULE_EEPROM_PAGE_LEN) {
		NL_SET_ERR_MSG_ATTR(extack, tb[ETHTOOL_A_MODULE_EEPROM_PAGE],
				    "reading from lower half page is allowed for page 0 only");
		return -EINVAL;
	}

	if (request->offset < ETH_MODULE_EEPROM_PAGE_LEN &&
	    request->offset + request->length > ETH_MODULE_EEPROM_PAGE_LEN) {
		NL_SET_ERR_MSG_ATTR(extack, tb[ETHTOOL_A_MODULE_EEPROM_LENGTH],
				    "reading cross half page boundary is illegal");
		return -EINVAL;
	} else if (request->offset + request->length > ETH_MODULE_EEPROM_PAGE_LEN * 2) {
		NL_SET_ERR_MSG_ATTR(extack, tb[ETHTOOL_A_MODULE_EEPROM_LENGTH],
				    "reading cross page boundary is illegal");
		return -EINVAL;
	}

	if (tb[ETHTOOL_A_MODULE_EEPROM_BANK])
		request->bank = nla_get_u8(tb[ETHTOOL_A_MODULE_EEPROM_BANK]);

	return 0;
}

static int eeprom_reply_size(const struct ethnl_req_info *req_base,
			     const struct ethnl_reply_data *reply_base)
{
	const struct eeprom_req_info *request = MODULE_EEPROM_REQINFO(req_base);

	return nla_total_size(sizeof(u8) * request->length); /* _EEPROM_DATA */
}

static int eeprom_fill_reply(struct sk_buff *skb,
			     const struct ethnl_req_info *req_base,
			     const struct ethnl_reply_data *reply_base)
{
	struct eeprom_reply_data *reply = MODULE_EEPROM_REPDATA(reply_base);

	return nla_put(skb, ETHTOOL_A_MODULE_EEPROM_DATA, reply->length, reply->data);
}

static void eeprom_cleanup_data(struct ethnl_reply_data *reply_base)
{
	struct eeprom_reply_data *reply = MODULE_EEPROM_REPDATA(reply_base);

	kfree(reply->data);
}

const struct ethnl_request_ops ethnl_module_eeprom_request_ops = {
	.request_cmd		= ETHTOOL_MSG_MODULE_EEPROM_GET,
	.reply_cmd		= ETHTOOL_MSG_MODULE_EEPROM_GET_REPLY,
	.hdr_attr		= ETHTOOL_A_MODULE_EEPROM_HEADER,
	.req_info_size		= sizeof(struct eeprom_req_info),
	.reply_data_size	= sizeof(struct eeprom_reply_data),

	.parse_request		= eeprom_parse_request,
	.prepare_data		= eeprom_prepare_data,
	.reply_size		= eeprom_reply_size,
	.fill_reply		= eeprom_fill_reply,
	.cleanup_data		= eeprom_cleanup_data,
};

const struct nla_policy ethnl_module_eeprom_get_policy[] = {
	[ETHTOOL_A_MODULE_EEPROM_HEADER]	= NLA_POLICY_NESTED(ethnl_header_policy),
	[ETHTOOL_A_MODULE_EEPROM_OFFSET]	=
		NLA_POLICY_MAX(NLA_U32, ETH_MODULE_EEPROM_PAGE_LEN * 2 - 1),
	[ETHTOOL_A_MODULE_EEPROM_LENGTH]	=
		NLA_POLICY_RANGE(NLA_U32, 1, ETH_MODULE_EEPROM_PAGE_LEN),
	[ETHTOOL_A_MODULE_EEPROM_PAGE]		= { .type = NLA_U8 },
	[ETHTOOL_A_MODULE_EEPROM_BANK]		= { .type = NLA_U8 },
	[ETHTOOL_A_MODULE_EEPROM_I2C_ADDRESS]	=
		NLA_POLICY_RANGE(NLA_U8, 0, ETH_MODULE_MAX_I2C_ADDRESS),
};
Commit	Line	Data
c781ff12 VT	1	// SPDX-License-Identifier: GPL-2.0-only
	2
	3	#include <linux/ethtool.h>
c97a31f6	4	#include <linux/sfp.h>
c781ff12 VT	5	#include "netlink.h"
	6	#include "common.h"
	7
	8	struct eeprom_req_info {
	9	struct ethnl_req_info base;
	10	u32 offset;
	11	u32 length;
	12	u8 page;
	13	u8 bank;
	14	u8 i2c_address;
	15	};
	16
	17	struct eeprom_reply_data {
	18	struct ethnl_reply_data base;
	19	u32 length;
	20	u8 *data;
	21	};
	22
	23	#define MODULE_EEPROM_REQINFO(__req_base) \
	24	container_of(__req_base, struct eeprom_req_info, base)
	25
	26	#define MODULE_EEPROM_REPDATA(__reply_base) \
	27	container_of(__reply_base, struct eeprom_reply_data, base)
	28
96d971e3 VT	29	static int fallback_set_params(struct eeprom_req_info *request,
	30	struct ethtool_modinfo *modinfo,
	31	struct ethtool_eeprom *eeprom)
	32	{
	33	u32 offset = request->offset;
	34	u32 length = request->length;
	35
	36	if (request->page)
	37	offset = request->page * ETH_MODULE_EEPROM_PAGE_LEN + offset;
	38
a3bb7b63	39	if (modinfo->type == ETH_MODULE_SFF_8472 &&
96d971e3 VT	40	request->i2c_address == 0x51)
	41	offset += ETH_MODULE_EEPROM_PAGE_LEN * 2;
	42
	43	if (offset >= modinfo->eeprom_len)
	44	return -EINVAL;
	45
	46	eeprom->cmd = ETHTOOL_GMODULEEEPROM;
	47	eeprom->len = length;
	48	eeprom->offset = offset;
	49
	50	return 0;
	51	}
	52
	53	static int eeprom_fallback(struct eeprom_req_info *request,
	54	struct eeprom_reply_data *reply,
	55	struct genl_info *info)
	56	{
	57	struct net_device *dev = reply->base.dev;
	58	struct ethtool_modinfo modinfo = {0};
	59	struct ethtool_eeprom eeprom = {0};
	60	u8 *data;
	61	int err;
	62
	63	modinfo.cmd = ETHTOOL_GMODULEINFO;
	64	err = ethtool_get_module_info_call(dev, &modinfo);
	65	if (err < 0)
	66	return err;
	67
	68	err = fallback_set_params(request, &modinfo, &eeprom);
	69	if (err < 0)
	70	return err;
	71
	72	data = kmalloc(eeprom.len, GFP_KERNEL);
	73	if (!data)
	74	return -ENOMEM;
	75	err = ethtool_get_module_eeprom_call(dev, &eeprom, data);
	76	if (err < 0)
	77	goto err_out;
	78
	79	reply->data = data;
	80	reply->length = eeprom.len;
	81
	82	return 0;
	83
	84	err_out:
	85	kfree(data);
	86	return err;
	87	}
	88
c97a31f6 AL	89	static int get_module_eeprom_by_page(struct net_device *dev,
	90	struct ethtool_module_eeprom *page_data,
	91	struct netlink_ext_ack *extack)
	92	{
	93	const struct ethtool_ops *ops = dev->ethtool_ops;
	94
	95	if (dev->sfp_bus)
	96	return sfp_get_module_eeprom_by_page(dev->sfp_bus, page_data, extack);
	97
51c96a56	98	if (ops->get_module_eeprom_by_page)
c97a31f6 AL	99	return ops->get_module_eeprom_by_page(dev, page_data, extack);
	100
	101	return -EOPNOTSUPP;
	102	}
	103
c781ff12 VT	104	static int eeprom_prepare_data(const struct ethnl_req_info *req_base,
	105	struct ethnl_reply_data *reply_base,
	106	struct genl_info *info)
	107	{
	108	struct eeprom_reply_data *reply = MODULE_EEPROM_REPDATA(reply_base);
	109	struct eeprom_req_info *request = MODULE_EEPROM_REQINFO(req_base);
	110	struct ethtool_module_eeprom page_data = {0};
	111	struct net_device *dev = reply_base->dev;
	112	int ret;
	113
c781ff12 VT	114	page_data.offset = request->offset;
	115	page_data.length = request->length;
	116	page_data.i2c_address = request->i2c_address;
	117	page_data.page = request->page;
	118	page_data.bank = request->bank;
	119	page_data.data = kmalloc(page_data.length, GFP_KERNEL);
	120	if (!page_data.data)
	121	return -ENOMEM;
	122
	123	ret = ethnl_ops_begin(dev);
	124	if (ret)
	125	goto err_free;
	126
9d9effca	127	ret = get_module_eeprom_by_page(dev, &page_data, info ? info->extack : NULL);
c781ff12 VT	128	if (ret < 0)
	129	goto err_ops;
	130
	131	reply->length = ret;
	132	reply->data = page_data.data;
	133
	134	ethnl_ops_complete(dev);
	135	return 0;
	136
	137	err_ops:
	138	ethnl_ops_complete(dev);
	139	err_free:
	140	kfree(page_data.data);
c97a31f6 AL	141
	142	if (ret == -EOPNOTSUPP)
	143	return eeprom_fallback(request, reply, info);
c781ff12 VT	144	return ret;
	145	}
	146
	147	static int eeprom_parse_request(struct ethnl_req_info req_info, struct nlattr *tb,
	148	struct netlink_ext_ack *extack)
	149	{
	150	struct eeprom_req_info *request = MODULE_EEPROM_REQINFO(req_info);
	151
	152	if (!tb[ETHTOOL_A_MODULE_EEPROM_OFFSET] \|\|
	153	!tb[ETHTOOL_A_MODULE_EEPROM_LENGTH] \|\|
	154	!tb[ETHTOOL_A_MODULE_EEPROM_PAGE] \|\|
	155	!tb[ETHTOOL_A_MODULE_EEPROM_I2C_ADDRESS])
	156	return -EINVAL;
	157
	158	request->i2c_address = nla_get_u8(tb[ETHTOOL_A_MODULE_EEPROM_I2C_ADDRESS]);
	159	request->offset = nla_get_u32(tb[ETHTOOL_A_MODULE_EEPROM_OFFSET]);
	160	request->length = nla_get_u32(tb[ETHTOOL_A_MODULE_EEPROM_LENGTH]);
	161
c781ff12 VT	162	/* The following set of conditions limit the API to only dump 1/2
	163	* EEPROM page without crossing low page boundary located at offset 128.
	164	* This means user may only request dumps of length limited to 128 from
	165	* either low 128 bytes or high 128 bytes.
	166	* For pages higher than 0 only high 128 bytes are accessible.
	167	*/
	168	request->page = nla_get_u8(tb[ETHTOOL_A_MODULE_EEPROM_PAGE]);
	169	if (request->page && request->offset < ETH_MODULE_EEPROM_PAGE_LEN) {
	170	NL_SET_ERR_MSG_ATTR(extack, tb[ETHTOOL_A_MODULE_EEPROM_PAGE],
	171	"reading from lower half page is allowed for page 0 only");
	172	return -EINVAL;
	173	}
	174
	175	if (request->offset < ETH_MODULE_EEPROM_PAGE_LEN &&
	176	request->offset + request->length > ETH_MODULE_EEPROM_PAGE_LEN) {
	177	NL_SET_ERR_MSG_ATTR(extack, tb[ETHTOOL_A_MODULE_EEPROM_LENGTH],
	178	"reading cross half page boundary is illegal");
	179	return -EINVAL;
c781ff12 VT	180	} else if (request->offset + request->length > ETH_MODULE_EEPROM_PAGE_LEN * 2) {
	181	NL_SET_ERR_MSG_ATTR(extack, tb[ETHTOOL_A_MODULE_EEPROM_LENGTH],
	182	"reading cross page boundary is illegal");
	183	return -EINVAL;
	184	}
	185
	186	if (tb[ETHTOOL_A_MODULE_EEPROM_BANK])
	187	request->bank = nla_get_u8(tb[ETHTOOL_A_MODULE_EEPROM_BANK]);
	188
	189	return 0;
	190	}
	191
	192	static int eeprom_reply_size(const struct ethnl_req_info *req_base,
	193	const struct ethnl_reply_data *reply_base)
	194	{
	195	const struct eeprom_req_info *request = MODULE_EEPROM_REQINFO(req_base);
	196
	197	return nla_total_size(sizeof(u8) * request->length); /* _EEPROM_DATA */
	198	}
	199
	200	static int eeprom_fill_reply(struct sk_buff *skb,
	201	const struct ethnl_req_info *req_base,
	202	const struct ethnl_reply_data *reply_base)
	203	{
	204	struct eeprom_reply_data *reply = MODULE_EEPROM_REPDATA(reply_base);
	205
	206	return nla_put(skb, ETHTOOL_A_MODULE_EEPROM_DATA, reply->length, reply->data);
	207	}
	208
	209	static void eeprom_cleanup_data(struct ethnl_reply_data *reply_base)
	210	{
	211	struct eeprom_reply_data *reply = MODULE_EEPROM_REPDATA(reply_base);
	212
	213	kfree(reply->data);
	214	}
	215
	216	const struct ethnl_request_ops ethnl_module_eeprom_request_ops = {
	217	.request_cmd = ETHTOOL_MSG_MODULE_EEPROM_GET,
	218	.reply_cmd = ETHTOOL_MSG_MODULE_EEPROM_GET_REPLY,
	219	.hdr_attr = ETHTOOL_A_MODULE_EEPROM_HEADER,
	220	.req_info_size = sizeof(struct eeprom_req_info),
	221	.reply_data_size = sizeof(struct eeprom_reply_data),
	222
	223	.parse_request = eeprom_parse_request,
	224	.prepare_data = eeprom_prepare_data,
	225	.reply_size = eeprom_reply_size,
	226	.fill_reply = eeprom_fill_reply,
	227	.cleanup_data = eeprom_cleanup_data,
	228	};
	229
	230	const struct nla_policy ethnl_module_eeprom_get_policy[] = {
	231	[ETHTOOL_A_MODULE_EEPROM_HEADER] = NLA_POLICY_NESTED(ethnl_header_policy),
88f9a87a IS	232	[ETHTOOL_A_MODULE_EEPROM_OFFSET] =
88f9a87a IS	233	NLA_POLICY_MAX(NLA_U32, ETH_MODULE_EEPROM_PAGE_LEN * 2 - 1),
0dc7dd02 IS	234	[ETHTOOL_A_MODULE_EEPROM_LENGTH] =
0dc7dd02 IS	235	NLA_POLICY_RANGE(NLA_U32, 1, ETH_MODULE_EEPROM_PAGE_LEN),
c781ff12 VT	236	[ETHTOOL_A_MODULE_EEPROM_PAGE] = { .type = NLA_U8 },
	237	[ETHTOOL_A_MODULE_EEPROM_BANK] = { .type = NLA_U8 },
	238	[ETHTOOL_A_MODULE_EEPROM_I2C_ADDRESS] =
	239	NLA_POLICY_RANGE(NLA_U8, 0, ETH_MODULE_MAX_I2C_ADDRESS),
	240	};
	241