1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * net/dsa/dsa2.c - Hardware switch handling, binding version 2
4 * Copyright (c) 2008-2009 Marvell Semiconductor
5 * Copyright (c) 2013 Florian Fainelli <florian@openwrt.org>
6 * Copyright (c) 2016 Andrew Lunn <andrew@lunn.ch>
9 #include <linux/device.h>
10 #include <linux/err.h>
11 #include <linux/list.h>
12 #include <linux/netdevice.h>
13 #include <linux/slab.h>
14 #include <linux/rtnetlink.h>
16 #include <linux/of_net.h>
17 #include <net/devlink.h>
21 static DEFINE_MUTEX(dsa2_mutex);
22 LIST_HEAD(dsa_tree_list);
24 /* Track the bridges with forwarding offload enabled */
25 static unsigned long dsa_fwd_offloading_bridges;
28 * dsa_tree_notify - Execute code for all switches in a DSA switch tree.
29 * @dst: collection of struct dsa_switch devices to notify.
30 * @e: event, must be of type DSA_NOTIFIER_*
31 * @v: event-specific value.
33 * Given a struct dsa_switch_tree, this can be used to run a function once for
34 * each member DSA switch. The other alternative of traversing the tree is only
35 * through its ports list, which does not uniquely list the switches.
37 int dsa_tree_notify(struct dsa_switch_tree *dst, unsigned long e, void *v)
39 struct raw_notifier_head *nh = &dst->nh;
42 err = raw_notifier_call_chain(nh, e, v);
44 return notifier_to_errno(err);
48 * dsa_broadcast - Notify all DSA trees in the system.
49 * @e: event, must be of type DSA_NOTIFIER_*
50 * @v: event-specific value.
52 * Can be used to notify the switching fabric of events such as cross-chip
53 * bridging between disjoint trees (such as islands of tagger-compatible
54 * switches bridged by an incompatible middle switch).
56 * WARNING: this function is not reliable during probe time, because probing
57 * between trees is asynchronous and not all DSA trees might have probed.
59 int dsa_broadcast(unsigned long e, void *v)
61 struct dsa_switch_tree *dst;
64 list_for_each_entry(dst, &dsa_tree_list, list) {
65 err = dsa_tree_notify(dst, e, v);
74 * dsa_lag_map() - Map LAG netdev to a linear LAG ID
75 * @dst: Tree in which to record the mapping.
76 * @lag: Netdev that is to be mapped to an ID.
78 * dsa_lag_id/dsa_lag_dev can then be used to translate between the
79 * two spaces. The size of the mapping space is determined by the
80 * driver by setting ds->num_lag_ids. It is perfectly legal to leave
81 * it unset if it is not needed, in which case these functions become
84 void dsa_lag_map(struct dsa_switch_tree *dst, struct net_device *lag)
88 if (dsa_lag_id(dst, lag) >= 0)
92 for (id = 0; id < dst->lags_len; id++) {
93 if (!dsa_lag_dev(dst, id)) {
99 /* No IDs left, which is OK. Some drivers do not need it. The
100 * ones that do, e.g. mv88e6xxx, will discover that dsa_lag_id
101 * returns an error for this device when joining the LAG. The
102 * driver can then return -EOPNOTSUPP back to DSA, which will
103 * fall back to a software LAG.
108 * dsa_lag_unmap() - Remove a LAG ID mapping
109 * @dst: Tree in which the mapping is recorded.
110 * @lag: Netdev that was mapped.
112 * As there may be multiple users of the mapping, it is only removed
113 * if there are no other references to it.
115 void dsa_lag_unmap(struct dsa_switch_tree *dst, struct net_device *lag)
120 dsa_lag_foreach_port(dp, dst, lag)
121 /* There are remaining users of this mapping */
124 dsa_lags_foreach_id(id, dst) {
125 if (dsa_lag_dev(dst, id) == lag) {
126 dst->lags[id] = NULL;
132 static int dsa_bridge_num_find(const struct net_device *bridge_dev)
134 struct dsa_switch_tree *dst;
137 /* When preparing the offload for a port, it will have a valid
138 * dp->bridge_dev pointer but a not yet valid dp->bridge_num.
139 * However there might be other ports having the same dp->bridge_dev
140 * and a valid dp->bridge_num, so just ignore this port.
142 list_for_each_entry(dst, &dsa_tree_list, list)
143 list_for_each_entry(dp, &dst->ports, list)
144 if (dp->bridge_dev == bridge_dev &&
145 dp->bridge_num != -1)
146 return dp->bridge_num;
151 int dsa_bridge_num_get(const struct net_device *bridge_dev, int max)
153 int bridge_num = dsa_bridge_num_find(bridge_dev);
155 if (bridge_num < 0) {
156 /* First port that offloads TX forwarding for this bridge */
157 bridge_num = find_first_zero_bit(&dsa_fwd_offloading_bridges,
158 DSA_MAX_NUM_OFFLOADING_BRIDGES);
159 if (bridge_num >= max)
162 set_bit(bridge_num, &dsa_fwd_offloading_bridges);
168 void dsa_bridge_num_put(const struct net_device *bridge_dev, int bridge_num)
170 /* Check if the bridge is still in use, otherwise it is time
171 * to clean it up so we can reuse this bridge_num later.
173 if (!dsa_bridge_num_find(bridge_dev))
174 clear_bit(bridge_num, &dsa_fwd_offloading_bridges);
177 struct dsa_switch *dsa_switch_find(int tree_index, int sw_index)
179 struct dsa_switch_tree *dst;
182 list_for_each_entry(dst, &dsa_tree_list, list) {
183 if (dst->index != tree_index)
186 list_for_each_entry(dp, &dst->ports, list) {
187 if (dp->ds->index != sw_index)
196 EXPORT_SYMBOL_GPL(dsa_switch_find);
198 static struct dsa_switch_tree *dsa_tree_find(int index)
200 struct dsa_switch_tree *dst;
202 list_for_each_entry(dst, &dsa_tree_list, list)
203 if (dst->index == index)
209 static struct dsa_switch_tree *dsa_tree_alloc(int index)
211 struct dsa_switch_tree *dst;
213 dst = kzalloc(sizeof(*dst), GFP_KERNEL);
219 INIT_LIST_HEAD(&dst->rtable);
221 INIT_LIST_HEAD(&dst->ports);
223 INIT_LIST_HEAD(&dst->list);
224 list_add_tail(&dst->list, &dsa_tree_list);
226 kref_init(&dst->refcount);
231 static void dsa_tree_free(struct dsa_switch_tree *dst)
234 dsa_tag_driver_put(dst->tag_ops);
235 list_del(&dst->list);
239 static struct dsa_switch_tree *dsa_tree_get(struct dsa_switch_tree *dst)
242 kref_get(&dst->refcount);
247 static struct dsa_switch_tree *dsa_tree_touch(int index)
249 struct dsa_switch_tree *dst;
251 dst = dsa_tree_find(index);
253 return dsa_tree_get(dst);
255 return dsa_tree_alloc(index);
258 static void dsa_tree_release(struct kref *ref)
260 struct dsa_switch_tree *dst;
262 dst = container_of(ref, struct dsa_switch_tree, refcount);
267 static void dsa_tree_put(struct dsa_switch_tree *dst)
270 kref_put(&dst->refcount, dsa_tree_release);
273 static struct dsa_port *dsa_tree_find_port_by_node(struct dsa_switch_tree *dst,
274 struct device_node *dn)
278 list_for_each_entry(dp, &dst->ports, list)
285 static struct dsa_link *dsa_link_touch(struct dsa_port *dp,
286 struct dsa_port *link_dp)
288 struct dsa_switch *ds = dp->ds;
289 struct dsa_switch_tree *dst;
294 list_for_each_entry(dl, &dst->rtable, list)
295 if (dl->dp == dp && dl->link_dp == link_dp)
298 dl = kzalloc(sizeof(*dl), GFP_KERNEL);
303 dl->link_dp = link_dp;
305 INIT_LIST_HEAD(&dl->list);
306 list_add_tail(&dl->list, &dst->rtable);
311 static bool dsa_port_setup_routing_table(struct dsa_port *dp)
313 struct dsa_switch *ds = dp->ds;
314 struct dsa_switch_tree *dst = ds->dst;
315 struct device_node *dn = dp->dn;
316 struct of_phandle_iterator it;
317 struct dsa_port *link_dp;
321 of_for_each_phandle(&it, err, dn, "link", NULL, 0) {
322 link_dp = dsa_tree_find_port_by_node(dst, it.node);
324 of_node_put(it.node);
328 dl = dsa_link_touch(dp, link_dp);
330 of_node_put(it.node);
338 static bool dsa_tree_setup_routing_table(struct dsa_switch_tree *dst)
340 bool complete = true;
343 list_for_each_entry(dp, &dst->ports, list) {
344 if (dsa_port_is_dsa(dp)) {
345 complete = dsa_port_setup_routing_table(dp);
354 static struct dsa_port *dsa_tree_find_first_cpu(struct dsa_switch_tree *dst)
358 list_for_each_entry(dp, &dst->ports, list)
359 if (dsa_port_is_cpu(dp))
365 /* Assign the default CPU port (the first one in the tree) to all ports of the
366 * fabric which don't already have one as part of their own switch.
368 static int dsa_tree_setup_default_cpu(struct dsa_switch_tree *dst)
370 struct dsa_port *cpu_dp, *dp;
372 cpu_dp = dsa_tree_find_first_cpu(dst);
374 pr_err("DSA: tree %d has no CPU port\n", dst->index);
378 list_for_each_entry(dp, &dst->ports, list) {
382 if (dsa_port_is_user(dp) || dsa_port_is_dsa(dp))
389 /* Perform initial assignment of CPU ports to user ports and DSA links in the
390 * fabric, giving preference to CPU ports local to each switch. Default to
391 * using the first CPU port in the switch tree if the port does not have a CPU
392 * port local to this switch.
394 static int dsa_tree_setup_cpu_ports(struct dsa_switch_tree *dst)
396 struct dsa_port *cpu_dp, *dp;
398 list_for_each_entry(cpu_dp, &dst->ports, list) {
399 if (!dsa_port_is_cpu(cpu_dp))
402 list_for_each_entry(dp, &dst->ports, list) {
403 /* Prefer a local CPU port */
404 if (dp->ds != cpu_dp->ds)
407 /* Prefer the first local CPU port found */
411 if (dsa_port_is_user(dp) || dsa_port_is_dsa(dp))
416 return dsa_tree_setup_default_cpu(dst);
419 static void dsa_tree_teardown_cpu_ports(struct dsa_switch_tree *dst)
423 list_for_each_entry(dp, &dst->ports, list)
424 if (dsa_port_is_user(dp) || dsa_port_is_dsa(dp))
428 static int dsa_port_setup(struct dsa_port *dp)
430 struct devlink_port *dlp = &dp->devlink_port;
431 bool dsa_port_link_registered = false;
432 bool dsa_port_enabled = false;
438 INIT_LIST_HEAD(&dp->fdbs);
439 INIT_LIST_HEAD(&dp->mdbs);
442 case DSA_PORT_TYPE_UNUSED:
443 dsa_port_disable(dp);
445 case DSA_PORT_TYPE_CPU:
446 err = dsa_port_link_register_of(dp);
449 dsa_port_link_registered = true;
451 err = dsa_port_enable(dp, NULL);
454 dsa_port_enabled = true;
457 case DSA_PORT_TYPE_DSA:
458 err = dsa_port_link_register_of(dp);
461 dsa_port_link_registered = true;
463 err = dsa_port_enable(dp, NULL);
466 dsa_port_enabled = true;
469 case DSA_PORT_TYPE_USER:
470 of_get_mac_address(dp->dn, dp->mac);
471 err = dsa_slave_create(dp);
475 devlink_port_type_eth_set(dlp, dp->slave);
479 if (err && dsa_port_enabled)
480 dsa_port_disable(dp);
481 if (err && dsa_port_link_registered)
482 dsa_port_link_unregister_of(dp);
491 static int dsa_port_devlink_setup(struct dsa_port *dp)
493 struct devlink_port *dlp = &dp->devlink_port;
494 struct dsa_switch_tree *dst = dp->ds->dst;
495 struct devlink_port_attrs attrs = {};
496 struct devlink *dl = dp->ds->devlink;
497 const unsigned char *id;
501 id = (const unsigned char *)&dst->index;
502 len = sizeof(dst->index);
504 attrs.phys.port_number = dp->index;
505 memcpy(attrs.switch_id.id, id, len);
506 attrs.switch_id.id_len = len;
507 memset(dlp, 0, sizeof(*dlp));
510 case DSA_PORT_TYPE_UNUSED:
511 attrs.flavour = DEVLINK_PORT_FLAVOUR_UNUSED;
513 case DSA_PORT_TYPE_CPU:
514 attrs.flavour = DEVLINK_PORT_FLAVOUR_CPU;
516 case DSA_PORT_TYPE_DSA:
517 attrs.flavour = DEVLINK_PORT_FLAVOUR_DSA;
519 case DSA_PORT_TYPE_USER:
520 attrs.flavour = DEVLINK_PORT_FLAVOUR_PHYSICAL;
524 devlink_port_attrs_set(dlp, &attrs);
525 err = devlink_port_register(dl, dlp, dp->index);
528 dp->devlink_port_setup = true;
533 static void dsa_port_teardown(struct dsa_port *dp)
535 struct devlink_port *dlp = &dp->devlink_port;
536 struct dsa_mac_addr *a, *tmp;
541 devlink_port_type_clear(dlp);
544 case DSA_PORT_TYPE_UNUSED:
546 case DSA_PORT_TYPE_CPU:
547 dsa_port_disable(dp);
548 dsa_port_link_unregister_of(dp);
550 case DSA_PORT_TYPE_DSA:
551 dsa_port_disable(dp);
552 dsa_port_link_unregister_of(dp);
554 case DSA_PORT_TYPE_USER:
556 dsa_slave_destroy(dp->slave);
562 list_for_each_entry_safe(a, tmp, &dp->fdbs, list) {
567 list_for_each_entry_safe(a, tmp, &dp->mdbs, list) {
575 static void dsa_port_devlink_teardown(struct dsa_port *dp)
577 struct devlink_port *dlp = &dp->devlink_port;
579 if (dp->devlink_port_setup)
580 devlink_port_unregister(dlp);
581 dp->devlink_port_setup = false;
584 static int dsa_devlink_info_get(struct devlink *dl,
585 struct devlink_info_req *req,
586 struct netlink_ext_ack *extack)
588 struct dsa_switch *ds = dsa_devlink_to_ds(dl);
590 if (ds->ops->devlink_info_get)
591 return ds->ops->devlink_info_get(ds, req, extack);
596 static int dsa_devlink_sb_pool_get(struct devlink *dl,
597 unsigned int sb_index, u16 pool_index,
598 struct devlink_sb_pool_info *pool_info)
600 struct dsa_switch *ds = dsa_devlink_to_ds(dl);
602 if (!ds->ops->devlink_sb_pool_get)
605 return ds->ops->devlink_sb_pool_get(ds, sb_index, pool_index,
609 static int dsa_devlink_sb_pool_set(struct devlink *dl, unsigned int sb_index,
610 u16 pool_index, u32 size,
611 enum devlink_sb_threshold_type threshold_type,
612 struct netlink_ext_ack *extack)
614 struct dsa_switch *ds = dsa_devlink_to_ds(dl);
616 if (!ds->ops->devlink_sb_pool_set)
619 return ds->ops->devlink_sb_pool_set(ds, sb_index, pool_index, size,
620 threshold_type, extack);
623 static int dsa_devlink_sb_port_pool_get(struct devlink_port *dlp,
624 unsigned int sb_index, u16 pool_index,
627 struct dsa_switch *ds = dsa_devlink_port_to_ds(dlp);
628 int port = dsa_devlink_port_to_port(dlp);
630 if (!ds->ops->devlink_sb_port_pool_get)
633 return ds->ops->devlink_sb_port_pool_get(ds, port, sb_index,
634 pool_index, p_threshold);
637 static int dsa_devlink_sb_port_pool_set(struct devlink_port *dlp,
638 unsigned int sb_index, u16 pool_index,
640 struct netlink_ext_ack *extack)
642 struct dsa_switch *ds = dsa_devlink_port_to_ds(dlp);
643 int port = dsa_devlink_port_to_port(dlp);
645 if (!ds->ops->devlink_sb_port_pool_set)
648 return ds->ops->devlink_sb_port_pool_set(ds, port, sb_index,
649 pool_index, threshold, extack);
653 dsa_devlink_sb_tc_pool_bind_get(struct devlink_port *dlp,
654 unsigned int sb_index, u16 tc_index,
655 enum devlink_sb_pool_type pool_type,
656 u16 *p_pool_index, u32 *p_threshold)
658 struct dsa_switch *ds = dsa_devlink_port_to_ds(dlp);
659 int port = dsa_devlink_port_to_port(dlp);
661 if (!ds->ops->devlink_sb_tc_pool_bind_get)
664 return ds->ops->devlink_sb_tc_pool_bind_get(ds, port, sb_index,
666 p_pool_index, p_threshold);
670 dsa_devlink_sb_tc_pool_bind_set(struct devlink_port *dlp,
671 unsigned int sb_index, u16 tc_index,
672 enum devlink_sb_pool_type pool_type,
673 u16 pool_index, u32 threshold,
674 struct netlink_ext_ack *extack)
676 struct dsa_switch *ds = dsa_devlink_port_to_ds(dlp);
677 int port = dsa_devlink_port_to_port(dlp);
679 if (!ds->ops->devlink_sb_tc_pool_bind_set)
682 return ds->ops->devlink_sb_tc_pool_bind_set(ds, port, sb_index,
684 pool_index, threshold,
688 static int dsa_devlink_sb_occ_snapshot(struct devlink *dl,
689 unsigned int sb_index)
691 struct dsa_switch *ds = dsa_devlink_to_ds(dl);
693 if (!ds->ops->devlink_sb_occ_snapshot)
696 return ds->ops->devlink_sb_occ_snapshot(ds, sb_index);
699 static int dsa_devlink_sb_occ_max_clear(struct devlink *dl,
700 unsigned int sb_index)
702 struct dsa_switch *ds = dsa_devlink_to_ds(dl);
704 if (!ds->ops->devlink_sb_occ_max_clear)
707 return ds->ops->devlink_sb_occ_max_clear(ds, sb_index);
710 static int dsa_devlink_sb_occ_port_pool_get(struct devlink_port *dlp,
711 unsigned int sb_index,
712 u16 pool_index, u32 *p_cur,
715 struct dsa_switch *ds = dsa_devlink_port_to_ds(dlp);
716 int port = dsa_devlink_port_to_port(dlp);
718 if (!ds->ops->devlink_sb_occ_port_pool_get)
721 return ds->ops->devlink_sb_occ_port_pool_get(ds, port, sb_index,
722 pool_index, p_cur, p_max);
726 dsa_devlink_sb_occ_tc_port_bind_get(struct devlink_port *dlp,
727 unsigned int sb_index, u16 tc_index,
728 enum devlink_sb_pool_type pool_type,
729 u32 *p_cur, u32 *p_max)
731 struct dsa_switch *ds = dsa_devlink_port_to_ds(dlp);
732 int port = dsa_devlink_port_to_port(dlp);
734 if (!ds->ops->devlink_sb_occ_tc_port_bind_get)
737 return ds->ops->devlink_sb_occ_tc_port_bind_get(ds, port,
743 static const struct devlink_ops dsa_devlink_ops = {
744 .info_get = dsa_devlink_info_get,
745 .sb_pool_get = dsa_devlink_sb_pool_get,
746 .sb_pool_set = dsa_devlink_sb_pool_set,
747 .sb_port_pool_get = dsa_devlink_sb_port_pool_get,
748 .sb_port_pool_set = dsa_devlink_sb_port_pool_set,
749 .sb_tc_pool_bind_get = dsa_devlink_sb_tc_pool_bind_get,
750 .sb_tc_pool_bind_set = dsa_devlink_sb_tc_pool_bind_set,
751 .sb_occ_snapshot = dsa_devlink_sb_occ_snapshot,
752 .sb_occ_max_clear = dsa_devlink_sb_occ_max_clear,
753 .sb_occ_port_pool_get = dsa_devlink_sb_occ_port_pool_get,
754 .sb_occ_tc_port_bind_get = dsa_devlink_sb_occ_tc_port_bind_get,
757 static int dsa_switch_setup_tag_protocol(struct dsa_switch *ds)
759 const struct dsa_device_ops *tag_ops = ds->dst->tag_ops;
760 struct dsa_switch_tree *dst = ds->dst;
763 if (tag_ops->proto == dst->default_proto)
766 for (port = 0; port < ds->num_ports; port++) {
767 if (!dsa_is_cpu_port(ds, port))
770 err = ds->ops->change_tag_protocol(ds, port, tag_ops->proto);
772 dev_err(ds->dev, "Unable to use tag protocol \"%s\": %pe\n",
773 tag_ops->name, ERR_PTR(err));
781 static int dsa_switch_setup(struct dsa_switch *ds)
783 struct dsa_devlink_priv *dl_priv;
790 /* Initialize ds->phys_mii_mask before registering the slave MDIO bus
791 * driver and before ops->setup() has run, since the switch drivers and
792 * the slave MDIO bus driver rely on these values for probing PHY
795 ds->phys_mii_mask |= dsa_user_ports(ds);
797 /* Add the switch to devlink before calling setup, so that setup can
801 devlink_alloc(&dsa_devlink_ops, sizeof(*dl_priv), ds->dev);
804 dl_priv = devlink_priv(ds->devlink);
807 err = devlink_register(ds->devlink);
811 /* Setup devlink port instances now, so that the switch
812 * setup() can register regions etc, against the ports
814 list_for_each_entry(dp, &ds->dst->ports, list) {
816 err = dsa_port_devlink_setup(dp);
818 goto unregister_devlink_ports;
822 err = dsa_switch_register_notifier(ds);
824 goto unregister_devlink_ports;
826 ds->configure_vlan_while_not_filtering = true;
828 err = ds->ops->setup(ds);
830 goto unregister_notifier;
832 err = dsa_switch_setup_tag_protocol(ds);
836 devlink_params_publish(ds->devlink);
838 if (!ds->slave_mii_bus && ds->ops->phy_read) {
839 ds->slave_mii_bus = devm_mdiobus_alloc(ds->dev);
840 if (!ds->slave_mii_bus) {
845 dsa_slave_mii_bus_init(ds);
847 err = mdiobus_register(ds->slave_mii_bus);
857 if (ds->ops->teardown)
858 ds->ops->teardown(ds);
860 dsa_switch_unregister_notifier(ds);
861 unregister_devlink_ports:
862 list_for_each_entry(dp, &ds->dst->ports, list)
864 dsa_port_devlink_teardown(dp);
865 devlink_unregister(ds->devlink);
867 devlink_free(ds->devlink);
873 static void dsa_switch_teardown(struct dsa_switch *ds)
880 if (ds->slave_mii_bus && ds->ops->phy_read)
881 mdiobus_unregister(ds->slave_mii_bus);
883 dsa_switch_unregister_notifier(ds);
885 if (ds->ops->teardown)
886 ds->ops->teardown(ds);
889 list_for_each_entry(dp, &ds->dst->ports, list)
891 dsa_port_devlink_teardown(dp);
892 devlink_unregister(ds->devlink);
893 devlink_free(ds->devlink);
900 static int dsa_tree_setup_switches(struct dsa_switch_tree *dst)
905 list_for_each_entry(dp, &dst->ports, list) {
906 err = dsa_switch_setup(dp->ds);
911 list_for_each_entry(dp, &dst->ports, list) {
912 err = dsa_port_setup(dp);
914 dsa_port_devlink_teardown(dp);
915 dp->type = DSA_PORT_TYPE_UNUSED;
916 err = dsa_port_devlink_setup(dp);
926 list_for_each_entry(dp, &dst->ports, list)
927 dsa_port_teardown(dp);
929 list_for_each_entry(dp, &dst->ports, list)
930 dsa_switch_teardown(dp->ds);
935 static void dsa_tree_teardown_switches(struct dsa_switch_tree *dst)
939 list_for_each_entry(dp, &dst->ports, list)
940 dsa_port_teardown(dp);
942 list_for_each_entry(dp, &dst->ports, list)
943 dsa_switch_teardown(dp->ds);
946 static int dsa_tree_setup_master(struct dsa_switch_tree *dst)
951 list_for_each_entry(dp, &dst->ports, list) {
952 if (dsa_port_is_cpu(dp)) {
953 err = dsa_master_setup(dp->master, dp);
962 static void dsa_tree_teardown_master(struct dsa_switch_tree *dst)
966 list_for_each_entry(dp, &dst->ports, list)
967 if (dsa_port_is_cpu(dp))
968 dsa_master_teardown(dp->master);
971 static int dsa_tree_setup_lags(struct dsa_switch_tree *dst)
973 unsigned int len = 0;
976 list_for_each_entry(dp, &dst->ports, list) {
977 if (dp->ds->num_lag_ids > len)
978 len = dp->ds->num_lag_ids;
984 dst->lags = kcalloc(len, sizeof(*dst->lags), GFP_KERNEL);
992 static void dsa_tree_teardown_lags(struct dsa_switch_tree *dst)
997 static int dsa_tree_setup(struct dsa_switch_tree *dst)
1003 pr_err("DSA: tree %d already setup! Disjoint trees?\n",
1008 complete = dsa_tree_setup_routing_table(dst);
1012 err = dsa_tree_setup_cpu_ports(dst);
1016 err = dsa_tree_setup_switches(dst);
1018 goto teardown_cpu_ports;
1020 err = dsa_tree_setup_master(dst);
1022 goto teardown_switches;
1024 err = dsa_tree_setup_lags(dst);
1026 goto teardown_master;
1030 pr_info("DSA: tree %d setup\n", dst->index);
1035 dsa_tree_teardown_master(dst);
1037 dsa_tree_teardown_switches(dst);
1039 dsa_tree_teardown_cpu_ports(dst);
1044 static void dsa_tree_teardown(struct dsa_switch_tree *dst)
1046 struct dsa_link *dl, *next;
1051 dsa_tree_teardown_lags(dst);
1053 dsa_tree_teardown_master(dst);
1055 dsa_tree_teardown_switches(dst);
1057 dsa_tree_teardown_cpu_ports(dst);
1059 list_for_each_entry_safe(dl, next, &dst->rtable, list) {
1060 list_del(&dl->list);
1064 pr_info("DSA: tree %d torn down\n", dst->index);
1069 /* Since the dsa/tagging sysfs device attribute is per master, the assumption
1070 * is that all DSA switches within a tree share the same tagger, otherwise
1071 * they would have formed disjoint trees (different "dsa,member" values).
1073 int dsa_tree_change_tag_proto(struct dsa_switch_tree *dst,
1074 struct net_device *master,
1075 const struct dsa_device_ops *tag_ops,
1076 const struct dsa_device_ops *old_tag_ops)
1078 struct dsa_notifier_tag_proto_info info;
1079 struct dsa_port *dp;
1082 if (!rtnl_trylock())
1083 return restart_syscall();
1085 /* At the moment we don't allow changing the tag protocol under
1086 * traffic. The rtnl_mutex also happens to serialize concurrent
1087 * attempts to change the tagging protocol. If we ever lift the IFF_UP
1088 * restriction, there needs to be another mutex which serializes this.
1090 if (master->flags & IFF_UP)
1093 list_for_each_entry(dp, &dst->ports, list) {
1094 if (!dsa_is_user_port(dp->ds, dp->index))
1097 if (dp->slave->flags & IFF_UP)
1101 info.tag_ops = tag_ops;
1102 err = dsa_tree_notify(dst, DSA_NOTIFIER_TAG_PROTO, &info);
1104 goto out_unwind_tagger;
1106 dst->tag_ops = tag_ops;
1113 info.tag_ops = old_tag_ops;
1114 dsa_tree_notify(dst, DSA_NOTIFIER_TAG_PROTO, &info);
1120 static struct dsa_port *dsa_port_touch(struct dsa_switch *ds, int index)
1122 struct dsa_switch_tree *dst = ds->dst;
1123 struct dsa_port *dp;
1125 list_for_each_entry(dp, &dst->ports, list)
1126 if (dp->ds == ds && dp->index == index)
1129 dp = kzalloc(sizeof(*dp), GFP_KERNEL);
1135 dp->bridge_num = -1;
1137 INIT_LIST_HEAD(&dp->list);
1138 list_add_tail(&dp->list, &dst->ports);
1143 static int dsa_port_parse_user(struct dsa_port *dp, const char *name)
1148 dp->type = DSA_PORT_TYPE_USER;
1154 static int dsa_port_parse_dsa(struct dsa_port *dp)
1156 dp->type = DSA_PORT_TYPE_DSA;
1161 static enum dsa_tag_protocol dsa_get_tag_protocol(struct dsa_port *dp,
1162 struct net_device *master)
1164 enum dsa_tag_protocol tag_protocol = DSA_TAG_PROTO_NONE;
1165 struct dsa_switch *mds, *ds = dp->ds;
1166 unsigned int mdp_upstream;
1167 struct dsa_port *mdp;
1169 /* It is possible to stack DSA switches onto one another when that
1170 * happens the switch driver may want to know if its tagging protocol
1171 * is going to work in such a configuration.
1173 if (dsa_slave_dev_check(master)) {
1174 mdp = dsa_slave_to_port(master);
1176 mdp_upstream = dsa_upstream_port(mds, mdp->index);
1177 tag_protocol = mds->ops->get_tag_protocol(mds, mdp_upstream,
1178 DSA_TAG_PROTO_NONE);
1181 /* If the master device is not itself a DSA slave in a disjoint DSA
1182 * tree, then return immediately.
1184 return ds->ops->get_tag_protocol(ds, dp->index, tag_protocol);
1187 static int dsa_port_parse_cpu(struct dsa_port *dp, struct net_device *master,
1188 const char *user_protocol)
1190 struct dsa_switch *ds = dp->ds;
1191 struct dsa_switch_tree *dst = ds->dst;
1192 const struct dsa_device_ops *tag_ops;
1193 enum dsa_tag_protocol default_proto;
1195 /* Find out which protocol the switch would prefer. */
1196 default_proto = dsa_get_tag_protocol(dp, master);
1197 if (dst->default_proto) {
1198 if (dst->default_proto != default_proto) {
1200 "A DSA switch tree can have only one tagging protocol\n");
1204 dst->default_proto = default_proto;
1207 /* See if the user wants to override that preference. */
1208 if (user_protocol) {
1209 if (!ds->ops->change_tag_protocol) {
1210 dev_err(ds->dev, "Tag protocol cannot be modified\n");
1214 tag_ops = dsa_find_tagger_by_name(user_protocol);
1216 tag_ops = dsa_tag_driver_get(default_proto);
1219 if (IS_ERR(tag_ops)) {
1220 if (PTR_ERR(tag_ops) == -ENOPROTOOPT)
1221 return -EPROBE_DEFER;
1223 dev_warn(ds->dev, "No tagger for this switch\n");
1224 return PTR_ERR(tag_ops);
1228 if (dst->tag_ops != tag_ops) {
1230 "A DSA switch tree can have only one tagging protocol\n");
1232 dsa_tag_driver_put(tag_ops);
1236 /* In the case of multiple CPU ports per switch, the tagging
1237 * protocol is still reference-counted only per switch tree.
1239 dsa_tag_driver_put(tag_ops);
1241 dst->tag_ops = tag_ops;
1244 dp->master = master;
1245 dp->type = DSA_PORT_TYPE_CPU;
1246 dsa_port_set_tag_protocol(dp, dst->tag_ops);
1249 /* At this point, the tree may be configured to use a different
1250 * tagger than the one chosen by the switch driver during
1251 * .setup, in the case when a user selects a custom protocol
1254 * This is resolved by syncing the driver with the tree in
1255 * dsa_switch_setup_tag_protocol once .setup has run and the
1256 * driver is ready to accept calls to .change_tag_protocol. If
1257 * the driver does not support the custom protocol at that
1258 * point, the tree is wholly rejected, thereby ensuring that the
1259 * tree and driver are always in agreement on the protocol to
1265 static int dsa_port_parse_of(struct dsa_port *dp, struct device_node *dn)
1267 struct device_node *ethernet = of_parse_phandle(dn, "ethernet", 0);
1268 const char *name = of_get_property(dn, "label", NULL);
1269 bool link = of_property_read_bool(dn, "link");
1274 struct net_device *master;
1275 const char *user_protocol;
1277 master = of_find_net_device_by_node(ethernet);
1279 return -EPROBE_DEFER;
1281 user_protocol = of_get_property(dn, "dsa-tag-protocol", NULL);
1282 return dsa_port_parse_cpu(dp, master, user_protocol);
1286 return dsa_port_parse_dsa(dp);
1288 return dsa_port_parse_user(dp, name);
1291 static int dsa_switch_parse_ports_of(struct dsa_switch *ds,
1292 struct device_node *dn)
1294 struct device_node *ports, *port;
1295 struct dsa_port *dp;
1299 ports = of_get_child_by_name(dn, "ports");
1301 /* The second possibility is "ethernet-ports" */
1302 ports = of_get_child_by_name(dn, "ethernet-ports");
1304 dev_err(ds->dev, "no ports child node found\n");
1309 for_each_available_child_of_node(ports, port) {
1310 err = of_property_read_u32(port, "reg", ®);
1314 if (reg >= ds->num_ports) {
1315 dev_err(ds->dev, "port %pOF index %u exceeds num_ports (%zu)\n",
1316 port, reg, ds->num_ports);
1321 dp = dsa_to_port(ds, reg);
1323 err = dsa_port_parse_of(dp, port);
1333 static int dsa_switch_parse_member_of(struct dsa_switch *ds,
1334 struct device_node *dn)
1336 u32 m[2] = { 0, 0 };
1339 /* Don't error out if this optional property isn't found */
1340 sz = of_property_read_variable_u32_array(dn, "dsa,member", m, 2, 2);
1341 if (sz < 0 && sz != -EINVAL)
1346 ds->dst = dsa_tree_touch(m[0]);
1350 if (dsa_switch_find(ds->dst->index, ds->index)) {
1352 "A DSA switch with index %d already exists in tree %d\n",
1353 ds->index, ds->dst->index);
1357 if (ds->dst->last_switch < ds->index)
1358 ds->dst->last_switch = ds->index;
1363 static int dsa_switch_touch_ports(struct dsa_switch *ds)
1365 struct dsa_port *dp;
1368 for (port = 0; port < ds->num_ports; port++) {
1369 dp = dsa_port_touch(ds, port);
1377 static int dsa_switch_parse_of(struct dsa_switch *ds, struct device_node *dn)
1381 err = dsa_switch_parse_member_of(ds, dn);
1385 err = dsa_switch_touch_ports(ds);
1389 return dsa_switch_parse_ports_of(ds, dn);
1392 static int dsa_port_parse(struct dsa_port *dp, const char *name,
1395 if (!strcmp(name, "cpu")) {
1396 struct net_device *master;
1398 master = dsa_dev_to_net_device(dev);
1400 return -EPROBE_DEFER;
1404 return dsa_port_parse_cpu(dp, master, NULL);
1407 if (!strcmp(name, "dsa"))
1408 return dsa_port_parse_dsa(dp);
1410 return dsa_port_parse_user(dp, name);
1413 static int dsa_switch_parse_ports(struct dsa_switch *ds,
1414 struct dsa_chip_data *cd)
1416 bool valid_name_found = false;
1417 struct dsa_port *dp;
1423 for (i = 0; i < DSA_MAX_PORTS; i++) {
1424 name = cd->port_names[i];
1425 dev = cd->netdev[i];
1426 dp = dsa_to_port(ds, i);
1431 err = dsa_port_parse(dp, name, dev);
1435 valid_name_found = true;
1438 if (!valid_name_found && i == DSA_MAX_PORTS)
1444 static int dsa_switch_parse(struct dsa_switch *ds, struct dsa_chip_data *cd)
1450 /* We don't support interconnected switches nor multiple trees via
1451 * platform data, so this is the unique switch of the tree.
1454 ds->dst = dsa_tree_touch(0);
1458 err = dsa_switch_touch_ports(ds);
1462 return dsa_switch_parse_ports(ds, cd);
1465 static void dsa_switch_release_ports(struct dsa_switch *ds)
1467 struct dsa_switch_tree *dst = ds->dst;
1468 struct dsa_port *dp, *next;
1470 list_for_each_entry_safe(dp, next, &dst->ports, list) {
1473 list_del(&dp->list);
1478 static int dsa_switch_probe(struct dsa_switch *ds)
1480 struct dsa_switch_tree *dst;
1481 struct dsa_chip_data *pdata;
1482 struct device_node *np;
1488 pdata = ds->dev->platform_data;
1489 np = ds->dev->of_node;
1495 err = dsa_switch_parse_of(ds, np);
1497 dsa_switch_release_ports(ds);
1499 err = dsa_switch_parse(ds, pdata);
1501 dsa_switch_release_ports(ds);
1511 err = dsa_tree_setup(dst);
1513 dsa_switch_release_ports(ds);
1520 int dsa_register_switch(struct dsa_switch *ds)
1524 mutex_lock(&dsa2_mutex);
1525 err = dsa_switch_probe(ds);
1526 dsa_tree_put(ds->dst);
1527 mutex_unlock(&dsa2_mutex);
1531 EXPORT_SYMBOL_GPL(dsa_register_switch);
1533 static void dsa_switch_remove(struct dsa_switch *ds)
1535 struct dsa_switch_tree *dst = ds->dst;
1537 dsa_tree_teardown(dst);
1538 dsa_switch_release_ports(ds);
1542 void dsa_unregister_switch(struct dsa_switch *ds)
1544 mutex_lock(&dsa2_mutex);
1545 dsa_switch_remove(ds);
1546 mutex_unlock(&dsa2_mutex);
1548 EXPORT_SYMBOL_GPL(dsa_unregister_switch);