net/dsa/dsa2.c

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