Commit 0a23ae23 authored by Yevhen Orlov's avatar Yevhen Orlov Committed by Jakub Kicinski
Browse files

net: marvell: prestera: Add router nexthops ABI 



- Add functions to allocate/delete/set nexthop group
  - NOTE: non-ECMP nexthop is nexthop group with allocated size = 1
- Add function to read state of HW nh (if packets going through it)

Co-developed-by: default avatarTaras Chornyi <tchornyi@marvell.com>
Signed-off-by: default avatarTaras Chornyi <tchornyi@marvell.com>
Co-developed-by: default avatarOleksandr Mazur <oleksandr.mazur@plvision.eu>
Signed-off-by: default avatarOleksandr Mazur <oleksandr.mazur@plvision.eu>
Signed-off-by: default avatarYevhen Orlov <yevhen.orlov@plvision.eu>
Signed-off-by: default avatarJakub Kicinski <kuba@kernel.org>
parent 899b8cd0

drivers/net/ethernet/marvell/prestera/prestera.h

+5 −0
Original line number Diff line number Diff line
@@ -306,17 +306,22 @@ struct prestera_switch { 
	struct prestera_counter *counter;

	u8 lag_member_max;

	u8 lag_max;

	u32 size_tbl_router_nexthop;

};



struct prestera_router {

	struct prestera_switch *sw;

	struct list_head vr_list;

	struct list_head rif_entry_list;

	struct rhashtable nh_neigh_ht;

	struct rhashtable nexthop_group_ht;

	struct rhashtable fib_ht;

	struct rhashtable kern_fib_cache_ht;

	struct notifier_block inetaddr_nb;

	struct notifier_block inetaddr_valid_nb;

	struct notifier_block fib_nb;

	u8 *nhgrp_hw_state_cache; /* Bitmap cached hw state of nhs */

	unsigned long nhgrp_hw_cache_kick; /* jiffies */

};



struct prestera_rxtx_params {

drivers/net/ethernet/marvell/prestera/prestera_hw.c

+130 −0
Original line number Diff line number Diff line
@@ -10,11 +10,14 @@ 
#include "prestera_hw.h"

#include "prestera_acl.h"

#include "prestera_counter.h"

#include "prestera_router_hw.h"



#define PRESTERA_SWITCH_INIT_TIMEOUT_MS (30 * 1000)



#define PRESTERA_MIN_MTU 64



#define PRESTERA_MSG_CHUNK_SIZE 1024



enum prestera_cmd_type_t {

	PRESTERA_CMD_TYPE_SWITCH_INIT = 0x1,

