[linux.git] / net / dsa / dsa.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * net/dsa/dsa.c - Hardware switch handling
 * Copyright (c) 2008-2009 Marvell Semiconductor
 * Copyright (c) 2013 Florian Fainelli <[email protected]>
 */

#include <linux/device.h>
#include <linux/list.h>
#include <linux/platform_device.h>
#include <linux/slab.h>
#include <linux/module.h>
#include <linux/notifier.h>
#include <linux/of.h>
#include <linux/of_mdio.h>
#include <linux/of_platform.h>
#include <linux/of_net.h>
#include <linux/netdevice.h>
#include <linux/sysfs.h>
#include <linux/phy_fixed.h>
#include <linux/ptp_classify.h>
#include <linux/etherdevice.h>

#include "dsa_priv.h"

static LIST_HEAD(dsa_tag_drivers_list);
static DEFINE_MUTEX(dsa_tag_drivers_lock);

static struct sk_buff *dsa_slave_notag_xmit(struct sk_buff *skb,
					    struct net_device *dev)
{
	/* Just return the original SKB */
	return skb;
}

static const struct dsa_device_ops none_ops = {
	.name	= "none",
	.proto	= DSA_TAG_PROTO_NONE,
	.xmit	= dsa_slave_notag_xmit,
	.rcv	= NULL,
};

DSA_TAG_DRIVER(none_ops);

static void dsa_tag_driver_register(struct dsa_tag_driver *dsa_tag_driver,
				    struct module *owner)
{
	dsa_tag_driver->owner = owner;

	mutex_lock(&dsa_tag_drivers_lock);
	list_add_tail(&dsa_tag_driver->list, &dsa_tag_drivers_list);
	mutex_unlock(&dsa_tag_drivers_lock);
}

void dsa_tag_drivers_register(struct dsa_tag_driver *dsa_tag_driver_array[],
			      unsigned int count, struct module *owner)
{
	unsigned int i;

	for (i = 0; i < count; i++)
		dsa_tag_driver_register(dsa_tag_driver_array[i], owner);
}

static void dsa_tag_driver_unregister(struct dsa_tag_driver *dsa_tag_driver)
{
	mutex_lock(&dsa_tag_drivers_lock);
	list_del(&dsa_tag_driver->list);
	mutex_unlock(&dsa_tag_drivers_lock);
}
EXPORT_SYMBOL_GPL(dsa_tag_drivers_register);

void dsa_tag_drivers_unregister(struct dsa_tag_driver *dsa_tag_driver_array[],
				unsigned int count)
{
	unsigned int i;

	for (i = 0; i < count; i++)
		dsa_tag_driver_unregister(dsa_tag_driver_array[i]);
}
EXPORT_SYMBOL_GPL(dsa_tag_drivers_unregister);

const char *dsa_tag_protocol_to_str(const struct dsa_device_ops *ops)
{
	return ops->name;
};

const struct dsa_device_ops *dsa_tag_driver_get(int tag_protocol)
{
	struct dsa_tag_driver *dsa_tag_driver;
	const struct dsa_device_ops *ops;
	bool found = false;

	request_module("%s%d", DSA_TAG_DRIVER_ALIAS, tag_protocol);

	mutex_lock(&dsa_tag_drivers_lock);
	list_for_each_entry(dsa_tag_driver, &dsa_tag_drivers_list, list) {
		ops = dsa_tag_driver->ops;
		if (ops->proto == tag_protocol) {
			found = true;
			break;
		}
	}

	if (found) {
		if (!try_module_get(dsa_tag_driver->owner))
			ops = ERR_PTR(-ENOPROTOOPT);
	} else {
		ops = ERR_PTR(-ENOPROTOOPT);
	}

	mutex_unlock(&dsa_tag_drivers_lock);

	return ops;
}

