dsa2.c 15.2 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
#include "dsa_priv.h"

24
static LIST_HEAD(dsa_tree_list);
25 26
static DEFINE_MUTEX(dsa2_mutex);

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

30
static struct dsa_switch_tree *dsa_tree_find(int index)
31 32 33
{
	struct dsa_switch_tree *dst;

34
	list_for_each_entry(dst, &dsa_tree_list, list)
35
		if (dst->index == index)
36
			return dst;
37

38 39 40
	return NULL;
}

41
static struct dsa_switch_tree *dsa_tree_alloc(int index)
42 43 44 45 46 47
{
	struct dsa_switch_tree *dst;

	dst = kzalloc(sizeof(*dst), GFP_KERNEL);
	if (!dst)
		return NULL;
48

49
	dst->index = index;
50

51
	INIT_LIST_HEAD(&dst->list);
52
	list_add_tail(&dsa_tree_list, &dst->list);
53 54

	/* Initialize the reference counter to the number of switches, not 1 */
55
	kref_init(&dst->refcount);
56
	refcount_set(&dst->refcount.refcount, 0);
57 58 59 60

	return dst;
}

61 62 63 64 65 66
static void dsa_tree_free(struct dsa_switch_tree *dst)
{
	list_del(&dst->list);
	kfree(dst);
}

67 68 69 70 71 72 73 74 75 76 77
static struct dsa_switch_tree *dsa_tree_touch(int index)
{
	struct dsa_switch_tree *dst;

	dst = dsa_tree_find(index);
	if (!dst)
		dst = dsa_tree_alloc(index);

	return dst;
}

78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96
static void dsa_tree_get(struct dsa_switch_tree *dst)
{
	kref_get(&dst->refcount);
}

static void dsa_tree_release(struct kref *ref)
{
	struct dsa_switch_tree *dst;

	dst = container_of(ref, struct dsa_switch_tree, refcount);

	dsa_tree_free(dst);
}

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

97
static bool dsa_port_is_dsa(struct dsa_port *port)
98
{
99
	return port->type == DSA_PORT_TYPE_DSA;
100 101 102 103
}

static bool dsa_port_is_cpu(struct dsa_port *port)
{
104
	return port->type == DSA_PORT_TYPE_CPU;
105 106
}

107 108 109 110 111
static bool dsa_port_is_user(struct dsa_port *dp)
{
	return dp->type == DSA_PORT_TYPE_USER;
}

112 113
static struct dsa_port *dsa_tree_find_port_by_node(struct dsa_switch_tree *dst,
						   struct device_node *dn)
114 115
{
	struct dsa_switch *ds;
116 117
	struct dsa_port *dp;
	int device, port;
118

119 120
	for (device = 0; device < DSA_MAX_SWITCHES; device++) {
		ds = dst->ds[device];
121 122 123
		if (!ds)
			continue;

124 125 126 127 128 129
		for (port = 0; port < ds->num_ports; port++) {
			dp = &ds->ports[port];

			if (dp->dn == dn)
				return dp;
		}
130 131 132 133 134
	}

	return NULL;
}

V
Vivien Didelot 已提交
135
static bool dsa_port_setup_routing_table(struct dsa_port *dp)
136
{
V
Vivien Didelot 已提交
137 138 139
	struct dsa_switch *ds = dp->ds;
	struct dsa_switch_tree *dst = ds->dst;
	struct device_node *dn = dp->dn;
V
Vivien Didelot 已提交
140
	struct of_phandle_iterator it;
141
	struct dsa_port *link_dp;
V
Vivien Didelot 已提交
142
	int err;
143

V
Vivien Didelot 已提交
144 145 146 147
	of_for_each_phandle(&it, err, dn, "link", NULL, 0) {
		link_dp = dsa_tree_find_port_by_node(dst, it.node);
		if (!link_dp) {
			of_node_put(it.node);
V
Vivien Didelot 已提交
148
			return false;
V
Vivien Didelot 已提交
149
		}
150

V
Vivien Didelot 已提交
151
		ds->rtable[link_dp->ds->index] = dp->index;
152 153
	}

V
Vivien Didelot 已提交
154
	return true;
155 156
}

