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 <[email protected]>
   6  * Copyright (c) 2016 Andrew Lunn <[email protected]>
   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         struct dsa_switch *ds = dp->ds;
 433         bool dsa_port_enabled = false;
 434         int err = 0;
 435
 436         if (dp->setup)
 437                 return 0;
 438
 439         INIT_LIST_HEAD(&dp->fdbs);
 440         INIT_LIST_HEAD(&dp->mdbs);
 441
 442         if (ds->ops->port_setup) {
 443                 err = ds->ops->port_setup(ds, dp->index);
 444                 if (err)
 445                         return err;
 446         }
 447
 448         switch (dp->type) {
 449         case DSA_PORT_TYPE_UNUSED:
 450                 dsa_port_disable(dp);
 451                 break;
 452         case DSA_PORT_TYPE_CPU:
 453                 err = dsa_port_link_register_of(dp);
 454                 if (err)
 455                         break;
 456                 dsa_port_link_registered = true;
 457
 458                 err = dsa_port_enable(dp, NULL);
 459                 if (err)
 460                         break;
 461                 dsa_port_enabled = true;
 462
 463                 break;
 464         case DSA_PORT_TYPE_DSA:
 465                 err = dsa_port_link_register_of(dp);
 466                 if (err)
 467                         break;
 468                 dsa_port_link_registered = true;
 469
 470                 err = dsa_port_enable(dp, NULL);
 471                 if (err)
 472                         break;
 473                 dsa_port_enabled = true;
 474
 475                 break;
 476         case DSA_PORT_TYPE_USER:
 477                 of_get_mac_address(dp->dn, dp->mac);
 478                 err = dsa_slave_create(dp);
 479                 if (err)
 480                         break;
 481
 482                 devlink_port_type_eth_set(dlp, dp->slave);
 483                 break;
 484         }
 485
 486         if (err && dsa_port_enabled)
 487                 dsa_port_disable(dp);
 488         if (err && dsa_port_link_registered)
 489                 dsa_port_link_unregister_of(dp);
 490         if (err) {
 491                 if (ds->ops->port_teardown)
 492                         ds->ops->port_teardown(ds, dp->index);
 493                 return err;
 494         }
 495
 496         dp->setup = true;
 497
 498         return 0;
 499 }
 500
 501 static int dsa_port_devlink_setup(struct dsa_port *dp)
 502 {
 503         struct devlink_port *dlp = &dp->devlink_port;
 504         struct dsa_switch_tree *dst = dp->ds->dst;
 505         struct devlink_port_attrs attrs = {};
 506         struct devlink *dl = dp->ds->devlink;
 507         const unsigned char *id;
 508         unsigned char len;
 509         int err;
 510
 511         id = (const unsigned char *)&dst->index;
 512         len = sizeof(dst->index);
 513
 514         attrs.phys.port_number = dp->index;
 515         memcpy(attrs.switch_id.id, id, len);
 516         attrs.switch_id.id_len = len;
 517         memset(dlp, 0, sizeof(*dlp));
 518
 519         switch (dp->type) {
 520         case DSA_PORT_TYPE_UNUSED:
 521                 attrs.flavour = DEVLINK_PORT_FLAVOUR_UNUSED;
 522                 break;
 523         case DSA_PORT_TYPE_CPU:
 524                 attrs.flavour = DEVLINK_PORT_FLAVOUR_CPU;
 525                 break;
 526         case DSA_PORT_TYPE_DSA:
 527                 attrs.flavour = DEVLINK_PORT_FLAVOUR_DSA;
 528                 break;
 529         case DSA_PORT_TYPE_USER:
 530                 attrs.flavour = DEVLINK_PORT_FLAVOUR_PHYSICAL;
 531                 break;
 532         }
 533
 534         devlink_port_attrs_set(dlp, &attrs);
 535         err = devlink_port_register(dl, dlp, dp->index);
 536
 537         if (!err)
 538                 dp->devlink_port_setup = true;
 539
 540         return err;
 541 }
 542
 543 static void dsa_port_teardown(struct dsa_port *dp)
 544 {
 545         struct devlink_port *dlp = &dp->devlink_port;
 546         struct dsa_switch *ds = dp->ds;
 547         struct dsa_mac_addr *a, *tmp;
 548
 549         if (!dp->setup)
 550                 return;
 551
 552         if (ds->ops->port_teardown)
 553                 ds->ops->port_teardown(ds, dp->index);
 554
 555         devlink_port_type_clear(dlp);
 556
 557         switch (dp->type) {
 558         case DSA_PORT_TYPE_UNUSED:
 559                 break;
 560         case DSA_PORT_TYPE_CPU:
 561                 dsa_port_disable(dp);
 562                 dsa_port_link_unregister_of(dp);
 563                 break;
 564         case DSA_PORT_TYPE_DSA:
 565                 dsa_port_disable(dp);
 566                 dsa_port_link_unregister_of(dp);
 567                 break;
 568         case DSA_PORT_TYPE_USER:
 569                 if (dp->slave) {
 570                         dsa_slave_destroy(dp->slave);
 571                         dp->slave = NULL;
 572                 }
 573                 break;
 574         }
 575
 576         list_for_each_entry_safe(a, tmp, &dp->fdbs, list) {
 577                 list_del(&a->list);
 578                 kfree(a);
 579         }
 580
 581         list_for_each_entry_safe(a, tmp, &dp->mdbs, list) {
 582                 list_del(&a->list);
 583                 kfree(a);
 584         }
 585
 586         dp->setup = false;
 587 }
 588
 589 static void dsa_port_devlink_teardown(struct dsa_port *dp)
 590 {
 591         struct devlink_port *dlp = &dp->devlink_port;
 592
 593         if (dp->devlink_port_setup)
 594                 devlink_port_unregister(dlp);
 595         dp->devlink_port_setup = false;
 596 }
 597
 598 /* Destroy the current devlink port, and create a new one which has the UNUSED
 599  * flavour. At this point, any call to ds->ops->port_setup has been already
 600  * balanced out by a call to ds->ops->port_teardown, so we know that any
 601  * devlink port regions the driver had are now unregistered. We then call its
 602  * ds->ops->port_setup again, in order for the driver to re-create them on the
 603  * new devlink port.
 604  */
 605 static int dsa_port_reinit_as_unused(struct dsa_port *dp)
 606 {
 607         struct dsa_switch *ds = dp->ds;
 608         int err;
 609
 610         dsa_port_devlink_teardown(dp);
 611         dp->type = DSA_PORT_TYPE_UNUSED;
 612         err = dsa_port_devlink_setup(dp);
 613         if (err)
 614                 return err;
 615
 616         if (ds->ops->port_setup) {
 617                 /* On error, leave the devlink port registered,
 618                  * dsa_switch_teardown will clean it up later.
 619                  */
 620                 err = ds->ops->port_setup(ds, dp->index);
 621                 if (err)
 622                         return err;
 623         }
 624
 625         return 0;
 626 }
 627
 628 static int dsa_devlink_info_get(struct devlink *dl,
 629                                 struct devlink_info_req *req,
 630                                 struct netlink_ext_ack *extack)
 631 {
 632         struct dsa_switch *ds = dsa_devlink_to_ds(dl);
 633
 634         if (ds->ops->devlink_info_get)
 635                 return ds->ops->devlink_info_get(ds, req, extack);
 636
 637         return -EOPNOTSUPP;
 638 }
 639
 640 static int dsa_devlink_sb_pool_get(struct devlink *dl,
 641                                    unsigned int sb_index, u16 pool_index,
 642                                    struct devlink_sb_pool_info *pool_info)
 643 {
 644         struct dsa_switch *ds = dsa_devlink_to_ds(dl);
 645
 646         if (!ds->ops->devlink_sb_pool_get)
 647                 return -EOPNOTSUPP;
 648
 649         return ds->ops->devlink_sb_pool_get(ds, sb_index, pool_index,
 650                                             pool_info);
 651 }
 652
 653 static int dsa_devlink_sb_pool_set(struct devlink *dl, unsigned int sb_index,
 654                                    u16 pool_index, u32 size,
 655                                    enum devlink_sb_threshold_type threshold_type,
 656                                    struct netlink_ext_ack *extack)
 657 {
 658         struct dsa_switch *ds = dsa_devlink_to_ds(dl);
 659
 660         if (!ds->ops->devlink_sb_pool_set)
 661                 return -EOPNOTSUPP;
 662
 663         return ds->ops->devlink_sb_pool_set(ds, sb_index, pool_index, size,
 664                                             threshold_type, extack);
 665 }
 666
 667 static int dsa_devlink_sb_port_pool_get(struct devlink_port *dlp,
 668                                         unsigned int sb_index, u16 pool_index,
 669                                         u32 *p_threshold)
 670 {
 671         struct dsa_switch *ds = dsa_devlink_port_to_ds(dlp);
 672         int port = dsa_devlink_port_to_port(dlp);
 673
 674         if (!ds->ops->devlink_sb_port_pool_get)
 675                 return -EOPNOTSUPP;
 676
 677         return ds->ops->devlink_sb_port_pool_get(ds, port, sb_index,
 678                                                  pool_index, p_threshold);
 679 }
 680
 681 static int dsa_devlink_sb_port_pool_set(struct devlink_port *dlp,
 682                                         unsigned int sb_index, u16 pool_index,
 683                                         u32 threshold,
 684                                         struct netlink_ext_ack *extack)
 685 {
 686         struct dsa_switch *ds = dsa_devlink_port_to_ds(dlp);
 687         int port = dsa_devlink_port_to_port(dlp);
 688
 689         if (!ds->ops->devlink_sb_port_pool_set)
 690                 return -EOPNOTSUPP;
 691
 692         return ds->ops->devlink_sb_port_pool_set(ds, port, sb_index,
 693                                                  pool_index, threshold, extack);
 694 }
 695
 696 static int
 697 dsa_devlink_sb_tc_pool_bind_get(struct devlink_port *dlp,
 698                                 unsigned int sb_index, u16 tc_index,
 699                                 enum devlink_sb_pool_type pool_type,
 700                                 u16 *p_pool_index, u32 *p_threshold)
 701 {
 702         struct dsa_switch *ds = dsa_devlink_port_to_ds(dlp);
 703         int port = dsa_devlink_port_to_port(dlp);
 704
 705         if (!ds->ops->devlink_sb_tc_pool_bind_get)
 706                 return -EOPNOTSUPP;
 707
 708         return ds->ops->devlink_sb_tc_pool_bind_get(ds, port, sb_index,
 709                                                     tc_index, pool_type,
 710                                                     p_pool_index, p_threshold);
 711 }
 712
 713 static int
 714 dsa_devlink_sb_tc_pool_bind_set(struct devlink_port *dlp,
 715                                 unsigned int sb_index, u16 tc_index,
 716                                 enum devlink_sb_pool_type pool_type,
 717                                 u16 pool_index, u32 threshold,
 718                                 struct netlink_ext_ack *extack)
 719 {
 720         struct dsa_switch *ds = dsa_devlink_port_to_ds(dlp);
 721         int port = dsa_devlink_port_to_port(dlp);
 722
 723         if (!ds->ops->devlink_sb_tc_pool_bind_set)
 724                 return -EOPNOTSUPP;
 725
 726         return ds->ops->devlink_sb_tc_pool_bind_set(ds, port, sb_index,
 727                                                     tc_index, pool_type,
 728                                                     pool_index, threshold,
 729                                                     extack);
 730 }
 731
 732 static int dsa_devlink_sb_occ_snapshot(struct devlink *dl,
 733                                        unsigned int sb_index)
 734 {
 735         struct dsa_switch *ds = dsa_devlink_to_ds(dl);
 736
 737         if (!ds->ops->devlink_sb_occ_snapshot)
 738                 return -EOPNOTSUPP;
 739
 740         return ds->ops->devlink_sb_occ_snapshot(ds, sb_index);
 741 }
 742
 743 static int dsa_devlink_sb_occ_max_clear(struct devlink *dl,
 744                                         unsigned int sb_index)
 745 {
 746         struct dsa_switch *ds = dsa_devlink_to_ds(dl);
 747
 748         if (!ds->ops->devlink_sb_occ_max_clear)
 749                 return -EOPNOTSUPP;
 750
 751         return ds->ops->devlink_sb_occ_max_clear(ds, sb_index);
 752 }
 753
 754 static int dsa_devlink_sb_occ_port_pool_get(struct devlink_port *dlp,
 755                                             unsigned int sb_index,
 756                                             u16 pool_index, u32 *p_cur,
 757                                             u32 *p_max)
 758 {
 759         struct dsa_switch *ds = dsa_devlink_port_to_ds(dlp);
 760         int port = dsa_devlink_port_to_port(dlp);
 761
 762         if (!ds->ops->devlink_sb_occ_port_pool_get)
 763                 return -EOPNOTSUPP;
 764
 765         return ds->ops->devlink_sb_occ_port_pool_get(ds, port, sb_index,
 766                                                      pool_index, p_cur, p_max);
 767 }
 768
 769 static int
 770 dsa_devlink_sb_occ_tc_port_bind_get(struct devlink_port *dlp,
 771                                     unsigned int sb_index, u16 tc_index,
 772                                     enum devlink_sb_pool_type pool_type,
 773                                     u32 *p_cur, u32 *p_max)
 774 {
 775         struct dsa_switch *ds = dsa_devlink_port_to_ds(dlp);
 776         int port = dsa_devlink_port_to_port(dlp);
 777
 778         if (!ds->ops->devlink_sb_occ_tc_port_bind_get)
 779                 return -EOPNOTSUPP;
 780
 781         return ds->ops->devlink_sb_occ_tc_port_bind_get(ds, port,
 782                                                         sb_index, tc_index,
 783                                                         pool_type, p_cur,
 784                                                         p_max);
 785 }
 786
 787 static const struct devlink_ops dsa_devlink_ops = {
 788         .info_get                       = dsa_devlink_info_get,
 789         .sb_pool_get                    = dsa_devlink_sb_pool_get,
 790         .sb_pool_set                    = dsa_devlink_sb_pool_set,
 791         .sb_port_pool_get               = dsa_devlink_sb_port_pool_get,
 792         .sb_port_pool_set               = dsa_devlink_sb_port_pool_set,
 793         .sb_tc_pool_bind_get            = dsa_devlink_sb_tc_pool_bind_get,
 794         .sb_tc_pool_bind_set            = dsa_devlink_sb_tc_pool_bind_set,
 795         .sb_occ_snapshot                = dsa_devlink_sb_occ_snapshot,
 796         .sb_occ_max_clear               = dsa_devlink_sb_occ_max_clear,
 797         .sb_occ_port_pool_get           = dsa_devlink_sb_occ_port_pool_get,
 798         .sb_occ_tc_port_bind_get        = dsa_devlink_sb_occ_tc_port_bind_get,
 799 };
 800
 801 static int dsa_switch_setup_tag_protocol(struct dsa_switch *ds)
 802 {
 803         const struct dsa_device_ops *tag_ops = ds->dst->tag_ops;
 804         struct dsa_switch_tree *dst = ds->dst;
 805         int port, err;
 806
 807         if (tag_ops->proto == dst->default_proto)
 808                 return 0;
 809
 810         for (port = 0; port < ds->num_ports; port++) {
 811                 if (!dsa_is_cpu_port(ds, port))
 812                         continue;
 813
 814                 err = ds->ops->change_tag_protocol(ds, port, tag_ops->proto);
 815                 if (err) {
 816                         dev_err(ds->dev, "Unable to use tag protocol \"%s\": %pe\n",
 817                                 tag_ops->name, ERR_PTR(err));
 818                         return err;
 819                 }
 820         }
 821
 822         return 0;
 823 }
 824
 825 static int dsa_switch_setup(struct dsa_switch *ds)
 826 {
 827         struct dsa_devlink_priv *dl_priv;
 828         struct dsa_port *dp;
 829         int err;
 830
 831         if (ds->setup)
 832                 return 0;
 833
 834         /* Initialize ds->phys_mii_mask before registering the slave MDIO bus
 835          * driver and before ops->setup() has run, since the switch drivers and
 836          * the slave MDIO bus driver rely on these values for probing PHY
 837          * devices or not
 838          */
 839         ds->phys_mii_mask |= dsa_user_ports(ds);
 840
 841         /* Add the switch to devlink before calling setup, so that setup can
 842          * add dpipe tables
 843          */
 844         ds->devlink =
 845                 devlink_alloc(&dsa_devlink_ops, sizeof(*dl_priv), ds->dev);
 846         if (!ds->devlink)
 847                 return -ENOMEM;
 848         dl_priv = devlink_priv(ds->devlink);
 849         dl_priv->ds = ds;
 850
 851         /* Setup devlink port instances now, so that the switch
 852          * setup() can register regions etc, against the ports
 853          */
 854         list_for_each_entry(dp, &ds->dst->ports, list) {
 855                 if (dp->ds == ds) {
 856                         err = dsa_port_devlink_setup(dp);
 857                         if (err)
 858                                 goto unregister_devlink_ports;
 859                 }
 860         }
 861
 862         err = dsa_switch_register_notifier(ds);
 863         if (err)
 864                 goto unregister_devlink_ports;
 865
 866         ds->configure_vlan_while_not_filtering = true;
 867
 868         err = ds->ops->setup(ds);
 869         if (err < 0)
 870                 goto unregister_notifier;
 871
 872         err = dsa_switch_setup_tag_protocol(ds);
 873         if (err)
 874                 goto teardown;
 875
 876         if (!ds->slave_mii_bus && ds->ops->phy_read) {
 877                 ds->slave_mii_bus = mdiobus_alloc();
 878                 if (!ds->slave_mii_bus) {
 879                         err = -ENOMEM;
 880                         goto teardown;
 881                 }
 882
 883                 dsa_slave_mii_bus_init(ds);
 884
 885                 err = mdiobus_register(ds->slave_mii_bus);
 886                 if (err < 0)
 887                         goto free_slave_mii_bus;
 888         }
 889
 890         ds->setup = true;
 891         devlink_register(ds->devlink);
 892         return 0;
 893
 894 free_slave_mii_bus:
 895         if (ds->slave_mii_bus && ds->ops->phy_read)
 896                 mdiobus_free(ds->slave_mii_bus);
 897 teardown:
 898         if (ds->ops->teardown)
 899                 ds->ops->teardown(ds);
 900 unregister_notifier:
 901         dsa_switch_unregister_notifier(ds);
 902 unregister_devlink_ports:
 903         list_for_each_entry(dp, &ds->dst->ports, list)
 904                 if (dp->ds == ds)
 905                         dsa_port_devlink_teardown(dp);
 906         devlink_free(ds->devlink);
 907         ds->devlink = NULL;
 908         return err;
 909 }
 910
 911 static void dsa_switch_teardown(struct dsa_switch *ds)
 912 {
 913         struct dsa_port *dp;
 914
 915         if (!ds->setup)
 916                 return;
 917
 918         if (ds->devlink)
 919                 devlink_unregister(ds->devlink);
 920
 921         if (ds->slave_mii_bus && ds->ops->phy_read) {
 922                 mdiobus_unregister(ds->slave_mii_bus);
 923                 mdiobus_free(ds->slave_mii_bus);
 924                 ds->slave_mii_bus = NULL;
 925         }
 926
 927         dsa_switch_unregister_notifier(ds);
 928
 929         if (ds->ops->teardown)
 930                 ds->ops->teardown(ds);
 931
 932         if (ds->devlink) {
 933                 list_for_each_entry(dp, &ds->dst->ports, list)
 934                         if (dp->ds == ds)
 935                                 dsa_port_devlink_teardown(dp);
 936                 devlink_free(ds->devlink);
 937                 ds->devlink = NULL;
 938         }
 939
 940         ds->setup = false;
 941 }
 942
 943 /* First tear down the non-shared, then the shared ports. This ensures that
 944  * all work items scheduled by our switchdev handlers for user ports have
 945  * completed before we destroy the refcounting kept on the shared ports.
 946  */
 947 static void dsa_tree_teardown_ports(struct dsa_switch_tree *dst)
 948 {
 949         struct dsa_port *dp;
 950
 951         list_for_each_entry(dp, &dst->ports, list)
 952                 if (dsa_port_is_user(dp) || dsa_port_is_unused(dp))
 953                         dsa_port_teardown(dp);
 954
 955         dsa_flush_workqueue();
 956
 957         list_for_each_entry(dp, &dst->ports, list)
 958                 if (dsa_port_is_dsa(dp) || dsa_port_is_cpu(dp))
 959                         dsa_port_teardown(dp);
 960 }
 961
 962 static void dsa_tree_teardown_switches(struct dsa_switch_tree *dst)
 963 {
 964         struct dsa_port *dp;
 965
 966         list_for_each_entry(dp, &dst->ports, list)
 967                 dsa_switch_teardown(dp->ds);
 968 }
 969
 970 static int dsa_tree_setup_switches(struct dsa_switch_tree *dst)
 971 {
 972         struct dsa_port *dp;
 973         int err;
 974
 975         list_for_each_entry(dp, &dst->ports, list) {
 976                 err = dsa_switch_setup(dp->ds);
 977                 if (err)
 978                         goto teardown;
 979         }
 980
 981         list_for_each_entry(dp, &dst->ports, list) {
 982                 err = dsa_port_setup(dp);
 983                 if (err) {
 984                         err = dsa_port_reinit_as_unused(dp);
 985                         if (err)
 986                                 goto teardown;
 987                 }
 988         }
 989
 990         return 0;
 991
 992 teardown:
 993         dsa_tree_teardown_ports(dst);
 994
 995         dsa_tree_teardown_switches(dst);
 996
 997         return err;
 998 }
 999
