2 * net/dsa/dsa2.c - Hardware switch handling, binding version 2
3 * Copyright (c) 2008-2009 Marvell Semiconductor
4 * Copyright (c) 2013 Florian Fainelli <florian@openwrt.org>
5 * Copyright (c) 2016 Andrew Lunn <andrew@lunn.ch>
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
13 #include <linux/device.h>
14 #include <linux/err.h>
15 #include <linux/list.h>
16 #include <linux/slab.h>
17 #include <linux/rtnetlink.h>
20 #include <linux/of_net.h>
23 static LIST_HEAD(dsa_switch_trees
);
24 static DEFINE_MUTEX(dsa2_mutex
);
26 static struct dsa_switch_tree
*dsa_get_dst(u32 tree
)
28 struct dsa_switch_tree
*dst
;
30 list_for_each_entry(dst
, &dsa_switch_trees
, list
)
31 if (dst
->tree
== tree
)
36 static void dsa_free_dst(struct kref
*ref
)
38 struct dsa_switch_tree
*dst
= container_of(ref
, struct dsa_switch_tree
,
45 static void dsa_put_dst(struct dsa_switch_tree
*dst
)
47 kref_put(&dst
->refcount
, dsa_free_dst
);
50 static struct dsa_switch_tree
*dsa_add_dst(u32 tree
)
52 struct dsa_switch_tree
*dst
;
54 dst
= kzalloc(sizeof(*dst
), GFP_KERNEL
);
59 INIT_LIST_HEAD(&dst
->list
);
60 list_add_tail(&dsa_switch_trees
, &dst
->list
);
61 kref_init(&dst
->refcount
);
66 static void dsa_dst_add_ds(struct dsa_switch_tree
*dst
,
67 struct dsa_switch
*ds
, u32 index
)
69 kref_get(&dst
->refcount
);
73 static void dsa_dst_del_ds(struct dsa_switch_tree
*dst
,
74 struct dsa_switch
*ds
, u32 index
)
76 dst
->ds
[index
] = NULL
;
77 kref_put(&dst
->refcount
, dsa_free_dst
);
80 static bool dsa_port_is_dsa(struct device_node
*port
)
84 name
= of_get_property(port
, "label", NULL
);
88 if (!strcmp(name
, "dsa"))
94 static bool dsa_port_is_cpu(struct device_node
*port
)
98 name
= of_get_property(port
, "label", NULL
);
102 if (!strcmp(name
, "cpu"))
108 static bool dsa_ds_find_port(struct dsa_switch
*ds
,
109 struct device_node
*port
)
113 for (index
= 0; index
< DSA_MAX_PORTS
; index
++)
114 if (ds
->ports
[index
].dn
== port
)
119 static struct dsa_switch
*dsa_dst_find_port(struct dsa_switch_tree
*dst
,
120 struct device_node
*port
)
122 struct dsa_switch
*ds
;
125 for (index
= 0; index
< DSA_MAX_SWITCHES
; index
++) {
130 if (dsa_ds_find_port(ds
, port
))
137 static int dsa_port_complete(struct dsa_switch_tree
*dst
,
138 struct dsa_switch
*src_ds
,
139 struct device_node
*port
,
142 struct device_node
*link
;
144 struct dsa_switch
*dst_ds
;
146 for (index
= 0;; index
++) {
147 link
= of_parse_phandle(port
, "link", index
);
151 dst_ds
= dsa_dst_find_port(dst
, link
);
157 src_ds
->rtable
[dst_ds
->index
] = src_port
;
163 /* A switch is complete if all the DSA ports phandles point to ports
164 * known in the tree. A return value of 1 means the tree is not
165 * complete. This is not an error condition. A value of 0 is
168 static int dsa_ds_complete(struct dsa_switch_tree
*dst
, struct dsa_switch
*ds
)
170 struct device_node
*port
;
174 for (index
= 0; index
< DSA_MAX_PORTS
; index
++) {
175 port
= ds
->ports
[index
].dn
;
179 if (!dsa_port_is_dsa(port
))
182 err
= dsa_port_complete(dst
, ds
, port
, index
);
186 ds
->dsa_port_mask
|= BIT(index
);
192 /* A tree is complete if all the DSA ports phandles point to ports
193 * known in the tree. A return value of 1 means the tree is not
194 * complete. This is not an error condition. A value of 0 is
197 static int dsa_dst_complete(struct dsa_switch_tree
*dst
)
199 struct dsa_switch
*ds
;
203 for (index
= 0; index
< DSA_MAX_SWITCHES
; index
++) {
208 err
= dsa_ds_complete(dst
, ds
);
216 static int dsa_dsa_port_apply(struct device_node
*port
, u32 index
,
217 struct dsa_switch
*ds
)
221 err
= dsa_cpu_dsa_setup(ds
, ds
->dev
, port
, index
);
223 dev_warn(ds
->dev
, "Failed to setup dsa port %d: %d\n",
231 static void dsa_dsa_port_unapply(struct device_node
*port
, u32 index
,
232 struct dsa_switch
*ds
)
234 dsa_cpu_dsa_destroy(port
);
237 static int dsa_cpu_port_apply(struct device_node
*port
, u32 index
,
238 struct dsa_switch
*ds
)
242 err
= dsa_cpu_dsa_setup(ds
, ds
->dev
, port
, index
);
244 dev_warn(ds
->dev
, "Failed to setup cpu port %d: %d\n",
249 ds
->cpu_port_mask
|= BIT(index
);
254 static void dsa_cpu_port_unapply(struct device_node
*port
, u32 index
,
255 struct dsa_switch
*ds
)
257 dsa_cpu_dsa_destroy(port
);
258 ds
->cpu_port_mask
&= ~BIT(index
);
262 static int dsa_user_port_apply(struct device_node
*port
, u32 index
,
263 struct dsa_switch
*ds
)
268 name
= of_get_property(port
, "label", NULL
);
270 err
= dsa_slave_create(ds
, ds
->dev
, index
, name
);
272 dev_warn(ds
->dev
, "Failed to create slave %d: %d\n",
280 static void dsa_user_port_unapply(struct device_node
*port
, u32 index
,
281 struct dsa_switch
*ds
)
283 if (ds
->ports
[index
].netdev
) {
284 dsa_slave_destroy(ds
->ports
[index
].netdev
);
285 ds
->ports
[index
].netdev
= NULL
;
286 ds
->enabled_port_mask
&= ~(1 << index
);
290 static int dsa_ds_apply(struct dsa_switch_tree
*dst
, struct dsa_switch
*ds
)
292 struct device_node
*port
;
296 /* Initialize ds->phys_mii_mask before registering the slave MDIO bus
297 * driver and before ops->setup() has run, since the switch drivers and
298 * the slave MDIO bus driver rely on these values for probing PHY
301 ds
->phys_mii_mask
= ds
->enabled_port_mask
;
303 err
= ds
->ops
->setup(ds
);
307 err
= ds
->ops
->set_addr(ds
, dst
->master_netdev
->dev_addr
);
311 err
= ds
->ops
->set_addr(ds
, dst
->master_netdev
->dev_addr
);
315 if (!ds
->slave_mii_bus
&& ds
->ops
->phy_read
) {
316 ds
->slave_mii_bus
= devm_mdiobus_alloc(ds
->dev
);
317 if (!ds
->slave_mii_bus
)
320 dsa_slave_mii_bus_init(ds
);
322 err
= mdiobus_register(ds
->slave_mii_bus
);
327 for (index
= 0; index
< DSA_MAX_PORTS
; index
++) {
328 port
= ds
->ports
[index
].dn
;
332 if (dsa_port_is_dsa(port
)) {
333 err
= dsa_dsa_port_apply(port
, index
, ds
);
339 if (dsa_port_is_cpu(port
)) {
340 err
= dsa_cpu_port_apply(port
, index
, ds
);
346 err
= dsa_user_port_apply(port
, index
, ds
);
354 static void dsa_ds_unapply(struct dsa_switch_tree
*dst
, struct dsa_switch
*ds
)
356 struct device_node
*port
;
359 for (index
= 0; index
< DSA_MAX_PORTS
; index
++) {
360 port
= ds
->ports
[index
].dn
;
364 if (dsa_port_is_dsa(port
)) {
365 dsa_dsa_port_unapply(port
, index
, ds
);
369 if (dsa_port_is_cpu(port
)) {
370 dsa_cpu_port_unapply(port
, index
, ds
);
374 dsa_user_port_unapply(port
, index
, ds
);
377 if (ds
->slave_mii_bus
&& ds
->ops
->phy_read
)
378 mdiobus_unregister(ds
->slave_mii_bus
);
381 static int dsa_dst_apply(struct dsa_switch_tree
*dst
)
383 struct dsa_switch
*ds
;
387 for (index
= 0; index
< DSA_MAX_SWITCHES
; index
++) {
392 err
= dsa_ds_apply(dst
, ds
);
397 err
= dsa_cpu_port_ethtool_setup(dst
->ds
[0]);
401 /* If we use a tagging format that doesn't have an ethertype
402 * field, make sure that all packets from this point on get
403 * sent to the tag format's receive function.
406 dst
->master_netdev
->dsa_ptr
= (void *)dst
;
412 static void dsa_dst_unapply(struct dsa_switch_tree
*dst
)
414 struct dsa_switch
*ds
;
420 dst
->master_netdev
->dsa_ptr
= NULL
;
422 /* If we used a tagging format that doesn't have an ethertype
423 * field, make sure that all packets from this point get sent
424 * without the tag and go through the regular receive path.
428 for (index
= 0; index
< DSA_MAX_SWITCHES
; index
++) {
433 dsa_ds_unapply(dst
, ds
);
436 dsa_cpu_port_ethtool_restore(dst
->ds
[0]);
438 pr_info("DSA: tree %d unapplied\n", dst
->tree
);
439 dst
->applied
= false;
442 static int dsa_cpu_parse(struct device_node
*port
, u32 index
,
443 struct dsa_switch_tree
*dst
,
444 struct dsa_switch
*ds
)
446 enum dsa_tag_protocol tag_protocol
;
447 struct net_device
*ethernet_dev
;
448 struct device_node
*ethernet
;
450 ethernet
= of_parse_phandle(port
, "ethernet", 0);
454 ethernet_dev
= of_find_net_device_by_node(ethernet
);
456 return -EPROBE_DEFER
;
458 if (!ds
->master_netdev
)
459 ds
->master_netdev
= ethernet_dev
;
461 if (!dst
->master_netdev
)
462 dst
->master_netdev
= ethernet_dev
;
464 if (dst
->cpu_switch
== -1) {
465 dst
->cpu_switch
= ds
->index
;
466 dst
->cpu_port
= index
;
469 tag_protocol
= ds
->ops
->get_tag_protocol(ds
);
470 dst
->tag_ops
= dsa_resolve_tag_protocol(tag_protocol
);
471 if (IS_ERR(dst
->tag_ops
)) {
472 dev_warn(ds
->dev
, "No tagger for this switch\n");
473 return PTR_ERR(dst
->tag_ops
);
476 dst
->rcv
= dst
->tag_ops
->rcv
;
481 static int dsa_ds_parse(struct dsa_switch_tree
*dst
, struct dsa_switch
*ds
)
483 struct device_node
*port
;
487 for (index
= 0; index
< DSA_MAX_PORTS
; index
++) {
488 port
= ds
->ports
[index
].dn
;
492 if (dsa_port_is_cpu(port
)) {
493 err
= dsa_cpu_parse(port
, index
, dst
, ds
);
499 pr_info("DSA: switch %d %d parsed\n", dst
->tree
, ds
->index
);
504 static int dsa_dst_parse(struct dsa_switch_tree
*dst
)
506 struct dsa_switch
*ds
;
510 for (index
= 0; index
< DSA_MAX_SWITCHES
; index
++) {
515 err
= dsa_ds_parse(dst
, ds
);
520 if (!dst
->master_netdev
) {
521 pr_warn("Tree has no master device\n");
525 pr_info("DSA: tree %d parsed\n", dst
->tree
);
530 static int dsa_parse_ports_dn(struct device_node
*ports
, struct dsa_switch
*ds
)
532 struct device_node
*port
;
536 for_each_available_child_of_node(ports
, port
) {
537 err
= of_property_read_u32(port
, "reg", ®
);
541 if (reg
>= DSA_MAX_PORTS
)
544 ds
->ports
[reg
].dn
= port
;
546 /* Initialize enabled_port_mask now for ops->setup()
547 * to have access to a correct value, just like what
548 * net/dsa/dsa.c::dsa_switch_setup_one does.
550 if (!dsa_port_is_cpu(port
))
551 ds
->enabled_port_mask
|= 1 << reg
;
557 static int dsa_parse_member(struct device_node
*np
, u32
*tree
, u32
*index
)
563 err
= of_property_read_u32_index(np
, "dsa,member", 0, tree
);
565 /* Does not exist, but it is optional */
571 err
= of_property_read_u32_index(np
, "dsa,member", 1, index
);
575 if (*index
>= DSA_MAX_SWITCHES
)
581 static struct device_node
*dsa_get_ports(struct dsa_switch
*ds
,
582 struct device_node
*np
)
584 struct device_node
*ports
;
586 ports
= of_get_child_by_name(np
, "ports");
588 dev_err(ds
->dev
, "no ports child node found\n");
589 return ERR_PTR(-EINVAL
);
595 static int _dsa_register_switch(struct dsa_switch
*ds
, struct device_node
*np
)
597 struct device_node
*ports
= dsa_get_ports(ds
, np
);
598 struct dsa_switch_tree
*dst
;
602 err
= dsa_parse_member(np
, &tree
, &index
);
607 return PTR_ERR(ports
);
609 err
= dsa_parse_ports_dn(ports
, ds
);
613 dst
= dsa_get_dst(tree
);
615 dst
= dsa_add_dst(tree
);
620 if (dst
->ds
[index
]) {
628 /* Initialize the routing table */
629 for (i
= 0; i
< DSA_MAX_SWITCHES
; ++i
)
630 ds
->rtable
[i
] = DSA_RTABLE_NONE
;
632 dsa_dst_add_ds(dst
, ds
, index
);
634 err
= dsa_dst_complete(dst
);
639 /* Not all switches registered yet */
645 pr_info("DSA: Disjoint trees?\n");
649 err
= dsa_dst_parse(dst
);
653 err
= dsa_dst_apply(dst
);
655 dsa_dst_unapply(dst
);
663 dsa_dst_del_ds(dst
, ds
, ds
->index
);
670 int dsa_register_switch(struct dsa_switch
*ds
, struct device_node
*np
)
674 mutex_lock(&dsa2_mutex
);
675 err
= _dsa_register_switch(ds
, np
);
676 mutex_unlock(&dsa2_mutex
);
680 EXPORT_SYMBOL_GPL(dsa_register_switch
);
682 static void _dsa_unregister_switch(struct dsa_switch
*ds
)
684 struct dsa_switch_tree
*dst
= ds
->dst
;
686 dsa_dst_unapply(dst
);
688 dsa_dst_del_ds(dst
, ds
, ds
->index
);
691 void dsa_unregister_switch(struct dsa_switch
*ds
)
693 mutex_lock(&dsa2_mutex
);
694 _dsa_unregister_switch(ds
);
695 mutex_unlock(&dsa2_mutex
);
697 EXPORT_SYMBOL_GPL(dsa_unregister_switch
);