dsa2.c 16.7 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
/*
 * net/dsa/dsa2.c - Hardware switch handling, binding version 2
 * Copyright (c) 2008-2009 Marvell Semiconductor
 * Copyright (c) 2013 Florian Fainelli <florian@openwrt.org>
 * Copyright (c) 2016 Andrew Lunn <andrew@lunn.ch>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 */

#include <linux/device.h>
#include <linux/err.h>
#include <linux/list.h>
16
#include <linux/netdevice.h>
17 18 19 20
#include <linux/slab.h>
#include <linux/rtnetlink.h>
#include <linux/of.h>
#include <linux/of_net.h>
21

22 23 24 25 26
#include "dsa_priv.h"

static LIST_HEAD(dsa_switch_trees);
static DEFINE_MUTEX(dsa2_mutex);

27 28 29
static const struct devlink_ops dsa_devlink_ops = {
};

30 31 32 33 34
static struct dsa_switch_tree *dsa_get_dst(u32 tree)
{
	struct dsa_switch_tree *dst;

	list_for_each_entry(dst, &dsa_switch_trees, list)
35 36
		if (dst->tree == tree) {
			kref_get(&dst->refcount);
37
			return dst;
38
		}
39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84
	return NULL;
}

static void dsa_free_dst(struct kref *ref)
{
	struct dsa_switch_tree *dst = container_of(ref, struct dsa_switch_tree,
						   refcount);

	list_del(&dst->list);
	kfree(dst);
}

static void dsa_put_dst(struct dsa_switch_tree *dst)
{
	kref_put(&dst->refcount, dsa_free_dst);
}

static struct dsa_switch_tree *dsa_add_dst(u32 tree)
{
	struct dsa_switch_tree *dst;

	dst = kzalloc(sizeof(*dst), GFP_KERNEL);
	if (!dst)
		return NULL;
	dst->tree = tree;
	INIT_LIST_HEAD(&dst->list);
	list_add_tail(&dsa_switch_trees, &dst->list);
	kref_init(&dst->refcount);

	return dst;
}

static void dsa_dst_add_ds(struct dsa_switch_tree *dst,
			   struct dsa_switch *ds, u32 index)
{
	kref_get(&dst->refcount);
	dst->ds[index] = ds;
}

static void dsa_dst_del_ds(struct dsa_switch_tree *dst,
			   struct dsa_switch *ds, u32 index)
{
	dst->ds[index] = NULL;
	kref_put(&dst->refcount, dsa_free_dst);
}

85 86 87
/* For platform data configurations, we need to have a valid name argument to
 * differentiate a disabled port from an enabled one
 */
88
static bool dsa_port_is_valid(struct dsa_port *port)
89
{
90
	return port->type != DSA_PORT_TYPE_UNUSED;
91 92
}

93
static bool dsa_port_is_dsa(struct dsa_port *port)
94
{
95
	return port->type == DSA_PORT_TYPE_DSA;
96 97 98 99
}

static bool dsa_port_is_cpu(struct dsa_port *port)
{
100
	return port->type == DSA_PORT_TYPE_CPU;
101 102
}

103 104
static bool dsa_ds_find_port_dn(struct dsa_switch *ds,
				struct device_node *port)
105 106 107
{
	u32 index;

108
	for (index = 0; index < ds->num_ports; index++)
109 110 111 112 113
		if (ds->ports[index].dn == port)
			return true;
	return false;
}

114 115
static struct dsa_switch *dsa_dst_find_port_dn(struct dsa_switch_tree *dst,
					       struct device_node *port)
116 117 118 119 120 121 122 123 124
{
	struct dsa_switch *ds;
	u32 index;

	for (index = 0; index < DSA_MAX_SWITCHES; index++) {
		ds = dst->ds[index];
		if (!ds)
			continue;

125
		if (dsa_ds_find_port_dn(ds, port))
126 127 128 129 130 131 132 133
			return ds;
	}

	return NULL;
}