void dsa_tag_driver_put(const struct dsa_device_ops *ops)
{
	struct dsa_tag_driver *dsa_tag_driver;

	mutex_lock(&dsa_tag_drivers_lock);
	list_for_each_entry(dsa_tag_driver, &dsa_tag_drivers_list, list) {
		if (dsa_tag_driver->ops == ops) {
			module_put(dsa_tag_driver->owner);
			break;
		}
	}
	mutex_unlock(&dsa_tag_drivers_lock);
}

static int dev_is_class(struct device *dev, void *class)
{
	if (dev->class != NULL && !strcmp(dev->class->name, class))
		return 1;

	return 0;
}

static struct device *dev_find_class(struct device *parent, char *class)
{
	if (dev_is_class(parent, class)) {
		get_device(parent);
		return parent;
	}

	return device_find_child(parent, class, dev_is_class);
}

struct net_device *dsa_dev_to_net_device(struct device *dev)
{
	struct device *d;

	d = dev_find_class(dev, "net");
	if (d != NULL) {
		struct net_device *nd;

		nd = to_net_dev(d);
		dev_hold(nd);
		put_device(d);

		return nd;
	}

	return NULL;
}
EXPORT_SYMBOL_GPL(dsa_dev_to_net_device);

/* Determine if we should defer delivery of skb until we have a rx timestamp.
 *
 * Called from dsa_switch_rcv. For now, this will only work if tagging is
 * enabled on the switch. Normally the MAC driver would retrieve the hardware
 * timestamp when it reads the packet out of the hardware. However in a DSA
 * switch, the DSA driver owning the interface to which the packet is
 * delivered is never notified unless we do so here.
 */
static bool dsa_skb_defer_rx_timestamp(struct dsa_slave_priv *p,
				       struct sk_buff *skb)
{
	struct dsa_switch *ds = p->dp->ds;
	unsigned int type;

	if (skb_headroom(skb) < ETH_HLEN)
		return false;

	__skb_push(skb, ETH_HLEN);

	type = ptp_classify_raw(skb);

	__skb_pull(skb, ETH_HLEN);

	if (type == PTP_CLASS_NONE)
		return false;

	if (likely(ds->ops->port_rxtstamp))
		return ds->ops->port_rxtstamp(ds, p->dp->index, skb, type);

	return false;
}

static int dsa_switch_rcv(struct sk_buff *skb, struct net_device *dev,
			  struct packet_type *pt, struct net_device *unused)
{
	struct dsa_port *cpu_dp = dev->dsa_ptr;
	struct sk_buff *nskb = NULL;
	struct pcpu_sw_netstats *s;
	struct dsa_slave_priv *p;

	if (unlikely(!cpu_dp)) {
		kfree_skb(skb);
		return 0;
	}

	skb = skb_unshare(skb, GFP_ATOMIC);
	if (!skb)
		return 0;

	nskb = cpu_dp->rcv(skb, dev, pt);
	if (!nskb) {
		kfree_skb(skb);
		return 0;
	}

	skb = nskb;
	p = netdev_priv(skb->dev);
	skb_push(skb, ETH_HLEN);
	skb->pkt_type = PACKET_HOST;
	skb->protocol = eth_type_trans(skb, skb->dev);

	s = this_cpu_ptr(p->stats64);
	u64_stats_update_begin(&s->syncp);
	s->rx_packets++;
	s->rx_bytes += skb->len;
	u64_stats_update_end(&s->syncp);

	if (dsa_skb_defer_rx_timestamp(p, skb))
		return 0;

	netif_receive_skb(skb);

	return 0;
}

#ifdef CONFIG_PM_SLEEP
static bool dsa_is_port_initialized(struct dsa_switch *ds, int p)
{
	const struct dsa_port *dp = dsa_to_port(ds, p);

	return dp->type == DSA_PORT_TYPE_USER && dp->slave;
}

