Commit 5cf2c75b authored by Vladimir Oltean's avatar Vladimir Oltean Committed by Jakub Kicinski
Browse files

net: dsa: move bulk of devlink code to devlink.{c,h} 



dsa.c and dsa2.c are bloated with too much off-topic code. Identify all
code related to devlink and move it to a new devlink.c file.

Steer clear of the dsa_priv.h dumping ground antipattern and create a
dedicated devlink.h for it, which will be included only by the C files
which need it. Usage of dsa_priv.h will be minimized in later patches.

Signed-off-by: default avatarVladimir Oltean <vladimir.oltean@nxp.com>
Reviewed-by: default avatarFlorian Fainelli <f.fainelli@gmail.com>
Signed-off-by: default avatarJakub Kicinski <kuba@kernel.org>
parent d2be3204

net/dsa/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -2,6 +2,7 @@ 
# the core

obj-$(CONFIG_NET_DSA) += dsa_core.o

dsa_core-y += \

	devlink.o \

	dsa.o \

	dsa2.o \

	master.o \

net/dsa/devlink.c

0 → 100644
+355 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0-or-later

/*

 * DSA devlink handling

 */



#include <net/dsa.h>

#include <net/devlink.h>



#include "devlink.h"



static int dsa_devlink_info_get(struct devlink *dl,

				struct devlink_info_req *req,

				struct netlink_ext_ack *extack)

{

	struct dsa_switch *ds = dsa_devlink_to_ds(dl);



	if (ds->ops->devlink_info_get)

		return ds->ops->devlink_info_get(ds, req, extack);



	return -EOPNOTSUPP;

}



static int dsa_devlink_sb_pool_get(struct devlink *dl,

				   unsigned int sb_index, u16 pool_index,

				   struct devlink_sb_pool_info *pool_info)

{

	struct dsa_switch *ds = dsa_devlink_to_ds(dl);



	if (!ds->ops->devlink_sb_pool_get)

		return -EOPNOTSUPP;



	return ds->ops->devlink_sb_pool_get(ds, sb_index, pool_index,

					    pool_info);

}



static int 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)

{

	struct dsa_switch *ds = dsa_devlink_to_ds(dl);



	if (!ds->ops->devlink_sb_pool_set)

		return -EOPNOTSUPP;



	return ds->ops->devlink_sb_pool_set(ds, sb_index, pool_index, size,

					    threshold_type, extack);

}



static int dsa_devlink_sb_port_pool_get(struct devlink_port *dlp,

					unsigned int sb_index, u16 pool_index,

					u32 *p_threshold)

{

	struct dsa_switch *ds = dsa_devlink_port_to_ds(dlp);

	int port = dsa_devlink_port_to_port(dlp);



	if (!ds->ops->devlink_sb_port_pool_get)

		return -EOPNOTSUPP;



	return ds->ops->devlink_sb_port_pool_get(ds, port, sb_index,

						 pool_index, p_threshold);

}



static int dsa_devlink_sb_port_pool_set(struct devlink_port *dlp,

					unsigned int sb_index, u16 pool_index,

					u32 threshold,

					struct netlink_ext_ack *extack)

{

	struct dsa_switch *ds = dsa_devlink_port_to_ds(dlp);

	int port = dsa_devlink_port_to_port(dlp);



	if (!ds->ops->devlink_sb_port_pool_set)

		return -EOPNOTSUPP;



	return ds->ops->devlink_sb_port_pool_set(ds, port, sb_index,

						 pool_index, threshold, extack);

}



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)

{

	struct dsa_switch *ds = dsa_devlink_port_to_ds(dlp);

	int port = dsa_devlink_port_to_port(dlp);



	if (!ds->ops->devlink_sb_tc_pool_bind_get)

		return -EOPNOTSUPP;



	return ds->ops->devlink_sb_tc_pool_bind_get(ds, port, sb_index,

						    tc_index, pool_type,

						    p_pool_index, p_threshold);

}



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)

{

	struct dsa_switch *ds = dsa_devlink_port_to_ds(dlp);

	int port = dsa_devlink_port_to_port(dlp);



	if (!ds->ops->devlink_sb_tc_pool_bind_set)

		return -EOPNOTSUPP;



	return ds->ops->devlink_sb_tc_pool_bind_set(ds, port, sb_index,

						    tc_index, pool_type,

						    pool_index, threshold,

						    extack);

}