static int dsa_port_complete(struct dsa_switch_tree *dst,
			     struct dsa_switch *src_ds,
134
			     struct dsa_port *port,
135 136 137 138 139 140 141
			     u32 src_port)
{
	struct device_node *link;
	int index;
	struct dsa_switch *dst_ds;

	for (index = 0;; index++) {
142
		link = of_parse_phandle(port->dn, "link", index);
143 144 145
		if (!link)
			break;

146
		dst_ds = dsa_dst_find_port_dn(dst, link);
147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164
		of_node_put(link);

		if (!dst_ds)
			return 1;

		src_ds->rtable[dst_ds->index] = src_port;
	}

	return 0;
}

/* A switch is complete if all the DSA ports phandles point to ports
 * known in the tree. A return value of 1 means the tree is not
 * complete. This is not an error condition. A value of 0 is
 * success.
 */
static int dsa_ds_complete(struct dsa_switch_tree *dst, struct dsa_switch *ds)
{
165
	struct dsa_port *port;
166 167 168
	u32 index;
	int err;

169
	for (index = 0; index < ds->num_ports; index++) {
170 171
		port = &ds->ports[index];
		if (!dsa_port_is_valid(port))
172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208
			continue;

		if (!dsa_port_is_dsa(port))
			continue;

		err = dsa_port_complete(dst, ds, port, index);
		if (err != 0)
			return err;
	}

	return 0;
}

/* A tree is complete if all the DSA ports phandles point to ports
 * known in the tree. A return value of 1 means the tree is not
 * complete. This is not an error condition. A value of 0 is
 * success.
 */
static int dsa_dst_complete(struct dsa_switch_tree *dst)
{
	struct dsa_switch *ds;
	u32 index;
	int err;

	for (index = 0; index < DSA_MAX_SWITCHES; index++) {
		ds = dst->ds[index];
		if (!ds)
			continue;

		err = dsa_ds_complete(dst, ds);
		if (err != 0)
			return err;
	}

	return 0;
}

209
static int dsa_dsa_port_apply(struct dsa_port *port)
210
{
211
	struct dsa_switch *ds = port->ds;
212 213
	int err;

214
	err = dsa_port_fixed_link_register_of(port);
215 216
	if (err) {
		dev_warn(ds->dev, "Failed to setup dsa port %d: %d\n",
217
			 port->index, err);
218 219 220
		return err;
	}

221
	memset(&port->devlink_port, 0, sizeof(port->devlink_port));
222

223 224
	return devlink_port_register(ds->devlink, &port->devlink_port,
				     port->index);
225 226
}

227
static void dsa_dsa_port_unapply(struct dsa_port *port)
228
{
229
	devlink_port_unregister(&port->devlink_port);
230
	dsa_port_fixed_link_unregister_of(port);
231 232
}

233
static int dsa_cpu_port_apply(struct dsa_port *port)
234
{
235
	struct dsa_switch *ds = port->ds;
236 237
	int err;

238
	err = dsa_port_fixed_link_register_of(port);
239 240
	if (err) {
		dev_warn(ds->dev, "Failed to setup cpu port %d: %d\n",
241
			 port->index, err);
242 243 244
		return err;
	}

245 246 247
	memset(&port->devlink_port, 0, sizeof(port->devlink_port));
	err = devlink_port_register(ds->devlink, &port->devlink_port,
				    port->index);
248
	return err;
249 250
}

251
static void dsa_cpu_port_unapply(struct dsa_port *port)
252
{
253
	devlink_port_unregister(&port->devlink_port);
254
	dsa_port_fixed_link_unregister_of(port);
255 256
}

257
static int dsa_user_port_apply(struct dsa_port *port)
258
{
259
	struct dsa_switch *ds = port->ds;
260
	const char *name = port->name;
261 262
	int err;

263 264
	if (port->dn)
		name = of_get_property(port->dn, "label", NULL);
265 266
	if (!name)
		name = "eth%d";
267

268
	err = dsa_slave_create(port, name);
269 270
	if (err) {
		dev_warn(ds->dev, "Failed to create slave %d: %d\n",
271
			 port->index, err);
272
		port->slave = NULL;
273 274 275
		return err;
	}

276 277 278
	memset(&port->devlink_port, 0, sizeof(port->devlink_port));
	err = devlink_port_register(ds->devlink, &port->devlink_port,
				    port->index);
279 280 281
	if (err)
		return err;

282
	devlink_port_type_eth_set(&port->devlink_port, port->slave);
283

284 285 286
	return 0;
}

