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 struct dsa_switch
*ds
= dp
->ds
;
433 bool dsa_port_enabled
= false;
439 INIT_LIST_HEAD(&dp
->fdbs
);
440 INIT_LIST_HEAD(&dp
->mdbs
);
442 if (ds
->ops
->port_setup
) {
443 err
= ds
->ops
->port_setup(ds
, dp
->index
);
449 case DSA_PORT_TYPE_UNUSED
:
450 dsa_port_disable(dp
);
452 case DSA_PORT_TYPE_CPU
:
453 err
= dsa_port_link_register_of(dp
);
456 dsa_port_link_registered
= true;
458 err
= dsa_port_enable(dp
, NULL
);
461 dsa_port_enabled
= true;
464 case DSA_PORT_TYPE_DSA
:
465 err
= dsa_port_link_register_of(dp
);
468 dsa_port_link_registered
= true;
470 err
= dsa_port_enable(dp
, NULL
);
473 dsa_port_enabled
= true;
476 case DSA_PORT_TYPE_USER
:
477 of_get_mac_address(dp
->dn
, dp
->mac
);
478 err
= dsa_slave_create(dp
);
482 devlink_port_type_eth_set(dlp
, dp
->slave
);
486 if (err
&& dsa_port_enabled
)
487 dsa_port_disable(dp
);
488 if (err
&& dsa_port_link_registered
)
489 dsa_port_link_unregister_of(dp
);
491 if (ds
->ops
->port_teardown
)
492 ds
->ops
->port_teardown(ds
, dp
->index
);
501 static int dsa_port_devlink_setup(struct dsa_port
*dp
)
503 struct devlink_port
*dlp
= &dp
->devlink_port
;
504 struct dsa_switch_tree
*dst
= dp
->ds
->dst
;
505 struct devlink_port_attrs attrs
= {};
506 struct devlink
*dl
= dp
->ds
->devlink
;
507 const unsigned char *id
;
511 id
= (const unsigned char *)&dst
->index
;
512 len
= sizeof(dst
->index
);
514 attrs
.phys
.port_number
= dp
->index
;
515 memcpy(attrs
.switch_id
.id
, id
, len
);
516 attrs
.switch_id
.id_len
= len
;
517 memset(dlp
, 0, sizeof(*dlp
));
520 case DSA_PORT_TYPE_UNUSED
:
521 attrs
.flavour
= DEVLINK_PORT_FLAVOUR_UNUSED
;
523 case DSA_PORT_TYPE_CPU
:
524 attrs
.flavour
= DEVLINK_PORT_FLAVOUR_CPU
;
526 case DSA_PORT_TYPE_DSA
:
527 attrs
.flavour
= DEVLINK_PORT_FLAVOUR_DSA
;
529 case DSA_PORT_TYPE_USER
:
530 attrs
.flavour
= DEVLINK_PORT_FLAVOUR_PHYSICAL
;
534 devlink_port_attrs_set(dlp
, &attrs
);
535 err
= devlink_port_register(dl
, dlp
, dp
->index
);
538 dp
->devlink_port_setup
= true;
543 static void dsa_port_teardown(struct dsa_port
*dp
)
545 struct devlink_port
*dlp
= &dp
->devlink_port
;
546 struct dsa_switch
*ds
= dp
->ds
;
547 struct dsa_mac_addr
*a
, *tmp
;
552 if (ds
->ops
->port_teardown
)
553 ds
->ops
->port_teardown(ds
, dp
->index
);
555 devlink_port_type_clear(dlp
);
558 case DSA_PORT_TYPE_UNUSED
:
560 case DSA_PORT_TYPE_CPU
:
561 dsa_port_disable(dp
);
562 dsa_port_link_unregister_of(dp
);
564 case DSA_PORT_TYPE_DSA
:
565 dsa_port_disable(dp
);
566 dsa_port_link_unregister_of(dp
);
568 case DSA_PORT_TYPE_USER
:
570 dsa_slave_destroy(dp
->slave
);
576 list_for_each_entry_safe(a
, tmp
, &dp
->fdbs
, list
) {
581 list_for_each_entry_safe(a
, tmp
, &dp
->mdbs
, list
) {
589 static void dsa_port_devlink_teardown(struct dsa_port
*dp
)
591 struct devlink_port
*dlp
= &dp
->devlink_port
;
593 if (dp
->devlink_port_setup
)
594 devlink_port_unregister(dlp
);
595 dp
->devlink_port_setup
= false;
598 /* Destroy the current devlink port, and create a new one which has the UNUSED
599 * flavour. At this point, any call to ds->ops->port_setup has been already
600 * balanced out by a call to ds->ops->port_teardown, so we know that any
601 * devlink port regions the driver had are now unregistered. We then call its
602 * ds->ops->port_setup again, in order for the driver to re-create them on the
605 static int dsa_port_reinit_as_unused(struct dsa_port
*dp
)
607 struct dsa_switch
*ds
= dp
->ds
;
610 dsa_port_devlink_teardown(dp
);
611 dp
->type
= DSA_PORT_TYPE_UNUSED
;
612 err
= dsa_port_devlink_setup(dp
);
616 if (ds
->ops
->port_setup
) {
617 /* On error, leave the devlink port registered,
618 * dsa_switch_teardown will clean it up later.
620 err
= ds
->ops
->port_setup(ds
, dp
->index
);
628 static int dsa_devlink_info_get(struct devlink
*dl
,
629 struct devlink_info_req
*req
,
630 struct netlink_ext_ack
*extack
)
632 struct dsa_switch
*ds
= dsa_devlink_to_ds(dl
);
634 if (ds
->ops
->devlink_info_get
)
635 return ds
->ops
->devlink_info_get(ds
, req
, extack
);
640 static int dsa_devlink_sb_pool_get(struct devlink
*dl
,
641 unsigned int sb_index
, u16 pool_index
,
642 struct devlink_sb_pool_info
*pool_info
)
644 struct dsa_switch
*ds
= dsa_devlink_to_ds(dl
);
646 if (!ds
->ops
->devlink_sb_pool_get
)
649 return ds
->ops
->devlink_sb_pool_get(ds
, sb_index
, pool_index
,
653 static int dsa_devlink_sb_pool_set(struct devlink
*dl
, unsigned int sb_index
,
654 u16 pool_index
, u32 size
,
655 enum devlink_sb_threshold_type threshold_type
,
656 struct netlink_ext_ack
*extack
)
658 struct dsa_switch
*ds
= dsa_devlink_to_ds(dl
);
660 if (!ds
->ops
->devlink_sb_pool_set
)
663 return ds
->ops
->devlink_sb_pool_set(ds
, sb_index
, pool_index
, size
,
664 threshold_type
, extack
);
667 static int dsa_devlink_sb_port_pool_get(struct devlink_port
*dlp
,
668 unsigned int sb_index
, u16 pool_index
,
671 struct dsa_switch
*ds
= dsa_devlink_port_to_ds(dlp
);
672 int port
= dsa_devlink_port_to_port(dlp
);
674 if (!ds
->ops
->devlink_sb_port_pool_get
)
677 return ds
->ops
->devlink_sb_port_pool_get(ds
, port
, sb_index
,
678 pool_index
, p_threshold
);
681 static int dsa_devlink_sb_port_pool_set(struct devlink_port
*dlp
,
682 unsigned int sb_index
, u16 pool_index
,
684 struct netlink_ext_ack
*extack
)
686 struct dsa_switch
*ds
= dsa_devlink_port_to_ds(dlp
);
687 int port
= dsa_devlink_port_to_port(dlp
);
689 if (!ds
->ops
->devlink_sb_port_pool_set
)
692 return ds
->ops
->devlink_sb_port_pool_set(ds
, port
, sb_index
,
693 pool_index
, threshold
, extack
);
697 dsa_devlink_sb_tc_pool_bind_get(struct devlink_port
*dlp
,
698 unsigned int sb_index
, u16 tc_index
,
699 enum devlink_sb_pool_type pool_type
,
700 u16
*p_pool_index
, u32
*p_threshold
)
702 struct dsa_switch
*ds
= dsa_devlink_port_to_ds(dlp
);
703 int port
= dsa_devlink_port_to_port(dlp
);
705 if (!ds
->ops
->devlink_sb_tc_pool_bind_get
)
708 return ds
->ops
->devlink_sb_tc_pool_bind_get(ds
, port
, sb_index
,
710 p_pool_index
, p_threshold
);
714 dsa_devlink_sb_tc_pool_bind_set(struct devlink_port
*dlp
,
715 unsigned int sb_index
, u16 tc_index
,
716 enum devlink_sb_pool_type pool_type
,
717 u16 pool_index
, u32 threshold
,
718 struct netlink_ext_ack
*extack
)
720 struct dsa_switch
*ds
= dsa_devlink_port_to_ds(dlp
);
721 int port
= dsa_devlink_port_to_port(dlp
);
723 if (!ds
->ops
->devlink_sb_tc_pool_bind_set
)
726 return ds
->ops
->devlink_sb_tc_pool_bind_set(ds
, port
, sb_index
,
728 pool_index
, threshold
,
732 static int dsa_devlink_sb_occ_snapshot(struct devlink
*dl
,
733 unsigned int sb_index
)
735 struct dsa_switch
*ds
= dsa_devlink_to_ds(dl
);
737 if (!ds
->ops
->devlink_sb_occ_snapshot
)
740 return ds
->ops
->devlink_sb_occ_snapshot(ds
, sb_index
);
743 static int dsa_devlink_sb_occ_max_clear(struct devlink
*dl
,
744 unsigned int sb_index
)
746 struct dsa_switch
*ds
= dsa_devlink_to_ds(dl
);
748 if (!ds
->ops
->devlink_sb_occ_max_clear
)
751 return ds
->ops
->devlink_sb_occ_max_clear(ds
, sb_index
);
754 static int dsa_devlink_sb_occ_port_pool_get(struct devlink_port
*dlp
,
755 unsigned int sb_index
,
756 u16 pool_index
, u32
*p_cur
,
759 struct dsa_switch
*ds
= dsa_devlink_port_to_ds(dlp
);
760 int port
= dsa_devlink_port_to_port(dlp
);
762 if (!ds
->ops
->devlink_sb_occ_port_pool_get
)
765 return ds
->ops
->devlink_sb_occ_port_pool_get(ds
, port
, sb_index
,
766 pool_index
, p_cur
, p_max
);
770 dsa_devlink_sb_occ_tc_port_bind_get(struct devlink_port
*dlp
,
771 unsigned int sb_index
, u16 tc_index
,
772 enum devlink_sb_pool_type pool_type
,
773 u32
*p_cur
, u32
*p_max
)
775 struct dsa_switch
*ds
= dsa_devlink_port_to_ds(dlp
);
776 int port
= dsa_devlink_port_to_port(dlp
);
778 if (!ds
->ops
->devlink_sb_occ_tc_port_bind_get
)
781 return ds
->ops
->devlink_sb_occ_tc_port_bind_get(ds
, port
,
787 static const struct devlink_ops dsa_devlink_ops
= {
788 .info_get
= dsa_devlink_info_get
,
789 .sb_pool_get
= dsa_devlink_sb_pool_get
,
790 .sb_pool_set
= dsa_devlink_sb_pool_set
,
791 .sb_port_pool_get
= dsa_devlink_sb_port_pool_get
,
792 .sb_port_pool_set
= dsa_devlink_sb_port_pool_set
,
793 .sb_tc_pool_bind_get
= dsa_devlink_sb_tc_pool_bind_get
,
794 .sb_tc_pool_bind_set
= dsa_devlink_sb_tc_pool_bind_set
,
795 .sb_occ_snapshot
= dsa_devlink_sb_occ_snapshot
,
796 .sb_occ_max_clear
= dsa_devlink_sb_occ_max_clear
,
797 .sb_occ_port_pool_get
= dsa_devlink_sb_occ_port_pool_get
,
798 .sb_occ_tc_port_bind_get
= dsa_devlink_sb_occ_tc_port_bind_get
,
801 static int dsa_switch_setup_tag_protocol(struct dsa_switch
*ds
)
803 const struct dsa_device_ops
*tag_ops
= ds
->dst
->tag_ops
;
804 struct dsa_switch_tree
*dst
= ds
->dst
;
807 if (tag_ops
->proto
== dst
->default_proto
)
810 for (port
= 0; port
< ds
->num_ports
; port
++) {
811 if (!dsa_is_cpu_port(ds
, port
))
814 err
= ds
->ops
->change_tag_protocol(ds
, port
, tag_ops
->proto
);
816 dev_err(ds
->dev
, "Unable to use tag protocol \"%s\": %pe\n",
817 tag_ops
->name
, ERR_PTR(err
));
825 static int dsa_switch_setup(struct dsa_switch
*ds
)
827 struct dsa_devlink_priv
*dl_priv
;
834 /* Initialize ds->phys_mii_mask before registering the slave MDIO bus
835 * driver and before ops->setup() has run, since the switch drivers and
836 * the slave MDIO bus driver rely on these values for probing PHY
839 ds
->phys_mii_mask
|= dsa_user_ports(ds
);
841 /* Add the switch to devlink before calling setup, so that setup can
845 devlink_alloc(&dsa_devlink_ops
, sizeof(*dl_priv
), ds
->dev
);
848 dl_priv
= devlink_priv(ds
->devlink
);
851 err
= devlink_register(ds
->devlink
);
855 /* Setup devlink port instances now, so that the switch
856 * setup() can register regions etc, against the ports
858 list_for_each_entry(dp
, &ds
->dst
->ports
, list
) {
860 err
= dsa_port_devlink_setup(dp
);
862 goto unregister_devlink_ports
;
866 err
= dsa_switch_register_notifier(ds
);
868 goto unregister_devlink_ports
;
870 ds
->configure_vlan_while_not_filtering
= true;
872 err
= ds
->ops
->setup(ds
);
874 goto unregister_notifier
;
876 err
= dsa_switch_setup_tag_protocol(ds
);
880 devlink_params_publish(ds
->devlink
);
882 if (!ds
->slave_mii_bus
&& ds
->ops
->phy_read
) {
883 ds
->slave_mii_bus
= devm_mdiobus_alloc(ds
->dev
);
884 if (!ds
->slave_mii_bus
) {
889 dsa_slave_mii_bus_init(ds
);
891 err
= mdiobus_register(ds
->slave_mii_bus
);
901 if (ds
->ops
->teardown
)
902 ds
->ops
->teardown(ds
);
904 dsa_switch_unregister_notifier(ds
);
905 unregister_devlink_ports
:
906 list_for_each_entry(dp
, &ds
->dst
->ports
, list
)
908 dsa_port_devlink_teardown(dp
);
909 devlink_unregister(ds
->devlink
);
911 devlink_free(ds
->devlink
);
917 static void dsa_switch_teardown(struct dsa_switch
*ds
)
924 if (ds
->slave_mii_bus
&& ds
->ops
->phy_read
)
925 mdiobus_unregister(ds
->slave_mii_bus
);
927 dsa_switch_unregister_notifier(ds
);
929 if (ds
->ops
->teardown
)
930 ds
->ops
->teardown(ds
);
933 list_for_each_entry(dp
, &ds
->dst
->ports
, list
)
935 dsa_port_devlink_teardown(dp
);
936 devlink_unregister(ds
->devlink
);
937 devlink_free(ds
->devlink
);
944 /* First tear down the non-shared, then the shared ports. This ensures that
945 * all work items scheduled by our switchdev handlers for user ports have
946 * completed before we destroy the refcounting kept on the shared ports.
948 static void dsa_tree_teardown_ports(struct dsa_switch_tree
*dst
)
952 list_for_each_entry(dp
, &dst
->ports
, list
)
953 if (dsa_port_is_user(dp
) || dsa_port_is_unused(dp
))
954 dsa_port_teardown(dp
);
956 dsa_flush_workqueue();
958 list_for_each_entry(dp
, &dst
->ports
, list
)
959 if (dsa_port_is_dsa(dp
) || dsa_port_is_cpu(dp
))
960 dsa_port_teardown(dp
);
963 static void dsa_tree_teardown_switches(struct dsa_switch_tree
*dst
)
967 list_for_each_entry(dp
, &dst
->ports
, list
)
968 dsa_switch_teardown(dp
->ds
);
971 static int dsa_tree_setup_switches(struct dsa_switch_tree
*dst
)
976 list_for_each_entry(dp
, &dst
->ports
, list
) {
977 err
= dsa_switch_setup(dp
->ds
);
982 list_for_each_entry(dp
, &dst
->ports
, list
) {
983 err
= dsa_port_setup(dp
);
985 err
= dsa_port_reinit_as_unused(dp
);
994 dsa_tree_teardown_ports(dst
);
996 dsa_tree_teardown_switches(dst
);
1001 static int dsa_tree_setup_master(struct dsa_switch_tree
*dst
)
1003 struct dsa_port
*dp
;
1006 list_for_each_entry(dp
, &dst
->ports
, list
) {
1007 if (dsa_port_is_cpu(dp
)) {
1008 err
= dsa_master_setup(dp
->master
, dp
);
1017 static void dsa_tree_teardown_master(struct dsa_switch_tree
*dst
)
1019 struct dsa_port
*dp
;
1021 list_for_each_entry(dp
, &dst
->ports
, list
)
1022 if (dsa_port_is_cpu(dp
))
1023 dsa_master_teardown(dp
->master
);
1026 static int dsa_tree_setup_lags(struct dsa_switch_tree
*dst
)
1028 unsigned int len
= 0;
1029 struct dsa_port
*dp
;
1031 list_for_each_entry(dp
, &dst
->ports
, list
) {
1032 if (dp
->ds
->num_lag_ids
> len
)
1033 len
= dp
->ds
->num_lag_ids
;
1039 dst
->lags
= kcalloc(len
, sizeof(*dst
->lags
), GFP_KERNEL
);
1043 dst
->lags_len
= len
;
1047 static void dsa_tree_teardown_lags(struct dsa_switch_tree
*dst
)
1052 static int dsa_tree_setup(struct dsa_switch_tree
*dst
)
1058 pr_err("DSA: tree %d already setup! Disjoint trees?\n",
1063 complete
= dsa_tree_setup_routing_table(dst
);
1067 err
= dsa_tree_setup_cpu_ports(dst
);
1071 err
= dsa_tree_setup_switches(dst
);
1073 goto teardown_cpu_ports
;
1075 err
= dsa_tree_setup_master(dst
);
1077 goto teardown_switches
;
1079 err
= dsa_tree_setup_lags(dst
);
1081 goto teardown_master
;
1085 pr_info("DSA: tree %d setup\n", dst
->index
);
1090 dsa_tree_teardown_master(dst
);
1092 dsa_tree_teardown_ports(dst
);
1093 dsa_tree_teardown_switches(dst
);
1095 dsa_tree_teardown_cpu_ports(dst
);
1100 static void dsa_tree_teardown(struct dsa_switch_tree
*dst
)
1102 struct dsa_link
*dl
, *next
;
1107 dsa_tree_teardown_lags(dst
);
1109 dsa_tree_teardown_master(dst
);
1111 dsa_tree_teardown_ports(dst
);
1113 dsa_tree_teardown_switches(dst
);
1115 dsa_tree_teardown_cpu_ports(dst
);
1117 list_for_each_entry_safe(dl
, next
, &dst
->rtable
, list
) {
1118 list_del(&dl
->list
);
1122 pr_info("DSA: tree %d torn down\n", dst
->index
);
1127 /* Since the dsa/tagging sysfs device attribute is per master, the assumption
1128 * is that all DSA switches within a tree share the same tagger, otherwise
1129 * they would have formed disjoint trees (different "dsa,member" values).
1131 int dsa_tree_change_tag_proto(struct dsa_switch_tree
*dst
,
1132 struct net_device
*master
,
1133 const struct dsa_device_ops
*tag_ops
,
1134 const struct dsa_device_ops
*old_tag_ops
)
1136 struct dsa_notifier_tag_proto_info info
;
1137 struct dsa_port
*dp
;
1140 if (!rtnl_trylock())
1141 return restart_syscall();
1143 /* At the moment we don't allow changing the tag protocol under
1144 * traffic. The rtnl_mutex also happens to serialize concurrent
1145 * attempts to change the tagging protocol. If we ever lift the IFF_UP
1146 * restriction, there needs to be another mutex which serializes this.
1148 if (master
->flags
& IFF_UP
)
1151 list_for_each_entry(dp
, &dst
->ports
, list
) {
1152 if (!dsa_is_user_port(dp
->ds
, dp
->index
))
1155 if (dp
->slave
->flags
& IFF_UP
)
1159 info
.tag_ops
= tag_ops
;
1160 err
= dsa_tree_notify(dst
, DSA_NOTIFIER_TAG_PROTO
, &info
);
1162 goto out_unwind_tagger
;
1164 dst
->tag_ops
= tag_ops
;
1171 info
.tag_ops
= old_tag_ops
;
1172 dsa_tree_notify(dst
, DSA_NOTIFIER_TAG_PROTO
, &info
);
1178 static struct dsa_port
*dsa_port_touch(struct dsa_switch
*ds
, int index
)
1180 struct dsa_switch_tree
*dst
= ds
->dst
;
1181 struct dsa_port
*dp
;
1183 list_for_each_entry(dp
, &dst
->ports
, list
)
1184 if (dp
->ds
== ds
&& dp
->index
== index
)
1187 dp
= kzalloc(sizeof(*dp
), GFP_KERNEL
);
1193 dp
->bridge_num
= -1;
1195 INIT_LIST_HEAD(&dp
->list
);
1196 list_add_tail(&dp
->list
, &dst
->ports
);
1201 static int dsa_port_parse_user(struct dsa_port
*dp
, const char *name
)
1206 dp
->type
= DSA_PORT_TYPE_USER
;
1212 static int dsa_port_parse_dsa(struct dsa_port
*dp
)
1214 dp
->type
= DSA_PORT_TYPE_DSA
;
1219 static enum dsa_tag_protocol
dsa_get_tag_protocol(struct dsa_port
*dp
,
1220 struct net_device
*master
)
1222 enum dsa_tag_protocol tag_protocol
= DSA_TAG_PROTO_NONE
;
1223 struct dsa_switch
*mds
, *ds
= dp
->ds
;
1224 unsigned int mdp_upstream
;
1225 struct dsa_port
*mdp
;
1227 /* It is possible to stack DSA switches onto one another when that
1228 * happens the switch driver may want to know if its tagging protocol
1229 * is going to work in such a configuration.
1231 if (dsa_slave_dev_check(master
)) {
1232 mdp
= dsa_slave_to_port(master
);
1234 mdp_upstream
= dsa_upstream_port(mds
, mdp
->index
);
1235 tag_protocol
= mds
->ops
->get_tag_protocol(mds
, mdp_upstream
,
1236 DSA_TAG_PROTO_NONE
);
1239 /* If the master device is not itself a DSA slave in a disjoint DSA
1240 * tree, then return immediately.
1242 return ds
->ops
->get_tag_protocol(ds
, dp
->index
, tag_protocol
);
1245 static int dsa_port_parse_cpu(struct dsa_port
*dp
, struct net_device
*master
,
1246 const char *user_protocol
)
1248 struct dsa_switch
*ds
= dp
->ds
;
1249 struct dsa_switch_tree
*dst
= ds
->dst
;
1250 const struct dsa_device_ops
*tag_ops
;
1251 enum dsa_tag_protocol default_proto
;
1253 /* Find out which protocol the switch would prefer. */
1254 default_proto
= dsa_get_tag_protocol(dp
, master
);
1255 if (dst
->default_proto
) {
1256 if (dst
->default_proto
!= default_proto
) {
1258 "A DSA switch tree can have only one tagging protocol\n");
1262 dst
->default_proto
= default_proto
;
1265 /* See if the user wants to override that preference. */
1266 if (user_protocol
) {
1267 if (!ds
->ops
->change_tag_protocol
) {
1268 dev_err(ds
->dev
, "Tag protocol cannot be modified\n");
1272 tag_ops
= dsa_find_tagger_by_name(user_protocol
);
1274 tag_ops
= dsa_tag_driver_get(default_proto
);
1277 if (IS_ERR(tag_ops
)) {
1278 if (PTR_ERR(tag_ops
) == -ENOPROTOOPT
)
1279 return -EPROBE_DEFER
;
1281 dev_warn(ds
->dev
, "No tagger for this switch\n");
1282 return PTR_ERR(tag_ops
);
1286 if (dst
->tag_ops
!= tag_ops
) {
1288 "A DSA switch tree can have only one tagging protocol\n");
1290 dsa_tag_driver_put(tag_ops
);
1294 /* In the case of multiple CPU ports per switch, the tagging
1295 * protocol is still reference-counted only per switch tree.
1297 dsa_tag_driver_put(tag_ops
);
1299 dst
->tag_ops
= tag_ops
;
1302 dp
->master
= master
;
1303 dp
->type
= DSA_PORT_TYPE_CPU
;
1304 dsa_port_set_tag_protocol(dp
, dst
->tag_ops
);
1307 /* At this point, the tree may be configured to use a different
1308 * tagger than the one chosen by the switch driver during
1309 * .setup, in the case when a user selects a custom protocol
1312 * This is resolved by syncing the driver with the tree in
1313 * dsa_switch_setup_tag_protocol once .setup has run and the
1314 * driver is ready to accept calls to .change_tag_protocol. If
1315 * the driver does not support the custom protocol at that
1316 * point, the tree is wholly rejected, thereby ensuring that the
1317 * tree and driver are always in agreement on the protocol to
1323 static int dsa_port_parse_of(struct dsa_port
*dp
, struct device_node
*dn
)
1325 struct device_node
*ethernet
= of_parse_phandle(dn
, "ethernet", 0);
1326 const char *name
= of_get_property(dn
, "label", NULL
);
1327 bool link
= of_property_read_bool(dn
, "link");
1332 struct net_device
*master
;
1333 const char *user_protocol
;
1335 master
= of_find_net_device_by_node(ethernet
);
1337 return -EPROBE_DEFER
;
1339 user_protocol
= of_get_property(dn
, "dsa-tag-protocol", NULL
);
1340 return dsa_port_parse_cpu(dp
, master
, user_protocol
);
1344 return dsa_port_parse_dsa(dp
);
1346 return dsa_port_parse_user(dp
, name
);
1349 static int dsa_switch_parse_ports_of(struct dsa_switch
*ds
,
1350 struct device_node
*dn
)
1352 struct device_node
*ports
, *port
;
1353 struct dsa_port
*dp
;
1357 ports
= of_get_child_by_name(dn
, "ports");
1359 /* The second possibility is "ethernet-ports" */
1360 ports
= of_get_child_by_name(dn
, "ethernet-ports");
1362 dev_err(ds
->dev
, "no ports child node found\n");
1367 for_each_available_child_of_node(ports
, port
) {
1368 err
= of_property_read_u32(port
, "reg", ®
);
1372 if (reg
>= ds
->num_ports
) {
1373 dev_err(ds
->dev
, "port %pOF index %u exceeds num_ports (%zu)\n",
1374 port
, reg
, ds
->num_ports
);
1379 dp
= dsa_to_port(ds
, reg
);
1381 err
= dsa_port_parse_of(dp
, port
);
1391 static int dsa_switch_parse_member_of(struct dsa_switch
*ds
,
1392 struct device_node
*dn
)
1394 u32 m
[2] = { 0, 0 };
1397 /* Don't error out if this optional property isn't found */
1398 sz
= of_property_read_variable_u32_array(dn
, "dsa,member", m
, 2, 2);
1399 if (sz
< 0 && sz
!= -EINVAL
)
1404 ds
->dst
= dsa_tree_touch(m
[0]);
1408 if (dsa_switch_find(ds
->dst
->index
, ds
->index
)) {
1410 "A DSA switch with index %d already exists in tree %d\n",
1411 ds
->index
, ds
->dst
->index
);
1415 if (ds
->dst
->last_switch
< ds
->index
)
1416 ds
->dst
->last_switch
= ds
->index
;
1421 static int dsa_switch_touch_ports(struct dsa_switch
*ds
)
1423 struct dsa_port
*dp
;
1426 for (port
= 0; port
< ds
->num_ports
; port
++) {
1427 dp
= dsa_port_touch(ds
, port
);
1435 static int dsa_switch_parse_of(struct dsa_switch
*ds
, struct device_node
*dn
)
1439 err
= dsa_switch_parse_member_of(ds
, dn
);
1443 err
= dsa_switch_touch_ports(ds
);
1447 return dsa_switch_parse_ports_of(ds
, dn
);
1450 static int dsa_port_parse(struct dsa_port
*dp
, const char *name
,
1453 if (!strcmp(name
, "cpu")) {
1454 struct net_device
*master
;
1456 master
= dsa_dev_to_net_device(dev
);
1458 return -EPROBE_DEFER
;
1462 return dsa_port_parse_cpu(dp
, master
, NULL
);
1465 if (!strcmp(name
, "dsa"))
1466 return dsa_port_parse_dsa(dp
);
1468 return dsa_port_parse_user(dp
, name
);
1471 static int dsa_switch_parse_ports(struct dsa_switch
*ds
,
1472 struct dsa_chip_data
*cd
)
1474 bool valid_name_found
= false;
1475 struct dsa_port
*dp
;
1481 for (i
= 0; i
< DSA_MAX_PORTS
; i
++) {
1482 name
= cd
->port_names
[i
];
1483 dev
= cd
->netdev
[i
];
1484 dp
= dsa_to_port(ds
, i
);
1489 err
= dsa_port_parse(dp
, name
, dev
);
1493 valid_name_found
= true;
1496 if (!valid_name_found
&& i
== DSA_MAX_PORTS
)
1502 static int dsa_switch_parse(struct dsa_switch
*ds
, struct dsa_chip_data
*cd
)
1508 /* We don't support interconnected switches nor multiple trees via
1509 * platform data, so this is the unique switch of the tree.
1512 ds
->dst
= dsa_tree_touch(0);
1516 err
= dsa_switch_touch_ports(ds
);
1520 return dsa_switch_parse_ports(ds
, cd
);
1523 static void dsa_switch_release_ports(struct dsa_switch
*ds
)
1525 struct dsa_switch_tree
*dst
= ds
->dst
;
1526 struct dsa_port
*dp
, *next
;
1528 list_for_each_entry_safe(dp
, next
, &dst
->ports
, list
) {
1531 list_del(&dp
->list
);
1536 static int dsa_switch_probe(struct dsa_switch
*ds
)
1538 struct dsa_switch_tree
*dst
;
1539 struct dsa_chip_data
*pdata
;
1540 struct device_node
*np
;
1546 pdata
= ds
->dev
->platform_data
;
1547 np
= ds
->dev
->of_node
;
1553 err
= dsa_switch_parse_of(ds
, np
);
1555 dsa_switch_release_ports(ds
);
1557 err
= dsa_switch_parse(ds
, pdata
);
1559 dsa_switch_release_ports(ds
);
1569 err
= dsa_tree_setup(dst
);
1571 dsa_switch_release_ports(ds
);
1578 int dsa_register_switch(struct dsa_switch
*ds
)
1582 mutex_lock(&dsa2_mutex
);
1583 err
= dsa_switch_probe(ds
);
1584 dsa_tree_put(ds
->dst
);
1585 mutex_unlock(&dsa2_mutex
);
1589 EXPORT_SYMBOL_GPL(dsa_register_switch
);
1591 static void dsa_switch_remove(struct dsa_switch
*ds
)
1593 struct dsa_switch_tree
*dst
= ds
->dst
;
1595 dsa_tree_teardown(dst
);
1596 dsa_switch_release_ports(ds
);
1600 void dsa_unregister_switch(struct dsa_switch
*ds
)
1602 mutex_lock(&dsa2_mutex
);
1603 dsa_switch_remove(ds
);
1604 mutex_unlock(&dsa2_mutex
);
1606 EXPORT_SYMBOL_GPL(dsa_unregister_switch
);
1608 /* If the DSA master chooses to unregister its net_device on .shutdown, DSA is
1609 * blocking that operation from completion, due to the dev_hold taken inside
1610 * netdev_upper_dev_link. Unlink the DSA slave interfaces from being uppers of
1611 * the DSA master, so that the system can reboot successfully.
1613 void dsa_switch_shutdown(struct dsa_switch
*ds
)
1615 struct net_device
*master
, *slave_dev
;
1616 LIST_HEAD(unregister_list
);
1617 struct dsa_port
*dp
;
1619 mutex_lock(&dsa2_mutex
);
1622 list_for_each_entry(dp
, &ds
->dst
->ports
, list
) {
1626 if (!dsa_port_is_user(dp
))
1629 master
= dp
->cpu_dp
->master
;
1630 slave_dev
= dp
->slave
;
1632 netdev_upper_dev_unlink(master
, slave_dev
);
1633 /* Just unlinking ourselves as uppers of the master is not
1634 * sufficient. When the master net device unregisters, that will
1635 * also call dev_close, which we will catch as NETDEV_GOING_DOWN
1636 * and trigger a dev_close on our own devices (dsa_slave_close).
1637 * In turn, that will call dev_mc_unsync on the master's net
1638 * device. If the master is also a DSA switch port, this will
1639 * trigger dsa_slave_set_rx_mode which will call dev_mc_sync on
1640 * its own master. Lockdep will complain about the fact that
1641 * all cascaded masters have the same dsa_master_addr_list_lock_key,
1642 * which it normally would not do if the cascaded masters would
1643 * be in a proper upper/lower relationship, which we've just
1645 * To suppress the lockdep warnings, let's actually unregister
1646 * the DSA slave interfaces too, to avoid the nonsensical
1647 * multicast address list synchronization on shutdown.
1649 unregister_netdevice_queue(slave_dev
, &unregister_list
);
1651 unregister_netdevice_many(&unregister_list
);
1654 mutex_unlock(&dsa2_mutex
);
1656 EXPORT_SYMBOL_GPL(dsa_switch_shutdown
);