devlink.c

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