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