dsa2.c 16.5 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->dn || port->name);
91 92
}

93
static bool dsa_port_is_dsa(struct dsa_port *port)
94
{
95 96 97 98
	if (port->name && !strcmp(port->name, "dsa"))
		return true;
	else
		return !!of_parse_phandle(port->dn, "link", 0);
99 100 101 102
}

static bool dsa_port_is_cpu(struct dsa_port *port)
{
103 104 105 106
	if (port->name && !strcmp(port->name, "cpu"))
		return true;
	else
		return !!of_parse_phandle(port->dn, "ethernet", 0);
107 108
}

109 110
static bool dsa_ds_find_port_dn(struct dsa_switch *ds,
				struct device_node *port)
111 112 113
{
	u32 index;

114
	for (index = 0; index < ds->num_ports; index++)
115 116 117 118 119
		if (ds->ports[index].dn == port)
			return true;
	return false;
}

120 121
static struct dsa_switch *dsa_dst_find_port_dn(struct dsa_switch_tree *dst,
					       struct device_node *port)
122 123 124 125 126 127 128 129 130
{
	struct dsa_switch *ds;
	u32 index;

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

131
		if (dsa_ds_find_port_dn(ds, port))
132 133 134 135 136 137 138 139
			return ds;
	}

	return NULL;
}

