?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
of: MSI: Simplify irqdomain lookup
[linux/fpc-iii.git] / net / dsa / dsa.c
blob1eba07feb34adb451734e18e1c73031c9b7b2e35
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/ctype.h>
13 #include <linux/device.h>
14 #include <linux/hwmon.h>
15 #include <linux/list.h>
16 #include <linux/platform_device.h>
17 #include <linux/slab.h>
18 #include <linux/module.h>
19 #include <net/dsa.h>
20 #include <linux/of.h>
21 #include <linux/of_mdio.h>
22 #include <linux/of_platform.h>
23 #include <linux/of_net.h>
24 #include <linux/sysfs.h>
25 #include <linux/phy_fixed.h>
26 #include "dsa_priv.h"
27
28 char dsa_driver_version[] = "0.1";
29
30
31 /* switch driver registration ***********************************************/
32 static DEFINE_MUTEX(dsa_switch_drivers_mutex);
33 static LIST_HEAD(dsa_switch_drivers);
34
35 void register_switch_driver(struct dsa_switch_driver *drv)
36 {
37 mutex_lock(&dsa_switch_drivers_mutex);
38 list_add_tail(&drv->list, &dsa_switch_drivers);
39 mutex_unlock(&dsa_switch_drivers_mutex);
40 }
41 EXPORT_SYMBOL_GPL(register_switch_driver);
42
43 void unregister_switch_driver(struct dsa_switch_driver *drv)
44 {
45 mutex_lock(&dsa_switch_drivers_mutex);
46 list_del_init(&drv->list);
47 mutex_unlock(&dsa_switch_drivers_mutex);
48 }
49 EXPORT_SYMBOL_GPL(unregister_switch_driver);
50
51 static struct dsa_switch_driver *
52 dsa_switch_probe(struct device *host_dev, int sw_addr, char **_name)
53 {
54 struct dsa_switch_driver *ret;
55 struct list_head *list;
56 char *name;
57
58 ret = NULL;
59 name = NULL;
60
61 mutex_lock(&dsa_switch_drivers_mutex);
62 list_for_each(list, &dsa_switch_drivers) {
63 struct dsa_switch_driver *drv;
64
65 drv = list_entry(list, struct dsa_switch_driver, list);
66
67 name = drv->probe(host_dev, sw_addr);
68 if (name != NULL) {
69 ret = drv;
70 break;
71 }
72 }
73 mutex_unlock(&dsa_switch_drivers_mutex);
74
75 *_name = name;
76
77 return ret;
78 }
79
80 /* hwmon support ************************************************************/
81
82 #ifdef CONFIG_NET_DSA_HWMON
83
84 static ssize_t temp1_input_show(struct device *dev,
85 struct device_attribute *attr, char *buf)
86 {
87 struct dsa_switch *ds = dev_get_drvdata(dev);
88 int temp, ret;
89
90 ret = ds->drv->get_temp(ds, &temp);
91 if (ret < 0)
92 return ret;
93
94 return sprintf(buf, "%d\n", temp * 1000);
95 }
96 static DEVICE_ATTR_RO(temp1_input);
97
98 static ssize_t temp1_max_show(struct device *dev,
99 struct device_attribute *attr, char *buf)
100 {
101 struct dsa_switch *ds = dev_get_drvdata(dev);
102 int temp, ret;
103
104 ret = ds->drv->get_temp_limit(ds, &temp);
105 if (ret < 0)
106 return ret;
107
108 return sprintf(buf, "%d\n", temp * 1000);
109 }
110
111 static ssize_t temp1_max_store(struct device *dev,
112 struct device_attribute *attr, const char *buf,
113 size_t count)
114 {
115 struct dsa_switch *ds = dev_get_drvdata(dev);
116 int temp, ret;
117
118 ret = kstrtoint(buf, 0, &temp);
119 if (ret < 0)
120 return ret;
121
122 ret = ds->drv->set_temp_limit(ds, DIV_ROUND_CLOSEST(temp, 1000));
123 if (ret < 0)
124 return ret;
125
126 return count;
127 }
128 static DEVICE_ATTR_RW(temp1_max);
129
130 static ssize_t temp1_max_alarm_show(struct device *dev,
131 struct device_attribute *attr, char *buf)
132 {
133 struct dsa_switch *ds = dev_get_drvdata(dev);
134 bool alarm;
135 int ret;
136
137 ret = ds->drv->get_temp_alarm(ds, &alarm);
138 if (ret < 0)
139 return ret;
140
141 return sprintf(buf, "%d\n", alarm);
142 }
143 static DEVICE_ATTR_RO(temp1_max_alarm);
144
145 static struct attribute *dsa_hwmon_attrs[] = {
146 &dev_attr_temp1_input.attr, /* 0 */
147 &dev_attr_temp1_max.attr, /* 1 */
148 &dev_attr_temp1_max_alarm.attr, /* 2 */
149 NULL
150 };
151
152 static umode_t dsa_hwmon_attrs_visible(struct kobject *kobj,
153 struct attribute *attr, int index)
154 {
155 struct device *dev = container_of(kobj, struct device, kobj);
156 struct dsa_switch *ds = dev_get_drvdata(dev);
157 struct dsa_switch_driver *drv = ds->drv;
158 umode_t mode = attr->mode;
159
160 if (index == 1) {
161 if (!drv->get_temp_limit)
162 mode = 0;
163 else if (!drv->set_temp_limit)
164 mode &= ~S_IWUSR;
165 } else if (index == 2 && !drv->get_temp_alarm) {
166 mode = 0;
167 }
168 return mode;
169 }
170
171 static const struct attribute_group dsa_hwmon_group = {
172 .attrs = dsa_hwmon_attrs,
173 .is_visible = dsa_hwmon_attrs_visible,
174 };
175 __ATTRIBUTE_GROUPS(dsa_hwmon);
176
177 #endif /* CONFIG_NET_DSA_HWMON */
178
179 /* basic switch operations **************************************************/
180 static int dsa_cpu_dsa_setup(struct dsa_switch *ds, struct net_device *master)
181 {
182 struct dsa_chip_data *cd = ds->pd;
183 struct device_node *port_dn;
184 struct phy_device *phydev;
185 int ret, port, mode;
186
187 for (port = 0; port < DSA_MAX_PORTS; port++) {
188 if (!(dsa_is_cpu_port(ds, port) || dsa_is_dsa_port(ds, port)))
189 continue;
190
191 port_dn = cd->port_dn[port];
192 if (of_phy_is_fixed_link(port_dn)) {
193 ret = of_phy_register_fixed_link(port_dn);
194 if (ret) {
195 netdev_err(master,
196 "failed to register fixed PHY\n");
197 return ret;
198 }
199 phydev = of_phy_find_device(port_dn);
200
201 mode = of_get_phy_mode(port_dn);
202 if (mode < 0)
203 mode = PHY_INTERFACE_MODE_NA;
204 phydev->interface = mode;
205
206 genphy_config_init(phydev);
207 genphy_read_status(phydev);
208 if (ds->drv->adjust_link)
209 ds->drv->adjust_link(ds, port, phydev);
210 }
211 }
212 return 0;
213 }
214
215 static int dsa_switch_setup_one(struct dsa_switch *ds, struct device *parent)
216 {
217 struct dsa_switch_driver *drv = ds->drv;
218 struct dsa_switch_tree *dst = ds->dst;
219 struct dsa_chip_data *pd = ds->pd;
220 bool valid_name_found = false;
221 int index = ds->index;
222 int i, ret;
223
224 /*
225 * Validate supplied switch configuration.
226 */
227 for (i = 0; i < DSA_MAX_PORTS; i++) {
228 char *name;
229
230 name = pd->port_names[i];
231 if (name == NULL)
232 continue;
233
234 if (!strcmp(name, "cpu")) {
235 if (dst->cpu_switch != -1) {
236 netdev_err(dst->master_netdev,
237 "multiple cpu ports?!\n");
238 ret = -EINVAL;
239 goto out;
240 }
241 dst->cpu_switch = index;
242 dst->cpu_port = i;
243 } else if (!strcmp(name, "dsa")) {
244 ds->dsa_port_mask |= 1 << i;
245 } else {
246 ds->phys_port_mask |= 1 << i;
247 }
248 valid_name_found = true;
249 }
250
251 if (!valid_name_found && i == DSA_MAX_PORTS) {
252 ret = -EINVAL;
253 goto out;
254 }
255
256 /* Make the built-in MII bus mask match the number of ports,
257 * switch drivers can override this later
258 */
259 ds->phys_mii_mask = ds->phys_port_mask;
260
261 /*
262 * If the CPU connects to this switch, set the switch tree
263 * tagging protocol to the preferred tagging format of this
264 * switch.
265 */
266 if (dst->cpu_switch == index) {
267 switch (ds->tag_protocol) {
268 #ifdef CONFIG_NET_DSA_TAG_DSA
269 case DSA_TAG_PROTO_DSA:
270 dst->rcv = dsa_netdev_ops.rcv;
271 break;
272 #endif
273 #ifdef CONFIG_NET_DSA_TAG_EDSA
274 case DSA_TAG_PROTO_EDSA:
275 dst->rcv = edsa_netdev_ops.rcv;
276 break;
277 #endif
278 #ifdef CONFIG_NET_DSA_TAG_TRAILER
279 case DSA_TAG_PROTO_TRAILER:
280 dst->rcv = trailer_netdev_ops.rcv;
281 break;
282 #endif
283 #ifdef CONFIG_NET_DSA_TAG_BRCM
284 case DSA_TAG_PROTO_BRCM:
285 dst->rcv = brcm_netdev_ops.rcv;
286 break;
287 #endif
288 case DSA_TAG_PROTO_NONE:
289 break;
290 default:
291 ret = -ENOPROTOOPT;
292 goto out;
293 }
294
295 dst->tag_protocol = ds->tag_protocol;
296 }
297
298 /*
299 * Do basic register setup.
300 */
301 ret = drv->setup(ds);
302 if (ret < 0)
303 goto out;
304
305 ret = drv->set_addr(ds, dst->master_netdev->dev_addr);
306 if (ret < 0)
307 goto out;
308
309 ds->slave_mii_bus = devm_mdiobus_alloc(parent);
310 if (ds->slave_mii_bus == NULL) {
311 ret = -ENOMEM;
312 goto out;
313 }
314 dsa_slave_mii_bus_init(ds);
315
316 ret = mdiobus_register(ds->slave_mii_bus);
317 if (ret < 0)
318 goto out;
319
320
321 /*
322 * Create network devices for physical switch ports.
323 */
324 for (i = 0; i < DSA_MAX_PORTS; i++) {
325 if (!(ds->phys_port_mask & (1 << i)))
326 continue;
327
328 ret = dsa_slave_create(ds, parent, i, pd->port_names[i]);
329 if (ret < 0) {
330 netdev_err(dst->master_netdev, "[%d]: can't create dsa slave device for port %d(%s): %d\n",
331 index, i, pd->port_names[i], ret);
332 ret = 0;
333 }
334 }
335
336 /* Perform configuration of the CPU and DSA ports */
337 ret = dsa_cpu_dsa_setup(ds, dst->master_netdev);
338 if (ret < 0) {
339 netdev_err(dst->master_netdev, "[%d] : can't configure CPU and DSA ports\n",
340 index);
341 ret = 0;
342 }
343
344 #ifdef CONFIG_NET_DSA_HWMON
345 /* If the switch provides a temperature sensor,
346 * register with hardware monitoring subsystem.
347 * Treat registration error as non-fatal and ignore it.
348 */
349 if (drv->get_temp) {
350 const char *netname = netdev_name(dst->master_netdev);
351 char hname[IFNAMSIZ + 1];
352 int i, j;
353
354 /* Create valid hwmon 'name' attribute */
355 for (i = j = 0; i < IFNAMSIZ && netname[i]; i++) {
356 if (isalnum(netname[i]))
357 hname[j++] = netname[i];
358 }
359 hname[j] = '\0';
360 scnprintf(ds->hwmon_name, sizeof(ds->hwmon_name), "%s_dsa%d",
361 hname, index);
362 ds->hwmon_dev = hwmon_device_register_with_groups(NULL,
363 ds->hwmon_name, ds, dsa_hwmon_groups);
364 if (IS_ERR(ds->hwmon_dev))
365 ds->hwmon_dev = NULL;
366 }
367 #endif /* CONFIG_NET_DSA_HWMON */
368
369 return ret;
370
371 out:
372 return ret;
373 }
374
375 static struct dsa_switch *
376 dsa_switch_setup(struct dsa_switch_tree *dst, int index,
377 struct device *parent, struct device *host_dev)
378 {
379 struct dsa_chip_data *pd = dst->pd->chip + index;
380 struct dsa_switch_driver *drv;
381 struct dsa_switch *ds;
382 int ret;
383 char *name;
384
385 /*
386 * Probe for switch model.
387 */
388 drv = dsa_switch_probe(host_dev, pd->sw_addr, &name);
389 if (drv == NULL) {
390 netdev_err(dst->master_netdev, "[%d]: could not detect attached switch\n",
391 index);
392 return ERR_PTR(-EINVAL);
393 }
394 netdev_info(dst->master_netdev, "[%d]: detected a %s switch\n",
395 index, name);
396
397
398 /*
399 * Allocate and initialise switch state.
400 */
401 ds = devm_kzalloc(parent, sizeof(*ds) + drv->priv_size, GFP_KERNEL);
402 if (ds == NULL)
403 return ERR_PTR(-ENOMEM);
404
405 ds->dst = dst;
406 ds->index = index;
407 ds->pd = pd;
408 ds->drv = drv;
409 ds->tag_protocol = drv->tag_protocol;
410 ds->master_dev = host_dev;
411
412 ret = dsa_switch_setup_one(ds, parent);
413 if (ret)
414 return ERR_PTR(ret);
415
416 return ds;
417 }
418
419 static void dsa_switch_destroy(struct dsa_switch *ds)
420 {
421 struct device_node *port_dn;
422 struct phy_device *phydev;
423 struct dsa_chip_data *cd = ds->pd;
424 int port;
425
426 #ifdef CONFIG_NET_DSA_HWMON
427 if (ds->hwmon_dev)
428 hwmon_device_unregister(ds->hwmon_dev);
429 #endif
430
431 /* Disable configuration of the CPU and DSA ports */
432 for (port = 0; port < DSA_MAX_PORTS; port++) {
433 if (!(dsa_is_cpu_port(ds, port) || dsa_is_dsa_port(ds, port)))
434 continue;
435
436 port_dn = cd->port_dn[port];
437 if (of_phy_is_fixed_link(port_dn)) {
438 phydev = of_phy_find_device(port_dn);
439 if (phydev) {
440 int addr = phydev->addr;
441
442 phy_device_free(phydev);
443 of_node_put(port_dn);
444 fixed_phy_del(addr);
445 }
446 }
447 }
448
449 /* Destroy network devices for physical switch ports. */
450 for (port = 0; port < DSA_MAX_PORTS; port++) {
451 if (!(ds->phys_port_mask & (1 << port)))
452 continue;
453
454 if (!ds->ports[port])
455 continue;
456
457 unregister_netdev(ds->ports[port]);
458 free_netdev(ds->ports[port]);
459 }
460
461 mdiobus_unregister(ds->slave_mii_bus);
462 }
463
464 #ifdef CONFIG_PM_SLEEP
465 static int dsa_switch_suspend(struct dsa_switch *ds)
466 {
467 int i, ret = 0;
468
469 /* Suspend slave network devices */
470 for (i = 0; i < DSA_MAX_PORTS; i++) {
471 if (!dsa_is_port_initialized(ds, i))
472 continue;
473
474 ret = dsa_slave_suspend(ds->ports[i]);
475 if (ret)
476 return ret;
477 }
478
479 if (ds->drv->suspend)
480 ret = ds->drv->suspend(ds);
481
482 return ret;
483 }
484
485 static int dsa_switch_resume(struct dsa_switch *ds)
486 {
487 int i, ret = 0;
488
489 if (ds->drv->resume)
490 ret = ds->drv->resume(ds);
491
492 if (ret)
493 return ret;
494
495 /* Resume slave network devices */
496 for (i = 0; i < DSA_MAX_PORTS; i++) {
497 if (!dsa_is_port_initialized(ds, i))
498 continue;
499
500 ret = dsa_slave_resume(ds->ports[i]);
501 if (ret)
502 return ret;
503 }
504
505 return 0;
506 }
507 #endif
508
509
510 /* link polling *************************************************************/
511 static void dsa_link_poll_work(struct work_struct *ugly)
512 {
513 struct dsa_switch_tree *dst;
514 int i;
515
516 dst = container_of(ugly, struct dsa_switch_tree, link_poll_work);
517
518 for (i = 0; i < dst->pd->nr_chips; i++) {
519 struct dsa_switch *ds = dst->ds[i];
520
521 if (ds != NULL && ds->drv->poll_link != NULL)
522 ds->drv->poll_link(ds);
523 }
524
525 mod_timer(&dst->link_poll_timer, round_jiffies(jiffies + HZ));
526 }
527
528 static void dsa_link_poll_timer(unsigned long _dst)
529 {
530 struct dsa_switch_tree *dst = (void *)_dst;
531
532 schedule_work(&dst->link_poll_work);
533 }
534
535
536 /* platform driver init and cleanup *****************************************/
537 static int dev_is_class(struct device *dev, void *class)
538 {
539 if (dev->class != NULL && !strcmp(dev->class->name, class))
540 return 1;
541
542 return 0;
543 }
544
545 static struct device *dev_find_class(struct device *parent, char *class)
546 {
547 if (dev_is_class(parent, class)) {
548 get_device(parent);
549 return parent;
550 }
551
552 return device_find_child(parent, class, dev_is_class);
553 }
554
555 struct mii_bus *dsa_host_dev_to_mii_bus(struct device *dev)
556 {
557 struct device *d;
558
559 d = dev_find_class(dev, "mdio_bus");
560 if (d != NULL) {
561 struct mii_bus *bus;
562
563 bus = to_mii_bus(d);
564 put_device(d);
565
566 return bus;
567 }
568
569 return NULL;
570 }
571 EXPORT_SYMBOL_GPL(dsa_host_dev_to_mii_bus);
572
573 static struct net_device *dev_to_net_device(struct device *dev)
574 {
575 struct device *d;
576
577 d = dev_find_class(dev, "net");
578 if (d != NULL) {
579 struct net_device *nd;
580
581 nd = to_net_dev(d);
582 dev_hold(nd);
583 put_device(d);
584
585 return nd;
586 }
587
588 return NULL;
589 }
590
591 #ifdef CONFIG_OF
592 static int dsa_of_setup_routing_table(struct dsa_platform_data *pd,
593 struct dsa_chip_data *cd,
594 int chip_index, int port_index,
595 struct device_node *link)
596 {
597 const __be32 *reg;
598 int link_sw_addr;
599 struct device_node *parent_sw;
600 int len;
601
602 parent_sw = of_get_parent(link);
603 if (!parent_sw)
604 return -EINVAL;
605
606 reg = of_get_property(parent_sw, "reg", &len);
607 if (!reg || (len != sizeof(*reg) * 2))
608 return -EINVAL;
609
610 /*
611 * Get the destination switch number from the second field of its 'reg'
612 * property, i.e. for "reg = <0x19 1>" sw_addr is '1'.
613 */
614 link_sw_addr = be32_to_cpup(reg + 1);
615
616 if (link_sw_addr >= pd->nr_chips)
617 return -EINVAL;
618
619 /* First time routing table allocation */
620 if (!cd->rtable) {
621 cd->rtable = kmalloc_array(pd->nr_chips, sizeof(s8),
622 GFP_KERNEL);
623 if (!cd->rtable)
624 return -ENOMEM;
625
626 /* default to no valid uplink/downlink */
627 memset(cd->rtable, -1, pd->nr_chips * sizeof(s8));
628 }
629
630 cd->rtable[link_sw_addr] = port_index;
631
632 return 0;
633 }
634
635 static int dsa_of_probe_links(struct dsa_platform_data *pd,
636 struct dsa_chip_data *cd,
637 int chip_index, int port_index,
638 struct device_node *port,
639 const char *port_name)
640 {
641 struct device_node *link;
642 int link_index;
643 int ret;
644
645 for (link_index = 0;; link_index++) {
646 link = of_parse_phandle(port, "link", link_index);
647 if (!link)
648 break;
649
650 if (!strcmp(port_name, "dsa") && pd->nr_chips > 1) {
651 ret = dsa_of_setup_routing_table(pd, cd, chip_index,
652 port_index, link);
653 if (ret)
654 return ret;
655 }
656 }
657 return 0;
658 }
659
660 static void dsa_of_free_platform_data(struct dsa_platform_data *pd)
661 {
662 int i;
663 int port_index;
664
665 for (i = 0; i < pd->nr_chips; i++) {
666 port_index = 0;
667 while (port_index < DSA_MAX_PORTS) {
668 kfree(pd->chip[i].port_names[port_index]);
669 port_index++;
670 }
671 kfree(pd->chip[i].rtable);
672
673 /* Drop our reference to the MDIO bus device */
674 if (pd->chip[i].host_dev)
675 put_device(pd->chip[i].host_dev);
676 }
677 kfree(pd->chip);
678 }
679
680 static int dsa_of_probe(struct device *dev)
681 {
682 struct device_node *np = dev->of_node;
683 struct device_node *child, *mdio, *ethernet, *port;
684 struct mii_bus *mdio_bus, *mdio_bus_switch;
685 struct net_device *ethernet_dev;
686 struct dsa_platform_data *pd;
687 struct dsa_chip_data *cd;
688 const char *port_name;
689 int chip_index, port_index;
690 const unsigned int *sw_addr, *port_reg;
691 u32 eeprom_len;
692 int ret;
693
694 mdio = of_parse_phandle(np, "dsa,mii-bus", 0);
695 if (!mdio)
696 return -EINVAL;
697
698 mdio_bus = of_mdio_find_bus(mdio);
699 if (!mdio_bus)
700 return -EPROBE_DEFER;
701
702 ethernet = of_parse_phandle(np, "dsa,ethernet", 0);
703 if (!ethernet) {
704 ret = -EINVAL;
705 goto out_put_mdio;
706 }
707
708 ethernet_dev = of_find_net_device_by_node(ethernet);
709 if (!ethernet_dev) {
710 ret = -EPROBE_DEFER;
711 goto out_put_mdio;
712 }
713
714 pd = kzalloc(sizeof(*pd), GFP_KERNEL);
715 if (!pd) {
716 ret = -ENOMEM;
717 goto out_put_ethernet;
718 }
719
720 dev->platform_data = pd;
721 pd->of_netdev = ethernet_dev;
722 pd->nr_chips = of_get_available_child_count(np);
723 if (pd->nr_chips > DSA_MAX_SWITCHES)
724 pd->nr_chips = DSA_MAX_SWITCHES;
725
726 pd->chip = kcalloc(pd->nr_chips, sizeof(struct dsa_chip_data),
727 GFP_KERNEL);
728 if (!pd->chip) {
729 ret = -ENOMEM;
730 goto out_free;
731 }
732
733 chip_index = -1;
734 for_each_available_child_of_node(np, child) {
735 chip_index++;
736 cd = &pd->chip[chip_index];
737
738 cd->of_node = child;
739
740 /* When assigning the host device, increment its refcount */
741 cd->host_dev = get_device(&mdio_bus->dev);
742
743 sw_addr = of_get_property(child, "reg", NULL);
744 if (!sw_addr)
745 continue;
746
747 cd->sw_addr = be32_to_cpup(sw_addr);
748 if (cd->sw_addr >= PHY_MAX_ADDR)
749 continue;
750
751 if (!of_property_read_u32(child, "eeprom-length", &eeprom_len))
752 cd->eeprom_len = eeprom_len;
753
754 mdio = of_parse_phandle(child, "mii-bus", 0);
755 if (mdio) {
756 mdio_bus_switch = of_mdio_find_bus(mdio);
757 if (!mdio_bus_switch) {
758 ret = -EPROBE_DEFER;
759 goto out_free_chip;
760 }
761
762 /* Drop the mdio_bus device ref, replacing the host
763 * device with the mdio_bus_switch device, keeping
764 * the refcount from of_mdio_find_bus() above.
765 */
766 put_device(cd->host_dev);
767 cd->host_dev = &mdio_bus_switch->dev;
768 }
769
770 for_each_available_child_of_node(child, port) {
771 port_reg = of_get_property(port, "reg", NULL);
772 if (!port_reg)
773 continue;
774
775 port_index = be32_to_cpup(port_reg);
776 if (port_index >= DSA_MAX_PORTS)
777 break;
778
779 port_name = of_get_property(port, "label", NULL);
780 if (!port_name)
781 continue;
782
783 cd->port_dn[port_index] = port;
784
785 cd->port_names[port_index] = kstrdup(port_name,
786 GFP_KERNEL);
787 if (!cd->port_names[port_index]) {
788 ret = -ENOMEM;
789 goto out_free_chip;
790 }
791
792 ret = dsa_of_probe_links(pd, cd, chip_index,
793 port_index, port, port_name);
794 if (ret)
795 goto out_free_chip;
796
797 }
798 }
799
800 /* The individual chips hold their own refcount on the mdio bus,
801 * so drop ours */
802 put_device(&mdio_bus->dev);
803
804 return 0;
805
806 out_free_chip:
807 dsa_of_free_platform_data(pd);
808 out_free:
809 kfree(pd);
810 dev->platform_data = NULL;
811 out_put_ethernet:
812 put_device(&ethernet_dev->dev);
813 out_put_mdio:
814 put_device(&mdio_bus->dev);
815 return ret;
816 }
817
818 static void dsa_of_remove(struct device *dev)
819 {
820 struct dsa_platform_data *pd = dev->platform_data;
821
822 if (!dev->of_node)
823 return;
824
825 dsa_of_free_platform_data(pd);
826 put_device(&pd->of_netdev->dev);
827 kfree(pd);
828 }
829 #else
830 static inline int dsa_of_probe(struct device *dev)
831 {
832 return 0;
833 }
834
835 static inline void dsa_of_remove(struct device *dev)
836 {
837 }
838 #endif
839
840 static int dsa_setup_dst(struct dsa_switch_tree *dst, struct net_device *dev,
841 struct device *parent, struct dsa_platform_data *pd)
842 {
843 int i;
844 unsigned configured = 0;
845
846 dst->pd = pd;
847 dst->master_netdev = dev;
848 dst->cpu_switch = -1;
849 dst->cpu_port = -1;
850
851 for (i = 0; i < pd->nr_chips; i++) {
852 struct dsa_switch *ds;
853
854 ds = dsa_switch_setup(dst, i, parent, pd->chip[i].host_dev);
855 if (IS_ERR(ds)) {
856 netdev_err(dev, "[%d]: couldn't create dsa switch instance (error %ld)\n",
857 i, PTR_ERR(ds));
858 continue;
859 }
860
861 dst->ds[i] = ds;
862 if (ds->drv->poll_link != NULL)
863 dst->link_poll_needed = 1;
864
865 ++configured;
866 }
867
868 /*
869 * If no switch was found, exit cleanly
870 */
871 if (!configured)
872 return -EPROBE_DEFER;
873
874 /*
875 * If we use a tagging format that doesn't have an ethertype
876 * field, make sure that all packets from this point on get
877 * sent to the tag format's receive function.
878 */
879 wmb();
880 dev->dsa_ptr = (void *)dst;
881
882 if (dst->link_poll_needed) {
883 INIT_WORK(&dst->link_poll_work, dsa_link_poll_work);
884 init_timer(&dst->link_poll_timer);
885 dst->link_poll_timer.data = (unsigned long)dst;
886 dst->link_poll_timer.function = dsa_link_poll_timer;
887 dst->link_poll_timer.expires = round_jiffies(jiffies + HZ);
888 add_timer(&dst->link_poll_timer);
889 }
890
891 return 0;
892 }
893
894 static int dsa_probe(struct platform_device *pdev)
895 {
896 struct dsa_platform_data *pd = pdev->dev.platform_data;
897 struct net_device *dev;
898 struct dsa_switch_tree *dst;
899 int ret;
900
901 pr_notice_once("Distributed Switch Architecture driver version %s\n",
902 dsa_driver_version);
903
904 if (pdev->dev.of_node) {
905 ret = dsa_of_probe(&pdev->dev);
906 if (ret)
907 return ret;
908
909 pd = pdev->dev.platform_data;
910 }
911
912 if (pd == NULL || (pd->netdev == NULL && pd->of_netdev == NULL))
913 return -EINVAL;
914
915 if (pd->of_netdev) {
916 dev = pd->of_netdev;
917 dev_hold(dev);
918 } else {
919 dev = dev_to_net_device(pd->netdev);
920 }
921 if (dev == NULL) {
922 ret = -EPROBE_DEFER;
923 goto out;
924 }
925
926 if (dev->dsa_ptr != NULL) {
927 dev_put(dev);
928 ret = -EEXIST;
929 goto out;
930 }
931
932 dst = devm_kzalloc(&pdev->dev, sizeof(*dst), GFP_KERNEL);
933 if (dst == NULL) {
934 dev_put(dev);
935 ret = -ENOMEM;
936 goto out;
937 }
938
939 platform_set_drvdata(pdev, dst);
940
941 ret = dsa_setup_dst(dst, dev, &pdev->dev, pd);
942 if (ret)
943 goto out;
944
945 return 0;
946
947 out:
948 dsa_of_remove(&pdev->dev);
949
950 return ret;
951 }
952
953 static void dsa_remove_dst(struct dsa_switch_tree *dst)
954 {
955 int i;
956
957 if (dst->link_poll_needed)
958 del_timer_sync(&dst->link_poll_timer);
959
960 flush_work(&dst->link_poll_work);
961
962 for (i = 0; i < dst->pd->nr_chips; i++) {
963 struct dsa_switch *ds = dst->ds[i];
964
965 if (ds)
966 dsa_switch_destroy(ds);
967 }
968 }
969
970 static int dsa_remove(struct platform_device *pdev)
971 {
972 struct dsa_switch_tree *dst = platform_get_drvdata(pdev);
973
974 dsa_remove_dst(dst);
975 dsa_of_remove(&pdev->dev);
976
977 return 0;
978 }
979
980 static void dsa_shutdown(struct platform_device *pdev)
981 {
982 }
983
984 static int dsa_switch_rcv(struct sk_buff *skb, struct net_device *dev,
985 struct packet_type *pt, struct net_device *orig_dev)
986 {
987 struct dsa_switch_tree *dst = dev->dsa_ptr;
988
989 if (unlikely(dst == NULL)) {
990 kfree_skb(skb);
991 return 0;
992 }
993
994 return dst->rcv(skb, dev, pt, orig_dev);
995 }
996
997 static struct packet_type dsa_pack_type __read_mostly = {
998 .type = cpu_to_be16(ETH_P_XDSA),
999 .func = dsa_switch_rcv,
1000 };
1001
1002 static struct notifier_block dsa_netdevice_nb __read_mostly = {
1003 .notifier_call = dsa_slave_netdevice_event,
1004 };
1005
1006 #ifdef CONFIG_PM_SLEEP
1007 static int dsa_suspend(struct device *d)
1008 {
1009 struct platform_device *pdev = to_platform_device(d);
1010 struct dsa_switch_tree *dst = platform_get_drvdata(pdev);
1011 int i, ret = 0;
1012
1013 for (i = 0; i < dst->pd->nr_chips; i++) {
1014 struct dsa_switch *ds = dst->ds[i];
1015
1016 if (ds != NULL)
1017 ret = dsa_switch_suspend(ds);
1018 }
1019
1020 return ret;
1021 }
1022
1023 static int dsa_resume(struct device *d)
1024 {
1025 struct platform_device *pdev = to_platform_device(d);
1026 struct dsa_switch_tree *dst = platform_get_drvdata(pdev);
1027 int i, ret = 0;
1028
1029 for (i = 0; i < dst->pd->nr_chips; i++) {
1030 struct dsa_switch *ds = dst->ds[i];
1031
1032 if (ds != NULL)
1033 ret = dsa_switch_resume(ds);
1034 }
1035
1036 return ret;
1037 }
1038 #endif
1039
1040 static SIMPLE_DEV_PM_OPS(dsa_pm_ops, dsa_suspend, dsa_resume);
1041
1042 static const struct of_device_id dsa_of_match_table[] = {
1043 { .compatible = "brcm,bcm7445-switch-v4.0" },
1044 { .compatible = "marvell,dsa", },
1045 {}
1046 };
1047 MODULE_DEVICE_TABLE(of, dsa_of_match_table);
1048
1049 static struct platform_driver dsa_driver = {
1050 .probe = dsa_probe,
1051 .remove = dsa_remove,
1052 .shutdown = dsa_shutdown,
1053 .driver = {
1054 .name = "dsa",
1055 .of_match_table = dsa_of_match_table,
1056 .pm = &dsa_pm_ops,
1057 },
1058 };
1059
1060 static int __init dsa_init_module(void)
1061 {
1062 int rc;
1063
1064 register_netdevice_notifier(&dsa_netdevice_nb);
1065
1066 rc = platform_driver_register(&dsa_driver);
1067 if (rc)
1068 return rc;
1069
1070 dev_add_pack(&dsa_pack_type);
1071
1072 return 0;
1073 }
1074 module_init(dsa_init_module);
1075
1076 static void __exit dsa_cleanup_module(void)
1077 {
1078 unregister_netdevice_notifier(&dsa_netdevice_nb);
1079 dev_remove_pack(&dsa_pack_type);
1080 platform_driver_unregister(&dsa_driver);
1081 }
1082 module_exit(dsa_cleanup_module);
1083
1084 MODULE_AUTHOR("Lennert Buytenhek <buytenh@wantstofly.org>");
1085 MODULE_DESCRIPTION("Driver for Distributed Switch Architecture switch chips");
1086 MODULE_LICENSE("GPL");
1087 MODULE_ALIAS("platform:dsa");
Linux with added FPC-III support