[linux-2.6-block.git] / net / dsa / switch.c

/*
 * Handling of a single switch chip, part of a switch fabric
 *
 * Copyright (c) 2017 Savoir-faire Linux Inc.
 *	Vivien Didelot <vivien.didelot@savoirfairelinux.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 */

#include <linux/netdevice.h>
#include <linux/notifier.h>
#include <net/switchdev.h>

#include "dsa_priv.h"

static unsigned int dsa_switch_fastest_ageing_time(struct dsa_switch *ds,
						   unsigned int ageing_time)
{
	int i;

	for (i = 0; i < ds->num_ports; ++i) {
		struct dsa_port *dp = &ds->ports[i];

		if (dp->ageing_time && dp->ageing_time < ageing_time)
			ageing_time = dp->ageing_time;
	}

	return ageing_time;
}

static int dsa_switch_ageing_time(struct dsa_switch *ds,
				  struct dsa_notifier_ageing_time_info *info)
{
	unsigned int ageing_time = info->ageing_time;
	struct switchdev_trans *trans = info->trans;

	if (switchdev_trans_ph_prepare(trans)) {
		if (ds->ageing_time_min && ageing_time < ds->ageing_time_min)
			return -ERANGE;
		if (ds->ageing_time_max && ageing_time > ds->ageing_time_max)
			return -ERANGE;
		return 0;
	}

	/* Program the fastest ageing time in case of multiple bridges */
	ageing_time = dsa_switch_fastest_ageing_time(ds, ageing_time);

	if (ds->ops->set_ageing_time)
		return ds->ops->set_ageing_time(ds, ageing_time);

	return 0;
}

static int dsa_switch_bridge_join(struct dsa_switch *ds,
				  struct dsa_notifier_bridge_info *info)
{
	if (ds->index == info->sw_index && ds->ops->port_bridge_join)
		return ds->ops->port_bridge_join(ds, info->port, info->br);

	if (ds->index != info->sw_index && ds->ops->crosschip_bridge_join)
		return ds->ops->crosschip_bridge_join(ds, info->sw_index,
						      info->port, info->br);

	return 0;
}

static int dsa_switch_bridge_leave(struct dsa_switch *ds,
				   struct dsa_notifier_bridge_info *info)
{
	if (ds->index == info->sw_index && ds->ops->port_bridge_leave)
		ds->ops->port_bridge_leave(ds, info->port, info->br);

	if (ds->index != info->sw_index && ds->ops->crosschip_bridge_leave)
		ds->ops->crosschip_bridge_leave(ds, info->sw_index, info->port,
						info->br);

	return 0;
}

static int dsa_switch_fdb_add(struct dsa_switch *ds,
			      struct dsa_notifier_fdb_info *info)
{
	int port = dsa_towards_port(ds, info->sw_index, info->port);

	if (!ds->ops->port_fdb_add)
		return -EOPNOTSUPP;

	return ds->ops->port_fdb_add(ds, port, info->addr, info->vid);
}

static int dsa_switch_fdb_del(struct dsa_switch *ds,
			      struct dsa_notifier_fdb_info *info)
{
	int port = dsa_towards_port(ds, info->sw_index, info->port);

	if (!ds->ops->port_fdb_del)
		return -EOPNOTSUPP;

	return ds->ops->port_fdb_del(ds, port, info->addr, info->vid);
}

static int
dsa_switch_mdb_prepare_bitmap(struct dsa_switch *ds,
			      const struct switchdev_obj_port_mdb *mdb,
			      const unsigned long *bitmap)
{
	int port, err;

	if (!ds->ops->port_mdb_prepare || !ds->ops->port_mdb_add)
		return -EOPNOTSUPP;

	for_each_set_bit(port, bitmap, ds->num_ports) {
		err = ds->ops->port_mdb_prepare(ds, port, mdb);
		if (err)
			return err;
	}

	return 0;
}

static void dsa_switch_mdb_add_bitmap(struct dsa_switch *ds,
				      const struct switchdev_obj_port_mdb *mdb,
				      const unsigned long *bitmap)
{
	int port;

	for_each_set_bit(port, bitmap, ds->num_ports)
		ds->ops->port_mdb_add(ds, port, mdb);
}

static int dsa_switch_mdb_add(struct dsa_switch *ds,
			      struct dsa_notifier_mdb_info *info)
{
	const struct switchdev_obj_port_mdb *mdb = info->mdb;
	struct switchdev_trans *trans = info->trans;
	DECLARE_BITMAP(group, ds->num_ports);
	int port;

