drivers/net/ethernet/mellanox/mlxsw/spectrum2_kvdl.c

   1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
   2 /* Copyright (c) 2018 Mellanox Technologies. All rights reserved */
   3
   4 #include <linux/kernel.h>
   5 #include <linux/bitops.h>
   6
   7 #include "spectrum.h"
   8 #include "core.h"
   9 #include "reg.h"
  10 #include "resources.h"
  11
  12 struct mlxsw_sp2_kvdl_part_info {
  13         u8 res_type;
  14         /* For each defined partititon we need to know how many
  15          * usage bits we need and how many indexes there are
  16          * represented by a single bit. This could be got from FW
  17          * querying appropriate resources. So have the resource
  18          * ids for this purpose in partition definition.
  19          */
  20         enum mlxsw_res_id usage_bit_count_res_id;
  21         enum mlxsw_res_id index_range_res_id;
  22 };
  23
  24 #define MLXSW_SP2_KVDL_PART_INFO(_entry_type, _res_type,                        \
  25                                  _usage_bit_count_res_id, _index_range_res_id)  \
  26 [MLXSW_SP_KVDL_ENTRY_TYPE_##_entry_type] = {                                    \
  27         .res_type = _res_type,                                                  \
  28         .usage_bit_count_res_id = MLXSW_RES_ID_##_usage_bit_count_res_id,       \
  29         .index_range_res_id = MLXSW_RES_ID_##_index_range_res_id,               \
  30 }
  31
  32 static const struct mlxsw_sp2_kvdl_part_info mlxsw_sp2_kvdl_parts_info[] = {
  33         MLXSW_SP2_KVDL_PART_INFO(ADJ, 0x21, KVD_SIZE, MAX_KVD_LINEAR_RANGE),
  34         MLXSW_SP2_KVDL_PART_INFO(ACTSET, 0x23, MAX_KVD_ACTION_SETS,
  35                                  MAX_KVD_ACTION_SETS),
  36         MLXSW_SP2_KVDL_PART_INFO(PBS, 0x24, KVD_SIZE, KVD_SIZE),
  37         MLXSW_SP2_KVDL_PART_INFO(MCRIGR, 0x26, KVD_SIZE, KVD_SIZE),
  38         MLXSW_SP2_KVDL_PART_INFO(IPV6_ADDRESS, 0x28, KVD_SIZE, KVD_SIZE),
  39         MLXSW_SP2_KVDL_PART_INFO(TNUMT, 0x29, KVD_SIZE, KVD_SIZE),
  40 };
  41
  42 #define MLXSW_SP2_KVDL_PARTS_INFO_LEN ARRAY_SIZE(mlxsw_sp2_kvdl_parts_info)
  43
  44 struct mlxsw_sp2_kvdl_part {
  45         const struct mlxsw_sp2_kvdl_part_info *info;
  46         unsigned int usage_bit_count;
  47         unsigned int indexes_per_usage_bit;
  48         unsigned int last_allocated_bit;
  49         unsigned long usage[];  /* Usage bits */
  50 };
  51
  52 struct mlxsw_sp2_kvdl {
  53         struct mlxsw_sp2_kvdl_part *parts[MLXSW_SP2_KVDL_PARTS_INFO_LEN];
  54 };
  55
  56 static int mlxsw_sp2_kvdl_part_find_zero_bits(struct mlxsw_sp2_kvdl_part *part,
  57                                               unsigned int bit_count,
  58                                               unsigned int *p_bit)
  59 {
  60         unsigned int start_bit;
  61         unsigned int bit;
  62         unsigned int i;
  63         bool wrap = false;
  64
  65         start_bit = part->last_allocated_bit + 1;
  66         if (start_bit == part->usage_bit_count)
  67                 start_bit = 0;
  68         bit = start_bit;
  69 again:
  70         bit = find_next_zero_bit(part->usage, part->usage_bit_count, bit);
  71         if (!wrap && bit + bit_count >= part->usage_bit_count) {
  72                 wrap = true;
  73                 bit = 0;
  74                 goto again;
  75         }
  76         if (wrap && bit + bit_count >= start_bit)
  77                 return -ENOBUFS;
  78         for (i = 0; i < bit_count; i++) {
  79                 if (test_bit(bit + i, part->usage)) {
  80                         bit += bit_count;
  81                         goto again;
  82                 }
  83         }
  84         *p_bit = bit;
  85         return 0;
  86 }
  87
  88 static int mlxsw_sp2_kvdl_part_alloc(struct mlxsw_sp2_kvdl_part *part,
  89                                      unsigned int size,
  90                                      u32 *p_kvdl_index)
  91 {
  92         unsigned int bit_count;
  93         unsigned int bit;
  94         unsigned int i;
  95         int err;
  96
  97         bit_count = DIV_ROUND_UP(size, part->indexes_per_usage_bit);
  98         err = mlxsw_sp2_kvdl_part_find_zero_bits(part, bit_count, &bit);
  99         if (err)
 100                 return err;
 101         for (i = 0; i < bit_count; i++)
 102                 __set_bit(bit + i, part->usage);
 103         *p_kvdl_index = bit * part->indexes_per_usage_bit;
 104         return 0;
 105 }
 106
 107 static int mlxsw_sp2_kvdl_rec_del(struct mlxsw_sp *mlxsw_sp, u8 res_type,
 108                                   u16 size, u32 kvdl_index)
 109 {
 110         char *iedr_pl;
 111         int err;
 112
 113         iedr_pl = kmalloc(MLXSW_REG_IEDR_LEN, GFP_KERNEL);
 114         if (!iedr_pl)
 115                 return -ENOMEM;
 116
 117         mlxsw_reg_iedr_pack(iedr_pl);
 118         mlxsw_reg_iedr_rec_pack(iedr_pl, 0, res_type, size, kvdl_index);
 119         err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(iedr), iedr_pl);
 120         kfree(iedr_pl);
 121         return err;
 122 }
 123
 124 static void mlxsw_sp2_kvdl_part_free(struct mlxsw_sp *mlxsw_sp,
 125                                      struct mlxsw_sp2_kvdl_part *part,
 126                                      unsigned int size, u32 kvdl_index)
 127 {
 128         unsigned int bit_count;
 129         unsigned int bit;
 130         unsigned int i;
 131         int err;
 132
 133         /* We need to ask FW to delete previously used KVD linear index */
 134         err = mlxsw_sp2_kvdl_rec_del(mlxsw_sp, part->info->res_type,
 135                                      size, kvdl_index);
 136         if (err)
 137                 return;
 138
 139         bit_count = DIV_ROUND_UP(size, part->indexes_per_usage_bit);
 140         bit = kvdl_index / part->indexes_per_usage_bit;
 141         for (i = 0; i < bit_count; i++)
 142                 __clear_bit(bit + i, part->usage);
 143 }
 144
 145 static int mlxsw_sp2_kvdl_alloc(struct mlxsw_sp *mlxsw_sp, void *priv,
 146                                 enum mlxsw_sp_kvdl_entry_type type,
 147                                 unsigned int entry_count,
 148                                 u32 *p_entry_index)
 149 {
 150         unsigned int size = entry_count * mlxsw_sp_kvdl_entry_size(type);
 151         struct mlxsw_sp2_kvdl *kvdl = priv;
 152         struct mlxsw_sp2_kvdl_part *part = kvdl->parts[type];
 153
 154         return mlxsw_sp2_kvdl_part_alloc(part, size, p_entry_index);
 155 }
 156
 157 static void mlxsw_sp2_kvdl_free(struct mlxsw_sp *mlxsw_sp, void *priv,
 158                                 enum mlxsw_sp_kvdl_entry_type type,
 159                                 unsigned int entry_count,
 160                                 int entry_index)
 161 {
 162         unsigned int size = entry_count * mlxsw_sp_kvdl_entry_size(type);
 163         struct mlxsw_sp2_kvdl *kvdl = priv;
 164         struct mlxsw_sp2_kvdl_part *part = kvdl->parts[type];
 165
 166         return mlxsw_sp2_kvdl_part_free(mlxsw_sp, part, size, entry_index);
 167 }
 168
 169 static int mlxsw_sp2_kvdl_alloc_size_query(struct mlxsw_sp *mlxsw_sp,
 170                                            void *priv,
 171                                            enum mlxsw_sp_kvdl_entry_type type,
 172                                            unsigned int entry_count,
 173                                            unsigned int *p_alloc_count)
 174 {
 175         *p_alloc_count = entry_count;
 176         return 0;
 177 }
 178
 179 static struct mlxsw_sp2_kvdl_part *
 180 mlxsw_sp2_kvdl_part_init(struct mlxsw_sp *mlxsw_sp,
 181                          const struct mlxsw_sp2_kvdl_part_info *info)
 182 {
 183         unsigned int indexes_per_usage_bit;
 184         struct mlxsw_sp2_kvdl_part *part;
 185         unsigned int index_range;
 186         unsigned int usage_bit_count;
 187         size_t usage_size;
 188
 189         if (!mlxsw_core_res_valid(mlxsw_sp->core,
 190                                   info->usage_bit_count_res_id) ||
 191             !mlxsw_core_res_valid(mlxsw_sp->core,
 192                                   info->index_range_res_id))
 193                 return ERR_PTR(-EIO);
 194         usage_bit_count = mlxsw_core_res_get(mlxsw_sp->core,
 195                                              info->usage_bit_count_res_id);
 196         index_range = mlxsw_core_res_get(mlxsw_sp->core,
 197                                          info->index_range_res_id);
 198
 199         /* For some partitions, one usage bit represents a group of indexes.
 200          * That's why we compute the number of indexes per usage bit here,
 201          * according to queried resources.
 202          */
 203         indexes_per_usage_bit = index_range / usage_bit_count;
 204
 205         usage_size = BITS_TO_LONGS(usage_bit_count) * sizeof(unsigned long);
 206         part = kzalloc(sizeof(*part) + usage_size, GFP_KERNEL);
 207         if (!part)
 208                 return ERR_PTR(-ENOMEM);
 209         part->info = info;
 210         part->usage_bit_count = usage_bit_count;
 211         part->indexes_per_usage_bit = indexes_per_usage_bit;
 212         part->last_allocated_bit = usage_bit_count - 1;
 213         return part;
 214 }
 215
 216 static void mlxsw_sp2_kvdl_part_fini(struct mlxsw_sp2_kvdl_part *part)
 217 {
 218         kfree(part);
 219 }
 220
 221 static int mlxsw_sp2_kvdl_parts_init(struct mlxsw_sp *mlxsw_sp,
 222                                      struct mlxsw_sp2_kvdl *kvdl)
 223 {
 224         const struct mlxsw_sp2_kvdl_part_info *info;
 225         int i;
 226         int err;
 227
 228         for (i = 0; i < MLXSW_SP2_KVDL_PARTS_INFO_LEN; i++) {
 229                 info = &mlxsw_sp2_kvdl_parts_info[i];
 230                 kvdl->parts[i] = mlxsw_sp2_kvdl_part_init(mlxsw_sp, info);
 231                 if (IS_ERR(kvdl->parts[i])) {
 232                         err = PTR_ERR(kvdl->parts[i]);
 233                         goto err_kvdl_part_init;
 234                 }
 235         }
 236         return 0;
 237
 238 err_kvdl_part_init:
 239         for (i--; i >= 0; i--)
 240                 mlxsw_sp2_kvdl_part_fini(kvdl->parts[i]);
 241         return err;
 242 }
 243
 244 static void mlxsw_sp2_kvdl_parts_fini(struct mlxsw_sp2_kvdl *kvdl)
 245 {
 246         int i;
 247
 248         for (i = 0; i < MLXSW_SP2_KVDL_PARTS_INFO_LEN; i++)
 249                 mlxsw_sp2_kvdl_part_fini(kvdl->parts[i]);
 250 }
 251
 252 static int mlxsw_sp2_kvdl_init(struct mlxsw_sp *mlxsw_sp, void *priv)
 253 {
 254         struct mlxsw_sp2_kvdl *kvdl = priv;
 255
 256         return mlxsw_sp2_kvdl_parts_init(mlxsw_sp, kvdl);
 257 }
 258
 259 static void mlxsw_sp2_kvdl_fini(struct mlxsw_sp *mlxsw_sp, void *priv)
 260 {
 261         struct mlxsw_sp2_kvdl *kvdl = priv;
 262
 263         mlxsw_sp2_kvdl_parts_fini(kvdl);
 264 }
 265
 266 const struct mlxsw_sp_kvdl_ops mlxsw_sp2_kvdl_ops = {
 267         .priv_size = sizeof(struct mlxsw_sp2_kvdl),
 268         .init = mlxsw_sp2_kvdl_init,
 269         .fini = mlxsw_sp2_kvdl_fini,
 270         .alloc = mlxsw_sp2_kvdl_alloc,
 271         .free = mlxsw_sp2_kvdl_free,
 272         .alloc_size_query = mlxsw_sp2_kvdl_alloc_size_query,
 273 };