[linux-2.6-block.git] / drivers / net / ethernet / mellanox / mlxsw / spectrum_dpipe.c

/*
 * drivers/net/ethernet/mellanox/mlxsw/spectrum_dpipe.c
 * Copyright (c) 2017 Mellanox Technologies. All rights reserved.
 * Copyright (c) 2017 Arkadi Sharshevsky <arakdis@mellanox.com>
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the names of the copyright holders nor the names of its
 *    contributors may be used to endorse or promote products derived from
 *    this software without specific prior written permission.
 *
 * Alternatively, this software may be distributed under the terms of the
 * GNU General Public License ("GPL") version 2 as published by the Free
 * Software Foundation.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include <linux/kernel.h>
#include <net/devlink.h>

#include "spectrum.h"
#include "spectrum_dpipe.h"
#include "spectrum_router.h"

enum mlxsw_sp_field_metadata_id {
	MLXSW_SP_DPIPE_FIELD_METADATA_ERIF_PORT,
	MLXSW_SP_DPIPE_FIELD_METADATA_L3_FORWARD,
	MLXSW_SP_DPIPE_FIELD_METADATA_L3_DROP,
};

static struct devlink_dpipe_field mlxsw_sp_dpipe_fields_metadata[] = {
	{ .name = "erif_port",
	  .id = MLXSW_SP_DPIPE_FIELD_METADATA_ERIF_PORT,
	  .bitwidth = 32,
	  .mapping_type = DEVLINK_DPIPE_FIELD_MAPPING_TYPE_IFINDEX,
	},
	{ .name = "l3_forward",
	  .id = MLXSW_SP_DPIPE_FIELD_METADATA_L3_FORWARD,
	  .bitwidth = 1,
	},
	{ .name = "l3_drop",
	  .id = MLXSW_SP_DPIPE_FIELD_METADATA_L3_DROP,
	  .bitwidth = 1,
	},
};

enum mlxsw_sp_dpipe_header_id {
	MLXSW_SP_DPIPE_HEADER_METADATA,
};

static struct devlink_dpipe_header mlxsw_sp_dpipe_header_metadata = {
	.name = "mlxsw_meta",
	.id = MLXSW_SP_DPIPE_HEADER_METADATA,
	.fields = mlxsw_sp_dpipe_fields_metadata,
	.fields_count = ARRAY_SIZE(mlxsw_sp_dpipe_fields_metadata),
};

static struct devlink_dpipe_header *mlxsw_dpipe_headers[] = {
	&mlxsw_sp_dpipe_header_metadata,
};

static struct devlink_dpipe_headers mlxsw_sp_dpipe_headers = {
	.headers = mlxsw_dpipe_headers,
	.headers_count = ARRAY_SIZE(mlxsw_dpipe_headers),
};

static int mlxsw_sp_dpipe_table_erif_actions_dump(void *priv,
						  struct sk_buff *skb)
{
	struct devlink_dpipe_action action = {0};
	int err;

	action.type = DEVLINK_DPIPE_ACTION_TYPE_FIELD_MODIFY;
	action.header = &mlxsw_sp_dpipe_header_metadata;
	action.field_id = MLXSW_SP_DPIPE_FIELD_METADATA_L3_FORWARD;

	err = devlink_dpipe_action_put(skb, &action);
	if (err)
		return err;

	action.type = DEVLINK_DPIPE_ACTION_TYPE_FIELD_MODIFY;
	action.header = &mlxsw_sp_dpipe_header_metadata;
	action.field_id = MLXSW_SP_DPIPE_FIELD_METADATA_L3_DROP;

	return devlink_dpipe_action_put(skb, &action);
}

static int mlxsw_sp_dpipe_table_erif_matches_dump(void *priv,
						  struct sk_buff *skb)
{
	struct devlink_dpipe_match match = {0};

	match.type = DEVLINK_DPIPE_MATCH_TYPE_FIELD_EXACT;
	match.header = &mlxsw_sp_dpipe_header_metadata;
	match.field_id = MLXSW_SP_DPIPE_FIELD_METADATA_ERIF_PORT;

	return devlink_dpipe_match_put(skb, &match);
}

static void mlxsw_sp_erif_entry_clear(struct devlink_dpipe_entry *entry)
{
	unsigned int value_count, value_index;
	struct devlink_dpipe_value *value;

	value = entry->action_values;
	value_count = entry->action_values_count;
	for (value_index = 0; value_index < value_count; value_index++) {
		kfree(value[value_index].value);
		kfree(value[value_index].mask);
	}

	value = entry->match_values;
	value_count = entry->match_values_count;
	for (value_index = 0; value_index < value_count; value_index++) {
		kfree(value[value_index].value);
		kfree(value[value_index].mask);
	}
}

static void
mlxsw_sp_erif_match_action_prepare(struct devlink_dpipe_match *match,
				   struct devlink_dpipe_action *action)
{
	action->type = DEVLINK_DPIPE_ACTION_TYPE_FIELD_MODIFY;
	action->header = &mlxsw_sp_dpipe_header_metadata;
	action->field_id = MLXSW_SP_DPIPE_FIELD_METADATA_L3_FORWARD;

	match->type = DEVLINK_DPIPE_MATCH_TYPE_FIELD_EXACT;
	match->header = &mlxsw_sp_dpipe_header_metadata;
	match->field_id = MLXSW_SP_DPIPE_FIELD_METADATA_ERIF_PORT;
}

static int mlxsw_sp_erif_entry_prepare(struct devlink_dpipe_entry *entry,
				       struct devlink_dpipe_value *match_value,
				       struct devlink_dpipe_match *match,
				       struct devlink_dpipe_value *action_value,
				       struct devlink_dpipe_action *action)
{
	entry->match_values = match_value;
	entry->match_values_count = 1;

	entry->action_values = action_value;
	entry->action_values_count = 1;

	match_value->match = match;
	match_value->value_size = sizeof(u32);
	match_value->value = kmalloc(match_value->value_size, GFP_KERNEL);
	if (!match_value->value)
		return -ENOMEM;

	action_value->action = action;
	action_value->value_size = sizeof(u32);
	action_value->value = kmalloc(action_value->value_size, GFP_KERNEL);
	if (!action_value->value)
		goto err_action_alloc;
	return 0;

err_action_alloc:
	kfree(match_value->value);
	return -ENOMEM;
}

static int mlxsw_sp_erif_entry_get(struct mlxsw_sp *mlxsw_sp,
				   struct devlink_dpipe_entry *entry,
				   struct mlxsw_sp_rif *rif,
				   bool counters_enabled)
{
	u32 *action_value;
	u32 *rif_value;
	u64 cnt;
	int err;

	/* Set Match RIF index */
	rif_value = entry->match_values->value;
	*rif_value = mlxsw_sp_rif_index(rif);
	entry->match_values->mapping_value = mlxsw_sp_rif_dev_ifindex(rif);
	entry->match_values->mapping_valid = true;

	/* Set Action Forwarding */
	action_value = entry->action_values->value;
	*action_value = 1;

	entry->counter_valid = false;
	entry->counter = 0;
	if (!counters_enabled)
		return 0;

	entry->index = mlxsw_sp_rif_index(rif);
	err = mlxsw_sp_rif_counter_value_get(mlxsw_sp, rif,
					     MLXSW_SP_RIF_COUNTER_EGRESS,
					     &cnt);
	if (!err) {
		entry->counter = cnt;
		entry->counter_valid = true;
	}
	return 0;
}