	/* Build a mask of Multicast group members */
	bitmap_zero(group, ds->num_ports);
	if (ds->index == info->sw_index)
		set_bit(info->port, group);
	for (port = 0; port < ds->num_ports; port++)
		if (dsa_is_dsa_port(ds, port))
			set_bit(port, group);

	if (switchdev_trans_ph_prepare(trans))
		return dsa_switch_mdb_prepare_bitmap(ds, mdb, group);

	dsa_switch_mdb_add_bitmap(ds, mdb, group);

	return 0;
}

static int dsa_switch_mdb_del(struct dsa_switch *ds,
			      struct dsa_notifier_mdb_info *info)
{
	const struct switchdev_obj_port_mdb *mdb = info->mdb;

	if (!ds->ops->port_mdb_del)
		return -EOPNOTSUPP;

	if (ds->index == info->sw_index)
		return ds->ops->port_mdb_del(ds, info->port, mdb);

	return 0;
}

static int
dsa_switch_vlan_prepare_bitmap(struct dsa_switch *ds,
			       const struct switchdev_obj_port_vlan *vlan,
			       const unsigned long *bitmap)
{
	int port, err;

	if (!ds->ops->port_vlan_prepare || !ds->ops->port_vlan_add)
		return -EOPNOTSUPP;

	for_each_set_bit(port, bitmap, ds->num_ports) {
		err = ds->ops->port_vlan_prepare(ds, port, vlan);
		if (err)
			return err;
	}

	return 0;
}

static void
dsa_switch_vlan_add_bitmap(struct dsa_switch *ds,
			   const struct switchdev_obj_port_vlan *vlan,
			   const unsigned long *bitmap)
{
	int port;

	for_each_set_bit(port, bitmap, ds->num_ports)
		ds->ops->port_vlan_add(ds, port, vlan);
}

static int dsa_switch_vlan_add(struct dsa_switch *ds,
			       struct dsa_notifier_vlan_info *info)
{
	const struct switchdev_obj_port_vlan *vlan = info->vlan;
	struct switchdev_trans *trans = info->trans;
	DECLARE_BITMAP(members, ds->num_ports);
	int port;

	/* Build a mask of VLAN members */
	bitmap_zero(members, ds->num_ports);
	if (ds->index == info->sw_index)
		set_bit(info->port, members);
	for (port = 0; port < ds->num_ports; port++)
		if (dsa_is_cpu_port(ds, port) || dsa_is_dsa_port(ds, port))
			set_bit(port, members);

	if (switchdev_trans_ph_prepare(trans))
		return dsa_switch_vlan_prepare_bitmap(ds, vlan, members);

	dsa_switch_vlan_add_bitmap(ds, vlan, members);

	return 0;
}

static int dsa_switch_vlan_del(struct dsa_switch *ds,
			       struct dsa_notifier_vlan_info *info)
{
	const struct switchdev_obj_port_vlan *vlan = info->vlan;

	if (!ds->ops->port_vlan_del)
		return -EOPNOTSUPP;

	if (ds->index == info->sw_index)
		return ds->ops->port_vlan_del(ds, info->port, vlan);

	return 0;
}

static int dsa_switch_event(struct notifier_block *nb,
			    unsigned long event, void *info)
{
	struct dsa_switch *ds = container_of(nb, struct dsa_switch, nb);
	int err;

	switch (event) {
	case DSA_NOTIFIER_AGEING_TIME:
		err = dsa_switch_ageing_time(ds, info);
		break;
	case DSA_NOTIFIER_BRIDGE_JOIN:
		err = dsa_switch_bridge_join(ds, info);
		break;
	case DSA_NOTIFIER_BRIDGE_LEAVE:
		err = dsa_switch_bridge_leave(ds, info);
		break;
	case DSA_NOTIFIER_FDB_ADD:
		err = dsa_switch_fdb_add(ds, info);
		break;
	case DSA_NOTIFIER_FDB_DEL:
		err = dsa_switch_fdb_del(ds, info);
		break;
	case DSA_NOTIFIER_MDB_ADD:
		err = dsa_switch_mdb_add(ds, info);
		break;
	case DSA_NOTIFIER_MDB_DEL:
		err = dsa_switch_mdb_del(ds, info);
		break;
	case DSA_NOTIFIER_VLAN_ADD:
		err = dsa_switch_vlan_add(ds, info);
		break;
	case DSA_NOTIFIER_VLAN_DEL:
		err = dsa_switch_vlan_del(ds, info);
		break;
	default:
		err = -EOPNOTSUPP;
		break;
	}

	/* Non-switchdev operations cannot be rolled back. If a DSA driver
	 * returns an error during the chained call, switch chips may be in an
	 * inconsistent state.
	 */
	if (err)
		dev_dbg(ds->dev, "breaking chain for DSA event %lu (%d)\n",
			event, err);

	return notifier_from_errno(err);
}

