1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * DSA devlink handling
4 */
5
6 #include <net/dsa.h>
7 #include <net/devlink.h>
8
9 #include "devlink.h"
10
11 static int dsa_devlink_info_get(struct devlink *dl,
12 struct devlink_info_req *req,
13 struct netlink_ext_ack *extack)
14 {
15 struct dsa_switch *ds = dsa_devlink_to_ds(dl);
16
17 if (ds->ops->devlink_info_get)
18 return ds->ops->devlink_info_get(ds, req, extack);
19
20 return -EOPNOTSUPP;
21 }
22
23 static int dsa_devlink_sb_pool_get(struct devlink *dl,
24 unsigned int sb_index, u16 pool_index,
25 struct devlink_sb_pool_info *pool_info)
26 {
27 struct dsa_switch *ds = dsa_devlink_to_ds(dl);
28
29 if (!ds->ops->devlink_sb_pool_get)
30 return -EOPNOTSUPP;
31
32 return ds->ops->devlink_sb_pool_get(ds, sb_index, pool_index,
33 pool_info);
34 }
35
36 static int dsa_devlink_sb_pool_set(struct devlink *dl, unsigned int sb_index,
37 u16 pool_index, u32 size,
38 enum devlink_sb_threshold_type threshold_type,
39 struct netlink_ext_ack *extack)
40 {
41 struct dsa_switch *ds = dsa_devlink_to_ds(dl);
42
43 if (!ds->ops->devlink_sb_pool_set)
44 return -EOPNOTSUPP;
45
46 return ds->ops->devlink_sb_pool_set(ds, sb_index, pool_index, size,
47 threshold_type, extack);
48 }
49
50 static int dsa_devlink_sb_port_pool_get(struct devlink_port *dlp,
51 unsigned int sb_index, u16 pool_index,
52 u32 *p_threshold)
53 {
54 struct dsa_switch *ds = dsa_devlink_port_to_ds(dlp);
55 int port = dsa_devlink_port_to_port(dlp);
56
57 if (!ds->ops->devlink_sb_port_pool_get)
58 return -EOPNOTSUPP;
59
60 return ds->ops->devlink_sb_port_pool_get(ds, port, sb_index,
61 pool_index, p_threshold);
62 }
63
64 static int dsa_devlink_sb_port_pool_set(struct devlink_port *dlp,
65 unsigned int sb_index, u16 pool_index,
66 u32 threshold,
67 struct netlink_ext_ack *extack)
68 {
69 struct dsa_switch *ds = dsa_devlink_port_to_ds(dlp);
70 int port = dsa_devlink_port_to_port(dlp);
71
72 if (!ds->ops->devlink_sb_port_pool_set)
73 return -EOPNOTSUPP;
74
75 return ds->ops->devlink_sb_port_pool_set(ds, port, sb_index,
76 pool_index, threshold, extack);
77 }
78
79 static int
80 dsa_devlink_sb_tc_pool_bind_get(struct devlink_port *dlp,
81 unsigned int sb_index, u16 tc_index,
82 enum devlink_sb_pool_type pool_type,
83 u16 *p_pool_index, u32 *p_threshold)
84 {
85 struct dsa_switch *ds = dsa_devlink_port_to_ds(dlp);
86 int port = dsa_devlink_port_to_port(dlp);
87
88 if (!ds->ops->devlink_sb_tc_pool_bind_get)
89 return -EOPNOTSUPP;
90
91 return ds->ops->devlink_sb_tc_pool_bind_get(ds, port, sb_index,
92 tc_index, pool_type,
93 p_pool_index, p_threshold);
94 }
95
96 static int
97 dsa_devlink_sb_tc_pool_bind_set(struct devlink_port *dlp,
98 unsigned int sb_index, u16 tc_index,
99 enum devlink_sb_pool_type pool_type,
100 u16 pool_index, u32 threshold,
101 struct netlink_ext_ack *extack)
102 {
103 struct dsa_switch *ds = dsa_devlink_port_to_ds(dlp);
104 int port = dsa_devlink_port_to_port(dlp);
105
106 if (!ds->ops->devlink_sb_tc_pool_bind_set)
107 return -EOPNOTSUPP;
108
109 return ds->ops->devlink_sb_tc_pool_bind_set(ds, port, sb_index,
110 tc_index, pool_type,
111 pool_index, threshold,
112 extack);
113 }
114
115 static int dsa_devlink_sb_occ_snapshot(struct devlink *dl,
116 unsigned int sb_index)
117 {
118 struct dsa_switch *ds = dsa_devlink_to_ds(dl);
119
120 if (!ds->ops->devlink_sb_occ_snapshot)
121 return -EOPNOTSUPP;
122
123 return ds->ops->devlink_sb_occ_snapshot(ds, sb_index);
124 }
125
126 static int dsa_devlink_sb_occ_max_clear(struct devlink *dl,
127 unsigned int sb_index)
128 {
129 struct dsa_switch *ds = dsa_devlink_to_ds(dl);
130
131 if (!ds->ops->devlink_sb_occ_max_clear)
132 return -EOPNOTSUPP;
133
134 return ds->ops->devlink_sb_occ_max_clear(ds, sb_index);
135 }
136
137 static int dsa_devlink_sb_occ_port_pool_get(struct devlink_port *dlp,
138 unsigned int sb_index,
139 u16 pool_index, u32 *p_cur,
140 u32 *p_max)
141 {
142 struct dsa_switch *ds = dsa_devlink_port_to_ds(dlp);
143 int port = dsa_devlink_port_to_port(dlp);
144
145 if (!ds->ops->devlink_sb_occ_port_pool_get)
146 return -EOPNOTSUPP;
147
148 return ds->ops->devlink_sb_occ_port_pool_get(ds, port, sb_index,
149 pool_index, p_cur, p_max);
150 }
151
152 static int
153 dsa_devlink_sb_occ_tc_port_bind_get(struct devlink_port *dlp,
154 unsigned int sb_index, u16 tc_index,
155 enum devlink_sb_pool_type pool_type,
156 u32 *p_cur, u32 *p_max)
157 {
158 struct dsa_switch *ds = dsa_devlink_port_to_ds(dlp);
159 int port = dsa_devlink_port_to_port(dlp);
160
161 if (!ds->ops->devlink_sb_occ_tc_port_bind_get)
162 return -EOPNOTSUPP;
163
164 return ds->ops->devlink_sb_occ_tc_port_bind_get(ds, port,
165 sb_index, tc_index,
166 pool_type, p_cur,
167 p_max);
168 }
169
170 static const struct devlink_ops dsa_devlink_ops = {
171 .info_get = dsa_devlink_info_get,
172 .sb_pool_get = dsa_devlink_sb_pool_get,
173 .sb_pool_set = dsa_devlink_sb_pool_set,
174 .sb_port_pool_get = dsa_devlink_sb_port_pool_get,
175 .sb_port_pool_set = dsa_devlink_sb_port_pool_set,
176 .sb_tc_pool_bind_get = dsa_devlink_sb_tc_pool_bind_get,
177 .sb_tc_pool_bind_set = dsa_devlink_sb_tc_pool_bind_set,
178 .sb_occ_snapshot = dsa_devlink_sb_occ_snapshot,
179 .sb_occ_max_clear = dsa_devlink_sb_occ_max_clear,
180 .sb_occ_port_pool_get = dsa_devlink_sb_occ_port_pool_get,
181 .sb_occ_tc_port_bind_get = dsa_devlink_sb_occ_tc_port_bind_get,
182 };
183
184 int dsa_devlink_param_get(struct devlink *dl, u32 id,
185 struct devlink_param_gset_ctx *ctx)
186 {
187 struct dsa_switch *ds = dsa_devlink_to_ds(dl);
188
189 if (!ds->ops->devlink_param_get)
190 return -EOPNOTSUPP;
191
192 return ds->ops->devlink_param_get(ds, id, ctx);
193 }
194 EXPORT_SYMBOL_GPL(dsa_devlink_param_get);
195
196 int dsa_devlink_param_set(struct devlink *dl, u32 id,
197 struct devlink_param_gset_ctx *ctx,
198 struct netlink_ext_ack *extack)
199 {
200 struct dsa_switch *ds = dsa_devlink_to_ds(dl);
201
202 if (!ds->ops->devlink_param_set)
203 return -EOPNOTSUPP;
204
205 return ds->ops->devlink_param_set(ds, id, ctx);
206 }
207 EXPORT_SYMBOL_GPL(dsa_devlink_param_set);
208
209 int dsa_devlink_params_register(struct dsa_switch *ds,
210 const struct devlink_param *params,
211 size_t params_count)
212 {
213 return devlink_params_register(ds->devlink, params, params_count);
214 }
215 EXPORT_SYMBOL_GPL(dsa_devlink_params_register);
216
217 void dsa_devlink_params_unregister(struct dsa_switch *ds,
218 const struct devlink_param *params,
219 size_t params_count)
220 {
221 devlink_params_unregister(ds->devlink, params, params_count);
222 }
223 EXPORT_SYMBOL_GPL(dsa_devlink_params_unregister);
224
225 int dsa_devlink_resource_register(struct dsa_switch *ds,
226 const char *resource_name,
227 u64 resource_size,
228 u64 resource_id,
229 u64 parent_resource_id,
230 const struct devlink_resource_size_params *size_params)
231 {
232 return devlink_resource_register(ds->devlink, resource_name,
233 resource_size, resource_id,
234 parent_resource_id,
235 size_params);
236 }
237 EXPORT_SYMBOL_GPL(dsa_devlink_resource_register);
238
239 void dsa_devlink_resources_unregister(struct dsa_switch *ds)
240 {
241 devlink_resources_unregister(ds->devlink);
242 }
243 EXPORT_SYMBOL_GPL(dsa_devlink_resources_unregister);
244
245 void dsa_devlink_resource_occ_get_register(struct dsa_switch *ds,
246 u64 resource_id,
247 devlink_resource_occ_get_t *occ_get,
248 void *occ_get_priv)
249 {
250 return devlink_resource_occ_get_register(ds->devlink, resource_id,
251 occ_get, occ_get_priv);
252 }
253 EXPORT_SYMBOL_GPL(dsa_devlink_resource_occ_get_register);
254
255 void dsa_devlink_resource_occ_get_unregister(struct dsa_switch *ds,
256 u64 resource_id)
257 {
258 devlink_resource_occ_get_unregister(ds->devlink, resource_id);
259 }
260 EXPORT_SYMBOL_GPL(dsa_devlink_resource_occ_get_unregister);
261
262 struct devlink_region *
263 dsa_devlink_region_create(struct dsa_switch *ds,
264 const struct devlink_region_ops *ops,
265 u32 region_max_snapshots, u64 region_size)
266 {
267 return devlink_region_create(ds->devlink, ops, region_max_snapshots,
268 region_size);
269 }
270 EXPORT_SYMBOL_GPL(dsa_devlink_region_create);
271
272 struct devlink_region *
273 dsa_devlink_port_region_create(struct dsa_switch *ds,
274 int port,
275 const struct devlink_port_region_ops *ops,
276 u32 region_max_snapshots, u64 region_size)
277 {
278 struct dsa_port *dp = dsa_to_port(ds, port);
279
280 return devlink_port_region_create(&dp->devlink_port, ops,
281 region_max_snapshots,
282 region_size);
283 }
284 EXPORT_SYMBOL_GPL(dsa_devlink_port_region_create);
285
286 void dsa_devlink_region_destroy(struct devlink_region *region)
287 {
288 devlink_region_destroy(region);
289 }
290 EXPORT_SYMBOL_GPL(dsa_devlink_region_destroy);
291
292 int dsa_port_devlink_setup(struct dsa_port *dp)
293 {
294 struct devlink_port *dlp = &dp->devlink_port;
295 struct dsa_switch_tree *dst = dp->ds->dst;
296 struct devlink_port_attrs attrs = {};
297 struct devlink *dl = dp->ds->devlink;
298 struct dsa_switch *ds = dp->ds;
299 const unsigned char *id;
300 unsigned char len;
301 int err;
302
303 memset(dlp, 0, sizeof(*dlp));
304 devlink_port_init(dl, dlp);
305
306 if (ds->ops->port_setup) {
307 err = ds->ops->port_setup(ds, dp->index);
308 if (err)
309 return err;
310 }
311
312 id = (const unsigned char *)&dst->index;
313 len = sizeof(dst->index);
314
315 attrs.phys.port_number = dp->index;
316 memcpy(attrs.switch_id.id, id, len);
317 attrs.switch_id.id_len = len;
318
319 switch (dp->type) {
320 case DSA_PORT_TYPE_UNUSED:
321 attrs.flavour = DEVLINK_PORT_FLAVOUR_UNUSED;
322 break;
323 case DSA_PORT_TYPE_CPU:
324 attrs.flavour = DEVLINK_PORT_FLAVOUR_CPU;
325 break;
326 case DSA_PORT_TYPE_DSA:
327 attrs.flavour = DEVLINK_PORT_FLAVOUR_DSA;
328 break;
329 case DSA_PORT_TYPE_USER:
330 attrs.flavour = DEVLINK_PORT_FLAVOUR_PHYSICAL;
331 break;
332 }
333
334 devlink_port_attrs_set(dlp, &attrs);
335 err = devlink_port_register(dl, dlp, dp->index);
336 if (err) {
337 if (ds->ops->port_teardown)
338 ds->ops->port_teardown(ds, dp->index);
339 return err;
340 }
341
342 return 0;
343 }
344
345 void dsa_port_devlink_teardown(struct dsa_port *dp)
346 {
347 struct devlink_port *dlp = &dp->devlink_port;
348 struct dsa_switch *ds = dp->ds;
349
350 devlink_port_unregister(dlp);
351
352 if (ds->ops->port_teardown)
353 ds->ops->port_teardown(ds, dp->index);
354
355 devlink_port_fini(dlp);
356 }
357
358 void dsa_switch_devlink_register(struct dsa_switch *ds)
359 {
360 devlink_register(ds->devlink);
361 }
362
363 void dsa_switch_devlink_unregister(struct dsa_switch *ds)
364 {
365 devlink_unregister(ds->devlink);
366 }
367
368 int dsa_switch_devlink_alloc(struct dsa_switch *ds)
369 {
370 struct dsa_devlink_priv *dl_priv;
371 struct devlink *dl;
372
373 /* Add the switch to devlink before calling setup, so that setup can
374 * add dpipe tables
375 */
376 dl = devlink_alloc(&dsa_devlink_ops, sizeof(*dl_priv), ds->dev);
377 if (!dl)
378 return -ENOMEM;
379
380 ds->devlink = dl;
381
382 dl_priv = devlink_priv(ds->devlink);
383 dl_priv->ds = ds;
384
385 return 0;
386 }
387
388 void dsa_switch_devlink_free(struct dsa_switch *ds)
389 {
390 devlink_free(ds->devlink);
391 ds->devlink = NULL;
392 }
393
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.