mlxsw: spectrum: Change KVD linear parts from list to array

The parts info is array. The parts copy this info array, yet they are a
list. So make the indexing according to the id and change the list of
parts into array of parts. This helps to eliminate lookups and
constructs like mlxsw_sp_kvdl_part_update() (took me some non-trivial
time to figure out what is going on there).
Alongside with that, introduce a helper macro to define the parts infos.

Signed-off-by: Jiri Pirko <jiri@mellanox.com>
Signed-off-by: Ido Schimmel <idosch@mellanox.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

diff --git a/drivers/net/ethernet/mellanox/mlxsw/spectrum_kvdl.c b/drivers/net/ethernet/mellanox/mlxsw/spectrum_kvdl.c
index 201825c0019b7fde958d7009efe69c74d21c235f..7b28f65d64070b56ee79d1a1ce5640b3de5a6fe2 100644 (file)
--- a/drivers/net/ethernet/mellanox/mlxsw/spectrum_kvdl.c
+++ b/drivers/net/ethernet/mellanox/mlxsw/spectrum_kvdl.c
@@ -55,24 +55,47 @@
 #define MLXSW_SP_KVDL_LARGE_CHUNKS_END \
        (MLXSW_SP_KVDL_LARGE_CHUNKS_SIZE + MLXSW_SP_KVDL_LARGE_CHUNKS_BASE - 1)
 
-#define MLXSW_SP_CHUNK_MAX 32
-#define MLXSW_SP_LARGE_CHUNK_MAX 512
+#define MLXSW_SP_KVDL_SINGLE_ALLOC_SIZE 1
+#define MLXSW_SP_KVDL_CHUNKS_ALLOC_SIZE 32
+#define MLXSW_SP_KVDL_LARGE_CHUNKS_ALLOC_SIZE 512
 
 struct mlxsw_sp_kvdl_part_info {
        unsigned int part_index;
        unsigned int start_index;
        unsigned int end_index;
        unsigned int alloc_size;
+       enum mlxsw_sp_resource_id resource_id;
+};
+
+enum mlxsw_sp_kvdl_part_id {
+       MLXSW_SP_KVDL_PART_ID_SINGLE,
+       MLXSW_SP_KVDL_PART_ID_CHUNKS,
+       MLXSW_SP_KVDL_PART_ID_LARGE_CHUNKS,
 };
 
+#define MLXSW_SP_KVDL_PART_INFO(id)                            \
+[MLXSW_SP_KVDL_PART_ID_##id] = {                               \
+       .start_index = MLXSW_SP_KVDL_##id##_BASE,               \
+       .end_index = MLXSW_SP_KVDL_##id##_END,                  \
+       .alloc_size = MLXSW_SP_KVDL_##id##_ALLOC_SIZE,          \
+       .resource_id = MLXSW_SP_RESOURCE_KVD_LINEAR_##id,       \
+}
+
+static const struct mlxsw_sp_kvdl_part_info mlxsw_sp_kvdl_parts_info[] = {
+       MLXSW_SP_KVDL_PART_INFO(SINGLE),
+       MLXSW_SP_KVDL_PART_INFO(CHUNKS),
+       MLXSW_SP_KVDL_PART_INFO(LARGE_CHUNKS),
+};
+
+#define MLXSW_SP_KVDL_PARTS_INFO_LEN ARRAY_SIZE(mlxsw_sp_kvdl_parts_info)
+
 struct mlxsw_sp_kvdl_part {
-       struct list_head list;
-       struct mlxsw_sp_kvdl_part_info *info;
+       struct mlxsw_sp_kvdl_part_info info;
        unsigned long usage[0]; /* Entries */
 };
 
 struct mlxsw_sp_kvdl {
-       struct list_head parts_list;
+       struct mlxsw_sp_kvdl_part *parts[MLXSW_SP_KVDL_PARTS_INFO_LEN];
 };
 
 static struct mlxsw_sp_kvdl_part *
