xref: /openbmc/linux/net/dsa/dsa.c (revision 94c7b6fc) 
1 /*
2  * net/dsa/dsa.c - Hardware switch handling
3  * Copyright (c) 2008-2009 Marvell Semiconductor
4  * Copyright (c) 2013 Florian Fainelli <florian@openwrt.org>
5  *
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.
10  */
11 
12 #include <linux/list.h>
13 #include <linux/netdevice.h>
14 #include <linux/platform_device.h>
15 #include <linux/slab.h>
16 #include <linux/module.h>
17 #include <net/dsa.h>
18 #include <linux/of.h>
19 #include <linux/of_mdio.h>
20 #include <linux/of_platform.h>
21 #include "dsa_priv.h"
22 
23 char dsa_driver_version[] = "0.1";
24 
25 
26 /* switch driver registration ***********************************************/
27 static DEFINE_MUTEX(dsa_switch_drivers_mutex);
28 static LIST_HEAD(dsa_switch_drivers);
29 
30 void register_switch_driver(struct dsa_switch_driver *drv)
31 {
32 	mutex_lock(&dsa_switch_drivers_mutex);
33 	list_add_tail(&drv->list, &dsa_switch_drivers);
34 	mutex_unlock(&dsa_switch_drivers_mutex);
35 }
36 EXPORT_SYMBOL_GPL(register_switch_driver);
37 
38 void unregister_switch_driver(struct dsa_switch_driver *drv)
39 {
40 	mutex_lock(&dsa_switch_drivers_mutex);
41 	list_del_init(&drv->list);
42 	mutex_unlock(&dsa_switch_drivers_mutex);
43 }
44 EXPORT_SYMBOL_GPL(unregister_switch_driver);
45 
46 static struct dsa_switch_driver *
47 dsa_switch_probe(struct mii_bus *bus, int sw_addr, char **_name)
48 {
49 	struct dsa_switch_driver *ret;
50 	struct list_head *list;
51 	char *name;
52 
53 	ret = NULL;
54 	name = NULL;
55 
56 	mutex_lock(&dsa_switch_drivers_mutex);
57 	list_for_each(list, &dsa_switch_drivers) {
58 		struct dsa_switch_driver *drv;
59 
60 		drv = list_entry(list, struct dsa_switch_driver, list);
61 
62 		name = drv->probe(bus, sw_addr);
63 		if (name != NULL) {
64 			ret = drv;
65 			break;
66 		}
67 	}
68 	mutex_unlock(&dsa_switch_drivers_mutex);
69 
70 	*_name = name;
71 
72 	return ret;
73 }
74 
75 
76 /* basic switch operations **************************************************/
77 static struct dsa_switch *
78 dsa_switch_setup(struct dsa_switch_tree *dst, int index,
79 		 struct device *parent, struct mii_bus *bus)
80 {
81 	struct dsa_chip_data *pd = dst->pd->chip + index;
82 	struct dsa_switch_driver *drv;
83 	struct dsa_switch *ds;
84 	int ret;
85 	char *name;
86 	int i;
87 	bool valid_name_found = false;
88 
89 	/*
90 	 * Probe for switch model.
91 	 */
92 	drv = dsa_switch_probe(bus, pd->sw_addr, &name);
93 	if (drv == NULL) {
94 		printk(KERN_ERR "%s[%d]: could not detect attached switch\n",
95 		       dst->master_netdev->name, index);
96 		return ERR_PTR(-EINVAL);
97 	}
98 	printk(KERN_INFO "%s[%d]: detected a %s switch\n",
99 		dst->master_netdev->name, index, name);
100 
101 
102 	/*
103 	 * Allocate and initialise switch state.
104 	 */
105 	ds = kzalloc(sizeof(*ds) + drv->priv_size, GFP_KERNEL);
106 	if (ds == NULL)
107 		return ERR_PTR(-ENOMEM);
108 
109 	ds->dst = dst;
110 	ds->index = index;
111 	ds->pd = dst->pd->chip + index;
112 	ds->drv = drv;
113 	ds->master_mii_bus = bus;
114 
115 
116 	/*
117 	 * Validate supplied switch configuration.
118 	 */
119 	for (i = 0; i < DSA_MAX_PORTS; i++) {
120 		char *name;
121 
122 		name = pd->port_names[i];
123 		if (name == NULL)
124 			continue;
125 
126 		if (!strcmp(name, "cpu")) {
127 			if (dst->cpu_switch != -1) {
128 				printk(KERN_ERR "multiple cpu ports?!\n");
129 				ret = -EINVAL;
130 				goto out;
131 			}
132 			dst->cpu_switch = index;
133 			dst->cpu_port = i;
134 		} else if (!strcmp(name, "dsa")) {
135 			ds->dsa_port_mask |= 1 << i;
136 		} else {
137 			ds->phys_port_mask |= 1 << i;
138 		}
139 		valid_name_found = true;
140 	}
141 
142 	if (!valid_name_found && i == DSA_MAX_PORTS) {
143 		ret = -EINVAL;
144 		goto out;
145 	}
146 
147 	/*
148 	 * If the CPU connects to this switch, set the switch tree
149 	 * tagging protocol to the preferred tagging format of this
150 	 * switch.
151 	 */
152 	if (ds->dst->cpu_switch == index)
153 		ds->dst->tag_protocol = drv->tag_protocol;
154 
155 
156 	/*
157 	 * Do basic register setup.
158 	 */
159 	ret = drv->setup(ds);
160 	if (ret < 0)
161 		goto out;
162 
163 	ret = drv->set_addr(ds, dst->master_netdev->dev_addr);
164 	if (ret < 0)
165 		goto out;
166 
167 	ds->slave_mii_bus = mdiobus_alloc();
168 	if (ds->slave_mii_bus == NULL) {
169 		ret = -ENOMEM;
170 		goto out;
171 	}
172 	dsa_slave_mii_bus_init(ds);
173 
174 	ret = mdiobus_register(ds->slave_mii_bus);
175 	if (ret < 0)
176 		goto out_free;
177 
178 
179 	/*
180 	 * Create network devices for physical switch ports.
181 	 */
182 	for (i = 0; i < DSA_MAX_PORTS; i++) {
183 		struct net_device *slave_dev;
184 
185 		if (!(ds->phys_port_mask & (1 << i)))
186 			continue;
187 
188 		slave_dev = dsa_slave_create(ds, parent, i, pd->port_names[i]);
189 		if (slave_dev == NULL) {
190 			printk(KERN_ERR "%s[%d]: can't create dsa "
191 			       "slave device for port %d(%s)\n",
192 			       dst->master_netdev->name,
193 			       index, i, pd->port_names[i]);
194 			continue;
195 		}
196 
197 		ds->ports[i] = slave_dev;
198 	}
199 
200 	return ds;
201 
202 out_free:
203 	mdiobus_free(ds->slave_mii_bus);
204 out:
205 	kfree(ds);
206 	return ERR_PTR(ret);
207 }
208 
209 static void dsa_switch_destroy(struct dsa_switch *ds)
210 {
211 }
212 
213 
214 /* link polling *************************************************************/
215 static void dsa_link_poll_work(struct work_struct *ugly)
216 {
217 	struct dsa_switch_tree *dst;
218 	int i;
219 
220 	dst = container_of(ugly, struct dsa_switch_tree, link_poll_work);
221 
222 	for (i = 0; i < dst->pd->nr_chips; i++) {
223 		struct dsa_switch *ds = dst->ds[i];
224 
225 		if (ds != NULL && ds->drv->poll_link != NULL)
226 			ds->drv->poll_link(ds);
227 	}
228 
229 	mod_timer(&dst->link_poll_timer, round_jiffies(jiffies + HZ));
230 }
231 
232 static void dsa_link_poll_timer(unsigned long _dst)
233 {
234 	struct dsa_switch_tree *dst = (void *)_dst;
235 
236 	schedule_work(&dst->link_poll_work);
237 }
238 
239 
240 /* platform driver init and cleanup *****************************************/
241 static int dev_is_class(struct device *dev, void *class)
242 {
243 	if (dev->class != NULL && !strcmp(dev->class->name, class))
244 		return 1;
245 
246 	return 0;
247 }
248 
249 static struct device *dev_find_class(struct device *parent, char *class)
250 {
251 	if (dev_is_class(parent, class)) {
252 		get_device(parent);
253 		return parent;
254 	}
255 
256 	return device_find_child(parent, class, dev_is_class);
257 }
258 
259 static struct mii_bus *dev_to_mii_bus(struct device *dev)
260 {
261 	struct device *d;
262 
263 	d = dev_find_class(dev, "mdio_bus");
264 	if (d != NULL) {
265 		struct mii_bus *bus;
266 
267 		bus = to_mii_bus(d);
268 		put_device(d);
269 
270 		return bus;
271 	}
272 
273 	return NULL;
274 }
275 
276 static struct net_device *dev_to_net_device(struct device *dev)
277 {
278 	struct device *d;
279 
280 	d = dev_find_class(dev, "net");
281 	if (d != NULL) {
282 		struct net_device *nd;
283 
284 		nd = to_net_dev(d);
285 		dev_hold(nd);
286 		put_device(d);
287 
288 		return nd;
289 	}
290 
291 	return NULL;
292 }
293 
294 #ifdef CONFIG_OF
295 static int dsa_of_setup_routing_table(struct dsa_platform_data *pd,
296 					struct dsa_chip_data *cd,
297 					int chip_index,
298 					struct device_node *link)
299 {
300 	int ret;
301 	const __be32 *reg;
302 	int link_port_addr;
303 	int link_sw_addr;
304 	struct device_node *parent_sw;
305 	int len;
306 
307 	parent_sw = of_get_parent(link);
308 	if (!parent_sw)
309 		return -EINVAL;
310 
311 	reg = of_get_property(parent_sw, "reg", &len);
312 	if (!reg || (len != sizeof(*reg) * 2))
313 		return -EINVAL;
314 
315 	link_sw_addr = be32_to_cpup(reg + 1);
316 
317 	if (link_sw_addr >= pd->nr_chips)
318 		return -EINVAL;
319 
320 	/* First time routing table allocation */
321 	if (!cd->rtable) {
322 		cd->rtable = kmalloc(pd->nr_chips * sizeof(s8), GFP_KERNEL);
323 		if (!cd->rtable)
324 			return -ENOMEM;
325 
326 		/* default to no valid uplink/downlink */
327 		memset(cd->rtable, -1, pd->nr_chips * sizeof(s8));
328 	}
329 
330 	reg = of_get_property(link, "reg", NULL);
331 	if (!reg) {
332 		ret = -EINVAL;
333 		goto out;
334 	}
335 
336 	link_port_addr = be32_to_cpup(reg);
337 
338 	cd->rtable[link_sw_addr] = link_port_addr;
339 
340 	return 0;
341 out:
342 	kfree(cd->rtable);
343 	return ret;
344 }
345 
346 static void dsa_of_free_platform_data(struct dsa_platform_data *pd)
347 {
348 	int i;
349 	int port_index;
350 
351 	for (i = 0; i < pd->nr_chips; i++) {
352 		port_index = 0;
353 		while (port_index < DSA_MAX_PORTS) {
354 			if (pd->chip[i].port_names[port_index])
355 				kfree(pd->chip[i].port_names[port_index]);
356 			port_index++;
357 		}
358 		kfree(pd->chip[i].rtable);
359 	}
360 	kfree(pd->chip);
361 }
362 
363 static int dsa_of_probe(struct platform_device *pdev)
364 {
365 	struct device_node *np = pdev->dev.of_node;
366 	struct device_node *child, *mdio, *ethernet, *port, *link;
367 	struct mii_bus *mdio_bus;
368 	struct platform_device *ethernet_dev;
369 	struct dsa_platform_data *pd;
370 	struct dsa_chip_data *cd;
371 	const char *port_name;
372 	int chip_index, port_index;
373 	const unsigned int *sw_addr, *port_reg;
374 	int ret;
375 
376 	mdio = of_parse_phandle(np, "dsa,mii-bus", 0);
377 	if (!mdio)
378 		return -EINVAL;
379 
380 	mdio_bus = of_mdio_find_bus(mdio);
381 	if (!mdio_bus)
382 		return -EINVAL;
383 
384 	ethernet = of_parse_phandle(np, "dsa,ethernet", 0);
385 	if (!ethernet)
386 		return -EINVAL;
387 
388 	ethernet_dev = of_find_device_by_node(ethernet);
389 	if (!ethernet_dev)
390 		return -ENODEV;
391 
392 	pd = kzalloc(sizeof(*pd), GFP_KERNEL);
393 	if (!pd)
394 		return -ENOMEM;
395 
396 	pdev->dev.platform_data = pd;
397 	pd->netdev = &ethernet_dev->dev;
398 	pd->nr_chips = of_get_child_count(np);
399 	if (pd->nr_chips > DSA_MAX_SWITCHES)
400 		pd->nr_chips = DSA_MAX_SWITCHES;
401 
402 	pd->chip = kzalloc(pd->nr_chips * sizeof(struct dsa_chip_data),
403 			GFP_KERNEL);
404 	if (!pd->chip) {
405 		ret = -ENOMEM;
406 		goto out_free;
407 	}
408 
409 	chip_index = -1;
410 	for_each_available_child_of_node(np, child) {
411 		chip_index++;
412 		cd = &pd->chip[chip_index];
413 
414 		cd->mii_bus = &mdio_bus->dev;
415 
416 		sw_addr = of_get_property(child, "reg", NULL);
417 		if (!sw_addr)
418 			continue;
419 
420 		cd->sw_addr = be32_to_cpup(sw_addr);
421 		if (cd->sw_addr > PHY_MAX_ADDR)
422 			continue;
423 
424 		for_each_available_child_of_node(child, port) {
425 			port_reg = of_get_property(port, "reg", NULL);
426 			if (!port_reg)
427 				continue;
428 
429 			port_index = be32_to_cpup(port_reg);
430 
431 			port_name = of_get_property(port, "label", NULL);
432 			if (!port_name)
433 				continue;
434 
435 			cd->port_names[port_index] = kstrdup(port_name,
436 					GFP_KERNEL);
437 			if (!cd->port_names[port_index]) {
438 				ret = -ENOMEM;
439 				goto out_free_chip;
440 			}
441 
442 			link = of_parse_phandle(port, "link", 0);
443 
444 			if (!strcmp(port_name, "dsa") && link &&
445 					pd->nr_chips > 1) {
446 				ret = dsa_of_setup_routing_table(pd, cd,
447 						chip_index, link);
448 				if (ret)
449 					goto out_free_chip;
450 			}
451 
452 			if (port_index == DSA_MAX_PORTS)
453 				break;
454 		}
455 	}
456 
457 	return 0;
458 
459 out_free_chip:
460 	dsa_of_free_platform_data(pd);
461 out_free:
462 	kfree(pd);
463 	pdev->dev.platform_data = NULL;
464 	return ret;
465 }
466 
467 static void dsa_of_remove(struct platform_device *pdev)
468 {
469 	struct dsa_platform_data *pd = pdev->dev.platform_data;
470 
471 	if (!pdev->dev.of_node)
472 		return;
473 
474 	dsa_of_free_platform_data(pd);
475 	kfree(pd);
476 }
477 #else
478 static inline int dsa_of_probe(struct platform_device *pdev)
479 {
480 	return 0;
481 }
482 
483 static inline void dsa_of_remove(struct platform_device *pdev)
484 {
485 }
486 #endif
487 
488 static int dsa_probe(struct platform_device *pdev)
489 {
490 	static int dsa_version_printed;
491 	struct dsa_platform_data *pd = pdev->dev.platform_data;
492 	struct net_device *dev;
493 	struct dsa_switch_tree *dst;
494 	int i, ret;
495 
496 	if (!dsa_version_printed++)
497 		printk(KERN_NOTICE "Distributed Switch Architecture "
498 			"driver version %s\n", dsa_driver_version);
499 
500 	if (pdev->dev.of_node) {
501 		ret = dsa_of_probe(pdev);
502 		if (ret)
503 			return ret;
504 
505 		pd = pdev->dev.platform_data;
506 	}
507 
508 	if (pd == NULL || pd->netdev == NULL)
509 		return -EINVAL;
510 
511 	dev = dev_to_net_device(pd->netdev);
512 	if (dev == NULL) {
513 		ret = -EINVAL;
514 		goto out;
515 	}
516 
517 	if (dev->dsa_ptr != NULL) {
518 		dev_put(dev);
519 		ret = -EEXIST;
520 		goto out;
521 	}
522 
523 	dst = kzalloc(sizeof(*dst), GFP_KERNEL);
524 	if (dst == NULL) {
525 		dev_put(dev);
526 		ret = -ENOMEM;
527 		goto out;
528 	}
529 
530 	platform_set_drvdata(pdev, dst);
531 
532 	dst->pd = pd;
533 	dst->master_netdev = dev;
534 	dst->cpu_switch = -1;
535 	dst->cpu_port = -1;
536 
537 	for (i = 0; i < pd->nr_chips; i++) {
538 		struct mii_bus *bus;
539 		struct dsa_switch *ds;
540 
541 		bus = dev_to_mii_bus(pd->chip[i].mii_bus);
542 		if (bus == NULL) {
543 			printk(KERN_ERR "%s[%d]: no mii bus found for "
544 				"dsa switch\n", dev->name, i);
545 			continue;
546 		}
547 
548 		ds = dsa_switch_setup(dst, i, &pdev->dev, bus);
549 		if (IS_ERR(ds)) {
550 			printk(KERN_ERR "%s[%d]: couldn't create dsa switch "
551 				"instance (error %ld)\n", dev->name, i,
552 				PTR_ERR(ds));
553 			continue;
554 		}
555 
556 		dst->ds[i] = ds;
557 		if (ds->drv->poll_link != NULL)
558 			dst->link_poll_needed = 1;
559 	}
560 
561 	/*
562 	 * If we use a tagging format that doesn't have an ethertype
563 	 * field, make sure that all packets from this point on get
564 	 * sent to the tag format's receive function.
565 	 */
566 	wmb();
567 	dev->dsa_ptr = (void *)dst;
568 
569 	if (dst->link_poll_needed) {
570 		INIT_WORK(&dst->link_poll_work, dsa_link_poll_work);
571 		init_timer(&dst->link_poll_timer);
572 		dst->link_poll_timer.data = (unsigned long)dst;
573 		dst->link_poll_timer.function = dsa_link_poll_timer;
574 		dst->link_poll_timer.expires = round_jiffies(jiffies + HZ);
575 		add_timer(&dst->link_poll_timer);
576 	}
577 
578 	return 0;
579 
580 out:
581 	dsa_of_remove(pdev);
582 
583 	return ret;
584 }
585 
586 static int dsa_remove(struct platform_device *pdev)
587 {
588 	struct dsa_switch_tree *dst = platform_get_drvdata(pdev);
589 	int i;
590 
591 	if (dst->link_poll_needed)
592 		del_timer_sync(&dst->link_poll_timer);
593 
594 	flush_work(&dst->link_poll_work);
595 
596 	for (i = 0; i < dst->pd->nr_chips; i++) {
597 		struct dsa_switch *ds = dst->ds[i];
598 
599 		if (ds != NULL)
600 			dsa_switch_destroy(ds);
601 	}
602 
603 	dsa_of_remove(pdev);
604 
605 	return 0;
606 }
607 
608 static void dsa_shutdown(struct platform_device *pdev)
609 {
610 }
611 
612 static const struct of_device_id dsa_of_match_table[] = {
613 	{ .compatible = "marvell,dsa", },
614 	{}
615 };
616 MODULE_DEVICE_TABLE(of, dsa_of_match_table);
617 
618 static struct platform_driver dsa_driver = {
619 	.probe		= dsa_probe,
620 	.remove		= dsa_remove,
621 	.shutdown	= dsa_shutdown,
622 	.driver = {
623 		.name	= "dsa",
624 		.owner	= THIS_MODULE,
625 		.of_match_table = dsa_of_match_table,
626 	},
627 };
628 
629 static int __init dsa_init_module(void)
630 {
631 	int rc;
632 
633 	rc = platform_driver_register(&dsa_driver);
634 	if (rc)
635 		return rc;
636 
637 #ifdef CONFIG_NET_DSA_TAG_DSA
638 	dev_add_pack(&dsa_packet_type);
639 #endif
640 #ifdef CONFIG_NET_DSA_TAG_EDSA
641 	dev_add_pack(&edsa_packet_type);
642 #endif
643 #ifdef CONFIG_NET_DSA_TAG_TRAILER
644 	dev_add_pack(&trailer_packet_type);
645 #endif
646 	return 0;
647 }
648 module_init(dsa_init_module);
649 
650 static void __exit dsa_cleanup_module(void)
651 {
652 #ifdef CONFIG_NET_DSA_TAG_TRAILER
653 	dev_remove_pack(&trailer_packet_type);
654 #endif
655 #ifdef CONFIG_NET_DSA_TAG_EDSA
656 	dev_remove_pack(&edsa_packet_type);
657 #endif
658 #ifdef CONFIG_NET_DSA_TAG_DSA
659 	dev_remove_pack(&dsa_packet_type);
660 #endif
661 	platform_driver_unregister(&dsa_driver);
662 }
663 module_exit(dsa_cleanup_module);
664 
665 MODULE_AUTHOR("Lennert Buytenhek <buytenh@wantstofly.org>");
666 MODULE_DESCRIPTION("Driver for Distributed Switch Architecture switch chips");
667 MODULE_LICENSE("GPL");
668 MODULE_ALIAS("platform:dsa");
669