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