static int dsa_devlink_sb_occ_snapshot(struct devlink *dl,

				       unsigned int sb_index)

{

	struct dsa_switch *ds = dsa_devlink_to_ds(dl);



	if (!ds->ops->devlink_sb_occ_snapshot)

		return -EOPNOTSUPP;



	return ds->ops->devlink_sb_occ_snapshot(ds, sb_index);

}



static int dsa_devlink_sb_occ_max_clear(struct devlink *dl,

					unsigned int sb_index)

{

	struct dsa_switch *ds = dsa_devlink_to_ds(dl);



	if (!ds->ops->devlink_sb_occ_max_clear)

		return -EOPNOTSUPP;



	return ds->ops->devlink_sb_occ_max_clear(ds, sb_index);

}



static int dsa_devlink_sb_occ_port_pool_get(struct devlink_port *dlp,

					    unsigned int sb_index,

					    u16 pool_index, u32 *p_cur,

					    u32 *p_max)

{

	struct dsa_switch *ds = dsa_devlink_port_to_ds(dlp);

	int port = dsa_devlink_port_to_port(dlp);



	if (!ds->ops->devlink_sb_occ_port_pool_get)

		return -EOPNOTSUPP;



	return ds->ops->devlink_sb_occ_port_pool_get(ds, port, sb_index,

						     pool_index, p_cur, p_max);

}



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)

{

	struct dsa_switch *ds = dsa_devlink_port_to_ds(dlp);

	int port = dsa_devlink_port_to_port(dlp);



	if (!ds->ops->devlink_sb_occ_tc_port_bind_get)

		return -EOPNOTSUPP;



	return ds->ops->devlink_sb_occ_tc_port_bind_get(ds, port,

							sb_index, tc_index,

							pool_type, p_cur,

							p_max);

}



const struct devlink_ops dsa_devlink_ops = {

	.info_get			= dsa_devlink_info_get,

	.sb_pool_get			= dsa_devlink_sb_pool_get,

	.sb_pool_set			= dsa_devlink_sb_pool_set,

	.sb_port_pool_get		= dsa_devlink_sb_port_pool_get,

	.sb_port_pool_set		= dsa_devlink_sb_port_pool_set,

	.sb_tc_pool_bind_get		= dsa_devlink_sb_tc_pool_bind_get,

	.sb_tc_pool_bind_set		= dsa_devlink_sb_tc_pool_bind_set,

	.sb_occ_snapshot		= dsa_devlink_sb_occ_snapshot,

	.sb_occ_max_clear		= dsa_devlink_sb_occ_max_clear,

	.sb_occ_port_pool_get		= dsa_devlink_sb_occ_port_pool_get,

	.sb_occ_tc_port_bind_get	= dsa_devlink_sb_occ_tc_port_bind_get,

};



int dsa_devlink_param_get(struct devlink *dl, u32 id,

			  struct devlink_param_gset_ctx *ctx)

{

	struct dsa_switch *ds = dsa_devlink_to_ds(dl);



	if (!ds->ops->devlink_param_get)

		return -EOPNOTSUPP;



	return ds->ops->devlink_param_get(ds, id, ctx);

}

EXPORT_SYMBOL_GPL(dsa_devlink_param_get);



int dsa_devlink_param_set(struct devlink *dl, u32 id,

			  struct devlink_param_gset_ctx *ctx)

{

	struct dsa_switch *ds = dsa_devlink_to_ds(dl);



	if (!ds->ops->devlink_param_set)

		return -EOPNOTSUPP;



	return ds->ops->devlink_param_set(ds, id, ctx);

}

EXPORT_SYMBOL_GPL(dsa_devlink_param_set);



int dsa_devlink_params_register(struct dsa_switch *ds,

				const struct devlink_param *params,

				size_t params_count)

{

	return devlink_params_register(ds->devlink, params, params_count);

}

EXPORT_SYMBOL_GPL(dsa_devlink_params_register);



void dsa_devlink_params_unregister(struct dsa_switch *ds,

				   const struct devlink_param *params,

				   size_t params_count)

{

	devlink_params_unregister(ds->devlink, params, params_count);

}

EXPORT_SYMBOL_GPL(dsa_devlink_params_unregister);



int 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)

