Commit 990e4839 authored by Steen Hegelund's avatar Steen Hegelund Committed by David S. Miller
Browse files

net: microchip: sparx5: Add/delete rules in sorted order 



This adds a sorting criteria to rule insertion and deletion.

The criteria is (in the listed order):

- Rule size (largest size first)
- User (based on an enumerated user value)
- Priority (highest priority first, aka lowest value)

When a rule is deleted the other rules may need to be moved to fill the gap
to use the available VCAP address space in the best possible way.

Signed-off-by: default avatarSteen Hegelund <steen.hegelund@microchip.com>
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parent 3a344f99

drivers/net/ethernet/microchip/sparx5/sparx5_vcap_impl.c

+26 −1
Original line number Diff line number Diff line
@@ -477,7 +477,32 @@ static void sparx5_vcap_update(struct net_device *ndev, 
static void sparx5_vcap_move(struct net_device *ndev, struct vcap_admin *admin,

			     u32 addr, int offset, int count)

{

	/* this will be added later */

	struct sparx5_port *port = netdev_priv(ndev);

	struct sparx5 *sparx5 = port->sparx5;

	enum vcap_command cmd;

	u16 mv_num_pos;

	u16 mv_size;



	mv_size = count - 1;

	if (offset > 0) {

		mv_num_pos = offset - 1;

		cmd = VCAP_CMD_MOVE_DOWN;

	} else {

		mv_num_pos = -offset - 1;

		cmd = VCAP_CMD_MOVE_UP;

	}

	spx5_wr(VCAP_SUPER_CFG_MV_NUM_POS_SET(mv_num_pos) |

		VCAP_SUPER_CFG_MV_SIZE_SET(mv_size),

		sparx5, VCAP_SUPER_CFG);

	spx5_wr(VCAP_SUPER_CTRL_UPDATE_CMD_SET(cmd) |

		VCAP_SUPER_CTRL_UPDATE_ENTRY_DIS_SET(0) |

		VCAP_SUPER_CTRL_UPDATE_ACTION_DIS_SET(0) |

		VCAP_SUPER_CTRL_UPDATE_CNT_DIS_SET(0) |

		VCAP_SUPER_CTRL_UPDATE_ADDR_SET(addr) |

		VCAP_SUPER_CTRL_CLEAR_CACHE_SET(false) |

		VCAP_SUPER_CTRL_UPDATE_SHOT_SET(true),

		sparx5, VCAP_SUPER_CTRL);

	sparx5_vcap_wait_super_update(sparx5);

}



/* Provide port information via a callback interface */

drivers/net/ethernet/microchip/vcap/vcap_api.c

+125 −12
Original line number Diff line number Diff line
@@ -941,6 +941,16 @@ int vcap_val_rule(struct vcap_rule *rule, u16 l3_proto) 
}

EXPORT_SYMBOL_GPL(vcap_val_rule);



/* Entries are sorted with increasing values of sort_key.

 * I.e. Lowest numerical sort_key is first in list.

 * In order to locate largest keys first in list we negate the key size with

 * (max_size - size).

 */

static u32 vcap_sort_key(u32 max_size, u32 size, u8 user, u16 prio)

{

	return ((max_size - size) << 24) | (user << 16) | prio;

}



/* calculate the address of the next rule after this (lower address and prio) */

static u32 vcap_next_rule_addr(u32 addr, struct vcap_rule_internal *ri)