int dsa_switch_register_notifier(struct dsa_switch *ds)
{
	ds->nb.notifier_call = dsa_switch_event;

	return raw_notifier_chain_register(&ds->dst->nh, &ds->nb);
}

void dsa_switch_unregister_notifier(struct dsa_switch *ds)
{
	int err;

	err = raw_notifier_chain_unregister(&ds->dst->nh, &ds->nb);
	if (err)
		dev_err(ds->dev, "failed to unregister notifier (%d)\n", err);
}
Commit	Line	Data
f515f192 VD	1	/*
	2	* Handling of a single switch chip, part of a switch fabric
	3	*
4333d619 VD	4	* Copyright (c) 2017 Savoir-faire Linux Inc.
4333d619 VD	5	* Vivien Didelot <vivien.didelot@savoirfairelinux.com>
f515f192 VD	6	*
	7	* This program is free software; you can redistribute it and/or modify
	8	* it under the terms of the GNU General Public License as published by
	9	* the Free Software Foundation; either version 2 of the License, or
	10	* (at your option) any later version.
	11	*/
	12
	13	#include <linux/netdevice.h>
	14	#include <linux/notifier.h>
1faabf74	15	#include <net/switchdev.h>
ea5dd34b VD	16
ea5dd34b VD	17	#include "dsa_priv.h"
f515f192	18
1faabf74 VD	19	static unsigned int dsa_switch_fastest_ageing_time(struct dsa_switch *ds,
	20	unsigned int ageing_time)
	21	{
	22	int i;
	23
	24	for (i = 0; i < ds->num_ports; ++i) {
	25	struct dsa_port *dp = &ds->ports[i];
	26
	27	if (dp->ageing_time && dp->ageing_time < ageing_time)
	28	ageing_time = dp->ageing_time;
	29	}
	30
	31	return ageing_time;
	32	}
	33
	34	static int dsa_switch_ageing_time(struct dsa_switch *ds,
	35	struct dsa_notifier_ageing_time_info *info)
	36	{
	37	unsigned int ageing_time = info->ageing_time;
	38	struct switchdev_trans *trans = info->trans;
	39
1faabf74 VD	40	if (switchdev_trans_ph_prepare(trans)) {
	41	if (ds->ageing_time_min && ageing_time < ds->ageing_time_min)
	42	return -ERANGE;
	43	if (ds->ageing_time_max && ageing_time > ds->ageing_time_max)
	44	return -ERANGE;
	45	return 0;
	46	}
	47
	48	/* Program the fastest ageing time in case of multiple bridges */
	49	ageing_time = dsa_switch_fastest_ageing_time(ds, ageing_time);
	50
	51	if (ds->ops->set_ageing_time)
	52	return ds->ops->set_ageing_time(ds, ageing_time);
	53
	54	return 0;
	55	}
	56
04d3a4c6 VD	57	static int dsa_switch_bridge_join(struct dsa_switch *ds,
	58	struct dsa_notifier_bridge_info *info)
	59	{
	60	if (ds->index == info->sw_index && ds->ops->port_bridge_join)
	61	return ds->ops->port_bridge_join(ds, info->port, info->br);
	62
40ef2c93 VD	63	if (ds->index != info->sw_index && ds->ops->crosschip_bridge_join)
	64	return ds->ops->crosschip_bridge_join(ds, info->sw_index,
	65	info->port, info->br);
04d3a4c6 VD	66
	67	return 0;
	68	}
	69
	70	static int dsa_switch_bridge_leave(struct dsa_switch *ds,
	71	struct dsa_notifier_bridge_info *info)
	72	{
	73	if (ds->index == info->sw_index && ds->ops->port_bridge_leave)
	74	ds->ops->port_bridge_leave(ds, info->port, info->br);
	75
40ef2c93 VD	76	if (ds->index != info->sw_index && ds->ops->crosschip_bridge_leave)
	77	ds->ops->crosschip_bridge_leave(ds, info->sw_index, info->port,
	78	info->br);
04d3a4c6 VD	79
	80	return 0;
	81	}
	82