static int
mlxsw_sp_table_erif_entries_dump(void *priv, bool counters_enabled,
				 struct devlink_dpipe_dump_ctx *dump_ctx)
{
	struct devlink_dpipe_value match_value = {{0}}, action_value = {{0}};
	struct devlink_dpipe_action action = {0};
	struct devlink_dpipe_match match = {0};
	struct devlink_dpipe_entry entry = {0};
	struct mlxsw_sp *mlxsw_sp = priv;
	unsigned int rif_count;
	int i, j;
	int err;

	mlxsw_sp_erif_match_action_prepare(&match, &action);
	err = mlxsw_sp_erif_entry_prepare(&entry, &match_value, &match,
					  &action_value, &action);
	if (err)
		return err;

	rif_count = MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_RIFS);
	rtnl_lock();
	i = 0;
start_again:
	err = devlink_dpipe_entry_ctx_prepare(dump_ctx);
	if (err)
		return err;
	j = 0;
	for (; i < rif_count; i++) {
		if (!mlxsw_sp->rifs[i])
			continue;
		err = mlxsw_sp_erif_entry_get(mlxsw_sp, &entry,
					      mlxsw_sp->rifs[i],
					      counters_enabled);
		if (err)
			goto err_entry_get;
		err = devlink_dpipe_entry_ctx_append(dump_ctx, &entry);
		if (err) {
			if (err == -EMSGSIZE) {
				if (!j)
					goto err_entry_append;
				break;
			}
			goto err_entry_append;
		}
		j++;
	}

	devlink_dpipe_entry_ctx_close(dump_ctx);
	if (i != rif_count)
		goto start_again;
	rtnl_unlock();

	mlxsw_sp_erif_entry_clear(&entry);
	return 0;
