Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
tjh.dev
kernel
os
linux
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
11static 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
23static 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
36static 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
50static 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
64static 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
79static int
80dsa_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
96static int
97dsa_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
115static 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
126static 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
137static 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
152static int
153dsa_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
170static 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
184int 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}
194EXPORT_SYMBOL_GPL(dsa_devlink_param_get);
195
196int 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}
207EXPORT_SYMBOL_GPL(dsa_devlink_param_set);
208
209int 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}
215EXPORT_SYMBOL_GPL(dsa_devlink_params_register);
216
217void 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}
223EXPORT_SYMBOL_GPL(dsa_devlink_params_unregister);
224
225int 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}
237EXPORT_SYMBOL_GPL(dsa_devlink_resource_register);
238
239void dsa_devlink_resources_unregister(struct dsa_switch *ds)
240{
241 devlink_resources_unregister(ds->devlink);
242}
243EXPORT_SYMBOL_GPL(dsa_devlink_resources_unregister);
244
245void 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}
253EXPORT_SYMBOL_GPL(dsa_devlink_resource_occ_get_register);
254
255void 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}
260EXPORT_SYMBOL_GPL(dsa_devlink_resource_occ_get_unregister);
261
262struct devlink_region *
263dsa_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}
270EXPORT_SYMBOL_GPL(dsa_devlink_region_create);
271
272struct devlink_region *
273dsa_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}
284EXPORT_SYMBOL_GPL(dsa_devlink_port_region_create);
285
286void dsa_devlink_region_destroy(struct devlink_region *region)
287{
288 devlink_region_destroy(region);
289}
290EXPORT_SYMBOL_GPL(dsa_devlink_region_destroy);
291
292int 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
345void 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
358void dsa_switch_devlink_register(struct dsa_switch *ds)
359{
360 devlink_register(ds->devlink);
361}
362
363void dsa_switch_devlink_unregister(struct dsa_switch *ds)
364{
365 devlink_unregister(ds->devlink);
366}
367
368int 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
388void dsa_switch_devlink_free(struct dsa_switch *ds)
389{
390 devlink_free(ds->devlink);
391 ds->devlink = NULL;
392}