V
Vivien Didelot 已提交
157
static bool dsa_switch_setup_routing_table(struct dsa_switch *ds)
158
{
V
Vivien Didelot 已提交
159 160 161
	bool complete = true;
	struct dsa_port *dp;
	int i;
162

V
Vivien Didelot 已提交
163 164
	for (i = 0; i < DSA_MAX_SWITCHES; i++)
		ds->rtable[i] = DSA_RTABLE_NONE;
165

V
Vivien Didelot 已提交
166 167
	for (i = 0; i < ds->num_ports; i++) {
		dp = &ds->ports[i];
168

V
Vivien Didelot 已提交
169 170 171 172 173
		if (dsa_port_is_dsa(dp)) {
			complete = dsa_port_setup_routing_table(dp);
			if (!complete)
				break;
		}
174 175
	}

V
Vivien Didelot 已提交
176
	return complete;
177 178
}

V
Vivien Didelot 已提交
179
static bool dsa_tree_setup_routing_table(struct dsa_switch_tree *dst)
180 181
{
	struct dsa_switch *ds;
V
Vivien Didelot 已提交
182 183
	bool complete = true;
	int device;
184

V
Vivien Didelot 已提交
185 186
	for (device = 0; device < DSA_MAX_SWITCHES; device++) {
		ds = dst->ds[device];
187 188 189
		if (!ds)
			continue;

V
Vivien Didelot 已提交
190 191 192
		complete = dsa_switch_setup_routing_table(ds);
		if (!complete)
			break;
193 194
	}

V
Vivien Didelot 已提交
195
	return complete;
196 197
}

198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255
static struct dsa_port *dsa_tree_find_first_cpu(struct dsa_switch_tree *dst)
{
	struct dsa_switch *ds;
	struct dsa_port *dp;
	int device, port;

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

		for (port = 0; port < ds->num_ports; port++) {
			dp = &ds->ports[port];

			if (dsa_port_is_cpu(dp))
				return dp;
		}
	}

	return NULL;
}

static int dsa_tree_setup_default_cpu(struct dsa_switch_tree *dst)
{
	struct dsa_switch *ds;
	struct dsa_port *dp;
	int device, port;

	/* DSA currently only supports a single CPU port */
	dst->cpu_dp = dsa_tree_find_first_cpu(dst);
	if (!dst->cpu_dp) {
		pr_warn("Tree has no master device\n");
		return -EINVAL;
	}

	/* Assign the default CPU port to all ports of the fabric */
	for (device = 0; device < DSA_MAX_SWITCHES; device++) {
		ds = dst->ds[device];
		if (!ds)
			continue;

		for (port = 0; port < ds->num_ports; port++) {
			dp = &ds->ports[port];

			if (dsa_port_is_user(dp))
				dp->cpu_dp = dst->cpu_dp;
		}
	}

	return 0;
}

static void dsa_tree_teardown_default_cpu(struct dsa_switch_tree *dst)
{
	/* DSA currently only supports a single CPU port */
	dst->cpu_dp = NULL;
}

256
static int dsa_port_setup(struct dsa_port *dp)
257
{
258
	struct dsa_switch *ds = dp->ds;
259 260
	int err;

261
	memset(&dp->devlink_port, 0, sizeof(dp->devlink_port));
262

263 264
	err = devlink_port_register(ds->devlink, &dp->devlink_port, dp->index);
	if (err)
265 266
		return err;

267 268 269 270 271 272 273 274 275 276 277
	switch (dp->type) {
	case DSA_PORT_TYPE_UNUSED:
		break;
	case DSA_PORT_TYPE_CPU:
	case DSA_PORT_TYPE_DSA:
		err = dsa_port_fixed_link_register_of(dp);
		if (err) {
			dev_err(ds->dev, "failed to register fixed link for port %d.%d\n",
				ds->index, dp->index);
			return err;
		}
278

279 280 281 282 283 284 285 286 287
		break;
	case DSA_PORT_TYPE_USER:
		err = dsa_slave_create(dp);
		if (err)
			dev_err(ds->dev, "failed to create slave for port %d.%d\n",
				ds->index, dp->index);
		else
			devlink_port_type_eth_set(&dp->devlink_port, dp->slave);
		break;
288 289 290 291 292
	}

	return 0;
}

293
static void dsa_port_teardown(struct dsa_port *dp)
294
{
295 296 297 298 299 300 301 302 303 304 305 306 307 308 309
	devlink_port_unregister(&dp->devlink_port);

	switch (dp->type) {
	case DSA_PORT_TYPE_UNUSED:
		break;
	case DSA_PORT_TYPE_CPU:
	case DSA_PORT_TYPE_DSA:
		dsa_port_fixed_link_unregister_of(dp);
		break;
	case DSA_PORT_TYPE_USER:
		if (dp->slave) {
			dsa_slave_destroy(dp->slave);
			dp->slave = NULL;
		}
		break;
310 311 312
	}
}

