mirror of
https://mirrors.bfsu.edu.cn/git/linux.git
synced 2024-12-12 21:44:06 +08:00
c64b9c0504
The big problem which mandates cross-chip notifiers for tag_8021q is this: | sw0p0 sw0p1 sw0p2 sw0p3 sw0p4 [ user ] [ user ] [ user ] [ dsa ] [ cpu ] | +---------+ | sw1p0 sw1p1 sw1p2 sw1p3 sw1p4 [ user ] [ user ] [ user ] [ dsa ] [ dsa ] | +---------+ | sw2p0 sw2p1 sw2p2 sw2p3 sw2p4 [ user ] [ user ] [ user ] [ dsa ] [ dsa ] When the user runs: ip link add br0 type bridge ip link set sw0p0 master br0 ip link set sw2p0 master br0 It doesn't work. This is because dsa_8021q_crosschip_bridge_join() assumes that "ds" and "other_ds" are at most 1 hop away from each other, so it is sufficient to add the RX VLAN of {ds, port} into {other_ds, other_port} and vice versa and presto, the cross-chip link works. When there is another switch in the middle, such as in this case switch 1 with its DSA links sw1p3 and sw1p4, somebody needs to tell it about these VLANs too. Which is exactly why the problem is quadratic: when a port joins a bridge, for each port in the tree that's already in that same bridge we notify a tag_8021q VLAN addition of that port's RX VLAN to the entire tree. It is a very complicated web of VLANs. It must be mentioned that currently we install tag_8021q VLANs on too many ports (DSA links - to be precise, on all of them). For example, when sw2p0 joins br0, and assuming sw1p0 was part of br0 too, we add the RX VLAN of sw2p0 on the DSA links of switch 0 too, even though there isn't any port of switch 0 that is a member of br0 (at least yet). In theory we could notify only the switches which sit in between the port joining the bridge and the port reacting to that bridge_join event. But in practice that is impossible, because of the way 'link' properties are described in the device tree. The DSA bindings require DT writers to list out not only the real/physical DSA links, but in fact the entire routing table, like for example switch 0 above will have: sw0p3: port@3 { link = <&sw1p4 &sw2p4>; }; This was done because: /* TODO: ideally DSA ports would have a single dp->link_dp member, * and no dst->rtable nor this struct dsa_link would be needed, * but this would require some more complex tree walking, * so keep it stupid at the moment and list them all. */ but it is a perfect example of a situation where too much information is actively detrimential, because we are now in the position where we cannot distinguish a real DSA link from one that is put there to avoid the 'complex tree walking'. And because DT is ABI, there is not much we can change. And because we do not know which DSA links are real and which ones aren't, we can't really know if DSA switch A is in the data path between switches B and C, in the general case. So this is why tag_8021q RX VLANs are added on all DSA links, and probably why it will never change. On the other hand, at least the number of additions/deletions is well balanced, and this means that once we implement reference counting at the cross-chip notifier level a la fdb/mdb, there is absolutely zero need for a struct dsa_8021q_crosschip_link, it's all self-managing. In fact, with the tag_8021q notifiers emitted from the bridge join notifiers, it becomes so generic that sja1105 does not need to do anything anymore, we can just delete its implementation of the .crosschip_bridge_{join,leave} methods. Among other things we can simply delete is the home-grown implementation of sja1105_notify_crosschip_switches(). The reason why that is wrong is because it is not quadratic - it only covers remote switches to which we have a cross-chip bridging link and that does not cover in-between switches. This deletion is part of the same patch because sja1105 used to poke deep inside the guts of the tag_8021q context in order to do that. Because the cross-chip links went away, so needs the sja1105 code. Last but not least, dsa_8021q_setup_port() is simplified (and also renamed). Because our TAG_8021Q_VLAN_ADD notifier is designed to react on the CPU port too, the four dsa_8021q_vid_apply() calls: - 1 for RX VLAN on user port - 1 for the user port's RX VLAN on the CPU port - 1 for TX VLAN on user port - 1 for the user port's TX VLAN on the CPU port now get squashed into only 2 notifier calls via dsa_port_tag_8021q_vlan_add. And because the notifiers to add and to delete a tag_8021q VLAN are distinct, now we finally break up the port setup and teardown into separate functions instead of relying on a "bool enabled" flag which tells us what to do. Arguably it should have been this way from the get go. Signed-off-by: Vladimir Oltean <vladimir.oltean@nxp.com> Signed-off-by: David S. Miller <davem@davemloft.net>
770 lines
18 KiB
C
770 lines
18 KiB
C
// SPDX-License-Identifier: GPL-2.0-or-later
|
|
/*
|
|
* Handling of a single switch chip, part of a switch fabric
|
|
*
|
|
* Copyright (c) 2017 Savoir-faire Linux Inc.
|
|
* Vivien Didelot <vivien.didelot@savoirfairelinux.com>
|
|
*/
|
|
|
|
#include <linux/if_bridge.h>
|
|
#include <linux/netdevice.h>
|
|
#include <linux/notifier.h>
|
|
#include <linux/if_vlan.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 = dsa_to_port(ds, 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;
|
|
|
|
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;
|
|
|
|
/* 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 bool dsa_switch_mtu_match(struct dsa_switch *ds, int port,
|
|
struct dsa_notifier_mtu_info *info)
|
|
{
|
|
if (ds->index == info->sw_index && port == info->port)
|
|
return true;
|
|
|
|
/* Do not propagate to other switches in the tree if the notifier was
|
|
* targeted for a single switch.
|
|
*/
|
|
if (info->targeted_match)
|
|
return false;
|
|
|
|
if (dsa_is_dsa_port(ds, port) || dsa_is_cpu_port(ds, port))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
static int dsa_switch_mtu(struct dsa_switch *ds,
|
|
struct dsa_notifier_mtu_info *info)
|
|
{
|
|
int port, ret;
|
|
|
|
if (!ds->ops->port_change_mtu)
|
|
return -EOPNOTSUPP;
|
|
|
|
for (port = 0; port < ds->num_ports; port++) {
|
|
if (dsa_switch_mtu_match(ds, port, info)) {
|
|
ret = ds->ops->port_change_mtu(ds, port, info->mtu);
|
|
if (ret)
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int dsa_switch_bridge_join(struct dsa_switch *ds,
|
|
struct dsa_notifier_bridge_info *info)
|
|
{
|
|
struct dsa_switch_tree *dst = ds->dst;
|
|
int err;
|
|
|
|
if (dst->index == info->tree_index && ds->index == info->sw_index &&
|
|
ds->ops->port_bridge_join) {
|
|
err = ds->ops->port_bridge_join(ds, info->port, info->br);
|
|
if (err)
|
|
return err;
|
|
}
|
|
|
|
if ((dst->index != info->tree_index || ds->index != info->sw_index) &&
|
|
ds->ops->crosschip_bridge_join) {
|
|
err = ds->ops->crosschip_bridge_join(ds, info->tree_index,
|
|
info->sw_index,
|
|
info->port, info->br);
|
|
if (err)
|
|
return err;
|
|
}
|
|
|
|
return dsa_tag_8021q_bridge_join(ds, info);
|
|
}
|
|
|
|
static int dsa_switch_bridge_leave(struct dsa_switch *ds,
|
|
struct dsa_notifier_bridge_info *info)
|
|
{
|
|
bool unset_vlan_filtering = br_vlan_enabled(info->br);
|
|
struct dsa_switch_tree *dst = ds->dst;
|
|
struct netlink_ext_ack extack = {0};
|
|
int err, port;
|
|
|
|
if (dst->index == info->tree_index && ds->index == info->sw_index &&
|
|
ds->ops->port_bridge_leave)
|
|
ds->ops->port_bridge_leave(ds, info->port, info->br);
|
|
|
|
if ((dst->index != info->tree_index || ds->index != info->sw_index) &&
|
|
ds->ops->crosschip_bridge_leave)
|
|
ds->ops->crosschip_bridge_leave(ds, info->tree_index,
|
|
info->sw_index, info->port,
|
|
info->br);
|
|
|
|
/* If the bridge was vlan_filtering, the bridge core doesn't trigger an
|
|
* event for changing vlan_filtering setting upon slave ports leaving
|
|
* it. That is a good thing, because that lets us handle it and also
|
|
* handle the case where the switch's vlan_filtering setting is global
|
|
* (not per port). When that happens, the correct moment to trigger the
|
|
* vlan_filtering callback is only when the last port leaves the last
|
|
* VLAN-aware bridge.
|
|
*/
|
|
if (unset_vlan_filtering && ds->vlan_filtering_is_global) {
|
|
for (port = 0; port < ds->num_ports; port++) {
|
|
struct net_device *bridge_dev;
|
|
|
|
bridge_dev = dsa_to_port(ds, port)->bridge_dev;
|
|
|
|
if (bridge_dev && br_vlan_enabled(bridge_dev)) {
|
|
unset_vlan_filtering = false;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (unset_vlan_filtering) {
|
|
err = dsa_port_vlan_filtering(dsa_to_port(ds, info->port),
|
|
false, &extack);
|
|
if (extack._msg)
|
|
dev_err(ds->dev, "port %d: %s\n", info->port,
|
|
extack._msg);
|
|
if (err && err != EOPNOTSUPP)
|
|
return err;
|
|
}
|
|
|
|
return dsa_tag_8021q_bridge_leave(ds, info);
|
|
}
|
|
|
|
/* Matches for all upstream-facing ports (the CPU port and all upstream-facing
|
|
* DSA links) that sit between the targeted port on which the notifier was
|
|
* emitted and its dedicated CPU port.
|
|
*/
|
|
static bool dsa_switch_host_address_match(struct dsa_switch *ds, int port,
|
|
int info_sw_index, int info_port)
|
|
{
|
|
struct dsa_port *targeted_dp, *cpu_dp;
|
|
struct dsa_switch *targeted_ds;
|
|
|
|
targeted_ds = dsa_switch_find(ds->dst->index, info_sw_index);
|
|
targeted_dp = dsa_to_port(targeted_ds, info_port);
|
|
cpu_dp = targeted_dp->cpu_dp;
|
|
|
|
if (dsa_switch_is_upstream_of(ds, targeted_ds))
|
|
return port == dsa_towards_port(ds, cpu_dp->ds->index,
|
|
cpu_dp->index);
|
|
|
|
return false;
|
|
}
|
|
|
|
static struct dsa_mac_addr *dsa_mac_addr_find(struct list_head *addr_list,
|
|
const unsigned char *addr,
|
|
u16 vid)
|
|
{
|
|
struct dsa_mac_addr *a;
|
|
|
|
list_for_each_entry(a, addr_list, list)
|
|
if (ether_addr_equal(a->addr, addr) && a->vid == vid)
|
|
return a;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static int dsa_switch_do_mdb_add(struct dsa_switch *ds, int port,
|
|
const struct switchdev_obj_port_mdb *mdb)
|
|
{
|
|
struct dsa_port *dp = dsa_to_port(ds, port);
|
|
struct dsa_mac_addr *a;
|
|
int err;
|
|
|
|
/* No need to bother with refcounting for user ports */
|
|
if (!(dsa_port_is_cpu(dp) || dsa_port_is_dsa(dp)))
|
|
return ds->ops->port_mdb_add(ds, port, mdb);
|
|
|
|
a = dsa_mac_addr_find(&dp->mdbs, mdb->addr, mdb->vid);
|
|
if (a) {
|
|
refcount_inc(&a->refcount);
|
|
return 0;
|
|
}
|
|
|
|
a = kzalloc(sizeof(*a), GFP_KERNEL);
|
|
if (!a)
|
|
return -ENOMEM;
|
|
|
|
err = ds->ops->port_mdb_add(ds, port, mdb);
|
|
if (err) {
|
|
kfree(a);
|
|
return err;
|
|
}
|
|
|
|
ether_addr_copy(a->addr, mdb->addr);
|
|
a->vid = mdb->vid;
|
|
refcount_set(&a->refcount, 1);
|
|
list_add_tail(&a->list, &dp->mdbs);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int dsa_switch_do_mdb_del(struct dsa_switch *ds, int port,
|
|
const struct switchdev_obj_port_mdb *mdb)
|
|
{
|
|
struct dsa_port *dp = dsa_to_port(ds, port);
|
|
struct dsa_mac_addr *a;
|
|
int err;
|
|
|
|
/* No need to bother with refcounting for user ports */
|
|
if (!(dsa_port_is_cpu(dp) || dsa_port_is_dsa(dp)))
|
|
return ds->ops->port_mdb_del(ds, port, mdb);
|
|
|
|
a = dsa_mac_addr_find(&dp->mdbs, mdb->addr, mdb->vid);
|
|
if (!a)
|
|
return -ENOENT;
|
|
|
|
if (!refcount_dec_and_test(&a->refcount))
|
|
return 0;
|
|
|
|
err = ds->ops->port_mdb_del(ds, port, mdb);
|
|
if (err) {
|
|
refcount_inc(&a->refcount);
|
|
return err;
|
|
}
|
|
|
|
list_del(&a->list);
|
|
kfree(a);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int dsa_switch_do_fdb_add(struct dsa_switch *ds, int port,
|
|
const unsigned char *addr, u16 vid)
|
|
{
|
|
struct dsa_port *dp = dsa_to_port(ds, port);
|
|
struct dsa_mac_addr *a;
|
|
int err;
|
|
|
|
/* No need to bother with refcounting for user ports */
|
|
if (!(dsa_port_is_cpu(dp) || dsa_port_is_dsa(dp)))
|
|
return ds->ops->port_fdb_add(ds, port, addr, vid);
|
|
|
|
a = dsa_mac_addr_find(&dp->fdbs, addr, vid);
|
|
if (a) {
|
|
refcount_inc(&a->refcount);
|
|
return 0;
|
|
}
|
|
|
|
a = kzalloc(sizeof(*a), GFP_KERNEL);
|
|
if (!a)
|
|
return -ENOMEM;
|
|
|
|
err = ds->ops->port_fdb_add(ds, port, addr, vid);
|
|
if (err) {
|
|
kfree(a);
|
|
return err;
|
|
}
|
|
|
|
ether_addr_copy(a->addr, addr);
|
|
a->vid = vid;
|
|
refcount_set(&a->refcount, 1);
|
|
list_add_tail(&a->list, &dp->fdbs);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int dsa_switch_do_fdb_del(struct dsa_switch *ds, int port,
|
|
const unsigned char *addr, u16 vid)
|
|
{
|
|
struct dsa_port *dp = dsa_to_port(ds, port);
|
|
struct dsa_mac_addr *a;
|
|
int err;
|
|
|
|
/* No need to bother with refcounting for user ports */
|
|
if (!(dsa_port_is_cpu(dp) || dsa_port_is_dsa(dp)))
|
|
return ds->ops->port_fdb_del(ds, port, addr, vid);
|
|
|
|
a = dsa_mac_addr_find(&dp->fdbs, addr, vid);
|
|
if (!a)
|
|
return -ENOENT;
|
|
|
|
if (!refcount_dec_and_test(&a->refcount))
|
|
return 0;
|
|
|
|
err = ds->ops->port_fdb_del(ds, port, addr, vid);
|
|
if (err) {
|
|
refcount_inc(&a->refcount);
|
|
return err;
|
|
}
|
|
|
|
list_del(&a->list);
|
|
kfree(a);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int dsa_switch_host_fdb_add(struct dsa_switch *ds,
|
|
struct dsa_notifier_fdb_info *info)
|
|
{
|
|
int err = 0;
|
|
int port;
|
|
|
|
if (!ds->ops->port_fdb_add)
|
|
return -EOPNOTSUPP;
|
|
|
|
for (port = 0; port < ds->num_ports; port++) {
|
|
if (dsa_switch_host_address_match(ds, port, info->sw_index,
|
|
info->port)) {
|
|
err = dsa_switch_do_fdb_add(ds, port, info->addr,
|
|
info->vid);
|
|
if (err)
|
|
break;
|
|
}
|
|
}
|
|
|
|
return err;
|
|
}
|
|
|
|
static int dsa_switch_host_fdb_del(struct dsa_switch *ds,
|
|
struct dsa_notifier_fdb_info *info)
|
|
{
|
|
int err = 0;
|
|
int port;
|
|
|
|
if (!ds->ops->port_fdb_del)
|
|
return -EOPNOTSUPP;
|
|
|
|
for (port = 0; port < ds->num_ports; port++) {
|
|
if (dsa_switch_host_address_match(ds, port, info->sw_index,
|
|
info->port)) {
|
|
err = dsa_switch_do_fdb_del(ds, port, info->addr,
|
|
info->vid);
|
|
if (err)
|
|
break;
|
|
}
|
|
}
|
|
|
|
return err;
|
|
}
|
|
|
|
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 dsa_switch_do_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 dsa_switch_do_fdb_del(ds, port, info->addr, info->vid);
|
|
}
|
|
|
|
static int dsa_switch_hsr_join(struct dsa_switch *ds,
|
|
struct dsa_notifier_hsr_info *info)
|
|
{
|
|
if (ds->index == info->sw_index && ds->ops->port_hsr_join)
|
|
return ds->ops->port_hsr_join(ds, info->port, info->hsr);
|
|
|
|
return -EOPNOTSUPP;
|
|
}
|
|
|
|
static int dsa_switch_hsr_leave(struct dsa_switch *ds,
|
|
struct dsa_notifier_hsr_info *info)
|
|
{
|
|
if (ds->index == info->sw_index && ds->ops->port_hsr_leave)
|
|
return ds->ops->port_hsr_leave(ds, info->port, info->hsr);
|
|
|
|
return -EOPNOTSUPP;
|
|
}
|
|
|
|
static int dsa_switch_lag_change(struct dsa_switch *ds,
|
|
struct dsa_notifier_lag_info *info)
|
|
{
|
|
if (ds->index == info->sw_index && ds->ops->port_lag_change)
|
|
return ds->ops->port_lag_change(ds, info->port);
|
|
|
|
if (ds->index != info->sw_index && ds->ops->crosschip_lag_change)
|
|
return ds->ops->crosschip_lag_change(ds, info->sw_index,
|
|
info->port);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int dsa_switch_lag_join(struct dsa_switch *ds,
|
|
struct dsa_notifier_lag_info *info)
|
|
{
|
|
if (ds->index == info->sw_index && ds->ops->port_lag_join)
|
|
return ds->ops->port_lag_join(ds, info->port, info->lag,
|
|
info->info);
|
|
|
|
if (ds->index != info->sw_index && ds->ops->crosschip_lag_join)
|
|
return ds->ops->crosschip_lag_join(ds, info->sw_index,
|
|
info->port, info->lag,
|
|
info->info);
|
|
|
|
return -EOPNOTSUPP;
|
|
}
|
|
|
|
static int dsa_switch_lag_leave(struct dsa_switch *ds,
|
|
struct dsa_notifier_lag_info *info)
|
|
{
|
|
if (ds->index == info->sw_index && ds->ops->port_lag_leave)
|
|
return ds->ops->port_lag_leave(ds, info->port, info->lag);
|
|
|
|
if (ds->index != info->sw_index && ds->ops->crosschip_lag_leave)
|
|
return ds->ops->crosschip_lag_leave(ds, info->sw_index,
|
|
info->port, info->lag);
|
|
|
|
return -EOPNOTSUPP;
|
|
}
|
|
|
|
static int dsa_switch_mdb_add(struct dsa_switch *ds,
|
|
struct dsa_notifier_mdb_info *info)
|
|
{
|
|
int port = dsa_towards_port(ds, info->sw_index, info->port);
|
|
|
|
if (!ds->ops->port_mdb_add)
|
|
return -EOPNOTSUPP;
|
|
|
|
return dsa_switch_do_mdb_add(ds, port, info->mdb);
|
|
}
|
|
|
|
static int dsa_switch_mdb_del(struct dsa_switch *ds,
|
|
struct dsa_notifier_mdb_info *info)
|
|
{
|
|
int port = dsa_towards_port(ds, info->sw_index, info->port);
|
|
|
|
if (!ds->ops->port_mdb_del)
|
|
return -EOPNOTSUPP;
|
|
|
|
return dsa_switch_do_mdb_del(ds, port, info->mdb);
|
|
}
|
|
|
|
static int dsa_switch_host_mdb_add(struct dsa_switch *ds,
|
|
struct dsa_notifier_mdb_info *info)
|
|
{
|
|
int err = 0;
|
|
int port;
|
|
|
|
if (!ds->ops->port_mdb_add)
|
|
return -EOPNOTSUPP;
|
|
|
|
for (port = 0; port < ds->num_ports; port++) {
|
|
if (dsa_switch_host_address_match(ds, port, info->sw_index,
|
|
info->port)) {
|
|
err = dsa_switch_do_mdb_add(ds, port, info->mdb);
|
|
if (err)
|
|
break;
|
|
}
|
|
}
|
|
|
|
return err;
|
|
}
|
|
|
|
static int dsa_switch_host_mdb_del(struct dsa_switch *ds,
|
|
struct dsa_notifier_mdb_info *info)
|
|
{
|
|
int err = 0;
|
|
int port;
|
|
|
|
if (!ds->ops->port_mdb_del)
|
|
return -EOPNOTSUPP;
|
|
|
|
for (port = 0; port < ds->num_ports; port++) {
|
|
if (dsa_switch_host_address_match(ds, port, info->sw_index,
|
|
info->port)) {
|
|
err = dsa_switch_do_mdb_del(ds, port, info->mdb);
|
|
if (err)
|
|
break;
|
|
}
|
|
}
|
|
|
|
return err;
|
|
}
|
|
|
|
static bool dsa_switch_vlan_match(struct dsa_switch *ds, int port,
|
|
struct dsa_notifier_vlan_info *info)
|
|
{
|
|
if (ds->index == info->sw_index && port == info->port)
|
|
return true;
|
|
|
|
if (dsa_is_dsa_port(ds, port))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
static int dsa_switch_vlan_add(struct dsa_switch *ds,
|
|
struct dsa_notifier_vlan_info *info)
|
|
{
|
|
int port, err;
|
|
|
|
if (!ds->ops->port_vlan_add)
|
|
return -EOPNOTSUPP;
|
|
|
|
for (port = 0; port < ds->num_ports; port++) {
|
|
if (dsa_switch_vlan_match(ds, port, info)) {
|
|
err = ds->ops->port_vlan_add(ds, port, info->vlan,
|
|
info->extack);
|
|
if (err)
|
|
return err;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int dsa_switch_vlan_del(struct dsa_switch *ds,
|
|
struct dsa_notifier_vlan_info *info)
|
|
{
|
|
if (!ds->ops->port_vlan_del)
|
|
return -EOPNOTSUPP;
|
|
|
|
if (ds->index == info->sw_index)
|
|
return ds->ops->port_vlan_del(ds, info->port, info->vlan);
|
|
|
|
/* Do not deprogram the DSA links as they may be used as conduit
|
|
* for other VLAN members in the fabric.
|
|
*/
|
|
return 0;
|
|
}
|
|
|
|
static int dsa_switch_change_tag_proto(struct dsa_switch *ds,
|
|
struct dsa_notifier_tag_proto_info *info)
|
|
{
|
|
const struct dsa_device_ops *tag_ops = info->tag_ops;
|
|
int port, err;
|
|
|
|
if (!ds->ops->change_tag_protocol)
|
|
return -EOPNOTSUPP;
|
|
|
|
ASSERT_RTNL();
|
|
|
|
for (port = 0; port < ds->num_ports; port++) {
|
|
if (!dsa_is_cpu_port(ds, port))
|
|
continue;
|
|
|
|
err = ds->ops->change_tag_protocol(ds, port, tag_ops->proto);
|
|
if (err)
|
|
return err;
|
|
|
|
dsa_port_set_tag_protocol(dsa_to_port(ds, port), tag_ops);
|
|
}
|
|
|
|
/* Now that changing the tag protocol can no longer fail, let's update
|
|
* the remaining bits which are "duplicated for faster access", and the
|
|
* bits that depend on the tagger, such as the MTU.
|
|
*/
|
|
for (port = 0; port < ds->num_ports; port++) {
|
|
if (dsa_is_user_port(ds, port)) {
|
|
struct net_device *slave;
|
|
|
|
slave = dsa_to_port(ds, port)->slave;
|
|
dsa_slave_setup_tagger(slave);
|
|
|
|
/* rtnl_mutex is held in dsa_tree_change_tag_proto */
|
|
dsa_slave_change_mtu(slave, slave->mtu);
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int dsa_switch_mrp_add(struct dsa_switch *ds,
|
|
struct dsa_notifier_mrp_info *info)
|
|
{
|
|
if (!ds->ops->port_mrp_add)
|
|
return -EOPNOTSUPP;
|
|
|
|
if (ds->index == info->sw_index)
|
|
return ds->ops->port_mrp_add(ds, info->port, info->mrp);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int dsa_switch_mrp_del(struct dsa_switch *ds,
|
|
struct dsa_notifier_mrp_info *info)
|
|
{
|
|
if (!ds->ops->port_mrp_del)
|
|
return -EOPNOTSUPP;
|
|
|
|
if (ds->index == info->sw_index)
|
|
return ds->ops->port_mrp_del(ds, info->port, info->mrp);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
dsa_switch_mrp_add_ring_role(struct dsa_switch *ds,
|
|
struct dsa_notifier_mrp_ring_role_info *info)
|
|
{
|
|
if (!ds->ops->port_mrp_add)
|
|
return -EOPNOTSUPP;
|
|
|
|
if (ds->index == info->sw_index)
|
|
return ds->ops->port_mrp_add_ring_role(ds, info->port,
|
|
info->mrp);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
dsa_switch_mrp_del_ring_role(struct dsa_switch *ds,
|
|
struct dsa_notifier_mrp_ring_role_info *info)
|
|
{
|
|
if (!ds->ops->port_mrp_del)
|
|
return -EOPNOTSUPP;
|
|
|
|
if (ds->index == info->sw_index)
|
|
return ds->ops->port_mrp_del_ring_role(ds, info->port,
|
|
info->mrp);
|
|
|
|
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_HOST_FDB_ADD:
|
|
err = dsa_switch_host_fdb_add(ds, info);
|
|
break;
|
|
case DSA_NOTIFIER_HOST_FDB_DEL:
|
|
err = dsa_switch_host_fdb_del(ds, info);
|
|
break;
|
|
case DSA_NOTIFIER_HSR_JOIN:
|
|
err = dsa_switch_hsr_join(ds, info);
|
|
break;
|
|
case DSA_NOTIFIER_HSR_LEAVE:
|
|
err = dsa_switch_hsr_leave(ds, info);
|
|
break;
|
|
case DSA_NOTIFIER_LAG_CHANGE:
|
|
err = dsa_switch_lag_change(ds, info);
|
|
break;
|
|
case DSA_NOTIFIER_LAG_JOIN:
|
|
err = dsa_switch_lag_join(ds, info);
|
|
break;
|
|
case DSA_NOTIFIER_LAG_LEAVE:
|
|
err = dsa_switch_lag_leave(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_HOST_MDB_ADD:
|
|
err = dsa_switch_host_mdb_add(ds, info);
|
|
break;
|
|
case DSA_NOTIFIER_HOST_MDB_DEL:
|
|
err = dsa_switch_host_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;
|
|
case DSA_NOTIFIER_MTU:
|
|
err = dsa_switch_mtu(ds, info);
|
|
break;
|
|
case DSA_NOTIFIER_TAG_PROTO:
|
|
err = dsa_switch_change_tag_proto(ds, info);
|
|
break;
|
|
case DSA_NOTIFIER_MRP_ADD:
|
|
err = dsa_switch_mrp_add(ds, info);
|
|
break;
|
|
case DSA_NOTIFIER_MRP_DEL:
|
|
err = dsa_switch_mrp_del(ds, info);
|
|
break;
|
|
case DSA_NOTIFIER_MRP_ADD_RING_ROLE:
|
|
err = dsa_switch_mrp_add_ring_role(ds, info);
|
|
break;
|
|
case DSA_NOTIFIER_MRP_DEL_RING_ROLE:
|
|
err = dsa_switch_mrp_del_ring_role(ds, info);
|
|
break;
|
|
case DSA_NOTIFIER_TAG_8021Q_VLAN_ADD:
|
|
err = dsa_switch_tag_8021q_vlan_add(ds, info);
|
|
break;
|
|
case DSA_NOTIFIER_TAG_8021Q_VLAN_DEL:
|
|
err = dsa_switch_tag_8021q_vlan_del(ds, info);
|
|
break;
|
|
default:
|
|
err = -EOPNOTSUPP;
|
|
break;
|
|
}
|
|
|
|
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);
|
|
}
|