mlxsw: Extend PGT APIs to support maintaining list of ports per entry

Add an API to associate a PGT entry with SMPE index and add or remove a
port. This API will be used by FID code and MDB code, to add/remove port
from specific PGT entry.

When the first port is added to PGT entry, allocate the entry in the given
MID index, when the last port is removed from PGT entry, free it.

Signed-off-by: Amit Cohen <amcohen@nvidia.com>
Signed-off-by: Ido Schimmel <idosch@nvidia.com>
Signed-off-by: Paolo Abeni <pabeni@redhat.com>

diff --git a/drivers/net/ethernet/mellanox/mlxsw/spectrum.h b/drivers/net/ethernet/mellanox/mlxsw/spectrum.h
index 645244ac5dfcca42c109453cf7f6d6202ef27daf..b128692611d9afbad5bb6328545be2f92b5d541f 100644 (file)
--- a/drivers/net/ethernet/mellanox/mlxsw/spectrum.h
+++ b/drivers/net/ethernet/mellanox/mlxsw/spectrum.h
@@ -1483,6 +1483,8 @@ int mlxsw_sp_pgt_mid_alloc_range(struct mlxsw_sp *mlxsw_sp, u16 mid_base,
                                 u16 count);
 void mlxsw_sp_pgt_mid_free_range(struct mlxsw_sp *mlxsw_sp, u16 mid_base,
                                 u16 count);
+int mlxsw_sp_pgt_entry_port_set(struct mlxsw_sp *mlxsw_sp, u16 mid,
+                               u16 smpe, u16 local_port, bool member);
 int mlxsw_sp_pgt_init(struct mlxsw_sp *mlxsw_sp);
 void mlxsw_sp_pgt_fini(struct mlxsw_sp *mlxsw_sp);
 

diff --git a/drivers/net/ethernet/mellanox/mlxsw/spectrum_pgt.c b/drivers/net/ethernet/mellanox/mlxsw/spectrum_pgt.c
index 0fc29d486efc6d7d4bdc02baaec11e80c062ea65..3b7265b539b27c53f65fa5e56aa38634ff290bc8 100644 (file)
--- a/drivers/net/ethernet/mellanox/mlxsw/spectrum_pgt.c
+++ b/drivers/net/ethernet/mellanox/mlxsw/spectrum_pgt.c
@@ -14,6 +14,17 @@ struct mlxsw_sp_pgt {
        bool smpe_index_valid;
 };
 
+struct mlxsw_sp_pgt_entry {
+       struct list_head ports_list;
+       u16 index;
+       u16 smpe_index;
+};
+
+struct mlxsw_sp_pgt_entry_port {
+       struct list_head list; /* Member of 'ports_list'. */
+       u16 local_port;
+};
+
 int mlxsw_sp_pgt_mid_alloc(struct mlxsw_sp *mlxsw_sp, u16 *p_mid)
 {
        int index, err = 0;
@@ -94,6 +105,224 @@ mlxsw_sp_pgt_mid_free_range(struct mlxsw_sp *mlxsw_sp, u16 mid_base, u16 count)
        mutex_unlock(&mlxsw_sp->pgt->lock);
 }
 
