mlxsw: spectrum: Add Support for erif table entries access

Implement dpipe's table ops for erif table which provide:
1. Getting the entries in the table with the associate values.
	- match on "mlxsw_meta:erif_index"
	- action on "mlxsw_meta:forwared_out"
2. Synchronize the hardware in case of enabling/disabling counters which
   mean removing erif counters from all interfaces.

Signed-off-by: Arkadi Sharshevsky <arkadis@mellanox.com>
Signed-off-by: Jiri Pirko <jiri@mellanox.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

diff --git a/drivers/net/ethernet/mellanox/mlxsw/spectrum_dpipe.c b/drivers/net/ethernet/mellanox/mlxsw/spectrum_dpipe.c
index 5dde2222bf4e47cb0ff3d0eaac97c32744608b10..ea56f6ade6b429585f35a2f72dae20f8d51d4a0f 100644 (file)
--- a/drivers/net/ethernet/mellanox/mlxsw/spectrum_dpipe.c
+++ b/drivers/net/ethernet/mellanox/mlxsw/spectrum_dpipe.c
@@ -37,6 +37,7 @@
 
 #include "spectrum.h"
 #include "spectrum_dpipe.h"
+#include "spectrum_router.h"
 
 enum mlxsw_sp_field_metadata_id {
        MLXSW_SP_DPIPE_FIELD_METADATA_ERIF_PORT,
@@ -113,9 +114,193 @@ static int mlxsw_sp_dpipe_table_erif_matches_dump(void *priv,
        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)