err_entry_append:
err_entry_get:
	rtnl_unlock();
	mlxsw_sp_erif_entry_clear(&entry);
	return err;
}

static int mlxsw_sp_table_erif_counters_update(void *priv, bool enable)
{
	struct mlxsw_sp *mlxsw_sp = priv;
	int i;

	rtnl_lock();
	for (i = 0; i < MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_RIFS); i++) {
		if (!mlxsw_sp->rifs[i])
			continue;
		if (enable)
			mlxsw_sp_rif_counter_alloc(mlxsw_sp,
						   mlxsw_sp->rifs[i],
						   MLXSW_SP_RIF_COUNTER_EGRESS);
		else
			mlxsw_sp_rif_counter_free(mlxsw_sp,
						  mlxsw_sp->rifs[i],
						  MLXSW_SP_RIF_COUNTER_EGRESS);
	}
	rtnl_unlock();
	return 0;
}

static struct devlink_dpipe_table_ops mlxsw_sp_erif_ops = {
	.matches_dump = mlxsw_sp_dpipe_table_erif_matches_dump,
	.actions_dump = mlxsw_sp_dpipe_table_erif_actions_dump,
	.entries_dump = mlxsw_sp_table_erif_entries_dump,
	.counters_set_update = mlxsw_sp_table_erif_counters_update,
};

static int mlxsw_sp_dpipe_erif_table_init(struct mlxsw_sp *mlxsw_sp)
{
	struct devlink *devlink = priv_to_devlink(mlxsw_sp->core);
	u64 table_size;

	table_size = MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_RIFS);
	return devlink_dpipe_table_register(devlink,
					    MLXSW_SP_DPIPE_TABLE_NAME_ERIF,
					    &mlxsw_sp_erif_ops,
					    mlxsw_sp, table_size,
					    false);
}

static void mlxsw_sp_dpipe_erif_table_fini(struct mlxsw_sp *mlxsw_sp)
{
	struct devlink *devlink = priv_to_devlink(mlxsw_sp->core);

	devlink_dpipe_table_unregister(devlink, MLXSW_SP_DPIPE_TABLE_NAME_ERIF);
}

