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 int dsa_port_set_state(struct dsa_port *dp, u8 state)
  34 {
  35         struct dsa_switch *ds = dp->ds;
  36         int port = dp->index;
  37
  38         if (!ds->ops->port_stp_state_set)
  39                 return -EOPNOTSUPP;
  40
  41         ds->ops->port_stp_state_set(ds, port, state);
  42
  43         if (ds->ops->port_fast_age) {
  44                 /* Fast age FDB entries or flush appropriate forwarding database
  45                  * for the given port, if we are moving it from Learning or
  46                  * Forwarding state, to Disabled or Blocking or Listening state.
  47                  */
  48
  49                 if ((dp->stp_state == BR_STATE_LEARNING ||
  50                      dp->stp_state == BR_STATE_FORWARDING) &&
  51                     (state == BR_STATE_DISABLED ||
  52                      state == BR_STATE_BLOCKING ||
  53                      state == BR_STATE_LISTENING))
  54                         ds->ops->port_fast_age(ds, port);
  55         }
  56
  57         dp->stp_state = state;
  58
  59         return 0;
  60 }
  61
  62 static void dsa_port_set_state_now(struct dsa_port *dp, u8 state)
  63 {
  64         int err;
  65
  66         err = dsa_port_set_state(dp, state);
  67         if (err)
  68                 pr_err("DSA: failed to set STP state %u (%d)\n", state, err);
  69 }
  70
  71 int dsa_port_enable_rt(struct dsa_port *dp, struct phy_device *phy)
  72 {
  73         struct dsa_switch *ds = dp->ds;
  74         int port = dp->index;
  75         int err;
  76
  77         if (ds->ops->port_enable) {
  78                 err = ds->ops->port_enable(ds, port, phy);
  79                 if (err)
  80                         return err;
  81         }
  82
  83         if (!dp->bridge_dev)
  84                 dsa_port_set_state_now(dp, BR_STATE_FORWARDING);
  85
  86         if (dp->pl)
  87                 phylink_start(dp->pl);
  88
  89         return 0;
  90 }
  91
  92 int dsa_port_enable(struct dsa_port *dp, struct phy_device *phy)
  93 {
  94         int err;
  95
  96         rtnl_lock();
  97         err = dsa_port_enable_rt(dp, phy);
  98         rtnl_unlock();
  99
 100         return err;
 101 }
 102
 103 void dsa_port_disable_rt(struct dsa_port *dp)
 104 {
 105         struct dsa_switch *ds = dp->ds;
 106         int port = dp->index;
 107
 108         if (dp->pl)
 109                 phylink_stop(dp->pl);
 110
 111         if (!dp->bridge_dev)
 112                 dsa_port_set_state_now(dp, BR_STATE_DISABLED);
 113
 114         if (ds->ops->port_disable)
 115                 ds->ops->port_disable(ds, port);
 116 }
 117
 118 void dsa_port_disable(struct dsa_port *dp)
 119 {
 120         rtnl_lock();
 121         dsa_port_disable_rt(dp);
 122         rtnl_unlock();
 123 }
 124
 125 static int dsa_port_inherit_brport_flags(struct dsa_port *dp,
 126                                          struct netlink_ext_ack *extack)
 127 {
 128         const unsigned long mask = BR_LEARNING | BR_FLOOD | BR_MCAST_FLOOD |
 129                                    BR_BCAST_FLOOD;
 130         struct net_device *brport_dev = dsa_port_to_bridge_port(dp);
 131         int flag, err;
 132
 133         for_each_set_bit(flag, &mask, 32) {
 134                 struct switchdev_brport_flags flags = {0};
 135
 136                 flags.mask = BIT(flag);
 137
 138                 if (br_port_flag_is_set(brport_dev, BIT(flag)))
 139                         flags.val = BIT(flag);
 140
 141                 err = dsa_port_bridge_flags(dp, flags, extack);
 142                 if (err && err != -EOPNOTSUPP)
 143                         return err;
 144         }
 145
 146         return 0;
 147 }
 148
 149 static void dsa_port_clear_brport_flags(struct dsa_port *dp)
 150 {
 151         const unsigned long val = BR_FLOOD | BR_MCAST_FLOOD | BR_BCAST_FLOOD;
 152         const unsigned long mask = BR_LEARNING | BR_FLOOD | BR_MCAST_FLOOD |
 153                                    BR_BCAST_FLOOD;
 154         int flag, err;
 155
 156         for_each_set_bit(flag, &mask, 32) {
 157                 struct switchdev_brport_flags flags = {0};
 158
 159                 flags.mask = BIT(flag);
 160                 flags.val = val & BIT(flag);
 161
 162                 err = dsa_port_bridge_flags(dp, flags, NULL);
 163                 if (err && err != -EOPNOTSUPP)
 164                         dev_err(dp->ds->dev,
 165                                 "failed to clear bridge port flag %lu: %pe\n",
 166                                 flags.val, ERR_PTR(err));
 167         }
 168 }
 169
 170 static int dsa_port_switchdev_sync(struct dsa_port *dp,
 171                                    struct netlink_ext_ack *extack)
 172 {
 173         struct net_device *brport_dev = dsa_port_to_bridge_port(dp);
 174         struct net_device *br = dp->bridge_dev;
 175         int err;
 176
 177         err = dsa_port_inherit_brport_flags(dp, extack);
 178         if (err)
 179                 return err;
 180
 181         err = dsa_port_set_state(dp, br_port_get_stp_state(brport_dev));
 182         if (err && err != -EOPNOTSUPP)
 183                 return err;
 184
 185         err = dsa_port_vlan_filtering(dp, br_vlan_enabled(br), extack);
 186         if (err && err != -EOPNOTSUPP)
 187                 return err;
 188
 189         err = dsa_port_mrouter(dp->cpu_dp, br_multicast_router(br), extack);
 190         if (err && err != -EOPNOTSUPP)
 191                 return err;
 192
 193         err = dsa_port_ageing_time(dp, br_get_ageing_time(br));
 194         if (err && err != -EOPNOTSUPP)
 195                 return err;
 196
 197         err = br_mdb_replay(br, brport_dev, dp, true,
 198                             &dsa_slave_switchdev_blocking_notifier, extack);
 199         if (err && err != -EOPNOTSUPP)
 200                 return err;
 201
 202         err = br_fdb_replay(br, brport_dev, dp, true,
 203                             &dsa_slave_switchdev_notifier);
 204         if (err && err != -EOPNOTSUPP)
 205                 return err;
 206
 207         err = br_vlan_replay(br, brport_dev, dp, true,
 208                              &dsa_slave_switchdev_blocking_notifier, extack);
 209         if (err && err != -EOPNOTSUPP)
 210                 return err;
 211
 212         return 0;
 213 }
 214
 215 static int dsa_port_switchdev_unsync_objs(struct dsa_port *dp,
 216                                           struct net_device *br,
 217                                           struct netlink_ext_ack *extack)
 218 {
 219         struct net_device *brport_dev = dsa_port_to_bridge_port(dp);
 220         int err;
 221
 222         /* Delete the switchdev objects left on this port */
 223         err = br_mdb_replay(br, brport_dev, dp, false,
 224                             &dsa_slave_switchdev_blocking_notifier, extack);
 225         if (err && err != -EOPNOTSUPP)
 226                 return err;
 227
 228         err = br_fdb_replay(br, brport_dev, dp, false,
 229                             &dsa_slave_switchdev_notifier);
 230         if (err && err != -EOPNOTSUPP)
 231                 return err;
 232
 233         err = br_vlan_replay(br, brport_dev, dp, false,
 234                              &dsa_slave_switchdev_blocking_notifier, extack);
 235         if (err && err != -EOPNOTSUPP)
 236                 return err;
 237
 238         return 0;
 239 }
 240
 241 static void dsa_port_switchdev_unsync_attrs(struct dsa_port *dp)
 242 {
 243         /* Configure the port for standalone mode (no address learning,
 244          * flood everything).
 245          * The bridge only emits SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS events
 246          * when the user requests it through netlink or sysfs, but not
 247          * automatically at port join or leave, so we need to handle resetting
 248          * the brport flags ourselves. But we even prefer it that way, because
 249          * otherwise, some setups might never get the notification they need,
 250          * for example, when a port leaves a LAG that offloads the bridge,
 251          * it becomes standalone, but as far as the bridge is concerned, no
 252          * port ever left.
 253          */
 254         dsa_port_clear_brport_flags(dp);
 255
 256         /* Port left the bridge, put in BR_STATE_DISABLED by the bridge layer,
 257          * so allow it to be in BR_STATE_FORWARDING to be kept functional
 258          */
 259         dsa_port_set_state_now(dp, BR_STATE_FORWARDING);
 260
 261         /* VLAN filtering is handled by dsa_switch_bridge_leave */
 262
 263         /* Some drivers treat the notification for having a local multicast
 264          * router by allowing multicast to be flooded to the CPU, so we should
 265          * allow this in standalone mode too.
 266          */
 267         dsa_port_mrouter(dp->cpu_dp, true, NULL);
 268
 269         /* Ageing time may be global to the switch chip, so don't change it
 270          * here because we have no good reason (or value) to change it to.
 271          */
 272 }
 273
 274 int dsa_port_bridge_join(struct dsa_port *dp, struct net_device *br,
 275                          struct netlink_ext_ack *extack)
 276 {
 277         struct dsa_notifier_bridge_info info = {
 278                 .tree_index = dp->ds->dst->index,
 279                 .sw_index = dp->ds->index,
 280                 .port = dp->index,
 281                 .br = br,
 282         };
 283         int err;
 284
 285         /* Here the interface is already bridged. Reflect the current
 286          * configuration so that drivers can program their chips accordingly.
 287          */
 288         dp->bridge_dev = br;
 289
 290         err = dsa_broadcast(DSA_NOTIFIER_BRIDGE_JOIN, &info);
 291         if (err)
 292                 goto out_rollback;
 293
 294         err = dsa_port_switchdev_sync(dp, extack);
 295         if (err)
 296                 goto out_rollback_unbridge;
 297
 298         return 0;
 299
 300 out_rollback_unbridge:
 301         dsa_broadcast(DSA_NOTIFIER_BRIDGE_LEAVE, &info);
 302 out_rollback:
 303         dp->bridge_dev = NULL;
 304         return err;
 305 }
 306
 307 int dsa_port_pre_bridge_leave(struct dsa_port *dp, struct net_device *br,
 308                               struct netlink_ext_ack *extack)
 309 {
 310         return dsa_port_switchdev_unsync_objs(dp, br, extack);
 311 }
 312
 313 void dsa_port_bridge_leave(struct dsa_port *dp, struct net_device *br)
 314 {
 315         struct dsa_notifier_bridge_info info = {
 316                 .tree_index = dp->ds->dst->index,
 317                 .sw_index = dp->ds->index,
 318                 .port = dp->index,
 319                 .br = br,
 320         };
 321         int err;
 322
 323         /* Here the port is already unbridged. Reflect the current configuration
 324          * so that drivers can program their chips accordingly.
 325          */
 326         dp->bridge_dev = NULL;
 327
 328         err = dsa_broadcast(DSA_NOTIFIER_BRIDGE_LEAVE, &info);
 329         if (err)
 330                 pr_err("DSA: failed to notify DSA_NOTIFIER_BRIDGE_LEAVE\n");
 331
 332         dsa_port_switchdev_unsync_attrs(dp);
 333 }
 334
 335 int dsa_port_lag_change(struct dsa_port *dp,
 336                         struct netdev_lag_lower_state_info *linfo)
 337 {
 338         struct dsa_notifier_lag_info info = {
 339                 .sw_index = dp->ds->index,
 340                 .port = dp->index,
 341         };
 342         bool tx_enabled;
 343
 344         if (!dp->lag_dev)
 345                 return 0;
 346
 347         /* On statically configured aggregates (e.g. loadbalance
 348          * without LACP) ports will always be tx_enabled, even if the
 349          * link is down. Thus we require both link_up and tx_enabled
 350          * in order to include it in the tx set.
 351          */
 352         tx_enabled = linfo->link_up && linfo->tx_enabled;
 353
 354         if (tx_enabled == dp->lag_tx_enabled)
 355                 return 0;
 356
 357         dp->lag_tx_enabled = tx_enabled;
 358
 359         return dsa_port_notify(dp, DSA_NOTIFIER_LAG_CHANGE, &info);
 360 }
 361
 362 int dsa_port_lag_join(struct dsa_port *dp, struct net_device *lag,
 363                       struct netdev_lag_upper_info *uinfo,
 364                       struct netlink_ext_ack *extack)
 365 {
 366         struct dsa_notifier_lag_info info = {
 367                 .sw_index = dp->ds->index,
 368                 .port = dp->index,
 369                 .lag = lag,
 370                 .info = uinfo,
 371         };
 372         struct net_device *bridge_dev;
 373         int err;
 374
 375         dsa_lag_map(dp->ds->dst, lag);
 376         dp->lag_dev = lag;
 377
 378         err = dsa_port_notify(dp, DSA_NOTIFIER_LAG_JOIN, &info);
 379         if (err)
 380                 goto err_lag_join;
 381
 382         bridge_dev = netdev_master_upper_dev_get(lag);
 383         if (!bridge_dev || !netif_is_bridge_master(bridge_dev))
 384                 return 0;
 385
 386         err = dsa_port_bridge_join(dp, bridge_dev, extack);
 387         if (err)
 388                 goto err_bridge_join;
 389
 390         return 0;
 391
 392 err_bridge_join:
 393         dsa_port_notify(dp, DSA_NOTIFIER_LAG_LEAVE, &info);
 394 err_lag_join:
 395         dp->lag_dev = NULL;
 396         dsa_lag_unmap(dp->ds->dst, lag);
 397         return err;
 398 }
 399
 400 int dsa_port_pre_lag_leave(struct dsa_port *dp, struct net_device *lag,
 401                            struct netlink_ext_ack *extack)
 402 {
 403         if (dp->bridge_dev)
 404                 return dsa_port_pre_bridge_leave(dp, dp->bridge_dev, extack);
 405
 406         return 0;
 407 }
 408
 409 void dsa_port_lag_leave(struct dsa_port *dp, struct net_device *lag)
 410 {
 411         struct dsa_notifier_lag_info info = {
 412                 .sw_index = dp->ds->index,
 413                 .port = dp->index,
 414                 .lag = lag,
 415         };
 416         int err;
 417
 418         if (!dp->lag_dev)
 419                 return;
 420
 421         /* Port might have been part of a LAG that in turn was
 422          * attached to a bridge.
 423          */
 424         if (dp->bridge_dev)
 425                 dsa_port_bridge_leave(dp, dp->bridge_dev);
 426
 427         dp->lag_tx_enabled = false;
 428         dp->lag_dev = NULL;
 429
 430         err = dsa_port_notify(dp, DSA_NOTIFIER_LAG_LEAVE, &info);
 431         if (err)
 432                 pr_err("DSA: failed to notify DSA_NOTIFIER_LAG_LEAVE: %d\n",
 433                        err);
 434
 435         dsa_lag_unmap(dp->ds->dst, lag);
 436 }
 437
 438 /* Must be called under rcu_read_lock() */
 439 static bool dsa_port_can_apply_vlan_filtering(struct dsa_port *dp,
 440                                               bool vlan_filtering,
 441                                               struct netlink_ext_ack *extack)
 442 {
 443         struct dsa_switch *ds = dp->ds;
 444         int err, i;
 445
 446         /* VLAN awareness was off, so the question is "can we turn it on".
 447          * We may have had 8021q uppers, those need to go. Make sure we don't
 448          * enter an inconsistent state: deny changing the VLAN awareness state
 449          * as long as we have 8021q uppers.
 450          */
 451         if (vlan_filtering && dsa_is_user_port(ds, dp->index)) {
 452                 struct net_device *upper_dev, *slave = dp->slave;
 453                 struct net_device *br = dp->bridge_dev;
 454                 struct list_head *iter;
 455
 456                 netdev_for_each_upper_dev_rcu(slave, upper_dev, iter) {
 457                         struct bridge_vlan_info br_info;
 458                         u16 vid;
 459
 460                         if (!is_vlan_dev(upper_dev))
 461                                 continue;
 462
 463                         vid = vlan_dev_vlan_id(upper_dev);
 464
 465                         /* br_vlan_get_info() returns -EINVAL or -ENOENT if the
 466                          * device, respectively the VID is not found, returning
 467                          * 0 means success, which is a failure for us here.
 468                          */
 469                         err = br_vlan_get_info(br, vid, &br_info);
 470                         if (err == 0) {
 471                                 NL_SET_ERR_MSG_MOD(extack,
 472                                                    "Must first remove VLAN uppers having VIDs also present in bridge");
 473                                 return false;
 474                         }
 475                 }
 476         }
 477
 478         if (!ds->vlan_filtering_is_global)
 479                 return true;
 480
 481         /* For cases where enabling/disabling VLAN awareness is global to the
 482          * switch, we need to handle the case where multiple bridges span
 483          * different ports of the same switch device and one of them has a
 484          * different setting than what is being requested.
 485          */
 486         for (i = 0; i < ds->num_ports; i++) {
 487                 struct net_device *other_bridge;
 488
 489                 other_bridge = dsa_to_port(ds, i)->bridge_dev;
 490                 if (!other_bridge)
 491                         continue;
 492                 /* If it's the same bridge, it also has same
 493                  * vlan_filtering setting => no need to check
 494                  */
 495                 if (other_bridge == dp->bridge_dev)
 496                         continue;
 497                 if (br_vlan_enabled(other_bridge) != vlan_filtering) {
 498                         NL_SET_ERR_MSG_MOD(extack,
 499                                            "VLAN filtering is a global setting");
 500                         return false;
 501                 }
 502         }
 503         return true;
 504 }
 505
 506 int dsa_port_vlan_filtering(struct dsa_port *dp, bool vlan_filtering,
 507                             struct netlink_ext_ack *extack)
 508 {
 509         struct dsa_switch *ds = dp->ds;
 510         bool apply;
 511         int err;
 512
 513         if (!ds->ops->port_vlan_filtering)
 514                 return -EOPNOTSUPP;
 515
 516         /* We are called from dsa_slave_switchdev_blocking_event(),
 517          * which is not under rcu_read_lock(), unlike
 518          * dsa_slave_switchdev_event().
 519          */
 520         rcu_read_lock();
 521         apply = dsa_port_can_apply_vlan_filtering(dp, vlan_filtering, extack);
 522         rcu_read_unlock();
 523         if (!apply)
 524                 return -EINVAL;
 525
 526         if (dsa_port_is_vlan_filtering(dp) == vlan_filtering)
 527                 return 0;
 528
 529         err = ds->ops->port_vlan_filtering(ds, dp->index, vlan_filtering,
 530                                            extack);
 531         if (err)
 532                 return err;
 533
 534         if (ds->vlan_filtering_is_global)
 535                 ds->vlan_filtering = vlan_filtering;
 536         else
 537                 dp->vlan_filtering = vlan_filtering;
 538
 539         return 0;
 540 }
 541
 542 /* This enforces legacy behavior for switch drivers which assume they can't
 543  * receive VLAN configuration when enslaved to a bridge with vlan_filtering=0
 544  */
 545 bool dsa_port_skip_vlan_configuration(struct dsa_port *dp)
 546 {
 547         struct dsa_switch *ds = dp->ds;
 548
 549         if (!dp->bridge_dev)
 550                 return false;
 551
 552         return (!ds->configure_vlan_while_not_filtering &&
 553                 !br_vlan_enabled(dp->bridge_dev));
 554 }
 555
 556 int dsa_port_ageing_time(struct dsa_port *dp, clock_t ageing_clock)
 557 {
 558         unsigned long ageing_jiffies = clock_t_to_jiffies(ageing_clock);
 559         unsigned int ageing_time = jiffies_to_msecs(ageing_jiffies);
 560         struct dsa_notifier_ageing_time_info info;
 561         int err;
 562
 563         info.ageing_time = ageing_time;
 564
 565         err = dsa_port_notify(dp, DSA_NOTIFIER_AGEING_TIME, &info);
 566         if (err)
 567                 return err;
 568
 569         dp->ageing_time = ageing_time;
 570
 571         return 0;
 572 }
 573
 574 int dsa_port_pre_bridge_flags(const struct dsa_port *dp,
 575                               struct switchdev_brport_flags flags,
 576                               struct netlink_ext_ack *extack)
 577 {
 578         struct dsa_switch *ds = dp->ds;
 579
 580         if (!ds->ops->port_pre_bridge_flags)
 581                 return -EINVAL;
 582
 583         return ds->ops->port_pre_bridge_flags(ds, dp->index, flags, extack);
 584 }
 585
 586 int dsa_port_bridge_flags(const struct dsa_port *dp,
 587                           struct switchdev_brport_flags flags,
 588                           struct netlink_ext_ack *extack)
 589 {
 590         struct dsa_switch *ds = dp->ds;
 591
 592         if (!ds->ops->port_bridge_flags)
 593                 return -EOPNOTSUPP;
 594
 595         return ds->ops->port_bridge_flags(ds, dp->index, flags, extack);
 596 }
 597
 598 int dsa_port_mrouter(struct dsa_port *dp, bool mrouter,
 599                      struct netlink_ext_ack *extack)
 600 {
 601         struct dsa_switch *ds = dp->ds;
 602
 603         if (!ds->ops->port_set_mrouter)
 604                 return -EOPNOTSUPP;
 605
 606         return ds->ops->port_set_mrouter(ds, dp->index, mrouter, extack);
 607 }
 608
 609 int dsa_port_mtu_change(struct dsa_port *dp, int new_mtu,
 610                         bool targeted_match)
 611 {
 612         struct dsa_notifier_mtu_info info = {
 613                 .sw_index = dp->ds->index,
 614                 .targeted_match = targeted_match,
 615                 .port = dp->index,
 616                 .mtu = new_mtu,
 617         };
 618
 619         return dsa_port_notify(dp, DSA_NOTIFIER_MTU, &info);
 620 }
 621
 622 int dsa_port_fdb_add(struct dsa_port *dp, const unsigned char *addr,
 623                      u16 vid)
 624 {
 625         struct dsa_notifier_fdb_info info = {
 626                 .sw_index = dp->ds->index,
 627                 .port = dp->index,
 628                 .addr = addr,
 629                 .vid = vid,
 630         };
 631
 632         return dsa_port_notify(dp, DSA_NOTIFIER_FDB_ADD, &info);
 633 }
 634
 635 int dsa_port_fdb_del(struct dsa_port *dp, const unsigned char *addr,
 636                      u16 vid)
 637 {
 638         struct dsa_notifier_fdb_info info = {
 639                 .sw_index = dp->ds->index,
 640                 .port = dp->index,
 641                 .addr = addr,
 642                 .vid = vid,
 643
 644         };
 645
 646         return dsa_port_notify(dp, DSA_NOTIFIER_FDB_DEL, &info);
 647 }
 648
 649 int dsa_port_host_fdb_add(struct dsa_port *dp, const unsigned char *addr,
 650                           u16 vid)
 651 {
 652         struct dsa_notifier_fdb_info info = {
 653                 .sw_index = dp->ds->index,
 654                 .port = dp->index,
 655                 .addr = addr,
 656                 .vid = vid,
 657         };
 658
 659         return dsa_port_notify(dp, DSA_NOTIFIER_HOST_FDB_ADD, &info);
 660 }
 661
 662 int dsa_port_host_fdb_del(struct dsa_port *dp, const unsigned char *addr,
 663                           u16 vid)
 664 {
 665         struct dsa_notifier_fdb_info info = {
 666                 .sw_index = dp->ds->index,
 667                 .port = dp->index,
 668                 .addr = addr,
 669                 .vid = vid,
 670         };
 671
 672         return dsa_port_notify(dp, DSA_NOTIFIER_HOST_FDB_DEL, &info);
 673 }
 674
 675 int dsa_port_fdb_dump(struct dsa_port *dp, dsa_fdb_dump_cb_t *cb, void *data)
 676 {
 677         struct dsa_switch *ds = dp->ds;
 678         int port = dp->index;
 679
 680         if (!ds->ops->port_fdb_dump)
 681                 return -EOPNOTSUPP;
 682
 683         return ds->ops->port_fdb_dump(ds, port, cb, data);
 684 }
 685
 686 int dsa_port_mdb_add(const struct dsa_port *dp,
 687                      const struct switchdev_obj_port_mdb *mdb)
 688 {
 689         struct dsa_notifier_mdb_info info = {
 690                 .sw_index = dp->ds->index,
 691                 .port = dp->index,
 692                 .mdb = mdb,
 693         };
 694
 695         return dsa_port_notify(dp, DSA_NOTIFIER_MDB_ADD, &info);
 696 }
 697
 698 int dsa_port_mdb_del(const struct dsa_port *dp,
 699                      const struct switchdev_obj_port_mdb *mdb)
 700 {
 701         struct dsa_notifier_mdb_info info = {
 702                 .sw_index = dp->ds->index,
 703                 .port = dp->index,
 704                 .mdb = mdb,
 705         };
 706
 707         return dsa_port_notify(dp, DSA_NOTIFIER_MDB_DEL, &info);
 708 }
 709
 710 int dsa_port_host_mdb_add(const struct dsa_port *dp,
 711                           const struct switchdev_obj_port_mdb *mdb)
 712 {
 713         struct dsa_notifier_mdb_info info = {
 714                 .sw_index = dp->ds->index,
 715                 .port = dp->index,
 716                 .mdb = mdb,
 717         };
 718
 719         return dsa_port_notify(dp, DSA_NOTIFIER_HOST_MDB_ADD, &info);
 720 }
 721
 722 int dsa_port_host_mdb_del(const struct dsa_port *dp,
 723                           const struct switchdev_obj_port_mdb *mdb)
 724 {
 725         struct dsa_notifier_mdb_info info = {
 726                 .sw_index = dp->ds->index,
 727                 .port = dp->index,
 728                 .mdb = mdb,
 729         };
 730
 731         return dsa_port_notify(dp, DSA_NOTIFIER_HOST_MDB_DEL, &info);
 732 }
 733
 734 int dsa_port_vlan_add(struct dsa_port *dp,
 735                       const struct switchdev_obj_port_vlan *vlan,
 736                       struct netlink_ext_ack *extack)
 737 {
 738         struct dsa_notifier_vlan_info info = {
 739                 .sw_index = dp->ds->index,
 740                 .port = dp->index,
 741                 .vlan = vlan,
 742                 .extack = extack,
 743         };
 744
 745         return dsa_port_notify(dp, DSA_NOTIFIER_VLAN_ADD, &info);
 746 }
 747
 748 int dsa_port_vlan_del(struct dsa_port *dp,
 749                       const struct switchdev_obj_port_vlan *vlan)
 750 {
 751         struct dsa_notifier_vlan_info info = {
 752                 .sw_index = dp->ds->index,
 753                 .port = dp->index,
 754                 .vlan = vlan,
 755         };
 756
 757         return dsa_port_notify(dp, DSA_NOTIFIER_VLAN_DEL, &info);
 758 }
 759
 760 int dsa_port_mrp_add(const struct dsa_port *dp,
 761                      const struct switchdev_obj_mrp *mrp)
 762 {
 763         struct dsa_notifier_mrp_info info = {
 764                 .sw_index = dp->ds->index,
 765                 .port = dp->index,
 766                 .mrp = mrp,
 767         };
 768
 769         return dsa_port_notify(dp, DSA_NOTIFIER_MRP_ADD, &info);
 770 }
 771
 772 int dsa_port_mrp_del(const struct dsa_port *dp,
 773                      const struct switchdev_obj_mrp *mrp)
 774 {
 775         struct dsa_notifier_mrp_info info = {
 776                 .sw_index = dp->ds->index,
 777                 .port = dp->index,
 778                 .mrp = mrp,
 779         };
 780
 781         return dsa_port_notify(dp, DSA_NOTIFIER_MRP_DEL, &info);
 782 }
 783
 784 int dsa_port_mrp_add_ring_role(const struct dsa_port *dp,
 785                                const struct switchdev_obj_ring_role_mrp *mrp)
 786 {
 787         struct dsa_notifier_mrp_ring_role_info info = {
 788                 .sw_index = dp->ds->index,
 789                 .port = dp->index,
 790                 .mrp = mrp,
 791         };
 792
 793         return dsa_port_notify(dp, DSA_NOTIFIER_MRP_ADD_RING_ROLE, &info);
 794 }
 795
 796 int dsa_port_mrp_del_ring_role(const struct dsa_port *dp,
 797                                const struct switchdev_obj_ring_role_mrp *mrp)
 798 {
 799         struct dsa_notifier_mrp_ring_role_info info = {
 800                 .sw_index = dp->ds->index,
 801                 .port = dp->index,
 802                 .mrp = mrp,
 803         };
 804
 805         return dsa_port_notify(dp, DSA_NOTIFIER_MRP_DEL_RING_ROLE, &info);
 806 }
 807
 808 void dsa_port_set_tag_protocol(struct dsa_port *cpu_dp,
 809                                const struct dsa_device_ops *tag_ops)
 810 {
 811         cpu_dp->filter = tag_ops->filter;
 812         cpu_dp->rcv = tag_ops->rcv;
 813         cpu_dp->tag_ops = tag_ops;
 814 }
 815
 816 static struct phy_device *dsa_port_get_phy_device(struct dsa_port *dp)
 817 {
 818         struct device_node *phy_dn;
 819         struct phy_device *phydev;
 820
 821         phy_dn = of_parse_phandle(dp->dn, "phy-handle", 0);
 822         if (!phy_dn)
 823                 return NULL;
 824
 825         phydev = of_phy_find_device(phy_dn);
 826         if (!phydev) {
 827                 of_node_put(phy_dn);
 828                 return ERR_PTR(-EPROBE_DEFER);
 829         }
 830
 831         of_node_put(phy_dn);
 832         return phydev;
 833 }
 834
 835 static void dsa_port_phylink_validate(struct phylink_config *config,
 836                                       unsigned long *supported,
 837                                       struct phylink_link_state *state)
 838 {
 839         struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
 840         struct dsa_switch *ds = dp->ds;
 841
 842         if (!ds->ops->phylink_validate)
 843                 return;
 844
 845         ds->ops->phylink_validate(ds, dp->index, supported, state);
 846 }
 847
 848 static void dsa_port_phylink_mac_pcs_get_state(struct phylink_config *config,
 849                                                struct phylink_link_state *state)
 850 {
 851         struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
 852         struct dsa_switch *ds = dp->ds;
 853         int err;
 854
 855         /* Only called for inband modes */
 856         if (!ds->ops->phylink_mac_link_state) {
 857                 state->link = 0;
 858                 return;
 859         }
 860
 861         err = ds->ops->phylink_mac_link_state(ds, dp->index, state);
 862         if (err < 0) {
 863                 dev_err(ds->dev, "p%d: phylink_mac_link_state() failed: %d\n",
 864                         dp->index, err);
 865                 state->link = 0;
 866         }
 867 }
 868
 869 static void dsa_port_phylink_mac_config(struct phylink_config *config,
 870                                         unsigned int mode,
 871                                         const struct phylink_link_state *state)
 872 {
 873         struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
 874         struct dsa_switch *ds = dp->ds;
 875
 876         if (!ds->ops->phylink_mac_config)
 877                 return;
 878
 879         ds->ops->phylink_mac_config(ds, dp->index, mode, state);
 880 }
 881
 882 static void dsa_port_phylink_mac_an_restart(struct phylink_config *config)
 883 {
 884         struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
 885         struct dsa_switch *ds = dp->ds;
 886
 887         if (!ds->ops->phylink_mac_an_restart)
 888                 return;
 889
 890         ds->ops->phylink_mac_an_restart(ds, dp->index);
 891 }
 892
 893 static void dsa_port_phylink_mac_link_down(struct phylink_config *config,
 894                                            unsigned int mode,
 895                                            phy_interface_t interface)
 896 {
 897         struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
 898         struct phy_device *phydev = NULL;
 899         struct dsa_switch *ds = dp->ds;
 900
 901         if (dsa_is_user_port(ds, dp->index))
 902                 phydev = dp->slave->phydev;
 903
 904         if (!ds->ops->phylink_mac_link_down) {
 905                 if (ds->ops->adjust_link && phydev)
 906                         ds->ops->adjust_link(ds, dp->index, phydev);
 907                 return;
 908         }
 909
 910         ds->ops->phylink_mac_link_down(ds, dp->index, mode, interface);
 911 }
 912
 913 static void dsa_port_phylink_mac_link_up(struct phylink_config *config,
 914                                          struct phy_device *phydev,
 915                                          unsigned int mode,
 916                                          phy_interface_t interface,
 917                                          int speed, int duplex,
 918                                          bool tx_pause, bool rx_pause)
 919 {
 920         struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
 921         struct dsa_switch *ds = dp->ds;
 922
 923         if (!ds->ops->phylink_mac_link_up) {
 924                 if (ds->ops->adjust_link && phydev)
 925                         ds->ops->adjust_link(ds, dp->index, phydev);
 926                 return;
 927         }
 928
 929         ds->ops->phylink_mac_link_up(ds, dp->index, mode, interface, phydev,
 930                                      speed, duplex, tx_pause, rx_pause);
 931 }
 932
 933 const struct phylink_mac_ops dsa_port_phylink_mac_ops = {
 934         .validate = dsa_port_phylink_validate,
 935         .mac_pcs_get_state = dsa_port_phylink_mac_pcs_get_state,
 936         .mac_config = dsa_port_phylink_mac_config,
 937         .mac_an_restart = dsa_port_phylink_mac_an_restart,
 938         .mac_link_down = dsa_port_phylink_mac_link_down,
 939         .mac_link_up = dsa_port_phylink_mac_link_up,
 940 };
 941
 942 static int dsa_port_setup_phy_of(struct dsa_port *dp, bool enable)
 943 {
 944         struct dsa_switch *ds = dp->ds;
 945         struct phy_device *phydev;
 946         int port = dp->index;
 947         int err = 0;
 948
 949         phydev = dsa_port_get_phy_device(dp);
 950         if (!phydev)
 951                 return 0;
 952
 953         if (IS_ERR(phydev))
 954                 return PTR_ERR(phydev);
 955
 956         if (enable) {
 957                 err = genphy_resume(phydev);
 958                 if (err < 0)
 959                         goto err_put_dev;
 960
 961                 err = genphy_read_status(phydev);
 962                 if (err < 0)
 963                         goto err_put_dev;
 964         } else {
 965                 err = genphy_suspend(phydev);
 966                 if (err < 0)
 967                         goto err_put_dev;
 968         }
 969
 970         if (ds->ops->adjust_link)
 971                 ds->ops->adjust_link(ds, port, phydev);
 972
 973         dev_dbg(ds->dev, "enabled port's phy: %s", phydev_name(phydev));
 974
 975 err_put_dev:
 976         put_device(&phydev->mdio.dev);
 977         return err;
 978 }
 979
 980 static int dsa_port_fixed_link_register_of(struct dsa_port *dp)
 981 {
 982         struct device_node *dn = dp->dn;
 983         struct dsa_switch *ds = dp->ds;
 984         struct phy_device *phydev;
 985         int port = dp->index;
 986         phy_interface_t mode;
 987         int err;
 988
 989         err = of_phy_register_fixed_link(dn);
 990         if (err) {
 991                 dev_err(ds->dev,
 992                         "failed to register the fixed PHY of port %d\n",
 993                         port);
 994                 return err;
 995         }
 996
 997         phydev = of_phy_find_device(dn);
 998
 999         err = of_get_phy_mode(dn, &mode);
1000         if (err)
1001                 mode = PHY_INTERFACE_MODE_NA;
1002         phydev->interface = mode;
1003
1004         genphy_read_status(phydev);
1005
1006         if (ds->ops->adjust_link)
1007                 ds->ops->adjust_link(ds, port, phydev);
1008
1009         put_device(&phydev->mdio.dev);
1010
1011         return 0;
1012 }
1013
1014 static int dsa_port_phylink_register(struct dsa_port *dp)
1015 {
1016         struct dsa_switch *ds = dp->ds;
1017         struct device_node *port_dn = dp->dn;
1018         phy_interface_t mode;
1019         int err;
1020
1021         err = of_get_phy_mode(port_dn, &mode);
1022         if (err)
1023                 mode = PHY_INTERFACE_MODE_NA;
1024
1025         dp->pl_config.dev = ds->dev;
1026         dp->pl_config.type = PHYLINK_DEV;
1027         dp->pl_config.pcs_poll = ds->pcs_poll;
1028
1029         dp->pl = phylink_create(&dp->pl_config, of_fwnode_handle(port_dn),
1030                                 mode, &dsa_port_phylink_mac_ops);
1031         if (IS_ERR(dp->pl)) {
1032                 pr_err("error creating PHYLINK: %ld\n", PTR_ERR(dp->pl));
1033                 return PTR_ERR(dp->pl);
1034         }
1035
1036         err = phylink_of_phy_connect(dp->pl, port_dn, 0);
1037         if (err && err != -ENODEV) {
1038                 pr_err("could not attach to PHY: %d\n", err);
1039                 goto err_phy_connect;
1040         }
1041
1042         return 0;
1043
1044 err_phy_connect:
1045         phylink_destroy(dp->pl);
1046         return err;
1047 }
1048
1049 int dsa_port_link_register_of(struct dsa_port *dp)
1050 {
1051         struct dsa_switch *ds = dp->ds;
1052         struct device_node *phy_np;
1053         int port = dp->index;
1054
1055         if (!ds->ops->adjust_link) {
1056                 phy_np = of_parse_phandle(dp->dn, "phy-handle", 0);
1057                 if (of_phy_is_fixed_link(dp->dn) || phy_np) {
1058                         if (ds->ops->phylink_mac_link_down)
1059                                 ds->ops->phylink_mac_link_down(ds, port,
1060                                         MLO_AN_FIXED, PHY_INTERFACE_MODE_NA);
1061                         return dsa_port_phylink_register(dp);
1062                 }
1063                 return 0;
1064         }
1065
1066         dev_warn(ds->dev,
1067                  "Using legacy PHYLIB callbacks. Please migrate to PHYLINK!\n");
1068
1069         if (of_phy_is_fixed_link(dp->dn))
1070                 return dsa_port_fixed_link_register_of(dp);
1071         else
1072                 return dsa_port_setup_phy_of(dp, true);
1073 }
1074
1075 void dsa_port_link_unregister_of(struct dsa_port *dp)
1076 {
1077         struct dsa_switch *ds = dp->ds;
1078
1079         if (!ds->ops->adjust_link && dp->pl) {
1080                 rtnl_lock();
1081                 phylink_disconnect_phy(dp->pl);
1082                 rtnl_unlock();
1083                 phylink_destroy(dp->pl);
1084                 dp->pl = NULL;
1085                 return;
1086         }
1087
1088         if (of_phy_is_fixed_link(dp->dn))
1089                 of_phy_deregister_fixed_link(dp->dn);
1090         else
1091                 dsa_port_setup_phy_of(dp, false);
1092 }
1093
1094 int dsa_port_get_phy_strings(struct dsa_port *dp, uint8_t *data)
1095 {
1096         struct phy_device *phydev;
1097         int ret = -EOPNOTSUPP;
1098
1099         if (of_phy_is_fixed_link(dp->dn))
1100                 return ret;
1101
1102         phydev = dsa_port_get_phy_device(dp);
1103         if (IS_ERR_OR_NULL(phydev))
1104                 return ret;
1105
1106         ret = phy_ethtool_get_strings(phydev, data);
1107         put_device(&phydev->mdio.dev);
1108
1109         return ret;
1110 }
1111 EXPORT_SYMBOL_GPL(dsa_port_get_phy_strings);
1112
1113 int dsa_port_get_ethtool_phy_stats(struct dsa_port *dp, uint64_t *data)
1114 {
1115         struct phy_device *phydev;
1116         int ret = -EOPNOTSUPP;
1117
1118         if (of_phy_is_fixed_link(dp->dn))
1119                 return ret;
1120
1121         phydev = dsa_port_get_phy_device(dp);
1122         if (IS_ERR_OR_NULL(phydev))
1123                 return ret;
1124
1125         ret = phy_ethtool_get_stats(phydev, NULL, data);
1126         put_device(&phydev->mdio.dev);
1127
1128         return ret;
1129 }
1130 EXPORT_SYMBOL_GPL(dsa_port_get_ethtool_phy_stats);
1131
1132 int dsa_port_get_phy_sset_count(struct dsa_port *dp)
1133 {
1134         struct phy_device *phydev;
1135         int ret = -EOPNOTSUPP;
1136
1137         if (of_phy_is_fixed_link(dp->dn))
1138                 return ret;
1139
1140         phydev = dsa_port_get_phy_device(dp);
1141         if (IS_ERR_OR_NULL(phydev))
1142                 return ret;
1143
1144         ret = phy_ethtool_get_sset_count(phydev);
1145         put_device(&phydev->mdio.dev);
1146
1147         return ret;
1148 }
1149 EXPORT_SYMBOL_GPL(dsa_port_get_phy_sset_count);
1150
1151 int dsa_port_hsr_join(struct dsa_port *dp, struct net_device *hsr)
1152 {
1153         struct dsa_notifier_hsr_info info = {
1154                 .sw_index = dp->ds->index,
1155                 .port = dp->index,
1156                 .hsr = hsr,
1157         };
1158         int err;
1159
1160         dp->hsr_dev = hsr;
1161
1162         err = dsa_port_notify(dp, DSA_NOTIFIER_HSR_JOIN, &info);
1163         if (err)
1164                 dp->hsr_dev = NULL;
1165
1166         return err;
1167 }
1168
1169 void dsa_port_hsr_leave(struct dsa_port *dp, struct net_device *hsr)
1170 {
1171         struct dsa_notifier_hsr_info info = {
1172                 .sw_index = dp->ds->index,
1173                 .port = dp->index,
1174                 .hsr = hsr,
1175         };
1176         int err;
1177
1178         dp->hsr_dev = NULL;
1179
1180         err = dsa_port_notify(dp, DSA_NOTIFIER_HSR_LEAVE, &info);
1181         if (err)
1182                 pr_err("DSA: failed to notify DSA_NOTIFIER_HSR_LEAVE\n");
1183 }