{

	return devlink_resource_register(ds->devlink, resource_name,

					 resource_size, resource_id,

					 parent_resource_id,

					 size_params);

}

EXPORT_SYMBOL_GPL(dsa_devlink_resource_register);



void dsa_devlink_resources_unregister(struct dsa_switch *ds)

{

	devlink_resources_unregister(ds->devlink);

}

EXPORT_SYMBOL_GPL(dsa_devlink_resources_unregister);



void dsa_devlink_resource_occ_get_register(struct dsa_switch *ds,

					   u64 resource_id,

					   devlink_resource_occ_get_t *occ_get,

					   void *occ_get_priv)

{

	return devlink_resource_occ_get_register(ds->devlink, resource_id,

						 occ_get, occ_get_priv);

}

EXPORT_SYMBOL_GPL(dsa_devlink_resource_occ_get_register);



void dsa_devlink_resource_occ_get_unregister(struct dsa_switch *ds,

					     u64 resource_id)

{

	devlink_resource_occ_get_unregister(ds->devlink, resource_id);

}

EXPORT_SYMBOL_GPL(dsa_devlink_resource_occ_get_unregister);



struct devlink_region *

dsa_devlink_region_create(struct dsa_switch *ds,

			  const struct devlink_region_ops *ops,

			  u32 region_max_snapshots, u64 region_size)

{

	return devlink_region_create(ds->devlink, ops, region_max_snapshots,

				     region_size);

}

EXPORT_SYMBOL_GPL(dsa_devlink_region_create);



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)

{

	struct dsa_port *dp = dsa_to_port(ds, port);



	return devlink_port_region_create(&dp->devlink_port, ops,

					  region_max_snapshots,

					  region_size);

}

EXPORT_SYMBOL_GPL(dsa_devlink_port_region_create);



void dsa_devlink_region_destroy(struct devlink_region *region)

{

	devlink_region_destroy(region);

}

EXPORT_SYMBOL_GPL(dsa_devlink_region_destroy);



int dsa_port_devlink_setup(struct dsa_port *dp)

{

	struct devlink_port *dlp = &dp->devlink_port;

	struct dsa_switch_tree *dst = dp->ds->dst;

	struct devlink_port_attrs attrs = {};

	struct devlink *dl = dp->ds->devlink;

	struct dsa_switch *ds = dp->ds;

	const unsigned char *id;

	unsigned char len;

	int err;



	memset(dlp, 0, sizeof(*dlp));

	devlink_port_init(dl, dlp);



	if (ds->ops->port_setup) {

		err = ds->ops->port_setup(ds, dp->index);

		if (err)

			return err;

	}



	id = (const unsigned char *)&dst->index;

	len = sizeof(dst->index);



	attrs.phys.port_number = dp->index;

	memcpy(attrs.switch_id.id, id, len);

	attrs.switch_id.id_len = len;



	switch (dp->type) {

	case DSA_PORT_TYPE_UNUSED:

		attrs.flavour = DEVLINK_PORT_FLAVOUR_UNUSED;

		break;

	case DSA_PORT_TYPE_CPU:

		attrs.flavour = DEVLINK_PORT_FLAVOUR_CPU;

		break;

	case DSA_PORT_TYPE_DSA:

		attrs.flavour = DEVLINK_PORT_FLAVOUR_DSA;

		break;

	case DSA_PORT_TYPE_USER:

		attrs.flavour = DEVLINK_PORT_FLAVOUR_PHYSICAL;

		break;

	}



	devlink_port_attrs_set(dlp, &attrs);

	err = devlink_port_register(dl, dlp, dp->index);

	if (err) {

		if (ds->ops->port_teardown)

			ds->ops->port_teardown(ds, dp->index);

		return err;

	}



	return 0;

}



void dsa_port_devlink_teardown(struct dsa_port *dp)

{

	struct devlink_port *dlp = &dp->devlink_port;

	struct dsa_switch *ds = dp->ds;



	devlink_port_unregister(dlp);



	if (ds->ops->port_teardown)

		ds->ops->port_teardown(ds, dp->index);



	devlink_port_fini(dlp);

}

net/dsa/devlink.h

0 → 100644
+13 −0
Original line number Diff line number Diff line 
/* SPDX-License-Identifier: GPL-2.0-or-later */



#ifndef __DSA_DEVLINK_H

#define __DSA_DEVLINK_H



struct dsa_port;



