1// SPDX-License-Identifier: GPL-2.0-or-later
   2/*
   3 * DSA topology and switch handling
   4 *
   5 * Copyright (c) 2008-2009 Marvell Semiconductor
   6 * Copyright (c) 2013 Florian Fainelli <florian@openwrt.org>
   7 * Copyright (c) 2016 Andrew Lunn <andrew@lunn.ch>
   8 */
   9
  10#include <linux/device.h>
  11#include <linux/err.h>
  12#include <linux/list.h>
  13#include <linux/module.h>
  14#include <linux/netdevice.h>
  15#include <linux/slab.h>
  16#include <linux/rtnetlink.h>
 
  17#include <linux/of.h>
  18#include <linux/of_mdio.h>
 
  19#include <linux/of_net.h>
  20#include <net/sch_generic.h>
  21
  22#include "devlink.h"
  23#include "dsa.h"
  24#include "master.h"
  25#include "netlink.h"
  26#include "port.h"
  27#include "slave.h"
  28#include "switch.h"
  29#include "tag.h"
  30
  31#define DSA_MAX_NUM_OFFLOADING_BRIDGES		BITS_PER_LONG
  32
  33static DEFINE_MUTEX(dsa2_mutex);
  34LIST_HEAD(dsa_tree_list);
  35
  36static struct workqueue_struct *dsa_owq;
  37
  38/* Track the bridges with forwarding offload enabled */
  39static unsigned long dsa_fwd_offloading_bridges;
  40
  41bool dsa_schedule_work(struct work_struct *work)
  42{
  43	return queue_work(dsa_owq, work);
  44}
  45
  46void dsa_flush_workqueue(void)
  47{
  48	flush_workqueue(dsa_owq);
  49}
  50EXPORT_SYMBOL_GPL(dsa_flush_workqueue);
  51
  52/**
  53 * dsa_lag_map() - Map LAG structure to a linear LAG array
  54 * @dst: Tree in which to record the mapping.
  55 * @lag: LAG structure that is to be mapped to the tree's array.
  56 *
  57 * dsa_lag_id/dsa_lag_by_id can then be used to translate between the
  58 * two spaces. The size of the mapping space is determined by the
  59 * driver by setting ds->num_lag_ids. It is perfectly legal to leave
  60 * it unset if it is not needed, in which case these functions become
  61 * no-ops.
  62 */
  63void dsa_lag_map(struct dsa_switch_tree *dst, struct dsa_lag *lag)
  64{
  65	unsigned int id;
  66
  67	for (id = 1; id <= dst->lags_len; id++) {
  68		if (!dsa_lag_by_id(dst, id)) {
  69			dst->lags[id - 1] = lag;
  70			lag->id = id;
  71			return;
  72		}
  73	}
  74
  75	/* No IDs left, which is OK. Some drivers do not need it. The
  76	 * ones that do, e.g. mv88e6xxx, will discover that dsa_lag_id
  77	 * returns an error for this device when joining the LAG. The
  78	 * driver can then return -EOPNOTSUPP back to DSA, which will
  79	 * fall back to a software LAG.
  80	 */
  81}
  82
  83/**
  84 * dsa_lag_unmap() - Remove a LAG ID mapping
  85 * @dst: Tree in which the mapping is recorded.
  86 * @lag: LAG structure that was mapped.
  87 *
  88 * As there may be multiple users of the mapping, it is only removed
  89 * if there are no other references to it.
  90 */
  91void dsa_lag_unmap(struct dsa_switch_tree *dst, struct dsa_lag *lag)
  92{
  93	unsigned int id;
  94
  95	dsa_lags_foreach_id(id, dst) {
  96		if (dsa_lag_by_id(dst, id) == lag) {
  97			dst->lags[id - 1] = NULL;
  98			lag->id = 0;
  99			break;
 100		}
 101	}
 102}
 103
 104struct dsa_lag *dsa_tree_lag_find(struct dsa_switch_tree *dst,
 105				  const struct net_device *lag_dev)
 106{
 107	struct dsa_port *dp;
 108
 109	list_for_each_entry(dp, &dst->ports, list)
 110		if (dsa_port_lag_dev_get(dp) == lag_dev)
 111			return dp->lag;
 112
 113	return NULL;
 114}
 115
 116struct dsa_bridge *dsa_tree_bridge_find(struct dsa_switch_tree *dst,
 117					const struct net_device *br)
 118{
 119	struct dsa_port *dp;
 120
 121	list_for_each_entry(dp, &dst->ports, list)
 122		if (dsa_port_bridge_dev_get(dp) == br)
 123			return dp->bridge;
 124
 125	return NULL;
 126}
 127
 128static int dsa_bridge_num_find(const struct net_device *bridge_dev)
 129{
 130	struct dsa_switch_tree *dst;
 131
 132	list_for_each_entry(dst, &dsa_tree_list, list) {
 133		struct dsa_bridge *bridge;
 134
 135		bridge = dsa_tree_bridge_find(dst, bridge_dev);
 136		if (bridge)
 137			return bridge->num;
 138	}
 139
 140	return 0;
 141}
 142
 143unsigned int dsa_bridge_num_get(const struct net_device *bridge_dev, int max)
 144{
 145	unsigned int bridge_num = dsa_bridge_num_find(bridge_dev);
 146
 147	/* Switches without FDB isolation support don't get unique
 148	 * bridge numbering
 149	 */
 150	if (!max)
 151		return 0;
 152
 153	if (!bridge_num) {
 154		/* First port that requests FDB isolation or TX forwarding
 155		 * offload for this bridge
 156		 */
 157		bridge_num = find_next_zero_bit(&dsa_fwd_offloading_bridges,
 158						DSA_MAX_NUM_OFFLOADING_BRIDGES,
 159						1);
 160		if (bridge_num >= max)
 161			return 0;
 162
 163		set_bit(bridge_num, &dsa_fwd_offloading_bridges);
 164	}
 165
 166	return bridge_num;
 167}
 168
 169void dsa_bridge_num_put(const struct net_device *bridge_dev,
 170			unsigned int bridge_num)
 171{
 172	/* Since we refcount bridges, we know that when we call this function
 173	 * it is no longer in use, so we can just go ahead and remove it from
 174	 * the bit mask.
 175	 */
 176	clear_bit(bridge_num, &dsa_fwd_offloading_bridges);
 177}
 178
 179struct dsa_switch *dsa_switch_find(int tree_index, int sw_index)
 180{
 181	struct dsa_switch_tree *dst;
 182	struct dsa_port *dp;
 183
 184	list_for_each_entry(dst, &dsa_tree_list, list) {
 185		if (dst->index != tree_index)
 186			continue;
 187
 188		list_for_each_entry(dp, &dst->ports, list) {
 189			if (dp->ds->index != sw_index)
 190				continue;
 191
 192			return dp->ds;
 193		}
 194	}
 195
 196	return NULL;
 197}
 198EXPORT_SYMBOL_GPL(dsa_switch_find);
 199
 200static struct dsa_switch_tree *dsa_tree_find(int index)
 201{
 202	struct dsa_switch_tree *dst;
 203
 204	list_for_each_entry(dst, &dsa_tree_list, list)
 205		if (dst->index == index)
 206			return dst;
 207
 208	return NULL;
 209}
 210
 211static struct dsa_switch_tree *dsa_tree_alloc(int index)
 212{
 213	struct dsa_switch_tree *dst;
 214
 215	dst = kzalloc(sizeof(*dst), GFP_KERNEL);
 216	if (!dst)
 217		return NULL;
 218
 219	dst->index = index;
 220
 221	INIT_LIST_HEAD(&dst->rtable);
 222
 223	INIT_LIST_HEAD(&dst->ports);
 224
 225	INIT_LIST_HEAD(&dst->list);
 226	list_add_tail(&dst->list, &dsa_tree_list);
 227
 228	kref_init(&dst->refcount);
 229
 230	return dst;
 231}
 232
 233static void dsa_tree_free(struct dsa_switch_tree *dst)
 234{
 235	if (dst->tag_ops)
 236		dsa_tag_driver_put(dst->tag_ops);
 237	list_del(&dst->list);
 238	kfree(dst);
 239}
 240
 241static struct dsa_switch_tree *dsa_tree_get(struct dsa_switch_tree *dst)
 242{
 243	if (dst)
 244		kref_get(&dst->refcount);
 245
 246	return dst;
 247}
 248
 249static struct dsa_switch_tree *dsa_tree_touch(int index)
 250{
 251	struct dsa_switch_tree *dst;
 252
 253	dst = dsa_tree_find(index);
 254	if (dst)
 255		return dsa_tree_get(dst);
 256	else
 257		return dsa_tree_alloc(index);
 258}
 259
 260static void dsa_tree_release(struct kref *ref)
 261{
 262	struct dsa_switch_tree *dst;
 263
 264	dst = container_of(ref, struct dsa_switch_tree, refcount);
 265
 266	dsa_tree_free(dst);
 267}
 268
 269static void dsa_tree_put(struct dsa_switch_tree *dst)
 270{
 271	if (dst)
 272		kref_put(&dst->refcount, dsa_tree_release);
 273}
 274
 275static struct dsa_port *dsa_tree_find_port_by_node(struct dsa_switch_tree *dst,
 276						   struct device_node *dn)
 277{
 278	struct dsa_port *dp;
 279
 280	list_for_each_entry(dp, &dst->ports, list)
 281		if (dp->dn == dn)
 282			return dp;
 283
 284	return NULL;
 285}
 286
 287static struct dsa_link *dsa_link_touch(struct dsa_port *dp,
 288				       struct dsa_port *link_dp)
 289{
 290	struct dsa_switch *ds = dp->ds;
 291	struct dsa_switch_tree *dst;
 292	struct dsa_link *dl;
 293
 294	dst = ds->dst;
 295
 296	list_for_each_entry(dl, &dst->rtable, list)
 297		if (dl->dp == dp && dl->link_dp == link_dp)
 298			return dl;
 299
 300	dl = kzalloc(sizeof(*dl), GFP_KERNEL);
 301	if (!dl)
 302		return NULL;
 303
 304	dl->dp = dp;
 305	dl->link_dp = link_dp;
 306
 307	INIT_LIST_HEAD(&dl->list);
 308	list_add_tail(&dl->list, &dst->rtable);
 309
 310	return dl;
 311}
 312
 313static bool dsa_port_setup_routing_table(struct dsa_port *dp)
 314{
 315	struct dsa_switch *ds = dp->ds;
 316	struct dsa_switch_tree *dst = ds->dst;
 317	struct device_node *dn = dp->dn;
 318	struct of_phandle_iterator it;
 319	struct dsa_port *link_dp;
 320	struct dsa_link *dl;
 321	int err;
 322
 323	of_for_each_phandle(&it, err, dn, "link", NULL, 0) {
 324		link_dp = dsa_tree_find_port_by_node(dst, it.node);
 325		if (!link_dp) {
 326			of_node_put(it.node);
 327			return false;
 328		}
 329
 330		dl = dsa_link_touch(dp, link_dp);
 331		if (!dl) {
 332			of_node_put(it.node);
 333			return false;
 334		}
 335	}
 336
 337	return true;
 338}
 339
 340static bool dsa_tree_setup_routing_table(struct dsa_switch_tree *dst)
 341{
 342	bool complete = true;
 343	struct dsa_port *dp;
 344
 345	list_for_each_entry(dp, &dst->ports, list) {
 346		if (dsa_port_is_dsa(dp)) {
 347			complete = dsa_port_setup_routing_table(dp);
 348			if (!complete)
 349				break;
 350		}
 351	}
 352
 353	return complete;
 354}
 355
 356static struct dsa_port *dsa_tree_find_first_cpu(struct dsa_switch_tree *dst)
 357{
 358	struct dsa_port *dp;
 359
 360	list_for_each_entry(dp, &dst->ports, list)
 361		if (dsa_port_is_cpu(dp))
 362			return dp;
 363
 364	return NULL;
 365}
 366
 367struct net_device *dsa_tree_find_first_master(struct dsa_switch_tree *dst)
 368{
 369	struct device_node *ethernet;
 370	struct net_device *master;
 371	struct dsa_port *cpu_dp;
 372
 373	cpu_dp = dsa_tree_find_first_cpu(dst);
 374	ethernet = of_parse_phandle(cpu_dp->dn, "ethernet", 0);
 375	master = of_find_net_device_by_node(ethernet);
 376	of_node_put(ethernet);
 377
 378	return master;
 379}
 380
 381/* Assign the default CPU port (the first one in the tree) to all ports of the
 382 * fabric which don't already have one as part of their own switch.
 383 */
 384static int dsa_tree_setup_default_cpu(struct dsa_switch_tree *dst)
 385{
 386	struct dsa_port *cpu_dp, *dp;
 387
 388	cpu_dp = dsa_tree_find_first_cpu(dst);
 389	if (!cpu_dp) {
 390		pr_err("DSA: tree %d has no CPU port\n", dst->index);
 391		return -EINVAL;
 392	}
 393
 394	list_for_each_entry(dp, &dst->ports, list) {
 395		if (dp->cpu_dp)
 396			continue;
 397
 398		if (dsa_port_is_user(dp) || dsa_port_is_dsa(dp))
 399			dp->cpu_dp = cpu_dp;
 400	}
 401
 402	return 0;
 403}
 404
 405/* Perform initial assignment of CPU ports to user ports and DSA links in the
 406 * fabric, giving preference to CPU ports local to each switch. Default to
 407 * using the first CPU port in the switch tree if the port does not have a CPU
 408 * port local to this switch.
 409 */
 410static int dsa_tree_setup_cpu_ports(struct dsa_switch_tree *dst)
 411{
 412	struct dsa_port *cpu_dp, *dp;
 413
 414	list_for_each_entry(cpu_dp, &dst->ports, list) {
 415		if (!dsa_port_is_cpu(cpu_dp))
 416			continue;
 417
 418		/* Prefer a local CPU port */
 419		dsa_switch_for_each_port(dp, cpu_dp->ds) {
 420			/* Prefer the first local CPU port found */
 421			if (dp->cpu_dp)
 422				continue;
 423
 424			if (dsa_port_is_user(dp) || dsa_port_is_dsa(dp))
 425				dp->cpu_dp = cpu_dp;
 426		}
 427	}
 428
 429	return dsa_tree_setup_default_cpu(dst);
 430}
 431
 432static void dsa_tree_teardown_cpu_ports(struct dsa_switch_tree *dst)
 433{
 434	struct dsa_port *dp;
 435
 436	list_for_each_entry(dp, &dst->ports, list)
 437		if (dsa_port_is_user(dp) || dsa_port_is_dsa(dp))
 438			dp->cpu_dp = NULL;
 439}
 440
 441static int dsa_port_setup(struct dsa_port *dp)
 442{
 443	bool dsa_port_link_registered = false;
 444	struct dsa_switch *ds = dp->ds;
 445	bool dsa_port_enabled = false;
 446	int err = 0;
 447
 448	if (dp->setup)
 449		return 0;
 450
 451	err = dsa_port_devlink_setup(dp);
 452	if (err)
 453		return err;
 454
 455	switch (dp->type) {
 456	case DSA_PORT_TYPE_UNUSED:
 457		dsa_port_disable(dp);
 458		break;
 459	case DSA_PORT_TYPE_CPU:
 460		if (dp->dn) {
 461			err = dsa_shared_port_link_register_of(dp);
 462			if (err)
 463				break;
 464			dsa_port_link_registered = true;
 465		} else {
 466			dev_warn(ds->dev,
 467				 "skipping link registration for CPU port %d\n",
 468				 dp->index);
 469		}
 470
 471		err = dsa_port_enable(dp, NULL);
 472		if (err)
 473			break;
 474		dsa_port_enabled = true;
 475
 476		break;
 477	case DSA_PORT_TYPE_DSA:
 478		if (dp->dn) {
 479			err = dsa_shared_port_link_register_of(dp);
 480			if (err)
 481				break;
 482			dsa_port_link_registered = true;
 483		} else {
 484			dev_warn(ds->dev,
 485				 "skipping link registration for DSA port %d\n",
 486				 dp->index);
 487		}
 488
 489		err = dsa_port_enable(dp, NULL);
 490		if (err)
 491			break;
 492		dsa_port_enabled = true;
 493
 494		break;
 495	case DSA_PORT_TYPE_USER:
 496		of_get_mac_address(dp->dn, dp->mac);
 497		err = dsa_slave_create(dp);
 498		break;
 499	}
 500
 501	if (err && dsa_port_enabled)
 502		dsa_port_disable(dp);
 503	if (err && dsa_port_link_registered)
 504		dsa_shared_port_link_unregister_of(dp);
 505	if (err) {
 506		dsa_port_devlink_teardown(dp);
 507		return err;
 508	}
 509
 510	dp->setup = true;
 511
 512	return 0;
 513}
 514
 515static void dsa_port_teardown(struct dsa_port *dp)
 516{
 517	if (!dp->setup)
 518		return;
 519
 520	switch (dp->type) {
 521	case DSA_PORT_TYPE_UNUSED:
 522		break;
 523	case DSA_PORT_TYPE_CPU:
 524		dsa_port_disable(dp);
 525		if (dp->dn)
 526			dsa_shared_port_link_unregister_of(dp);
 527		break;
 528	case DSA_PORT_TYPE_DSA:
 529		dsa_port_disable(dp);
 530		if (dp->dn)
 531			dsa_shared_port_link_unregister_of(dp);
 532		break;
 533	case DSA_PORT_TYPE_USER:
 534		if (dp->slave) {
 535			dsa_slave_destroy(dp->slave);
 536			dp->slave = NULL;
 537		}
 538		break;
 539	}
 540
 541	dsa_port_devlink_teardown(dp);
 542
 543	dp->setup = false;
 544}
 545
 546static int dsa_port_setup_as_unused(struct dsa_port *dp)
 547{
 548	dp->type = DSA_PORT_TYPE_UNUSED;
 549	return dsa_port_setup(dp);
 550}
 551
 552static int dsa_switch_setup_tag_protocol(struct dsa_switch *ds)
 553{
 554	const struct dsa_device_ops *tag_ops = ds->dst->tag_ops;
 555	struct dsa_switch_tree *dst = ds->dst;
 556	int err;
 557
 558	if (tag_ops->proto == dst->default_proto)
 559		goto connect;
 560
 561	rtnl_lock();
 562	err = ds->ops->change_tag_protocol(ds, tag_ops->proto);
 563	rtnl_unlock();
 564	if (err) {
 565		dev_err(ds->dev, "Unable to use tag protocol \"%s\": %pe\n",
 566			tag_ops->name, ERR_PTR(err));
 567		return err;
 568	}
 569
 570connect:
 571	if (tag_ops->connect) {
 572		err = tag_ops->connect(ds);
 573		if (err)
 574			return err;
 575	}
 576
 577	if (ds->ops->connect_tag_protocol) {
 578		err = ds->ops->connect_tag_protocol(ds, tag_ops->proto);
 579		if (err) {
 580			dev_err(ds->dev,
 581				"Unable to connect to tag protocol \"%s\": %pe\n",
 582				tag_ops->name, ERR_PTR(err));
 583			goto disconnect;
 584		}
 585	}
 586
 587	return 0;
 588
 589disconnect:
 590	if (tag_ops->disconnect)
 591		tag_ops->disconnect(ds);
 592
 593	return err;
 594}
 595
 596static void dsa_switch_teardown_tag_protocol(struct dsa_switch *ds)
 
 597{
 598	const struct dsa_device_ops *tag_ops = ds->dst->tag_ops;
 599
 600	if (tag_ops->disconnect)
 601		tag_ops->disconnect(ds);
 602}
 603
 604static int dsa_switch_setup(struct dsa_switch *ds)
 605{
 606	struct device_node *dn;
 607	int err;
 608
 609	if (ds->setup)
 610		return 0;
 611
 612	/* Initialize ds->phys_mii_mask before registering the slave MDIO bus
 613	 * driver and before ops->setup() has run, since the switch drivers and
 614	 * the slave MDIO bus driver rely on these values for probing PHY
 615	 * devices or not
 616	 */
 617	ds->phys_mii_mask |= dsa_user_ports(ds);
 618
 619	err = dsa_switch_devlink_alloc(ds);
 620	if (err)
 621		return err;
 622
 623	err = dsa_switch_register_notifier(ds);
 624	if (err)
 625		goto devlink_free;
 626
 627	ds->configure_vlan_while_not_filtering = true;
 628
 629	err = ds->ops->setup(ds);
 630	if (err < 0)
 631		goto unregister_notifier;
 632
 633	err = dsa_switch_setup_tag_protocol(ds);
 634	if (err)
 635		goto teardown;
 636
 637	if (!ds->slave_mii_bus && ds->ops->phy_read) {
 638		ds->slave_mii_bus = mdiobus_alloc();
 639		if (!ds->slave_mii_bus) {
 640			err = -ENOMEM;
 641			goto teardown;
 642		}
 643
 644		dsa_slave_mii_bus_init(ds);
 645
 646		dn = of_get_child_by_name(ds->dev->of_node, "mdio");
 647
 648		err = of_mdiobus_register(ds->slave_mii_bus, dn);
 649		of_node_put(dn);
 650		if (err < 0)
 651			goto free_slave_mii_bus;
 652	}
 653
 654	dsa_switch_devlink_register(ds);
 655
 656	ds->setup = true;
 657	return 0;
 658
 659free_slave_mii_bus:
 660	if (ds->slave_mii_bus && ds->ops->phy_read)
 661		mdiobus_free(ds->slave_mii_bus);
 662teardown:
 663	if (ds->ops->teardown)
 664		ds->ops->teardown(ds);
 665unregister_notifier:
 666	dsa_switch_unregister_notifier(ds);
 667devlink_free:
 668	dsa_switch_devlink_free(ds);
 669	return err;
 670}
 671
 672static void dsa_switch_teardown(struct dsa_switch *ds)
 
 673{
 674	if (!ds->setup)
 675		return;
 676
 677	dsa_switch_devlink_unregister(ds);
 678
 679	if (ds->slave_mii_bus && ds->ops->phy_read) {
 680		mdiobus_unregister(ds->slave_mii_bus);
 681		mdiobus_free(ds->slave_mii_bus);
 682		ds->slave_mii_bus = NULL;
 683	}
 684
 685	dsa_switch_teardown_tag_protocol(ds);
 686
 687	if (ds->ops->teardown)
 688		ds->ops->teardown(ds);
 689
 690	dsa_switch_unregister_notifier(ds);
 691
 692	dsa_switch_devlink_free(ds);
 693
 694	ds->setup = false;
 695}
 696
 697/* First tear down the non-shared, then the shared ports. This ensures that
 698 * all work items scheduled by our switchdev handlers for user ports have
 699 * completed before we destroy the refcounting kept on the shared ports.
 700 */
 701static void dsa_tree_teardown_ports(struct dsa_switch_tree *dst)
 702{
 703	struct dsa_port *dp;
 704
 705	list_for_each_entry(dp, &dst->ports, list)
 706		if (dsa_port_is_user(dp) || dsa_port_is_unused(dp))
 707			dsa_port_teardown(dp);
 708
 709	dsa_flush_workqueue();
 710
 711	list_for_each_entry(dp, &dst->ports, list)
 712		if (dsa_port_is_dsa(dp) || dsa_port_is_cpu(dp))
 713			dsa_port_teardown(dp);
 714}
 715
 716static void dsa_tree_teardown_switches(struct dsa_switch_tree *dst)
 717{
 718	struct dsa_port *dp;
 719
 720	list_for_each_entry(dp, &dst->ports, list)
 721		dsa_switch_teardown(dp->ds);
 722}
 
 723
 724/* Bring shared ports up first, then non-shared ports */
 725static int dsa_tree_setup_ports(struct dsa_switch_tree *dst)
 726{
 727	struct dsa_port *dp;
 728	int err = 0;
 729
 730	list_for_each_entry(dp, &dst->ports, list) {
 731		if (dsa_port_is_dsa(dp) || dsa_port_is_cpu(dp)) {
 732			err = dsa_port_setup(dp);
 733			if (err)
 734				goto teardown;
 735		}
 736	}
 737
 738	list_for_each_entry(dp, &dst->ports, list) {
 739		if (dsa_port_is_user(dp) || dsa_port_is_unused(dp)) {
 740			err = dsa_port_setup(dp);
 741			if (err) {
 742				err = dsa_port_setup_as_unused(dp);
 743				if (err)
 744					goto teardown;
 745			}
 746		}
 747	}
 748
 749	return 0;
 750
 751teardown:
 752	dsa_tree_teardown_ports(dst);
 753
 754	return err;
 
 755}
 
 756
 757static int dsa_tree_setup_switches(struct dsa_switch_tree *dst)
 758{
 759	struct dsa_port *dp;
 760	int err = 0;
 761
 762	list_for_each_entry(dp, &dst->ports, list) {
 763		err = dsa_switch_setup(dp->ds);
 764		if (err) {
 765			dsa_tree_teardown_switches(dst);
 766			break;
 767		}
 768	}
 769
 770	return err;
 771}
 772
 773static int dsa_tree_setup_master(struct dsa_switch_tree *dst)
 774{
 775	struct dsa_port *cpu_dp;
 776	int err = 0;
 
 
 777
 778	rtnl_lock();
 
 779
 780	dsa_tree_for_each_cpu_port(cpu_dp, dst) {
 781		struct net_device *master = cpu_dp->master;
 782		bool admin_up = (master->flags & IFF_UP) &&
 783				!qdisc_tx_is_noop(master);
 784
 785		err = dsa_master_setup(master, cpu_dp);
 786		if (err)
 
 
 
 787			break;
 788
 789		/* Replay master state event */
 790		dsa_tree_master_admin_state_change(dst, master, admin_up);
 791		dsa_tree_master_oper_state_change(dst, master,
 792						  netif_oper_up(master));
 793	}
 794
 795	rtnl_unlock();
 796
 797	return err;
 798}
 799
 800static void dsa_tree_teardown_master(struct dsa_switch_tree *dst)
 801{
 802	struct dsa_port *cpu_dp;
 803
 804	rtnl_lock();
 805
 806	dsa_tree_for_each_cpu_port(cpu_dp, dst) {
 807		struct net_device *master = cpu_dp->master;
 808
 809		/* Synthesizing an "admin down" state is sufficient for
 810		 * the switches to get a notification if the master is
 811		 * currently up and running.
 812		 */
 813		dsa_tree_master_admin_state_change(dst, master, false);
 814
 815		dsa_master_teardown(master);
 816	}
 817
 818	rtnl_unlock();
 819}
 820
 821static int dsa_tree_setup_lags(struct dsa_switch_tree *dst)
 822{
 823	unsigned int len = 0;
 824	struct dsa_port *dp;
 825
 826	list_for_each_entry(dp, &dst->ports, list) {
 827		if (dp->ds->num_lag_ids > len)
 828			len = dp->ds->num_lag_ids;
 829	}
 830
 831	if (!len)
 832		return 0;
 833
 834	dst->lags = kcalloc(len, sizeof(*dst->lags), GFP_KERNEL);
 835	if (!dst->lags)
 836		return -ENOMEM;
 837
 838	dst->lags_len = len;
 839	return 0;
 840}
 841
 842static void dsa_tree_teardown_lags(struct dsa_switch_tree *dst)
 843{
 844	kfree(dst->lags);
 845}
 846
 847static int dsa_tree_setup(struct dsa_switch_tree *dst)
 848{
 849	bool complete;
 850	int err;
 851
 852	if (dst->setup) {
 853		pr_err("DSA: tree %d already setup! Disjoint trees?\n",
 854		       dst->index);
 855		return -EEXIST;
 856	}
 857
 858	complete = dsa_tree_setup_routing_table(dst);
 859	if (!complete)
 860		return 0;
 861
 862	err = dsa_tree_setup_cpu_ports(dst);
 863	if (err)
 864		return err;
 865
 866	err = dsa_tree_setup_switches(dst);
 867	if (err)
 868		goto teardown_cpu_ports;
 869
 870	err = dsa_tree_setup_ports(dst);
 871	if (err)
 872		goto teardown_switches;
 873
 874	err = dsa_tree_setup_master(dst);
 875	if (err)
 876		goto teardown_ports;
 877
 878	err = dsa_tree_setup_lags(dst);
 879	if (err)
 880		goto teardown_master;
 881
 882	dst->setup = true;
 883
 884	pr_info("DSA: tree %d setup\n", dst->index);
 885
 886	return 0;
 887
 888teardown_master:
 889	dsa_tree_teardown_master(dst);
 890teardown_ports:
 891	dsa_tree_teardown_ports(dst);
 892teardown_switches:
 893	dsa_tree_teardown_switches(dst);
 894teardown_cpu_ports:
 895	dsa_tree_teardown_cpu_ports(dst);
 896
 897	return err;
 898}
 899
 900static void dsa_tree_teardown(struct dsa_switch_tree *dst)
 901{
 902	struct dsa_link *dl, *next;
 903
 904	if (!dst->setup)
 905		return;
 906
 907	dsa_tree_teardown_lags(dst);
 908
 909	dsa_tree_teardown_master(dst);
 910
 911	dsa_tree_teardown_ports(dst);
 912
 913	dsa_tree_teardown_switches(dst);
 914
 915	dsa_tree_teardown_cpu_ports(dst);
 916
 917	list_for_each_entry_safe(dl, next, &dst->rtable, list) {
 918		list_del(&dl->list);
 919		kfree(dl);
 920	}
 921
 922	pr_info("DSA: tree %d torn down\n", dst->index);
 923
 924	dst->setup = false;
 925}
 926
 927static int dsa_tree_bind_tag_proto(struct dsa_switch_tree *dst,
 928				   const struct dsa_device_ops *tag_ops)
 929{
 930	const struct dsa_device_ops *old_tag_ops = dst->tag_ops;
 931	struct dsa_notifier_tag_proto_info info;
 932	int err;
 933
 934	dst->tag_ops = tag_ops;
 935
 936	/* Notify the switches from this tree about the connection
 937	 * to the new tagger
 938	 */
 939	info.tag_ops = tag_ops;
 940	err = dsa_tree_notify(dst, DSA_NOTIFIER_TAG_PROTO_CONNECT, &info);
 941	if (err && err != -EOPNOTSUPP)
 942		goto out_disconnect;
 943
 944	/* Notify the old tagger about the disconnection from this tree */
 945	info.tag_ops = old_tag_ops;
 946	dsa_tree_notify(dst, DSA_NOTIFIER_TAG_PROTO_DISCONNECT, &info);
 947
 948	return 0;
 949
 950out_disconnect:
 951	info.tag_ops = tag_ops;
 952	dsa_tree_notify(dst, DSA_NOTIFIER_TAG_PROTO_DISCONNECT, &info);
 953	dst->tag_ops = old_tag_ops;
 954
 955	return err;
 956}
 957
 958/* Since the dsa/tagging sysfs device attribute is per master, the assumption
 959 * is that all DSA switches within a tree share the same tagger, otherwise
 960 * they would have formed disjoint trees (different "dsa,member" values).
 961 */
 962int dsa_tree_change_tag_proto(struct dsa_switch_tree *dst,
 963			      const struct dsa_device_ops *tag_ops,
 964			      const struct dsa_device_ops *old_tag_ops)
 965{
 966	struct dsa_notifier_tag_proto_info info;
 967	struct dsa_port *dp;
 968	int err = -EBUSY;
 969
 970	if (!rtnl_trylock())
 971		return restart_syscall();
 972
 973	/* At the moment we don't allow changing the tag protocol under
 974	 * traffic. The rtnl_mutex also happens to serialize concurrent
 975	 * attempts to change the tagging protocol. If we ever lift the IFF_UP
 976	 * restriction, there needs to be another mutex which serializes this.
 977	 */
 978	dsa_tree_for_each_user_port(dp, dst) {
 979		if (dsa_port_to_master(dp)->flags & IFF_UP)
 980			goto out_unlock;
 981
 982		if (dp->slave->flags & IFF_UP)
 983			goto out_unlock;
 984	}
 985
 986	/* Notify the tag protocol change */
 987	info.tag_ops = tag_ops;
 988	err = dsa_tree_notify(dst, DSA_NOTIFIER_TAG_PROTO, &info);
 989	if (err)
 990		goto out_unwind_tagger;
 991
 992	err = dsa_tree_bind_tag_proto(dst, tag_ops);
 993	if (err)
 994		goto out_unwind_tagger;
 995
 996	rtnl_unlock();
 997
 998	return 0;
 999
1000out_unwind_tagger:
1001	info.tag_ops = old_tag_ops;
1002	dsa_tree_notify(dst, DSA_NOTIFIER_TAG_PROTO, &info);
1003out_unlock:
1004	rtnl_unlock();
1005	return err;
1006}
1007
1008static void dsa_tree_master_state_change(struct dsa_switch_tree *dst,
1009					 struct net_device *master)
1010{
1011	struct dsa_notifier_master_state_info info;
1012	struct dsa_port *cpu_dp = master->dsa_ptr;
1013
1014	info.master = master;
1015	info.operational = dsa_port_master_is_operational(cpu_dp);
1016
1017	dsa_tree_notify(dst, DSA_NOTIFIER_MASTER_STATE_CHANGE, &info);
1018}
1019
1020void dsa_tree_master_admin_state_change(struct dsa_switch_tree *dst,
1021					struct net_device *master,
1022					bool up)
1023{
1024	struct dsa_port *cpu_dp = master->dsa_ptr;
1025	bool notify = false;
1026
1027	/* Don't keep track of admin state on LAG DSA masters,
1028	 * but rather just of physical DSA masters
1029	 */
1030	if (netif_is_lag_master(master))
1031		return;
1032
1033	if ((dsa_port_master_is_operational(cpu_dp)) !=
1034	    (up && cpu_dp->master_oper_up))
1035		notify = true;
1036
1037	cpu_dp->master_admin_up = up;
1038
1039	if (notify)
1040		dsa_tree_master_state_change(dst, master);
1041}
1042
1043void dsa_tree_master_oper_state_change(struct dsa_switch_tree *dst,
1044				       struct net_device *master,
1045				       bool up)
1046{
1047	struct dsa_port *cpu_dp = master->dsa_ptr;
1048	bool notify = false;
1049
1050	/* Don't keep track of oper state on LAG DSA masters,
1051	 * but rather just of physical DSA masters
1052	 */
1053	if (netif_is_lag_master(master))
1054		return;
1055
1056	if ((dsa_port_master_is_operational(cpu_dp)) !=
1057	    (cpu_dp->master_admin_up && up))
1058		notify = true;
1059
1060	cpu_dp->master_oper_up = up;
1061
1062	if (notify)
1063		dsa_tree_master_state_change(dst, master);
1064}
1065
1066static struct dsa_port *dsa_port_touch(struct dsa_switch *ds, int index)
1067{
1068	struct dsa_switch_tree *dst = ds->dst;
1069	struct dsa_port *dp;
1070
1071	dsa_switch_for_each_port(dp, ds)
1072		if (dp->index == index)
1073			return dp;
1074
1075	dp = kzalloc(sizeof(*dp), GFP_KERNEL);
1076	if (!dp)
1077		return NULL;
1078
1079	dp->ds = ds;
1080	dp->index = index;
1081
1082	mutex_init(&dp->addr_lists_lock);
1083	mutex_init(&dp->vlans_lock);
1084	INIT_LIST_HEAD(&dp->fdbs);
1085	INIT_LIST_HEAD(&dp->mdbs);
1086	INIT_LIST_HEAD(&dp->vlans);
1087	INIT_LIST_HEAD(&dp->list);
1088	list_add_tail(&dp->list, &dst->ports);
1089
1090	return dp;
1091}
1092
1093static int dsa_port_parse_user(struct dsa_port *dp, const char *name)
1094{
1095	dp->type = DSA_PORT_TYPE_USER;
1096	dp->name = name;
1097
1098	return 0;
1099}
1100
1101static int dsa_port_parse_dsa(struct dsa_port *dp)
1102{
1103	dp->type = DSA_PORT_TYPE_DSA;
1104
1105	return 0;
1106}
1107
1108static enum dsa_tag_protocol dsa_get_tag_protocol(struct dsa_port *dp,
1109						  struct net_device *master)
1110{
1111	enum dsa_tag_protocol tag_protocol = DSA_TAG_PROTO_NONE;
1112	struct dsa_switch *mds, *ds = dp->ds;
1113	unsigned int mdp_upstream;
1114	struct dsa_port *mdp;
1115
1116	/* It is possible to stack DSA switches onto one another when that
1117	 * happens the switch driver may want to know if its tagging protocol
1118	 * is going to work in such a configuration.
1119	 */
1120	if (dsa_slave_dev_check(master)) {
1121		mdp = dsa_slave_to_port(master);
1122		mds = mdp->ds;
1123		mdp_upstream = dsa_upstream_port(mds, mdp->index);
1124		tag_protocol = mds->ops->get_tag_protocol(mds, mdp_upstream,
1125							  DSA_TAG_PROTO_NONE);
1126	}
1127
1128	/* If the master device is not itself a DSA slave in a disjoint DSA
1129	 * tree, then return immediately.
1130	 */
1131	return ds->ops->get_tag_protocol(ds, dp->index, tag_protocol);
1132}
1133
1134static int dsa_port_parse_cpu(struct dsa_port *dp, struct net_device *master,
1135			      const char *user_protocol)
1136{
1137	const struct dsa_device_ops *tag_ops = NULL;
1138	struct dsa_switch *ds = dp->ds;
1139	struct dsa_switch_tree *dst = ds->dst;
1140	enum dsa_tag_protocol default_proto;
1141
1142	/* Find out which protocol the switch would prefer. */
1143	default_proto = dsa_get_tag_protocol(dp, master);
1144	if (dst->default_proto) {
1145		if (dst->default_proto != default_proto) {
1146			dev_err(ds->dev,
1147				"A DSA switch tree can have only one tagging protocol\n");
1148			return -EINVAL;
1149		}
1150	} else {
1151		dst->default_proto = default_proto;
1152	}
1153
1154	/* See if the user wants to override that preference. */
1155	if (user_protocol) {
1156		if (!ds->ops->change_tag_protocol) {
1157			dev_err(ds->dev, "Tag protocol cannot be modified\n");
1158			return -EINVAL;
1159		}
1160
1161		tag_ops = dsa_tag_driver_get_by_name(user_protocol);
1162		if (IS_ERR(tag_ops)) {
1163			dev_warn(ds->dev,
1164				 "Failed to find a tagging driver for protocol %s, using default\n",
1165				 user_protocol);
1166			tag_ops = NULL;
1167		}
1168	}
1169
1170	if (!tag_ops)
1171		tag_ops = dsa_tag_driver_get_by_id(default_proto);
1172
1173	if (IS_ERR(tag_ops)) {
1174		if (PTR_ERR(tag_ops) == -ENOPROTOOPT)
1175			return -EPROBE_DEFER;
1176
1177		dev_warn(ds->dev, "No tagger for this switch\n");
1178		return PTR_ERR(tag_ops);
1179	}
1180
1181	if (dst->tag_ops) {
1182		if (dst->tag_ops != tag_ops) {
1183			dev_err(ds->dev,
1184				"A DSA switch tree can have only one tagging protocol\n");
1185
1186			dsa_tag_driver_put(tag_ops);
1187			return -EINVAL;
1188		}
1189
1190		/* In the case of multiple CPU ports per switch, the tagging
1191		 * protocol is still reference-counted only per switch tree.
1192		 */
1193		dsa_tag_driver_put(tag_ops);
1194	} else {
1195		dst->tag_ops = tag_ops;
1196	}
1197
1198	dp->master = master;
1199	dp->type = DSA_PORT_TYPE_CPU;
1200	dsa_port_set_tag_protocol(dp, dst->tag_ops);
1201	dp->dst = dst;
1202
1203	/* At this point, the tree may be configured to use a different
1204	 * tagger than the one chosen by the switch driver during
1205	 * .setup, in the case when a user selects a custom protocol
1206	 * through the DT.
1207	 *
1208	 * This is resolved by syncing the driver with the tree in
1209	 * dsa_switch_setup_tag_protocol once .setup has run and the
1210	 * driver is ready to accept calls to .change_tag_protocol. If
1211	 * the driver does not support the custom protocol at that
1212	 * point, the tree is wholly rejected, thereby ensuring that the
1213	 * tree and driver are always in agreement on the protocol to
1214	 * use.
1215	 */
1216	return 0;
1217}
1218
1219static int dsa_port_parse_of(struct dsa_port *dp, struct device_node *dn)
1220{
1221	struct device_node *ethernet = of_parse_phandle(dn, "ethernet", 0);
1222	const char *name = of_get_property(dn, "label", NULL);
1223	bool link = of_property_read_bool(dn, "link");
1224
1225	dp->dn = dn;
1226
1227	if (ethernet) {
1228		struct net_device *master;
1229		const char *user_protocol;
1230
1231		master = of_find_net_device_by_node(ethernet);
1232		of_node_put(ethernet);
1233		if (!master)
1234			return -EPROBE_DEFER;
1235
1236		user_protocol = of_get_property(dn, "dsa-tag-protocol", NULL);
1237		return dsa_port_parse_cpu(dp, master, user_protocol);
1238	}
1239
1240	if (link)
1241		return dsa_port_parse_dsa(dp);
1242
1243	return dsa_port_parse_user(dp, name);
1244}
1245
1246static int dsa_switch_parse_ports_of(struct dsa_switch *ds,
1247				     struct device_node *dn)
1248{
1249	struct device_node *ports, *port;
1250	struct dsa_port *dp;
1251	int err = 0;
1252	u32 reg;
1253
1254	ports = of_get_child_by_name(dn, "ports");
1255	if (!ports) {
1256		/* The second possibility is "ethernet-ports" */
1257		ports = of_get_child_by_name(dn, "ethernet-ports");
1258		if (!ports) {
1259			dev_err(ds->dev, "no ports child node found\n");
1260			return -EINVAL;
1261		}
1262	}
1263
1264	for_each_available_child_of_node(ports, port) {
1265		err = of_property_read_u32(port, "reg", &reg);
1266		if (err) {
1267			of_node_put(port);
1268			goto out_put_node;
1269		}
1270
1271		if (reg >= ds->num_ports) {
1272			dev_err(ds->dev, "port %pOF index %u exceeds num_ports (%u)\n",
1273				port, reg, ds->num_ports);
1274			of_node_put(port);
1275			err = -EINVAL;
1276			goto out_put_node;
1277		}
1278
1279		dp = dsa_to_port(ds, reg);
1280
1281		err = dsa_port_parse_of(dp, port);
1282		if (err) {
1283			of_node_put(port);
1284			goto out_put_node;
 
1285		}
1286	}
1287
1288out_put_node:
1289	of_node_put(ports);
1290	return err;
1291}
1292
1293static int dsa_switch_parse_member_of(struct dsa_switch *ds,
1294				      struct device_node *dn)
1295{
1296	u32 m[2] = { 0, 0 };
1297	int sz;
1298
1299	/* Don't error out if this optional property isn't found */
1300	sz = of_property_read_variable_u32_array(dn, "dsa,member", m, 2, 2);
1301	if (sz < 0 && sz != -EINVAL)
1302		return sz;
1303
1304	ds->index = m[1];
1305
1306	ds->dst = dsa_tree_touch(m[0]);
1307	if (!ds->dst)
1308		return -ENOMEM;
1309
1310	if (dsa_switch_find(ds->dst->index, ds->index)) {
1311		dev_err(ds->dev,
1312			"A DSA switch with index %d already exists in tree %d\n",
1313			ds->index, ds->dst->index);
1314		return -EEXIST;
1315	}
1316
1317	if (ds->dst->last_switch < ds->index)
1318		ds->dst->last_switch = ds->index;
1319
1320	return 0;
1321}
1322
1323static int dsa_switch_touch_ports(struct dsa_switch *ds)
1324{
1325	struct dsa_port *dp;
1326	int port;
1327
1328	for (port = 0; port < ds->num_ports; port++) {
1329		dp = dsa_port_touch(ds, port);
1330		if (!dp)
1331			return -ENOMEM;
1332	}
1333
1334	return 0;
1335}
1336
1337static int dsa_switch_parse_of(struct dsa_switch *ds, struct device_node *dn)
1338{
1339	int err;
1340
1341	err = dsa_switch_parse_member_of(ds, dn);
1342	if (err)
1343		return err;
1344
1345	err = dsa_switch_touch_ports(ds);
1346	if (err)
1347		return err;
1348
1349	return dsa_switch_parse_ports_of(ds, dn);
1350}
1351
1352static int dev_is_class(struct device *dev, void *class)
1353{
1354	if (dev->class != NULL && !strcmp(dev->class->name, class))
1355		return 1;
1356
1357	return 0;
1358}
1359
1360static struct device *dev_find_class(struct device *parent, char *class)
1361{
1362	if (dev_is_class(parent, class)) {
1363		get_device(parent);
1364		return parent;
1365	}
1366
1367	return device_find_child(parent, class, dev_is_class);
1368}
1369
1370static struct net_device *dsa_dev_to_net_device(struct device *dev)
1371{
1372	struct device *d;
1373
1374	d = dev_find_class(dev, "net");
1375	if (d != NULL) {
1376		struct net_device *nd;
1377
1378		nd = to_net_dev(d);
1379		dev_hold(nd);
1380		put_device(d);
1381
1382		return nd;
1383	}
1384
1385	return NULL;
1386}
 
