1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0 2 /* Copyright (c) 2017-2018 Mellanox Technologies. All rights reserved */ 3 4 #include <linux/kernel.h> 5 #include <linux/bitops.h> 6 #include <linux/spinlock.h> 7 8 #include "spectrum_cnt.h" 9 10 struct mlxsw_sp_counter_sub_pool { 11 u64 size; 12 unsigned int base_index; 13 enum mlxsw_res_id entry_size_res_id; 14 const char *resource_name; /* devlink resource name */ 15 u64 resource_id; /* devlink resource id */ 16 unsigned int entry_size; 17 unsigned int bank_count; 18 atomic_t active_entries_count; 19 }; 20 21 struct mlxsw_sp_counter_pool { 22 u64 pool_size; 23 unsigned long *usage; /* Usage bitmap */ 24 spinlock_t counter_pool_lock; /* Protects counter pool allocations */ 25 atomic_t active_entries_count; 26 unsigned int sub_pools_count; 27 struct mlxsw_sp_counter_sub_pool sub_pools[] __counted_by(sub_pools_count); 28 }; 29 30 static const struct mlxsw_sp_counter_sub_pool mlxsw_sp_counter_sub_pools[] = { 31 [MLXSW_SP_COUNTER_SUB_POOL_FLOW] = { 32 .entry_size_res_id = MLXSW_RES_ID_COUNTER_SIZE_PACKETS_BYTES, 33 .resource_name = MLXSW_SP_RESOURCE_NAME_COUNTERS_FLOW, 34 .resource_id = MLXSW_SP_RESOURCE_COUNTERS_FLOW, 35 .bank_count = 6, 36 }, 37 [MLXSW_SP_COUNTER_SUB_POOL_RIF] = { 38 .entry_size_res_id = MLXSW_RES_ID_COUNTER_SIZE_ROUTER_BASIC, 39 .resource_name = MLXSW_SP_RESOURCE_NAME_COUNTERS_RIF, 40 .resource_id = MLXSW_SP_RESOURCE_COUNTERS_RIF, 41 .bank_count = 2, 42 } 43 }; 44 45 static u64 mlxsw_sp_counter_sub_pool_occ_get(void *priv) 46 { 47 const struct mlxsw_sp_counter_sub_pool *sub_pool = priv; 48 49 return atomic_read(&sub_pool->active_entries_count); 50 } 51 52 static int mlxsw_sp_counter_sub_pools_init(struct mlxsw_sp *mlxsw_sp) 53 { 54 struct mlxsw_sp_counter_pool *pool = mlxsw_sp->counter_pool; 55 struct devlink *devlink = priv_to_devlink(mlxsw_sp->core); 56 struct mlxsw_sp_counter_sub_pool *sub_pool; 57 unsigned int base_index = 0; 58 enum mlxsw_res_id res_id; 59 int err; 60 int i; 61 62 for (i = 0; i < pool->sub_pools_count; i++) { 63 sub_pool = &pool->sub_pools[i]; 64 res_id = sub_pool->entry_size_res_id; 65 66 if (!mlxsw_core_res_valid(mlxsw_sp->core, res_id)) 67 return -EIO; 68 sub_pool->entry_size = mlxsw_core_res_get(mlxsw_sp->core, 69 res_id); 70 err = devl_resource_size_get(devlink, 71 sub_pool->resource_id, 72 &sub_pool->size); 73 if (err) 74 goto err_resource_size_get; 75 76 devl_resource_occ_get_register(devlink, 77 sub_pool->resource_id, 78 mlxsw_sp_counter_sub_pool_occ_get, 79 sub_pool); 80 81 sub_pool->base_index = base_index; 82 base_index += sub_pool->size; 83 atomic_set(&sub_pool->active_entries_count, 0); 84 } 85 return 0; 86 87 err_resource_size_get: 88 for (i--; i >= 0; i--) { 89 sub_pool = &pool->sub_pools[i]; 90 91 devl_resource_occ_get_unregister(devlink, 92 sub_pool->resource_id); 93 } 94 return err; 95 } 96 97 static void mlxsw_sp_counter_sub_pools_fini(struct mlxsw_sp *mlxsw_sp) 98 { 99 struct mlxsw_sp_counter_pool *pool = mlxsw_sp->counter_pool; 100 struct devlink *devlink = priv_to_devlink(mlxsw_sp->core); 101 struct mlxsw_sp_counter_sub_pool *sub_pool; 102 int i; 103 104 for (i = 0; i < pool->sub_pools_count; i++) { 105 sub_pool = &pool->sub_pools[i]; 106 107 WARN_ON(atomic_read(&sub_pool->active_entries_count)); 108 devl_resource_occ_get_unregister(devlink, 109 sub_pool->resource_id); 110 } 111 } 112 113 static u64 mlxsw_sp_counter_pool_occ_get(void *priv) 114 { 115 const struct mlxsw_sp_counter_pool *pool = priv; 116 117 return atomic_read(&pool->active_entries_count); 118 } 119 120 int mlxsw_sp_counter_pool_init(struct mlxsw_sp *mlxsw_sp) 121 { 122 unsigned int sub_pools_count = ARRAY_SIZE(mlxsw_sp_counter_sub_pools); 123 struct devlink *devlink = priv_to_devlink(mlxsw_sp->core); 124 struct mlxsw_sp_counter_pool *pool; 125 int err; 126 127 pool = kzalloc(struct_size(pool, sub_pools, sub_pools_count), 128 GFP_KERNEL); 129 if (!pool) 130 return -ENOMEM; 131 mlxsw_sp->counter_pool = pool; 132 pool->sub_pools_count = sub_pools_count; 133 memcpy(pool->sub_pools, mlxsw_sp_counter_sub_pools, 134 flex_array_size(pool, sub_pools, pool->sub_pools_count)); 135 spin_lock_init(&pool->counter_pool_lock); 136 atomic_set(&pool->active_entries_count, 0); 137 138 err = devl_resource_size_get(devlink, MLXSW_SP_RESOURCE_COUNTERS, 139 &pool->pool_size); 140 if (err) 141 goto err_pool_resource_size_get; 142 devl_resource_occ_get_register(devlink, MLXSW_SP_RESOURCE_COUNTERS, 143 mlxsw_sp_counter_pool_occ_get, pool); 144 145 pool->usage = bitmap_zalloc(pool->pool_size, GFP_KERNEL); 146 if (!pool->usage) { 147 err = -ENOMEM; 148 goto err_usage_alloc; 149 } 150 151 err = mlxsw_sp_counter_sub_pools_init(mlxsw_sp); 152 if (err) 153 goto err_sub_pools_init; 154 155 return 0; 156 157 err_sub_pools_init: 158 bitmap_free(pool->usage); 159 err_usage_alloc: 160 devl_resource_occ_get_unregister(devlink, 161 MLXSW_SP_RESOURCE_COUNTERS); 162 err_pool_resource_size_get: 163 kfree(pool); 164 return err; 165 } 166 167 void mlxsw_sp_counter_pool_fini(struct mlxsw_sp *mlxsw_sp) 168 { 169 struct mlxsw_sp_counter_pool *pool = mlxsw_sp->counter_pool; 170 struct devlink *devlink = priv_to_devlink(mlxsw_sp->core); 171 172 mlxsw_sp_counter_sub_pools_fini(mlxsw_sp); 173 WARN_ON(!bitmap_empty(pool->usage, pool->pool_size)); 174 WARN_ON(atomic_read(&pool->active_entries_count)); 175 bitmap_free(pool->usage); 176 devl_resource_occ_get_unregister(devlink, 177 MLXSW_SP_RESOURCE_COUNTERS); 178 kfree(pool); 179 } 180 181 int mlxsw_sp_counter_alloc(struct mlxsw_sp *mlxsw_sp, 182 enum mlxsw_sp_counter_sub_pool_id sub_pool_id, 183 unsigned int *p_counter_index) 184 { 185 struct mlxsw_sp_counter_pool *pool = mlxsw_sp->counter_pool; 186 struct mlxsw_sp_counter_sub_pool *sub_pool; 187 unsigned int entry_index; 188 unsigned int stop_index; 189 int i, err; 190 191 sub_pool = &pool->sub_pools[sub_pool_id]; 192 stop_index = sub_pool->base_index + sub_pool->size; 193 entry_index = sub_pool->base_index; 194 195 spin_lock(&pool->counter_pool_lock); 196 entry_index = find_next_zero_bit(pool->usage, stop_index, entry_index); 197 if (entry_index == stop_index) { 198 err = -ENOBUFS; 199 goto err_alloc; 200 } 201 /* The sub-pools can contain non-integer number of entries 202 * so we must check for overflow 203 */ 204 if (entry_index + sub_pool->entry_size > stop_index) { 205 err = -ENOBUFS; 206 goto err_alloc; 207 } 208 for (i = 0; i < sub_pool->entry_size; i++) 209 __set_bit(entry_index + i, pool->usage); 210 spin_unlock(&pool->counter_pool_lock); 211 212 *p_counter_index = entry_index; 213 atomic_add(sub_pool->entry_size, &sub_pool->active_entries_count); 214 atomic_add(sub_pool->entry_size, &pool->active_entries_count); 215 return 0; 216 217 err_alloc: 218 spin_unlock(&pool->counter_pool_lock); 219 return err; 220 } 221 222 void mlxsw_sp_counter_free(struct mlxsw_sp *mlxsw_sp, 223 enum mlxsw_sp_counter_sub_pool_id sub_pool_id, 224 unsigned int counter_index) 225 { 226 struct mlxsw_sp_counter_pool *pool = mlxsw_sp->counter_pool; 227 struct mlxsw_sp_counter_sub_pool *sub_pool; 228 int i; 229 230 if (WARN_ON(counter_index >= pool->pool_size)) 231 return; 232 sub_pool = &pool->sub_pools[sub_pool_id]; 233 spin_lock(&pool->counter_pool_lock); 234 for (i = 0; i < sub_pool->entry_size; i++) 235 __clear_bit(counter_index + i, pool->usage); 236 spin_unlock(&pool->counter_pool_lock); 237 atomic_sub(sub_pool->entry_size, &sub_pool->active_entries_count); 238 atomic_sub(sub_pool->entry_size, &pool->active_entries_count); 239 } 240 241 int mlxsw_sp_counter_resources_register(struct mlxsw_core *mlxsw_core) 242 { 243 static struct devlink_resource_size_params size_params; 244 struct devlink *devlink = priv_to_devlink(mlxsw_core); 245 const struct mlxsw_sp_counter_sub_pool *sub_pool; 246 unsigned int total_bank_config; 247 u64 sub_pool_size; 248 u64 base_index; 249 u64 pool_size; 250 u64 bank_size; 251 int err; 252 int i; 253 254 if (!MLXSW_CORE_RES_VALID(mlxsw_core, COUNTER_POOL_SIZE) || 255 !MLXSW_CORE_RES_VALID(mlxsw_core, COUNTER_BANK_SIZE)) 256 return -EIO; 257 258 pool_size = MLXSW_CORE_RES_GET(mlxsw_core, COUNTER_POOL_SIZE); 259 bank_size = MLXSW_CORE_RES_GET(mlxsw_core, COUNTER_BANK_SIZE); 260 261 devlink_resource_size_params_init(&size_params, pool_size, 262 pool_size, bank_size, 263 DEVLINK_RESOURCE_UNIT_ENTRY); 264 err = devl_resource_register(devlink, 265 MLXSW_SP_RESOURCE_NAME_COUNTERS, 266 pool_size, 267 MLXSW_SP_RESOURCE_COUNTERS, 268 DEVLINK_RESOURCE_ID_PARENT_TOP, 269 &size_params); 270 if (err) 271 return err; 272 273 /* Allocation is based on bank count which should be 274 * specified for each sub pool statically. 275 */ 276 total_bank_config = 0; 277 base_index = 0; 278 for (i = 0; i < ARRAY_SIZE(mlxsw_sp_counter_sub_pools); i++) { 279 sub_pool = &mlxsw_sp_counter_sub_pools[i]; 280 sub_pool_size = sub_pool->bank_count * bank_size; 281 /* The last bank can't be fully used */ 282 if (base_index + sub_pool_size > pool_size) 283 sub_pool_size = pool_size - base_index; 284 base_index += sub_pool_size; 285 286 devlink_resource_size_params_init(&size_params, sub_pool_size, 287 sub_pool_size, bank_size, 288 DEVLINK_RESOURCE_UNIT_ENTRY); 289 err = devl_resource_register(devlink, 290 sub_pool->resource_name, 291 sub_pool_size, 292 sub_pool->resource_id, 293 MLXSW_SP_RESOURCE_COUNTERS, 294 &size_params); 295 if (err) 296 return err; 297 total_bank_config += sub_pool->bank_count; 298 } 299 300 /* Check config is valid, no bank over subscription */ 301 if (WARN_ON(total_bank_config > div64_u64(pool_size, bank_size) + 1)) 302 return -EINVAL; 303 304 return 0; 305 } 306