+static struct mlxsw_sp_pgt_entry_port *
+mlxsw_sp_pgt_entry_port_lookup(struct mlxsw_sp_pgt_entry *pgt_entry,
+                              u16 local_port)
+{
+       struct mlxsw_sp_pgt_entry_port *pgt_entry_port;
+
+       list_for_each_entry(pgt_entry_port, &pgt_entry->ports_list, list) {
+               if (pgt_entry_port->local_port == local_port)
+                       return pgt_entry_port;
+       }
+
+       return NULL;
+}
+
+static struct mlxsw_sp_pgt_entry *
+mlxsw_sp_pgt_entry_create(struct mlxsw_sp_pgt *pgt, u16 mid, u16 smpe)
+{
+       struct mlxsw_sp_pgt_entry *pgt_entry;
+       void *ret;
+       int err;
+
+       pgt_entry = kzalloc(sizeof(*pgt_entry), GFP_KERNEL);
+       if (!pgt_entry)
+               return ERR_PTR(-ENOMEM);
+
+       ret = idr_replace(&pgt->pgt_idr, pgt_entry, mid);
+       if (IS_ERR(ret)) {
+               err = PTR_ERR(ret);
+               goto err_idr_replace;
+       }
+
+       INIT_LIST_HEAD(&pgt_entry->ports_list);
+       pgt_entry->index = mid;
+       pgt_entry->smpe_index = smpe;
+       return pgt_entry;
+
+err_idr_replace:
+       kfree(pgt_entry);
+       return ERR_PTR(err);
+}
+
+static void mlxsw_sp_pgt_entry_destroy(struct mlxsw_sp_pgt *pgt,
+                                      struct mlxsw_sp_pgt_entry *pgt_entry)
+{
+       WARN_ON(!list_empty(&pgt_entry->ports_list));
+
+       pgt_entry = idr_replace(&pgt->pgt_idr, NULL, pgt_entry->index);
+       if (WARN_ON(IS_ERR(pgt_entry)))
+               return;
+
+       kfree(pgt_entry);
+}
+
+static struct mlxsw_sp_pgt_entry *
+mlxsw_sp_pgt_entry_get(struct mlxsw_sp_pgt *pgt, u16 mid, u16 smpe)
+{
+       struct mlxsw_sp_pgt_entry *pgt_entry;
+
+       pgt_entry = idr_find(&pgt->pgt_idr, mid);
+       if (pgt_entry)
+               return pgt_entry;
+
+       return mlxsw_sp_pgt_entry_create(pgt, mid, smpe);
+}
+
+static void mlxsw_sp_pgt_entry_put(struct mlxsw_sp_pgt *pgt, u16 mid)
+{
+       struct mlxsw_sp_pgt_entry *pgt_entry;
+
+       pgt_entry = idr_find(&pgt->pgt_idr, mid);
+       if (WARN_ON(!pgt_entry))
+               return;
+
+       if (list_empty(&pgt_entry->ports_list))
+               mlxsw_sp_pgt_entry_destroy(pgt, pgt_entry);
+}
+
+static void mlxsw_sp_pgt_smid2_port_set(char *smid2_pl, u16 local_port,
+                                       bool member)
+{
+       mlxsw_reg_smid2_port_set(smid2_pl, local_port, member);
+       mlxsw_reg_smid2_port_mask_set(smid2_pl, local_port, 1);
+}
+
+static int
+mlxsw_sp_pgt_entry_port_write(struct mlxsw_sp *mlxsw_sp,
+                             const struct mlxsw_sp_pgt_entry *pgt_entry,
+                             u16 local_port, bool member)
+{
+       bool smpe_index_valid;
+       char *smid2_pl;
+       u16 smpe;
+       int err;
+
+       smid2_pl = kmalloc(MLXSW_REG_SMID2_LEN, GFP_KERNEL);
+       if (!smid2_pl)
+               return -ENOMEM;
+
+       smpe_index_valid = mlxsw_sp->ubridge ? mlxsw_sp->pgt->smpe_index_valid :
+                          false;
+       smpe = mlxsw_sp->ubridge ? pgt_entry->smpe_index : 0;
+
+       mlxsw_reg_smid2_pack(smid2_pl, pgt_entry->index, 0, 0, smpe_index_valid,
+                            smpe);
+
+       mlxsw_sp_pgt_smid2_port_set(smid2_pl, local_port, member);
+       err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(smid2), smid2_pl);
+
+       kfree(smid2_pl);
+
+       return err;
+}
+
+static struct mlxsw_sp_pgt_entry_port *
+mlxsw_sp_pgt_entry_port_create(struct mlxsw_sp *mlxsw_sp,
+                              struct mlxsw_sp_pgt_entry *pgt_entry,
+                              u16 local_port)
+{
+       struct mlxsw_sp_pgt_entry_port *pgt_entry_port;
+       int err;
+
+       pgt_entry_port = kzalloc(sizeof(*pgt_entry_port), GFP_KERNEL);
+       if (!pgt_entry_port)
+               return ERR_PTR(-ENOMEM);
+
+       err = mlxsw_sp_pgt_entry_port_write(mlxsw_sp, pgt_entry, local_port,
+                                           true);
+       if (err)
+               goto err_pgt_entry_port_write;
+
+       pgt_entry_port->local_port = local_port;
+       list_add(&pgt_entry_port->list, &pgt_entry->ports_list);
+
+       return pgt_entry_port;
+
+err_pgt_entry_port_write:
+       kfree(pgt_entry_port);
+       return ERR_PTR(err);
+}
+
+static void
+mlxsw_sp_pgt_entry_port_destroy(struct mlxsw_sp *mlxsw_sp,
+                               struct mlxsw_sp_pgt_entry *pgt_entry,
+                               struct mlxsw_sp_pgt_entry_port *pgt_entry_port)
+
+{
+       list_del(&pgt_entry_port->list);
+       mlxsw_sp_pgt_entry_port_write(mlxsw_sp, pgt_entry,
+                                     pgt_entry_port->local_port, false);
+       kfree(pgt_entry_port);
+}
+
+static int mlxsw_sp_pgt_entry_port_add(struct mlxsw_sp *mlxsw_sp, u16 mid,
+                                      u16 smpe, u16 local_port)
+{
+       struct mlxsw_sp_pgt_entry_port *pgt_entry_port;
+       struct mlxsw_sp_pgt_entry *pgt_entry;
+       int err;
+
+       mutex_lock(&mlxsw_sp->pgt->lock);
+
+       pgt_entry = mlxsw_sp_pgt_entry_get(mlxsw_sp->pgt, mid, smpe);
+       if (IS_ERR(pgt_entry)) {
+               err = PTR_ERR(pgt_entry);
+               goto err_pgt_entry_get;
+       }
+
+       pgt_entry_port = mlxsw_sp_pgt_entry_port_create(mlxsw_sp, pgt_entry,
+                                                       local_port);
+       if (IS_ERR(pgt_entry_port)) {
+               err = PTR_ERR(pgt_entry_port);
+               goto err_pgt_entry_port_get;
+       }
+
+       mutex_unlock(&mlxsw_sp->pgt->lock);
+       return 0;
+
+err_pgt_entry_port_get:
+       mlxsw_sp_pgt_entry_put(mlxsw_sp->pgt, mid);
+err_pgt_entry_get:
+       mutex_unlock(&mlxsw_sp->pgt->lock);
+       return err;
+}
+
+static void mlxsw_sp_pgt_entry_port_del(struct mlxsw_sp *mlxsw_sp,
+                                       u16 mid, u16 smpe, u16 local_port)
+{
+       struct mlxsw_sp_pgt_entry_port *pgt_entry_port;
+       struct mlxsw_sp_pgt_entry *pgt_entry;
+
+       mutex_lock(&mlxsw_sp->pgt->lock);
+
+       pgt_entry = idr_find(&mlxsw_sp->pgt->pgt_idr, mid);
+       if (!pgt_entry)
+               goto out;
+
+       pgt_entry_port = mlxsw_sp_pgt_entry_port_lookup(pgt_entry, local_port);
+       if (!pgt_entry_port)
+               goto out;
+
+       mlxsw_sp_pgt_entry_port_destroy(mlxsw_sp, pgt_entry, pgt_entry_port);
+       mlxsw_sp_pgt_entry_put(mlxsw_sp->pgt, mid);
+
+out:
+       mutex_unlock(&mlxsw_sp->pgt->lock);
+}
+
+int mlxsw_sp_pgt_entry_port_set(struct mlxsw_sp *mlxsw_sp, u16 mid,
+                               u16 smpe, u16 local_port, bool member)
+{
+       if (member)
+               return mlxsw_sp_pgt_entry_port_add(mlxsw_sp, mid, smpe,
+                                                  local_port);
+
+       mlxsw_sp_pgt_entry_port_del(mlxsw_sp, mid, smpe, local_port);
+       return 0;
+}
+
 int mlxsw_sp_pgt_init(struct mlxsw_sp *mlxsw_sp)
 {
        struct mlxsw_sp_pgt *pgt;