287
static void dsa_user_port_unapply(struct dsa_port *port)
288
{
289
	devlink_port_unregister(&port->devlink_port);
290 291 292
	if (port->slave) {
		dsa_slave_destroy(port->slave);
		port->slave = NULL;
293 294 295 296 297
	}
}

static int dsa_ds_apply(struct dsa_switch_tree *dst, struct dsa_switch *ds)
{
298
	struct dsa_port *port;
299 300 301
	u32 index;
	int err;

302
	/* Initialize ds->phys_mii_mask before registering the slave MDIO bus
303
	 * driver and before ops->setup() has run, since the switch drivers and
304 305 306
	 * the slave MDIO bus driver rely on these values for probing PHY
	 * devices or not
	 */
307
	ds->phys_mii_mask |= dsa_user_ports(ds);
308

309 310 311 312 313 314 315 316 317 318 319
	/* Add the switch to devlink before calling setup, so that setup can
	 * add dpipe tables
	 */
	ds->devlink = devlink_alloc(&dsa_devlink_ops, 0);
	if (!ds->devlink)
		return -ENOMEM;

	err = devlink_register(ds->devlink, ds->dev);
	if (err)
		return err;

320
	err = ds->ops->setup(ds);
321 322 323
	if (err < 0)
		return err;

V
Vivien Didelot 已提交
324 325 326 327
	err = dsa_switch_register_notifier(ds);
	if (err)
		return err;

328
	if (!ds->slave_mii_bus && ds->ops->phy_read) {
329 330 331 332 333 334 335 336 337 338 339
		ds->slave_mii_bus = devm_mdiobus_alloc(ds->dev);
		if (!ds->slave_mii_bus)
			return -ENOMEM;

		dsa_slave_mii_bus_init(ds);

		err = mdiobus_register(ds->slave_mii_bus);
		if (err < 0)
			return err;
	}

340
	for (index = 0; index < ds->num_ports; index++) {
341 342
		port = &ds->ports[index];
		if (!dsa_port_is_valid(port))
343 344 345
			continue;

		if (dsa_port_is_dsa(port)) {
346
			err = dsa_dsa_port_apply(port);
347 348 349 350 351 352
			if (err)
				return err;
			continue;
		}

		if (dsa_port_is_cpu(port)) {
353
			err = dsa_cpu_port_apply(port);
354 355 356 357 358
			if (err)
				return err;
			continue;
		}

359
		err = dsa_user_port_apply(port);
360 361 362 363 364 365 366 367 368
		if (err)
			continue;
	}

	return 0;
}

static void dsa_ds_unapply(struct dsa_switch_tree *dst, struct dsa_switch *ds)
{
369
	struct dsa_port *port;
370 371
	u32 index;

372
	for (index = 0; index < ds->num_ports; index++) {
373 374
		port = &ds->ports[index];
		if (!dsa_port_is_valid(port))
375 376 377
			continue;

		if (dsa_port_is_dsa(port)) {
378
			dsa_dsa_port_unapply(port);
379 380 381 382
			continue;
		}

		if (dsa_port_is_cpu(port)) {
383
			dsa_cpu_port_unapply(port);
384 385 386
			continue;
		}

387
		dsa_user_port_unapply(port);
388
	}
389

390
	if (ds->slave_mii_bus && ds->ops->phy_read)
391
		mdiobus_unregister(ds->slave_mii_bus);
V
Vivien Didelot 已提交
392 393

	dsa_switch_unregister_notifier(ds);
394 395 396 397 398 399 400

	if (ds->devlink) {
		devlink_unregister(ds->devlink);
		devlink_free(ds->devlink);
		ds->devlink = NULL;
	}

401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423
}

static int dsa_dst_apply(struct dsa_switch_tree *dst)
{
	struct dsa_switch *ds;
	u32 index;
	int err;

	for (index = 0; index < DSA_MAX_SWITCHES; index++) {
		ds = dst->ds[index];
		if (!ds)
			continue;

		err = dsa_ds_apply(dst, ds);
		if (err)
			return err;
	}

	/* If we use a tagging format that doesn't have an ethertype
	 * field, make sure that all packets from this point on get
	 * sent to the tag format's receive function.
	 */
	wmb();
424
	dst->cpu_dp->master->dsa_ptr = dst->cpu_dp;
425

426
	err = dsa_master_ethtool_setup(dst->cpu_dp->master);
427 428 429
	if (err)
		return err;

430 431 432 433 434 435 436 437 438 439 440 441 442
	dst->applied = true;

	return 0;
}