int dsa_switch_suspend(struct dsa_switch *ds)
{
	int i, ret = 0;

	/* Suspend slave network devices */
	for (i = 0; i < ds->num_ports; i++) {
		if (!dsa_is_port_initialized(ds, i))
			continue;

		ret = dsa_slave_suspend(dsa_to_port(ds, i)->slave);
		if (ret)
			return ret;
	}

	if (ds->ops->suspend)
		ret = ds->ops->suspend(ds);

	return ret;
}
EXPORT_SYMBOL_GPL(dsa_switch_suspend);

int dsa_switch_resume(struct dsa_switch *ds)
{
	int i, ret = 0;

	if (ds->ops->resume)
		ret = ds->ops->resume(ds);

	if (ret)
		return ret;

	/* Resume slave network devices */
	for (i = 0; i < ds->num_ports; i++) {
		if (!dsa_is_port_initialized(ds, i))
			continue;

		ret = dsa_slave_resume(dsa_to_port(ds, i)->slave);
		if (ret)
			return ret;
	}

	return 0;
}
EXPORT_SYMBOL_GPL(dsa_switch_resume);
#endif

static struct packet_type dsa_pack_type __read_mostly = {
	.type	= cpu_to_be16(ETH_P_XDSA),
	.func	= dsa_switch_rcv,
};

static struct workqueue_struct *dsa_owq;

bool dsa_schedule_work(struct work_struct *work)
{
	return queue_work(dsa_owq, work);
}

static ATOMIC_NOTIFIER_HEAD(dsa_notif_chain);

int register_dsa_notifier(struct notifier_block *nb)
{
	return atomic_notifier_chain_register(&dsa_notif_chain, nb);
}
EXPORT_SYMBOL_GPL(register_dsa_notifier);

int unregister_dsa_notifier(struct notifier_block *nb)
{
	return atomic_notifier_chain_unregister(&dsa_notif_chain, nb);
}
EXPORT_SYMBOL_GPL(unregister_dsa_notifier);

int call_dsa_notifiers(unsigned long val, struct net_device *dev,
		       struct dsa_notifier_info *info)
{
	info->dev = dev;
	return atomic_notifier_call_chain(&dsa_notif_chain, val, info);
}
EXPORT_SYMBOL_GPL(call_dsa_notifiers);

int dsa_devlink_param_get(struct devlink *dl, u32 id,
			  struct devlink_param_gset_ctx *ctx)
{
	struct dsa_devlink_priv *dl_priv;
	struct dsa_switch *ds;

	dl_priv = devlink_priv(dl);
	ds = dl_priv->ds;

	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_devlink_priv *dl_priv;
	struct dsa_switch *ds;

	dl_priv = devlink_priv(dl);
	ds = dl_priv->ds;

	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, NULL);
}
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);

static int __init dsa_init_module(void)
{
	int rc;

	dsa_owq = alloc_ordered_workqueue("dsa_ordered",
					  WQ_MEM_RECLAIM);
	if (!dsa_owq)
		return -ENOMEM;

	rc = dsa_slave_register_notifier();
	if (rc)
		goto register_notifier_fail;

	dev_add_pack(&dsa_pack_type);

	dsa_tag_driver_register(&DSA_TAG_DRIVER_NAME(none_ops),
				THIS_MODULE);

	return 0;

register_notifier_fail:
	destroy_workqueue(dsa_owq);

	return rc;
}
module_init(dsa_init_module);

static void __exit dsa_cleanup_module(void)
{
	dsa_tag_driver_unregister(&DSA_TAG_DRIVER_NAME(none_ops));

	dsa_slave_unregister_notifier();
	dev_remove_pack(&dsa_pack_type);
	destroy_workqueue(dsa_owq);
}
module_exit(dsa_cleanup_module);