313
static int dsa_switch_setup(struct dsa_switch *ds)
314 315 316
{
	int err;

317
	/* Initialize ds->phys_mii_mask before registering the slave MDIO bus
318
	 * driver and before ops->setup() has run, since the switch drivers and
319 320 321
	 * the slave MDIO bus driver rely on these values for probing PHY
	 * devices or not
	 */
322
	ds->phys_mii_mask |= dsa_user_ports(ds);
323

324 325 326 327 328 329 330 331 332 333 334
	/* 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;

335
	err = ds->ops->setup(ds);
336 337 338
	if (err < 0)
		return err;

V
Vivien Didelot 已提交
339 340 341 342
	err = dsa_switch_register_notifier(ds);
	if (err)
		return err;

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

355 356 357
	return 0;
}

358
static void dsa_switch_teardown(struct dsa_switch *ds)
359
{
360
	if (ds->slave_mii_bus && ds->ops->phy_read)
361
		mdiobus_unregister(ds->slave_mii_bus);
V
Vivien Didelot 已提交
362 363

	dsa_switch_unregister_notifier(ds);
364 365 366 367 368 369 370

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

371 372
}

373 374 375
static int dsa_tree_setup_switches(struct dsa_switch_tree *dst)
{
	struct dsa_switch *ds;
376 377
	struct dsa_port *dp;
	int device, port;
378 379 380 381 382 383 384 385 386 387
	int err;

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

		err = dsa_switch_setup(ds);
		if (err)
			return err;
388 389 390 391 392 393 394 395

		for (port = 0; port < ds->num_ports; port++) {
			dp = &ds->ports[port];

			err = dsa_port_setup(dp);
			if (err)
				return err;
		}
396 397 398 399 400 401 402 403
	}

	return 0;
}

static void dsa_tree_teardown_switches(struct dsa_switch_tree *dst)
{
	struct dsa_switch *ds;
404 405
	struct dsa_port *dp;
	int device, port;
406 407 408 409 410 411

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

412 413 414 415 416 417
		for (port = 0; port < ds->num_ports; port++) {
			dp = &ds->ports[port];

			dsa_port_teardown(dp);
		}

418 419 420 421
		dsa_switch_teardown(ds);
	}
}

422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438
static int dsa_tree_setup_master(struct dsa_switch_tree *dst)
{
	struct dsa_port *cpu_dp = dst->cpu_dp;
	struct net_device *master = cpu_dp->master;

	/* DSA currently supports a single pair of CPU port and master device */
	return dsa_master_setup(master, cpu_dp);
}

static void dsa_tree_teardown_master(struct dsa_switch_tree *dst)
{
	struct dsa_port *cpu_dp = dst->cpu_dp;
	struct net_device *master = cpu_dp->master;

	return dsa_master_teardown(master);
}

V
Vivien Didelot 已提交
439
static int dsa_tree_setup(struct dsa_switch_tree *dst)
440
{
V
Vivien Didelot 已提交
441
	bool complete;
442 443
	int err;

V
Vivien Didelot 已提交
444 445 446 447 448 449
	if (dst->setup) {
		pr_err("DSA: tree %d already setup! Disjoint trees?\n",
		       dst->index);
		return -EEXIST;
	}

V
Vivien Didelot 已提交
450 451 452 453
	complete = dsa_tree_setup_routing_table(dst);
	if (!complete)
		return 0;

454 455 456 457
	err = dsa_tree_setup_default_cpu(dst);
	if (err)
		return err;

458 459 460
	err = dsa_tree_setup_switches(dst);
	if (err)
		return err;
461

462
	err = dsa_tree_setup_master(dst);
463 464 465
	if (err)
		return err;

V
Vivien Didelot 已提交
466 467 468
	dst->setup = true;

	pr_info("DSA: tree %d setup\n", dst->index);
469 470 471 472

	return 0;
}

V
Vivien Didelot 已提交
473
static void dsa_tree_teardown(struct dsa_switch_tree *dst)
474
{
V
Vivien Didelot 已提交
475
	if (!dst->setup)
476 477
		return;

478
	dsa_tree_teardown_master(dst);
479

480
	dsa_tree_teardown_switches(dst);
481

482
	dsa_tree_teardown_default_cpu(dst);
483

V
Vivien Didelot 已提交
484 485 486
	pr_info("DSA: tree %d torn down\n", dst->index);

	dst->setup = false;
487 488
}

