net: dsa: mv88e6xxx: Add Hardware bridging support

Bridge support is similar for all chips supported by the mv88e6xxx code,
so add the code there.

Reviewed-by: Andrew Lunn <andrew@lunn.ch>
Tested-by: Andrew Lunn <andrew@lunn.ch>
Signed-off-by: Guenter Roeck <linux@roeck-us.net>
Signed-off-by: David S. Miller <davem@davemloft.net>

2 files changed, 292 insertions, 7 deletions

diff --git a/drivers/net/dsa/mv88e6xxx.c b/drivers/net/dsa/mv88e6xxx.c
index d8f13327a438..17aa74f64233 100644
--- a/drivers/net/dsa/mv88e6xxx.c
+++ b/drivers/net/dsa/mv88e6xxx.c
@@ -9,6 +9,7 @@
  */
 
 #include <linux/delay.h>
+#include <linux/if_bridge.h>
 #include <linux/jiffies.h>
 #include <linux/list.h>
 #include <linux/module.h>
@@ -644,6 +645,31 @@ int mv88e6xxx_eeprom_busy_wait(struct dsa_switch *ds)
         return mv88e6xxx_wait(ds, REG_GLOBAL2, 0x14, 0x8000);
 }
 
+/* Must be called with SMI lock held */
+static int _mv88e6xxx_wait(struct dsa_switch *ds, int reg, int offset, u16 mask)
+{
+        unsigned long timeout = jiffies + HZ / 10;
+
+        while (time_before(jiffies, timeout)) {
+                int ret;
+
+                ret = _mv88e6xxx_reg_read(ds, reg, offset);
+                if (ret < 0)
+                        return ret;
+                if (!(ret & mask))
+                        return 0;
+
+                usleep_range(1000, 2000);
+        }
+        return -ETIMEDOUT;
+}
+
+/* Must be called with SMI lock held */
+static int _mv88e6xxx_atu_wait(struct dsa_switch *ds)
+{
+        return _mv88e6xxx_wait(ds, REG_GLOBAL, 0x0b, ATU_BUSY);
+}
+
 int mv88e6xxx_phy_read_indirect(struct dsa_switch *ds, int addr, int regnum)
 {
         int ret;
@@ -717,10 +743,236 @@ int mv88e6xxx_set_eee(struct dsa_switch *ds, int port,
         return 0;
 }
 
+static int _mv88e6xxx_atu_cmd(struct dsa_switch *ds, int fid, u16 cmd)
+{
+        int ret;
+
+        ret = _mv88e6xxx_reg_write(ds, REG_GLOBAL, 0x01, fid);
+        if (ret < 0)
+                return ret;
+
+        ret = _mv88e6xxx_reg_write(ds, REG_GLOBAL, 0x0b, cmd);
+        if (ret < 0)
+                return ret;
+
+        return _mv88e6xxx_atu_wait(ds);
+}
+
+static int _mv88e6xxx_flush_fid(struct dsa_switch *ds, int fid)
+{
+        int ret;
+
+        ret = _mv88e6xxx_atu_wait(ds);
+        if (ret < 0)
+                return ret;
+
+        return _mv88e6xxx_atu_cmd(ds, fid, ATU_CMD_FLUSH_NONSTATIC_FID);
+}
+
+static int mv88e6xxx_set_port_state(struct dsa_switch *ds, int port, u8 state)
+{
+        struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
+        int reg, ret;
+        u8 oldstate;
+
+        mutex_lock(&ps->smi_mutex);
+
+        reg = _mv88e6xxx_reg_read(ds, REG_PORT(port), 0x04);
+        if (reg < 0)
+                goto abort;
+
+        oldstate = reg & PSTATE_MASK;
+        if (oldstate != state) {
+                /* Flush forwarding database if we're moving a port
+                 * from Learning or Forwarding state to Disabled or
+                 * Blocking or Listening state.
+                 */
+                if (oldstate >= PSTATE_LEARNING && state <= PSTATE_BLOCKING) {
+                        ret = _mv88e6xxx_flush_fid(ds, ps->fid[port]);
+                        if (ret)
+                                goto abort;
+                }
+                reg = (reg & ~PSTATE_MASK) | state;
+                ret = _mv88e6xxx_reg_write(ds, REG_PORT(port), 0x04, reg);
+        }
+
+abort:
+        mutex_unlock(&ps->smi_mutex);
+        return ret;
+}
+
+/* Must be called with smi lock held */
+static int _mv88e6xxx_update_port_config(struct dsa_switch *ds, int port)
+{
+        struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
+        u8 fid = ps->fid[port];
+        u16 reg = fid << 12;
+
+        if (dsa_is_cpu_port(ds, port))
+                reg |= ds->phys_port_mask;
+        else
+                reg |= (ps->bridge_mask[fid] |
+                       (1 << dsa_upstream_port(ds))) & ~(1 << port);
+
+        return _mv88e6xxx_reg_write(ds, REG_PORT(port), 0x06, reg);
+}
+
+/* Must be called with smi lock held */
+static int _mv88e6xxx_update_bridge_config(struct dsa_switch *ds, int fid)
+{
+        struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
+        int port;
+        u32 mask;
+        int ret;
+
+        mask = ds->phys_port_mask;
+        while (mask) {
+                port = __ffs(mask);
+                mask &= ~(1 << port);
+                if (ps->fid[port] != fid)
+                        continue;
+
+                ret = _mv88e6xxx_update_port_config(ds, port);
+                if (ret)
+                        return ret;
+        }
+
+        return _mv88e6xxx_flush_fid(ds, fid);
+}
+
+/* Bridge handling functions */
+
+int mv88e6xxx_join_bridge(struct dsa_switch *ds, int port, u32 br_port_mask)
+{
+        struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
+        int ret = 0;
+        u32 nmask;
+        int fid;
+
+        /* If the bridge group is not empty, join that group.
+         * Otherwise create a new group.
+         */
+        fid = ps->fid[port];
+        nmask = br_port_mask & ~(1 << port);
+        if (nmask)
+                fid = ps->fid[__ffs(nmask)];
+
+        nmask = ps->bridge_mask[fid] | (1 << port);
+        if (nmask != br_port_mask) {
+                netdev_err(ds->ports[port],
+                           "join: Bridge port mask mismatch fid=%d mask=0x%x expected 0x%x\n",
+                           fid, br_port_mask, nmask);
+                return -EINVAL;
+        }
+
+        mutex_lock(&ps->smi_mutex);
+
+        ps->bridge_mask[fid] = br_port_mask;
+
+        if (fid != ps->fid[port]) {
+                ps->fid_mask |= 1 << ps->fid[port];
+                ps->fid[port] = fid;
+                ret = _mv88e6xxx_update_bridge_config(ds, fid);
+        }
+
+        mutex_unlock(&ps->smi_mutex);
+
+        return ret;
+}
+
+int mv88e6xxx_leave_bridge(struct dsa_switch *ds, int port, u32 br_port_mask)
+{
+        struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
+        u8 fid, newfid;
+        int ret;
+
+        fid = ps->fid[port];
+