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