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
, struct device
*dev
)
83 struct dsa_port
*dport
;
86 for (port
= 0; port
< ds
->num_ports
; port
++) {
87 if (!(dsa_is_cpu_port(ds
, port
) || dsa_is_dsa_port(ds
, port
)))
90 dport
= &ds
->ports
[port
];
91 ret
= dsa_cpu_dsa_setup(ds
, dev
, dport
, port
);
98 static int dsa_switch_setup_one(struct dsa_switch
*ds
, struct device
*parent
)
100 const struct dsa_switch_ops
*ops
= ds
->ops
;
101 struct dsa_switch_tree
*dst
= ds
->dst
;
102 struct dsa_chip_data
*cd
= ds
->cd
;
103 bool valid_name_found
= false;
104 int index
= ds
->index
;
108 * Validate supplied switch configuration.
110 for (i
= 0; i
< ds
->num_ports
; i
++) {
113 name
= cd
->port_names
[i
];
117 if (!strcmp(name
, "cpu")) {
118 if (dst
->cpu_switch
) {
119 netdev_err(dst
->master_netdev
,
120 "multiple cpu ports?!\n");
123 dst
->cpu_switch
= ds
;
125 ds
->cpu_port_mask
|= 1 << i
;
126 } else if (!strcmp(name
, "dsa")) {
127 ds
->dsa_port_mask
|= 1 << i
;
129 ds
->enabled_port_mask
|= 1 << i
;
131 valid_name_found
= true;
134 if (!valid_name_found
&& i
== ds
->num_ports
)
137 /* Make the built-in MII bus mask match the number of ports,
138 * switch drivers can override this later
140 ds
->phys_mii_mask
= ds
->enabled_port_mask
;
143 * If the CPU connects to this switch, set the switch tree
144 * tagging protocol to the preferred tagging format of this
147 if (dst
->cpu_switch
== ds
) {
148 enum dsa_tag_protocol tag_protocol
;
150 tag_protocol
= ops
->get_tag_protocol(ds
);
151 dst
->tag_ops
= dsa_resolve_tag_protocol(tag_protocol
);
152 if (IS_ERR(dst
->tag_ops
))
153 return PTR_ERR(dst
->tag_ops
);
155 dst
->rcv
= dst
->tag_ops
->rcv
;
158 memcpy(ds
->rtable
, cd
->rtable
, sizeof(ds
->rtable
));
161 * Do basic register setup.
163 ret
= ops
->setup(ds
);
167 ret
= dsa_switch_register_notifier(ds
);
172 ret
= ops
->set_addr(ds
, dst
->master_netdev
->dev_addr
);
177 if (!ds
->slave_mii_bus
&& ops
->phy_read
) {
178 ds
->slave_mii_bus
= devm_mdiobus_alloc(parent
);
179 if (!ds
->slave_mii_bus
)
181 dsa_slave_mii_bus_init(ds
);
183 ret
= mdiobus_register(ds
->slave_mii_bus
);
189 * Create network devices for physical switch ports.
191 for (i
= 0; i
< ds
->num_ports
; i
++) {
192 ds
->ports
[i
].dn
= cd
->port_dn
[i
];
194 if (!(ds
->enabled_port_mask
& (1 << i
)))
197 ret
= dsa_slave_create(ds
, parent
, i
, cd
->port_names
[i
]);
199 netdev_err(dst
->master_netdev
, "[%d]: can't create dsa slave device for port %d(%s): %d\n",
200 index
, i
, cd
->port_names
[i
], ret
);
203 /* Perform configuration of the CPU and DSA ports */
204 ret
= dsa_cpu_dsa_setups(ds
, parent
);
206 netdev_err(dst
->master_netdev
, "[%d] : can't configure CPU and DSA ports\n",
209 ret
= dsa_cpu_port_ethtool_setup(ds
);
216 static struct dsa_switch
*
217 dsa_switch_setup(struct dsa_switch_tree
*dst
, int index
,
218 struct device
*parent
, struct device
*host_dev
)
220 struct dsa_chip_data
*cd
= dst
->pd
->chip
+ index
;
221 const struct dsa_switch_ops
*ops
;
222 struct dsa_switch
*ds
;
228 * Probe for switch model.
230 ops
= dsa_switch_probe(parent
, host_dev
, cd
->sw_addr
, &name
, &priv
);
232 netdev_err(dst
->master_netdev
, "[%d]: could not detect attached switch\n",
234 return ERR_PTR(-EINVAL
);
236 netdev_info(dst
->master_netdev
, "[%d]: detected a %s switch\n",
241 * Allocate and initialise switch state.
243 ds
= dsa_switch_alloc(parent
, DSA_MAX_PORTS
);
245 return ERR_PTR(-ENOMEM
);
253 ret
= dsa_switch_setup_one(ds
, parent
);
260 static void dsa_switch_destroy(struct dsa_switch
*ds
)
264 /* Destroy network devices for physical switch ports. */
265 for (port
= 0; port
< ds
->num_ports
; port
++) {
266 if (!(ds
->enabled_port_mask
& (1 << port
)))
269 if (!ds
->ports
[port
].netdev
)
272 dsa_slave_destroy(ds
->ports
[port
].netdev
);
275 /* Disable configuration of the CPU and DSA ports */
276 for (port
= 0; port
< ds
->num_ports
; port
++) {
277 if (!(dsa_is_cpu_port(ds
, port
) || dsa_is_dsa_port(ds
, port
)))
279 dsa_cpu_dsa_destroy(&ds
->ports
[port
]);
281 /* Clearing a bit which is not set does no harm */
282 ds
->cpu_port_mask
|= ~(1 << port
);
283 ds
->dsa_port_mask
|= ~(1 << port
);
286 if (ds
->slave_mii_bus
&& ds
->ops
->phy_read
)
287 mdiobus_unregister(ds
->slave_mii_bus
);
289 dsa_switch_unregister_notifier(ds
);
292 #ifdef CONFIG_PM_SLEEP
293 int dsa_switch_suspend(struct dsa_switch
*ds
)
297 /* Suspend slave network devices */
298 for (i
= 0; i
< ds
->num_ports
; i
++) {
299 if (!dsa_is_port_initialized(ds
, i
))
302 ret
= dsa_slave_suspend(ds
->ports
[i
].netdev
);
307 if (ds
->ops
->suspend
)
308 ret
= ds
->ops
->suspend(ds
);
312 EXPORT_SYMBOL_GPL(dsa_switch_suspend
);
314 int dsa_switch_resume(struct dsa_switch
*ds
)
319 ret
= ds
->ops
->resume(ds
);
324 /* Resume slave network devices */
325 for (i
= 0; i
< ds
->num_ports
; i
++) {
326 if (!dsa_is_port_initialized(ds
, i
))
329 ret
= dsa_slave_resume(ds
->ports
[i
].netdev
);
336 EXPORT_SYMBOL_GPL(dsa_switch_resume
);
339 /* platform driver init and cleanup *****************************************/
340 static int dev_is_class(struct device
*dev
, void *class)
342 if (dev
->class != NULL
&& !strcmp(dev
->class->name
, class))
348 static struct device
*dev_find_class(struct device
*parent
, char *class)
350 if (dev_is_class(parent
, class)) {
355 return device_find_child(parent
, class, dev_is_class
);
358 struct mii_bus
*dsa_host_dev_to_mii_bus(struct device
*dev
)
362 d
= dev_find_class(dev
, "mdio_bus");
374 EXPORT_SYMBOL_GPL(dsa_host_dev_to_mii_bus
);
377 static int dsa_of_setup_routing_table(struct dsa_platform_data
*pd
,
378 struct dsa_chip_data
*cd
,
379 int chip_index
, int port_index
,
380 struct device_node
*link
)
384 struct device_node
*parent_sw
;
387 parent_sw
= of_get_parent(link
);
391 reg
= of_get_property(parent_sw
, "reg", &len
);
392 if (!reg
|| (len
!= sizeof(*reg
) * 2))
396 * Get the destination switch number from the second field of its 'reg'
397 * property, i.e. for "reg = <0x19 1>" sw_addr is '1'.
399 link_sw_addr
= be32_to_cpup(reg
+ 1);
401 if (link_sw_addr
>= pd
->nr_chips
)
404 cd
->rtable
[link_sw_addr
] = port_index
;
409 static int dsa_of_probe_links(struct dsa_platform_data
*pd
,
410 struct dsa_chip_data
*cd
,
411 int chip_index
, int port_index
,
412 struct device_node
*port
,
413 const char *port_name
)
415 struct device_node
*link
;
419 for (link_index
= 0;; link_index
++) {
420 link
= of_parse_phandle(port
, "link", link_index
);
424 if (!strcmp(port_name
, "dsa") && pd
->nr_chips
> 1) {
425 ret
= dsa_of_setup_routing_table(pd
, cd
, chip_index
,
434 static void dsa_of_free_platform_data(struct dsa_platform_data
*pd
)
439 for (i
= 0; i
< pd
->nr_chips
; i
++) {
441 while (port_index
< DSA_MAX_PORTS
) {
442 kfree(pd
->chip
[i
].port_names
[port_index
]);
446 /* Drop our reference to the MDIO bus device */
447 if (pd
->chip
[i
].host_dev
)
448 put_device(pd
->chip
[i
].host_dev
);
453 static int dsa_of_probe(struct device
*dev
)
455 struct device_node
*np
= dev
->of_node
;
456 struct device_node
*child
, *mdio
, *ethernet
, *port
;
457 struct mii_bus
*mdio_bus
, *mdio_bus_switch
;
458 struct net_device
*ethernet_dev
;
459 struct dsa_platform_data
*pd
;
460 struct dsa_chip_data
*cd
;
461 const char *port_name
;
462 int chip_index
, port_index
;
463 const unsigned int *sw_addr
, *port_reg
;
467 mdio
= of_parse_phandle(np
, "dsa,mii-bus", 0);
471 mdio_bus
= of_mdio_find_bus(mdio
);
473 return -EPROBE_DEFER
;
475 ethernet
= of_parse_phandle(np
, "dsa,ethernet", 0);
481 ethernet_dev
= of_find_net_device_by_node(ethernet
);
487 pd
= kzalloc(sizeof(*pd
), GFP_KERNEL
);
490 goto out_put_ethernet
;
493 dev
->platform_data
= pd
;
494 pd
->of_netdev
= ethernet_dev
;
495 pd
->nr_chips
= of_get_available_child_count(np
);
496 if (pd
->nr_chips
> DSA_MAX_SWITCHES
)
497 pd
->nr_chips
= DSA_MAX_SWITCHES
;
499 pd
->chip
= kcalloc(pd
->nr_chips
, sizeof(struct dsa_chip_data
),
507 for_each_available_child_of_node(np
, child
) {
511 cd
= &pd
->chip
[chip_index
];
515 /* Initialize the routing table */
516 for (i
= 0; i
< DSA_MAX_SWITCHES
; ++i
)
517 cd
->rtable
[i
] = DSA_RTABLE_NONE
;
519 /* When assigning the host device, increment its refcount */
520 cd
->host_dev
= get_device(&mdio_bus
->dev
);
522 sw_addr
= of_get_property(child
, "reg", NULL
);
526 cd
->sw_addr
= be32_to_cpup(sw_addr
);
527 if (cd
->sw_addr
>= PHY_MAX_ADDR
)
530 if (!of_property_read_u32(child
, "eeprom-length", &eeprom_len
))
531 cd
->eeprom_len
= eeprom_len
;
533 mdio
= of_parse_phandle(child
, "mii-bus", 0);
535 mdio_bus_switch
= of_mdio_find_bus(mdio
);
536 if (!mdio_bus_switch
) {
541 /* Drop the mdio_bus device ref, replacing the host
542 * device with the mdio_bus_switch device, keeping
543 * the refcount from of_mdio_find_bus() above.
545 put_device(cd
->host_dev
);
546 cd
->host_dev
= &mdio_bus_switch
->dev
;
549 for_each_available_child_of_node(child
, port
) {
550 port_reg
= of_get_property(port
, "reg", NULL
);
554 port_index
= be32_to_cpup(port_reg
);
555 if (port_index
>= DSA_MAX_PORTS
)
558 port_name
= of_get_property(port
, "label", NULL
);
562 cd
->port_dn
[port_index
] = port
;
564 cd
->port_names
[port_index
] = kstrdup(port_name
,
566 if (!cd
->port_names
[port_index
]) {
571 ret
= dsa_of_probe_links(pd
, cd
, chip_index
,
572 port_index
, port
, port_name
);
579 /* The individual chips hold their own refcount on the mdio bus,
581 put_device(&mdio_bus
->dev
);
586 dsa_of_free_platform_data(pd
);
589 dev
->platform_data
= NULL
;
591 put_device(ðernet_dev
->dev
);
593 put_device(&mdio_bus
->dev
);
597 static void dsa_of_remove(struct device
*dev
)
599 struct dsa_platform_data
*pd
= dev
->platform_data
;
604 dsa_of_free_platform_data(pd
);
605 put_device(&pd
->of_netdev
->dev
);
609 static inline int dsa_of_probe(struct device
*dev
)
614 static inline void dsa_of_remove(struct device
*dev
)
619 static int dsa_setup_dst(struct dsa_switch_tree
*dst
, struct net_device
*dev
,
620 struct device
*parent
, struct dsa_platform_data
*pd
)
623 unsigned configured
= 0;
626 dst
->master_netdev
= dev
;
629 for (i
= 0; i
< pd
->nr_chips
; i
++) {
630 struct dsa_switch
*ds
;
632 ds
= dsa_switch_setup(dst
, i
, parent
, pd
->chip
[i
].host_dev
);
634 netdev_err(dev
, "[%d]: couldn't create dsa switch instance (error %ld)\n",
645 * If no switch was found, exit cleanly
648 return -EPROBE_DEFER
;
651 * If we use a tagging format that doesn't have an ethertype
652 * field, make sure that all packets from this point on get
653 * sent to the tag format's receive function.
656 dev
->dsa_ptr
= (void *)dst
;
661 static int dsa_probe(struct platform_device
*pdev
)
663 struct dsa_platform_data
*pd
= pdev
->dev
.platform_data
;
664 struct net_device
*dev
;
665 struct dsa_switch_tree
*dst
;
668 if (pdev
->dev
.of_node
) {
669 ret
= dsa_of_probe(&pdev
->dev
);
673 pd
= pdev
->dev
.platform_data
;
676 if (pd
== NULL
|| (pd
->netdev
== NULL
&& pd
->of_netdev
== NULL
))
683 dev
= dsa_dev_to_net_device(pd
->netdev
);
690 if (dev
->dsa_ptr
!= NULL
) {
696 dst
= devm_kzalloc(&pdev
->dev
, sizeof(*dst
), GFP_KERNEL
);
703 platform_set_drvdata(pdev
, dst
);
705 ret
= dsa_setup_dst(dst
, dev
, &pdev
->dev
, pd
);
714 dsa_of_remove(&pdev
->dev
);
719 static void dsa_remove_dst(struct dsa_switch_tree
*dst
)
723 dst
->master_netdev
->dsa_ptr
= NULL
;
725 /* If we used a tagging format that doesn't have an ethertype
726 * field, make sure that all packets from this point get sent
727 * without the tag and go through the regular receive path.
731 for (i
= 0; i
< dst
->pd
->nr_chips
; i
++) {
732 struct dsa_switch
*ds
= dst
->ds
[i
];
735 dsa_switch_destroy(ds
);
738 dsa_cpu_port_ethtool_restore(dst
->cpu_switch
);
740 dev_put(dst
->master_netdev
);
743 static int dsa_remove(struct platform_device
*pdev
)
745 struct dsa_switch_tree
*dst
= platform_get_drvdata(pdev
);
748 dsa_of_remove(&pdev
->dev
);
753 static void dsa_shutdown(struct platform_device
*pdev
)
757 #ifdef CONFIG_PM_SLEEP
758 static int dsa_suspend(struct device
*d
)
760 struct platform_device
*pdev
= to_platform_device(d
);
761 struct dsa_switch_tree
*dst
= platform_get_drvdata(pdev
);
764 for (i
= 0; i
< dst
->pd
->nr_chips
; i
++) {
765 struct dsa_switch
*ds
= dst
->ds
[i
];
768 ret
= dsa_switch_suspend(ds
);
774 static int dsa_resume(struct device
*d
)
776 struct platform_device
*pdev
= to_platform_device(d
);
777 struct dsa_switch_tree
*dst
= platform_get_drvdata(pdev
);
780 for (i
= 0; i
< dst
->pd
->nr_chips
; i
++) {
781 struct dsa_switch
*ds
= dst
->ds
[i
];
784 ret
= dsa_switch_resume(ds
);
791 static SIMPLE_DEV_PM_OPS(dsa_pm_ops
, dsa_suspend
, dsa_resume
);
793 static const struct of_device_id dsa_of_match_table
[] = {
794 { .compatible
= "marvell,dsa", },
797 MODULE_DEVICE_TABLE(of
, dsa_of_match_table
);
799 static struct platform_driver dsa_driver
= {
801 .remove
= dsa_remove
,
802 .shutdown
= dsa_shutdown
,
805 .of_match_table
= dsa_of_match_table
,
810 int dsa_legacy_register(void)
812 return platform_driver_register(&dsa_driver
);
815 void dsa_legacy_unregister(void)
817 platform_driver_unregister(&dsa_driver
);