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