685fb6a4 VD	83	static int dsa_switch_fdb_add(struct dsa_switch *ds,
	84	struct dsa_notifier_fdb_info *info)
	85	{
3169241f	86	int port = dsa_towards_port(ds, info->sw_index, info->port);
685fb6a4	87
1b6dd556 AS	88	if (!ds->ops->port_fdb_add)
1b6dd556 AS	89	return -EOPNOTSUPP;
685fb6a4	90
3169241f	91	return ds->ops->port_fdb_add(ds, port, info->addr, info->vid);
685fb6a4 VD	92	}
	93
	94	static int dsa_switch_fdb_del(struct dsa_switch *ds,
	95	struct dsa_notifier_fdb_info *info)
	96	{
3169241f	97	int port = dsa_towards_port(ds, info->sw_index, info->port);
685fb6a4 VD	98
	99	if (!ds->ops->port_fdb_del)
	100	return -EOPNOTSUPP;
	101
3169241f	102	return ds->ops->port_fdb_del(ds, port, info->addr, info->vid);
685fb6a4 VD	103	}
685fb6a4 VD	104
e6db98db VD	105	static int
	106	dsa_switch_mdb_prepare_bitmap(struct dsa_switch *ds,
	107	const struct switchdev_obj_port_mdb *mdb,
	108	const unsigned long *bitmap)
	109	{
	110	int port, err;
	111
	112	if (!ds->ops->port_mdb_prepare \|\| !ds->ops->port_mdb_add)
	113	return -EOPNOTSUPP;
	114
	115	for_each_set_bit(port, bitmap, ds->num_ports) {
	116	err = ds->ops->port_mdb_prepare(ds, port, mdb);
	117	if (err)
	118	return err;
	119	}
	120
	121	return 0;
	122	}
	123
	124	static void dsa_switch_mdb_add_bitmap(struct dsa_switch *ds,
	125	const struct switchdev_obj_port_mdb *mdb,
	126	const unsigned long *bitmap)
	127	{
	128	int port;
	129
	130	for_each_set_bit(port, bitmap, ds->num_ports)
	131	ds->ops->port_mdb_add(ds, port, mdb);
	132	}
	133
8ae5bcdc VD	134	static int dsa_switch_mdb_add(struct dsa_switch *ds,
	135	struct dsa_notifier_mdb_info *info)
	136	{
	137	const struct switchdev_obj_port_mdb *mdb = info->mdb;
	138	struct switchdev_trans *trans = info->trans;
a1a6b7ea	139	DECLARE_BITMAP(group, ds->num_ports);
e6db98db	140	int port;
8ae5bcdc	141
a1a6b7ea VD	142	/* Build a mask of Multicast group members */
	143	bitmap_zero(group, ds->num_ports);
	144	if (ds->index == info->sw_index)
	145	set_bit(info->port, group);
	146	for (port = 0; port < ds->num_ports; port++)
ae45102c	147	if (dsa_is_dsa_port(ds, port))
a1a6b7ea	148	set_bit(port, group);
8ae5bcdc	149
e6db98db VD	150	if (switchdev_trans_ph_prepare(trans))
e6db98db VD	151	return dsa_switch_mdb_prepare_bitmap(ds, mdb, group);
8ae5bcdc	152
e6db98db	153	dsa_switch_mdb_add_bitmap(ds, mdb, group);
8ae5bcdc VD	154
	155	return 0;
	156	}
	157
	158	static int dsa_switch_mdb_del(struct dsa_switch *ds,
	159	struct dsa_notifier_mdb_info *info)
	160	{
	161	const struct switchdev_obj_port_mdb *mdb = info->mdb;
	162
8ae5bcdc VD	163	if (!ds->ops->port_mdb_del)
	164	return -EOPNOTSUPP;
	165
a1a6b7ea VD	166	if (ds->index == info->sw_index)
	167	return ds->ops->port_mdb_del(ds, info->port, mdb);
	168
	169	return 0;
8ae5bcdc VD	170	}
8ae5bcdc VD	171
9c428c59 VD	172	static int
	173	dsa_switch_vlan_prepare_bitmap(struct dsa_switch *ds,
	174	const struct switchdev_obj_port_vlan *vlan,
	175	const unsigned long *bitmap)
	176	{
	177	int port, err;
	178
	179	if (!ds->ops->port_vlan_prepare \|\| !ds->ops->port_vlan_add)
	180	return -EOPNOTSUPP;
	181
	182	for_each_set_bit(port, bitmap, ds->num_ports) {
	183	err = ds->ops->port_vlan_prepare(ds, port, vlan);
	184	if (err)
	185	return err;
	186	}
	187
	188	return 0;
	189	}
	190
	191	static void
	192	dsa_switch_vlan_add_bitmap(struct dsa_switch *ds,
	193	const struct switchdev_obj_port_vlan *vlan,
	194	const unsigned long *bitmap)
	195	{
	196	int port;
	197
	198	for_each_set_bit(port, bitmap, ds->num_ports)
	199	ds->ops->port_vlan_add(ds, port, vlan);
	200	}
	201