extern const struct devlink_ops dsa_devlink_ops;



int dsa_port_devlink_setup(struct dsa_port *dp);

void dsa_port_devlink_teardown(struct dsa_port *dp);



#endif

net/dsa/dsa.c

+0 −107
Original line number Diff line number Diff line
@@ -344,113 +344,6 @@ void dsa_flush_workqueue(void) 
}

EXPORT_SYMBOL_GPL(dsa_flush_workqueue);



int dsa_devlink_param_get(struct devlink *dl, u32 id,

			  struct devlink_param_gset_ctx *ctx)

{

	struct dsa_switch *ds = dsa_devlink_to_ds(dl);



	if (!ds->ops->devlink_param_get)

		return -EOPNOTSUPP;



	return ds->ops->devlink_param_get(ds, id, ctx);

}

EXPORT_SYMBOL_GPL(dsa_devlink_param_get);



int dsa_devlink_param_set(struct devlink *dl, u32 id,

			  struct devlink_param_gset_ctx *ctx)

{

	struct dsa_switch *ds = dsa_devlink_to_ds(dl);



	if (!ds->ops->devlink_param_set)

		return -EOPNOTSUPP;



	return ds->ops->devlink_param_set(ds, id, ctx);

}

EXPORT_SYMBOL_GPL(dsa_devlink_param_set);



int dsa_devlink_params_register(struct dsa_switch *ds,

				const struct devlink_param *params,

				size_t params_count)

{

	return devlink_params_register(ds->devlink, params, params_count);

}

EXPORT_SYMBOL_GPL(dsa_devlink_params_register);



void dsa_devlink_params_unregister(struct dsa_switch *ds,

				   const struct devlink_param *params,

				   size_t params_count)

{

	devlink_params_unregister(ds->devlink, params, params_count);

}

EXPORT_SYMBOL_GPL(dsa_devlink_params_unregister);



int 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)

{

	return devlink_resource_register(ds->devlink, resource_name,

					 resource_size, resource_id,

					 parent_resource_id,

					 size_params);

}

EXPORT_SYMBOL_GPL(dsa_devlink_resource_register);



void dsa_devlink_resources_unregister(struct dsa_switch *ds)

{

	devlink_resources_unregister(ds->devlink);

}

EXPORT_SYMBOL_GPL(dsa_devlink_resources_unregister);



void dsa_devlink_resource_occ_get_register(struct dsa_switch *ds,

					   u64 resource_id,

					   devlink_resource_occ_get_t *occ_get,

					   void *occ_get_priv)

{

	return devlink_resource_occ_get_register(ds->devlink, resource_id,

						 occ_get, occ_get_priv);

}

EXPORT_SYMBOL_GPL(dsa_devlink_resource_occ_get_register);



void dsa_devlink_resource_occ_get_unregister(struct dsa_switch *ds,

					     u64 resource_id)

{

	devlink_resource_occ_get_unregister(ds->devlink, resource_id);

}

EXPORT_SYMBOL_GPL(dsa_devlink_resource_occ_get_unregister);



struct devlink_region *

dsa_devlink_region_create(struct dsa_switch *ds,

			  const struct devlink_region_ops *ops,

			  u32 region_max_snapshots, u64 region_size)

{

	return devlink_region_create(ds->devlink, ops, region_max_snapshots,

				     region_size);

}

EXPORT_SYMBOL_GPL(dsa_devlink_region_create);



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)

{

	struct dsa_port *dp = dsa_to_port(ds, port);



	return devlink_port_region_create(&dp->devlink_port, ops,

					  region_max_snapshots,

					  region_size);

}

EXPORT_SYMBOL_GPL(dsa_devlink_port_region_create);



void dsa_devlink_region_destroy(struct devlink_region *region)

{

	devlink_region_destroy(region);

}

EXPORT_SYMBOL_GPL(dsa_devlink_region_destroy);



struct dsa_port *dsa_port_from_netdev(struct net_device *netdev)

{

	if (!netdev || !dsa_slave_dev_check(netdev))

net/dsa/dsa2.c

+1 −239
Original line number Diff line number Diff line
@@ -18,6 +18,7 @@ 
#include <net/devlink.h>

#include <net/sch_generic.h>



#include "devlink.h"

#include "dsa_priv.h"



static DEFINE_MUTEX(dsa2_mutex);
@@ -461,72 +462,6 @@ static void dsa_tree_teardown_cpu_ports(struct dsa_switch_tree *dst) 
			dp->cpu_dp = NULL;

}



