net/dsa/dsa2.c

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