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 LIST_HEAD(dsa_tree_list);
  22 static DEFINE_MUTEX(dsa2_mutex);
  23
  24 static const struct devlink_ops dsa_devlink_ops = {
  25 };
  26
  27 static struct dsa_switch_tree *dsa_tree_find(int index)
  28 {
  29         struct dsa_switch_tree *dst;
  30
  31         list_for_each_entry(dst, &dsa_tree_list, list)
  32                 if (dst->index == index)
  33                         return dst;
  34
  35         return NULL;
  36 }
  37
  38 static struct dsa_switch_tree *dsa_tree_alloc(int index)
  39 {
  40         struct dsa_switch_tree *dst;
  41
  42         dst = kzalloc(sizeof(*dst), GFP_KERNEL);
  43         if (!dst)
  44                 return NULL;
  45
  46         dst->index = index;
  47
  48         INIT_LIST_HEAD(&dst->rtable);
  49
  50         INIT_LIST_HEAD(&dst->ports);
  51
  52         INIT_LIST_HEAD(&dst->list);
  53         list_add_tail(&dst->list, &dsa_tree_list);
  54
  55         kref_init(&dst->refcount);
  56
  57         return dst;
  58 }
  59
  60 static void dsa_tree_free(struct dsa_switch_tree *dst)
  61 {
  62         list_del(&dst->list);
  63         kfree(dst);
  64 }
  65
  66 static struct dsa_switch_tree *dsa_tree_get(struct dsa_switch_tree *dst)
  67 {
  68         if (dst)
  69                 kref_get(&dst->refcount);
  70
  71         return dst;
  72 }
  73
  74 static struct dsa_switch_tree *dsa_tree_touch(int index)
  75 {
  76         struct dsa_switch_tree *dst;
  77
  78         dst = dsa_tree_find(index);
  79         if (dst)
  80                 return dsa_tree_get(dst);
  81         else
  82                 return dsa_tree_alloc(index);
  83 }
  84
  85 static void dsa_tree_release(struct kref *ref)
  86 {
  87         struct dsa_switch_tree *dst;
  88
  89         dst = container_of(ref, struct dsa_switch_tree, refcount);
  90
  91         dsa_tree_free(dst);
  92 }
  93
  94 static void dsa_tree_put(struct dsa_switch_tree *dst)
  95 {
  96         if (dst)
  97                 kref_put(&dst->refcount, dsa_tree_release);
  98 }
  99
 100 static bool dsa_port_is_dsa(struct dsa_port *port)
 101 {
 102         return port->type == DSA_PORT_TYPE_DSA;
 103 }
 104
 105 static bool dsa_port_is_cpu(struct dsa_port *port)
 106 {
 107         return port->type == DSA_PORT_TYPE_CPU;
 108 }
 109
 110 static bool dsa_port_is_user(struct dsa_port *dp)
 111 {
 112         return dp->type == DSA_PORT_TYPE_USER;
 113 }
 114
 115 static struct dsa_port *dsa_tree_find_port_by_node(struct dsa_switch_tree *dst,
 116                                                    struct device_node *dn)
 117 {
 118         struct dsa_port *dp;
 119
 120         list_for_each_entry(dp, &dst->ports, list)
 121                 if (dp->dn == dn)
 122                         return dp;
 123
 124         return NULL;
 125 }
 126
 127 static struct dsa_link *dsa_link_touch(struct dsa_port *dp,
 128                                        struct dsa_port *link_dp)
 129 {
 130         struct dsa_switch *ds = dp->ds;
 131         struct dsa_switch_tree *dst;
 132         struct dsa_link *dl;
 133
 134         dst = ds->dst;
 135
 136         list_for_each_entry(dl, &dst->rtable, list)
 137                 if (dl->dp == dp && dl->link_dp == link_dp)
 138                         return dl;
 139
 140         dl = kzalloc(sizeof(*dl), GFP_KERNEL);
 141         if (!dl)
 142                 return NULL;
 143
 144         dl->dp = dp;
 145         dl->link_dp = link_dp;
 146
 147         INIT_LIST_HEAD(&dl->list);
 148         list_add_tail(&dl->list, &dst->rtable);
 149
 150         return dl;
 151 }
 152
 153 static bool dsa_port_setup_routing_table(struct dsa_port *dp)
 154 {
 155         struct dsa_switch *ds = dp->ds;
 156         struct dsa_switch_tree *dst = ds->dst;
 157         struct device_node *dn = dp->dn;
 158         struct of_phandle_iterator it;
 159         struct dsa_port *link_dp;
 160         struct dsa_link *dl;
 161         int err;
 162
 163         of_for_each_phandle(&it, err, dn, "link", NULL, 0) {
 164                 link_dp = dsa_tree_find_port_by_node(dst, it.node);
 165                 if (!link_dp) {
 166                         of_node_put(it.node);
 167                         return false;
 168                 }
 169
 170                 dl = dsa_link_touch(dp, link_dp);
 171                 if (!dl) {
 172                         of_node_put(it.node);
 173                         return false;
 174                 }
 175         }
 176
 177         return true;
 178 }
 179
 180 static bool dsa_tree_setup_routing_table(struct dsa_switch_tree *dst)
 181 {
 182         bool complete = true;
 183         struct dsa_port *dp;
 184
 185         list_for_each_entry(dp, &dst->ports, list) {
 186                 if (dsa_port_is_dsa(dp)) {
 187                         complete = dsa_port_setup_routing_table(dp);
 188                         if (!complete)
 189                                 break;
 190                 }
 191         }
 192
 193         return complete;
 194 }
 195
 196 static struct dsa_port *dsa_tree_find_first_cpu(struct dsa_switch_tree *dst)
 197 {
 198         struct dsa_port *dp;
 199
 200         list_for_each_entry(dp, &dst->ports, list)
 201                 if (dsa_port_is_cpu(dp))
 202                         return dp;
 203
 204         return NULL;
 205 }
 206
 207 static int dsa_tree_setup_default_cpu(struct dsa_switch_tree *dst)
 208 {
 209         struct dsa_port *cpu_dp, *dp;
 210
 211         cpu_dp = dsa_tree_find_first_cpu(dst);
 212         if (!cpu_dp) {
 213                 pr_err("DSA: tree %d has no CPU port\n", dst->index);
 214                 return -EINVAL;
 215         }
 216
 217         /* Assign the default CPU port to all ports of the fabric */
 218         list_for_each_entry(dp, &dst->ports, list)
 219                 if (dsa_port_is_user(dp) || dsa_port_is_dsa(dp))
 220                         dp->cpu_dp = cpu_dp;
 221
 222         return 0;
 223 }
 224
 225 static void dsa_tree_teardown_default_cpu(struct dsa_switch_tree *dst)
 226 {
 227         struct dsa_port *dp;
 228
 229         list_for_each_entry(dp, &dst->ports, list)
 230                 if (dsa_port_is_user(dp) || dsa_port_is_dsa(dp))
 231                         dp->cpu_dp = NULL;
 232 }
 233
 234 static int dsa_port_setup(struct dsa_port *dp)
 235 {
 236         struct dsa_switch *ds = dp->ds;
 237         struct dsa_switch_tree *dst = ds->dst;
 238         const unsigned char *id = (const unsigned char *)&dst->index;
 239         const unsigned char len = sizeof(dst->index);
 240         struct devlink_port *dlp = &dp->devlink_port;
 241         bool dsa_port_link_registered = false;
 242         bool devlink_port_registered = false;
 243         struct devlink *dl = ds->devlink;
 244         bool dsa_port_enabled = false;
 245         int err = 0;
 246
 247         if (dp->setup)
 248                 return 0;
 249
 250         switch (dp->type) {
 251         case DSA_PORT_TYPE_UNUSED:
 252                 dsa_port_disable(dp);
 253                 break;
 254         case DSA_PORT_TYPE_CPU:
 255                 memset(dlp, 0, sizeof(*dlp));
 256                 devlink_port_attrs_set(dlp, DEVLINK_PORT_FLAVOUR_CPU,
 257                                        dp->index, false, 0, id, len);
 258                 err = devlink_port_register(dl, dlp, dp->index);
 259                 if (err)
 260                         break;
 261                 devlink_port_registered = true;
 262
 263                 err = dsa_port_link_register_of(dp);
 264                 if (err)
 265                         break;
 266                 dsa_port_link_registered = true;
 267
 268                 err = dsa_port_enable(dp, NULL);
 269                 if (err)
 270                         break;
 271                 dsa_port_enabled = true;
 272
 273                 break;
 274         case DSA_PORT_TYPE_DSA:
 275                 memset(dlp, 0, sizeof(*dlp));
 276                 devlink_port_attrs_set(dlp, DEVLINK_PORT_FLAVOUR_DSA,
 277                                        dp->index, false, 0, id, len);
 278                 err = devlink_port_register(dl, dlp, dp->index);
 279                 if (err)
 280                         break;
 281                 devlink_port_registered = true;
 282
 283                 err = dsa_port_link_register_of(dp);
 284                 if (err)
 285                         break;
 286                 dsa_port_link_registered = true;
 287
 288                 err = dsa_port_enable(dp, NULL);
 289                 if (err)
 290                         break;
 291                 dsa_port_enabled = true;
 292
 293                 break;
 294         case DSA_PORT_TYPE_USER:
 295                 memset(dlp, 0, sizeof(*dlp));
 296                 devlink_port_attrs_set(dlp, DEVLINK_PORT_FLAVOUR_PHYSICAL,
 297                                        dp->index, false, 0, id, len);
 298                 err = devlink_port_register(dl, dlp, dp->index);
 299                 if (err)
 300                         break;
 301                 devlink_port_registered = true;
 302
 303                 dp->mac = of_get_mac_address(dp->dn);
 304                 err = dsa_slave_create(dp);
 305                 if (err)
 306                         break;
 307
 308                 devlink_port_type_eth_set(dlp, dp->slave);
 309                 break;
 310         }
 311
 312         if (err && dsa_port_enabled)
 313                 dsa_port_disable(dp);
 314         if (err && dsa_port_link_registered)
 315                 dsa_port_link_unregister_of(dp);
 316         if (err && devlink_port_registered)
 317                 devlink_port_unregister(dlp);
 318         if (err)
 319                 return err;
 320
 321         dp->setup = true;
 322
 323         return 0;
 324 }
 325
 326 static void dsa_port_teardown(struct dsa_port *dp)
 327 {
 328         struct devlink_port *dlp = &dp->devlink_port;
 329
 330         if (!dp->setup)
 331                 return;
 332
 333         switch (dp->type) {
 334         case DSA_PORT_TYPE_UNUSED:
 335                 break;
 336         case DSA_PORT_TYPE_CPU:
 337                 dsa_port_disable(dp);
 338                 dsa_tag_driver_put(dp->tag_ops);
 339                 devlink_port_unregister(dlp);
 340                 dsa_port_link_unregister_of(dp);
 341                 break;
 342         case DSA_PORT_TYPE_DSA:
 343                 dsa_port_disable(dp);
 344                 devlink_port_unregister(dlp);
 345                 dsa_port_link_unregister_of(dp);
 346                 break;
 347         case DSA_PORT_TYPE_USER:
 348                 devlink_port_unregister(dlp);
 349                 if (dp->slave) {
 350                         dsa_slave_destroy(dp->slave);
 351                         dp->slave = NULL;
 352                 }
 353                 break;
 354         }
 355
 356         dp->setup = false;
 357 }
 358
 359 static int dsa_switch_setup(struct dsa_switch *ds)
 360 {
 361         struct dsa_devlink_priv *dl_priv;
 362         int err;
 363
 364         if (ds->setup)
 365                 return 0;
 366
 367         /* Initialize ds->phys_mii_mask before registering the slave MDIO bus
 368          * driver and before ops->setup() has run, since the switch drivers and
 369          * the slave MDIO bus driver rely on these values for probing PHY
 370          * devices or not
 371          */
 372         ds->phys_mii_mask |= dsa_user_ports(ds);
 373
 374         /* Add the switch to devlink before calling setup, so that setup can
 375          * add dpipe tables
 376          */
 377         ds->devlink = devlink_alloc(&dsa_devlink_ops, sizeof(*dl_priv));
 378         if (!ds->devlink)
 379                 return -ENOMEM;
 380         dl_priv = devlink_priv(ds->devlink);
 381         dl_priv->ds = ds;
 382
 383         err = devlink_register(ds->devlink, ds->dev);
 384         if (err)
 385                 goto free_devlink;
 386
 387         err = dsa_switch_register_notifier(ds);
 388         if (err)
 389                 goto unregister_devlink;
 390
 391         err = ds->ops->setup(ds);
 392         if (err < 0)
 393                 goto unregister_notifier;
 394
 395         devlink_params_publish(ds->devlink);
 396
 397         if (!ds->slave_mii_bus && ds->ops->phy_read) {
 398                 ds->slave_mii_bus = devm_mdiobus_alloc(ds->dev);
 399                 if (!ds->slave_mii_bus) {
 400                         err = -ENOMEM;
 401                         goto unregister_notifier;
 402                 }
 403
 404                 dsa_slave_mii_bus_init(ds);
 405
 406                 err = mdiobus_register(ds->slave_mii_bus);
 407                 if (err < 0)
 408                         goto unregister_notifier;
 409         }
 410
 411         ds->setup = true;
 412
 413         return 0;
 414
 415 unregister_notifier:
 416         dsa_switch_unregister_notifier(ds);
 417 unregister_devlink:
 418         devlink_unregister(ds->devlink);
 419 free_devlink:
 420         devlink_free(ds->devlink);
 421         ds->devlink = NULL;
 422
 423         return err;
 424 }
 425
 426 static void dsa_switch_teardown(struct dsa_switch *ds)
 427 {
 428         if (!ds->setup)
 429                 return;
 430
 431         if (ds->slave_mii_bus && ds->ops->phy_read)
 432                 mdiobus_unregister(ds->slave_mii_bus);
 433
 434         dsa_switch_unregister_notifier(ds);
 435
 436         if (ds->ops->teardown)
 437                 ds->ops->teardown(ds);
 438
 439         if (ds->devlink) {
 440                 devlink_unregister(ds->devlink);
 441                 devlink_free(ds->devlink);
 442                 ds->devlink = NULL;
 443         }
 444
 445         ds->setup = false;
 446 }
 447
 448 static int dsa_tree_setup_switches(struct dsa_switch_tree *dst)
 449 {
 450         struct dsa_port *dp;
 451         int err;
 452
 453         list_for_each_entry(dp, &dst->ports, list) {
 454                 err = dsa_switch_setup(dp->ds);
 455                 if (err)
 456                         goto teardown;
 457         }
 458
 459         list_for_each_entry(dp, &dst->ports, list) {
 460                 err = dsa_port_setup(dp);
 461                 if (err)
 462                         goto teardown;
 463         }
 464
 465         return 0;
 466
 467 teardown:
 468         list_for_each_entry(dp, &dst->ports, list)
 469                 dsa_port_teardown(dp);
 470
 471         list_for_each_entry(dp, &dst->ports, list)
 472                 dsa_switch_teardown(dp->ds);
 473
 474         return err;
 475 }
 476
 477 static void dsa_tree_teardown_switches(struct dsa_switch_tree *dst)
 478 {
 479         struct dsa_port *dp;
 480
 481         list_for_each_entry(dp, &dst->ports, list)
 482                 dsa_port_teardown(dp);
 483
 484         list_for_each_entry(dp, &dst->ports, list)
 485                 dsa_switch_teardown(dp->ds);
 486 }
 487
 488 static int dsa_tree_setup_master(struct dsa_switch_tree *dst)
 489 {
 490         struct dsa_port *dp;
 491         int err;
 492
 493         list_for_each_entry(dp, &dst->ports, list) {
 494                 if (dsa_port_is_cpu(dp)) {
 495                         err = dsa_master_setup(dp->master, dp);
 496                         if (err)
 497                                 return err;
 498                 }
 499         }
 500
 501         return 0;
 502 }
 503
 504 static void dsa_tree_teardown_master(struct dsa_switch_tree *dst)
 505 {
 506         struct dsa_port *dp;
 507
 508         list_for_each_entry(dp, &dst->ports, list)
 509                 if (dsa_port_is_cpu(dp))
 510                         dsa_master_teardown(dp->master);
 511 }
 512
 513 static int dsa_tree_setup(struct dsa_switch_tree *dst)
 514 {
 515         bool complete;
 516         int err;
 517
 518         if (dst->setup) {
 519                 pr_err("DSA: tree %d already setup! Disjoint trees?\n",
 520                        dst->index);
 521                 return -EEXIST;
 522         }
 523
 524         complete = dsa_tree_setup_routing_table(dst);
 525         if (!complete)
 526                 return 0;
 527
 528         err = dsa_tree_setup_default_cpu(dst);
 529         if (err)
 530                 return err;
 531
 532         err = dsa_tree_setup_switches(dst);
 533         if (err)
 534                 goto teardown_default_cpu;
 535
 536         err = dsa_tree_setup_master(dst);
 537         if (err)
 538                 goto teardown_switches;
 539
 540         dst->setup = true;
 541
 542         pr_info("DSA: tree %d setup\n", dst->index);
 543
 544         return 0;
 545
 546 teardown_switches:
 547         dsa_tree_teardown_switches(dst);
 548 teardown_default_cpu:
 549         dsa_tree_teardown_default_cpu(dst);
 550
 551         return err;
 552 }
 553
 554 static void dsa_tree_teardown(struct dsa_switch_tree *dst)
 555 {
 556         struct dsa_link *dl, *next;
 557
 558         if (!dst->setup)
 559                 return;
 560
 561         dsa_tree_teardown_master(dst);
 562
 563         dsa_tree_teardown_switches(dst);
 564
 565         dsa_tree_teardown_default_cpu(dst);
 566
 567         list_for_each_entry_safe(dl, next, &dst->rtable, list) {
 568                 list_del(&dl->list);
 569                 kfree(dl);
 570         }
 571
 572         pr_info("DSA: tree %d torn down\n", dst->index);
 573
 574         dst->setup = false;
 575 }
 576
 577 static struct dsa_port *dsa_port_touch(struct dsa_switch *ds, int index)
 578 {
 579         struct dsa_switch_tree *dst = ds->dst;
 580         struct dsa_port *dp;
 581
 582         list_for_each_entry(dp, &dst->ports, list)
 583                 if (dp->ds == ds && dp->index == index)
 584                         return dp;
 585
 586         dp = kzalloc(sizeof(*dp), GFP_KERNEL);
 587         if (!dp)
 588                 return NULL;
 589
 590         dp->ds = ds;
 591         dp->index = index;
 592
 593         INIT_LIST_HEAD(&dp->list);
 594         list_add_tail(&dp->list, &dst->ports);
 595
 596         return dp;
 597 }
 598
 599 static int dsa_port_parse_user(struct dsa_port *dp, const char *name)
 600 {
 601         if (!name)
 602                 name = "eth%d";
 603
 604         dp->type = DSA_PORT_TYPE_USER;
 605         dp->name = name;
 606
 607         return 0;
 608 }
 609
 610 static int dsa_port_parse_dsa(struct dsa_port *dp)
 611 {
 612         dp->type = DSA_PORT_TYPE_DSA;
 613
 614         return 0;
 615 }
 616
 617 static int dsa_port_parse_cpu(struct dsa_port *dp, struct net_device *master)
 618 {
 619         struct dsa_switch *ds = dp->ds;
 620         struct dsa_switch_tree *dst = ds->dst;
 621         const struct dsa_device_ops *tag_ops;
 622         enum dsa_tag_protocol tag_protocol;
 623
 624         tag_protocol = ds->ops->get_tag_protocol(ds, dp->index);
 625         tag_ops = dsa_tag_driver_get(tag_protocol);
 626         if (IS_ERR(tag_ops)) {
 627                 if (PTR_ERR(tag_ops) == -ENOPROTOOPT)
 628                         return -EPROBE_DEFER;
 629                 dev_warn(ds->dev, "No tagger for this switch\n");
 630                 return PTR_ERR(tag_ops);
 631         }
 632
 633         dp->type = DSA_PORT_TYPE_CPU;
 634         dp->filter = tag_ops->filter;
 635         dp->rcv = tag_ops->rcv;
 636         dp->tag_ops = tag_ops;
 637         dp->master = master;
 638         dp->dst = dst;
 639
 640         return 0;
 641 }
 642
 643 static int dsa_port_parse_of(struct dsa_port *dp, struct device_node *dn)
 644 {
 645         struct device_node *ethernet = of_parse_phandle(dn, "ethernet", 0);
 646         const char *name = of_get_property(dn, "label", NULL);
 647         bool link = of_property_read_bool(dn, "link");
 648
 649         dp->dn = dn;
 650
 651         if (ethernet) {
 652                 struct net_device *master;
 653
 654                 master = of_find_net_device_by_node(ethernet);
 655                 if (!master)
 656                         return -EPROBE_DEFER;
 657
 658                 return dsa_port_parse_cpu(dp, master);
 659         }
 660
 661         if (link)
 662                 return dsa_port_parse_dsa(dp);
 663
 664         return dsa_port_parse_user(dp, name);
 665 }
 666
 667 static int dsa_switch_parse_ports_of(struct dsa_switch *ds,
 668                                      struct device_node *dn)
 669 {
 670         struct device_node *ports, *port;
 671         struct dsa_port *dp;
 672         int err = 0;
 673         u32 reg;
 674
 675         ports = of_get_child_by_name(dn, "ports");
 676         if (!ports) {
 677                 dev_err(ds->dev, "no ports child node found\n");
 678                 return -EINVAL;
 679         }
 680
 681         for_each_available_child_of_node(ports, port) {
 682                 err = of_property_read_u32(port, "reg", &reg);
 683                 if (err)
 684                         goto out_put_node;
 685
 686                 if (reg >= ds->num_ports) {
 687                         err = -EINVAL;
 688                         goto out_put_node;
 689                 }
 690
 691                 dp = dsa_to_port(ds, reg);
 692
 693                 err = dsa_port_parse_of(dp, port);
 694                 if (err)
 695                         goto out_put_node;
 696         }
 697
 698 out_put_node:
 699         of_node_put(ports);
 700         return err;
 701 }
 702
 703 static int dsa_switch_parse_member_of(struct dsa_switch *ds,
 704                                       struct device_node *dn)
 705 {
 706         u32 m[2] = { 0, 0 };
 707         int sz;
 708
 709         /* Don't error out if this optional property isn't found */
 710         sz = of_property_read_variable_u32_array(dn, "dsa,member", m, 2, 2);
 711         if (sz < 0 && sz != -EINVAL)
 712                 return sz;
 713
 714         ds->index = m[1];
 715
 716         ds->dst = dsa_tree_touch(m[0]);
 717         if (!ds->dst)
 718                 return -ENOMEM;
 719
 720         return 0;
 721 }
 722
 723 static int dsa_switch_touch_ports(struct dsa_switch *ds)
 724 {
 725         struct dsa_port *dp;
 726         int port;
 727
 728         for (port = 0; port < ds->num_ports; port++) {
 729                 dp = dsa_port_touch(ds, port);
 730                 if (!dp)
 731                         return -ENOMEM;
 732         }
 733
 734         return 0;
 735 }
 736
 737 static int dsa_switch_parse_of(struct dsa_switch *ds, struct device_node *dn)
 738 {
 739         int err;
 740
 741         err = dsa_switch_parse_member_of(ds, dn);
 742         if (err)
 743                 return err;
 744
 745         err = dsa_switch_touch_ports(ds);
 746         if (err)
 747                 return err;
 748
 749         return dsa_switch_parse_ports_of(ds, dn);
 750 }
 751
 752 static int dsa_port_parse(struct dsa_port *dp, const char *name,
 753                           struct device *dev)
 754 {
 755         if (!strcmp(name, "cpu")) {
 756                 struct net_device *master;
 757
 758                 master = dsa_dev_to_net_device(dev);
 759                 if (!master)
 760                         return -EPROBE_DEFER;
 761
 762                 dev_put(master);
 763
 764                 return dsa_port_parse_cpu(dp, master);
 765         }
 766
 767         if (!strcmp(name, "dsa"))
 768                 return dsa_port_parse_dsa(dp);
 769
 770         return dsa_port_parse_user(dp, name);
 771 }
 772
 773 static int dsa_switch_parse_ports(struct dsa_switch *ds,
 774                                   struct dsa_chip_data *cd)
 775 {
 776         bool valid_name_found = false;
 777         struct dsa_port *dp;
 778         struct device *dev;
 779         const char *name;
 780         unsigned int i;
 781         int err;
 782
 783         for (i = 0; i < DSA_MAX_PORTS; i++) {
 784                 name = cd->port_names[i];
 785                 dev = cd->netdev[i];
 786                 dp = dsa_to_port(ds, i);
 787
 788                 if (!name)
 789                         continue;
 790
 791                 err = dsa_port_parse(dp, name, dev);
 792                 if (err)
 793                         return err;
 794
 795                 valid_name_found = true;
 796         }
 797
 798         if (!valid_name_found && i == DSA_MAX_PORTS)
 799                 return -EINVAL;
 800
 801         return 0;
 802 }
 803
 804 static int dsa_switch_parse(struct dsa_switch *ds, struct dsa_chip_data *cd)
 805 {
 806         int err;
 807
 808         ds->cd = cd;
 809
 810         /* We don't support interconnected switches nor multiple trees via
 811          * platform data, so this is the unique switch of the tree.
 812          */
 813         ds->index = 0;
 814         ds->dst = dsa_tree_touch(0);
 815         if (!ds->dst)
 816                 return -ENOMEM;
 817
 818         err = dsa_switch_touch_ports(ds);
 819         if (err)
 820                 return err;
 821
 822         return dsa_switch_parse_ports(ds, cd);
 823 }
 824
 825 static int dsa_switch_probe(struct dsa_switch *ds)
 826 {
 827         struct dsa_switch_tree *dst;
 828         struct dsa_chip_data *pdata;
 829         struct device_node *np;
 830         int err;
 831
 832         if (!ds->dev)
 833                 return -ENODEV;
 834
 835         pdata = ds->dev->platform_data;
 836         np = ds->dev->of_node;
 837
 838         if (!ds->num_ports)
 839                 return -EINVAL;
 840
 841         if (np)
 842                 err = dsa_switch_parse_of(ds, np);
 843         else if (pdata)
 844                 err = dsa_switch_parse(ds, pdata);
 845         else
 846                 err = -ENODEV;
 847
 848         if (err)
 849                 return err;
 850
 851         dst = ds->dst;
 852         dsa_tree_get(dst);
 853         err = dsa_tree_setup(dst);
 854         if (err)
 855                 dsa_tree_put(dst);
 856
 857         return err;
 858 }
 859
 860 int dsa_register_switch(struct dsa_switch *ds)
 861 {
 862         int err;
 863
 864         mutex_lock(&dsa2_mutex);
 865         err = dsa_switch_probe(ds);
 866         dsa_tree_put(ds->dst);
 867         mutex_unlock(&dsa2_mutex);
 868
 869         return err;
 870 }
 871 EXPORT_SYMBOL_GPL(dsa_register_switch);
 872
 873 static void dsa_switch_remove(struct dsa_switch *ds)
 874 {
 875         struct dsa_switch_tree *dst = ds->dst;
 876         struct dsa_port *dp, *next;
 877
 878         dsa_tree_teardown(dst);
 879
 880         list_for_each_entry_safe(dp, next, &dst->ports, list) {
 881                 list_del(&dp->list);
 882                 kfree(dp);
 883         }
 884
 885         dsa_tree_put(dst);
 886 }
 887
 888 void dsa_unregister_switch(struct dsa_switch *ds)
 889 {
 890         mutex_lock(&dsa2_mutex);
 891         dsa_switch_remove(ds);
 892         mutex_unlock(&dsa2_mutex);
 893 }
 894 EXPORT_SYMBOL_GPL(dsa_unregister_switch);