net/dsa/dsa2.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * net/dsa/dsa2.c - Hardware switch handling, binding version 2
   4  * Copyright (c) 2008-2009 Marvell Semiconductor
   5  * Copyright (c) 2013 Florian Fainelli <florian@openwrt.org>
   6  * Copyright (c) 2016 Andrew Lunn <andrew@lunn.ch>
   7  */
   8
   9 #include <linux/device.h>
  10 #include <linux/err.h>
  11 #include <linux/list.h>
  12 #include <linux/netdevice.h>
  13 #include <linux/slab.h>
  14 #include <linux/rtnetlink.h>
  15 #include <linux/of.h>
  16 #include <linux/of_net.h>
  17 #include <net/devlink.h>
  18
  19 #include "dsa_priv.h"
  20
  21 static DEFINE_MUTEX(dsa2_mutex);
  22 LIST_HEAD(dsa_tree_list);
  23
  24 /**
  25  * dsa_tree_notify - Execute code for all switches in a DSA switch tree.
  26  * @dst: collection of struct dsa_switch devices to notify.
  27  * @e: event, must be of type DSA_NOTIFIER_*
  28  * @v: event-specific value.
  29  *
  30  * Given a struct dsa_switch_tree, this can be used to run a function once for
  31  * each member DSA switch. The other alternative of traversing the tree is only
  32  * through its ports list, which does not uniquely list the switches.
  33  */
  34 int dsa_tree_notify(struct dsa_switch_tree *dst, unsigned long e, void *v)
  35 {
  36         struct raw_notifier_head *nh = &dst->nh;
  37         int err;
  38
  39         err = raw_notifier_call_chain(nh, e, v);
  40
  41         return notifier_to_errno(err);
  42 }
  43
  44 /**
  45  * dsa_broadcast - Notify all DSA trees in the system.
  46  * @e: event, must be of type DSA_NOTIFIER_*
  47  * @v: event-specific value.
  48  *
  49  * Can be used to notify the switching fabric of events such as cross-chip
  50  * bridging between disjoint trees (such as islands of tagger-compatible
  51  * switches bridged by an incompatible middle switch).
  52  */
  53 int dsa_broadcast(unsigned long e, void *v)
  54 {
  55         struct dsa_switch_tree *dst;
  56         int err = 0;
  57
  58         list_for_each_entry(dst, &dsa_tree_list, list) {
  59                 err = dsa_tree_notify(dst, e, v);
  60                 if (err)
  61                         break;
  62         }
  63
  64         return err;
  65 }
  66
  67 /**
  68  * dsa_lag_map() - Map LAG netdev to a linear LAG ID
  69  * @dst: Tree in which to record the mapping.
  70  * @lag: Netdev that is to be mapped to an ID.
  71  *
  72  * dsa_lag_id/dsa_lag_dev can then be used to translate between the
  73  * two spaces. The size of the mapping space is determined by the
  74  * driver by setting ds->num_lag_ids. It is perfectly legal to leave
  75  * it unset if it is not needed, in which case these functions become
  76  * no-ops.
  77  */
  78 void dsa_lag_map(struct dsa_switch_tree *dst, struct net_device *lag)
  79 {
  80         unsigned int id;
  81
  82         if (dsa_lag_id(dst, lag) >= 0)
  83                 /* Already mapped */
  84                 return;
  85
  86         for (id = 0; id < dst->lags_len; id++) {
  87                 if (!dsa_lag_dev(dst, id)) {
  88                         dst->lags[id] = lag;
  89                         return;
  90                 }
  91         }
  92
  93         /* No IDs left, which is OK. Some drivers do not need it. The
  94          * ones that do, e.g. mv88e6xxx, will discover that dsa_lag_id
  95          * returns an error for this device when joining the LAG. The
  96          * driver can then return -EOPNOTSUPP back to DSA, which will
  97          * fall back to a software LAG.
  98          */
  99 }
 100
 101 /**
 102  * dsa_lag_unmap() - Remove a LAG ID mapping
 103  * @dst: Tree in which the mapping is recorded.
 104  * @lag: Netdev that was mapped.
 105  *
 106  * As there may be multiple users of the mapping, it is only removed
 107  * if there are no other references to it.
 108  */
 109 void dsa_lag_unmap(struct dsa_switch_tree *dst, struct net_device *lag)
 110 {
 111         struct dsa_port *dp;
 112         unsigned int id;
 113
 114         dsa_lag_foreach_port(dp, dst, lag)
 115                 /* There are remaining users of this mapping */
 116                 return;
 117
 118         dsa_lags_foreach_id(id, dst) {
 119                 if (dsa_lag_dev(dst, id) == lag) {
 120                         dst->lags[id] = NULL;
 121                         break;
 122                 }
 123         }
 124 }
 125
 126 struct dsa_switch *dsa_switch_find(int tree_index, int sw_index)
 127 {
 128         struct dsa_switch_tree *dst;
 129         struct dsa_port *dp;
 130
 131         list_for_each_entry(dst, &dsa_tree_list, list) {
 132                 if (dst->index != tree_index)
 133                         continue;
 134
 135                 list_for_each_entry(dp, &dst->ports, list) {
 136                         if (dp->ds->index != sw_index)
 137                                 continue;
 138
 139                         return dp->ds;
 140                 }
 141         }
 142
 143         return NULL;
 144 }
 145 EXPORT_SYMBOL_GPL(dsa_switch_find);
 146
 147 static struct dsa_switch_tree *dsa_tree_find(int index)
 148 {
 149         struct dsa_switch_tree *dst;
 150
 151         list_for_each_entry(dst, &dsa_tree_list, list)
 152                 if (dst->index == index)
 153                         return dst;
 154
 155         return NULL;
 156 }
 157
 158 static struct dsa_switch_tree *dsa_tree_alloc(int index)
 159 {
 160         struct dsa_switch_tree *dst;
 161
 162         dst = kzalloc(sizeof(*dst), GFP_KERNEL);
 163         if (!dst)
 164                 return NULL;
 165
 166         dst->index = index;
 167
 168         INIT_LIST_HEAD(&dst->rtable);
 169
 170         INIT_LIST_HEAD(&dst->ports);
 171
 172         INIT_LIST_HEAD(&dst->list);
 173         list_add_tail(&dst->list, &dsa_tree_list);
 174
 175         kref_init(&dst->refcount);
 176
 177         return dst;
 178 }
 179
 180 static void dsa_tree_free(struct dsa_switch_tree *dst)
 181 {
 182         if (dst->tag_ops)
 183                 dsa_tag_driver_put(dst->tag_ops);
 184         list_del(&dst->list);
 185         kfree(dst);
 186 }
 187
 188 static struct dsa_switch_tree *dsa_tree_get(struct dsa_switch_tree *dst)
 189 {
 190         if (dst)
 191                 kref_get(&dst->refcount);
 192
 193         return dst;
 194 }
 195
 196 static struct dsa_switch_tree *dsa_tree_touch(int index)
 197 {
 198         struct dsa_switch_tree *dst;
 199
 200         dst = dsa_tree_find(index);
 201         if (dst)
 202                 return dsa_tree_get(dst);
 203         else
 204                 return dsa_tree_alloc(index);
 205 }
 206
 207 static void dsa_tree_release(struct kref *ref)
 208 {
 209         struct dsa_switch_tree *dst;
 210
 211         dst = container_of(ref, struct dsa_switch_tree, refcount);
 212
 213         dsa_tree_free(dst);
 214 }
 215
 216 static void dsa_tree_put(struct dsa_switch_tree *dst)
 217 {
 218         if (dst)
 219                 kref_put(&dst->refcount, dsa_tree_release);
 220 }
 221
 222 static struct dsa_port *dsa_tree_find_port_by_node(struct dsa_switch_tree *dst,
 223                                                    struct device_node *dn)
 224 {
 225         struct dsa_port *dp;
 226
 227         list_for_each_entry(dp, &dst->ports, list)
 228                 if (dp->dn == dn)
 229                         return dp;
 230
 231         return NULL;
 232 }
 233
 234 static struct dsa_link *dsa_link_touch(struct dsa_port *dp,
 235                                        struct dsa_port *link_dp)
 236 {
 237         struct dsa_switch *ds = dp->ds;
 238         struct dsa_switch_tree *dst;
 239         struct dsa_link *dl;
 240
 241         dst = ds->dst;
 242
 243         list_for_each_entry(dl, &dst->rtable, list)
 244                 if (dl->dp == dp && dl->link_dp == link_dp)
 245                         return dl;
 246
 247         dl = kzalloc(sizeof(*dl), GFP_KERNEL);
 248         if (!dl)
 249                 return NULL;
 250
 251         dl->dp = dp;
 252         dl->link_dp = link_dp;
 253
 254         INIT_LIST_HEAD(&dl->list);
 255         list_add_tail(&dl->list, &dst->rtable);
 256
 257         return dl;
 258 }
 259
 260 static bool dsa_port_setup_routing_table(struct dsa_port *dp)
 261 {
 262         struct dsa_switch *ds = dp->ds;
 263         struct dsa_switch_tree *dst = ds->dst;
 264         struct device_node *dn = dp->dn;
 265         struct of_phandle_iterator it;
 266         struct dsa_port *link_dp;
 267         struct dsa_link *dl;
 268         int err;
 269
 270         of_for_each_phandle(&it, err, dn, "link", NULL, 0) {
 271                 link_dp = dsa_tree_find_port_by_node(dst, it.node);
 272                 if (!link_dp) {
 273                         of_node_put(it.node);
 274                         return false;
 275                 }
 276
 277                 dl = dsa_link_touch(dp, link_dp);
 278                 if (!dl) {
 279                         of_node_put(it.node);
 280                         return false;
 281                 }
 282         }
 283
 284         return true;
 285 }
 286
 287 static bool dsa_tree_setup_routing_table(struct dsa_switch_tree *dst)
 288 {
 289         bool complete = true;
 290         struct dsa_port *dp;
 291
 292         list_for_each_entry(dp, &dst->ports, list) {
 293                 if (dsa_port_is_dsa(dp)) {
 294                         complete = dsa_port_setup_routing_table(dp);
 295                         if (!complete)
 296                                 break;
 297                 }
 298         }
 299
 300         return complete;
 301 }
 302
 303 static struct dsa_port *dsa_tree_find_first_cpu(struct dsa_switch_tree *dst)
 304 {
 305         struct dsa_port *dp;
 306
 307         list_for_each_entry(dp, &dst->ports, list)
 308                 if (dsa_port_is_cpu(dp))
 309                         return dp;
 310
 311         return NULL;
 312 }
 313
 314 static int dsa_tree_setup_default_cpu(struct dsa_switch_tree *dst)
 315 {
 316         struct dsa_port *cpu_dp, *dp;
 317
 318         cpu_dp = dsa_tree_find_first_cpu(dst);
 319         if (!cpu_dp) {
 320                 pr_err("DSA: tree %d has no CPU port\n", dst->index);
 321                 return -EINVAL;
 322         }
 323
 324         /* Assign the default CPU port to all ports of the fabric */
 325         list_for_each_entry(dp, &dst->ports, list)
 326                 if (dsa_port_is_user(dp) || dsa_port_is_dsa(dp))
 327                         dp->cpu_dp = cpu_dp;
 328
 329         return 0;
 330 }
 331
 332 static void dsa_tree_teardown_default_cpu(struct dsa_switch_tree *dst)
 333 {
 334         struct dsa_port *dp;
 335
 336         list_for_each_entry(dp, &dst->ports, list)
 337                 if (dsa_port_is_user(dp) || dsa_port_is_dsa(dp))
 338                         dp->cpu_dp = NULL;
 339 }
 340
 341 static int dsa_port_setup(struct dsa_port *dp)
 342 {
 343         struct devlink_port *dlp = &dp->devlink_port;
 344         bool dsa_port_link_registered = false;
 345         bool dsa_port_enabled = false;
 346         int err = 0;
 347
 348         if (dp->setup)
 349                 return 0;
 350
 351         INIT_LIST_HEAD(&dp->mdbs);
 352
 353         switch (dp->type) {
 354         case DSA_PORT_TYPE_UNUSED:
 355                 dsa_port_disable(dp);
 356                 break;
 357         case DSA_PORT_TYPE_CPU:
 358                 err = dsa_port_link_register_of(dp);
 359                 if (err)
 360                         break;
 361                 dsa_port_link_registered = true;
 362
 363                 err = dsa_port_enable(dp, NULL);
 364                 if (err)
 365                         break;
 366                 dsa_port_enabled = true;
 367
 368                 break;
 369         case DSA_PORT_TYPE_DSA:
 370                 err = dsa_port_link_register_of(dp);
 371                 if (err)
 372                         break;
 373                 dsa_port_link_registered = true;
 374
 375                 err = dsa_port_enable(dp, NULL);
 376                 if (err)
 377                         break;
 378                 dsa_port_enabled = true;
 379
 380                 break;
 381         case DSA_PORT_TYPE_USER:
 382                 of_get_mac_address(dp->dn, dp->mac);
 383                 err = dsa_slave_create(dp);
 384                 if (err)
 385                         break;
 386
 387                 devlink_port_type_eth_set(dlp, dp->slave);
 388                 break;
 389         }
 390
 391         if (err && dsa_port_enabled)
 392                 dsa_port_disable(dp);
 393         if (err && dsa_port_link_registered)
 394                 dsa_port_link_unregister_of(dp);
 395         if (err)
 396                 return err;
 397
 398         dp->setup = true;
 399
 400         return 0;
 401 }
 402
 403 static int dsa_port_devlink_setup(struct dsa_port *dp)
 404 {
 405         struct devlink_port *dlp = &dp->devlink_port;
 406         struct dsa_switch_tree *dst = dp->ds->dst;
 407         struct devlink_port_attrs attrs = {};
 408         struct devlink *dl = dp->ds->devlink;
 409         const unsigned char *id;
 410         unsigned char len;
 411         int err;
 412
 413         id = (const unsigned char *)&dst->index;
 414         len = sizeof(dst->index);
 415
 416         attrs.phys.port_number = dp->index;
 417         memcpy(attrs.switch_id.id, id, len);
 418         attrs.switch_id.id_len = len;
 419         memset(dlp, 0, sizeof(*dlp));
 420
 421         switch (dp->type) {
 422         case DSA_PORT_TYPE_UNUSED:
 423                 attrs.flavour = DEVLINK_PORT_FLAVOUR_UNUSED;
 424                 break;
 425         case DSA_PORT_TYPE_CPU:
 426                 attrs.flavour = DEVLINK_PORT_FLAVOUR_CPU;
 427                 break;
 428         case DSA_PORT_TYPE_DSA:
 429                 attrs.flavour = DEVLINK_PORT_FLAVOUR_DSA;
 430                 break;
 431         case DSA_PORT_TYPE_USER:
 432                 attrs.flavour = DEVLINK_PORT_FLAVOUR_PHYSICAL;
 433                 break;
 434         }
 435
 436         devlink_port_attrs_set(dlp, &attrs);
 437         err = devlink_port_register(dl, dlp, dp->index);
 438
 439         if (!err)
 440                 dp->devlink_port_setup = true;
 441
 442         return err;
 443 }
 444
 445 static void dsa_port_teardown(struct dsa_port *dp)
 446 {
 447         struct devlink_port *dlp = &dp->devlink_port;
 448         struct dsa_mac_addr *a, *tmp;
 449
 450         if (!dp->setup)
 451                 return;
 452
 453         devlink_port_type_clear(dlp);
 454
 455         switch (dp->type) {
 456         case DSA_PORT_TYPE_UNUSED:
 457                 break;
 458         case DSA_PORT_TYPE_CPU:
 459                 dsa_port_disable(dp);
 460                 dsa_port_link_unregister_of(dp);
 461                 break;
 462         case DSA_PORT_TYPE_DSA:
 463                 dsa_port_disable(dp);
 464                 dsa_port_link_unregister_of(dp);
 465                 break;
 466         case DSA_PORT_TYPE_USER:
 467                 if (dp->slave) {
 468                         dsa_slave_destroy(dp->slave);
 469                         dp->slave = NULL;
 470                 }
 471                 break;
 472         }
 473
 474         list_for_each_entry_safe(a, tmp, &dp->mdbs, list) {
 475                 list_del(&a->list);
 476                 kfree(a);
 477         }
 478
 479         dp->setup = false;
 480 }
 481
 482 static void dsa_port_devlink_teardown(struct dsa_port *dp)
 483 {
 484         struct devlink_port *dlp = &dp->devlink_port;
 485
 486         if (dp->devlink_port_setup)
 487                 devlink_port_unregister(dlp);
 488         dp->devlink_port_setup = false;
 489 }
 490
 491 static int dsa_devlink_info_get(struct devlink *dl,
 492                                 struct devlink_info_req *req,
 493                                 struct netlink_ext_ack *extack)
 494 {
 495         struct dsa_switch *ds = dsa_devlink_to_ds(dl);
 496
 497         if (ds->ops->devlink_info_get)
 498                 return ds->ops->devlink_info_get(ds, req, extack);
 499
 500         return -EOPNOTSUPP;
 501 }
 502
 503 static int dsa_devlink_sb_pool_get(struct devlink *dl,
 504                                    unsigned int sb_index, u16 pool_index,
 505                                    struct devlink_sb_pool_info *pool_info)
 506 {
 507         struct dsa_switch *ds = dsa_devlink_to_ds(dl);
 508
 509         if (!ds->ops->devlink_sb_pool_get)
 510                 return -EOPNOTSUPP;
 511
 512         return ds->ops->devlink_sb_pool_get(ds, sb_index, pool_index,
 513                                             pool_info);
 514 }
 515
 516 static int dsa_devlink_sb_pool_set(struct devlink *dl, unsigned int sb_index,
 517                                    u16 pool_index, u32 size,
 518                                    enum devlink_sb_threshold_type threshold_type,
 519                                    struct netlink_ext_ack *extack)
 520 {
 521         struct dsa_switch *ds = dsa_devlink_to_ds(dl);
 522
 523         if (!ds->ops->devlink_sb_pool_set)
 524                 return -EOPNOTSUPP;
 525
 526         return ds->ops->devlink_sb_pool_set(ds, sb_index, pool_index, size,
 527                                             threshold_type, extack);
 528 }
 529
 530 static int dsa_devlink_sb_port_pool_get(struct devlink_port *dlp,
 531                                         unsigned int sb_index, u16 pool_index,
 532                                         u32 *p_threshold)
 533 {
 534         struct dsa_switch *ds = dsa_devlink_port_to_ds(dlp);
 535         int port = dsa_devlink_port_to_port(dlp);
 536
 537         if (!ds->ops->devlink_sb_port_pool_get)
 538                 return -EOPNOTSUPP;
 539
 540         return ds->ops->devlink_sb_port_pool_get(ds, port, sb_index,
 541                                                  pool_index, p_threshold);
 542 }
 543
 544 static int dsa_devlink_sb_port_pool_set(struct devlink_port *dlp,
 545                                         unsigned int sb_index, u16 pool_index,
 546                                         u32 threshold,
 547                                         struct netlink_ext_ack *extack)
 548 {
 549         struct dsa_switch *ds = dsa_devlink_port_to_ds(dlp);
 550         int port = dsa_devlink_port_to_port(dlp);
 551
 552         if (!ds->ops->devlink_sb_port_pool_set)
 553                 return -EOPNOTSUPP;
 554
 555         return ds->ops->devlink_sb_port_pool_set(ds, port, sb_index,
 556                                                  pool_index, threshold, extack);
 557 }
 558
 559 static int
 560 dsa_devlink_sb_tc_pool_bind_get(struct devlink_port *dlp,
 561                                 unsigned int sb_index, u16 tc_index,
 562                                 enum devlink_sb_pool_type pool_type,
 563                                 u16 *p_pool_index, u32 *p_threshold)
 564 {
 565         struct dsa_switch *ds = dsa_devlink_port_to_ds(dlp);
 566         int port = dsa_devlink_port_to_port(dlp);
 567
 568         if (!ds->ops->devlink_sb_tc_pool_bind_get)
 569                 return -EOPNOTSUPP;
 570
 571         return ds->ops->devlink_sb_tc_pool_bind_get(ds, port, sb_index,
 572                                                     tc_index, pool_type,
 573                                                     p_pool_index, p_threshold);
 574 }
 575
 576 static int
 577 dsa_devlink_sb_tc_pool_bind_set(struct devlink_port *dlp,
 578                                 unsigned int sb_index, u16 tc_index,
 579                                 enum devlink_sb_pool_type pool_type,
 580                                 u16 pool_index, u32 threshold,
 581                                 struct netlink_ext_ack *extack)
 582 {
 583         struct dsa_switch *ds = dsa_devlink_port_to_ds(dlp);
 584         int port = dsa_devlink_port_to_port(dlp);
 585
 586         if (!ds->ops->devlink_sb_tc_pool_bind_set)
 587                 return -EOPNOTSUPP;
 588
 589         return ds->ops->devlink_sb_tc_pool_bind_set(ds, port, sb_index,
 590                                                     tc_index, pool_type,
 591                                                     pool_index, threshold,
 592                                                     extack);
 593 }
 594
 595 static int dsa_devlink_sb_occ_snapshot(struct devlink *dl,
 596                                        unsigned int sb_index)
 597 {
 598         struct dsa_switch *ds = dsa_devlink_to_ds(dl);
 599
 600         if (!ds->ops->devlink_sb_occ_snapshot)
 601                 return -EOPNOTSUPP;
 602
 603         return ds->ops->devlink_sb_occ_snapshot(ds, sb_index);
 604 }
 605
 606 static int dsa_devlink_sb_occ_max_clear(struct devlink *dl,
 607                                         unsigned int sb_index)
 608 {
 609         struct dsa_switch *ds = dsa_devlink_to_ds(dl);
 610
 611         if (!ds->ops->devlink_sb_occ_max_clear)
 612                 return -EOPNOTSUPP;
 613
 614         return ds->ops->devlink_sb_occ_max_clear(ds, sb_index);
 615 }
 616
 617 static int dsa_devlink_sb_occ_port_pool_get(struct devlink_port *dlp,
 618                                             unsigned int sb_index,
 619                                             u16 pool_index, u32 *p_cur,
 620                                             u32 *p_max)
 621 {
 622         struct dsa_switch *ds = dsa_devlink_port_to_ds(dlp);
 623         int port = dsa_devlink_port_to_port(dlp);
 624
 625         if (!ds->ops->devlink_sb_occ_port_pool_get)
 626                 return -EOPNOTSUPP;
 627
 628         return ds->ops->devlink_sb_occ_port_pool_get(ds, port, sb_index,
 629                                                      pool_index, p_cur, p_max);
 630 }
 631
 632 static int
 633 dsa_devlink_sb_occ_tc_port_bind_get(struct devlink_port *dlp,
 634                                     unsigned int sb_index, u16 tc_index,
 635                                     enum devlink_sb_pool_type pool_type,
 636                                     u32 *p_cur, u32 *p_max)
 637 {
 638         struct dsa_switch *ds = dsa_devlink_port_to_ds(dlp);
 639         int port = dsa_devlink_port_to_port(dlp);
 640
 641         if (!ds->ops->devlink_sb_occ_tc_port_bind_get)
 642                 return -EOPNOTSUPP;
 643
 644         return ds->ops->devlink_sb_occ_tc_port_bind_get(ds, port,
 645                                                         sb_index, tc_index,
 646                                                         pool_type, p_cur,
 647                                                         p_max);
 648 }
 649
 650 static const struct devlink_ops dsa_devlink_ops = {
 651         .info_get                       = dsa_devlink_info_get,
 652         .sb_pool_get                    = dsa_devlink_sb_pool_get,
 653         .sb_pool_set                    = dsa_devlink_sb_pool_set,
 654         .sb_port_pool_get               = dsa_devlink_sb_port_pool_get,
 655         .sb_port_pool_set               = dsa_devlink_sb_port_pool_set,
 656         .sb_tc_pool_bind_get            = dsa_devlink_sb_tc_pool_bind_get,
 657         .sb_tc_pool_bind_set            = dsa_devlink_sb_tc_pool_bind_set,
 658         .sb_occ_snapshot                = dsa_devlink_sb_occ_snapshot,
 659         .sb_occ_max_clear               = dsa_devlink_sb_occ_max_clear,
 660         .sb_occ_port_pool_get           = dsa_devlink_sb_occ_port_pool_get,
 661         .sb_occ_tc_port_bind_get        = dsa_devlink_sb_occ_tc_port_bind_get,
 662 };
 663
 664 static int dsa_switch_setup_tag_protocol(struct dsa_switch *ds)
 665 {
 666         const struct dsa_device_ops *tag_ops = ds->dst->tag_ops;
 667         struct dsa_switch_tree *dst = ds->dst;
 668         int port, err;
 669
 670         if (tag_ops->proto == dst->default_proto)
 671                 return 0;
 672
 673         for (port = 0; port < ds->num_ports; port++) {
 674                 if (!dsa_is_cpu_port(ds, port))
 675                         continue;
 676
 677                 err = ds->ops->change_tag_protocol(ds, port, tag_ops->proto);
 678                 if (err) {
 679                         dev_err(ds->dev, "Unable to use tag protocol \"%s\": %pe\n",
 680                                 tag_ops->name, ERR_PTR(err));
 681                         return err;
 682                 }
 683         }
 684
 685         return 0;
 686 }
 687
 688 static int dsa_switch_setup(struct dsa_switch *ds)
 689 {
 690         struct dsa_devlink_priv *dl_priv;
 691         struct dsa_port *dp;
 692         int err;
 693
 694         if (ds->setup)
 695                 return 0;
 696
 697         /* Initialize ds->phys_mii_mask before registering the slave MDIO bus
 698          * driver and before ops->setup() has run, since the switch drivers and
 699          * the slave MDIO bus driver rely on these values for probing PHY
 700          * devices or not
 701          */
 702         ds->phys_mii_mask |= dsa_user_ports(ds);
 703
 704         /* Add the switch to devlink before calling setup, so that setup can
 705          * add dpipe tables
 706          */
 707         ds->devlink = devlink_alloc(&dsa_devlink_ops, sizeof(*dl_priv));
 708         if (!ds->devlink)
 709                 return -ENOMEM;
 710         dl_priv = devlink_priv(ds->devlink);
 711         dl_priv->ds = ds;
 712
 713         err = devlink_register(ds->devlink, ds->dev);
 714         if (err)
 715                 goto free_devlink;
 716
 717         /* Setup devlink port instances now, so that the switch
 718          * setup() can register regions etc, against the ports
 719          */
 720         list_for_each_entry(dp, &ds->dst->ports, list) {
 721                 if (dp->ds == ds) {
 722                         err = dsa_port_devlink_setup(dp);
 723                         if (err)
 724                                 goto unregister_devlink_ports;
 725                 }
 726         }
 727
 728         err = dsa_switch_register_notifier(ds);
 729         if (err)
 730                 goto unregister_devlink_ports;
 731
 732         ds->configure_vlan_while_not_filtering = true;
 733
 734         err = ds->ops->setup(ds);
 735         if (err < 0)
 736                 goto unregister_notifier;
 737
 738         err = dsa_switch_setup_tag_protocol(ds);
 739         if (err)
 740                 goto teardown;
 741
 742         devlink_params_publish(ds->devlink);
 743
 744         if (!ds->slave_mii_bus && ds->ops->phy_read) {
 745                 ds->slave_mii_bus = devm_mdiobus_alloc(ds->dev);
 746                 if (!ds->slave_mii_bus) {
 747                         err = -ENOMEM;
 748                         goto teardown;
 749                 }
 750
 751                 dsa_slave_mii_bus_init(ds);
 752
 753                 err = mdiobus_register(ds->slave_mii_bus);
 754                 if (err < 0)
 755                         goto teardown;
 756         }
 757
 758         ds->setup = true;
 759
 760         return 0;
 761
 762 teardown:
 763         if (ds->ops->teardown)
 764                 ds->ops->teardown(ds);
 765 unregister_notifier:
 766         dsa_switch_unregister_notifier(ds);
 767 unregister_devlink_ports:
 768         list_for_each_entry(dp, &ds->dst->ports, list)
 769                 if (dp->ds == ds)
 770                         dsa_port_devlink_teardown(dp);
 771         devlink_unregister(ds->devlink);
 772 free_devlink:
 773         devlink_free(ds->devlink);
 774         ds->devlink = NULL;
 775
 776         return err;
 777 }
 778
 779 static void dsa_switch_teardown(struct dsa_switch *ds)
 780 {
 781         struct dsa_port *dp;
 782
 783         if (!ds->setup)
 784                 return;
 785
 786         if (ds->slave_mii_bus && ds->ops->phy_read)
 787                 mdiobus_unregister(ds->slave_mii_bus);
 788
 789         dsa_switch_unregister_notifier(ds);
 790
 791         if (ds->ops->teardown)
 792                 ds->ops->teardown(ds);
 793
 794         if (ds->devlink) {
 795                 list_for_each_entry(dp, &ds->dst->ports, list)
 796                         if (dp->ds == ds)
 797                                 dsa_port_devlink_teardown(dp);
 798                 devlink_unregister(ds->devlink);
 799                 devlink_free(ds->devlink);
 800                 ds->devlink = NULL;
 801         }
 802
 803         ds->setup = false;
 804 }
 805
 806 static int dsa_tree_setup_switches(struct dsa_switch_tree *dst)
 807 {
 808         struct dsa_port *dp;
 809         int err;
 810
 811         list_for_each_entry(dp, &dst->ports, list) {
 812                 err = dsa_switch_setup(dp->ds);
 813                 if (err)
 814                         goto teardown;
 815         }
 816
 817         list_for_each_entry(dp, &dst->ports, list) {
 818                 err = dsa_port_setup(dp);
 819                 if (err) {
 820                         dsa_port_devlink_teardown(dp);
 821                         dp->type = DSA_PORT_TYPE_UNUSED;
 822                         err = dsa_port_devlink_setup(dp);
 823                         if (err)
 824                                 goto teardown;
 825                         continue;
 826                 }
 827         }
 828
 829         return 0;
 830
 831 teardown:
 832         list_for_each_entry(dp, &dst->ports, list)
 833                 dsa_port_teardown(dp);
 834
 835         list_for_each_entry(dp, &dst->ports, list)
 836                 dsa_switch_teardown(dp->ds);
 837
 838         return err;
 839 }
 840
 841 static void dsa_tree_teardown_switches(struct dsa_switch_tree *dst)
 842 {
 843         struct dsa_port *dp;
 844
 845         list_for_each_entry(dp, &dst->ports, list)
 846                 dsa_port_teardown(dp);
 847
 848         list_for_each_entry(dp, &dst->ports, list)
 849                 dsa_switch_teardown(dp->ds);
 850 }
 851
 852 static int dsa_tree_setup_master(struct dsa_switch_tree *dst)
 853 {
 854         struct dsa_port *dp;
 855         int err;
 856
 857         list_for_each_entry(dp, &dst->ports, list) {
 858                 if (dsa_port_is_cpu(dp)) {
 859                         err = dsa_master_setup(dp->master, dp);
 860                         if (err)
 861                                 return err;
 862                 }
 863         }
 864
 865         return 0;
 866 }
 867
 868 static void dsa_tree_teardown_master(struct dsa_switch_tree *dst)
 869 {
 870         struct dsa_port *dp;
 871
 872         list_for_each_entry(dp, &dst->ports, list)
 873                 if (dsa_port_is_cpu(dp))
 874                         dsa_master_teardown(dp->master);
 875 }
 876
 877 static int dsa_tree_setup_lags(struct dsa_switch_tree *dst)
 878 {
 879         unsigned int len = 0;
 880         struct dsa_port *dp;
 881
 882         list_for_each_entry(dp, &dst->ports, list) {
 883                 if (dp->ds->num_lag_ids > len)
 884                         len = dp->ds->num_lag_ids;
 885         }
 886
 887         if (!len)
 888                 return 0;
 889
 890         dst->lags = kcalloc(len, sizeof(*dst->lags), GFP_KERNEL);
 891         if (!dst->lags)
 892                 return -ENOMEM;
 893
 894         dst->lags_len = len;
 895         return 0;
 896 }
 897
 898 static void dsa_tree_teardown_lags(struct dsa_switch_tree *dst)
 899 {
 900         kfree(dst->lags);
 901 }
 902
 903 static int dsa_tree_setup(struct dsa_switch_tree *dst)
 904 {
 905         bool complete;
 906         int err;
 907
 908         if (dst->setup) {
 909                 pr_err("DSA: tree %d already setup! Disjoint trees?\n",
 910                        dst->index);
 911                 return -EEXIST;
 912         }
 913
 914         complete = dsa_tree_setup_routing_table(dst);
 915         if (!complete)
 916                 return 0;
 917
 918         err = dsa_tree_setup_default_cpu(dst);
 919         if (err)
 920                 return err;
 921
 922         err = dsa_tree_setup_switches(dst);
 923         if (err)
 924                 goto teardown_default_cpu;
 925
 926         err = dsa_tree_setup_master(dst);
 927         if (err)
 928                 goto teardown_switches;
 929
 930         err = dsa_tree_setup_lags(dst);
 931         if (err)
 932                 goto teardown_master;
 933
 934         dst->setup = true;
 935
 936         pr_info("DSA: tree %d setup\n", dst->index);
 937
 938         return 0;
 939
 940 teardown_master:
 941         dsa_tree_teardown_master(dst);
 942 teardown_switches:
 943         dsa_tree_teardown_switches(dst);
 944 teardown_default_cpu:
 945         dsa_tree_teardown_default_cpu(dst);
 946
 947         return err;
 948 }
 949
 950 static void dsa_tree_teardown(struct dsa_switch_tree *dst)
 951 {
 952         struct dsa_link *dl, *next;
 953
 954         if (!dst->setup)
 955                 return;
 956
 957         dsa_tree_teardown_lags(dst);
 958
 959         dsa_tree_teardown_master(dst);
 960
 961         dsa_tree_teardown_switches(dst);
 962
 963         dsa_tree_teardown_default_cpu(dst);
 964
 965         list_for_each_entry_safe(dl, next, &dst->rtable, list) {
 966                 list_del(&dl->list);
 967                 kfree(dl);
 968         }
 969
 970         pr_info("DSA: tree %d torn down\n", dst->index);
 971
 972         dst->setup = false;
 973 }
 974
 975 /* Since the dsa/tagging sysfs device attribute is per master, the assumption
 976  * is that all DSA switches within a tree share the same tagger, otherwise
 977  * they would have formed disjoint trees (different "dsa,member" values).
 978  */
 979 int dsa_tree_change_tag_proto(struct dsa_switch_tree *dst,
 980                               struct net_device *master,
 981                               const struct dsa_device_ops *tag_ops,
 982                               const struct dsa_device_ops *old_tag_ops)
 983 {
 984         struct dsa_notifier_tag_proto_info info;
 985         struct dsa_port *dp;
 986         int err = -EBUSY;
 987
 988         if (!rtnl_trylock())
 989                 return restart_syscall();
 990
 991         /* At the moment we don't allow changing the tag protocol under
 992          * traffic. The rtnl_mutex also happens to serialize concurrent
 993          * attempts to change the tagging protocol. If we ever lift the IFF_UP
 994          * restriction, there needs to be another mutex which serializes this.
 995          */
 996         if (master->flags & IFF_UP)
 997                 goto out_unlock;
 998
 999         list_for_each_entry(dp, &dst->ports, list) {
1000                 if (!dsa_is_user_port(dp->ds, dp->index))
1001                         continue;
1002
1003                 if (dp->slave->flags & IFF_UP)
1004                         goto out_unlock;
1005         }
1006
1007         info.tag_ops = tag_ops;
1008         err = dsa_tree_notify(dst, DSA_NOTIFIER_TAG_PROTO, &info);
1009         if (err)
1010                 goto out_unwind_tagger;
1011
1012         dst->tag_ops = tag_ops;
1013
1014         rtnl_unlock();
1015
1016         return 0;
1017
1018 out_unwind_tagger:
1019         info.tag_ops = old_tag_ops;
1020         dsa_tree_notify(dst, DSA_NOTIFIER_TAG_PROTO, &info);
1021 out_unlock:
1022         rtnl_unlock();
1023         return err;
1024 }
1025
1026 static struct dsa_port *dsa_port_touch(struct dsa_switch *ds, int index)
1027 {
1028         struct dsa_switch_tree *dst = ds->dst;
1029         struct dsa_port *dp;
1030
1031         list_for_each_entry(dp, &dst->ports, list)
1032                 if (dp->ds == ds && dp->index == index)
1033                         return dp;
1034
1035         dp = kzalloc(sizeof(*dp), GFP_KERNEL);
1036         if (!dp)
1037                 return NULL;
1038
1039         dp->ds = ds;
1040         dp->index = index;
1041
1042         INIT_LIST_HEAD(&dp->list);
1043         list_add_tail(&dp->list, &dst->ports);
1044
1045         return dp;
1046 }
1047
1048 static int dsa_port_parse_user(struct dsa_port *dp, const char *name)
1049 {
1050         if (!name)
1051                 name = "eth%d";
1052
1053         dp->type = DSA_PORT_TYPE_USER;
1054         dp->name = name;
1055
1056         return 0;
1057 }
1058
1059 static int dsa_port_parse_dsa(struct dsa_port *dp)
1060 {
1061         dp->type = DSA_PORT_TYPE_DSA;
1062
1063         return 0;
1064 }
1065
1066 static enum dsa_tag_protocol dsa_get_tag_protocol(struct dsa_port *dp,
1067                                                   struct net_device *master)
1068 {
1069         enum dsa_tag_protocol tag_protocol = DSA_TAG_PROTO_NONE;
1070         struct dsa_switch *mds, *ds = dp->ds;
1071         unsigned int mdp_upstream;
1072         struct dsa_port *mdp;
1073
1074         /* It is possible to stack DSA switches onto one another when that
1075          * happens the switch driver may want to know if its tagging protocol
1076          * is going to work in such a configuration.
1077          */
1078         if (dsa_slave_dev_check(master)) {
1079                 mdp = dsa_slave_to_port(master);
1080                 mds = mdp->ds;
1081                 mdp_upstream = dsa_upstream_port(mds, mdp->index);
1082                 tag_protocol = mds->ops->get_tag_protocol(mds, mdp_upstream,
1083                                                           DSA_TAG_PROTO_NONE);
1084         }
1085
1086         /* If the master device is not itself a DSA slave in a disjoint DSA
1087          * tree, then return immediately.
1088          */
1089         return ds->ops->get_tag_protocol(ds, dp->index, tag_protocol);
1090 }
1091
1092 static int dsa_port_parse_cpu(struct dsa_port *dp, struct net_device *master,
1093                               const char *user_protocol)
1094 {
1095         struct dsa_switch *ds = dp->ds;
1096         struct dsa_switch_tree *dst = ds->dst;
1097         const struct dsa_device_ops *tag_ops;
1098         enum dsa_tag_protocol default_proto;
1099
1100         /* Find out which protocol the switch would prefer. */
1101         default_proto = dsa_get_tag_protocol(dp, master);
1102         if (dst->default_proto) {
1103                 if (dst->default_proto != default_proto) {
1104                         dev_err(ds->dev,
1105                                 "A DSA switch tree can have only one tagging protocol\n");
1106                         return -EINVAL;
1107                 }
1108         } else {
1109                 dst->default_proto = default_proto;
1110         }
1111
1112         /* See if the user wants to override that preference. */
1113         if (user_protocol) {
1114                 if (!ds->ops->change_tag_protocol) {
1115                         dev_err(ds->dev, "Tag protocol cannot be modified\n");
1116                         return -EINVAL;
1117                 }
1118
1119                 tag_ops = dsa_find_tagger_by_name(user_protocol);
1120         } else {
1121                 tag_ops = dsa_tag_driver_get(default_proto);
1122         }
1123
1124         if (IS_ERR(tag_ops)) {
1125                 if (PTR_ERR(tag_ops) == -ENOPROTOOPT)
1126                         return -EPROBE_DEFER;
1127
1128                 dev_warn(ds->dev, "No tagger for this switch\n");
1129                 return PTR_ERR(tag_ops);
1130         }
1131
1132         if (dst->tag_ops) {
1133                 if (dst->tag_ops != tag_ops) {
1134                         dev_err(ds->dev,
1135                                 "A DSA switch tree can have only one tagging protocol\n");
1136
1137                         dsa_tag_driver_put(tag_ops);
1138                         return -EINVAL;
1139                 }
1140
1141                 /* In the case of multiple CPU ports per switch, the tagging
1142                  * protocol is still reference-counted only per switch tree.
1143                  */
1144                 dsa_tag_driver_put(tag_ops);
1145         } else {
1146                 dst->tag_ops = tag_ops;
1147         }
1148
1149         dp->master = master;
1150         dp->type = DSA_PORT_TYPE_CPU;
1151         dsa_port_set_tag_protocol(dp, dst->tag_ops);
1152         dp->dst = dst;
1153
1154         /* At this point, the tree may be configured to use a different
1155          * tagger than the one chosen by the switch driver during
1156          * .setup, in the case when a user selects a custom protocol
1157          * through the DT.
1158          *
1159          * This is resolved by syncing the driver with the tree in
1160          * dsa_switch_setup_tag_protocol once .setup has run and the
1161          * driver is ready to accept calls to .change_tag_protocol. If
1162          * the driver does not support the custom protocol at that
1163          * point, the tree is wholly rejected, thereby ensuring that the
1164          * tree and driver are always in agreement on the protocol to
1165          * use.
1166          */
1167         return 0;
1168 }
1169
1170 static int dsa_port_parse_of(struct dsa_port *dp, struct device_node *dn)
1171 {
1172         struct device_node *ethernet = of_parse_phandle(dn, "ethernet", 0);
1173         const char *name = of_get_property(dn, "label", NULL);
1174         bool link = of_property_read_bool(dn, "link");
1175
1176         dp->dn = dn;
1177
1178         if (ethernet) {
1179                 struct net_device *master;
1180                 const char *user_protocol;
1181
1182                 master = of_find_net_device_by_node(ethernet);
1183                 if (!master)
1184                         return -EPROBE_DEFER;
1185
1186                 user_protocol = of_get_property(dn, "dsa-tag-protocol", NULL);
1187                 return dsa_port_parse_cpu(dp, master, user_protocol);
1188         }
1189
1190         if (link)
1191                 return dsa_port_parse_dsa(dp);
1192
1193         return dsa_port_parse_user(dp, name);
1194 }
1195
1196 static int dsa_switch_parse_ports_of(struct dsa_switch *ds,
1197                                      struct device_node *dn)
1198 {
1199         struct device_node *ports, *port;
1200         struct dsa_port *dp;
1201         int err = 0;
1202         u32 reg;
1203
1204         ports = of_get_child_by_name(dn, "ports");
1205         if (!ports) {
1206                 /* The second possibility is "ethernet-ports" */
1207                 ports = of_get_child_by_name(dn, "ethernet-ports");
1208                 if (!ports) {
1209                         dev_err(ds->dev, "no ports child node found\n");
1210                         return -EINVAL;
1211                 }
1212         }
1213
1214         for_each_available_child_of_node(ports, port) {
1215                 err = of_property_read_u32(port, "reg", &reg);
1216                 if (err)
1217                         goto out_put_node;
1218
1219                 if (reg >= ds->num_ports) {
1220                         dev_err(ds->dev, "port %pOF index %u exceeds num_ports (%zu)\n",
1221                                 port, reg, ds->num_ports);
1222                         err = -EINVAL;
1223                         goto out_put_node;
1224                 }
1225
1226                 dp = dsa_to_port(ds, reg);
1227
1228                 err = dsa_port_parse_of(dp, port);
1229                 if (err)
1230                         goto out_put_node;
1231         }
1232
1233 out_put_node:
1234         of_node_put(ports);
1235         return err;
1236 }
1237
1238 static int dsa_switch_parse_member_of(struct dsa_switch *ds,
1239                                       struct device_node *dn)
1240 {
1241         u32 m[2] = { 0, 0 };
1242         int sz;
1243
1244         /* Don't error out if this optional property isn't found */
1245         sz = of_property_read_variable_u32_array(dn, "dsa,member", m, 2, 2);
1246         if (sz < 0 && sz != -EINVAL)
1247                 return sz;
1248
1249         ds->index = m[1];
1250
1251         ds->dst = dsa_tree_touch(m[0]);
1252         if (!ds->dst)
1253                 return -ENOMEM;
1254
1255         if (dsa_switch_find(ds->dst->index, ds->index)) {
1256                 dev_err(ds->dev,
1257                         "A DSA switch with index %d already exists in tree %d\n",
1258                         ds->index, ds->dst->index);
1259                 return -EEXIST;
1260         }
1261
1262         return 0;
1263 }
1264
1265 static int dsa_switch_touch_ports(struct dsa_switch *ds)
1266 {
1267         struct dsa_port *dp;
1268         int port;
1269
1270         for (port = 0; port < ds->num_ports; port++) {
1271                 dp = dsa_port_touch(ds, port);
1272                 if (!dp)
1273                         return -ENOMEM;
1274         }
1275
1276         return 0;
1277 }
1278
1279 static int dsa_switch_parse_of(struct dsa_switch *ds, struct device_node *dn)
1280 {
1281         int err;
1282
1283         err = dsa_switch_parse_member_of(ds, dn);
1284         if (err)
1285                 return err;
1286
1287         err = dsa_switch_touch_ports(ds);
1288         if (err)
1289                 return err;
1290
1291         return dsa_switch_parse_ports_of(ds, dn);
1292 }
1293
1294 static int dsa_port_parse(struct dsa_port *dp, const char *name,
1295                           struct device *dev)
1296 {
1297         if (!strcmp(name, "cpu")) {
1298                 struct net_device *master;
1299
1300                 master = dsa_dev_to_net_device(dev);
1301                 if (!master)
1302                         return -EPROBE_DEFER;
1303
1304                 dev_put(master);
1305
1306                 return dsa_port_parse_cpu(dp, master, NULL);
1307         }
1308
1309         if (!strcmp(name, "dsa"))
1310                 return dsa_port_parse_dsa(dp);
1311
1312         return dsa_port_parse_user(dp, name);
1313 }
1314
1315 static int dsa_switch_parse_ports(struct dsa_switch *ds,
1316                                   struct dsa_chip_data *cd)
1317 {
1318         bool valid_name_found = false;
1319         struct dsa_port *dp;
1320         struct device *dev;
1321         const char *name;
1322         unsigned int i;
1323         int err;
1324
1325         for (i = 0; i < DSA_MAX_PORTS; i++) {
1326                 name = cd->port_names[i];
1327                 dev = cd->netdev[i];
1328                 dp = dsa_to_port(ds, i);
1329
1330                 if (!name)
1331                         continue;
1332
1333                 err = dsa_port_parse(dp, name, dev);
1334                 if (err)
1335                         return err;
1336
1337                 valid_name_found = true;
1338         }
1339
1340         if (!valid_name_found && i == DSA_MAX_PORTS)
1341                 return -EINVAL;
1342
1343         return 0;
1344 }
1345
1346 static int dsa_switch_parse(struct dsa_switch *ds, struct dsa_chip_data *cd)
1347 {
1348         int err;
1349
1350         ds->cd = cd;
1351
1352         /* We don't support interconnected switches nor multiple trees via
1353          * platform data, so this is the unique switch of the tree.
1354          */
1355         ds->index = 0;
1356         ds->dst = dsa_tree_touch(0);
1357         if (!ds->dst)
1358                 return -ENOMEM;
1359
1360         err = dsa_switch_touch_ports(ds);
1361         if (err)
1362                 return err;
1363
1364         return dsa_switch_parse_ports(ds, cd);
1365 }
1366
1367 static void dsa_switch_release_ports(struct dsa_switch *ds)
1368 {
1369         struct dsa_switch_tree *dst = ds->dst;
1370         struct dsa_port *dp, *next;
1371
1372         list_for_each_entry_safe(dp, next, &dst->ports, list) {
1373                 if (dp->ds != ds)
1374                         continue;
1375                 list_del(&dp->list);
1376                 kfree(dp);
1377         }
1378 }
1379
1380 static int dsa_switch_probe(struct dsa_switch *ds)
1381 {
1382         struct dsa_switch_tree *dst;
1383         struct dsa_chip_data *pdata;
1384         struct device_node *np;
1385         int err;
1386
1387         if (!ds->dev)
1388                 return -ENODEV;
1389
1390         pdata = ds->dev->platform_data;
1391         np = ds->dev->of_node;
1392
1393         if (!ds->num_ports)
1394                 return -EINVAL;
1395
1396         if (np) {
1397                 err = dsa_switch_parse_of(ds, np);
1398                 if (err)
1399                         dsa_switch_release_ports(ds);
1400         } else if (pdata) {
1401                 err = dsa_switch_parse(ds, pdata);
1402                 if (err)
1403                         dsa_switch_release_ports(ds);
1404         } else {
1405                 err = -ENODEV;
1406         }
1407
1408         if (err)
1409                 return err;
1410
1411         dst = ds->dst;
1412         dsa_tree_get(dst);
1413         err = dsa_tree_setup(dst);
1414         if (err) {
1415                 dsa_switch_release_ports(ds);
1416                 dsa_tree_put(dst);
1417         }
1418
1419         return err;
1420 }
1421
1422 int dsa_register_switch(struct dsa_switch *ds)
1423 {
1424         int err;
1425
1426         mutex_lock(&dsa2_mutex);
1427         err = dsa_switch_probe(ds);
1428         dsa_tree_put(ds->dst);
1429         mutex_unlock(&dsa2_mutex);
1430
1431         return err;
1432 }
1433 EXPORT_SYMBOL_GPL(dsa_register_switch);
1434
1435 static void dsa_switch_remove(struct dsa_switch *ds)
1436 {
1437         struct dsa_switch_tree *dst = ds->dst;
1438
1439         dsa_tree_teardown(dst);
1440         dsa_switch_release_ports(ds);
1441         dsa_tree_put(dst);
1442 }
1443
1444 void dsa_unregister_switch(struct dsa_switch *ds)
1445 {
1446         mutex_lock(&dsa2_mutex);
1447         dsa_switch_remove(ds);
1448         mutex_unlock(&dsa2_mutex);
1449 }
1450 EXPORT_SYMBOL_GPL(dsa_unregister_switch);