Since commit2f1e8ea726
("net: dsa: link interfaces with the DSA master to get rid of lockdep warnings"), DSA gained a requirement which it did not fulfill, which is to unlink itself from the DSA master at shutdown time. Since the Arrow SpeedChips XRS700x driver was introduced after the bad commit, it has never worked with DSA masters which decide to unregister their net_device on shutdown, effectively hanging the reboot process. To fix that, we need to call dsa_switch_shutdown. These devices can be connected by I2C or by MDIO, and if I search for I2C or MDIO bus drivers that implement their ->shutdown by redirecting it to ->remove I don't see any, however this does not mean it would not be possible. To be compatible with that pattern, it is necessary to implement an "if this then not that" scheme, to avoid ->remove and ->shutdown from being called both for the same struct device. Fixes:ee00b24f32
("net: dsa: add Arrow SpeedChips XRS700x driver") Link: https://lore.kernel.org/netdev/20210909095324.12978-1-LinoSanfilippo@gmx.de/ Reported-by: Lino Sanfilippo <LinoSanfilippo@gmx.de> Signed-off-by: Vladimir Oltean <vladimir.oltean@nxp.com> Reviewed-by: George McCollister <george.mccollister@gmail.com> Reviewed-by: Florian Fainelli <f.fainelli@gmail.com> Signed-off-by: David S. Miller <davem@davemloft.net>
833 lines
21 KiB
C
833 lines
21 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* Copyright (C) 2020 NovaTech LLC
|
|
* George McCollister <george.mccollister@gmail.com>
|
|
*/
|
|
|
|
#include <net/dsa.h>
|
|
#include <linux/if_bridge.h>
|
|
#include <linux/of_device.h>
|
|
#include <linux/netdev_features.h>
|
|
#include <linux/if_hsr.h>
|
|
#include "xrs700x.h"
|
|
#include "xrs700x_reg.h"
|
|
|
|
#define XRS700X_MIB_INTERVAL msecs_to_jiffies(3000)
|
|
|
|
#define XRS7000X_SUPPORTED_HSR_FEATURES \
|
|
(NETIF_F_HW_HSR_TAG_INS | NETIF_F_HW_HSR_TAG_RM | \
|
|
NETIF_F_HW_HSR_FWD | NETIF_F_HW_HSR_DUP)
|
|
|
|
#define XRS7003E_ID 0x100
|
|
#define XRS7003F_ID 0x101
|
|
#define XRS7004E_ID 0x200
|
|
#define XRS7004F_ID 0x201
|
|
|
|
const struct xrs700x_info xrs7003e_info = {XRS7003E_ID, "XRS7003E", 3};
|
|
EXPORT_SYMBOL(xrs7003e_info);
|
|
|
|
const struct xrs700x_info xrs7003f_info = {XRS7003F_ID, "XRS7003F", 3};
|
|
EXPORT_SYMBOL(xrs7003f_info);
|
|
|
|
const struct xrs700x_info xrs7004e_info = {XRS7004E_ID, "XRS7004E", 4};
|
|
EXPORT_SYMBOL(xrs7004e_info);
|
|
|
|
const struct xrs700x_info xrs7004f_info = {XRS7004F_ID, "XRS7004F", 4};
|
|
EXPORT_SYMBOL(xrs7004f_info);
|
|
|
|
struct xrs700x_regfield {
|
|
struct reg_field rf;
|
|
struct regmap_field **rmf;
|
|
};
|
|
|
|
struct xrs700x_mib {
|
|
unsigned int offset;
|
|
const char *name;
|
|
int stats64_offset;
|
|
};
|
|
|
|
#define XRS700X_MIB_ETHTOOL_ONLY(o, n) {o, n, -1}
|
|
#define XRS700X_MIB(o, n, m) {o, n, offsetof(struct rtnl_link_stats64, m)}
|
|
|
|
static const struct xrs700x_mib xrs700x_mibs[] = {
|
|
XRS700X_MIB(XRS_RX_GOOD_OCTETS_L, "rx_good_octets", rx_bytes),
|
|
XRS700X_MIB_ETHTOOL_ONLY(XRS_RX_BAD_OCTETS_L, "rx_bad_octets"),
|
|
XRS700X_MIB(XRS_RX_UNICAST_L, "rx_unicast", rx_packets),
|
|
XRS700X_MIB(XRS_RX_BROADCAST_L, "rx_broadcast", rx_packets),
|
|
XRS700X_MIB(XRS_RX_MULTICAST_L, "rx_multicast", multicast),
|
|
XRS700X_MIB(XRS_RX_UNDERSIZE_L, "rx_undersize", rx_length_errors),
|
|
XRS700X_MIB(XRS_RX_FRAGMENTS_L, "rx_fragments", rx_length_errors),
|
|
XRS700X_MIB(XRS_RX_OVERSIZE_L, "rx_oversize", rx_length_errors),
|
|
XRS700X_MIB(XRS_RX_JABBER_L, "rx_jabber", rx_length_errors),
|
|
XRS700X_MIB(XRS_RX_ERR_L, "rx_err", rx_errors),
|
|
XRS700X_MIB(XRS_RX_CRC_L, "rx_crc", rx_crc_errors),
|
|
XRS700X_MIB_ETHTOOL_ONLY(XRS_RX_64_L, "rx_64"),
|
|
XRS700X_MIB_ETHTOOL_ONLY(XRS_RX_65_127_L, "rx_65_127"),
|
|
XRS700X_MIB_ETHTOOL_ONLY(XRS_RX_128_255_L, "rx_128_255"),
|
|
XRS700X_MIB_ETHTOOL_ONLY(XRS_RX_256_511_L, "rx_256_511"),
|
|
XRS700X_MIB_ETHTOOL_ONLY(XRS_RX_512_1023_L, "rx_512_1023"),
|
|
XRS700X_MIB_ETHTOOL_ONLY(XRS_RX_1024_1536_L, "rx_1024_1536"),
|
|
XRS700X_MIB_ETHTOOL_ONLY(XRS_RX_HSR_PRP_L, "rx_hsr_prp"),
|
|
XRS700X_MIB_ETHTOOL_ONLY(XRS_RX_WRONGLAN_L, "rx_wronglan"),
|
|
XRS700X_MIB_ETHTOOL_ONLY(XRS_RX_DUPLICATE_L, "rx_duplicate"),
|
|
XRS700X_MIB(XRS_TX_OCTETS_L, "tx_octets", tx_bytes),
|
|
XRS700X_MIB(XRS_TX_UNICAST_L, "tx_unicast", tx_packets),
|
|
XRS700X_MIB(XRS_TX_BROADCAST_L, "tx_broadcast", tx_packets),
|
|
XRS700X_MIB(XRS_TX_MULTICAST_L, "tx_multicast", tx_packets),
|
|
XRS700X_MIB_ETHTOOL_ONLY(XRS_TX_HSR_PRP_L, "tx_hsr_prp"),
|
|
XRS700X_MIB(XRS_PRIQ_DROP_L, "priq_drop", tx_dropped),
|
|
XRS700X_MIB(XRS_EARLY_DROP_L, "early_drop", tx_dropped),
|
|
};
|
|
|
|
static const u8 eth_hsrsup_addr[ETH_ALEN] = {
|
|
0x01, 0x15, 0x4e, 0x00, 0x01, 0x00};
|
|
|
|
static void xrs700x_get_strings(struct dsa_switch *ds, int port,
|
|
u32 stringset, u8 *data)
|
|
{
|
|
int i;
|
|
|
|
if (stringset != ETH_SS_STATS)
|
|
return;
|
|
|
|
for (i = 0; i < ARRAY_SIZE(xrs700x_mibs); i++) {
|
|
strscpy(data, xrs700x_mibs[i].name, ETH_GSTRING_LEN);
|
|
data += ETH_GSTRING_LEN;
|
|
}
|
|
}
|
|
|
|
static int xrs700x_get_sset_count(struct dsa_switch *ds, int port, int sset)
|
|
{
|
|
if (sset != ETH_SS_STATS)
|
|
return -EOPNOTSUPP;
|
|
|
|
return ARRAY_SIZE(xrs700x_mibs);
|
|
}
|
|
|
|
static void xrs700x_read_port_counters(struct xrs700x *priv, int port)
|
|
{
|
|
struct xrs700x_port *p = &priv->ports[port];
|
|
struct rtnl_link_stats64 stats;
|
|
int i;
|
|
|
|
memset(&stats, 0, sizeof(stats));
|
|
|
|
mutex_lock(&p->mib_mutex);
|
|
|
|
/* Capture counter values */
|
|
regmap_write(priv->regmap, XRS_CNT_CTRL(port), 1);
|
|
|
|
for (i = 0; i < ARRAY_SIZE(xrs700x_mibs); i++) {
|
|
unsigned int high = 0, low = 0, reg;
|
|
|
|
reg = xrs700x_mibs[i].offset + XRS_PORT_OFFSET * port;
|
|
regmap_read(priv->regmap, reg, &low);
|
|
regmap_read(priv->regmap, reg + 2, &high);
|
|
|
|
p->mib_data[i] += (high << 16) | low;
|
|
|
|
if (xrs700x_mibs[i].stats64_offset >= 0) {
|
|
u8 *s = (u8 *)&stats + xrs700x_mibs[i].stats64_offset;
|
|
*(u64 *)s += p->mib_data[i];
|
|
}
|
|
}
|
|
|
|
/* multicast must be added to rx_packets (which already includes
|
|
* unicast and broadcast)
|
|
*/
|
|
stats.rx_packets += stats.multicast;
|
|
|
|
u64_stats_update_begin(&p->syncp);
|
|
p->stats64 = stats;
|
|
u64_stats_update_end(&p->syncp);
|
|
|
|
mutex_unlock(&p->mib_mutex);
|
|
}
|
|
|
|
static void xrs700x_mib_work(struct work_struct *work)
|
|
{
|
|
struct xrs700x *priv = container_of(work, struct xrs700x,
|
|
mib_work.work);
|
|
int i;
|
|
|
|
for (i = 0; i < priv->ds->num_ports; i++)
|
|
xrs700x_read_port_counters(priv, i);
|
|
|
|
schedule_delayed_work(&priv->mib_work, XRS700X_MIB_INTERVAL);
|
|
}
|
|
|
|
static void xrs700x_get_ethtool_stats(struct dsa_switch *ds, int port,
|
|
u64 *data)
|
|
{
|
|
struct xrs700x *priv = ds->priv;
|
|
struct xrs700x_port *p = &priv->ports[port];
|
|
|
|
xrs700x_read_port_counters(priv, port);
|
|
|
|
mutex_lock(&p->mib_mutex);
|
|
memcpy(data, p->mib_data, sizeof(*data) * ARRAY_SIZE(xrs700x_mibs));
|
|
mutex_unlock(&p->mib_mutex);
|
|
}
|
|
|
|
static void xrs700x_get_stats64(struct dsa_switch *ds, int port,
|
|
struct rtnl_link_stats64 *s)
|
|
{
|
|
struct xrs700x *priv = ds->priv;
|
|
struct xrs700x_port *p = &priv->ports[port];
|
|
unsigned int start;
|
|
|
|
do {
|
|
start = u64_stats_fetch_begin(&p->syncp);
|
|
*s = p->stats64;
|
|
} while (u64_stats_fetch_retry(&p->syncp, start));
|
|
}
|
|
|
|
static int xrs700x_setup_regmap_range(struct xrs700x *priv)
|
|
{
|
|
struct xrs700x_regfield regfields[] = {
|
|
{
|
|
.rf = REG_FIELD_ID(XRS_PORT_STATE(0), 0, 1,
|
|
priv->ds->num_ports,
|
|
XRS_PORT_OFFSET),
|
|
.rmf = &priv->ps_forward
|
|
},
|
|
{
|
|
.rf = REG_FIELD_ID(XRS_PORT_STATE(0), 2, 3,
|
|
priv->ds->num_ports,
|
|
XRS_PORT_OFFSET),
|
|
.rmf = &priv->ps_management
|
|
},
|
|
{
|
|
.rf = REG_FIELD_ID(XRS_PORT_STATE(0), 4, 9,
|
|
priv->ds->num_ports,
|
|
XRS_PORT_OFFSET),
|
|
.rmf = &priv->ps_sel_speed
|
|
},
|
|
{
|
|
.rf = REG_FIELD_ID(XRS_PORT_STATE(0), 10, 11,
|
|
priv->ds->num_ports,
|
|
XRS_PORT_OFFSET),
|
|
.rmf = &priv->ps_cur_speed
|
|
}
|
|
};
|
|
int i = 0;
|
|
|
|
for (; i < ARRAY_SIZE(regfields); i++) {
|
|
*regfields[i].rmf = devm_regmap_field_alloc(priv->dev,
|
|
priv->regmap,
|
|
regfields[i].rf);
|
|
if (IS_ERR(*regfields[i].rmf))
|
|
return PTR_ERR(*regfields[i].rmf);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static enum dsa_tag_protocol xrs700x_get_tag_protocol(struct dsa_switch *ds,
|
|
int port,
|
|
enum dsa_tag_protocol m)
|
|
{
|
|
return DSA_TAG_PROTO_XRS700X;
|
|
}
|
|
|
|
static int xrs700x_reset(struct dsa_switch *ds)
|
|
{
|
|
struct xrs700x *priv = ds->priv;
|
|
unsigned int val;
|
|
int ret;
|
|
|
|
ret = regmap_write(priv->regmap, XRS_GENERAL, XRS_GENERAL_RESET);
|
|
if (ret)
|
|
goto error;
|
|
|
|
ret = regmap_read_poll_timeout(priv->regmap, XRS_GENERAL,
|
|
val, !(val & XRS_GENERAL_RESET),
|
|
10, 1000);
|
|
error:
|
|
if (ret) {
|
|
dev_err_ratelimited(priv->dev, "error resetting switch: %d\n",
|
|
ret);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static void xrs700x_port_stp_state_set(struct dsa_switch *ds, int port,
|
|
u8 state)
|
|
{
|
|
struct xrs700x *priv = ds->priv;
|
|
unsigned int bpdus = 1;
|
|
unsigned int val;
|
|
|
|
switch (state) {
|
|
case BR_STATE_DISABLED:
|
|
bpdus = 0;
|
|
fallthrough;
|
|
case BR_STATE_BLOCKING:
|
|
case BR_STATE_LISTENING:
|
|
val = XRS_PORT_DISABLED;
|
|
break;
|
|
case BR_STATE_LEARNING:
|
|
val = XRS_PORT_LEARNING;
|
|
break;
|
|
case BR_STATE_FORWARDING:
|
|
val = XRS_PORT_FORWARDING;
|
|
break;
|
|
default:
|
|
dev_err(ds->dev, "invalid STP state: %d\n", state);
|
|
return;
|
|
}
|
|
|
|
regmap_fields_write(priv->ps_forward, port, val);
|
|
|
|
/* Enable/disable inbound policy added by xrs700x_port_add_bpdu_ipf()
|
|
* which allows BPDU forwarding to the CPU port when the front facing
|
|
* port is in disabled/learning state.
|
|
*/
|
|
regmap_update_bits(priv->regmap, XRS_ETH_ADDR_CFG(port, 0), 1, bpdus);
|
|
|
|
dev_dbg_ratelimited(priv->dev, "%s - port: %d, state: %u, val: 0x%x\n",
|
|
__func__, port, state, val);
|
|
}
|
|
|
|
/* Add an inbound policy filter which matches the BPDU destination MAC
|
|
* and forwards to the CPU port. Leave the policy disabled, it will be
|
|
* enabled as needed.
|
|
*/
|
|
static int xrs700x_port_add_bpdu_ipf(struct dsa_switch *ds, int port)
|
|
{
|
|
struct xrs700x *priv = ds->priv;
|
|
unsigned int val = 0;
|
|
int i = 0;
|
|
int ret;
|
|
|
|
/* Compare all 48 bits of the destination MAC address. */
|
|
ret = regmap_write(priv->regmap, XRS_ETH_ADDR_CFG(port, 0), 48 << 2);
|
|
if (ret)
|
|
return ret;
|
|
|
|
/* match BPDU destination 01:80:c2:00:00:00 */
|
|
for (i = 0; i < sizeof(eth_stp_addr); i += 2) {
|
|
ret = regmap_write(priv->regmap, XRS_ETH_ADDR_0(port, 0) + i,
|
|
eth_stp_addr[i] |
|
|
(eth_stp_addr[i + 1] << 8));
|
|
if (ret)
|
|
return ret;
|
|
}
|
|
|
|
/* Mirror BPDU to CPU port */
|
|
for (i = 0; i < ds->num_ports; i++) {
|
|
if (dsa_is_cpu_port(ds, i))
|
|
val |= BIT(i);
|
|
}
|
|
|
|
ret = regmap_write(priv->regmap, XRS_ETH_ADDR_FWD_MIRROR(port, 0), val);
|
|
if (ret)
|
|
return ret;
|
|
|
|
ret = regmap_write(priv->regmap, XRS_ETH_ADDR_FWD_ALLOW(port, 0), 0);
|
|
if (ret)
|
|
return ret;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* Add an inbound policy filter which matches the HSR/PRP supervision MAC
|
|
* range and forwards to the CPU port without discarding duplicates.
|
|
* This is required to correctly populate the HSR/PRP node_table.
|
|
* Leave the policy disabled, it will be enabled as needed.
|
|
*/
|
|
static int xrs700x_port_add_hsrsup_ipf(struct dsa_switch *ds, int port,
|
|
int fwdport)
|
|
{
|
|
struct xrs700x *priv = ds->priv;
|
|
unsigned int val = 0;
|
|
int i = 0;
|
|
int ret;
|
|
|
|
/* Compare 40 bits of the destination MAC address. */
|
|
ret = regmap_write(priv->regmap, XRS_ETH_ADDR_CFG(port, 1), 40 << 2);
|
|
if (ret)
|
|
return ret;
|
|
|
|
/* match HSR/PRP supervision destination 01:15:4e:00:01:XX */
|
|
for (i = 0; i < sizeof(eth_hsrsup_addr); i += 2) {
|
|
ret = regmap_write(priv->regmap, XRS_ETH_ADDR_0(port, 1) + i,
|
|
eth_hsrsup_addr[i] |
|
|
(eth_hsrsup_addr[i + 1] << 8));
|
|
if (ret)
|
|
return ret;
|
|
}
|
|
|
|
/* Mirror HSR/PRP supervision to CPU port */
|
|
for (i = 0; i < ds->num_ports; i++) {
|
|
if (dsa_is_cpu_port(ds, i))
|
|
val |= BIT(i);
|
|
}
|
|
|
|
ret = regmap_write(priv->regmap, XRS_ETH_ADDR_FWD_MIRROR(port, 1), val);
|
|
if (ret)
|
|
return ret;
|
|
|
|
if (fwdport >= 0)
|
|
val |= BIT(fwdport);
|
|
|
|
/* Allow must be set prevent duplicate discard */
|
|
ret = regmap_write(priv->regmap, XRS_ETH_ADDR_FWD_ALLOW(port, 1), val);
|
|
if (ret)
|
|
return ret;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int xrs700x_port_setup(struct dsa_switch *ds, int port)
|
|
{
|
|
bool cpu_port = dsa_is_cpu_port(ds, port);
|
|
struct xrs700x *priv = ds->priv;
|
|
unsigned int val = 0;
|
|
int ret, i;
|
|
|
|
xrs700x_port_stp_state_set(ds, port, BR_STATE_DISABLED);
|
|
|
|
/* Disable forwarding to non-CPU ports */
|
|
for (i = 0; i < ds->num_ports; i++) {
|
|
if (!dsa_is_cpu_port(ds, i))
|
|
val |= BIT(i);
|
|
}
|
|
|
|
/* 1 = Disable forwarding to the port */
|
|
ret = regmap_write(priv->regmap, XRS_PORT_FWD_MASK(port), val);
|
|
if (ret)
|
|
return ret;
|
|
|
|
val = cpu_port ? XRS_PORT_MODE_MANAGEMENT : XRS_PORT_MODE_NORMAL;
|
|
ret = regmap_fields_write(priv->ps_management, port, val);
|
|
if (ret)
|
|
return ret;
|
|
|
|
if (!cpu_port) {
|
|
ret = xrs700x_port_add_bpdu_ipf(ds, port);
|
|
if (ret)
|
|
return ret;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int xrs700x_setup(struct dsa_switch *ds)
|
|
{
|
|
struct xrs700x *priv = ds->priv;
|
|
int ret, i;
|
|
|
|
ret = xrs700x_reset(ds);
|
|
if (ret)
|
|
return ret;
|
|
|
|
for (i = 0; i < ds->num_ports; i++) {
|
|
ret = xrs700x_port_setup(ds, i);
|
|
if (ret)
|
|
return ret;
|
|
}
|
|
|
|
schedule_delayed_work(&priv->mib_work, XRS700X_MIB_INTERVAL);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void xrs700x_teardown(struct dsa_switch *ds)
|
|
{
|
|
struct xrs700x *priv = ds->priv;
|
|
|
|
cancel_delayed_work_sync(&priv->mib_work);
|
|
}
|
|
|
|
static void xrs700x_phylink_validate(struct dsa_switch *ds, int port,
|
|
unsigned long *supported,
|
|
struct phylink_link_state *state)
|
|
{
|
|
__ETHTOOL_DECLARE_LINK_MODE_MASK(mask) = { 0, };
|
|
|
|
switch (port) {
|
|
case 0:
|
|
break;
|
|
case 1:
|
|
case 2:
|
|
case 3:
|
|
phylink_set(mask, 1000baseT_Full);
|
|
break;
|
|
default:
|
|
bitmap_zero(supported, __ETHTOOL_LINK_MODE_MASK_NBITS);
|
|
dev_err(ds->dev, "Unsupported port: %i\n", port);
|
|
return;
|
|
}
|
|
|
|
phylink_set_port_modes(mask);
|
|
|
|
/* The switch only supports full duplex. */
|
|
phylink_set(mask, 10baseT_Full);
|
|
phylink_set(mask, 100baseT_Full);
|
|
|
|
bitmap_and(supported, supported, mask,
|
|
__ETHTOOL_LINK_MODE_MASK_NBITS);
|
|
bitmap_and(state->advertising, state->advertising, mask,
|
|
__ETHTOOL_LINK_MODE_MASK_NBITS);
|
|
}
|
|
|
|
static void xrs700x_mac_link_up(struct dsa_switch *ds, int port,
|
|
unsigned int mode, phy_interface_t interface,
|
|
struct phy_device *phydev,
|
|
int speed, int duplex,
|
|
bool tx_pause, bool rx_pause)
|
|
{
|
|
struct xrs700x *priv = ds->priv;
|
|
unsigned int val;
|
|
|
|
switch (speed) {
|
|
case SPEED_1000:
|
|
val = XRS_PORT_SPEED_1000;
|
|
break;
|
|
case SPEED_100:
|
|
val = XRS_PORT_SPEED_100;
|
|
break;
|
|
case SPEED_10:
|
|
val = XRS_PORT_SPEED_10;
|
|
break;
|
|
default:
|
|
return;
|
|
}
|
|
|
|
regmap_fields_write(priv->ps_sel_speed, port, val);
|
|
|
|
dev_dbg_ratelimited(priv->dev, "%s: port: %d mode: %u speed: %u\n",
|
|
__func__, port, mode, speed);
|
|
}
|
|
|
|
static int xrs700x_bridge_common(struct dsa_switch *ds, int port,
|
|
struct net_device *bridge, bool join)
|
|
{
|
|
unsigned int i, cpu_mask = 0, mask = 0;
|
|
struct xrs700x *priv = ds->priv;
|
|
int ret;
|
|
|
|
for (i = 0; i < ds->num_ports; i++) {
|
|
if (dsa_is_cpu_port(ds, i))
|
|
continue;
|
|
|
|
cpu_mask |= BIT(i);
|
|
|
|
if (dsa_to_port(ds, i)->bridge_dev == bridge)
|
|
continue;
|
|
|
|
mask |= BIT(i);
|
|
}
|
|
|
|
for (i = 0; i < ds->num_ports; i++) {
|
|
if (dsa_to_port(ds, i)->bridge_dev != bridge)
|
|
continue;
|
|
|
|
/* 1 = Disable forwarding to the port */
|
|
ret = regmap_write(priv->regmap, XRS_PORT_FWD_MASK(i), mask);
|
|
if (ret)
|
|
return ret;
|
|
}
|
|
|
|
if (!join) {
|
|
ret = regmap_write(priv->regmap, XRS_PORT_FWD_MASK(port),
|
|
cpu_mask);
|
|
if (ret)
|
|
return ret;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int xrs700x_bridge_join(struct dsa_switch *ds, int port,
|
|
struct net_device *bridge)
|
|
{
|
|
return xrs700x_bridge_common(ds, port, bridge, true);
|
|
}
|
|
|
|
static void xrs700x_bridge_leave(struct dsa_switch *ds, int port,
|
|
struct net_device *bridge)
|
|
{
|
|
xrs700x_bridge_common(ds, port, bridge, false);
|
|
}
|
|
|
|
static int xrs700x_hsr_join(struct dsa_switch *ds, int port,
|
|
struct net_device *hsr)
|
|
{
|
|
unsigned int val = XRS_HSR_CFG_HSR_PRP;
|
|
struct dsa_port *partner = NULL, *dp;
|
|
struct xrs700x *priv = ds->priv;
|
|
struct net_device *slave;
|
|
int ret, i, hsr_pair[2];
|
|
enum hsr_version ver;
|
|
bool fwd = false;
|
|
|
|
ret = hsr_get_version(hsr, &ver);
|
|
if (ret)
|
|
return ret;
|
|
|
|
/* Only ports 1 and 2 can be HSR/PRP redundant ports. */
|
|
if (port != 1 && port != 2)
|
|
return -EOPNOTSUPP;
|
|
|
|
if (ver == HSR_V1)
|
|
val |= XRS_HSR_CFG_HSR;
|
|
else if (ver == PRP_V1)
|
|
val |= XRS_HSR_CFG_PRP;
|
|
else
|
|
return -EOPNOTSUPP;
|
|
|
|
dsa_hsr_foreach_port(dp, ds, hsr) {
|
|
if (dp->index != port) {
|
|
partner = dp;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* We can't enable redundancy on the switch until both
|
|
* redundant ports have signed up.
|
|
*/
|
|
if (!partner)
|
|
return 0;
|
|
|
|
regmap_fields_write(priv->ps_forward, partner->index,
|
|
XRS_PORT_DISABLED);
|
|
regmap_fields_write(priv->ps_forward, port, XRS_PORT_DISABLED);
|
|
|
|
regmap_write(priv->regmap, XRS_HSR_CFG(partner->index),
|
|
val | XRS_HSR_CFG_LANID_A);
|
|
regmap_write(priv->regmap, XRS_HSR_CFG(port),
|
|
val | XRS_HSR_CFG_LANID_B);
|
|
|
|
/* Clear bits for both redundant ports (HSR only) and the CPU port to
|
|
* enable forwarding.
|
|
*/
|
|
val = GENMASK(ds->num_ports - 1, 0);
|
|
if (ver == HSR_V1) {
|
|
val &= ~BIT(partner->index);
|
|
val &= ~BIT(port);
|
|
fwd = true;
|
|
}
|
|
val &= ~BIT(dsa_upstream_port(ds, port));
|
|
regmap_write(priv->regmap, XRS_PORT_FWD_MASK(partner->index), val);
|
|
regmap_write(priv->regmap, XRS_PORT_FWD_MASK(port), val);
|
|
|
|
regmap_fields_write(priv->ps_forward, partner->index,
|
|
XRS_PORT_FORWARDING);
|
|
regmap_fields_write(priv->ps_forward, port, XRS_PORT_FORWARDING);
|
|
|
|
/* Enable inbound policy which allows HSR/PRP supervision forwarding
|
|
* to the CPU port without discarding duplicates. Continue to
|
|
* forward to redundant ports when in HSR mode while discarding
|
|
* duplicates.
|
|
*/
|
|
ret = xrs700x_port_add_hsrsup_ipf(ds, partner->index, fwd ? port : -1);
|
|
if (ret)
|
|
return ret;
|
|
|
|
ret = xrs700x_port_add_hsrsup_ipf(ds, port, fwd ? partner->index : -1);
|
|
if (ret)
|
|
return ret;
|
|
|
|
regmap_update_bits(priv->regmap,
|
|
XRS_ETH_ADDR_CFG(partner->index, 1), 1, 1);
|
|
regmap_update_bits(priv->regmap, XRS_ETH_ADDR_CFG(port, 1), 1, 1);
|
|
|
|
hsr_pair[0] = port;
|
|
hsr_pair[1] = partner->index;
|
|
for (i = 0; i < ARRAY_SIZE(hsr_pair); i++) {
|
|
slave = dsa_to_port(ds, hsr_pair[i])->slave;
|
|
slave->features |= XRS7000X_SUPPORTED_HSR_FEATURES;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int xrs700x_hsr_leave(struct dsa_switch *ds, int port,
|
|
struct net_device *hsr)
|
|
{
|
|
struct dsa_port *partner = NULL, *dp;
|
|
struct xrs700x *priv = ds->priv;
|
|
struct net_device *slave;
|
|
int i, hsr_pair[2];
|
|
unsigned int val;
|
|
|
|
dsa_hsr_foreach_port(dp, ds, hsr) {
|
|
if (dp->index != port) {
|
|
partner = dp;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!partner)
|
|
return 0;
|
|
|
|
regmap_fields_write(priv->ps_forward, partner->index,
|
|
XRS_PORT_DISABLED);
|
|
regmap_fields_write(priv->ps_forward, port, XRS_PORT_DISABLED);
|
|
|
|
regmap_write(priv->regmap, XRS_HSR_CFG(partner->index), 0);
|
|
regmap_write(priv->regmap, XRS_HSR_CFG(port), 0);
|
|
|
|
/* Clear bit for the CPU port to enable forwarding. */
|
|
val = GENMASK(ds->num_ports - 1, 0);
|
|
val &= ~BIT(dsa_upstream_port(ds, port));
|
|
regmap_write(priv->regmap, XRS_PORT_FWD_MASK(partner->index), val);
|
|
regmap_write(priv->regmap, XRS_PORT_FWD_MASK(port), val);
|
|
|
|
regmap_fields_write(priv->ps_forward, partner->index,
|
|
XRS_PORT_FORWARDING);
|
|
regmap_fields_write(priv->ps_forward, port, XRS_PORT_FORWARDING);
|
|
|
|
/* Disable inbound policy added by xrs700x_port_add_hsrsup_ipf()
|
|
* which allows HSR/PRP supervision forwarding to the CPU port without
|
|
* discarding duplicates.
|
|
*/
|
|
regmap_update_bits(priv->regmap,
|
|
XRS_ETH_ADDR_CFG(partner->index, 1), 1, 0);
|
|
regmap_update_bits(priv->regmap, XRS_ETH_ADDR_CFG(port, 1), 1, 0);
|
|
|
|
hsr_pair[0] = port;
|
|
hsr_pair[1] = partner->index;
|
|
for (i = 0; i < ARRAY_SIZE(hsr_pair); i++) {
|
|
slave = dsa_to_port(ds, hsr_pair[i])->slave;
|
|
slave->features &= ~XRS7000X_SUPPORTED_HSR_FEATURES;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static const struct dsa_switch_ops xrs700x_ops = {
|
|
.get_tag_protocol = xrs700x_get_tag_protocol,
|
|
.setup = xrs700x_setup,
|
|
.teardown = xrs700x_teardown,
|
|
.port_stp_state_set = xrs700x_port_stp_state_set,
|
|
.phylink_validate = xrs700x_phylink_validate,
|
|
.phylink_mac_link_up = xrs700x_mac_link_up,
|
|
.get_strings = xrs700x_get_strings,
|
|
.get_sset_count = xrs700x_get_sset_count,
|
|
.get_ethtool_stats = xrs700x_get_ethtool_stats,
|
|
.get_stats64 = xrs700x_get_stats64,
|
|
.port_bridge_join = xrs700x_bridge_join,
|
|
.port_bridge_leave = xrs700x_bridge_leave,
|
|
.port_hsr_join = xrs700x_hsr_join,
|
|
.port_hsr_leave = xrs700x_hsr_leave,
|
|
};
|
|
|
|
static int xrs700x_detect(struct xrs700x *priv)
|
|
{
|
|
const struct xrs700x_info *info;
|
|
unsigned int id;
|
|
int ret;
|
|
|
|
ret = regmap_read(priv->regmap, XRS_DEV_ID0, &id);
|
|
if (ret) {
|
|
dev_err(priv->dev, "error %d while reading switch id.\n",
|
|
ret);
|
|
return ret;
|
|
}
|
|
|
|
info = of_device_get_match_data(priv->dev);
|
|
if (!info)
|
|
return -EINVAL;
|
|
|
|
if (info->id == id) {
|
|
priv->ds->num_ports = info->num_ports;
|
|
dev_info(priv->dev, "%s detected.\n", info->name);
|
|
return 0;
|
|
}
|
|
|
|
dev_err(priv->dev, "expected switch id 0x%x but found 0x%x.\n",
|
|
info->id, id);
|
|
|
|
return -ENODEV;
|
|
}
|
|
|
|
struct xrs700x *xrs700x_switch_alloc(struct device *base, void *devpriv)
|
|
{
|
|
struct dsa_switch *ds;
|
|
struct xrs700x *priv;
|
|
|
|
ds = devm_kzalloc(base, sizeof(*ds), GFP_KERNEL);
|
|
if (!ds)
|
|
return NULL;
|
|
|
|
ds->dev = base;
|
|
|
|
priv = devm_kzalloc(base, sizeof(*priv), GFP_KERNEL);
|
|
if (!priv)
|
|
return NULL;
|
|
|
|
INIT_DELAYED_WORK(&priv->mib_work, xrs700x_mib_work);
|
|
|
|
ds->ops = &xrs700x_ops;
|
|
ds->priv = priv;
|
|
priv->dev = base;
|
|
|
|
priv->ds = ds;
|
|
priv->priv = devpriv;
|
|
|
|
return priv;
|
|
}
|
|
EXPORT_SYMBOL(xrs700x_switch_alloc);
|
|
|
|
static int xrs700x_alloc_port_mib(struct xrs700x *priv, int port)
|
|
{
|
|
struct xrs700x_port *p = &priv->ports[port];
|
|
|
|
p->mib_data = devm_kcalloc(priv->dev, ARRAY_SIZE(xrs700x_mibs),
|
|
sizeof(*p->mib_data), GFP_KERNEL);
|
|
if (!p->mib_data)
|
|
return -ENOMEM;
|
|
|
|
mutex_init(&p->mib_mutex);
|
|
u64_stats_init(&p->syncp);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int xrs700x_switch_register(struct xrs700x *priv)
|
|
{
|
|
int ret;
|
|
int i;
|
|
|
|
ret = xrs700x_detect(priv);
|
|
if (ret)
|
|
return ret;
|
|
|
|
ret = xrs700x_setup_regmap_range(priv);
|
|
if (ret)
|
|
return ret;
|
|
|
|
priv->ports = devm_kcalloc(priv->dev, priv->ds->num_ports,
|
|
sizeof(*priv->ports), GFP_KERNEL);
|
|
if (!priv->ports)
|
|
return -ENOMEM;
|
|
|
|
for (i = 0; i < priv->ds->num_ports; i++) {
|
|
ret = xrs700x_alloc_port_mib(priv, i);
|
|
if (ret)
|
|
return ret;
|
|
}
|
|
|
|
return dsa_register_switch(priv->ds);
|
|
}
|
|
EXPORT_SYMBOL(xrs700x_switch_register);
|
|
|
|
void xrs700x_switch_remove(struct xrs700x *priv)
|
|
{
|
|
dsa_unregister_switch(priv->ds);
|
|
}
|
|
EXPORT_SYMBOL(xrs700x_switch_remove);
|
|
|
|
void xrs700x_switch_shutdown(struct xrs700x *priv)
|
|
{
|
|
dsa_switch_shutdown(priv->ds);
|
|
}
|
|
EXPORT_SYMBOL(xrs700x_switch_shutdown);
|
|
|
|
MODULE_AUTHOR("George McCollister <george.mccollister@gmail.com>");
|
|
MODULE_DESCRIPTION("Arrow SpeedChips XRS700x DSA driver");
|
|
MODULE_LICENSE("GPL v2");
|