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 461 /* Only called for inband modes */ 462 if (!ds->ops->phylink_mac_link_state) { 463 state->link = 0; 464 return; 465 } 466 467 if (ds->ops->phylink_mac_link_state(ds, dp->index, state) < 0) 468 state->link = 0; 469 } 470 471 static void dsa_port_phylink_mac_config(struct phylink_config *config, 472 unsigned int mode, 473 const struct phylink_link_state *state) 474 { 475 struct dsa_port *dp = container_of(config, struct dsa_port, pl_config); 476 struct dsa_switch *ds = dp->ds; 477 478 if (!ds->ops->phylink_mac_config) 479 return; 480 481 ds->ops->phylink_mac_config(ds, dp->index, mode, state); 482 } 483 484 static void dsa_port_phylink_mac_an_restart(struct phylink_config *config) 485 { 486 struct dsa_port *dp = container_of(config, struct dsa_port, pl_config); 487 struct dsa_switch *ds = dp->ds; 488 489 if (!ds->ops->phylink_mac_an_restart) 490 return; 491 492 ds->ops->phylink_mac_an_restart(ds, dp->index); 493 } 494 495 static void dsa_port_phylink_mac_link_down(struct phylink_config *config, 496 unsigned int mode, 497 phy_interface_t interface) 498 { 499 struct dsa_port *dp = container_of(config, struct dsa_port, pl_config); 500 struct phy_device *phydev = NULL; 501 struct dsa_switch *ds = dp->ds; 502 503 if (dsa_is_user_port(ds, dp->index)) 504 phydev = dp->slave->phydev; 505 506 if (!ds->ops->phylink_mac_link_down) { 507 if (ds->ops->adjust_link && phydev) 508 ds->ops->adjust_link(ds, dp->index, phydev); 509 return; 510 } 511 512 ds->ops->phylink_mac_link_down(ds, dp->index, mode, interface); 513 } 514 515 static void dsa_port_phylink_mac_link_up(struct phylink_config *config, 516 unsigned int mode, 517 phy_interface_t interface, 518 struct phy_device *phydev) 519 { 520 struct dsa_port *dp = container_of(config, struct dsa_port, pl_config); 521 struct dsa_switch *ds = dp->ds; 522 523 if (!ds->ops->phylink_mac_link_up) { 524 if (ds->ops->adjust_link && phydev) 525 ds->ops->adjust_link(ds, dp->index, phydev); 526 return; 527 } 528 529 ds->ops->phylink_mac_link_up(ds, dp->index, mode, interface, phydev); 530 } 531 532 const struct phylink_mac_ops dsa_port_phylink_mac_ops = { 533 .validate = dsa_port_phylink_validate, 534 .mac_pcs_get_state = dsa_port_phylink_mac_pcs_get_state, 535 .mac_config = dsa_port_phylink_mac_config, 536 .mac_an_restart = dsa_port_phylink_mac_an_restart, 537 .mac_link_down = dsa_port_phylink_mac_link_down, 538 .mac_link_up = dsa_port_phylink_mac_link_up, 539 }; 540 541 static int dsa_port_setup_phy_of(struct dsa_port *dp, bool enable) 542 { 543 struct dsa_switch *ds = dp->ds; 544 struct phy_device *phydev; 545 int port = dp->index; 546 int err = 0; 547 548 phydev = dsa_port_get_phy_device(dp); 549 if (!phydev) 550 return 0; 551 552 if (IS_ERR(phydev)) 553 return PTR_ERR(phydev); 554 555 if (enable) { 556 err = genphy_resume(phydev); 557 if (err < 0) 558 goto err_put_dev; 559 560 err = genphy_read_status(phydev); 561 if (err < 0) 562 goto err_put_dev; 563 } else { 564 err = genphy_suspend(phydev); 565 if (err < 0) 566 goto err_put_dev; 567 } 568 569 if (ds->ops->adjust_link) 570 ds->ops->adjust_link(ds, port, phydev); 571 572 dev_dbg(ds->dev, "enabled port's phy: %s", phydev_name(phydev)); 573 574 err_put_dev: 575 put_device(&phydev->mdio.dev); 576 return err; 577 } 578 579 static int dsa_port_fixed_link_register_of(struct dsa_port *dp) 580 { 581 struct device_node *dn = dp->dn; 582 struct dsa_switch *ds = dp->ds; 583 struct phy_device *phydev; 584 int port = dp->index; 585 phy_interface_t mode; 586 int err; 587 588 err = of_phy_register_fixed_link(dn); 589 if (err) { 590 dev_err(ds->dev, 591 "failed to register the fixed PHY of port %d\n", 592 port); 593 return err; 594 } 595 596 phydev = of_phy_find_device(dn); 597 598 err = of_get_phy_mode(dn, &mode); 599 if (err) 600 mode = PHY_INTERFACE_MODE_NA; 601 phydev->interface = mode; 602 603 genphy_read_status(phydev); 604 605 if (ds->ops->adjust_link) 606 ds->ops->adjust_link(ds, port, phydev); 607 608 put_device(&phydev->mdio.dev); 609 610 return 0; 611 } 612 613 static int dsa_port_phylink_register(struct dsa_port *dp) 614 { 615 struct dsa_switch *ds = dp->ds; 616 struct device_node *port_dn = dp->dn; 617 phy_interface_t mode; 618 int err; 619 620 err = of_get_phy_mode(port_dn, &mode); 621 if (err) 622 mode = PHY_INTERFACE_MODE_NA; 623 624 dp->pl_config.dev = ds->dev; 625 dp->pl_config.type = PHYLINK_DEV; 626 dp->pl_config.pcs_poll = ds->pcs_poll; 627 628 dp->pl = phylink_create(&dp->pl_config, of_fwnode_handle(port_dn), 629 mode, &dsa_port_phylink_mac_ops); 630 if (IS_ERR(dp->pl)) { 631 pr_err("error creating PHYLINK: %ld\n", PTR_ERR(dp->pl)); 632 return PTR_ERR(dp->pl); 633 } 634 635 err = phylink_of_phy_connect(dp->pl, port_dn, 0); 636 if (err && err != -ENODEV) { 637 pr_err("could not attach to PHY: %d\n", err); 638 goto err_phy_connect; 639 } 640 641 return 0; 642 643 err_phy_connect: 644 phylink_destroy(dp->pl); 645 return err; 646 } 647 648 int dsa_port_link_register_of(struct dsa_port *dp) 649 { 650 struct dsa_switch *ds = dp->ds; 651 struct device_node *phy_np; 652 653 if (!ds->ops->adjust_link) { 654 phy_np = of_parse_phandle(dp->dn, "phy-handle", 0); 655 if (of_phy_is_fixed_link(dp->dn) || phy_np) 656 return dsa_port_phylink_register(dp); 657 return 0; 658 } 659 660 dev_warn(ds->dev, 661 "Using legacy PHYLIB callbacks. Please migrate to PHYLINK!\n"); 662 663 if (of_phy_is_fixed_link(dp->dn)) 664 return dsa_port_fixed_link_register_of(dp); 665 else 666 return dsa_port_setup_phy_of(dp, true); 667 } 668 669 void dsa_port_link_unregister_of(struct dsa_port *dp) 670 { 671 struct dsa_switch *ds = dp->ds; 672 673 if (!ds->ops->adjust_link && dp->pl) { 674 rtnl_lock(); 675 phylink_disconnect_phy(dp->pl); 676 rtnl_unlock(); 677 phylink_destroy(dp->pl); 678 dp->pl = NULL; 679 return; 680 } 681 682 if (of_phy_is_fixed_link(dp->dn)) 683 of_phy_deregister_fixed_link(dp->dn); 684 else 685 dsa_port_setup_phy_of(dp, false); 686 } 687 688 int dsa_port_get_phy_strings(struct dsa_port *dp, uint8_t *data) 689 { 690 struct phy_device *phydev; 691 int ret = -EOPNOTSUPP; 692 693 if (of_phy_is_fixed_link(dp->dn)) 694 return ret; 695 696 phydev = dsa_port_get_phy_device(dp); 697 if (IS_ERR_OR_NULL(phydev)) 698 return ret; 699 700 ret = phy_ethtool_get_strings(phydev, data); 701 put_device(&phydev->mdio.dev); 702 703 return ret; 704 } 705 EXPORT_SYMBOL_GPL(dsa_port_get_phy_strings); 706 707 int dsa_port_get_ethtool_phy_stats(struct dsa_port *dp, uint64_t *data) 708 { 709 struct phy_device *phydev; 710 int ret = -EOPNOTSUPP; 711 712 if (of_phy_is_fixed_link(dp->dn)) 713 return ret; 714 715 phydev = dsa_port_get_phy_device(dp); 716 if (IS_ERR_OR_NULL(phydev)) 717 return ret; 718 719 ret = phy_ethtool_get_stats(phydev, NULL, data); 720 put_device(&phydev->mdio.dev); 721 722 return ret; 723 } 724 EXPORT_SYMBOL_GPL(dsa_port_get_ethtool_phy_stats); 725 726 int dsa_port_get_phy_sset_count(struct dsa_port *dp) 727 { 728 struct phy_device *phydev; 729 int ret = -EOPNOTSUPP; 730 731 if (of_phy_is_fixed_link(dp->dn)) 732 return ret; 733 734 phydev = dsa_port_get_phy_device(dp); 735 if (IS_ERR_OR_NULL(phydev)) 736 return ret; 737 738 ret = phy_ethtool_get_sset_count(phydev); 739 put_device(&phydev->mdio.dev); 740 741 return ret; 742 } 743 EXPORT_SYMBOL_GPL(dsa_port_get_phy_sset_count); 744