1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Handling of a single switch port 4 * 5 * Copyright (c) 2017 Savoir-faire Linux Inc. 6 * Vivien Didelot <vivien.didelot@savoirfairelinux.com> 7 */ 8 9 #include <linux/if_bridge.h> 10 #include <linux/notifier.h> 11 #include <linux/of_mdio.h> 12 #include <linux/of_net.h> 13 14 #include "dsa_priv.h" 15 16 /** 17 * dsa_port_notify - Notify the switching fabric of changes to a port 18 * @dp: port on which change occurred 19 * @e: event, must be of type DSA_NOTIFIER_* 20 * @v: event-specific value. 21 * 22 * Notify all switches in the DSA tree that this port's switch belongs to, 23 * including this switch itself, of an event. Allows the other switches to 24 * reconfigure themselves for cross-chip operations. Can also be used to 25 * reconfigure ports without net_devices (CPU ports, DSA links) whenever 26 * a user port's state changes. 27 */ 28 static int dsa_port_notify(const struct dsa_port *dp, unsigned long e, void *v) 29 { 30 return dsa_tree_notify(dp->ds->dst, e, v); 31 } 32 33 int dsa_port_set_state(struct dsa_port *dp, u8 state) 34 { 35 struct dsa_switch *ds = dp->ds; 36 int port = dp->index; 37 38 if (!ds->ops->port_stp_state_set) 39 return -EOPNOTSUPP; 40 41 ds->ops->port_stp_state_set(ds, port, state); 42 43 if (ds->ops->port_fast_age) { 44 /* Fast age FDB entries or flush appropriate forwarding database 45 * for the given port, if we are moving it from Learning or 46 * Forwarding state, to Disabled or Blocking or Listening state. 47 */ 48 49 if ((dp->stp_state == BR_STATE_LEARNING || 50 dp->stp_state == BR_STATE_FORWARDING) && 51 (state == BR_STATE_DISABLED || 52 state == BR_STATE_BLOCKING || 53 state == BR_STATE_LISTENING)) 54 ds->ops->port_fast_age(ds, port); 55 } 56 57 dp->stp_state = state; 58 59 return 0; 60 } 61 62 static void dsa_port_set_state_now(struct dsa_port *dp, u8 state) 63 { 64 int err; 65 66 err = dsa_port_set_state(dp, state); 67 if (err) 68 pr_err("DSA: failed to set STP state %u (%d)\n", state, err); 69 } 70 71 int dsa_port_enable_rt(struct dsa_port *dp, struct phy_device *phy) 72 { 73 struct dsa_switch *ds = dp->ds; 74 int port = dp->index; 75 int err; 76 77 if (ds->ops->port_enable) { 78 err = ds->ops->port_enable(ds, port, phy); 79 if (err) 80 return err; 81 } 82 83 if (!dp->bridge_dev) 84 dsa_port_set_state_now(dp, BR_STATE_FORWARDING); 85 86 if (dp->pl) 87 phylink_start(dp->pl); 88 89 return 0; 90 } 91 92 int dsa_port_enable(struct dsa_port *dp, struct phy_device *phy) 93 { 94 int err; 95 96 rtnl_lock(); 97 err = dsa_port_enable_rt(dp, phy); 98 rtnl_unlock(); 99 100 return err; 101 } 102 103 void dsa_port_disable_rt(struct dsa_port *dp) 104 { 105 struct dsa_switch *ds = dp->ds; 106 int port = dp->index; 107 108 if (dp->pl) 109 phylink_stop(dp->pl); 110 111 if (!dp->bridge_dev) 112 dsa_port_set_state_now(dp, BR_STATE_DISABLED); 113 114 if (ds->ops->port_disable) 115 ds->ops->port_disable(ds, port); 116 } 117 118 void dsa_port_disable(struct dsa_port *dp) 119 { 120 rtnl_lock(); 121 dsa_port_disable_rt(dp); 122 rtnl_unlock(); 123 } 124 125 static int dsa_port_inherit_brport_flags(struct dsa_port *dp, 126 struct netlink_ext_ack *extack) 127 { 128 const unsigned long mask = BR_LEARNING | BR_FLOOD | BR_MCAST_FLOOD | 129 BR_BCAST_FLOOD; 130 struct net_device *brport_dev = dsa_port_to_bridge_port(dp); 131 int flag, err; 132 133 for_each_set_bit(flag, &mask, 32) { 134 struct switchdev_brport_flags flags = {0}; 135 136 flags.mask = BIT(flag); 137 138 if (br_port_flag_is_set(brport_dev, BIT(flag))) 139 flags.val = BIT(flag); 140 141 err = dsa_port_bridge_flags(dp, flags, extack); 142 if (err && err != -EOPNOTSUPP) 143 return err; 144 } 145 146 return 0; 147 } 148 149 static void dsa_port_clear_brport_flags(struct dsa_port *dp) 150 { 151 const unsigned long val = BR_FLOOD | BR_MCAST_FLOOD | BR_BCAST_FLOOD; 152 const unsigned long mask = BR_LEARNING | BR_FLOOD | BR_MCAST_FLOOD | 153 BR_BCAST_FLOOD; 154 int flag, err; 155 156 for_each_set_bit(flag, &mask, 32) { 157 struct switchdev_brport_flags flags = {0}; 158 159 flags.mask = BIT(flag); 160 flags.val = val & BIT(flag); 161 162 err = dsa_port_bridge_flags(dp, flags, NULL); 163 if (err && err != -EOPNOTSUPP) 164 dev_err(dp->ds->dev, 165 "failed to clear bridge port flag %lu: %pe\n", 166 flags.val, ERR_PTR(err)); 167 } 168 } 169 170 static int dsa_port_switchdev_sync(struct dsa_port *dp, 171 struct netlink_ext_ack *extack) 172 { 173 struct net_device *brport_dev = dsa_port_to_bridge_port(dp); 174 struct net_device *br = dp->bridge_dev; 175 int err; 176 177 err = dsa_port_inherit_brport_flags(dp, extack); 178 if (err) 179 return err; 180 181 err = dsa_port_set_state(dp, br_port_get_stp_state(brport_dev)); 182 if (err && err != -EOPNOTSUPP) 183 return err; 184 185 err = dsa_port_vlan_filtering(dp, br_vlan_enabled(br), extack); 186 if (err && err != -EOPNOTSUPP) 187 return err; 188 189 err = dsa_port_mrouter(dp->cpu_dp, br_multicast_router(br), extack); 190 if (err && err != -EOPNOTSUPP) 191 return err; 192 193 err = dsa_port_ageing_time(dp, br_get_ageing_time(br)); 194 if (err && err != -EOPNOTSUPP) 195 return err; 196 197 err = br_mdb_replay(br, brport_dev, dp, true, 198 &dsa_slave_switchdev_blocking_notifier, extack); 199 if (err && err != -EOPNOTSUPP) 200 return err; 201 202 /* Forwarding and termination FDB entries on the port */ 203 err = br_fdb_replay(br, brport_dev, dp, true, 204 &dsa_slave_switchdev_notifier); 205 if (err && err != -EOPNOTSUPP) 206 return err; 207 208 /* Termination FDB entries on the bridge itself */ 209 err = br_fdb_replay(br, br, dp, true, &dsa_slave_switchdev_notifier); 210 if (err && err != -EOPNOTSUPP) 211 return err; 212 213 err = br_vlan_replay(br, brport_dev, dp, true, 214 &dsa_slave_switchdev_blocking_notifier, extack); 215 if (err && err != -EOPNOTSUPP) 216 return err; 217 218 return 0; 219 } 220 221 static int dsa_port_switchdev_unsync_objs(struct dsa_port *dp, 222 struct net_device *br, 223 struct netlink_ext_ack *extack) 224 { 225 struct net_device *brport_dev = dsa_port_to_bridge_port(dp); 226 int err; 227 228 /* Delete the switchdev objects left on this port */ 229 err = br_mdb_replay(br, brport_dev, dp, false, 230 &dsa_slave_switchdev_blocking_notifier, extack); 231 if (err && err != -EOPNOTSUPP) 232 return err; 233 234 /* Forwarding and termination FDB entries on the port */ 235 err = br_fdb_replay(br, brport_dev, dp, false, 236 &dsa_slave_switchdev_notifier); 237 if (err && err != -EOPNOTSUPP) 238 return err; 239 240 /* Termination FDB entries on the bridge itself */ 241 err = br_fdb_replay(br, br, dp, false, &dsa_slave_switchdev_notifier); 242 if (err && err != -EOPNOTSUPP) 243 return err; 244 245 err = br_vlan_replay(br, brport_dev, dp, false, 246 &dsa_slave_switchdev_blocking_notifier, extack); 247 if (err && err != -EOPNOTSUPP) 248 return err; 249 250 return 0; 251 } 252 253 static void dsa_port_switchdev_unsync_attrs(struct dsa_port *dp) 254 { 255 /* Configure the port for standalone mode (no address learning, 256 * flood everything). 257 * The bridge only emits SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS events 258 * when the user requests it through netlink or sysfs, but not 259 * automatically at port join or leave, so we need to handle resetting 260 * the brport flags ourselves. But we even prefer it that way, because 261 * otherwise, some setups might never get the notification they need, 262 * for example, when a port leaves a LAG that offloads the bridge, 263 * it becomes standalone, but as far as the bridge is concerned, no 264 * port ever left. 265 */ 266 dsa_port_clear_brport_flags(dp); 267 268 /* Port left the bridge, put in BR_STATE_DISABLED by the bridge layer, 269 * so allow it to be in BR_STATE_FORWARDING to be kept functional 270 */ 271 dsa_port_set_state_now(dp, BR_STATE_FORWARDING); 272 273 /* VLAN filtering is handled by dsa_switch_bridge_leave */ 274 275 /* Some drivers treat the notification for having a local multicast 276 * router by allowing multicast to be flooded to the CPU, so we should 277 * allow this in standalone mode too. 278 */ 279 dsa_port_mrouter(dp->cpu_dp, true, NULL); 280 281 /* Ageing time may be global to the switch chip, so don't change it 282 * here because we have no good reason (or value) to change it to. 283 */ 284 } 285 286 int dsa_port_bridge_join(struct dsa_port *dp, struct net_device *br, 287 struct netlink_ext_ack *extack) 288 { 289 struct dsa_notifier_bridge_info info = { 290 .tree_index = dp->ds->dst->index, 291 .sw_index = dp->ds->index, 292 .port = dp->index, 293 .br = br, 294 }; 295 struct net_device *dev = dp->slave; 296 struct net_device *brport_dev; 297 int err; 298 299 /* Here the interface is already bridged. Reflect the current 300 * configuration so that drivers can program their chips accordingly. 301 */ 302 dp->bridge_dev = br; 303 304 brport_dev = dsa_port_to_bridge_port(dp); 305 306 err = dsa_broadcast(DSA_NOTIFIER_BRIDGE_JOIN, &info); 307 if (err) 308 goto out_rollback; 309 310 err = switchdev_bridge_port_offload(brport_dev, dev, extack); 311 if (err) 312 goto out_rollback_unbridge; 313 314 err = dsa_port_switchdev_sync(dp, extack); 315 if (err) 316 goto out_rollback_unoffload; 317 318 return 0; 319 320 out_rollback_unoffload: 321 switchdev_bridge_port_unoffload(brport_dev); 322 out_rollback_unbridge: 323 dsa_broadcast(DSA_NOTIFIER_BRIDGE_LEAVE, &info); 324 out_rollback: 325 dp->bridge_dev = NULL; 326 return err; 327 } 328 329 int dsa_port_pre_bridge_leave(struct dsa_port *dp, struct net_device *br, 330 struct netlink_ext_ack *extack) 331 { 332 struct net_device *brport_dev = dsa_port_to_bridge_port(dp); 333 334 switchdev_bridge_port_unoffload(brport_dev); 335 336 return dsa_port_switchdev_unsync_objs(dp, br, extack); 337 } 338 339 void dsa_port_bridge_leave(struct dsa_port *dp, struct net_device *br) 340 { 341 struct dsa_notifier_bridge_info info = { 342 .tree_index = dp->ds->dst->index, 343 .sw_index = dp->ds->index, 344 .port = dp->index, 345 .br = br, 346 }; 347 int err; 348 349 /* Here the port is already unbridged. Reflect the current configuration 350 * so that drivers can program their chips accordingly. 351 */ 352 dp->bridge_dev = NULL; 353 354 err = dsa_broadcast(DSA_NOTIFIER_BRIDGE_LEAVE, &info); 355 if (err) 356 pr_err("DSA: failed to notify DSA_NOTIFIER_BRIDGE_LEAVE\n"); 357 358 dsa_port_switchdev_unsync_attrs(dp); 359 } 360 361 int dsa_port_lag_change(struct dsa_port *dp, 362 struct netdev_lag_lower_state_info *linfo) 363 { 364 struct dsa_notifier_lag_info info = { 365 .sw_index = dp->ds->index, 366 .port = dp->index, 367 }; 368 bool tx_enabled; 369 370 if (!dp->lag_dev) 371 return 0; 372 373 /* On statically configured aggregates (e.g. loadbalance 374 * without LACP) ports will always be tx_enabled, even if the 375 * link is down. Thus we require both link_up and tx_enabled 376 * in order to include it in the tx set. 377 */ 378 tx_enabled = linfo->link_up && linfo->tx_enabled; 379 380 if (tx_enabled == dp->lag_tx_enabled) 381 return 0; 382 383 dp->lag_tx_enabled = tx_enabled; 384 385 return dsa_port_notify(dp, DSA_NOTIFIER_LAG_CHANGE, &info); 386 } 387 388 int dsa_port_lag_join(struct dsa_port *dp, struct net_device *lag, 389 struct netdev_lag_upper_info *uinfo, 390 struct netlink_ext_ack *extack) 391 { 392 struct dsa_notifier_lag_info info = { 393 .sw_index = dp->ds->index, 394 .port = dp->index, 395 .lag = lag, 396 .info = uinfo, 397 }; 398 struct net_device *bridge_dev; 399 int err; 400 401 dsa_lag_map(dp->ds->dst, lag); 402 dp->lag_dev = lag; 403 404 err = dsa_port_notify(dp, DSA_NOTIFIER_LAG_JOIN, &info); 405 if (err) 406 goto err_lag_join; 407 408 bridge_dev = netdev_master_upper_dev_get(lag); 409 if (!bridge_dev || !netif_is_bridge_master(bridge_dev)) 410 return 0; 411 412 err = dsa_port_bridge_join(dp, bridge_dev, extack); 413 if (err) 414 goto err_bridge_join; 415 416 return 0; 417 418 err_bridge_join: 419 dsa_port_notify(dp, DSA_NOTIFIER_LAG_LEAVE, &info); 420 err_lag_join: 421 dp->lag_dev = NULL; 422 dsa_lag_unmap(dp->ds->dst, lag); 423 return err; 424 } 425 426 int dsa_port_pre_lag_leave(struct dsa_port *dp, struct net_device *lag, 427 struct netlink_ext_ack *extack) 428 { 429 if (dp->bridge_dev) 430 return dsa_port_pre_bridge_leave(dp, dp->bridge_dev, extack); 431 432 return 0; 433 } 434 435 void dsa_port_lag_leave(struct dsa_port *dp, struct net_device *lag) 436 { 437 struct dsa_notifier_lag_info info = { 438 .sw_index = dp->ds->index, 439 .port = dp->index, 440 .lag = lag, 441 }; 442 int err; 443 444 if (!dp->lag_dev) 445 return; 446 447 /* Port might have been part of a LAG that in turn was 448 * attached to a bridge. 449 */ 450 if (dp->bridge_dev) 451 dsa_port_bridge_leave(dp, dp->bridge_dev); 452 453 dp->lag_tx_enabled = false; 454 dp->lag_dev = NULL; 455 456 err = dsa_port_notify(dp, DSA_NOTIFIER_LAG_LEAVE, &info); 457 if (err) 458 pr_err("DSA: failed to notify DSA_NOTIFIER_LAG_LEAVE: %d\n", 459 err); 460 461 dsa_lag_unmap(dp->ds->dst, lag); 462 } 463 464 /* Must be called under rcu_read_lock() */ 465 static bool dsa_port_can_apply_vlan_filtering(struct dsa_port *dp, 466 bool vlan_filtering, 467 struct netlink_ext_ack *extack) 468 { 469 struct dsa_switch *ds = dp->ds; 470 int err, i; 471 472 /* VLAN awareness was off, so the question is "can we turn it on". 473 * We may have had 8021q uppers, those need to go. Make sure we don't 474 * enter an inconsistent state: deny changing the VLAN awareness state 475 * as long as we have 8021q uppers. 476 */ 477 if (vlan_filtering && dsa_is_user_port(ds, dp->index)) { 478 struct net_device *upper_dev, *slave = dp->slave; 479 struct net_device *br = dp->bridge_dev; 480 struct list_head *iter; 481 482 netdev_for_each_upper_dev_rcu(slave, upper_dev, iter) { 483 struct bridge_vlan_info br_info; 484 u16 vid; 485 486 if (!is_vlan_dev(upper_dev)) 487 continue; 488 489 vid = vlan_dev_vlan_id(upper_dev); 490 491 /* br_vlan_get_info() returns -EINVAL or -ENOENT if the 492 * device, respectively the VID is not found, returning 493 * 0 means success, which is a failure for us here. 494 */ 495 err = br_vlan_get_info(br, vid, &br_info); 496 if (err == 0) { 497 NL_SET_ERR_MSG_MOD(extack, 498 "Must first remove VLAN uppers having VIDs also present in bridge"); 499 return false; 500 } 501 } 502 } 503 504 if (!ds->vlan_filtering_is_global) 505 return true; 506 507 /* For cases where enabling/disabling VLAN awareness is global to the 508 * switch, we need to handle the case where multiple bridges span 509 * different ports of the same switch device and one of them has a 510 * different setting than what is being requested. 511 */ 512 for (i = 0; i < ds->num_ports; i++) { 513 struct net_device *other_bridge; 514 515 other_bridge = dsa_to_port(ds, i)->bridge_dev; 516 if (!other_bridge) 517 continue; 518 /* If it's the same bridge, it also has same 519 * vlan_filtering setting => no need to check 520 */ 521 if (other_bridge == dp->bridge_dev) 522 continue; 523 if (br_vlan_enabled(other_bridge) != vlan_filtering) { 524 NL_SET_ERR_MSG_MOD(extack, 525 "VLAN filtering is a global setting"); 526 return false; 527 } 528 } 529 return true; 530 } 531 532 int dsa_port_vlan_filtering(struct dsa_port *dp, bool vlan_filtering, 533 struct netlink_ext_ack *extack) 534 { 535 struct dsa_switch *ds = dp->ds; 536 bool apply; 537 int err; 538 539 if (!ds->ops->port_vlan_filtering) 540 return -EOPNOTSUPP; 541 542 /* We are called from dsa_slave_switchdev_blocking_event(), 543 * which is not under rcu_read_lock(), unlike 544 * dsa_slave_switchdev_event(). 545 */ 546 rcu_read_lock(); 547 apply = dsa_port_can_apply_vlan_filtering(dp, vlan_filtering, extack); 548 rcu_read_unlock(); 549 if (!apply) 550 return -EINVAL; 551 552 if (dsa_port_is_vlan_filtering(dp) == vlan_filtering) 553 return 0; 554 555 err = ds->ops->port_vlan_filtering(ds, dp->index, vlan_filtering, 556 extack); 557 if (err) 558 return err; 559 560 if (ds->vlan_filtering_is_global) 561 ds->vlan_filtering = vlan_filtering; 562 else 563 dp->vlan_filtering = vlan_filtering; 564 565 return 0; 566 } 567 568 /* This enforces legacy behavior for switch drivers which assume they can't 569 * receive VLAN configuration when enslaved to a bridge with vlan_filtering=0 570 */ 571 bool dsa_port_skip_vlan_configuration(struct dsa_port *dp) 572 { 573 struct dsa_switch *ds = dp->ds; 574 575 if (!dp->bridge_dev) 576 return false; 577 578 return (!ds->configure_vlan_while_not_filtering && 579 !br_vlan_enabled(dp->bridge_dev)); 580 } 581 582 int dsa_port_ageing_time(struct dsa_port *dp, clock_t ageing_clock) 583 { 584 unsigned long ageing_jiffies = clock_t_to_jiffies(ageing_clock); 585 unsigned int ageing_time = jiffies_to_msecs(ageing_jiffies); 586 struct dsa_notifier_ageing_time_info info; 587 int err; 588 589 info.ageing_time = ageing_time; 590 591 err = dsa_port_notify(dp, DSA_NOTIFIER_AGEING_TIME, &info); 592 if (err) 593 return err; 594 595 dp->ageing_time = ageing_time; 596 597 return 0; 598 } 599 600 int dsa_port_pre_bridge_flags(const struct dsa_port *dp, 601 struct switchdev_brport_flags flags, 602 struct netlink_ext_ack *extack) 603 { 604 struct dsa_switch *ds = dp->ds; 605 606 if (!ds->ops->port_pre_bridge_flags) 607 return -EINVAL; 608 609 return ds->ops->port_pre_bridge_flags(ds, dp->index, flags, extack); 610 } 611 612 int dsa_port_bridge_flags(const struct dsa_port *dp, 613 struct switchdev_brport_flags flags, 614 struct netlink_ext_ack *extack) 615 { 616 struct dsa_switch *ds = dp->ds; 617 618 if (!ds->ops->port_bridge_flags) 619 return -EOPNOTSUPP; 620 621 return ds->ops->port_bridge_flags(ds, dp->index, flags, extack); 622 } 623 624 int dsa_port_mrouter(struct dsa_port *dp, bool mrouter, 625 struct netlink_ext_ack *extack) 626 { 627 struct dsa_switch *ds = dp->ds; 628 629 if (!ds->ops->port_set_mrouter) 630 return -EOPNOTSUPP; 631 632 return ds->ops->port_set_mrouter(ds, dp->index, mrouter, extack); 633 } 634 635 int dsa_port_mtu_change(struct dsa_port *dp, int new_mtu, 636 bool targeted_match) 637 { 638 struct dsa_notifier_mtu_info info = { 639 .sw_index = dp->ds->index, 640 .targeted_match = targeted_match, 641 .port = dp->index, 642 .mtu = new_mtu, 643 }; 644 645 return dsa_port_notify(dp, DSA_NOTIFIER_MTU, &info); 646 } 647 648 int dsa_port_fdb_add(struct dsa_port *dp, const unsigned char *addr, 649 u16 vid) 650 { 651 struct dsa_notifier_fdb_info info = { 652 .sw_index = dp->ds->index, 653 .port = dp->index, 654 .addr = addr, 655 .vid = vid, 656 }; 657 658 return dsa_port_notify(dp, DSA_NOTIFIER_FDB_ADD, &info); 659 } 660 661 int dsa_port_fdb_del(struct dsa_port *dp, const unsigned char *addr, 662 u16 vid) 663 { 664 struct dsa_notifier_fdb_info info = { 665 .sw_index = dp->ds->index, 666 .port = dp->index, 667 .addr = addr, 668 .vid = vid, 669 670 }; 671 672 return dsa_port_notify(dp, DSA_NOTIFIER_FDB_DEL, &info); 673 } 674 675 int dsa_port_host_fdb_add(struct dsa_port *dp, const unsigned char *addr, 676 u16 vid) 677 { 678 struct dsa_notifier_fdb_info info = { 679 .sw_index = dp->ds->index, 680 .port = dp->index, 681 .addr = addr, 682 .vid = vid, 683 }; 684 struct dsa_port *cpu_dp = dp->cpu_dp; 685 int err; 686 687 err = dev_uc_add(cpu_dp->master, addr); 688 if (err) 689 return err; 690 691 return dsa_port_notify(dp, DSA_NOTIFIER_HOST_FDB_ADD, &info); 692 } 693 694 int dsa_port_host_fdb_del(struct dsa_port *dp, const unsigned char *addr, 695 u16 vid) 696 { 697 struct dsa_notifier_fdb_info info = { 698 .sw_index = dp->ds->index, 699 .port = dp->index, 700 .addr = addr, 701 .vid = vid, 702 }; 703 struct dsa_port *cpu_dp = dp->cpu_dp; 704 int err; 705 706 err = dev_uc_del(cpu_dp->master, addr); 707 if (err) 708 return err; 709 710 return dsa_port_notify(dp, DSA_NOTIFIER_HOST_FDB_DEL, &info); 711 } 712 713 int dsa_port_fdb_dump(struct dsa_port *dp, dsa_fdb_dump_cb_t *cb, void *data) 714 { 715 struct dsa_switch *ds = dp->ds; 716 int port = dp->index; 717 718 if (!ds->ops->port_fdb_dump) 719 return -EOPNOTSUPP; 720 721 return ds->ops->port_fdb_dump(ds, port, cb, data); 722 } 723 724 int dsa_port_mdb_add(const struct dsa_port *dp, 725 const struct switchdev_obj_port_mdb *mdb) 726 { 727 struct dsa_notifier_mdb_info info = { 728 .sw_index = dp->ds->index, 729 .port = dp->index, 730 .mdb = mdb, 731 }; 732 733 return dsa_port_notify(dp, DSA_NOTIFIER_MDB_ADD, &info); 734 } 735 736 int dsa_port_mdb_del(const struct dsa_port *dp, 737 const struct switchdev_obj_port_mdb *mdb) 738 { 739 struct dsa_notifier_mdb_info info = { 740 .sw_index = dp->ds->index, 741 .port = dp->index, 742 .mdb = mdb, 743 }; 744 745 return dsa_port_notify(dp, DSA_NOTIFIER_MDB_DEL, &info); 746 } 747 748 int dsa_port_host_mdb_add(const struct dsa_port *dp, 749 const struct switchdev_obj_port_mdb *mdb) 750 { 751 struct dsa_notifier_mdb_info info = { 752 .sw_index = dp->ds->index, 753 .port = dp->index, 754 .mdb = mdb, 755 }; 756 struct dsa_port *cpu_dp = dp->cpu_dp; 757 int err; 758 759 err = dev_mc_add(cpu_dp->master, mdb->addr); 760 if (err) 761 return err; 762 763 return dsa_port_notify(dp, DSA_NOTIFIER_HOST_MDB_ADD, &info); 764 } 765 766 int dsa_port_host_mdb_del(const struct dsa_port *dp, 767 const struct switchdev_obj_port_mdb *mdb) 768 { 769 struct dsa_notifier_mdb_info info = { 770 .sw_index = dp->ds->index, 771 .port = dp->index, 772 .mdb = mdb, 773 }; 774 struct dsa_port *cpu_dp = dp->cpu_dp; 775 int err; 776 777 err = dev_mc_del(cpu_dp->master, mdb->addr); 778 if (err) 779 return err; 780 781 return dsa_port_notify(dp, DSA_NOTIFIER_HOST_MDB_DEL, &info); 782 } 783 784 int dsa_port_vlan_add(struct dsa_port *dp, 785 const struct switchdev_obj_port_vlan *vlan, 786 struct netlink_ext_ack *extack) 787 { 788 struct dsa_notifier_vlan_info info = { 789 .sw_index = dp->ds->index, 790 .port = dp->index, 791 .vlan = vlan, 792 .extack = extack, 793 }; 794 795 return dsa_port_notify(dp, DSA_NOTIFIER_VLAN_ADD, &info); 796 } 797 798 int dsa_port_vlan_del(struct dsa_port *dp, 799 const struct switchdev_obj_port_vlan *vlan) 800 { 801 struct dsa_notifier_vlan_info info = { 802 .sw_index = dp->ds->index, 803 .port = dp->index, 804 .vlan = vlan, 805 }; 806 807 return dsa_port_notify(dp, DSA_NOTIFIER_VLAN_DEL, &info); 808 } 809 810 int dsa_port_mrp_add(const struct dsa_port *dp, 811 const struct switchdev_obj_mrp *mrp) 812 { 813 struct dsa_notifier_mrp_info info = { 814 .sw_index = dp->ds->index, 815 .port = dp->index, 816 .mrp = mrp, 817 }; 818 819 return dsa_port_notify(dp, DSA_NOTIFIER_MRP_ADD, &info); 820 } 821 822 int dsa_port_mrp_del(const struct dsa_port *dp, 823 const struct switchdev_obj_mrp *mrp) 824 { 825 struct dsa_notifier_mrp_info info = { 826 .sw_index = dp->ds->index, 827 .port = dp->index, 828 .mrp = mrp, 829 }; 830 831 return dsa_port_notify(dp, DSA_NOTIFIER_MRP_DEL, &info); 832 } 833 834 int dsa_port_mrp_add_ring_role(const struct dsa_port *dp, 835 const struct switchdev_obj_ring_role_mrp *mrp) 836 { 837 struct dsa_notifier_mrp_ring_role_info info = { 838 .sw_index = dp->ds->index, 839 .port = dp->index, 840 .mrp = mrp, 841 }; 842 843 return dsa_port_notify(dp, DSA_NOTIFIER_MRP_ADD_RING_ROLE, &info); 844 } 845 846 int dsa_port_mrp_del_ring_role(const struct dsa_port *dp, 847 const struct switchdev_obj_ring_role_mrp *mrp) 848 { 849 struct dsa_notifier_mrp_ring_role_info info = { 850 .sw_index = dp->ds->index, 851 .port = dp->index, 852 .mrp = mrp, 853 }; 854 855 return dsa_port_notify(dp, DSA_NOTIFIER_MRP_DEL_RING_ROLE, &info); 856 } 857 858 void dsa_port_set_tag_protocol(struct dsa_port *cpu_dp, 859 const struct dsa_device_ops *tag_ops) 860 { 861 cpu_dp->filter = tag_ops->filter; 862 cpu_dp->rcv = tag_ops->rcv; 863 cpu_dp->tag_ops = tag_ops; 864 } 865 866 static struct phy_device *dsa_port_get_phy_device(struct dsa_port *dp) 867 { 868 struct device_node *phy_dn; 869 struct phy_device *phydev; 870 871 phy_dn = of_parse_phandle(dp->dn, "phy-handle", 0); 872 if (!phy_dn) 873 return NULL; 874 875 phydev = of_phy_find_device(phy_dn); 876 if (!phydev) { 877 of_node_put(phy_dn); 878 return ERR_PTR(-EPROBE_DEFER); 879 } 880 881 of_node_put(phy_dn); 882 return phydev; 883 } 884 885 static void dsa_port_phylink_validate(struct phylink_config *config, 886 unsigned long *supported, 887 struct phylink_link_state *state) 888 { 889 struct dsa_port *dp = container_of(config, struct dsa_port, pl_config); 890 struct dsa_switch *ds = dp->ds; 891 892 if (!ds->ops->phylink_validate) 893 return; 894 895 ds->ops->phylink_validate(ds, dp->index, supported, state); 896 } 897 898 static void dsa_port_phylink_mac_pcs_get_state(struct phylink_config *config, 899 struct phylink_link_state *state) 900 { 901 struct dsa_port *dp = container_of(config, struct dsa_port, pl_config); 902 struct dsa_switch *ds = dp->ds; 903 int err; 904 905 /* Only called for inband modes */ 906 if (!ds->ops->phylink_mac_link_state) { 907 state->link = 0; 908 return; 909 } 910 911 err = ds->ops->phylink_mac_link_state(ds, dp->index, state); 912 if (err < 0) { 913 dev_err(ds->dev, "p%d: phylink_mac_link_state() failed: %d\n", 914 dp->index, err); 915 state->link = 0; 916 } 917 } 918 919 static void dsa_port_phylink_mac_config(struct phylink_config *config, 920 unsigned int mode, 921 const struct phylink_link_state *state) 922 { 923 struct dsa_port *dp = container_of(config, struct dsa_port, pl_config); 924 struct dsa_switch *ds = dp->ds; 925 926 if (!ds->ops->phylink_mac_config) 927 return; 928 929 ds->ops->phylink_mac_config(ds, dp->index, mode, state); 930 } 931 932 static void dsa_port_phylink_mac_an_restart(struct phylink_config *config) 933 { 934 struct dsa_port *dp = container_of(config, struct dsa_port, pl_config); 935 struct dsa_switch *ds = dp->ds; 936 937 if (!ds->ops->phylink_mac_an_restart) 938 return; 939 940 ds->ops->phylink_mac_an_restart(ds, dp->index); 941 } 942 943 static void dsa_port_phylink_mac_link_down(struct phylink_config *config, 944 unsigned int mode, 945 phy_interface_t interface) 946 { 947 struct dsa_port *dp = container_of(config, struct dsa_port, pl_config); 948 struct phy_device *phydev = NULL; 949 struct dsa_switch *ds = dp->ds; 950 951 if (dsa_is_user_port(ds, dp->index)) 952 phydev = dp->slave->phydev; 953 954 if (!ds->ops->phylink_mac_link_down) { 955 if (ds->ops->adjust_link && phydev) 956 ds->ops->adjust_link(ds, dp->index, phydev); 957 return; 958 } 959 960 ds->ops->phylink_mac_link_down(ds, dp->index, mode, interface); 961 } 962 963 static void dsa_port_phylink_mac_link_up(struct phylink_config *config, 964 struct phy_device *phydev, 965 unsigned int mode, 966 phy_interface_t interface, 967 int speed, int duplex, 968 bool tx_pause, bool rx_pause) 969 { 970 struct dsa_port *dp = container_of(config, struct dsa_port, pl_config); 971 struct dsa_switch *ds = dp->ds; 972 973 if (!ds->ops->phylink_mac_link_up) { 974 if (ds->ops->adjust_link && phydev) 975 ds->ops->adjust_link(ds, dp->index, phydev); 976 return; 977 } 978 979 ds->ops->phylink_mac_link_up(ds, dp->index, mode, interface, phydev, 980 speed, duplex, tx_pause, rx_pause); 981 } 982 983 const struct phylink_mac_ops dsa_port_phylink_mac_ops = { 984 .validate = dsa_port_phylink_validate, 985 .mac_pcs_get_state = dsa_port_phylink_mac_pcs_get_state, 986 .mac_config = dsa_port_phylink_mac_config, 987 .mac_an_restart = dsa_port_phylink_mac_an_restart, 988 .mac_link_down = dsa_port_phylink_mac_link_down, 989 .mac_link_up = dsa_port_phylink_mac_link_up, 990 }; 991 992 static int dsa_port_setup_phy_of(struct dsa_port *dp, bool enable) 993 { 994 struct dsa_switch *ds = dp->ds; 995 struct phy_device *phydev; 996 int port = dp->index; 997 int err = 0; 998 999 phydev = dsa_port_get_phy_device(dp); 1000 if (!phydev) 1001 return 0; 1002 1003 if (IS_ERR(phydev)) 1004 return PTR_ERR(phydev); 1005 1006 if (enable) { 1007 err = genphy_resume(phydev); 1008 if (err < 0) 1009 goto err_put_dev; 1010 1011 err = genphy_read_status(phydev); 1012 if (err < 0) 1013 goto err_put_dev; 1014 } else { 1015 err = genphy_suspend(phydev); 1016 if (err < 0) 1017 goto err_put_dev; 1018 } 1019 1020 if (ds->ops->adjust_link) 1021 ds->ops->adjust_link(ds, port, phydev); 1022 1023 dev_dbg(ds->dev, "enabled port's phy: %s", phydev_name(phydev)); 1024 1025 err_put_dev: 1026 put_device(&phydev->mdio.dev); 1027 return err; 1028 } 1029 1030 static int dsa_port_fixed_link_register_of(struct dsa_port *dp) 1031 { 1032 struct device_node *dn = dp->dn; 1033 struct dsa_switch *ds = dp->ds; 1034 struct phy_device *phydev; 1035 int port = dp->index; 1036 phy_interface_t mode; 1037 int err; 1038 1039 err = of_phy_register_fixed_link(dn); 1040 if (err) { 1041 dev_err(ds->dev, 1042 "failed to register the fixed PHY of port %d\n", 1043 port); 1044 return err; 1045 } 1046 1047 phydev = of_phy_find_device(dn); 1048 1049 err = of_get_phy_mode(dn, &mode); 1050 if (err) 1051 mode = PHY_INTERFACE_MODE_NA; 1052 phydev->interface = mode; 1053 1054 genphy_read_status(phydev); 1055 1056 if (ds->ops->adjust_link) 1057 ds->ops->adjust_link(ds, port, phydev); 1058 1059 put_device(&phydev->mdio.dev); 1060 1061 return 0; 1062 } 1063 1064 static int dsa_port_phylink_register(struct dsa_port *dp) 1065 { 1066 struct dsa_switch *ds = dp->ds; 1067 struct device_node *port_dn = dp->dn; 1068 phy_interface_t mode; 1069 int err; 1070 1071 err = of_get_phy_mode(port_dn, &mode); 1072 if (err) 1073 mode = PHY_INTERFACE_MODE_NA; 1074 1075 dp->pl_config.dev = ds->dev; 1076 dp->pl_config.type = PHYLINK_DEV; 1077 dp->pl_config.pcs_poll = ds->pcs_poll; 1078 1079 dp->pl = phylink_create(&dp->pl_config, of_fwnode_handle(port_dn), 1080 mode, &dsa_port_phylink_mac_ops); 1081 if (IS_ERR(dp->pl)) { 1082 pr_err("error creating PHYLINK: %ld\n", PTR_ERR(dp->pl)); 1083 return PTR_ERR(dp->pl); 1084 } 1085 1086 err = phylink_of_phy_connect(dp->pl, port_dn, 0); 1087 if (err && err != -ENODEV) { 1088 pr_err("could not attach to PHY: %d\n", err); 1089 goto err_phy_connect; 1090 } 1091 1092 return 0; 1093 1094 err_phy_connect: 1095 phylink_destroy(dp->pl); 1096 return err; 1097 } 1098 1099 int dsa_port_link_register_of(struct dsa_port *dp) 1100 { 1101 struct dsa_switch *ds = dp->ds; 1102 struct device_node *phy_np; 1103 int port = dp->index; 1104 1105 if (!ds->ops->adjust_link) { 1106 phy_np = of_parse_phandle(dp->dn, "phy-handle", 0); 1107 if (of_phy_is_fixed_link(dp->dn) || phy_np) { 1108 if (ds->ops->phylink_mac_link_down) 1109 ds->ops->phylink_mac_link_down(ds, port, 1110 MLO_AN_FIXED, PHY_INTERFACE_MODE_NA); 1111 return dsa_port_phylink_register(dp); 1112 } 1113 return 0; 1114 } 1115 1116 dev_warn(ds->dev, 1117 "Using legacy PHYLIB callbacks. Please migrate to PHYLINK!\n"); 1118 1119 if (of_phy_is_fixed_link(dp->dn)) 1120 return dsa_port_fixed_link_register_of(dp); 1121 else 1122 return dsa_port_setup_phy_of(dp, true); 1123 } 1124 1125 void dsa_port_link_unregister_of(struct dsa_port *dp) 1126 { 1127 struct dsa_switch *ds = dp->ds; 1128 1129 if (!ds->ops->adjust_link && dp->pl) { 1130 rtnl_lock(); 1131 phylink_disconnect_phy(dp->pl); 1132 rtnl_unlock(); 1133 phylink_destroy(dp->pl); 1134 dp->pl = NULL; 1135 return; 1136 } 1137 1138 if (of_phy_is_fixed_link(dp->dn)) 1139 of_phy_deregister_fixed_link(dp->dn); 1140 else 1141 dsa_port_setup_phy_of(dp, false); 1142 } 1143 1144 int dsa_port_get_phy_strings(struct dsa_port *dp, uint8_t *data) 1145 { 1146 struct phy_device *phydev; 1147 int ret = -EOPNOTSUPP; 1148 1149 if (of_phy_is_fixed_link(dp->dn)) 1150 return ret; 1151 1152 phydev = dsa_port_get_phy_device(dp); 1153 if (IS_ERR_OR_NULL(phydev)) 1154 return ret; 1155 1156 ret = phy_ethtool_get_strings(phydev, data); 1157 put_device(&phydev->mdio.dev); 1158 1159 return ret; 1160 } 1161 EXPORT_SYMBOL_GPL(dsa_port_get_phy_strings); 1162 1163 int dsa_port_get_ethtool_phy_stats(struct dsa_port *dp, uint64_t *data) 1164 { 1165 struct phy_device *phydev; 1166 int ret = -EOPNOTSUPP; 1167 1168 if (of_phy_is_fixed_link(dp->dn)) 1169 return ret; 1170 1171 phydev = dsa_port_get_phy_device(dp); 1172 if (IS_ERR_OR_NULL(phydev)) 1173 return ret; 1174 1175 ret = phy_ethtool_get_stats(phydev, NULL, data); 1176 put_device(&phydev->mdio.dev); 1177 1178 return ret; 1179 } 1180 EXPORT_SYMBOL_GPL(dsa_port_get_ethtool_phy_stats); 1181 1182 int dsa_port_get_phy_sset_count(struct dsa_port *dp) 1183 { 1184 struct phy_device *phydev; 1185 int ret = -EOPNOTSUPP; 1186 1187 if (of_phy_is_fixed_link(dp->dn)) 1188 return ret; 1189 1190 phydev = dsa_port_get_phy_device(dp); 1191 if (IS_ERR_OR_NULL(phydev)) 1192 return ret; 1193 1194 ret = phy_ethtool_get_sset_count(phydev); 1195 put_device(&phydev->mdio.dev); 1196 1197 return ret; 1198 } 1199 EXPORT_SYMBOL_GPL(dsa_port_get_phy_sset_count); 1200 1201 int dsa_port_hsr_join(struct dsa_port *dp, struct net_device *hsr) 1202 { 1203 struct dsa_notifier_hsr_info info = { 1204 .sw_index = dp->ds->index, 1205 .port = dp->index, 1206 .hsr = hsr, 1207 }; 1208 int err; 1209 1210 dp->hsr_dev = hsr; 1211 1212 err = dsa_port_notify(dp, DSA_NOTIFIER_HSR_JOIN, &info); 1213 if (err) 1214 dp->hsr_dev = NULL; 1215 1216 return err; 1217 } 1218 1219 void dsa_port_hsr_leave(struct dsa_port *dp, struct net_device *hsr) 1220 { 1221 struct dsa_notifier_hsr_info info = { 1222 .sw_index = dp->ds->index, 1223 .port = dp->index, 1224 .hsr = hsr, 1225 }; 1226 int err; 1227 1228 dp->hsr_dev = NULL; 1229 1230 err = dsa_port_notify(dp, DSA_NOTIFIER_HSR_LEAVE, &info); 1231 if (err) 1232 pr_err("DSA: failed to notify DSA_NOTIFIER_HSR_LEAVE\n"); 1233 } 1234 1235 int dsa_port_tag_8021q_vlan_add(struct dsa_port *dp, u16 vid) 1236 { 1237 struct dsa_notifier_tag_8021q_vlan_info info = { 1238 .tree_index = dp->ds->dst->index, 1239 .sw_index = dp->ds->index, 1240 .port = dp->index, 1241 .vid = vid, 1242 }; 1243 1244 return dsa_broadcast(DSA_NOTIFIER_TAG_8021Q_VLAN_ADD, &info); 1245 } 1246 1247 void dsa_port_tag_8021q_vlan_del(struct dsa_port *dp, u16 vid) 1248 { 1249 struct dsa_notifier_tag_8021q_vlan_info info = { 1250 .tree_index = dp->ds->dst->index, 1251 .sw_index = dp->ds->index, 1252 .port = dp->index, 1253 .vid = vid, 1254 }; 1255 int err; 1256 1257 err = dsa_broadcast(DSA_NOTIFIER_TAG_8021Q_VLAN_DEL, &info); 1258 if (err) 1259 pr_err("DSA: failed to notify tag_8021q VLAN deletion: %pe\n", 1260 ERR_PTR(err)); 1261 } 1262