1387
1388static int dsa_port_parse(struct dsa_port *dp, const char *name,
1389			  struct device *dev)
1390{
1391	if (!strcmp(name, "cpu")) {
1392		struct net_device *master;
1393
1394		master = dsa_dev_to_net_device(dev);
1395		if (!master)
1396			return -EPROBE_DEFER;
1397
1398		dev_put(master);
1399
1400		return dsa_port_parse_cpu(dp, master, NULL);
1401	}
1402
1403	if (!strcmp(name, "dsa"))
1404		return dsa_port_parse_dsa(dp);
1405
1406	return dsa_port_parse_user(dp, name);
1407}
1408
1409static int dsa_switch_parse_ports(struct dsa_switch *ds,
1410				  struct dsa_chip_data *cd)
1411{
1412	bool valid_name_found = false;
1413	struct dsa_port *dp;
1414	struct device *dev;
1415	const char *name;
1416	unsigned int i;
1417	int err;
1418
1419	for (i = 0; i < DSA_MAX_PORTS; i++) {
1420		name = cd->port_names[i];
1421		dev = cd->netdev[i];
1422		dp = dsa_to_port(ds, i);
1423
1424		if (!name)
1425			continue;
1426
1427		err = dsa_port_parse(dp, name, dev);
1428		if (err)
1429			return err;
1430
1431		valid_name_found = true;
1432	}
1433
1434	if (!valid_name_found && i == DSA_MAX_PORTS)
1435		return -EINVAL;
1436
1437	return 0;
1438}
1439
1440static int dsa_switch_parse(struct dsa_switch *ds, struct dsa_chip_data *cd)
1441{
1442	int err;
1443
1444	ds->cd = cd;
1445
1446	/* We don't support interconnected switches nor multiple trees via
1447	 * platform data, so this is the unique switch of the tree.
1448	 */
1449	ds->index = 0;
1450	ds->dst = dsa_tree_touch(0);
1451	if (!ds->dst)
1452		return -ENOMEM;
1453
1454	err = dsa_switch_touch_ports(ds);
1455	if (err)
1456		return err;
1457
1458	return dsa_switch_parse_ports(ds, cd);
1459}
1460
1461static void dsa_switch_release_ports(struct dsa_switch *ds)
 
