1// SPDX-License-Identifier: GPL-2.0-or-later 2/* 3 * DSA topology and switch handling 4 * 5 * Copyright (c) 2008-2009 Marvell Semiconductor 6 * Copyright (c) 2013 Florian Fainelli <florian@openwrt.org> 7 * Copyright (c) 2016 Andrew Lunn <andrew@lunn.ch> 8 */ 9 10#include <linux/device.h> 11#include <linux/err.h> 12#include <linux/list.h> 13#include <linux/module.h> 14#include <linux/netdevice.h> 15#include <linux/slab.h> 16#include <linux/rtnetlink.h> 17#include <linux/of.h> 18#include <linux/of_mdio.h> 19#include <linux/of_net.h> 20#include <net/dsa_stubs.h> 21#include <net/sch_generic.h> 22 23#include "devlink.h" 24#include "dsa.h" 25#include "master.h" 26#include "netlink.h" 27#include "port.h" 28#include "slave.h" 29#include "switch.h" 30#include "tag.h" 31 32#define DSA_MAX_NUM_OFFLOADING_BRIDGES BITS_PER_LONG 33 34static DEFINE_MUTEX(dsa2_mutex); 35LIST_HEAD(dsa_tree_list); 36 37static struct workqueue_struct *dsa_owq; 38 39/* Track the bridges with forwarding offload enabled */ 40static unsigned long dsa_fwd_offloading_bridges; 41 42bool dsa_schedule_work(struct work_struct *work) 43{ 44 return queue_work(dsa_owq, work); 45} 46 47void dsa_flush_workqueue(void) 48{ 49 flush_workqueue(dsa_owq); 50} 51EXPORT_SYMBOL_GPL(dsa_flush_workqueue); 52 53/** 54 * dsa_lag_map() - Map LAG structure to a linear LAG array 55 * @dst: Tree in which to record the mapping. 56 * @lag: LAG structure that is to be mapped to the tree's array. 57 * 58 * dsa_lag_id/dsa_lag_by_id can then be used to translate between the 59 * two spaces. The size of the mapping space is determined by the 60 * driver by setting ds->num_lag_ids. It is perfectly legal to leave 61 * it unset if it is not needed, in which case these functions become 62 * no-ops. 63 */ 64void dsa_lag_map(struct dsa_switch_tree *dst, struct dsa_lag *lag) 65{ 66 unsigned int id; 67 68 for (id = 1; id <= dst->lags_len; id++) { 69 if (!dsa_lag_by_id(dst, id)) { 70 dst->lags[id - 1] = lag; 71 lag->id = id; 72 return; 73 } 74 } 75 76 /* No IDs left, which is OK. Some drivers do not need it. The 77 * ones that do, e.g. mv88e6xxx, will discover that dsa_lag_id 78 * returns an error for this device when joining the LAG. The 79 * driver can then return -EOPNOTSUPP back to DSA, which will 80 * fall back to a software LAG. 81 */ 82} 83 84/** 85 * dsa_lag_unmap() - Remove a LAG ID mapping 86 * @dst: Tree in which the mapping is recorded. 87 * @lag: LAG structure that was mapped. 88 * 89 * As there may be multiple users of the mapping, it is only removed 90 * if there are no other references to it. 91 */ 92void dsa_lag_unmap(struct dsa_switch_tree *dst, struct dsa_lag *lag) 93{ 94 unsigned int id; 95 96 dsa_lags_foreach_id(id, dst) { 97 if (dsa_lag_by_id(dst, id) == lag) { 98 dst->lags[id - 1] = NULL; 99 lag->id = 0; 100 break; 101 } 102 } 103} 104 105struct dsa_lag *dsa_tree_lag_find(struct dsa_switch_tree *dst, 106 const struct net_device *lag_dev) 107{ 108 struct dsa_port *dp; 109 110 list_for_each_entry(dp, &dst->ports, list) 111 if (dsa_port_lag_dev_get(dp) == lag_dev) 112 return dp->lag; 113 114 return NULL; 115} 116 117struct dsa_bridge *dsa_tree_bridge_find(struct dsa_switch_tree *dst, 118 const struct net_device *br) 119{ 120 struct dsa_port *dp; 121 122 list_for_each_entry(dp, &dst->ports, list) 123 if (dsa_port_bridge_dev_get(dp) == br) 124 return dp->bridge; 125 126 return NULL; 127} 128 129static int dsa_bridge_num_find(const struct net_device *bridge_dev) 130{ 131 struct dsa_switch_tree *dst; 132 133 list_for_each_entry(dst, &dsa_tree_list, list) { 134 struct dsa_bridge *bridge; 135 136 bridge = dsa_tree_bridge_find(dst, bridge_dev); 137 if (bridge) 138 return bridge->num; 139 } 140 141 return 0; 142} 143 144unsigned int dsa_bridge_num_get(const struct net_device *bridge_dev, int max) 145{ 146 unsigned int bridge_num = dsa_bridge_num_find(bridge_dev); 147 148 /* Switches without FDB isolation support don't get unique 149 * bridge numbering 150 */ 151 if (!max) 152 return 0; 153 154 if (!bridge_num) { 155 /* First port that requests FDB isolation or TX forwarding 156 * offload for this bridge 157 */ 158 bridge_num = find_next_zero_bit(&dsa_fwd_offloading_bridges, 159 DSA_MAX_NUM_OFFLOADING_BRIDGES, 160 1); 161 if (bridge_num >= max) 162 return 0; 163 164 set_bit(bridge_num, &dsa_fwd_offloading_bridges); 165 } 166 167 return bridge_num; 168} 169 170void dsa_bridge_num_put(const struct net_device *bridge_dev, 171 unsigned int bridge_num) 172{ 173 /* Since we refcount bridges, we know that when we call this function 174 * it is no longer in use, so we can just go ahead and remove it from 175 * the bit mask. 176 */ 177 clear_bit(bridge_num, &dsa_fwd_offloading_bridges); 178} 179 180struct dsa_switch *dsa_switch_find(int tree_index, int sw_index) 181{ 182 struct dsa_switch_tree *dst; 183 struct dsa_port *dp; 184 185 list_for_each_entry(dst, &dsa_tree_list, list) { 186 if (dst->index != tree_index) 187 continue; 188 189 list_for_each_entry(dp, &dst->ports, list) { 190 if (dp->ds->index != sw_index) 191 continue; 192 193 return dp->ds; 194 } 195 } 196 197 return NULL; 198} 199EXPORT_SYMBOL_GPL(dsa_switch_find); 200 201static struct dsa_switch_tree *dsa_tree_find(int index) 202{ 203 struct dsa_switch_tree *dst; 204 205 list_for_each_entry(dst, &dsa_tree_list, list) 206 if (dst->index == index) 207 return dst; 208 209 return NULL; 210} 211 212static struct dsa_switch_tree *dsa_tree_alloc(int index) 213{ 214 struct dsa_switch_tree *dst; 215 216 dst = kzalloc(sizeof(*dst), GFP_KERNEL); 217 if (!dst) 218 return NULL; 219 220 dst->index = index; 221 222 INIT_LIST_HEAD(&dst->rtable); 223 224 INIT_LIST_HEAD(&dst->ports); 225 226 INIT_LIST_HEAD(&dst->list); 227 list_add_tail(&dst->list, &dsa_tree_list); 228 229 kref_init(&dst->refcount); 230 231 return dst; 232} 233 234static void dsa_tree_free(struct dsa_switch_tree *dst) 235{ 236 if (dst->tag_ops) 237 dsa_tag_driver_put(dst->tag_ops); 238 list_del(&dst->list); 239 kfree(dst); 240} 241 242static struct dsa_switch_tree *dsa_tree_get(struct dsa_switch_tree *dst) 243{ 244 if (dst) 245 kref_get(&dst->refcount); 246 247 return dst; 248} 249 250static struct dsa_switch_tree *dsa_tree_touch(int index) 251{ 252 struct dsa_switch_tree *dst; 253 254 dst = dsa_tree_find(index); 255 if (dst) 256 return dsa_tree_get(dst); 257 else 258 return dsa_tree_alloc(index); 259} 260 261static void dsa_tree_release(struct kref *ref) 262{ 263 struct dsa_switch_tree *dst; 264 265 dst = container_of(ref, struct dsa_switch_tree, refcount); 266 267 dsa_tree_free(dst); 268} 269 270static void dsa_tree_put(struct dsa_switch_tree *dst) 271{ 272 if (dst) 273 kref_put(&dst->refcount, dsa_tree_release); 274} 275 276static struct dsa_port *dsa_tree_find_port_by_node(struct dsa_switch_tree *dst, 277 struct device_node *dn) 278{ 279 struct dsa_port *dp; 280 281 list_for_each_entry(dp, &dst->ports, list) 282 if (dp->dn == dn) 283 return dp; 284 285 return NULL; 286} 287 288static struct dsa_link *dsa_link_touch(struct dsa_port *dp, 289 struct dsa_port *link_dp) 290{ 291 struct dsa_switch *ds = dp->ds; 292 struct dsa_switch_tree *dst; 293 struct dsa_link *dl; 294 295 dst = ds->dst; 296 297 list_for_each_entry(dl, &dst->rtable, list) 298 if (dl->dp == dp && dl->link_dp == link_dp) 299 return dl; 300 301 dl = kzalloc(sizeof(*dl), GFP_KERNEL); 302 if (!dl) 303 return NULL; 304 305 dl->dp = dp; 306 dl->link_dp = link_dp; 307 308 INIT_LIST_HEAD(&dl->list); 309 list_add_tail(&dl->list, &dst->rtable); 310 311 return dl; 312} 313 314static bool dsa_port_setup_routing_table(struct dsa_port *dp) 315{ 316 struct dsa_switch *ds = dp->ds; 317 struct dsa_switch_tree *dst = ds->dst; 318 struct device_node *dn = dp->dn; 319 struct of_phandle_iterator it; 320 struct dsa_port *link_dp; 321 struct dsa_link *dl; 322 int err; 323 324 of_for_each_phandle(&it, err, dn, "link", NULL, 0) { 325 link_dp = dsa_tree_find_port_by_node(dst, it.node); 326 if (!link_dp) { 327 of_node_put(it.node); 328 return false; 329 } 330 331 dl = dsa_link_touch(dp, link_dp); 332 if (!dl) { 333 of_node_put(it.node); 334 return false; 335 } 336 } 337 338 return true; 339} 340 341static bool dsa_tree_setup_routing_table(struct dsa_switch_tree *dst) 342{ 343 bool complete = true; 344 struct dsa_port *dp; 345 346 list_for_each_entry(dp, &dst->ports, list) { 347 if (dsa_port_is_dsa(dp)) { 348 complete = dsa_port_setup_routing_table(dp); 349 if (!complete) 350 break; 351 } 352 } 353 354 return complete; 355} 356 357static struct dsa_port *dsa_tree_find_first_cpu(struct dsa_switch_tree *dst) 358{ 359 struct dsa_port *dp; 360 361 list_for_each_entry(dp, &dst->ports, list) 362 if (dsa_port_is_cpu(dp)) 363 return dp; 364 365 return NULL; 366} 367 368struct net_device *dsa_tree_find_first_master(struct dsa_switch_tree *dst) 369{ 370 struct device_node *ethernet; 371 struct net_device *master; 372 struct dsa_port *cpu_dp; 373 374 cpu_dp = dsa_tree_find_first_cpu(dst); 375 ethernet = of_parse_phandle(cpu_dp->dn, "ethernet", 0); 376 master = of_find_net_device_by_node(ethernet); 377 of_node_put(ethernet); 378 379 return master; 380} 381 382/* Assign the default CPU port (the first one in the tree) to all ports of the 383 * fabric which don't already have one as part of their own switch. 384 */ 385static int dsa_tree_setup_default_cpu(struct dsa_switch_tree *dst) 386{ 387 struct dsa_port *cpu_dp, *dp; 388 389 cpu_dp = dsa_tree_find_first_cpu(dst); 390 if (!cpu_dp) { 391 pr_err("DSA: tree %d has no CPU port\n", dst->index); 392 return -EINVAL; 393 } 394 395 list_for_each_entry(dp, &dst->ports, list) { 396 if (dp->cpu_dp) 397 continue; 398 399 if (dsa_port_is_user(dp) || dsa_port_is_dsa(dp)) 400 dp->cpu_dp = cpu_dp; 401 } 402 403 return 0; 404} 405 406static struct dsa_port * 407dsa_switch_preferred_default_local_cpu_port(struct dsa_switch *ds) 408{ 409 struct dsa_port *cpu_dp; 410 411 if (!ds->ops->preferred_default_local_cpu_port) 412 return NULL; 413 414 cpu_dp = ds->ops->preferred_default_local_cpu_port(ds); 415 if (!cpu_dp) 416 return NULL; 417 418 if (WARN_ON(!dsa_port_is_cpu(cpu_dp) || cpu_dp->ds != ds)) 419 return NULL; 420 421 return cpu_dp; 422} 423 424/* Perform initial assignment of CPU ports to user ports and DSA links in the 425 * fabric, giving preference to CPU ports local to each switch. Default to 426 * using the first CPU port in the switch tree if the port does not have a CPU 427 * port local to this switch. 428 */ 429static int dsa_tree_setup_cpu_ports(struct dsa_switch_tree *dst) 430{ 431 struct dsa_port *preferred_cpu_dp, *cpu_dp, *dp; 432 433 list_for_each_entry(cpu_dp, &dst->ports, list) { 434 if (!dsa_port_is_cpu(cpu_dp)) 435 continue; 436 437 preferred_cpu_dp = dsa_switch_preferred_default_local_cpu_port(cpu_dp->ds); 438 if (preferred_cpu_dp && preferred_cpu_dp != cpu_dp) 439 continue; 440 441 /* Prefer a local CPU port */ 442 dsa_switch_for_each_port(dp, cpu_dp->ds) { 443 /* Prefer the first local CPU port found */ 444 if (dp->cpu_dp) 445 continue; 446 447 if (dsa_port_is_user(dp) || dsa_port_is_dsa(dp)) 448 dp->cpu_dp = cpu_dp; 449 } 450 } 451 452 return dsa_tree_setup_default_cpu(dst); 453} 454 455static void dsa_tree_teardown_cpu_ports(struct dsa_switch_tree *dst) 456{ 457 struct dsa_port *dp; 458 459 list_for_each_entry(dp, &dst->ports, list) 460 if (dsa_port_is_user(dp) || dsa_port_is_dsa(dp)) 461 dp->cpu_dp = NULL; 462} 463 464static int dsa_port_setup(struct dsa_port *dp) 465{ 466 bool dsa_port_link_registered = false; 467 struct dsa_switch *ds = dp->ds; 468 bool dsa_port_enabled = false; 469 int err = 0; 470 471 if (dp->setup) 472 return 0; 473 474 err = dsa_port_devlink_setup(dp); 475 if (err) 476 return err; 477 478 switch (dp->type) { 479 case DSA_PORT_TYPE_UNUSED: 480 dsa_port_disable(dp); 481 break; 482 case DSA_PORT_TYPE_CPU: 483 if (dp->dn) { 484 err = dsa_shared_port_link_register_of(dp); 485 if (err) 486 break; 487 dsa_port_link_registered = true; 488 } else { 489 dev_warn(ds->dev, 490 "skipping link registration for CPU port %d\n", 491 dp->index); 492 } 493 494 err = dsa_port_enable(dp, NULL); 495 if (err) 496 break; 497 dsa_port_enabled = true; 498 499 break; 500 case DSA_PORT_TYPE_DSA: 501 if (dp->dn) { 502 err = dsa_shared_port_link_register_of(dp); 503 if (err) 504 break; 505 dsa_port_link_registered = true; 506 } else { 507 dev_warn(ds->dev, 508 "skipping link registration for DSA port %d\n", 509 dp->index); 510 } 511 512 err = dsa_port_enable(dp, NULL); 513 if (err) 514 break; 515 dsa_port_enabled = true; 516 517 break; 518 case DSA_PORT_TYPE_USER: 519 of_get_mac_address(dp->dn, dp->mac); 520 err = dsa_slave_create(dp); 521 break; 522 } 523 524 if (err && dsa_port_enabled) 525 dsa_port_disable(dp); 526 if (err && dsa_port_link_registered) 527 dsa_shared_port_link_unregister_of(dp); 528 if (err) { 529 dsa_port_devlink_teardown(dp); 530 return err; 531 } 532 533 dp->setup = true; 534 535 return 0; 536} 537 538static void dsa_port_teardown(struct dsa_port *dp) 539{ 540 if (!dp->setup) 541 return; 542 543 switch (dp->type) { 544 case DSA_PORT_TYPE_UNUSED: 545 break; 546 case DSA_PORT_TYPE_CPU: 547 dsa_port_disable(dp); 548 if (dp->dn) 549 dsa_shared_port_link_unregister_of(dp); 550 break; 551 case DSA_PORT_TYPE_DSA: 552 dsa_port_disable(dp); 553 if (dp->dn) 554 dsa_shared_port_link_unregister_of(dp); 555 break; 556 case DSA_PORT_TYPE_USER: 557 if (dp->slave) { 558 dsa_slave_destroy(dp->slave); 559 dp->slave = NULL; 560 } 561 break; 562 } 563 564 dsa_port_devlink_teardown(dp); 565 566 dp->setup = false; 567} 568 569static int dsa_port_setup_as_unused(struct dsa_port *dp) 570{ 571 dp->type = DSA_PORT_TYPE_UNUSED; 572 return dsa_port_setup(dp); 573} 574 575static int dsa_switch_setup_tag_protocol(struct dsa_switch *ds) 576{ 577 const struct dsa_device_ops *tag_ops = ds->dst->tag_ops; 578 struct dsa_switch_tree *dst = ds->dst; 579 int err; 580 581 if (tag_ops->proto == dst->default_proto) 582 goto connect; 583 584 rtnl_lock(); 585 err = ds->ops->change_tag_protocol(ds, tag_ops->proto); 586 rtnl_unlock(); 587 if (err) { 588 dev_err(ds->dev, "Unable to use tag protocol \"%s\": %pe\n", 589 tag_ops->name, ERR_PTR(err)); 590 return err; 591 } 592 593connect: 594 if (tag_ops->connect) { 595 err = tag_ops->connect(ds); 596 if (err) 597 return err; 598 } 599 600 if (ds->ops->connect_tag_protocol) { 601 err = ds->ops->connect_tag_protocol(ds, tag_ops->proto); 602 if (err) { 603 dev_err(ds->dev, 604 "Unable to connect to tag protocol \"%s\": %pe\n", 605 tag_ops->name, ERR_PTR(err)); 606 goto disconnect; 607 } 608 } 609 610 return 0; 611 612disconnect: 613 if (tag_ops->disconnect) 614 tag_ops->disconnect(ds); 615 616 return err; 617} 618 619static void dsa_switch_teardown_tag_protocol(struct dsa_switch *ds) 620{ 621 const struct dsa_device_ops *tag_ops = ds->dst->tag_ops; 622 623 if (tag_ops->disconnect) 624 tag_ops->disconnect(ds); 625} 626 627static int dsa_switch_setup(struct dsa_switch *ds) 628{ 629 struct device_node *dn; 630 int err; 631 632 if (ds->setup) 633 return 0; 634 635 /* Initialize ds->phys_mii_mask before registering the slave MDIO bus 636 * driver and before ops->setup() has run, since the switch drivers and 637 * the slave MDIO bus driver rely on these values for probing PHY 638 * devices or not 639 */ 640 ds->phys_mii_mask |= dsa_user_ports(ds); 641 642 err = dsa_switch_devlink_alloc(ds); 643 if (err) 644 return err; 645 646 err = dsa_switch_register_notifier(ds); 647 if (err) 648 goto devlink_free; 649 650 ds->configure_vlan_while_not_filtering = true; 651 652 err = ds->ops->setup(ds); 653 if (err < 0) 654 goto unregister_notifier; 655 656 err = dsa_switch_setup_tag_protocol(ds); 657 if (err) 658 goto teardown; 659 660 if (!ds->slave_mii_bus && ds->ops->phy_read) { 661 ds->slave_mii_bus = mdiobus_alloc(); 662 if (!ds->slave_mii_bus) { 663 err = -ENOMEM; 664 goto teardown; 665 } 666 667 dsa_slave_mii_bus_init(ds); 668 669 dn = of_get_child_by_name(ds->dev->of_node, "mdio"); 670 671 err = of_mdiobus_register(ds->slave_mii_bus, dn); 672 of_node_put(dn); 673 if (err < 0) 674 goto free_slave_mii_bus; 675 } 676 677 dsa_switch_devlink_register(ds); 678 679 ds->setup = true; 680 return 0; 681 682free_slave_mii_bus: 683 if (ds->slave_mii_bus && ds->ops->phy_read) 684 mdiobus_free(ds->slave_mii_bus); 685teardown: 686 if (ds->ops->teardown) 687 ds->ops->teardown(ds); 688unregister_notifier: 689 dsa_switch_unregister_notifier(ds); 690devlink_free: 691 dsa_switch_devlink_free(ds); 692 return err; 693} 694 695static void dsa_switch_teardown(struct dsa_switch *ds) 696{ 697 if (!ds->setup) 698 return; 699 700 dsa_switch_devlink_unregister(ds); 701 702 if (ds->slave_mii_bus && ds->ops->phy_read) { 703 mdiobus_unregister(ds->slave_mii_bus); 704 mdiobus_free(ds->slave_mii_bus); 705 ds->slave_mii_bus = NULL; 706 } 707 708 dsa_switch_teardown_tag_protocol(ds); 709 710 if (ds->ops->teardown) 711 ds->ops->teardown(ds); 712 713 dsa_switch_unregister_notifier(ds); 714 715 dsa_switch_devlink_free(ds); 716 717 ds->setup = false; 718} 719 720/* First tear down the non-shared, then the shared ports. This ensures that 721 * all work items scheduled by our switchdev handlers for user ports have 722 * completed before we destroy the refcounting kept on the shared ports. 723 */ 724static void dsa_tree_teardown_ports(struct dsa_switch_tree *dst) 725{ 726 struct dsa_port *dp; 727 728 list_for_each_entry(dp, &dst->ports, list) 729 if (dsa_port_is_user(dp) || dsa_port_is_unused(dp)) 730 dsa_port_teardown(dp); 731 732 dsa_flush_workqueue(); 733 734 list_for_each_entry(dp, &dst->ports, list) 735 if (dsa_port_is_dsa(dp) || dsa_port_is_cpu(dp)) 736 dsa_port_teardown(dp); 737} 738 739static void dsa_tree_teardown_switches(struct dsa_switch_tree *dst) 740{ 741 struct dsa_port *dp; 742 743 list_for_each_entry(dp, &dst->ports, list) 744 dsa_switch_teardown(dp->ds); 745} 746 747/* Bring shared ports up first, then non-shared ports */ 748static int dsa_tree_setup_ports(struct dsa_switch_tree *dst) 749{ 750 struct dsa_port *dp; 751 int err = 0; 752 753 list_for_each_entry(dp, &dst->ports, list) { 754 if (dsa_port_is_dsa(dp) || dsa_port_is_cpu(dp)) { 755 err = dsa_port_setup(dp); 756 if (err) 757 goto teardown; 758 } 759 } 760 761 list_for_each_entry(dp, &dst->ports, list) { 762 if (dsa_port_is_user(dp) || dsa_port_is_unused(dp)) { 763 err = dsa_port_setup(dp); 764 if (err) { 765 err = dsa_port_setup_as_unused(dp); 766 if (err) 767 goto teardown; 768 } 769 } 770 } 771 772 return 0; 773 774teardown: 775 dsa_tree_teardown_ports(dst); 776 777 return err; 778} 779 780static int dsa_tree_setup_switches(struct dsa_switch_tree *dst) 781{ 782 struct dsa_port *dp; 783 int err = 0; 784 785 list_for_each_entry(dp, &dst->ports, list) { 786 err = dsa_switch_setup(dp->ds); 787 if (err) { 788 dsa_tree_teardown_switches(dst); 789 break; 790 } 791 } 792 793 return err; 794} 795 796static int dsa_tree_setup_master(struct dsa_switch_tree *dst) 797{ 798 struct dsa_port *cpu_dp; 799 int err = 0; 800 801 rtnl_lock(); 802 803 dsa_tree_for_each_cpu_port(cpu_dp, dst) { 804 struct net_device *master = cpu_dp->master; 805 bool admin_up = (master->flags & IFF_UP) && 806 !qdisc_tx_is_noop(master); 807 808 err = dsa_master_setup(master, cpu_dp); 809 if (err) 810 break; 811 812 /* Replay master state event */ 813 dsa_tree_master_admin_state_change(dst, master, admin_up); 814 dsa_tree_master_oper_state_change(dst, master, 815 netif_oper_up(master)); 816 } 817 818 rtnl_unlock(); 819 820 return err; 821} 822 823static void dsa_tree_teardown_master(struct dsa_switch_tree *dst) 824{ 825 struct dsa_port *cpu_dp; 826 827 rtnl_lock(); 828 829 dsa_tree_for_each_cpu_port(cpu_dp, dst) { 830 struct net_device *master = cpu_dp->master; 831 832 /* Synthesizing an "admin down" state is sufficient for 833 * the switches to get a notification if the master is 834 * currently up and running. 835 */ 836 dsa_tree_master_admin_state_change(dst, master, false); 837 838 dsa_master_teardown(master); 839 } 840 841 rtnl_unlock(); 842} 843 844static int dsa_tree_setup_lags(struct dsa_switch_tree *dst) 845{ 846 unsigned int len = 0; 847 struct dsa_port *dp; 848 849 list_for_each_entry(dp, &dst->ports, list) { 850 if (dp->ds->num_lag_ids > len) 851 len = dp->ds->num_lag_ids; 852 } 853 854 if (!len) 855 return 0; 856 857 dst->lags = kcalloc(len, sizeof(*dst->lags), GFP_KERNEL); 858 if (!dst->lags) 859 return -ENOMEM; 860 861 dst->lags_len = len; 862 return 0; 863} 864 865static void dsa_tree_teardown_lags(struct dsa_switch_tree *dst) 866{ 867 kfree(dst->lags); 868} 869 870static int dsa_tree_setup(struct dsa_switch_tree *dst) 871{ 872 bool complete; 873 int err; 874 875 if (dst->setup) { 876 pr_err("DSA: tree %d already setup! Disjoint trees?\n", 877 dst->index); 878 return -EEXIST; 879 } 880 881 complete = dsa_tree_setup_routing_table(dst); 882 if (!complete) 883 return 0; 884 885 err = dsa_tree_setup_cpu_ports(dst); 886 if (err) 887 return err; 888 889 err = dsa_tree_setup_switches(dst); 890 if (err) 891 goto teardown_cpu_ports; 892 893 err = dsa_tree_setup_ports(dst); 894 if (err) 895 goto teardown_switches; 896 897 err = dsa_tree_setup_master(dst); 898 if (err) 899 goto teardown_ports; 900 901 err = dsa_tree_setup_lags(dst); 902 if (err) 903 goto teardown_master; 904 905 dst->setup = true; 906 907 pr_info("DSA: tree %d setup\n", dst->index); 908 909 return 0; 910 911teardown_master: 912 dsa_tree_teardown_master(dst); 913teardown_ports: 914 dsa_tree_teardown_ports(dst); 915teardown_switches: 916 dsa_tree_teardown_switches(dst); 917teardown_cpu_ports: 918 dsa_tree_teardown_cpu_ports(dst); 919 920 return err; 921} 922 923static void dsa_tree_teardown(struct dsa_switch_tree *dst) 924{ 925 struct dsa_link *dl, *next; 926 927 if (!dst->setup) 928 return; 929 930 dsa_tree_teardown_lags(dst); 931 932 dsa_tree_teardown_master(dst); 933 934 dsa_tree_teardown_ports(dst); 935 936 dsa_tree_teardown_switches(dst); 937 938 dsa_tree_teardown_cpu_ports(dst); 939 940 list_for_each_entry_safe(dl, next, &dst->rtable, list) { 941 list_del(&dl->list); 942 kfree(dl); 943 } 944 945 pr_info("DSA: tree %d torn down\n", dst->index); 946 947 dst->setup = false; 948} 949 950static int dsa_tree_bind_tag_proto(struct dsa_switch_tree *dst, 951 const struct dsa_device_ops *tag_ops) 952{ 953 const struct dsa_device_ops *old_tag_ops = dst->tag_ops; 954 struct dsa_notifier_tag_proto_info info; 955 int err; 956 957 dst->tag_ops = tag_ops; 958 959 /* Notify the switches from this tree about the connection 960 * to the new tagger 961 */ 962 info.tag_ops = tag_ops; 963 err = dsa_tree_notify(dst, DSA_NOTIFIER_TAG_PROTO_CONNECT, &info); 964 if (err && err != -EOPNOTSUPP) 965 goto out_disconnect; 966 967 /* Notify the old tagger about the disconnection from this tree */ 968 info.tag_ops = old_tag_ops; 969 dsa_tree_notify(dst, DSA_NOTIFIER_TAG_PROTO_DISCONNECT, &info); 970 971 return 0; 972 973out_disconnect: 974 info.tag_ops = tag_ops; 975 dsa_tree_notify(dst, DSA_NOTIFIER_TAG_PROTO_DISCONNECT, &info); 976 dst->tag_ops = old_tag_ops; 977 978 return err; 979} 980 981/* Since the dsa/tagging sysfs device attribute is per master, the assumption 982 * is that all DSA switches within a tree share the same tagger, otherwise 983 * they would have formed disjoint trees (different "dsa,member" values). 984 */ 985int dsa_tree_change_tag_proto(struct dsa_switch_tree *dst, 986 const struct dsa_device_ops *tag_ops, 987 const struct dsa_device_ops *old_tag_ops) 988{ 989 struct dsa_notifier_tag_proto_info info; 990 struct dsa_port *dp; 991 int err = -EBUSY; 992 993 if (!rtnl_trylock()) 994 return restart_syscall(); 995 996 /* At the moment we don't allow changing the tag protocol under 997 * traffic. The rtnl_mutex also happens to serialize concurrent 998 * attempts to change the tagging protocol. If we ever lift the IFF_UP 999 * restriction, there needs to be another mutex which serializes this. 1000 */ 1001 dsa_tree_for_each_user_port(dp, dst) { 1002 if (dsa_port_to_master(dp)->flags & IFF_UP) 1003 goto out_unlock; 1004 1005 if (dp->slave->flags & IFF_UP) 1006 goto out_unlock; 1007 } 1008 1009 /* Notify the tag protocol change */ 1010 info.tag_ops = tag_ops; 1011 err = dsa_tree_notify(dst, DSA_NOTIFIER_TAG_PROTO, &info); 1012 if (err) 1013 goto out_unwind_tagger; 1014 1015 err = dsa_tree_bind_tag_proto(dst, tag_ops); 1016 if (err) 1017 goto out_unwind_tagger; 1018 1019 rtnl_unlock(); 1020 1021 return 0; 1022 1023out_unwind_tagger: 1024 info.tag_ops = old_tag_ops; 1025 dsa_tree_notify(dst, DSA_NOTIFIER_TAG_PROTO, &info); 1026out_unlock: 1027 rtnl_unlock(); 1028 return err; 1029} 1030 1031static void dsa_tree_master_state_change(struct dsa_switch_tree *dst, 1032 struct net_device *master) 1033{ 1034 struct dsa_notifier_master_state_info info; 1035 struct dsa_port *cpu_dp = master->dsa_ptr; 1036 1037 info.master = master; 1038 info.operational = dsa_port_master_is_operational(cpu_dp); 1039 1040 dsa_tree_notify(dst, DSA_NOTIFIER_MASTER_STATE_CHANGE, &info); 1041} 1042 1043void dsa_tree_master_admin_state_change(struct dsa_switch_tree *dst, 1044 struct net_device *master, 1045 bool up) 1046{ 1047 struct dsa_port *cpu_dp = master->dsa_ptr; 1048 bool notify = false; 1049 1050 /* Don't keep track of admin state on LAG DSA masters, 1051 * but rather just of physical DSA masters 1052 */ 1053 if (netif_is_lag_master(master)) 1054 return; 1055 1056 if ((dsa_port_master_is_operational(cpu_dp)) != 1057 (up && cpu_dp->master_oper_up)) 1058 notify = true; 1059 1060 cpu_dp->master_admin_up = up; 1061 1062 if (notify) 1063 dsa_tree_master_state_change(dst, master); 1064} 1065 1066void dsa_tree_master_oper_state_change(struct dsa_switch_tree *dst, 1067 struct net_device *master, 1068 bool up) 1069{ 1070 struct dsa_port *cpu_dp = master->dsa_ptr; 1071 bool notify = false; 1072 1073 /* Don't keep track of oper state on LAG DSA masters, 1074 * but rather just of physical DSA masters 1075 */ 1076 if (netif_is_lag_master(master)) 1077 return; 1078 1079 if ((dsa_port_master_is_operational(cpu_dp)) != 1080 (cpu_dp->master_admin_up && up)) 1081 notify = true; 1082 1083 cpu_dp->master_oper_up = up; 1084 1085 if (notify) 1086 dsa_tree_master_state_change(dst, master); 1087} 1088 1089static struct dsa_port *dsa_port_touch(struct dsa_switch *ds, int index) 1090{ 1091 struct dsa_switch_tree *dst = ds->dst; 1092 struct dsa_port *dp; 1093 1094 dsa_switch_for_each_port(dp, ds) 1095 if (dp->index == index) 1096 return dp; 1097 1098 dp = kzalloc(sizeof(*dp), GFP_KERNEL); 1099 if (!dp) 1100 return NULL; 1101 1102 dp->ds = ds; 1103 dp->index = index; 1104 1105 mutex_init(&dp->addr_lists_lock); 1106 mutex_init(&dp->vlans_lock); 1107 INIT_LIST_HEAD(&dp->fdbs); 1108 INIT_LIST_HEAD(&dp->mdbs); 1109 INIT_LIST_HEAD(&dp->vlans); /* also initializes &dp->user_vlans */ 1110 INIT_LIST_HEAD(&dp->list); 1111 list_add_tail(&dp->list, &dst->ports); 1112 1113 return dp; 1114} 1115 1116static int dsa_port_parse_user(struct dsa_port *dp, const char *name) 1117{ 1118 dp->type = DSA_PORT_TYPE_USER; 1119 dp->name = name; 1120 1121 return 0; 1122} 1123 1124static int dsa_port_parse_dsa(struct dsa_port *dp) 1125{ 1126 dp->type = DSA_PORT_TYPE_DSA; 1127 1128 return 0; 1129} 1130 1131static enum dsa_tag_protocol dsa_get_tag_protocol(struct dsa_port *dp, 1132 struct net_device *master) 1133{ 1134 enum dsa_tag_protocol tag_protocol = DSA_TAG_PROTO_NONE; 1135 struct dsa_switch *mds, *ds = dp->ds; 1136 unsigned int mdp_upstream; 1137 struct dsa_port *mdp; 1138 1139 /* It is possible to stack DSA switches onto one another when that 1140 * happens the switch driver may want to know if its tagging protocol 1141 * is going to work in such a configuration. 1142 */ 1143 if (dsa_slave_dev_check(master)) { 1144 mdp = dsa_slave_to_port(master); 1145 mds = mdp->ds; 1146 mdp_upstream = dsa_upstream_port(mds, mdp->index); 1147 tag_protocol = mds->ops->get_tag_protocol(mds, mdp_upstream, 1148 DSA_TAG_PROTO_NONE); 1149 } 1150 1151 /* If the master device is not itself a DSA slave in a disjoint DSA 1152 * tree, then return immediately. 1153 */ 1154 return ds->ops->get_tag_protocol(ds, dp->index, tag_protocol); 1155} 1156 1157static int dsa_port_parse_cpu(struct dsa_port *dp, struct net_device *master, 1158 const char *user_protocol) 1159{ 1160 const struct dsa_device_ops *tag_ops = NULL; 1161 struct dsa_switch *ds = dp->ds; 1162 struct dsa_switch_tree *dst = ds->dst; 1163 enum dsa_tag_protocol default_proto; 1164 1165 /* Find out which protocol the switch would prefer. */ 1166 default_proto = dsa_get_tag_protocol(dp, master); 1167 if (dst->default_proto) { 1168 if (dst->default_proto != default_proto) { 1169 dev_err(ds->dev, 1170 "A DSA switch tree can have only one tagging protocol\n"); 1171 return -EINVAL; 1172 } 1173 } else { 1174 dst->default_proto = default_proto; 1175 } 1176 1177 /* See if the user wants to override that preference. */ 1178 if (user_protocol) { 1179 if (!ds->ops->change_tag_protocol) { 1180 dev_err(ds->dev, "Tag protocol cannot be modified\n"); 1181 return -EINVAL; 1182 } 1183 1184 tag_ops = dsa_tag_driver_get_by_name(user_protocol); 1185 if (IS_ERR(tag_ops)) { 1186 dev_warn(ds->dev, 1187 "Failed to find a tagging driver for protocol %s, using default\n", 1188 user_protocol); 1189 tag_ops = NULL; 1190 } 1191 } 1192 1193 if (!tag_ops) 1194 tag_ops = dsa_tag_driver_get_by_id(default_proto); 1195 1196 if (IS_ERR(tag_ops)) { 1197 if (PTR_ERR(tag_ops) == -ENOPROTOOPT) 1198 return -EPROBE_DEFER; 1199 1200 dev_warn(ds->dev, "No tagger for this switch\n"); 1201 return PTR_ERR(tag_ops); 1202 } 1203 1204 if (dst->tag_ops) { 1205 if (dst->tag_ops != tag_ops) { 1206 dev_err(ds->dev, 1207 "A DSA switch tree can have only one tagging protocol\n"); 1208 1209 dsa_tag_driver_put(tag_ops); 1210 return -EINVAL; 1211 } 1212 1213 /* In the case of multiple CPU ports per switch, the tagging 1214 * protocol is still reference-counted only per switch tree. 1215 */ 1216 dsa_tag_driver_put(tag_ops); 1217 } else { 1218 dst->tag_ops = tag_ops; 1219 } 1220 1221 dp->master = master; 1222 dp->type = DSA_PORT_TYPE_CPU; 1223 dsa_port_set_tag_protocol(dp, dst->tag_ops); 1224 dp->dst = dst; 1225 1226 /* At this point, the tree may be configured to use a different 1227 * tagger than the one chosen by the switch driver during 1228 * .setup, in the case when a user selects a custom protocol 1229 * through the DT. 1230 * 1231 * This is resolved by syncing the driver with the tree in 1232 * dsa_switch_setup_tag_protocol once .setup has run and the 1233 * driver is ready to accept calls to .change_tag_protocol. If 1234 * the driver does not support the custom protocol at that 1235 * point, the tree is wholly rejected, thereby ensuring that the 1236 * tree and driver are always in agreement on the protocol to 1237 * use. 1238 */ 1239 return 0; 1240} 1241 1242static int dsa_port_parse_of(struct dsa_port *dp, struct device_node *dn) 1243{ 1244 struct device_node *ethernet = of_parse_phandle(dn, "ethernet", 0); 1245 const char *name = of_get_property(dn, "label", NULL); 1246 bool link = of_property_read_bool(dn, "link"); 1247 1248 dp->dn = dn; 1249 1250 if (ethernet) { 1251 struct net_device *master; 1252 const char *user_protocol; 1253 1254 master = of_find_net_device_by_node(ethernet); 1255 of_node_put(ethernet); 1256 if (!master) 1257 return -EPROBE_DEFER; 1258 1259 user_protocol = of_get_property(dn, "dsa-tag-protocol", NULL); 1260 return dsa_port_parse_cpu(dp, master, user_protocol); 1261 } 1262 1263 if (link) 1264 return dsa_port_parse_dsa(dp); 1265 1266 return dsa_port_parse_user(dp, name); 1267} 1268 1269static int dsa_switch_parse_ports_of(struct dsa_switch *ds, 1270 struct device_node *dn) 1271{ 1272 struct device_node *ports, *port; 1273 struct dsa_port *dp; 1274 int err = 0; 1275 u32 reg; 1276 1277 ports = of_get_child_by_name(dn, "ports"); 1278 if (!ports) { 1279 /* The second possibility is "ethernet-ports" */ 1280 ports = of_get_child_by_name(dn, "ethernet-ports"); 1281 if (!ports) { 1282 dev_err(ds->dev, "no ports child node found\n"); 1283 return -EINVAL; 1284 } 1285 } 1286 1287 for_each_available_child_of_node(ports, port) { 1288 err = of_property_read_u32(port, "reg", ®); 1289 if (err) { 1290 of_node_put(port); 1291 goto out_put_node; 1292 } 1293 1294 if (reg >= ds->num_ports) { 1295 dev_err(ds->dev, "port %pOF index %u exceeds num_ports (%u)\n", 1296 port, reg, ds->num_ports); 1297 of_node_put(port); 1298 err = -EINVAL; 1299 goto out_put_node; 1300 } 1301 1302 dp = dsa_to_port(ds, reg); 1303 1304 err = dsa_port_parse_of(dp, port); 1305 if (err) { 1306 of_node_put(port); 1307 goto out_put_node; 1308 } 1309 } 1310 1311out_put_node: 1312 of_node_put(ports); 1313 return err; 1314} 1315 1316static int dsa_switch_parse_member_of(struct dsa_switch *ds, 1317 struct device_node *dn) 1318{ 1319 u32 m[2] = { 0, 0 }; 1320 int sz; 1321 1322 /* Don't error out if this optional property isn't found */ 1323 sz = of_property_read_variable_u32_array(dn, "dsa,member", m, 2, 2); 1324 if (sz < 0 && sz != -EINVAL) 1325 return sz; 1326 1327 ds->index = m[1]; 1328 1329 ds->dst = dsa_tree_touch(m[0]); 1330 if (!ds->dst) 1331 return -ENOMEM; 1332 1333 if (dsa_switch_find(ds->dst->index, ds->index)) { 1334 dev_err(ds->dev, 1335 "A DSA switch with index %d already exists in tree %d\n", 1336 ds->index, ds->dst->index); 1337 return -EEXIST; 1338 } 1339 1340 if (ds->dst->last_switch < ds->index) 1341 ds->dst->last_switch = ds->index; 1342 1343 return 0; 1344} 1345 1346static int dsa_switch_touch_ports(struct dsa_switch *ds) 1347{ 1348 struct dsa_port *dp; 1349 int port; 1350 1351 for (port = 0; port < ds->num_ports; port++) { 1352 dp = dsa_port_touch(ds, port); 1353 if (!dp) 1354 return -ENOMEM; 1355 } 1356 1357 return 0; 1358} 1359 1360static int dsa_switch_parse_of(struct dsa_switch *ds, struct device_node *dn) 1361{ 1362 int err; 1363 1364 err = dsa_switch_parse_member_of(ds, dn); 1365 if (err) 1366 return err; 1367 1368 err = dsa_switch_touch_ports(ds); 1369 if (err) 1370 return err; 1371 1372 return dsa_switch_parse_ports_of(ds, dn); 1373} 1374 1375static int dev_is_class(struct device *dev, void *class) 1376{ 1377 if (dev->class != NULL && !strcmp(dev->class->name, class)) 1378 return 1; 1379 1380 return 0; 1381} 1382 1383static struct device *dev_find_class(struct device *parent, char *class) 1384{ 1385 if (dev_is_class(parent, class)) { 1386 get_device(parent); 1387 return parent; 1388 } 1389 1390 return device_find_child(parent, class, dev_is_class); 1391} 1392 1393static struct net_device *dsa_dev_to_net_device(struct device *dev) 1394{ 1395 struct device *d; 1396 1397 d = dev_find_class(dev, "net"); 1398 if (d != NULL) { 1399 struct net_device *nd; 1400 1401 nd = to_net_dev(d); 1402 dev_hold(nd); 1403 put_device(d); 1404 1405 return nd; 1406 } 1407 1408 return NULL; 1409} 1410 1411static int dsa_port_parse(struct dsa_port *dp, const char *name, 1412 struct device *dev) 1413{ 1414 if (!strcmp(name, "cpu")) { 1415 struct net_device *master; 1416 1417 master = dsa_dev_to_net_device(dev); 1418 if (!master) 1419 return -EPROBE_DEFER; 1420 1421 dev_put(master); 1422 1423 return dsa_port_parse_cpu(dp, master, NULL); 1424 } 1425 1426 if (!strcmp(name, "dsa")) 1427 return dsa_port_parse_dsa(dp); 1428 1429 return dsa_port_parse_user(dp, name); 1430} 1431 1432static int dsa_switch_parse_ports(struct dsa_switch *ds, 1433 struct dsa_chip_data *cd) 1434{ 1435 bool valid_name_found = false; 1436 struct dsa_port *dp; 1437 struct device *dev; 1438 const char *name; 1439 unsigned int i; 1440 int err; 1441 1442 for (i = 0; i < DSA_MAX_PORTS; i++) { 1443 name = cd->port_names[i]; 1444 dev = cd->netdev[i]; 1445 dp = dsa_to_port(ds, i); 1446 1447 if (!name) 1448 continue; 1449 1450 err = dsa_port_parse(dp, name, dev); 1451 if (err) 1452 return err; 1453 1454 valid_name_found = true; 1455 } 1456 1457 if (!valid_name_found && i == DSA_MAX_PORTS) 1458 return -EINVAL; 1459 1460 return 0; 1461} 1462 1463static int dsa_switch_parse(struct dsa_switch *ds, struct dsa_chip_data *cd) 1464{ 1465 int err; 1466 1467 ds->cd = cd; 1468 1469 /* We don't support interconnected switches nor multiple trees via 1470 * platform data, so this is the unique switch of the tree. 1471 */ 1472 ds->index = 0; 1473 ds->dst = dsa_tree_touch(0); 1474 if (!ds->dst) 1475 return -ENOMEM; 1476 1477 err = dsa_switch_touch_ports(ds); 1478 if (err) 1479 return err; 1480 1481 return dsa_switch_parse_ports(ds, cd); 1482} 1483 1484static void dsa_switch_release_ports(struct dsa_switch *ds) 1485{ 1486 struct dsa_port *dp, *next; 1487 1488 dsa_switch_for_each_port_safe(dp, next, ds) { 1489 WARN_ON(!list_empty(&dp->fdbs)); 1490 WARN_ON(!list_empty(&dp->mdbs)); 1491 WARN_ON(!list_empty(&dp->vlans)); 1492 list_del(&dp->list); 1493 kfree(dp); 1494 } 1495} 1496 1497static int dsa_switch_probe(struct dsa_switch *ds) 1498{ 1499 struct dsa_switch_tree *dst; 1500 struct dsa_chip_data *pdata; 1501 struct device_node *np; 1502 int err; 1503 1504 if (!ds->dev) 1505 return -ENODEV; 1506 1507 pdata = ds->dev->platform_data; 1508 np = ds->dev->of_node; 1509 1510 if (!ds->num_ports) 1511 return -EINVAL; 1512 1513 if (np) { 1514 err = dsa_switch_parse_of(ds, np); 1515 if (err) 1516 dsa_switch_release_ports(ds); 1517 } else if (pdata) { 1518 err = dsa_switch_parse(ds, pdata); 1519 if (err) 1520 dsa_switch_release_ports(ds); 1521 } else { 1522 err = -ENODEV; 1523 } 1524 1525 if (err) 1526 return err; 1527 1528 dst = ds->dst; 1529 dsa_tree_get(dst); 1530 err = dsa_tree_setup(dst); 1531 if (err) { 1532 dsa_switch_release_ports(ds); 1533 dsa_tree_put(dst); 1534 } 1535 1536 return err; 1537} 1538 1539int dsa_register_switch(struct dsa_switch *ds) 1540{ 1541 int err; 1542 1543 mutex_lock(&dsa2_mutex); 1544 err = dsa_switch_probe(ds); 1545 dsa_tree_put(ds->dst); 1546 mutex_unlock(&dsa2_mutex); 1547 1548 return err; 1549} 1550EXPORT_SYMBOL_GPL(dsa_register_switch); 1551 1552static void dsa_switch_remove(struct dsa_switch *ds) 1553{ 1554 struct dsa_switch_tree *dst = ds->dst; 1555 1556 dsa_tree_teardown(dst); 1557 dsa_switch_release_ports(ds); 1558 dsa_tree_put(dst); 1559} 1560 1561void dsa_unregister_switch(struct dsa_switch *ds) 1562{ 1563 mutex_lock(&dsa2_mutex); 1564 dsa_switch_remove(ds); 1565 mutex_unlock(&dsa2_mutex); 1566} 1567EXPORT_SYMBOL_GPL(dsa_unregister_switch); 1568 1569/* If the DSA master chooses to unregister its net_device on .shutdown, DSA is 1570 * blocking that operation from completion, due to the dev_hold taken inside 1571 * netdev_upper_dev_link. Unlink the DSA slave interfaces from being uppers of 1572 * the DSA master, so that the system can reboot successfully. 1573 */ 1574void dsa_switch_shutdown(struct dsa_switch *ds) 1575{ 1576 struct net_device *master, *slave_dev; 1577 struct dsa_port *dp; 1578 1579 mutex_lock(&dsa2_mutex); 1580 1581 if (!ds->setup) 1582 goto out; 1583 1584 rtnl_lock(); 1585 1586 dsa_switch_for_each_user_port(dp, ds) { 1587 master = dsa_port_to_master(dp); 1588 slave_dev = dp->slave; 1589 1590 netdev_upper_dev_unlink(master, slave_dev); 1591 } 1592 1593 /* Disconnect from further netdevice notifiers on the master, 1594 * since netdev_uses_dsa() will now return false. 1595 */ 1596 dsa_switch_for_each_cpu_port(dp, ds) 1597 dp->master->dsa_ptr = NULL; 1598 1599 rtnl_unlock(); 1600out: 1601 mutex_unlock(&dsa2_mutex); 1602} 1603EXPORT_SYMBOL_GPL(dsa_switch_shutdown); 1604 1605#ifdef CONFIG_PM_SLEEP 1606static bool dsa_port_is_initialized(const struct dsa_port *dp) 1607{ 1608 return dp->type == DSA_PORT_TYPE_USER && dp->slave; 1609} 1610 1611int dsa_switch_suspend(struct dsa_switch *ds) 1612{ 1613 struct dsa_port *dp; 1614 int ret = 0; 1615 1616 /* Suspend slave network devices */ 1617 dsa_switch_for_each_port(dp, ds) { 1618 if (!dsa_port_is_initialized(dp)) 1619 continue; 1620 1621 ret = dsa_slave_suspend(dp->slave); 1622 if (ret) 1623 return ret; 1624 } 1625 1626 if (ds->ops->suspend) 1627 ret = ds->ops->suspend(ds); 1628 1629 return ret; 1630} 1631EXPORT_SYMBOL_GPL(dsa_switch_suspend); 1632 1633int dsa_switch_resume(struct dsa_switch *ds) 1634{ 1635 struct dsa_port *dp; 1636 int ret = 0; 1637 1638 if (ds->ops->resume) 1639 ret = ds->ops->resume(ds); 1640 1641 if (ret) 1642 return ret; 1643 1644 /* Resume slave network devices */ 1645 dsa_switch_for_each_port(dp, ds) { 1646 if (!dsa_port_is_initialized(dp)) 1647 continue; 1648 1649 ret = dsa_slave_resume(dp->slave); 1650 if (ret) 1651 return ret; 1652 } 1653 1654 return 0; 1655} 1656EXPORT_SYMBOL_GPL(dsa_switch_resume); 1657#endif 1658 1659struct dsa_port *dsa_port_from_netdev(struct net_device *netdev) 1660{ 1661 if (!netdev || !dsa_slave_dev_check(netdev)) 1662 return ERR_PTR(-ENODEV); 1663 1664 return dsa_slave_to_port(netdev); 1665} 1666EXPORT_SYMBOL_GPL(dsa_port_from_netdev); 1667 1668bool dsa_db_equal(const struct dsa_db *a, const struct dsa_db *b) 1669{ 1670 if (a->type != b->type) 1671 return false; 1672 1673 switch (a->type) { 1674 case DSA_DB_PORT: 1675 return a->dp == b->dp; 1676 case DSA_DB_LAG: 1677 return a->lag.dev == b->lag.dev; 1678 case DSA_DB_BRIDGE: 1679 return a->bridge.num == b->bridge.num; 1680 default: 1681 WARN_ON(1); 1682 return false; 1683 } 1684} 1685 1686bool dsa_fdb_present_in_other_db(struct dsa_switch *ds, int port, 1687 const unsigned char *addr, u16 vid, 1688 struct dsa_db db) 1689{ 1690 struct dsa_port *dp = dsa_to_port(ds, port); 1691 struct dsa_mac_addr *a; 1692 1693 lockdep_assert_held(&dp->addr_lists_lock); 1694 1695 list_for_each_entry(a, &dp->fdbs, list) { 1696 if (!ether_addr_equal(a->addr, addr) || a->vid != vid) 1697 continue; 1698 1699 if (a->db.type == db.type && !dsa_db_equal(&a->db, &db)) 1700 return true; 1701 } 1702 1703 return false; 1704} 1705EXPORT_SYMBOL_GPL(dsa_fdb_present_in_other_db); 1706 1707bool dsa_mdb_present_in_other_db(struct dsa_switch *ds, int port, 1708 const struct switchdev_obj_port_mdb *mdb, 1709 struct dsa_db db) 1710{ 1711 struct dsa_port *dp = dsa_to_port(ds, port); 1712 struct dsa_mac_addr *a; 1713 1714 lockdep_assert_held(&dp->addr_lists_lock); 1715 1716 list_for_each_entry(a, &dp->mdbs, list) { 1717 if (!ether_addr_equal(a->addr, mdb->addr) || a->vid != mdb->vid) 1718 continue; 1719 1720 if (a->db.type == db.type && !dsa_db_equal(&a->db, &db)) 1721 return true; 1722 } 1723 1724 return false; 1725} 1726EXPORT_SYMBOL_GPL(dsa_mdb_present_in_other_db); 1727 1728static const struct dsa_stubs __dsa_stubs = { 1729 .master_hwtstamp_validate = __dsa_master_hwtstamp_validate, 1730}; 1731 1732static void dsa_register_stubs(void) 1733{ 1734 dsa_stubs = &__dsa_stubs; 1735} 1736 1737static void dsa_unregister_stubs(void) 1738{ 1739 dsa_stubs = NULL; 1740} 1741 1742static int __init dsa_init_module(void) 1743{ 1744 int rc; 1745 1746 dsa_owq = alloc_ordered_workqueue("dsa_ordered", 1747 WQ_MEM_RECLAIM); 1748 if (!dsa_owq) 1749 return -ENOMEM; 1750 1751 rc = dsa_slave_register_notifier(); 1752 if (rc) 1753 goto register_notifier_fail; 1754 1755 dev_add_pack(&dsa_pack_type); 1756 1757 rc = rtnl_link_register(&dsa_link_ops); 1758 if (rc) 1759 goto netlink_register_fail; 1760 1761 dsa_register_stubs(); 1762 1763 return 0; 1764 1765netlink_register_fail: 1766 dsa_slave_unregister_notifier(); 1767 dev_remove_pack(&dsa_pack_type); 1768register_notifier_fail: 1769 destroy_workqueue(dsa_owq); 1770 1771 return rc; 1772} 1773module_init(dsa_init_module); 1774 1775static void __exit dsa_cleanup_module(void) 1776{ 1777 dsa_unregister_stubs(); 1778 1779 rtnl_link_unregister(&dsa_link_ops); 1780 1781 dsa_slave_unregister_notifier(); 1782 dev_remove_pack(&dsa_pack_type); 1783 destroy_workqueue(dsa_owq); 1784} 1785module_exit(dsa_cleanup_module); 1786 1787MODULE_AUTHOR("Lennert Buytenhek <buytenh@wantstofly.org>"); 1788MODULE_DESCRIPTION("Driver for Distributed Switch Architecture switch chips"); 1789MODULE_LICENSE("GPL"); 1790MODULE_ALIAS("platform:dsa"); 1791