int mlxsw_sp_dpipe_init(struct mlxsw_sp *mlxsw_sp)
{
	struct devlink *devlink = priv_to_devlink(mlxsw_sp->core);
	int err;

	err = devlink_dpipe_headers_register(devlink,
					     &mlxsw_sp_dpipe_headers);
	if (err)
		return err;
	err = mlxsw_sp_dpipe_erif_table_init(mlxsw_sp);
	if (err)
		goto err_erif_register;
	return 0;

err_erif_register:
	devlink_dpipe_headers_unregister(priv_to_devlink(mlxsw_sp->core));
	return err;
}

void mlxsw_sp_dpipe_fini(struct mlxsw_sp *mlxsw_sp)
{
	struct devlink *devlink = priv_to_devlink(mlxsw_sp->core);

	mlxsw_sp_dpipe_erif_table_fini(mlxsw_sp);
	devlink_dpipe_headers_unregister(devlink);
}
Commit	Line	Data
230ead01 AS	1	/*
	2	* drivers/net/ethernet/mellanox/mlxsw/spectrum_dpipe.c
	3	* Copyright (c) 2017 Mellanox Technologies. All rights reserved.
	4	* Copyright (c) 2017 Arkadi Sharshevsky <arakdis@mellanox.com>
	5	*
	6	* Redistribution and use in source and binary forms, with or without
	7	* modification, are permitted provided that the following conditions are met:
	8	*
	9	* 1. Redistributions of source code must retain the above copyright
	10	* notice, this list of conditions and the following disclaimer.
	11	* 2. Redistributions in binary form must reproduce the above copyright
	12	* notice, this list of conditions and the following disclaimer in the
	13	* documentation and/or other materials provided with the distribution.
	14	* 3. Neither the names of the copyright holders nor the names of its
	15	* contributors may be used to endorse or promote products derived from
	16	* this software without specific prior written permission.
	17	*
	18	* Alternatively, this software may be distributed under the terms of the
	19	* GNU General Public License ("GPL") version 2 as published by the Free
	20	* Software Foundation.
	21	*
	22	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
	23	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	24	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	25	* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
	26	* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
	27	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
	28	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
	29	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
	30	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
	31	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
	32	* POSSIBILITY OF SUCH DAMAGE.
	33	*/
	34
	35	#include <linux/kernel.h>
	36	#include <net/devlink.h>
	37
	38	#include "spectrum.h"
	39	#include "spectrum_dpipe.h"
2ba5999f	40	#include "spectrum_router.h"
230ead01	41
d54b70fe AS	42	enum mlxsw_sp_field_metadata_id {
	43	MLXSW_SP_DPIPE_FIELD_METADATA_ERIF_PORT,
	44	MLXSW_SP_DPIPE_FIELD_METADATA_L3_FORWARD,
	45	MLXSW_SP_DPIPE_FIELD_METADATA_L3_DROP,
	46	};
	47
	48	static struct devlink_dpipe_field mlxsw_sp_dpipe_fields_metadata[] = {
	49	{ .name = "erif_port",
	50	.id = MLXSW_SP_DPIPE_FIELD_METADATA_ERIF_PORT,
	51	.bitwidth = 32,
	52	.mapping_type = DEVLINK_DPIPE_FIELD_MAPPING_TYPE_IFINDEX,
	53	},
	54	{ .name = "l3_forward",
	55	.id = MLXSW_SP_DPIPE_FIELD_METADATA_L3_FORWARD,
	56	.bitwidth = 1,
	57	},
	58	{ .name = "l3_drop",
	59	.id = MLXSW_SP_DPIPE_FIELD_METADATA_L3_DROP,
	60	.bitwidth = 1,
	61	},
	62	};
	63
	64	enum mlxsw_sp_dpipe_header_id {
	65	MLXSW_SP_DPIPE_HEADER_METADATA,
	66	};
	67
	68	static struct devlink_dpipe_header mlxsw_sp_dpipe_header_metadata = {
	69	.name = "mlxsw_meta",
	70	.id = MLXSW_SP_DPIPE_HEADER_METADATA,
	71	.fields = mlxsw_sp_dpipe_fields_metadata,
	72	.fields_count = ARRAY_SIZE(mlxsw_sp_dpipe_fields_metadata),
	73	};
	74
	75	static struct devlink_dpipe_header *mlxsw_dpipe_headers[] = {
	76	&mlxsw_sp_dpipe_header_metadata,
	77	};