static void dsa_dst_unapply(struct dsa_switch_tree *dst)
{
	struct dsa_switch *ds;
	u32 index;

	if (!dst->applied)
		return;

443
	dsa_master_ethtool_restore(dst->cpu_dp->master);
444

445
	dst->cpu_dp->master->dsa_ptr = NULL;
446 447 448 449 450 451 452 453 454 455 456 457 458 459 460

	/* If we used a tagging format that doesn't have an ethertype
	 * field, make sure that all packets from this point get sent
	 * without the tag and go through the regular receive path.
	 */
	wmb();

	for (index = 0; index < DSA_MAX_SWITCHES; index++) {
		ds = dst->ds[index];
		if (!ds)
			continue;

		dsa_ds_unapply(dst, ds);
	}

461
	dst->cpu_dp = NULL;
462

463 464 465 466
	pr_info("DSA: tree %d unapplied\n", dst->tree);
	dst->applied = false;
}

467
static int dsa_cpu_parse(struct dsa_port *port, u32 index,
468 469 470
			 struct dsa_switch_tree *dst,
			 struct dsa_switch *ds)
{
471
	const struct dsa_device_ops *tag_ops;
472
	enum dsa_tag_protocol tag_protocol;
473 474 475
	struct net_device *ethernet_dev;
	struct device_node *ethernet;

476 477 478 479 480
	if (port->dn) {
		ethernet = of_parse_phandle(port->dn, "ethernet", 0);
		if (!ethernet)
			return -EINVAL;
		ethernet_dev = of_find_net_device_by_node(ethernet);
481 482
		if (!ethernet_dev)
			return -EPROBE_DEFER;
483 484
	} else {
		ethernet_dev = dsa_dev_to_net_device(ds->cd->netdev[index]);
485 486
		if (!ethernet_dev)
			return -EPROBE_DEFER;
487 488
		dev_put(ethernet_dev);
	}
489

490
	if (!dst->cpu_dp) {
491
		dst->cpu_dp = port;
492
		dst->cpu_dp->master = ethernet_dev;
493
	}
494

495
	tag_protocol = ds->ops->get_tag_protocol(ds);
496 497
	tag_ops = dsa_resolve_tag_protocol(tag_protocol);
	if (IS_ERR(tag_ops)) {
498
		dev_warn(ds->dev, "No tagger for this switch\n");
499
		return PTR_ERR(tag_ops);
500 501
	}

V
Vivien Didelot 已提交
502
	dst->cpu_dp->tag_ops = tag_ops;
503 504 505 506

	/* Make a few copies for faster access in master receive hot path */
	dst->cpu_dp->rcv = dst->cpu_dp->tag_ops->rcv;
	dst->cpu_dp->dst = dst;
507 508 509 510 511 512

	return 0;
}

static int dsa_ds_parse(struct dsa_switch_tree *dst, struct dsa_switch *ds)
{
513
	struct dsa_port *port;
514 515 516
	u32 index;
	int err;

517
	for (index = 0; index < ds->num_ports; index++) {
518
		port = &ds->ports[index];
519 520
		if (!dsa_port_is_valid(port) ||
		    dsa_port_is_dsa(port))
521 522 523 524 525 526 527
			continue;

		if (dsa_port_is_cpu(port)) {
			err = dsa_cpu_parse(port, index, dst, ds);
			if (err)
				return err;
		}
528

529 530 531 532 533 534 535 536 537 538
	}

	pr_info("DSA: switch %d %d parsed\n", dst->tree, ds->index);

	return 0;
}