1462{
1463	struct dsa_port *dp, *next;
 
 
 
1464
1465	dsa_switch_for_each_port_safe(dp, next, ds) {
1466		WARN_ON(!list_empty(&dp->fdbs));
1467		WARN_ON(!list_empty(&dp->mdbs));
1468		WARN_ON(!list_empty(&dp->vlans));
1469		list_del(&dp->list);
1470		kfree(dp);
1471	}
1472}
1473
1474static int dsa_switch_probe(struct dsa_switch *ds)
1475{
1476	struct dsa_switch_tree *dst;
1477	struct dsa_chip_data *pdata;
1478	struct device_node *np;
1479	int err;
1480
1481	if (!ds->dev)
1482		return -ENODEV;
1483
1484	pdata = ds->dev->platform_data;
1485	np = ds->dev->of_node;
1486
1487	if (!ds->num_ports)
1488		return -EINVAL;
1489
1490	if (np) {
1491		err = dsa_switch_parse_of(ds, np);
1492		if (err)
1493			dsa_switch_release_ports(ds);
1494	} else if (pdata) {
1495		err = dsa_switch_parse(ds, pdata);
1496		if (err)
1497			dsa_switch_release_ports(ds);
1498	} else {
1499		err = -ENODEV;
1500	}
1501
1502	if (err)
1503		return err;
 
1504
1505	dst = ds->dst;
1506	dsa_tree_get(dst);
1507	err = dsa_tree_setup(dst);
1508	if (err) {
1509		dsa_switch_release_ports(ds);
1510		dsa_tree_put(dst);
1511	}
1512
1513	return err;
1514}
1515
1516int dsa_register_switch(struct dsa_switch *ds)
1517{
1518	int err;
1519
1520	mutex_lock(&dsa2_mutex);
1521	err = dsa_switch_probe(ds);
1522	dsa_tree_put(ds->dst);
1523	mutex_unlock(&dsa2_mutex);
1524
1525	return err;
1526}
1527EXPORT_SYMBOL_GPL(dsa_register_switch);
1528
1529static void dsa_switch_remove(struct dsa_switch *ds)
1530{
1531	struct dsa_switch_tree *dst = ds->dst;
1532
1533	dsa_tree_teardown(dst);
1534	dsa_switch_release_ports(ds);
1535	dsa_tree_put(dst);
1536}
1537
1538void dsa_unregister_switch(struct dsa_switch *ds)
1539{
1540	mutex_lock(&dsa2_mutex);
1541	dsa_switch_remove(ds);
1542	mutex_unlock(&dsa2_mutex);
1543}
1544EXPORT_SYMBOL_GPL(dsa_unregister_switch);
1545
1546/* If the DSA master chooses to unregister its net_device on .shutdown, DSA is
1547 * blocking that operation from completion, due to the dev_hold taken inside
1548 * netdev_upper_dev_link. Unlink the DSA slave interfaces from being uppers of
1549 * the DSA master, so that the system can reboot successfully.
1550 */
1551void dsa_switch_shutdown(struct dsa_switch *ds)
1552{
1553	struct net_device *master, *slave_dev;
1554	struct dsa_port *dp;
1555
1556	mutex_lock(&dsa2_mutex);
1557
1558	if (!ds->setup)
1559		goto out;
1560
1561	rtnl_lock();
1562
1563	dsa_switch_for_each_user_port(dp, ds) {
1564		master = dsa_port_to_master(dp);
1565		slave_dev = dp->slave;
1566
1567		netdev_upper_dev_unlink(master, slave_dev);
1568	}
1569
1570	/* Disconnect from further netdevice notifiers on the master,
1571	 * since netdev_uses_dsa() will now return false.
1572	 */
1573	dsa_switch_for_each_cpu_port(dp, ds)
1574		dp->master->dsa_ptr = NULL;
1575
1576	rtnl_unlock();
1577out:
1578	mutex_unlock(&dsa2_mutex);
1579}
1580EXPORT_SYMBOL_GPL(dsa_switch_shutdown);
1581
1582#ifdef CONFIG_PM_SLEEP
1583static bool dsa_port_is_initialized(const struct dsa_port *dp)
1584{
1585	return dp->type == DSA_PORT_TYPE_USER && dp->slave;
1586}
1587
1588int dsa_switch_suspend(struct dsa_switch *ds)
1589{
1590	struct dsa_port *dp;
1591	int ret = 0;
1592
1593	/* Suspend slave network devices */
1594	dsa_switch_for_each_port(dp, ds) {
1595		if (!dsa_port_is_initialized(dp))
1596			continue;
1597
1598		ret = dsa_slave_suspend(dp->slave);
1599		if (ret)
1600			return ret;
1601	}
1602
1603	if (ds->ops->suspend)
1604		ret = ds->ops->suspend(ds);
1605
1606	return ret;
1607}
1608EXPORT_SYMBOL_GPL(dsa_switch_suspend);
1609
1610int dsa_switch_resume(struct dsa_switch *ds)
1611{
1612	struct dsa_port *dp;
1613	int ret = 0;
1614
1615	if (ds->ops->resume)
1616		ret = ds->ops->resume(ds);
1617
1618	if (ret)
1619		return ret;
1620
1621	/* Resume slave network devices */
1622	dsa_switch_for_each_port(dp, ds) {
1623		if (!dsa_port_is_initialized(dp))
1624			continue;
1625
1626		ret = dsa_slave_resume(dp->slave);
1627		if (ret)
1628			return ret;
1629	}
1630
1631	return 0;
1632}
1633EXPORT_SYMBOL_GPL(dsa_switch_resume);
1634#endif
1635
1636struct dsa_port *dsa_port_from_netdev(struct net_device *netdev)
1637{
1638	if (!netdev || !dsa_slave_dev_check(netdev))
1639		return ERR_PTR(-ENODEV);
1640
1641	return dsa_slave_to_port(netdev);
1642}
1643EXPORT_SYMBOL_GPL(dsa_port_from_netdev);
1644
1645bool dsa_db_equal(const struct dsa_db *a, const struct dsa_db *b)
1646{
1647	if (a->type != b->type)
1648		return false;
1649
1650	switch (a->type) {
1651	case DSA_DB_PORT:
1652		return a->dp == b->dp;
1653	case DSA_DB_LAG:
1654		return a->lag.dev == b->lag.dev;
1655	case DSA_DB_BRIDGE:
1656		return a->bridge.num == b->bridge.num;
1657	default:
1658		WARN_ON(1);
1659		return false;
1660	}
1661}
1662
1663bool dsa_fdb_present_in_other_db(struct dsa_switch *ds, int port,
1664				 const unsigned char *addr, u16 vid,
1665				 struct dsa_db db)
1666{
1667	struct dsa_port *dp = dsa_to_port(ds, port);
1668	struct dsa_mac_addr *a;
1669
1670	lockdep_assert_held(&dp->addr_lists_lock);
1671
1672	list_for_each_entry(a, &dp->fdbs, list) {
1673		if (!ether_addr_equal(a->addr, addr) || a->vid != vid)
1674			continue;
1675
1676		if (a->db.type == db.type && !dsa_db_equal(&a->db, &db))
1677			return true;
1678	}
1679
1680	return false;
 
 
1681}
1682EXPORT_SYMBOL_GPL(dsa_fdb_present_in_other_db);
1683
1684bool dsa_mdb_present_in_other_db(struct dsa_switch *ds, int port,
1685				 const struct switchdev_obj_port_mdb *mdb,
1686				 struct dsa_db db)
1687{
1688	struct dsa_port *dp = dsa_to_port(ds, port);
1689	struct dsa_mac_addr *a;
1690
1691	lockdep_assert_held(&dp->addr_lists_lock);
1692
1693	list_for_each_entry(a, &dp->mdbs, list) {
1694		if (!ether_addr_equal(a->addr, mdb->addr) || a->vid != mdb->vid)
1695			continue;
1696
1697		if (a->db.type == db.type && !dsa_db_equal(&a->db, &db))
1698			return true;
1699	}
1700
1701	return false;
 
 
 
 
1702}
1703EXPORT_SYMBOL_GPL(dsa_mdb_present_in_other_db);
1704
1705static int __init dsa_init_module(void)
1706{
1707	int rc;
1708
1709	dsa_owq = alloc_ordered_workqueue("dsa_ordered",
1710					  WQ_MEM_RECLAIM);
1711	if (!dsa_owq)
1712		return -ENOMEM;
1713
1714	rc = dsa_slave_register_notifier();
1715	if (rc)
1716		goto register_notifier_fail;
1717
1718	dev_add_pack(&dsa_pack_type);
1719
1720	rc = rtnl_link_register(&dsa_link_ops);
1721	if (rc)
1722		goto netlink_register_fail;
1723
1724	return 0;
1725
1726netlink_register_fail:
1727	dsa_slave_unregister_notifier();
1728	dev_remove_pack(&dsa_pack_type);
1729register_notifier_fail:
1730	destroy_workqueue(dsa_owq);
1731
1732	return rc;
1733}
1734module_init(dsa_init_module);
1735
1736static void __exit dsa_cleanup_module(void)
1737{
1738	rtnl_link_unregister(&dsa_link_ops);
1739
1740	dsa_slave_unregister_notifier();
1741	dev_remove_pack(&dsa_pack_type);
1742	destroy_workqueue(dsa_owq);
1743}
1744module_exit(dsa_cleanup_module);
1745
1746MODULE_AUTHOR("Lennert Buytenhek <buytenh@wantstofly.org>");
1747MODULE_DESCRIPTION("Driver for Distributed Switch Architecture switch chips");
1748MODULE_LICENSE("GPL");
1749MODULE_ALIAS("platform:dsa");