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_switch_trees);
  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_get_dst(u32 tree)
  31 {
  32         struct dsa_switch_tree *dst;
  33
  34         list_for_each_entry(dst, &dsa_switch_trees, list)
  35                 if (dst->tree == tree) {
  36                         kref_get(&dst->refcount);
  37                         return dst;
  38                 }
  39         return NULL;
  40 }
  41
  42 static void dsa_free_dst(struct kref *ref)
  43 {
  44         struct dsa_switch_tree *dst = container_of(ref, struct dsa_switch_tree,
  45                                                    refcount);
  46
  47         list_del(&dst->list);
  48         kfree(dst);
  49 }
  50
  51 static void dsa_put_dst(struct dsa_switch_tree *dst)
  52 {
  53         kref_put(&dst->refcount, dsa_free_dst);
  54 }
  55
  56 static struct dsa_switch_tree *dsa_add_dst(u32 tree)
  57 {
  58         struct dsa_switch_tree *dst;
  59
  60         dst = kzalloc(sizeof(*dst), GFP_KERNEL);
  61         if (!dst)
  62                 return NULL;
  63         dst->tree = tree;
  64         INIT_LIST_HEAD(&dst->list);
  65         list_add_tail(&dsa_switch_trees, &dst->list);
  66         kref_init(&dst->refcount);
  67
  68         return dst;
  69 }
  70
  71 static void dsa_dst_add_ds(struct dsa_switch_tree *dst,
  72                            struct dsa_switch *ds, u32 index)
  73 {
  74         kref_get(&dst->refcount);
  75         dst->ds[index] = ds;
  76 }
  77
  78 static void dsa_dst_del_ds(struct dsa_switch_tree *dst,
  79                            struct dsa_switch *ds, u32 index)
  80 {
  81         dst->ds[index] = NULL;
  82         kref_put(&dst->refcount, dsa_free_dst);
  83 }
  84
  85 /* For platform data configurations, we need to have a valid name argument to
  86  * differentiate a disabled port from an enabled one
  87  */
  88 static bool dsa_port_is_valid(struct dsa_port *port)
  89 {
  90         return !!(port->dn || port->name);
  91 }
  92
  93 static bool dsa_port_is_dsa(struct dsa_port *port)
  94 {
  95         if (port->name && !strcmp(port->name, "dsa"))
  96                 return true;
  97         else
  98                 return !!of_parse_phandle(port->dn, "link", 0);
  99 }
 100
 101 static bool dsa_port_is_cpu(struct dsa_port *port)
 102 {
 103         if (port->name && !strcmp(port->name, "cpu"))
 104                 return true;
 105         else
 106                 return !!of_parse_phandle(port->dn, "ethernet", 0);
 107 }
 108
 109 static bool dsa_ds_find_port_dn(struct dsa_switch *ds,
 110                                 struct device_node *port)
 111 {
 112         u32 index;
 113
 114         for (index = 0; index < ds->num_ports; index++)
 115                 if (ds->ports[index].dn == port)
 116                         return true;
 117         return false;
 118 }
 119
 120 static struct dsa_switch *dsa_dst_find_port_dn(struct dsa_switch_tree *dst,
 121                                                struct device_node *port)
 122 {
 123         struct dsa_switch *ds;
 124         u32 index;
 125
 126         for (index = 0; index < DSA_MAX_SWITCHES; index++) {
 127                 ds = dst->ds[index];
 128                 if (!ds)
 129                         continue;
 130
 131                 if (dsa_ds_find_port_dn(ds, port))
 132                         return ds;
 133         }
 134
 135         return NULL;
 136 }
 137
 138 static int dsa_port_complete(struct dsa_switch_tree *dst,
 139                              struct dsa_switch *src_ds,
 140                              struct dsa_port *port,
 141                              u32 src_port)
 142 {
 143         struct device_node *link;
 144         int index;
 145         struct dsa_switch *dst_ds;
 146
 147         for (index = 0;; index++) {
 148                 link = of_parse_phandle(port->dn, "link", index);
 149                 if (!link)
 150                         break;
 151
 152                 dst_ds = dsa_dst_find_port_dn(dst, link);
 153                 of_node_put(link);
 154
 155                 if (!dst_ds)
 156                         return 1;
 157
 158                 src_ds->rtable[dst_ds->index] = src_port;
 159         }
 160
 161         return 0;
 162 }
 163
 164 /* A switch is complete if all the DSA ports phandles point to ports
 165  * known in the tree. A return value of 1 means the tree is not
 166  * complete. This is not an error condition. A value of 0 is
 167  * success.
 168  */
 169 static int dsa_ds_complete(struct dsa_switch_tree *dst, struct dsa_switch *ds)
 170 {
 171         struct dsa_port *port;
 172         u32 index;
 173         int err;
 174
 175         for (index = 0; index < ds->num_ports; index++) {
 176                 port = &ds->ports[index];
 177                 if (!dsa_port_is_valid(port))
 178                         continue;
 179
 180                 if (!dsa_port_is_dsa(port))
 181                         continue;
 182
 183                 err = dsa_port_complete(dst, ds, port, index);
 184                 if (err != 0)
 185                         return err;
 186
 187                 ds->dsa_port_mask |= BIT(index);
 188         }
 189
 190         return 0;
 191 }
 192
 193 /* A tree is complete if all the DSA ports phandles point to ports
 194  * known in the tree. A return value of 1 means the tree is not
 195  * complete. This is not an error condition. A value of 0 is
 196  * success.
 197  */
 198 static int dsa_dst_complete(struct dsa_switch_tree *dst)
 199 {
 200         struct dsa_switch *ds;
 201         u32 index;
 202         int err;
 203
 204         for (index = 0; index < DSA_MAX_SWITCHES; index++) {
 205                 ds = dst->ds[index];
 206                 if (!ds)
 207                         continue;
 208
 209                 err = dsa_ds_complete(dst, ds);
 210                 if (err != 0)
 211                         return err;
 212         }
 213
 214         return 0;
 215 }
 216
 217 static int dsa_dsa_port_apply(struct dsa_port *port)
 218 {
 219         struct dsa_switch *ds = port->ds;
 220         int err;
 221
 222         err = dsa_cpu_dsa_setup(ds, ds->dev, port, port->index);
 223         if (err) {
 224                 dev_warn(ds->dev, "Failed to setup dsa port %d: %d\n",
 225                          port->index, err);
 226                 return err;
 227         }
 228
 229         memset(&port->devlink_port, 0, sizeof(port->devlink_port));
 230
 231         return devlink_port_register(ds->devlink, &port->devlink_port,
 232                                      port->index);
 233 }
 234
 235 static void dsa_dsa_port_unapply(struct dsa_port *port)
 236 {
 237         devlink_port_unregister(&port->devlink_port);
 238         dsa_cpu_dsa_destroy(port);
 239 }
 240
 241 static int dsa_cpu_port_apply(struct dsa_port *port)
 242 {
 243         struct dsa_switch *ds = port->ds;
 244         int err;
 245
 246         err = dsa_cpu_dsa_setup(ds, ds->dev, port, port->index);
 247         if (err) {
 248                 dev_warn(ds->dev, "Failed to setup cpu port %d: %d\n",
 249                          port->index, err);
 250                 return err;
 251         }
 252
 253         memset(&port->devlink_port, 0, sizeof(port->devlink_port));
 254         err = devlink_port_register(ds->devlink, &port->devlink_port,
 255                                     port->index);
 256         return err;
 257 }
 258
 259 static void dsa_cpu_port_unapply(struct dsa_port *port)
 260 {
 261         devlink_port_unregister(&port->devlink_port);
 262         dsa_cpu_dsa_destroy(port);
 263         port->ds->cpu_port_mask &= ~BIT(port->index);
 264
 265 }
 266
 267 static int dsa_user_port_apply(struct dsa_port *port)
 268 {
 269         struct dsa_switch *ds = port->ds;
 270         const char *name = port->name;
 271         int err;
 272
 273         if (port->dn)
 274                 name = of_get_property(port->dn, "label", NULL);
 275         if (!name)
 276                 name = "eth%d";
 277
 278         err = dsa_slave_create(ds, ds->dev, port->index, name);
 279         if (err) {
 280                 dev_warn(ds->dev, "Failed to create slave %d: %d\n",
 281                          port->index, err);
 282                 port->netdev = NULL;
 283                 return err;
 284         }
 285
 286         memset(&port->devlink_port, 0, sizeof(port->devlink_port));
 287         err = devlink_port_register(ds->devlink, &port->devlink_port,
 288                                     port->index);
 289         if (err)
 290                 return err;
 291
 292         devlink_port_type_eth_set(&port->devlink_port, port->netdev);
 293
 294         return 0;
 295 }
 296
 297 static void dsa_user_port_unapply(struct dsa_port *port)
 298 {
 299         devlink_port_unregister(&port->devlink_port);
 300         if (port->netdev) {
 301                 dsa_slave_destroy(port->netdev);
 302                 port->netdev = NULL;
 303                 port->ds->enabled_port_mask &= ~(1 << port->index);
 304         }
 305 }
 306
 307 static int dsa_ds_apply(struct dsa_switch_tree *dst, struct dsa_switch *ds)
 308 {
 309         struct dsa_port *port;
 310         u32 index;
 311         int err;
 312
 313         /* Initialize ds->phys_mii_mask before registering the slave MDIO bus
 314          * driver and before ops->setup() has run, since the switch drivers and
 315          * the slave MDIO bus driver rely on these values for probing PHY
 316          * devices or not
 317          */
 318         ds->phys_mii_mask = ds->enabled_port_mask;
 319
 320         /* Add the switch to devlink before calling setup, so that setup can
 321          * add dpipe tables
 322          */
 323         ds->devlink = devlink_alloc(&dsa_devlink_ops, 0);
 324         if (!ds->devlink)
 325                 return -ENOMEM;
 326
 327         err = devlink_register(ds->devlink, ds->dev);
 328         if (err)
 329                 return err;
 330
 331         err = ds->ops->setup(ds);
 332         if (err < 0)
 333                 return err;
 334
 335         err = dsa_switch_register_notifier(ds);
 336         if (err)
 337                 return err;
 338
 339         if (ds->ops->set_addr) {
 340                 err = ds->ops->set_addr(ds, dst->cpu_dp->netdev->dev_addr);
 341                 if (err < 0)
 342                         return err;
 343         }
 344
 345         if (!ds->slave_mii_bus && ds->ops->phy_read) {
 346                 ds->slave_mii_bus = devm_mdiobus_alloc(ds->dev);
 347                 if (!ds->slave_mii_bus)
 348                         return -ENOMEM;
 349
 350                 dsa_slave_mii_bus_init(ds);
 351
 352                 err = mdiobus_register(ds->slave_mii_bus);
 353                 if (err < 0)
 354                         return err;
 355         }
 356
 357         for (index = 0; index < ds->num_ports; index++) {
 358                 port = &ds->ports[index];
 359                 if (!dsa_port_is_valid(port))
 360                         continue;
 361
 362                 if (dsa_port_is_dsa(port)) {
 363                         err = dsa_dsa_port_apply(port);
 364                         if (err)
 365                                 return err;
 366                         continue;
 367                 }
 368
 369                 if (dsa_port_is_cpu(port)) {
 370                         err = dsa_cpu_port_apply(port);
 371                         if (err)
 372                                 return err;
 373                         continue;
 374                 }
 375
 376                 err = dsa_user_port_apply(port);
 377                 if (err)
 378                         continue;
 379         }
 380
 381         return 0;
 382 }
 383
 384 static void dsa_ds_unapply(struct dsa_switch_tree *dst, struct dsa_switch *ds)
 385 {
 386         struct dsa_port *port;
 387         u32 index;
 388
 389         for (index = 0; index < ds->num_ports; index++) {
 390                 port = &ds->ports[index];
 391                 if (!dsa_port_is_valid(port))
 392                         continue;
 393
 394                 if (dsa_port_is_dsa(port)) {
 395                         dsa_dsa_port_unapply(port);
 396                         continue;
 397                 }
 398
 399                 if (dsa_port_is_cpu(port)) {
 400                         dsa_cpu_port_unapply(port);
 401                         continue;
 402                 }
 403
 404                 dsa_user_port_unapply(port);
 405         }
 406
 407         if (ds->slave_mii_bus && ds->ops->phy_read)
 408                 mdiobus_unregister(ds->slave_mii_bus);
 409
 410         dsa_switch_unregister_notifier(ds);
 411
 412         if (ds->devlink) {
 413                 devlink_unregister(ds->devlink);
 414                 devlink_free(ds->devlink);
 415                 ds->devlink = NULL;
 416         }
 417
 418 }
 419
 420 static int dsa_dst_apply(struct dsa_switch_tree *dst)
 421 {
 422         struct dsa_switch *ds;
 423         u32 index;
 424         int err;
 425
 426         for (index = 0; index < DSA_MAX_SWITCHES; index++) {
 427                 ds = dst->ds[index];
 428                 if (!ds)
 429                         continue;
 430
 431                 err = dsa_ds_apply(dst, ds);
 432                 if (err)
 433                         return err;
 434         }
 435
 436         if (dst->cpu_dp) {
 437                 err = dsa_cpu_port_ethtool_setup(dst->cpu_dp);
 438                 if (err)
 439                         return err;
 440         }
 441
 442         /* If we use a tagging format that doesn't have an ethertype
 443          * field, make sure that all packets from this point on get
 444          * sent to the tag format's receive function.
 445          */
 446         wmb();
 447         dst->cpu_dp->netdev->dsa_ptr = dst;
 448         dst->applied = true;
 449
 450         return 0;
 451 }
 452
 453 static void dsa_dst_unapply(struct dsa_switch_tree *dst)
 454 {
 455         struct dsa_switch *ds;
 456         u32 index;
 457
 458         if (!dst->applied)
 459                 return;
 460
 461         dst->cpu_dp->netdev->dsa_ptr = NULL;
 462
 463         /* If we used a tagging format that doesn't have an ethertype
 464          * field, make sure that all packets from this point get sent
 465          * without the tag and go through the regular receive path.
 466          */
 467         wmb();
 468
 469         for (index = 0; index < DSA_MAX_SWITCHES; index++) {
 470                 ds = dst->ds[index];
 471                 if (!ds)
 472                         continue;
 473
 474                 dsa_ds_unapply(dst, ds);
 475         }
 476
 477         if (dst->cpu_dp) {
 478                 dsa_cpu_port_ethtool_restore(dst->cpu_dp);
 479                 dst->cpu_dp = NULL;
 480         }
 481
 482         pr_info("DSA: tree %d unapplied\n", dst->tree);
 483         dst->applied = false;
 484 }
 485
 486 static int dsa_cpu_parse(struct dsa_port *port, u32 index,
 487                          struct dsa_switch_tree *dst,
 488                          struct dsa_switch *ds)
 489 {
 490         enum dsa_tag_protocol tag_protocol;
 491         struct net_device *ethernet_dev;
 492         struct device_node *ethernet;
 493
 494         if (port->dn) {
 495                 ethernet = of_parse_phandle(port->dn, "ethernet", 0);
 496                 if (!ethernet)
 497                         return -EINVAL;
 498                 ethernet_dev = of_find_net_device_by_node(ethernet);
 499         } else {
 500                 ethernet_dev = dsa_dev_to_net_device(ds->cd->netdev[index]);
 501                 dev_put(ethernet_dev);
 502         }
 503
 504         if (!ethernet_dev)
 505                 return -EPROBE_DEFER;
 506
 507         if (!dst->cpu_dp) {
 508                 dst->cpu_dp = port;
 509                 dst->cpu_dp->netdev = ethernet_dev;
 510         }
 511
 512         /* Initialize cpu_port_mask now for drv->setup()
 513          * to have access to a correct value, just like what
 514          * net/dsa/dsa.c::dsa_switch_setup_one does.
 515          */
 516         ds->cpu_port_mask |= BIT(index);
 517
 518         tag_protocol = ds->ops->get_tag_protocol(ds);
 519         dst->tag_ops = dsa_resolve_tag_protocol(tag_protocol);
 520         if (IS_ERR(dst->tag_ops)) {
 521                 dev_warn(ds->dev, "No tagger for this switch\n");
 522                 ds->cpu_port_mask &= ~BIT(index);
 523                 return PTR_ERR(dst->tag_ops);
 524         }
 525
 526         dst->rcv = dst->tag_ops->rcv;
 527
 528         return 0;
 529 }
 530
 531 static int dsa_ds_parse(struct dsa_switch_tree *dst, struct dsa_switch *ds)
 532 {
 533         struct dsa_port *port;
 534         u32 index;
 535         int err;
 536
 537         for (index = 0; index < ds->num_ports; index++) {
 538                 port = &ds->ports[index];
 539                 if (!dsa_port_is_valid(port) ||
 540                     dsa_port_is_dsa(port))
 541                         continue;
 542
 543                 if (dsa_port_is_cpu(port)) {
 544                         err = dsa_cpu_parse(port, index, dst, ds);
 545                         if (err)
 546                                 return err;
 547                 } else {
 548                         /* Initialize enabled_port_mask now for drv->setup()
 549                          * to have access to a correct value, just like what
 550                          * net/dsa/dsa.c::dsa_switch_setup_one does.
 551                          */
 552                         ds->enabled_port_mask |= BIT(index);
 553                 }
 554
 555         }
 556
 557         pr_info("DSA: switch %d %d parsed\n", dst->tree, ds->index);
 558
 559         return 0;
 560 }
 561
 562 static int dsa_dst_parse(struct dsa_switch_tree *dst)
 563 {
 564         struct dsa_switch *ds;
 565         struct dsa_port *dp;
 566         u32 index;
 567         int port;
 568         int err;
 569
 570         for (index = 0; index < DSA_MAX_SWITCHES; index++) {
 571                 ds = dst->ds[index];
 572                 if (!ds)
 573                         continue;
 574
 575                 err = dsa_ds_parse(dst, ds);
 576                 if (err)
 577                         return err;
 578         }
 579
 580         if (!dst->cpu_dp->netdev) {
 581                 pr_warn("Tree has no master device\n");
 582                 return -EINVAL;
 583         }
 584
 585         /* Assign the default CPU port to all ports of the fabric */
 586         for (index = 0; index < DSA_MAX_SWITCHES; index++) {
 587                 ds = dst->ds[index];
 588                 if (!ds)
 589                         continue;
 590
 591                 for (port = 0; port < ds->num_ports; port++) {
 592                         dp = &ds->ports[port];
 593                         if (!dsa_port_is_valid(dp) ||
 594                             dsa_port_is_dsa(dp) ||
 595                             dsa_port_is_cpu(dp))
 596                                 continue;
 597
 598                         dp->cpu_dp = dst->cpu_dp;
 599                 }
 600         }
 601
 602         pr_info("DSA: tree %d parsed\n", dst->tree);
 603
 604         return 0;
 605 }
 606
 607 static int dsa_parse_ports_dn(struct device_node *ports, struct dsa_switch *ds)
 608 {
 609         struct device_node *port;
 610         int err;
 611         u32 reg;
 612
 613         for_each_available_child_of_node(ports, port) {
 614                 err = of_property_read_u32(port, "reg", &reg);
 615                 if (err)
 616                         return err;
 617
 618                 if (reg >= ds->num_ports)
 619                         return -EINVAL;
 620
 621                 ds->ports[reg].dn = port;
 622         }
 623
 624         return 0;
 625 }
 626
 627 static int dsa_parse_ports(struct dsa_chip_data *cd, struct dsa_switch *ds)
 628 {
 629         bool valid_name_found = false;
 630         unsigned int i;
 631
 632         for (i = 0; i < DSA_MAX_PORTS; i++) {
 633                 if (!cd->port_names[i])
 634                         continue;
 635
 636                 ds->ports[i].name = cd->port_names[i];
 637                 valid_name_found = true;
 638         }
 639
 640         if (!valid_name_found && i == DSA_MAX_PORTS)
 641                 return -EINVAL;
 642
 643         return 0;
 644 }
 645
 646 static int dsa_parse_member_dn(struct device_node *np, u32 *tree, u32 *index)
 647 {
 648         int err;
 649
 650         *tree = *index = 0;
 651
 652         err = of_property_read_u32_index(np, "dsa,member", 0, tree);
 653         if (err) {
 654                 /* Does not exist, but it is optional */
 655                 if (err == -EINVAL)
 656                         return 0;
 657                 return err;
 658         }
 659
 660         err = of_property_read_u32_index(np, "dsa,member", 1, index);
 661         if (err)
 662                 return err;
 663
 664         if (*index >= DSA_MAX_SWITCHES)
 665                 return -EINVAL;
 666
 667         return 0;
 668 }
 669
 670 static int dsa_parse_member(struct dsa_chip_data *pd, u32 *tree, u32 *index)
 671 {
 672         if (!pd)
 673                 return -ENODEV;
 674
 675         /* We do not support complex trees with dsa_chip_data */
 676         *tree = 0;
 677         *index = 0;
 678
 679         return 0;
 680 }
 681
 682 static struct device_node *dsa_get_ports(struct dsa_switch *ds,
 683                                          struct device_node *np)
 684 {
 685         struct device_node *ports;
 686
 687         ports = of_get_child_by_name(np, "ports");
 688         if (!ports) {
 689                 dev_err(ds->dev, "no ports child node found\n");
 690                 return ERR_PTR(-EINVAL);
 691         }
 692
 693         return ports;
 694 }
 695
 696 static int _dsa_register_switch(struct dsa_switch *ds)
 697 {
 698         struct dsa_chip_data *pdata = ds->dev->platform_data;
 699         struct device_node *np = ds->dev->of_node;
 700         struct dsa_switch_tree *dst;
 701         struct device_node *ports;
 702         u32 tree, index;
 703         int i, err;
 704
 705         if (np) {
 706                 err = dsa_parse_member_dn(np, &tree, &index);
 707                 if (err)
 708                         return err;
 709
 710                 ports = dsa_get_ports(ds, np);
 711                 if (IS_ERR(ports))
 712                         return PTR_ERR(ports);
 713
 714                 err = dsa_parse_ports_dn(ports, ds);
 715                 if (err)
 716                         return err;
 717         } else {
 718                 err = dsa_parse_member(pdata, &tree, &index);
 719                 if (err)
 720                         return err;
 721
 722                 err = dsa_parse_ports(pdata, ds);
 723                 if (err)
 724                         return err;
 725         }
 726
 727         dst = dsa_get_dst(tree);
 728         if (!dst) {
 729                 dst = dsa_add_dst(tree);
 730                 if (!dst)
 731                         return -ENOMEM;
 732         }
 733
 734         if (dst->ds[index]) {
 735                 err = -EBUSY;
 736                 goto out;
 737         }
 738
 739         ds->dst = dst;
 740         ds->index = index;
 741         ds->cd = pdata;
 742
 743         /* Initialize the routing table */
 744         for (i = 0; i < DSA_MAX_SWITCHES; ++i)
 745                 ds->rtable[i] = DSA_RTABLE_NONE;
 746
 747         dsa_dst_add_ds(dst, ds, index);
 748
 749         err = dsa_dst_complete(dst);
 750         if (err < 0)
 751                 goto out_del_dst;
 752
 753         if (err == 1) {
 754                 /* Not all switches registered yet */
 755                 err = 0;
 756                 goto out;
 757         }
 758
 759         if (dst->applied) {
 760                 pr_info("DSA: Disjoint trees?\n");
 761                 return -EINVAL;
 762         }
 763
 764         err = dsa_dst_parse(dst);
 765         if (err) {
 766                 if (err == -EPROBE_DEFER) {
 767                         dsa_dst_del_ds(dst, ds, ds->index);
 768                         return err;
 769                 }
 770
 771                 goto out_del_dst;
 772         }
 773
 774         err = dsa_dst_apply(dst);
 775         if (err) {
 776                 dsa_dst_unapply(dst);
 777                 goto out_del_dst;
 778         }
 779
 780         dsa_put_dst(dst);
 781         return 0;
 782
 783 out_del_dst:
 784         dsa_dst_del_ds(dst, ds, ds->index);
 785 out:
 786         dsa_put_dst(dst);
 787
 788         return err;
 789 }
 790
 791 struct dsa_switch *dsa_switch_alloc(struct device *dev, size_t n)
 792 {
 793         size_t size = sizeof(struct dsa_switch) + n * sizeof(struct dsa_port);
 794         struct dsa_switch *ds;
 795         int i;
 796
 797         ds = devm_kzalloc(dev, size, GFP_KERNEL);
 798         if (!ds)
 799                 return NULL;
 800
 801         ds->dev = dev;
 802         ds->num_ports = n;
 803
 804         for (i = 0; i < ds->num_ports; ++i) {
 805                 ds->ports[i].index = i;
 806                 ds->ports[i].ds = ds;
 807         }
 808
 809         return ds;
 810 }
 811 EXPORT_SYMBOL_GPL(dsa_switch_alloc);
 812
 813 int dsa_register_switch(struct dsa_switch *ds)
 814 {
 815         int err;
 816
 817         mutex_lock(&dsa2_mutex);
 818         err = _dsa_register_switch(ds);
 819         mutex_unlock(&dsa2_mutex);
 820
 821         return err;
 822 }
 823 EXPORT_SYMBOL_GPL(dsa_register_switch);
 824
 825 static void _dsa_unregister_switch(struct dsa_switch *ds)
 826 {
 827         struct dsa_switch_tree *dst = ds->dst;
 828
 829         dsa_dst_unapply(dst);
 830
 831         dsa_dst_del_ds(dst, ds, ds->index);
 832 }
 833
 834 void dsa_unregister_switch(struct dsa_switch *ds)
 835 {
 836         mutex_lock(&dsa2_mutex);
 837         _dsa_unregister_switch(ds);
 838         mutex_unlock(&dsa2_mutex);
 839 }
 840 EXPORT_SYMBOL_GPL(dsa_unregister_switch);