MODULE_AUTHOR("Lennert Buytenhek <[email protected]>");
MODULE_DESCRIPTION("Driver for Distributed Switch Architecture switch chips");
MODULE_LICENSE("GPL");
MODULE_ALIAS("platform:dsa");
Commit	Line	Data
2874c5fd	1	// SPDX-License-Identifier: GPL-2.0-or-later
91da11f8 LB	2	/*
91da11f8 LB	3	* net/dsa/dsa.c - Hardware switch handling
e84665c9	4	* Copyright (c) 2008-2009 Marvell Semiconductor
5e95329b	5	* Copyright (c) 2013 Florian Fainelli <[email protected]>
91da11f8 LB	6	*/
91da11f8 LB	7
51579c3f	8	#include <linux/device.h>
91da11f8	9	#include <linux/list.h>
91da11f8	10	#include <linux/platform_device.h>
5a0e3ad6	11	#include <linux/slab.h>
3a9a231d	12	#include <linux/module.h>
60724d4b	13	#include <linux/notifier.h>
5e95329b FF	14	#include <linux/of.h>
	15	#include <linux/of_mdio.h>
	16	#include <linux/of_platform.h>
769a0202	17	#include <linux/of_net.h>
c6e970a0	18	#include <linux/netdevice.h>
51579c3f	19	#include <linux/sysfs.h>
cbc5d90b	20	#include <linux/phy_fixed.h>
90af1059	21	#include <linux/ptp_classify.h>
a86d8bec	22	#include <linux/etherdevice.h>
ea5dd34b	23
91da11f8 LB	24	#include "dsa_priv.h"
91da11f8 LB	25
bdc6fe5b AL	26	static LIST_HEAD(dsa_tag_drivers_list);
	27	static DEFINE_MUTEX(dsa_tag_drivers_lock);
	28
39a7f2a4 AL	29	static struct sk_buff dsa_slave_notag_xmit(struct sk_buff skb,
	30	struct net_device *dev)
	31	{
	32	/* Just return the original SKB */
	33	return skb;
	34	}
	35
	36	static const struct dsa_device_ops none_ops = {
875138f8	37	.name = "none",
056eed2f	38	.proto = DSA_TAG_PROTO_NONE,
39a7f2a4 AL	39	.xmit = dsa_slave_notag_xmit,
	40	.rcv = NULL,
	41	};
	42
409065b0 AL	43	DSA_TAG_DRIVER(none_ops);
409065b0 AL	44
bdc6fe5b AL	45	static void dsa_tag_driver_register(struct dsa_tag_driver *dsa_tag_driver,
	46	struct module *owner)
	47	{
	48	dsa_tag_driver->owner = owner;
	49
	50	mutex_lock(&dsa_tag_drivers_lock);
	51	list_add_tail(&dsa_tag_driver->list, &dsa_tag_drivers_list);
	52	mutex_unlock(&dsa_tag_drivers_lock);
	53	}
	54
d3b8c049 AL	55	void dsa_tag_drivers_register(struct dsa_tag_driver *dsa_tag_driver_array[],
	56	unsigned int count, struct module *owner)
	57	{
bdc6fe5b AL	58	unsigned int i;
	59
	60	for (i = 0; i < count; i++)
	61	dsa_tag_driver_register(dsa_tag_driver_array[i], owner);
	62	}
	63
	64	static void dsa_tag_driver_unregister(struct dsa_tag_driver *dsa_tag_driver)
	65	{
	66	mutex_lock(&dsa_tag_drivers_lock);
	67	list_del(&dsa_tag_driver->list);
	68	mutex_unlock(&dsa_tag_drivers_lock);
d3b8c049 AL	69	}
	70	EXPORT_SYMBOL_GPL(dsa_tag_drivers_register);
	71
	72	void dsa_tag_drivers_unregister(struct dsa_tag_driver *dsa_tag_driver_array[],
	73	unsigned int count)
	74	{
bdc6fe5b AL	75	unsigned int i;
	76
	77	for (i = 0; i < count; i++)
	78	dsa_tag_driver_unregister(dsa_tag_driver_array[i]);
d3b8c049 AL	79	}
	80	EXPORT_SYMBOL_GPL(dsa_tag_drivers_unregister);
	81
