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