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