{
@@ -970,20 +980,70 @@ static u32 vcap_set_rule_id(struct vcap_rule_internal *ri) 
static int vcap_insert_rule(struct vcap_rule_internal *ri,

			    struct vcap_rule_move *move)

{

	int sw_count = ri->vctrl->vcaps[ri->admin->vtype].sw_count;

	struct vcap_rule_internal *duprule, *iter, *elem = NULL;

	struct vcap_admin *admin = ri->admin;

	struct vcap_rule_internal *duprule;

	u32 addr;



	ri->sort_key = vcap_sort_key(sw_count, ri->size, ri->data.user,

				     ri->data.priority);



	/* Only support appending rules for now */

	/* Insert the new rule in the list of rule based on the sort key

	 * If the rule needs to be  inserted between existing rules then move

	 * these rules to make room for the new rule and update their start

	 * address.

	 */

	list_for_each_entry(iter, &admin->rules, list) {

		if (ri->sort_key < iter->sort_key) {

			elem = iter;

			break;

		}

	}



	if (!elem) {

		ri->addr = vcap_next_rule_addr(admin->last_used_addr, ri);

		admin->last_used_addr = ri->addr;



		/* Add a shallow copy of the rule to the VCAP list */

		duprule = vcap_dup_rule(ri);

		if (IS_ERR(duprule))

			return PTR_ERR(duprule);



		list_add_tail(&duprule->list, &admin->rules);

		return 0;

	}



	/* Reuse the space of the current rule */

	addr = elem->addr + elem->size;

	ri->addr = vcap_next_rule_addr(addr, ri);

	addr = ri->addr;



	/* Add a shallow copy of the rule to the VCAP list */

	duprule = vcap_dup_rule(ri);

	if (IS_ERR(duprule))

		return PTR_ERR(duprule);



	/* Add before the current entry */

	list_add_tail(&duprule->list, &elem->list);



	/* Update the current rule */

	elem->addr = vcap_next_rule_addr(addr, elem);

	addr = elem->addr;



	/* Update the address in the remaining rules in the list */

	list_for_each_entry_continue(elem, &admin->rules, list) {

		elem->addr = vcap_next_rule_addr(addr, elem);

		addr = elem->addr;

	}



	/* Update the move info */

	move->addr = admin->last_used_addr;

	move->count = ri->addr - addr;

	move->offset = admin->last_used_addr - addr;

	admin->last_used_addr = addr;

	return 0;

}



static void vcap_move_rules(struct vcap_rule_internal *ri,

			    struct vcap_rule_move *move)

{
@@ -1032,8 +1092,11 @@ struct vcap_rule *vcap_alloc_rule(struct vcap_control *vctrl, 
{

	struct vcap_rule_internal *ri;

	struct vcap_admin *admin;

	int maxsize;

	int err, maxsize;



	err = vcap_api_check(vctrl);

	if (err)

		return ERR_PTR(err);

	if (!ndev)

		return ERR_PTR(-ENODEV);

	/* Get the VCAP instance */
@@ -1098,12 +1161,57 @@ void vcap_free_rule(struct vcap_rule *rule) 
}

EXPORT_SYMBOL_GPL(vcap_free_rule);



/* Return the alignment offset for a new rule address */

static int vcap_valid_rule_move(struct vcap_rule_internal *el, int offset)

{

	return (el->addr + offset) % el->size;

}



/* Update the rule address with an offset */

static void vcap_adjust_rule_addr(struct vcap_rule_internal *el, int offset)

{

	el->addr += offset;

}



/* Rules needs to be moved to fill the gap of the deleted rule */

static int vcap_fill_rule_gap(struct vcap_rule_internal *ri)

{

	struct vcap_admin *admin = ri->admin;

	struct vcap_rule_internal *elem;

	struct vcap_rule_move move;

	int gap = 0, offset = 0;



	/* If the first rule is deleted: Move other rules to the top */

	if (list_is_first(&ri->list, &admin->rules))

		offset = admin->last_valid_addr + 1 - ri->addr - ri->size;



	/* Locate gaps between odd size rules and adjust the move */

	elem = ri;

	list_for_each_entry_continue(elem, &admin->rules, list)

		gap += vcap_valid_rule_move(elem, ri->size);



	/* Update the address in the remaining rules in the list */

	elem = ri;

	list_for_each_entry_continue(elem, &admin->rules, list)

		vcap_adjust_rule_addr(elem, ri->size + gap + offset);



	/* Update the move info */

	move.addr = admin->last_used_addr;

	move.count = ri->addr - admin->last_used_addr - gap;

	move.offset = -(ri->size + gap + offset);



	/* Do the actual move operation */

	vcap_move_rules(ri, &move);



	return gap + offset;

}



/* Delete rule in a VCAP instance */

int vcap_del_rule(struct vcap_control *vctrl, struct net_device *ndev, u32 id)

{

	struct vcap_rule_internal *ri, *elem;

	struct vcap_admin *admin;

	int err;

	int gap = 0, err;



	/* This will later also handle rule moving */

	if (!ndev)
@@ -1116,18 +1224,23 @@ int vcap_del_rule(struct vcap_control *vctrl, struct net_device *ndev, u32 id) 
	if (!ri)

		return -EINVAL;

	admin = ri->admin;



	if (ri->addr > admin->last_used_addr)

		gap = vcap_fill_rule_gap(ri);



	/* Delete the rule from the list of rules and the cache */

	list_del(&ri->list);

	vctrl->ops->init(ndev, admin, admin->last_used_addr, ri->size + gap);

	kfree(ri);



	/* delete the rule in the cache */

	vctrl->ops->init(ndev, admin, ri->addr, ri->size);

	/* Update the last used address */

	if (list_empty(&admin->rules)) {

		admin->last_used_addr = admin->last_valid_addr;

	} else {

		/* update the address range end marker from the last rule in the list */

		elem = list_last_entry(&admin->rules, struct vcap_rule_internal, list);

		elem = list_last_entry(&admin->rules, struct vcap_rule_internal,

				       list);

		admin->last_used_addr = elem->addr;

	}

	kfree(ri);

	return 0;

}

EXPORT_SYMBOL_GPL(vcap_del_rule);