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