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 
9 #define MLXSW_SP1_KVDL_SINGLE_BASE 0
10 #define MLXSW_SP1_KVDL_SINGLE_SIZE 16384
11 #define MLXSW_SP1_KVDL_SINGLE_END \
12 	(MLXSW_SP1_KVDL_SINGLE_SIZE + MLXSW_SP1_KVDL_SINGLE_BASE - 1)
13 
14 #define MLXSW_SP1_KVDL_CHUNKS_BASE \
15 	(MLXSW_SP1_KVDL_SINGLE_BASE + MLXSW_SP1_KVDL_SINGLE_SIZE)
16 #define MLXSW_SP1_KVDL_CHUNKS_SIZE 49152
17 #define MLXSW_SP1_KVDL_CHUNKS_END \
18 	(MLXSW_SP1_KVDL_CHUNKS_SIZE + MLXSW_SP1_KVDL_CHUNKS_BASE - 1)
19 
20 #define MLXSW_SP1_KVDL_LARGE_CHUNKS_BASE \
21 	(MLXSW_SP1_KVDL_CHUNKS_BASE + MLXSW_SP1_KVDL_CHUNKS_SIZE)
22 #define MLXSW_SP1_KVDL_LARGE_CHUNKS_SIZE \
23 	(MLXSW_SP_KVD_LINEAR_SIZE - MLXSW_SP1_KVDL_LARGE_CHUNKS_BASE)
24 #define MLXSW_SP1_KVDL_LARGE_CHUNKS_END \
25 	(MLXSW_SP1_KVDL_LARGE_CHUNKS_SIZE + MLXSW_SP1_KVDL_LARGE_CHUNKS_BASE - 1)
26 
27 #define MLXSW_SP1_KVDL_SINGLE_ALLOC_SIZE 1
28 #define MLXSW_SP1_KVDL_CHUNKS_ALLOC_SIZE 32
29 #define MLXSW_SP1_KVDL_LARGE_CHUNKS_ALLOC_SIZE 512
30 
31 struct mlxsw_sp1_kvdl_part_info {
32 	unsigned int part_index;
33 	unsigned int start_index;
34 	unsigned int end_index;
35 	unsigned int alloc_size;
36 	enum mlxsw_sp_resource_id resource_id;
37 };
38 
39 enum mlxsw_sp1_kvdl_part_id {
40 	MLXSW_SP1_KVDL_PART_ID_SINGLE,
41 	MLXSW_SP1_KVDL_PART_ID_CHUNKS,
42 	MLXSW_SP1_KVDL_PART_ID_LARGE_CHUNKS,
43 };
44 
45 #define MLXSW_SP1_KVDL_PART_INFO(id)				\
46 [MLXSW_SP1_KVDL_PART_ID_##id] = {				\
47 	.start_index = MLXSW_SP1_KVDL_##id##_BASE,		\
48 	.end_index = MLXSW_SP1_KVDL_##id##_END,			\
49 	.alloc_size = MLXSW_SP1_KVDL_##id##_ALLOC_SIZE,		\
50 	.resource_id = MLXSW_SP_RESOURCE_KVD_LINEAR_##id,	\
51 }
52 
53 static const struct mlxsw_sp1_kvdl_part_info mlxsw_sp1_kvdl_parts_info[] = {
54 	MLXSW_SP1_KVDL_PART_INFO(SINGLE),
55 	MLXSW_SP1_KVDL_PART_INFO(CHUNKS),
56 	MLXSW_SP1_KVDL_PART_INFO(LARGE_CHUNKS),
57 };
58 
59 #define MLXSW_SP1_KVDL_PARTS_INFO_LEN ARRAY_SIZE(mlxsw_sp1_kvdl_parts_info)
60 
61 struct mlxsw_sp1_kvdl_part {
62 	struct mlxsw_sp1_kvdl_part_info info;
63 	unsigned long usage[];	/* Entries */
64 };
65 
66 struct mlxsw_sp1_kvdl {
67 	struct mlxsw_sp1_kvdl_part *parts[MLXSW_SP1_KVDL_PARTS_INFO_LEN];
68 };
69 
70 static struct mlxsw_sp1_kvdl_part *
71 mlxsw_sp1_kvdl_alloc_size_part(struct mlxsw_sp1_kvdl *kvdl,
72 			       unsigned int alloc_size)
73 {
74 	struct mlxsw_sp1_kvdl_part *part, *min_part = NULL;
75 	int i;
76 
77 	for (i = 0; i < MLXSW_SP1_KVDL_PARTS_INFO_LEN; i++) {
78 		part = kvdl->parts[i];
79 		if (alloc_size <= part->info.alloc_size &&
80 		    (!min_part ||
81 		     part->info.alloc_size <= min_part->info.alloc_size))
82 			min_part = part;
83 	}
84 
85 	return min_part ?: ERR_PTR(-ENOBUFS);
86 }
87 
88 static struct mlxsw_sp1_kvdl_part *
89 mlxsw_sp1_kvdl_index_part(struct mlxsw_sp1_kvdl *kvdl, u32 kvdl_index)
90 {
91 	struct mlxsw_sp1_kvdl_part *part;
92 	int i;
93 
94 	for (i = 0; i < MLXSW_SP1_KVDL_PARTS_INFO_LEN; i++) {
95 		part = kvdl->parts[i];
96 		if (kvdl_index >= part->info.start_index &&
97 		    kvdl_index <= part->info.end_index)
98 			return part;
99 	}
100 
101 	return ERR_PTR(-EINVAL);
102 }
103 
104 static u32
105 mlxsw_sp1_kvdl_to_kvdl_index(const struct mlxsw_sp1_kvdl_part_info *info,
106 			     unsigned int entry_index)
107 {
108 	return info->start_index + entry_index * info->alloc_size;
109 }
110 
111 static unsigned int
112 mlxsw_sp1_kvdl_to_entry_index(const struct mlxsw_sp1_kvdl_part_info *info,
113 			      u32 kvdl_index)
114 {
115 	return (kvdl_index - info->start_index) / info->alloc_size;
116 }
117 
118 static int mlxsw_sp1_kvdl_part_alloc(struct mlxsw_sp1_kvdl_part *part,
119 				     u32 *p_kvdl_index)
120 {
121 	const struct mlxsw_sp1_kvdl_part_info *info = &part->info;
122 	unsigned int entry_index, nr_entries;
123 
124 	nr_entries = (info->end_index - info->start_index + 1) /
125 		     info->alloc_size;
126 	entry_index = find_first_zero_bit(part->usage, nr_entries);
127 	if (entry_index == nr_entries)
128 		return -ENOBUFS;
129 	__set_bit(entry_index, part->usage);
130 
131 	*p_kvdl_index = mlxsw_sp1_kvdl_to_kvdl_index(info, entry_index);
132 
133 	return 0;
134 }
135 
136 static void mlxsw_sp1_kvdl_part_free(struct mlxsw_sp1_kvdl_part *part,
137 				     u32 kvdl_index)
138 {
139 	const struct mlxsw_sp1_kvdl_part_info *info = &part->info;
140 	unsigned int entry_index;
141 
142 	entry_index = mlxsw_sp1_kvdl_to_entry_index(info, kvdl_index);
143 	__clear_bit(entry_index, part->usage);
144 }
145 
146 static int mlxsw_sp1_kvdl_alloc(struct mlxsw_sp *mlxsw_sp, void *priv,
147 				enum mlxsw_sp_kvdl_entry_type type,
148 				unsigned int entry_count,
149 				u32 *p_entry_index)
150 {
151 	struct mlxsw_sp1_kvdl *kvdl = priv;
152 	struct mlxsw_sp1_kvdl_part *part;
153 
154 	/* Find partition with smallest allocation size satisfying the
155 	 * requested size.
156 	 */
157 	part = mlxsw_sp1_kvdl_alloc_size_part(kvdl, entry_count);
158 	if (IS_ERR(part))
159 		return PTR_ERR(part);
160 
161 	return mlxsw_sp1_kvdl_part_alloc(part, p_entry_index);
162 }
163 
164 static void mlxsw_sp1_kvdl_free(struct mlxsw_sp *mlxsw_sp, void *priv,
165 				enum mlxsw_sp_kvdl_entry_type type,
166 				unsigned int entry_count, int entry_index)
167 {
168 	struct mlxsw_sp1_kvdl *kvdl = priv;
169 	struct mlxsw_sp1_kvdl_part *part;
170 
171 	part = mlxsw_sp1_kvdl_index_part(kvdl, entry_index);
172 	if (IS_ERR(part))
173 		return;
174 	mlxsw_sp1_kvdl_part_free(part, entry_index);
175 }
176 
177 static int mlxsw_sp1_kvdl_alloc_size_query(struct mlxsw_sp *mlxsw_sp,
178 					   void *priv,
179 					   enum mlxsw_sp_kvdl_entry_type type,
180 					   unsigned int entry_count,
181 					   unsigned int *p_alloc_size)
182 {
183 	struct mlxsw_sp1_kvdl *kvdl = priv;
184 	struct mlxsw_sp1_kvdl_part *part;
185 
186 	part = mlxsw_sp1_kvdl_alloc_size_part(kvdl, entry_count);
187 	if (IS_ERR(part))
188 		return PTR_ERR(part);
189 
190 	*p_alloc_size = part->info.alloc_size;
191 
192 	return 0;
193 }
194 
195 static void mlxsw_sp1_kvdl_part_update(struct mlxsw_sp1_kvdl_part *part,
196 				       struct mlxsw_sp1_kvdl_part *part_prev,
197 				       unsigned int size)
198 {
199 	if (!part_prev) {
200 		part->info.end_index = size - 1;
201 	} else {
202 		part->info.start_index = part_prev->info.end_index + 1;
203 		part->info.end_index = part->info.start_index + size - 1;
204 	}
205 }
206 
207 static struct mlxsw_sp1_kvdl_part *
208 mlxsw_sp1_kvdl_part_init(struct mlxsw_sp *mlxsw_sp,
209 			 const struct mlxsw_sp1_kvdl_part_info *info,
210 			 struct mlxsw_sp1_kvdl_part *part_prev)
211 {
212 	struct devlink *devlink = priv_to_devlink(mlxsw_sp->core);
213 	struct mlxsw_sp1_kvdl_part *part;
214 	bool need_update = true;
215 	unsigned int nr_entries;
216 	size_t usage_size;
217 	u64 resource_size;
218 	int err;
219 
220 	err = devlink_resource_size_get(devlink, info->resource_id,
221 					&resource_size);
222 	if (err) {
223 		need_update = false;
224 		resource_size = info->end_index - info->start_index + 1;
225 	}
226 
227 	nr_entries = div_u64(resource_size, info->alloc_size);
228 	usage_size = BITS_TO_LONGS(nr_entries) * sizeof(unsigned long);
229 	part = kzalloc(sizeof(*part) + usage_size, GFP_KERNEL);
230 	if (!part)
231 		return ERR_PTR(-ENOMEM);
232 
233 	memcpy(&part->info, info, sizeof(part->info));
234 
235 	if (need_update)
236 		mlxsw_sp1_kvdl_part_update(part, part_prev, resource_size);
237 	return part;
238 }
239 
240 static void mlxsw_sp1_kvdl_part_fini(struct mlxsw_sp1_kvdl_part *part)
241 {
242 	kfree(part);
243 }
244 
245 static int mlxsw_sp1_kvdl_parts_init(struct mlxsw_sp *mlxsw_sp,
246 				     struct mlxsw_sp1_kvdl *kvdl)
247 {
248 	const struct mlxsw_sp1_kvdl_part_info *info;
249 	struct mlxsw_sp1_kvdl_part *part_prev = NULL;
250 	int err, i;
251 
252 	for (i = 0; i < MLXSW_SP1_KVDL_PARTS_INFO_LEN; i++) {
253 		info = &mlxsw_sp1_kvdl_parts_info[i];
254 		kvdl->parts[i] = mlxsw_sp1_kvdl_part_init(mlxsw_sp, info,
255 							  part_prev);
256 		if (IS_ERR(kvdl->parts[i])) {
257 			err = PTR_ERR(kvdl->parts[i]);
258 			goto err_kvdl_part_init;
259 		}
260 		part_prev = kvdl->parts[i];
261 	}
262 	return 0;
263 
264 err_kvdl_part_init:
265 	for (i--; i >= 0; i--)
266 		mlxsw_sp1_kvdl_part_fini(kvdl->parts[i]);
267 	return err;
268 }
269 
270 static void mlxsw_sp1_kvdl_parts_fini(struct mlxsw_sp1_kvdl *kvdl)
271 {
272 	int i;
273 
274 	for (i = 0; i < MLXSW_SP1_KVDL_PARTS_INFO_LEN; i++)
275 		mlxsw_sp1_kvdl_part_fini(kvdl->parts[i]);
276 }
277 
278 static u64 mlxsw_sp1_kvdl_part_occ(struct mlxsw_sp1_kvdl_part *part)
279 {
280 	const struct mlxsw_sp1_kvdl_part_info *info = &part->info;
281 	unsigned int nr_entries;
282 	int bit = -1;
283 	u64 occ = 0;
284 
285 	nr_entries = (info->end_index -
286 		      info->start_index + 1) /
287 		      info->alloc_size;
288 	while ((bit = find_next_bit(part->usage, nr_entries, bit + 1))
289 		< nr_entries)
290 		occ += info->alloc_size;
291 	return occ;
292 }
293 
294 static u64 mlxsw_sp1_kvdl_occ_get(void *priv)
295 {
296 	const struct mlxsw_sp1_kvdl *kvdl = priv;
297 	u64 occ = 0;
298 	int i;
299 
300 	for (i = 0; i < MLXSW_SP1_KVDL_PARTS_INFO_LEN; i++)
301 		occ += mlxsw_sp1_kvdl_part_occ(kvdl->parts[i]);
302 
303 	return occ;
304 }
305 
306 static u64 mlxsw_sp1_kvdl_single_occ_get(void *priv)
307 {
308 	const struct mlxsw_sp1_kvdl *kvdl = priv;
309 	struct mlxsw_sp1_kvdl_part *part;
310 
311 	part = kvdl->parts[MLXSW_SP1_KVDL_PART_ID_SINGLE];
312 	return mlxsw_sp1_kvdl_part_occ(part);
313 }
314 
315 static u64 mlxsw_sp1_kvdl_chunks_occ_get(void *priv)
316 {
317 	const struct mlxsw_sp1_kvdl *kvdl = priv;
318 	struct mlxsw_sp1_kvdl_part *part;
319 
320 	part = kvdl->parts[MLXSW_SP1_KVDL_PART_ID_CHUNKS];
321 	return mlxsw_sp1_kvdl_part_occ(part);
322 }
323 
324 static u64 mlxsw_sp1_kvdl_large_chunks_occ_get(void *priv)
325 {
326 	const struct mlxsw_sp1_kvdl *kvdl = priv;
327 	struct mlxsw_sp1_kvdl_part *part;
328 
329 	part = kvdl->parts[MLXSW_SP1_KVDL_PART_ID_LARGE_CHUNKS];
330 	return mlxsw_sp1_kvdl_part_occ(part);
331 }
332 
333 static int mlxsw_sp1_kvdl_init(struct mlxsw_sp *mlxsw_sp, void *priv)
334 {
335 	struct devlink *devlink = priv_to_devlink(mlxsw_sp->core);
336 	struct mlxsw_sp1_kvdl *kvdl = priv;
337 	int err;
338 
339 	err = mlxsw_sp1_kvdl_parts_init(mlxsw_sp, kvdl);
340 	if (err)
341 		return err;
342 	devlink_resource_occ_get_register(devlink,
343 					  MLXSW_SP_RESOURCE_KVD_LINEAR,
344 					  mlxsw_sp1_kvdl_occ_get,
345 					  kvdl);
346 	devlink_resource_occ_get_register(devlink,
347 					  MLXSW_SP_RESOURCE_KVD_LINEAR_SINGLE,
348 					  mlxsw_sp1_kvdl_single_occ_get,
349 					  kvdl);
350 	devlink_resource_occ_get_register(devlink,
351 					  MLXSW_SP_RESOURCE_KVD_LINEAR_CHUNKS,
352 					  mlxsw_sp1_kvdl_chunks_occ_get,
353 					  kvdl);
354 	devlink_resource_occ_get_register(devlink,
355 					  MLXSW_SP_RESOURCE_KVD_LINEAR_LARGE_CHUNKS,
356 					  mlxsw_sp1_kvdl_large_chunks_occ_get,
357 					  kvdl);
358 	return 0;
359 }
360 
361 static void mlxsw_sp1_kvdl_fini(struct mlxsw_sp *mlxsw_sp, void *priv)
362 {
363 	struct devlink *devlink = priv_to_devlink(mlxsw_sp->core);
364 	struct mlxsw_sp1_kvdl *kvdl = priv;
365 
366 	devlink_resource_occ_get_unregister(devlink,
367 					    MLXSW_SP_RESOURCE_KVD_LINEAR_LARGE_CHUNKS);
368 	devlink_resource_occ_get_unregister(devlink,
369 					    MLXSW_SP_RESOURCE_KVD_LINEAR_CHUNKS);
370 	devlink_resource_occ_get_unregister(devlink,
371 					    MLXSW_SP_RESOURCE_KVD_LINEAR_SINGLE);
372 	devlink_resource_occ_get_unregister(devlink,
373 					    MLXSW_SP_RESOURCE_KVD_LINEAR);
374 	mlxsw_sp1_kvdl_parts_fini(kvdl);
375 }
376 
377 const struct mlxsw_sp_kvdl_ops mlxsw_sp1_kvdl_ops = {
378 	.priv_size = sizeof(struct mlxsw_sp1_kvdl),
379 	.init = mlxsw_sp1_kvdl_init,
380 	.fini = mlxsw_sp1_kvdl_fini,
381 	.alloc = mlxsw_sp1_kvdl_alloc,
382 	.free = mlxsw_sp1_kvdl_free,
383 	.alloc_size_query = mlxsw_sp1_kvdl_alloc_size_query,
384 };
385 
386 int mlxsw_sp1_kvdl_resources_register(struct mlxsw_core *mlxsw_core)
387 {
388 	struct devlink *devlink = priv_to_devlink(mlxsw_core);
389 	static struct devlink_resource_size_params size_params;
390 	u32 kvdl_max_size;
391 	int err;
392 
393 	kvdl_max_size = MLXSW_CORE_RES_GET(mlxsw_core, KVD_SIZE) -
394 			MLXSW_CORE_RES_GET(mlxsw_core, KVD_SINGLE_MIN_SIZE) -
395 			MLXSW_CORE_RES_GET(mlxsw_core, KVD_DOUBLE_MIN_SIZE);
396 
397 	devlink_resource_size_params_init(&size_params, 0, kvdl_max_size,
398 					  MLXSW_SP1_KVDL_SINGLE_ALLOC_SIZE,
399 					  DEVLINK_RESOURCE_UNIT_ENTRY);
400 	err = devlink_resource_register(devlink, MLXSW_SP_RESOURCE_NAME_KVD_LINEAR_SINGLES,
401 					MLXSW_SP1_KVDL_SINGLE_SIZE,
402 					MLXSW_SP_RESOURCE_KVD_LINEAR_SINGLE,
403 					MLXSW_SP_RESOURCE_KVD_LINEAR,
404 					&size_params);
405 	if (err)
406 		return err;
407 
408 	devlink_resource_size_params_init(&size_params, 0, kvdl_max_size,
409 					  MLXSW_SP1_KVDL_CHUNKS_ALLOC_SIZE,
410 					  DEVLINK_RESOURCE_UNIT_ENTRY);
411 	err = devlink_resource_register(devlink, MLXSW_SP_RESOURCE_NAME_KVD_LINEAR_CHUNKS,
412 					MLXSW_SP1_KVDL_CHUNKS_SIZE,
413 					MLXSW_SP_RESOURCE_KVD_LINEAR_CHUNKS,
414 					MLXSW_SP_RESOURCE_KVD_LINEAR,
415 					&size_params);
416 	if (err)
417 		return err;
418 
419 	devlink_resource_size_params_init(&size_params, 0, kvdl_max_size,
420 					  MLXSW_SP1_KVDL_LARGE_CHUNKS_ALLOC_SIZE,
421 					  DEVLINK_RESOURCE_UNIT_ENTRY);
422 	err = devlink_resource_register(devlink, MLXSW_SP_RESOURCE_NAME_KVD_LINEAR_LARGE_CHUNKS,
423 					MLXSW_SP1_KVDL_LARGE_CHUNKS_SIZE,
424 					MLXSW_SP_RESOURCE_KVD_LINEAR_LARGE_CHUNKS,
425 					MLXSW_SP_RESOURCE_KVD_LINEAR,
426 					&size_params);
427 	return err;
428 }
429