[linux-block.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 <florian@openwrt.org>
 */

#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;
};

/* Function takes a reference on the module owning the tagger,
 * so dsa_tag_driver_put must be called afterwards.
 */
const struct dsa_device_ops *dsa_find_tagger_by_name(const char *buf)
{
	const struct dsa_device_ops *ops = ERR_PTR(-ENOPROTOOPT);
	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) {
		const struct dsa_device_ops *tmp = dsa_tag_driver->ops;

		if (!sysfs_streq(buf, tmp->name))
			continue;

		if (!try_module_get(dsa_tag_driver->owner))
			break;

		ops = tmp;
		break;
	}
	mutex_unlock(&dsa_tag_drivers_lock);

	return ops;
}

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 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;
	skb_push(skb, ETH_HLEN);
	skb->pkt_type = PACKET_HOST;
	skb->protocol = eth_type_trans(skb, skb->dev);

	if (unlikely(!dsa_slave_dev_check(skb->dev))) {
		/* Packet is to be injected directly on an upper
		 * device, e.g. a team/bond, so skip all DSA-port
		 * specific actions.
		 */
		netif_rx(skb);
		return 0;
	}

	p = netdev_priv(skb->dev);

	if (unlikely(cpu_dp->ds->untag_bridge_pvid)) {
		nskb = dsa_untag_bridge_pvid(skb);
		if (!nskb) {
			kfree_skb(skb);
			return 0;
		}
		skb = nskb;
	}

	dev_sw_netstats_rx_add(skb->dev, skb->len);

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

	gro_cells_receive(&p->gcells, 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);
}

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

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))
		return ERR_PTR(-ENODEV);

	return dsa_slave_to_port(netdev);
}
EXPORT_SYMBOL_GPL(dsa_port_from_netdev);

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 <buytenh@wantstofly.org>");
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 <florian@openwrt.org>
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
53da0eba VO	87	/* Function takes a reference on the module owning the tagger,
	88	* so dsa_tag_driver_put must be called afterwards.
	89	*/
	90	const struct dsa_device_ops dsa_find_tagger_by_name(const char buf)
	91	{
	92	const struct dsa_device_ops *ops = ERR_PTR(-ENOPROTOOPT);
	93	struct dsa_tag_driver *dsa_tag_driver;
	94
	95	mutex_lock(&dsa_tag_drivers_lock);
	96	list_for_each_entry(dsa_tag_driver, &dsa_tag_drivers_list, list) {
	97	const struct dsa_device_ops *tmp = dsa_tag_driver->ops;
	98
	99	if (!sysfs_streq(buf, tmp->name))
	100	continue;
	101
	102	if (!try_module_get(dsa_tag_driver->owner))
	103	break;
	104
	105	ops = tmp;
	106	break;
	107	}
	108	mutex_unlock(&dsa_tag_drivers_lock);
	109
	110	return ops;
	111	}
	112
c39e2a1d	113	const struct dsa_device_ops *dsa_tag_driver_get(int tag_protocol)
39a7f2a4	114	{
36756175	115	struct dsa_tag_driver *dsa_tag_driver;
39a7f2a4	116	const struct dsa_device_ops *ops;
36756175	117	bool found = false;
39a7f2a4	118
ee91a83e	119	request_module("%s%d", DSA_TAG_DRIVER_ALIAS, tag_protocol);
36756175 AL	120
	121	mutex_lock(&dsa_tag_drivers_lock);
	122	list_for_each_entry(dsa_tag_driver, &dsa_tag_drivers_list, list) {
	123	ops = dsa_tag_driver->ops;
	124	if (ops->proto == tag_protocol) {
	125	found = true;
	126	break;
	127	}
	128	}
	129
	130	if (found) {
	131	if (!try_module_get(dsa_tag_driver->owner))
	132	ops = ERR_PTR(-ENOPROTOOPT);
	133	} else {
	134	ops = ERR_PTR(-ENOPROTOOPT);
	135	}
	136
	137	mutex_unlock(&dsa_tag_drivers_lock);
39a7f2a4 AL	138
	139	return ops;
	140	}
	141
4dad81ee AL	142	void dsa_tag_driver_put(const struct dsa_device_ops *ops)
4dad81ee AL	143	{
36756175 AL	144	struct dsa_tag_driver *dsa_tag_driver;
	145
	146	mutex_lock(&dsa_tag_drivers_lock);
	147	list_for_each_entry(dsa_tag_driver, &dsa_tag_drivers_list, list) {
	148	if (dsa_tag_driver->ops == ops) {
	149	module_put(dsa_tag_driver->owner);
	150	break;
	151	}
	152	}
	153	mutex_unlock(&dsa_tag_drivers_lock);
4dad81ee AL	154	}
4dad81ee AL	155
91da11f8 LB	156	static int dev_is_class(struct device dev, void class)
	157	{
	158	if (dev->class != NULL && !strcmp(dev->class->name, class))
	159	return 1;
	160
	161	return 0;
	162	}
	163
	164	static struct device dev_find_class(struct device parent, char *class)
	165	{
	166	if (dev_is_class(parent, class)) {
	167	get_device(parent);
	168	return parent;
	169	}
	170
	171	return device_find_child(parent, class, dev_is_class);
	172	}
	173
