[mirror_ubuntu-artful-kernel.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)
{
	const struct switchdev_obj_port_fdb *fdb = info->fdb;
	struct switchdev_trans *trans = info->trans;

	/* Do not care yet about other switch chips of the fabric */
	if (ds->index != info->sw_index)
		return 0;

	if (switchdev_trans_ph_prepare(trans)) {
		if (!ds->ops->port_fdb_prepare || !ds->ops->port_fdb_add)
			return -EOPNOTSUPP;

		return ds->ops->port_fdb_prepare(ds, info->port, fdb, trans);
	}

	ds->ops->port_fdb_add(ds, info->port, fdb, trans);

	return 0;
}

static int dsa_switch_fdb_del(struct dsa_switch *ds,
			      struct dsa_notifier_fdb_info *info)
{
	const struct switchdev_obj_port_fdb *fdb = info->fdb;

	/* Do not care yet about other switch chips of the fabric */
	if (ds->index != info->sw_index)
		return 0;

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

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

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

	/* 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_cpu_port(ds, port) || dsa_is_dsa_port(ds, port))
			set_bit(port, group);

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

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

	for_each_set_bit(port, group, ds->num_ports)
		ds->ops->port_mdb_add(ds, port, mdb, trans);

	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_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, err;

	/* 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)) {
		if (!ds->ops->port_vlan_prepare || !ds->ops->port_vlan_add)
			return -EOPNOTSUPP;

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

	for_each_set_bit(port, members, ds->num_ports)
		ds->ops->port_vlan_add(ds, port, vlan, trans);

	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	{
	86	const struct switchdev_obj_port_fdb *fdb = info->fdb;
	87	struct switchdev_trans *trans = info->trans;
	88
	89	/* Do not care yet about other switch chips of the fabric */
	90	if (ds->index != info->sw_index)
	91	return 0;
	92
	93	if (switchdev_trans_ph_prepare(trans)) {
	94	if (!ds->ops->port_fdb_prepare \|\| !ds->ops->port_fdb_add)
	95	return -EOPNOTSUPP;
	96
	97	return ds->ops->port_fdb_prepare(ds, info->port, fdb, trans);
	98	}
	99
	100	ds->ops->port_fdb_add(ds, info->port, fdb, trans);
	101
	102	return 0;
	103	}
	104
	105	static int dsa_switch_fdb_del(struct dsa_switch *ds,
	106	struct dsa_notifier_fdb_info *info)
	107	{
	108	const struct switchdev_obj_port_fdb *fdb = info->fdb;
	109
	110	/* Do not care yet about other switch chips of the fabric */
	111	if (ds->index != info->sw_index)
	112	return 0;
	113
	114	if (!ds->ops->port_fdb_del)
	115	return -EOPNOTSUPP;
	116
	117	return ds->ops->port_fdb_del(ds, info->port, fdb);
	118	}
	119