230ead01 AS	78
	79	static struct devlink_dpipe_headers mlxsw_sp_dpipe_headers = {
	80	.headers = mlxsw_dpipe_headers,
	81	.headers_count = ARRAY_SIZE(mlxsw_dpipe_headers),
	82	};
	83
d54b70fe AS	84	static int mlxsw_sp_dpipe_table_erif_actions_dump(void *priv,
	85	struct sk_buff *skb)
	86	{
	87	struct devlink_dpipe_action action = {0};
	88	int err;
	89
	90	action.type = DEVLINK_DPIPE_ACTION_TYPE_FIELD_MODIFY;
	91	action.header = &mlxsw_sp_dpipe_header_metadata;
	92	action.field_id = MLXSW_SP_DPIPE_FIELD_METADATA_L3_FORWARD;
	93
	94	err = devlink_dpipe_action_put(skb, &action);
	95	if (err)
	96	return err;
	97
	98	action.type = DEVLINK_DPIPE_ACTION_TYPE_FIELD_MODIFY;
	99	action.header = &mlxsw_sp_dpipe_header_metadata;
	100	action.field_id = MLXSW_SP_DPIPE_FIELD_METADATA_L3_DROP;
	101
	102	return devlink_dpipe_action_put(skb, &action);
	103	}
	104
	105	static int mlxsw_sp_dpipe_table_erif_matches_dump(void *priv,
	106	struct sk_buff *skb)
	107	{
	108	struct devlink_dpipe_match match = {0};
	109
	110	match.type = DEVLINK_DPIPE_MATCH_TYPE_FIELD_EXACT;
	111	match.header = &mlxsw_sp_dpipe_header_metadata;
	112	match.field_id = MLXSW_SP_DPIPE_FIELD_METADATA_ERIF_PORT;
	113
	114	return devlink_dpipe_match_put(skb, &match);
	115	}
	116