14b89f36	174	struct net_device dsa_dev_to_net_device(struct device dev)
91da11f8 LB	175	{
	176	struct device *d;
	177
	178	d = dev_find_class(dev, "net");
	179	if (d != NULL) {
	180	struct net_device *nd;
	181
	182	nd = to_net_dev(d);
	183	dev_hold(nd);
	184	put_device(d);
	185
	186	return nd;
	187	}
	188
	189	return NULL;
	190	}
14b89f36	191	EXPORT_SYMBOL_GPL(dsa_dev_to_net_device);
91da11f8	192
90af1059 BS	193	/* Determine if we should defer delivery of skb until we have a rx timestamp.
	194	*
	195	* Called from dsa_switch_rcv. For now, this will only work if tagging is
	196	* enabled on the switch. Normally the MAC driver would retrieve the hardware
	197	* timestamp when it reads the packet out of the hardware. However in a DSA
	198	* switch, the DSA driver owning the interface to which the packet is
	199	* delivered is never notified unless we do so here.
	200	*/
	201	static bool dsa_skb_defer_rx_timestamp(struct dsa_slave_priv *p,
	202	struct sk_buff *skb)
	203	{
	204	struct dsa_switch *ds = p->dp->ds;
	205	unsigned int type;
	206
	207	if (skb_headroom(skb) < ETH_HLEN)
	208	return false;
	209
	210	__skb_push(skb, ETH_HLEN);
	211
	212	type = ptp_classify_raw(skb);
	213
	214	__skb_pull(skb, ETH_HLEN);
	215
	216	if (type == PTP_CLASS_NONE)
	217	return false;
	218
	219	if (likely(ds->ops->port_rxtstamp))
	220	return ds->ops->port_rxtstamp(ds, p->dp->index, skb, type);
	221
	222	return false;
	223	}
	224
3e8a72d1	225	static int dsa_switch_rcv(struct sk_buff skb, struct net_device dev,
89e49506	226	struct packet_type pt, struct net_device unused)
3e8a72d1	227	{
2f657a60	228	struct dsa_port *cpu_dp = dev->dsa_ptr;
a86d8bec	229	struct sk_buff *nskb = NULL;
f613ed66	230	struct dsa_slave_priv *p;
3e8a72d1	231
2f657a60	232	if (unlikely(!cpu_dp)) {
3e8a72d1 FF	233	kfree_skb(skb);
	234	return 0;
	235	}
	236
16c5dcb1 FF	237	skb = skb_unshare(skb, GFP_ATOMIC);
	238	if (!skb)
	239	return 0;
	240
2f657a60	241	nskb = cpu_dp->rcv(skb, dev, pt);
a86d8bec FF	242	if (!nskb) {
	243	kfree_skb(skb);
	244	return 0;
	245	}
	246
	247	skb = nskb;
	248	skb_push(skb, ETH_HLEN);
	249	skb->pkt_type = PACKET_HOST;
	250	skb->protocol = eth_type_trans(skb, skb->dev);
	251
5b60dadb TW	252	if (unlikely(!dsa_slave_dev_check(skb->dev))) {
	253	/* Packet is to be injected directly on an upper
	254	* device, e.g. a team/bond, so skip all DSA-port
	255	* specific actions.
	256	*/
	257	netif_rx(skb);
	258	return 0;
	259	}
	260
	261	p = netdev_priv(skb->dev);
	262
1dc0408c FF	263	if (unlikely(cpu_dp->ds->untag_bridge_pvid)) {
	264	nskb = dsa_untag_bridge_pvid(skb);
	265	if (!nskb) {
	266	kfree_skb(skb);
	267	return 0;
	268	}
	269	skb = nskb;
	270	}
	271
6a900628	272	dev_sw_netstats_rx_add(skb->dev, skb->len);
a86d8bec	273
90af1059 BS	274	if (dsa_skb_defer_rx_timestamp(p, skb))
	275	return 0;
	276
e131a563	277	gro_cells_receive(&p->gcells, skb);
a86d8bec FF	278
a86d8bec FF	279	return 0;
3e8a72d1 FF	280	}
3e8a72d1 FF	281
ac2629a4	282	#ifdef CONFIG_PM_SLEEP
e7d53ad3 VD	283	static bool dsa_is_port_initialized(struct dsa_switch *ds, int p)
e7d53ad3 VD	284	{
68bb8ea8 VD	285	const struct dsa_port *dp = dsa_to_port(ds, p);
	286
	287	return dp->type == DSA_PORT_TYPE_USER && dp->slave;
e7d53ad3 VD	288	}
e7d53ad3 VD	289
ac2629a4 FF	290	int dsa_switch_suspend(struct dsa_switch *ds)
	291	{
	292	int i, ret = 0;
	293
	294	/* Suspend slave network devices */
	295	for (i = 0; i < ds->num_ports; i++) {
	296	if (!dsa_is_port_initialized(ds, i))
	297	continue;
	298
68bb8ea8	299	ret = dsa_slave_suspend(dsa_to_port(ds, i)->slave);
ac2629a4 FF	300	if (ret)
	301	return ret;
	302	}
	303
	304	if (ds->ops->suspend)
	305	ret = ds->ops->suspend(ds);
	306
	307	return ret;
	308	}
	309	EXPORT_SYMBOL_GPL(dsa_switch_suspend);
	310
	311	int dsa_switch_resume(struct dsa_switch *ds)
	312	{
	313	int i, ret = 0;
	314
	315	if (ds->ops->resume)
	316	ret = ds->ops->resume(ds);
	317
	318	if (ret)
	319	return ret;
	320
	321	/* Resume slave network devices */
	322	for (i = 0; i < ds->num_ports; i++) {
	323	if (!dsa_is_port_initialized(ds, i))
	324	continue;
	325
68bb8ea8	326	ret = dsa_slave_resume(dsa_to_port(ds, i)->slave);
ac2629a4 FF	327	if (ret)
	328	return ret;
	329	}
	330
	331	return 0;
	332	}
	333	EXPORT_SYMBOL_GPL(dsa_switch_resume);
	334	#endif
	335