8ae5bcdc VD	120	static int dsa_switch_mdb_add(struct dsa_switch *ds,
	121	struct dsa_notifier_mdb_info *info)
	122	{
	123	const struct switchdev_obj_port_mdb *mdb = info->mdb;
	124	struct switchdev_trans *trans = info->trans;
a1a6b7ea VD	125	DECLARE_BITMAP(group, ds->num_ports);
a1a6b7ea VD	126	int port, err;
8ae5bcdc	127
a1a6b7ea VD	128	/* Build a mask of Multicast group members */
	129	bitmap_zero(group, ds->num_ports);
	130	if (ds->index == info->sw_index)
	131	set_bit(info->port, group);
	132	for (port = 0; port < ds->num_ports; port++)
	133	if (dsa_is_cpu_port(ds, port) \|\| dsa_is_dsa_port(ds, port))
	134	set_bit(port, group);
8ae5bcdc VD	135
	136	if (switchdev_trans_ph_prepare(trans)) {
	137	if (!ds->ops->port_mdb_prepare \|\| !ds->ops->port_mdb_add)
	138	return -EOPNOTSUPP;
	139
a1a6b7ea VD	140	for_each_set_bit(port, group, ds->num_ports) {
	141	err = ds->ops->port_mdb_prepare(ds, port, mdb, trans);
	142	if (err)
	143	return err;
	144	}
8ae5bcdc VD	145	}
8ae5bcdc VD	146
a1a6b7ea VD	147	for_each_set_bit(port, group, ds->num_ports)
a1a6b7ea VD	148	ds->ops->port_mdb_add(ds, port, mdb, trans);
8ae5bcdc VD	149
	150	return 0;
	151	}
	152
	153	static int dsa_switch_mdb_del(struct dsa_switch *ds,
	154	struct dsa_notifier_mdb_info *info)
	155	{
	156	const struct switchdev_obj_port_mdb *mdb = info->mdb;
	157
8ae5bcdc VD	158	if (!ds->ops->port_mdb_del)
	159	return -EOPNOTSUPP;
	160
a1a6b7ea VD	161	if (ds->index == info->sw_index)
	162	return ds->ops->port_mdb_del(ds, info->port, mdb);
	163
	164	return 0;
8ae5bcdc VD	165	}
8ae5bcdc VD	166
d0c627b8 VD	167	static int dsa_switch_vlan_add(struct dsa_switch *ds,
	168	struct dsa_notifier_vlan_info *info)
	169	{
	170	const struct switchdev_obj_port_vlan *vlan = info->vlan;
	171	struct switchdev_trans *trans = info->trans;
1ca4aa9c VD	172	DECLARE_BITMAP(members, ds->num_ports);
1ca4aa9c VD	173	int port, err;
d0c627b8	174
1ca4aa9c VD	175	/* Build a mask of VLAN members */
	176	bitmap_zero(members, ds->num_ports);
	177	if (ds->index == info->sw_index)
	178	set_bit(info->port, members);
b2f81d30 VD	179	for (port = 0; port < ds->num_ports; port++)
	180	if (dsa_is_cpu_port(ds, port) \|\| dsa_is_dsa_port(ds, port))
	181	set_bit(port, members);
d0c627b8 VD	182
	183	if (switchdev_trans_ph_prepare(trans)) {
	184	if (!ds->ops->port_vlan_prepare \|\| !ds->ops->port_vlan_add)
	185	return -EOPNOTSUPP;
	186
1ca4aa9c VD	187	for_each_set_bit(port, members, ds->num_ports) {
	188	err = ds->ops->port_vlan_prepare(ds, port, vlan, trans);
	189	if (err)
	190	return err;
	191	}
d0c627b8 VD	192	}
d0c627b8 VD	193
1ca4aa9c VD	194	for_each_set_bit(port, members, ds->num_ports)
1ca4aa9c VD	195	ds->ops->port_vlan_add(ds, port, vlan, trans);
d0c627b8 VD	196
	197	return 0;
	198	}
	199
	200	static int dsa_switch_vlan_del(struct dsa_switch *ds,
	201	struct dsa_notifier_vlan_info *info)
	202	{
	203	const struct switchdev_obj_port_vlan *vlan = info->vlan;
	204
d0c627b8 VD	205	if (!ds->ops->port_vlan_del)
	206	return -EOPNOTSUPP;
	207
1ca4aa9c VD	208	if (ds->index == info->sw_index)
	209	return ds->ops->port_vlan_del(ds, info->port, vlan);
	210
	211	return 0;
d0c627b8 VD	212	}
d0c627b8 VD	213
f515f192 VD	214	static int dsa_switch_event(struct notifier_block *nb,
	215	unsigned long event, void *info)
	216	{
	217	struct dsa_switch *ds = container_of(nb, struct dsa_switch, nb);
	218	int err;
	219
	220	switch (event) {
1faabf74 VD	221	case DSA_NOTIFIER_AGEING_TIME:
	222	err = dsa_switch_ageing_time(ds, info);
	223	break;
04d3a4c6 VD	224	case DSA_NOTIFIER_BRIDGE_JOIN:
	225	err = dsa_switch_bridge_join(ds, info);
	226	break;
	227	case DSA_NOTIFIER_BRIDGE_LEAVE:
	228	err = dsa_switch_bridge_leave(ds, info);
	229	break;
685fb6a4 VD	230	case DSA_NOTIFIER_FDB_ADD:
	231	err = dsa_switch_fdb_add(ds, info);
	232	break;
	233	case DSA_NOTIFIER_FDB_DEL:
	234	err = dsa_switch_fdb_del(ds, info);
	235	break;
8ae5bcdc VD	236	case DSA_NOTIFIER_MDB_ADD:
	237	err = dsa_switch_mdb_add(ds, info);
	238	break;
	239	case DSA_NOTIFIER_MDB_DEL:
	240	err = dsa_switch_mdb_del(ds, info);
	241	break;
d0c627b8 VD	242	case DSA_NOTIFIER_VLAN_ADD:
	243	err = dsa_switch_vlan_add(ds, info);
	244	break;
	245	case DSA_NOTIFIER_VLAN_DEL:
	246	err = dsa_switch_vlan_del(ds, info);
	247	break;
f515f192 VD	248	default:
	249	err = -EOPNOTSUPP;
	250	break;
	251	}
	252
	253	/* Non-switchdev operations cannot be rolled back. If a DSA driver
	254	* returns an error during the chained call, switch chips may be in an
	255	* inconsistent state.
	256	*/
	257	if (err)
	258	dev_dbg(ds->dev, "breaking chain for DSA event %lu (%d)\n",
	259	event, err);
	260
	261	return notifier_from_errno(err);
	262	}
	263
	264	int dsa_switch_register_notifier(struct dsa_switch *ds)
	265	{
	266	ds->nb.notifier_call = dsa_switch_event;
	267
	268	return raw_notifier_chain_register(&ds->dst->nh, &ds->nb);
	269	}
	270
	271	void dsa_switch_unregister_notifier(struct dsa_switch *ds)
	272	{
	273	int err;
	274
	275	err = raw_notifier_chain_unregister(&ds->dst->nh, &ds->nb);
	276	if (err)
	277	dev_err(ds->dev, "failed to unregister notifier (%d)\n", err);
	278	}