static int dsa_port_complete(struct dsa_switch_tree *dst,
			     struct dsa_switch *src_ds,
140
			     struct dsa_port *port,
141 142 143 144 145 146 147
			     u32 src_port)
{
	struct device_node *link;
	int index;
	struct dsa_switch *dst_ds;

	for (index = 0;; index++) {
148
		link = of_parse_phandle(port->dn, "link", index);
149 150 151
		if (!link)
			break;

152
		dst_ds = dsa_dst_find_port_dn(dst, link);
153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170
		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)
{
171
	struct dsa_port *port;
172 173 174
	u32 index;
	int err;

175
	for (index = 0; index < ds->num_ports; index++) {
176 177
		port = &ds->ports[index];
		if (!dsa_port_is_valid(port))
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 209 210 211 212 213 214 215 216
			continue;

		if (!dsa_port_is_dsa(port))
			continue;

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

		ds->dsa_port_mask |= BIT(index);
	}

	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;
}

217
static int dsa_dsa_port_apply(struct dsa_port *port)
218
{
219
	struct dsa_switch *ds = port->ds;
220 221
	int err;

222
	err = dsa_cpu_dsa_setup(ds, ds->dev, port, port->index);
223 224
	if (err) {
		dev_warn(ds->dev, "Failed to setup dsa port %d: %d\n",
225
			 port->index, err);
226 227 228
		return err;
	}

229
	memset(&port->devlink_port, 0, sizeof(port->devlink_port));
230

231 232
	return devlink_port_register(ds->devlink, &port->devlink_port,
				     port->index);
233 234
}

235
static void dsa_dsa_port_unapply(struct dsa_port *port)
236
{
237
	devlink_port_unregister(&port->devlink_port);
238 239 240
	dsa_cpu_dsa_destroy(port);
}

241
static int dsa_cpu_port_apply(struct dsa_port *port)
242
{
243
	struct dsa_switch *ds = port->ds;
244 245
	int err;

246
	err = dsa_cpu_dsa_setup(ds, ds->dev, port, port->index);
247 248
	if (err) {
		dev_warn(ds->dev, "Failed to setup cpu port %d: %d\n",
249
			 port->index, err);
250 251 252
		return err;
	}

253 254 255
	memset(&port->devlink_port, 0, sizeof(port->devlink_port));
	err = devlink_port_register(ds->devlink, &port->devlink_port,
				    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 272
	int err;

273 274
	if (port->dn)
		name = of_get_property(port->dn, "label", NULL);
275 276
	if (!name)
		name = "eth%d";
277

278
	err = dsa_slave_create(ds, ds->dev, port->index, name);
279 280
	if (err) {
		dev_warn(ds->dev, "Failed to create slave %d: %d\n",
281 282
			 port->index, err);
		port->netdev = NULL;
283 284 285
		return err;
	}

286 287 288
	memset(&port->devlink_port, 0, sizeof(port->devlink_port));
	err = devlink_port_register(ds->devlink, &port->devlink_port,
				    port->index);
289 290 291
	if (err)
		return err;

292
	devlink_port_type_eth_set(&port->devlink_port, port->netdev);
293

294 295 296
	return 0;
}

297
static void dsa_user_port_unapply(struct dsa_port *port)
298
{
299 300 301 302 303
	devlink_port_unregister(&port->devlink_port);
	if (port->netdev) {
		dsa_slave_destroy(port->netdev);
		port->netdev = NULL;
		port->ds->enabled_port_mask &= ~(1 << port->index);
304 305 306 307 308
	}
}

static int dsa_ds_apply(struct dsa_switch_tree *dst, struct dsa_switch *ds)
{
309
	struct dsa_port *port;
310 311 312
	u32 index;
	int err;

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 316 317 318 319
	 * the slave MDIO bus driver rely on these values for probing PHY
	 * devices or not
	 */
	ds->phys_mii_mask = ds->enabled_port_mask;

320 321 322 323 324 325 326 327 328 329 330
	/* 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;

331
	err = ds->ops->setup(ds);
332 333 334
	if (err < 0)
		return err;

V
Vivien Didelot 已提交
335 336 337 338
	err = dsa_switch_register_notifier(ds);
	if (err)
		return err;

339
	if (ds->ops->set_addr) {
340
		err = ds->ops->set_addr(ds, dst->cpu_dp->netdev->dev_addr);
341 342 343
		if (err < 0)
			return err;
	}
344

345
	if (!ds->slave_mii_bus && ds->ops->phy_read) {
346 347 348 349 350 351 352 353 354 355 356
		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;
	}

357
	for (index = 0; index < ds->num_ports; index++) {
358 359
		port = &ds->ports[index];
		if (!dsa_port_is_valid(port))
360 361 362
			continue;

		if (dsa_port_is_dsa(port)) {
363
			err = dsa_dsa_port_apply(port);
364 365 366 367 368 369
			if (err)
				return err;
			continue;
		}

		if (dsa_port_is_cpu(port)) {
370
			err = dsa_cpu_port_apply(port);
371 372 373 374 375
			if (err)
				return err;
			continue;
		}

376
		err = dsa_user_port_apply(port);
377 378 379 380 381 382 383 384 385
		if (err)
			continue;
	}

	return 0;
}

static void dsa_ds_unapply(struct dsa_switch_tree *dst, struct dsa_switch *ds)
{
386
	struct dsa_port *port;
387 388
	u32 index;

389
	for (index = 0; index < ds->num_ports; index++) {
390 391
		port = &ds->ports[index];
		if (!dsa_port_is_valid(port))
392 393 394
			continue;

		if (dsa_port_is_dsa(port)) {
395
			dsa_dsa_port_unapply(port);
396 397 398 399
			continue;
		}

		if (dsa_port_is_cpu(port)) {
400
			dsa_cpu_port_unapply(port);
401 402 403
			continue;
		}

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);
V
Vivien Didelot 已提交
409 410

	dsa_switch_unregister_notifier(ds);
411 412 413 414 415 416 417

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

418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435
}

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;
	}

436
	if (dst->cpu_dp) {
437
		err = dsa_cpu_port_ethtool_setup(dst->cpu_dp);
438 439 440
		if (err)
			return err;
	}
441

442 443 444 445 446
	/* 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();
447
	dst->cpu_dp->netdev->dsa_ptr = dst;
448 449 450 451 452 453 454 455 456 457 458 459 460
	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;

461
	dst->cpu_dp->netdev->dsa_ptr = NULL;
462 463 464 465 466 467 468 469 470 471 472 473 474 475 476

	/* 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);
	}

477
	if (dst->cpu_dp) {
478
		dsa_cpu_port_ethtool_restore(dst->cpu_dp);
479
		dst->cpu_dp = NULL;
480
	}
481

482 483 484 485
	pr_info("DSA: tree %d unapplied\n", dst->tree);
	dst->applied = false;
}

486
static int dsa_cpu_parse(struct dsa_port *port, u32 index,
487 488 489
			 struct dsa_switch_tree *dst,
			 struct dsa_switch *ds)
{
490
	enum dsa_tag_protocol tag_protocol;
491 492
	struct net_device *ethernet_dev;
	struct device_node *ethernet;
493 494
	struct dsa_port *p;
	unsigned int i;
495

496 497 498 499 500 501 502 503 504
	if (port->dn) {
		ethernet = of_parse_phandle(port->dn, "ethernet", 0);
		if (!ethernet)
			return -EINVAL;
		ethernet_dev = of_find_net_device_by_node(ethernet);
	} else {
		ethernet_dev = dsa_dev_to_net_device(ds->cd->netdev[index]);
		dev_put(ethernet_dev);
	}
505 506 507 508

	if (!ethernet_dev)
		return -EPROBE_DEFER;

509
	if (!dst->cpu_dp) {
510
		dst->cpu_dp = port;
511
		dst->cpu_dp->netdev = ethernet_dev;
512 513 514 515 516 517 518 519 520

		for (i = 0; i < ds->num_ports; i++) {
			p = &ds->ports[i];
			if (!dsa_port_is_valid(p) ||
			    i == index)
				continue;

			p->cpu_dp = port;
		}
521
	}
522

523
	tag_protocol = ds->ops->get_tag_protocol(ds);
524
	dst->tag_ops = dsa_resolve_tag_protocol(tag_protocol);
525 526 527 528 529 530 531
	if (IS_ERR(dst->tag_ops)) {
		dev_warn(ds->dev, "No tagger for this switch\n");
		return PTR_ERR(dst->tag_ops);
	}

	dst->rcv = dst->tag_ops->rcv;

532 533 534 535 536 537
	/* Initialize cpu_port_mask now for drv->setup()
	 * to have access to a correct value, just like what
	 * net/dsa/dsa.c::dsa_switch_setup_one does.
	 */
	ds->cpu_port_mask |= BIT(index);

538 539 540 541 542
	return 0;
}

static int dsa_ds_parse(struct dsa_switch_tree *dst, struct dsa_switch *ds)
{
543
	struct dsa_port *port;
544 545 546
	u32 index;
	int err;

547
	for (index = 0; index < ds->num_ports; index++) {
548
		port = &ds->ports[index];
549 550
		if (!dsa_port_is_valid(port) ||
		    dsa_port_is_dsa(port))
551 552 553 554 555 556
			continue;

		if (dsa_port_is_cpu(port)) {
			err = dsa_cpu_parse(port, index, dst, ds);
			if (err)
				return err;
557 558 559 560 561 562
		} else {
			/* Initialize enabled_port_mask now for drv->setup()
			 * to have access to a correct value, just like what
			 * net/dsa/dsa.c::dsa_switch_setup_one does.
			 */
			ds->enabled_port_mask |= BIT(index);
563
		}
564

565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587
	}

	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;
	u32 index;
	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;
	}

588
	if (!dst->cpu_dp->netdev) {
589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608
		pr_warn("Tree has no master device\n");
		return -EINVAL;
	}

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

	return 0;
}

static int dsa_parse_ports_dn(struct device_node *ports, struct dsa_switch *ds)
{
	struct device_node *port;
	int err;
	u32 reg;

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

609
		if (reg >= ds->num_ports)
610 611 612 613 614 615 616 617
			return -EINVAL;

		ds->ports[reg].dn = port;
	}

	return 0;
}

