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{
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}
206EXPORT_SYMBOL_GPL(dsa_devlink_param_set);
207
208int 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}
214EXPORT_SYMBOL_GPL(dsa_devlink_params_register);
215
216void 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}
222EXPORT_SYMBOL_GPL(dsa_devlink_params_unregister);
223
224int 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}
236EXPORT_SYMBOL_GPL(dsa_devlink_resource_register);
237
238void dsa_devlink_resources_unregister(struct dsa_switch *ds)
239{
240	devlink_resources_unregister(ds->devlink);
241}
242EXPORT_SYMBOL_GPL(dsa_devlink_resources_unregister);
243
244void 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}
252EXPORT_SYMBOL_GPL(dsa_devlink_resource_occ_get_register);
253
254void 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}
259EXPORT_SYMBOL_GPL(dsa_devlink_resource_occ_get_unregister);
260
261struct devlink_region *
262dsa_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}
269EXPORT_SYMBOL_GPL(dsa_devlink_region_create);
270
271struct devlink_region *
272dsa_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}
283EXPORT_SYMBOL_GPL(dsa_devlink_port_region_create);
284
285void dsa_devlink_region_destroy(struct devlink_region *region)
286{
287	devlink_region_destroy(region);
288}
289EXPORT_SYMBOL_GPL(dsa_devlink_region_destroy);
290
291int 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
344void 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
357void dsa_switch_devlink_register(struct dsa_switch *ds)
358{
359	devlink_register(ds->devlink);
360}
361
362void dsa_switch_devlink_unregister(struct dsa_switch *ds)
363{
364	devlink_unregister(ds->devlink);
365}
366
367int 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
387void dsa_switch_devlink_free(struct dsa_switch *ds)
388{
389	devlink_free(ds->devlink);
390	ds->devlink = NULL;
391}
392