1 /* 2 * drivers/net/ethernet/mellanox/mlxsw/spectrum_kvdl.c 3 * Copyright (c) 2016 Mellanox Technologies. All rights reserved. 4 * Copyright (c) 2016 Jiri Pirko <jiri@mellanox.com> 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions are met: 8 * 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 3. Neither the names of the copyright holders nor the names of its 15 * contributors may be used to endorse or promote products derived from 16 * this software without specific prior written permission. 17 * 18 * Alternatively, this software may be distributed under the terms of the 19 * GNU General Public License ("GPL") version 2 as published by the Free 20 * Software Foundation. 21 * 22 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 23 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 24 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 25 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 26 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 27 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 28 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 29 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 30 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 31 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 32 * POSSIBILITY OF SUCH DAMAGE. 33 */ 34 35 #include <linux/kernel.h> 36 #include <linux/bitops.h> 37 38 #include "spectrum.h" 39 40 #define MLXSW_SP_KVDL_SINGLE_BASE 0 41 #define MLXSW_SP_KVDL_SINGLE_SIZE 16384 42 #define MLXSW_SP_KVDL_SINGLE_END \ 43 (MLXSW_SP_KVDL_SINGLE_SIZE + MLXSW_SP_KVDL_SINGLE_BASE - 1) 44 45 #define MLXSW_SP_KVDL_CHUNKS_BASE \ 46 (MLXSW_SP_KVDL_SINGLE_BASE + MLXSW_SP_KVDL_SINGLE_SIZE) 47 #define MLXSW_SP_KVDL_CHUNKS_SIZE 49152 48 #define MLXSW_SP_KVDL_CHUNKS_END \ 49 (MLXSW_SP_KVDL_CHUNKS_SIZE + MLXSW_SP_KVDL_CHUNKS_BASE - 1) 50 51 #define MLXSW_SP_KVDL_LARGE_CHUNKS_BASE \ 52 (MLXSW_SP_KVDL_CHUNKS_BASE + MLXSW_SP_KVDL_CHUNKS_SIZE) 53 #define MLXSW_SP_KVDL_LARGE_CHUNKS_SIZE \ 54 (MLXSW_SP_KVD_LINEAR_SIZE - MLXSW_SP_KVDL_LARGE_CHUNKS_BASE) 55 #define MLXSW_SP_KVDL_LARGE_CHUNKS_END \ 56 (MLXSW_SP_KVDL_LARGE_CHUNKS_SIZE + MLXSW_SP_KVDL_LARGE_CHUNKS_BASE - 1) 57 58 #define MLXSW_SP_CHUNK_MAX 32 59 #define MLXSW_SP_LARGE_CHUNK_MAX 512 60 61 struct mlxsw_sp_kvdl_part_info { 62 unsigned int part_index; 63 unsigned int start_index; 64 unsigned int end_index; 65 unsigned int alloc_size; 66 }; 67 68 struct mlxsw_sp_kvdl_part { 69 struct list_head list; 70 struct mlxsw_sp_kvdl_part_info *info; 71 unsigned long usage[0]; /* Entries */ 72 }; 73 74 struct mlxsw_sp_kvdl { 75 struct list_head parts_list; 76 }; 77 78 static struct mlxsw_sp_kvdl_part * 79 mlxsw_sp_kvdl_alloc_size_part(struct mlxsw_sp_kvdl *kvdl, 80 unsigned int alloc_size) 81 { 82 struct mlxsw_sp_kvdl_part *part, *min_part = NULL; 83 84 list_for_each_entry(part, &kvdl->parts_list, list) { 85 if (alloc_size <= part->info->alloc_size && 86 (!min_part || 87 part->info->alloc_size <= min_part->info->alloc_size)) 88 min_part = part; 89 } 90 91 return min_part ?: ERR_PTR(-ENOBUFS); 92 } 93 94 static struct mlxsw_sp_kvdl_part * 95 mlxsw_sp_kvdl_index_part(struct mlxsw_sp_kvdl *kvdl, u32 kvdl_index) 96 { 97 struct mlxsw_sp_kvdl_part *part; 98 99 list_for_each_entry(part, &kvdl->parts_list, list) { 100 if (kvdl_index >= part->info->start_index && 101 kvdl_index <= part->info->end_index) 102 return part; 103 } 104 105 return ERR_PTR(-EINVAL); 106 } 107 108 static u32 109 mlxsw_sp_entry_index_kvdl_index(const struct mlxsw_sp_kvdl_part_info *info, 110 unsigned int entry_index) 111 { 112 return info->start_index + entry_index * info->alloc_size; 113 } 114 115 static unsigned int 116 mlxsw_sp_kvdl_index_entry_index(const struct mlxsw_sp_kvdl_part_info *info, 117 u32 kvdl_index) 118 { 119 return (kvdl_index - info->start_index) / info->alloc_size; 120 } 121 122 static int mlxsw_sp_kvdl_part_alloc(struct mlxsw_sp_kvdl_part *part, 123 u32 *p_kvdl_index) 124 { 125 const struct mlxsw_sp_kvdl_part_info *info = part->info; 126 unsigned int entry_index, nr_entries; 127 128 nr_entries = (info->end_index - info->start_index + 1) / 129 info->alloc_size; 130 entry_index = find_first_zero_bit(part->usage, nr_entries); 131 if (entry_index == nr_entries) 132 return -ENOBUFS; 133 __set_bit(entry_index, part->usage); 134 135 *p_kvdl_index = mlxsw_sp_entry_index_kvdl_index(part->info, 136 entry_index); 137 138 return 0; 139 } 140 141 static void mlxsw_sp_kvdl_part_free(struct mlxsw_sp_kvdl_part *part, 142 u32 kvdl_index) 143 { 144 unsigned int entry_index; 145 146 entry_index = mlxsw_sp_kvdl_index_entry_index(part->info, 147 kvdl_index); 148 __clear_bit(entry_index, part->usage); 149 } 150 151 int mlxsw_sp_kvdl_alloc(struct mlxsw_sp *mlxsw_sp, unsigned int entry_count, 152 u32 *p_entry_index) 153 { 154 struct mlxsw_sp_kvdl_part *part; 155 156 /* Find partition with smallest allocation size satisfying the 157 * requested size. 158 */ 159 part = mlxsw_sp_kvdl_alloc_size_part(mlxsw_sp->kvdl, entry_count); 160 if (IS_ERR(part)) 161 return PTR_ERR(part); 162 163 return mlxsw_sp_kvdl_part_alloc(part, p_entry_index); 164 } 165 166 void mlxsw_sp_kvdl_free(struct mlxsw_sp *mlxsw_sp, int entry_index) 167 { 168 struct mlxsw_sp_kvdl_part *part; 169 170 part = mlxsw_sp_kvdl_index_part(mlxsw_sp->kvdl, entry_index); 171 if (IS_ERR(part)) 172 return; 173 mlxsw_sp_kvdl_part_free(part, entry_index); 174 } 175 176 int mlxsw_sp_kvdl_alloc_size_query(struct mlxsw_sp *mlxsw_sp, 177 unsigned int entry_count, 178 unsigned int *p_alloc_size) 179 { 180 struct mlxsw_sp_kvdl_part *part; 181 182 part = mlxsw_sp_kvdl_alloc_size_part(mlxsw_sp->kvdl, entry_count); 183 if (IS_ERR(part)) 184 return PTR_ERR(part); 185 186 *p_alloc_size = part->info->alloc_size; 187 188 return 0; 189 } 190 191 enum mlxsw_sp_kvdl_part_id { 192 MLXSW_SP_KVDL_PART_SINGLE, 193 MLXSW_SP_KVDL_PART_CHUNKS, 194 MLXSW_SP_KVDL_PART_LARGE_CHUNKS, 195 }; 196 197 static const struct mlxsw_sp_kvdl_part_info kvdl_parts_info[] = { 198 { 199 .part_index = MLXSW_SP_KVDL_PART_SINGLE, 200 .start_index = MLXSW_SP_KVDL_SINGLE_BASE, 201 .end_index = MLXSW_SP_KVDL_SINGLE_END, 202 .alloc_size = 1, 203 }, 204 { 205 .part_index = MLXSW_SP_KVDL_PART_CHUNKS, 206 .start_index = MLXSW_SP_KVDL_CHUNKS_BASE, 207 .end_index = MLXSW_SP_KVDL_CHUNKS_END, 208 .alloc_size = MLXSW_SP_CHUNK_MAX, 209 }, 210 { 211 .part_index = MLXSW_SP_KVDL_PART_LARGE_CHUNKS, 212 .start_index = MLXSW_SP_KVDL_LARGE_CHUNKS_BASE, 213 .end_index = MLXSW_SP_KVDL_LARGE_CHUNKS_END, 214 .alloc_size = MLXSW_SP_LARGE_CHUNK_MAX, 215 }, 216 }; 217 218 static struct mlxsw_sp_kvdl_part * 219 mlxsw_sp_kvdl_part_find(struct mlxsw_sp *mlxsw_sp, unsigned int part_index) 220 { 221 struct mlxsw_sp_kvdl_part *part; 222 223 list_for_each_entry(part, &mlxsw_sp->kvdl->parts_list, list) { 224 if (part->info->part_index == part_index) 225 return part; 226 } 227 228 return NULL; 229 } 230 231 static void 232 mlxsw_sp_kvdl_part_update(struct mlxsw_sp *mlxsw_sp, 233 struct mlxsw_sp_kvdl_part *part, unsigned int size) 234 { 235 struct mlxsw_sp_kvdl_part_info *info = part->info; 236 237 if (list_is_last(&part->list, &mlxsw_sp->kvdl->parts_list)) { 238 info->end_index = size - 1; 239 } else { 240 struct mlxsw_sp_kvdl_part *last_part; 241 242 last_part = list_next_entry(part, list); 243 info->start_index = last_part->info->end_index + 1; 244 info->end_index = info->start_index + size - 1; 245 } 246 } 247 248 static int mlxsw_sp_kvdl_part_init(struct mlxsw_sp *mlxsw_sp, 249 unsigned int part_index) 250 { 251 struct devlink *devlink = priv_to_devlink(mlxsw_sp->core); 252 const struct mlxsw_sp_kvdl_part_info *info; 253 enum mlxsw_sp_resource_id resource_id; 254 struct mlxsw_sp_kvdl_part *part; 255 bool need_update = true; 256 unsigned int nr_entries; 257 size_t usage_size; 258 u64 resource_size; 259 int err; 260 261 info = &kvdl_parts_info[part_index]; 262 263 switch (part_index) { 264 case MLXSW_SP_KVDL_PART_SINGLE: 265 resource_id = MLXSW_SP_RESOURCE_KVD_LINEAR_SINGLE; 266 break; 267 case MLXSW_SP_KVDL_PART_CHUNKS: 268 resource_id = MLXSW_SP_RESOURCE_KVD_LINEAR_CHUNKS; 269 break; 270 case MLXSW_SP_KVDL_PART_LARGE_CHUNKS: 271 resource_id = MLXSW_SP_RESOURCE_KVD_LINEAR_LARGE_CHUNKS; 272 break; 273 default: 274 return -EINVAL; 275 } 276 277 err = devlink_resource_size_get(devlink, resource_id, &resource_size); 278 if (err) { 279 need_update = false; 280 resource_size = info->end_index - info->start_index + 1; 281 } 282 283 nr_entries = div_u64(resource_size, info->alloc_size); 284 usage_size = BITS_TO_LONGS(nr_entries) * sizeof(unsigned long); 285 part = kzalloc(sizeof(*part) + usage_size, GFP_KERNEL); 286 if (!part) 287 return -ENOMEM; 288 289 part->info = kmemdup(info, sizeof(*part->info), GFP_KERNEL); 290 if (!part->info) 291 goto err_part_info_alloc; 292 293 list_add(&part->list, &mlxsw_sp->kvdl->parts_list); 294 if (need_update) 295 mlxsw_sp_kvdl_part_update(mlxsw_sp, part, resource_size); 296 return 0; 297 298 err_part_info_alloc: 299 kfree(part); 300 return -ENOMEM; 301 } 302 303 static void mlxsw_sp_kvdl_part_fini(struct mlxsw_sp *mlxsw_sp, 304 unsigned int part_index) 305 { 306 struct mlxsw_sp_kvdl_part *part; 307 308 part = mlxsw_sp_kvdl_part_find(mlxsw_sp, part_index); 309 if (!part) 310 return; 311 312 list_del(&part->list); 313 kfree(part->info); 314 kfree(part); 315 } 316 317 static int mlxsw_sp_kvdl_parts_init(struct mlxsw_sp *mlxsw_sp) 318 { 319 int err, i; 320 321 INIT_LIST_HEAD(&mlxsw_sp->kvdl->parts_list); 322 323 for (i = 0; i < ARRAY_SIZE(kvdl_parts_info); i++) { 324 err = mlxsw_sp_kvdl_part_init(mlxsw_sp, i); 325 if (err) 326 goto err_kvdl_part_init; 327 } 328 329 return 0; 330 331 err_kvdl_part_init: 332 for (i--; i >= 0; i--) 333 mlxsw_sp_kvdl_part_fini(mlxsw_sp, i); 334 return err; 335 } 336 337 static void mlxsw_sp_kvdl_parts_fini(struct mlxsw_sp *mlxsw_sp) 338 { 339 int i; 340 341 for (i = ARRAY_SIZE(kvdl_parts_info) - 1; i >= 0; i--) 342 mlxsw_sp_kvdl_part_fini(mlxsw_sp, i); 343 } 344 345 static u64 mlxsw_sp_kvdl_part_occ(struct mlxsw_sp_kvdl_part *part) 346 { 347 unsigned int nr_entries; 348 int bit = -1; 349 u64 occ = 0; 350 351 nr_entries = (part->info->end_index - 352 part->info->start_index + 1) / 353 part->info->alloc_size; 354 while ((bit = find_next_bit(part->usage, nr_entries, bit + 1)) 355 < nr_entries) 356 occ += part->info->alloc_size; 357 return occ; 358 } 359 360 u64 mlxsw_sp_kvdl_occ_get(const struct mlxsw_sp *mlxsw_sp) 361 { 362 struct mlxsw_sp_kvdl_part *part; 363 u64 occ = 0; 364 365 list_for_each_entry(part, &mlxsw_sp->kvdl->parts_list, list) 366 occ += mlxsw_sp_kvdl_part_occ(part); 367 368 return occ; 369 } 370 371 u64 mlxsw_sp_kvdl_single_occ_get(struct devlink *devlink) 372 { 373 struct mlxsw_core *mlxsw_core = devlink_priv(devlink); 374 struct mlxsw_sp *mlxsw_sp = mlxsw_core_driver_priv(mlxsw_core); 375 struct mlxsw_sp_kvdl_part *part; 376 377 part = mlxsw_sp_kvdl_part_find(mlxsw_sp, MLXSW_SP_KVDL_PART_SINGLE); 378 if (!part) 379 return -EINVAL; 380 381 return mlxsw_sp_kvdl_part_occ(part); 382 } 383 384 u64 mlxsw_sp_kvdl_chunks_occ_get(struct devlink *devlink) 385 { 386 struct mlxsw_core *mlxsw_core = devlink_priv(devlink); 387 struct mlxsw_sp *mlxsw_sp = mlxsw_core_driver_priv(mlxsw_core); 388 struct mlxsw_sp_kvdl_part *part; 389 390 part = mlxsw_sp_kvdl_part_find(mlxsw_sp, MLXSW_SP_KVDL_PART_CHUNKS); 391 if (!part) 392 return -EINVAL; 393 394 return mlxsw_sp_kvdl_part_occ(part); 395 } 396 397 u64 mlxsw_sp_kvdl_large_chunks_occ_get(struct devlink *devlink) 398 { 399 struct mlxsw_core *mlxsw_core = devlink_priv(devlink); 400 struct mlxsw_sp *mlxsw_sp = mlxsw_core_driver_priv(mlxsw_core); 401 struct mlxsw_sp_kvdl_part *part; 402 403 part = mlxsw_sp_kvdl_part_find(mlxsw_sp, 404 MLXSW_SP_KVDL_PART_LARGE_CHUNKS); 405 if (!part) 406 return -EINVAL; 407 408 return mlxsw_sp_kvdl_part_occ(part); 409 } 410 411 static struct devlink_resource_ops mlxsw_sp_kvdl_single_ops = { 412 .occ_get = mlxsw_sp_kvdl_single_occ_get, 413 }; 414 415 static struct devlink_resource_ops mlxsw_sp_kvdl_chunks_ops = { 416 .occ_get = mlxsw_sp_kvdl_chunks_occ_get, 417 }; 418 419 static struct devlink_resource_ops mlxsw_sp_kvdl_chunks_large_ops = { 420 .occ_get = mlxsw_sp_kvdl_large_chunks_occ_get, 421 }; 422 423 static struct devlink_resource_size_params mlxsw_sp_kvdl_single_size_params = { 424 .size_min = 0, 425 .size_granularity = 1, 426 .unit = DEVLINK_RESOURCE_UNIT_ENTRY, 427 }; 428 429 static struct devlink_resource_size_params mlxsw_sp_kvdl_chunks_size_params = { 430 .size_min = 0, 431 .size_granularity = MLXSW_SP_CHUNK_MAX, 432 .unit = DEVLINK_RESOURCE_UNIT_ENTRY, 433 }; 434 435 static struct devlink_resource_size_params mlxsw_sp_kvdl_large_chunks_size_params = { 436 .size_min = 0, 437 .size_granularity = MLXSW_SP_LARGE_CHUNK_MAX, 438 .unit = DEVLINK_RESOURCE_UNIT_ENTRY, 439 }; 440 441 static void 442 mlxsw_sp_kvdl_resource_size_params_prepare(struct devlink *devlink) 443 { 444 struct mlxsw_core *mlxsw_core = devlink_priv(devlink); 445 u32 kvdl_max_size; 446 447 kvdl_max_size = MLXSW_CORE_RES_GET(mlxsw_core, KVD_SIZE) - 448 MLXSW_CORE_RES_GET(mlxsw_core, KVD_SINGLE_MIN_SIZE) - 449 MLXSW_CORE_RES_GET(mlxsw_core, KVD_DOUBLE_MIN_SIZE); 450 451 mlxsw_sp_kvdl_single_size_params.size_max = kvdl_max_size; 452 mlxsw_sp_kvdl_chunks_size_params.size_max = kvdl_max_size; 453 mlxsw_sp_kvdl_large_chunks_size_params.size_max = kvdl_max_size; 454 } 455 456 int mlxsw_sp_kvdl_resources_register(struct devlink *devlink) 457 { 458 int err; 459 460 mlxsw_sp_kvdl_resource_size_params_prepare(devlink); 461 err = devlink_resource_register(devlink, MLXSW_SP_RESOURCE_NAME_KVD_LINEAR_SINGLES, 462 false, MLXSW_SP_KVDL_SINGLE_SIZE, 463 MLXSW_SP_RESOURCE_KVD_LINEAR_SINGLE, 464 MLXSW_SP_RESOURCE_KVD_LINEAR, 465 &mlxsw_sp_kvdl_single_size_params, 466 &mlxsw_sp_kvdl_single_ops); 467 if (err) 468 return err; 469 470 err = devlink_resource_register(devlink, MLXSW_SP_RESOURCE_NAME_KVD_LINEAR_CHUNKS, 471 false, MLXSW_SP_KVDL_CHUNKS_SIZE, 472 MLXSW_SP_RESOURCE_KVD_LINEAR_CHUNKS, 473 MLXSW_SP_RESOURCE_KVD_LINEAR, 474 &mlxsw_sp_kvdl_chunks_size_params, 475 &mlxsw_sp_kvdl_chunks_ops); 476 if (err) 477 return err; 478 479 err = devlink_resource_register(devlink, MLXSW_SP_RESOURCE_NAME_KVD_LINEAR_LARGE_CHUNKS, 480 false, MLXSW_SP_KVDL_LARGE_CHUNKS_SIZE, 481 MLXSW_SP_RESOURCE_KVD_LINEAR_LARGE_CHUNKS, 482 MLXSW_SP_RESOURCE_KVD_LINEAR, 483 &mlxsw_sp_kvdl_large_chunks_size_params, 484 &mlxsw_sp_kvdl_chunks_large_ops); 485 return err; 486 } 487 488 int mlxsw_sp_kvdl_init(struct mlxsw_sp *mlxsw_sp) 489 { 490 struct mlxsw_sp_kvdl *kvdl; 491 int err; 492 493 kvdl = kzalloc(sizeof(*mlxsw_sp->kvdl), GFP_KERNEL); 494 if (!kvdl) 495 return -ENOMEM; 496 mlxsw_sp->kvdl = kvdl; 497 498 err = mlxsw_sp_kvdl_parts_init(mlxsw_sp); 499 if (err) 500 goto err_kvdl_parts_init; 501 502 return 0; 503 504 err_kvdl_parts_init: 505 kfree(mlxsw_sp->kvdl); 506 return err; 507 } 508 509 void mlxsw_sp_kvdl_fini(struct mlxsw_sp *mlxsw_sp) 510 { 511 mlxsw_sp_kvdl_parts_fini(mlxsw_sp); 512 kfree(mlxsw_sp->kvdl); 513 } 514