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/netdevice.h> 11#include <linux/notifier.h> 12#include <linux/of_mdio.h> 13#include <linux/of_net.h> 14 15#include "dsa.h" 16#include "port.h" 17#include "switch.h" 18#include "tag_8021q.h" 19#include "user.h" 20 21/** 22 * dsa_port_notify - Notify the switching fabric of changes to a port 23 * @dp: port on which change occurred 24 * @e: event, must be of type DSA_NOTIFIER_* 25 * @v: event-specific value. 26 * 27 * Notify all switches in the DSA tree that this port's switch belongs to, 28 * including this switch itself, of an event. Allows the other switches to 29 * reconfigure themselves for cross-chip operations. Can also be used to 30 * reconfigure ports without net_devices (CPU ports, DSA links) whenever 31 * a user port's state changes. 32 */ 33static int dsa_port_notify(const struct dsa_port *dp, unsigned long e, void *v) 34{ 35 return dsa_tree_notify(dp->ds->dst, e, v); 36} 37 38static void dsa_port_notify_bridge_fdb_flush(const struct dsa_port *dp, u16 vid) 39{ 40 struct net_device *brport_dev = dsa_port_to_bridge_port(dp); 41 struct switchdev_notifier_fdb_info info = { 42 .vid = vid, 43 }; 44 45 /* When the port becomes standalone it has already left the bridge. 46 * Don't notify the bridge in that case. 47 */ 48 if (!brport_dev) 49 return; 50 51 call_switchdev_notifiers(SWITCHDEV_FDB_FLUSH_TO_BRIDGE, 52 brport_dev, &info.info, NULL); 53} 54 55static void dsa_port_fast_age(const struct dsa_port *dp) 56{ 57 struct dsa_switch *ds = dp->ds; 58 59 if (!ds->ops->port_fast_age) 60 return; 61 62 ds->ops->port_fast_age(ds, dp->index); 63 64 /* flush all VLANs */ 65 dsa_port_notify_bridge_fdb_flush(dp, 0); 66} 67 68static int dsa_port_vlan_fast_age(const struct dsa_port *dp, u16 vid) 69{ 70 struct dsa_switch *ds = dp->ds; 71 int err; 72 73 if (!ds->ops->port_vlan_fast_age) 74 return -EOPNOTSUPP; 75 76 err = ds->ops->port_vlan_fast_age(ds, dp->index, vid); 77 78 if (!err) 79 dsa_port_notify_bridge_fdb_flush(dp, vid); 80 81 return err; 82} 83 84static int dsa_port_msti_fast_age(const struct dsa_port *dp, u16 msti) 85{ 86 DECLARE_BITMAP(vids, VLAN_N_VID) = { 0 }; 87 int err, vid; 88 89 err = br_mst_get_info(dsa_port_bridge_dev_get(dp), msti, vids); 90 if (err) 91 return err; 92 93 for_each_set_bit(vid, vids, VLAN_N_VID) { 94 err = dsa_port_vlan_fast_age(dp, vid); 95 if (err) 96 return err; 97 } 98 99 return 0; 100} 101 102static bool dsa_port_can_configure_learning(struct dsa_port *dp) 103{ 104 struct switchdev_brport_flags flags = { 105 .mask = BR_LEARNING, 106 }; 107 struct dsa_switch *ds = dp->ds; 108 int err; 109 110 if (!ds->ops->port_bridge_flags || !ds->ops->port_pre_bridge_flags) 111 return false; 112 113 err = ds->ops->port_pre_bridge_flags(ds, dp->index, flags, NULL); 114 return !err; 115} 116 117bool dsa_port_supports_hwtstamp(struct dsa_port *dp) 118{ 119 struct dsa_switch *ds = dp->ds; 120 struct ifreq ifr = {}; 121 int err; 122 123 if (!ds->ops->port_hwtstamp_get || !ds->ops->port_hwtstamp_set) 124 return false; 125 126 /* "See through" shim implementations of the "get" method. 127 * Since we can't cook up a complete ioctl request structure, this will 128 * fail in copy_to_user() with -EFAULT, which hopefully is enough to 129 * detect a valid implementation. 130 */ 131 err = ds->ops->port_hwtstamp_get(ds, dp->index, &ifr); 132 return err != -EOPNOTSUPP; 133} 134 135int dsa_port_set_state(struct dsa_port *dp, u8 state, bool do_fast_age) 136{ 137 struct dsa_switch *ds = dp->ds; 138 int port = dp->index; 139 140 if (!ds->ops->port_stp_state_set) 141 return -EOPNOTSUPP; 142 143 ds->ops->port_stp_state_set(ds, port, state); 144 145 if (!dsa_port_can_configure_learning(dp) || 146 (do_fast_age && dp->learning)) { 147 /* Fast age FDB entries or flush appropriate forwarding database 148 * for the given port, if we are moving it from Learning or 149 * Forwarding state, to Disabled or Blocking or Listening state. 150 * Ports that were standalone before the STP state change don't 151 * need to fast age the FDB, since address learning is off in 152 * standalone mode. 153 */ 154 155 if ((dp->stp_state == BR_STATE_LEARNING || 156 dp->stp_state == BR_STATE_FORWARDING) && 157 (state == BR_STATE_DISABLED || 158 state == BR_STATE_BLOCKING || 159 state == BR_STATE_LISTENING)) 160 dsa_port_fast_age(dp); 161 } 162 163 dp->stp_state = state; 164 165 return 0; 166} 167 168static void dsa_port_set_state_now(struct dsa_port *dp, u8 state, 169 bool do_fast_age) 170{ 171 struct dsa_switch *ds = dp->ds; 172 int err; 173 174 err = dsa_port_set_state(dp, state, do_fast_age); 175 if (err && err != -EOPNOTSUPP) { 176 dev_err(ds->dev, "port %d failed to set STP state %u: %pe\n", 177 dp->index, state, ERR_PTR(err)); 178 } 179} 180 181int dsa_port_set_mst_state(struct dsa_port *dp, 182 const struct switchdev_mst_state *state, 183 struct netlink_ext_ack *extack) 184{ 185 struct dsa_switch *ds = dp->ds; 186 u8 prev_state; 187 int err; 188 189 if (!ds->ops->port_mst_state_set) 190 return -EOPNOTSUPP; 191 192 err = br_mst_get_state(dsa_port_to_bridge_port(dp), state->msti, 193 &prev_state); 194 if (err) 195 return err; 196 197 err = ds->ops->port_mst_state_set(ds, dp->index, state); 198 if (err) 199 return err; 200 201 if (!(dp->learning && 202 (prev_state == BR_STATE_LEARNING || 203 prev_state == BR_STATE_FORWARDING) && 204 (state->state == BR_STATE_DISABLED || 205 state->state == BR_STATE_BLOCKING || 206 state->state == BR_STATE_LISTENING))) 207 return 0; 208 209 err = dsa_port_msti_fast_age(dp, state->msti); 210 if (err) 211 NL_SET_ERR_MSG_MOD(extack, 212 "Unable to flush associated VLANs"); 213 214 return 0; 215} 216 217int dsa_port_enable_rt(struct dsa_port *dp, struct phy_device *phy) 218{ 219 struct dsa_switch *ds = dp->ds; 220 int port = dp->index; 221 int err; 222 223 if (ds->ops->port_enable) { 224 err = ds->ops->port_enable(ds, port, phy); 225 if (err) 226 return err; 227 } 228 229 if (!dp->bridge) 230 dsa_port_set_state_now(dp, BR_STATE_FORWARDING, false); 231 232 if (dp->pl) 233 phylink_start(dp->pl); 234 235 return 0; 236} 237 238int dsa_port_enable(struct dsa_port *dp, struct phy_device *phy) 239{ 240 int err; 241 242 rtnl_lock(); 243 err = dsa_port_enable_rt(dp, phy); 244 rtnl_unlock(); 245 246 return err; 247} 248 249void dsa_port_disable_rt(struct dsa_port *dp) 250{ 251 struct dsa_switch *ds = dp->ds; 252 int port = dp->index; 253 254 if (dp->pl) 255 phylink_stop(dp->pl); 256 257 if (!dp->bridge) 258 dsa_port_set_state_now(dp, BR_STATE_DISABLED, false); 259 260 if (ds->ops->port_disable) 261 ds->ops->port_disable(ds, port); 262} 263 264void dsa_port_disable(struct dsa_port *dp) 265{ 266 rtnl_lock(); 267 dsa_port_disable_rt(dp); 268 rtnl_unlock(); 269} 270 271static void dsa_port_reset_vlan_filtering(struct dsa_port *dp, 272 struct dsa_bridge bridge) 273{ 274 struct netlink_ext_ack extack = {0}; 275 bool change_vlan_filtering = false; 276 struct dsa_switch *ds = dp->ds; 277 struct dsa_port *other_dp; 278 bool vlan_filtering; 279 int err; 280 281 if (ds->needs_standalone_vlan_filtering && 282 !br_vlan_enabled(bridge.dev)) { 283 change_vlan_filtering = true; 284 vlan_filtering = true; 285 } else if (!ds->needs_standalone_vlan_filtering && 286 br_vlan_enabled(bridge.dev)) { 287 change_vlan_filtering = true; 288 vlan_filtering = false; 289 } 290 291 /* If the bridge was vlan_filtering, the bridge core doesn't trigger an 292 * event for changing vlan_filtering setting upon user ports leaving 293 * it. That is a good thing, because that lets us handle it and also 294 * handle the case where the switch's vlan_filtering setting is global 295 * (not per port). When that happens, the correct moment to trigger the 296 * vlan_filtering callback is only when the last port leaves the last 297 * VLAN-aware bridge. 298 */ 299 if (change_vlan_filtering && ds->vlan_filtering_is_global) { 300 dsa_switch_for_each_port(other_dp, ds) { 301 struct net_device *br = dsa_port_bridge_dev_get(other_dp); 302 303 if (br && br_vlan_enabled(br)) { 304 change_vlan_filtering = false; 305 break; 306 } 307 } 308 } 309 310 if (!change_vlan_filtering) 311 return; 312 313 err = dsa_port_vlan_filtering(dp, vlan_filtering, &extack); 314 if (extack._msg) { 315 dev_err(ds->dev, "port %d: %s\n", dp->index, 316 extack._msg); 317 } 318 if (err && err != -EOPNOTSUPP) { 319 dev_err(ds->dev, 320 "port %d failed to reset VLAN filtering to %d: %pe\n", 321 dp->index, vlan_filtering, ERR_PTR(err)); 322 } 323} 324 325static int dsa_port_inherit_brport_flags(struct dsa_port *dp, 326 struct netlink_ext_ack *extack) 327{ 328 const unsigned long mask = BR_LEARNING | BR_FLOOD | BR_MCAST_FLOOD | 329 BR_BCAST_FLOOD | BR_PORT_LOCKED; 330 struct net_device *brport_dev = dsa_port_to_bridge_port(dp); 331 int flag, err; 332 333 for_each_set_bit(flag, &mask, 32) { 334 struct switchdev_brport_flags flags = {0}; 335 336 flags.mask = BIT(flag); 337 338 if (br_port_flag_is_set(brport_dev, BIT(flag))) 339 flags.val = BIT(flag); 340 341 err = dsa_port_bridge_flags(dp, flags, extack); 342 if (err && err != -EOPNOTSUPP) 343 return err; 344 } 345 346 return 0; 347} 348 349static void dsa_port_clear_brport_flags(struct dsa_port *dp) 350{ 351 const unsigned long val = BR_FLOOD | BR_MCAST_FLOOD | BR_BCAST_FLOOD; 352 const unsigned long mask = BR_LEARNING | BR_FLOOD | BR_MCAST_FLOOD | 353 BR_BCAST_FLOOD | BR_PORT_LOCKED; 354 int flag, err; 355 356 for_each_set_bit(flag, &mask, 32) { 357 struct switchdev_brport_flags flags = {0}; 358 359 flags.mask = BIT(flag); 360 flags.val = val & BIT(flag); 361 362 err = dsa_port_bridge_flags(dp, flags, NULL); 363 if (err && err != -EOPNOTSUPP) 364 dev_err(dp->ds->dev, 365 "failed to clear bridge port flag %lu: %pe\n", 366 flags.val, ERR_PTR(err)); 367 } 368} 369 370static int dsa_port_switchdev_sync_attrs(struct dsa_port *dp, 371 struct netlink_ext_ack *extack) 372{ 373 struct net_device *brport_dev = dsa_port_to_bridge_port(dp); 374 struct net_device *br = dsa_port_bridge_dev_get(dp); 375 int err; 376 377 err = dsa_port_inherit_brport_flags(dp, extack); 378 if (err) 379 return err; 380 381 err = dsa_port_set_state(dp, br_port_get_stp_state(brport_dev), false); 382 if (err && err != -EOPNOTSUPP) 383 return err; 384 385 err = dsa_port_vlan_filtering(dp, br_vlan_enabled(br), extack); 386 if (err && err != -EOPNOTSUPP) 387 return err; 388 389 err = dsa_port_ageing_time(dp, br_get_ageing_time(br)); 390 if (err && err != -EOPNOTSUPP) 391 return err; 392 393 return 0; 394} 395 396static void dsa_port_switchdev_unsync_attrs(struct dsa_port *dp, 397 struct dsa_bridge bridge) 398{ 399 /* Configure the port for standalone mode (no address learning, 400 * flood everything). 401 * The bridge only emits SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS events 402 * when the user requests it through netlink or sysfs, but not 403 * automatically at port join or leave, so we need to handle resetting 404 * the brport flags ourselves. But we even prefer it that way, because 405 * otherwise, some setups might never get the notification they need, 406 * for example, when a port leaves a LAG that offloads the bridge, 407 * it becomes standalone, but as far as the bridge is concerned, no 408 * port ever left. 409 */ 410 dsa_port_clear_brport_flags(dp); 411 412 /* Port left the bridge, put in BR_STATE_DISABLED by the bridge layer, 413 * so allow it to be in BR_STATE_FORWARDING to be kept functional 414 */ 415 dsa_port_set_state_now(dp, BR_STATE_FORWARDING, true); 416 417 dsa_port_reset_vlan_filtering(dp, bridge); 418 419 /* Ageing time may be global to the switch chip, so don't change it 420 * here because we have no good reason (or value) to change it to. 421 */ 422} 423 424static int dsa_port_bridge_create(struct dsa_port *dp, 425 struct net_device *br, 426 struct netlink_ext_ack *extack) 427{ 428 struct dsa_switch *ds = dp->ds; 429 struct dsa_bridge *bridge; 430 431 bridge = dsa_tree_bridge_find(ds->dst, br); 432 if (bridge) { 433 refcount_inc(&bridge->refcount); 434 dp->bridge = bridge; 435 return 0; 436 } 437 438 bridge = kzalloc(sizeof(*bridge), GFP_KERNEL); 439 if (!bridge) 440 return -ENOMEM; 441 442 refcount_set(&bridge->refcount, 1); 443 444 bridge->dev = br; 445 446 bridge->num = dsa_bridge_num_get(br, ds->max_num_bridges); 447 if (ds->max_num_bridges && !bridge->num) { 448 NL_SET_ERR_MSG_MOD(extack, 449 "Range of offloadable bridges exceeded"); 450 kfree(bridge); 451 return -EOPNOTSUPP; 452 } 453 454 dp->bridge = bridge; 455 456 return 0; 457} 458 459static void dsa_port_bridge_destroy(struct dsa_port *dp, 460 const struct net_device *br) 461{ 462 struct dsa_bridge *bridge = dp->bridge; 463 464 dp->bridge = NULL; 465 466 if (!refcount_dec_and_test(&bridge->refcount)) 467 return; 468 469 if (bridge->num) 470 dsa_bridge_num_put(br, bridge->num); 471 472 kfree(bridge); 473} 474 475static bool dsa_port_supports_mst(struct dsa_port *dp) 476{ 477 struct dsa_switch *ds = dp->ds; 478 479 return ds->ops->vlan_msti_set && 480 ds->ops->port_mst_state_set && 481 ds->ops->port_vlan_fast_age && 482 dsa_port_can_configure_learning(dp); 483} 484 485int dsa_port_bridge_join(struct dsa_port *dp, struct net_device *br, 486 struct netlink_ext_ack *extack) 487{ 488 struct dsa_notifier_bridge_info info = { 489 .dp = dp, 490 .extack = extack, 491 }; 492 struct net_device *dev = dp->user; 493 struct net_device *brport_dev; 494 int err; 495 496 if (br_mst_enabled(br) && !dsa_port_supports_mst(dp)) 497 return -EOPNOTSUPP; 498 499 /* Here the interface is already bridged. Reflect the current 500 * configuration so that drivers can program their chips accordingly. 501 */ 502 err = dsa_port_bridge_create(dp, br, extack); 503 if (err) 504 return err; 505 506 brport_dev = dsa_port_to_bridge_port(dp); 507 508 info.bridge = *dp->bridge; 509 err = dsa_broadcast(DSA_NOTIFIER_BRIDGE_JOIN, &info); 510 if (err) 511 goto out_rollback; 512 513 /* Drivers which support bridge TX forwarding should set this */ 514 dp->bridge->tx_fwd_offload = info.tx_fwd_offload; 515 516 err = switchdev_bridge_port_offload(brport_dev, dev, dp, 517 &dsa_user_switchdev_notifier, 518 &dsa_user_switchdev_blocking_notifier, 519 dp->bridge->tx_fwd_offload, extack); 520 if (err) 521 goto out_rollback_unbridge; 522 523 err = dsa_port_switchdev_sync_attrs(dp, extack); 524 if (err) 525 goto out_rollback_unoffload; 526 527 return 0; 528 529out_rollback_unoffload: 530 switchdev_bridge_port_unoffload(brport_dev, dp, 531 &dsa_user_switchdev_notifier, 532 &dsa_user_switchdev_blocking_notifier); 533 dsa_flush_workqueue(); 534out_rollback_unbridge: 535 dsa_broadcast(DSA_NOTIFIER_BRIDGE_LEAVE, &info); 536out_rollback: 537 dsa_port_bridge_destroy(dp, br); 538 return err; 539} 540 541void dsa_port_pre_bridge_leave(struct dsa_port *dp, struct net_device *br) 542{ 543 struct net_device *brport_dev = dsa_port_to_bridge_port(dp); 544 545 /* Don't try to unoffload something that is not offloaded */ 546 if (!brport_dev) 547 return; 548 549 switchdev_bridge_port_unoffload(brport_dev, dp, 550 &dsa_user_switchdev_notifier, 551 &dsa_user_switchdev_blocking_notifier); 552 553 dsa_flush_workqueue(); 554} 555 556void dsa_port_bridge_leave(struct dsa_port *dp, struct net_device *br) 557{ 558 struct dsa_notifier_bridge_info info = { 559 .dp = dp, 560 }; 561 int err; 562 563 /* If the port could not be offloaded to begin with, then 564 * there is nothing to do. 565 */ 566 if (!dp->bridge) 567 return; 568 569 info.bridge = *dp->bridge; 570 571 /* Here the port is already unbridged. Reflect the current configuration 572 * so that drivers can program their chips accordingly. 573 */ 574 dsa_port_bridge_destroy(dp, br); 575 576 err = dsa_broadcast(DSA_NOTIFIER_BRIDGE_LEAVE, &info); 577 if (err) 578 dev_err(dp->ds->dev, 579 "port %d failed to notify DSA_NOTIFIER_BRIDGE_LEAVE: %pe\n", 580 dp->index, ERR_PTR(err)); 581 582 dsa_port_switchdev_unsync_attrs(dp, info.bridge); 583} 584 585int dsa_port_lag_change(struct dsa_port *dp, 586 struct netdev_lag_lower_state_info *linfo) 587{ 588 struct dsa_notifier_lag_info info = { 589 .dp = dp, 590 }; 591 bool tx_enabled; 592 593 if (!dp->lag) 594 return 0; 595 596 /* On statically configured aggregates (e.g. loadbalance 597 * without LACP) ports will always be tx_enabled, even if the 598 * link is down. Thus we require both link_up and tx_enabled 599 * in order to include it in the tx set. 600 */ 601 tx_enabled = linfo->link_up && linfo->tx_enabled; 602 603 if (tx_enabled == dp->lag_tx_enabled) 604 return 0; 605 606 dp->lag_tx_enabled = tx_enabled; 607 608 return dsa_port_notify(dp, DSA_NOTIFIER_LAG_CHANGE, &info); 609} 610 611static int dsa_port_lag_create(struct dsa_port *dp, 612 struct net_device *lag_dev) 613{ 614 struct dsa_switch *ds = dp->ds; 615 struct dsa_lag *lag; 616 617 lag = dsa_tree_lag_find(ds->dst, lag_dev); 618 if (lag) { 619 refcount_inc(&lag->refcount); 620 dp->lag = lag; 621 return 0; 622 } 623 624 lag = kzalloc(sizeof(*lag), GFP_KERNEL); 625 if (!lag) 626 return -ENOMEM; 627 628 refcount_set(&lag->refcount, 1); 629 mutex_init(&lag->fdb_lock); 630 INIT_LIST_HEAD(&lag->fdbs); 631 lag->dev = lag_dev; 632 dsa_lag_map(ds->dst, lag); 633 dp->lag = lag; 634 635 return 0; 636} 637 638static void dsa_port_lag_destroy(struct dsa_port *dp) 639{ 640 struct dsa_lag *lag = dp->lag; 641 642 dp->lag = NULL; 643 dp->lag_tx_enabled = false; 644 645 if (!refcount_dec_and_test(&lag->refcount)) 646 return; 647 648 WARN_ON(!list_empty(&lag->fdbs)); 649 dsa_lag_unmap(dp->ds->dst, lag); 650 kfree(lag); 651} 652 653int dsa_port_lag_join(struct dsa_port *dp, struct net_device *lag_dev, 654 struct netdev_lag_upper_info *uinfo, 655 struct netlink_ext_ack *extack) 656{ 657 struct dsa_notifier_lag_info info = { 658 .dp = dp, 659 .info = uinfo, 660 .extack = extack, 661 }; 662 struct net_device *bridge_dev; 663 int err; 664 665 err = dsa_port_lag_create(dp, lag_dev); 666 if (err) 667 goto err_lag_create; 668 669 info.lag = *dp->lag; 670 err = dsa_port_notify(dp, DSA_NOTIFIER_LAG_JOIN, &info); 671 if (err) 672 goto err_lag_join; 673 674 bridge_dev = netdev_master_upper_dev_get(lag_dev); 675 if (!bridge_dev || !netif_is_bridge_master(bridge_dev)) 676 return 0; 677 678 err = dsa_port_bridge_join(dp, bridge_dev, extack); 679 if (err) 680 goto err_bridge_join; 681 682 return 0; 683 684err_bridge_join: 685 dsa_port_notify(dp, DSA_NOTIFIER_LAG_LEAVE, &info); 686err_lag_join: 687 dsa_port_lag_destroy(dp); 688err_lag_create: 689 return err; 690} 691 692void dsa_port_pre_lag_leave(struct dsa_port *dp, struct net_device *lag_dev) 693{ 694 struct net_device *br = dsa_port_bridge_dev_get(dp); 695 696 if (br) 697 dsa_port_pre_bridge_leave(dp, br); 698} 699 700void dsa_port_lag_leave(struct dsa_port *dp, struct net_device *lag_dev) 701{ 702 struct net_device *br = dsa_port_bridge_dev_get(dp); 703 struct dsa_notifier_lag_info info = { 704 .dp = dp, 705 }; 706 int err; 707 708 if (!dp->lag) 709 return; 710 711 /* Port might have been part of a LAG that in turn was 712 * attached to a bridge. 713 */ 714 if (br) 715 dsa_port_bridge_leave(dp, br); 716 717 info.lag = *dp->lag; 718 719 dsa_port_lag_destroy(dp); 720 721 err = dsa_port_notify(dp, DSA_NOTIFIER_LAG_LEAVE, &info); 722 if (err) 723 dev_err(dp->ds->dev, 724 "port %d failed to notify DSA_NOTIFIER_LAG_LEAVE: %pe\n", 725 dp->index, ERR_PTR(err)); 726} 727 728/* Must be called under rcu_read_lock() */ 729static bool dsa_port_can_apply_vlan_filtering(struct dsa_port *dp, 730 bool vlan_filtering, 731 struct netlink_ext_ack *extack) 732{ 733 struct dsa_switch *ds = dp->ds; 734 struct dsa_port *other_dp; 735 int err; 736 737 /* VLAN awareness was off, so the question is "can we turn it on". 738 * We may have had 8021q uppers, those need to go. Make sure we don't 739 * enter an inconsistent state: deny changing the VLAN awareness state 740 * as long as we have 8021q uppers. 741 */ 742 if (vlan_filtering && dsa_port_is_user(dp)) { 743 struct net_device *br = dsa_port_bridge_dev_get(dp); 744 struct net_device *upper_dev, *user = dp->user; 745 struct list_head *iter; 746 747 netdev_for_each_upper_dev_rcu(user, upper_dev, iter) { 748 struct bridge_vlan_info br_info; 749 u16 vid; 750 751 if (!is_vlan_dev(upper_dev)) 752 continue; 753 754 vid = vlan_dev_vlan_id(upper_dev); 755 756 /* br_vlan_get_info() returns -EINVAL or -ENOENT if the 757 * device, respectively the VID is not found, returning 758 * 0 means success, which is a failure for us here. 759 */ 760 err = br_vlan_get_info(br, vid, &br_info); 761 if (err == 0) { 762 NL_SET_ERR_MSG_MOD(extack, 763 "Must first remove VLAN uppers having VIDs also present in bridge"); 764 return false; 765 } 766 } 767 } 768 769 if (!ds->vlan_filtering_is_global) 770 return true; 771 772 /* For cases where enabling/disabling VLAN awareness is global to the 773 * switch, we need to handle the case where multiple bridges span 774 * different ports of the same switch device and one of them has a 775 * different setting than what is being requested. 776 */ 777 dsa_switch_for_each_port(other_dp, ds) { 778 struct net_device *other_br = dsa_port_bridge_dev_get(other_dp); 779 780 /* If it's the same bridge, it also has same 781 * vlan_filtering setting => no need to check 782 */ 783 if (!other_br || other_br == dsa_port_bridge_dev_get(dp)) 784 continue; 785 786 if (br_vlan_enabled(other_br) != vlan_filtering) { 787 NL_SET_ERR_MSG_MOD(extack, 788 "VLAN filtering is a global setting"); 789 return false; 790 } 791 } 792 return true; 793} 794 795int dsa_port_vlan_filtering(struct dsa_port *dp, bool vlan_filtering, 796 struct netlink_ext_ack *extack) 797{ 798 bool old_vlan_filtering = dsa_port_is_vlan_filtering(dp); 799 struct dsa_switch *ds = dp->ds; 800 bool apply; 801 int err; 802 803 if (!ds->ops->port_vlan_filtering) 804 return -EOPNOTSUPP; 805 806 /* We are called from dsa_user_switchdev_blocking_event(), 807 * which is not under rcu_read_lock(), unlike 808 * dsa_user_switchdev_event(). 809 */ 810 rcu_read_lock(); 811 apply = dsa_port_can_apply_vlan_filtering(dp, vlan_filtering, extack); 812 rcu_read_unlock(); 813 if (!apply) 814 return -EINVAL; 815 816 if (dsa_port_is_vlan_filtering(dp) == vlan_filtering) 817 return 0; 818 819 err = ds->ops->port_vlan_filtering(ds, dp->index, vlan_filtering, 820 extack); 821 if (err) 822 return err; 823 824 if (ds->vlan_filtering_is_global) { 825 struct dsa_port *other_dp; 826 827 ds->vlan_filtering = vlan_filtering; 828 829 dsa_switch_for_each_user_port(other_dp, ds) { 830 struct net_device *user = other_dp->user; 831 832 /* We might be called in the unbind path, so not 833 * all user devices might still be registered. 834 */ 835 if (!user) 836 continue; 837 838 err = dsa_user_manage_vlan_filtering(user, 839 vlan_filtering); 840 if (err) 841 goto restore; 842 } 843 } else { 844 dp->vlan_filtering = vlan_filtering; 845 846 err = dsa_user_manage_vlan_filtering(dp->user, 847 vlan_filtering); 848 if (err) 849 goto restore; 850 } 851 852 return 0; 853 854restore: 855 ds->ops->port_vlan_filtering(ds, dp->index, old_vlan_filtering, NULL); 856 857 if (ds->vlan_filtering_is_global) 858 ds->vlan_filtering = old_vlan_filtering; 859 else 860 dp->vlan_filtering = old_vlan_filtering; 861 862 return err; 863} 864 865/* This enforces legacy behavior for switch drivers which assume they can't 866 * receive VLAN configuration when joining a bridge with vlan_filtering=0 867 */ 868bool dsa_port_skip_vlan_configuration(struct dsa_port *dp) 869{ 870 struct net_device *br = dsa_port_bridge_dev_get(dp); 871 struct dsa_switch *ds = dp->ds; 872 873 if (!br) 874 return false; 875 876 return !ds->configure_vlan_while_not_filtering && !br_vlan_enabled(br); 877} 878 879int dsa_port_ageing_time(struct dsa_port *dp, clock_t ageing_clock) 880{ 881 unsigned long ageing_jiffies = clock_t_to_jiffies(ageing_clock); 882 unsigned int ageing_time = jiffies_to_msecs(ageing_jiffies); 883 struct dsa_notifier_ageing_time_info info; 884 int err; 885 886 info.ageing_time = ageing_time; 887 888 err = dsa_port_notify(dp, DSA_NOTIFIER_AGEING_TIME, &info); 889 if (err) 890 return err; 891 892 dp->ageing_time = ageing_time; 893 894 return 0; 895} 896 897int dsa_port_mst_enable(struct dsa_port *dp, bool on, 898 struct netlink_ext_ack *extack) 899{ 900 if (on && !dsa_port_supports_mst(dp)) { 901 NL_SET_ERR_MSG_MOD(extack, "Hardware does not support MST"); 902 return -EINVAL; 903 } 904 905 return 0; 906} 907 908int dsa_port_pre_bridge_flags(const struct dsa_port *dp, 909 struct switchdev_brport_flags flags, 910 struct netlink_ext_ack *extack) 911{ 912 struct dsa_switch *ds = dp->ds; 913 914 if (!ds->ops->port_pre_bridge_flags) 915 return -EINVAL; 916 917 return ds->ops->port_pre_bridge_flags(ds, dp->index, flags, extack); 918} 919 920int dsa_port_bridge_flags(struct dsa_port *dp, 921 struct switchdev_brport_flags flags, 922 struct netlink_ext_ack *extack) 923{ 924 struct dsa_switch *ds = dp->ds; 925 int err; 926 927 if (!ds->ops->port_bridge_flags) 928 return -EOPNOTSUPP; 929 930 err = ds->ops->port_bridge_flags(ds, dp->index, flags, extack); 931 if (err) 932 return err; 933 934 if (flags.mask & BR_LEARNING) { 935 bool learning = flags.val & BR_LEARNING; 936 937 if (learning == dp->learning) 938 return 0; 939 940 if ((dp->learning && !learning) && 941 (dp->stp_state == BR_STATE_LEARNING || 942 dp->stp_state == BR_STATE_FORWARDING)) 943 dsa_port_fast_age(dp); 944 945 dp->learning = learning; 946 } 947 948 return 0; 949} 950 951void dsa_port_set_host_flood(struct dsa_port *dp, bool uc, bool mc) 952{ 953 struct dsa_switch *ds = dp->ds; 954 955 if (ds->ops->port_set_host_flood) 956 ds->ops->port_set_host_flood(ds, dp->index, uc, mc); 957} 958 959int dsa_port_vlan_msti(struct dsa_port *dp, 960 const struct switchdev_vlan_msti *msti) 961{ 962 struct dsa_switch *ds = dp->ds; 963 964 if (!ds->ops->vlan_msti_set) 965 return -EOPNOTSUPP; 966 967 return ds->ops->vlan_msti_set(ds, *dp->bridge, msti); 968} 969 970int dsa_port_mtu_change(struct dsa_port *dp, int new_mtu) 971{ 972 struct dsa_notifier_mtu_info info = { 973 .dp = dp, 974 .mtu = new_mtu, 975 }; 976 977 return dsa_port_notify(dp, DSA_NOTIFIER_MTU, &info); 978} 979 980int dsa_port_fdb_add(struct dsa_port *dp, const unsigned char *addr, 981 u16 vid) 982{ 983 struct dsa_notifier_fdb_info info = { 984 .dp = dp, 985 .addr = addr, 986 .vid = vid, 987 .db = { 988 .type = DSA_DB_BRIDGE, 989 .bridge = *dp->bridge, 990 }, 991 }; 992 993 /* Refcounting takes bridge.num as a key, and should be global for all 994 * bridges in the absence of FDB isolation, and per bridge otherwise. 995 * Force the bridge.num to zero here in the absence of FDB isolation. 996 */ 997 if (!dp->ds->fdb_isolation) 998 info.db.bridge.num = 0; 999 1000 return dsa_port_notify(dp, DSA_NOTIFIER_FDB_ADD, &info); 1001} 1002 1003int dsa_port_fdb_del(struct dsa_port *dp, const unsigned char *addr, 1004 u16 vid) 1005{ 1006 struct dsa_notifier_fdb_info info = { 1007 .dp = dp, 1008 .addr = addr, 1009 .vid = vid, 1010 .db = { 1011 .type = DSA_DB_BRIDGE, 1012 .bridge = *dp->bridge, 1013 }, 1014 }; 1015 1016 if (!dp->ds->fdb_isolation) 1017 info.db.bridge.num = 0; 1018 1019 return dsa_port_notify(dp, DSA_NOTIFIER_FDB_DEL, &info); 1020} 1021 1022static int dsa_port_host_fdb_add(struct dsa_port *dp, 1023 const unsigned char *addr, u16 vid, 1024 struct dsa_db db) 1025{ 1026 struct dsa_notifier_fdb_info info = { 1027 .dp = dp, 1028 .addr = addr, 1029 .vid = vid, 1030 .db = db, 1031 }; 1032 1033 return dsa_port_notify(dp, DSA_NOTIFIER_HOST_FDB_ADD, &info); 1034} 1035 1036int dsa_port_standalone_host_fdb_add(struct dsa_port *dp, 1037 const unsigned char *addr, u16 vid) 1038{ 1039 struct dsa_db db = { 1040 .type = DSA_DB_PORT, 1041 .dp = dp, 1042 }; 1043 1044 return dsa_port_host_fdb_add(dp, addr, vid, db); 1045} 1046 1047int dsa_port_bridge_host_fdb_add(struct dsa_port *dp, 1048 const unsigned char *addr, u16 vid) 1049{ 1050 struct net_device *conduit = dsa_port_to_conduit(dp); 1051 struct dsa_db db = { 1052 .type = DSA_DB_BRIDGE, 1053 .bridge = *dp->bridge, 1054 }; 1055 int err; 1056 1057 if (!dp->ds->fdb_isolation) 1058 db.bridge.num = 0; 1059 1060 /* Avoid a call to __dev_set_promiscuity() on the conduit, which 1061 * requires rtnl_lock(), since we can't guarantee that is held here, 1062 * and we can't take it either. 1063 */ 1064 if (conduit->priv_flags & IFF_UNICAST_FLT) { 1065 err = dev_uc_add(conduit, addr); 1066 if (err) 1067 return err; 1068 } 1069 1070 return dsa_port_host_fdb_add(dp, addr, vid, db); 1071} 1072 1073static int dsa_port_host_fdb_del(struct dsa_port *dp, 1074 const unsigned char *addr, u16 vid, 1075 struct dsa_db db) 1076{ 1077 struct dsa_notifier_fdb_info info = { 1078 .dp = dp, 1079 .addr = addr, 1080 .vid = vid, 1081 .db = db, 1082 }; 1083 1084 return dsa_port_notify(dp, DSA_NOTIFIER_HOST_FDB_DEL, &info); 1085} 1086 1087int dsa_port_standalone_host_fdb_del(struct dsa_port *dp, 1088 const unsigned char *addr, u16 vid) 1089{ 1090 struct dsa_db db = { 1091 .type = DSA_DB_PORT, 1092 .dp = dp, 1093 }; 1094 1095 return dsa_port_host_fdb_del(dp, addr, vid, db); 1096} 1097 1098int dsa_port_bridge_host_fdb_del(struct dsa_port *dp, 1099 const unsigned char *addr, u16 vid) 1100{ 1101 struct net_device *conduit = dsa_port_to_conduit(dp); 1102 struct dsa_db db = { 1103 .type = DSA_DB_BRIDGE, 1104 .bridge = *dp->bridge, 1105 }; 1106 int err; 1107 1108 if (!dp->ds->fdb_isolation) 1109 db.bridge.num = 0; 1110 1111 if (conduit->priv_flags & IFF_UNICAST_FLT) { 1112 err = dev_uc_del(conduit, addr); 1113 if (err) 1114 return err; 1115 } 1116 1117 return dsa_port_host_fdb_del(dp, addr, vid, db); 1118} 1119 1120int dsa_port_lag_fdb_add(struct dsa_port *dp, const unsigned char *addr, 1121 u16 vid) 1122{ 1123 struct dsa_notifier_lag_fdb_info info = { 1124 .lag = dp->lag, 1125 .addr = addr, 1126 .vid = vid, 1127 .db = { 1128 .type = DSA_DB_BRIDGE, 1129 .bridge = *dp->bridge, 1130 }, 1131 }; 1132 1133 if (!dp->ds->fdb_isolation) 1134 info.db.bridge.num = 0; 1135 1136 return dsa_port_notify(dp, DSA_NOTIFIER_LAG_FDB_ADD, &info); 1137} 1138 1139int dsa_port_lag_fdb_del(struct dsa_port *dp, const unsigned char *addr, 1140 u16 vid) 1141{ 1142 struct dsa_notifier_lag_fdb_info info = { 1143 .lag = dp->lag, 1144 .addr = addr, 1145 .vid = vid, 1146 .db = { 1147 .type = DSA_DB_BRIDGE, 1148 .bridge = *dp->bridge, 1149 }, 1150 }; 1151 1152 if (!dp->ds->fdb_isolation) 1153 info.db.bridge.num = 0; 1154 1155 return dsa_port_notify(dp, DSA_NOTIFIER_LAG_FDB_DEL, &info); 1156} 1157 1158int dsa_port_fdb_dump(struct dsa_port *dp, dsa_fdb_dump_cb_t *cb, void *data) 1159{ 1160 struct dsa_switch *ds = dp->ds; 1161 int port = dp->index; 1162 1163 if (!ds->ops->port_fdb_dump) 1164 return -EOPNOTSUPP; 1165 1166 return ds->ops->port_fdb_dump(ds, port, cb, data); 1167} 1168 1169int dsa_port_mdb_add(const struct dsa_port *dp, 1170 const struct switchdev_obj_port_mdb *mdb) 1171{ 1172 struct dsa_notifier_mdb_info info = { 1173 .dp = dp, 1174 .mdb = mdb, 1175 .db = { 1176 .type = DSA_DB_BRIDGE, 1177 .bridge = *dp->bridge, 1178 }, 1179 }; 1180 1181 if (!dp->ds->fdb_isolation) 1182 info.db.bridge.num = 0; 1183 1184 return dsa_port_notify(dp, DSA_NOTIFIER_MDB_ADD, &info); 1185} 1186 1187int dsa_port_mdb_del(const struct dsa_port *dp, 1188 const struct switchdev_obj_port_mdb *mdb) 1189{ 1190 struct dsa_notifier_mdb_info info = { 1191 .dp = dp, 1192 .mdb = mdb, 1193 .db = { 1194 .type = DSA_DB_BRIDGE, 1195 .bridge = *dp->bridge, 1196 }, 1197 }; 1198 1199 if (!dp->ds->fdb_isolation) 1200 info.db.bridge.num = 0; 1201 1202 return dsa_port_notify(dp, DSA_NOTIFIER_MDB_DEL, &info); 1203} 1204 1205static int dsa_port_host_mdb_add(const struct dsa_port *dp, 1206 const struct switchdev_obj_port_mdb *mdb, 1207 struct dsa_db db) 1208{ 1209 struct dsa_notifier_mdb_info info = { 1210 .dp = dp, 1211 .mdb = mdb, 1212 .db = db, 1213 }; 1214 1215 return dsa_port_notify(dp, DSA_NOTIFIER_HOST_MDB_ADD, &info); 1216} 1217 1218int dsa_port_standalone_host_mdb_add(const struct dsa_port *dp, 1219 const struct switchdev_obj_port_mdb *mdb) 1220{ 1221 struct dsa_db db = { 1222 .type = DSA_DB_PORT, 1223 .dp = dp, 1224 }; 1225 1226 return dsa_port_host_mdb_add(dp, mdb, db); 1227} 1228 1229int dsa_port_bridge_host_mdb_add(const struct dsa_port *dp, 1230 const struct switchdev_obj_port_mdb *mdb) 1231{ 1232 struct net_device *conduit = dsa_port_to_conduit(dp); 1233 struct dsa_db db = { 1234 .type = DSA_DB_BRIDGE, 1235 .bridge = *dp->bridge, 1236 }; 1237 int err; 1238 1239 if (!dp->ds->fdb_isolation) 1240 db.bridge.num = 0; 1241 1242 err = dev_mc_add(conduit, mdb->addr); 1243 if (err) 1244 return err; 1245 1246 return dsa_port_host_mdb_add(dp, mdb, db); 1247} 1248 1249static int dsa_port_host_mdb_del(const struct dsa_port *dp, 1250 const struct switchdev_obj_port_mdb *mdb, 1251 struct dsa_db db) 1252{ 1253 struct dsa_notifier_mdb_info info = { 1254 .dp = dp, 1255 .mdb = mdb, 1256 .db = db, 1257 }; 1258 1259 return dsa_port_notify(dp, DSA_NOTIFIER_HOST_MDB_DEL, &info); 1260} 1261 1262int dsa_port_standalone_host_mdb_del(const struct dsa_port *dp, 1263 const struct switchdev_obj_port_mdb *mdb) 1264{ 1265 struct dsa_db db = { 1266 .type = DSA_DB_PORT, 1267 .dp = dp, 1268 }; 1269 1270 return dsa_port_host_mdb_del(dp, mdb, db); 1271} 1272 1273int dsa_port_bridge_host_mdb_del(const struct dsa_port *dp, 1274 const struct switchdev_obj_port_mdb *mdb) 1275{ 1276 struct net_device *conduit = dsa_port_to_conduit(dp); 1277 struct dsa_db db = { 1278 .type = DSA_DB_BRIDGE, 1279 .bridge = *dp->bridge, 1280 }; 1281 int err; 1282 1283 if (!dp->ds->fdb_isolation) 1284 db.bridge.num = 0; 1285 1286 err = dev_mc_del(conduit, mdb->addr); 1287 if (err) 1288 return err; 1289 1290 return dsa_port_host_mdb_del(dp, mdb, db); 1291} 1292 1293int dsa_port_vlan_add(struct dsa_port *dp, 1294 const struct switchdev_obj_port_vlan *vlan, 1295 struct netlink_ext_ack *extack) 1296{ 1297 struct dsa_notifier_vlan_info info = { 1298 .dp = dp, 1299 .vlan = vlan, 1300 .extack = extack, 1301 }; 1302 1303 return dsa_port_notify(dp, DSA_NOTIFIER_VLAN_ADD, &info); 1304} 1305 1306int dsa_port_vlan_del(struct dsa_port *dp, 1307 const struct switchdev_obj_port_vlan *vlan) 1308{ 1309 struct dsa_notifier_vlan_info info = { 1310 .dp = dp, 1311 .vlan = vlan, 1312 }; 1313 1314 return dsa_port_notify(dp, DSA_NOTIFIER_VLAN_DEL, &info); 1315} 1316 1317int dsa_port_host_vlan_add(struct dsa_port *dp, 1318 const struct switchdev_obj_port_vlan *vlan, 1319 struct netlink_ext_ack *extack) 1320{ 1321 struct net_device *conduit = dsa_port_to_conduit(dp); 1322 struct dsa_notifier_vlan_info info = { 1323 .dp = dp, 1324 .vlan = vlan, 1325 .extack = extack, 1326 }; 1327 int err; 1328 1329 err = dsa_port_notify(dp, DSA_NOTIFIER_HOST_VLAN_ADD, &info); 1330 if (err && err != -EOPNOTSUPP) 1331 return err; 1332 1333 vlan_vid_add(conduit, htons(ETH_P_8021Q), vlan->vid); 1334 1335 return err; 1336} 1337 1338int dsa_port_host_vlan_del(struct dsa_port *dp, 1339 const struct switchdev_obj_port_vlan *vlan) 1340{ 1341 struct net_device *conduit = dsa_port_to_conduit(dp); 1342 struct dsa_notifier_vlan_info info = { 1343 .dp = dp, 1344 .vlan = vlan, 1345 }; 1346 int err; 1347 1348 err = dsa_port_notify(dp, DSA_NOTIFIER_HOST_VLAN_DEL, &info); 1349 if (err && err != -EOPNOTSUPP) 1350 return err; 1351 1352 vlan_vid_del(conduit, htons(ETH_P_8021Q), vlan->vid); 1353 1354 return err; 1355} 1356 1357int dsa_port_mrp_add(const struct dsa_port *dp, 1358 const struct switchdev_obj_mrp *mrp) 1359{ 1360 struct dsa_switch *ds = dp->ds; 1361 1362 if (!ds->ops->port_mrp_add) 1363 return -EOPNOTSUPP; 1364 1365 return ds->ops->port_mrp_add(ds, dp->index, mrp); 1366} 1367 1368int dsa_port_mrp_del(const struct dsa_port *dp, 1369 const struct switchdev_obj_mrp *mrp) 1370{ 1371 struct dsa_switch *ds = dp->ds; 1372 1373 if (!ds->ops->port_mrp_del) 1374 return -EOPNOTSUPP; 1375 1376 return ds->ops->port_mrp_del(ds, dp->index, mrp); 1377} 1378 1379int dsa_port_mrp_add_ring_role(const struct dsa_port *dp, 1380 const struct switchdev_obj_ring_role_mrp *mrp) 1381{ 1382 struct dsa_switch *ds = dp->ds; 1383 1384 if (!ds->ops->port_mrp_add_ring_role) 1385 return -EOPNOTSUPP; 1386 1387 return ds->ops->port_mrp_add_ring_role(ds, dp->index, mrp); 1388} 1389 1390int dsa_port_mrp_del_ring_role(const struct dsa_port *dp, 1391 const struct switchdev_obj_ring_role_mrp *mrp) 1392{ 1393 struct dsa_switch *ds = dp->ds; 1394 1395 if (!ds->ops->port_mrp_del_ring_role) 1396 return -EOPNOTSUPP; 1397 1398 return ds->ops->port_mrp_del_ring_role(ds, dp->index, mrp); 1399} 1400 1401static int dsa_port_assign_conduit(struct dsa_port *dp, 1402 struct net_device *conduit, 1403 struct netlink_ext_ack *extack, 1404 bool fail_on_err) 1405{ 1406 struct dsa_switch *ds = dp->ds; 1407 int port = dp->index, err; 1408 1409 err = ds->ops->port_change_conduit(ds, port, conduit, extack); 1410 if (err && !fail_on_err) 1411 dev_err(ds->dev, "port %d failed to assign conduit %s: %pe\n", 1412 port, conduit->name, ERR_PTR(err)); 1413 1414 if (err && fail_on_err) 1415 return err; 1416 1417 dp->cpu_dp = conduit->dsa_ptr; 1418 dp->cpu_port_in_lag = netif_is_lag_master(conduit); 1419 1420 return 0; 1421} 1422 1423/* Change the dp->cpu_dp affinity for a user port. Note that both cross-chip 1424 * notifiers and drivers have implicit assumptions about user-to-CPU-port 1425 * mappings, so we unfortunately cannot delay the deletion of the objects 1426 * (switchdev, standalone addresses, standalone VLANs) on the old CPU port 1427 * until the new CPU port has been set up. So we need to completely tear down 1428 * the old CPU port before changing it, and restore it on errors during the 1429 * bringup of the new one. 1430 */ 1431int dsa_port_change_conduit(struct dsa_port *dp, struct net_device *conduit, 1432 struct netlink_ext_ack *extack) 1433{ 1434 struct net_device *bridge_dev = dsa_port_bridge_dev_get(dp); 1435 struct net_device *old_conduit = dsa_port_to_conduit(dp); 1436 struct net_device *dev = dp->user; 1437 struct dsa_switch *ds = dp->ds; 1438 bool vlan_filtering; 1439 int err, tmp; 1440 1441 /* Bridges may hold host FDB, MDB and VLAN objects. These need to be 1442 * migrated, so dynamically unoffload and later reoffload the bridge 1443 * port. 1444 */ 1445 if (bridge_dev) { 1446 dsa_port_pre_bridge_leave(dp, bridge_dev); 1447 dsa_port_bridge_leave(dp, bridge_dev); 1448 } 1449 1450 /* The port might still be VLAN filtering even if it's no longer 1451 * under a bridge, either due to ds->vlan_filtering_is_global or 1452 * ds->needs_standalone_vlan_filtering. In turn this means VLANs 1453 * on the CPU port. 1454 */ 1455 vlan_filtering = dsa_port_is_vlan_filtering(dp); 1456 if (vlan_filtering) { 1457 err = dsa_user_manage_vlan_filtering(dev, false); 1458 if (err) { 1459 NL_SET_ERR_MSG_MOD(extack, 1460 "Failed to remove standalone VLANs"); 1461 goto rewind_old_bridge; 1462 } 1463 } 1464 1465 /* Standalone addresses, and addresses of upper interfaces like 1466 * VLAN, LAG, HSR need to be migrated. 1467 */ 1468 dsa_user_unsync_ha(dev); 1469 1470 err = dsa_port_assign_conduit(dp, conduit, extack, true); 1471 if (err) 1472 goto rewind_old_addrs; 1473 1474 dsa_user_sync_ha(dev); 1475 1476 if (vlan_filtering) { 1477 err = dsa_user_manage_vlan_filtering(dev, true); 1478 if (err) { 1479 NL_SET_ERR_MSG_MOD(extack, 1480 "Failed to restore standalone VLANs"); 1481 goto rewind_new_addrs; 1482 } 1483 } 1484 1485 if (bridge_dev) { 1486 err = dsa_port_bridge_join(dp, bridge_dev, extack); 1487 if (err && err == -EOPNOTSUPP) { 1488 NL_SET_ERR_MSG_MOD(extack, 1489 "Failed to reoffload bridge"); 1490 goto rewind_new_vlan; 1491 } 1492 } 1493 1494 return 0; 1495 1496rewind_new_vlan: 1497 if (vlan_filtering) 1498 dsa_user_manage_vlan_filtering(dev, false); 1499 1500rewind_new_addrs: 1501 dsa_user_unsync_ha(dev); 1502 1503 dsa_port_assign_conduit(dp, old_conduit, NULL, false); 1504 1505/* Restore the objects on the old CPU port */ 1506rewind_old_addrs: 1507 dsa_user_sync_ha(dev); 1508 1509 if (vlan_filtering) { 1510 tmp = dsa_user_manage_vlan_filtering(dev, true); 1511 if (tmp) { 1512 dev_err(ds->dev, 1513 "port %d failed to restore standalone VLANs: %pe\n", 1514 dp->index, ERR_PTR(tmp)); 1515 } 1516 } 1517 1518rewind_old_bridge: 1519 if (bridge_dev) { 1520 tmp = dsa_port_bridge_join(dp, bridge_dev, extack); 1521 if (tmp) { 1522 dev_err(ds->dev, 1523 "port %d failed to rejoin bridge %s: %pe\n", 1524 dp->index, bridge_dev->name, ERR_PTR(tmp)); 1525 } 1526 } 1527 1528 return err; 1529} 1530 1531void dsa_port_set_tag_protocol(struct dsa_port *cpu_dp, 1532 const struct dsa_device_ops *tag_ops) 1533{ 1534 cpu_dp->rcv = tag_ops->rcv; 1535 cpu_dp->tag_ops = tag_ops; 1536} 1537 1538static struct phy_device *dsa_port_get_phy_device(struct dsa_port *dp) 1539{ 1540 struct device_node *phy_dn; 1541 struct phy_device *phydev; 1542 1543 phy_dn = of_parse_phandle(dp->dn, "phy-handle", 0); 1544 if (!phy_dn) 1545 return NULL; 1546 1547 phydev = of_phy_find_device(phy_dn); 1548 if (!phydev) { 1549 of_node_put(phy_dn); 1550 return ERR_PTR(-EPROBE_DEFER); 1551 } 1552 1553 of_node_put(phy_dn); 1554 return phydev; 1555} 1556 1557static struct phylink_pcs * 1558dsa_port_phylink_mac_select_pcs(struct phylink_config *config, 1559 phy_interface_t interface) 1560{ 1561 struct dsa_port *dp = container_of(config, struct dsa_port, pl_config); 1562 struct phylink_pcs *pcs = ERR_PTR(-EOPNOTSUPP); 1563 struct dsa_switch *ds = dp->ds; 1564 1565 if (ds->ops->phylink_mac_select_pcs) 1566 pcs = ds->ops->phylink_mac_select_pcs(ds, dp->index, interface); 1567 1568 return pcs; 1569} 1570 1571static int dsa_port_phylink_mac_prepare(struct phylink_config *config, 1572 unsigned int mode, 1573 phy_interface_t interface) 1574{ 1575 struct dsa_port *dp = container_of(config, struct dsa_port, pl_config); 1576 struct dsa_switch *ds = dp->ds; 1577 int err = 0; 1578 1579 if (ds->ops->phylink_mac_prepare) 1580 err = ds->ops->phylink_mac_prepare(ds, dp->index, mode, 1581 interface); 1582 1583 return err; 1584} 1585 1586static void dsa_port_phylink_mac_config(struct phylink_config *config, 1587 unsigned int mode, 1588 const struct phylink_link_state *state) 1589{ 1590 struct dsa_port *dp = container_of(config, struct dsa_port, pl_config); 1591 struct dsa_switch *ds = dp->ds; 1592 1593 if (!ds->ops->phylink_mac_config) 1594 return; 1595 1596 ds->ops->phylink_mac_config(ds, dp->index, mode, state); 1597} 1598 1599static int dsa_port_phylink_mac_finish(struct phylink_config *config, 1600 unsigned int mode, 1601 phy_interface_t interface) 1602{ 1603 struct dsa_port *dp = container_of(config, struct dsa_port, pl_config); 1604 struct dsa_switch *ds = dp->ds; 1605 int err = 0; 1606 1607 if (ds->ops->phylink_mac_finish) 1608 err = ds->ops->phylink_mac_finish(ds, dp->index, mode, 1609 interface); 1610 1611 return err; 1612} 1613 1614static void dsa_port_phylink_mac_link_down(struct phylink_config *config, 1615 unsigned int mode, 1616 phy_interface_t interface) 1617{ 1618 struct dsa_port *dp = container_of(config, struct dsa_port, pl_config); 1619 struct phy_device *phydev = NULL; 1620 struct dsa_switch *ds = dp->ds; 1621 1622 if (dsa_port_is_user(dp)) 1623 phydev = dp->user->phydev; 1624 1625 if (!ds->ops->phylink_mac_link_down) { 1626 if (ds->ops->adjust_link && phydev) 1627 ds->ops->adjust_link(ds, dp->index, phydev); 1628 return; 1629 } 1630 1631 ds->ops->phylink_mac_link_down(ds, dp->index, mode, interface); 1632} 1633 1634static void dsa_port_phylink_mac_link_up(struct phylink_config *config, 1635 struct phy_device *phydev, 1636 unsigned int mode, 1637 phy_interface_t interface, 1638 int speed, int duplex, 1639 bool tx_pause, bool rx_pause) 1640{ 1641 struct dsa_port *dp = container_of(config, struct dsa_port, pl_config); 1642 struct dsa_switch *ds = dp->ds; 1643 1644 if (!ds->ops->phylink_mac_link_up) { 1645 if (ds->ops->adjust_link && phydev) 1646 ds->ops->adjust_link(ds, dp->index, phydev); 1647 return; 1648 } 1649 1650 ds->ops->phylink_mac_link_up(ds, dp->index, mode, interface, phydev, 1651 speed, duplex, tx_pause, rx_pause); 1652} 1653 1654static const struct phylink_mac_ops dsa_port_phylink_mac_ops = { 1655 .mac_select_pcs = dsa_port_phylink_mac_select_pcs, 1656 .mac_prepare = dsa_port_phylink_mac_prepare, 1657 .mac_config = dsa_port_phylink_mac_config, 1658 .mac_finish = dsa_port_phylink_mac_finish, 1659 .mac_link_down = dsa_port_phylink_mac_link_down, 1660 .mac_link_up = dsa_port_phylink_mac_link_up, 1661}; 1662 1663int dsa_port_phylink_create(struct dsa_port *dp) 1664{ 1665 struct dsa_switch *ds = dp->ds; 1666 phy_interface_t mode; 1667 struct phylink *pl; 1668 int err; 1669 1670 err = of_get_phy_mode(dp->dn, &mode); 1671 if (err) 1672 mode = PHY_INTERFACE_MODE_NA; 1673 1674 if (ds->ops->phylink_get_caps) { 1675 ds->ops->phylink_get_caps(ds, dp->index, &dp->pl_config); 1676 } else { 1677 /* For legacy drivers */ 1678 if (mode != PHY_INTERFACE_MODE_NA) { 1679 __set_bit(mode, dp->pl_config.supported_interfaces); 1680 } else { 1681 __set_bit(PHY_INTERFACE_MODE_INTERNAL, 1682 dp->pl_config.supported_interfaces); 1683 __set_bit(PHY_INTERFACE_MODE_GMII, 1684 dp->pl_config.supported_interfaces); 1685 } 1686 } 1687 1688 pl = phylink_create(&dp->pl_config, of_fwnode_handle(dp->dn), 1689 mode, &dsa_port_phylink_mac_ops); 1690 if (IS_ERR(pl)) { 1691 pr_err("error creating PHYLINK: %ld\n", PTR_ERR(pl)); 1692 return PTR_ERR(pl); 1693 } 1694 1695 dp->pl = pl; 1696 1697 return 0; 1698} 1699 1700void dsa_port_phylink_destroy(struct dsa_port *dp) 1701{ 1702 phylink_destroy(dp->pl); 1703 dp->pl = NULL; 1704} 1705 1706static int dsa_shared_port_setup_phy_of(struct dsa_port *dp, bool enable) 1707{ 1708 struct dsa_switch *ds = dp->ds; 1709 struct phy_device *phydev; 1710 int port = dp->index; 1711 int err = 0; 1712 1713 phydev = dsa_port_get_phy_device(dp); 1714 if (!phydev) 1715 return 0; 1716 1717 if (IS_ERR(phydev)) 1718 return PTR_ERR(phydev); 1719 1720 if (enable) { 1721 err = genphy_resume(phydev); 1722 if (err < 0) 1723 goto err_put_dev; 1724 1725 err = genphy_read_status(phydev); 1726 if (err < 0) 1727 goto err_put_dev; 1728 } else { 1729 err = genphy_suspend(phydev); 1730 if (err < 0) 1731 goto err_put_dev; 1732 } 1733 1734 if (ds->ops->adjust_link) 1735 ds->ops->adjust_link(ds, port, phydev); 1736 1737 dev_dbg(ds->dev, "enabled port's phy: %s", phydev_name(phydev)); 1738 1739err_put_dev: 1740 put_device(&phydev->mdio.dev); 1741 return err; 1742} 1743 1744static int dsa_shared_port_fixed_link_register_of(struct dsa_port *dp) 1745{ 1746 struct device_node *dn = dp->dn; 1747 struct dsa_switch *ds = dp->ds; 1748 struct phy_device *phydev; 1749 int port = dp->index; 1750 phy_interface_t mode; 1751 int err; 1752 1753 err = of_phy_register_fixed_link(dn); 1754 if (err) { 1755 dev_err(ds->dev, 1756 "failed to register the fixed PHY of port %d\n", 1757 port); 1758 return err; 1759 } 1760 1761 phydev = of_phy_find_device(dn); 1762 1763 err = of_get_phy_mode(dn, &mode); 1764 if (err) 1765 mode = PHY_INTERFACE_MODE_NA; 1766 phydev->interface = mode; 1767 1768 genphy_read_status(phydev); 1769 1770 if (ds->ops->adjust_link) 1771 ds->ops->adjust_link(ds, port, phydev); 1772 1773 put_device(&phydev->mdio.dev); 1774 1775 return 0; 1776} 1777 1778static int dsa_shared_port_phylink_register(struct dsa_port *dp) 1779{ 1780 struct dsa_switch *ds = dp->ds; 1781 struct device_node *port_dn = dp->dn; 1782 int err; 1783 1784 dp->pl_config.dev = ds->dev; 1785 dp->pl_config.type = PHYLINK_DEV; 1786 1787 err = dsa_port_phylink_create(dp); 1788 if (err) 1789 return err; 1790 1791 err = phylink_of_phy_connect(dp->pl, port_dn, 0); 1792 if (err && err != -ENODEV) { 1793 pr_err("could not attach to PHY: %d\n", err); 1794 goto err_phy_connect; 1795 } 1796 1797 return 0; 1798 1799err_phy_connect: 1800 dsa_port_phylink_destroy(dp); 1801 return err; 1802} 1803 1804/* During the initial DSA driver migration to OF, port nodes were sometimes 1805 * added to device trees with no indication of how they should operate from a 1806 * link management perspective (phy-handle, fixed-link, etc). Additionally, the 1807 * phy-mode may be absent. The interpretation of these port OF nodes depends on 1808 * their type. 1809 * 1810 * User ports with no phy-handle or fixed-link are expected to connect to an 1811 * internal PHY located on the ds->user_mii_bus at an MDIO address equal to 1812 * the port number. This description is still actively supported. 1813 * 1814 * Shared (CPU and DSA) ports with no phy-handle or fixed-link are expected to 1815 * operate at the maximum speed that their phy-mode is capable of. If the 1816 * phy-mode is absent, they are expected to operate using the phy-mode 1817 * supported by the port that gives the highest link speed. It is unspecified 1818 * if the port should use flow control or not, half duplex or full duplex, or 1819 * if the phy-mode is a SERDES link, whether in-band autoneg is expected to be 1820 * enabled or not. 1821 * 1822 * In the latter case of shared ports, omitting the link management description 1823 * from the firmware node is deprecated and strongly discouraged. DSA uses 1824 * phylink, which rejects the firmware nodes of these ports for lacking 1825 * required properties. 1826 * 1827 * For switches in this table, DSA will skip enforcing validation and will 1828 * later omit registering a phylink instance for the shared ports, if they lack 1829 * a fixed-link, a phy-handle, or a managed = "in-band-status" property. 1830 * It becomes the responsibility of the driver to ensure that these ports 1831 * operate at the maximum speed (whatever this means) and will interoperate 1832 * with the DSA conduit or other cascade port, since phylink methods will not be 1833 * invoked for them. 1834 * 1835 * If you are considering expanding this table for newly introduced switches, 1836 * think again. It is OK to remove switches from this table if there aren't DT 1837 * blobs in circulation which rely on defaulting the shared ports. 1838 */ 1839static const char * const dsa_switches_apply_workarounds[] = { 1840#if IS_ENABLED(CONFIG_NET_DSA_XRS700X) 1841 "arrow,xrs7003e", 1842 "arrow,xrs7003f", 1843 "arrow,xrs7004e", 1844 "arrow,xrs7004f", 1845#endif 1846#if IS_ENABLED(CONFIG_B53) 1847 "brcm,bcm5325", 1848 "brcm,bcm53115", 1849 "brcm,bcm53125", 1850 "brcm,bcm53128", 1851 "brcm,bcm5365", 1852 "brcm,bcm5389", 1853 "brcm,bcm5395", 1854 "brcm,bcm5397", 1855 "brcm,bcm5398", 1856 "brcm,bcm53010-srab", 1857 "brcm,bcm53011-srab", 1858 "brcm,bcm53012-srab", 1859 "brcm,bcm53018-srab", 1860 "brcm,bcm53019-srab", 1861 "brcm,bcm5301x-srab", 1862 "brcm,bcm11360-srab", 1863 "brcm,bcm58522-srab", 1864 "brcm,bcm58525-srab", 1865 "brcm,bcm58535-srab", 1866 "brcm,bcm58622-srab", 1867 "brcm,bcm58623-srab", 1868 "brcm,bcm58625-srab", 1869 "brcm,bcm88312-srab", 1870 "brcm,cygnus-srab", 1871 "brcm,nsp-srab", 1872 "brcm,omega-srab", 1873 "brcm,bcm3384-switch", 1874 "brcm,bcm6328-switch", 1875 "brcm,bcm6368-switch", 1876 "brcm,bcm63xx-switch", 1877#endif 1878#if IS_ENABLED(CONFIG_NET_DSA_BCM_SF2) 1879 "brcm,bcm7445-switch-v4.0", 1880 "brcm,bcm7278-switch-v4.0", 1881 "brcm,bcm7278-switch-v4.8", 1882#endif 1883#if IS_ENABLED(CONFIG_NET_DSA_LANTIQ_GSWIP) 1884 "lantiq,xrx200-gswip", 1885 "lantiq,xrx300-gswip", 1886 "lantiq,xrx330-gswip", 1887#endif 1888#if IS_ENABLED(CONFIG_NET_DSA_MV88E6060) 1889 "marvell,mv88e6060", 1890#endif 1891#if IS_ENABLED(CONFIG_NET_DSA_MV88E6XXX) 1892 "marvell,mv88e6085", 1893 "marvell,mv88e6190", 1894 "marvell,mv88e6250", 1895#endif 1896#if IS_ENABLED(CONFIG_NET_DSA_MICROCHIP_KSZ_COMMON) 1897 "microchip,ksz8765", 1898 "microchip,ksz8794", 1899 "microchip,ksz8795", 1900 "microchip,ksz8863", 1901 "microchip,ksz8873", 1902 "microchip,ksz9477", 1903 "microchip,ksz9897", 1904 "microchip,ksz9893", 1905 "microchip,ksz9563", 1906 "microchip,ksz8563", 1907 "microchip,ksz9567", 1908#endif 1909#if IS_ENABLED(CONFIG_NET_DSA_SMSC_LAN9303_MDIO) 1910 "smsc,lan9303-mdio", 1911#endif 1912#if IS_ENABLED(CONFIG_NET_DSA_SMSC_LAN9303_I2C) 1913 "smsc,lan9303-i2c", 1914#endif 1915 NULL, 1916}; 1917 1918static void dsa_shared_port_validate_of(struct dsa_port *dp, 1919 bool *missing_phy_mode, 1920 bool *missing_link_description) 1921{ 1922 struct device_node *dn = dp->dn, *phy_np; 1923 struct dsa_switch *ds = dp->ds; 1924 phy_interface_t mode; 1925 1926 *missing_phy_mode = false; 1927 *missing_link_description = false; 1928 1929 if (of_get_phy_mode(dn, &mode)) { 1930 *missing_phy_mode = true; 1931 dev_err(ds->dev, 1932 "OF node %pOF of %s port %d lacks the required \"phy-mode\" property\n", 1933 dn, dsa_port_is_cpu(dp) ? "CPU" : "DSA", dp->index); 1934 } 1935 1936 /* Note: of_phy_is_fixed_link() also returns true for 1937 * managed = "in-band-status" 1938 */ 1939 if (of_phy_is_fixed_link(dn)) 1940 return; 1941 1942 phy_np = of_parse_phandle(dn, "phy-handle", 0); 1943 if (phy_np) { 1944 of_node_put(phy_np); 1945 return; 1946 } 1947 1948 *missing_link_description = true; 1949 1950 dev_err(ds->dev, 1951 "OF node %pOF of %s port %d lacks the required \"phy-handle\", \"fixed-link\" or \"managed\" properties\n", 1952 dn, dsa_port_is_cpu(dp) ? "CPU" : "DSA", dp->index); 1953} 1954 1955int dsa_shared_port_link_register_of(struct dsa_port *dp) 1956{ 1957 struct dsa_switch *ds = dp->ds; 1958 bool missing_link_description; 1959 bool missing_phy_mode; 1960 int port = dp->index; 1961 1962 dsa_shared_port_validate_of(dp, &missing_phy_mode, 1963 &missing_link_description); 1964 1965 if ((missing_phy_mode || missing_link_description) && 1966 !of_device_compatible_match(ds->dev->of_node, 1967 dsa_switches_apply_workarounds)) 1968 return -EINVAL; 1969 1970 if (!ds->ops->adjust_link) { 1971 if (missing_link_description) { 1972 dev_warn(ds->dev, 1973 "Skipping phylink registration for %s port %d\n", 1974 dsa_port_is_cpu(dp) ? "CPU" : "DSA", dp->index); 1975 } else { 1976 if (ds->ops->phylink_mac_link_down) 1977 ds->ops->phylink_mac_link_down(ds, port, 1978 MLO_AN_FIXED, PHY_INTERFACE_MODE_NA); 1979 1980 return dsa_shared_port_phylink_register(dp); 1981 } 1982 return 0; 1983 } 1984 1985 dev_warn(ds->dev, 1986 "Using legacy PHYLIB callbacks. Please migrate to PHYLINK!\n"); 1987 1988 if (of_phy_is_fixed_link(dp->dn)) 1989 return dsa_shared_port_fixed_link_register_of(dp); 1990 else 1991 return dsa_shared_port_setup_phy_of(dp, true); 1992} 1993 1994void dsa_shared_port_link_unregister_of(struct dsa_port *dp) 1995{ 1996 struct dsa_switch *ds = dp->ds; 1997 1998 if (!ds->ops->adjust_link && dp->pl) { 1999 rtnl_lock(); 2000 phylink_disconnect_phy(dp->pl); 2001 rtnl_unlock(); 2002 dsa_port_phylink_destroy(dp); 2003 return; 2004 } 2005 2006 if (of_phy_is_fixed_link(dp->dn)) 2007 of_phy_deregister_fixed_link(dp->dn); 2008 else 2009 dsa_shared_port_setup_phy_of(dp, false); 2010} 2011 2012int dsa_port_hsr_join(struct dsa_port *dp, struct net_device *hsr, 2013 struct netlink_ext_ack *extack) 2014{ 2015 struct dsa_switch *ds = dp->ds; 2016 int err; 2017 2018 if (!ds->ops->port_hsr_join) 2019 return -EOPNOTSUPP; 2020 2021 dp->hsr_dev = hsr; 2022 2023 err = ds->ops->port_hsr_join(ds, dp->index, hsr, extack); 2024 if (err) 2025 dp->hsr_dev = NULL; 2026 2027 return err; 2028} 2029 2030void dsa_port_hsr_leave(struct dsa_port *dp, struct net_device *hsr) 2031{ 2032 struct dsa_switch *ds = dp->ds; 2033 int err; 2034 2035 dp->hsr_dev = NULL; 2036 2037 if (ds->ops->port_hsr_leave) { 2038 err = ds->ops->port_hsr_leave(ds, dp->index, hsr); 2039 if (err) 2040 dev_err(dp->ds->dev, 2041 "port %d failed to leave HSR %s: %pe\n", 2042 dp->index, hsr->name, ERR_PTR(err)); 2043 } 2044} 2045 2046int dsa_port_tag_8021q_vlan_add(struct dsa_port *dp, u16 vid, bool broadcast) 2047{ 2048 struct dsa_notifier_tag_8021q_vlan_info info = { 2049 .dp = dp, 2050 .vid = vid, 2051 }; 2052 2053 if (broadcast) 2054 return dsa_broadcast(DSA_NOTIFIER_TAG_8021Q_VLAN_ADD, &info); 2055 2056 return dsa_port_notify(dp, DSA_NOTIFIER_TAG_8021Q_VLAN_ADD, &info); 2057} 2058 2059void dsa_port_tag_8021q_vlan_del(struct dsa_port *dp, u16 vid, bool broadcast) 2060{ 2061 struct dsa_notifier_tag_8021q_vlan_info info = { 2062 .dp = dp, 2063 .vid = vid, 2064 }; 2065 int err; 2066 2067 if (broadcast) 2068 err = dsa_broadcast(DSA_NOTIFIER_TAG_8021Q_VLAN_DEL, &info); 2069 else 2070 err = dsa_port_notify(dp, DSA_NOTIFIER_TAG_8021Q_VLAN_DEL, &info); 2071 if (err) 2072 dev_err(dp->ds->dev, 2073 "port %d failed to notify tag_8021q VLAN %d deletion: %pe\n", 2074 dp->index, vid, ERR_PTR(err)); 2075} 2076