98cdb480 FF	82	const char dsa_tag_protocol_to_str(const struct dsa_device_ops ops)
98cdb480 FF	83	{
875138f8	84	return ops->name;
98cdb480 FF	85	};
98cdb480 FF	86
c39e2a1d	87	const struct dsa_device_ops *dsa_tag_driver_get(int tag_protocol)
39a7f2a4	88	{
36756175	89	struct dsa_tag_driver *dsa_tag_driver;
39a7f2a4	90	const struct dsa_device_ops *ops;
36756175	91	bool found = false;
39a7f2a4	92
ee91a83e	93	request_module("%s%d", DSA_TAG_DRIVER_ALIAS, tag_protocol);
36756175 AL	94
	95	mutex_lock(&dsa_tag_drivers_lock);
	96	list_for_each_entry(dsa_tag_driver, &dsa_tag_drivers_list, list) {
	97	ops = dsa_tag_driver->ops;
	98	if (ops->proto == tag_protocol) {
	99	found = true;
	100	break;
	101	}
	102	}
	103
	104	if (found) {
	105	if (!try_module_get(dsa_tag_driver->owner))
	106	ops = ERR_PTR(-ENOPROTOOPT);
	107	} else {
	108	ops = ERR_PTR(-ENOPROTOOPT);
	109	}
	110
	111	mutex_unlock(&dsa_tag_drivers_lock);
39a7f2a4 AL	112
	113	return ops;
	114	}
	115
4dad81ee AL	116	void dsa_tag_driver_put(const struct dsa_device_ops *ops)
4dad81ee AL	117	{
36756175 AL	118	struct dsa_tag_driver *dsa_tag_driver;
	119
	120	mutex_lock(&dsa_tag_drivers_lock);
	121	list_for_each_entry(dsa_tag_driver, &dsa_tag_drivers_list, list) {
	122	if (dsa_tag_driver->ops == ops) {
	123	module_put(dsa_tag_driver->owner);
	124	break;
	125	}
	126	}
	127	mutex_unlock(&dsa_tag_drivers_lock);
4dad81ee AL	128	}
4dad81ee AL	129
91da11f8 LB	130	static int dev_is_class(struct device dev, void class)
	131	{
	132	if (dev->class != NULL && !strcmp(dev->class->name, class))
	133	return 1;
	134
	135	return 0;
	136	}
	137
	138	static struct device dev_find_class(struct device parent, char *class)
	139	{
	140	if (dev_is_class(parent, class)) {
	141	get_device(parent);
	142	return parent;
	143	}
	144
	145	return device_find_child(parent, class, dev_is_class);
	146	}
	147
14b89f36	148	struct net_device dsa_dev_to_net_device(struct device dev)
91da11f8 LB	149	{
	150	struct device *d;
	151
	152	d = dev_find_class(dev, "net");
	153	if (d != NULL) {
	154	struct net_device *nd;
	155
	156	nd = to_net_dev(d);
	157	dev_hold(nd);
	158	put_device(d);
	159
	160	return nd;
	161	}
	162
	163	return NULL;
	164	}
