1/*
2 * net/dsa/dsa.c - Hardware switch handling
3 * Copyright (c) 2008-2009 Marvell Semiconductor
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 */
10
11#include <linux/list.h>
12#include <linux/netdevice.h>
13#include <linux/platform_device.h>
14#include <linux/slab.h>
15#include <net/dsa.h>
16#include "dsa_priv.h"
17
18char dsa_driver_version[] = "0.1";
19
20
21/* switch driver registration ***********************************************/
22static DEFINE_MUTEX(dsa_switch_drivers_mutex);
23static LIST_HEAD(dsa_switch_drivers);
24
25void register_switch_driver(struct dsa_switch_driver *drv)
26{
27	mutex_lock(&dsa_switch_drivers_mutex);
28	list_add_tail(&drv->list, &dsa_switch_drivers);
29	mutex_unlock(&dsa_switch_drivers_mutex);
30}
31
32void unregister_switch_driver(struct dsa_switch_driver *drv)
33{
34	mutex_lock(&dsa_switch_drivers_mutex);
35	list_del_init(&drv->list);
36	mutex_unlock(&dsa_switch_drivers_mutex);
37}
38
39static struct dsa_switch_driver *
40dsa_switch_probe(struct mii_bus *bus, int sw_addr, char **_name)
41{
42	struct dsa_switch_driver *ret;
43	struct list_head *list;
44	char *name;
45
46	ret = NULL;
47	name = NULL;
48
49	mutex_lock(&dsa_switch_drivers_mutex);
50	list_for_each(list, &dsa_switch_drivers) {
51		struct dsa_switch_driver *drv;
52
53		drv = list_entry(list, struct dsa_switch_driver, list);
54
55		name = drv->probe(bus, sw_addr);
56		if (name != NULL) {
57			ret = drv;
58			break;
59		}
60	}
61	mutex_unlock(&dsa_switch_drivers_mutex);
62
63	*_name = name;
64
65	return ret;
66}
67
68
69/* basic switch operations **************************************************/
70static struct dsa_switch *
71dsa_switch_setup(struct dsa_switch_tree *dst, int index,
72		 struct device *parent, struct mii_bus *bus)
73{
74	struct dsa_chip_data *pd = dst->pd->chip + index;
75	struct dsa_switch_driver *drv;
76	struct dsa_switch *ds;
77	int ret;
78	char *name;
79	int i;
80
81	/*
82	 * Probe for switch model.
83	 */
84	drv = dsa_switch_probe(bus, pd->sw_addr, &name);
85	if (drv == NULL) {
86		printk(KERN_ERR "%s[%d]: could not detect attached switch\n",
87		       dst->master_netdev->name, index);
88		return ERR_PTR(-EINVAL);
89	}
90	printk(KERN_INFO "%s[%d]: detected a %s switch\n",
91		dst->master_netdev->name, index, name);
92
93
94	/*
95	 * Allocate and initialise switch state.
96	 */
97	ds = kzalloc(sizeof(*ds) + drv->priv_size, GFP_KERNEL);
98	if (ds == NULL)
99		return ERR_PTR(-ENOMEM);
100
101	ds->dst = dst;
102	ds->index = index;
103	ds->pd = dst->pd->chip + index;
104	ds->drv = drv;
105	ds->master_mii_bus = bus;
106
107
108	/*
109	 * Validate supplied switch configuration.
110	 */
111	for (i = 0; i < DSA_MAX_PORTS; i++) {
112		char *name;
113
114		name = pd->port_names[i];
115		if (name == NULL)
116			continue;
117
118		if (!strcmp(name, "cpu")) {
119			if (dst->cpu_switch != -1) {
120				printk(KERN_ERR "multiple cpu ports?!\n");
121				ret = -EINVAL;
122				goto out;
123			}
124			dst->cpu_switch = index;
125			dst->cpu_port = i;
126		} else if (!strcmp(name, "dsa")) {
127			ds->dsa_port_mask |= 1 << i;
128		} else {
129			ds->phys_port_mask |= 1 << i;
130		}
131	}
132
133
134	/*
135	 * If the CPU connects to this switch, set the switch tree
136	 * tagging protocol to the preferred tagging format of this
137	 * switch.
138	 */
139	if (ds->dst->cpu_switch == index)
140		ds->dst->tag_protocol = drv->tag_protocol;
141
142
143	/*
144	 * Do basic register setup.
145	 */
146	ret = drv->setup(ds);
147	if (ret < 0)
148		goto out;
149
150	ret = drv->set_addr(ds, dst->master_netdev->dev_addr);
151	if (ret < 0)
152		goto out;
153
154	ds->slave_mii_bus = mdiobus_alloc();
155	if (ds->slave_mii_bus == NULL) {
156		ret = -ENOMEM;
157		goto out;
158	}
159	dsa_slave_mii_bus_init(ds);
160
161	ret = mdiobus_register(ds->slave_mii_bus);
162	if (ret < 0)
163		goto out_free;
164
165
166	/*
167	 * Create network devices for physical switch ports.
168	 */
169	for (i = 0; i < DSA_MAX_PORTS; i++) {
170		struct net_device *slave_dev;
171
172		if (!(ds->phys_port_mask & (1 << i)))
173			continue;
174
175		slave_dev = dsa_slave_create(ds, parent, i, pd->port_names[i]);
176		if (slave_dev == NULL) {
177			printk(KERN_ERR "%s[%d]: can't create dsa "
178			       "slave device for port %d(%s)\n",
179			       dst->master_netdev->name,
180			       index, i, pd->port_names[i]);
181			continue;
182		}
183
184		ds->ports[i] = slave_dev;
185	}
186
187	return ds;
188
189out_free:
190	mdiobus_free(ds->slave_mii_bus);
191out:
192	kfree(ds);
193	return ERR_PTR(ret);
194}
195
196static void dsa_switch_destroy(struct dsa_switch *ds)
197{
198}
199
200
201/* hooks for ethertype-less tagging formats *********************************/
202/*
203 * The original DSA tag format and some other tag formats have no
204 * ethertype, which means that we need to add a little hack to the
205 * networking receive path to make sure that received frames get
206 * the right ->protocol assigned to them when one of those tag
207 * formats is in use.
208 */
209bool dsa_uses_dsa_tags(void *dsa_ptr)
210{
211	struct dsa_switch_tree *dst = dsa_ptr;
212
213	return !!(dst->tag_protocol == htons(ETH_P_DSA));
214}
215
216bool dsa_uses_trailer_tags(void *dsa_ptr)
217{
218	struct dsa_switch_tree *dst = dsa_ptr;
219
220	return !!(dst->tag_protocol == htons(ETH_P_TRAILER));
221}
222
223
224/* link polling *************************************************************/
225static void dsa_link_poll_work(struct work_struct *ugly)
226{
227	struct dsa_switch_tree *dst;
228	int i;
229
230	dst = container_of(ugly, struct dsa_switch_tree, link_poll_work);
231
232	for (i = 0; i < dst->pd->nr_chips; i++) {
233		struct dsa_switch *ds = dst->ds[i];
234
235		if (ds != NULL && ds->drv->poll_link != NULL)
236			ds->drv->poll_link(ds);
237	}
238
239	mod_timer(&dst->link_poll_timer, round_jiffies(jiffies + HZ));
240}
241
242static void dsa_link_poll_timer(unsigned long _dst)
243{
244	struct dsa_switch_tree *dst = (void *)_dst;
245
246	schedule_work(&dst->link_poll_work);
247}
248
249
250/* platform driver init and cleanup *****************************************/
251static int dev_is_class(struct device *dev, void *class)
252{
253	if (dev->class != NULL && !strcmp(dev->class->name, class))
254		return 1;
255
256	return 0;
257}
258
259static struct device *dev_find_class(struct device *parent, char *class)
260{
261	if (dev_is_class(parent, class)) {
262		get_device(parent);
263		return parent;
264	}
265
266	return device_find_child(parent, class, dev_is_class);
267}
268
269static struct mii_bus *dev_to_mii_bus(struct device *dev)
270{
271	struct device *d;
272
273	d = dev_find_class(dev, "mdio_bus");
274	if (d != NULL) {
275		struct mii_bus *bus;
276
277		bus = to_mii_bus(d);
278		put_device(d);
279
280		return bus;
281	}
282
283	return NULL;
284}
285
286static struct net_device *dev_to_net_device(struct device *dev)
287{
288	struct device *d;
289
290	d = dev_find_class(dev, "net");
291	if (d != NULL) {
292		struct net_device *nd;
293
294		nd = to_net_dev(d);
295		dev_hold(nd);
296		put_device(d);
297
298		return nd;
299	}
300
301	return NULL;
302}
303
304static int dsa_probe(struct platform_device *pdev)
305{
306	static int dsa_version_printed;
307	struct dsa_platform_data *pd = pdev->dev.platform_data;
308	struct net_device *dev;
309	struct dsa_switch_tree *dst;
310	int i;
311
312	if (!dsa_version_printed++)
313		printk(KERN_NOTICE "Distributed Switch Architecture "
314			"driver version %s\n", dsa_driver_version);
315
316	if (pd == NULL || pd->netdev == NULL)
317		return -EINVAL;
318
319	dev = dev_to_net_device(pd->netdev);
320	if (dev == NULL)
321		return -EINVAL;
322
323	if (dev->dsa_ptr != NULL) {
324		dev_put(dev);
325		return -EEXIST;
326	}
327
328	dst = kzalloc(sizeof(*dst), GFP_KERNEL);
329	if (dst == NULL) {
330		dev_put(dev);
331		return -ENOMEM;
332	}
333
334	platform_set_drvdata(pdev, dst);
335
336	dst->pd = pd;
337	dst->master_netdev = dev;
338	dst->cpu_switch = -1;
339	dst->cpu_port = -1;
340
341	for (i = 0; i < pd->nr_chips; i++) {
342		struct mii_bus *bus;
343		struct dsa_switch *ds;
344
345		bus = dev_to_mii_bus(pd->chip[i].mii_bus);
346		if (bus == NULL) {
347			printk(KERN_ERR "%s[%d]: no mii bus found for "
348				"dsa switch\n", dev->name, i);
349			continue;
350		}
351
352		ds = dsa_switch_setup(dst, i, &pdev->dev, bus);
353		if (IS_ERR(ds)) {
354			printk(KERN_ERR "%s[%d]: couldn't create dsa switch "
355				"instance (error %ld)\n", dev->name, i,
356				PTR_ERR(ds));
357			continue;
358		}
359
360		dst->ds[i] = ds;
361		if (ds->drv->poll_link != NULL)
362			dst->link_poll_needed = 1;
363	}
364
365	/*
366	 * If we use a tagging format that doesn't have an ethertype
367	 * field, make sure that all packets from this point on get
368	 * sent to the tag format's receive function.
369	 */
370	wmb();
371	dev->dsa_ptr = (void *)dst;
372
373	if (dst->link_poll_needed) {
374		INIT_WORK(&dst->link_poll_work, dsa_link_poll_work);
375		init_timer(&dst->link_poll_timer);
376		dst->link_poll_timer.data = (unsigned long)dst;
377		dst->link_poll_timer.function = dsa_link_poll_timer;
378		dst->link_poll_timer.expires = round_jiffies(jiffies + HZ);
379		add_timer(&dst->link_poll_timer);
380	}
381
382	return 0;
383}
384
385static int dsa_remove(struct platform_device *pdev)
386{
387	struct dsa_switch_tree *dst = platform_get_drvdata(pdev);
388	int i;
389
390	if (dst->link_poll_needed)
391		del_timer_sync(&dst->link_poll_timer);
392
393	flush_scheduled_work();
394
395	for (i = 0; i < dst->pd->nr_chips; i++) {
396		struct dsa_switch *ds = dst->ds[i];
397
398		if (ds != NULL)
399			dsa_switch_destroy(ds);
400	}
401
402	return 0;
403}
404
405static void dsa_shutdown(struct platform_device *pdev)
406{
407}
408
409static struct platform_driver dsa_driver = {
410	.probe		= dsa_probe,
411	.remove		= dsa_remove,
412	.shutdown	= dsa_shutdown,
413	.driver = {
414		.name	= "dsa",
415		.owner	= THIS_MODULE,
416	},
417};
418
419static int __init dsa_init_module(void)
420{
421	return platform_driver_register(&dsa_driver);
422}
423module_init(dsa_init_module);
424
425static void __exit dsa_cleanup_module(void)
426{
427	platform_driver_unregister(&dsa_driver);
428}
429module_exit(dsa_cleanup_module);
430
431MODULE_AUTHOR("Lennert Buytenhek <buytenh@wantstofly.org>")
432MODULE_DESCRIPTION("Driver for Distributed Switch Architecture switch chips");
433MODULE_LICENSE("GPL");
434MODULE_ALIAS("platform:dsa");
435