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