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
10struct 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
21struct 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
30static 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
45static 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(v: &sub_pool->active_entries_count);
50}
51
52static 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(priv: 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_core: mlxsw_sp->core, res_id))
67 return -EIO;
68 sub_pool->entry_size = mlxsw_core_res_get(mlxsw_core: mlxsw_sp->core,
69 res_id);
70 err = devl_resource_size_get(devlink,
71 resource_id: sub_pool->resource_id,
72 p_resource_size: &sub_pool->size);
73 if (err)
74 goto err_resource_size_get;
75
76 devl_resource_occ_get_register(devlink,
77 resource_id: sub_pool->resource_id,
78 occ_get: mlxsw_sp_counter_sub_pool_occ_get,
79 occ_get_priv: sub_pool);
80
81 sub_pool->base_index = base_index;
82 base_index += sub_pool->size;
83 atomic_set(v: &sub_pool->active_entries_count, i: 0);
84 }
85 return 0;
86
87err_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 resource_id: sub_pool->resource_id);
93 }
94 return err;
95}
96
97static 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(priv: 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 resource_id: sub_pool->resource_id);
110 }
111}
112
113static u64 mlxsw_sp_counter_pool_occ_get(void *priv)
114{
115 const struct mlxsw_sp_counter_pool *pool = priv;
116
117 return atomic_read(v: &pool->active_entries_count);
118}
119
120int 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(priv: 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(v: &pool->active_entries_count, i: 0);
137
138 err = devl_resource_size_get(devlink, resource_id: MLXSW_SP_RESOURCE_COUNTERS,
139 p_resource_size: &pool->pool_size);
140 if (err)
141 goto err_pool_resource_size_get;
142 devl_resource_occ_get_register(devlink, resource_id: MLXSW_SP_RESOURCE_COUNTERS,
143 occ_get: mlxsw_sp_counter_pool_occ_get, occ_get_priv: pool);
144
145 pool->usage = bitmap_zalloc(nbits: 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
157err_sub_pools_init:
158 bitmap_free(bitmap: pool->usage);
159err_usage_alloc:
160 devl_resource_occ_get_unregister(devlink,
161 resource_id: MLXSW_SP_RESOURCE_COUNTERS);
162err_pool_resource_size_get:
163 kfree(objp: pool);
164 return err;
165}
166
167void 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(priv: mlxsw_sp->core);
171
172 mlxsw_sp_counter_sub_pools_fini(mlxsw_sp);
173 WARN_ON(find_first_bit(pool->usage, pool->pool_size) !=
174 pool->pool_size);
175 WARN_ON(atomic_read(&pool->active_entries_count));
176 bitmap_free(bitmap: pool->usage);
177 devl_resource_occ_get_unregister(devlink,
178 resource_id: MLXSW_SP_RESOURCE_COUNTERS);
179 kfree(objp: pool);
180}
181
182int mlxsw_sp_counter_alloc(struct mlxsw_sp *mlxsw_sp,
183 enum mlxsw_sp_counter_sub_pool_id sub_pool_id,
184 unsigned int *p_counter_index)
185{
186 struct mlxsw_sp_counter_pool *pool = mlxsw_sp->counter_pool;
187 struct mlxsw_sp_counter_sub_pool *sub_pool;
188 unsigned int entry_index;
189 unsigned int stop_index;
190 int i, err;
191
192 sub_pool = &pool->sub_pools[sub_pool_id];
193 stop_index = sub_pool->base_index + sub_pool->size;
194 entry_index = sub_pool->base_index;
195
196 spin_lock(lock: &pool->counter_pool_lock);
197 entry_index = find_next_zero_bit(addr: pool->usage, size: stop_index, offset: entry_index);
198 if (entry_index == stop_index) {
199 err = -ENOBUFS;
200 goto err_alloc;
201 }
202 /* The sub-pools can contain non-integer number of entries
203 * so we must check for overflow
204 */
205 if (entry_index + sub_pool->entry_size > stop_index) {
206 err = -ENOBUFS;
207 goto err_alloc;
208 }
209 for (i = 0; i < sub_pool->entry_size; i++)
210 __set_bit(entry_index + i, pool->usage);
211 spin_unlock(lock: &pool->counter_pool_lock);
212
213 *p_counter_index = entry_index;
214 atomic_add(i: sub_pool->entry_size, v: &sub_pool->active_entries_count);
215 atomic_add(i: sub_pool->entry_size, v: &pool->active_entries_count);
216 return 0;
217
218err_alloc:
219 spin_unlock(lock: &pool->counter_pool_lock);
220 return err;
221}
222
223void mlxsw_sp_counter_free(struct mlxsw_sp *mlxsw_sp,
224 enum mlxsw_sp_counter_sub_pool_id sub_pool_id,
225 unsigned int counter_index)
226{
227 struct mlxsw_sp_counter_pool *pool = mlxsw_sp->counter_pool;
228 struct mlxsw_sp_counter_sub_pool *sub_pool;
229 int i;
230
231 if (WARN_ON(counter_index >= pool->pool_size))
232 return;
233 sub_pool = &pool->sub_pools[sub_pool_id];
234 spin_lock(lock: &pool->counter_pool_lock);
235 for (i = 0; i < sub_pool->entry_size; i++)
236 __clear_bit(counter_index + i, pool->usage);
237 spin_unlock(lock: &pool->counter_pool_lock);
238 atomic_sub(i: sub_pool->entry_size, v: &sub_pool->active_entries_count);
239 atomic_sub(i: sub_pool->entry_size, v: &pool->active_entries_count);
240}
241
242int mlxsw_sp_counter_resources_register(struct mlxsw_core *mlxsw_core)
243{
244 static struct devlink_resource_size_params size_params;
245 struct devlink *devlink = priv_to_devlink(priv: mlxsw_core);
246 const struct mlxsw_sp_counter_sub_pool *sub_pool;
247 unsigned int total_bank_config;
248 u64 sub_pool_size;
249 u64 base_index;
250 u64 pool_size;
251 u64 bank_size;
252 int err;
253 int i;
254
255 if (!MLXSW_CORE_RES_VALID(mlxsw_core, COUNTER_POOL_SIZE) ||
256 !MLXSW_CORE_RES_VALID(mlxsw_core, COUNTER_BANK_SIZE))
257 return -EIO;
258
259 pool_size = MLXSW_CORE_RES_GET(mlxsw_core, COUNTER_POOL_SIZE);
260 bank_size = MLXSW_CORE_RES_GET(mlxsw_core, COUNTER_BANK_SIZE);
261
262 devlink_resource_size_params_init(size_params: &size_params, size_min: pool_size,
263 size_max: pool_size, size_granularity: bank_size,
264 unit: DEVLINK_RESOURCE_UNIT_ENTRY);
265 err = devl_resource_register(devlink,
266 MLXSW_SP_RESOURCE_NAME_COUNTERS,
267 resource_size: pool_size,
268 resource_id: MLXSW_SP_RESOURCE_COUNTERS,
269 DEVLINK_RESOURCE_ID_PARENT_TOP,
270 size_params: &size_params);
271 if (err)
272 return err;
273
274 /* Allocation is based on bank count which should be
275 * specified for each sub pool statically.
276 */
277 total_bank_config = 0;
278 base_index = 0;
279 for (i = 0; i < ARRAY_SIZE(mlxsw_sp_counter_sub_pools); i++) {
280 sub_pool = &mlxsw_sp_counter_sub_pools[i];
281 sub_pool_size = sub_pool->bank_count * bank_size;
282 /* The last bank can't be fully used */
283 if (base_index + sub_pool_size > pool_size)
284 sub_pool_size = pool_size - base_index;
285 base_index += sub_pool_size;
286
287 devlink_resource_size_params_init(size_params: &size_params, size_min: sub_pool_size,
288 size_max: sub_pool_size, size_granularity: bank_size,
289 unit: DEVLINK_RESOURCE_UNIT_ENTRY);
290 err = devl_resource_register(devlink,
291 resource_name: sub_pool->resource_name,
292 resource_size: sub_pool_size,
293 resource_id: sub_pool->resource_id,
294 parent_resource_id: MLXSW_SP_RESOURCE_COUNTERS,
295 size_params: &size_params);
296 if (err)
297 return err;
298 total_bank_config += sub_pool->bank_count;
299 }
300
301 /* Check config is valid, no bank over subscription */
302 if (WARN_ON(total_bank_config > div64_u64(pool_size, bank_size) + 1))
303 return -EINVAL;
304
305 return 0;
306}
307

source code of linux/drivers/net/ethernet/mellanox/mlxsw/spectrum_cnt.c