489 490 491
static void dsa_tree_remove_switch(struct dsa_switch_tree *dst,
				   unsigned int index)
{
492 493
	dsa_tree_teardown(dst);

494 495 496 497 498 499 500 501
	dst->ds[index] = NULL;
	dsa_tree_put(dst);
}

static int dsa_tree_add_switch(struct dsa_switch_tree *dst,
			       struct dsa_switch *ds)
{
	unsigned int index = ds->index;
502
	int err;
503 504 505 506 507 508 509

	if (dst->ds[index])
		return -EBUSY;

	dsa_tree_get(dst);
	dst->ds[index] = ds;

510 511 512 513 514
	err = dsa_tree_setup(dst);
	if (err)
		dsa_tree_remove_switch(dst, index);

	return err;
515 516
}

517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536
static int dsa_port_parse_user(struct dsa_port *dp, const char *name)
{
	if (!name)
		name = "eth%d";

	dp->type = DSA_PORT_TYPE_USER;
	dp->name = name;

	return 0;
}

static int dsa_port_parse_dsa(struct dsa_port *dp)
{
	dp->type = DSA_PORT_TYPE_DSA;

	return 0;
}

static int dsa_port_parse_cpu(struct dsa_port *dp, struct net_device *master)
{
537 538 539 540 541
	struct dsa_switch *ds = dp->ds;
	struct dsa_switch_tree *dst = ds->dst;
	const struct dsa_device_ops *tag_ops;
	enum dsa_tag_protocol tag_protocol;

542
	tag_protocol = ds->ops->get_tag_protocol(ds, dp->index);
543 544 545 546 547 548
	tag_ops = dsa_resolve_tag_protocol(tag_protocol);
	if (IS_ERR(tag_ops)) {
		dev_warn(ds->dev, "No tagger for this switch\n");
		return PTR_ERR(tag_ops);
	}

549
	dp->type = DSA_PORT_TYPE_CPU;
550 551
	dp->rcv = tag_ops->rcv;
	dp->tag_ops = tag_ops;
552
	dp->master = master;
553
	dp->dst = dst;
554 555 556 557

	return 0;
}

558 559
static int dsa_port_parse_of(struct dsa_port *dp, struct device_node *dn)
{
560
	struct device_node *ethernet = of_parse_phandle(dn, "ethernet", 0);
561
	const char *name = of_get_property(dn, "label", NULL);
562
	bool link = of_property_read_bool(dn, "link");
563

564 565
	dp->dn = dn;

566
	if (ethernet) {
567 568 569 570 571 572
		struct net_device *master;

		master = of_find_net_device_by_node(ethernet);
		if (!master)
			return -EPROBE_DEFER;

573
		return dsa_port_parse_cpu(dp, master);
574 575
	}

576 577
	if (link)
		return dsa_port_parse_dsa(dp);
578

579
	return dsa_port_parse_user(dp, name);
580 581
}

V
Vivien Didelot 已提交
582 583
static int dsa_switch_parse_ports_of(struct dsa_switch *ds,
				     struct device_node *dn)
584
{
585
	struct device_node *ports, *port;
586
	struct dsa_port *dp;
587
	u32 reg;
588 589 590 591 592 593 594
	int err;

	ports = of_get_child_by_name(dn, "ports");
	if (!ports) {
		dev_err(ds->dev, "no ports child node found\n");
		return -EINVAL;
	}
595 596 597 598 599 600

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

601
		if (reg >= ds->num_ports)
602 603
			return -EINVAL;

604 605 606 607 608
		dp = &ds->ports[reg];

		err = dsa_port_parse_of(dp, port);
		if (err)
			return err;
609 610 611 612 613
	}

	return 0;
}

V
Vivien Didelot 已提交
614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646
static int dsa_switch_parse_member_of(struct dsa_switch *ds,
				      struct device_node *dn)
{
	u32 m[2] = { 0, 0 };
	int sz;

	/* Don't error out if this optional property isn't found */
	sz = of_property_read_variable_u32_array(dn, "dsa,member", m, 2, 2);
	if (sz < 0 && sz != -EINVAL)
		return sz;

	ds->index = m[1];
	if (ds->index >= DSA_MAX_SWITCHES)
		return -EINVAL;

	ds->dst = dsa_tree_touch(m[0]);
	if (!ds->dst)
		return -ENOMEM;

	return 0;
}