static int dsa_port_devlink_setup(struct dsa_port *dp)

{

	struct devlink_port *dlp = &dp->devlink_port;

	struct dsa_switch_tree *dst = dp->ds->dst;

	struct devlink_port_attrs attrs = {};

	struct devlink *dl = dp->ds->devlink;

	struct dsa_switch *ds = dp->ds;

	const unsigned char *id;

	unsigned char len;

	int err;



	memset(dlp, 0, sizeof(*dlp));

	devlink_port_init(dl, dlp);



	if (ds->ops->port_setup) {

		err = ds->ops->port_setup(ds, dp->index);

		if (err)

			return err;

	}



	id = (const unsigned char *)&dst->index;

	len = sizeof(dst->index);



	attrs.phys.port_number = dp->index;

	memcpy(attrs.switch_id.id, id, len);

	attrs.switch_id.id_len = len;



	switch (dp->type) {

	case DSA_PORT_TYPE_UNUSED:

		attrs.flavour = DEVLINK_PORT_FLAVOUR_UNUSED;

		break;

	case DSA_PORT_TYPE_CPU:

		attrs.flavour = DEVLINK_PORT_FLAVOUR_CPU;

		break;

	case DSA_PORT_TYPE_DSA:

		attrs.flavour = DEVLINK_PORT_FLAVOUR_DSA;

		break;

	case DSA_PORT_TYPE_USER:

		attrs.flavour = DEVLINK_PORT_FLAVOUR_PHYSICAL;

		break;

	}



	devlink_port_attrs_set(dlp, &attrs);

	err = devlink_port_register(dl, dlp, dp->index);

	if (err) {

		if (ds->ops->port_teardown)

			ds->ops->port_teardown(ds, dp->index);

		return err;

	}



	return 0;

}



static void dsa_port_devlink_teardown(struct dsa_port *dp)

{

	struct devlink_port *dlp = &dp->devlink_port;

	struct dsa_switch *ds = dp->ds;



	devlink_port_unregister(dlp);



	if (ds->ops->port_teardown)

		ds->ops->port_teardown(ds, dp->index);



	devlink_port_fini(dlp);

}



static int dsa_port_setup(struct dsa_port *dp)

{

	bool dsa_port_link_registered = false;
@@ -638,179 +573,6 @@ static int dsa_port_setup_as_unused(struct dsa_port *dp) 
	return dsa_port_setup(dp);

}



static int dsa_devlink_info_get(struct devlink *dl,

				struct devlink_info_req *req,

				struct netlink_ext_ack *extack)

{

	struct dsa_switch *ds = dsa_devlink_to_ds(dl);



	if (ds->ops->devlink_info_get)

		return ds->ops->devlink_info_get(ds, req, extack);



	return -EOPNOTSUPP;

}



static int dsa_devlink_sb_pool_get(struct devlink *dl,

				   unsigned int sb_index, u16 pool_index,

				   struct devlink_sb_pool_info *pool_info)

{

	struct dsa_switch *ds = dsa_devlink_to_ds(dl);



	if (!ds->ops->devlink_sb_pool_get)

		return -EOPNOTSUPP;



	return ds->ops->devlink_sb_pool_get(ds, sb_index, pool_index,

					    pool_info);

}



static int 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)

{

	struct dsa_switch *ds = dsa_devlink_to_ds(dl);



	if (!ds->ops->devlink_sb_pool_set)

		return -EOPNOTSUPP;



	return ds->ops->devlink_sb_pool_set(ds, sb_index, pool_index, size,

					    threshold_type, extack);

}



static int dsa_devlink_sb_port_pool_get(struct devlink_port *dlp,

					unsigned int sb_index, u16 pool_index,

					u32 *p_threshold)

{

	struct dsa_switch *ds = dsa_devlink_port_to_ds(dlp);

	int port = dsa_devlink_port_to_port(dlp);



	if (!ds->ops->devlink_sb_port_pool_get)

		return -EOPNOTSUPP;



	return ds->ops->devlink_sb_port_pool_get(ds, port, sb_index,

						 pool_index, p_threshold);

}



