net/dsa/port.c

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