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>
17 * dsa_port_notify - Notify the switching fabric of changes to a port
18 * @dp: port on which change occurred
19 * @e: event, must be of type DSA_NOTIFIER_*
20 * @v: event-specific value.
22 * Notify all switches in the DSA tree that this port's switch belongs to,
23 * including this switch itself, of an event. Allows the other switches to
24 * reconfigure themselves for cross-chip operations. Can also be used to
25 * reconfigure ports without net_devices (CPU ports, DSA links) whenever
26 * a user port's state changes.
28 static int dsa_port_notify(const struct dsa_port *dp, unsigned long e, void *v)
30 return dsa_tree_notify(dp->ds->dst, e, v);
33 int dsa_port_set_state(struct dsa_port *dp, u8 state)
35 struct dsa_switch *ds = dp->ds;
38 if (!ds->ops->port_stp_state_set)
41 ds->ops->port_stp_state_set(ds, port, state);
43 if (ds->ops->port_fast_age) {
44 /* Fast age FDB entries or flush appropriate forwarding database
45 * for the given port, if we are moving it from Learning or
46 * Forwarding state, to Disabled or Blocking or Listening state.
49 if ((dp->stp_state == BR_STATE_LEARNING ||
50 dp->stp_state == BR_STATE_FORWARDING) &&
51 (state == BR_STATE_DISABLED ||
52 state == BR_STATE_BLOCKING ||
53 state == BR_STATE_LISTENING))
54 ds->ops->port_fast_age(ds, port);
57 dp->stp_state = state;
62 static void dsa_port_set_state_now(struct dsa_port *dp, u8 state)
66 err = dsa_port_set_state(dp, state);
68 pr_err("DSA: failed to set STP state %u (%d)\n", state, err);
71 int dsa_port_enable_rt(struct dsa_port *dp, struct phy_device *phy)
73 struct dsa_switch *ds = dp->ds;
77 if (ds->ops->port_enable) {
78 err = ds->ops->port_enable(ds, port, phy);
84 dsa_port_set_state_now(dp, BR_STATE_FORWARDING);
87 phylink_start(dp->pl);
92 int dsa_port_enable(struct dsa_port *dp, struct phy_device *phy)
97 err = dsa_port_enable_rt(dp, phy);
103 void dsa_port_disable_rt(struct dsa_port *dp)
105 struct dsa_switch *ds = dp->ds;
106 int port = dp->index;
109 phylink_stop(dp->pl);
112 dsa_port_set_state_now(dp, BR_STATE_DISABLED);
114 if (ds->ops->port_disable)
115 ds->ops->port_disable(ds, port);
118 void dsa_port_disable(struct dsa_port *dp)
121 dsa_port_disable_rt(dp);
125 static int dsa_port_inherit_brport_flags(struct dsa_port *dp,
126 struct netlink_ext_ack *extack)
128 const unsigned long mask = BR_LEARNING | BR_FLOOD | BR_MCAST_FLOOD |
130 struct net_device *brport_dev = dsa_port_to_bridge_port(dp);
133 for_each_set_bit(flag, &mask, 32) {
134 struct switchdev_brport_flags flags = {0};
136 flags.mask = BIT(flag);
138 if (br_port_flag_is_set(brport_dev, BIT(flag)))
139 flags.val = BIT(flag);
141 err = dsa_port_bridge_flags(dp, flags, extack);
142 if (err && err != -EOPNOTSUPP)
149 static void dsa_port_clear_brport_flags(struct dsa_port *dp)
151 const unsigned long val = BR_FLOOD | BR_MCAST_FLOOD | BR_BCAST_FLOOD;
152 const unsigned long mask = BR_LEARNING | BR_FLOOD | BR_MCAST_FLOOD |
156 for_each_set_bit(flag, &mask, 32) {
157 struct switchdev_brport_flags flags = {0};
159 flags.mask = BIT(flag);
160 flags.val = val & BIT(flag);
162 err = dsa_port_bridge_flags(dp, flags, NULL);
163 if (err && err != -EOPNOTSUPP)
165 "failed to clear bridge port flag %lu: %pe\n",
166 flags.val, ERR_PTR(err));
170 static int dsa_port_switchdev_sync_attrs(struct dsa_port *dp,
171 struct netlink_ext_ack *extack)
173 struct net_device *brport_dev = dsa_port_to_bridge_port(dp);
174 struct net_device *br = dp->bridge_dev;
177 err = dsa_port_inherit_brport_flags(dp, extack);
181 err = dsa_port_set_state(dp, br_port_get_stp_state(brport_dev));
182 if (err && err != -EOPNOTSUPP)
185 err = dsa_port_vlan_filtering(dp, br_vlan_enabled(br), extack);
186 if (err && err != -EOPNOTSUPP)
189 err = dsa_port_mrouter(dp->cpu_dp, br_multicast_router(br), extack);
190 if (err && err != -EOPNOTSUPP)
193 err = dsa_port_ageing_time(dp, br_get_ageing_time(br));
194 if (err && err != -EOPNOTSUPP)
200 static void dsa_port_switchdev_unsync_attrs(struct dsa_port *dp)
202 /* Configure the port for standalone mode (no address learning,
204 * The bridge only emits SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS events
205 * when the user requests it through netlink or sysfs, but not
206 * automatically at port join or leave, so we need to handle resetting
207 * the brport flags ourselves. But we even prefer it that way, because
208 * otherwise, some setups might never get the notification they need,
209 * for example, when a port leaves a LAG that offloads the bridge,
210 * it becomes standalone, but as far as the bridge is concerned, no
213 dsa_port_clear_brport_flags(dp);
215 /* Port left the bridge, put in BR_STATE_DISABLED by the bridge layer,
216 * so allow it to be in BR_STATE_FORWARDING to be kept functional
218 dsa_port_set_state_now(dp, BR_STATE_FORWARDING);
220 /* VLAN filtering is handled by dsa_switch_bridge_leave */
222 /* Some drivers treat the notification for having a local multicast
223 * router by allowing multicast to be flooded to the CPU, so we should
224 * allow this in standalone mode too.
226 dsa_port_mrouter(dp->cpu_dp, true, NULL);
228 /* Ageing time may be global to the switch chip, so don't change it
229 * here because we have no good reason (or value) to change it to.
233 int dsa_port_bridge_join(struct dsa_port *dp, struct net_device *br,
234 struct netlink_ext_ack *extack)
236 struct dsa_notifier_bridge_info info = {
237 .tree_index = dp->ds->dst->index,
238 .sw_index = dp->ds->index,
242 struct net_device *dev = dp->slave;
243 struct net_device *brport_dev;
246 /* Here the interface is already bridged. Reflect the current
247 * configuration so that drivers can program their chips accordingly.
251 brport_dev = dsa_port_to_bridge_port(dp);
253 err = dsa_broadcast(DSA_NOTIFIER_BRIDGE_JOIN, &info);
257 err = switchdev_bridge_port_offload(brport_dev, dev, dp,
258 &dsa_slave_switchdev_notifier,
259 &dsa_slave_switchdev_blocking_notifier,
262 goto out_rollback_unbridge;
264 err = dsa_port_switchdev_sync_attrs(dp, extack);
266 goto out_rollback_unoffload;
270 out_rollback_unoffload:
271 switchdev_bridge_port_unoffload(brport_dev, dp,
272 &dsa_slave_switchdev_notifier,
273 &dsa_slave_switchdev_blocking_notifier);
274 out_rollback_unbridge:
275 dsa_broadcast(DSA_NOTIFIER_BRIDGE_LEAVE, &info);
277 dp->bridge_dev = NULL;
281 void dsa_port_pre_bridge_leave(struct dsa_port *dp, struct net_device *br)
283 struct net_device *brport_dev = dsa_port_to_bridge_port(dp);
285 switchdev_bridge_port_unoffload(brport_dev, dp,
286 &dsa_slave_switchdev_notifier,
287 &dsa_slave_switchdev_blocking_notifier);
290 void dsa_port_bridge_leave(struct dsa_port *dp, struct net_device *br)
292 struct dsa_notifier_bridge_info info = {
293 .tree_index = dp->ds->dst->index,
294 .sw_index = dp->ds->index,
300 /* Here the port is already unbridged. Reflect the current configuration
301 * so that drivers can program their chips accordingly.
303 dp->bridge_dev = NULL;
305 err = dsa_broadcast(DSA_NOTIFIER_BRIDGE_LEAVE, &info);
307 pr_err("DSA: failed to notify DSA_NOTIFIER_BRIDGE_LEAVE\n");
309 dsa_port_switchdev_unsync_attrs(dp);
312 int dsa_port_lag_change(struct dsa_port *dp,
313 struct netdev_lag_lower_state_info *linfo)
315 struct dsa_notifier_lag_info info = {
316 .sw_index = dp->ds->index,
324 /* On statically configured aggregates (e.g. loadbalance
325 * without LACP) ports will always be tx_enabled, even if the
326 * link is down. Thus we require both link_up and tx_enabled
327 * in order to include it in the tx set.
329 tx_enabled = linfo->link_up && linfo->tx_enabled;
331 if (tx_enabled == dp->lag_tx_enabled)
334 dp->lag_tx_enabled = tx_enabled;
336 return dsa_port_notify(dp, DSA_NOTIFIER_LAG_CHANGE, &info);
339 int dsa_port_lag_join(struct dsa_port *dp, struct net_device *lag,
340 struct netdev_lag_upper_info *uinfo,
341 struct netlink_ext_ack *extack)
343 struct dsa_notifier_lag_info info = {
344 .sw_index = dp->ds->index,
349 struct net_device *bridge_dev;
352 dsa_lag_map(dp->ds->dst, lag);
355 err = dsa_port_notify(dp, DSA_NOTIFIER_LAG_JOIN, &info);
359 bridge_dev = netdev_master_upper_dev_get(lag);
360 if (!bridge_dev || !netif_is_bridge_master(bridge_dev))
363 err = dsa_port_bridge_join(dp, bridge_dev, extack);
365 goto err_bridge_join;
370 dsa_port_notify(dp, DSA_NOTIFIER_LAG_LEAVE, &info);
373 dsa_lag_unmap(dp->ds->dst, lag);
377 void dsa_port_pre_lag_leave(struct dsa_port *dp, struct net_device *lag)
380 dsa_port_pre_bridge_leave(dp, dp->bridge_dev);
383 void dsa_port_lag_leave(struct dsa_port *dp, struct net_device *lag)
385 struct dsa_notifier_lag_info info = {
386 .sw_index = dp->ds->index,
395 /* Port might have been part of a LAG that in turn was
396 * attached to a bridge.
399 dsa_port_bridge_leave(dp, dp->bridge_dev);
401 dp->lag_tx_enabled = false;
404 err = dsa_port_notify(dp, DSA_NOTIFIER_LAG_LEAVE, &info);
406 pr_err("DSA: failed to notify DSA_NOTIFIER_LAG_LEAVE: %d\n",
409 dsa_lag_unmap(dp->ds->dst, lag);
412 /* Must be called under rcu_read_lock() */
413 static bool dsa_port_can_apply_vlan_filtering(struct dsa_port *dp,
415 struct netlink_ext_ack *extack)
417 struct dsa_switch *ds = dp->ds;
420 /* VLAN awareness was off, so the question is "can we turn it on".
421 * We may have had 8021q uppers, those need to go. Make sure we don't
422 * enter an inconsistent state: deny changing the VLAN awareness state
423 * as long as we have 8021q uppers.
425 if (vlan_filtering && dsa_is_user_port(ds, dp->index)) {
426 struct net_device *upper_dev, *slave = dp->slave;
427 struct net_device *br = dp->bridge_dev;
428 struct list_head *iter;
430 netdev_for_each_upper_dev_rcu(slave, upper_dev, iter) {
431 struct bridge_vlan_info br_info;
434 if (!is_vlan_dev(upper_dev))
437 vid = vlan_dev_vlan_id(upper_dev);
439 /* br_vlan_get_info() returns -EINVAL or -ENOENT if the
440 * device, respectively the VID is not found, returning
441 * 0 means success, which is a failure for us here.
443 err = br_vlan_get_info(br, vid, &br_info);
445 NL_SET_ERR_MSG_MOD(extack,
446 "Must first remove VLAN uppers having VIDs also present in bridge");
452 if (!ds->vlan_filtering_is_global)
455 /* For cases where enabling/disabling VLAN awareness is global to the
456 * switch, we need to handle the case where multiple bridges span
457 * different ports of the same switch device and one of them has a
458 * different setting than what is being requested.
460 for (i = 0; i < ds->num_ports; i++) {
461 struct net_device *other_bridge;
463 other_bridge = dsa_to_port(ds, i)->bridge_dev;
466 /* If it's the same bridge, it also has same
467 * vlan_filtering setting => no need to check
469 if (other_bridge == dp->bridge_dev)
471 if (br_vlan_enabled(other_bridge) != vlan_filtering) {
472 NL_SET_ERR_MSG_MOD(extack,
473 "VLAN filtering is a global setting");
480 int dsa_port_vlan_filtering(struct dsa_port *dp, bool vlan_filtering,
481 struct netlink_ext_ack *extack)
483 struct dsa_switch *ds = dp->ds;
487 if (!ds->ops->port_vlan_filtering)
490 /* We are called from dsa_slave_switchdev_blocking_event(),
491 * which is not under rcu_read_lock(), unlike
492 * dsa_slave_switchdev_event().
495 apply = dsa_port_can_apply_vlan_filtering(dp, vlan_filtering, extack);
500 if (dsa_port_is_vlan_filtering(dp) == vlan_filtering)
503 err = ds->ops->port_vlan_filtering(ds, dp->index, vlan_filtering,
508 if (ds->vlan_filtering_is_global)
509 ds->vlan_filtering = vlan_filtering;
511 dp->vlan_filtering = vlan_filtering;
516 /* This enforces legacy behavior for switch drivers which assume they can't
517 * receive VLAN configuration when enslaved to a bridge with vlan_filtering=0
519 bool dsa_port_skip_vlan_configuration(struct dsa_port *dp)
521 struct dsa_switch *ds = dp->ds;
526 return (!ds->configure_vlan_while_not_filtering &&
527 !br_vlan_enabled(dp->bridge_dev));
530 int dsa_port_ageing_time(struct dsa_port *dp, clock_t ageing_clock)
532 unsigned long ageing_jiffies = clock_t_to_jiffies(ageing_clock);
533 unsigned int ageing_time = jiffies_to_msecs(ageing_jiffies);
534 struct dsa_notifier_ageing_time_info info;
537 info.ageing_time = ageing_time;
539 err = dsa_port_notify(dp, DSA_NOTIFIER_AGEING_TIME, &info);
543 dp->ageing_time = ageing_time;
548 int dsa_port_pre_bridge_flags(const struct dsa_port *dp,
549 struct switchdev_brport_flags flags,
550 struct netlink_ext_ack *extack)
552 struct dsa_switch *ds = dp->ds;
554 if (!ds->ops->port_pre_bridge_flags)
557 return ds->ops->port_pre_bridge_flags(ds, dp->index, flags, extack);
560 int dsa_port_bridge_flags(const struct dsa_port *dp,
561 struct switchdev_brport_flags flags,
562 struct netlink_ext_ack *extack)
564 struct dsa_switch *ds = dp->ds;
566 if (!ds->ops->port_bridge_flags)
569 return ds->ops->port_bridge_flags(ds, dp->index, flags, extack);
572 int dsa_port_mrouter(struct dsa_port *dp, bool mrouter,
573 struct netlink_ext_ack *extack)
575 struct dsa_switch *ds = dp->ds;
577 if (!ds->ops->port_set_mrouter)
580 return ds->ops->port_set_mrouter(ds, dp->index, mrouter, extack);
583 int dsa_port_mtu_change(struct dsa_port *dp, int new_mtu,
586 struct dsa_notifier_mtu_info info = {
587 .sw_index = dp->ds->index,
588 .targeted_match = targeted_match,
593 return dsa_port_notify(dp, DSA_NOTIFIER_MTU, &info);
596 int dsa_port_fdb_add(struct dsa_port *dp, const unsigned char *addr,
599 struct dsa_notifier_fdb_info info = {
600 .sw_index = dp->ds->index,
606 return dsa_port_notify(dp, DSA_NOTIFIER_FDB_ADD, &info);
609 int dsa_port_fdb_del(struct dsa_port *dp, const unsigned char *addr,
612 struct dsa_notifier_fdb_info info = {
613 .sw_index = dp->ds->index,
620 return dsa_port_notify(dp, DSA_NOTIFIER_FDB_DEL, &info);
623 int dsa_port_host_fdb_add(struct dsa_port *dp, const unsigned char *addr,
626 struct dsa_notifier_fdb_info info = {
627 .sw_index = dp->ds->index,
632 struct dsa_port *cpu_dp = dp->cpu_dp;
635 err = dev_uc_add(cpu_dp->master, addr);
639 return dsa_port_notify(dp, DSA_NOTIFIER_HOST_FDB_ADD, &info);
642 int dsa_port_host_fdb_del(struct dsa_port *dp, const unsigned char *addr,
645 struct dsa_notifier_fdb_info info = {
646 .sw_index = dp->ds->index,
651 struct dsa_port *cpu_dp = dp->cpu_dp;
654 err = dev_uc_del(cpu_dp->master, addr);
658 return dsa_port_notify(dp, DSA_NOTIFIER_HOST_FDB_DEL, &info);
661 int dsa_port_fdb_dump(struct dsa_port *dp, dsa_fdb_dump_cb_t *cb, void *data)
663 struct dsa_switch *ds = dp->ds;
664 int port = dp->index;
666 if (!ds->ops->port_fdb_dump)
669 return ds->ops->port_fdb_dump(ds, port, cb, data);
672 int dsa_port_mdb_add(const struct dsa_port *dp,
673 const struct switchdev_obj_port_mdb *mdb)
675 struct dsa_notifier_mdb_info info = {
676 .sw_index = dp->ds->index,
681 return dsa_port_notify(dp, DSA_NOTIFIER_MDB_ADD, &info);
684 int dsa_port_mdb_del(const struct dsa_port *dp,
685 const struct switchdev_obj_port_mdb *mdb)
687 struct dsa_notifier_mdb_info info = {
688 .sw_index = dp->ds->index,
693 return dsa_port_notify(dp, DSA_NOTIFIER_MDB_DEL, &info);
696 int dsa_port_host_mdb_add(const struct dsa_port *dp,
697 const struct switchdev_obj_port_mdb *mdb)
699 struct dsa_notifier_mdb_info info = {
700 .sw_index = dp->ds->index,
704 struct dsa_port *cpu_dp = dp->cpu_dp;
707 err = dev_mc_add(cpu_dp->master, mdb->addr);
711 return dsa_port_notify(dp, DSA_NOTIFIER_HOST_MDB_ADD, &info);
714 int dsa_port_host_mdb_del(const struct dsa_port *dp,
715 const struct switchdev_obj_port_mdb *mdb)
717 struct dsa_notifier_mdb_info info = {
718 .sw_index = dp->ds->index,
722 struct dsa_port *cpu_dp = dp->cpu_dp;
725 err = dev_mc_del(cpu_dp->master, mdb->addr);
729 return dsa_port_notify(dp, DSA_NOTIFIER_HOST_MDB_DEL, &info);
732 int dsa_port_vlan_add(struct dsa_port *dp,
733 const struct switchdev_obj_port_vlan *vlan,
734 struct netlink_ext_ack *extack)
736 struct dsa_notifier_vlan_info info = {
737 .sw_index = dp->ds->index,
743 return dsa_port_notify(dp, DSA_NOTIFIER_VLAN_ADD, &info);
746 int dsa_port_vlan_del(struct dsa_port *dp,
747 const struct switchdev_obj_port_vlan *vlan)
749 struct dsa_notifier_vlan_info info = {
750 .sw_index = dp->ds->index,
755 return dsa_port_notify(dp, DSA_NOTIFIER_VLAN_DEL, &info);
758 int dsa_port_mrp_add(const struct dsa_port *dp,
759 const struct switchdev_obj_mrp *mrp)
761 struct dsa_notifier_mrp_info info = {
762 .sw_index = dp->ds->index,
767 return dsa_port_notify(dp, DSA_NOTIFIER_MRP_ADD, &info);
770 int dsa_port_mrp_del(const struct dsa_port *dp,
771 const struct switchdev_obj_mrp *mrp)
773 struct dsa_notifier_mrp_info info = {
774 .sw_index = dp->ds->index,
779 return dsa_port_notify(dp, DSA_NOTIFIER_MRP_DEL, &info);
782 int dsa_port_mrp_add_ring_role(const struct dsa_port *dp,
783 const struct switchdev_obj_ring_role_mrp *mrp)
785 struct dsa_notifier_mrp_ring_role_info info = {
786 .sw_index = dp->ds->index,
791 return dsa_port_notify(dp, DSA_NOTIFIER_MRP_ADD_RING_ROLE, &info);
794 int dsa_port_mrp_del_ring_role(const struct dsa_port *dp,
795 const struct switchdev_obj_ring_role_mrp *mrp)
797 struct dsa_notifier_mrp_ring_role_info info = {
798 .sw_index = dp->ds->index,
803 return dsa_port_notify(dp, DSA_NOTIFIER_MRP_DEL_RING_ROLE, &info);
806 void dsa_port_set_tag_protocol(struct dsa_port *cpu_dp,
807 const struct dsa_device_ops *tag_ops)
809 cpu_dp->filter = tag_ops->filter;
810 cpu_dp->rcv = tag_ops->rcv;
811 cpu_dp->tag_ops = tag_ops;
814 static struct phy_device *dsa_port_get_phy_device(struct dsa_port *dp)
816 struct device_node *phy_dn;
817 struct phy_device *phydev;
819 phy_dn = of_parse_phandle(dp->dn, "phy-handle", 0);
823 phydev = of_phy_find_device(phy_dn);
826 return ERR_PTR(-EPROBE_DEFER);
833 static void dsa_port_phylink_validate(struct phylink_config *config,
834 unsigned long *supported,
835 struct phylink_link_state *state)
837 struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
838 struct dsa_switch *ds = dp->ds;
840 if (!ds->ops->phylink_validate)
843 ds->ops->phylink_validate(ds, dp->index, supported, state);
846 static void dsa_port_phylink_mac_pcs_get_state(struct phylink_config *config,
847 struct phylink_link_state *state)
849 struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
850 struct dsa_switch *ds = dp->ds;
853 /* Only called for inband modes */
854 if (!ds->ops->phylink_mac_link_state) {
859 err = ds->ops->phylink_mac_link_state(ds, dp->index, state);
861 dev_err(ds->dev, "p%d: phylink_mac_link_state() failed: %d\n",
867 static void dsa_port_phylink_mac_config(struct phylink_config *config,
869 const struct phylink_link_state *state)
871 struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
872 struct dsa_switch *ds = dp->ds;
874 if (!ds->ops->phylink_mac_config)
877 ds->ops->phylink_mac_config(ds, dp->index, mode, state);
880 static void dsa_port_phylink_mac_an_restart(struct phylink_config *config)
882 struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
883 struct dsa_switch *ds = dp->ds;
885 if (!ds->ops->phylink_mac_an_restart)
888 ds->ops->phylink_mac_an_restart(ds, dp->index);
891 static void dsa_port_phylink_mac_link_down(struct phylink_config *config,
893 phy_interface_t interface)
895 struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
896 struct phy_device *phydev = NULL;
897 struct dsa_switch *ds = dp->ds;
899 if (dsa_is_user_port(ds, dp->index))
900 phydev = dp->slave->phydev;
902 if (!ds->ops->phylink_mac_link_down) {
903 if (ds->ops->adjust_link && phydev)
904 ds->ops->adjust_link(ds, dp->index, phydev);
908 ds->ops->phylink_mac_link_down(ds, dp->index, mode, interface);
911 static void dsa_port_phylink_mac_link_up(struct phylink_config *config,
912 struct phy_device *phydev,
914 phy_interface_t interface,
915 int speed, int duplex,
916 bool tx_pause, bool rx_pause)
918 struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
919 struct dsa_switch *ds = dp->ds;
921 if (!ds->ops->phylink_mac_link_up) {
922 if (ds->ops->adjust_link && phydev)
923 ds->ops->adjust_link(ds, dp->index, phydev);
927 ds->ops->phylink_mac_link_up(ds, dp->index, mode, interface, phydev,
928 speed, duplex, tx_pause, rx_pause);
931 const struct phylink_mac_ops dsa_port_phylink_mac_ops = {
932 .validate = dsa_port_phylink_validate,
933 .mac_pcs_get_state = dsa_port_phylink_mac_pcs_get_state,
934 .mac_config = dsa_port_phylink_mac_config,
935 .mac_an_restart = dsa_port_phylink_mac_an_restart,
936 .mac_link_down = dsa_port_phylink_mac_link_down,
937 .mac_link_up = dsa_port_phylink_mac_link_up,
940 static int dsa_port_setup_phy_of(struct dsa_port *dp, bool enable)
942 struct dsa_switch *ds = dp->ds;
943 struct phy_device *phydev;
944 int port = dp->index;
947 phydev = dsa_port_get_phy_device(dp);
952 return PTR_ERR(phydev);
955 err = genphy_resume(phydev);
959 err = genphy_read_status(phydev);
963 err = genphy_suspend(phydev);
968 if (ds->ops->adjust_link)
969 ds->ops->adjust_link(ds, port, phydev);
971 dev_dbg(ds->dev, "enabled port's phy: %s", phydev_name(phydev));
974 put_device(&phydev->mdio.dev);
978 static int dsa_port_fixed_link_register_of(struct dsa_port *dp)
980 struct device_node *dn = dp->dn;
981 struct dsa_switch *ds = dp->ds;
982 struct phy_device *phydev;
983 int port = dp->index;
984 phy_interface_t mode;
987 err = of_phy_register_fixed_link(dn);
990 "failed to register the fixed PHY of port %d\n",
995 phydev = of_phy_find_device(dn);
997 err = of_get_phy_mode(dn, &mode);
999 mode = PHY_INTERFACE_MODE_NA;
1000 phydev->interface = mode;
1002 genphy_read_status(phydev);
1004 if (ds->ops->adjust_link)
1005 ds->ops->adjust_link(ds, port, phydev);
1007 put_device(&phydev->mdio.dev);
1012 static int dsa_port_phylink_register(struct dsa_port *dp)
1014 struct dsa_switch *ds = dp->ds;
1015 struct device_node *port_dn = dp->dn;
1016 phy_interface_t mode;
1019 err = of_get_phy_mode(port_dn, &mode);
1021 mode = PHY_INTERFACE_MODE_NA;
1023 dp->pl_config.dev = ds->dev;
1024 dp->pl_config.type = PHYLINK_DEV;
1025 dp->pl_config.pcs_poll = ds->pcs_poll;
1027 dp->pl = phylink_create(&dp->pl_config, of_fwnode_handle(port_dn),
1028 mode, &dsa_port_phylink_mac_ops);
1029 if (IS_ERR(dp->pl)) {
1030 pr_err("error creating PHYLINK: %ld\n", PTR_ERR(dp->pl));
1031 return PTR_ERR(dp->pl);
1034 err = phylink_of_phy_connect(dp->pl, port_dn, 0);
1035 if (err && err != -ENODEV) {
1036 pr_err("could not attach to PHY: %d\n", err);
1037 goto err_phy_connect;
1043 phylink_destroy(dp->pl);
1047 int dsa_port_link_register_of(struct dsa_port *dp)
1049 struct dsa_switch *ds = dp->ds;
1050 struct device_node *phy_np;
1051 int port = dp->index;
1053 if (!ds->ops->adjust_link) {
1054 phy_np = of_parse_phandle(dp->dn, "phy-handle", 0);
1055 if (of_phy_is_fixed_link(dp->dn) || phy_np) {
1056 if (ds->ops->phylink_mac_link_down)
1057 ds->ops->phylink_mac_link_down(ds, port,
1058 MLO_AN_FIXED, PHY_INTERFACE_MODE_NA);
1059 return dsa_port_phylink_register(dp);
1065 "Using legacy PHYLIB callbacks. Please migrate to PHYLINK!\n");
1067 if (of_phy_is_fixed_link(dp->dn))
1068 return dsa_port_fixed_link_register_of(dp);
1070 return dsa_port_setup_phy_of(dp, true);
1073 void dsa_port_link_unregister_of(struct dsa_port *dp)
1075 struct dsa_switch *ds = dp->ds;
1077 if (!ds->ops->adjust_link && dp->pl) {
1079 phylink_disconnect_phy(dp->pl);
1081 phylink_destroy(dp->pl);
1086 if (of_phy_is_fixed_link(dp->dn))
1087 of_phy_deregister_fixed_link(dp->dn);
1089 dsa_port_setup_phy_of(dp, false);
1092 int dsa_port_get_phy_strings(struct dsa_port *dp, uint8_t *data)
1094 struct phy_device *phydev;
1095 int ret = -EOPNOTSUPP;
1097 if (of_phy_is_fixed_link(dp->dn))
1100 phydev = dsa_port_get_phy_device(dp);
1101 if (IS_ERR_OR_NULL(phydev))
1104 ret = phy_ethtool_get_strings(phydev, data);
1105 put_device(&phydev->mdio.dev);
1109 EXPORT_SYMBOL_GPL(dsa_port_get_phy_strings);
1111 int dsa_port_get_ethtool_phy_stats(struct dsa_port *dp, uint64_t *data)
1113 struct phy_device *phydev;
1114 int ret = -EOPNOTSUPP;
1116 if (of_phy_is_fixed_link(dp->dn))
1119 phydev = dsa_port_get_phy_device(dp);
1120 if (IS_ERR_OR_NULL(phydev))
1123 ret = phy_ethtool_get_stats(phydev, NULL, data);
1124 put_device(&phydev->mdio.dev);
1128 EXPORT_SYMBOL_GPL(dsa_port_get_ethtool_phy_stats);
1130 int dsa_port_get_phy_sset_count(struct dsa_port *dp)
1132 struct phy_device *phydev;
1133 int ret = -EOPNOTSUPP;
1135 if (of_phy_is_fixed_link(dp->dn))
1138 phydev = dsa_port_get_phy_device(dp);
1139 if (IS_ERR_OR_NULL(phydev))
1142 ret = phy_ethtool_get_sset_count(phydev);
1143 put_device(&phydev->mdio.dev);
1147 EXPORT_SYMBOL_GPL(dsa_port_get_phy_sset_count);
1149 int dsa_port_hsr_join(struct dsa_port *dp, struct net_device *hsr)
1151 struct dsa_notifier_hsr_info info = {
1152 .sw_index = dp->ds->index,
1160 err = dsa_port_notify(dp, DSA_NOTIFIER_HSR_JOIN, &info);
1167 void dsa_port_hsr_leave(struct dsa_port *dp, struct net_device *hsr)
1169 struct dsa_notifier_hsr_info info = {
1170 .sw_index = dp->ds->index,
1178 err = dsa_port_notify(dp, DSA_NOTIFIER_HSR_LEAVE, &info);
1180 pr_err("DSA: failed to notify DSA_NOTIFIER_HSR_LEAVE\n");
1183 int dsa_port_tag_8021q_vlan_add(struct dsa_port *dp, u16 vid)
1185 struct dsa_notifier_tag_8021q_vlan_info info = {
1186 .tree_index = dp->ds->dst->index,
1187 .sw_index = dp->ds->index,
1192 return dsa_broadcast(DSA_NOTIFIER_TAG_8021Q_VLAN_ADD, &info);
1195 void dsa_port_tag_8021q_vlan_del(struct dsa_port *dp, u16 vid)
1197 struct dsa_notifier_tag_8021q_vlan_info info = {
1198 .tree_index = dp->ds->dst->index,
1199 .sw_index = dp->ds->index,
1205 err = dsa_broadcast(DSA_NOTIFIER_TAG_8021Q_VLAN_DEL, &info);
1207 pr_err("DSA: failed to notify tag_8021q VLAN deletion: %pe\n",