static int dsa_devlink_sb_port_pool_set(struct devlink_port *dlp,

					unsigned int sb_index, u16 pool_index,

					u32 threshold,

					struct netlink_ext_ack *extack)

{

	struct dsa_switch *ds = dsa_devlink_port_to_ds(dlp);

	int port = dsa_devlink_port_to_port(dlp);



	if (!ds->ops->devlink_sb_port_pool_set)

		return -EOPNOTSUPP;



	return ds->ops->devlink_sb_port_pool_set(ds, port, sb_index,

						 pool_index, threshold, extack);

}



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)

{

	struct dsa_switch *ds = dsa_devlink_port_to_ds(dlp);

	int port = dsa_devlink_port_to_port(dlp);



	if (!ds->ops->devlink_sb_tc_pool_bind_get)

		return -EOPNOTSUPP;



	return ds->ops->devlink_sb_tc_pool_bind_get(ds, port, sb_index,

						    tc_index, pool_type,

						    p_pool_index, p_threshold);

}



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)

{

	struct dsa_switch *ds = dsa_devlink_port_to_ds(dlp);

	int port = dsa_devlink_port_to_port(dlp);



	if (!ds->ops->devlink_sb_tc_pool_bind_set)

		return -EOPNOTSUPP;



	return ds->ops->devlink_sb_tc_pool_bind_set(ds, port, sb_index,

						    tc_index, pool_type,

						    pool_index, threshold,

						    extack);

}



static int dsa_devlink_sb_occ_snapshot(struct devlink *dl,

				       unsigned int sb_index)

{

	struct dsa_switch *ds = dsa_devlink_to_ds(dl);



	if (!ds->ops->devlink_sb_occ_snapshot)

		return -EOPNOTSUPP;



	return ds->ops->devlink_sb_occ_snapshot(ds, sb_index);

}



static int dsa_devlink_sb_occ_max_clear(struct devlink *dl,

					unsigned int sb_index)

{

	struct dsa_switch *ds = dsa_devlink_to_ds(dl);



	if (!ds->ops->devlink_sb_occ_max_clear)

		return -EOPNOTSUPP;



	return ds->ops->devlink_sb_occ_max_clear(ds, sb_index);

}



static int dsa_devlink_sb_occ_port_pool_get(struct devlink_port *dlp,

					    unsigned int sb_index,

					    u16 pool_index, u32 *p_cur,

					    u32 *p_max)

{

	struct dsa_switch *ds = dsa_devlink_port_to_ds(dlp);

	int port = dsa_devlink_port_to_port(dlp);



	if (!ds->ops->devlink_sb_occ_port_pool_get)

		return -EOPNOTSUPP;



	return ds->ops->devlink_sb_occ_port_pool_get(ds, port, sb_index,

						     pool_index, p_cur, p_max);

}



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)

{

	struct dsa_switch *ds = dsa_devlink_port_to_ds(dlp);

	int port = dsa_devlink_port_to_port(dlp);



	if (!ds->ops->devlink_sb_occ_tc_port_bind_get)

		return -EOPNOTSUPP;



	return ds->ops->devlink_sb_occ_tc_port_bind_get(ds, port,

							sb_index, tc_index,

							pool_type, p_cur,

							p_max);

}



static const struct devlink_ops dsa_devlink_ops = {

	.info_get			= dsa_devlink_info_get,

	.sb_pool_get			= dsa_devlink_sb_pool_get,

	.sb_pool_set			= dsa_devlink_sb_pool_set,

	.sb_port_pool_get		= dsa_devlink_sb_port_pool_get,

	.sb_port_pool_set		= dsa_devlink_sb_port_pool_set,

	.sb_tc_pool_bind_get		= dsa_devlink_sb_tc_pool_bind_get,

	.sb_tc_pool_bind_set		= dsa_devlink_sb_tc_pool_bind_set,

	.sb_occ_snapshot		= dsa_devlink_sb_occ_snapshot,

	.sb_occ_max_clear		= dsa_devlink_sb_occ_max_clear,

	.sb_occ_port_pool_get		= dsa_devlink_sb_occ_port_pool_get,

	.sb_occ_tc_port_bind_get	= dsa_devlink_sb_occ_tc_port_bind_get,

};



static int dsa_switch_setup_tag_protocol(struct dsa_switch *ds)

{

	const struct dsa_device_ops *tag_ops = ds->dst->tag_ops;