61b7363f	336	static struct packet_type dsa_pack_type __read_mostly = {
3e8a72d1 FF	337	.type = cpu_to_be16(ETH_P_XDSA),
	338	.func = dsa_switch_rcv,
	339	};
	340
c9eb3e0f AS	341	static struct workqueue_struct *dsa_owq;
	342
	343	bool dsa_schedule_work(struct work_struct *work)
	344	{
	345	return queue_work(dsa_owq, work);
	346	}
	347
6b297524 AL	348	int dsa_devlink_param_get(struct devlink *dl, u32 id,
	349	struct devlink_param_gset_ctx *ctx)
	350	{
ccc3e6b0	351	struct dsa_switch *ds = dsa_devlink_to_ds(dl);
6b297524 AL	352
	353	if (!ds->ops->devlink_param_get)
	354	return -EOPNOTSUPP;
	355
	356	return ds->ops->devlink_param_get(ds, id, ctx);
	357	}
	358	EXPORT_SYMBOL_GPL(dsa_devlink_param_get);
	359
	360	int dsa_devlink_param_set(struct devlink *dl, u32 id,
	361	struct devlink_param_gset_ctx *ctx)
	362	{
ccc3e6b0	363	struct dsa_switch *ds = dsa_devlink_to_ds(dl);
6b297524 AL	364
	365	if (!ds->ops->devlink_param_set)
	366	return -EOPNOTSUPP;
	367
	368	return ds->ops->devlink_param_set(ds, id, ctx);
	369	}
	370	EXPORT_SYMBOL_GPL(dsa_devlink_param_set);
	371
	372	int dsa_devlink_params_register(struct dsa_switch *ds,
	373	const struct devlink_param *params,
	374	size_t params_count)
	375	{
	376	return devlink_params_register(ds->devlink, params, params_count);
	377	}
	378	EXPORT_SYMBOL_GPL(dsa_devlink_params_register);
	379
	380	void dsa_devlink_params_unregister(struct dsa_switch *ds,
	381	const struct devlink_param *params,
	382	size_t params_count)
	383	{
	384	devlink_params_unregister(ds->devlink, params, params_count);
	385	}
	386	EXPORT_SYMBOL_GPL(dsa_devlink_params_unregister);
	387
