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
);
176 ret
= ops
->set_addr(ds
, master
->dev_addr
);
181 if (!ds
->slave_mii_bus
&& ops
->phy_read
) {
182 ds
->slave_mii_bus
= devm_mdiobus_alloc(ds
->dev
);
183 if (!ds
->slave_mii_bus
)
185 dsa_slave_mii_bus_init(ds
);
187 ret
= mdiobus_register(ds
->slave_mii_bus
);
193 * Create network devices for physical switch ports.
195 for (i
= 0; i
< ds
->num_ports
; i
++) {
196 ds
->ports
[i
].dn
= cd
->port_dn
[i
];
197 ds
->ports
[i
].cpu_dp
= dst
->cpu_dp
;
199 if (!(ds
->enabled_port_mask
& (1 << i
)))
202 ret
= dsa_slave_create(&ds
->ports
[i
], cd
->port_names
[i
]);
204 netdev_err(master
, "[%d]: can't create dsa slave device for port %d(%s): %d\n",
205 index
, i
, cd
->port_names
[i
], ret
);
208 /* Perform configuration of the CPU and DSA ports */
209 ret
= dsa_cpu_dsa_setups(ds
);
211 netdev_err(master
, "[%d] : can't configure CPU and DSA ports\n",
217 static struct dsa_switch
*
218 dsa_switch_setup(struct dsa_switch_tree
*dst
, struct net_device
*master
,
219 int index
, struct device
*parent
, struct device
*host_dev
)
221 struct dsa_chip_data
*cd
= dst
->pd
->chip
+ index
;
222 const struct dsa_switch_ops
*ops
;
223 struct dsa_switch
*ds
;
229 * Probe for switch model.
231 ops
= dsa_switch_probe(parent
, host_dev
, cd
->sw_addr
, &name
, &priv
);
233 netdev_err(master
, "[%d]: could not detect attached switch\n",
235 return ERR_PTR(-EINVAL
);
237 netdev_info(master
, "[%d]: detected a %s switch\n",
242 * Allocate and initialise switch state.
244 ds
= dsa_switch_alloc(parent
, DSA_MAX_PORTS
);
246 return ERR_PTR(-ENOMEM
);
254 ret
= dsa_switch_setup_one(ds
, master
);
261 static void dsa_switch_destroy(struct dsa_switch
*ds
)
265 /* Destroy network devices for physical switch ports. */
266 for (port
= 0; port
< ds
->num_ports
; port
++) {
267 if (!(ds
->enabled_port_mask
& (1 << port
)))
270 if (!ds
->ports
[port
].netdev
)
273 dsa_slave_destroy(ds
->ports
[port
].netdev
);
276 /* Disable configuration of the CPU and DSA ports */
277 for (port
= 0; port
< ds
->num_ports
; port
++) {
278 if (!(dsa_is_cpu_port(ds
, port
) || dsa_is_dsa_port(ds
, port
)))
280 dsa_cpu_dsa_destroy(&ds
->ports
[port
]);
282 /* Clearing a bit which is not set does no harm */
283 ds
->cpu_port_mask
|= ~(1 << port
);
284 ds
->dsa_port_mask
|= ~(1 << port
);
287 if (ds
->slave_mii_bus
&& ds
->ops
->phy_read
)
288 mdiobus_unregister(ds
->slave_mii_bus
);
290 dsa_switch_unregister_notifier(ds
);
293 /* platform driver init and cleanup *****************************************/
294 static int dev_is_class(struct device
*dev
, void *class)
296 if (dev
->class != NULL
&& !strcmp(dev
->class->name
, class))
302 static struct device
*dev_find_class(struct device
*parent
, char *class)
304 if (dev_is_class(parent
, class)) {
309 return device_find_child(parent
, class, dev_is_class
);
312 struct mii_bus
*dsa_host_dev_to_mii_bus(struct device
*dev
)
316 d
= dev_find_class(dev
, "mdio_bus");
328 EXPORT_SYMBOL_GPL(dsa_host_dev_to_mii_bus
);
331 static int dsa_of_setup_routing_table(struct dsa_platform_data
*pd
,
332 struct dsa_chip_data
*cd
,
333 int chip_index
, int port_index
,
334 struct device_node
*link
)
338 struct device_node
*parent_sw
;
341 parent_sw
= of_get_parent(link
);
345 reg
= of_get_property(parent_sw
, "reg", &len
);
346 if (!reg
|| (len
!= sizeof(*reg
) * 2))
350 * Get the destination switch number from the second field of its 'reg'
351 * property, i.e. for "reg = <0x19 1>" sw_addr is '1'.
353 link_sw_addr
= be32_to_cpup(reg
+ 1);
355 if (link_sw_addr
>= pd
->nr_chips
)
358 cd
->rtable
[link_sw_addr
] = port_index
;
363 static int dsa_of_probe_links(struct dsa_platform_data
*pd
,
364 struct dsa_chip_data
*cd
,
365 int chip_index
, int port_index
,
366 struct device_node
*port
,
367 const char *port_name
)
369 struct device_node
*link
;
373 for (link_index
= 0;; link_index
++) {
374 link
= of_parse_phandle(port
, "link", link_index
);
378 if (!strcmp(port_name
, "dsa") && pd
->nr_chips
> 1) {
379 ret
= dsa_of_setup_routing_table(pd
, cd
, chip_index
,
388 static void dsa_of_free_platform_data(struct dsa_platform_data
*pd
)
393 for (i
= 0; i
< pd
->nr_chips
; i
++) {
395 while (port_index
< DSA_MAX_PORTS
) {
396 kfree(pd
->chip
[i
].port_names
[port_index
]);
400 /* Drop our reference to the MDIO bus device */
401 if (pd
->chip
[i
].host_dev
)
402 put_device(pd
->chip
[i
].host_dev
);
407 static int dsa_of_probe(struct device
*dev
)
409 struct device_node
*np
= dev
->of_node
;
410 struct device_node
*child
, *mdio
, *ethernet
, *port
;
411 struct mii_bus
*mdio_bus
, *mdio_bus_switch
;
412 struct net_device
*ethernet_dev
;
413 struct dsa_platform_data
*pd
;
414 struct dsa_chip_data
*cd
;
415 const char *port_name
;
416 int chip_index
, port_index
;
417 const unsigned int *sw_addr
, *port_reg
;
421 mdio
= of_parse_phandle(np
, "dsa,mii-bus", 0);
425 mdio_bus
= of_mdio_find_bus(mdio
);
427 return -EPROBE_DEFER
;
429 ethernet
= of_parse_phandle(np
, "dsa,ethernet", 0);
435 ethernet_dev
= of_find_net_device_by_node(ethernet
);
441 pd
= kzalloc(sizeof(*pd
), GFP_KERNEL
);
444 goto out_put_ethernet
;
447 dev
->platform_data
= pd
;
448 pd
->of_netdev
= ethernet_dev
;
449 pd
->nr_chips
= of_get_available_child_count(np
);
450 if (pd
->nr_chips
> DSA_MAX_SWITCHES
)
451 pd
->nr_chips
= DSA_MAX_SWITCHES
;
453 pd
->chip
= kcalloc(pd
->nr_chips
, sizeof(struct dsa_chip_data
),
461 for_each_available_child_of_node(np
, child
) {
465 cd
= &pd
->chip
[chip_index
];
469 /* Initialize the routing table */
470 for (i
= 0; i
< DSA_MAX_SWITCHES
; ++i
)
471 cd
->rtable
[i
] = DSA_RTABLE_NONE
;
473 /* When assigning the host device, increment its refcount */
474 cd
->host_dev
= get_device(&mdio_bus
->dev
);
476 sw_addr
= of_get_property(child
, "reg", NULL
);
480 cd
->sw_addr
= be32_to_cpup(sw_addr
);
481 if (cd
->sw_addr
>= PHY_MAX_ADDR
)
484 if (!of_property_read_u32(child
, "eeprom-length", &eeprom_len
))
485 cd
->eeprom_len
= eeprom_len
;
487 mdio
= of_parse_phandle(child
, "mii-bus", 0);
489 mdio_bus_switch
= of_mdio_find_bus(mdio
);
490 if (!mdio_bus_switch
) {
495 /* Drop the mdio_bus device ref, replacing the host
496 * device with the mdio_bus_switch device, keeping
497 * the refcount from of_mdio_find_bus() above.
499 put_device(cd
->host_dev
);
500 cd
->host_dev
= &mdio_bus_switch
->dev
;
503 for_each_available_child_of_node(child
, port
) {
504 port_reg
= of_get_property(port
, "reg", NULL
);
508 port_index
= be32_to_cpup(port_reg
);
509 if (port_index
>= DSA_MAX_PORTS
)
512 port_name
= of_get_property(port
, "label", NULL
);
516 cd
->port_dn
[port_index
] = port
;
518 cd
->port_names
[port_index
] = kstrdup(port_name
,
520 if (!cd
->port_names
[port_index
]) {
525 ret
= dsa_of_probe_links(pd
, cd
, chip_index
,
526 port_index
, port
, port_name
);
533 /* The individual chips hold their own refcount on the mdio bus,
535 put_device(&mdio_bus
->dev
);
540 dsa_of_free_platform_data(pd
);
543 dev
->platform_data
= NULL
;
545 put_device(ðernet_dev
->dev
);
547 put_device(&mdio_bus
->dev
);
551 static void dsa_of_remove(struct device
*dev
)
553 struct dsa_platform_data
*pd
= dev
->platform_data
;
558 dsa_of_free_platform_data(pd
);
559 put_device(&pd
->of_netdev
->dev
);
563 static inline int dsa_of_probe(struct device
*dev
)
568 static inline void dsa_of_remove(struct device
*dev
)
573 static int dsa_setup_dst(struct dsa_switch_tree
*dst
, struct net_device
*dev
,
574 struct device
*parent
, struct dsa_platform_data
*pd
)
577 unsigned configured
= 0;
581 for (i
= 0; i
< pd
->nr_chips
; i
++) {
582 struct dsa_switch
*ds
;
584 ds
= dsa_switch_setup(dst
, dev
, i
, parent
, pd
->chip
[i
].host_dev
);
586 netdev_err(dev
, "[%d]: couldn't create dsa switch instance (error %ld)\n",
597 * If no switch was found, exit cleanly
600 return -EPROBE_DEFER
;
603 * If we use a tagging format that doesn't have an ethertype
604 * field, make sure that all packets from this point on get
605 * sent to the tag format's receive function.
608 dev
->dsa_ptr
= dst
->cpu_dp
;
610 return dsa_master_ethtool_setup(dst
->cpu_dp
->netdev
);
613 static int dsa_probe(struct platform_device
*pdev
)
615 struct dsa_platform_data
*pd
= pdev
->dev
.platform_data
;
616 struct net_device
*dev
;
617 struct dsa_switch_tree
*dst
;
620 if (pdev
->dev
.of_node
) {
621 ret
= dsa_of_probe(&pdev
->dev
);
625 pd
= pdev
->dev
.platform_data
;
628 if (pd
== NULL
|| (pd
->netdev
== NULL
&& pd
->of_netdev
== NULL
))
635 dev
= dsa_dev_to_net_device(pd
->netdev
);
642 if (dev
->dsa_ptr
!= NULL
) {
648 dst
= devm_kzalloc(&pdev
->dev
, sizeof(*dst
), GFP_KERNEL
);
655 platform_set_drvdata(pdev
, dst
);
657 ret
= dsa_setup_dst(dst
, dev
, &pdev
->dev
, pd
);
666 dsa_of_remove(&pdev
->dev
);
671 static void dsa_remove_dst(struct dsa_switch_tree
*dst
)
675 dsa_master_ethtool_restore(dst
->cpu_dp
->netdev
);
677 dst
->cpu_dp
->netdev
->dsa_ptr
= NULL
;
679 /* If we used a tagging format that doesn't have an ethertype
680 * field, make sure that all packets from this point get sent
681 * without the tag and go through the regular receive path.
685 for (i
= 0; i
< dst
->pd
->nr_chips
; i
++) {
686 struct dsa_switch
*ds
= dst
->ds
[i
];
689 dsa_switch_destroy(ds
);
692 dev_put(dst
->cpu_dp
->netdev
);
695 static int dsa_remove(struct platform_device
*pdev
)
697 struct dsa_switch_tree
*dst
= platform_get_drvdata(pdev
);
700 dsa_of_remove(&pdev
->dev
);
705 static void dsa_shutdown(struct platform_device
*pdev
)
709 #ifdef CONFIG_PM_SLEEP
710 static int dsa_suspend(struct device
*d
)
712 struct platform_device
*pdev
= to_platform_device(d
);
713 struct dsa_switch_tree
*dst
= platform_get_drvdata(pdev
);
716 for (i
= 0; i
< dst
->pd
->nr_chips
; i
++) {
717 struct dsa_switch
*ds
= dst
->ds
[i
];
720 ret
= dsa_switch_suspend(ds
);
726 static int dsa_resume(struct device
*d
)
728 struct platform_device
*pdev
= to_platform_device(d
);
729 struct dsa_switch_tree
*dst
= platform_get_drvdata(pdev
);
732 for (i
= 0; i
< dst
->pd
->nr_chips
; i
++) {
733 struct dsa_switch
*ds
= dst
->ds
[i
];
736 ret
= dsa_switch_resume(ds
);
743 /* legacy way, bypassing the bridge *****************************************/
744 int dsa_legacy_fdb_add(struct ndmsg
*ndm
, struct nlattr
*tb
[],
745 struct net_device
*dev
,
746 const unsigned char *addr
, u16 vid
,
749 struct dsa_slave_priv
*p
= netdev_priv(dev
);
750 struct dsa_port
*dp
= p
->dp
;
752 return dsa_port_fdb_add(dp
, addr
, vid
);
755 int dsa_legacy_fdb_del(struct ndmsg
*ndm
, struct nlattr
*tb
[],
756 struct net_device
*dev
,
757 const unsigned char *addr
, u16 vid
)
759 struct dsa_slave_priv
*p
= netdev_priv(dev
);
760 struct dsa_port
*dp
= p
->dp
;
762 return dsa_port_fdb_del(dp
, addr
, vid
);
765 static SIMPLE_DEV_PM_OPS(dsa_pm_ops
, dsa_suspend
, dsa_resume
);
767 static const struct of_device_id dsa_of_match_table
[] = {
768 { .compatible
= "marvell,dsa", },
771 MODULE_DEVICE_TABLE(of
, dsa_of_match_table
);
773 static struct platform_driver dsa_driver
= {
775 .remove
= dsa_remove
,
776 .shutdown
= dsa_shutdown
,
779 .of_match_table
= dsa_of_match_table
,
784 int dsa_legacy_register(void)
786 return platform_driver_register(&dsa_driver
);
789 void dsa_legacy_unregister(void)
791 platform_driver_unregister(&dsa_driver
);