static int dsa_dst_parse(struct dsa_switch_tree *dst)
{
	struct dsa_switch *ds;
539
	struct dsa_port *dp;
540
	u32 index;
541
	int port;
542 543 544 545 546 547 548 549 550 551 552 553
	int err;

	for (index = 0; index < DSA_MAX_SWITCHES; index++) {
		ds = dst->ds[index];
		if (!ds)
			continue;

		err = dsa_ds_parse(dst, ds);
		if (err)
			return err;
	}

554
	if (!dst->cpu_dp) {
555 556 557 558
		pr_warn("Tree has no master device\n");
		return -EINVAL;
	}

559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575
	/* Assign the default CPU port to all ports of the fabric */
	for (index = 0; index < DSA_MAX_SWITCHES; index++) {
		ds = dst->ds[index];
		if (!ds)
			continue;

		for (port = 0; port < ds->num_ports; port++) {
			dp = &ds->ports[port];
			if (!dsa_port_is_valid(dp) ||
			    dsa_port_is_dsa(dp) ||
			    dsa_port_is_cpu(dp))
				continue;

			dp->cpu_dp = dst->cpu_dp;
		}
	}

576 577 578 579 580
	pr_info("DSA: tree %d parsed\n", dst->tree);

	return 0;
}

581 582
static int dsa_port_parse_of(struct dsa_port *dp, struct device_node *dn)
{
583 584 585 586 587 588 589 590 591 592 593
	struct device_node *ethernet = of_parse_phandle(dn, "ethernet", 0);
	struct device_node *link = of_parse_phandle(dn, "link", 0);

	if (ethernet) {
		dp->type = DSA_PORT_TYPE_CPU;
	} else if (link) {
		dp->type = DSA_PORT_TYPE_DSA;
	} else {
		dp->type = DSA_PORT_TYPE_USER;
	}

594 595 596 597 598
	dp->dn = dn;

	return 0;
}

599
static int dsa_parse_ports_of(struct device_node *dn, struct dsa_switch *ds)
600
{
601
	struct device_node *ports, *port;
602
	struct dsa_port *dp;
603
	u32 reg;
604 605 606 607 608 609 610
	int err;

	ports = of_get_child_by_name(dn, "ports");
	if (!ports) {
		dev_err(ds->dev, "no ports child node found\n");
		return -EINVAL;
	}
611 612 613 614 615 616

	for_each_available_child_of_node(ports, port) {
		err = of_property_read_u32(port, "reg", &reg);
		if (err)
			return err;

617
		if (reg >= ds->num_ports)
618 619
			return -EINVAL;

620 621 622 623 624
		dp = &ds->ports[reg];

		err = dsa_port_parse_of(dp, port);
		if (err)
			return err;
625 626 627 628 629
	}

	return 0;
}

630 631 632
static int dsa_port_parse(struct dsa_port *dp, const char *name,
			  struct device *dev)
{
633 634 635 636 637 638 639 640
	if (!strcmp(name, "cpu")) {
		dp->type = DSA_PORT_TYPE_CPU;
	} else if (!strcmp(name, "dsa")) {
		dp->type = DSA_PORT_TYPE_DSA;
	} else {
		dp->type = DSA_PORT_TYPE_USER;
	}

641 642 643 644 645
	dp->name = name;

	return 0;
}

646 647 648
static int dsa_parse_ports(struct dsa_chip_data *cd, struct dsa_switch *ds)
{
	bool valid_name_found = false;
649 650 651
	struct dsa_port *dp;
	struct device *dev;
	const char *name;
652
	unsigned int i;
653
	int err;
654 655

	for (i = 0; i < DSA_MAX_PORTS; i++) {
656 657 658 659 660
		name = cd->port_names[i];
		dev = cd->netdev[i];
		dp = &ds->ports[i];

		if (!name)
661 662
			continue;

663 664 665 666
		err = dsa_port_parse(dp, name, dev);
		if (err)
			return err;

667 668 669 670 671 672 673 674 675
		valid_name_found = true;
	}

	if (!valid_name_found && i == DSA_MAX_PORTS)
		return -EINVAL;

	return 0;
}

676
static int dsa_parse_member_dn(struct device_node *np, u32 *tree, u32 *index)
677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699
{
	int err;

	*tree = *index = 0;

	err = of_property_read_u32_index(np, "dsa,member", 0, tree);
	if (err) {
		/* Does not exist, but it is optional */
		if (err == -EINVAL)
			return 0;
		return err;
	}

	err = of_property_read_u32_index(np, "dsa,member", 1, index);
	if (err)
		return err;

	if (*index >= DSA_MAX_SWITCHES)
		return -EINVAL;

	return 0;
}

