xref: /openbmc/linux/drivers/net/dsa/xrs700x/xrs700x.c (revision c900529f3d9161bfde5cca0754f83b4d3c3e0220)
1  // SPDX-License-Identifier: GPL-2.0
2  /*
3   * Copyright (C) 2020 NovaTech LLC
4   * George McCollister <george.mccollister@gmail.com>
5   */
6  
7  #include <net/dsa.h>
8  #include <linux/etherdevice.h>
9  #include <linux/if_bridge.h>
10  #include <linux/of.h>
11  #include <linux/netdev_features.h>
12  #include <linux/if_hsr.h>
13  #include "xrs700x.h"
14  #include "xrs700x_reg.h"
15  
16  #define XRS700X_MIB_INTERVAL msecs_to_jiffies(3000)
17  
18  #define XRS7000X_SUPPORTED_HSR_FEATURES \
19  	(NETIF_F_HW_HSR_TAG_INS | NETIF_F_HW_HSR_TAG_RM | \
20  	 NETIF_F_HW_HSR_FWD | NETIF_F_HW_HSR_DUP)
21  
22  #define XRS7003E_ID	0x100
23  #define XRS7003F_ID	0x101
24  #define XRS7004E_ID	0x200
25  #define XRS7004F_ID	0x201
26  
27  const struct xrs700x_info xrs7003e_info = {XRS7003E_ID, "XRS7003E", 3};
28  EXPORT_SYMBOL(xrs7003e_info);
29  
30  const struct xrs700x_info xrs7003f_info = {XRS7003F_ID, "XRS7003F", 3};
31  EXPORT_SYMBOL(xrs7003f_info);
32  
33  const struct xrs700x_info xrs7004e_info = {XRS7004E_ID, "XRS7004E", 4};
34  EXPORT_SYMBOL(xrs7004e_info);
35  
36  const struct xrs700x_info xrs7004f_info = {XRS7004F_ID, "XRS7004F", 4};
37  EXPORT_SYMBOL(xrs7004f_info);
38  
39  struct xrs700x_regfield {
40  	struct reg_field rf;
41  	struct regmap_field **rmf;
42  };
43  
44  struct xrs700x_mib {
45  	unsigned int offset;
46  	const char *name;
47  	int stats64_offset;
48  };
49  
50  #define XRS700X_MIB_ETHTOOL_ONLY(o, n) {o, n, -1}
51  #define XRS700X_MIB(o, n, m) {o, n, offsetof(struct rtnl_link_stats64, m)}
52  
53  static const struct xrs700x_mib xrs700x_mibs[] = {
54  	XRS700X_MIB(XRS_RX_GOOD_OCTETS_L, "rx_good_octets", rx_bytes),
55  	XRS700X_MIB_ETHTOOL_ONLY(XRS_RX_BAD_OCTETS_L, "rx_bad_octets"),
56  	XRS700X_MIB(XRS_RX_UNICAST_L, "rx_unicast", rx_packets),
57  	XRS700X_MIB(XRS_RX_BROADCAST_L, "rx_broadcast", rx_packets),
58  	XRS700X_MIB(XRS_RX_MULTICAST_L, "rx_multicast", multicast),
59  	XRS700X_MIB(XRS_RX_UNDERSIZE_L, "rx_undersize", rx_length_errors),
60  	XRS700X_MIB(XRS_RX_FRAGMENTS_L, "rx_fragments", rx_length_errors),
61  	XRS700X_MIB(XRS_RX_OVERSIZE_L, "rx_oversize", rx_length_errors),
62  	XRS700X_MIB(XRS_RX_JABBER_L, "rx_jabber", rx_length_errors),
63  	XRS700X_MIB(XRS_RX_ERR_L, "rx_err", rx_errors),
64  	XRS700X_MIB(XRS_RX_CRC_L, "rx_crc", rx_crc_errors),
65  	XRS700X_MIB_ETHTOOL_ONLY(XRS_RX_64_L, "rx_64"),
66  	XRS700X_MIB_ETHTOOL_ONLY(XRS_RX_65_127_L, "rx_65_127"),
67  	XRS700X_MIB_ETHTOOL_ONLY(XRS_RX_128_255_L, "rx_128_255"),
68  	XRS700X_MIB_ETHTOOL_ONLY(XRS_RX_256_511_L, "rx_256_511"),
69  	XRS700X_MIB_ETHTOOL_ONLY(XRS_RX_512_1023_L, "rx_512_1023"),
70  	XRS700X_MIB_ETHTOOL_ONLY(XRS_RX_1024_1536_L, "rx_1024_1536"),
71  	XRS700X_MIB_ETHTOOL_ONLY(XRS_RX_HSR_PRP_L, "rx_hsr_prp"),
72  	XRS700X_MIB_ETHTOOL_ONLY(XRS_RX_WRONGLAN_L, "rx_wronglan"),
73  	XRS700X_MIB_ETHTOOL_ONLY(XRS_RX_DUPLICATE_L, "rx_duplicate"),
74  	XRS700X_MIB(XRS_TX_OCTETS_L, "tx_octets", tx_bytes),
75  	XRS700X_MIB(XRS_TX_UNICAST_L, "tx_unicast", tx_packets),
76  	XRS700X_MIB(XRS_TX_BROADCAST_L, "tx_broadcast", tx_packets),
77  	XRS700X_MIB(XRS_TX_MULTICAST_L, "tx_multicast", tx_packets),
78  	XRS700X_MIB_ETHTOOL_ONLY(XRS_TX_HSR_PRP_L, "tx_hsr_prp"),
79  	XRS700X_MIB(XRS_PRIQ_DROP_L, "priq_drop", tx_dropped),
80  	XRS700X_MIB(XRS_EARLY_DROP_L, "early_drop", tx_dropped),
81  };
82  
83  static const u8 eth_hsrsup_addr[ETH_ALEN] = {
84  	0x01, 0x15, 0x4e, 0x00, 0x01, 0x00};
85  
xrs700x_get_strings(struct dsa_switch * ds,int port,u32 stringset,u8 * data)86  static void xrs700x_get_strings(struct dsa_switch *ds, int port,
87  				u32 stringset, u8 *data)
88  {
89  	int i;
90  
91  	if (stringset != ETH_SS_STATS)
92  		return;
93  
94  	for (i = 0; i < ARRAY_SIZE(xrs700x_mibs); i++) {
95  		strscpy(data, xrs700x_mibs[i].name, ETH_GSTRING_LEN);
96  		data += ETH_GSTRING_LEN;
97  	}
98  }
99  
xrs700x_get_sset_count(struct dsa_switch * ds,int port,int sset)100  static int xrs700x_get_sset_count(struct dsa_switch *ds, int port, int sset)
101  {
102  	if (sset != ETH_SS_STATS)
103  		return -EOPNOTSUPP;
104  
105  	return ARRAY_SIZE(xrs700x_mibs);
106  }
107  
xrs700x_read_port_counters(struct xrs700x * priv,int port)108  static void xrs700x_read_port_counters(struct xrs700x *priv, int port)
109  {
110  	struct xrs700x_port *p = &priv->ports[port];
111  	struct rtnl_link_stats64 stats;
112  	unsigned long flags;
113  	int i;
114  
115  	memset(&stats, 0, sizeof(stats));
116  
117  	mutex_lock(&p->mib_mutex);
118  
119  	/* Capture counter values */
120  	regmap_write(priv->regmap, XRS_CNT_CTRL(port), 1);
121  
122  	for (i = 0; i < ARRAY_SIZE(xrs700x_mibs); i++) {
123  		unsigned int high = 0, low = 0, reg;
124  
125  		reg = xrs700x_mibs[i].offset + XRS_PORT_OFFSET * port;
126  		regmap_read(priv->regmap, reg, &low);
127  		regmap_read(priv->regmap, reg + 2, &high);
128  
129  		p->mib_data[i] += (high << 16) | low;
130  
131  		if (xrs700x_mibs[i].stats64_offset >= 0) {
132  			u8 *s = (u8 *)&stats + xrs700x_mibs[i].stats64_offset;
133  			*(u64 *)s += p->mib_data[i];
134  		}
135  	}
136  
137  	/* multicast must be added to rx_packets (which already includes
138  	 * unicast and broadcast)
139  	 */
140  	stats.rx_packets += stats.multicast;
141  
142  	flags = u64_stats_update_begin_irqsave(&p->syncp);
143  	p->stats64 = stats;
144  	u64_stats_update_end_irqrestore(&p->syncp, flags);
145  
146  	mutex_unlock(&p->mib_mutex);
147  }
148  
xrs700x_mib_work(struct work_struct * work)149  static void xrs700x_mib_work(struct work_struct *work)
150  {
151  	struct xrs700x *priv = container_of(work, struct xrs700x,
152  					    mib_work.work);
153  	int i;
154  
155  	for (i = 0; i < priv->ds->num_ports; i++)
156  		xrs700x_read_port_counters(priv, i);
157  
158  	schedule_delayed_work(&priv->mib_work, XRS700X_MIB_INTERVAL);
159  }
160  
xrs700x_get_ethtool_stats(struct dsa_switch * ds,int port,u64 * data)161  static void xrs700x_get_ethtool_stats(struct dsa_switch *ds, int port,
162  				      u64 *data)
163  {
164  	struct xrs700x *priv = ds->priv;
165  	struct xrs700x_port *p = &priv->ports[port];
166  
167  	xrs700x_read_port_counters(priv, port);
168  
169  	mutex_lock(&p->mib_mutex);
170  	memcpy(data, p->mib_data, sizeof(*data) * ARRAY_SIZE(xrs700x_mibs));
171  	mutex_unlock(&p->mib_mutex);
172  }
173  
xrs700x_get_stats64(struct dsa_switch * ds,int port,struct rtnl_link_stats64 * s)174  static void xrs700x_get_stats64(struct dsa_switch *ds, int port,
175  				struct rtnl_link_stats64 *s)
176  {
177  	struct xrs700x *priv = ds->priv;
178  	struct xrs700x_port *p = &priv->ports[port];
179  	unsigned int start;
180  
181  	do {
182  		start = u64_stats_fetch_begin(&p->syncp);
183  		*s = p->stats64;
184  	} while (u64_stats_fetch_retry(&p->syncp, start));
185  }
186  
xrs700x_setup_regmap_range(struct xrs700x * priv)187  static int xrs700x_setup_regmap_range(struct xrs700x *priv)
188  {
189  	struct xrs700x_regfield regfields[] = {
190  		{
191  			.rf = REG_FIELD_ID(XRS_PORT_STATE(0), 0, 1,
192  					   priv->ds->num_ports,
193  					   XRS_PORT_OFFSET),
194  			.rmf = &priv->ps_forward
195  		},
196  		{
197  			.rf = REG_FIELD_ID(XRS_PORT_STATE(0), 2, 3,
198  					   priv->ds->num_ports,
199  					   XRS_PORT_OFFSET),
200  			.rmf = &priv->ps_management
201  		},
202  		{
203  			.rf = REG_FIELD_ID(XRS_PORT_STATE(0), 4, 9,
204  					   priv->ds->num_ports,
205  					   XRS_PORT_OFFSET),
206  			.rmf = &priv->ps_sel_speed
207  		},
208  		{
209  			.rf = REG_FIELD_ID(XRS_PORT_STATE(0), 10, 11,
210  					   priv->ds->num_ports,
211  					   XRS_PORT_OFFSET),
212  			.rmf = &priv->ps_cur_speed
213  		}
214  	};
215  	int i = 0;
216  
217  	for (; i < ARRAY_SIZE(regfields); i++) {
218  		*regfields[i].rmf = devm_regmap_field_alloc(priv->dev,
219  							    priv->regmap,
220  							    regfields[i].rf);
221  		if (IS_ERR(*regfields[i].rmf))
222  			return PTR_ERR(*regfields[i].rmf);
223  	}
224  
225  	return 0;
226  }
227  
xrs700x_get_tag_protocol(struct dsa_switch * ds,int port,enum dsa_tag_protocol m)228  static enum dsa_tag_protocol xrs700x_get_tag_protocol(struct dsa_switch *ds,
229  						      int port,
230  						      enum dsa_tag_protocol m)
231  {
232  	return DSA_TAG_PROTO_XRS700X;
233  }
234  
xrs700x_reset(struct dsa_switch * ds)235  static int xrs700x_reset(struct dsa_switch *ds)
236  {
237  	struct xrs700x *priv = ds->priv;
238  	unsigned int val;
239  	int ret;
240  
241  	ret = regmap_write(priv->regmap, XRS_GENERAL, XRS_GENERAL_RESET);
242  	if (ret)
243  		goto error;
244  
245  	ret = regmap_read_poll_timeout(priv->regmap, XRS_GENERAL,
246  				       val, !(val & XRS_GENERAL_RESET),
247  				       10, 1000);
248  error:
249  	if (ret) {
250  		dev_err_ratelimited(priv->dev, "error resetting switch: %d\n",
251  				    ret);
252  	}
253  
254  	return ret;
255  }
256  
xrs700x_port_stp_state_set(struct dsa_switch * ds,int port,u8 state)257  static void xrs700x_port_stp_state_set(struct dsa_switch *ds, int port,
258  				       u8 state)
259  {
260  	struct xrs700x *priv = ds->priv;
261  	unsigned int bpdus = 1;
262  	unsigned int val;
263  
264  	switch (state) {
265  	case BR_STATE_DISABLED:
266  		bpdus = 0;
267  		fallthrough;
268  	case BR_STATE_BLOCKING:
269  	case BR_STATE_LISTENING:
270  		val = XRS_PORT_DISABLED;
271  		break;
272  	case BR_STATE_LEARNING:
273  		val = XRS_PORT_LEARNING;
274  		break;
275  	case BR_STATE_FORWARDING:
276  		val = XRS_PORT_FORWARDING;
277  		break;
278  	default:
279  		dev_err(ds->dev, "invalid STP state: %d\n", state);
280  		return;
281  	}
282  
283  	regmap_fields_write(priv->ps_forward, port, val);
284  
285  	/* Enable/disable inbound policy added by xrs700x_port_add_bpdu_ipf()
286  	 * which allows BPDU forwarding to the CPU port when the front facing
287  	 * port is in disabled/learning state.
288  	 */
289  	regmap_update_bits(priv->regmap, XRS_ETH_ADDR_CFG(port, 0), 1, bpdus);
290  
291  	dev_dbg_ratelimited(priv->dev, "%s - port: %d, state: %u, val: 0x%x\n",
292  			    __func__, port, state, val);
293  }
294  
295  /* Add an inbound policy filter which matches the BPDU destination MAC
296   * and forwards to the CPU port. Leave the policy disabled, it will be
297   * enabled as needed.
298   */
xrs700x_port_add_bpdu_ipf(struct dsa_switch * ds,int port)299  static int xrs700x_port_add_bpdu_ipf(struct dsa_switch *ds, int port)
300  {
301  	struct xrs700x *priv = ds->priv;
302  	unsigned int val = 0;
303  	int i = 0;
304  	int ret;
305  
306  	/* Compare all 48 bits of the destination MAC address. */
307  	ret = regmap_write(priv->regmap, XRS_ETH_ADDR_CFG(port, 0), 48 << 2);
308  	if (ret)
309  		return ret;
310  
311  	/* match BPDU destination 01:80:c2:00:00:00 */
312  	for (i = 0; i < sizeof(eth_stp_addr); i += 2) {
313  		ret = regmap_write(priv->regmap, XRS_ETH_ADDR_0(port, 0) + i,
314  				   eth_stp_addr[i] |
315  				   (eth_stp_addr[i + 1] << 8));
316  		if (ret)
317  			return ret;
318  	}
319  
320  	/* Mirror BPDU to CPU port */
321  	for (i = 0; i < ds->num_ports; i++) {
322  		if (dsa_is_cpu_port(ds, i))
323  			val |= BIT(i);
324  	}
325  
326  	ret = regmap_write(priv->regmap, XRS_ETH_ADDR_FWD_MIRROR(port, 0), val);
327  	if (ret)
328  		return ret;
329  
330  	ret = regmap_write(priv->regmap, XRS_ETH_ADDR_FWD_ALLOW(port, 0), 0);
331  	if (ret)
332  		return ret;
333  
334  	return 0;
335  }
336  
337  /* Add an inbound policy filter which matches the HSR/PRP supervision MAC
338   * range and forwards to the CPU port without discarding duplicates.
339   * This is required to correctly populate the HSR/PRP node_table.
340   * Leave the policy disabled, it will be enabled as needed.
341   */
xrs700x_port_add_hsrsup_ipf(struct dsa_switch * ds,int port,int fwdport)342  static int xrs700x_port_add_hsrsup_ipf(struct dsa_switch *ds, int port,
343  				       int fwdport)
344  {
345  	struct xrs700x *priv = ds->priv;
346  	unsigned int val = 0;
347  	int i = 0;
348  	int ret;
349  
350  	/* Compare 40 bits of the destination MAC address. */
351  	ret = regmap_write(priv->regmap, XRS_ETH_ADDR_CFG(port, 1), 40 << 2);
352  	if (ret)
353  		return ret;
354  
355  	/* match HSR/PRP supervision destination 01:15:4e:00:01:XX */
356  	for (i = 0; i < sizeof(eth_hsrsup_addr); i += 2) {
357  		ret = regmap_write(priv->regmap, XRS_ETH_ADDR_0(port, 1) + i,
358  				   eth_hsrsup_addr[i] |
359  				   (eth_hsrsup_addr[i + 1] << 8));
360  		if (ret)
361  			return ret;
362  	}
363  
364  	/* Mirror HSR/PRP supervision to CPU port */
365  	for (i = 0; i < ds->num_ports; i++) {
366  		if (dsa_is_cpu_port(ds, i))
367  			val |= BIT(i);
368  	}
369  
370  	ret = regmap_write(priv->regmap, XRS_ETH_ADDR_FWD_MIRROR(port, 1), val);
371  	if (ret)
372  		return ret;
373  
374  	if (fwdport >= 0)
375  		val |= BIT(fwdport);
376  
377  	/* Allow must be set prevent duplicate discard */
378  	ret = regmap_write(priv->regmap, XRS_ETH_ADDR_FWD_ALLOW(port, 1), val);
379  	if (ret)
380  		return ret;
381  
382  	return 0;
383  }
384  
xrs700x_port_setup(struct dsa_switch * ds,int port)385  static int xrs700x_port_setup(struct dsa_switch *ds, int port)
386  {
387  	bool cpu_port = dsa_is_cpu_port(ds, port);
388  	struct xrs700x *priv = ds->priv;
389  	unsigned int val = 0;
390  	int ret, i;
391  
392  	xrs700x_port_stp_state_set(ds, port, BR_STATE_DISABLED);
393  
394  	/* Disable forwarding to non-CPU ports */
395  	for (i = 0; i < ds->num_ports; i++) {
396  		if (!dsa_is_cpu_port(ds, i))
397  			val |= BIT(i);
398  	}
399  
400  	/* 1 = Disable forwarding to the port */
401  	ret = regmap_write(priv->regmap, XRS_PORT_FWD_MASK(port), val);
402  	if (ret)
403  		return ret;
404  
405  	val = cpu_port ? XRS_PORT_MODE_MANAGEMENT : XRS_PORT_MODE_NORMAL;
406  	ret = regmap_fields_write(priv->ps_management, port, val);
407  	if (ret)
408  		return ret;
409  
410  	if (!cpu_port) {
411  		ret = xrs700x_port_add_bpdu_ipf(ds, port);
412  		if (ret)
413  			return ret;
414  	}
415  
416  	return 0;
417  }
418  
xrs700x_setup(struct dsa_switch * ds)419  static int xrs700x_setup(struct dsa_switch *ds)
420  {
421  	struct xrs700x *priv = ds->priv;
422  	int ret, i;
423  
424  	ret = xrs700x_reset(ds);
425  	if (ret)
426  		return ret;
427  
428  	for (i = 0; i < ds->num_ports; i++) {
429  		ret = xrs700x_port_setup(ds, i);
430  		if (ret)
431  			return ret;
432  	}
433  
434  	schedule_delayed_work(&priv->mib_work, XRS700X_MIB_INTERVAL);
435  
436  	return 0;
437  }
438  
xrs700x_teardown(struct dsa_switch * ds)439  static void xrs700x_teardown(struct dsa_switch *ds)
440  {
441  	struct xrs700x *priv = ds->priv;
442  
443  	cancel_delayed_work_sync(&priv->mib_work);
444  }
445  
xrs700x_phylink_get_caps(struct dsa_switch * ds,int port,struct phylink_config * config)446  static void xrs700x_phylink_get_caps(struct dsa_switch *ds, int port,
447  				     struct phylink_config *config)
448  {
449  	switch (port) {
450  	case 0:
451  		__set_bit(PHY_INTERFACE_MODE_RMII,
452  			  config->supported_interfaces);
453  		config->mac_capabilities = MAC_10FD | MAC_100FD;
454  		break;
455  
456  	case 1:
457  	case 2:
458  	case 3:
459  		phy_interface_set_rgmii(config->supported_interfaces);
460  		config->mac_capabilities = MAC_10FD | MAC_100FD | MAC_1000FD;
461  		break;
462  
463  	default:
464  		dev_err(ds->dev, "Unsupported port: %i\n", port);
465  		break;
466  	}
467  }
468  
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)469  static void xrs700x_mac_link_up(struct dsa_switch *ds, int port,
470  				unsigned int mode, phy_interface_t interface,
471  				struct phy_device *phydev,
472  				int speed, int duplex,
473  				bool tx_pause, bool rx_pause)
474  {
475  	struct xrs700x *priv = ds->priv;
476  	unsigned int val;
477  
478  	switch (speed) {
479  	case SPEED_1000:
480  		val = XRS_PORT_SPEED_1000;
481  		break;
482  	case SPEED_100:
483  		val = XRS_PORT_SPEED_100;
484  		break;
485  	case SPEED_10:
486  		val = XRS_PORT_SPEED_10;
487  		break;
488  	default:
489  		return;
490  	}
491  
492  	regmap_fields_write(priv->ps_sel_speed, port, val);
493  
494  	dev_dbg_ratelimited(priv->dev, "%s: port: %d mode: %u speed: %u\n",
495  			    __func__, port, mode, speed);
496  }
497  
xrs700x_bridge_common(struct dsa_switch * ds,int port,struct dsa_bridge bridge,bool join)498  static int xrs700x_bridge_common(struct dsa_switch *ds, int port,
499  				 struct dsa_bridge bridge, bool join)
500  {
501  	unsigned int i, cpu_mask = 0, mask = 0;
502  	struct xrs700x *priv = ds->priv;
503  	int ret;
504  
505  	for (i = 0; i < ds->num_ports; i++) {
506  		if (dsa_is_cpu_port(ds, i))
507  			continue;
508  
509  		cpu_mask |= BIT(i);
510  
511  		if (dsa_port_offloads_bridge(dsa_to_port(ds, i), &bridge))
512  			continue;
513  
514  		mask |= BIT(i);
515  	}
516  
517  	for (i = 0; i < ds->num_ports; i++) {
518  		if (!dsa_port_offloads_bridge(dsa_to_port(ds, i), &bridge))
519  			continue;
520  
521  		/* 1 = Disable forwarding to the port */
522  		ret = regmap_write(priv->regmap, XRS_PORT_FWD_MASK(i), mask);
523  		if (ret)
524  			return ret;
525  	}
526  
527  	if (!join) {
528  		ret = regmap_write(priv->regmap, XRS_PORT_FWD_MASK(port),
529  				   cpu_mask);
530  		if (ret)
531  			return ret;
532  	}
533  
534  	return 0;
535  }
536  
xrs700x_bridge_join(struct dsa_switch * ds,int port,struct dsa_bridge bridge,bool * tx_fwd_offload,struct netlink_ext_ack * extack)537  static int xrs700x_bridge_join(struct dsa_switch *ds, int port,
538  			       struct dsa_bridge bridge, bool *tx_fwd_offload,
539  			       struct netlink_ext_ack *extack)
540  {
541  	return xrs700x_bridge_common(ds, port, bridge, true);
542  }
543  
xrs700x_bridge_leave(struct dsa_switch * ds,int port,struct dsa_bridge bridge)544  static void xrs700x_bridge_leave(struct dsa_switch *ds, int port,
545  				 struct dsa_bridge bridge)
546  {
547  	xrs700x_bridge_common(ds, port, bridge, false);
548  }
549  
xrs700x_hsr_join(struct dsa_switch * ds,int port,struct net_device * hsr)550  static int xrs700x_hsr_join(struct dsa_switch *ds, int port,
551  			    struct net_device *hsr)
552  {
553  	unsigned int val = XRS_HSR_CFG_HSR_PRP;
554  	struct dsa_port *partner = NULL, *dp;
555  	struct xrs700x *priv = ds->priv;
556  	struct net_device *slave;
557  	int ret, i, hsr_pair[2];
558  	enum hsr_version ver;
559  	bool fwd = false;
560  
561  	ret = hsr_get_version(hsr, &ver);
562  	if (ret)
563  		return ret;
564  
565  	/* Only ports 1 and 2 can be HSR/PRP redundant ports. */
566  	if (port != 1 && port != 2)
567  		return -EOPNOTSUPP;
568  
569  	if (ver == HSR_V1)
570  		val |= XRS_HSR_CFG_HSR;
571  	else if (ver == PRP_V1)
572  		val |= XRS_HSR_CFG_PRP;
573  	else
574  		return -EOPNOTSUPP;
575  
576  	dsa_hsr_foreach_port(dp, ds, hsr) {
577  		if (dp->index != port) {
578  			partner = dp;
579  			break;
580  		}
581  	}
582  
583  	/* We can't enable redundancy on the switch until both
584  	 * redundant ports have signed up.
585  	 */
586  	if (!partner)
587  		return 0;
588  
589  	regmap_fields_write(priv->ps_forward, partner->index,
590  			    XRS_PORT_DISABLED);
591  	regmap_fields_write(priv->ps_forward, port, XRS_PORT_DISABLED);
592  
593  	regmap_write(priv->regmap, XRS_HSR_CFG(partner->index),
594  		     val | XRS_HSR_CFG_LANID_A);
595  	regmap_write(priv->regmap, XRS_HSR_CFG(port),
596  		     val | XRS_HSR_CFG_LANID_B);
597  
598  	/* Clear bits for both redundant ports (HSR only) and the CPU port to
599  	 * enable forwarding.
600  	 */
601  	val = GENMASK(ds->num_ports - 1, 0);
602  	if (ver == HSR_V1) {
603  		val &= ~BIT(partner->index);
604  		val &= ~BIT(port);
605  		fwd = true;
606  	}
607  	val &= ~BIT(dsa_upstream_port(ds, port));
608  	regmap_write(priv->regmap, XRS_PORT_FWD_MASK(partner->index), val);
609  	regmap_write(priv->regmap, XRS_PORT_FWD_MASK(port), val);
610  
611  	regmap_fields_write(priv->ps_forward, partner->index,
612  			    XRS_PORT_FORWARDING);
613  	regmap_fields_write(priv->ps_forward, port, XRS_PORT_FORWARDING);
614  
615  	/* Enable inbound policy which allows HSR/PRP supervision forwarding
616  	 * to the CPU port without discarding duplicates. Continue to
617  	 * forward to redundant ports when in HSR mode while discarding
618  	 * duplicates.
619  	 */
620  	ret = xrs700x_port_add_hsrsup_ipf(ds, partner->index, fwd ? port : -1);
621  	if (ret)
622  		return ret;
623  
624  	ret = xrs700x_port_add_hsrsup_ipf(ds, port, fwd ? partner->index : -1);
625  	if (ret)
626  		return ret;
627  
628  	regmap_update_bits(priv->regmap,
629  			   XRS_ETH_ADDR_CFG(partner->index, 1), 1, 1);
630  	regmap_update_bits(priv->regmap, XRS_ETH_ADDR_CFG(port, 1), 1, 1);
631  
632  	hsr_pair[0] = port;
633  	hsr_pair[1] = partner->index;
634  	for (i = 0; i < ARRAY_SIZE(hsr_pair); i++) {
635  		slave = dsa_to_port(ds, hsr_pair[i])->slave;
636  		slave->features |= XRS7000X_SUPPORTED_HSR_FEATURES;
637  	}
638  
639  	return 0;
640  }
641  
xrs700x_hsr_leave(struct dsa_switch * ds,int port,struct net_device * hsr)642  static int xrs700x_hsr_leave(struct dsa_switch *ds, int port,
643  			     struct net_device *hsr)
644  {
645  	struct dsa_port *partner = NULL, *dp;
646  	struct xrs700x *priv = ds->priv;
647  	struct net_device *slave;
648  	int i, hsr_pair[2];
649  	unsigned int val;
650  
651  	dsa_hsr_foreach_port(dp, ds, hsr) {
652  		if (dp->index != port) {
653  			partner = dp;
654  			break;
655  		}
656  	}
657  
658  	if (!partner)
659  		return 0;
660  
661  	regmap_fields_write(priv->ps_forward, partner->index,
662  			    XRS_PORT_DISABLED);
663  	regmap_fields_write(priv->ps_forward, port, XRS_PORT_DISABLED);
664  
665  	regmap_write(priv->regmap, XRS_HSR_CFG(partner->index), 0);
666  	regmap_write(priv->regmap, XRS_HSR_CFG(port), 0);
667  
668  	/* Clear bit for the CPU port to enable forwarding. */
669  	val = GENMASK(ds->num_ports - 1, 0);
670  	val &= ~BIT(dsa_upstream_port(ds, port));
671  	regmap_write(priv->regmap, XRS_PORT_FWD_MASK(partner->index), val);
672  	regmap_write(priv->regmap, XRS_PORT_FWD_MASK(port), val);
673  
674  	regmap_fields_write(priv->ps_forward, partner->index,
675  			    XRS_PORT_FORWARDING);
676  	regmap_fields_write(priv->ps_forward, port, XRS_PORT_FORWARDING);
677  
678  	/* Disable inbound policy added by xrs700x_port_add_hsrsup_ipf()
679  	 * which allows HSR/PRP supervision forwarding to the CPU port without
680  	 * discarding duplicates.
681  	 */
682  	regmap_update_bits(priv->regmap,
683  			   XRS_ETH_ADDR_CFG(partner->index, 1), 1, 0);
684  	regmap_update_bits(priv->regmap, XRS_ETH_ADDR_CFG(port, 1), 1, 0);
685  
686  	hsr_pair[0] = port;
687  	hsr_pair[1] = partner->index;
688  	for (i = 0; i < ARRAY_SIZE(hsr_pair); i++) {
689  		slave = dsa_to_port(ds, hsr_pair[i])->slave;
690  		slave->features &= ~XRS7000X_SUPPORTED_HSR_FEATURES;
691  	}
692  
693  	return 0;
694  }
695  
696  static const struct dsa_switch_ops xrs700x_ops = {
697  	.get_tag_protocol	= xrs700x_get_tag_protocol,
698  	.setup			= xrs700x_setup,
699  	.teardown		= xrs700x_teardown,
700  	.port_stp_state_set	= xrs700x_port_stp_state_set,
701  	.phylink_get_caps	= xrs700x_phylink_get_caps,
702  	.phylink_mac_link_up	= xrs700x_mac_link_up,
703  	.get_strings		= xrs700x_get_strings,
704  	.get_sset_count		= xrs700x_get_sset_count,
705  	.get_ethtool_stats	= xrs700x_get_ethtool_stats,
706  	.get_stats64		= xrs700x_get_stats64,
707  	.port_bridge_join	= xrs700x_bridge_join,
708  	.port_bridge_leave	= xrs700x_bridge_leave,
709  	.port_hsr_join		= xrs700x_hsr_join,
710  	.port_hsr_leave		= xrs700x_hsr_leave,
711  };
712  
xrs700x_detect(struct xrs700x * priv)713  static int xrs700x_detect(struct xrs700x *priv)
714  {
715  	const struct xrs700x_info *info;
716  	unsigned int id;
717  	int ret;
718  
719  	ret = regmap_read(priv->regmap, XRS_DEV_ID0, &id);
720  	if (ret) {
721  		dev_err(priv->dev, "error %d while reading switch id.\n",
722  			ret);
723  		return ret;
724  	}
725  
726  	info = of_device_get_match_data(priv->dev);
727  	if (!info)
728  		return -EINVAL;
729  
730  	if (info->id == id) {
731  		priv->ds->num_ports = info->num_ports;
732  		dev_info(priv->dev, "%s detected.\n", info->name);
733  		return 0;
734  	}
735  
736  	dev_err(priv->dev, "expected switch id 0x%x but found 0x%x.\n",
737  		info->id, id);
738  
739  	return -ENODEV;
740  }
741  
xrs700x_switch_alloc(struct device * base,void * devpriv)742  struct xrs700x *xrs700x_switch_alloc(struct device *base, void *devpriv)
743  {
744  	struct dsa_switch *ds;
745  	struct xrs700x *priv;
746  
747  	ds = devm_kzalloc(base, sizeof(*ds), GFP_KERNEL);
748  	if (!ds)
749  		return NULL;
750  
751  	ds->dev = base;
752  
753  	priv = devm_kzalloc(base, sizeof(*priv), GFP_KERNEL);
754  	if (!priv)
755  		return NULL;
756  
757  	INIT_DELAYED_WORK(&priv->mib_work, xrs700x_mib_work);
758  
759  	ds->ops = &xrs700x_ops;
760  	ds->priv = priv;
761  	priv->dev = base;
762  
763  	priv->ds = ds;
764  	priv->priv = devpriv;
765  
766  	return priv;
767  }
768  EXPORT_SYMBOL(xrs700x_switch_alloc);
769  
xrs700x_alloc_port_mib(struct xrs700x * priv,int port)770  static int xrs700x_alloc_port_mib(struct xrs700x *priv, int port)
771  {
772  	struct xrs700x_port *p = &priv->ports[port];
773  
774  	p->mib_data = devm_kcalloc(priv->dev, ARRAY_SIZE(xrs700x_mibs),
775  				   sizeof(*p->mib_data), GFP_KERNEL);
776  	if (!p->mib_data)
777  		return -ENOMEM;
778  
779  	mutex_init(&p->mib_mutex);
780  	u64_stats_init(&p->syncp);
781  
782  	return 0;
783  }
784  
xrs700x_switch_register(struct xrs700x * priv)785  int xrs700x_switch_register(struct xrs700x *priv)
786  {
787  	int ret;
788  	int i;
789  
790  	ret = xrs700x_detect(priv);
791  	if (ret)
792  		return ret;
793  
794  	ret = xrs700x_setup_regmap_range(priv);
795  	if (ret)
796  		return ret;
797  
798  	priv->ports = devm_kcalloc(priv->dev, priv->ds->num_ports,
799  				   sizeof(*priv->ports), GFP_KERNEL);
800  	if (!priv->ports)
801  		return -ENOMEM;
802  
803  	for (i = 0; i < priv->ds->num_ports; i++) {
804  		ret = xrs700x_alloc_port_mib(priv, i);
805  		if (ret)
806  			return ret;
807  	}
808  
809  	return dsa_register_switch(priv->ds);
810  }
811  EXPORT_SYMBOL(xrs700x_switch_register);
812  
xrs700x_switch_remove(struct xrs700x * priv)813  void xrs700x_switch_remove(struct xrs700x *priv)
814  {
815  	dsa_unregister_switch(priv->ds);
816  }
817  EXPORT_SYMBOL(xrs700x_switch_remove);
818  
xrs700x_switch_shutdown(struct xrs700x * priv)819  void xrs700x_switch_shutdown(struct xrs700x *priv)
820  {
821  	dsa_switch_shutdown(priv->ds);
822  }
823  EXPORT_SYMBOL(xrs700x_switch_shutdown);
824  
825  MODULE_AUTHOR("George McCollister <george.mccollister@gmail.com>");
826  MODULE_DESCRIPTION("Arrow SpeedChips XRS700x DSA driver");
827  MODULE_LICENSE("GPL v2");
828