14b89f36	165	EXPORT_SYMBOL_GPL(dsa_dev_to_net_device);
91da11f8	166
90af1059 BS	167	/* Determine if we should defer delivery of skb until we have a rx timestamp.
	168	*
	169	* Called from dsa_switch_rcv. For now, this will only work if tagging is
	170	* enabled on the switch. Normally the MAC driver would retrieve the hardware
	171	* timestamp when it reads the packet out of the hardware. However in a DSA
	172	* switch, the DSA driver owning the interface to which the packet is
	173	* delivered is never notified unless we do so here.
	174	*/
	175	static bool dsa_skb_defer_rx_timestamp(struct dsa_slave_priv *p,
	176	struct sk_buff *skb)
	177	{
	178	struct dsa_switch *ds = p->dp->ds;
	179	unsigned int type;
	180
	181	if (skb_headroom(skb) < ETH_HLEN)
	182	return false;
	183
	184	__skb_push(skb, ETH_HLEN);
	185
	186	type = ptp_classify_raw(skb);
	187
	188	__skb_pull(skb, ETH_HLEN);
	189
	190	if (type == PTP_CLASS_NONE)
	191	return false;
	192
	193	if (likely(ds->ops->port_rxtstamp))
	194	return ds->ops->port_rxtstamp(ds, p->dp->index, skb, type);
	195
	196	return false;
	197	}
	198
3e8a72d1	199	static int dsa_switch_rcv(struct sk_buff skb, struct net_device dev,
89e49506	200	struct packet_type pt, struct net_device unused)
3e8a72d1	201	{
2f657a60	202	struct dsa_port *cpu_dp = dev->dsa_ptr;
a86d8bec	203	struct sk_buff *nskb = NULL;
5f6b4e14	204	struct pcpu_sw_netstats *s;
f613ed66	205	struct dsa_slave_priv *p;
3e8a72d1	206
2f657a60	207	if (unlikely(!cpu_dp)) {
3e8a72d1 FF	208	kfree_skb(skb);
	209	return 0;
	210	}
	211
16c5dcb1 FF	212	skb = skb_unshare(skb, GFP_ATOMIC);
	213	if (!skb)
	214	return 0;
	215
2f657a60	216	nskb = cpu_dp->rcv(skb, dev, pt);
a86d8bec FF	217	if (!nskb) {
	218	kfree_skb(skb);
	219	return 0;
	220	}
	221
	222	skb = nskb;
f613ed66	223	p = netdev_priv(skb->dev);
a86d8bec FF	224	skb_push(skb, ETH_HLEN);
	225	skb->pkt_type = PACKET_HOST;
	226	skb->protocol = eth_type_trans(skb, skb->dev);
	227
5f6b4e14 FF	228	s = this_cpu_ptr(p->stats64);
	229	u64_stats_update_begin(&s->syncp);
	230	s->rx_packets++;
	231	s->rx_bytes += skb->len;
	232	u64_stats_update_end(&s->syncp);
a86d8bec	233
90af1059 BS	234	if (dsa_skb_defer_rx_timestamp(p, skb))
	235	return 0;
	236
a86d8bec FF	237	netif_receive_skb(skb);
	238
	239	return 0;
3e8a72d1 FF	240	}
3e8a72d1 FF	241
ac2629a4	242	#ifdef CONFIG_PM_SLEEP
e7d53ad3 VD	243	static bool dsa_is_port_initialized(struct dsa_switch *ds, int p)
e7d53ad3 VD	244	{
68bb8ea8 VD	245	const struct dsa_port *dp = dsa_to_port(ds, p);
	246
	247	return dp->type == DSA_PORT_TYPE_USER && dp->slave;
e7d53ad3 VD	248	}
e7d53ad3 VD	249
ac2629a4 FF	250	int dsa_switch_suspend(struct dsa_switch *ds)
	251	{
	252	int i, ret = 0;
	253
	254	/* Suspend slave network devices */
	255	for (i = 0; i < ds->num_ports; i++) {
	256	if (!dsa_is_port_initialized(ds, i))
	257	continue;
	258
68bb8ea8	259	ret = dsa_slave_suspend(dsa_to_port(ds, i)->slave);
ac2629a4 FF	260	if (ret)
	261	return ret;
	262	}
	263
	264	if (ds->ops->suspend)
	265	ret = ds->ops->suspend(ds);
	266
	267	return ret;
	268	}
	269	EXPORT_SYMBOL_GPL(dsa_switch_suspend);
	270
	271	int dsa_switch_resume(struct dsa_switch *ds)
	272	{
	273	int i, ret = 0;
	274
	275	if (ds->ops->resume)
	276	ret = ds->ops->resume(ds);
	277
	278	if (ret)
	279	return ret;
	280
	281	/* Resume slave network devices */
	282	for (i = 0; i < ds->num_ports; i++) {
	283	if (!dsa_is_port_initialized(ds, i))
	284	continue;
	285
68bb8ea8	286	ret = dsa_slave_resume(dsa_to_port(ds, i)->slave);
ac2629a4 FF	287	if (ret)
	288	return ret;
	289	}
	290
	291	return 0;
	292	}
	293	EXPORT_SYMBOL_GPL(dsa_switch_resume);
	294	#endif
	295