d0c627b8 VD	202	static int dsa_switch_vlan_add(struct dsa_switch *ds,
	203	struct dsa_notifier_vlan_info *info)
	204	{
	205	const struct switchdev_obj_port_vlan *vlan = info->vlan;
	206	struct switchdev_trans *trans = info->trans;
1ca4aa9c	207	DECLARE_BITMAP(members, ds->num_ports);
9c428c59	208	int port;
d0c627b8	209
1ca4aa9c VD	210	/* Build a mask of VLAN members */
	211	bitmap_zero(members, ds->num_ports);
	212	if (ds->index == info->sw_index)
	213	set_bit(info->port, members);
b2f81d30 VD	214	for (port = 0; port < ds->num_ports; port++)
	215	if (dsa_is_cpu_port(ds, port) \|\| dsa_is_dsa_port(ds, port))
	216	set_bit(port, members);
d0c627b8	217
9c428c59 VD	218	if (switchdev_trans_ph_prepare(trans))
9c428c59 VD	219	return dsa_switch_vlan_prepare_bitmap(ds, vlan, members);
d0c627b8	220
9c428c59	221	dsa_switch_vlan_add_bitmap(ds, vlan, members);
d0c627b8 VD	222
	223	return 0;
	224	}
	225
	226	static int dsa_switch_vlan_del(struct dsa_switch *ds,
	227	struct dsa_notifier_vlan_info *info)
	228	{
	229	const struct switchdev_obj_port_vlan *vlan = info->vlan;
	230
d0c627b8 VD	231	if (!ds->ops->port_vlan_del)
	232	return -EOPNOTSUPP;
	233
1ca4aa9c VD	234	if (ds->index == info->sw_index)
	235	return ds->ops->port_vlan_del(ds, info->port, vlan);
	236
	237	return 0;
d0c627b8 VD	238	}
d0c627b8 VD	239
f515f192 VD	240	static int dsa_switch_event(struct notifier_block *nb,
	241	unsigned long event, void *info)
	242	{
	243	struct dsa_switch *ds = container_of(nb, struct dsa_switch, nb);
	244	int err;
	245
	246	switch (event) {
1faabf74 VD	247	case DSA_NOTIFIER_AGEING_TIME:
	248	err = dsa_switch_ageing_time(ds, info);
	249	break;
04d3a4c6 VD	250	case DSA_NOTIFIER_BRIDGE_JOIN:
	251	err = dsa_switch_bridge_join(ds, info);
	252	break;
	253	case DSA_NOTIFIER_BRIDGE_LEAVE:
	254	err = dsa_switch_bridge_leave(ds, info);
	255	break;
685fb6a4 VD	256	case DSA_NOTIFIER_FDB_ADD:
	257	err = dsa_switch_fdb_add(ds, info);
	258	break;
	259	case DSA_NOTIFIER_FDB_DEL:
	260	err = dsa_switch_fdb_del(ds, info);
	261	break;
8ae5bcdc VD	262	case DSA_NOTIFIER_MDB_ADD:
	263	err = dsa_switch_mdb_add(ds, info);
	264	break;
	265	case DSA_NOTIFIER_MDB_DEL:
	266	err = dsa_switch_mdb_del(ds, info);
	267	break;
d0c627b8 VD	268	case DSA_NOTIFIER_VLAN_ADD:
	269	err = dsa_switch_vlan_add(ds, info);
	270	break;
	271	case DSA_NOTIFIER_VLAN_DEL:
	272	err = dsa_switch_vlan_del(ds, info);
	273	break;
f515f192 VD	274	default:
	275	err = -EOPNOTSUPP;
	276	break;
	277	}
	278
	279	/* Non-switchdev operations cannot be rolled back. If a DSA driver
	280	* returns an error during the chained call, switch chips may be in an
	281	* inconsistent state.
	282	*/
	283	if (err)
	284	dev_dbg(ds->dev, "breaking chain for DSA event %lu (%d)\n",
	285	event, err);
	286
	287	return notifier_from_errno(err);
	288	}
	289
	290	int dsa_switch_register_notifier(struct dsa_switch *ds)
	291	{
	292	ds->nb.notifier_call = dsa_switch_event;
	293
	294	return raw_notifier_chain_register(&ds->dst->nh, &ds->nb);
	295	}
	296
	297	void dsa_switch_unregister_notifier(struct dsa_switch *ds)
	298	{
	299	int err;
	300
	301	err = raw_notifier_chain_unregister(&ds->dst->nh, &ds->nb);
	302	if (err)
	303	dev_err(ds->dev, "failed to unregister notifier (%d)\n", err);
	304	}