net: ocelot: support multiple bridges

The ocelot switches are a bit odd in that they do not have an STP state
to put the ports into. Instead, the forwarding configuration is delayed
from the typical port_bridge_join into stp_state_set, when the port enters
the BR_STATE_FORWARDING state.

I can only guess that the implementation of this quirk is the reason that
led to the simplification of the driver such that only one bridge could
be offloaded at a time.

We can simplify the data structures somewhat, and introduce a per-port
bridge device pointer and STP state, similar to how the LAG offload
works now (there we have a per-port bonding device pointer and TX
enabled state). This allows offloading multiple bridges with relative
ease, while still keeping in place the quirk to delay the programming of
the PGIDs.

We actually need this change now because we need to remove the bogus
restriction from ocelot_bridge_stp_state_set that ocelot->bridge_mask
needs to contain BIT(port), otherwise that function is a no-op.

Signed-off-by: Vladimir Oltean <vladimir.oltean@nxp.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

diff --git a/drivers/net/ethernet/mscc/ocelot.c b/drivers/net/ethernet/mscc/ocelot.c
index 9f0c9bd..ce57929 100644 (file)
--- a/drivers/net/ethernet/mscc/ocelot.c
+++ b/drivers/net/ethernet/mscc/ocelot.c
@@ -766,7 +766,7 @@ int ocelot_xtr_poll_frame(struct ocelot *ocelot, int grp, struct sk_buff **nskb)
        /* Everything we see on an interface that is in the HW bridge
         * has already been forwarded.
         */
-       if (ocelot->bridge_mask & BIT(src_port))
+       if (ocelot->ports[src_port]->bridge)
                skb->offload_fwd_mark = 1;
 
        skb->protocol = eth_type_trans(skb, dev);
@@ -1183,6 +1183,26 @@ static u32 ocelot_get_bond_mask(struct ocelot *ocelot, struct net_device *bond,
        return mask;
 }
 
+static u32 ocelot_get_bridge_fwd_mask(struct ocelot *ocelot,
+                                     struct net_device *bridge)
+{
+       u32 mask = 0;
+       int port;
+
+       for (port = 0; port < ocelot->num_phys_ports; port++) {
+               struct ocelot_port *ocelot_port = ocelot->ports[port];
+
+               if (!ocelot_port)
+                       continue;
+
+               if (ocelot_port->stp_state == BR_STATE_FORWARDING &&
+                   ocelot_port->bridge == bridge)
+                       mask |= BIT(port);
+       }
+
+       return mask;
+}
+
 static u32 ocelot_get_dsa_8021q_cpu_mask(struct ocelot *ocelot)
 {
        u32 mask = 0;
@@ -1232,10 +1252,12 @@ void ocelot_apply_bridge_fwd_mask(struct ocelot *ocelot)
                         */
                        mask = GENMASK(ocelot->num_phys_ports - 1, 0);
                        mask &= ~cpu_fwd_mask;
-               } else if (ocelot->bridge_fwd_mask & BIT(port)) {
+               } else if (ocelot_port->bridge) {
+                       struct net_device *bridge = ocelot_port->bridge;
                        struct net_device *bond = ocelot_port->bond;
 
-                       mask = ocelot->bridge_fwd_mask & ~BIT(port);
+                       mask = ocelot_get_bridge_fwd_mask(ocelot, bridge);
+                       mask &= ~BIT(port);
                        if (bond) {
                                mask &= ~ocelot_get_bond_mask(ocelot, bond,
                                                              false);
@@ -1256,29 +1278,16 @@ EXPORT_SYMBOL(ocelot_apply_bridge_fwd_mask);
 void ocelot_bridge_stp_state_set(struct ocelot *ocelot, int port, u8 state)
 {
        struct ocelot_port *ocelot_port = ocelot->ports[port];
-       u32 port_cfg;
-
-       if (!(BIT(port) & ocelot->bridge_mask))
-               return;
+       u32 learn_ena = 0;
 
-       port_cfg = ocelot_read_gix(ocelot, ANA_PORT_PORT_CFG, port);
+       ocelot_port->stp_state = state;
 
-       switch (state) {
-       case BR_STATE_FORWARDING:
-               ocelot->bridge_fwd_mask |= BIT(port);
-               fallthrough;
-       case BR_STATE_LEARNING:
-               if (ocelot_port->learn_ena)
-                       port_cfg |= ANA_PORT_PORT_CFG_LEARN_ENA;
-               break;
-
-       default:
-               port_cfg &= ~ANA_PORT_PORT_CFG_LEARN_ENA;
-               ocelot->bridge_fwd_mask &= ~BIT(port);
-               break;
-       }
+       if ((state == BR_STATE_LEARNING || state == BR_STATE_FORWARDING) &&
+           ocelot_port->learn_ena)
+               learn_ena = ANA_PORT_PORT_CFG_LEARN_ENA;
 
-       ocelot_write_gix(ocelot, port_cfg, ANA_PORT_PORT_CFG, port);
+       ocelot_rmw_gix(ocelot, learn_ena, ANA_PORT_PORT_CFG_LEARN_ENA,
+                      ANA_PORT_PORT_CFG, port);
 
        ocelot_apply_bridge_fwd_mask(ocelot);
 }
@@ -1508,16 +1517,9 @@ EXPORT_SYMBOL(ocelot_port_mdb_del);
 int ocelot_port_bridge_join(struct ocelot *ocelot, int port,
                            struct net_device *bridge)
 {
-       if (!ocelot->bridge_mask) {
-               ocelot->hw_bridge_dev = bridge;
-       } else {
-               if (ocelot->hw_bridge_dev != bridge)
-                       /* This is adding the port to a second bridge, this is
-                        * unsupported */
-                       return -ENODEV;
-       }
+       struct ocelot_port *ocelot_port = ocelot->ports[port];
 
-       ocelot->bridge_mask |= BIT(port);
+       ocelot_port->bridge = bridge;
 
        return 0;
 }
@@ -1526,13 +1528,11 @@ EXPORT_SYMBOL(ocelot_port_bridge_join);
 int ocelot_port_bridge_leave(struct ocelot *ocelot, int port,
                             struct net_device *bridge)
 {
+       struct ocelot_port *ocelot_port = ocelot->ports[port];
        struct ocelot_vlan pvid = {0}, native_vlan = {0};
        int ret;
 
-       ocelot->bridge_mask &= ~BIT(port);
-
-       if (!ocelot->bridge_mask)
-               ocelot->hw_bridge_dev = NULL;
+       ocelot_port->bridge = NULL;
 
        ret = ocelot_port_vlan_filtering(ocelot, port, false);
        if (ret)

diff --git a/include/soc/mscc/ocelot.h b/include/soc/mscc/ocelot.h
index 0a0751b..ce7e5c1 100644 (file)
--- a/include/soc/mscc/ocelot.h
+++ b/include/soc/mscc/ocelot.h
@@ -615,6 +615,9 @@ struct ocelot_port {
        bool                            lag_tx_active;
 
        u16                             mrp_ring_id;
+
+       struct net_device               *bridge;
+       u8                              stp_state;
 };
 
 struct ocelot {
@@ -634,10 +637,6 @@ struct ocelot {
        int                             num_frame_refs;
        int                             num_mact_rows;
 
-       struct net_device               *hw_bridge_dev;
-       u16                             bridge_mask;
-       u16                             bridge_fwd_mask;
-
        struct ocelot_port              **ports;
 
        u8                              base_mac[ETH_ALEN];