1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * Handling of a single switch port
5 * Copyright (c) 2017 Savoir-faire Linux Inc.
6 * Vivien Didelot <vivien.didelot@savoirfairelinux.com>
9 #include <linux/if_bridge.h>
10 #include <linux/notifier.h>
11 #include <linux/of_mdio.h>
12 #include <linux/of_net.h>
16 static int dsa_port_notify(const struct dsa_port *dp, unsigned long e, void *v)
18 struct raw_notifier_head *nh = &dp->ds->dst->nh;
21 err = raw_notifier_call_chain(nh, e, v);
23 return notifier_to_errno(err);
26 int dsa_port_set_state(struct dsa_port *dp, u8 state,
27 struct switchdev_trans *trans)
29 struct dsa_switch *ds = dp->ds;
32 if (switchdev_trans_ph_prepare(trans))
33 return ds->ops->port_stp_state_set ? 0 : -EOPNOTSUPP;
35 if (ds->ops->port_stp_state_set)
36 ds->ops->port_stp_state_set(ds, port, state);
38 if (ds->ops->port_fast_age) {
39 /* Fast age FDB entries or flush appropriate forwarding database
40 * for the given port, if we are moving it from Learning or
41 * Forwarding state, to Disabled or Blocking or Listening state.
44 if ((dp->stp_state == BR_STATE_LEARNING ||
45 dp->stp_state == BR_STATE_FORWARDING) &&
46 (state == BR_STATE_DISABLED ||
47 state == BR_STATE_BLOCKING ||
48 state == BR_STATE_LISTENING))
49 ds->ops->port_fast_age(ds, port);
52 dp->stp_state = state;
57 static void dsa_port_set_state_now(struct dsa_port *dp, u8 state)
61 err = dsa_port_set_state(dp, state, NULL);
63 pr_err("DSA: failed to set STP state %u (%d)\n", state, err);
66 int dsa_port_enable_rt(struct dsa_port *dp, struct phy_device *phy)
68 struct dsa_switch *ds = dp->ds;
72 if (ds->ops->port_enable) {
73 err = ds->ops->port_enable(ds, port, phy);
79 dsa_port_set_state_now(dp, BR_STATE_FORWARDING);
82 phylink_start(dp->pl);
87 int dsa_port_enable(struct dsa_port *dp, struct phy_device *phy)
92 err = dsa_port_enable_rt(dp, phy);
98 void dsa_port_disable_rt(struct dsa_port *dp)
100 struct dsa_switch *ds = dp->ds;
101 int port = dp->index;
104 phylink_stop(dp->pl);
107 dsa_port_set_state_now(dp, BR_STATE_DISABLED);
109 if (ds->ops->port_disable)
110 ds->ops->port_disable(ds, port);
113 void dsa_port_disable(struct dsa_port *dp)
116 dsa_port_disable_rt(dp);
120 int dsa_port_bridge_join(struct dsa_port *dp, struct net_device *br)
122 struct dsa_notifier_bridge_info info = {
123 .sw_index = dp->ds->index,
129 /* Set the flooding mode before joining the port in the switch */
130 err = dsa_port_bridge_flags(dp, BR_FLOOD | BR_MCAST_FLOOD, NULL);
134 /* Here the interface is already bridged. Reflect the current
135 * configuration so that drivers can program their chips accordingly.
139 err = dsa_port_notify(dp, DSA_NOTIFIER_BRIDGE_JOIN, &info);
141 /* The bridging is rolled back on error */
143 dsa_port_bridge_flags(dp, 0, NULL);
144 dp->bridge_dev = NULL;
150 void dsa_port_bridge_leave(struct dsa_port *dp, struct net_device *br)
152 struct dsa_notifier_bridge_info info = {
153 .sw_index = dp->ds->index,
159 /* Here the port is already unbridged. Reflect the current configuration
160 * so that drivers can program their chips accordingly.
162 dp->bridge_dev = NULL;
164 err = dsa_port_notify(dp, DSA_NOTIFIER_BRIDGE_LEAVE, &info);
166 pr_err("DSA: failed to notify DSA_NOTIFIER_BRIDGE_LEAVE\n");
168 /* Port is leaving the bridge, disable flooding */
169 dsa_port_bridge_flags(dp, 0, NULL);
171 /* Port left the bridge, put in BR_STATE_DISABLED by the bridge layer,
172 * so allow it to be in BR_STATE_FORWARDING to be kept functional
174 dsa_port_set_state_now(dp, BR_STATE_FORWARDING);
177 static bool dsa_port_can_apply_vlan_filtering(struct dsa_port *dp,
180 struct dsa_switch *ds = dp->ds;
183 if (!ds->vlan_filtering_is_global)
186 /* For cases where enabling/disabling VLAN awareness is global to the
187 * switch, we need to handle the case where multiple bridges span
188 * different ports of the same switch device and one of them has a
189 * different setting than what is being requested.
191 for (i = 0; i < ds->num_ports; i++) {
192 struct net_device *other_bridge;
194 other_bridge = dsa_to_port(ds, i)->bridge_dev;
197 /* If it's the same bridge, it also has same
198 * vlan_filtering setting => no need to check
200 if (other_bridge == dp->bridge_dev)
202 if (br_vlan_enabled(other_bridge) != vlan_filtering) {
203 dev_err(ds->dev, "VLAN filtering is a global setting\n");
210 int dsa_port_vlan_filtering(struct dsa_port *dp, bool vlan_filtering,
211 struct switchdev_trans *trans)
213 struct dsa_switch *ds = dp->ds;
216 /* bridge skips -EOPNOTSUPP, so skip the prepare phase */
217 if (switchdev_trans_ph_prepare(trans))
220 if (!ds->ops->port_vlan_filtering)
223 if (!dsa_port_can_apply_vlan_filtering(dp, vlan_filtering))
226 if (dsa_port_is_vlan_filtering(dp) == vlan_filtering)
229 err = ds->ops->port_vlan_filtering(ds, dp->index,
234 if (ds->vlan_filtering_is_global)
235 ds->vlan_filtering = vlan_filtering;
237 dp->vlan_filtering = vlan_filtering;
241 int dsa_port_ageing_time(struct dsa_port *dp, clock_t ageing_clock,
242 struct switchdev_trans *trans)
244 unsigned long ageing_jiffies = clock_t_to_jiffies(ageing_clock);
245 unsigned int ageing_time = jiffies_to_msecs(ageing_jiffies);
246 struct dsa_notifier_ageing_time_info info = {
247 .ageing_time = ageing_time,
251 if (switchdev_trans_ph_prepare(trans))
252 return dsa_port_notify(dp, DSA_NOTIFIER_AGEING_TIME, &info);
254 dp->ageing_time = ageing_time;
256 return dsa_port_notify(dp, DSA_NOTIFIER_AGEING_TIME, &info);
259 int dsa_port_pre_bridge_flags(const struct dsa_port *dp, unsigned long flags,
260 struct switchdev_trans *trans)
262 struct dsa_switch *ds = dp->ds;
264 if (!ds->ops->port_egress_floods ||
265 (flags & ~(BR_FLOOD | BR_MCAST_FLOOD)))
271 int dsa_port_bridge_flags(const struct dsa_port *dp, unsigned long flags,
272 struct switchdev_trans *trans)
274 struct dsa_switch *ds = dp->ds;
275 int port = dp->index;
278 if (switchdev_trans_ph_prepare(trans))
281 if (ds->ops->port_egress_floods)
282 err = ds->ops->port_egress_floods(ds, port, flags & BR_FLOOD,
283 flags & BR_MCAST_FLOOD);
288 int dsa_port_mrouter(struct dsa_port *dp, bool mrouter,
289 struct switchdev_trans *trans)
291 struct dsa_switch *ds = dp->ds;
292 int port = dp->index;
294 if (switchdev_trans_ph_prepare(trans))
295 return ds->ops->port_egress_floods ? 0 : -EOPNOTSUPP;
297 return ds->ops->port_egress_floods(ds, port, true, mrouter);
300 int dsa_port_fdb_add(struct dsa_port *dp, const unsigned char *addr,
303 struct dsa_notifier_fdb_info info = {
304 .sw_index = dp->ds->index,
310 return dsa_port_notify(dp, DSA_NOTIFIER_FDB_ADD, &info);
313 int dsa_port_fdb_del(struct dsa_port *dp, const unsigned char *addr,
316 struct dsa_notifier_fdb_info info = {
317 .sw_index = dp->ds->index,
324 return dsa_port_notify(dp, DSA_NOTIFIER_FDB_DEL, &info);
327 int dsa_port_fdb_dump(struct dsa_port *dp, dsa_fdb_dump_cb_t *cb, void *data)
329 struct dsa_switch *ds = dp->ds;
330 int port = dp->index;
332 if (!ds->ops->port_fdb_dump)
335 return ds->ops->port_fdb_dump(ds, port, cb, data);
338 int dsa_port_mdb_add(const struct dsa_port *dp,
339 const struct switchdev_obj_port_mdb *mdb,
340 struct switchdev_trans *trans)
342 struct dsa_notifier_mdb_info info = {
343 .sw_index = dp->ds->index,
349 return dsa_port_notify(dp, DSA_NOTIFIER_MDB_ADD, &info);
352 int dsa_port_mdb_del(const struct dsa_port *dp,
353 const struct switchdev_obj_port_mdb *mdb)
355 struct dsa_notifier_mdb_info info = {
356 .sw_index = dp->ds->index,
361 return dsa_port_notify(dp, DSA_NOTIFIER_MDB_DEL, &info);
364 int dsa_port_vlan_add(struct dsa_port *dp,
365 const struct switchdev_obj_port_vlan *vlan,
366 struct switchdev_trans *trans)
368 struct dsa_notifier_vlan_info info = {
369 .sw_index = dp->ds->index,
375 return dsa_port_notify(dp, DSA_NOTIFIER_VLAN_ADD, &info);
378 int dsa_port_vlan_del(struct dsa_port *dp,
379 const struct switchdev_obj_port_vlan *vlan)
381 struct dsa_notifier_vlan_info info = {
382 .sw_index = dp->ds->index,
387 return dsa_port_notify(dp, DSA_NOTIFIER_VLAN_DEL, &info);
390 int dsa_port_vid_add(struct dsa_port *dp, u16 vid, u16 flags)
392 struct switchdev_obj_port_vlan vlan = {
393 .obj.id = SWITCHDEV_OBJ_ID_PORT_VLAN,
398 struct switchdev_trans trans;
401 trans.ph_prepare = true;
402 err = dsa_port_vlan_add(dp, &vlan, &trans);
406 trans.ph_prepare = false;
407 return dsa_port_vlan_add(dp, &vlan, &trans);
409 EXPORT_SYMBOL(dsa_port_vid_add);
411 int dsa_port_vid_del(struct dsa_port *dp, u16 vid)
413 struct switchdev_obj_port_vlan vlan = {
414 .obj.id = SWITCHDEV_OBJ_ID_PORT_VLAN,
419 return dsa_port_vlan_del(dp, &vlan);
421 EXPORT_SYMBOL(dsa_port_vid_del);
423 static struct phy_device *dsa_port_get_phy_device(struct dsa_port *dp)
425 struct device_node *phy_dn;
426 struct phy_device *phydev;
428 phy_dn = of_parse_phandle(dp->dn, "phy-handle", 0);
432 phydev = of_phy_find_device(phy_dn);
435 return ERR_PTR(-EPROBE_DEFER);
442 void dsa_port_phylink_validate(struct phylink_config *config,
443 unsigned long *supported,
444 struct phylink_link_state *state)
446 struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
447 struct dsa_switch *ds = dp->ds;
449 if (!ds->ops->phylink_validate)
452 ds->ops->phylink_validate(ds, dp->index, supported, state);
454 EXPORT_SYMBOL_GPL(dsa_port_phylink_validate);
456 int dsa_port_phylink_mac_link_state(struct phylink_config *config,
457 struct phylink_link_state *state)
459 struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
460 struct dsa_switch *ds = dp->ds;
462 /* Only called for SGMII and 802.3z */
463 if (!ds->ops->phylink_mac_link_state)
466 return ds->ops->phylink_mac_link_state(ds, dp->index, state);
468 EXPORT_SYMBOL_GPL(dsa_port_phylink_mac_link_state);
470 void dsa_port_phylink_mac_config(struct phylink_config *config,
472 const struct phylink_link_state *state)
474 struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
475 struct dsa_switch *ds = dp->ds;
477 if (!ds->ops->phylink_mac_config)
480 ds->ops->phylink_mac_config(ds, dp->index, mode, state);
482 EXPORT_SYMBOL_GPL(dsa_port_phylink_mac_config);
484 void dsa_port_phylink_mac_an_restart(struct phylink_config *config)
486 struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
487 struct dsa_switch *ds = dp->ds;
489 if (!ds->ops->phylink_mac_an_restart)
492 ds->ops->phylink_mac_an_restart(ds, dp->index);
494 EXPORT_SYMBOL_GPL(dsa_port_phylink_mac_an_restart);
496 void dsa_port_phylink_mac_link_down(struct phylink_config *config,
498 phy_interface_t interface)
500 struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
501 struct phy_device *phydev = NULL;
502 struct dsa_switch *ds = dp->ds;
504 if (dsa_is_user_port(ds, dp->index))
505 phydev = dp->slave->phydev;
507 if (!ds->ops->phylink_mac_link_down) {
508 if (ds->ops->adjust_link && phydev)
509 ds->ops->adjust_link(ds, dp->index, phydev);
513 ds->ops->phylink_mac_link_down(ds, dp->index, mode, interface);
515 EXPORT_SYMBOL_GPL(dsa_port_phylink_mac_link_down);
517 void dsa_port_phylink_mac_link_up(struct phylink_config *config,
519 phy_interface_t interface,
520 struct phy_device *phydev)
522 struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
523 struct dsa_switch *ds = dp->ds;
525 if (!ds->ops->phylink_mac_link_up) {
526 if (ds->ops->adjust_link && phydev)
527 ds->ops->adjust_link(ds, dp->index, phydev);
531 ds->ops->phylink_mac_link_up(ds, dp->index, mode, interface, phydev);
533 EXPORT_SYMBOL_GPL(dsa_port_phylink_mac_link_up);
535 const struct phylink_mac_ops dsa_port_phylink_mac_ops = {
536 .validate = dsa_port_phylink_validate,
537 .mac_link_state = dsa_port_phylink_mac_link_state,
538 .mac_config = dsa_port_phylink_mac_config,
539 .mac_an_restart = dsa_port_phylink_mac_an_restart,
540 .mac_link_down = dsa_port_phylink_mac_link_down,
541 .mac_link_up = dsa_port_phylink_mac_link_up,
544 static int dsa_port_setup_phy_of(struct dsa_port *dp, bool enable)
546 struct dsa_switch *ds = dp->ds;
547 struct phy_device *phydev;
548 int port = dp->index;
551 phydev = dsa_port_get_phy_device(dp);
556 return PTR_ERR(phydev);
559 err = genphy_resume(phydev);
563 err = genphy_read_status(phydev);
567 err = genphy_suspend(phydev);
572 if (ds->ops->adjust_link)
573 ds->ops->adjust_link(ds, port, phydev);
575 dev_dbg(ds->dev, "enabled port's phy: %s", phydev_name(phydev));
578 put_device(&phydev->mdio.dev);
582 static int dsa_port_fixed_link_register_of(struct dsa_port *dp)
584 struct device_node *dn = dp->dn;
585 struct dsa_switch *ds = dp->ds;
586 struct phy_device *phydev;
587 int port = dp->index;
591 err = of_phy_register_fixed_link(dn);
594 "failed to register the fixed PHY of port %d\n",
599 phydev = of_phy_find_device(dn);
601 mode = of_get_phy_mode(dn);
603 mode = PHY_INTERFACE_MODE_NA;
604 phydev->interface = mode;
606 genphy_read_status(phydev);
608 if (ds->ops->adjust_link)
609 ds->ops->adjust_link(ds, port, phydev);
611 put_device(&phydev->mdio.dev);
616 static int dsa_port_phylink_register(struct dsa_port *dp)
618 struct dsa_switch *ds = dp->ds;
619 struct device_node *port_dn = dp->dn;
622 mode = of_get_phy_mode(port_dn);
624 mode = PHY_INTERFACE_MODE_NA;
626 dp->pl_config.dev = ds->dev;
627 dp->pl_config.type = PHYLINK_DEV;
629 dp->pl = phylink_create(&dp->pl_config, of_fwnode_handle(port_dn),
630 mode, &dsa_port_phylink_mac_ops);
631 if (IS_ERR(dp->pl)) {
632 pr_err("error creating PHYLINK: %ld\n", PTR_ERR(dp->pl));
633 return PTR_ERR(dp->pl);
636 err = phylink_of_phy_connect(dp->pl, port_dn, 0);
637 if (err && err != -ENODEV) {
638 pr_err("could not attach to PHY: %d\n", err);
639 goto err_phy_connect;
645 phylink_destroy(dp->pl);
649 int dsa_port_link_register_of(struct dsa_port *dp)
651 struct dsa_switch *ds = dp->ds;
652 struct device_node *phy_np;
654 if (!ds->ops->adjust_link) {
655 phy_np = of_parse_phandle(dp->dn, "phy-handle", 0);
656 if (of_phy_is_fixed_link(dp->dn) || phy_np)
657 return dsa_port_phylink_register(dp);
662 "Using legacy PHYLIB callbacks. Please migrate to PHYLINK!\n");
664 if (of_phy_is_fixed_link(dp->dn))
665 return dsa_port_fixed_link_register_of(dp);
667 return dsa_port_setup_phy_of(dp, true);
670 void dsa_port_link_unregister_of(struct dsa_port *dp)
672 struct dsa_switch *ds = dp->ds;
674 if (!ds->ops->adjust_link && dp->pl) {
676 phylink_disconnect_phy(dp->pl);
678 phylink_destroy(dp->pl);
683 if (of_phy_is_fixed_link(dp->dn))
684 of_phy_deregister_fixed_link(dp->dn);
686 dsa_port_setup_phy_of(dp, false);
689 int dsa_port_get_phy_strings(struct dsa_port *dp, uint8_t *data)
691 struct phy_device *phydev;
692 int ret = -EOPNOTSUPP;
694 if (of_phy_is_fixed_link(dp->dn))
697 phydev = dsa_port_get_phy_device(dp);
698 if (IS_ERR_OR_NULL(phydev))
701 ret = phy_ethtool_get_strings(phydev, data);
702 put_device(&phydev->mdio.dev);
706 EXPORT_SYMBOL_GPL(dsa_port_get_phy_strings);
708 int dsa_port_get_ethtool_phy_stats(struct dsa_port *dp, uint64_t *data)
710 struct phy_device *phydev;
711 int ret = -EOPNOTSUPP;
713 if (of_phy_is_fixed_link(dp->dn))
716 phydev = dsa_port_get_phy_device(dp);
717 if (IS_ERR_OR_NULL(phydev))
720 ret = phy_ethtool_get_stats(phydev, NULL, data);
721 put_device(&phydev->mdio.dev);
725 EXPORT_SYMBOL_GPL(dsa_port_get_ethtool_phy_stats);
727 int dsa_port_get_phy_sset_count(struct dsa_port *dp)
729 struct phy_device *phydev;
730 int ret = -EOPNOTSUPP;
732 if (of_phy_is_fixed_link(dp->dn))
735 phydev = dsa_port_get_phy_device(dp);
736 if (IS_ERR_OR_NULL(phydev))
739 ret = phy_ethtool_get_sset_count(phydev);
740 put_device(&phydev->mdio.dev);
744 EXPORT_SYMBOL_GPL(dsa_port_get_phy_sset_count);