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 static int dsa_broadcast(unsigned long e, void *v)
  17 {
  18         struct dsa_switch_tree *dst;
  19         int err = 0;
  20
  21         list_for_each_entry(dst, &dsa_tree_list, list) {
  22                 struct raw_notifier_head *nh = &dst->nh;
  23
  24                 err = raw_notifier_call_chain(nh, e, v);
  25                 err = notifier_to_errno(err);
  26                 if (err)
  27                         break;
  28         }
  29
  30         return err;
  31 }
  32
  33 static int dsa_port_notify(const struct dsa_port *dp, unsigned long e, void *v)
  34 {
  35         struct raw_notifier_head *nh = &dp->ds->dst->nh;
  36         int err;
  37
  38         err = raw_notifier_call_chain(nh, e, v);
  39
  40         return notifier_to_errno(err);
  41 }
  42
  43 int dsa_port_set_state(struct dsa_port *dp, u8 state)
  44 {
  45         struct dsa_switch *ds = dp->ds;
  46         int port = dp->index;
  47
  48         if (!ds->ops->port_stp_state_set)
  49                 return -EOPNOTSUPP;
  50
  51         ds->ops->port_stp_state_set(ds, port, state);
  52
  53         if (ds->ops->port_fast_age) {
  54                 /* Fast age FDB entries or flush appropriate forwarding database
  55                  * for the given port, if we are moving it from Learning or
  56                  * Forwarding state, to Disabled or Blocking or Listening state.
  57                  */
  58
  59                 if ((dp->stp_state == BR_STATE_LEARNING ||
  60                      dp->stp_state == BR_STATE_FORWARDING) &&
  61                     (state == BR_STATE_DISABLED ||
  62                      state == BR_STATE_BLOCKING ||
  63                      state == BR_STATE_LISTENING))
  64                         ds->ops->port_fast_age(ds, port);
  65         }
  66
  67         dp->stp_state = state;
  68
  69         return 0;
  70 }
  71
  72 static void dsa_port_set_state_now(struct dsa_port *dp, u8 state)
  73 {
  74         int err;
  75
  76         err = dsa_port_set_state(dp, state);
  77         if (err)
  78                 pr_err("DSA: failed to set STP state %u (%d)\n", state, err);
  79 }
  80
  81 int dsa_port_enable_rt(struct dsa_port *dp, struct phy_device *phy)
  82 {
  83         struct dsa_switch *ds = dp->ds;
  84         int port = dp->index;
  85         int err;
  86
  87         if (ds->ops->port_enable) {
  88                 err = ds->ops->port_enable(ds, port, phy);
  89                 if (err)
  90                         return err;
  91         }
  92
  93         if (!dp->bridge_dev)
  94                 dsa_port_set_state_now(dp, BR_STATE_FORWARDING);
  95
  96         if (dp->pl)
  97                 phylink_start(dp->pl);
  98
  99         return 0;
 100 }
 101
 102 int dsa_port_enable(struct dsa_port *dp, struct phy_device *phy)
 103 {
 104         int err;
 105
 106         rtnl_lock();
 107         err = dsa_port_enable_rt(dp, phy);
 108         rtnl_unlock();
 109
 110         return err;
 111 }
 112
 113 void dsa_port_disable_rt(struct dsa_port *dp)
 114 {
 115         struct dsa_switch *ds = dp->ds;
 116         int port = dp->index;
 117
 118         if (dp->pl)
 119                 phylink_stop(dp->pl);
 120
 121         if (!dp->bridge_dev)
 122                 dsa_port_set_state_now(dp, BR_STATE_DISABLED);
 123
 124         if (ds->ops->port_disable)
 125                 ds->ops->port_disable(ds, port);
 126 }
 127
 128 void dsa_port_disable(struct dsa_port *dp)
 129 {
 130         rtnl_lock();
 131         dsa_port_disable_rt(dp);
 132         rtnl_unlock();
 133 }
 134
 135 int dsa_port_bridge_join(struct dsa_port *dp, struct net_device *br)
 136 {
 137         struct dsa_notifier_bridge_info info = {
 138                 .tree_index = dp->ds->dst->index,
 139                 .sw_index = dp->ds->index,
 140                 .port = dp->index,
 141                 .br = br,
 142         };
 143         int err;
 144
 145         /* Set the flooding mode before joining the port in the switch */
 146         err = dsa_port_bridge_flags(dp, BR_FLOOD | BR_MCAST_FLOOD);
 147         if (err)
 148                 return err;
 149
 150         /* Here the interface is already bridged. Reflect the current
 151          * configuration so that drivers can program their chips accordingly.
 152          */
 153         dp->bridge_dev = br;
 154
 155         err = dsa_broadcast(DSA_NOTIFIER_BRIDGE_JOIN, &info);
 156
 157         /* The bridging is rolled back on error */
 158         if (err) {
 159                 dsa_port_bridge_flags(dp, 0);
 160                 dp->bridge_dev = NULL;
 161         }
 162
 163         return err;
 164 }
 165
 166 void dsa_port_bridge_leave(struct dsa_port *dp, struct net_device *br)
 167 {
 168         struct dsa_notifier_bridge_info info = {
 169                 .tree_index = dp->ds->dst->index,
 170                 .sw_index = dp->ds->index,
 171                 .port = dp->index,
 172                 .br = br,
 173         };
 174         int err;
 175
 176         /* Here the port is already unbridged. Reflect the current configuration
 177          * so that drivers can program their chips accordingly.
 178          */
 179         dp->bridge_dev = NULL;
 180
 181         err = dsa_broadcast(DSA_NOTIFIER_BRIDGE_LEAVE, &info);
 182         if (err)
 183                 pr_err("DSA: failed to notify DSA_NOTIFIER_BRIDGE_LEAVE\n");
 184
 185         /* Port is leaving the bridge, disable flooding */
 186         dsa_port_bridge_flags(dp, 0);
 187
 188         /* Port left the bridge, put in BR_STATE_DISABLED by the bridge layer,
 189          * so allow it to be in BR_STATE_FORWARDING to be kept functional
 190          */
 191         dsa_port_set_state_now(dp, BR_STATE_FORWARDING);
 192 }
 193
 194 int dsa_port_lag_change(struct dsa_port *dp,
 195                         struct netdev_lag_lower_state_info *linfo)
 196 {
 197         struct dsa_notifier_lag_info info = {
 198                 .sw_index = dp->ds->index,
 199                 .port = dp->index,
 200         };
 201         bool tx_enabled;
 202
 203         if (!dp->lag_dev)
 204                 return 0;
 205
 206         /* On statically configured aggregates (e.g. loadbalance
 207          * without LACP) ports will always be tx_enabled, even if the
 208          * link is down. Thus we require both link_up and tx_enabled
 209          * in order to include it in the tx set.
 210          */
 211         tx_enabled = linfo->link_up && linfo->tx_enabled;
 212
 213         if (tx_enabled == dp->lag_tx_enabled)
 214                 return 0;
 215
 216         dp->lag_tx_enabled = tx_enabled;
 217
 218         return dsa_port_notify(dp, DSA_NOTIFIER_LAG_CHANGE, &info);
 219 }
 220
 221 int dsa_port_lag_join(struct dsa_port *dp, struct net_device *lag,
 222                       struct netdev_lag_upper_info *uinfo)
 223 {
 224         struct dsa_notifier_lag_info info = {
 225                 .sw_index = dp->ds->index,
 226                 .port = dp->index,
 227                 .lag = lag,
 228                 .info = uinfo,
 229         };
 230         int err;
 231
 232         dsa_lag_map(dp->ds->dst, lag);
 233         dp->lag_dev = lag;
 234
 235         err = dsa_port_notify(dp, DSA_NOTIFIER_LAG_JOIN, &info);
 236         if (err) {
 237                 dp->lag_dev = NULL;
 238                 dsa_lag_unmap(dp->ds->dst, lag);
 239         }
 240
 241         return err;
 242 }
 243
 244 void dsa_port_lag_leave(struct dsa_port *dp, struct net_device *lag)
 245 {
 246         struct dsa_notifier_lag_info info = {
 247                 .sw_index = dp->ds->index,
 248                 .port = dp->index,
 249                 .lag = lag,
 250         };
 251         int err;
 252
 253         if (!dp->lag_dev)
 254                 return;
 255
 256         /* Port might have been part of a LAG that in turn was
 257          * attached to a bridge.
 258          */
 259         if (dp->bridge_dev)
 260                 dsa_port_bridge_leave(dp, dp->bridge_dev);
 261
 262         dp->lag_tx_enabled = false;
 263         dp->lag_dev = NULL;
 264
 265         err = dsa_port_notify(dp, DSA_NOTIFIER_LAG_LEAVE, &info);
 266         if (err)
 267                 pr_err("DSA: failed to notify DSA_NOTIFIER_LAG_LEAVE: %d\n",
 268                        err);
 269
 270         dsa_lag_unmap(dp->ds->dst, lag);
 271 }
 272
 273 /* Must be called under rcu_read_lock() */
 274 static bool dsa_port_can_apply_vlan_filtering(struct dsa_port *dp,
 275                                               bool vlan_filtering)
 276 {
 277         struct dsa_switch *ds = dp->ds;
 278         int err, i;
 279
 280         /* VLAN awareness was off, so the question is "can we turn it on".
 281          * We may have had 8021q uppers, those need to go. Make sure we don't
 282          * enter an inconsistent state: deny changing the VLAN awareness state
 283          * as long as we have 8021q uppers.
 284          */
 285         if (vlan_filtering && dsa_is_user_port(ds, dp->index)) {
 286                 struct net_device *upper_dev, *slave = dp->slave;
 287                 struct net_device *br = dp->bridge_dev;
 288                 struct list_head *iter;
 289
 290                 netdev_for_each_upper_dev_rcu(slave, upper_dev, iter) {
 291                         struct bridge_vlan_info br_info;
 292                         u16 vid;
 293
 294                         if (!is_vlan_dev(upper_dev))
 295                                 continue;
 296
 297                         vid = vlan_dev_vlan_id(upper_dev);
 298
 299                         /* br_vlan_get_info() returns -EINVAL or -ENOENT if the
 300                          * device, respectively the VID is not found, returning
 301                          * 0 means success, which is a failure for us here.
 302                          */
 303                         err = br_vlan_get_info(br, vid, &br_info);
 304                         if (err == 0) {
 305                                 dev_err(ds->dev, "Must remove upper %s first\n",
 306                                         upper_dev->name);
 307                                 return false;
 308                         }
 309                 }
 310         }
 311
 312         if (!ds->vlan_filtering_is_global)
 313                 return true;
 314
 315         /* For cases where enabling/disabling VLAN awareness is global to the
 316          * switch, we need to handle the case where multiple bridges span
 317          * different ports of the same switch device and one of them has a
 318          * different setting than what is being requested.
 319          */
 320         for (i = 0; i < ds->num_ports; i++) {
 321                 struct net_device *other_bridge;
 322
 323                 other_bridge = dsa_to_port(ds, i)->bridge_dev;
 324                 if (!other_bridge)
 325                         continue;
 326                 /* If it's the same bridge, it also has same
 327                  * vlan_filtering setting => no need to check
 328                  */
 329                 if (other_bridge == dp->bridge_dev)
 330                         continue;
 331                 if (br_vlan_enabled(other_bridge) != vlan_filtering) {
 332                         dev_err(ds->dev, "VLAN filtering is a global setting\n");
 333                         return false;
 334                 }
 335         }
 336         return true;
 337 }
 338
 339 int dsa_port_vlan_filtering(struct dsa_port *dp, bool vlan_filtering)
 340 {
 341         struct dsa_switch *ds = dp->ds;
 342         bool apply;
 343         int err;
 344
 345         if (!ds->ops->port_vlan_filtering)
 346                 return -EOPNOTSUPP;
 347
 348         /* We are called from dsa_slave_switchdev_blocking_event(),
 349          * which is not under rcu_read_lock(), unlike
 350          * dsa_slave_switchdev_event().
 351          */
 352         rcu_read_lock();
 353         apply = dsa_port_can_apply_vlan_filtering(dp, vlan_filtering);
 354         rcu_read_unlock();
 355         if (!apply)
 356                 return -EINVAL;
 357
 358         if (dsa_port_is_vlan_filtering(dp) == vlan_filtering)
 359                 return 0;
 360
 361         err = ds->ops->port_vlan_filtering(ds, dp->index, vlan_filtering);
 362         if (err)
 363                 return err;
 364
 365         if (ds->vlan_filtering_is_global)
 366                 ds->vlan_filtering = vlan_filtering;
 367         else
 368                 dp->vlan_filtering = vlan_filtering;
 369
 370         return 0;
 371 }
 372
 373 /* This enforces legacy behavior for switch drivers which assume they can't
 374  * receive VLAN configuration when enslaved to a bridge with vlan_filtering=0
 375  */
 376 bool dsa_port_skip_vlan_configuration(struct dsa_port *dp)
 377 {
 378         struct dsa_switch *ds = dp->ds;
 379
 380         if (!dp->bridge_dev)
 381                 return false;
 382
 383         return (!ds->configure_vlan_while_not_filtering &&
 384                 !br_vlan_enabled(dp->bridge_dev));
 385 }
 386
 387 int dsa_port_ageing_time(struct dsa_port *dp, clock_t ageing_clock)
 388 {
 389         unsigned long ageing_jiffies = clock_t_to_jiffies(ageing_clock);
 390         unsigned int ageing_time = jiffies_to_msecs(ageing_jiffies);
 391         struct dsa_notifier_ageing_time_info info;
 392         int err;
 393
 394         info.ageing_time = ageing_time;
 395
 396         err = dsa_port_notify(dp, DSA_NOTIFIER_AGEING_TIME, &info);
 397         if (err)
 398                 return err;
 399
 400         dp->ageing_time = ageing_time;
 401
 402         return 0;
 403 }
 404
 405 int dsa_port_pre_bridge_flags(const struct dsa_port *dp, unsigned long flags)
 406 {
 407         struct dsa_switch *ds = dp->ds;
 408
 409         if (!ds->ops->port_egress_floods ||
 410             (flags & ~(BR_FLOOD | BR_MCAST_FLOOD)))
 411                 return -EINVAL;
 412
 413         return 0;
 414 }
 415
 416 int dsa_port_bridge_flags(const struct dsa_port *dp, unsigned long flags)
 417 {
 418         struct dsa_switch *ds = dp->ds;
 419         int port = dp->index;
 420         int err = 0;
 421
 422         if (ds->ops->port_egress_floods)
 423                 err = ds->ops->port_egress_floods(ds, port, flags & BR_FLOOD,
 424                                                   flags & BR_MCAST_FLOOD);
 425
 426         return err;
 427 }
 428
 429 int dsa_port_mrouter(struct dsa_port *dp, bool mrouter)
 430 {
 431         struct dsa_switch *ds = dp->ds;
 432         int port = dp->index;
 433
 434         if (!ds->ops->port_egress_floods)
 435                 return -EOPNOTSUPP;
 436
 437         return ds->ops->port_egress_floods(ds, port, true, mrouter);
 438 }
 439
 440 int dsa_port_mtu_change(struct dsa_port *dp, int new_mtu,
 441                         bool propagate_upstream)
 442 {
 443         struct dsa_notifier_mtu_info info = {
 444                 .sw_index = dp->ds->index,
 445                 .propagate_upstream = propagate_upstream,
 446                 .port = dp->index,
 447                 .mtu = new_mtu,
 448         };
 449
 450         return dsa_port_notify(dp, DSA_NOTIFIER_MTU, &info);
 451 }
 452
 453 int dsa_port_fdb_add(struct dsa_port *dp, const unsigned char *addr,
 454                      u16 vid)
 455 {
 456         struct dsa_notifier_fdb_info info = {
 457                 .sw_index = dp->ds->index,
 458                 .port = dp->index,
 459                 .addr = addr,
 460                 .vid = vid,
 461         };
 462
 463         return dsa_port_notify(dp, DSA_NOTIFIER_FDB_ADD, &info);
 464 }
 465
 466 int dsa_port_fdb_del(struct dsa_port *dp, const unsigned char *addr,
 467                      u16 vid)
 468 {
 469         struct dsa_notifier_fdb_info info = {
 470                 .sw_index = dp->ds->index,
 471                 .port = dp->index,
 472                 .addr = addr,
 473                 .vid = vid,
 474
 475         };
 476
 477         return dsa_port_notify(dp, DSA_NOTIFIER_FDB_DEL, &info);
 478 }
 479
 480 int dsa_port_fdb_dump(struct dsa_port *dp, dsa_fdb_dump_cb_t *cb, void *data)
 481 {
 482         struct dsa_switch *ds = dp->ds;
 483         int port = dp->index;
 484
 485         if (!ds->ops->port_fdb_dump)
 486                 return -EOPNOTSUPP;
 487
 488         return ds->ops->port_fdb_dump(ds, port, cb, data);
 489 }
 490
 491 int dsa_port_mdb_add(const struct dsa_port *dp,
 492                      const struct switchdev_obj_port_mdb *mdb)
 493 {
 494         struct dsa_notifier_mdb_info info = {
 495                 .sw_index = dp->ds->index,
 496                 .port = dp->index,
 497                 .mdb = mdb,
 498         };
 499
 500         return dsa_port_notify(dp, DSA_NOTIFIER_MDB_ADD, &info);
 501 }
 502
 503 int dsa_port_mdb_del(const struct dsa_port *dp,
 504                      const struct switchdev_obj_port_mdb *mdb)
 505 {
 506         struct dsa_notifier_mdb_info info = {
 507                 .sw_index = dp->ds->index,
 508                 .port = dp->index,
 509                 .mdb = mdb,
 510         };
 511
 512         return dsa_port_notify(dp, DSA_NOTIFIER_MDB_DEL, &info);
 513 }
 514
 515 int dsa_port_vlan_add(struct dsa_port *dp,
 516                       const struct switchdev_obj_port_vlan *vlan)
 517 {
 518         struct dsa_notifier_vlan_info info = {
 519                 .sw_index = dp->ds->index,
 520                 .port = dp->index,
 521                 .vlan = vlan,
 522         };
 523
 524         return dsa_port_notify(dp, DSA_NOTIFIER_VLAN_ADD, &info);
 525 }
 526
 527 int dsa_port_vlan_del(struct dsa_port *dp,
 528                       const struct switchdev_obj_port_vlan *vlan)
 529 {
 530         struct dsa_notifier_vlan_info info = {
 531                 .sw_index = dp->ds->index,
 532                 .port = dp->index,
 533                 .vlan = vlan,
 534         };
 535
 536         return dsa_port_notify(dp, DSA_NOTIFIER_VLAN_DEL, &info);
 537 }
 538
 539 static struct phy_device *dsa_port_get_phy_device(struct dsa_port *dp)
 540 {
 541         struct device_node *phy_dn;
 542         struct phy_device *phydev;
 543
 544         phy_dn = of_parse_phandle(dp->dn, "phy-handle", 0);
 545         if (!phy_dn)
 546                 return NULL;
 547
 548         phydev = of_phy_find_device(phy_dn);
 549         if (!phydev) {
 550                 of_node_put(phy_dn);
 551                 return ERR_PTR(-EPROBE_DEFER);
 552         }
 553
 554         of_node_put(phy_dn);
 555         return phydev;
 556 }
 557
 558 static void dsa_port_phylink_validate(struct phylink_config *config,
 559                                       unsigned long *supported,
 560                                       struct phylink_link_state *state)
 561 {
 562         struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
 563         struct dsa_switch *ds = dp->ds;
 564
 565         if (!ds->ops->phylink_validate)
 566                 return;
 567
 568         ds->ops->phylink_validate(ds, dp->index, supported, state);
 569 }
 570
 571 static void dsa_port_phylink_mac_pcs_get_state(struct phylink_config *config,
 572                                                struct phylink_link_state *state)
 573 {
 574         struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
 575         struct dsa_switch *ds = dp->ds;
 576         int err;
 577
 578         /* Only called for inband modes */
 579         if (!ds->ops->phylink_mac_link_state) {
 580                 state->link = 0;
 581                 return;
 582         }
 583
 584         err = ds->ops->phylink_mac_link_state(ds, dp->index, state);
 585         if (err < 0) {
 586                 dev_err(ds->dev, "p%d: phylink_mac_link_state() failed: %d\n",
 587                         dp->index, err);
 588                 state->link = 0;
 589         }
 590 }
 591
 592 static void dsa_port_phylink_mac_config(struct phylink_config *config,
 593                                         unsigned int mode,
 594                                         const struct phylink_link_state *state)
 595 {
 596         struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
 597         struct dsa_switch *ds = dp->ds;
 598
 599         if (!ds->ops->phylink_mac_config)
 600                 return;
 601
 602         ds->ops->phylink_mac_config(ds, dp->index, mode, state);
 603 }
 604
 605 static void dsa_port_phylink_mac_an_restart(struct phylink_config *config)
 606 {
 607         struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
 608         struct dsa_switch *ds = dp->ds;
 609
 610         if (!ds->ops->phylink_mac_an_restart)
 611                 return;
 612
 613         ds->ops->phylink_mac_an_restart(ds, dp->index);
 614 }
 615
 616 static void dsa_port_phylink_mac_link_down(struct phylink_config *config,
 617                                            unsigned int mode,
 618                                            phy_interface_t interface)
 619 {
 620         struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
 621         struct phy_device *phydev = NULL;
 622         struct dsa_switch *ds = dp->ds;
 623
 624         if (dsa_is_user_port(ds, dp->index))
 625                 phydev = dp->slave->phydev;
 626
 627         if (!ds->ops->phylink_mac_link_down) {
 628                 if (ds->ops->adjust_link && phydev)
 629                         ds->ops->adjust_link(ds, dp->index, phydev);
 630                 return;
 631         }
 632
 633         ds->ops->phylink_mac_link_down(ds, dp->index, mode, interface);
 634 }
 635
 636 static void dsa_port_phylink_mac_link_up(struct phylink_config *config,
 637                                          struct phy_device *phydev,
 638                                          unsigned int mode,
 639                                          phy_interface_t interface,
 640                                          int speed, int duplex,
 641                                          bool tx_pause, bool rx_pause)
 642 {
 643         struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
 644         struct dsa_switch *ds = dp->ds;
 645
 646         if (!ds->ops->phylink_mac_link_up) {
 647                 if (ds->ops->adjust_link && phydev)
 648                         ds->ops->adjust_link(ds, dp->index, phydev);
 649                 return;
 650         }
 651
 652         ds->ops->phylink_mac_link_up(ds, dp->index, mode, interface, phydev,
 653                                      speed, duplex, tx_pause, rx_pause);
 654 }
 655
 656 const struct phylink_mac_ops dsa_port_phylink_mac_ops = {
 657         .validate = dsa_port_phylink_validate,
 658         .mac_pcs_get_state = dsa_port_phylink_mac_pcs_get_state,
 659         .mac_config = dsa_port_phylink_mac_config,
 660         .mac_an_restart = dsa_port_phylink_mac_an_restart,
 661         .mac_link_down = dsa_port_phylink_mac_link_down,
 662         .mac_link_up = dsa_port_phylink_mac_link_up,
 663 };
 664
 665 static int dsa_port_setup_phy_of(struct dsa_port *dp, bool enable)
 666 {
 667         struct dsa_switch *ds = dp->ds;
 668         struct phy_device *phydev;
 669         int port = dp->index;
 670         int err = 0;
 671
 672         phydev = dsa_port_get_phy_device(dp);
 673         if (!phydev)
 674                 return 0;
 675
 676         if (IS_ERR(phydev))
 677                 return PTR_ERR(phydev);
 678
 679         if (enable) {
 680                 err = genphy_resume(phydev);
 681                 if (err < 0)
 682                         goto err_put_dev;
 683
 684                 err = genphy_read_status(phydev);
 685                 if (err < 0)
 686                         goto err_put_dev;
 687         } else {
 688                 err = genphy_suspend(phydev);
 689                 if (err < 0)
 690                         goto err_put_dev;
 691         }
 692
 693         if (ds->ops->adjust_link)
 694                 ds->ops->adjust_link(ds, port, phydev);
 695
 696         dev_dbg(ds->dev, "enabled port's phy: %s", phydev_name(phydev));
 697
 698 err_put_dev:
 699         put_device(&phydev->mdio.dev);
 700         return err;
 701 }
 702
 703 static int dsa_port_fixed_link_register_of(struct dsa_port *dp)
 704 {
 705         struct device_node *dn = dp->dn;
 706         struct dsa_switch *ds = dp->ds;
 707         struct phy_device *phydev;
 708         int port = dp->index;
 709         phy_interface_t mode;
 710         int err;
 711
 712         err = of_phy_register_fixed_link(dn);
 713         if (err) {
 714                 dev_err(ds->dev,
 715                         "failed to register the fixed PHY of port %d\n",
 716                         port);
 717                 return err;
 718         }
 719
 720         phydev = of_phy_find_device(dn);
 721
 722         err = of_get_phy_mode(dn, &mode);
 723         if (err)
 724                 mode = PHY_INTERFACE_MODE_NA;
 725         phydev->interface = mode;
 726
 727         genphy_read_status(phydev);
 728
 729         if (ds->ops->adjust_link)
 730                 ds->ops->adjust_link(ds, port, phydev);
 731
 732         put_device(&phydev->mdio.dev);
 733
 734         return 0;
 735 }
 736
 737 static int dsa_port_phylink_register(struct dsa_port *dp)
 738 {
 739         struct dsa_switch *ds = dp->ds;
 740         struct device_node *port_dn = dp->dn;
 741         phy_interface_t mode;
 742         int err;
 743
 744         err = of_get_phy_mode(port_dn, &mode);
 745         if (err)
 746                 mode = PHY_INTERFACE_MODE_NA;
 747
 748         dp->pl_config.dev = ds->dev;
 749         dp->pl_config.type = PHYLINK_DEV;
 750         dp->pl_config.pcs_poll = ds->pcs_poll;
 751
 752         dp->pl = phylink_create(&dp->pl_config, of_fwnode_handle(port_dn),
 753                                 mode, &dsa_port_phylink_mac_ops);
 754         if (IS_ERR(dp->pl)) {
 755                 pr_err("error creating PHYLINK: %ld\n", PTR_ERR(dp->pl));
 756                 return PTR_ERR(dp->pl);
 757         }
 758
 759         err = phylink_of_phy_connect(dp->pl, port_dn, 0);
 760         if (err && err != -ENODEV) {
 761                 pr_err("could not attach to PHY: %d\n", err);
 762                 goto err_phy_connect;
 763         }
 764
 765         return 0;
 766
 767 err_phy_connect:
 768         phylink_destroy(dp->pl);
 769         return err;
 770 }
 771
 772 int dsa_port_link_register_of(struct dsa_port *dp)
 773 {
 774         struct dsa_switch *ds = dp->ds;
 775         struct device_node *phy_np;
 776         int port = dp->index;
 777
 778         if (!ds->ops->adjust_link) {
 779                 phy_np = of_parse_phandle(dp->dn, "phy-handle", 0);
 780                 if (of_phy_is_fixed_link(dp->dn) || phy_np) {
 781                         if (ds->ops->phylink_mac_link_down)
 782                                 ds->ops->phylink_mac_link_down(ds, port,
 783                                         MLO_AN_FIXED, PHY_INTERFACE_MODE_NA);
 784                         return dsa_port_phylink_register(dp);
 785                 }
 786                 return 0;
 787         }
 788
 789         dev_warn(ds->dev,
 790                  "Using legacy PHYLIB callbacks. Please migrate to PHYLINK!\n");
 791
 792         if (of_phy_is_fixed_link(dp->dn))
 793                 return dsa_port_fixed_link_register_of(dp);
 794         else
 795                 return dsa_port_setup_phy_of(dp, true);
 796 }
 797
 798 void dsa_port_link_unregister_of(struct dsa_port *dp)
 799 {
 800         struct dsa_switch *ds = dp->ds;
 801
 802         if (!ds->ops->adjust_link && dp->pl) {
 803                 rtnl_lock();
 804                 phylink_disconnect_phy(dp->pl);
 805                 rtnl_unlock();
 806                 phylink_destroy(dp->pl);
 807                 dp->pl = NULL;
 808                 return;
 809         }
 810
 811         if (of_phy_is_fixed_link(dp->dn))
 812                 of_phy_deregister_fixed_link(dp->dn);
 813         else
 814                 dsa_port_setup_phy_of(dp, false);
 815 }
 816
 817 int dsa_port_get_phy_strings(struct dsa_port *dp, uint8_t *data)
 818 {
 819         struct phy_device *phydev;
 820         int ret = -EOPNOTSUPP;
 821
 822         if (of_phy_is_fixed_link(dp->dn))
 823                 return ret;
 824
 825         phydev = dsa_port_get_phy_device(dp);
 826         if (IS_ERR_OR_NULL(phydev))
 827                 return ret;
 828
 829         ret = phy_ethtool_get_strings(phydev, data);
 830         put_device(&phydev->mdio.dev);
 831
 832         return ret;
 833 }
 834 EXPORT_SYMBOL_GPL(dsa_port_get_phy_strings);
 835
 836 int dsa_port_get_ethtool_phy_stats(struct dsa_port *dp, uint64_t *data)
 837 {
 838         struct phy_device *phydev;
 839         int ret = -EOPNOTSUPP;
 840
 841         if (of_phy_is_fixed_link(dp->dn))
 842                 return ret;
 843
 844         phydev = dsa_port_get_phy_device(dp);
 845         if (IS_ERR_OR_NULL(phydev))
 846                 return ret;
 847
 848         ret = phy_ethtool_get_stats(phydev, NULL, data);
 849         put_device(&phydev->mdio.dev);
 850
 851         return ret;
 852 }
 853 EXPORT_SYMBOL_GPL(dsa_port_get_ethtool_phy_stats);
 854
 855 int dsa_port_get_phy_sset_count(struct dsa_port *dp)
 856 {
 857         struct phy_device *phydev;
 858         int ret = -EOPNOTSUPP;
 859
 860         if (of_phy_is_fixed_link(dp->dn))
 861                 return ret;
 862
 863         phydev = dsa_port_get_phy_device(dp);
 864         if (IS_ERR_OR_NULL(phydev))
 865                 return ret;
 866
 867         ret = phy_ethtool_get_sset_count(phydev);
 868         put_device(&phydev->mdio.dev);
 869
 870         return ret;
 871 }
 872 EXPORT_SYMBOL_GPL(dsa_port_get_phy_sset_count);