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