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
7 #include "spectrum_cnt.h"
8
9 #define MLXSW_SP_COUNTER_POOL_BANK_SIZE 4096
10
11 struct mlxsw_sp_counter_sub_pool {
12 unsigned int base_index;
13 unsigned int size;
14 unsigned int entry_size;
15 unsigned int bank_count;
16 };
17
18 struct mlxsw_sp_counter_pool {
19 unsigned int pool_size;
20 unsigned long *usage; /* Usage bitmap */
21 struct mlxsw_sp_counter_sub_pool *sub_pools;
22 };
23
24 static struct mlxsw_sp_counter_sub_pool mlxsw_sp_counter_sub_pools[] = {
25 [MLXSW_SP_COUNTER_SUB_POOL_FLOW] = {
26 .bank_count = 6,
27 },
28 [MLXSW_SP_COUNTER_SUB_POOL_RIF] = {
29 .bank_count = 2,
30 }
31 };
32
mlxsw_sp_counter_pool_validate(struct mlxsw_sp * mlxsw_sp)33 static int mlxsw_sp_counter_pool_validate(struct mlxsw_sp *mlxsw_sp)
34 {
35 unsigned int total_bank_config = 0;
36 unsigned int pool_size;
37 int i;
38
39 pool_size = MLXSW_CORE_RES_GET(mlxsw_sp->core, COUNTER_POOL_SIZE);
40 /* Check config is valid, no bank over subscription */
41 for (i = 0; i < ARRAY_SIZE(mlxsw_sp_counter_sub_pools); i++)
42 total_bank_config += mlxsw_sp_counter_sub_pools[i].bank_count;
43 if (total_bank_config > pool_size / MLXSW_SP_COUNTER_POOL_BANK_SIZE + 1)
44 return -EINVAL;
45 return 0;
46 }
47
mlxsw_sp_counter_sub_pools_prepare(struct mlxsw_sp * mlxsw_sp)48 static int mlxsw_sp_counter_sub_pools_prepare(struct mlxsw_sp *mlxsw_sp)
49 {
50 struct mlxsw_sp_counter_sub_pool *sub_pool;
51
52 /* Prepare generic flow pool*/
53 sub_pool = &mlxsw_sp_counter_sub_pools[MLXSW_SP_COUNTER_SUB_POOL_FLOW];
54 if (!MLXSW_CORE_RES_VALID(mlxsw_sp->core, COUNTER_SIZE_PACKETS_BYTES))
55 return -EIO;
56 sub_pool->entry_size = MLXSW_CORE_RES_GET(mlxsw_sp->core,
57 COUNTER_SIZE_PACKETS_BYTES);
58 /* Prepare erif pool*/
59 sub_pool = &mlxsw_sp_counter_sub_pools[MLXSW_SP_COUNTER_SUB_POOL_RIF];
60 if (!MLXSW_CORE_RES_VALID(mlxsw_sp->core, COUNTER_SIZE_ROUTER_BASIC))
61 return -EIO;
62 sub_pool->entry_size = MLXSW_CORE_RES_GET(mlxsw_sp->core,
63 COUNTER_SIZE_ROUTER_BASIC);
64 return 0;
65 }
66
mlxsw_sp_counter_pool_init(struct mlxsw_sp * mlxsw_sp)67 int mlxsw_sp_counter_pool_init(struct mlxsw_sp *mlxsw_sp)
68 {
69 struct mlxsw_sp_counter_sub_pool *sub_pool;
70 struct mlxsw_sp_counter_pool *pool;
71 unsigned int base_index;
72 unsigned int map_size;
73 int i;
74 int err;
75
76 if (!MLXSW_CORE_RES_VALID(mlxsw_sp->core, COUNTER_POOL_SIZE))
77 return -EIO;
78
79 err = mlxsw_sp_counter_pool_validate(mlxsw_sp);
80 if (err)
81 return err;
82
83 err = mlxsw_sp_counter_sub_pools_prepare(mlxsw_sp);
84 if (err)
85 return err;
86
87 pool = kzalloc(sizeof(*pool), GFP_KERNEL);
88 if (!pool)
89 return -ENOMEM;
90
91 pool->pool_size = MLXSW_CORE_RES_GET(mlxsw_sp->core, COUNTER_POOL_SIZE);
92 map_size = BITS_TO_LONGS(pool->pool_size) * sizeof(unsigned long);
93
94 pool->usage = kzalloc(map_size, GFP_KERNEL);
95 if (!pool->usage) {
96 err = -ENOMEM;
97 goto err_usage_alloc;
98 }
99
100 pool->sub_pools = mlxsw_sp_counter_sub_pools;
101 /* Allocation is based on bank count which should be
102 * specified for each sub pool statically.
103 */
104 base_index = 0;
105 for (i = 0; i < ARRAY_SIZE(mlxsw_sp_counter_sub_pools); i++) {
106 sub_pool = &pool->sub_pools[i];
107 sub_pool->size = sub_pool->bank_count *
108 MLXSW_SP_COUNTER_POOL_BANK_SIZE;
109 sub_pool->base_index = base_index;
110 base_index += sub_pool->size;
111 /* The last bank can't be fully used */
112 if (sub_pool->base_index + sub_pool->size > pool->pool_size)
113 sub_pool->size = pool->pool_size - sub_pool->base_index;
114 }
115
116 mlxsw_sp->counter_pool = pool;
117 return 0;
118
119 err_usage_alloc:
120 kfree(pool);
121 return err;
122 }
123
mlxsw_sp_counter_pool_fini(struct mlxsw_sp * mlxsw_sp)124 void mlxsw_sp_counter_pool_fini(struct mlxsw_sp *mlxsw_sp)
125 {
126 struct mlxsw_sp_counter_pool *pool = mlxsw_sp->counter_pool;
127
128 WARN_ON(find_first_bit(pool->usage, pool->pool_size) !=
129 pool->pool_size);
130 kfree(pool->usage);
131 kfree(pool);
132 }
133
mlxsw_sp_counter_alloc(struct mlxsw_sp * mlxsw_sp,enum mlxsw_sp_counter_sub_pool_id sub_pool_id,unsigned int * p_counter_index)134 int mlxsw_sp_counter_alloc(struct mlxsw_sp *mlxsw_sp,
135 enum mlxsw_sp_counter_sub_pool_id sub_pool_id,
136 unsigned int *p_counter_index)
137 {
138 struct mlxsw_sp_counter_pool *pool = mlxsw_sp->counter_pool;
139 struct mlxsw_sp_counter_sub_pool *sub_pool;
140 unsigned int entry_index;
141 unsigned int stop_index;
142 int i;
143
144 sub_pool = &mlxsw_sp_counter_sub_pools[sub_pool_id];
145 stop_index = sub_pool->base_index + sub_pool->size;
146 entry_index = sub_pool->base_index;
147
148 entry_index = find_next_zero_bit(pool->usage, stop_index, entry_index);
149 if (entry_index == stop_index)
150 return -ENOBUFS;
151 /* The sub-pools can contain non-integer number of entries
152 * so we must check for overflow
153 */
154 if (entry_index + sub_pool->entry_size > stop_index)
155 return -ENOBUFS;
156 for (i = 0; i < sub_pool->entry_size; i++)
157 __set_bit(entry_index + i, pool->usage);
158
159 *p_counter_index = entry_index;
160 return 0;
161 }
162
mlxsw_sp_counter_free(struct mlxsw_sp * mlxsw_sp,enum mlxsw_sp_counter_sub_pool_id sub_pool_id,unsigned int counter_index)163 void mlxsw_sp_counter_free(struct mlxsw_sp *mlxsw_sp,
164 enum mlxsw_sp_counter_sub_pool_id sub_pool_id,
165 unsigned int counter_index)
166 {
167 struct mlxsw_sp_counter_pool *pool = mlxsw_sp->counter_pool;
168 struct mlxsw_sp_counter_sub_pool *sub_pool;
169 int i;
170
171 if (WARN_ON(counter_index >= pool->pool_size))
172 return;
173 sub_pool = &mlxsw_sp_counter_sub_pools[sub_pool_id];
174 for (i = 0; i < sub_pool->entry_size; i++)
175 __clear_bit(counter_index + i, pool->usage);
176 }
177