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