net/dsa/port.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Handling of a single switch port
   4  *
   5  * Copyright (c) 2017 Savoir-faire Linux Inc.
   6  *      Vivien Didelot <vivien.didelot@savoirfairelinux.com>
   7  */
   8
   9 #include <linux/if_bridge.h>
  10 #include <linux/notifier.h>
  11 #include <linux/of_mdio.h>
  12 #include <linux/of_net.h>
  13
  14 #include "dsa_priv.h"
  15
  16 /**
  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.
  21  *
  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.
  27  */
  28 static int dsa_port_notify(const struct dsa_port *dp, unsigned long e, void *v)
  29 {
  30         return dsa_tree_notify(dp->ds->dst, e, v);
  31 }
  32
  33 static void dsa_port_notify_bridge_fdb_flush(const struct dsa_port *dp)
  34 {
  35         struct net_device *brport_dev = dsa_port_to_bridge_port(dp);
  36         struct switchdev_notifier_fdb_info info = {
  37                 /* flush all VLANs */
  38                 .vid = 0,
  39         };
  40
  41         /* When the port becomes standalone it has already left the bridge.
  42          * Don't notify the bridge in that case.
  43          */
  44         if (!brport_dev)
  45                 return;
  46
  47         call_switchdev_notifiers(SWITCHDEV_FDB_FLUSH_TO_BRIDGE,
  48                                  brport_dev, &info.info, NULL);
  49 }
  50
  51 static void dsa_port_fast_age(const struct dsa_port *dp)
  52 {
  53         struct dsa_switch *ds = dp->ds;
  54
  55         if (!ds->ops->port_fast_age)
  56                 return;
  57
  58         ds->ops->port_fast_age(ds, dp->index);
  59
  60         dsa_port_notify_bridge_fdb_flush(dp);
  61 }
  62
  63 static bool dsa_port_can_configure_learning(struct dsa_port *dp)
  64 {
  65         struct switchdev_brport_flags flags = {
  66                 .mask = BR_LEARNING,
  67         };
  68         struct dsa_switch *ds = dp->ds;
  69         int err;
  70
  71         if (!ds->ops->port_bridge_flags || !ds->ops->port_pre_bridge_flags)
  72                 return false;
  73
  74         err = ds->ops->port_pre_bridge_flags(ds, dp->index, flags, NULL);
  75         return !err;
  76 }
  77
  78 int dsa_port_set_state(struct dsa_port *dp, u8 state, bool do_fast_age)
  79 {
  80         struct dsa_switch *ds = dp->ds;
  81         int port = dp->index;
  82
  83         if (!ds->ops->port_stp_state_set)
  84                 return -EOPNOTSUPP;
  85
  86         ds->ops->port_stp_state_set(ds, port, state);
  87
  88         if (!dsa_port_can_configure_learning(dp) ||
  89             (do_fast_age && dp->learning)) {
  90                 /* Fast age FDB entries or flush appropriate forwarding database
  91                  * for the given port, if we are moving it from Learning or
  92                  * Forwarding state, to Disabled or Blocking or Listening state.
  93                  * Ports that were standalone before the STP state change don't
  94                  * need to fast age the FDB, since address learning is off in
  95                  * standalone mode.
  96                  */
  97
  98                 if ((dp->stp_state == BR_STATE_LEARNING ||
  99                      dp->stp_state == BR_STATE_FORWARDING) &&
 100                     (state == BR_STATE_DISABLED ||
 101                      state == BR_STATE_BLOCKING ||
 102                      state == BR_STATE_LISTENING))
 103                         dsa_port_fast_age(dp);
 104         }
 105
 106         dp->stp_state = state;
 107
 108         return 0;
 109 }
 110
 111 static void dsa_port_set_state_now(struct dsa_port *dp, u8 state,
 112                                    bool do_fast_age)
 113 {
 114         int err;
 115
 116         err = dsa_port_set_state(dp, state, do_fast_age);
 117         if (err)
 118                 pr_err("DSA: failed to set STP state %u (%d)\n", state, err);
 119 }
 120
 121 int dsa_port_enable_rt(struct dsa_port *dp, struct phy_device *phy)
 122 {
 123         struct dsa_switch *ds = dp->ds;
 124         int port = dp->index;
 125         int err;
 126
 127         if (ds->ops->port_enable) {
 128                 err = ds->ops->port_enable(ds, port, phy);
 129                 if (err)
 130                         return err;
 131         }
 132
 133         if (!dp->bridge)
 134                 dsa_port_set_state_now(dp, BR_STATE_FORWARDING, false);
 135
 136         if (dp->pl)
 137                 phylink_start(dp->pl);
 138
 139         return 0;
 140 }
 141
 142 int dsa_port_enable(struct dsa_port *dp, struct phy_device *phy)
 143 {
 144         int err;
 145
 146         rtnl_lock();
 147         err = dsa_port_enable_rt(dp, phy);
 148         rtnl_unlock();
 149
 150         return err;
 151 }
 152
 153 void dsa_port_disable_rt(struct dsa_port *dp)
 154 {
 155         struct dsa_switch *ds = dp->ds;
 156         int port = dp->index;
 157
 158         if (dp->pl)
 159                 phylink_stop(dp->pl);
 160
 161         if (!dp->bridge)
 162                 dsa_port_set_state_now(dp, BR_STATE_DISABLED, false);
 163
 164         if (ds->ops->port_disable)
 165                 ds->ops->port_disable(ds, port);
 166 }
 167
 168 void dsa_port_disable(struct dsa_port *dp)
 169 {
 170         rtnl_lock();
 171         dsa_port_disable_rt(dp);
 172         rtnl_unlock();
 173 }
 174
 175 static int dsa_port_inherit_brport_flags(struct dsa_port *dp,
 176                                          struct netlink_ext_ack *extack)
 177 {
 178         const unsigned long mask = BR_LEARNING | BR_FLOOD | BR_MCAST_FLOOD |
 179                                    BR_BCAST_FLOOD | BR_PORT_LOCKED;
 180         struct net_device *brport_dev = dsa_port_to_bridge_port(dp);
 181         int flag, err;
 182
 183         for_each_set_bit(flag, &mask, 32) {
 184                 struct switchdev_brport_flags flags = {0};
 185
 186                 flags.mask = BIT(flag);
 187
 188                 if (br_port_flag_is_set(brport_dev, BIT(flag)))
 189                         flags.val = BIT(flag);
 190
 191                 err = dsa_port_bridge_flags(dp, flags, extack);
 192                 if (err && err != -EOPNOTSUPP)
 193                         return err;
 194         }
 195
 196         return 0;
 197 }
 198
 199 static void dsa_port_clear_brport_flags(struct dsa_port *dp)
 200 {
 201         const unsigned long val = BR_FLOOD | BR_MCAST_FLOOD | BR_BCAST_FLOOD;
 202         const unsigned long mask = BR_LEARNING | BR_FLOOD | BR_MCAST_FLOOD |
 203                                    BR_BCAST_FLOOD | BR_PORT_LOCKED;
 204         int flag, err;
 205
 206         for_each_set_bit(flag, &mask, 32) {
 207                 struct switchdev_brport_flags flags = {0};
 208
 209                 flags.mask = BIT(flag);
 210                 flags.val = val & BIT(flag);
 211
 212                 err = dsa_port_bridge_flags(dp, flags, NULL);
 213                 if (err && err != -EOPNOTSUPP)
 214                         dev_err(dp->ds->dev,
 215                                 "failed to clear bridge port flag %lu: %pe\n",
 216                                 flags.val, ERR_PTR(err));
 217         }
 218 }
 219
 220 static int dsa_port_switchdev_sync_attrs(struct dsa_port *dp,
 221                                          struct netlink_ext_ack *extack)
 222 {
 223         struct net_device *brport_dev = dsa_port_to_bridge_port(dp);
 224         struct net_device *br = dsa_port_bridge_dev_get(dp);
 225         int err;
 226
 227         err = dsa_port_inherit_brport_flags(dp, extack);
 228         if (err)
 229                 return err;
 230
 231         err = dsa_port_set_state(dp, br_port_get_stp_state(brport_dev), false);
 232         if (err && err != -EOPNOTSUPP)
 233                 return err;
 234
 235         err = dsa_port_vlan_filtering(dp, br_vlan_enabled(br), extack);
 236         if (err && err != -EOPNOTSUPP)
 237                 return err;
 238
 239         err = dsa_port_ageing_time(dp, br_get_ageing_time(br));
 240         if (err && err != -EOPNOTSUPP)
 241                 return err;
 242
 243         return 0;
 244 }
 245
 246 static void dsa_port_switchdev_unsync_attrs(struct dsa_port *dp)
 247 {
 248         /* Configure the port for standalone mode (no address learning,
 249          * flood everything).
 250          * The bridge only emits SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS events
 251          * when the user requests it through netlink or sysfs, but not
 252          * automatically at port join or leave, so we need to handle resetting
 253          * the brport flags ourselves. But we even prefer it that way, because
 254          * otherwise, some setups might never get the notification they need,
 255          * for example, when a port leaves a LAG that offloads the bridge,
 256          * it becomes standalone, but as far as the bridge is concerned, no
 257          * port ever left.
 258          */
 259         dsa_port_clear_brport_flags(dp);
 260
 261         /* Port left the bridge, put in BR_STATE_DISABLED by the bridge layer,
 262          * so allow it to be in BR_STATE_FORWARDING to be kept functional
 263          */
 264         dsa_port_set_state_now(dp, BR_STATE_FORWARDING, true);
 265
 266         /* VLAN filtering is handled by dsa_switch_bridge_leave */
 267
 268         /* Ageing time may be global to the switch chip, so don't change it
 269          * here because we have no good reason (or value) to change it to.
 270          */
 271 }
 272
 273 static int dsa_port_bridge_create(struct dsa_port *dp,
 274                                   struct net_device *br,
 275                                   struct netlink_ext_ack *extack)
 276 {
 277         struct dsa_switch *ds = dp->ds;
 278         struct dsa_bridge *bridge;
 279
 280         bridge = dsa_tree_bridge_find(ds->dst, br);
 281         if (bridge) {
 282                 refcount_inc(&bridge->refcount);
 283                 dp->bridge = bridge;
 284                 return 0;
 285         }
 286
 287         bridge = kzalloc(sizeof(*bridge), GFP_KERNEL);
 288         if (!bridge)
 289                 return -ENOMEM;
 290
 291         refcount_set(&bridge->refcount, 1);
 292
 293         bridge->dev = br;
 294
 295         bridge->num = dsa_bridge_num_get(br, ds->max_num_bridges);
 296         if (ds->max_num_bridges && !bridge->num) {
 297                 NL_SET_ERR_MSG_MOD(extack,
 298                                    "Range of offloadable bridges exceeded");
 299                 kfree(bridge);
 300                 return -EOPNOTSUPP;
 301         }
 302
 303         dp->bridge = bridge;
 304
 305         return 0;
 306 }
 307
 308 static void dsa_port_bridge_destroy(struct dsa_port *dp,
 309                                     const struct net_device *br)
 310 {
 311         struct dsa_bridge *bridge = dp->bridge;
 312
 313         dp->bridge = NULL;
 314
 315         if (!refcount_dec_and_test(&bridge->refcount))
 316                 return;
 317
 318         if (bridge->num)
 319                 dsa_bridge_num_put(br, bridge->num);
 320
 321         kfree(bridge);
 322 }
 323
 324 int dsa_port_bridge_join(struct dsa_port *dp, struct net_device *br,
 325                          struct netlink_ext_ack *extack)
 326 {
 327         struct dsa_notifier_bridge_info info = {
 328                 .tree_index = dp->ds->dst->index,
 329                 .sw_index = dp->ds->index,
 330                 .port = dp->index,
 331         };
 332         struct net_device *dev = dp->slave;
 333         struct net_device *brport_dev;
 334         int err;
 335
 336         /* Here the interface is already bridged. Reflect the current
 337          * configuration so that drivers can program their chips accordingly.
 338          */
 339         err = dsa_port_bridge_create(dp, br, extack);
 340         if (err)
 341                 return err;
 342
 343         brport_dev = dsa_port_to_bridge_port(dp);
 344
 345         info.bridge = *dp->bridge;
 346         err = dsa_broadcast(DSA_NOTIFIER_BRIDGE_JOIN, &info);
 347         if (err)
 348                 goto out_rollback;
 349
 350         /* Drivers which support bridge TX forwarding should set this */
 351         dp->bridge->tx_fwd_offload = info.tx_fwd_offload;
 352
 353         err = switchdev_bridge_port_offload(brport_dev, dev, dp,
 354                                             &dsa_slave_switchdev_notifier,
 355                                             &dsa_slave_switchdev_blocking_notifier,
 356                                             dp->bridge->tx_fwd_offload, extack);
 357         if (err)
 358                 goto out_rollback_unbridge;
 359
 360         err = dsa_port_switchdev_sync_attrs(dp, extack);
 361         if (err)
 362                 goto out_rollback_unoffload;
 363
 364         return 0;
 365
 366 out_rollback_unoffload:
 367         switchdev_bridge_port_unoffload(brport_dev, dp,
 368                                         &dsa_slave_switchdev_notifier,
 369                                         &dsa_slave_switchdev_blocking_notifier);
 370 out_rollback_unbridge:
 371         dsa_broadcast(DSA_NOTIFIER_BRIDGE_LEAVE, &info);
 372 out_rollback:
 373         dsa_port_bridge_destroy(dp, br);
 374         return err;
 375 }
 376
 377 void dsa_port_pre_bridge_leave(struct dsa_port *dp, struct net_device *br)
 378 {
 379         struct net_device *brport_dev = dsa_port_to_bridge_port(dp);
 380
 381         /* Don't try to unoffload something that is not offloaded */
 382         if (!brport_dev)
 383                 return;
 384
 385         switchdev_bridge_port_unoffload(brport_dev, dp,
 386                                         &dsa_slave_switchdev_notifier,
 387                                         &dsa_slave_switchdev_blocking_notifier);
 388
 389         dsa_flush_workqueue();
 390 }
 391
 392 void dsa_port_bridge_leave(struct dsa_port *dp, struct net_device *br)
 393 {
 394         struct dsa_notifier_bridge_info info = {
 395                 .tree_index = dp->ds->dst->index,
 396                 .sw_index = dp->ds->index,
 397                 .port = dp->index,
 398         };
 399         int err;
 400
 401         /* If the port could not be offloaded to begin with, then
 402          * there is nothing to do.
 403          */
 404         if (!dp->bridge)
 405                 return;
 406
 407         info.bridge = *dp->bridge;
 408
 409         /* Here the port is already unbridged. Reflect the current configuration
 410          * so that drivers can program their chips accordingly.
 411          */
 412         dsa_port_bridge_destroy(dp, br);
 413
 414         err = dsa_broadcast(DSA_NOTIFIER_BRIDGE_LEAVE, &info);
 415         if (err)
 416                 dev_err(dp->ds->dev,
 417                         "port %d failed to notify DSA_NOTIFIER_BRIDGE_LEAVE: %pe\n",
 418                         dp->index, ERR_PTR(err));
 419
 420         dsa_port_switchdev_unsync_attrs(dp);
 421 }
 422
 423 int dsa_port_lag_change(struct dsa_port *dp,
 424                         struct netdev_lag_lower_state_info *linfo)
 425 {
 426         struct dsa_notifier_lag_info info = {
 427                 .sw_index = dp->ds->index,
 428                 .port = dp->index,
 429         };
 430         bool tx_enabled;
 431
 432         if (!dp->lag)
 433                 return 0;
 434
 435         /* On statically configured aggregates (e.g. loadbalance
 436          * without LACP) ports will always be tx_enabled, even if the
 437          * link is down. Thus we require both link_up and tx_enabled
 438          * in order to include it in the tx set.
 439          */
 440         tx_enabled = linfo->link_up && linfo->tx_enabled;
 441
 442         if (tx_enabled == dp->lag_tx_enabled)
 443                 return 0;
 444
 445         dp->lag_tx_enabled = tx_enabled;
 446
 447         return dsa_port_notify(dp, DSA_NOTIFIER_LAG_CHANGE, &info);
 448 }
 449
 450 static int dsa_port_lag_create(struct dsa_port *dp,
 451                                struct net_device *lag_dev)
 452 {
 453         struct dsa_switch *ds = dp->ds;
 454         struct dsa_lag *lag;
 455
 456         lag = dsa_tree_lag_find(ds->dst, lag_dev);
 457         if (lag) {
 458                 refcount_inc(&lag->refcount);
 459                 dp->lag = lag;
 460                 return 0;
 461         }
 462
 463         lag = kzalloc(sizeof(*lag), GFP_KERNEL);
 464         if (!lag)
 465                 return -ENOMEM;
 466
 467         refcount_set(&lag->refcount, 1);
 468         mutex_init(&lag->fdb_lock);
 469         INIT_LIST_HEAD(&lag->fdbs);
 470         lag->dev = lag_dev;
 471         dsa_lag_map(ds->dst, lag);
 472         dp->lag = lag;
 473
 474         return 0;
 475 }
 476
 477 static void dsa_port_lag_destroy(struct dsa_port *dp)
 478 {
 479         struct dsa_lag *lag = dp->lag;
 480
 481         dp->lag = NULL;
 482         dp->lag_tx_enabled = false;
 483
 484         if (!refcount_dec_and_test(&lag->refcount))
 485                 return;
 486
 487         WARN_ON(!list_empty(&lag->fdbs));
 488         dsa_lag_unmap(dp->ds->dst, lag);
 489         kfree(lag);
 490 }
 491
 492 int dsa_port_lag_join(struct dsa_port *dp, struct net_device *lag_dev,
 493                       struct netdev_lag_upper_info *uinfo,
 494                       struct netlink_ext_ack *extack)
 495 {
 496         struct dsa_notifier_lag_info info = {
 497                 .sw_index = dp->ds->index,
 498                 .port = dp->index,
 499                 .info = uinfo,
 500         };
 501         struct net_device *bridge_dev;
 502         int err;
 503
 504         err = dsa_port_lag_create(dp, lag_dev);
 505         if (err)
 506                 goto err_lag_create;
 507
 508         info.lag = *dp->lag;
 509         err = dsa_port_notify(dp, DSA_NOTIFIER_LAG_JOIN, &info);
 510         if (err)
 511                 goto err_lag_join;
 512
 513         bridge_dev = netdev_master_upper_dev_get(lag_dev);
 514         if (!bridge_dev || !netif_is_bridge_master(bridge_dev))
 515                 return 0;
 516
 517         err = dsa_port_bridge_join(dp, bridge_dev, extack);
 518         if (err)
 519                 goto err_bridge_join;
 520
 521         return 0;
 522
 523 err_bridge_join:
 524         dsa_port_notify(dp, DSA_NOTIFIER_LAG_LEAVE, &info);
 525 err_lag_join:
 526         dsa_port_lag_destroy(dp);
 527 err_lag_create:
 528         return err;
 529 }
 530
 531 void dsa_port_pre_lag_leave(struct dsa_port *dp, struct net_device *lag_dev)
 532 {
 533         struct net_device *br = dsa_port_bridge_dev_get(dp);
 534
 535         if (br)
 536                 dsa_port_pre_bridge_leave(dp, br);
 537 }
 538
 539 void dsa_port_lag_leave(struct dsa_port *dp, struct net_device *lag_dev)
 540 {
 541         struct net_device *br = dsa_port_bridge_dev_get(dp);
 542         struct dsa_notifier_lag_info info = {
 543                 .sw_index = dp->ds->index,
 544                 .port = dp->index,
 545         };
 546         int err;
 547
 548         if (!dp->lag)
 549                 return;
 550
 551         /* Port might have been part of a LAG that in turn was
 552          * attached to a bridge.
 553          */
 554         if (br)
 555                 dsa_port_bridge_leave(dp, br);
 556
 557         info.lag = *dp->lag;
 558
 559         dsa_port_lag_destroy(dp);
 560
 561         err = dsa_port_notify(dp, DSA_NOTIFIER_LAG_LEAVE, &info);
 562         if (err)
 563                 dev_err(dp->ds->dev,
 564                         "port %d failed to notify DSA_NOTIFIER_LAG_LEAVE: %pe\n",
 565                         dp->index, ERR_PTR(err));
 566 }
 567
 568 /* Must be called under rcu_read_lock() */
 569 static bool dsa_port_can_apply_vlan_filtering(struct dsa_port *dp,
 570                                               bool vlan_filtering,
 571                                               struct netlink_ext_ack *extack)
 572 {
 573         struct dsa_switch *ds = dp->ds;
 574         struct dsa_port *other_dp;
 575         int err;
 576
 577         /* VLAN awareness was off, so the question is "can we turn it on".
 578          * We may have had 8021q uppers, those need to go. Make sure we don't
 579          * enter an inconsistent state: deny changing the VLAN awareness state
 580          * as long as we have 8021q uppers.
 581          */
 582         if (vlan_filtering && dsa_port_is_user(dp)) {
 583                 struct net_device *br = dsa_port_bridge_dev_get(dp);
 584                 struct net_device *upper_dev, *slave = dp->slave;
 585                 struct list_head *iter;
 586
 587                 netdev_for_each_upper_dev_rcu(slave, upper_dev, iter) {
 588                         struct bridge_vlan_info br_info;
 589                         u16 vid;
 590
 591                         if (!is_vlan_dev(upper_dev))
 592                                 continue;
 593
 594                         vid = vlan_dev_vlan_id(upper_dev);
 595
 596                         /* br_vlan_get_info() returns -EINVAL or -ENOENT if the
 597                          * device, respectively the VID is not found, returning
 598                          * 0 means success, which is a failure for us here.
 599                          */
 600                         err = br_vlan_get_info(br, vid, &br_info);
 601                         if (err == 0) {
 602                                 NL_SET_ERR_MSG_MOD(extack,
 603                                                    "Must first remove VLAN uppers having VIDs also present in bridge");
 604                                 return false;
 605                         }
 606                 }
 607         }
 608
 609         if (!ds->vlan_filtering_is_global)
 610                 return true;
 611
 612         /* For cases where enabling/disabling VLAN awareness is global to the
 613          * switch, we need to handle the case where multiple bridges span
 614          * different ports of the same switch device and one of them has a
 615          * different setting than what is being requested.
 616          */
 617         dsa_switch_for_each_port(other_dp, ds) {
 618                 struct net_device *other_br = dsa_port_bridge_dev_get(other_dp);
 619
 620                 /* If it's the same bridge, it also has same
 621                  * vlan_filtering setting => no need to check
 622                  */
 623                 if (!other_br || other_br == dsa_port_bridge_dev_get(dp))
 624                         continue;
 625
 626                 if (br_vlan_enabled(other_br) != vlan_filtering) {
 627                         NL_SET_ERR_MSG_MOD(extack,
 628                                            "VLAN filtering is a global setting");
 629                         return false;
 630                 }
 631         }
 632         return true;
 633 }
 634
 635 int dsa_port_vlan_filtering(struct dsa_port *dp, bool vlan_filtering,
 636                             struct netlink_ext_ack *extack)
 637 {
 638         bool old_vlan_filtering = dsa_port_is_vlan_filtering(dp);
 639         struct dsa_switch *ds = dp->ds;
 640         bool apply;
 641         int err;
 642
 643         if (!ds->ops->port_vlan_filtering)
 644                 return -EOPNOTSUPP;
 645
 646         /* We are called from dsa_slave_switchdev_blocking_event(),
 647          * which is not under rcu_read_lock(), unlike
 648          * dsa_slave_switchdev_event().
 649          */
 650         rcu_read_lock();
 651         apply = dsa_port_can_apply_vlan_filtering(dp, vlan_filtering, extack);
 652         rcu_read_unlock();
 653         if (!apply)
 654                 return -EINVAL;
 655
 656         if (dsa_port_is_vlan_filtering(dp) == vlan_filtering)
 657                 return 0;
 658
 659         err = ds->ops->port_vlan_filtering(ds, dp->index, vlan_filtering,
 660                                            extack);
 661         if (err)
 662                 return err;
 663
 664         if (ds->vlan_filtering_is_global) {
 665                 struct dsa_port *other_dp;
 666
 667                 ds->vlan_filtering = vlan_filtering;
 668
 669                 dsa_switch_for_each_user_port(other_dp, ds) {
 670                         struct net_device *slave = dp->slave;
 671
 672                         /* We might be called in the unbind path, so not
 673                          * all slave devices might still be registered.
 674                          */
 675                         if (!slave)
 676                                 continue;
 677
 678                         err = dsa_slave_manage_vlan_filtering(slave,
 679                                                               vlan_filtering);
 680                         if (err)
 681                                 goto restore;
 682                 }
 683         } else {
 684                 dp->vlan_filtering = vlan_filtering;
 685
 686                 err = dsa_slave_manage_vlan_filtering(dp->slave,
 687                                                       vlan_filtering);
 688                 if (err)
 689                         goto restore;
 690         }
 691
 692         return 0;
 693
 694 restore:
 695         ds->ops->port_vlan_filtering(ds, dp->index, old_vlan_filtering, NULL);
 696
 697         if (ds->vlan_filtering_is_global)
 698                 ds->vlan_filtering = old_vlan_filtering;
 699         else
 700                 dp->vlan_filtering = old_vlan_filtering;
 701
 702         return err;
 703 }
 704
 705 /* This enforces legacy behavior for switch drivers which assume they can't
 706  * receive VLAN configuration when enslaved to a bridge with vlan_filtering=0
 707  */
 708 bool dsa_port_skip_vlan_configuration(struct dsa_port *dp)
 709 {
 710         struct net_device *br = dsa_port_bridge_dev_get(dp);
 711         struct dsa_switch *ds = dp->ds;
 712
 713         if (!br)
 714                 return false;
 715
 716         return !ds->configure_vlan_while_not_filtering && !br_vlan_enabled(br);
 717 }
 718
 719 int dsa_port_ageing_time(struct dsa_port *dp, clock_t ageing_clock)
 720 {
 721         unsigned long ageing_jiffies = clock_t_to_jiffies(ageing_clock);
 722         unsigned int ageing_time = jiffies_to_msecs(ageing_jiffies);
 723         struct dsa_notifier_ageing_time_info info;
 724         int err;
 725
 726         info.ageing_time = ageing_time;
 727
 728         err = dsa_port_notify(dp, DSA_NOTIFIER_AGEING_TIME, &info);
 729         if (err)
 730                 return err;
 731
 732         dp->ageing_time = ageing_time;
 733
 734         return 0;
 735 }
 736
 737 int dsa_port_pre_bridge_flags(const struct dsa_port *dp,
 738                               struct switchdev_brport_flags flags,
 739                               struct netlink_ext_ack *extack)
 740 {
 741         struct dsa_switch *ds = dp->ds;
 742
 743         if (!ds->ops->port_pre_bridge_flags)
 744                 return -EINVAL;
 745
 746         return ds->ops->port_pre_bridge_flags(ds, dp->index, flags, extack);
 747 }
 748
 749 int dsa_port_bridge_flags(struct dsa_port *dp,
 750                           struct switchdev_brport_flags flags,
 751                           struct netlink_ext_ack *extack)
 752 {
 753         struct dsa_switch *ds = dp->ds;
 754         int err;
 755
 756         if (!ds->ops->port_bridge_flags)
 757                 return -EOPNOTSUPP;
 758
 759         err = ds->ops->port_bridge_flags(ds, dp->index, flags, extack);
 760         if (err)
 761                 return err;
 762
 763         if (flags.mask & BR_LEARNING) {
 764                 bool learning = flags.val & BR_LEARNING;
 765
 766                 if (learning == dp->learning)
 767                         return 0;
 768
 769                 if ((dp->learning && !learning) &&
 770                     (dp->stp_state == BR_STATE_LEARNING ||
 771                      dp->stp_state == BR_STATE_FORWARDING))
 772                         dsa_port_fast_age(dp);
 773
 774                 dp->learning = learning;
 775         }
 776
 777         return 0;
 778 }
 779
 780 int dsa_port_mtu_change(struct dsa_port *dp, int new_mtu,
 781                         bool targeted_match)
 782 {
 783         struct dsa_notifier_mtu_info info = {
 784                 .sw_index = dp->ds->index,
 785                 .targeted_match = targeted_match,
 786                 .port = dp->index,
 787                 .mtu = new_mtu,
 788         };
 789
 790         return dsa_port_notify(dp, DSA_NOTIFIER_MTU, &info);
 791 }
 792
 793 int dsa_port_fdb_add(struct dsa_port *dp, const unsigned char *addr,
 794                      u16 vid)
 795 {
 796         struct dsa_notifier_fdb_info info = {
 797                 .sw_index = dp->ds->index,
 798                 .port = dp->index,
 799                 .addr = addr,
 800                 .vid = vid,
 801                 .db = {
 802                         .type = DSA_DB_BRIDGE,
 803                         .bridge = *dp->bridge,
 804                 },
 805         };
 806
 807         /* Refcounting takes bridge.num as a key, and should be global for all
 808          * bridges in the absence of FDB isolation, and per bridge otherwise.
 809          * Force the bridge.num to zero here in the absence of FDB isolation.
 810          */
 811         if (!dp->ds->fdb_isolation)
 812                 info.db.bridge.num = 0;
 813
 814         return dsa_port_notify(dp, DSA_NOTIFIER_FDB_ADD, &info);
 815 }
 816
 817 int dsa_port_fdb_del(struct dsa_port *dp, const unsigned char *addr,
 818                      u16 vid)
 819 {
 820         struct dsa_notifier_fdb_info info = {
 821                 .sw_index = dp->ds->index,
 822                 .port = dp->index,
 823                 .addr = addr,
 824                 .vid = vid,
 825                 .db = {
 826                         .type = DSA_DB_BRIDGE,
 827                         .bridge = *dp->bridge,
 828                 },
 829         };
 830
 831         if (!dp->ds->fdb_isolation)
 832                 info.db.bridge.num = 0;
 833
 834         return dsa_port_notify(dp, DSA_NOTIFIER_FDB_DEL, &info);
 835 }
 836
 837 int dsa_port_host_fdb_add(struct dsa_port *dp, const unsigned char *addr,
 838                           u16 vid)
 839 {
 840         struct dsa_notifier_fdb_info info = {
 841                 .sw_index = dp->ds->index,
 842                 .port = dp->index,
 843                 .addr = addr,
 844                 .vid = vid,
 845                 .db = {
 846                         .type = DSA_DB_BRIDGE,
 847                         .bridge = *dp->bridge,
 848                 },
 849         };
 850         struct dsa_port *cpu_dp = dp->cpu_dp;
 851         int err;
 852
 853         /* Avoid a call to __dev_set_promiscuity() on the master, which
 854          * requires rtnl_lock(), since we can't guarantee that is held here,
 855          * and we can't take it either.
 856          */
 857         if (cpu_dp->master->priv_flags & IFF_UNICAST_FLT) {
 858                 err = dev_uc_add(cpu_dp->master, addr);
 859                 if (err)
 860                         return err;
 861         }
 862
 863         if (!dp->ds->fdb_isolation)
 864                 info.db.bridge.num = 0;
 865
 866         return dsa_port_notify(dp, DSA_NOTIFIER_HOST_FDB_ADD, &info);
 867 }
 868
 869 int dsa_port_host_fdb_del(struct dsa_port *dp, const unsigned char *addr,
 870                           u16 vid)
 871 {
 872         struct dsa_notifier_fdb_info info = {
 873                 .sw_index = dp->ds->index,
 874                 .port = dp->index,
 875                 .addr = addr,
 876                 .vid = vid,
 877                 .db = {
 878                         .type = DSA_DB_BRIDGE,
 879                         .bridge = *dp->bridge,
 880                 },
 881         };
 882         struct dsa_port *cpu_dp = dp->cpu_dp;
 883         int err;
 884
 885         if (cpu_dp->master->priv_flags & IFF_UNICAST_FLT) {
 886                 err = dev_uc_del(cpu_dp->master, addr);
 887                 if (err)
 888                         return err;
 889         }
 890
 891         if (!dp->ds->fdb_isolation)
 892                 info.db.bridge.num = 0;
 893
 894         return dsa_port_notify(dp, DSA_NOTIFIER_HOST_FDB_DEL, &info);
 895 }
 896
 897 int dsa_port_lag_fdb_add(struct dsa_port *dp, const unsigned char *addr,
 898                          u16 vid)
 899 {
 900         struct dsa_notifier_lag_fdb_info info = {
 901                 .lag = dp->lag,
 902                 .addr = addr,
 903                 .vid = vid,
 904                 .db = {
 905                         .type = DSA_DB_BRIDGE,
 906                         .bridge = *dp->bridge,
 907                 },
 908         };
 909
 910         if (!dp->ds->fdb_isolation)
 911                 info.db.bridge.num = 0;
 912
 913         return dsa_port_notify(dp, DSA_NOTIFIER_LAG_FDB_ADD, &info);
 914 }
 915
 916 int dsa_port_lag_fdb_del(struct dsa_port *dp, const unsigned char *addr,
 917                          u16 vid)
 918 {
 919         struct dsa_notifier_lag_fdb_info info = {
 920                 .lag = dp->lag,
 921                 .addr = addr,
 922                 .vid = vid,
 923                 .db = {
 924                         .type = DSA_DB_BRIDGE,
 925                         .bridge = *dp->bridge,
 926                 },
 927         };
 928
 929         if (!dp->ds->fdb_isolation)
 930                 info.db.bridge.num = 0;
 931
 932         return dsa_port_notify(dp, DSA_NOTIFIER_LAG_FDB_DEL, &info);
 933 }
 934
 935 int dsa_port_fdb_dump(struct dsa_port *dp, dsa_fdb_dump_cb_t *cb, void *data)
 936 {
 937         struct dsa_switch *ds = dp->ds;
 938         int port = dp->index;
 939
 940         if (!ds->ops->port_fdb_dump)
 941                 return -EOPNOTSUPP;
 942
 943         return ds->ops->port_fdb_dump(ds, port, cb, data);
 944 }
 945
 946 int dsa_port_mdb_add(const struct dsa_port *dp,
 947                      const struct switchdev_obj_port_mdb *mdb)
 948 {
 949         struct dsa_notifier_mdb_info info = {
 950                 .sw_index = dp->ds->index,
 951                 .port = dp->index,
 952                 .mdb = mdb,
 953                 .db = {
 954                         .type = DSA_DB_BRIDGE,
 955                         .bridge = *dp->bridge,
 956                 },
 957         };
 958
 959         if (!dp->ds->fdb_isolation)
 960                 info.db.bridge.num = 0;
 961
 962         return dsa_port_notify(dp, DSA_NOTIFIER_MDB_ADD, &info);
 963 }
 964
 965 int dsa_port_mdb_del(const struct dsa_port *dp,
 966                      const struct switchdev_obj_port_mdb *mdb)
 967 {
 968         struct dsa_notifier_mdb_info info = {
 969                 .sw_index = dp->ds->index,
 970                 .port = dp->index,
 971                 .mdb = mdb,
 972                 .db = {
 973                         .type = DSA_DB_BRIDGE,
 974                         .bridge = *dp->bridge,
 975                 },
 976         };
 977
 978         if (!dp->ds->fdb_isolation)
 979                 info.db.bridge.num = 0;
 980
 981         return dsa_port_notify(dp, DSA_NOTIFIER_MDB_DEL, &info);
 982 }
 983
 984 int dsa_port_host_mdb_add(const struct dsa_port *dp,
 985                           const struct switchdev_obj_port_mdb *mdb)
 986 {
 987         struct dsa_notifier_mdb_info info = {
 988                 .sw_index = dp->ds->index,
 989                 .port = dp->index,
 990                 .mdb = mdb,
 991                 .db = {
 992                         .type = DSA_DB_BRIDGE,
 993                         .bridge = *dp->bridge,
 994                 },
 995         };
 996         struct dsa_port *cpu_dp = dp->cpu_dp;
 997         int err;
 998
 999         err = dev_mc_add(cpu_dp->master, mdb->addr);
1000         if (err)
1001                 return err;
1002
1003         if (!dp->ds->fdb_isolation)
1004                 info.db.bridge.num = 0;
1005
1006         return dsa_port_notify(dp, DSA_NOTIFIER_HOST_MDB_ADD, &info);
1007 }
1008
1009 int dsa_port_host_mdb_del(const struct dsa_port *dp,
1010                           const struct switchdev_obj_port_mdb *mdb)
1011 {
1012         struct dsa_notifier_mdb_info info = {
1013                 .sw_index = dp->ds->index,
1014                 .port = dp->index,
1015                 .mdb = mdb,
1016                 .db = {
1017                         .type = DSA_DB_BRIDGE,
1018                         .bridge = *dp->bridge,
1019                 },
1020         };
1021         struct dsa_port *cpu_dp = dp->cpu_dp;
1022         int err;
1023
1024         err = dev_mc_del(cpu_dp->master, mdb->addr);
1025         if (err)
1026                 return err;
1027
1028         if (!dp->ds->fdb_isolation)
1029                 info.db.bridge.num = 0;
1030
1031         return dsa_port_notify(dp, DSA_NOTIFIER_HOST_MDB_DEL, &info);
1032 }
1033
1034 int dsa_port_vlan_add(struct dsa_port *dp,
1035                       const struct switchdev_obj_port_vlan *vlan,
1036                       struct netlink_ext_ack *extack)
1037 {
1038         struct dsa_notifier_vlan_info info = {
1039                 .sw_index = dp->ds->index,
1040                 .port = dp->index,
1041                 .vlan = vlan,
1042                 .extack = extack,
1043         };
1044
1045         return dsa_port_notify(dp, DSA_NOTIFIER_VLAN_ADD, &info);
1046 }
1047
1048 int dsa_port_vlan_del(struct dsa_port *dp,
1049                       const struct switchdev_obj_port_vlan *vlan)
1050 {
1051         struct dsa_notifier_vlan_info info = {
1052                 .sw_index = dp->ds->index,
1053                 .port = dp->index,
1054                 .vlan = vlan,
1055         };
1056
1057         return dsa_port_notify(dp, DSA_NOTIFIER_VLAN_DEL, &info);
1058 }
1059
1060 int dsa_port_host_vlan_add(struct dsa_port *dp,
1061                            const struct switchdev_obj_port_vlan *vlan,
1062                            struct netlink_ext_ack *extack)
1063 {
1064         struct dsa_notifier_vlan_info info = {
1065                 .sw_index = dp->ds->index,
1066                 .port = dp->index,
1067                 .vlan = vlan,
1068                 .extack = extack,
1069         };
1070         struct dsa_port *cpu_dp = dp->cpu_dp;
1071         int err;
1072
1073         err = dsa_port_notify(dp, DSA_NOTIFIER_HOST_VLAN_ADD, &info);
1074         if (err && err != -EOPNOTSUPP)
1075                 return err;
1076
1077         vlan_vid_add(cpu_dp->master, htons(ETH_P_8021Q), vlan->vid);
1078
1079         return err;
1080 }
1081
1082 int dsa_port_host_vlan_del(struct dsa_port *dp,
1083                            const struct switchdev_obj_port_vlan *vlan)
1084 {
1085         struct dsa_notifier_vlan_info info = {
1086                 .sw_index = dp->ds->index,
1087                 .port = dp->index,
1088                 .vlan = vlan,
1089         };
1090         struct dsa_port *cpu_dp = dp->cpu_dp;
1091         int err;
1092
1093         err = dsa_port_notify(dp, DSA_NOTIFIER_HOST_VLAN_DEL, &info);
1094         if (err && err != -EOPNOTSUPP)
1095                 return err;
1096
1097         vlan_vid_del(cpu_dp->master, htons(ETH_P_8021Q), vlan->vid);
1098
1099         return err;
1100 }
1101
1102 int dsa_port_mrp_add(const struct dsa_port *dp,
1103                      const struct switchdev_obj_mrp *mrp)
1104 {
1105         struct dsa_switch *ds = dp->ds;
1106
1107         if (!ds->ops->port_mrp_add)
1108                 return -EOPNOTSUPP;
1109
1110         return ds->ops->port_mrp_add(ds, dp->index, mrp);
1111 }
1112
1113 int dsa_port_mrp_del(const struct dsa_port *dp,
1114                      const struct switchdev_obj_mrp *mrp)
1115 {
1116         struct dsa_switch *ds = dp->ds;
1117
1118         if (!ds->ops->port_mrp_del)
1119                 return -EOPNOTSUPP;
1120
1121         return ds->ops->port_mrp_del(ds, dp->index, mrp);
1122 }
1123
1124 int dsa_port_mrp_add_ring_role(const struct dsa_port *dp,
1125                                const struct switchdev_obj_ring_role_mrp *mrp)
1126 {
1127         struct dsa_switch *ds = dp->ds;
1128
1129         if (!ds->ops->port_mrp_add_ring_role)
1130                 return -EOPNOTSUPP;
1131
1132         return ds->ops->port_mrp_add_ring_role(ds, dp->index, mrp);
1133 }
1134
1135 int dsa_port_mrp_del_ring_role(const struct dsa_port *dp,
1136                                const struct switchdev_obj_ring_role_mrp *mrp)
1137 {
1138         struct dsa_switch *ds = dp->ds;
1139
1140         if (!ds->ops->port_mrp_del_ring_role)
1141                 return -EOPNOTSUPP;
1142
1143         return ds->ops->port_mrp_del_ring_role(ds, dp->index, mrp);
1144 }
1145
1146 void dsa_port_set_tag_protocol(struct dsa_port *cpu_dp,
1147                                const struct dsa_device_ops *tag_ops)
1148 {
1149         cpu_dp->rcv = tag_ops->rcv;
1150         cpu_dp->tag_ops = tag_ops;
1151 }
1152
1153 static struct phy_device *dsa_port_get_phy_device(struct dsa_port *dp)
1154 {
1155         struct device_node *phy_dn;
1156         struct phy_device *phydev;
1157
1158         phy_dn = of_parse_phandle(dp->dn, "phy-handle", 0);
1159         if (!phy_dn)
1160                 return NULL;
1161
1162         phydev = of_phy_find_device(phy_dn);
1163         if (!phydev) {
1164                 of_node_put(phy_dn);
1165                 return ERR_PTR(-EPROBE_DEFER);
1166         }
1167
1168         of_node_put(phy_dn);
1169         return phydev;
1170 }
1171
1172 static void dsa_port_phylink_validate(struct phylink_config *config,
1173                                       unsigned long *supported,
1174                                       struct phylink_link_state *state)
1175 {
1176         struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
1177         struct dsa_switch *ds = dp->ds;
1178
1179         if (!ds->ops->phylink_validate) {
1180                 if (config->mac_capabilities)
1181                         phylink_generic_validate(config, supported, state);
1182                 return;
1183         }
1184
1185         ds->ops->phylink_validate(ds, dp->index, supported, state);
1186 }
1187
1188 static void dsa_port_phylink_mac_pcs_get_state(struct phylink_config *config,
1189                                                struct phylink_link_state *state)
1190 {
1191         struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
1192         struct dsa_switch *ds = dp->ds;
1193         int err;
1194
1195         /* Only called for inband modes */
1196         if (!ds->ops->phylink_mac_link_state) {
1197                 state->link = 0;
1198                 return;
1199         }
1200
1201         err = ds->ops->phylink_mac_link_state(ds, dp->index, state);
1202         if (err < 0) {
1203                 dev_err(ds->dev, "p%d: phylink_mac_link_state() failed: %d\n",
1204                         dp->index, err);
1205                 state->link = 0;
1206         }
1207 }
1208
1209 static struct phylink_pcs *
1210 dsa_port_phylink_mac_select_pcs(struct phylink_config *config,
1211                                 phy_interface_t interface)
1212 {
1213         struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
1214         struct phylink_pcs *pcs = ERR_PTR(-EOPNOTSUPP);
1215         struct dsa_switch *ds = dp->ds;
1216
1217         if (ds->ops->phylink_mac_select_pcs)
1218                 pcs = ds->ops->phylink_mac_select_pcs(ds, dp->index, interface);
1219
1220         return pcs;
1221 }
1222
1223 static void dsa_port_phylink_mac_config(struct phylink_config *config,
1224                                         unsigned int mode,
1225                                         const struct phylink_link_state *state)
1226 {
1227         struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
1228         struct dsa_switch *ds = dp->ds;
1229
1230         if (!ds->ops->phylink_mac_config)
1231                 return;
1232
1233         ds->ops->phylink_mac_config(ds, dp->index, mode, state);
1234 }
1235
1236 static void dsa_port_phylink_mac_an_restart(struct phylink_config *config)
1237 {
1238         struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
1239         struct dsa_switch *ds = dp->ds;
1240
1241         if (!ds->ops->phylink_mac_an_restart)
1242                 return;
1243
1244         ds->ops->phylink_mac_an_restart(ds, dp->index);
1245 }
1246
1247 static void dsa_port_phylink_mac_link_down(struct phylink_config *config,
1248                                            unsigned int mode,
1249                                            phy_interface_t interface)
1250 {
1251         struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
1252         struct phy_device *phydev = NULL;
1253         struct dsa_switch *ds = dp->ds;
1254
1255         if (dsa_port_is_user(dp))
1256                 phydev = dp->slave->phydev;
1257
1258         if (!ds->ops->phylink_mac_link_down) {
1259                 if (ds->ops->adjust_link && phydev)
1260                         ds->ops->adjust_link(ds, dp->index, phydev);
1261                 return;
1262         }
1263
1264         ds->ops->phylink_mac_link_down(ds, dp->index, mode, interface);
1265 }
1266
1267 static void dsa_port_phylink_mac_link_up(struct phylink_config *config,
1268                                          struct phy_device *phydev,
1269                                          unsigned int mode,
1270                                          phy_interface_t interface,
1271                                          int speed, int duplex,
1272                                          bool tx_pause, bool rx_pause)
1273 {
1274         struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
1275         struct dsa_switch *ds = dp->ds;
1276
1277         if (!ds->ops->phylink_mac_link_up) {
1278                 if (ds->ops->adjust_link && phydev)
1279                         ds->ops->adjust_link(ds, dp->index, phydev);
1280                 return;
1281         }
1282
1283         ds->ops->phylink_mac_link_up(ds, dp->index, mode, interface, phydev,
1284                                      speed, duplex, tx_pause, rx_pause);
1285 }
1286
1287 static const struct phylink_mac_ops dsa_port_phylink_mac_ops = {
1288         .validate = dsa_port_phylink_validate,
1289         .mac_select_pcs = dsa_port_phylink_mac_select_pcs,
1290         .mac_pcs_get_state = dsa_port_phylink_mac_pcs_get_state,
1291         .mac_config = dsa_port_phylink_mac_config,
1292         .mac_an_restart = dsa_port_phylink_mac_an_restart,
1293         .mac_link_down = dsa_port_phylink_mac_link_down,
1294         .mac_link_up = dsa_port_phylink_mac_link_up,
1295 };
1296
1297 int dsa_port_phylink_create(struct dsa_port *dp)
1298 {
1299         struct dsa_switch *ds = dp->ds;
1300         phy_interface_t mode;
1301         int err;
1302
1303         err = of_get_phy_mode(dp->dn, &mode);
1304         if (err)
1305                 mode = PHY_INTERFACE_MODE_NA;
1306
1307         /* Presence of phylink_mac_link_state or phylink_mac_an_restart is
1308          * an indicator of a legacy phylink driver.
1309          */
1310         if (ds->ops->phylink_mac_link_state ||
1311             ds->ops->phylink_mac_an_restart)
1312                 dp->pl_config.legacy_pre_march2020 = true;
1313
1314         if (ds->ops->phylink_get_caps)
1315                 ds->ops->phylink_get_caps(ds, dp->index, &dp->pl_config);
1316
1317         dp->pl = phylink_create(&dp->pl_config, of_fwnode_handle(dp->dn),
1318                                 mode, &dsa_port_phylink_mac_ops);
1319         if (IS_ERR(dp->pl)) {
1320                 pr_err("error creating PHYLINK: %ld\n", PTR_ERR(dp->pl));
1321                 return PTR_ERR(dp->pl);
1322         }
1323
1324         return 0;
1325 }
1326
1327 static int dsa_port_setup_phy_of(struct dsa_port *dp, bool enable)
1328 {
1329         struct dsa_switch *ds = dp->ds;
1330         struct phy_device *phydev;
1331         int port = dp->index;
1332         int err = 0;
1333
1334         phydev = dsa_port_get_phy_device(dp);
1335         if (!phydev)
1336                 return 0;
1337
1338         if (IS_ERR(phydev))
1339                 return PTR_ERR(phydev);
1340
1341         if (enable) {
1342                 err = genphy_resume(phydev);
1343                 if (err < 0)
1344                         goto err_put_dev;
1345
1346                 err = genphy_read_status(phydev);
1347                 if (err < 0)
1348                         goto err_put_dev;
1349         } else {
1350                 err = genphy_suspend(phydev);
1351                 if (err < 0)
1352                         goto err_put_dev;
1353         }
1354
1355         if (ds->ops->adjust_link)
1356                 ds->ops->adjust_link(ds, port, phydev);
1357
1358         dev_dbg(ds->dev, "enabled port's phy: %s", phydev_name(phydev));
1359
1360 err_put_dev:
1361         put_device(&phydev->mdio.dev);
1362         return err;
1363 }
1364
1365 static int dsa_port_fixed_link_register_of(struct dsa_port *dp)
1366 {
1367         struct device_node *dn = dp->dn;
1368         struct dsa_switch *ds = dp->ds;
1369         struct phy_device *phydev;
1370         int port = dp->index;
1371         phy_interface_t mode;
1372         int err;
1373
1374         err = of_phy_register_fixed_link(dn);
1375         if (err) {
1376                 dev_err(ds->dev,
1377                         "failed to register the fixed PHY of port %d\n",
1378                         port);
1379                 return err;
1380         }
1381
1382         phydev = of_phy_find_device(dn);
1383
1384         err = of_get_phy_mode(dn, &mode);
1385         if (err)
1386                 mode = PHY_INTERFACE_MODE_NA;
1387         phydev->interface = mode;
1388
1389         genphy_read_status(phydev);
1390
1391         if (ds->ops->adjust_link)
1392                 ds->ops->adjust_link(ds, port, phydev);
1393
1394         put_device(&phydev->mdio.dev);
1395
1396         return 0;
1397 }
1398
1399 static int dsa_port_phylink_register(struct dsa_port *dp)
1400 {
1401         struct dsa_switch *ds = dp->ds;
1402         struct device_node *port_dn = dp->dn;
1403         int err;
1404
1405         dp->pl_config.dev = ds->dev;
1406         dp->pl_config.type = PHYLINK_DEV;
1407
1408         err = dsa_port_phylink_create(dp);
1409         if (err)
1410                 return err;
1411
1412         err = phylink_of_phy_connect(dp->pl, port_dn, 0);
1413         if (err && err != -ENODEV) {
1414                 pr_err("could not attach to PHY: %d\n", err);
1415                 goto err_phy_connect;
1416         }
1417
1418         return 0;
1419
1420 err_phy_connect:
1421         phylink_destroy(dp->pl);
1422         return err;
1423 }
1424
1425 int dsa_port_link_register_of(struct dsa_port *dp)
1426 {
1427         struct dsa_switch *ds = dp->ds;
1428         struct device_node *phy_np;
1429         int port = dp->index;
1430
1431         if (!ds->ops->adjust_link) {
1432                 phy_np = of_parse_phandle(dp->dn, "phy-handle", 0);
1433                 if (of_phy_is_fixed_link(dp->dn) || phy_np) {
1434                         if (ds->ops->phylink_mac_link_down)
1435                                 ds->ops->phylink_mac_link_down(ds, port,
1436                                         MLO_AN_FIXED, PHY_INTERFACE_MODE_NA);
1437                         return dsa_port_phylink_register(dp);
1438                 }
1439                 return 0;
1440         }
1441
1442         dev_warn(ds->dev,
1443                  "Using legacy PHYLIB callbacks. Please migrate to PHYLINK!\n");
1444
1445         if (of_phy_is_fixed_link(dp->dn))
1446                 return dsa_port_fixed_link_register_of(dp);
1447         else
1448                 return dsa_port_setup_phy_of(dp, true);
1449 }
1450
1451 void dsa_port_link_unregister_of(struct dsa_port *dp)
1452 {
1453         struct dsa_switch *ds = dp->ds;
1454
1455         if (!ds->ops->adjust_link && dp->pl) {
1456                 rtnl_lock();
1457                 phylink_disconnect_phy(dp->pl);
1458                 rtnl_unlock();
1459                 phylink_destroy(dp->pl);
1460                 dp->pl = NULL;
1461                 return;
1462         }
1463
1464         if (of_phy_is_fixed_link(dp->dn))
1465                 of_phy_deregister_fixed_link(dp->dn);
1466         else
1467                 dsa_port_setup_phy_of(dp, false);
1468 }
1469
1470 int dsa_port_hsr_join(struct dsa_port *dp, struct net_device *hsr)
1471 {
1472         struct dsa_switch *ds = dp->ds;
1473         int err;
1474
1475         if (!ds->ops->port_hsr_join)
1476                 return -EOPNOTSUPP;
1477
1478         dp->hsr_dev = hsr;
1479
1480         err = ds->ops->port_hsr_join(ds, dp->index, hsr);
1481         if (err)
1482                 dp->hsr_dev = NULL;
1483
1484         return err;
1485 }
1486
1487 void dsa_port_hsr_leave(struct dsa_port *dp, struct net_device *hsr)
1488 {
1489         struct dsa_switch *ds = dp->ds;
1490         int err;
1491
1492         dp->hsr_dev = NULL;
1493
1494         if (ds->ops->port_hsr_leave) {
1495                 err = ds->ops->port_hsr_leave(ds, dp->index, hsr);
1496                 if (err)
1497                         dev_err(dp->ds->dev,
1498                                 "port %d failed to leave HSR %s: %pe\n",
1499                                 dp->index, hsr->name, ERR_PTR(err));
1500         }
1501 }
1502
1503 int dsa_port_tag_8021q_vlan_add(struct dsa_port *dp, u16 vid, bool broadcast)
1504 {
1505         struct dsa_notifier_tag_8021q_vlan_info info = {
1506                 .tree_index = dp->ds->dst->index,
1507                 .sw_index = dp->ds->index,
1508                 .port = dp->index,
1509                 .vid = vid,
1510         };
1511
1512         if (broadcast)
1513                 return dsa_broadcast(DSA_NOTIFIER_TAG_8021Q_VLAN_ADD, &info);
1514
1515         return dsa_port_notify(dp, DSA_NOTIFIER_TAG_8021Q_VLAN_ADD, &info);
1516 }
1517
1518 void dsa_port_tag_8021q_vlan_del(struct dsa_port *dp, u16 vid, bool broadcast)
1519 {
1520         struct dsa_notifier_tag_8021q_vlan_info info = {
1521                 .tree_index = dp->ds->dst->index,
1522                 .sw_index = dp->ds->index,
1523                 .port = dp->index,
1524                 .vid = vid,
1525         };
1526         int err;
1527
1528         if (broadcast)
1529                 err = dsa_broadcast(DSA_NOTIFIER_TAG_8021Q_VLAN_DEL, &info);
1530         else
1531                 err = dsa_port_notify(dp, DSA_NOTIFIER_TAG_8021Q_VLAN_DEL, &info);
1532         if (err)
1533                 dev_err(dp->ds->dev,
1534                         "port %d failed to notify tag_8021q VLAN %d deletion: %pe\n",
1535                         dp->index, vid, ERR_PTR(err));
1536 }