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

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

#include "netlink.h"
#include "common.h"

struct coalesce_req_info {
	struct ethnl_req_info		base;
};

struct coalesce_reply_data {
	struct ethnl_reply_data		base;
	struct ethtool_coalesce		coalesce;
	struct kernel_ethtool_coalesce	kernel_coalesce;
	u32				supported_params;
};

#define COALESCE_REPDATA(__reply_base) \
	container_of(__reply_base, struct coalesce_reply_data, base)

#define __SUPPORTED_OFFSET ETHTOOL_A_COALESCE_RX_USECS
static u32 attr_to_mask(unsigned int attr_type)
{
	return BIT(attr_type - __SUPPORTED_OFFSET);
}

/* build time check that indices in ethtool_ops::supported_coalesce_params
 * match corresponding attribute types with an offset
 */
#define __CHECK_SUPPORTED_OFFSET(x) \
	static_assert((ETHTOOL_ ## x) == \
		      BIT((ETHTOOL_A_ ## x) - __SUPPORTED_OFFSET))
__CHECK_SUPPORTED_OFFSET(COALESCE_RX_USECS);
__CHECK_SUPPORTED_OFFSET(COALESCE_RX_MAX_FRAMES);
__CHECK_SUPPORTED_OFFSET(COALESCE_RX_USECS_IRQ);
__CHECK_SUPPORTED_OFFSET(COALESCE_RX_MAX_FRAMES_IRQ);
__CHECK_SUPPORTED_OFFSET(COALESCE_TX_USECS);
__CHECK_SUPPORTED_OFFSET(COALESCE_TX_MAX_FRAMES);
__CHECK_SUPPORTED_OFFSET(COALESCE_TX_USECS_IRQ);
__CHECK_SUPPORTED_OFFSET(COALESCE_TX_MAX_FRAMES_IRQ);
__CHECK_SUPPORTED_OFFSET(COALESCE_STATS_BLOCK_USECS);
__CHECK_SUPPORTED_OFFSET(COALESCE_USE_ADAPTIVE_RX);
__CHECK_SUPPORTED_OFFSET(COALESCE_USE_ADAPTIVE_TX);
__CHECK_SUPPORTED_OFFSET(COALESCE_PKT_RATE_LOW);
__CHECK_SUPPORTED_OFFSET(COALESCE_RX_USECS_LOW);
__CHECK_SUPPORTED_OFFSET(COALESCE_RX_MAX_FRAMES_LOW);
__CHECK_SUPPORTED_OFFSET(COALESCE_TX_USECS_LOW);
__CHECK_SUPPORTED_OFFSET(COALESCE_TX_MAX_FRAMES_LOW);
__CHECK_SUPPORTED_OFFSET(COALESCE_PKT_RATE_HIGH);
__CHECK_SUPPORTED_OFFSET(COALESCE_RX_USECS_HIGH);
__CHECK_SUPPORTED_OFFSET(COALESCE_RX_MAX_FRAMES_HIGH);
__CHECK_SUPPORTED_OFFSET(COALESCE_TX_USECS_HIGH);
__CHECK_SUPPORTED_OFFSET(COALESCE_TX_MAX_FRAMES_HIGH);
__CHECK_SUPPORTED_OFFSET(COALESCE_RATE_SAMPLE_INTERVAL);

const struct nla_policy ethnl_coalesce_get_policy[] = {
	[ETHTOOL_A_COALESCE_HEADER]		=
		NLA_POLICY_NESTED(ethnl_header_policy),
};

static int coalesce_prepare_data(const struct ethnl_req_info *req_base,
				 struct ethnl_reply_data *reply_base,
				 struct genl_info *info)
{
	struct coalesce_reply_data *data = COALESCE_REPDATA(reply_base);
	struct netlink_ext_ack *extack = info ? info->extack : NULL;
	struct net_device *dev = reply_base->dev;
	int ret;

	if (!dev->ethtool_ops->get_coalesce)
		return -EOPNOTSUPP;
	data->supported_params = dev->ethtool_ops->supported_coalesce_params;
	ret = ethnl_ops_begin(dev);
	if (ret < 0)
		return ret;
	ret = dev->ethtool_ops->get_coalesce(dev, &data->coalesce,
					     &data->kernel_coalesce, extack);
	ethnl_ops_complete(dev);

	return ret;
}

static int coalesce_reply_size(const struct ethnl_req_info *req_base,
			       const struct ethnl_reply_data *reply_base)
{
	return nla_total_size(sizeof(u32)) +	/* _RX_USECS */
	       nla_total_size(sizeof(u32)) +	/* _RX_MAX_FRAMES */
	       nla_total_size(sizeof(u32)) +	/* _RX_USECS_IRQ */
	       nla_total_size(sizeof(u32)) +	/* _RX_MAX_FRAMES_IRQ */
	       nla_total_size(sizeof(u32)) +	/* _TX_USECS */
	       nla_total_size(sizeof(u32)) +	/* _TX_MAX_FRAMES */
	       nla_total_size(sizeof(u32)) +	/* _TX_USECS_IRQ */
	       nla_total_size(sizeof(u32)) +	/* _TX_MAX_FRAMES_IRQ */
	       nla_total_size(sizeof(u32)) +	/* _STATS_BLOCK_USECS */
	       nla_total_size(sizeof(u8)) +	/* _USE_ADAPTIVE_RX */
	       nla_total_size(sizeof(u8)) +	/* _USE_ADAPTIVE_TX */
	       nla_total_size(sizeof(u32)) +	/* _PKT_RATE_LOW */
	       nla_total_size(sizeof(u32)) +	/* _RX_USECS_LOW */
	       nla_total_size(sizeof(u32)) +	/* _RX_MAX_FRAMES_LOW */
	       nla_total_size(sizeof(u32)) +	/* _TX_USECS_LOW */
	       nla_total_size(sizeof(u32)) +	/* _TX_MAX_FRAMES_LOW */
	       nla_total_size(sizeof(u32)) +	/* _PKT_RATE_HIGH */
	       nla_total_size(sizeof(u32)) +	/* _RX_USECS_HIGH */
	       nla_total_size(sizeof(u32)) +	/* _RX_MAX_FRAMES_HIGH */
	       nla_total_size(sizeof(u32)) +	/* _TX_USECS_HIGH */
	       nla_total_size(sizeof(u32)) +	/* _TX_MAX_FRAMES_HIGH */
	       nla_total_size(sizeof(u32)) +	/* _RATE_SAMPLE_INTERVAL */
	       nla_total_size(sizeof(u8)) +	/* _USE_CQE_MODE_TX */
	       nla_total_size(sizeof(u8)) +	/* _USE_CQE_MODE_RX */
	       nla_total_size(sizeof(u32)) +	/* _TX_AGGR_MAX_BYTES */
	       nla_total_size(sizeof(u32)) +	/* _TX_AGGR_MAX_FRAMES */
	       nla_total_size(sizeof(u32));	/* _TX_AGGR_TIME_USECS */
}

static bool coalesce_put_u32(struct sk_buff *skb, u16 attr_type, u32 val,
			     u32 supported_params)
{
	if (!val && !(supported_params & attr_to_mask(attr_type)))
		return false;
	return nla_put_u32(skb, attr_type, val);
}

static bool coalesce_put_bool(struct sk_buff *skb, u16 attr_type, u32 val,
			      u32 supported_params)
{
	if (!val && !(supported_params & attr_to_mask(attr_type)))
		return false;
	return nla_put_u8(skb, attr_type, !!val);
}

static int coalesce_fill_reply(struct sk_buff *skb,
			       const struct ethnl_req_info *req_base,
			       const struct ethnl_reply_data *reply_base)
{
	const struct coalesce_reply_data *data = COALESCE_REPDATA(reply_base);
	const struct kernel_ethtool_coalesce *kcoal = &data->kernel_coalesce;
	const struct ethtool_coalesce *coal = &data->coalesce;
	u32 supported = data->supported_params;

	if (coalesce_put_u32(skb, ETHTOOL_A_COALESCE_RX_USECS,
			     coal->rx_coalesce_usecs, supported) ||
	    coalesce_put_u32(skb, ETHTOOL_A_COALESCE_RX_MAX_FRAMES,
			     coal->rx_max_coalesced_frames, supported) ||
	    coalesce_put_u32(skb, ETHTOOL_A_COALESCE_RX_USECS_IRQ,
			     coal->rx_coalesce_usecs_irq, supported) ||
	    coalesce_put_u32(skb, ETHTOOL_A_COALESCE_RX_MAX_FRAMES_IRQ,
			     coal->rx_max_coalesced_frames_irq, supported) ||
	    coalesce_put_u32(skb, ETHTOOL_A_COALESCE_TX_USECS,
			     coal->tx_coalesce_usecs, supported) ||
	    coalesce_put_u32(skb, ETHTOOL_A_COALESCE_TX_MAX_FRAMES,
			     coal->tx_max_coalesced_frames, supported) ||
	    coalesce_put_u32(skb, ETHTOOL_A_COALESCE_TX_USECS_IRQ,
			     coal->tx_coalesce_usecs_irq, supported) ||
	    coalesce_put_u32(skb, ETHTOOL_A_COALESCE_TX_MAX_FRAMES_IRQ,
			     coal->tx_max_coalesced_frames_irq, supported) ||
	    coalesce_put_u32(skb, ETHTOOL_A_COALESCE_STATS_BLOCK_USECS,
			     coal->stats_block_coalesce_usecs, supported) ||
	    coalesce_put_bool(skb, ETHTOOL_A_COALESCE_USE_ADAPTIVE_RX,
			      coal->use_adaptive_rx_coalesce, supported) ||
	    coalesce_put_bool(skb, ETHTOOL_A_COALESCE_USE_ADAPTIVE_TX,
			      coal->use_adaptive_tx_coalesce, supported) ||
	    coalesce_put_u32(skb, ETHTOOL_A_COALESCE_PKT_RATE_LOW,
			     coal->pkt_rate_low, supported) ||
	    coalesce_put_u32(skb, ETHTOOL_A_COALESCE_RX_USECS_LOW,
			     coal->rx_coalesce_usecs_low, supported) ||
	    coalesce_put_u32(skb, ETHTOOL_A_COALESCE_RX_MAX_FRAMES_LOW,
			     coal->rx_max_coalesced_frames_low, supported) ||
	    coalesce_put_u32(skb, ETHTOOL_A_COALESCE_TX_USECS_LOW,
			     coal->tx_coalesce_usecs_low, supported) ||
	    coalesce_put_u32(skb, ETHTOOL_A_COALESCE_TX_MAX_FRAMES_LOW,
			     coal->tx_max_coalesced_frames_low, supported) ||
	    coalesce_put_u32(skb, ETHTOOL_A_COALESCE_PKT_RATE_HIGH,
			     coal->pkt_rate_high, supported) ||
	    coalesce_put_u32(skb, ETHTOOL_A_COALESCE_RX_USECS_HIGH,
			     coal->rx_coalesce_usecs_high, supported) ||
	    coalesce_put_u32(skb, ETHTOOL_A_COALESCE_RX_MAX_FRAMES_HIGH,
			     coal->rx_max_coalesced_frames_high, supported) ||
	    coalesce_put_u32(skb, ETHTOOL_A_COALESCE_TX_USECS_HIGH,
			     coal->tx_coalesce_usecs_high, supported) ||
	    coalesce_put_u32(skb, ETHTOOL_A_COALESCE_TX_MAX_FRAMES_HIGH,
			     coal->tx_max_coalesced_frames_high, supported) ||
	    coalesce_put_u32(skb, ETHTOOL_A_COALESCE_RATE_SAMPLE_INTERVAL,
			     coal->rate_sample_interval, supported) ||
	    coalesce_put_bool(skb, ETHTOOL_A_COALESCE_USE_CQE_MODE_TX,
			      kcoal->use_cqe_mode_tx, supported) ||
	    coalesce_put_bool(skb, ETHTOOL_A_COALESCE_USE_CQE_MODE_RX,
			      kcoal->use_cqe_mode_rx, supported) ||
	    coalesce_put_u32(skb, ETHTOOL_A_COALESCE_TX_AGGR_MAX_BYTES,
			     kcoal->tx_aggr_max_bytes, supported) ||
	    coalesce_put_u32(skb, ETHTOOL_A_COALESCE_TX_AGGR_MAX_FRAMES,
			     kcoal->tx_aggr_max_frames, supported) ||
	    coalesce_put_u32(skb, ETHTOOL_A_COALESCE_TX_AGGR_TIME_USECS,
			     kcoal->tx_aggr_time_usecs, supported))
		return -EMSGSIZE;

	return 0;
}

/* COALESCE_SET */

const struct nla_policy ethnl_coalesce_set_policy[] = {
	[ETHTOOL_A_COALESCE_HEADER]		=
		NLA_POLICY_NESTED(ethnl_header_policy),
	[ETHTOOL_A_COALESCE_RX_USECS]		= { .type = NLA_U32 },
	[ETHTOOL_A_COALESCE_RX_MAX_FRAMES]	= { .type = NLA_U32 },
	[ETHTOOL_A_COALESCE_RX_USECS_IRQ]	= { .type = NLA_U32 },
	[ETHTOOL_A_COALESCE_RX_MAX_FRAMES_IRQ]	= { .type = NLA_U32 },
	[ETHTOOL_A_COALESCE_TX_USECS]		= { .type = NLA_U32 },
	[ETHTOOL_A_COALESCE_TX_MAX_FRAMES]	= { .type = NLA_U32 },
	[ETHTOOL_A_COALESCE_TX_USECS_IRQ]	= { .type = NLA_U32 },
	[ETHTOOL_A_COALESCE_TX_MAX_FRAMES_IRQ]	= { .type = NLA_U32 },
	[ETHTOOL_A_COALESCE_STATS_BLOCK_USECS]	= { .type = NLA_U32 },
	[ETHTOOL_A_COALESCE_USE_ADAPTIVE_RX]	= { .type = NLA_U8 },
	[ETHTOOL_A_COALESCE_USE_ADAPTIVE_TX]	= { .type = NLA_U8 },
	[ETHTOOL_A_COALESCE_PKT_RATE_LOW]	= { .type = NLA_U32 },
	[ETHTOOL_A_COALESCE_RX_USECS_LOW]	= { .type = NLA_U32 },
	[ETHTOOL_A_COALESCE_RX_MAX_FRAMES_LOW]	= { .type = NLA_U32 },
	[ETHTOOL_A_COALESCE_TX_USECS_LOW]	= { .type = NLA_U32 },
	[ETHTOOL_A_COALESCE_TX_MAX_FRAMES_LOW]	= { .type = NLA_U32 },
	[ETHTOOL_A_COALESCE_PKT_RATE_HIGH]	= { .type = NLA_U32 },
	[ETHTOOL_A_COALESCE_RX_USECS_HIGH]	= { .type = NLA_U32 },
	[ETHTOOL_A_COALESCE_RX_MAX_FRAMES_HIGH]	= { .type = NLA_U32 },
	[ETHTOOL_A_COALESCE_TX_USECS_HIGH]	= { .type = NLA_U32 },
	[ETHTOOL_A_COALESCE_TX_MAX_FRAMES_HIGH]	= { .type = NLA_U32 },
	[ETHTOOL_A_COALESCE_RATE_SAMPLE_INTERVAL] = { .type = NLA_U32 },
	[ETHTOOL_A_COALESCE_USE_CQE_MODE_TX]	= NLA_POLICY_MAX(NLA_U8, 1),
	[ETHTOOL_A_COALESCE_USE_CQE_MODE_RX]	= NLA_POLICY_MAX(NLA_U8, 1),
	[ETHTOOL_A_COALESCE_TX_AGGR_MAX_BYTES] = { .type = NLA_U32 },
	[ETHTOOL_A_COALESCE_TX_AGGR_MAX_FRAMES] = { .type = NLA_U32 },
	[ETHTOOL_A_COALESCE_TX_AGGR_TIME_USECS] = { .type = NLA_U32 },
};

static int
ethnl_set_coalesce_validate(struct ethnl_req_info *req_info,
			    struct genl_info *info)
{
	const struct ethtool_ops *ops = req_info->dev->ethtool_ops;
	struct nlattr **tb = info->attrs;
	u32 supported_params;
	u16 a;

	if (!ops->get_coalesce || !ops->set_coalesce)
		return -EOPNOTSUPP;

	/* make sure that only supported parameters are present */
	supported_params = ops->supported_coalesce_params;
	for (a = ETHTOOL_A_COALESCE_RX_USECS; a < __ETHTOOL_A_COALESCE_CNT; a++)
		if (tb[a] && !(supported_params & attr_to_mask(a))) {
			NL_SET_ERR_MSG_ATTR(info->extack, tb[a],
					    "cannot modify an unsupported parameter");
			return -EINVAL;
		}

	return 1;
}

static int
ethnl_set_coalesce(struct ethnl_req_info *req_info, struct genl_info *info)
{
	struct kernel_ethtool_coalesce kernel_coalesce = {};
	struct net_device *dev = req_info->dev;
	struct ethtool_coalesce coalesce = {};
	struct nlattr **tb = info->attrs;
	bool mod = false;
	int ret;

	ret = dev->ethtool_ops->get_coalesce(dev, &coalesce, &kernel_coalesce,
					     info->extack);
	if (ret < 0)
		return ret;

	ethnl_update_u32(&coalesce.rx_coalesce_usecs,
			 tb[ETHTOOL_A_COALESCE_RX_USECS], &mod);
	ethnl_update_u32(&coalesce.rx_max_coalesced_frames,
			 tb[ETHTOOL_A_COALESCE_RX_MAX_FRAMES], &mod);
	ethnl_update_u32(&coalesce.rx_coalesce_usecs_irq,
			 tb[ETHTOOL_A_COALESCE_RX_USECS_IRQ], &mod);
	ethnl_update_u32(&coalesce.rx_max_coalesced_frames_irq,
			 tb[ETHTOOL_A_COALESCE_RX_MAX_FRAMES_IRQ], &mod);
	ethnl_update_u32(&coalesce.tx_coalesce_usecs,
			 tb[ETHTOOL_A_COALESCE_TX_USECS], &mod);
	ethnl_update_u32(&coalesce.tx_max_coalesced_frames,
			 tb[ETHTOOL_A_COALESCE_TX_MAX_FRAMES], &mod);
	ethnl_update_u32(&coalesce.tx_coalesce_usecs_irq,
			 tb[ETHTOOL_A_COALESCE_TX_USECS_IRQ], &mod);
	ethnl_update_u32(&coalesce.tx_max_coalesced_frames_irq,
			 tb[ETHTOOL_A_COALESCE_TX_MAX_FRAMES_IRQ], &mod);
	ethnl_update_u32(&coalesce.stats_block_coalesce_usecs,
			 tb[ETHTOOL_A_COALESCE_STATS_BLOCK_USECS], &mod);
	ethnl_update_bool32(&coalesce.use_adaptive_rx_coalesce,
			    tb[ETHTOOL_A_COALESCE_USE_ADAPTIVE_RX], &mod);
	ethnl_update_bool32(&coalesce.use_adaptive_tx_coalesce,
			    tb[ETHTOOL_A_COALESCE_USE_ADAPTIVE_TX], &mod);
	ethnl_update_u32(&coalesce.pkt_rate_low,
			 tb[ETHTOOL_A_COALESCE_PKT_RATE_LOW], &mod);
	ethnl_update_u32(&coalesce.rx_coalesce_usecs_low,
			 tb[ETHTOOL_A_COALESCE_RX_USECS_LOW], &mod);
	ethnl_update_u32(&coalesce.rx_max_coalesced_frames_low,
			 tb[ETHTOOL_A_COALESCE_RX_MAX_FRAMES_LOW], &mod);
	ethnl_update_u32(&coalesce.tx_coalesce_usecs_low,
			 tb[ETHTOOL_A_COALESCE_TX_USECS_LOW], &mod);
	ethnl_update_u32(&coalesce.tx_max_coalesced_frames_low,
			 tb[ETHTOOL_A_COALESCE_TX_MAX_FRAMES_LOW], &mod);
	ethnl_update_u32(&coalesce.pkt_rate_high,
			 tb[ETHTOOL_A_COALESCE_PKT_RATE_HIGH], &mod);
	ethnl_update_u32(&coalesce.rx_coalesce_usecs_high,
			 tb[ETHTOOL_A_COALESCE_RX_USECS_HIGH], &mod);
	ethnl_update_u32(&coalesce.rx_max_coalesced_frames_high,
			 tb[ETHTOOL_A_COALESCE_RX_MAX_FRAMES_HIGH], &mod);
	ethnl_update_u32(&coalesce.tx_coalesce_usecs_high,
			 tb[ETHTOOL_A_COALESCE_TX_USECS_HIGH], &mod);
	ethnl_update_u32(&coalesce.tx_max_coalesced_frames_high,
			 tb[ETHTOOL_A_COALESCE_TX_MAX_FRAMES_HIGH], &mod);
	ethnl_update_u32(&coalesce.rate_sample_interval,
			 tb[ETHTOOL_A_COALESCE_RATE_SAMPLE_INTERVAL], &mod);
	ethnl_update_u8(&kernel_coalesce.use_cqe_mode_tx,
			tb[ETHTOOL_A_COALESCE_USE_CQE_MODE_TX], &mod);
	ethnl_update_u8(&kernel_coalesce.use_cqe_mode_rx,
			tb[ETHTOOL_A_COALESCE_USE_CQE_MODE_RX], &mod);
	ethnl_update_u32(&kernel_coalesce.tx_aggr_max_bytes,
			 tb[ETHTOOL_A_COALESCE_TX_AGGR_MAX_BYTES], &mod);
	ethnl_update_u32(&kernel_coalesce.tx_aggr_max_frames,
			 tb[ETHTOOL_A_COALESCE_TX_AGGR_MAX_FRAMES], &mod);
	ethnl_update_u32(&kernel_coalesce.tx_aggr_time_usecs,
			 tb[ETHTOOL_A_COALESCE_TX_AGGR_TIME_USECS], &mod);
	if (!mod)
		return 0;

	ret = dev->ethtool_ops->set_coalesce(dev, &coalesce, &kernel_coalesce,
					     info->extack);
	return ret < 0 ? ret : 1;
}

const struct ethnl_request_ops ethnl_coalesce_request_ops = {
	.request_cmd		= ETHTOOL_MSG_COALESCE_GET,
	.reply_cmd		= ETHTOOL_MSG_COALESCE_GET_REPLY,
	.hdr_attr		= ETHTOOL_A_COALESCE_HEADER,
	.req_info_size		= sizeof(struct coalesce_req_info),
	.reply_data_size	= sizeof(struct coalesce_reply_data),

	.prepare_data		= coalesce_prepare_data,
	.reply_size		= coalesce_reply_size,
	.fill_reply		= coalesce_fill_reply,

	.set_validate		= ethnl_set_coalesce_validate,
	.set			= ethnl_set_coalesce,
	.set_ntf_cmd		= ETHTOOL_MSG_COALESCE_NTF,
};
Commit	Line	Data
21727545 MK	1	// SPDX-License-Identifier: GPL-2.0-only
	2
	3	#include "netlink.h"
	4	#include "common.h"
	5
	6	struct coalesce_req_info {
	7	struct ethnl_req_info base;
	8	};
	9
	10	struct coalesce_reply_data {
	11	struct ethnl_reply_data base;
	12	struct ethtool_coalesce coalesce;
029ee6b1	13	struct kernel_ethtool_coalesce kernel_coalesce;
21727545 MK	14	u32 supported_params;
	15	};
	16
	17	#define COALESCE_REPDATA(__reply_base) \
	18	container_of(__reply_base, struct coalesce_reply_data, base)
	19
	20	#define __SUPPORTED_OFFSET ETHTOOL_A_COALESCE_RX_USECS
	21	static u32 attr_to_mask(unsigned int attr_type)
	22	{
	23	return BIT(attr_type - __SUPPORTED_OFFSET);
	24	}
	25
	26	/* build time check that indices in ethtool_ops::supported_coalesce_params
	27	* match corresponding attribute types with an offset
	28	*/
	29	#define __CHECK_SUPPORTED_OFFSET(x) \
	30	static_assert((ETHTOOL_ ## x) == \
	31	BIT((ETHTOOL_A_ ## x) - __SUPPORTED_OFFSET))
	32	__CHECK_SUPPORTED_OFFSET(COALESCE_RX_USECS);
	33	__CHECK_SUPPORTED_OFFSET(COALESCE_RX_MAX_FRAMES);
	34	__CHECK_SUPPORTED_OFFSET(COALESCE_RX_USECS_IRQ);
	35	__CHECK_SUPPORTED_OFFSET(COALESCE_RX_MAX_FRAMES_IRQ);
	36	__CHECK_SUPPORTED_OFFSET(COALESCE_TX_USECS);
	37	__CHECK_SUPPORTED_OFFSET(COALESCE_TX_MAX_FRAMES);
	38	__CHECK_SUPPORTED_OFFSET(COALESCE_TX_USECS_IRQ);
	39	__CHECK_SUPPORTED_OFFSET(COALESCE_TX_MAX_FRAMES_IRQ);
	40	__CHECK_SUPPORTED_OFFSET(COALESCE_STATS_BLOCK_USECS);
	41	__CHECK_SUPPORTED_OFFSET(COALESCE_USE_ADAPTIVE_RX);
	42	__CHECK_SUPPORTED_OFFSET(COALESCE_USE_ADAPTIVE_TX);
	43	__CHECK_SUPPORTED_OFFSET(COALESCE_PKT_RATE_LOW);
	44	__CHECK_SUPPORTED_OFFSET(COALESCE_RX_USECS_LOW);
	45	__CHECK_SUPPORTED_OFFSET(COALESCE_RX_MAX_FRAMES_LOW);
	46	__CHECK_SUPPORTED_OFFSET(COALESCE_TX_USECS_LOW);
	47	__CHECK_SUPPORTED_OFFSET(COALESCE_TX_MAX_FRAMES_LOW);
	48	__CHECK_SUPPORTED_OFFSET(COALESCE_PKT_RATE_HIGH);
	49	__CHECK_SUPPORTED_OFFSET(COALESCE_RX_USECS_HIGH);
	50	__CHECK_SUPPORTED_OFFSET(COALESCE_RX_MAX_FRAMES_HIGH);
	51	__CHECK_SUPPORTED_OFFSET(COALESCE_TX_USECS_HIGH);
	52	__CHECK_SUPPORTED_OFFSET(COALESCE_TX_MAX_FRAMES_HIGH);
	53	__CHECK_SUPPORTED_OFFSET(COALESCE_RATE_SAMPLE_INTERVAL);
	54
ff419afa	55	const struct nla_policy ethnl_coalesce_get_policy[] = {
329d9c33 JK	56	[ETHTOOL_A_COALESCE_HEADER] =
329d9c33 JK	57	NLA_POLICY_NESTED(ethnl_header_policy),
21727545 MK	58	};
	59
	60	static int coalesce_prepare_data(const struct ethnl_req_info *req_base,
	61	struct ethnl_reply_data *reply_base,
	62	struct genl_info *info)
	63	{
	64	struct coalesce_reply_data *data = COALESCE_REPDATA(reply_base);
f3ccfda1	65	struct netlink_ext_ack *extack = info ? info->extack : NULL;
21727545 MK	66	struct net_device *dev = reply_base->dev;
	67	int ret;
	68
	69	if (!dev->ethtool_ops->get_coalesce)
	70	return -EOPNOTSUPP;
	71	data->supported_params = dev->ethtool_ops->supported_coalesce_params;
	72	ret = ethnl_ops_begin(dev);
	73	if (ret < 0)
	74	return ret;
f3ccfda1 YM	75	ret = dev->ethtool_ops->get_coalesce(dev, &data->coalesce,
f3ccfda1 YM	76	&data->kernel_coalesce, extack);
21727545 MK	77	ethnl_ops_complete(dev);
	78
	79	return ret;
	80	}
	81
	82	static int coalesce_reply_size(const struct ethnl_req_info *req_base,
	83	const struct ethnl_reply_data *reply_base)
	84	{
	85	return nla_total_size(sizeof(u32)) + /* _RX_USECS */
	86	nla_total_size(sizeof(u32)) + /* _RX_MAX_FRAMES */
	87	nla_total_size(sizeof(u32)) + /* _RX_USECS_IRQ */
	88	nla_total_size(sizeof(u32)) + /* _RX_MAX_FRAMES_IRQ */
	89	nla_total_size(sizeof(u32)) + /* _TX_USECS */
	90	nla_total_size(sizeof(u32)) + /* _TX_MAX_FRAMES */
	91	nla_total_size(sizeof(u32)) + /* _TX_USECS_IRQ */
	92	nla_total_size(sizeof(u32)) + /* _TX_MAX_FRAMES_IRQ */
	93	nla_total_size(sizeof(u32)) + /* _STATS_BLOCK_USECS */
	94	nla_total_size(sizeof(u8)) + /* _USE_ADAPTIVE_RX */
	95	nla_total_size(sizeof(u8)) + /* _USE_ADAPTIVE_TX */
	96	nla_total_size(sizeof(u32)) + /* _PKT_RATE_LOW */
	97	nla_total_size(sizeof(u32)) + /* _RX_USECS_LOW */
	98	nla_total_size(sizeof(u32)) + /* _RX_MAX_FRAMES_LOW */
	99	nla_total_size(sizeof(u32)) + /* _TX_USECS_LOW */
	100	nla_total_size(sizeof(u32)) + /* _TX_MAX_FRAMES_LOW */
	101	nla_total_size(sizeof(u32)) + /* _PKT_RATE_HIGH */
	102	nla_total_size(sizeof(u32)) + /* _RX_USECS_HIGH */
	103	nla_total_size(sizeof(u32)) + /* _RX_MAX_FRAMES_HIGH */
	104	nla_total_size(sizeof(u32)) + /* _TX_USECS_HIGH */
	105	nla_total_size(sizeof(u32)) + /* _TX_MAX_FRAMES_HIGH */
029ee6b1 YM	106	nla_total_size(sizeof(u32)) + /* _RATE_SAMPLE_INTERVAL */
029ee6b1 YM	107	nla_total_size(sizeof(u8)) + /* _USE_CQE_MODE_TX */
31de2842 DP	108	nla_total_size(sizeof(u8)) + /* _USE_CQE_MODE_RX */
	109	nla_total_size(sizeof(u32)) + /* _TX_AGGR_MAX_BYTES */
	110	nla_total_size(sizeof(u32)) + /* _TX_AGGR_MAX_FRAMES */
	111	nla_total_size(sizeof(u32)); /* _TX_AGGR_TIME_USECS */
21727545 MK	112	}
	113
	114	static bool coalesce_put_u32(struct sk_buff *skb, u16 attr_type, u32 val,
	115	u32 supported_params)
	116	{
	117	if (!val && !(supported_params & attr_to_mask(attr_type)))
	118	return false;
	119	return nla_put_u32(skb, attr_type, val);
	120	}
	121
	122	static bool coalesce_put_bool(struct sk_buff *skb, u16 attr_type, u32 val,
	123	u32 supported_params)
	124	{
	125	if (!val && !(supported_params & attr_to_mask(attr_type)))
	126	return false;
	127	return nla_put_u8(skb, attr_type, !!val);
	128	}
	129
	130	static int coalesce_fill_reply(struct sk_buff *skb,
	131	const struct ethnl_req_info *req_base,
	132	const struct ethnl_reply_data *reply_base)
	133	{
	134	const struct coalesce_reply_data *data = COALESCE_REPDATA(reply_base);
029ee6b1	135	const struct kernel_ethtool_coalesce *kcoal = &data->kernel_coalesce;
21727545 MK	136	const struct ethtool_coalesce *coal = &data->coalesce;
	137	u32 supported = data->supported_params;
	138
	139	if (coalesce_put_u32(skb, ETHTOOL_A_COALESCE_RX_USECS,
	140	coal->rx_coalesce_usecs, supported) \|\|
	141	coalesce_put_u32(skb, ETHTOOL_A_COALESCE_RX_MAX_FRAMES,
	142	coal->rx_max_coalesced_frames, supported) \|\|
	143	coalesce_put_u32(skb, ETHTOOL_A_COALESCE_RX_USECS_IRQ,
	144	coal->rx_coalesce_usecs_irq, supported) \|\|
	145	coalesce_put_u32(skb, ETHTOOL_A_COALESCE_RX_MAX_FRAMES_IRQ,
	146	coal->rx_max_coalesced_frames_irq, supported) \|\|
	147	coalesce_put_u32(skb, ETHTOOL_A_COALESCE_TX_USECS,
	148	coal->tx_coalesce_usecs, supported) \|\|
	149	coalesce_put_u32(skb, ETHTOOL_A_COALESCE_TX_MAX_FRAMES,
	150	coal->tx_max_coalesced_frames, supported) \|\|
	151	coalesce_put_u32(skb, ETHTOOL_A_COALESCE_TX_USECS_IRQ,
	152	coal->tx_coalesce_usecs_irq, supported) \|\|
	153	coalesce_put_u32(skb, ETHTOOL_A_COALESCE_TX_MAX_FRAMES_IRQ,
	154	coal->tx_max_coalesced_frames_irq, supported) \|\|
	155	coalesce_put_u32(skb, ETHTOOL_A_COALESCE_STATS_BLOCK_USECS,
	156	coal->stats_block_coalesce_usecs, supported) \|\|
	157	coalesce_put_bool(skb, ETHTOOL_A_COALESCE_USE_ADAPTIVE_RX,
	158	coal->use_adaptive_rx_coalesce, supported) \|\|
	159	coalesce_put_bool(skb, ETHTOOL_A_COALESCE_USE_ADAPTIVE_TX,
	160	coal->use_adaptive_tx_coalesce, supported) \|\|
	161	coalesce_put_u32(skb, ETHTOOL_A_COALESCE_PKT_RATE_LOW,
	162	coal->pkt_rate_low, supported) \|\|
	163	coalesce_put_u32(skb, ETHTOOL_A_COALESCE_RX_USECS_LOW,
	164	coal->rx_coalesce_usecs_low, supported) \|\|
	165	coalesce_put_u32(skb, ETHTOOL_A_COALESCE_RX_MAX_FRAMES_LOW,
	166	coal->rx_max_coalesced_frames_low, supported) \|\|
	167	coalesce_put_u32(skb, ETHTOOL_A_COALESCE_TX_USECS_LOW,
	168	coal->tx_coalesce_usecs_low, supported) \|\|
	169	coalesce_put_u32(skb, ETHTOOL_A_COALESCE_TX_MAX_FRAMES_LOW,
	170	coal->tx_max_coalesced_frames_low, supported) \|\|
	171	coalesce_put_u32(skb, ETHTOOL_A_COALESCE_PKT_RATE_HIGH,
	172	coal->pkt_rate_high, supported) \|\|
	173	coalesce_put_u32(skb, ETHTOOL_A_COALESCE_RX_USECS_HIGH,
	174	coal->rx_coalesce_usecs_high, supported) \|\|
	175	coalesce_put_u32(skb, ETHTOOL_A_COALESCE_RX_MAX_FRAMES_HIGH,
	176	coal->rx_max_coalesced_frames_high, supported) \|\|
	177	coalesce_put_u32(skb, ETHTOOL_A_COALESCE_TX_USECS_HIGH,
	178	coal->tx_coalesce_usecs_high, supported) \|\|
	179	coalesce_put_u32(skb, ETHTOOL_A_COALESCE_TX_MAX_FRAMES_HIGH,
	180	coal->tx_max_coalesced_frames_high, supported) \|\|
	181	coalesce_put_u32(skb, ETHTOOL_A_COALESCE_RATE_SAMPLE_INTERVAL,
029ee6b1 YM	182	coal->rate_sample_interval, supported) \|\|
	183	coalesce_put_bool(skb, ETHTOOL_A_COALESCE_USE_CQE_MODE_TX,
	184	kcoal->use_cqe_mode_tx, supported) \|\|
	185	coalesce_put_bool(skb, ETHTOOL_A_COALESCE_USE_CQE_MODE_RX,
31de2842 DP	186	kcoal->use_cqe_mode_rx, supported) \|\|
	187	coalesce_put_u32(skb, ETHTOOL_A_COALESCE_TX_AGGR_MAX_BYTES,
	188	kcoal->tx_aggr_max_bytes, supported) \|\|
	189	coalesce_put_u32(skb, ETHTOOL_A_COALESCE_TX_AGGR_MAX_FRAMES,
	190	kcoal->tx_aggr_max_frames, supported) \|\|
	191	coalesce_put_u32(skb, ETHTOOL_A_COALESCE_TX_AGGR_TIME_USECS,
	192	kcoal->tx_aggr_time_usecs, supported))
21727545 MK	193	return -EMSGSIZE;
	194
	195	return 0;
	196	}
	197
9881418c MK	198	/* COALESCE_SET */
9881418c MK	199
ff419afa	200	const struct nla_policy ethnl_coalesce_set_policy[] = {
329d9c33 JK	201	[ETHTOOL_A_COALESCE_HEADER] =
329d9c33 JK	202	NLA_POLICY_NESTED(ethnl_header_policy),
9881418c MK	203	[ETHTOOL_A_COALESCE_RX_USECS] = { .type = NLA_U32 },
	204	[ETHTOOL_A_COALESCE_RX_MAX_FRAMES] = { .type = NLA_U32 },
	205	[ETHTOOL_A_COALESCE_RX_USECS_IRQ] = { .type = NLA_U32 },
	206	[ETHTOOL_A_COALESCE_RX_MAX_FRAMES_IRQ] = { .type = NLA_U32 },
	207	[ETHTOOL_A_COALESCE_TX_USECS] = { .type = NLA_U32 },
	208	[ETHTOOL_A_COALESCE_TX_MAX_FRAMES] = { .type = NLA_U32 },
	209	[ETHTOOL_A_COALESCE_TX_USECS_IRQ] = { .type = NLA_U32 },
	210	[ETHTOOL_A_COALESCE_TX_MAX_FRAMES_IRQ] = { .type = NLA_U32 },
	211	[ETHTOOL_A_COALESCE_STATS_BLOCK_USECS] = { .type = NLA_U32 },
	212	[ETHTOOL_A_COALESCE_USE_ADAPTIVE_RX] = { .type = NLA_U8 },
	213	[ETHTOOL_A_COALESCE_USE_ADAPTIVE_TX] = { .type = NLA_U8 },
	214	[ETHTOOL_A_COALESCE_PKT_RATE_LOW] = { .type = NLA_U32 },
	215	[ETHTOOL_A_COALESCE_RX_USECS_LOW] = { .type = NLA_U32 },
	216	[ETHTOOL_A_COALESCE_RX_MAX_FRAMES_LOW] = { .type = NLA_U32 },
	217	[ETHTOOL_A_COALESCE_TX_USECS_LOW] = { .type = NLA_U32 },
	218	[ETHTOOL_A_COALESCE_TX_MAX_FRAMES_LOW] = { .type = NLA_U32 },
	219	[ETHTOOL_A_COALESCE_PKT_RATE_HIGH] = { .type = NLA_U32 },
	220	[ETHTOOL_A_COALESCE_RX_USECS_HIGH] = { .type = NLA_U32 },
	221	[ETHTOOL_A_COALESCE_RX_MAX_FRAMES_HIGH] = { .type = NLA_U32 },
	222	[ETHTOOL_A_COALESCE_TX_USECS_HIGH] = { .type = NLA_U32 },
	223	[ETHTOOL_A_COALESCE_TX_MAX_FRAMES_HIGH] = { .type = NLA_U32 },
	224	[ETHTOOL_A_COALESCE_RATE_SAMPLE_INTERVAL] = { .type = NLA_U32 },
029ee6b1 YM	225	[ETHTOOL_A_COALESCE_USE_CQE_MODE_TX] = NLA_POLICY_MAX(NLA_U8, 1),
029ee6b1 YM	226	[ETHTOOL_A_COALESCE_USE_CQE_MODE_RX] = NLA_POLICY_MAX(NLA_U8, 1),
31de2842 DP	227	[ETHTOOL_A_COALESCE_TX_AGGR_MAX_BYTES] = { .type = NLA_U32 },
	228	[ETHTOOL_A_COALESCE_TX_AGGR_MAX_FRAMES] = { .type = NLA_U32 },
	229	[ETHTOOL_A_COALESCE_TX_AGGR_TIME_USECS] = { .type = NLA_U32 },
9881418c MK	230	};
9881418c MK	231
04007961 JK	232	static int
	233	ethnl_set_coalesce_validate(struct ethnl_req_info *req_info,
	234	struct genl_info *info)
9881418c	235	{
04007961	236	const struct ethtool_ops *ops = req_info->dev->ethtool_ops;
5028588b	237	struct nlattr **tb = info->attrs;
9881418c	238	u32 supported_params;
9881418c MK	239	u16 a;
9881418c MK	240
9881418c	241	if (!ops->get_coalesce \|\| !ops->set_coalesce)
04007961	242	return -EOPNOTSUPP;
9881418c MK	243
	244	/* make sure that only supported parameters are present */
	245	supported_params = ops->supported_coalesce_params;
	246	for (a = ETHTOOL_A_COALESCE_RX_USECS; a < __ETHTOOL_A_COALESCE_CNT; a++)
	247	if (tb[a] && !(supported_params & attr_to_mask(a))) {
9881418c MK	248	NL_SET_ERR_MSG_ATTR(info->extack, tb[a],
9881418c MK	249	"cannot modify an unsupported parameter");
04007961	250	return -EINVAL;
9881418c MK	251	}
9881418c MK	252
04007961 JK	253	return 1;
	254	}
	255
	256	static int
	257	ethnl_set_coalesce(struct ethnl_req_info req_info, struct genl_info info)
	258	{
	259	struct kernel_ethtool_coalesce kernel_coalesce = {};
	260	struct net_device *dev = req_info->dev;
	261	struct ethtool_coalesce coalesce = {};
	262	struct nlattr **tb = info->attrs;
	263	bool mod = false;
	264	int ret;
	265
	266	ret = dev->ethtool_ops->get_coalesce(dev, &coalesce, &kernel_coalesce,
	267	info->extack);
9881418c	268	if (ret < 0)
04007961	269	return ret;
9881418c MK	270
	271	ethnl_update_u32(&coalesce.rx_coalesce_usecs,
	272	tb[ETHTOOL_A_COALESCE_RX_USECS], &mod);
	273	ethnl_update_u32(&coalesce.rx_max_coalesced_frames,
	274	tb[ETHTOOL_A_COALESCE_RX_MAX_FRAMES], &mod);
	275	ethnl_update_u32(&coalesce.rx_coalesce_usecs_irq,
	276	tb[ETHTOOL_A_COALESCE_RX_USECS_IRQ], &mod);
	277	ethnl_update_u32(&coalesce.rx_max_coalesced_frames_irq,
	278	tb[ETHTOOL_A_COALESCE_RX_MAX_FRAMES_IRQ], &mod);
	279	ethnl_update_u32(&coalesce.tx_coalesce_usecs,
	280	tb[ETHTOOL_A_COALESCE_TX_USECS], &mod);
	281	ethnl_update_u32(&coalesce.tx_max_coalesced_frames,
	282	tb[ETHTOOL_A_COALESCE_TX_MAX_FRAMES], &mod);
	283	ethnl_update_u32(&coalesce.tx_coalesce_usecs_irq,
	284	tb[ETHTOOL_A_COALESCE_TX_USECS_IRQ], &mod);
	285	ethnl_update_u32(&coalesce.tx_max_coalesced_frames_irq,
	286	tb[ETHTOOL_A_COALESCE_TX_MAX_FRAMES_IRQ], &mod);
	287	ethnl_update_u32(&coalesce.stats_block_coalesce_usecs,
	288	tb[ETHTOOL_A_COALESCE_STATS_BLOCK_USECS], &mod);
	289	ethnl_update_bool32(&coalesce.use_adaptive_rx_coalesce,
	290	tb[ETHTOOL_A_COALESCE_USE_ADAPTIVE_RX], &mod);
	291	ethnl_update_bool32(&coalesce.use_adaptive_tx_coalesce,
	292	tb[ETHTOOL_A_COALESCE_USE_ADAPTIVE_TX], &mod);
	293	ethnl_update_u32(&coalesce.pkt_rate_low,
	294	tb[ETHTOOL_A_COALESCE_PKT_RATE_LOW], &mod);
	295	ethnl_update_u32(&coalesce.rx_coalesce_usecs_low,
	296	tb[ETHTOOL_A_COALESCE_RX_USECS_LOW], &mod);
	297	ethnl_update_u32(&coalesce.rx_max_coalesced_frames_low,
	298	tb[ETHTOOL_A_COALESCE_RX_MAX_FRAMES_LOW], &mod);
	299	ethnl_update_u32(&coalesce.tx_coalesce_usecs_low,
	300	tb[ETHTOOL_A_COALESCE_TX_USECS_LOW], &mod);
	301	ethnl_update_u32(&coalesce.tx_max_coalesced_frames_low,
	302	tb[ETHTOOL_A_COALESCE_TX_MAX_FRAMES_LOW], &mod);
	303	ethnl_update_u32(&coalesce.pkt_rate_high,
	304	tb[ETHTOOL_A_COALESCE_PKT_RATE_HIGH], &mod);
	305	ethnl_update_u32(&coalesce.rx_coalesce_usecs_high,
	306	tb[ETHTOOL_A_COALESCE_RX_USECS_HIGH], &mod);
	307	ethnl_update_u32(&coalesce.rx_max_coalesced_frames_high,
	308	tb[ETHTOOL_A_COALESCE_RX_MAX_FRAMES_HIGH], &mod);
	309	ethnl_update_u32(&coalesce.tx_coalesce_usecs_high,
	310	tb[ETHTOOL_A_COALESCE_TX_USECS_HIGH], &mod);
	311	ethnl_update_u32(&coalesce.tx_max_coalesced_frames_high,
	312	tb[ETHTOOL_A_COALESCE_TX_MAX_FRAMES_HIGH], &mod);
	313	ethnl_update_u32(&coalesce.rate_sample_interval,
	314	tb[ETHTOOL_A_COALESCE_RATE_SAMPLE_INTERVAL], &mod);
029ee6b1 YM	315	ethnl_update_u8(&kernel_coalesce.use_cqe_mode_tx,
	316	tb[ETHTOOL_A_COALESCE_USE_CQE_MODE_TX], &mod);
	317	ethnl_update_u8(&kernel_coalesce.use_cqe_mode_rx,
	318	tb[ETHTOOL_A_COALESCE_USE_CQE_MODE_RX], &mod);
31de2842 DP	319	ethnl_update_u32(&kernel_coalesce.tx_aggr_max_bytes,
	320	tb[ETHTOOL_A_COALESCE_TX_AGGR_MAX_BYTES], &mod);
	321	ethnl_update_u32(&kernel_coalesce.tx_aggr_max_frames,
	322	tb[ETHTOOL_A_COALESCE_TX_AGGR_MAX_FRAMES], &mod);
	323	ethnl_update_u32(&kernel_coalesce.tx_aggr_time_usecs,
	324	tb[ETHTOOL_A_COALESCE_TX_AGGR_TIME_USECS], &mod);
9881418c	325	if (!mod)
04007961	326	return 0;
9881418c	327
f3ccfda1 YM	328	ret = dev->ethtool_ops->set_coalesce(dev, &coalesce, &kernel_coalesce,
f3ccfda1 YM	329	info->extack);
04007961	330	return ret < 0 ? ret : 1;
9881418c	331	}
04007961 JK	332
	333	const struct ethnl_request_ops ethnl_coalesce_request_ops = {
	334	.request_cmd = ETHTOOL_MSG_COALESCE_GET,
	335	.reply_cmd = ETHTOOL_MSG_COALESCE_GET_REPLY,
	336	.hdr_attr = ETHTOOL_A_COALESCE_HEADER,
	337	.req_info_size = sizeof(struct coalesce_req_info),
	338	.reply_data_size = sizeof(struct coalesce_reply_data),
	339
	340	.prepare_data = coalesce_prepare_data,
	341	.reply_size = coalesce_reply_size,
	342	.fill_reply = coalesce_fill_reply,
	343
	344	.set_validate = ethnl_set_coalesce_validate,
	345	.set = ethnl_set_coalesce,
	346	.set_ntf_cmd = ETHTOOL_MSG_COALESCE_NTF,
	347	};