61b7363f	296	static struct packet_type dsa_pack_type __read_mostly = {
3e8a72d1 FF	297	.type = cpu_to_be16(ETH_P_XDSA),
	298	.func = dsa_switch_rcv,
	299	};
	300
c9eb3e0f AS	301	static struct workqueue_struct *dsa_owq;
	302
	303	bool dsa_schedule_work(struct work_struct *work)
	304	{
	305	return queue_work(dsa_owq, work);
	306	}
	307
60724d4b FF	308	static ATOMIC_NOTIFIER_HEAD(dsa_notif_chain);
	309
	310	int register_dsa_notifier(struct notifier_block *nb)
	311	{
	312	return atomic_notifier_chain_register(&dsa_notif_chain, nb);
	313	}
	314	EXPORT_SYMBOL_GPL(register_dsa_notifier);
	315
	316	int unregister_dsa_notifier(struct notifier_block *nb)
	317	{
	318	return atomic_notifier_chain_unregister(&dsa_notif_chain, nb);
	319	}
	320	EXPORT_SYMBOL_GPL(unregister_dsa_notifier);
	321
	322	int call_dsa_notifiers(unsigned long val, struct net_device *dev,
	323	struct dsa_notifier_info *info)
	324	{
	325	info->dev = dev;
	326	return atomic_notifier_call_chain(&dsa_notif_chain, val, info);
	327	}
	328	EXPORT_SYMBOL_GPL(call_dsa_notifiers);
	329
6b297524 AL	330	int dsa_devlink_param_get(struct devlink *dl, u32 id,
	331	struct devlink_param_gset_ctx *ctx)
	332	{
	333	struct dsa_devlink_priv *dl_priv;
	334	struct dsa_switch *ds;
	335
	336	dl_priv = devlink_priv(dl);
	337	ds = dl_priv->ds;
	338
	339	if (!ds->ops->devlink_param_get)
	340	return -EOPNOTSUPP;
	341
	342	return ds->ops->devlink_param_get(ds, id, ctx);
	343	}
	344	EXPORT_SYMBOL_GPL(dsa_devlink_param_get);
	345
	346	int dsa_devlink_param_set(struct devlink *dl, u32 id,
	347	struct devlink_param_gset_ctx *ctx)
	348	{
	349	struct dsa_devlink_priv *dl_priv;
	350	struct dsa_switch *ds;
	351
	352	dl_priv = devlink_priv(dl);
	353	ds = dl_priv->ds;
	354
	355	if (!ds->ops->devlink_param_set)
	356	return -EOPNOTSUPP;
	357
	358	return ds->ops->devlink_param_set(ds, id, ctx);
	359	}
	360	EXPORT_SYMBOL_GPL(dsa_devlink_param_set);
	361
	362	int dsa_devlink_params_register(struct dsa_switch *ds,
	363	const struct devlink_param *params,
	364	size_t params_count)
	365	{
	366	return devlink_params_register(ds->devlink, params, params_count);
	367	}
	368	EXPORT_SYMBOL_GPL(dsa_devlink_params_register);
	369
	370	void dsa_devlink_params_unregister(struct dsa_switch *ds,
	371	const struct devlink_param *params,
	372	size_t params_count)
	373	{
	374	devlink_params_unregister(ds->devlink, params, params_count);
	375	}
	376	EXPORT_SYMBOL_GPL(dsa_devlink_params_unregister);
	377