700 701 702 703 704 705 706 707 708 709 710 711
static int dsa_parse_member(struct dsa_chip_data *pd, u32 *tree, u32 *index)
{
	if (!pd)
		return -ENODEV;

	/* We do not support complex trees with dsa_chip_data */
	*tree = 0;
	*index = 0;

	return 0;
}

712
static int _dsa_register_switch(struct dsa_switch *ds)
713
{
714 715
	struct dsa_chip_data *pdata = ds->dev->platform_data;
	struct device_node *np = ds->dev->of_node;
716 717
	struct dsa_switch_tree *dst;
	u32 tree, index;
718
	int i, err;
719

720 721 722 723
	if (np) {
		err = dsa_parse_member_dn(np, &tree, &index);
		if (err)
			return err;
724

725
		err = dsa_parse_ports_of(np, ds);
726 727 728 729 730 731 732 733 734 735 736
		if (err)
			return err;
	} else {
		err = dsa_parse_member(pdata, &tree, &index);
		if (err)
			return err;

		err = dsa_parse_ports(pdata, ds);
		if (err)
			return err;
	}
737 738 739 740 741 742 743 744 745 746 747 748 749 750 751

	dst = dsa_get_dst(tree);
	if (!dst) {
		dst = dsa_add_dst(tree);
		if (!dst)
			return -ENOMEM;
	}

	if (dst->ds[index]) {
		err = -EBUSY;
		goto out;
	}

	ds->dst = dst;
	ds->index = index;
752
	ds->cd = pdata;
753 754 755 756 757

	/* Initialize the routing table */
	for (i = 0; i < DSA_MAX_SWITCHES; ++i)
		ds->rtable[i] = DSA_RTABLE_NONE;

758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775
	dsa_dst_add_ds(dst, ds, index);

	err = dsa_dst_complete(dst);
	if (err < 0)
		goto out_del_dst;

	if (err == 1) {
		/* Not all switches registered yet */
		err = 0;
		goto out;
	}

	if (dst->applied) {
		pr_info("DSA: Disjoint trees?\n");
		return -EINVAL;
	}

	err = dsa_dst_parse(dst);
776 777 778 779 780 781
	if (err) {
		if (err == -EPROBE_DEFER) {
			dsa_dst_del_ds(dst, ds, ds->index);
			return err;
		}

782
		goto out_del_dst;
783
	}
784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801

	err = dsa_dst_apply(dst);
	if (err) {
		dsa_dst_unapply(dst);
		goto out_del_dst;
	}

	dsa_put_dst(dst);
	return 0;

out_del_dst:
	dsa_dst_del_ds(dst, ds, ds->index);
out:
	dsa_put_dst(dst);

	return err;
}

802 803 804 805
struct dsa_switch *dsa_switch_alloc(struct device *dev, size_t n)
{
	size_t size = sizeof(struct dsa_switch) + n * sizeof(struct dsa_port);
	struct dsa_switch *ds;
806
	int i;
807 808 809 810 811 812 813 814

	ds = devm_kzalloc(dev, size, GFP_KERNEL);
	if (!ds)
		return NULL;

	ds->dev = dev;
	ds->num_ports = n;

815 816 817 818 819
	for (i = 0; i < ds->num_ports; ++i) {
		ds->ports[i].index = i;
		ds->ports[i].ds = ds;
	}

820 821 822 823
	return ds;
}
EXPORT_SYMBOL_GPL(dsa_switch_alloc);

824
int dsa_register_switch(struct dsa_switch *ds)
825 826 827 828
{
	int err;

	mutex_lock(&dsa2_mutex);
829
	err = _dsa_register_switch(ds);
830 831 832 833 834 835
	mutex_unlock(&dsa2_mutex);

	return err;
}
EXPORT_SYMBOL_GPL(dsa_register_switch);

836
static void _dsa_unregister_switch(struct dsa_switch *ds)
837 838 839 840 841 842 843 844 845 846 847 848 849 850 851
{
	struct dsa_switch_tree *dst = ds->dst;

	dsa_dst_unapply(dst);

	dsa_dst_del_ds(dst, ds, ds->index);
}

void dsa_unregister_switch(struct dsa_switch *ds)
{
	mutex_lock(&dsa2_mutex);
	_dsa_unregister_switch(ds);
	mutex_unlock(&dsa2_mutex);
}
EXPORT_SYMBOL_GPL(dsa_unregister_switch);