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