618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636
static int dsa_parse_ports(struct dsa_chip_data *cd, struct dsa_switch *ds)
{
	bool valid_name_found = false;
	unsigned int i;

	for (i = 0; i < DSA_MAX_PORTS; i++) {
		if (!cd->port_names[i])
			continue;

		ds->ports[i].name = cd->port_names[i];
		valid_name_found = true;
	}

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

	return 0;
}

637
static int dsa_parse_member_dn(struct device_node *np, u32 *tree, u32 *index)
638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660
{
	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;
}

661 662 663 664 665 666 667 668 669 670 671 672
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;
}

673 674 675 676 677 678 679 680 681 682 683 684 685 686
static struct device_node *dsa_get_ports(struct dsa_switch *ds,
					 struct device_node *np)
{
	struct device_node *ports;

	ports = of_get_child_by_name(np, "ports");
	if (!ports) {
		dev_err(ds->dev, "no ports child node found\n");
		return ERR_PTR(-EINVAL);
	}

	return ports;
}

687
static int _dsa_register_switch(struct dsa_switch *ds)
688
{
689 690
	struct dsa_chip_data *pdata = ds->dev->platform_data;
	struct device_node *np = ds->dev->of_node;
691
	struct dsa_switch_tree *dst;
692
	struct device_node *ports;
693
	u32 tree, index;
694
	int i, err;
695

696 697 698 699
	if (np) {
		err = dsa_parse_member_dn(np, &tree, &index);
		if (err)
			return err;
700

701 702 703
		ports = dsa_get_ports(ds, np);
		if (IS_ERR(ports))
			return PTR_ERR(ports);
704

705 706 707 708 709 710 711 712 713 714 715 716
		err = dsa_parse_ports_dn(ports, ds);
		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;
	}
717 718 719 720 721 722 723 724 725 726 727 728 729 730 731

	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;
732
	ds->cd = pdata;
733 734 735 736 737

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

738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755
	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);
756 757 758 759 760 761
	if (err) {
		if (err == -EPROBE_DEFER) {
			dsa_dst_del_ds(dst, ds, ds->index);
			return err;
		}

762
		goto out_del_dst;
763
	}
764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781

	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;
}

782 783 784 785
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;
786
	int i;
787 788 789 790 791 792 793 794

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

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

795 796 797 798 799
	for (i = 0; i < ds->num_ports; ++i) {
		ds->ports[i].index = i;
		ds->ports[i].ds = ds;
	}

800 801 802 803
	return ds;
}
EXPORT_SYMBOL_GPL(dsa_switch_alloc);

804
int dsa_register_switch(struct dsa_switch *ds)
805 806 807 808
{
	int err;

	mutex_lock(&dsa2_mutex);
809
	err = _dsa_register_switch(ds);
810 811 812 813 814 815
	mutex_unlock(&dsa2_mutex);

	return err;
}
EXPORT_SYMBOL_GPL(dsa_register_switch);

816
static void _dsa_unregister_switch(struct dsa_switch *ds)
817 818 819 820 821 822 823 824 825 826 827 828 829 830 831
{
	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);