	PRESTERA_CMD_TYPE_SWITCH_ATTR_SET = 0x2,
@@ -57,6 +60,10 @@ enum prestera_cmd_type_t { 
	PRESTERA_CMD_TYPE_ROUTER_RIF_DELETE = 0x601,

	PRESTERA_CMD_TYPE_ROUTER_LPM_ADD = 0x610,

	PRESTERA_CMD_TYPE_ROUTER_LPM_DELETE = 0x611,

	PRESTERA_CMD_TYPE_ROUTER_NH_GRP_SET = 0x622,

	PRESTERA_CMD_TYPE_ROUTER_NH_GRP_BLK_GET = 0x645,

	PRESTERA_CMD_TYPE_ROUTER_NH_GRP_ADD = 0x623,

	PRESTERA_CMD_TYPE_ROUTER_NH_GRP_DELETE = 0x624,

	PRESTERA_CMD_TYPE_ROUTER_VR_CREATE = 0x630,

	PRESTERA_CMD_TYPE_ROUTER_VR_DELETE = 0x631,
@@ -542,6 +549,14 @@ struct prestera_msg_ip_addr { 
	u8 __pad[3];

};



struct prestera_msg_nh {

	struct prestera_msg_iface oif;

	__le32 hw_id;

	u8 mac[ETH_ALEN];

	u8 is_active;

	u8 pad;

};



struct prestera_msg_rif_req {

	struct prestera_msg_cmd cmd;

	struct prestera_msg_iface iif;
@@ -567,6 +582,34 @@ struct prestera_msg_lpm_req { 
	u8 __pad[2];

};



struct prestera_msg_nh_req {

	struct prestera_msg_cmd cmd;

	struct prestera_msg_nh nh[PRESTERA_NHGR_SIZE_MAX];

	__le32 size;

	__le32 grp_id;

};



struct prestera_msg_nh_chunk_req {

	struct prestera_msg_cmd cmd;

	__le32 offset;

};



struct prestera_msg_nh_chunk_resp {

	struct prestera_msg_ret ret;

	u8 hw_state[PRESTERA_MSG_CHUNK_SIZE];

};



struct prestera_msg_nh_grp_req {

	struct prestera_msg_cmd cmd;

	__le32 grp_id;

	__le32 size;

};



struct prestera_msg_nh_grp_resp {

	struct prestera_msg_ret ret;

	__le32 grp_id;

};



struct prestera_msg_vr_req {

	struct prestera_msg_cmd cmd;

	__le16 vr_id;
@@ -729,11 +772,15 @@ static void prestera_hw_build_tests(void) 
	BUILD_BUG_ON(sizeof(struct prestera_msg_flood_domain_ports_reset_req) != 8);

	BUILD_BUG_ON(sizeof(struct prestera_msg_mdb_create_req) != 16);

	BUILD_BUG_ON(sizeof(struct prestera_msg_mdb_destroy_req) != 16);

	BUILD_BUG_ON(sizeof(struct prestera_msg_nh_req) != 124);

	BUILD_BUG_ON(sizeof(struct prestera_msg_nh_chunk_req) != 8);

	BUILD_BUG_ON(sizeof(struct prestera_msg_nh_grp_req) != 12);



	/*  structure that are part of req/resp fw messages */

	BUILD_BUG_ON(sizeof(struct prestera_msg_iface) != 16);

	BUILD_BUG_ON(sizeof(struct prestera_msg_ip_addr) != 20);

	BUILD_BUG_ON(sizeof(struct prestera_msg_flood_domain_port) != 12);

	BUILD_BUG_ON(sizeof(struct prestera_msg_nh) != 28);



	/* check responses */

	BUILD_BUG_ON(sizeof(struct prestera_msg_common_resp) != 8);
@@ -750,6 +797,8 @@ static void prestera_hw_build_tests(void) 
	BUILD_BUG_ON(sizeof(struct prestera_msg_vr_resp) != 12);

	BUILD_BUG_ON(sizeof(struct prestera_msg_policer_resp) != 12);

	BUILD_BUG_ON(sizeof(struct prestera_msg_flood_domain_create_resp) != 12);

	BUILD_BUG_ON(sizeof(struct prestera_msg_nh_chunk_resp) != 1032);

	BUILD_BUG_ON(sizeof(struct prestera_msg_nh_grp_resp) != 12);



	/* check events */

	BUILD_BUG_ON(sizeof(struct prestera_msg_event_port) != 20);
@@ -1027,6 +1076,8 @@ int prestera_hw_switch_init(struct prestera_switch *sw) 
	sw->id = resp.switch_id;

	sw->lag_member_max = resp.lag_member_max;

	sw->lag_max = resp.lag_max;

	sw->size_tbl_router_nexthop =

		__le32_to_cpu(resp.size_tbl_router_nexthop);



	return 0;

}
@@ -2037,6 +2088,85 @@ int prestera_hw_lpm_del(struct prestera_switch *sw, u16 vr_id, 
			    sizeof(req));

}



int prestera_hw_nh_entries_set(struct prestera_switch *sw, int count,

			       struct prestera_neigh_info *nhs, u32 grp_id)

{

	struct prestera_msg_nh_req req = { .size = __cpu_to_le32((u32)count),

			.grp_id = __cpu_to_le32(grp_id) };

	int i, err;



	for (i = 0; i < count; i++) {

		req.nh[i].is_active = nhs[i].connected;

		memcpy(&req.nh[i].mac, nhs[i].ha, ETH_ALEN);

		err = prestera_iface_to_msg(&nhs[i].iface, &req.nh[i].oif);

		if (err)

			return err;

	}



	return prestera_cmd(sw, PRESTERA_CMD_TYPE_ROUTER_NH_GRP_SET, &req.cmd,

			    sizeof(req));

}



int prestera_hw_nhgrp_blk_get(struct prestera_switch *sw,

			      u8 *hw_state, u32 buf_size /* Buffer in bytes */)

{

	static struct prestera_msg_nh_chunk_resp resp;

	struct prestera_msg_nh_chunk_req req;

	u32 buf_offset;

	int err;



	memset(&hw_state[0], 0, buf_size);

	buf_offset = 0;

	while (1) {

		if (buf_offset >= buf_size)

			break;



		memset(&req, 0, sizeof(req));

		req.offset = __cpu_to_le32(buf_offset * 8); /* 8 bits in u8 */

		err = prestera_cmd_ret(sw,

				       PRESTERA_CMD_TYPE_ROUTER_NH_GRP_BLK_GET,

				       &req.cmd, sizeof(req), &resp.ret,

				       sizeof(resp));

		if (err)

			return err;



		memcpy(&hw_state[buf_offset], &resp.hw_state[0],

		       buf_offset + PRESTERA_MSG_CHUNK_SIZE > buf_size ?

			buf_size - buf_offset : PRESTERA_MSG_CHUNK_SIZE);

		buf_offset += PRESTERA_MSG_CHUNK_SIZE;

	}



	return 0;

}



int prestera_hw_nh_group_create(struct prestera_switch *sw, u16 nh_count,

				u32 *grp_id)

{

	struct prestera_msg_nh_grp_req req = { .size = __cpu_to_le32((u32)nh_count) };

	struct prestera_msg_nh_grp_resp resp;

	int err;



	err = prestera_cmd_ret(sw, PRESTERA_CMD_TYPE_ROUTER_NH_GRP_ADD,

			       &req.cmd, sizeof(req), &resp.ret, sizeof(resp));

	if (err)

		return err;



	*grp_id = __le32_to_cpu(resp.grp_id);

	return err;

}



int prestera_hw_nh_group_delete(struct prestera_switch *sw, u16 nh_count,

				u32 grp_id)

{

	struct prestera_msg_nh_grp_req req = {

	    .grp_id = __cpu_to_le32(grp_id),

	    .size = __cpu_to_le32(nh_count)

	};



	return prestera_cmd(sw, PRESTERA_CMD_TYPE_ROUTER_NH_GRP_DELETE,

			    &req.cmd, sizeof(req));

}



int prestera_hw_rxtx_init(struct prestera_switch *sw,

			  struct prestera_rxtx_params *params)

{

drivers/net/ethernet/marvell/prestera/prestera_hw.h

+11 −0
Original line number Diff line number Diff line
@@ -146,6 +146,7 @@ struct prestera_counter_stats; 
struct prestera_iface;

struct prestera_flood_domain;

struct prestera_mdb_entry;

struct prestera_neigh_info;



/* Switch API */

int prestera_hw_switch_init(struct prestera_switch *sw);
@@ -266,6 +267,16 @@ int prestera_hw_lpm_add(struct prestera_switch *sw, u16 vr_id, 
int prestera_hw_lpm_del(struct prestera_switch *sw, u16 vr_id,

			__be32 dst, u32 dst_len);



/* NH API */

int prestera_hw_nh_entries_set(struct prestera_switch *sw, int count,

			       struct prestera_neigh_info *nhs, u32 grp_id);

int prestera_hw_nhgrp_blk_get(struct prestera_switch *sw,

			      u8 *hw_state, u32 buf_size /* Buffer in bytes */);

int prestera_hw_nh_group_create(struct prestera_switch *sw, u16 nh_count,

				u32 *grp_id);

int prestera_hw_nh_group_delete(struct prestera_switch *sw, u16 nh_count,

				u32 grp_id);



/* Event handlers */

int prestera_hw_event_handler_register(struct prestera_switch *sw,

				       enum prestera_event_type type,

drivers/net/ethernet/marvell/prestera/prestera_router.c

+14 −2
Original line number Diff line number Diff line
@@ -191,7 +191,7 @@ static int __prestera_k_arb_f_lpm_set(struct prestera_switch *sw, 
		return 0;



	fib_node = prestera_fib_node_create(sw, &fc->lpm_info.fib_key,

					    fc->lpm_info.fib_type);

					    fc->lpm_info.fib_type, NULL);



	if (!fib_node) {

		dev_err(sw->dev->dev, "fib_node=NULL %pI4n/%d kern_tb_id = %d",
@@ -220,6 +220,8 @@ static int __prestera_k_arb_fc_apply(struct prestera_switch *sw, 
	}



	switch (fc->lpm_info.fib_type) {

	case PRESTERA_FIB_TYPE_UC_NH:

		break;

	case PRESTERA_FIB_TYPE_TRAP:

		__prestera_k_arb_fib_lpm_offload_set(sw, fc, false,

						     false, fc->reachable);
@@ -537,7 +539,7 @@ static int __prestera_router_fib_event(struct notifier_block *nb, 
int prestera_router_init(struct prestera_switch *sw)

{

	struct prestera_router *router;

	int err;

	int err, nhgrp_cache_bytes;



	router = kzalloc(sizeof(*sw->router), GFP_KERNEL);

	if (!router)
@@ -555,6 +557,13 @@ int prestera_router_init(struct prestera_switch *sw) 
	if (err)

		goto err_kern_fib_cache_ht_init;



	nhgrp_cache_bytes = sw->size_tbl_router_nexthop / 8 + 1;

	router->nhgrp_hw_state_cache = kzalloc(nhgrp_cache_bytes, GFP_KERNEL);

	if (!router->nhgrp_hw_state_cache) {

		err = -ENOMEM;

		goto err_nh_state_cache_alloc;

	}



	router->inetaddr_valid_nb.notifier_call = __prestera_inetaddr_valid_cb;

	err = register_inetaddr_validator_notifier(&router->inetaddr_valid_nb);

	if (err)
@@ -578,6 +587,8 @@ int prestera_router_init(struct prestera_switch *sw) 
err_register_inetaddr_notifier:

	unregister_inetaddr_validator_notifier(&router->inetaddr_valid_nb);

err_register_inetaddr_validator_notifier:

	kfree(router->nhgrp_hw_state_cache);

err_nh_state_cache_alloc:

	rhashtable_destroy(&router->kern_fib_cache_ht);

err_kern_fib_cache_ht_init:

	prestera_router_hw_fini(sw);
@@ -591,6 +602,7 @@ void prestera_router_fini(struct prestera_switch *sw) 
	unregister_fib_notifier(&init_net, &sw->router->fib_nb);

	unregister_inetaddr_notifier(&sw->router->inetaddr_nb);

	unregister_inetaddr_validator_notifier(&sw->router->inetaddr_valid_nb);

	kfree(sw->router->nhgrp_hw_state_cache);

	rhashtable_destroy(&sw->router->kern_fib_cache_ht);

	prestera_router_hw_fini(sw);

	kfree(sw->router);

drivers/net/ethernet/marvell/prestera/prestera_router_hw.c

+349 −5
Original line number Diff line number Diff line
@@ -8,10 +8,16 @@ 
#include "prestera_router_hw.h"

#include "prestera_acl.h"



/*            +--+

 *   +------->|vr|<-+

 *   |        +--+  |

 *   |              |

/*                                Nexthop is pointed

 *                                to port (not rif)

 *                                +-------+

 *                              +>|nexthop|

 *                              | +-------+

 *                              |

 *            +--+        +-----++

 *   +------->|vr|<-+   +>|nh_grp|

 *   |        +--+  |   | +------+

 *   |              |   |

 * +-+-------+   +--+---+-+

 * |rif_entry|   |fib_node|

 * +---------+   +--------+
@@ -23,6 +29,8 @@ 


#define PRESTERA_NHGR_UNUSED (0)

#define PRESTERA_NHGR_DROP (0xFFFFFFFF)

/* Need to merge it with router_manager */

#define PRESTERA_NH_ACTIVE_JIFFER_FILTER 3000 /* ms */



static const struct rhashtable_params __prestera_fib_ht_params = {

	.key_offset  = offsetof(struct prestera_fib_node, key),
@@ -31,10 +39,44 @@ static const struct rhashtable_params __prestera_fib_ht_params = { 
	.automatic_shrinking = true,

};



static const struct rhashtable_params __prestera_nh_neigh_ht_params = {

	.key_offset  = offsetof(struct prestera_nh_neigh, key),

	.key_len     = sizeof(struct prestera_nh_neigh_key),

	.head_offset = offsetof(struct prestera_nh_neigh, ht_node),

};



static const struct rhashtable_params __prestera_nexthop_group_ht_params = {

	.key_offset  = offsetof(struct prestera_nexthop_group, key),

	.key_len     = sizeof(struct prestera_nexthop_group_key),

	.head_offset = offsetof(struct prestera_nexthop_group, ht_node),

};



static int prestera_nexthop_group_set(struct prestera_switch *sw,

				      struct prestera_nexthop_group *nh_grp);

static bool

prestera_nexthop_group_util_hw_state(struct prestera_switch *sw,

				     struct prestera_nexthop_group *nh_grp);



/* TODO: move to router.h as macros */

static bool prestera_nh_neigh_key_is_valid(struct prestera_nh_neigh_key *key)

{

	return memchr_inv(key, 0, sizeof(*key)) ? true : false;

}



int prestera_router_hw_init(struct prestera_switch *sw)

{

	int err;



	err = rhashtable_init(&sw->router->nh_neigh_ht,

			      &__prestera_nh_neigh_ht_params);

	if (err)

		goto err_nh_neigh_ht_init;



	err = rhashtable_init(&sw->router->nexthop_group_ht,

			      &__prestera_nexthop_group_ht_params);

	if (err)

		goto err_nexthop_grp_ht_init;



	err = rhashtable_init(&sw->router->fib_ht,

			      &__prestera_fib_ht_params);

	if (err)
@@ -43,7 +85,13 @@ int prestera_router_hw_init(struct prestera_switch *sw) 
	INIT_LIST_HEAD(&sw->router->vr_list);

	INIT_LIST_HEAD(&sw->router->rif_entry_list);



	return 0;



err_fib_ht_init:

	rhashtable_destroy(&sw->router->nexthop_group_ht);

err_nexthop_grp_ht_init:

	rhashtable_destroy(&sw->router->nh_neigh_ht);

err_nh_neigh_ht_init:

	return 0;

}
@@ -52,6 +100,8 @@ void prestera_router_hw_fini(struct prestera_switch *sw) 
	WARN_ON(!list_empty(&sw->router->vr_list));

	WARN_ON(!list_empty(&sw->router->rif_entry_list));

	rhashtable_destroy(&sw->router->fib_ht);

	rhashtable_destroy(&sw->router->nexthop_group_ht);

	rhashtable_destroy(&sw->router->nh_neigh_ht);

}



static struct prestera_vr *__prestera_vr_find(struct prestera_switch *sw,
@@ -232,6 +282,286 @@ prestera_rif_entry_create(struct prestera_switch *sw, 
	return NULL;

}



static void __prestera_nh_neigh_destroy(struct prestera_switch *sw,

					struct prestera_nh_neigh *neigh)

{

	rhashtable_remove_fast(&sw->router->nh_neigh_ht,

			       &neigh->ht_node,

			       __prestera_nh_neigh_ht_params);

	kfree(neigh);

}



static struct prestera_nh_neigh *

__prestera_nh_neigh_create(struct prestera_switch *sw,

			   struct prestera_nh_neigh_key *key)

{

	struct prestera_nh_neigh *neigh;

	int err;



	neigh = kzalloc(sizeof(*neigh), GFP_KERNEL);

	if (!neigh)

		goto err_kzalloc;



	memcpy(&neigh->key, key, sizeof(*key));

	neigh->info.connected = false;

	INIT_LIST_HEAD(&neigh->nexthop_group_list);

	err = rhashtable_insert_fast(&sw->router->nh_neigh_ht,

				     &neigh->ht_node,

				     __prestera_nh_neigh_ht_params);

	if (err)

		goto err_rhashtable_insert;



	return neigh;



err_rhashtable_insert:

	kfree(neigh);

err_kzalloc:

	return NULL;

}



struct prestera_nh_neigh *

prestera_nh_neigh_find(struct prestera_switch *sw,

		       struct prestera_nh_neigh_key *key)

{

	struct prestera_nh_neigh *nh_neigh;



	nh_neigh = rhashtable_lookup_fast(&sw->router->nh_neigh_ht,

					  key, __prestera_nh_neigh_ht_params);

	return IS_ERR(nh_neigh) ? NULL : nh_neigh;

}



struct prestera_nh_neigh *

prestera_nh_neigh_get(struct prestera_switch *sw,

		      struct prestera_nh_neigh_key *key)

{

	struct prestera_nh_neigh *neigh;



	neigh = prestera_nh_neigh_find(sw, key);

	if (!neigh)

		return __prestera_nh_neigh_create(sw, key);



	return neigh;

}



void prestera_nh_neigh_put(struct prestera_switch *sw,

			   struct prestera_nh_neigh *neigh)

{

	if (list_empty(&neigh->nexthop_group_list))

		__prestera_nh_neigh_destroy(sw, neigh);

}



/* Updates new prestera_neigh_info */

int prestera_nh_neigh_set(struct prestera_switch *sw,

			  struct prestera_nh_neigh *neigh)

{

	struct prestera_nh_neigh_head *nh_head;

	struct prestera_nexthop_group *nh_grp;

	int err;



	list_for_each_entry(nh_head, &neigh->nexthop_group_list, head) {

		nh_grp = nh_head->this;

		err = prestera_nexthop_group_set(sw, nh_grp);

		if (err)

			return err;

	}



	return 0;

}



bool prestera_nh_neigh_util_hw_state(struct prestera_switch *sw,

				     struct prestera_nh_neigh *nh_neigh)

{

	bool state;

	struct prestera_nh_neigh_head *nh_head, *tmp;



	state = false;

	list_for_each_entry_safe(nh_head, tmp,

				 &nh_neigh->nexthop_group_list, head) {

		state = prestera_nexthop_group_util_hw_state(sw, nh_head->this);

		if (state)

			goto out;

	}



out:

	return state;

}



static struct prestera_nexthop_group *

__prestera_nexthop_group_create(struct prestera_switch *sw,

				struct prestera_nexthop_group_key *key)

{

	struct prestera_nexthop_group *nh_grp;

	struct prestera_nh_neigh *nh_neigh;

	int nh_cnt, err, gid;



	nh_grp = kzalloc(sizeof(*nh_grp), GFP_KERNEL);

	if (!nh_grp)

		goto err_kzalloc;



	memcpy(&nh_grp->key, key, sizeof(*key));

	for (nh_cnt = 0; nh_cnt < PRESTERA_NHGR_SIZE_MAX; nh_cnt++) {

		if (!prestera_nh_neigh_key_is_valid(&nh_grp->key.neigh[nh_cnt]))

			break;



		nh_neigh = prestera_nh_neigh_get(sw,

						 &nh_grp->key.neigh[nh_cnt]);

		if (!nh_neigh)

			goto err_nh_neigh_get;



		nh_grp->nh_neigh_head[nh_cnt].neigh = nh_neigh;

		nh_grp->nh_neigh_head[nh_cnt].this = nh_grp;

		list_add(&nh_grp->nh_neigh_head[nh_cnt].head,

			 &nh_neigh->nexthop_group_list);

	}



	err = prestera_hw_nh_group_create(sw, nh_cnt, &nh_grp->grp_id);

	if (err)

		goto err_nh_group_create;



	err = prestera_nexthop_group_set(sw, nh_grp);

	if (err)

		goto err_nexthop_group_set;



	err = rhashtable_insert_fast(&sw->router->nexthop_group_ht,

				     &nh_grp->ht_node,

				     __prestera_nexthop_group_ht_params);

	if (err)

		goto err_ht_insert;



	/* reset cache for created group */

	gid = nh_grp->grp_id;

	sw->router->nhgrp_hw_state_cache[gid / 8] &= ~BIT(gid % 8);



	return nh_grp;



err_ht_insert:

err_nexthop_group_set:

	prestera_hw_nh_group_delete(sw, nh_cnt, nh_grp->grp_id);

err_nh_group_create:

err_nh_neigh_get:

	for (nh_cnt--; nh_cnt >= 0; nh_cnt--) {

		list_del(&nh_grp->nh_neigh_head[nh_cnt].head);

		prestera_nh_neigh_put(sw, nh_grp->nh_neigh_head[nh_cnt].neigh);

	}



	kfree(nh_grp);

err_kzalloc:

	return NULL;

}



static void

__prestera_nexthop_group_destroy(struct prestera_switch *sw,

				 struct prestera_nexthop_group *nh_grp)

{

	struct prestera_nh_neigh *nh_neigh;

	int nh_cnt;



	rhashtable_remove_fast(&sw->router->nexthop_group_ht,

			       &nh_grp->ht_node,

			       __prestera_nexthop_group_ht_params);



	for (nh_cnt = 0; nh_cnt < PRESTERA_NHGR_SIZE_MAX; nh_cnt++) {

		nh_neigh = nh_grp->nh_neigh_head[nh_cnt].neigh;

		if (!nh_neigh)

			break;



		list_del(&nh_grp->nh_neigh_head[nh_cnt].head);

		prestera_nh_neigh_put(sw, nh_neigh);

	}



	prestera_hw_nh_group_delete(sw, nh_cnt, nh_grp->grp_id);

	kfree(nh_grp);

}



static struct prestera_nexthop_group *

__prestera_nexthop_group_find(struct prestera_switch *sw,

			      struct prestera_nexthop_group_key *key)

{

	struct prestera_nexthop_group *nh_grp;



	nh_grp = rhashtable_lookup_fast(&sw->router->nexthop_group_ht,

					key, __prestera_nexthop_group_ht_params);

	return IS_ERR(nh_grp) ? NULL : nh_grp;

}



static struct prestera_nexthop_group *

prestera_nexthop_group_get(struct prestera_switch *sw,

			   struct prestera_nexthop_group_key *key)

{

	struct prestera_nexthop_group *nh_grp;



	nh_grp = __prestera_nexthop_group_find(sw, key);

	if (nh_grp) {

		refcount_inc(&nh_grp->refcount);

	} else {

		nh_grp = __prestera_nexthop_group_create(sw, key);

		if (IS_ERR(nh_grp))

			return ERR_CAST(nh_grp);



		refcount_set(&nh_grp->refcount, 1);

	}



	return nh_grp;

}



static void prestera_nexthop_group_put(struct prestera_switch *sw,

				       struct prestera_nexthop_group *nh_grp)

{

	if (refcount_dec_and_test(&nh_grp->refcount))

		__prestera_nexthop_group_destroy(sw, nh_grp);

}



/* Updates with new nh_neigh's info */

static int prestera_nexthop_group_set(struct prestera_switch *sw,

				      struct prestera_nexthop_group *nh_grp)

{

	struct prestera_neigh_info info[PRESTERA_NHGR_SIZE_MAX];

	struct prestera_nh_neigh *neigh;

	int nh_cnt;



	memset(&info[0], 0, sizeof(info));

	for (nh_cnt = 0; nh_cnt < PRESTERA_NHGR_SIZE_MAX; nh_cnt++) {

		neigh = nh_grp->nh_neigh_head[nh_cnt].neigh;

		if (!neigh)

			break;



		memcpy(&info[nh_cnt], &neigh->info, sizeof(neigh->info));

	}



	return prestera_hw_nh_entries_set(sw, nh_cnt, &info[0], nh_grp->grp_id);

}



static bool

prestera_nexthop_group_util_hw_state(struct prestera_switch *sw,

				     struct prestera_nexthop_group *nh_grp)

{

	int err;

	u32 buf_size = sw->size_tbl_router_nexthop / 8 + 1;

	u32 gid = nh_grp->grp_id;

	u8 *cache = sw->router->nhgrp_hw_state_cache;



	/* Antijitter

	 * Prevent situation, when we read state of nh_grp twice in short time,

	 * and state bit is still cleared on second call. So just stuck active

	 * state for PRESTERA_NH_ACTIVE_JIFFER_FILTER, after last occurred.

	 */

	if (!time_before(jiffies, sw->router->nhgrp_hw_cache_kick +

			msecs_to_jiffies(PRESTERA_NH_ACTIVE_JIFFER_FILTER))) {

		err = prestera_hw_nhgrp_blk_get(sw, cache, buf_size);

		if (err) {

			pr_err("Failed to get hw state nh_grp's");

			return false;

		}



		sw->router->nhgrp_hw_cache_kick = jiffies;

	}



	if (cache[gid / 8] & BIT(gid % 8))

		return true;



	return false;

}



struct prestera_fib_node *

prestera_fib_node_find(struct prestera_switch *sw, struct prestera_fib_key *key)

{
@@ -251,6 +581,9 @@ static void __prestera_fib_node_destruct(struct prestera_switch *sw, 
	prestera_hw_lpm_del(sw, vr->hw_vr_id, fib_node->key.addr.u.ipv4,

			    fib_node->key.prefix_len);

	switch (fib_node->info.type) {

	case PRESTERA_FIB_TYPE_UC_NH:

		prestera_nexthop_group_put(sw, fib_node->info.nh_grp);

		break;

	case PRESTERA_FIB_TYPE_TRAP:

		break;

	case PRESTERA_FIB_TYPE_DROP:
@@ -275,7 +608,8 @@ void prestera_fib_node_destroy(struct prestera_switch *sw, 
struct prestera_fib_node *

prestera_fib_node_create(struct prestera_switch *sw,

			 struct prestera_fib_key *key,

			 enum prestera_fib_type fib_type)

			 enum prestera_fib_type fib_type,

			 struct prestera_nexthop_group_key *nh_grp_key)

{

	struct prestera_fib_node *fib_node;

	u32 grp_id;
@@ -302,6 +636,14 @@ prestera_fib_node_create(struct prestera_switch *sw, 
	case PRESTERA_FIB_TYPE_DROP:

		grp_id = PRESTERA_NHGR_DROP;

		break;

	case PRESTERA_FIB_TYPE_UC_NH:

		fib_node->info.nh_grp = prestera_nexthop_group_get(sw,

								   nh_grp_key);

		if (!fib_node->info.nh_grp)

			goto err_nh_grp_get;



		grp_id = fib_node->info.nh_grp->grp_id;

		break;

	default:

		pr_err("Unsupported fib_type %d", fib_type);

		goto err_nh_grp_get;
@@ -323,6 +665,8 @@ prestera_fib_node_create(struct prestera_switch *sw, 
	prestera_hw_lpm_del(sw, vr->hw_vr_id, key->addr.u.ipv4,

			    key->prefix_len);

err_lpm_add:

	if (fib_type == PRESTERA_FIB_TYPE_UC_NH)

		prestera_nexthop_group_put(sw, fib_node->info.nh_grp);

err_nh_grp_get:

	prestera_vr_put(sw, vr);

err_vr_get: