1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * Handling of a single switch port
5 * Copyright (c) 2017 Savoir-faire Linux Inc.
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(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);
84 void dsa_port_disable(struct dsa_port *dp)
86 struct dsa_switch *ds = dp->ds;
90 dsa_port_set_state_now(dp, BR_STATE_DISABLED);
92 if (ds->ops->port_disable)
93 ds->ops->port_disable(ds, port);
96 int dsa_port_bridge_join(struct dsa_port *dp, struct net_device *br)
98 struct dsa_notifier_bridge_info info = {
99 .sw_index = dp->ds->index,
105 /* Set the flooding mode before joining the port in the switch */
106 err = dsa_port_bridge_flags(dp, BR_FLOOD | BR_MCAST_FLOOD, NULL);
110 /* Here the interface is already bridged. Reflect the current
111 * configuration so that drivers can program their chips accordingly.
115 err = dsa_port_notify(dp, DSA_NOTIFIER_BRIDGE_JOIN, &info);
117 /* The bridging is rolled back on error */
119 dsa_port_bridge_flags(dp, 0, NULL);
120 dp->bridge_dev = NULL;
126 void dsa_port_bridge_leave(struct dsa_port *dp, struct net_device *br)
128 struct dsa_notifier_bridge_info info = {
129 .sw_index = dp->ds->index,
135 /* Here the port is already unbridged. Reflect the current configuration
136 * so that drivers can program their chips accordingly.
138 dp->bridge_dev = NULL;
140 err = dsa_port_notify(dp, DSA_NOTIFIER_BRIDGE_LEAVE, &info);
142 pr_err("DSA: failed to notify DSA_NOTIFIER_BRIDGE_LEAVE\n");
144 /* Port is leaving the bridge, disable flooding */
145 dsa_port_bridge_flags(dp, 0, NULL);
147 /* Port left the bridge, put in BR_STATE_DISABLED by the bridge layer,
148 * so allow it to be in BR_STATE_FORWARDING to be kept functional
150 dsa_port_set_state_now(dp, BR_STATE_FORWARDING);
153 static bool dsa_port_can_apply_vlan_filtering(struct dsa_port *dp,
156 struct dsa_switch *ds = dp->ds;
159 if (!ds->vlan_filtering_is_global)
162 /* For cases where enabling/disabling VLAN awareness is global to the
163 * switch, we need to handle the case where multiple bridges span
164 * different ports of the same switch device and one of them has a
165 * different setting than what is being requested.
167 for (i = 0; i < ds->num_ports; i++) {
168 struct net_device *other_bridge;
170 other_bridge = dsa_to_port(ds, i)->bridge_dev;
173 /* If it's the same bridge, it also has same
174 * vlan_filtering setting => no need to check
176 if (other_bridge == dp->bridge_dev)
178 if (br_vlan_enabled(other_bridge) != vlan_filtering) {
179 dev_err(ds->dev, "VLAN filtering is a global setting\n");
186 int dsa_port_vlan_filtering(struct dsa_port *dp, bool vlan_filtering,
187 struct switchdev_trans *trans)
189 struct dsa_switch *ds = dp->ds;
192 /* bridge skips -EOPNOTSUPP, so skip the prepare phase */
193 if (switchdev_trans_ph_prepare(trans))
196 if (!ds->ops->port_vlan_filtering)
199 if (!dsa_port_can_apply_vlan_filtering(dp, vlan_filtering))
202 if (dsa_port_is_vlan_filtering(dp) == vlan_filtering)
205 err = ds->ops->port_vlan_filtering(ds, dp->index,
210 if (ds->vlan_filtering_is_global)
211 ds->vlan_filtering = vlan_filtering;
213 dp->vlan_filtering = vlan_filtering;
217 int dsa_port_ageing_time(struct dsa_port *dp, clock_t ageing_clock,
218 struct switchdev_trans *trans)
220 unsigned long ageing_jiffies = clock_t_to_jiffies(ageing_clock);
221 unsigned int ageing_time = jiffies_to_msecs(ageing_jiffies);
222 struct dsa_notifier_ageing_time_info info = {
223 .ageing_time = ageing_time,
227 if (switchdev_trans_ph_prepare(trans))
228 return dsa_port_notify(dp, DSA_NOTIFIER_AGEING_TIME, &info);
230 dp->ageing_time = ageing_time;
232 return dsa_port_notify(dp, DSA_NOTIFIER_AGEING_TIME, &info);
235 int dsa_port_pre_bridge_flags(const struct dsa_port *dp, unsigned long flags,
236 struct switchdev_trans *trans)
238 struct dsa_switch *ds = dp->ds;
240 if (!ds->ops->port_egress_floods ||
241 (flags & ~(BR_FLOOD | BR_MCAST_FLOOD)))
247 int dsa_port_bridge_flags(const struct dsa_port *dp, unsigned long flags,
248 struct switchdev_trans *trans)
250 struct dsa_switch *ds = dp->ds;
251 int port = dp->index;
254 if (switchdev_trans_ph_prepare(trans))
257 if (ds->ops->port_egress_floods)
258 err = ds->ops->port_egress_floods(ds, port, flags & BR_FLOOD,
259 flags & BR_MCAST_FLOOD);
264 int dsa_port_mrouter(struct dsa_port *dp, bool mrouter,
265 struct switchdev_trans *trans)
267 struct dsa_switch *ds = dp->ds;
268 int port = dp->index;
270 if (switchdev_trans_ph_prepare(trans))
271 return ds->ops->port_egress_floods ? 0 : -EOPNOTSUPP;
273 return ds->ops->port_egress_floods(ds, port, true, mrouter);
276 int dsa_port_fdb_add(struct dsa_port *dp, const unsigned char *addr,
279 struct dsa_notifier_fdb_info info = {
280 .sw_index = dp->ds->index,
286 return dsa_port_notify(dp, DSA_NOTIFIER_FDB_ADD, &info);
289 int dsa_port_fdb_del(struct dsa_port *dp, const unsigned char *addr,
292 struct dsa_notifier_fdb_info info = {
293 .sw_index = dp->ds->index,
300 return dsa_port_notify(dp, DSA_NOTIFIER_FDB_DEL, &info);
303 int dsa_port_fdb_dump(struct dsa_port *dp, dsa_fdb_dump_cb_t *cb, void *data)
305 struct dsa_switch *ds = dp->ds;
306 int port = dp->index;
308 if (!ds->ops->port_fdb_dump)
311 return ds->ops->port_fdb_dump(ds, port, cb, data);
314 int dsa_port_mdb_add(const struct dsa_port *dp,
315 const struct switchdev_obj_port_mdb *mdb,
316 struct switchdev_trans *trans)
318 struct dsa_notifier_mdb_info info = {
319 .sw_index = dp->ds->index,
325 return dsa_port_notify(dp, DSA_NOTIFIER_MDB_ADD, &info);
328 int dsa_port_mdb_del(const struct dsa_port *dp,
329 const struct switchdev_obj_port_mdb *mdb)
331 struct dsa_notifier_mdb_info info = {
332 .sw_index = dp->ds->index,
337 return dsa_port_notify(dp, DSA_NOTIFIER_MDB_DEL, &info);
340 int dsa_port_vlan_add(struct dsa_port *dp,
341 const struct switchdev_obj_port_vlan *vlan,
342 struct switchdev_trans *trans)
344 struct dsa_notifier_vlan_info info = {
345 .sw_index = dp->ds->index,
351 if (!dp->bridge_dev || br_vlan_enabled(dp->bridge_dev))
352 return dsa_port_notify(dp, DSA_NOTIFIER_VLAN_ADD, &info);
357 int dsa_port_vlan_del(struct dsa_port *dp,
358 const struct switchdev_obj_port_vlan *vlan)
360 struct dsa_notifier_vlan_info info = {
361 .sw_index = dp->ds->index,
366 if (!dp->bridge_dev || br_vlan_enabled(dp->bridge_dev))
367 return dsa_port_notify(dp, DSA_NOTIFIER_VLAN_DEL, &info);
372 int dsa_port_vid_add(struct dsa_port *dp, u16 vid, u16 flags)
374 struct switchdev_obj_port_vlan vlan = {
375 .obj.id = SWITCHDEV_OBJ_ID_PORT_VLAN,
380 struct switchdev_trans trans;
383 trans.ph_prepare = true;
384 err = dsa_port_vlan_add(dp, &vlan, &trans);
385 if (err == -EOPNOTSUPP)
388 trans.ph_prepare = false;
389 return dsa_port_vlan_add(dp, &vlan, &trans);
391 EXPORT_SYMBOL(dsa_port_vid_add);
393 int dsa_port_vid_del(struct dsa_port *dp, u16 vid)
395 struct switchdev_obj_port_vlan vlan = {
396 .obj.id = SWITCHDEV_OBJ_ID_PORT_VLAN,
401 return dsa_port_vlan_del(dp, &vlan);
403 EXPORT_SYMBOL(dsa_port_vid_del);
405 static struct phy_device *dsa_port_get_phy_device(struct dsa_port *dp)
407 struct device_node *phy_dn;
408 struct phy_device *phydev;
410 phy_dn = of_parse_phandle(dp->dn, "phy-handle", 0);
414 phydev = of_phy_find_device(phy_dn);
417 return ERR_PTR(-EPROBE_DEFER);
424 void dsa_port_phylink_validate(struct phylink_config *config,
425 unsigned long *supported,
426 struct phylink_link_state *state)
428 struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
429 struct dsa_switch *ds = dp->ds;
431 if (!ds->ops->phylink_validate)
434 ds->ops->phylink_validate(ds, dp->index, supported, state);
436 EXPORT_SYMBOL_GPL(dsa_port_phylink_validate);
438 int dsa_port_phylink_mac_link_state(struct phylink_config *config,
439 struct phylink_link_state *state)
441 struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
442 struct dsa_switch *ds = dp->ds;
444 /* Only called for SGMII and 802.3z */
445 if (!ds->ops->phylink_mac_link_state)
448 return ds->ops->phylink_mac_link_state(ds, dp->index, state);
450 EXPORT_SYMBOL_GPL(dsa_port_phylink_mac_link_state);
452 void dsa_port_phylink_mac_config(struct phylink_config *config,
454 const struct phylink_link_state *state)
456 struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
457 struct dsa_switch *ds = dp->ds;
459 if (!ds->ops->phylink_mac_config)
462 ds->ops->phylink_mac_config(ds, dp->index, mode, state);
464 EXPORT_SYMBOL_GPL(dsa_port_phylink_mac_config);
466 void dsa_port_phylink_mac_an_restart(struct phylink_config *config)
468 struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
469 struct dsa_switch *ds = dp->ds;
471 if (!ds->ops->phylink_mac_an_restart)
474 ds->ops->phylink_mac_an_restart(ds, dp->index);
476 EXPORT_SYMBOL_GPL(dsa_port_phylink_mac_an_restart);
478 void dsa_port_phylink_mac_link_down(struct phylink_config *config,
480 phy_interface_t interface)
482 struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
483 struct phy_device *phydev = NULL;
484 struct dsa_switch *ds = dp->ds;
486 if (dsa_is_user_port(ds, dp->index))
487 phydev = dp->slave->phydev;
489 if (!ds->ops->phylink_mac_link_down) {
490 if (ds->ops->adjust_link && phydev)
491 ds->ops->adjust_link(ds, dp->index, phydev);
495 ds->ops->phylink_mac_link_down(ds, dp->index, mode, interface);
497 EXPORT_SYMBOL_GPL(dsa_port_phylink_mac_link_down);
499 void dsa_port_phylink_mac_link_up(struct phylink_config *config,
501 phy_interface_t interface,
502 struct phy_device *phydev)
504 struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
505 struct dsa_switch *ds = dp->ds;
507 if (!ds->ops->phylink_mac_link_up) {
508 if (ds->ops->adjust_link && phydev)
509 ds->ops->adjust_link(ds, dp->index, phydev);
513 ds->ops->phylink_mac_link_up(ds, dp->index, mode, interface, phydev);
515 EXPORT_SYMBOL_GPL(dsa_port_phylink_mac_link_up);
517 const struct phylink_mac_ops dsa_port_phylink_mac_ops = {
518 .validate = dsa_port_phylink_validate,
519 .mac_link_state = dsa_port_phylink_mac_link_state,
520 .mac_config = dsa_port_phylink_mac_config,
521 .mac_an_restart = dsa_port_phylink_mac_an_restart,
522 .mac_link_down = dsa_port_phylink_mac_link_down,
523 .mac_link_up = dsa_port_phylink_mac_link_up,
526 static int dsa_port_setup_phy_of(struct dsa_port *dp, bool enable)
528 struct dsa_switch *ds = dp->ds;
529 struct phy_device *phydev;
530 int port = dp->index;
533 phydev = dsa_port_get_phy_device(dp);
538 return PTR_ERR(phydev);
541 err = genphy_config_init(phydev);
545 err = genphy_resume(phydev);
549 err = genphy_read_status(phydev);
553 err = genphy_suspend(phydev);
558 if (ds->ops->adjust_link)
559 ds->ops->adjust_link(ds, port, phydev);
561 dev_dbg(ds->dev, "enabled port's phy: %s", phydev_name(phydev));
564 put_device(&phydev->mdio.dev);
568 static int dsa_port_fixed_link_register_of(struct dsa_port *dp)
570 struct device_node *dn = dp->dn;
571 struct dsa_switch *ds = dp->ds;
572 struct phy_device *phydev;
573 int port = dp->index;
577 err = of_phy_register_fixed_link(dn);
580 "failed to register the fixed PHY of port %d\n",
585 phydev = of_phy_find_device(dn);
587 mode = of_get_phy_mode(dn);
589 mode = PHY_INTERFACE_MODE_NA;
590 phydev->interface = mode;
592 genphy_config_init(phydev);
593 genphy_read_status(phydev);
595 if (ds->ops->adjust_link)
596 ds->ops->adjust_link(ds, port, phydev);
598 put_device(&phydev->mdio.dev);
603 static int dsa_port_phylink_register(struct dsa_port *dp)
605 struct dsa_switch *ds = dp->ds;
606 struct device_node *port_dn = dp->dn;
609 mode = of_get_phy_mode(port_dn);
611 mode = PHY_INTERFACE_MODE_NA;
613 dp->pl_config.dev = ds->dev;
614 dp->pl_config.type = PHYLINK_DEV;
616 dp->pl = phylink_create(&dp->pl_config, of_fwnode_handle(port_dn),
617 mode, &dsa_port_phylink_mac_ops);
618 if (IS_ERR(dp->pl)) {
619 pr_err("error creating PHYLINK: %ld\n", PTR_ERR(dp->pl));
620 return PTR_ERR(dp->pl);
623 err = phylink_of_phy_connect(dp->pl, port_dn, 0);
624 if (err && err != -ENODEV) {
625 pr_err("could not attach to PHY: %d\n", err);
626 goto err_phy_connect;
630 phylink_start(dp->pl);
636 phylink_destroy(dp->pl);
640 int dsa_port_link_register_of(struct dsa_port *dp)
642 struct dsa_switch *ds = dp->ds;
644 if (!ds->ops->adjust_link)
645 return dsa_port_phylink_register(dp);
648 "Using legacy PHYLIB callbacks. Please migrate to PHYLINK!\n");
650 if (of_phy_is_fixed_link(dp->dn))
651 return dsa_port_fixed_link_register_of(dp);
653 return dsa_port_setup_phy_of(dp, true);
656 void dsa_port_link_unregister_of(struct dsa_port *dp)
658 struct dsa_switch *ds = dp->ds;
660 if (!ds->ops->adjust_link) {
662 phylink_disconnect_phy(dp->pl);
664 phylink_destroy(dp->pl);
668 if (of_phy_is_fixed_link(dp->dn))
669 of_phy_deregister_fixed_link(dp->dn);
671 dsa_port_setup_phy_of(dp, false);
674 int dsa_port_get_phy_strings(struct dsa_port *dp, uint8_t *data)
676 struct phy_device *phydev;
677 int ret = -EOPNOTSUPP;
679 if (of_phy_is_fixed_link(dp->dn))
682 phydev = dsa_port_get_phy_device(dp);
683 if (IS_ERR_OR_NULL(phydev))
686 ret = phy_ethtool_get_strings(phydev, data);
687 put_device(&phydev->mdio.dev);
691 EXPORT_SYMBOL_GPL(dsa_port_get_phy_strings);
693 int dsa_port_get_ethtool_phy_stats(struct dsa_port *dp, uint64_t *data)
695 struct phy_device *phydev;
696 int ret = -EOPNOTSUPP;
698 if (of_phy_is_fixed_link(dp->dn))
701 phydev = dsa_port_get_phy_device(dp);
702 if (IS_ERR_OR_NULL(phydev))
705 ret = phy_ethtool_get_stats(phydev, NULL, data);
706 put_device(&phydev->mdio.dev);
710 EXPORT_SYMBOL_GPL(dsa_port_get_ethtool_phy_stats);
712 int dsa_port_get_phy_sset_count(struct dsa_port *dp)
714 struct phy_device *phydev;
715 int ret = -EOPNOTSUPP;
717 if (of_phy_is_fixed_link(dp->dn))
720 phydev = dsa_port_get_phy_device(dp);
721 if (IS_ERR_OR_NULL(phydev))
724 ret = phy_ethtool_get_sset_count(phydev);
725 put_device(&phydev->mdio.dev);
729 EXPORT_SYMBOL_GPL(dsa_port_get_phy_sset_count);