5cd73fbd AL	388	int dsa_devlink_resource_register(struct dsa_switch *ds,
	389	const char *resource_name,
	390	u64 resource_size,
	391	u64 resource_id,
	392	u64 parent_resource_id,
	393	const struct devlink_resource_size_params *size_params)
	394	{
	395	return devlink_resource_register(ds->devlink, resource_name,
	396	resource_size, resource_id,
	397	parent_resource_id,
	398	size_params);
	399	}
	400	EXPORT_SYMBOL_GPL(dsa_devlink_resource_register);
	401
	402	void dsa_devlink_resources_unregister(struct dsa_switch *ds)
	403	{
	404	devlink_resources_unregister(ds->devlink, NULL);
	405	}
	406	EXPORT_SYMBOL_GPL(dsa_devlink_resources_unregister);
	407
	408	void dsa_devlink_resource_occ_get_register(struct dsa_switch *ds,
	409	u64 resource_id,
	410	devlink_resource_occ_get_t *occ_get,
	411	void *occ_get_priv)
	412	{
	413	return devlink_resource_occ_get_register(ds->devlink, resource_id,
	414	occ_get, occ_get_priv);
	415	}
	416	EXPORT_SYMBOL_GPL(dsa_devlink_resource_occ_get_register);
	417
	418	void dsa_devlink_resource_occ_get_unregister(struct dsa_switch *ds,
	419	u64 resource_id)
	420	{
	421	devlink_resource_occ_get_unregister(ds->devlink, resource_id);
	422	}
	423	EXPORT_SYMBOL_GPL(dsa_devlink_resource_occ_get_unregister);
	424
97c82c23 AL	425	struct devlink_region *
	426	dsa_devlink_region_create(struct dsa_switch *ds,
	427	const struct devlink_region_ops *ops,
	428	u32 region_max_snapshots, u64 region_size)
	429	{
	430	return devlink_region_create(ds->devlink, ops, region_max_snapshots,
	431	region_size);
	432	}
	433	EXPORT_SYMBOL_GPL(dsa_devlink_region_create);
	434
08156ba4 AL	435	struct devlink_region *
	436	dsa_devlink_port_region_create(struct dsa_switch *ds,
	437	int port,
	438	const struct devlink_port_region_ops *ops,
	439	u32 region_max_snapshots, u64 region_size)
	440	{
	441	struct dsa_port *dp = dsa_to_port(ds, port);
	442
	443	return devlink_port_region_create(&dp->devlink_port, ops,
	444	region_max_snapshots,
	445	region_size);
	446	}
	447	EXPORT_SYMBOL_GPL(dsa_devlink_port_region_create);
	448
97c82c23 AL	449	void dsa_devlink_region_destroy(struct devlink_region *region)
	450	{
	451	devlink_region_destroy(region);
	452	}
	453	EXPORT_SYMBOL_GPL(dsa_devlink_region_destroy);
	454
e1eea811 VO	455	struct dsa_port dsa_port_from_netdev(struct net_device netdev)
	456	{
	457	if (!netdev \|\| !dsa_slave_dev_check(netdev))
	458	return ERR_PTR(-ENODEV);
	459
	460	return dsa_slave_to_port(netdev);
	461	}
	462	EXPORT_SYMBOL_GPL(dsa_port_from_netdev);
	463
91da11f8 LB	464	static int __init dsa_init_module(void)
91da11f8 LB	465	{
7df899c3 BH	466	int rc;
7df899c3 BH	467
c9eb3e0f AS	468	dsa_owq = alloc_ordered_workqueue("dsa_ordered",
	469	WQ_MEM_RECLAIM);
	470	if (!dsa_owq)
	471	return -ENOMEM;
	472
88e4f0ca VD	473	rc = dsa_slave_register_notifier();
88e4f0ca VD	474	if (rc)
68be9302	475	goto register_notifier_fail;
b73adef6	476
3e8a72d1 FF	477	dev_add_pack(&dsa_pack_type);
3e8a72d1 FF	478
409065b0 AL	479	dsa_tag_driver_register(&DSA_TAG_DRIVER_NAME(none_ops),
	480	THIS_MODULE);
	481
7df899c3	482	return 0;
68be9302	483
68be9302 Y	484	register_notifier_fail:
	485	destroy_workqueue(dsa_owq);
	486
	487	return rc;
91da11f8 LB	488	}
	489	module_init(dsa_init_module);
	490
	491	static void __exit dsa_cleanup_module(void)
	492	{
409065b0 AL	493	dsa_tag_driver_unregister(&DSA_TAG_DRIVER_NAME(none_ops));
409065b0 AL	494
88e4f0ca	495	dsa_slave_unregister_notifier();
3e8a72d1	496	dev_remove_pack(&dsa_pack_type);
c9eb3e0f	497	destroy_workqueue(dsa_owq);
91da11f8 LB	498	}
	499	module_exit(dsa_cleanup_module);
	500
577d6a7c	501	MODULE_AUTHOR("Lennert Buytenhek <buytenh@wantstofly.org>");
91da11f8 LB	502	MODULE_DESCRIPTION("Driver for Distributed Switch Architecture switch chips");
	503	MODULE_LICENSE("GPL");
	504	MODULE_ALIAS("platform:dsa");