5cd73fbd AL	378	int dsa_devlink_resource_register(struct dsa_switch *ds,
	379	const char *resource_name,
	380	u64 resource_size,
	381	u64 resource_id,
	382	u64 parent_resource_id,
	383	const struct devlink_resource_size_params *size_params)
	384	{
	385	return devlink_resource_register(ds->devlink, resource_name,
	386	resource_size, resource_id,
	387	parent_resource_id,
	388	size_params);
	389	}
	390	EXPORT_SYMBOL_GPL(dsa_devlink_resource_register);
	391
	392	void dsa_devlink_resources_unregister(struct dsa_switch *ds)
	393	{
	394	devlink_resources_unregister(ds->devlink, NULL);
	395	}
	396	EXPORT_SYMBOL_GPL(dsa_devlink_resources_unregister);
	397
	398	void dsa_devlink_resource_occ_get_register(struct dsa_switch *ds,
	399	u64 resource_id,
	400	devlink_resource_occ_get_t *occ_get,
	401	void *occ_get_priv)
	402	{
	403	return devlink_resource_occ_get_register(ds->devlink, resource_id,
	404	occ_get, occ_get_priv);
	405	}
	406	EXPORT_SYMBOL_GPL(dsa_devlink_resource_occ_get_register);
	407
	408	void dsa_devlink_resource_occ_get_unregister(struct dsa_switch *ds,
	409	u64 resource_id)
	410	{
	411	devlink_resource_occ_get_unregister(ds->devlink, resource_id);
	412	}
	413	EXPORT_SYMBOL_GPL(dsa_devlink_resource_occ_get_unregister);
	414
91da11f8 LB	415	static int __init dsa_init_module(void)
91da11f8 LB	416	{
7df899c3 BH	417	int rc;
7df899c3 BH	418
c9eb3e0f AS	419	dsa_owq = alloc_ordered_workqueue("dsa_ordered",
	420	WQ_MEM_RECLAIM);
	421	if (!dsa_owq)
	422	return -ENOMEM;
	423
88e4f0ca VD	424	rc = dsa_slave_register_notifier();
88e4f0ca VD	425	if (rc)
68be9302	426	goto register_notifier_fail;
b73adef6	427
3e8a72d1 FF	428	dev_add_pack(&dsa_pack_type);
3e8a72d1 FF	429
409065b0 AL	430	dsa_tag_driver_register(&DSA_TAG_DRIVER_NAME(none_ops),
	431	THIS_MODULE);
	432
7df899c3	433	return 0;
68be9302	434
68be9302 Y	435	register_notifier_fail:
	436	destroy_workqueue(dsa_owq);
	437
	438	return rc;
91da11f8 LB	439	}
	440	module_init(dsa_init_module);
	441
	442	static void __exit dsa_cleanup_module(void)
	443	{
409065b0 AL	444	dsa_tag_driver_unregister(&DSA_TAG_DRIVER_NAME(none_ops));
409065b0 AL	445
88e4f0ca	446	dsa_slave_unregister_notifier();
3e8a72d1	447	dev_remove_pack(&dsa_pack_type);
c9eb3e0f	448	destroy_workqueue(dsa_owq);
91da11f8 LB	449	}
	450	module_exit(dsa_cleanup_module);
	451
577d6a7c	452	MODULE_AUTHOR("Lennert Buytenhek <[email protected]>");
91da11f8 LB	453	MODULE_DESCRIPTION("Driver for Distributed Switch Architecture switch chips");
	454	MODULE_LICENSE("GPL");
	455	MODULE_ALIAS("platform:dsa");