Version:  2.0.40 2.2.26 2.4.37 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8

Linux/net/dsa/dsa.c

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us