2ba5999f AS	117	static void mlxsw_sp_erif_entry_clear(struct devlink_dpipe_entry *entry)
	118	{
	119	unsigned int value_count, value_index;
	120	struct devlink_dpipe_value *value;
	121
	122	value = entry->action_values;
	123	value_count = entry->action_values_count;
	124	for (value_index = 0; value_index < value_count; value_index++) {
	125	kfree(value[value_index].value);
	126	kfree(value[value_index].mask);
	127	}
	128
	129	value = entry->match_values;
	130	value_count = entry->match_values_count;
	131	for (value_index = 0; value_index < value_count; value_index++) {
	132	kfree(value[value_index].value);
	133	kfree(value[value_index].mask);
	134	}
	135	}
	136
	137	static void
	138	mlxsw_sp_erif_match_action_prepare(struct devlink_dpipe_match *match,
	139	struct devlink_dpipe_action *action)
	140	{
	141	action->type = DEVLINK_DPIPE_ACTION_TYPE_FIELD_MODIFY;
	142	action->header = &mlxsw_sp_dpipe_header_metadata;
	143	action->field_id = MLXSW_SP_DPIPE_FIELD_METADATA_L3_FORWARD;
	144
	145	match->type = DEVLINK_DPIPE_MATCH_TYPE_FIELD_EXACT;
	146	match->header = &mlxsw_sp_dpipe_header_metadata;
	147	match->field_id = MLXSW_SP_DPIPE_FIELD_METADATA_ERIF_PORT;
	148	}
	149
	150	static int mlxsw_sp_erif_entry_prepare(struct devlink_dpipe_entry *entry,
	151	struct devlink_dpipe_value *match_value,
	152	struct devlink_dpipe_match *match,
	153	struct devlink_dpipe_value *action_value,
	154	struct devlink_dpipe_action *action)
	155	{
	156	entry->match_values = match_value;
	157	entry->match_values_count = 1;
	158
	159	entry->action_values = action_value;
	160	entry->action_values_count = 1;
	161
	162	match_value->match = match;
	163	match_value->value_size = sizeof(u32);
	164	match_value->value = kmalloc(match_value->value_size, GFP_KERNEL);
	165	if (!match_value->value)
	166	return -ENOMEM;
	167
	168	action_value->action = action;
	169	action_value->value_size = sizeof(u32);
	170	action_value->value = kmalloc(action_value->value_size, GFP_KERNEL);
	171	if (!action_value->value)
	172	goto err_action_alloc;
	173	return 0;
	174
	175	err_action_alloc:
	176	kfree(match_value->value);
	177	return -ENOMEM;
	178	}
	179
	180	static int mlxsw_sp_erif_entry_get(struct mlxsw_sp *mlxsw_sp,
181	struct devlink_dpipe_entry *entry,
182	struct mlxsw_sp_rif *rif,
183	bool counters_enabled)
184	{
185	u32 *action_value;
186	u32 *rif_value;
187	u64 cnt;
188	int err;
189
190	/* Set Match RIF index */
191	rif_value = entry->match_values->value;
192	*rif_value = mlxsw_sp_rif_index(rif);
193	entry->match_values->mapping_value = mlxsw_sp_rif_dev_ifindex(rif);
194	entry->match_values->mapping_valid = true;
195
196	/* Set Action Forwarding */
197	action_value = entry->action_values->value;
198	*action_value = 1;
199
200	entry->counter_valid = false;
201	entry->counter = 0;
202	if (!counters_enabled)
203	return 0;
204
205	entry->index = mlxsw_sp_rif_index(rif);
206	err = mlxsw_sp_rif_counter_value_get(mlxsw_sp, rif,
207	MLXSW_SP_RIF_COUNTER_EGRESS,
208	&cnt);
209	if (!err) {
210	entry->counter = cnt;
211	entry->counter_valid = true;
212	}
213	return 0;
214	}
215
216	static int
217	mlxsw_sp_table_erif_entries_dump(void *priv, bool counters_enabled,
218	struct devlink_dpipe_dump_ctx *dump_ctx)
219	{
220	struct devlink_dpipe_value match_value = {{0}}, action_value = {{0}};
221	struct devlink_dpipe_action action = {0};
222	struct devlink_dpipe_match match = {0};
223	struct devlink_dpipe_entry entry = {0};
224	struct mlxsw_sp *mlxsw_sp = priv;
225	unsigned int rif_count;
226	int i, j;
227	int err;
228
229	mlxsw_sp_erif_match_action_prepare(&match, &action);
230	err = mlxsw_sp_erif_entry_prepare(&entry, &match_value, &match,
231	&action_value, &action);
232	if (err)
233	return err;
234
235	rif_count = MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_RIFS);
236	rtnl_lock();
237	i = 0;
238	start_again:
239	err = devlink_dpipe_entry_ctx_prepare(dump_ctx);
240	if (err)
241	return err;
242	j = 0;
243	for (; i < rif_count; i++) {
244	if (!mlxsw_sp->rifs[i])
245	continue;
246	err = mlxsw_sp_erif_entry_get(mlxsw_sp, &entry,
247	mlxsw_sp->rifs[i],
248	counters_enabled);
249	if (err)
250	goto err_entry_get;
251	err = devlink_dpipe_entry_ctx_append(dump_ctx, &entry);
252	if (err) {
253	if (err == -EMSGSIZE) {
254	if (!j)
255	goto err_entry_append;
256	break;
257	}
258	goto err_entry_append;
259	}
260	j++;
261	}
262
263	devlink_dpipe_entry_ctx_close(dump_ctx);
264	if (i != rif_count)
265	goto start_again;
266	rtnl_unlock();
267
268	mlxsw_sp_erif_entry_clear(&entry);
269	return 0;
270	err_entry_append:
271	err_entry_get:
272	rtnl_unlock();
273	mlxsw_sp_erif_entry_clear(&entry);
274	return err;
275	}
276
277	static int mlxsw_sp_table_erif_counters_update(void *priv, bool enable)
278	{
279	struct mlxsw_sp *mlxsw_sp = priv;
280	int i;
281
282	rtnl_lock();
283	for (i = 0; i < MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_RIFS); i++) {
284	if (!mlxsw_sp->rifs[i])
285	continue;
286	if (enable)
287	mlxsw_sp_rif_counter_alloc(mlxsw_sp,
288	mlxsw_sp->rifs[i],
289	MLXSW_SP_RIF_COUNTER_EGRESS);
290	else
291	mlxsw_sp_rif_counter_free(mlxsw_sp,
292	mlxsw_sp->rifs[i],
293	MLXSW_SP_RIF_COUNTER_EGRESS);
294	}
295	rtnl_unlock();
296	return 0;
297	}
298
d54b70fe AS	299	static struct devlink_dpipe_table_ops mlxsw_sp_erif_ops = {
	300	.matches_dump = mlxsw_sp_dpipe_table_erif_matches_dump,
	301	.actions_dump = mlxsw_sp_dpipe_table_erif_actions_dump,
2ba5999f AS	302	.entries_dump = mlxsw_sp_table_erif_entries_dump,
2ba5999f AS	303	.counters_set_update = mlxsw_sp_table_erif_counters_update,
d54b70fe AS	304	};
	305
	306	static int mlxsw_sp_dpipe_erif_table_init(struct mlxsw_sp *mlxsw_sp)
	307	{
	308	struct devlink *devlink = priv_to_devlink(mlxsw_sp->core);
	309	u64 table_size;
	310
	311	table_size = MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_RIFS);
	312	return devlink_dpipe_table_register(devlink,
	313	MLXSW_SP_DPIPE_TABLE_NAME_ERIF,
	314	&mlxsw_sp_erif_ops,
	315	mlxsw_sp, table_size,
	316	false);
	317	}
	318
	319	static void mlxsw_sp_dpipe_erif_table_fini(struct mlxsw_sp *mlxsw_sp)
	320	{
	321	struct devlink *devlink = priv_to_devlink(mlxsw_sp->core);
	322
	323	devlink_dpipe_table_unregister(devlink, MLXSW_SP_DPIPE_TABLE_NAME_ERIF);
	324	}
	325
230ead01 AS	326	int mlxsw_sp_dpipe_init(struct mlxsw_sp *mlxsw_sp)
230ead01 AS	327	{
d54b70fe AS	328	struct devlink *devlink = priv_to_devlink(mlxsw_sp->core);
	329	int err;
	330
	331	err = devlink_dpipe_headers_register(devlink,
	332	&mlxsw_sp_dpipe_headers);
	333	if (err)
	334	return err;
	335	err = mlxsw_sp_dpipe_erif_table_init(mlxsw_sp);
	336	if (err)
	337	goto err_erif_register;
	338	return 0;
	339
	340	err_erif_register:
	341	devlink_dpipe_headers_unregister(priv_to_devlink(mlxsw_sp->core));
	342	return err;
230ead01 AS	343	}
	344
	345	void mlxsw_sp_dpipe_fini(struct mlxsw_sp *mlxsw_sp)
	346	{
d54b70fe AS	347	struct devlink *devlink = priv_to_devlink(mlxsw_sp->core);
	348
	349	mlxsw_sp_dpipe_erif_table_fini(mlxsw_sp);
	350	devlink_dpipe_headers_unregister(devlink);
230ead01	351	}