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