net/dsa/dsa.c

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