1000 static int dsa_tree_setup_master(struct dsa_switch_tree *dst)
1001 {
1002         struct dsa_port *dp;
1003         int err;
1004
1005         list_for_each_entry(dp, &dst->ports, list) {
1006                 if (dsa_port_is_cpu(dp)) {
1007                         err = dsa_master_setup(dp->master, dp);
1008                         if (err)
1009                                 return err;
1010                 }
1011         }
1012
1013         return 0;
1014 }
1015
1016 static void dsa_tree_teardown_master(struct dsa_switch_tree *dst)
1017 {
1018         struct dsa_port *dp;
1019
1020         list_for_each_entry(dp, &dst->ports, list)
1021                 if (dsa_port_is_cpu(dp))
1022                         dsa_master_teardown(dp->master);
1023 }
1024
1025 static int dsa_tree_setup_lags(struct dsa_switch_tree *dst)
1026 {
1027         unsigned int len = 0;
1028         struct dsa_port *dp;
1029
1030         list_for_each_entry(dp, &dst->ports, list) {
1031                 if (dp->ds->num_lag_ids > len)
1032                         len = dp->ds->num_lag_ids;
1033         }
1034
1035         if (!len)
1036                 return 0;
1037
1038         dst->lags = kcalloc(len, sizeof(*dst->lags), GFP_KERNEL);
1039         if (!dst->lags)
1040                 return -ENOMEM;
1041
1042         dst->lags_len = len;
1043         return 0;
1044 }
1045
1046 static void dsa_tree_teardown_lags(struct dsa_switch_tree *dst)
1047 {
1048         kfree(dst->lags);
1049 }
1050
1051 static int dsa_tree_setup(struct dsa_switch_tree *dst)
1052 {
1053         bool complete;
1054         int err;
1055
1056         if (dst->setup) {
1057                 pr_err("DSA: tree %d already setup! Disjoint trees?\n",
1058                        dst->index);
1059                 return -EEXIST;
1060         }
1061
1062         complete = dsa_tree_setup_routing_table(dst);
1063         if (!complete)
1064                 return 0;
1065
1066         err = dsa_tree_setup_cpu_ports(dst);
1067         if (err)
1068                 return err;
1069
1070         err = dsa_tree_setup_switches(dst);
1071         if (err)
1072                 goto teardown_cpu_ports;
1073
1074         err = dsa_tree_setup_master(dst);
1075         if (err)
1076                 goto teardown_switches;
1077
1078         err = dsa_tree_setup_lags(dst);
1079         if (err)
1080                 goto teardown_master;
1081
1082         dst->setup = true;
1083
1084         pr_info("DSA: tree %d setup\n", dst->index);
1085
1086         return 0;
1087
1088 teardown_master:
1089         dsa_tree_teardown_master(dst);
1090 teardown_switches:
1091         dsa_tree_teardown_ports(dst);
1092         dsa_tree_teardown_switches(dst);
1093 teardown_cpu_ports:
1094         dsa_tree_teardown_cpu_ports(dst);
1095
1096         return err;
1097 }
1098
1099 static void dsa_tree_teardown(struct dsa_switch_tree *dst)
1100 {
1101         struct dsa_link *dl, *next;
1102
1103         if (!dst->setup)
1104                 return;
1105
1106         dsa_tree_teardown_lags(dst);
1107
1108         dsa_tree_teardown_master(dst);
1109
1110         dsa_tree_teardown_ports(dst);
1111
1112         dsa_tree_teardown_switches(dst);
1113
1114         dsa_tree_teardown_cpu_ports(dst);
1115
1116         list_for_each_entry_safe(dl, next, &dst->rtable, list) {
1117                 list_del(&dl->list);
1118                 kfree(dl);
1119         }
1120
1121         pr_info("DSA: tree %d torn down\n", dst->index);
1122
1123         dst->setup = false;
1124 }
1125
1126 /* Since the dsa/tagging sysfs device attribute is per master, the assumption
1127  * is that all DSA switches within a tree share the same tagger, otherwise
1128  * they would have formed disjoint trees (different "dsa,member" values).
1129  */
1130 int dsa_tree_change_tag_proto(struct dsa_switch_tree *dst,
1131                               struct net_device *master,
1132                               const struct dsa_device_ops *tag_ops,
1133                               const struct dsa_device_ops *old_tag_ops)
1134 {
1135         struct dsa_notifier_tag_proto_info info;
1136         struct dsa_port *dp;
1137         int err = -EBUSY;
1138
1139         if (!rtnl_trylock())
1140                 return restart_syscall();
1141
1142         /* At the moment we don't allow changing the tag protocol under
1143          * traffic. The rtnl_mutex also happens to serialize concurrent
1144          * attempts to change the tagging protocol. If we ever lift the IFF_UP
1145          * restriction, there needs to be another mutex which serializes this.
1146          */
1147         if (master->flags & IFF_UP)
1148                 goto out_unlock;
1149
1150         list_for_each_entry(dp, &dst->ports, list) {
1151                 if (!dsa_is_user_port(dp->ds, dp->index))
1152                         continue;
1153
1154                 if (dp->slave->flags & IFF_UP)
1155                         goto out_unlock;
1156         }
1157
1158         info.tag_ops = tag_ops;
1159         err = dsa_tree_notify(dst, DSA_NOTIFIER_TAG_PROTO, &info);
1160         if (err)
1161                 goto out_unwind_tagger;
1162
1163         dst->tag_ops = tag_ops;
1164
1165         rtnl_unlock();
1166
1167         return 0;
1168
1169 out_unwind_tagger:
1170         info.tag_ops = old_tag_ops;
1171         dsa_tree_notify(dst, DSA_NOTIFIER_TAG_PROTO, &info);
1172 out_unlock:
1173         rtnl_unlock();
1174         return err;
1175 }
1176
1177 static struct dsa_port *dsa_port_touch(struct dsa_switch *ds, int index)
1178 {
1179         struct dsa_switch_tree *dst = ds->dst;
1180         struct dsa_port *dp;
1181
1182         list_for_each_entry(dp, &dst->ports, list)
1183                 if (dp->ds == ds && dp->index == index)
1184                         return dp;
1185
1186         dp = kzalloc(sizeof(*dp), GFP_KERNEL);
1187         if (!dp)
1188                 return NULL;
1189
1190         dp->ds = ds;
1191         dp->index = index;
1192         dp->bridge_num = -1;
1193
1194         INIT_LIST_HEAD(&dp->list);
1195         list_add_tail(&dp->list, &dst->ports);
1196
1197         return dp;
1198 }
1199
1200 static int dsa_port_parse_user(struct dsa_port *dp, const char *name)
1201 {
1202         if (!name)
1203                 name = "eth%d";
1204
1205         dp->type = DSA_PORT_TYPE_USER;
1206         dp->name = name;
1207
1208         return 0;
1209 }
1210
1211 static int dsa_port_parse_dsa(struct dsa_port *dp)
1212 {
1213         dp->type = DSA_PORT_TYPE_DSA;
1214
1215         return 0;
1216 }
1217
1218 static enum dsa_tag_protocol dsa_get_tag_protocol(struct dsa_port *dp,
1219                                                   struct net_device *master)
1220 {
1221         enum dsa_tag_protocol tag_protocol = DSA_TAG_PROTO_NONE;
1222         struct dsa_switch *mds, *ds = dp->ds;
1223         unsigned int mdp_upstream;
1224         struct dsa_port *mdp;
1225
1226         /* It is possible to stack DSA switches onto one another when that
1227          * happens the switch driver may want to know if its tagging protocol
1228          * is going to work in such a configuration.
1229          */
1230         if (dsa_slave_dev_check(master)) {
1231                 mdp = dsa_slave_to_port(master);
1232                 mds = mdp->ds;
1233                 mdp_upstream = dsa_upstream_port(mds, mdp->index);
1234                 tag_protocol = mds->ops->get_tag_protocol(mds, mdp_upstream,
1235                                                           DSA_TAG_PROTO_NONE);
1236         }
1237
1238         /* If the master device is not itself a DSA slave in a disjoint DSA
1239          * tree, then return immediately.
1240          */
1241         return ds->ops->get_tag_protocol(ds, dp->index, tag_protocol);
1242 }
1243
1244 static int dsa_port_parse_cpu(struct dsa_port *dp, struct net_device *master,
1245                               const char *user_protocol)
1246 {
1247         struct dsa_switch *ds = dp->ds;
1248         struct dsa_switch_tree *dst = ds->dst;
1249         const struct dsa_device_ops *tag_ops;
1250         enum dsa_tag_protocol default_proto;
1251
1252         /* Find out which protocol the switch would prefer. */
1253         default_proto = dsa_get_tag_protocol(dp, master);
1254         if (dst->default_proto) {
1255                 if (dst->default_proto != default_proto) {
1256                         dev_err(ds->dev,
1257                                 "A DSA switch tree can have only one tagging protocol\n");
1258                         return -EINVAL;
1259                 }
1260         } else {
1261                 dst->default_proto = default_proto;
1262         }
1263
1264         /* See if the user wants to override that preference. */
1265         if (user_protocol) {
1266                 if (!ds->ops->change_tag_protocol) {
1267                         dev_err(ds->dev, "Tag protocol cannot be modified\n");
1268                         return -EINVAL;
1269                 }
1270
1271                 tag_ops = dsa_find_tagger_by_name(user_protocol);
1272         } else {
1273                 tag_ops = dsa_tag_driver_get(default_proto);
1274         }
1275
1276         if (IS_ERR(tag_ops)) {
1277                 if (PTR_ERR(tag_ops) == -ENOPROTOOPT)
1278                         return -EPROBE_DEFER;
1279
1280                 dev_warn(ds->dev, "No tagger for this switch\n");
1281                 return PTR_ERR(tag_ops);
1282         }
1283
1284         if (dst->tag_ops) {
1285                 if (dst->tag_ops != tag_ops) {
1286                         dev_err(ds->dev,
1287                                 "A DSA switch tree can have only one tagging protocol\n");
1288
1289                         dsa_tag_driver_put(tag_ops);
1290                         return -EINVAL;
1291                 }
1292
1293                 /* In the case of multiple CPU ports per switch, the tagging
1294                  * protocol is still reference-counted only per switch tree.
1295                  */
1296                 dsa_tag_driver_put(tag_ops);
1297         } else {
1298                 dst->tag_ops = tag_ops;
1299         }
1300
1301         dp->master = master;
1302         dp->type = DSA_PORT_TYPE_CPU;
1303         dsa_port_set_tag_protocol(dp, dst->tag_ops);
1304         dp->dst = dst;
1305
1306         /* At this point, the tree may be configured to use a different
1307          * tagger than the one chosen by the switch driver during
1308          * .setup, in the case when a user selects a custom protocol
1309          * through the DT.
1310          *
1311          * This is resolved by syncing the driver with the tree in
1312          * dsa_switch_setup_tag_protocol once .setup has run and the
1313          * driver is ready to accept calls to .change_tag_protocol. If
1314          * the driver does not support the custom protocol at that
1315          * point, the tree is wholly rejected, thereby ensuring that the
1316          * tree and driver are always in agreement on the protocol to
1317          * use.
1318          */
1319         return 0;
1320 }
1321
1322 static int dsa_port_parse_of(struct dsa_port *dp, struct device_node *dn)
1323 {
1324         struct device_node *ethernet = of_parse_phandle(dn, "ethernet", 0);
1325         const char *name = of_get_property(dn, "label", NULL);
1326         bool link = of_property_read_bool(dn, "link");
1327
1328         dp->dn = dn;
1329
1330         if (ethernet) {
1331                 struct net_device *master;
1332                 const char *user_protocol;
1333
1334                 master = of_find_net_device_by_node(ethernet);
1335                 if (!master)
1336                         return -EPROBE_DEFER;
1337
1338                 user_protocol = of_get_property(dn, "dsa-tag-protocol", NULL);
1339                 return dsa_port_parse_cpu(dp, master, user_protocol);
1340         }
1341
1342         if (link)
1343                 return dsa_port_parse_dsa(dp);
1344
1345         return dsa_port_parse_user(dp, name);
1346 }
1347
1348 static int dsa_switch_parse_ports_of(struct dsa_switch *ds,
1349                                      struct device_node *dn)
1350 {
1351         struct device_node *ports, *port;
1352         struct dsa_port *dp;
1353         int err = 0;
1354         u32 reg;
1355
1356         ports = of_get_child_by_name(dn, "ports");
1357         if (!ports) {
1358                 /* The second possibility is "ethernet-ports" */
1359                 ports = of_get_child_by_name(dn, "ethernet-ports");
1360                 if (!ports) {
1361                         dev_err(ds->dev, "no ports child node found\n");
1362                         return -EINVAL;
1363                 }
1364         }
1365
1366         for_each_available_child_of_node(ports, port) {
1367                 err = of_property_read_u32(port, "reg", &reg);
1368                 if (err)
1369                         goto out_put_node;
1370
1371                 if (reg >= ds->num_ports) {
1372                         dev_err(ds->dev, "port %pOF index %u exceeds num_ports (%zu)\n",
1373                                 port, reg, ds->num_ports);
1374                         err = -EINVAL;
1375                         goto out_put_node;
1376                 }
1377
1378                 dp = dsa_to_port(ds, reg);
1379
1380                 err = dsa_port_parse_of(dp, port);
1381                 if (err)
1382                         goto out_put_node;
1383         }
1384
1385 out_put_node:
1386         of_node_put(ports);
1387         return err;
1388 }
1389
1390 static int dsa_switch_parse_member_of(struct dsa_switch *ds,
1391                                       struct device_node *dn)
1392 {
1393         u32 m[2] = { 0, 0 };
1394         int sz;
1395
1396         /* Don't error out if this optional property isn't found */
1397         sz = of_property_read_variable_u32_array(dn, "dsa,member", m, 2, 2);
1398         if (sz < 0 && sz != -EINVAL)
1399                 return sz;
1400
1401         ds->index = m[1];
1402
1403         ds->dst = dsa_tree_touch(m[0]);
1404         if (!ds->dst)
1405                 return -ENOMEM;
1406
1407         if (dsa_switch_find(ds->dst->index, ds->index)) {
1408                 dev_err(ds->dev,
1409                         "A DSA switch with index %d already exists in tree %d\n",
1410                         ds->index, ds->dst->index);
1411                 return -EEXIST;
1412         }
1413
1414         if (ds->dst->last_switch < ds->index)
1415                 ds->dst->last_switch = ds->index;
1416
1417         return 0;
1418 }
1419
1420 static int dsa_switch_touch_ports(struct dsa_switch *ds)
1421 {
1422         struct dsa_port *dp;
1423         int port;
1424
1425         for (port = 0; port < ds->num_ports; port++) {
1426                 dp = dsa_port_touch(ds, port);
1427                 if (!dp)
1428                         return -ENOMEM;
1429         }
1430
1431         return 0;
1432 }
1433
1434 static int dsa_switch_parse_of(struct dsa_switch *ds, struct device_node *dn)
1435 {
1436         int err;
1437
1438         err = dsa_switch_parse_member_of(ds, dn);
1439         if (err)
1440                 return err;
1441
1442         err = dsa_switch_touch_ports(ds);
1443         if (err)
1444                 return err;
1445
1446         return dsa_switch_parse_ports_of(ds, dn);
1447 }
1448
1449 static int dsa_port_parse(struct dsa_port *dp, const char *name,
1450                           struct device *dev)
1451 {
1452         if (!strcmp(name, "cpu")) {
1453                 struct net_device *master;
1454
1455                 master = dsa_dev_to_net_device(dev);
1456                 if (!master)
1457                         return -EPROBE_DEFER;
1458
1459                 dev_put(master);
1460
1461                 return dsa_port_parse_cpu(dp, master, NULL);
1462         }
1463
1464         if (!strcmp(name, "dsa"))
1465                 return dsa_port_parse_dsa(dp);
1466
1467         return dsa_port_parse_user(dp, name);
1468 }
1469
1470 static int dsa_switch_parse_ports(struct dsa_switch *ds,
1471                                   struct dsa_chip_data *cd)
1472 {
1473         bool valid_name_found = false;
1474         struct dsa_port *dp;
1475         struct device *dev;
1476         const char *name;
1477         unsigned int i;
1478         int err;
1479
1480         for (i = 0; i < DSA_MAX_PORTS; i++) {
1481                 name = cd->port_names[i];
1482                 dev = cd->netdev[i];
1483                 dp = dsa_to_port(ds, i);
1484
1485                 if (!name)
1486                         continue;
1487
1488                 err = dsa_port_parse(dp, name, dev);
1489                 if (err)
1490                         return err;
1491
1492                 valid_name_found = true;
1493         }
1494
1495         if (!valid_name_found && i == DSA_MAX_PORTS)
1496                 return -EINVAL;
1497
1498         return 0;
1499 }
1500
1501 static int dsa_switch_parse(struct dsa_switch *ds, struct dsa_chip_data *cd)
1502 {
1503         int err;
1504
1505         ds->cd = cd;
1506
1507         /* We don't support interconnected switches nor multiple trees via
1508          * platform data, so this is the unique switch of the tree.
1509          */
1510         ds->index = 0;
1511         ds->dst = dsa_tree_touch(0);
1512         if (!ds->dst)
1513                 return -ENOMEM;
1514
1515         err = dsa_switch_touch_ports(ds);
1516         if (err)
1517                 return err;
1518
1519         return dsa_switch_parse_ports(ds, cd);
1520 }
1521
1522 static void dsa_switch_release_ports(struct dsa_switch *ds)
1523 {
1524         struct dsa_switch_tree *dst = ds->dst;
1525         struct dsa_port *dp, *next;
1526
1527         list_for_each_entry_safe(dp, next, &dst->ports, list) {
1528                 if (dp->ds != ds)
1529                         continue;
1530                 list_del(&dp->list);
1531                 kfree(dp);
1532         }
1533 }
1534
1535 static int dsa_switch_probe(struct dsa_switch *ds)
1536 {
1537         struct dsa_switch_tree *dst;
1538         struct dsa_chip_data *pdata;
1539         struct device_node *np;
1540         int err;
1541
1542         if (!ds->dev)
1543                 return -ENODEV;
1544
1545         pdata = ds->dev->platform_data;
1546         np = ds->dev->of_node;
1547
1548         if (!ds->num_ports)
1549                 return -EINVAL;
1550
1551         if (np) {
1552                 err = dsa_switch_parse_of(ds, np);
1553                 if (err)
1554                         dsa_switch_release_ports(ds);
1555         } else if (pdata) {
1556                 err = dsa_switch_parse(ds, pdata);
1557                 if (err)
1558                         dsa_switch_release_ports(ds);
1559         } else {
1560                 err = -ENODEV;
1561         }
1562
1563         if (err)
1564                 return err;
1565
1566         dst = ds->dst;
1567         dsa_tree_get(dst);
1568         err = dsa_tree_setup(dst);
1569         if (err) {
1570                 dsa_switch_release_ports(ds);
1571                 dsa_tree_put(dst);
1572         }
1573
1574         return err;
1575 }
1576
1577 int dsa_register_switch(struct dsa_switch *ds)
1578 {
1579         int err;
1580
1581         mutex_lock(&dsa2_mutex);
1582         err = dsa_switch_probe(ds);
1583         dsa_tree_put(ds->dst);
1584         mutex_unlock(&dsa2_mutex);
1585
1586         return err;
1587 }
1588 EXPORT_SYMBOL_GPL(dsa_register_switch);
1589
1590 static void dsa_switch_remove(struct dsa_switch *ds)
1591 {
1592         struct dsa_switch_tree *dst = ds->dst;
1593
1594         dsa_tree_teardown(dst);
1595         dsa_switch_release_ports(ds);
1596         dsa_tree_put(dst);
1597 }
1598
1599 void dsa_unregister_switch(struct dsa_switch *ds)
1600 {
1601         mutex_lock(&dsa2_mutex);
1602         dsa_switch_remove(ds);
1603         mutex_unlock(&dsa2_mutex);
1604 }
1605 EXPORT_SYMBOL_GPL(dsa_unregister_switch);
1606
1607 /* If the DSA master chooses to unregister its net_device on .shutdown, DSA is
1608  * blocking that operation from completion, due to the dev_hold taken inside
1609  * netdev_upper_dev_link. Unlink the DSA slave interfaces from being uppers of
1610  * the DSA master, so that the system can reboot successfully.
1611  */
1612 void dsa_switch_shutdown(struct dsa_switch *ds)
1613 {
1614         struct net_device *master, *slave_dev;
1615         LIST_HEAD(unregister_list);
1616         struct dsa_port *dp;
1617
1618         mutex_lock(&dsa2_mutex);
1619         rtnl_lock();
1620
1621         list_for_each_entry(dp, &ds->dst->ports, list) {
1622                 if (dp->ds != ds)
1623                         continue;
1624
1625                 if (!dsa_port_is_user(dp))
1626                         continue;
1627
1628                 master = dp->cpu_dp->master;
1629                 slave_dev = dp->slave;
1630
1631                 netdev_upper_dev_unlink(master, slave_dev);
1632                 /* Just unlinking ourselves as uppers of the master is not
1633                  * sufficient. When the master net device unregisters, that will
1634                  * also call dev_close, which we will catch as NETDEV_GOING_DOWN
1635                  * and trigger a dev_close on our own devices (dsa_slave_close).
1636                  * In turn, that will call dev_mc_unsync on the master's net
1637                  * device. If the master is also a DSA switch port, this will
1638                  * trigger dsa_slave_set_rx_mode which will call dev_mc_sync on
1639                  * its own master. Lockdep will complain about the fact that
1640                  * all cascaded masters have the same dsa_master_addr_list_lock_key,
1641                  * which it normally would not do if the cascaded masters would
1642                  * be in a proper upper/lower relationship, which we've just
1643                  * destroyed.
1644                  * To suppress the lockdep warnings, let's actually unregister
1645                  * the DSA slave interfaces too, to avoid the nonsensical
1646                  * multicast address list synchronization on shutdown.
1647                  */
1648                 unregister_netdevice_queue(slave_dev, &unregister_list);
1649         }
1650         unregister_netdevice_many(&unregister_list);
1651
1652         rtnl_unlock();
1653         mutex_unlock(&dsa2_mutex);
1654 }
1655 EXPORT_SYMBOL_GPL(dsa_switch_shutdown);