static int dsa_switch_parse_of(struct dsa_switch *ds, struct device_node *dn)
{
	int err;

	err = dsa_switch_parse_member_of(ds, dn);
	if (err)
		return err;

	return dsa_switch_parse_ports_of(ds, dn);
}

647 648 649
static int dsa_port_parse(struct dsa_port *dp, const char *name,
			  struct device *dev)
{
650
	if (!strcmp(name, "cpu")) {
651 652 653 654 655 656 657 658
		struct net_device *master;

		master = dsa_dev_to_net_device(dev);
		if (!master)
			return -EPROBE_DEFER;

		dev_put(master);

659
		return dsa_port_parse_cpu(dp, master);
660 661
	}

662 663
	if (!strcmp(name, "dsa"))
		return dsa_port_parse_dsa(dp);
664

665
	return dsa_port_parse_user(dp, name);
666 667
}

V
Vivien Didelot 已提交
668 669
static int dsa_switch_parse_ports(struct dsa_switch *ds,
				  struct dsa_chip_data *cd)
670 671
{
	bool valid_name_found = false;
672 673 674
	struct dsa_port *dp;
	struct device *dev;
	const char *name;
675
	unsigned int i;
676
	int err;
677 678

	for (i = 0; i < DSA_MAX_PORTS; i++) {
679 680 681 682 683
		name = cd->port_names[i];
		dev = cd->netdev[i];
		dp = &ds->ports[i];

		if (!name)
684 685
			continue;

686 687 688 689
		err = dsa_port_parse(dp, name, dev);
		if (err)
			return err;

690 691 692 693 694 695 696 697 698
		valid_name_found = true;
	}

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

	return 0;
}

V
Vivien Didelot 已提交
699
static int dsa_switch_parse(struct dsa_switch *ds, struct dsa_chip_data *cd)
700
{
V
Vivien Didelot 已提交
701
	ds->cd = cd;
702

V
Vivien Didelot 已提交
703 704 705 706 707 708 709
	/* We don't support interconnected switches nor multiple trees via
	 * platform data, so this is the unique switch of the tree.
	 */
	ds->index = 0;
	ds->dst = dsa_tree_touch(0);
	if (!ds->dst)
		return -ENOMEM;
710

V
Vivien Didelot 已提交
711
	return dsa_switch_parse_ports(ds, cd);
712 713
}

714 715 716 717 718 719 720
static int dsa_switch_add(struct dsa_switch *ds)
{
	struct dsa_switch_tree *dst = ds->dst;

	return dsa_tree_add_switch(dst, ds);
}

721
static int dsa_switch_probe(struct dsa_switch *ds)
722
{
723 724
	struct dsa_chip_data *pdata = ds->dev->platform_data;
	struct device_node *np = ds->dev->of_node;
V
Vivien Didelot 已提交
725
	int err;
726

V
Vivien Didelot 已提交
727 728 729 730 731 732
	if (np)
		err = dsa_switch_parse_of(ds, np);
	else if (pdata)
		err = dsa_switch_parse(ds, pdata);
	else
		err = -ENODEV;
733

V
Vivien Didelot 已提交
734 735
	if (err)
		return err;
736

737
	return dsa_switch_add(ds);
738 739
}

740 741 742 743
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;
744
	int i;
745 746 747 748 749 750 751 752

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

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

753 754 755 756 757
	for (i = 0; i < ds->num_ports; ++i) {
		ds->ports[i].index = i;
		ds->ports[i].ds = ds;
	}

758 759 760 761
	return ds;
}
EXPORT_SYMBOL_GPL(dsa_switch_alloc);

762
int dsa_register_switch(struct dsa_switch *ds)
763 764 765 766
{
	int err;

	mutex_lock(&dsa2_mutex);
767
	err = dsa_switch_probe(ds);
768 769 770 771 772 773
	mutex_unlock(&dsa2_mutex);

	return err;
}
EXPORT_SYMBOL_GPL(dsa_register_switch);

774
static void dsa_switch_remove(struct dsa_switch *ds)
775 776
{
	struct dsa_switch_tree *dst = ds->dst;
777
	unsigned int index = ds->index;
778

779
	dsa_tree_remove_switch(dst, index);
780 781 782 783 784
}

void dsa_unregister_switch(struct dsa_switch *ds)
{
	mutex_lock(&dsa2_mutex);
785
	dsa_switch_remove(ds);
786 787 788
	mutex_unlock(&dsa2_mutex);
}
EXPORT_SYMBOL_GPL(dsa_unregister_switch);