@@ -80,11 +103,13 @@ mlxsw_sp_kvdl_alloc_size_part(struct mlxsw_sp_kvdl *kvdl,
                              unsigned int alloc_size)
 {
        struct mlxsw_sp_kvdl_part *part, *min_part = NULL;
+       int i;
 
-       list_for_each_entry(part, &kvdl->parts_list, list) {
-               if (alloc_size <= part->info->alloc_size &&
+       for (i = 0; i < MLXSW_SP_KVDL_PARTS_INFO_LEN; i++) {
+               part = kvdl->parts[i];
+               if (alloc_size <= part->info.alloc_size &&
                    (!min_part ||
-                    part->info->alloc_size <= min_part->info->alloc_size))
+                    part->info.alloc_size <= min_part->info.alloc_size))
                        min_part = part;
        }
 
@@ -95,10 +120,12 @@ static struct mlxsw_sp_kvdl_part *
 mlxsw_sp_kvdl_index_part(struct mlxsw_sp_kvdl *kvdl, u32 kvdl_index)
 {
        struct mlxsw_sp_kvdl_part *part;
+       int i;
 
-       list_for_each_entry(part, &kvdl->parts_list, list) {
-               if (kvdl_index >= part->info->start_index &&
-                   kvdl_index <= part->info->end_index)
+       for (i = 0; i < MLXSW_SP_KVDL_PARTS_INFO_LEN; i++) {
+               part = kvdl->parts[i];
+               if (kvdl_index >= part->info.start_index &&
+                   kvdl_index <= part->info.end_index)
                        return part;
        }
 
@@ -122,7 +149,7 @@ mlxsw_sp_kvdl_index_entry_index(const struct mlxsw_sp_kvdl_part_info *info,
 static int mlxsw_sp_kvdl_part_alloc(struct mlxsw_sp_kvdl_part *part,
                                    u32 *p_kvdl_index)
 {
-       const struct mlxsw_sp_kvdl_part_info *info = part->info;
+       const struct mlxsw_sp_kvdl_part_info *info = &part->info;
        unsigned int entry_index, nr_entries;
 
        nr_entries = (info->end_index - info->start_index + 1) /
@@ -132,8 +159,7 @@ static int mlxsw_sp_kvdl_part_alloc(struct mlxsw_sp_kvdl_part *part,
                return -ENOBUFS;
        __set_bit(entry_index, part->usage);
 
-       *p_kvdl_index = mlxsw_sp_entry_index_kvdl_index(part->info,
-                                                       entry_index);
+       *p_kvdl_index = mlxsw_sp_entry_index_kvdl_index(info, entry_index);
 
        return 0;
 }
@@ -141,10 +167,10 @@ static int mlxsw_sp_kvdl_part_alloc(struct mlxsw_sp_kvdl_part *part,
 static void mlxsw_sp_kvdl_part_free(struct mlxsw_sp_kvdl_part *part,
                                    u32 kvdl_index)
 {
+       const struct mlxsw_sp_kvdl_part_info *info = &part->info;
        unsigned int entry_index;
 
-       entry_index = mlxsw_sp_kvdl_index_entry_index(part->info,
-                                                     kvdl_index);
+       entry_index = mlxsw_sp_kvdl_index_entry_index(info, kvdl_index);
        __clear_bit(entry_index, part->usage);
 }
 
@@ -183,74 +209,30 @@ int mlxsw_sp_kvdl_alloc_size_query(struct mlxsw_sp *mlxsw_sp,
        if (IS_ERR(part))
                return PTR_ERR(part);
 
-       *p_alloc_size = part->info->alloc_size;
+       *p_alloc_size = part->info.alloc_size;
 
        return 0;
 }
 
-enum mlxsw_sp_kvdl_part_id {
-       MLXSW_SP_KVDL_PART_SINGLE,
-       MLXSW_SP_KVDL_PART_CHUNKS,
-       MLXSW_SP_KVDL_PART_LARGE_CHUNKS,
-};
-
-static const struct mlxsw_sp_kvdl_part_info kvdl_parts_info[] = {
-       {
-               .part_index     = MLXSW_SP_KVDL_PART_SINGLE,
-               .start_index    = MLXSW_SP_KVDL_SINGLE_BASE,
-               .end_index      = MLXSW_SP_KVDL_SINGLE_END,
-               .alloc_size     = 1,
-       },
-       {
-               .part_index     = MLXSW_SP_KVDL_PART_CHUNKS,
-               .start_index    = MLXSW_SP_KVDL_CHUNKS_BASE,
-               .end_index      = MLXSW_SP_KVDL_CHUNKS_END,
-               .alloc_size     = MLXSW_SP_CHUNK_MAX,
-       },
-       {
-               .part_index     = MLXSW_SP_KVDL_PART_LARGE_CHUNKS,
-               .start_index    = MLXSW_SP_KVDL_LARGE_CHUNKS_BASE,
-               .end_index      = MLXSW_SP_KVDL_LARGE_CHUNKS_END,
-               .alloc_size     = MLXSW_SP_LARGE_CHUNK_MAX,
-       },
-};
-
-static struct mlxsw_sp_kvdl_part *
-mlxsw_sp_kvdl_part_find(struct mlxsw_sp *mlxsw_sp, unsigned int part_index)
-{
-       struct mlxsw_sp_kvdl_part *part;
-
-       list_for_each_entry(part, &mlxsw_sp->kvdl->parts_list, list) {
-               if (part->info->part_index == part_index)
-                       return part;
-       }
-
-       return NULL;
-}
-
-static void
-mlxsw_sp_kvdl_part_update(struct mlxsw_sp *mlxsw_sp,
-                         struct mlxsw_sp_kvdl_part *part, unsigned int size)
+static void mlxsw_sp_kvdl_part_update(struct mlxsw_sp_kvdl_part *part,
+                                     struct mlxsw_sp_kvdl_part *part_prev,
+                                     unsigned int size)
 {
-       struct mlxsw_sp_kvdl_part_info *info = part->info;
-
-       if (list_is_last(&part->list, &mlxsw_sp->kvdl->parts_list)) {
-               info->end_index = size - 1;
-       } else  {
-               struct mlxsw_sp_kvdl_part *last_part;
 
-               last_part = list_next_entry(part, list);
-               info->start_index = last_part->info->end_index + 1;
-               info->end_index = info->start_index + size - 1;
+       if (!part_prev) {
+               part->info.end_index = size - 1;
+       } else {
+               part->info.start_index = part_prev->info.end_index + 1;
+               part->info.end_index = part->info.start_index + size - 1;
        }
 }
 
-static int mlxsw_sp_kvdl_part_init(struct mlxsw_sp *mlxsw_sp,
-                                  unsigned int part_index)
+static struct mlxsw_sp_kvdl_part *
+mlxsw_sp_kvdl_part_init(struct mlxsw_sp *mlxsw_sp,
+                       const struct mlxsw_sp_kvdl_part_info *info,
+                       struct mlxsw_sp_kvdl_part *part_prev)
 {
        struct devlink *devlink = priv_to_devlink(mlxsw_sp->core);
-       const struct mlxsw_sp_kvdl_part_info *info;
-       enum mlxsw_sp_resource_id resource_id;
        struct mlxsw_sp_kvdl_part *part;
        bool need_update = true;
        unsigned int nr_entries;
@@ -258,23 +240,8 @@ static int mlxsw_sp_kvdl_part_init(struct mlxsw_sp *mlxsw_sp,
        u64 resource_size;
        int err;
 
-       info = &kvdl_parts_info[part_index];
-
-       switch (part_index) {
-       case MLXSW_SP_KVDL_PART_SINGLE:
-               resource_id = MLXSW_SP_RESOURCE_KVD_LINEAR_SINGLE;
-               break;
-       case MLXSW_SP_KVDL_PART_CHUNKS:
-               resource_id = MLXSW_SP_RESOURCE_KVD_LINEAR_CHUNKS;
-               break;
-       case MLXSW_SP_KVDL_PART_LARGE_CHUNKS:
-               resource_id = MLXSW_SP_RESOURCE_KVD_LINEAR_LARGE_CHUNKS;
-               break;
-       default:
-               return -EINVAL;
-       }
-
-       err = devlink_resource_size_get(devlink, resource_id, &resource_size);
+       err = devlink_resource_size_get(devlink, info->resource_id,
+                                       &resource_size);
        if (err) {
                need_update = false;
                resource_size = info->end_index - info->start_index + 1;
@@ -284,86 +251,77 @@ static int mlxsw_sp_kvdl_part_init(struct mlxsw_sp *mlxsw_sp,
        usage_size = BITS_TO_LONGS(nr_entries) * sizeof(unsigned long);
        part = kzalloc(sizeof(*part) + usage_size, GFP_KERNEL);
        if (!part)
-               return -ENOMEM;
+               return ERR_PTR(-ENOMEM);
 
-       part->info = kmemdup(info, sizeof(*part->info), GFP_KERNEL);
-       if (!part->info)
-               goto err_part_info_alloc;
+       memcpy(&part->info, info, sizeof(part->info));
 
-       list_add(&part->list, &mlxsw_sp->kvdl->parts_list);
        if (need_update)
-               mlxsw_sp_kvdl_part_update(mlxsw_sp, part, resource_size);
-       return 0;
-
-err_part_info_alloc:
-       kfree(part);
-       return -ENOMEM;
+               mlxsw_sp_kvdl_part_update(part, part_prev, resource_size);
+       return part;
 }
 
-static void mlxsw_sp_kvdl_part_fini(struct mlxsw_sp *mlxsw_sp,
-                                   unsigned int part_index)
+static void mlxsw_sp_kvdl_part_fini(struct mlxsw_sp_kvdl_part *part)
 {
-       struct mlxsw_sp_kvdl_part *part;
-
-       part = mlxsw_sp_kvdl_part_find(mlxsw_sp, part_index);
-       if (!part)
-               return;
-
-       list_del(&part->list);
-       kfree(part->info);
        kfree(part);
 }
 
 static int mlxsw_sp_kvdl_parts_init(struct mlxsw_sp *mlxsw_sp)
 {
+       struct mlxsw_sp_kvdl *kvdl = mlxsw_sp->kvdl;
+       const struct mlxsw_sp_kvdl_part_info *info;
+       struct mlxsw_sp_kvdl_part *part_prev = NULL;
        int err, i;
 
-       INIT_LIST_HEAD(&mlxsw_sp->kvdl->parts_list);
-
-       for (i = 0; i < ARRAY_SIZE(kvdl_parts_info); i++) {
-               err = mlxsw_sp_kvdl_part_init(mlxsw_sp, i);
-               if (err)
+       for (i = 0; i < MLXSW_SP_KVDL_PARTS_INFO_LEN; i++) {
+               info = &mlxsw_sp_kvdl_parts_info[i];
+               kvdl->parts[i] = mlxsw_sp_kvdl_part_init(mlxsw_sp, info,
+                                                        part_prev);
+               if (IS_ERR(kvdl->parts[i])) {
+                       err = PTR_ERR(kvdl->parts[i]);
                        goto err_kvdl_part_init;
+               }
+               part_prev = kvdl->parts[i];
        }
-
        return 0;
 
 err_kvdl_part_init:
        for (i--; i >= 0; i--)
-               mlxsw_sp_kvdl_part_fini(mlxsw_sp, i);
+               mlxsw_sp_kvdl_part_fini(kvdl->parts[i]);
        return err;
 }
 
 static void mlxsw_sp_kvdl_parts_fini(struct mlxsw_sp *mlxsw_sp)
 {
+       struct mlxsw_sp_kvdl *kvdl = mlxsw_sp->kvdl;
        int i;
 
-       for (i = ARRAY_SIZE(kvdl_parts_info) - 1; i >= 0; i--)
-               mlxsw_sp_kvdl_part_fini(mlxsw_sp, i);
+       for (i = 0; i < MLXSW_SP_KVDL_PARTS_INFO_LEN; i++)
+               mlxsw_sp_kvdl_part_fini(kvdl->parts[i]);
 }
 
 static u64 mlxsw_sp_kvdl_part_occ(struct mlxsw_sp_kvdl_part *part)
 {
+       const struct mlxsw_sp_kvdl_part_info *info = &part->info;
        unsigned int nr_entries;
        int bit = -1;
        u64 occ = 0;
 
-       nr_entries = (part->info->end_index -
-                     part->info->start_index + 1) /
-                     part->info->alloc_size;
+       nr_entries = (info->end_index -
+                     info->start_index + 1) /
+                     info->alloc_size;
        while ((bit = find_next_bit(part->usage, nr_entries, bit + 1))
                < nr_entries)
-               occ += part->info->alloc_size;
+               occ += info->alloc_size;
        return occ;
 }
 
 u64 mlxsw_sp_kvdl_occ_get(const struct mlxsw_sp *mlxsw_sp)
 {
-       struct mlxsw_sp_kvdl_part *part;
        u64 occ = 0;
+       int i;
 
-       list_for_each_entry(part, &mlxsw_sp->kvdl->parts_list, list)
-               occ += mlxsw_sp_kvdl_part_occ(part);
+       for (i = 0; i < MLXSW_SP_KVDL_PARTS_INFO_LEN; i++)
+               occ += mlxsw_sp_kvdl_part_occ(mlxsw_sp->kvdl->parts[i]);
 
        return occ;
 }
@@ -374,10 +332,7 @@ static u64 mlxsw_sp_kvdl_single_occ_get(struct devlink *devlink)
        struct mlxsw_sp *mlxsw_sp = mlxsw_core_driver_priv(mlxsw_core);
        struct mlxsw_sp_kvdl_part *part;
 
-       part = mlxsw_sp_kvdl_part_find(mlxsw_sp, MLXSW_SP_KVDL_PART_SINGLE);
-       if (!part)
-               return -EINVAL;
-
+       part = mlxsw_sp->kvdl->parts[MLXSW_SP_KVDL_PART_ID_SINGLE];
        return mlxsw_sp_kvdl_part_occ(part);
 }
 
@@ -387,10 +342,7 @@ static u64 mlxsw_sp_kvdl_chunks_occ_get(struct devlink *devlink)
        struct mlxsw_sp *mlxsw_sp = mlxsw_core_driver_priv(mlxsw_core);
        struct mlxsw_sp_kvdl_part *part;
 
-       part = mlxsw_sp_kvdl_part_find(mlxsw_sp, MLXSW_SP_KVDL_PART_CHUNKS);
-       if (!part)
-               return -EINVAL;
-
+       part = mlxsw_sp->kvdl->parts[MLXSW_SP_KVDL_PART_ID_CHUNKS];
        return mlxsw_sp_kvdl_part_occ(part);
 }
 
@@ -400,11 +352,7 @@ static u64 mlxsw_sp_kvdl_large_chunks_occ_get(struct devlink *devlink)
        struct mlxsw_sp *mlxsw_sp = mlxsw_core_driver_priv(mlxsw_core);
        struct mlxsw_sp_kvdl_part *part;
 
-       part = mlxsw_sp_kvdl_part_find(mlxsw_sp,
-                                      MLXSW_SP_KVDL_PART_LARGE_CHUNKS);
-       if (!part)
-               return -EINVAL;
-
+       part = mlxsw_sp->kvdl->parts[MLXSW_SP_KVDL_PART_ID_LARGE_CHUNKS];
        return mlxsw_sp_kvdl_part_occ(part);
 }
 
@@ -431,7 +379,8 @@ int mlxsw_sp_kvdl_resources_register(struct devlink *devlink)
                        MLXSW_CORE_RES_GET(mlxsw_core, KVD_SINGLE_MIN_SIZE) -
                        MLXSW_CORE_RES_GET(mlxsw_core, KVD_DOUBLE_MIN_SIZE);
 
-       devlink_resource_size_params_init(&size_params, 0, kvdl_max_size, 1,
+       devlink_resource_size_params_init(&size_params, 0, kvdl_max_size,
+                                         MLXSW_SP_KVDL_SINGLE_ALLOC_SIZE,
                                          DEVLINK_RESOURCE_UNIT_ENTRY);
        err = devlink_resource_register(devlink, MLXSW_SP_RESOURCE_NAME_KVD_LINEAR_SINGLES,
                                        MLXSW_SP_KVDL_SINGLE_SIZE,
@@ -443,7 +392,7 @@ int mlxsw_sp_kvdl_resources_register(struct devlink *devlink)
                return err;
 
        devlink_resource_size_params_init(&size_params, 0, kvdl_max_size,
-                                         MLXSW_SP_CHUNK_MAX,
+                                         MLXSW_SP_KVDL_CHUNKS_ALLOC_SIZE,
                                          DEVLINK_RESOURCE_UNIT_ENTRY);
        err = devlink_resource_register(devlink, MLXSW_SP_RESOURCE_NAME_KVD_LINEAR_CHUNKS,
                                        MLXSW_SP_KVDL_CHUNKS_SIZE,
@@ -455,7 +404,7 @@ int mlxsw_sp_kvdl_resources_register(struct devlink *devlink)
                return err;
 
        devlink_resource_size_params_init(&size_params, 0, kvdl_max_size,
-                                         MLXSW_SP_LARGE_CHUNK_MAX,
+                                         MLXSW_SP_KVDL_LARGE_CHUNKS_ALLOC_SIZE,
                                          DEVLINK_RESOURCE_UNIT_ENTRY);
        err = devlink_resource_register(devlink, MLXSW_SP_RESOURCE_NAME_KVD_LINEAR_LARGE_CHUNKS,
                                        MLXSW_SP_KVDL_LARGE_CHUNKS_SIZE,