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 #include "core.h"
9 #include "reg.h"
10 #include "resources.h"
11
12 struct mlxsw_sp2_kvdl_part_info {
13 u8 res_type;
14 /* For each defined partititon we need to know how many
15 * usage bits we need and how many indexes there are
16 * represented by a single bit. This could be got from FW
17 * querying appropriate resources. So have the resource
18 * ids for for this purpose in partition definition.
19 */
20 enum mlxsw_res_id usage_bit_count_res_id;
21 enum mlxsw_res_id index_range_res_id;
22 };
23
24 #define MLXSW_SP2_KVDL_PART_INFO(_entry_type, _res_type, \
25 _usage_bit_count_res_id, _index_range_res_id) \
26 [MLXSW_SP_KVDL_ENTRY_TYPE_##_entry_type] = { \
27 .res_type = _res_type, \
28 .usage_bit_count_res_id = MLXSW_RES_ID_##_usage_bit_count_res_id, \
29 .index_range_res_id = MLXSW_RES_ID_##_index_range_res_id, \
30 }
31
32 static const struct mlxsw_sp2_kvdl_part_info mlxsw_sp2_kvdl_parts_info[] = {
33 MLXSW_SP2_KVDL_PART_INFO(ADJ, 0x21, KVD_SIZE, MAX_KVD_LINEAR_RANGE),
34 MLXSW_SP2_KVDL_PART_INFO(ACTSET, 0x23, MAX_KVD_ACTION_SETS,
35 MAX_KVD_ACTION_SETS),
36 MLXSW_SP2_KVDL_PART_INFO(PBS, 0x24, KVD_SIZE, KVD_SIZE),
37 MLXSW_SP2_KVDL_PART_INFO(MCRIGR, 0x26, KVD_SIZE, KVD_SIZE),
38 MLXSW_SP2_KVDL_PART_INFO(TNUMT, 0x29, KVD_SIZE, KVD_SIZE),
39 };
40
41 #define MLXSW_SP2_KVDL_PARTS_INFO_LEN ARRAY_SIZE(mlxsw_sp2_kvdl_parts_info)
42
43 struct mlxsw_sp2_kvdl_part {
44 const struct mlxsw_sp2_kvdl_part_info *info;
45 unsigned int usage_bit_count;
46 unsigned int indexes_per_usage_bit;
47 unsigned int last_allocated_bit;
48 unsigned long usage[]; /* Usage bits */
49 };
50
51 struct mlxsw_sp2_kvdl {
52 struct mlxsw_sp2_kvdl_part *parts[MLXSW_SP2_KVDL_PARTS_INFO_LEN];
53 };
54
mlxsw_sp2_kvdl_part_find_zero_bits(struct mlxsw_sp2_kvdl_part * part,unsigned int bit_count,unsigned int * p_bit)55 static int mlxsw_sp2_kvdl_part_find_zero_bits(struct mlxsw_sp2_kvdl_part *part,
56 unsigned int bit_count,
57 unsigned int *p_bit)
58 {
59 unsigned int start_bit;
60 unsigned int bit;
61 unsigned int i;
62 bool wrap = false;
63
64 start_bit = part->last_allocated_bit + 1;
65 if (start_bit == part->usage_bit_count)
66 start_bit = 0;
67 bit = start_bit;
68 again:
69 bit = find_next_zero_bit(part->usage, part->usage_bit_count, bit);
70 if (!wrap && bit + bit_count >= part->usage_bit_count) {
71 wrap = true;
72 bit = 0;
73 goto again;
74 }
75 if (wrap && bit + bit_count >= start_bit)
76 return -ENOBUFS;
77 for (i = 0; i < bit_count; i++) {
78 if (test_bit(bit + i, part->usage)) {
79 bit += bit_count;
80 goto again;
81 }
82 }
83 *p_bit = bit;
84 return 0;
85 }
86
mlxsw_sp2_kvdl_part_alloc(struct mlxsw_sp2_kvdl_part * part,unsigned int size,u32 * p_kvdl_index)87 static int mlxsw_sp2_kvdl_part_alloc(struct mlxsw_sp2_kvdl_part *part,
88 unsigned int size,
89 u32 *p_kvdl_index)
90 {
91 unsigned int bit_count;
92 unsigned int bit;
93 unsigned int i;
94 int err;
95
96 bit_count = DIV_ROUND_UP(size, part->indexes_per_usage_bit);
97 err = mlxsw_sp2_kvdl_part_find_zero_bits(part, bit_count, &bit);
98 if (err)
99 return err;
100 for (i = 0; i < bit_count; i++)
101 __set_bit(bit + i, part->usage);
102 *p_kvdl_index = bit * part->indexes_per_usage_bit;
103 return 0;
104 }
105
mlxsw_sp2_kvdl_rec_del(struct mlxsw_sp * mlxsw_sp,u8 res_type,u16 size,u32 kvdl_index)106 static int mlxsw_sp2_kvdl_rec_del(struct mlxsw_sp *mlxsw_sp, u8 res_type,
107 u16 size, u32 kvdl_index)
108 {
109 char *iedr_pl;
110 int err;
111
112 iedr_pl = kmalloc(MLXSW_REG_IEDR_LEN, GFP_KERNEL);
113 if (!iedr_pl)
114 return -ENOMEM;
115
116 mlxsw_reg_iedr_pack(iedr_pl);
117 mlxsw_reg_iedr_rec_pack(iedr_pl, 0, res_type, size, kvdl_index);
118 err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(iedr), iedr_pl);
119 kfree(iedr_pl);
120 return err;
121 }
122
mlxsw_sp2_kvdl_part_free(struct mlxsw_sp * mlxsw_sp,struct mlxsw_sp2_kvdl_part * part,unsigned int size,u32 kvdl_index)123 static void mlxsw_sp2_kvdl_part_free(struct mlxsw_sp *mlxsw_sp,
124 struct mlxsw_sp2_kvdl_part *part,
125 unsigned int size, u32 kvdl_index)
126 {
127 unsigned int bit_count;
128 unsigned int bit;
129 unsigned int i;
130 int err;
131
132 /* We need to ask FW to delete previously used KVD linear index */
133 err = mlxsw_sp2_kvdl_rec_del(mlxsw_sp, part->info->res_type,
134 size, kvdl_index);
135 if (err)
136 return;
137
138 bit_count = DIV_ROUND_UP(size, part->indexes_per_usage_bit);
139 bit = kvdl_index / part->indexes_per_usage_bit;
140 for (i = 0; i < bit_count; i++)
141 __clear_bit(bit + i, part->usage);
142 }
143
mlxsw_sp2_kvdl_alloc(struct mlxsw_sp * mlxsw_sp,void * priv,enum mlxsw_sp_kvdl_entry_type type,unsigned int entry_count,u32 * p_entry_index)144 static int mlxsw_sp2_kvdl_alloc(struct mlxsw_sp *mlxsw_sp, void *priv,
145 enum mlxsw_sp_kvdl_entry_type type,
146 unsigned int entry_count,
147 u32 *p_entry_index)
148 {
149 unsigned int size = entry_count * mlxsw_sp_kvdl_entry_size(type);
150 struct mlxsw_sp2_kvdl *kvdl = priv;
151 struct mlxsw_sp2_kvdl_part *part = kvdl->parts[type];
152
153 return mlxsw_sp2_kvdl_part_alloc(part, size, p_entry_index);
154 }
155
mlxsw_sp2_kvdl_free(struct mlxsw_sp * mlxsw_sp,void * priv,enum mlxsw_sp_kvdl_entry_type type,unsigned int entry_count,int entry_index)156 static void mlxsw_sp2_kvdl_free(struct mlxsw_sp *mlxsw_sp, void *priv,
157 enum mlxsw_sp_kvdl_entry_type type,
158 unsigned int entry_count,
159 int entry_index)
160 {
161 unsigned int size = entry_count * mlxsw_sp_kvdl_entry_size(type);
162 struct mlxsw_sp2_kvdl *kvdl = priv;
163 struct mlxsw_sp2_kvdl_part *part = kvdl->parts[type];
164
165 return mlxsw_sp2_kvdl_part_free(mlxsw_sp, part, size, entry_index);
166 }
167
mlxsw_sp2_kvdl_alloc_size_query(struct mlxsw_sp * mlxsw_sp,void * priv,enum mlxsw_sp_kvdl_entry_type type,unsigned int entry_count,unsigned int * p_alloc_count)168 static int mlxsw_sp2_kvdl_alloc_size_query(struct mlxsw_sp *mlxsw_sp,
169 void *priv,
170 enum mlxsw_sp_kvdl_entry_type type,
171 unsigned int entry_count,
172 unsigned int *p_alloc_count)
173 {
174 *p_alloc_count = entry_count;
175 return 0;
176 }
177
178 static struct mlxsw_sp2_kvdl_part *
mlxsw_sp2_kvdl_part_init(struct mlxsw_sp * mlxsw_sp,const struct mlxsw_sp2_kvdl_part_info * info)179 mlxsw_sp2_kvdl_part_init(struct mlxsw_sp *mlxsw_sp,
180 const struct mlxsw_sp2_kvdl_part_info *info)
181 {
182 unsigned int indexes_per_usage_bit;
183 struct mlxsw_sp2_kvdl_part *part;
184 unsigned int index_range;
185 unsigned int usage_bit_count;
186 size_t usage_size;
187
188 if (!mlxsw_core_res_valid(mlxsw_sp->core,
189 info->usage_bit_count_res_id) ||
190 !mlxsw_core_res_valid(mlxsw_sp->core,
191 info->index_range_res_id))
192 return ERR_PTR(-EIO);
193 usage_bit_count = mlxsw_core_res_get(mlxsw_sp->core,
194 info->usage_bit_count_res_id);
195 index_range = mlxsw_core_res_get(mlxsw_sp->core,
196 info->index_range_res_id);
197
198 /* For some partitions, one usage bit represents a group of indexes.
199 * That's why we compute the number of indexes per usage bit here,
200 * according to queried resources.
201 */
202 indexes_per_usage_bit = index_range / usage_bit_count;
203
204 usage_size = BITS_TO_LONGS(usage_bit_count) * sizeof(unsigned long);
205 part = kzalloc(sizeof(*part) + usage_size, GFP_KERNEL);
206 if (!part)
207 return ERR_PTR(-ENOMEM);
208 part->info = info;
209 part->usage_bit_count = usage_bit_count;
210 part->indexes_per_usage_bit = indexes_per_usage_bit;
211 part->last_allocated_bit = usage_bit_count - 1;
212 return part;
213 }
214
mlxsw_sp2_kvdl_part_fini(struct mlxsw_sp2_kvdl_part * part)215 static void mlxsw_sp2_kvdl_part_fini(struct mlxsw_sp2_kvdl_part *part)
216 {
217 kfree(part);
218 }
219
mlxsw_sp2_kvdl_parts_init(struct mlxsw_sp * mlxsw_sp,struct mlxsw_sp2_kvdl * kvdl)220 static int mlxsw_sp2_kvdl_parts_init(struct mlxsw_sp *mlxsw_sp,
221 struct mlxsw_sp2_kvdl *kvdl)
222 {
223 const struct mlxsw_sp2_kvdl_part_info *info;
224 int i;
225 int err;
226
227 for (i = 0; i < MLXSW_SP2_KVDL_PARTS_INFO_LEN; i++) {
228 info = &mlxsw_sp2_kvdl_parts_info[i];
229 kvdl->parts[i] = mlxsw_sp2_kvdl_part_init(mlxsw_sp, info);
230 if (IS_ERR(kvdl->parts[i])) {
231 err = PTR_ERR(kvdl->parts[i]);
232 goto err_kvdl_part_init;
233 }
234 }
235 return 0;
236
237 err_kvdl_part_init:
238 for (i--; i >= 0; i--)
239 mlxsw_sp2_kvdl_part_fini(kvdl->parts[i]);
240 return err;
241 }
242
mlxsw_sp2_kvdl_parts_fini(struct mlxsw_sp2_kvdl * kvdl)243 static void mlxsw_sp2_kvdl_parts_fini(struct mlxsw_sp2_kvdl *kvdl)
244 {
245 int i;
246
247 for (i = 0; i < MLXSW_SP2_KVDL_PARTS_INFO_LEN; i++)
248 mlxsw_sp2_kvdl_part_fini(kvdl->parts[i]);
249 }
250
mlxsw_sp2_kvdl_init(struct mlxsw_sp * mlxsw_sp,void * priv)251 static int mlxsw_sp2_kvdl_init(struct mlxsw_sp *mlxsw_sp, void *priv)
252 {
253 struct mlxsw_sp2_kvdl *kvdl = priv;
254
255 return mlxsw_sp2_kvdl_parts_init(mlxsw_sp, kvdl);
256 }
257
mlxsw_sp2_kvdl_fini(struct mlxsw_sp * mlxsw_sp,void * priv)258 static void mlxsw_sp2_kvdl_fini(struct mlxsw_sp *mlxsw_sp, void *priv)
259 {
260 struct mlxsw_sp2_kvdl *kvdl = priv;
261
262 mlxsw_sp2_kvdl_parts_fini(kvdl);
263 }
264
265 const struct mlxsw_sp_kvdl_ops mlxsw_sp2_kvdl_ops = {
266 .priv_size = sizeof(struct mlxsw_sp2_kvdl),
267 .init = mlxsw_sp2_kvdl_init,
268 .fini = mlxsw_sp2_kvdl_fini,
269 .alloc = mlxsw_sp2_kvdl_alloc,
270 .free = mlxsw_sp2_kvdl_free,
271 .alloc_size_query = mlxsw_sp2_kvdl_alloc_size_query,
272 };
273