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 
dsa_devlink_info_get(struct devlink * dl,struct devlink_info_req * req,struct netlink_ext_ack * extack)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 
dsa_devlink_sb_pool_get(struct devlink * dl,unsigned int sb_index,u16 pool_index,struct devlink_sb_pool_info * pool_info)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 
dsa_devlink_sb_pool_set(struct devlink * dl,unsigned int sb_index,u16 pool_index,u32 size,enum devlink_sb_threshold_type threshold_type,struct netlink_ext_ack * extack)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 
dsa_devlink_sb_port_pool_get(struct devlink_port * dlp,unsigned int sb_index,u16 pool_index,u32 * p_threshold)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 
dsa_devlink_sb_port_pool_set(struct devlink_port * dlp,unsigned int sb_index,u16 pool_index,u32 threshold,struct netlink_ext_ack * extack)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
dsa_devlink_sb_tc_pool_bind_get(struct devlink_port * dlp,unsigned int sb_index,u16 tc_index,enum devlink_sb_pool_type pool_type,u16 * p_pool_index,u32 * p_threshold)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
dsa_devlink_sb_tc_pool_bind_set(struct devlink_port * dlp,unsigned int sb_index,u16 tc_index,enum devlink_sb_pool_type pool_type,u16 pool_index,u32 threshold,struct netlink_ext_ack * extack)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 
dsa_devlink_sb_occ_snapshot(struct devlink * dl,unsigned int sb_index)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 
dsa_devlink_sb_occ_max_clear(struct devlink * dl,unsigned int sb_index)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 
dsa_devlink_sb_occ_port_pool_get(struct devlink_port * dlp,unsigned int sb_index,u16 pool_index,u32 * p_cur,u32 * p_max)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
dsa_devlink_sb_occ_tc_port_bind_get(struct devlink_port * dlp,unsigned int sb_index,u16 tc_index,enum devlink_sb_pool_type pool_type,u32 * p_cur,u32 * p_max)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 
dsa_devlink_param_get(struct devlink * dl,u32 id,struct devlink_param_gset_ctx * ctx)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 
dsa_devlink_param_set(struct devlink * dl,u32 id,struct devlink_param_gset_ctx * ctx)196 int dsa_devlink_param_set(struct devlink *dl, u32 id,
197 			  struct devlink_param_gset_ctx *ctx)
198 {
199 	struct dsa_switch *ds = dsa_devlink_to_ds(dl);
200 
201 	if (!ds->ops->devlink_param_set)
202 		return -EOPNOTSUPP;
203 
204 	return ds->ops->devlink_param_set(ds, id, ctx);
205 }
206 EXPORT_SYMBOL_GPL(dsa_devlink_param_set);
207 
dsa_devlink_params_register(struct dsa_switch * ds,const struct devlink_param * params,size_t params_count)208 int dsa_devlink_params_register(struct dsa_switch *ds,
209 				const struct devlink_param *params,
210 				size_t params_count)
211 {
212 	return devlink_params_register(ds->devlink, params, params_count);
213 }
214 EXPORT_SYMBOL_GPL(dsa_devlink_params_register);
215 
dsa_devlink_params_unregister(struct dsa_switch * ds,const struct devlink_param * params,size_t params_count)216 void dsa_devlink_params_unregister(struct dsa_switch *ds,
217 				   const struct devlink_param *params,
218 				   size_t params_count)
219 {
220 	devlink_params_unregister(ds->devlink, params, params_count);
221 }
222 EXPORT_SYMBOL_GPL(dsa_devlink_params_unregister);
223 
dsa_devlink_resource_register(struct dsa_switch * ds,const char * resource_name,u64 resource_size,u64 resource_id,u64 parent_resource_id,const struct devlink_resource_size_params * size_params)224 int dsa_devlink_resource_register(struct dsa_switch *ds,
225 				  const char *resource_name,
226 				  u64 resource_size,
227 				  u64 resource_id,
228 				  u64 parent_resource_id,
229 				  const struct devlink_resource_size_params *size_params)
230 {
231 	return devlink_resource_register(ds->devlink, resource_name,
232 					 resource_size, resource_id,
233 					 parent_resource_id,
234 					 size_params);
235 }
236 EXPORT_SYMBOL_GPL(dsa_devlink_resource_register);
237 
dsa_devlink_resources_unregister(struct dsa_switch * ds)238 void dsa_devlink_resources_unregister(struct dsa_switch *ds)
239 {
240 	devlink_resources_unregister(ds->devlink);
241 }
242 EXPORT_SYMBOL_GPL(dsa_devlink_resources_unregister);
243 
dsa_devlink_resource_occ_get_register(struct dsa_switch * ds,u64 resource_id,devlink_resource_occ_get_t * occ_get,void * occ_get_priv)244 void dsa_devlink_resource_occ_get_register(struct dsa_switch *ds,
245 					   u64 resource_id,
246 					   devlink_resource_occ_get_t *occ_get,
247 					   void *occ_get_priv)
248 {
249 	return devlink_resource_occ_get_register(ds->devlink, resource_id,
250 						 occ_get, occ_get_priv);
251 }
252 EXPORT_SYMBOL_GPL(dsa_devlink_resource_occ_get_register);
253 
dsa_devlink_resource_occ_get_unregister(struct dsa_switch * ds,u64 resource_id)254 void dsa_devlink_resource_occ_get_unregister(struct dsa_switch *ds,
255 					     u64 resource_id)
256 {
257 	devlink_resource_occ_get_unregister(ds->devlink, resource_id);
258 }
259 EXPORT_SYMBOL_GPL(dsa_devlink_resource_occ_get_unregister);
260 
261 struct devlink_region *
dsa_devlink_region_create(struct dsa_switch * ds,const struct devlink_region_ops * ops,u32 region_max_snapshots,u64 region_size)262 dsa_devlink_region_create(struct dsa_switch *ds,
263 			  const struct devlink_region_ops *ops,
264 			  u32 region_max_snapshots, u64 region_size)
265 {
266 	return devlink_region_create(ds->devlink, ops, region_max_snapshots,
267 				     region_size);
268 }
269 EXPORT_SYMBOL_GPL(dsa_devlink_region_create);
270 
271 struct devlink_region *
dsa_devlink_port_region_create(struct dsa_switch * ds,int port,const struct devlink_port_region_ops * ops,u32 region_max_snapshots,u64 region_size)272 dsa_devlink_port_region_create(struct dsa_switch *ds,
273 			       int port,
274 			       const struct devlink_port_region_ops *ops,
275 			       u32 region_max_snapshots, u64 region_size)
276 {
277 	struct dsa_port *dp = dsa_to_port(ds, port);
278 
279 	return devlink_port_region_create(&dp->devlink_port, ops,
280 					  region_max_snapshots,
281 					  region_size);
282 }
283 EXPORT_SYMBOL_GPL(dsa_devlink_port_region_create);
284 
dsa_devlink_region_destroy(struct devlink_region * region)285 void dsa_devlink_region_destroy(struct devlink_region *region)
286 {
287 	devlink_region_destroy(region);
288 }
289 EXPORT_SYMBOL_GPL(dsa_devlink_region_destroy);
290 
dsa_port_devlink_setup(struct dsa_port * dp)291 int dsa_port_devlink_setup(struct dsa_port *dp)
292 {
293 	struct devlink_port *dlp = &dp->devlink_port;
294 	struct dsa_switch_tree *dst = dp->ds->dst;
295 	struct devlink_port_attrs attrs = {};
296 	struct devlink *dl = dp->ds->devlink;
297 	struct dsa_switch *ds = dp->ds;
298 	const unsigned char *id;
299 	unsigned char len;
300 	int err;
301 
302 	memset(dlp, 0, sizeof(*dlp));
303 	devlink_port_init(dl, dlp);
304 
305 	if (ds->ops->port_setup) {
306 		err = ds->ops->port_setup(ds, dp->index);
307 		if (err)
308 			return err;
309 	}
310 
311 	id = (const unsigned char *)&dst->index;
312 	len = sizeof(dst->index);
313 
314 	attrs.phys.port_number = dp->index;
315 	memcpy(attrs.switch_id.id, id, len);
316 	attrs.switch_id.id_len = len;
317 
318 	switch (dp->type) {
319 	case DSA_PORT_TYPE_UNUSED:
320 		attrs.flavour = DEVLINK_PORT_FLAVOUR_UNUSED;
321 		break;
322 	case DSA_PORT_TYPE_CPU:
323 		attrs.flavour = DEVLINK_PORT_FLAVOUR_CPU;
324 		break;
325 	case DSA_PORT_TYPE_DSA:
326 		attrs.flavour = DEVLINK_PORT_FLAVOUR_DSA;
327 		break;
328 	case DSA_PORT_TYPE_USER:
329 		attrs.flavour = DEVLINK_PORT_FLAVOUR_PHYSICAL;
330 		break;
331 	}
332 
333 	devlink_port_attrs_set(dlp, &attrs);
334 	err = devlink_port_register(dl, dlp, dp->index);
335 	if (err) {
336 		if (ds->ops->port_teardown)
337 			ds->ops->port_teardown(ds, dp->index);
338 		return err;
339 	}
340 
341 	return 0;
342 }
343 
dsa_port_devlink_teardown(struct dsa_port * dp)344 void dsa_port_devlink_teardown(struct dsa_port *dp)
345 {
346 	struct devlink_port *dlp = &dp->devlink_port;
347 	struct dsa_switch *ds = dp->ds;
348 
349 	devlink_port_unregister(dlp);
350 
351 	if (ds->ops->port_teardown)
352 		ds->ops->port_teardown(ds, dp->index);
353 
354 	devlink_port_fini(dlp);
355 }
356 
dsa_switch_devlink_register(struct dsa_switch * ds)357 void dsa_switch_devlink_register(struct dsa_switch *ds)
358 {
359 	devlink_register(ds->devlink);
360 }
361 
dsa_switch_devlink_unregister(struct dsa_switch * ds)362 void dsa_switch_devlink_unregister(struct dsa_switch *ds)
363 {
364 	devlink_unregister(ds->devlink);
365 }
366 
dsa_switch_devlink_alloc(struct dsa_switch * ds)367 int dsa_switch_devlink_alloc(struct dsa_switch *ds)
368 {
369 	struct dsa_devlink_priv *dl_priv;
370 	struct devlink *dl;
371 
372 	/* Add the switch to devlink before calling setup, so that setup can
373 	 * add dpipe tables
374 	 */
375 	dl = devlink_alloc(&dsa_devlink_ops, sizeof(*dl_priv), ds->dev);
376 	if (!dl)
377 		return -ENOMEM;
378 
379 	ds->devlink = dl;
380 
381 	dl_priv = devlink_priv(ds->devlink);
382 	dl_priv->ds = ds;
383 
384 	return 0;
385 }
386 
dsa_switch_devlink_free(struct dsa_switch * ds)387 void dsa_switch_devlink_free(struct dsa_switch *ds)
388 {
389 	devlink_free(ds->devlink);
390 	ds->devlink = NULL;
391 }
392