2 * net/dsa/legacy.c - Hardware switch handling
3 * Copyright (c) 2008-2009 Marvell Semiconductor
4 * Copyright (c) 2013 Florian Fainelli <florian@openwrt.org>
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
12 #include <linux/device.h>
13 #include <linux/list.h>
14 #include <linux/platform_device.h>
15 #include <linux/slab.h>
16 #include <linux/module.h>
18 #include <linux/of_mdio.h>
19 #include <linux/of_platform.h>
20 #include <linux/of_net.h>
21 #include <linux/netdevice.h>
22 #include <linux/sysfs.h>
23 #include <linux/phy_fixed.h>
24 #include <linux/etherdevice.h>
28 /* switch driver registration ***********************************************/
29 static DEFINE_MUTEX(dsa_switch_drivers_mutex
);
30 static LIST_HEAD(dsa_switch_drivers
);
32 void register_switch_driver(struct dsa_switch_driver
*drv
)
34 mutex_lock(&dsa_switch_drivers_mutex
);
35 list_add_tail(&drv
->list
, &dsa_switch_drivers
);
36 mutex_unlock(&dsa_switch_drivers_mutex
);
38 EXPORT_SYMBOL_GPL(register_switch_driver
);
40 void unregister_switch_driver(struct dsa_switch_driver
*drv
)
42 mutex_lock(&dsa_switch_drivers_mutex
);
43 list_del_init(&drv
->list
);
44 mutex_unlock(&dsa_switch_drivers_mutex
);
46 EXPORT_SYMBOL_GPL(unregister_switch_driver
);
48 static const struct dsa_switch_ops
*
49 dsa_switch_probe(struct device
*parent
, struct device
*host_dev
, int sw_addr
,
50 const char **_name
, void **priv
)
52 const struct dsa_switch_ops
*ret
;
53 struct list_head
*list
;
59 mutex_lock(&dsa_switch_drivers_mutex
);
60 list_for_each(list
, &dsa_switch_drivers
) {
61 const struct dsa_switch_ops
*ops
;
62 struct dsa_switch_driver
*drv
;
64 drv
= list_entry(list
, struct dsa_switch_driver
, list
);
67 name
= ops
->probe(parent
, host_dev
, sw_addr
, priv
);
73 mutex_unlock(&dsa_switch_drivers_mutex
);
80 /* basic switch operations **************************************************/
81 static int dsa_cpu_dsa_setups(struct dsa_switch
*ds
)
85 for (port
= 0; port
< ds
->num_ports
; port
++) {
86 if (!(dsa_is_cpu_port(ds
, port
) || dsa_is_dsa_port(ds
, port
)))
89 ret
= dsa_cpu_dsa_setup(&ds
->ports
[port
]);
96 static int dsa_switch_setup_one(struct dsa_switch
*ds
,
97 struct net_device
*master
)
99 const struct dsa_switch_ops
*ops
= ds
->ops
;
100 struct dsa_switch_tree
*dst
= ds
->dst
;
101 struct dsa_chip_data
*cd
= ds
->cd
;
102 bool valid_name_found
= false;
103 int index
= ds
->index
;
107 * Validate supplied switch configuration.
109 for (i
= 0; i
< ds
->num_ports
; i
++) {
112 name
= cd
->port_names
[i
];
116 if (!strcmp(name
, "cpu")) {
119 "multiple cpu ports?!\n");
122 dst
->cpu_dp
= &ds
->ports
[i
];
123 dst
->cpu_dp
->netdev
= master
;
124 ds
->cpu_port_mask
|= 1 << i
;
125 } else if (!strcmp(name
, "dsa")) {
126 ds
->dsa_port_mask
|= 1 << i
;
128 ds
->enabled_port_mask
|= 1 << i
;
130 valid_name_found
= true;
133 if (!valid_name_found
&& i
== ds
->num_ports
)
136 /* Make the built-in MII bus mask match the number of ports,
137 * switch drivers can override this later
139 ds
->phys_mii_mask
= ds
->enabled_port_mask
;
142 * If the CPU connects to this switch, set the switch tree
143 * tagging protocol to the preferred tagging format of this
146 if (dst
->cpu_dp
->ds
== ds
) {
147 const struct dsa_device_ops
*tag_ops
;
148 enum dsa_tag_protocol tag_protocol
;
150 tag_protocol
= ops
->get_tag_protocol(ds
);
151 tag_ops
= dsa_resolve_tag_protocol(tag_protocol
);
153 return PTR_ERR(tag_ops
);
155 dst
->cpu_dp
->tag_ops
= tag_ops
;
157 /* Few copies for faster access in master receive hot path */
158 dst
->cpu_dp
->rcv
= dst
->cpu_dp
->tag_ops
->rcv
;
159 dst
->cpu_dp
->dst
= dst
;
162 memcpy(ds
->rtable
, cd
->rtable
, sizeof(ds
->rtable
));
165 * Do basic register setup.
167 ret
= ops
->setup(ds
);
171 ret
= dsa_switch_register_notifier(ds
);
175 if (!ds
->slave_mii_bus
&& ops
->phy_read
) {
176 ds
->slave_mii_bus
= devm_mdiobus_alloc(ds
->dev
);
177 if (!ds
->slave_mii_bus
)
179 dsa_slave_mii_bus_init(ds
);
181 ret
= mdiobus_register(ds
->slave_mii_bus
);
187 * Create network devices for physical switch ports.
189 for (i
= 0; i
< ds
->num_ports
; i
++) {
190 ds
->ports
[i
].dn
= cd
->port_dn
[i
];
191 ds
->ports
[i
].cpu_dp
= dst
->cpu_dp
;
193 if (!(ds
->enabled_port_mask
& (1 << i
)))
196 ret
= dsa_slave_create(&ds
->ports
[i
], cd
->port_names
[i
]);
198 netdev_err(master
, "[%d]: can't create dsa slave device for port %d(%s): %d\n",
199 index
, i
, cd
->port_names
[i
], ret
);
202 /* Perform configuration of the CPU and DSA ports */
203 ret
= dsa_cpu_dsa_setups(ds
);
205 netdev_err(master
, "[%d] : can't configure CPU and DSA ports\n",
211 static struct dsa_switch
*
212 dsa_switch_setup(struct dsa_switch_tree
*dst
, struct net_device
*master
,
213 int index
, struct device
*parent
, struct device
*host_dev
)
215 struct dsa_chip_data
*cd
= dst
->pd
->chip
+ index
;
216 const struct dsa_switch_ops
*ops
;
217 struct dsa_switch
*ds
;
223 * Probe for switch model.
225 ops
= dsa_switch_probe(parent
, host_dev
, cd
->sw_addr
, &name
, &priv
);
227 netdev_err(master
, "[%d]: could not detect attached switch\n",
229 return ERR_PTR(-EINVAL
);
231 netdev_info(master
, "[%d]: detected a %s switch\n",
236 * Allocate and initialise switch state.
238 ds
= dsa_switch_alloc(parent
, DSA_MAX_PORTS
);
240 return ERR_PTR(-ENOMEM
);
248 ret
= dsa_switch_setup_one(ds
, master
);
255 static void dsa_switch_destroy(struct dsa_switch
*ds
)
259 /* Destroy network devices for physical switch ports. */
260 for (port
= 0; port
< ds
->num_ports
; port
++) {
261 if (!(ds
->enabled_port_mask
& (1 << port
)))
264 if (!ds
->ports
[port
].netdev
)
267 dsa_slave_destroy(ds
->ports
[port
].netdev
);
270 /* Disable configuration of the CPU and DSA ports */
271 for (port
= 0; port
< ds
->num_ports
; port
++) {
272 if (!(dsa_is_cpu_port(ds
, port
) || dsa_is_dsa_port(ds
, port
)))
274 dsa_cpu_dsa_destroy(&ds
->ports
[port
]);
276 /* Clearing a bit which is not set does no harm */
277 ds
->cpu_port_mask
|= ~(1 << port
);
278 ds
->dsa_port_mask
|= ~(1 << port
);
281 if (ds
->slave_mii_bus
&& ds
->ops
->phy_read
)
282 mdiobus_unregister(ds
->slave_mii_bus
);
284 dsa_switch_unregister_notifier(ds
);
287 /* platform driver init and cleanup *****************************************/
288 static int dev_is_class(struct device
*dev
, void *class)
290 if (dev
->class != NULL
&& !strcmp(dev
->class->name
, class))
296 static struct device
*dev_find_class(struct device
*parent
, char *class)
298 if (dev_is_class(parent
, class)) {
303 return device_find_child(parent
, class, dev_is_class
);
306 struct mii_bus
*dsa_host_dev_to_mii_bus(struct device
*dev
)
310 d
= dev_find_class(dev
, "mdio_bus");
322 EXPORT_SYMBOL_GPL(dsa_host_dev_to_mii_bus
);
325 static int dsa_of_setup_routing_table(struct dsa_platform_data
*pd
,
326 struct dsa_chip_data
*cd
,
327 int chip_index
, int port_index
,
328 struct device_node
*link
)
332 struct device_node
*parent_sw
;
335 parent_sw
= of_get_parent(link
);
339 reg
= of_get_property(parent_sw
, "reg", &len
);
340 if (!reg
|| (len
!= sizeof(*reg
) * 2))
344 * Get the destination switch number from the second field of its 'reg'
345 * property, i.e. for "reg = <0x19 1>" sw_addr is '1'.
347 link_sw_addr
= be32_to_cpup(reg
+ 1);
349 if (link_sw_addr
>= pd
->nr_chips
)
352 cd
->rtable
[link_sw_addr
] = port_index
;
357 static int dsa_of_probe_links(struct dsa_platform_data
*pd
,
358 struct dsa_chip_data
*cd
,
359 int chip_index
, int port_index
,
360 struct device_node
*port
,
361 const char *port_name
)
363 struct device_node
*link
;
367 for (link_index
= 0;; link_index
++) {
368 link
= of_parse_phandle(port
, "link", link_index
);
372 if (!strcmp(port_name
, "dsa") && pd
->nr_chips
> 1) {
373 ret
= dsa_of_setup_routing_table(pd
, cd
, chip_index
,
382 static void dsa_of_free_platform_data(struct dsa_platform_data
*pd
)
387 for (i
= 0; i
< pd
->nr_chips
; i
++) {
389 while (port_index
< DSA_MAX_PORTS
) {
390 kfree(pd
->chip
[i
].port_names
[port_index
]);
394 /* Drop our reference to the MDIO bus device */
395 if (pd
->chip
[i
].host_dev
)
396 put_device(pd
->chip
[i
].host_dev
);
401 static int dsa_of_probe(struct device
*dev
)
403 struct device_node
*np
= dev
->of_node
;
404 struct device_node
*child
, *mdio
, *ethernet
, *port
;
405 struct mii_bus
*mdio_bus
, *mdio_bus_switch
;
406 struct net_device
*ethernet_dev
;
407 struct dsa_platform_data
*pd
;
408 struct dsa_chip_data
*cd
;
409 const char *port_name
;
410 int chip_index
, port_index
;
411 const unsigned int *sw_addr
, *port_reg
;
415 mdio
= of_parse_phandle(np
, "dsa,mii-bus", 0);
419 mdio_bus
= of_mdio_find_bus(mdio
);
421 return -EPROBE_DEFER
;
423 ethernet
= of_parse_phandle(np
, "dsa,ethernet", 0);
429 ethernet_dev
= of_find_net_device_by_node(ethernet
);
435 pd
= kzalloc(sizeof(*pd
), GFP_KERNEL
);
438 goto out_put_ethernet
;
441 dev
->platform_data
= pd
;
442 pd
->of_netdev
= ethernet_dev
;
443 pd
->nr_chips
= of_get_available_child_count(np
);
444 if (pd
->nr_chips
> DSA_MAX_SWITCHES
)
445 pd
->nr_chips
= DSA_MAX_SWITCHES
;
447 pd
->chip
= kcalloc(pd
->nr_chips
, sizeof(struct dsa_chip_data
),
455 for_each_available_child_of_node(np
, child
) {
459 cd
= &pd
->chip
[chip_index
];
463 /* Initialize the routing table */
464 for (i
= 0; i
< DSA_MAX_SWITCHES
; ++i
)
465 cd
->rtable
[i
] = DSA_RTABLE_NONE
;
467 /* When assigning the host device, increment its refcount */
468 cd
->host_dev
= get_device(&mdio_bus
->dev
);
470 sw_addr
= of_get_property(child
, "reg", NULL
);
474 cd
->sw_addr
= be32_to_cpup(sw_addr
);
475 if (cd
->sw_addr
>= PHY_MAX_ADDR
)
478 if (!of_property_read_u32(child
, "eeprom-length", &eeprom_len
))
479 cd
->eeprom_len
= eeprom_len
;
481 mdio
= of_parse_phandle(child
, "mii-bus", 0);
483 mdio_bus_switch
= of_mdio_find_bus(mdio
);
484 if (!mdio_bus_switch
) {
489 /* Drop the mdio_bus device ref, replacing the host
490 * device with the mdio_bus_switch device, keeping
491 * the refcount from of_mdio_find_bus() above.
493 put_device(cd
->host_dev
);
494 cd
->host_dev
= &mdio_bus_switch
->dev
;
497 for_each_available_child_of_node(child
, port
) {
498 port_reg
= of_get_property(port
, "reg", NULL
);
502 port_index
= be32_to_cpup(port_reg
);
503 if (port_index
>= DSA_MAX_PORTS
)
506 port_name
= of_get_property(port
, "label", NULL
);
510 cd
->port_dn
[port_index
] = port
;
512 cd
->port_names
[port_index
] = kstrdup(port_name
,
514 if (!cd
->port_names
[port_index
]) {
519 ret
= dsa_of_probe_links(pd
, cd
, chip_index
,
520 port_index
, port
, port_name
);
527 /* The individual chips hold their own refcount on the mdio bus,
529 put_device(&mdio_bus
->dev
);
534 dsa_of_free_platform_data(pd
);
537 dev
->platform_data
= NULL
;
539 put_device(ðernet_dev
->dev
);
541 put_device(&mdio_bus
->dev
);
545 static void dsa_of_remove(struct device
*dev
)
547 struct dsa_platform_data
*pd
= dev
->platform_data
;
552 dsa_of_free_platform_data(pd
);
553 put_device(&pd
->of_netdev
->dev
);
557 static inline int dsa_of_probe(struct device
*dev
)
562 static inline void dsa_of_remove(struct device
*dev
)
567 static int dsa_setup_dst(struct dsa_switch_tree
*dst
, struct net_device
*dev
,
568 struct device
*parent
, struct dsa_platform_data
*pd
)
571 unsigned configured
= 0;
575 for (i
= 0; i
< pd
->nr_chips
; i
++) {
576 struct dsa_switch
*ds
;
578 ds
= dsa_switch_setup(dst
, dev
, i
, parent
, pd
->chip
[i
].host_dev
);
580 netdev_err(dev
, "[%d]: couldn't create dsa switch instance (error %ld)\n",
591 * If no switch was found, exit cleanly
594 return -EPROBE_DEFER
;
597 * If we use a tagging format that doesn't have an ethertype
598 * field, make sure that all packets from this point on get
599 * sent to the tag format's receive function.
602 dev
->dsa_ptr
= dst
->cpu_dp
;
604 return dsa_master_ethtool_setup(dst
->cpu_dp
->netdev
);
607 static int dsa_probe(struct platform_device
*pdev
)
609 struct dsa_platform_data
*pd
= pdev
->dev
.platform_data
;
610 struct net_device
*dev
;
611 struct dsa_switch_tree
*dst
;
614 if (pdev
->dev
.of_node
) {
615 ret
= dsa_of_probe(&pdev
->dev
);
619 pd
= pdev
->dev
.platform_data
;
622 if (pd
== NULL
|| (pd
->netdev
== NULL
&& pd
->of_netdev
== NULL
))
629 dev
= dsa_dev_to_net_device(pd
->netdev
);
636 if (dev
->dsa_ptr
!= NULL
) {
642 dst
= devm_kzalloc(&pdev
->dev
, sizeof(*dst
), GFP_KERNEL
);
649 platform_set_drvdata(pdev
, dst
);
651 ret
= dsa_setup_dst(dst
, dev
, &pdev
->dev
, pd
);
660 dsa_of_remove(&pdev
->dev
);
665 static void dsa_remove_dst(struct dsa_switch_tree
*dst
)
669 dsa_master_ethtool_restore(dst
->cpu_dp
->netdev
);
671 dst
->cpu_dp
->netdev
->dsa_ptr
= NULL
;
673 /* If we used a tagging format that doesn't have an ethertype
674 * field, make sure that all packets from this point get sent
675 * without the tag and go through the regular receive path.
679 for (i
= 0; i
< dst
->pd
->nr_chips
; i
++) {
680 struct dsa_switch
*ds
= dst
->ds
[i
];
683 dsa_switch_destroy(ds
);
686 dev_put(dst
->cpu_dp
->netdev
);
689 static int dsa_remove(struct platform_device
*pdev
)
691 struct dsa_switch_tree
*dst
= platform_get_drvdata(pdev
);
694 dsa_of_remove(&pdev
->dev
);
699 static void dsa_shutdown(struct platform_device
*pdev
)
703 #ifdef CONFIG_PM_SLEEP
704 static int dsa_suspend(struct device
*d
)
706 struct platform_device
*pdev
= to_platform_device(d
);
707 struct dsa_switch_tree
*dst
= platform_get_drvdata(pdev
);
710 for (i
= 0; i
< dst
->pd
->nr_chips
; i
++) {
711 struct dsa_switch
*ds
= dst
->ds
[i
];
714 ret
= dsa_switch_suspend(ds
);
720 static int dsa_resume(struct device
*d
)
722 struct platform_device
*pdev
= to_platform_device(d
);
723 struct dsa_switch_tree
*dst
= platform_get_drvdata(pdev
);
726 for (i
= 0; i
< dst
->pd
->nr_chips
; i
++) {
727 struct dsa_switch
*ds
= dst
->ds
[i
];
730 ret
= dsa_switch_resume(ds
);
737 /* legacy way, bypassing the bridge *****************************************/
738 int dsa_legacy_fdb_add(struct ndmsg
*ndm
, struct nlattr
*tb
[],
739 struct net_device
*dev
,
740 const unsigned char *addr
, u16 vid
,
743 struct dsa_slave_priv
*p
= netdev_priv(dev
);
744 struct dsa_port
*dp
= p
->dp
;
746 return dsa_port_fdb_add(dp
, addr
, vid
);
749 int dsa_legacy_fdb_del(struct ndmsg
*ndm
, struct nlattr
*tb
[],
750 struct net_device
*dev
,
751 const unsigned char *addr
, u16 vid
)
753 struct dsa_slave_priv
*p
= netdev_priv(dev
);
754 struct dsa_port
*dp
= p
->dp
;
756 return dsa_port_fdb_del(dp
, addr
, vid
);
759 static SIMPLE_DEV_PM_OPS(dsa_pm_ops
, dsa_suspend
, dsa_resume
);
761 static const struct of_device_id dsa_of_match_table
[] = {
762 { .compatible
= "marvell,dsa", },
765 MODULE_DEVICE_TABLE(of
, dsa_of_match_table
);
767 static struct platform_driver dsa_driver
= {
769 .remove
= dsa_remove
,
770 .shutdown
= dsa_shutdown
,
773 .of_match_table
= dsa_of_match_table
,
778 int dsa_legacy_register(void)
780 return platform_driver_register(&dsa_driver
);
783 void dsa_legacy_unregister(void)
785 platform_driver_unregister(&dsa_driver
);