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