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;
 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                         return err;
 302                 }
 303                 break;
 304         case DSA_PORT_TYPE_DSA:
 305                 err = dsa_port_link_register_of(dp);
 306                 if (err) {
 307                         dev_err(ds->dev, "failed to setup link for port %d.%d\n",
 308                                 ds->index, dp->index);
 309                         return err;
 310                 }
 311                 break;
 312         case DSA_PORT_TYPE_USER:
 313                 err = dsa_slave_create(dp);
 314                 if (err)
 315                         dev_err(ds->dev, "failed to create slave for port %d.%d\n",
 316                                 ds->index, dp->index);
 317                 else
 318                         devlink_port_type_eth_set(&dp->devlink_port, dp->slave);
 319                 break;
 320         }
 321
 322         return 0;
 323 }
 324
 325 static void dsa_port_teardown(struct dsa_port *dp)
 326 {
 327         if (dp->type != DSA_PORT_TYPE_UNUSED)
 328                 devlink_port_unregister(&dp->devlink_port);
 329
 330         switch (dp->type) {
 331         case DSA_PORT_TYPE_UNUSED:
 332                 break;
 333         case DSA_PORT_TYPE_CPU:
 334                 dsa_tag_driver_put(dp->tag_ops);
 335                 /* fall-through */
 336         case DSA_PORT_TYPE_DSA:
 337                 dsa_port_link_unregister_of(dp);
 338                 break;
 339         case DSA_PORT_TYPE_USER:
 340                 if (dp->slave) {
 341                         dsa_slave_destroy(dp->slave);
 342                         dp->slave = NULL;
 343                 }
 344                 break;
 345         }
 346 }
 347
 348 static int dsa_switch_setup(struct dsa_switch *ds)
 349 {
 350         int err;
 351
 352         /* Initialize ds->phys_mii_mask before registering the slave MDIO bus
 353          * driver and before ops->setup() has run, since the switch drivers and
 354          * the slave MDIO bus driver rely on these values for probing PHY
 355          * devices or not
 356          */
 357         ds->phys_mii_mask |= dsa_user_ports(ds);
 358
 359         /* Add the switch to devlink before calling setup, so that setup can
 360          * add dpipe tables
 361          */
 362         ds->devlink = devlink_alloc(&dsa_devlink_ops, 0);
 363         if (!ds->devlink)
 364                 return -ENOMEM;
 365
 366         err = devlink_register(ds->devlink, ds->dev);
 367         if (err)
 368                 return err;
 369
 370         err = dsa_switch_register_notifier(ds);
 371         if (err)
 372                 return err;
 373
 374         err = ds->ops->setup(ds);
 375         if (err < 0)
 376                 return err;
 377
 378         if (!ds->slave_mii_bus && ds->ops->phy_read) {
 379                 ds->slave_mii_bus = devm_mdiobus_alloc(ds->dev);
 380                 if (!ds->slave_mii_bus)
 381                         return -ENOMEM;
 382
 383                 dsa_slave_mii_bus_init(ds);
 384
 385                 err = mdiobus_register(ds->slave_mii_bus);
 386                 if (err < 0)
 387                         return err;
 388         }
 389
 390         return 0;
 391 }
 392
 393 static void dsa_switch_teardown(struct dsa_switch *ds)
 394 {
 395         if (ds->slave_mii_bus && ds->ops->phy_read)
 396                 mdiobus_unregister(ds->slave_mii_bus);
 397
 398         dsa_switch_unregister_notifier(ds);
 399
 400         if (ds->devlink) {
 401                 devlink_unregister(ds->devlink);
 402                 devlink_free(ds->devlink);
 403                 ds->devlink = NULL;
 404         }
 405
 406 }
 407
 408 static int dsa_tree_setup_switches(struct dsa_switch_tree *dst)
 409 {
 410         struct dsa_switch *ds;
 411         struct dsa_port *dp;
 412         int device, port;
 413         int err;
 414
 415         for (device = 0; device < DSA_MAX_SWITCHES; device++) {
 416                 ds = dst->ds[device];
 417                 if (!ds)
 418                         continue;
 419
 420                 err = dsa_switch_setup(ds);
 421                 if (err)
 422                         return err;
 423
 424                 for (port = 0; port < ds->num_ports; port++) {
 425                         dp = &ds->ports[port];
 426
 427                         err = dsa_port_setup(dp);
 428                         if (err)
 429                                 return err;
 430                 }
 431         }
 432
 433         return 0;
 434 }
 435
 436 static void dsa_tree_teardown_switches(struct dsa_switch_tree *dst)
 437 {
 438         struct dsa_switch *ds;
 439         struct dsa_port *dp;
 440         int device, port;
 441
 442         for (device = 0; device < DSA_MAX_SWITCHES; device++) {
 443                 ds = dst->ds[device];
 444                 if (!ds)
 445                         continue;
 446
 447                 for (port = 0; port < ds->num_ports; port++) {
 448                         dp = &ds->ports[port];
 449
 450                         dsa_port_teardown(dp);
 451                 }
 452
 453                 dsa_switch_teardown(ds);
 454         }
 455 }
 456
 457 static int dsa_tree_setup_master(struct dsa_switch_tree *dst)
 458 {
 459         struct dsa_port *cpu_dp = dst->cpu_dp;
 460         struct net_device *master = cpu_dp->master;
 461
 462         /* DSA currently supports a single pair of CPU port and master device */
 463         return dsa_master_setup(master, cpu_dp);
 464 }
 465
 466 static void dsa_tree_teardown_master(struct dsa_switch_tree *dst)
 467 {
 468         struct dsa_port *cpu_dp = dst->cpu_dp;
 469         struct net_device *master = cpu_dp->master;
 470
 471         return dsa_master_teardown(master);
 472 }
 473
 474 static int dsa_tree_setup(struct dsa_switch_tree *dst)
 475 {
 476         bool complete;
 477         int err;
 478
 479         if (dst->setup) {
 480                 pr_err("DSA: tree %d already setup! Disjoint trees?\n",
 481                        dst->index);
 482                 return -EEXIST;
 483         }
 484
 485         complete = dsa_tree_setup_routing_table(dst);
 486         if (!complete)
 487                 return 0;
 488
 489         err = dsa_tree_setup_default_cpu(dst);
 490         if (err)
 491                 return err;
 492
 493         err = dsa_tree_setup_switches(dst);
 494         if (err)
 495                 return err;
 496
 497         err = dsa_tree_setup_master(dst);
 498         if (err)
 499                 return err;
 500
 501         dst->setup = true;
 502
 503         pr_info("DSA: tree %d setup\n", dst->index);
 504
 505         return 0;
 506 }
 507
 508 static void dsa_tree_teardown(struct dsa_switch_tree *dst)
 509 {
 510         if (!dst->setup)
 511                 return;
 512
 513         dsa_tree_teardown_master(dst);
 514
 515         dsa_tree_teardown_switches(dst);
 516
 517         dsa_tree_teardown_default_cpu(dst);
 518
 519         pr_info("DSA: tree %d torn down\n", dst->index);
 520
 521         dst->setup = false;
 522 }
 523
 524 static void dsa_tree_remove_switch(struct dsa_switch_tree *dst,
 525                                    unsigned int index)
 526 {
 527         dsa_tree_teardown(dst);
 528
 529         dst->ds[index] = NULL;
 530         dsa_tree_put(dst);
 531 }
 532
 533 static int dsa_tree_add_switch(struct dsa_switch_tree *dst,
 534                                struct dsa_switch *ds)
 535 {
 536         unsigned int index = ds->index;
 537         int err;
 538
 539         if (dst->ds[index])
 540                 return -EBUSY;
 541
 542         dsa_tree_get(dst);
 543         dst->ds[index] = ds;
 544
 545         err = dsa_tree_setup(dst);
 546         if (err)
 547                 dsa_tree_remove_switch(dst, index);
 548
 549         return err;
 550 }
 551
 552 static int dsa_port_parse_user(struct dsa_port *dp, const char *name)
 553 {
 554         if (!name)
 555                 name = "eth%d";
 556
 557         dp->type = DSA_PORT_TYPE_USER;
 558         dp->name = name;
 559
 560         return 0;
 561 }
 562
 563 static int dsa_port_parse_dsa(struct dsa_port *dp)
 564 {
 565         dp->type = DSA_PORT_TYPE_DSA;
 566
 567         return 0;
 568 }
 569
 570 static int dsa_port_parse_cpu(struct dsa_port *dp, struct net_device *master)
 571 {
 572         struct dsa_switch *ds = dp->ds;
 573         struct dsa_switch_tree *dst = ds->dst;
 574         const struct dsa_device_ops *tag_ops;
 575         enum dsa_tag_protocol tag_protocol;
 576
 577         tag_protocol = ds->ops->get_tag_protocol(ds, dp->index);
 578         tag_ops = dsa_tag_driver_get(tag_protocol);
 579         if (IS_ERR(tag_ops)) {
 580                 dev_warn(ds->dev, "No tagger for this switch\n");
 581                 return PTR_ERR(tag_ops);
 582         }
 583
 584         dp->type = DSA_PORT_TYPE_CPU;
 585         dp->filter = tag_ops->filter;
 586         dp->rcv = tag_ops->rcv;
 587         dp->tag_ops = tag_ops;
 588         dp->master = master;
 589         dp->dst = dst;
 590
 591         return 0;
 592 }
 593
 594 static int dsa_port_parse_of(struct dsa_port *dp, struct device_node *dn)
 595 {
 596         struct device_node *ethernet = of_parse_phandle(dn, "ethernet", 0);
 597         const char *name = of_get_property(dn, "label", NULL);
 598         bool link = of_property_read_bool(dn, "link");
 599
 600         dp->dn = dn;
 601
 602         if (ethernet) {
 603                 struct net_device *master;
 604
 605                 master = of_find_net_device_by_node(ethernet);
 606                 if (!master)
 607                         return -EPROBE_DEFER;
 608
 609                 return dsa_port_parse_cpu(dp, master);
 610         }
 611
 612         if (link)
 613                 return dsa_port_parse_dsa(dp);
 614
 615         return dsa_port_parse_user(dp, name);
 616 }
 617
 618 static int dsa_switch_parse_ports_of(struct dsa_switch *ds,
 619                                      struct device_node *dn)
 620 {
 621         struct device_node *ports, *port;
 622         struct dsa_port *dp;
 623         int err = 0;
 624         u32 reg;
 625
 626         ports = of_get_child_by_name(dn, "ports");
 627         if (!ports) {
 628                 dev_err(ds->dev, "no ports child node found\n");
 629                 return -EINVAL;
 630         }
 631
 632         for_each_available_child_of_node(ports, port) {
 633                 err = of_property_read_u32(port, "reg", &reg);
 634                 if (err)
 635                         goto out_put_node;
 636
 637                 if (reg >= ds->num_ports) {
 638                         err = -EINVAL;
 639                         goto out_put_node;
 640                 }
 641
 642                 dp = &ds->ports[reg];
 643
 644                 err = dsa_port_parse_of(dp, port);
 645                 if (err)
 646                         goto out_put_node;
 647         }
 648
 649 out_put_node:
 650         of_node_put(ports);
 651         return err;
 652 }
 653
 654 static int dsa_switch_parse_member_of(struct dsa_switch *ds,
 655                                       struct device_node *dn)
 656 {
 657         u32 m[2] = { 0, 0 };
 658         int sz;
 659
 660         /* Don't error out if this optional property isn't found */
 661         sz = of_property_read_variable_u32_array(dn, "dsa,member", m, 2, 2);
 662         if (sz < 0 && sz != -EINVAL)
 663                 return sz;
 664
 665         ds->index = m[1];
 666         if (ds->index >= DSA_MAX_SWITCHES)
 667                 return -EINVAL;
 668
 669         ds->dst = dsa_tree_touch(m[0]);
 670         if (!ds->dst)
 671                 return -ENOMEM;
 672
 673         return 0;
 674 }
 675
 676 static int dsa_switch_parse_of(struct dsa_switch *ds, struct device_node *dn)
 677 {
 678         int err;
 679
 680         err = dsa_switch_parse_member_of(ds, dn);
 681         if (err)
 682                 return err;
 683
 684         return dsa_switch_parse_ports_of(ds, dn);
 685 }
 686
 687 static int dsa_port_parse(struct dsa_port *dp, const char *name,
 688                           struct device *dev)
 689 {
 690         if (!strcmp(name, "cpu")) {
 691                 struct net_device *master;
 692
 693                 master = dsa_dev_to_net_device(dev);
 694                 if (!master)
 695                         return -EPROBE_DEFER;
 696
 697                 dev_put(master);
 698
 699                 return dsa_port_parse_cpu(dp, master);
 700         }
 701
 702         if (!strcmp(name, "dsa"))
 703                 return dsa_port_parse_dsa(dp);
 704
 705         return dsa_port_parse_user(dp, name);
 706 }
 707
 708 static int dsa_switch_parse_ports(struct dsa_switch *ds,
 709                                   struct dsa_chip_data *cd)
 710 {
 711         bool valid_name_found = false;
 712         struct dsa_port *dp;
 713         struct device *dev;
 714         const char *name;
 715         unsigned int i;
 716         int err;
 717
 718         for (i = 0; i < DSA_MAX_PORTS; i++) {
 719                 name = cd->port_names[i];
 720                 dev = cd->netdev[i];
 721                 dp = &ds->ports[i];
 722
 723                 if (!name)
 724                         continue;
 725
 726                 err = dsa_port_parse(dp, name, dev);
 727                 if (err)
 728                         return err;
 729
 730                 valid_name_found = true;
 731         }
 732
 733         if (!valid_name_found && i == DSA_MAX_PORTS)
 734                 return -EINVAL;
 735
 736         return 0;
 737 }
 738
 739 static int dsa_switch_parse(struct dsa_switch *ds, struct dsa_chip_data *cd)
 740 {
 741         ds->cd = cd;
 742
 743         /* We don't support interconnected switches nor multiple trees via
 744          * platform data, so this is the unique switch of the tree.
 745          */
 746         ds->index = 0;
 747         ds->dst = dsa_tree_touch(0);
 748         if (!ds->dst)
 749                 return -ENOMEM;
 750
 751         return dsa_switch_parse_ports(ds, cd);
 752 }
 753
 754 static int dsa_switch_add(struct dsa_switch *ds)
 755 {
 756         struct dsa_switch_tree *dst = ds->dst;
 757
 758         return dsa_tree_add_switch(dst, ds);
 759 }
 760
 761 static int dsa_switch_probe(struct dsa_switch *ds)
 762 {
 763         struct dsa_chip_data *pdata = ds->dev->platform_data;
 764         struct device_node *np = ds->dev->of_node;
 765         int err;
 766
 767         if (np)
 768                 err = dsa_switch_parse_of(ds, np);
 769         else if (pdata)
 770                 err = dsa_switch_parse(ds, pdata);
 771         else
 772                 err = -ENODEV;
 773
 774         if (err)
 775                 return err;
 776
 777         return dsa_switch_add(ds);
 778 }
 779
 780 struct dsa_switch *dsa_switch_alloc(struct device *dev, size_t n)
 781 {
 782         struct dsa_switch *ds;
 783         int i;
 784
 785         ds = devm_kzalloc(dev, struct_size(ds, ports, n), GFP_KERNEL);
 786         if (!ds)
 787                 return NULL;
 788
 789         /* We avoid allocating memory outside dsa_switch
 790          * if it is not needed.
 791          */
 792         if (n <= sizeof(ds->_bitmap) * 8) {
 793                 ds->bitmap = &ds->_bitmap;
 794         } else {
 795                 ds->bitmap = devm_kcalloc(dev,
 796                                           BITS_TO_LONGS(n),
 797                                           sizeof(unsigned long),
 798                                           GFP_KERNEL);
 799                 if (unlikely(!ds->bitmap))
 800                         return NULL;
 801         }
 802
 803         ds->dev = dev;
 804         ds->num_ports = n;
 805
 806         for (i = 0; i < ds->num_ports; ++i) {
 807                 ds->ports[i].index = i;
 808                 ds->ports[i].ds = ds;
 809         }
 810
 811         return ds;
 812 }
 813 EXPORT_SYMBOL_GPL(dsa_switch_alloc);
 814
 815 int dsa_register_switch(struct dsa_switch *ds)
 816 {
 817         int err;
 818
 819         mutex_lock(&dsa2_mutex);
 820         err = dsa_switch_probe(ds);
 821         dsa_tree_put(ds->dst);
 822         mutex_unlock(&dsa2_mutex);
 823
 824         return err;
 825 }
 826 EXPORT_SYMBOL_GPL(dsa_register_switch);
 827
 828 static void dsa_switch_remove(struct dsa_switch *ds)
 829 {
 830         struct dsa_switch_tree *dst = ds->dst;
 831         unsigned int index = ds->index;
 832
 833         dsa_tree_remove_switch(dst, index);
 834 }
 835
 836 void dsa_unregister_switch(struct dsa_switch *ds)
 837 {
 838         mutex_lock(&dsa2_mutex);
 839         dsa_switch_remove(ds);
 840         mutex_unlock(&dsa2_mutex);
 841 }
 842 EXPORT_SYMBOL_GPL(dsa_unregister_switch);