Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * Handling of a single switch port
0004  *
0005  * Copyright (c) 2017 Savoir-faire Linux Inc.
0006  *  Vivien Didelot <vivien.didelot@savoirfairelinux.com>
0007  */
0008 
0009 #include <linux/if_bridge.h>
0010 #include <linux/notifier.h>
0011 #include <linux/of_mdio.h>
0012 #include <linux/of_net.h>
0013 
0014 #include "dsa_priv.h"
0015 
0016 /**
0017  * dsa_port_notify - Notify the switching fabric of changes to a port
0018  * @dp: port on which change occurred
0019  * @e: event, must be of type DSA_NOTIFIER_*
0020  * @v: event-specific value.
0021  *
0022  * Notify all switches in the DSA tree that this port's switch belongs to,
0023  * including this switch itself, of an event. Allows the other switches to
0024  * reconfigure themselves for cross-chip operations. Can also be used to
0025  * reconfigure ports without net_devices (CPU ports, DSA links) whenever
0026  * a user port's state changes.
0027  */
0028 static int dsa_port_notify(const struct dsa_port *dp, unsigned long e, void *v)
0029 {
0030     return dsa_tree_notify(dp->ds->dst, e, v);
0031 }
0032 
0033 static void dsa_port_notify_bridge_fdb_flush(const struct dsa_port *dp, u16 vid)
0034 {
0035     struct net_device *brport_dev = dsa_port_to_bridge_port(dp);
0036     struct switchdev_notifier_fdb_info info = {
0037         .vid = vid,
0038     };
0039 
0040     /* When the port becomes standalone it has already left the bridge.
0041      * Don't notify the bridge in that case.
0042      */
0043     if (!brport_dev)
0044         return;
0045 
0046     call_switchdev_notifiers(SWITCHDEV_FDB_FLUSH_TO_BRIDGE,
0047                  brport_dev, &info.info, NULL);
0048 }
0049 
0050 static void dsa_port_fast_age(const struct dsa_port *dp)
0051 {
0052     struct dsa_switch *ds = dp->ds;
0053 
0054     if (!ds->ops->port_fast_age)
0055         return;
0056 
0057     ds->ops->port_fast_age(ds, dp->index);
0058 
0059     /* flush all VLANs */
0060     dsa_port_notify_bridge_fdb_flush(dp, 0);
0061 }
0062 
0063 static int dsa_port_vlan_fast_age(const struct dsa_port *dp, u16 vid)
0064 {
0065     struct dsa_switch *ds = dp->ds;
0066     int err;
0067 
0068     if (!ds->ops->port_vlan_fast_age)
0069         return -EOPNOTSUPP;
0070 
0071     err = ds->ops->port_vlan_fast_age(ds, dp->index, vid);
0072 
0073     if (!err)
0074         dsa_port_notify_bridge_fdb_flush(dp, vid);
0075 
0076     return err;
0077 }
0078 
0079 static int dsa_port_msti_fast_age(const struct dsa_port *dp, u16 msti)
0080 {
0081     DECLARE_BITMAP(vids, VLAN_N_VID) = { 0 };
0082     int err, vid;
0083 
0084     err = br_mst_get_info(dsa_port_bridge_dev_get(dp), msti, vids);
0085     if (err)
0086         return err;
0087 
0088     for_each_set_bit(vid, vids, VLAN_N_VID) {
0089         err = dsa_port_vlan_fast_age(dp, vid);
0090         if (err)
0091             return err;
0092     }
0093 
0094     return 0;
0095 }
0096 
0097 static bool dsa_port_can_configure_learning(struct dsa_port *dp)
0098 {
0099     struct switchdev_brport_flags flags = {
0100         .mask = BR_LEARNING,
0101     };
0102     struct dsa_switch *ds = dp->ds;
0103     int err;
0104 
0105     if (!ds->ops->port_bridge_flags || !ds->ops->port_pre_bridge_flags)
0106         return false;
0107 
0108     err = ds->ops->port_pre_bridge_flags(ds, dp->index, flags, NULL);
0109     return !err;
0110 }
0111 
0112 int dsa_port_set_state(struct dsa_port *dp, u8 state, bool do_fast_age)
0113 {
0114     struct dsa_switch *ds = dp->ds;
0115     int port = dp->index;
0116 
0117     if (!ds->ops->port_stp_state_set)
0118         return -EOPNOTSUPP;
0119 
0120     ds->ops->port_stp_state_set(ds, port, state);
0121 
0122     if (!dsa_port_can_configure_learning(dp) ||
0123         (do_fast_age && dp->learning)) {
0124         /* Fast age FDB entries or flush appropriate forwarding database
0125          * for the given port, if we are moving it from Learning or
0126          * Forwarding state, to Disabled or Blocking or Listening state.
0127          * Ports that were standalone before the STP state change don't
0128          * need to fast age the FDB, since address learning is off in
0129          * standalone mode.
0130          */
0131 
0132         if ((dp->stp_state == BR_STATE_LEARNING ||
0133              dp->stp_state == BR_STATE_FORWARDING) &&
0134             (state == BR_STATE_DISABLED ||
0135              state == BR_STATE_BLOCKING ||
0136              state == BR_STATE_LISTENING))
0137             dsa_port_fast_age(dp);
0138     }
0139 
0140     dp->stp_state = state;
0141 
0142     return 0;
0143 }
0144 
0145 static void dsa_port_set_state_now(struct dsa_port *dp, u8 state,
0146                    bool do_fast_age)
0147 {
0148     struct dsa_switch *ds = dp->ds;
0149     int err;
0150 
0151     err = dsa_port_set_state(dp, state, do_fast_age);
0152     if (err && err != -EOPNOTSUPP) {
0153         dev_err(ds->dev, "port %d failed to set STP state %u: %pe\n",
0154             dp->index, state, ERR_PTR(err));
0155     }
0156 }
0157 
0158 int dsa_port_set_mst_state(struct dsa_port *dp,
0159                const struct switchdev_mst_state *state,
0160                struct netlink_ext_ack *extack)
0161 {
0162     struct dsa_switch *ds = dp->ds;
0163     u8 prev_state;
0164     int err;
0165 
0166     if (!ds->ops->port_mst_state_set)
0167         return -EOPNOTSUPP;
0168 
0169     err = br_mst_get_state(dsa_port_to_bridge_port(dp), state->msti,
0170                    &prev_state);
0171     if (err)
0172         return err;
0173 
0174     err = ds->ops->port_mst_state_set(ds, dp->index, state);
0175     if (err)
0176         return err;
0177 
0178     if (!(dp->learning &&
0179           (prev_state == BR_STATE_LEARNING ||
0180            prev_state == BR_STATE_FORWARDING) &&
0181           (state->state == BR_STATE_DISABLED ||
0182            state->state == BR_STATE_BLOCKING ||
0183            state->state == BR_STATE_LISTENING)))
0184         return 0;
0185 
0186     err = dsa_port_msti_fast_age(dp, state->msti);
0187     if (err)
0188         NL_SET_ERR_MSG_MOD(extack,
0189                    "Unable to flush associated VLANs");
0190 
0191     return 0;
0192 }
0193 
0194 int dsa_port_enable_rt(struct dsa_port *dp, struct phy_device *phy)
0195 {
0196     struct dsa_switch *ds = dp->ds;
0197     int port = dp->index;
0198     int err;
0199 
0200     if (ds->ops->port_enable) {
0201         err = ds->ops->port_enable(ds, port, phy);
0202         if (err)
0203             return err;
0204     }
0205 
0206     if (!dp->bridge)
0207         dsa_port_set_state_now(dp, BR_STATE_FORWARDING, false);
0208 
0209     if (dp->pl)
0210         phylink_start(dp->pl);
0211 
0212     return 0;
0213 }
0214 
0215 int dsa_port_enable(struct dsa_port *dp, struct phy_device *phy)
0216 {
0217     int err;
0218 
0219     rtnl_lock();
0220     err = dsa_port_enable_rt(dp, phy);
0221     rtnl_unlock();
0222 
0223     return err;
0224 }
0225 
0226 void dsa_port_disable_rt(struct dsa_port *dp)
0227 {
0228     struct dsa_switch *ds = dp->ds;
0229     int port = dp->index;
0230 
0231     if (dp->pl)
0232         phylink_stop(dp->pl);
0233 
0234     if (!dp->bridge)
0235         dsa_port_set_state_now(dp, BR_STATE_DISABLED, false);
0236 
0237     if (ds->ops->port_disable)
0238         ds->ops->port_disable(ds, port);
0239 }
0240 
0241 void dsa_port_disable(struct dsa_port *dp)
0242 {
0243     rtnl_lock();
0244     dsa_port_disable_rt(dp);
0245     rtnl_unlock();
0246 }
0247 
0248 static void dsa_port_reset_vlan_filtering(struct dsa_port *dp,
0249                       struct dsa_bridge bridge)
0250 {
0251     struct netlink_ext_ack extack = {0};
0252     bool change_vlan_filtering = false;
0253     struct dsa_switch *ds = dp->ds;
0254     struct dsa_port *other_dp;
0255     bool vlan_filtering;
0256     int err;
0257 
0258     if (ds->needs_standalone_vlan_filtering &&
0259         !br_vlan_enabled(bridge.dev)) {
0260         change_vlan_filtering = true;
0261         vlan_filtering = true;
0262     } else if (!ds->needs_standalone_vlan_filtering &&
0263            br_vlan_enabled(bridge.dev)) {
0264         change_vlan_filtering = true;
0265         vlan_filtering = false;
0266     }
0267 
0268     /* If the bridge was vlan_filtering, the bridge core doesn't trigger an
0269      * event for changing vlan_filtering setting upon slave ports leaving
0270      * it. That is a good thing, because that lets us handle it and also
0271      * handle the case where the switch's vlan_filtering setting is global
0272      * (not per port). When that happens, the correct moment to trigger the
0273      * vlan_filtering callback is only when the last port leaves the last
0274      * VLAN-aware bridge.
0275      */
0276     if (change_vlan_filtering && ds->vlan_filtering_is_global) {
0277         dsa_switch_for_each_port(other_dp, ds) {
0278             struct net_device *br = dsa_port_bridge_dev_get(other_dp);
0279 
0280             if (br && br_vlan_enabled(br)) {
0281                 change_vlan_filtering = false;
0282                 break;
0283             }
0284         }
0285     }
0286 
0287     if (!change_vlan_filtering)
0288         return;
0289 
0290     err = dsa_port_vlan_filtering(dp, vlan_filtering, &extack);
0291     if (extack._msg) {
0292         dev_err(ds->dev, "port %d: %s\n", dp->index,
0293             extack._msg);
0294     }
0295     if (err && err != -EOPNOTSUPP) {
0296         dev_err(ds->dev,
0297             "port %d failed to reset VLAN filtering to %d: %pe\n",
0298                dp->index, vlan_filtering, ERR_PTR(err));
0299     }
0300 }
0301 
0302 static int dsa_port_inherit_brport_flags(struct dsa_port *dp,
0303                      struct netlink_ext_ack *extack)
0304 {
0305     const unsigned long mask = BR_LEARNING | BR_FLOOD | BR_MCAST_FLOOD |
0306                    BR_BCAST_FLOOD | BR_PORT_LOCKED;
0307     struct net_device *brport_dev = dsa_port_to_bridge_port(dp);
0308     int flag, err;
0309 
0310     for_each_set_bit(flag, &mask, 32) {
0311         struct switchdev_brport_flags flags = {0};
0312 
0313         flags.mask = BIT(flag);
0314 
0315         if (br_port_flag_is_set(brport_dev, BIT(flag)))
0316             flags.val = BIT(flag);
0317 
0318         err = dsa_port_bridge_flags(dp, flags, extack);
0319         if (err && err != -EOPNOTSUPP)
0320             return err;
0321     }
0322 
0323     return 0;
0324 }
0325 
0326 static void dsa_port_clear_brport_flags(struct dsa_port *dp)
0327 {
0328     const unsigned long val = BR_FLOOD | BR_MCAST_FLOOD | BR_BCAST_FLOOD;
0329     const unsigned long mask = BR_LEARNING | BR_FLOOD | BR_MCAST_FLOOD |
0330                    BR_BCAST_FLOOD | BR_PORT_LOCKED;
0331     int flag, err;
0332 
0333     for_each_set_bit(flag, &mask, 32) {
0334         struct switchdev_brport_flags flags = {0};
0335 
0336         flags.mask = BIT(flag);
0337         flags.val = val & BIT(flag);
0338 
0339         err = dsa_port_bridge_flags(dp, flags, NULL);
0340         if (err && err != -EOPNOTSUPP)
0341             dev_err(dp->ds->dev,
0342                 "failed to clear bridge port flag %lu: %pe\n",
0343                 flags.val, ERR_PTR(err));
0344     }
0345 }
0346 
0347 static int dsa_port_switchdev_sync_attrs(struct dsa_port *dp,
0348                      struct netlink_ext_ack *extack)
0349 {
0350     struct net_device *brport_dev = dsa_port_to_bridge_port(dp);
0351     struct net_device *br = dsa_port_bridge_dev_get(dp);
0352     int err;
0353 
0354     err = dsa_port_inherit_brport_flags(dp, extack);
0355     if (err)
0356         return err;
0357 
0358     err = dsa_port_set_state(dp, br_port_get_stp_state(brport_dev), false);
0359     if (err && err != -EOPNOTSUPP)
0360         return err;
0361 
0362     err = dsa_port_vlan_filtering(dp, br_vlan_enabled(br), extack);
0363     if (err && err != -EOPNOTSUPP)
0364         return err;
0365 
0366     err = dsa_port_ageing_time(dp, br_get_ageing_time(br));
0367     if (err && err != -EOPNOTSUPP)
0368         return err;
0369 
0370     return 0;
0371 }
0372 
0373 static void dsa_port_switchdev_unsync_attrs(struct dsa_port *dp,
0374                         struct dsa_bridge bridge)
0375 {
0376     /* Configure the port for standalone mode (no address learning,
0377      * flood everything).
0378      * The bridge only emits SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS events
0379      * when the user requests it through netlink or sysfs, but not
0380      * automatically at port join or leave, so we need to handle resetting
0381      * the brport flags ourselves. But we even prefer it that way, because
0382      * otherwise, some setups might never get the notification they need,
0383      * for example, when a port leaves a LAG that offloads the bridge,
0384      * it becomes standalone, but as far as the bridge is concerned, no
0385      * port ever left.
0386      */
0387     dsa_port_clear_brport_flags(dp);
0388 
0389     /* Port left the bridge, put in BR_STATE_DISABLED by the bridge layer,
0390      * so allow it to be in BR_STATE_FORWARDING to be kept functional
0391      */
0392     dsa_port_set_state_now(dp, BR_STATE_FORWARDING, true);
0393 
0394     dsa_port_reset_vlan_filtering(dp, bridge);
0395 
0396     /* Ageing time may be global to the switch chip, so don't change it
0397      * here because we have no good reason (or value) to change it to.
0398      */
0399 }
0400 
0401 static int dsa_port_bridge_create(struct dsa_port *dp,
0402                   struct net_device *br,
0403                   struct netlink_ext_ack *extack)
0404 {
0405     struct dsa_switch *ds = dp->ds;
0406     struct dsa_bridge *bridge;
0407 
0408     bridge = dsa_tree_bridge_find(ds->dst, br);
0409     if (bridge) {
0410         refcount_inc(&bridge->refcount);
0411         dp->bridge = bridge;
0412         return 0;
0413     }
0414 
0415     bridge = kzalloc(sizeof(*bridge), GFP_KERNEL);
0416     if (!bridge)
0417         return -ENOMEM;
0418 
0419     refcount_set(&bridge->refcount, 1);
0420 
0421     bridge->dev = br;
0422 
0423     bridge->num = dsa_bridge_num_get(br, ds->max_num_bridges);
0424     if (ds->max_num_bridges && !bridge->num) {
0425         NL_SET_ERR_MSG_MOD(extack,
0426                    "Range of offloadable bridges exceeded");
0427         kfree(bridge);
0428         return -EOPNOTSUPP;
0429     }
0430 
0431     dp->bridge = bridge;
0432 
0433     return 0;
0434 }
0435 
0436 static void dsa_port_bridge_destroy(struct dsa_port *dp,
0437                     const struct net_device *br)
0438 {
0439     struct dsa_bridge *bridge = dp->bridge;
0440 
0441     dp->bridge = NULL;
0442 
0443     if (!refcount_dec_and_test(&bridge->refcount))
0444         return;
0445 
0446     if (bridge->num)
0447         dsa_bridge_num_put(br, bridge->num);
0448 
0449     kfree(bridge);
0450 }
0451 
0452 static bool dsa_port_supports_mst(struct dsa_port *dp)
0453 {
0454     struct dsa_switch *ds = dp->ds;
0455 
0456     return ds->ops->vlan_msti_set &&
0457         ds->ops->port_mst_state_set &&
0458         ds->ops->port_vlan_fast_age &&
0459         dsa_port_can_configure_learning(dp);
0460 }
0461 
0462 int dsa_port_bridge_join(struct dsa_port *dp, struct net_device *br,
0463              struct netlink_ext_ack *extack)
0464 {
0465     struct dsa_notifier_bridge_info info = {
0466         .dp = dp,
0467         .extack = extack,
0468     };
0469     struct net_device *dev = dp->slave;
0470     struct net_device *brport_dev;
0471     int err;
0472 
0473     if (br_mst_enabled(br) && !dsa_port_supports_mst(dp))
0474         return -EOPNOTSUPP;
0475 
0476     /* Here the interface is already bridged. Reflect the current
0477      * configuration so that drivers can program their chips accordingly.
0478      */
0479     err = dsa_port_bridge_create(dp, br, extack);
0480     if (err)
0481         return err;
0482 
0483     brport_dev = dsa_port_to_bridge_port(dp);
0484 
0485     info.bridge = *dp->bridge;
0486     err = dsa_broadcast(DSA_NOTIFIER_BRIDGE_JOIN, &info);
0487     if (err)
0488         goto out_rollback;
0489 
0490     /* Drivers which support bridge TX forwarding should set this */
0491     dp->bridge->tx_fwd_offload = info.tx_fwd_offload;
0492 
0493     err = switchdev_bridge_port_offload(brport_dev, dev, dp,
0494                         &dsa_slave_switchdev_notifier,
0495                         &dsa_slave_switchdev_blocking_notifier,
0496                         dp->bridge->tx_fwd_offload, extack);
0497     if (err)
0498         goto out_rollback_unbridge;
0499 
0500     err = dsa_port_switchdev_sync_attrs(dp, extack);
0501     if (err)
0502         goto out_rollback_unoffload;
0503 
0504     return 0;
0505 
0506 out_rollback_unoffload:
0507     switchdev_bridge_port_unoffload(brport_dev, dp,
0508                     &dsa_slave_switchdev_notifier,
0509                     &dsa_slave_switchdev_blocking_notifier);
0510     dsa_flush_workqueue();
0511 out_rollback_unbridge:
0512     dsa_broadcast(DSA_NOTIFIER_BRIDGE_LEAVE, &info);
0513 out_rollback:
0514     dsa_port_bridge_destroy(dp, br);
0515     return err;
0516 }
0517 
0518 void dsa_port_pre_bridge_leave(struct dsa_port *dp, struct net_device *br)
0519 {
0520     struct net_device *brport_dev = dsa_port_to_bridge_port(dp);
0521 
0522     /* Don't try to unoffload something that is not offloaded */
0523     if (!brport_dev)
0524         return;
0525 
0526     switchdev_bridge_port_unoffload(brport_dev, dp,
0527                     &dsa_slave_switchdev_notifier,
0528                     &dsa_slave_switchdev_blocking_notifier);
0529 
0530     dsa_flush_workqueue();
0531 }
0532 
0533 void dsa_port_bridge_leave(struct dsa_port *dp, struct net_device *br)
0534 {
0535     struct dsa_notifier_bridge_info info = {
0536         .dp = dp,
0537     };
0538     int err;
0539 
0540     /* If the port could not be offloaded to begin with, then
0541      * there is nothing to do.
0542      */
0543     if (!dp->bridge)
0544         return;
0545 
0546     info.bridge = *dp->bridge;
0547 
0548     /* Here the port is already unbridged. Reflect the current configuration
0549      * so that drivers can program their chips accordingly.
0550      */
0551     dsa_port_bridge_destroy(dp, br);
0552 
0553     err = dsa_broadcast(DSA_NOTIFIER_BRIDGE_LEAVE, &info);
0554     if (err)
0555         dev_err(dp->ds->dev,
0556             "port %d failed to notify DSA_NOTIFIER_BRIDGE_LEAVE: %pe\n",
0557             dp->index, ERR_PTR(err));
0558 
0559     dsa_port_switchdev_unsync_attrs(dp, info.bridge);
0560 }
0561 
0562 int dsa_port_lag_change(struct dsa_port *dp,
0563             struct netdev_lag_lower_state_info *linfo)
0564 {
0565     struct dsa_notifier_lag_info info = {
0566         .dp = dp,
0567     };
0568     bool tx_enabled;
0569 
0570     if (!dp->lag)
0571         return 0;
0572 
0573     /* On statically configured aggregates (e.g. loadbalance
0574      * without LACP) ports will always be tx_enabled, even if the
0575      * link is down. Thus we require both link_up and tx_enabled
0576      * in order to include it in the tx set.
0577      */
0578     tx_enabled = linfo->link_up && linfo->tx_enabled;
0579 
0580     if (tx_enabled == dp->lag_tx_enabled)
0581         return 0;
0582 
0583     dp->lag_tx_enabled = tx_enabled;
0584 
0585     return dsa_port_notify(dp, DSA_NOTIFIER_LAG_CHANGE, &info);
0586 }
0587 
0588 static int dsa_port_lag_create(struct dsa_port *dp,
0589                    struct net_device *lag_dev)
0590 {
0591     struct dsa_switch *ds = dp->ds;
0592     struct dsa_lag *lag;
0593 
0594     lag = dsa_tree_lag_find(ds->dst, lag_dev);
0595     if (lag) {
0596         refcount_inc(&lag->refcount);
0597         dp->lag = lag;
0598         return 0;
0599     }
0600 
0601     lag = kzalloc(sizeof(*lag), GFP_KERNEL);
0602     if (!lag)
0603         return -ENOMEM;
0604 
0605     refcount_set(&lag->refcount, 1);
0606     mutex_init(&lag->fdb_lock);
0607     INIT_LIST_HEAD(&lag->fdbs);
0608     lag->dev = lag_dev;
0609     dsa_lag_map(ds->dst, lag);
0610     dp->lag = lag;
0611 
0612     return 0;
0613 }
0614 
0615 static void dsa_port_lag_destroy(struct dsa_port *dp)
0616 {
0617     struct dsa_lag *lag = dp->lag;
0618 
0619     dp->lag = NULL;
0620     dp->lag_tx_enabled = false;
0621 
0622     if (!refcount_dec_and_test(&lag->refcount))
0623         return;
0624 
0625     WARN_ON(!list_empty(&lag->fdbs));
0626     dsa_lag_unmap(dp->ds->dst, lag);
0627     kfree(lag);
0628 }
0629 
0630 int dsa_port_lag_join(struct dsa_port *dp, struct net_device *lag_dev,
0631               struct netdev_lag_upper_info *uinfo,
0632               struct netlink_ext_ack *extack)
0633 {
0634     struct dsa_notifier_lag_info info = {
0635         .dp = dp,
0636         .info = uinfo,
0637     };
0638     struct net_device *bridge_dev;
0639     int err;
0640 
0641     err = dsa_port_lag_create(dp, lag_dev);
0642     if (err)
0643         goto err_lag_create;
0644 
0645     info.lag = *dp->lag;
0646     err = dsa_port_notify(dp, DSA_NOTIFIER_LAG_JOIN, &info);
0647     if (err)
0648         goto err_lag_join;
0649 
0650     bridge_dev = netdev_master_upper_dev_get(lag_dev);
0651     if (!bridge_dev || !netif_is_bridge_master(bridge_dev))
0652         return 0;
0653 
0654     err = dsa_port_bridge_join(dp, bridge_dev, extack);
0655     if (err)
0656         goto err_bridge_join;
0657 
0658     return 0;
0659 
0660 err_bridge_join:
0661     dsa_port_notify(dp, DSA_NOTIFIER_LAG_LEAVE, &info);
0662 err_lag_join:
0663     dsa_port_lag_destroy(dp);
0664 err_lag_create:
0665     return err;
0666 }
0667 
0668 void dsa_port_pre_lag_leave(struct dsa_port *dp, struct net_device *lag_dev)
0669 {
0670     struct net_device *br = dsa_port_bridge_dev_get(dp);
0671 
0672     if (br)
0673         dsa_port_pre_bridge_leave(dp, br);
0674 }
0675 
0676 void dsa_port_lag_leave(struct dsa_port *dp, struct net_device *lag_dev)
0677 {
0678     struct net_device *br = dsa_port_bridge_dev_get(dp);
0679     struct dsa_notifier_lag_info info = {
0680         .dp = dp,
0681     };
0682     int err;
0683 
0684     if (!dp->lag)
0685         return;
0686 
0687     /* Port might have been part of a LAG that in turn was
0688      * attached to a bridge.
0689      */
0690     if (br)
0691         dsa_port_bridge_leave(dp, br);
0692 
0693     info.lag = *dp->lag;
0694 
0695     dsa_port_lag_destroy(dp);
0696 
0697     err = dsa_port_notify(dp, DSA_NOTIFIER_LAG_LEAVE, &info);
0698     if (err)
0699         dev_err(dp->ds->dev,
0700             "port %d failed to notify DSA_NOTIFIER_LAG_LEAVE: %pe\n",
0701             dp->index, ERR_PTR(err));
0702 }
0703 
0704 /* Must be called under rcu_read_lock() */
0705 static bool dsa_port_can_apply_vlan_filtering(struct dsa_port *dp,
0706                           bool vlan_filtering,
0707                           struct netlink_ext_ack *extack)
0708 {
0709     struct dsa_switch *ds = dp->ds;
0710     struct dsa_port *other_dp;
0711     int err;
0712 
0713     /* VLAN awareness was off, so the question is "can we turn it on".
0714      * We may have had 8021q uppers, those need to go. Make sure we don't
0715      * enter an inconsistent state: deny changing the VLAN awareness state
0716      * as long as we have 8021q uppers.
0717      */
0718     if (vlan_filtering && dsa_port_is_user(dp)) {
0719         struct net_device *br = dsa_port_bridge_dev_get(dp);
0720         struct net_device *upper_dev, *slave = dp->slave;
0721         struct list_head *iter;
0722 
0723         netdev_for_each_upper_dev_rcu(slave, upper_dev, iter) {
0724             struct bridge_vlan_info br_info;
0725             u16 vid;
0726 
0727             if (!is_vlan_dev(upper_dev))
0728                 continue;
0729 
0730             vid = vlan_dev_vlan_id(upper_dev);
0731 
0732             /* br_vlan_get_info() returns -EINVAL or -ENOENT if the
0733              * device, respectively the VID is not found, returning
0734              * 0 means success, which is a failure for us here.
0735              */
0736             err = br_vlan_get_info(br, vid, &br_info);
0737             if (err == 0) {
0738                 NL_SET_ERR_MSG_MOD(extack,
0739                            "Must first remove VLAN uppers having VIDs also present in bridge");
0740                 return false;
0741             }
0742         }
0743     }
0744 
0745     if (!ds->vlan_filtering_is_global)
0746         return true;
0747 
0748     /* For cases where enabling/disabling VLAN awareness is global to the
0749      * switch, we need to handle the case where multiple bridges span
0750      * different ports of the same switch device and one of them has a
0751      * different setting than what is being requested.
0752      */
0753     dsa_switch_for_each_port(other_dp, ds) {
0754         struct net_device *other_br = dsa_port_bridge_dev_get(other_dp);
0755 
0756         /* If it's the same bridge, it also has same
0757          * vlan_filtering setting => no need to check
0758          */
0759         if (!other_br || other_br == dsa_port_bridge_dev_get(dp))
0760             continue;
0761 
0762         if (br_vlan_enabled(other_br) != vlan_filtering) {
0763             NL_SET_ERR_MSG_MOD(extack,
0764                        "VLAN filtering is a global setting");
0765             return false;
0766         }
0767     }
0768     return true;
0769 }
0770 
0771 int dsa_port_vlan_filtering(struct dsa_port *dp, bool vlan_filtering,
0772                 struct netlink_ext_ack *extack)
0773 {
0774     bool old_vlan_filtering = dsa_port_is_vlan_filtering(dp);
0775     struct dsa_switch *ds = dp->ds;
0776     bool apply;
0777     int err;
0778 
0779     if (!ds->ops->port_vlan_filtering)
0780         return -EOPNOTSUPP;
0781 
0782     /* We are called from dsa_slave_switchdev_blocking_event(),
0783      * which is not under rcu_read_lock(), unlike
0784      * dsa_slave_switchdev_event().
0785      */
0786     rcu_read_lock();
0787     apply = dsa_port_can_apply_vlan_filtering(dp, vlan_filtering, extack);
0788     rcu_read_unlock();
0789     if (!apply)
0790         return -EINVAL;
0791 
0792     if (dsa_port_is_vlan_filtering(dp) == vlan_filtering)
0793         return 0;
0794 
0795     err = ds->ops->port_vlan_filtering(ds, dp->index, vlan_filtering,
0796                        extack);
0797     if (err)
0798         return err;
0799 
0800     if (ds->vlan_filtering_is_global) {
0801         struct dsa_port *other_dp;
0802 
0803         ds->vlan_filtering = vlan_filtering;
0804 
0805         dsa_switch_for_each_user_port(other_dp, ds) {
0806             struct net_device *slave = other_dp->slave;
0807 
0808             /* We might be called in the unbind path, so not
0809              * all slave devices might still be registered.
0810              */
0811             if (!slave)
0812                 continue;
0813 
0814             err = dsa_slave_manage_vlan_filtering(slave,
0815                                   vlan_filtering);
0816             if (err)
0817                 goto restore;
0818         }
0819     } else {
0820         dp->vlan_filtering = vlan_filtering;
0821 
0822         err = dsa_slave_manage_vlan_filtering(dp->slave,
0823                               vlan_filtering);
0824         if (err)
0825             goto restore;
0826     }
0827 
0828     return 0;
0829 
0830 restore:
0831     ds->ops->port_vlan_filtering(ds, dp->index, old_vlan_filtering, NULL);
0832 
0833     if (ds->vlan_filtering_is_global)
0834         ds->vlan_filtering = old_vlan_filtering;
0835     else
0836         dp->vlan_filtering = old_vlan_filtering;
0837 
0838     return err;
0839 }
0840 
0841 /* This enforces legacy behavior for switch drivers which assume they can't
0842  * receive VLAN configuration when enslaved to a bridge with vlan_filtering=0
0843  */
0844 bool dsa_port_skip_vlan_configuration(struct dsa_port *dp)
0845 {
0846     struct net_device *br = dsa_port_bridge_dev_get(dp);
0847     struct dsa_switch *ds = dp->ds;
0848 
0849     if (!br)
0850         return false;
0851 
0852     return !ds->configure_vlan_while_not_filtering && !br_vlan_enabled(br);
0853 }
0854 
0855 int dsa_port_ageing_time(struct dsa_port *dp, clock_t ageing_clock)
0856 {
0857     unsigned long ageing_jiffies = clock_t_to_jiffies(ageing_clock);
0858     unsigned int ageing_time = jiffies_to_msecs(ageing_jiffies);
0859     struct dsa_notifier_ageing_time_info info;
0860     int err;
0861 
0862     info.ageing_time = ageing_time;
0863 
0864     err = dsa_port_notify(dp, DSA_NOTIFIER_AGEING_TIME, &info);
0865     if (err)
0866         return err;
0867 
0868     dp->ageing_time = ageing_time;
0869 
0870     return 0;
0871 }
0872 
0873 int dsa_port_mst_enable(struct dsa_port *dp, bool on,
0874             struct netlink_ext_ack *extack)
0875 {
0876     if (on && !dsa_port_supports_mst(dp)) {
0877         NL_SET_ERR_MSG_MOD(extack, "Hardware does not support MST");
0878         return -EINVAL;
0879     }
0880 
0881     return 0;
0882 }
0883 
0884 int dsa_port_pre_bridge_flags(const struct dsa_port *dp,
0885                   struct switchdev_brport_flags flags,
0886                   struct netlink_ext_ack *extack)
0887 {
0888     struct dsa_switch *ds = dp->ds;
0889 
0890     if (!ds->ops->port_pre_bridge_flags)
0891         return -EINVAL;
0892 
0893     return ds->ops->port_pre_bridge_flags(ds, dp->index, flags, extack);
0894 }
0895 
0896 int dsa_port_bridge_flags(struct dsa_port *dp,
0897               struct switchdev_brport_flags flags,
0898               struct netlink_ext_ack *extack)
0899 {
0900     struct dsa_switch *ds = dp->ds;
0901     int err;
0902 
0903     if (!ds->ops->port_bridge_flags)
0904         return -EOPNOTSUPP;
0905 
0906     err = ds->ops->port_bridge_flags(ds, dp->index, flags, extack);
0907     if (err)
0908         return err;
0909 
0910     if (flags.mask & BR_LEARNING) {
0911         bool learning = flags.val & BR_LEARNING;
0912 
0913         if (learning == dp->learning)
0914             return 0;
0915 
0916         if ((dp->learning && !learning) &&
0917             (dp->stp_state == BR_STATE_LEARNING ||
0918              dp->stp_state == BR_STATE_FORWARDING))
0919             dsa_port_fast_age(dp);
0920 
0921         dp->learning = learning;
0922     }
0923 
0924     return 0;
0925 }
0926 
0927 void dsa_port_set_host_flood(struct dsa_port *dp, bool uc, bool mc)
0928 {
0929     struct dsa_switch *ds = dp->ds;
0930 
0931     if (ds->ops->port_set_host_flood)
0932         ds->ops->port_set_host_flood(ds, dp->index, uc, mc);
0933 }
0934 
0935 int dsa_port_vlan_msti(struct dsa_port *dp,
0936                const struct switchdev_vlan_msti *msti)
0937 {
0938     struct dsa_switch *ds = dp->ds;
0939 
0940     if (!ds->ops->vlan_msti_set)
0941         return -EOPNOTSUPP;
0942 
0943     return ds->ops->vlan_msti_set(ds, *dp->bridge, msti);
0944 }
0945 
0946 int dsa_port_mtu_change(struct dsa_port *dp, int new_mtu)
0947 {
0948     struct dsa_notifier_mtu_info info = {
0949         .dp = dp,
0950         .mtu = new_mtu,
0951     };
0952 
0953     return dsa_port_notify(dp, DSA_NOTIFIER_MTU, &info);
0954 }
0955 
0956 int dsa_port_fdb_add(struct dsa_port *dp, const unsigned char *addr,
0957              u16 vid)
0958 {
0959     struct dsa_notifier_fdb_info info = {
0960         .dp = dp,
0961         .addr = addr,
0962         .vid = vid,
0963         .db = {
0964             .type = DSA_DB_BRIDGE,
0965             .bridge = *dp->bridge,
0966         },
0967     };
0968 
0969     /* Refcounting takes bridge.num as a key, and should be global for all
0970      * bridges in the absence of FDB isolation, and per bridge otherwise.
0971      * Force the bridge.num to zero here in the absence of FDB isolation.
0972      */
0973     if (!dp->ds->fdb_isolation)
0974         info.db.bridge.num = 0;
0975 
0976     return dsa_port_notify(dp, DSA_NOTIFIER_FDB_ADD, &info);
0977 }
0978 
0979 int dsa_port_fdb_del(struct dsa_port *dp, const unsigned char *addr,
0980              u16 vid)
0981 {
0982     struct dsa_notifier_fdb_info info = {
0983         .dp = dp,
0984         .addr = addr,
0985         .vid = vid,
0986         .db = {
0987             .type = DSA_DB_BRIDGE,
0988             .bridge = *dp->bridge,
0989         },
0990     };
0991 
0992     if (!dp->ds->fdb_isolation)
0993         info.db.bridge.num = 0;
0994 
0995     return dsa_port_notify(dp, DSA_NOTIFIER_FDB_DEL, &info);
0996 }
0997 
0998 static int dsa_port_host_fdb_add(struct dsa_port *dp,
0999                  const unsigned char *addr, u16 vid,
1000                  struct dsa_db db)
1001 {
1002     struct dsa_notifier_fdb_info info = {
1003         .dp = dp,
1004         .addr = addr,
1005         .vid = vid,
1006         .db = db,
1007     };
1008 
1009     if (!dp->ds->fdb_isolation)
1010         info.db.bridge.num = 0;
1011 
1012     return dsa_port_notify(dp, DSA_NOTIFIER_HOST_FDB_ADD, &info);
1013 }
1014 
1015 int dsa_port_standalone_host_fdb_add(struct dsa_port *dp,
1016                      const unsigned char *addr, u16 vid)
1017 {
1018     struct dsa_db db = {
1019         .type = DSA_DB_PORT,
1020         .dp = dp,
1021     };
1022 
1023     return dsa_port_host_fdb_add(dp, addr, vid, db);
1024 }
1025 
1026 int dsa_port_bridge_host_fdb_add(struct dsa_port *dp,
1027                  const unsigned char *addr, u16 vid)
1028 {
1029     struct dsa_port *cpu_dp = dp->cpu_dp;
1030     struct dsa_db db = {
1031         .type = DSA_DB_BRIDGE,
1032         .bridge = *dp->bridge,
1033     };
1034     int err;
1035 
1036     /* Avoid a call to __dev_set_promiscuity() on the master, which
1037      * requires rtnl_lock(), since we can't guarantee that is held here,
1038      * and we can't take it either.
1039      */
1040     if (cpu_dp->master->priv_flags & IFF_UNICAST_FLT) {
1041         err = dev_uc_add(cpu_dp->master, addr);
1042         if (err)
1043             return err;
1044     }
1045 
1046     return dsa_port_host_fdb_add(dp, addr, vid, db);
1047 }
1048 
1049 static int dsa_port_host_fdb_del(struct dsa_port *dp,
1050                  const unsigned char *addr, u16 vid,
1051                  struct dsa_db db)
1052 {
1053     struct dsa_notifier_fdb_info info = {
1054         .dp = dp,
1055         .addr = addr,
1056         .vid = vid,
1057         .db = db,
1058     };
1059 
1060     if (!dp->ds->fdb_isolation)
1061         info.db.bridge.num = 0;
1062 
1063     return dsa_port_notify(dp, DSA_NOTIFIER_HOST_FDB_DEL, &info);
1064 }
1065 
1066 int dsa_port_standalone_host_fdb_del(struct dsa_port *dp,
1067                      const unsigned char *addr, u16 vid)
1068 {
1069     struct dsa_db db = {
1070         .type = DSA_DB_PORT,
1071         .dp = dp,
1072     };
1073 
1074     return dsa_port_host_fdb_del(dp, addr, vid, db);
1075 }
1076 
1077 int dsa_port_bridge_host_fdb_del(struct dsa_port *dp,
1078                  const unsigned char *addr, u16 vid)
1079 {
1080     struct dsa_port *cpu_dp = dp->cpu_dp;
1081     struct dsa_db db = {
1082         .type = DSA_DB_BRIDGE,
1083         .bridge = *dp->bridge,
1084     };
1085     int err;
1086 
1087     if (cpu_dp->master->priv_flags & IFF_UNICAST_FLT) {
1088         err = dev_uc_del(cpu_dp->master, addr);
1089         if (err)
1090             return err;
1091     }
1092 
1093     return dsa_port_host_fdb_del(dp, addr, vid, db);
1094 }
1095 
1096 int dsa_port_lag_fdb_add(struct dsa_port *dp, const unsigned char *addr,
1097              u16 vid)
1098 {
1099     struct dsa_notifier_lag_fdb_info info = {
1100         .lag = dp->lag,
1101         .addr = addr,
1102         .vid = vid,
1103         .db = {
1104             .type = DSA_DB_BRIDGE,
1105             .bridge = *dp->bridge,
1106         },
1107     };
1108 
1109     if (!dp->ds->fdb_isolation)
1110         info.db.bridge.num = 0;
1111 
1112     return dsa_port_notify(dp, DSA_NOTIFIER_LAG_FDB_ADD, &info);
1113 }
1114 
1115 int dsa_port_lag_fdb_del(struct dsa_port *dp, const unsigned char *addr,
1116              u16 vid)
1117 {
1118     struct dsa_notifier_lag_fdb_info info = {
1119         .lag = dp->lag,
1120         .addr = addr,
1121         .vid = vid,
1122         .db = {
1123             .type = DSA_DB_BRIDGE,
1124             .bridge = *dp->bridge,
1125         },
1126     };
1127 
1128     if (!dp->ds->fdb_isolation)
1129         info.db.bridge.num = 0;
1130 
1131     return dsa_port_notify(dp, DSA_NOTIFIER_LAG_FDB_DEL, &info);
1132 }
1133 
1134 int dsa_port_fdb_dump(struct dsa_port *dp, dsa_fdb_dump_cb_t *cb, void *data)
1135 {
1136     struct dsa_switch *ds = dp->ds;
1137     int port = dp->index;
1138 
1139     if (!ds->ops->port_fdb_dump)
1140         return -EOPNOTSUPP;
1141 
1142     return ds->ops->port_fdb_dump(ds, port, cb, data);
1143 }
1144 
1145 int dsa_port_mdb_add(const struct dsa_port *dp,
1146              const struct switchdev_obj_port_mdb *mdb)
1147 {
1148     struct dsa_notifier_mdb_info info = {
1149         .dp = dp,
1150         .mdb = mdb,
1151         .db = {
1152             .type = DSA_DB_BRIDGE,
1153             .bridge = *dp->bridge,
1154         },
1155     };
1156 
1157     if (!dp->ds->fdb_isolation)
1158         info.db.bridge.num = 0;
1159 
1160     return dsa_port_notify(dp, DSA_NOTIFIER_MDB_ADD, &info);
1161 }
1162 
1163 int dsa_port_mdb_del(const struct dsa_port *dp,
1164              const struct switchdev_obj_port_mdb *mdb)
1165 {
1166     struct dsa_notifier_mdb_info info = {
1167         .dp = dp,
1168         .mdb = mdb,
1169         .db = {
1170             .type = DSA_DB_BRIDGE,
1171             .bridge = *dp->bridge,
1172         },
1173     };
1174 
1175     if (!dp->ds->fdb_isolation)
1176         info.db.bridge.num = 0;
1177 
1178     return dsa_port_notify(dp, DSA_NOTIFIER_MDB_DEL, &info);
1179 }
1180 
1181 static int dsa_port_host_mdb_add(const struct dsa_port *dp,
1182                  const struct switchdev_obj_port_mdb *mdb,
1183                  struct dsa_db db)
1184 {
1185     struct dsa_notifier_mdb_info info = {
1186         .dp = dp,
1187         .mdb = mdb,
1188         .db = db,
1189     };
1190 
1191     if (!dp->ds->fdb_isolation)
1192         info.db.bridge.num = 0;
1193 
1194     return dsa_port_notify(dp, DSA_NOTIFIER_HOST_MDB_ADD, &info);
1195 }
1196 
1197 int dsa_port_standalone_host_mdb_add(const struct dsa_port *dp,
1198                      const struct switchdev_obj_port_mdb *mdb)
1199 {
1200     struct dsa_db db = {
1201         .type = DSA_DB_PORT,
1202         .dp = dp,
1203     };
1204 
1205     return dsa_port_host_mdb_add(dp, mdb, db);
1206 }
1207 
1208 int dsa_port_bridge_host_mdb_add(const struct dsa_port *dp,
1209                  const struct switchdev_obj_port_mdb *mdb)
1210 {
1211     struct dsa_port *cpu_dp = dp->cpu_dp;
1212     struct dsa_db db = {
1213         .type = DSA_DB_BRIDGE,
1214         .bridge = *dp->bridge,
1215     };
1216     int err;
1217 
1218     err = dev_mc_add(cpu_dp->master, mdb->addr);
1219     if (err)
1220         return err;
1221 
1222     return dsa_port_host_mdb_add(dp, mdb, db);
1223 }
1224 
1225 static int dsa_port_host_mdb_del(const struct dsa_port *dp,
1226                  const struct switchdev_obj_port_mdb *mdb,
1227                  struct dsa_db db)
1228 {
1229     struct dsa_notifier_mdb_info info = {
1230         .dp = dp,
1231         .mdb = mdb,
1232         .db = db,
1233     };
1234 
1235     if (!dp->ds->fdb_isolation)
1236         info.db.bridge.num = 0;
1237 
1238     return dsa_port_notify(dp, DSA_NOTIFIER_HOST_MDB_DEL, &info);
1239 }
1240 
1241 int dsa_port_standalone_host_mdb_del(const struct dsa_port *dp,
1242                      const struct switchdev_obj_port_mdb *mdb)
1243 {
1244     struct dsa_db db = {
1245         .type = DSA_DB_PORT,
1246         .dp = dp,
1247     };
1248 
1249     return dsa_port_host_mdb_del(dp, mdb, db);
1250 }
1251 
1252 int dsa_port_bridge_host_mdb_del(const struct dsa_port *dp,
1253                  const struct switchdev_obj_port_mdb *mdb)
1254 {
1255     struct dsa_port *cpu_dp = dp->cpu_dp;
1256     struct dsa_db db = {
1257         .type = DSA_DB_BRIDGE,
1258         .bridge = *dp->bridge,
1259     };
1260     int err;
1261 
1262     err = dev_mc_del(cpu_dp->master, mdb->addr);
1263     if (err)
1264         return err;
1265 
1266     return dsa_port_host_mdb_del(dp, mdb, db);
1267 }
1268 
1269 int dsa_port_vlan_add(struct dsa_port *dp,
1270               const struct switchdev_obj_port_vlan *vlan,
1271               struct netlink_ext_ack *extack)
1272 {
1273     struct dsa_notifier_vlan_info info = {
1274         .dp = dp,
1275         .vlan = vlan,
1276         .extack = extack,
1277     };
1278 
1279     return dsa_port_notify(dp, DSA_NOTIFIER_VLAN_ADD, &info);
1280 }
1281 
1282 int dsa_port_vlan_del(struct dsa_port *dp,
1283               const struct switchdev_obj_port_vlan *vlan)
1284 {
1285     struct dsa_notifier_vlan_info info = {
1286         .dp = dp,
1287         .vlan = vlan,
1288     };
1289 
1290     return dsa_port_notify(dp, DSA_NOTIFIER_VLAN_DEL, &info);
1291 }
1292 
1293 int dsa_port_host_vlan_add(struct dsa_port *dp,
1294                const struct switchdev_obj_port_vlan *vlan,
1295                struct netlink_ext_ack *extack)
1296 {
1297     struct dsa_notifier_vlan_info info = {
1298         .dp = dp,
1299         .vlan = vlan,
1300         .extack = extack,
1301     };
1302     struct dsa_port *cpu_dp = dp->cpu_dp;
1303     int err;
1304 
1305     err = dsa_port_notify(dp, DSA_NOTIFIER_HOST_VLAN_ADD, &info);
1306     if (err && err != -EOPNOTSUPP)
1307         return err;
1308 
1309     vlan_vid_add(cpu_dp->master, htons(ETH_P_8021Q), vlan->vid);
1310 
1311     return err;
1312 }
1313 
1314 int dsa_port_host_vlan_del(struct dsa_port *dp,
1315                const struct switchdev_obj_port_vlan *vlan)
1316 {
1317     struct dsa_notifier_vlan_info info = {
1318         .dp = dp,
1319         .vlan = vlan,
1320     };
1321     struct dsa_port *cpu_dp = dp->cpu_dp;
1322     int err;
1323 
1324     err = dsa_port_notify(dp, DSA_NOTIFIER_HOST_VLAN_DEL, &info);
1325     if (err && err != -EOPNOTSUPP)
1326         return err;
1327 
1328     vlan_vid_del(cpu_dp->master, htons(ETH_P_8021Q), vlan->vid);
1329 
1330     return err;
1331 }
1332 
1333 int dsa_port_mrp_add(const struct dsa_port *dp,
1334              const struct switchdev_obj_mrp *mrp)
1335 {
1336     struct dsa_switch *ds = dp->ds;
1337 
1338     if (!ds->ops->port_mrp_add)
1339         return -EOPNOTSUPP;
1340 
1341     return ds->ops->port_mrp_add(ds, dp->index, mrp);
1342 }
1343 
1344 int dsa_port_mrp_del(const struct dsa_port *dp,
1345              const struct switchdev_obj_mrp *mrp)
1346 {
1347     struct dsa_switch *ds = dp->ds;
1348 
1349     if (!ds->ops->port_mrp_del)
1350         return -EOPNOTSUPP;
1351 
1352     return ds->ops->port_mrp_del(ds, dp->index, mrp);
1353 }
1354 
1355 int dsa_port_mrp_add_ring_role(const struct dsa_port *dp,
1356                    const struct switchdev_obj_ring_role_mrp *mrp)
1357 {
1358     struct dsa_switch *ds = dp->ds;
1359 
1360     if (!ds->ops->port_mrp_add_ring_role)
1361         return -EOPNOTSUPP;
1362 
1363     return ds->ops->port_mrp_add_ring_role(ds, dp->index, mrp);
1364 }
1365 
1366 int dsa_port_mrp_del_ring_role(const struct dsa_port *dp,
1367                    const struct switchdev_obj_ring_role_mrp *mrp)
1368 {
1369     struct dsa_switch *ds = dp->ds;
1370 
1371     if (!ds->ops->port_mrp_del_ring_role)
1372         return -EOPNOTSUPP;
1373 
1374     return ds->ops->port_mrp_del_ring_role(ds, dp->index, mrp);
1375 }
1376 
1377 void dsa_port_set_tag_protocol(struct dsa_port *cpu_dp,
1378                    const struct dsa_device_ops *tag_ops)
1379 {
1380     cpu_dp->rcv = tag_ops->rcv;
1381     cpu_dp->tag_ops = tag_ops;
1382 }
1383 
1384 static struct phy_device *dsa_port_get_phy_device(struct dsa_port *dp)
1385 {
1386     struct device_node *phy_dn;
1387     struct phy_device *phydev;
1388 
1389     phy_dn = of_parse_phandle(dp->dn, "phy-handle", 0);
1390     if (!phy_dn)
1391         return NULL;
1392 
1393     phydev = of_phy_find_device(phy_dn);
1394     if (!phydev) {
1395         of_node_put(phy_dn);
1396         return ERR_PTR(-EPROBE_DEFER);
1397     }
1398 
1399     of_node_put(phy_dn);
1400     return phydev;
1401 }
1402 
1403 static void dsa_port_phylink_validate(struct phylink_config *config,
1404                       unsigned long *supported,
1405                       struct phylink_link_state *state)
1406 {
1407     struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
1408     struct dsa_switch *ds = dp->ds;
1409 
1410     if (!ds->ops->phylink_validate) {
1411         if (config->mac_capabilities)
1412             phylink_generic_validate(config, supported, state);
1413         return;
1414     }
1415 
1416     ds->ops->phylink_validate(ds, dp->index, supported, state);
1417 }
1418 
1419 static void dsa_port_phylink_mac_pcs_get_state(struct phylink_config *config,
1420                            struct phylink_link_state *state)
1421 {
1422     struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
1423     struct dsa_switch *ds = dp->ds;
1424     int err;
1425 
1426     /* Only called for inband modes */
1427     if (!ds->ops->phylink_mac_link_state) {
1428         state->link = 0;
1429         return;
1430     }
1431 
1432     err = ds->ops->phylink_mac_link_state(ds, dp->index, state);
1433     if (err < 0) {
1434         dev_err(ds->dev, "p%d: phylink_mac_link_state() failed: %d\n",
1435             dp->index, err);
1436         state->link = 0;
1437     }
1438 }
1439 
1440 static struct phylink_pcs *
1441 dsa_port_phylink_mac_select_pcs(struct phylink_config *config,
1442                 phy_interface_t interface)
1443 {
1444     struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
1445     struct phylink_pcs *pcs = ERR_PTR(-EOPNOTSUPP);
1446     struct dsa_switch *ds = dp->ds;
1447 
1448     if (ds->ops->phylink_mac_select_pcs)
1449         pcs = ds->ops->phylink_mac_select_pcs(ds, dp->index, interface);
1450 
1451     return pcs;
1452 }
1453 
1454 static void dsa_port_phylink_mac_config(struct phylink_config *config,
1455                     unsigned int mode,
1456                     const struct phylink_link_state *state)
1457 {
1458     struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
1459     struct dsa_switch *ds = dp->ds;
1460 
1461     if (!ds->ops->phylink_mac_config)
1462         return;
1463 
1464     ds->ops->phylink_mac_config(ds, dp->index, mode, state);
1465 }
1466 
1467 static void dsa_port_phylink_mac_an_restart(struct phylink_config *config)
1468 {
1469     struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
1470     struct dsa_switch *ds = dp->ds;
1471 
1472     if (!ds->ops->phylink_mac_an_restart)
1473         return;
1474 
1475     ds->ops->phylink_mac_an_restart(ds, dp->index);
1476 }
1477 
1478 static void dsa_port_phylink_mac_link_down(struct phylink_config *config,
1479                        unsigned int mode,
1480                        phy_interface_t interface)
1481 {
1482     struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
1483     struct phy_device *phydev = NULL;
1484     struct dsa_switch *ds = dp->ds;
1485 
1486     if (dsa_port_is_user(dp))
1487         phydev = dp->slave->phydev;
1488 
1489     if (!ds->ops->phylink_mac_link_down) {
1490         if (ds->ops->adjust_link && phydev)
1491             ds->ops->adjust_link(ds, dp->index, phydev);
1492         return;
1493     }
1494 
1495     ds->ops->phylink_mac_link_down(ds, dp->index, mode, interface);
1496 }
1497 
1498 static void dsa_port_phylink_mac_link_up(struct phylink_config *config,
1499                      struct phy_device *phydev,
1500                      unsigned int mode,
1501                      phy_interface_t interface,
1502                      int speed, int duplex,
1503                      bool tx_pause, bool rx_pause)
1504 {
1505     struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
1506     struct dsa_switch *ds = dp->ds;
1507 
1508     if (!ds->ops->phylink_mac_link_up) {
1509         if (ds->ops->adjust_link && phydev)
1510             ds->ops->adjust_link(ds, dp->index, phydev);
1511         return;
1512     }
1513 
1514     ds->ops->phylink_mac_link_up(ds, dp->index, mode, interface, phydev,
1515                      speed, duplex, tx_pause, rx_pause);
1516 }
1517 
1518 static const struct phylink_mac_ops dsa_port_phylink_mac_ops = {
1519     .validate = dsa_port_phylink_validate,
1520     .mac_select_pcs = dsa_port_phylink_mac_select_pcs,
1521     .mac_pcs_get_state = dsa_port_phylink_mac_pcs_get_state,
1522     .mac_config = dsa_port_phylink_mac_config,
1523     .mac_an_restart = dsa_port_phylink_mac_an_restart,
1524     .mac_link_down = dsa_port_phylink_mac_link_down,
1525     .mac_link_up = dsa_port_phylink_mac_link_up,
1526 };
1527 
1528 int dsa_port_phylink_create(struct dsa_port *dp)
1529 {
1530     struct dsa_switch *ds = dp->ds;
1531     phy_interface_t mode;
1532     int err;
1533 
1534     err = of_get_phy_mode(dp->dn, &mode);
1535     if (err)
1536         mode = PHY_INTERFACE_MODE_NA;
1537 
1538     /* Presence of phylink_mac_link_state or phylink_mac_an_restart is
1539      * an indicator of a legacy phylink driver.
1540      */
1541     if (ds->ops->phylink_mac_link_state ||
1542         ds->ops->phylink_mac_an_restart)
1543         dp->pl_config.legacy_pre_march2020 = true;
1544 
1545     if (ds->ops->phylink_get_caps)
1546         ds->ops->phylink_get_caps(ds, dp->index, &dp->pl_config);
1547 
1548     dp->pl = phylink_create(&dp->pl_config, of_fwnode_handle(dp->dn),
1549                 mode, &dsa_port_phylink_mac_ops);
1550     if (IS_ERR(dp->pl)) {
1551         pr_err("error creating PHYLINK: %ld\n", PTR_ERR(dp->pl));
1552         return PTR_ERR(dp->pl);
1553     }
1554 
1555     return 0;
1556 }
1557 
1558 static int dsa_port_setup_phy_of(struct dsa_port *dp, bool enable)
1559 {
1560     struct dsa_switch *ds = dp->ds;
1561     struct phy_device *phydev;
1562     int port = dp->index;
1563     int err = 0;
1564 
1565     phydev = dsa_port_get_phy_device(dp);
1566     if (!phydev)
1567         return 0;
1568 
1569     if (IS_ERR(phydev))
1570         return PTR_ERR(phydev);
1571 
1572     if (enable) {
1573         err = genphy_resume(phydev);
1574         if (err < 0)
1575             goto err_put_dev;
1576 
1577         err = genphy_read_status(phydev);
1578         if (err < 0)
1579             goto err_put_dev;
1580     } else {
1581         err = genphy_suspend(phydev);
1582         if (err < 0)
1583             goto err_put_dev;
1584     }
1585 
1586     if (ds->ops->adjust_link)
1587         ds->ops->adjust_link(ds, port, phydev);
1588 
1589     dev_dbg(ds->dev, "enabled port's phy: %s", phydev_name(phydev));
1590 
1591 err_put_dev:
1592     put_device(&phydev->mdio.dev);
1593     return err;
1594 }
1595 
1596 static int dsa_port_fixed_link_register_of(struct dsa_port *dp)
1597 {
1598     struct device_node *dn = dp->dn;
1599     struct dsa_switch *ds = dp->ds;
1600     struct phy_device *phydev;
1601     int port = dp->index;
1602     phy_interface_t mode;
1603     int err;
1604 
1605     err = of_phy_register_fixed_link(dn);
1606     if (err) {
1607         dev_err(ds->dev,
1608             "failed to register the fixed PHY of port %d\n",
1609             port);
1610         return err;
1611     }
1612 
1613     phydev = of_phy_find_device(dn);
1614 
1615     err = of_get_phy_mode(dn, &mode);
1616     if (err)
1617         mode = PHY_INTERFACE_MODE_NA;
1618     phydev->interface = mode;
1619 
1620     genphy_read_status(phydev);
1621 
1622     if (ds->ops->adjust_link)
1623         ds->ops->adjust_link(ds, port, phydev);
1624 
1625     put_device(&phydev->mdio.dev);
1626 
1627     return 0;
1628 }
1629 
1630 static int dsa_port_phylink_register(struct dsa_port *dp)
1631 {
1632     struct dsa_switch *ds = dp->ds;
1633     struct device_node *port_dn = dp->dn;
1634     int err;
1635 
1636     dp->pl_config.dev = ds->dev;
1637     dp->pl_config.type = PHYLINK_DEV;
1638 
1639     err = dsa_port_phylink_create(dp);
1640     if (err)
1641         return err;
1642 
1643     err = phylink_of_phy_connect(dp->pl, port_dn, 0);
1644     if (err && err != -ENODEV) {
1645         pr_err("could not attach to PHY: %d\n", err);
1646         goto err_phy_connect;
1647     }
1648 
1649     return 0;
1650 
1651 err_phy_connect:
1652     phylink_destroy(dp->pl);
1653     return err;
1654 }
1655 
1656 int dsa_port_link_register_of(struct dsa_port *dp)
1657 {
1658     struct dsa_switch *ds = dp->ds;
1659     struct device_node *phy_np;
1660     int port = dp->index;
1661 
1662     if (!ds->ops->adjust_link) {
1663         phy_np = of_parse_phandle(dp->dn, "phy-handle", 0);
1664         if (of_phy_is_fixed_link(dp->dn) || phy_np) {
1665             if (ds->ops->phylink_mac_link_down)
1666                 ds->ops->phylink_mac_link_down(ds, port,
1667                     MLO_AN_FIXED, PHY_INTERFACE_MODE_NA);
1668             of_node_put(phy_np);
1669             return dsa_port_phylink_register(dp);
1670         }
1671         of_node_put(phy_np);
1672         return 0;
1673     }
1674 
1675     dev_warn(ds->dev,
1676          "Using legacy PHYLIB callbacks. Please migrate to PHYLINK!\n");
1677 
1678     if (of_phy_is_fixed_link(dp->dn))
1679         return dsa_port_fixed_link_register_of(dp);
1680     else
1681         return dsa_port_setup_phy_of(dp, true);
1682 }
1683 
1684 void dsa_port_link_unregister_of(struct dsa_port *dp)
1685 {
1686     struct dsa_switch *ds = dp->ds;
1687 
1688     if (!ds->ops->adjust_link && dp->pl) {
1689         rtnl_lock();
1690         phylink_disconnect_phy(dp->pl);
1691         rtnl_unlock();
1692         phylink_destroy(dp->pl);
1693         dp->pl = NULL;
1694         return;
1695     }
1696 
1697     if (of_phy_is_fixed_link(dp->dn))
1698         of_phy_deregister_fixed_link(dp->dn);
1699     else
1700         dsa_port_setup_phy_of(dp, false);
1701 }
1702 
1703 int dsa_port_hsr_join(struct dsa_port *dp, struct net_device *hsr)
1704 {
1705     struct dsa_switch *ds = dp->ds;
1706     int err;
1707 
1708     if (!ds->ops->port_hsr_join)
1709         return -EOPNOTSUPP;
1710 
1711     dp->hsr_dev = hsr;
1712 
1713     err = ds->ops->port_hsr_join(ds, dp->index, hsr);
1714     if (err)
1715         dp->hsr_dev = NULL;
1716 
1717     return err;
1718 }
1719 
1720 void dsa_port_hsr_leave(struct dsa_port *dp, struct net_device *hsr)
1721 {
1722     struct dsa_switch *ds = dp->ds;
1723     int err;
1724 
1725     dp->hsr_dev = NULL;
1726 
1727     if (ds->ops->port_hsr_leave) {
1728         err = ds->ops->port_hsr_leave(ds, dp->index, hsr);
1729         if (err)
1730             dev_err(dp->ds->dev,
1731                 "port %d failed to leave HSR %s: %pe\n",
1732                 dp->index, hsr->name, ERR_PTR(err));
1733     }
1734 }
1735 
1736 int dsa_port_tag_8021q_vlan_add(struct dsa_port *dp, u16 vid, bool broadcast)
1737 {
1738     struct dsa_notifier_tag_8021q_vlan_info info = {
1739         .dp = dp,
1740         .vid = vid,
1741     };
1742 
1743     if (broadcast)
1744         return dsa_broadcast(DSA_NOTIFIER_TAG_8021Q_VLAN_ADD, &info);
1745 
1746     return dsa_port_notify(dp, DSA_NOTIFIER_TAG_8021Q_VLAN_ADD, &info);
1747 }
1748 
1749 void dsa_port_tag_8021q_vlan_del(struct dsa_port *dp, u16 vid, bool broadcast)
1750 {
1751     struct dsa_notifier_tag_8021q_vlan_info info = {
1752         .dp = dp,
1753         .vid = vid,
1754     };
1755     int err;
1756 
1757     if (broadcast)
1758         err = dsa_broadcast(DSA_NOTIFIER_TAG_8021Q_VLAN_DEL, &info);
1759     else
1760         err = dsa_port_notify(dp, DSA_NOTIFIER_TAG_8021Q_VLAN_DEL, &info);
1761     if (err)
1762         dev_err(dp->ds->dev,
1763             "port %d failed to notify tag_8021q VLAN %d deletion: %pe\n",
1764             dp->index, vid, ERR_PTR(err));
1765 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!