Merge remote-tracking branches 'asoc/fix/compress', 'asoc/fix/core', 'asoc/fix/dapm...
[linux-2.6-microblaze.git] / net / dsa / dsa2.c
1 /*
2  * net/dsa/dsa2.c - Hardware switch handling, binding version 2
3  * Copyright (c) 2008-2009 Marvell Semiconductor
4  * Copyright (c) 2013 Florian Fainelli <florian@openwrt.org>
5  * Copyright (c) 2016 Andrew Lunn <andrew@lunn.ch>
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2 of the License, or
10  * (at your option) any later version.
11  */
12
13 #include <linux/device.h>
14 #include <linux/err.h>
15 #include <linux/list.h>
16 #include <linux/netdevice.h>
17 #include <linux/slab.h>
18 #include <linux/rtnetlink.h>
19 #include <linux/of.h>
20 #include <linux/of_net.h>
21
22 #include "dsa_priv.h"
23
24 static LIST_HEAD(dsa_tree_list);
25 static DEFINE_MUTEX(dsa2_mutex);
26
27 static const struct devlink_ops dsa_devlink_ops = {
28 };
29
30 static struct dsa_switch_tree *dsa_tree_find(int index)
31 {
32         struct dsa_switch_tree *dst;
33
34         list_for_each_entry(dst, &dsa_tree_list, list)
35                 if (dst->index == index)
36                         return dst;
37
38         return NULL;
39 }
40
41 static struct dsa_switch_tree *dsa_tree_alloc(int index)
42 {
43         struct dsa_switch_tree *dst;
44
45         dst = kzalloc(sizeof(*dst), GFP_KERNEL);
46         if (!dst)
47                 return NULL;
48
49         dst->index = index;
50
51         INIT_LIST_HEAD(&dst->list);
52         list_add_tail(&dsa_tree_list, &dst->list);
53
54         kref_init(&dst->refcount);
55
56         return dst;
57 }
58
59 static void dsa_tree_free(struct dsa_switch_tree *dst)
60 {
61         list_del(&dst->list);
62         kfree(dst);
63 }
64
65 static struct dsa_switch_tree *dsa_tree_get(struct dsa_switch_tree *dst)
66 {
67         if (dst)
68                 kref_get(&dst->refcount);
69
70         return dst;
71 }
72
73 static struct dsa_switch_tree *dsa_tree_touch(int index)
74 {
75         struct dsa_switch_tree *dst;
76
77         dst = dsa_tree_find(index);
78         if (dst)
79                 return dsa_tree_get(dst);
80         else
81                 return dsa_tree_alloc(index);
82 }
83
84 static void dsa_tree_release(struct kref *ref)
85 {
86         struct dsa_switch_tree *dst;
87
88         dst = container_of(ref, struct dsa_switch_tree, refcount);
89
90         dsa_tree_free(dst);
91 }
92
93 static void dsa_tree_put(struct dsa_switch_tree *dst)
94 {
95         if (dst)
96                 kref_put(&dst->refcount, dsa_tree_release);
97 }
98
99 static bool dsa_port_is_dsa(struct dsa_port *port)
100 {
101         return port->type == DSA_PORT_TYPE_DSA;
102 }
103
104 static bool dsa_port_is_cpu(struct dsa_port *port)
105 {
106         return port->type == DSA_PORT_TYPE_CPU;
107 }
108
109 static bool dsa_port_is_user(struct dsa_port *dp)
110 {
111         return dp->type == DSA_PORT_TYPE_USER;
112 }
113
114 static struct dsa_port *dsa_tree_find_port_by_node(struct dsa_switch_tree *dst,
115                                                    struct device_node *dn)
116 {
117         struct dsa_switch *ds;
118         struct dsa_port *dp;
119         int device, port;
120
121         for (device = 0; device < DSA_MAX_SWITCHES; device++) {
122                 ds = dst->ds[device];
123                 if (!ds)
124                         continue;
125
126                 for (port = 0; port < ds->num_ports; port++) {
127                         dp = &ds->ports[port];
128
129                         if (dp->dn == dn)
130                                 return dp;
131                 }
132         }
133
134         return NULL;
135 }
136
137 static bool dsa_port_setup_routing_table(struct dsa_port *dp)
138 {
139         struct dsa_switch *ds = dp->ds;
140         struct dsa_switch_tree *dst = ds->dst;
141         struct device_node *dn = dp->dn;
142         struct of_phandle_iterator it;
143         struct dsa_port *link_dp;
144         int err;
145
146         of_for_each_phandle(&it, err, dn, "link", NULL, 0) {
147                 link_dp = dsa_tree_find_port_by_node(dst, it.node);
148                 if (!link_dp) {
149                         of_node_put(it.node);
150                         return false;
151                 }
152
153                 ds->rtable[link_dp->ds->index] = dp->index;
154         }
155
156         return true;
157 }
158
159 static bool dsa_switch_setup_routing_table(struct dsa_switch *ds)
160 {
161         bool complete = true;
162         struct dsa_port *dp;
163         int i;
164
165         for (i = 0; i < DSA_MAX_SWITCHES; i++)
166                 ds->rtable[i] = DSA_RTABLE_NONE;
167
168         for (i = 0; i < ds->num_ports; i++) {
169                 dp = &ds->ports[i];
170
171                 if (dsa_port_is_dsa(dp)) {
172                         complete = dsa_port_setup_routing_table(dp);
173                         if (!complete)
174                                 break;
175                 }
176         }
177
178         return complete;
179 }
180
181 static bool dsa_tree_setup_routing_table(struct dsa_switch_tree *dst)
182 {
183         struct dsa_switch *ds;
184         bool complete = true;
185         int device;
186
187         for (device = 0; device < DSA_MAX_SWITCHES; device++) {
188                 ds = dst->ds[device];
189                 if (!ds)
190                         continue;
191
192                 complete = dsa_switch_setup_routing_table(ds);
193                 if (!complete)
194                         break;
195         }
196
197         return complete;
198 }
199
200 static struct dsa_port *dsa_tree_find_first_cpu(struct dsa_switch_tree *dst)
201 {
202         struct dsa_switch *ds;
203         struct dsa_port *dp;
204         int device, port;
205
206         for (device = 0; device < DSA_MAX_SWITCHES; device++) {
207                 ds = dst->ds[device];
208                 if (!ds)
209                         continue;
210
211                 for (port = 0; port < ds->num_ports; port++) {
212                         dp = &ds->ports[port];
213
214                         if (dsa_port_is_cpu(dp))
215                                 return dp;
216                 }
217         }
218
219         return NULL;
220 }
221
222 static int dsa_tree_setup_default_cpu(struct dsa_switch_tree *dst)
223 {
224         struct dsa_switch *ds;
225         struct dsa_port *dp;
226         int device, port;
227
228         /* DSA currently only supports a single CPU port */
229         dst->cpu_dp = dsa_tree_find_first_cpu(dst);
230         if (!dst->cpu_dp) {
231                 pr_warn("Tree has no master device\n");
232                 return -EINVAL;
233         }
234
235         /* Assign the default CPU port to all ports of the fabric */
236         for (device = 0; device < DSA_MAX_SWITCHES; device++) {
237                 ds = dst->ds[device];
238                 if (!ds)
239                         continue;
240
241                 for (port = 0; port < ds->num_ports; port++) {
242                         dp = &ds->ports[port];
243
244                         if (dsa_port_is_user(dp))
245                                 dp->cpu_dp = dst->cpu_dp;
246                 }
247         }
248
249         return 0;
250 }
251
252 static void dsa_tree_teardown_default_cpu(struct dsa_switch_tree *dst)
253 {
254         /* DSA currently only supports a single CPU port */
255         dst->cpu_dp = NULL;
256 }
257
258 static int dsa_port_setup(struct dsa_port *dp)
259 {
260         struct dsa_switch *ds = dp->ds;
261         int err;
262
263         memset(&dp->devlink_port, 0, sizeof(dp->devlink_port));
264
265         err = devlink_port_register(ds->devlink, &dp->devlink_port, dp->index);
266         if (err)
267                 return err;
268
269         switch (dp->type) {
270         case DSA_PORT_TYPE_UNUSED:
271                 break;
272         case DSA_PORT_TYPE_CPU:
273         case DSA_PORT_TYPE_DSA:
274                 err = dsa_port_fixed_link_register_of(dp);
275                 if (err) {
276                         dev_err(ds->dev, "failed to register fixed link for port %d.%d\n",
277                                 ds->index, dp->index);
278                         return err;
279                 }
280
281                 break;
282         case DSA_PORT_TYPE_USER:
283                 err = dsa_slave_create(dp);
284                 if (err)
285                         dev_err(ds->dev, "failed to create slave for port %d.%d\n",
286                                 ds->index, dp->index);
287                 else
288                         devlink_port_type_eth_set(&dp->devlink_port, dp->slave);
289                 break;
290         }
291
292         return 0;
293 }
294
295 static void dsa_port_teardown(struct dsa_port *dp)
296 {
297         devlink_port_unregister(&dp->devlink_port);
298
299         switch (dp->type) {
300         case DSA_PORT_TYPE_UNUSED:
301                 break;
302         case DSA_PORT_TYPE_CPU:
303         case DSA_PORT_TYPE_DSA:
304                 dsa_port_fixed_link_unregister_of(dp);
305                 break;
306         case DSA_PORT_TYPE_USER:
307                 if (dp->slave) {
308                         dsa_slave_destroy(dp->slave);
309                         dp->slave = NULL;
310                 }
311                 break;
312         }
313 }
314
315 static int dsa_switch_setup(struct dsa_switch *ds)
316 {
317         int err;
318
319         /* Initialize ds->phys_mii_mask before registering the slave MDIO bus
320          * driver and before ops->setup() has run, since the switch drivers and
321          * the slave MDIO bus driver rely on these values for probing PHY
322          * devices or not
323          */
324         ds->phys_mii_mask |= dsa_user_ports(ds);
325
326         /* Add the switch to devlink before calling setup, so that setup can
327          * add dpipe tables
328          */
329         ds->devlink = devlink_alloc(&dsa_devlink_ops, 0);
330         if (!ds->devlink)
331                 return -ENOMEM;
332
333         err = devlink_register(ds->devlink, ds->dev);
334         if (err)
335                 return err;
336
337         err = ds->ops->setup(ds);
338         if (err < 0)
339                 return err;
340
341         err = dsa_switch_register_notifier(ds);
342         if (err)
343                 return err;
344
345         if (!ds->slave_mii_bus && ds->ops->phy_read) {
346                 ds->slave_mii_bus = devm_mdiobus_alloc(ds->dev);
347                 if (!ds->slave_mii_bus)
348                         return -ENOMEM;
349
350                 dsa_slave_mii_bus_init(ds);
351
352                 err = mdiobus_register(ds->slave_mii_bus);
353                 if (err < 0)
354                         return err;
355         }
356
357         return 0;
358 }
359
360 static void dsa_switch_teardown(struct dsa_switch *ds)
361 {
362         if (ds->slave_mii_bus && ds->ops->phy_read)
363                 mdiobus_unregister(ds->slave_mii_bus);
364
365         dsa_switch_unregister_notifier(ds);
366
367         if (ds->devlink) {
368                 devlink_unregister(ds->devlink);
369                 devlink_free(ds->devlink);
370                 ds->devlink = NULL;
371         }
372
373 }
374
375 static int dsa_tree_setup_switches(struct dsa_switch_tree *dst)
376 {
377         struct dsa_switch *ds;
378         struct dsa_port *dp;
379         int device, port;
380         int err;
381
382         for (device = 0; device < DSA_MAX_SWITCHES; device++) {
383                 ds = dst->ds[device];
384                 if (!ds)
385                         continue;
386
387                 err = dsa_switch_setup(ds);
388                 if (err)
389                         return err;
390
391                 for (port = 0; port < ds->num_ports; port++) {
392                         dp = &ds->ports[port];
393
394                         err = dsa_port_setup(dp);
395                         if (err)
396                                 return err;
397                 }
398         }
399
400         return 0;
401 }
402
403 static void dsa_tree_teardown_switches(struct dsa_switch_tree *dst)
404 {
405         struct dsa_switch *ds;
406         struct dsa_port *dp;
407         int device, port;
408
409         for (device = 0; device < DSA_MAX_SWITCHES; device++) {
410                 ds = dst->ds[device];
411                 if (!ds)
412                         continue;
413
414                 for (port = 0; port < ds->num_ports; port++) {
415                         dp = &ds->ports[port];
416
417                         dsa_port_teardown(dp);
418                 }
419
420                 dsa_switch_teardown(ds);
421         }
422 }
423
424 static int dsa_tree_setup_master(struct dsa_switch_tree *dst)
425 {
426         struct dsa_port *cpu_dp = dst->cpu_dp;
427         struct net_device *master = cpu_dp->master;
428
429         /* DSA currently supports a single pair of CPU port and master device */
430         return dsa_master_setup(master, cpu_dp);
431 }
432
433 static void dsa_tree_teardown_master(struct dsa_switch_tree *dst)
434 {
435         struct dsa_port *cpu_dp = dst->cpu_dp;
436         struct net_device *master = cpu_dp->master;
437
438         return dsa_master_teardown(master);
439 }
440
441 static int dsa_tree_setup(struct dsa_switch_tree *dst)
442 {
443         bool complete;
444         int err;
445
446         if (dst->setup) {
447                 pr_err("DSA: tree %d already setup! Disjoint trees?\n",
448                        dst->index);
449                 return -EEXIST;
450         }
451
452         complete = dsa_tree_setup_routing_table(dst);
453         if (!complete)
454                 return 0;
455
456         err = dsa_tree_setup_default_cpu(dst);
457         if (err)
458                 return err;
459
460         err = dsa_tree_setup_switches(dst);
461         if (err)
462                 return err;
463
464         err = dsa_tree_setup_master(dst);
465         if (err)
466                 return err;
467
468         dst->setup = true;
469
470         pr_info("DSA: tree %d setup\n", dst->index);
471
472         return 0;
473 }
474
475 static void dsa_tree_teardown(struct dsa_switch_tree *dst)
476 {
477         if (!dst->setup)
478                 return;
479
480         dsa_tree_teardown_master(dst);
481
482         dsa_tree_teardown_switches(dst);
483
484         dsa_tree_teardown_default_cpu(dst);
485
486         pr_info("DSA: tree %d torn down\n", dst->index);
487
488         dst->setup = false;
489 }
490
491 static void dsa_tree_remove_switch(struct dsa_switch_tree *dst,
492                                    unsigned int index)
493 {
494         dsa_tree_teardown(dst);
495
496         dst->ds[index] = NULL;
497         dsa_tree_put(dst);
498 }
499
500 static int dsa_tree_add_switch(struct dsa_switch_tree *dst,
501                                struct dsa_switch *ds)
502 {
503         unsigned int index = ds->index;
504         int err;
505
506         if (dst->ds[index])
507                 return -EBUSY;
508
509         dsa_tree_get(dst);
510         dst->ds[index] = ds;
511
512         err = dsa_tree_setup(dst);
513         if (err)
514                 dsa_tree_remove_switch(dst, index);
515
516         return err;
517 }
518
519 static int dsa_port_parse_user(struct dsa_port *dp, const char *name)
520 {
521         if (!name)
522                 name = "eth%d";
523
524         dp->type = DSA_PORT_TYPE_USER;
525         dp->name = name;
526
527         return 0;
528 }
529
530 static int dsa_port_parse_dsa(struct dsa_port *dp)
531 {
532         dp->type = DSA_PORT_TYPE_DSA;
533
534         return 0;
535 }
536
537 static int dsa_port_parse_cpu(struct dsa_port *dp, struct net_device *master)
538 {
539         struct dsa_switch *ds = dp->ds;
540         struct dsa_switch_tree *dst = ds->dst;
541         const struct dsa_device_ops *tag_ops;
542         enum dsa_tag_protocol tag_protocol;
543
544         tag_protocol = ds->ops->get_tag_protocol(ds, dp->index);
545         tag_ops = dsa_resolve_tag_protocol(tag_protocol);
546         if (IS_ERR(tag_ops)) {
547                 dev_warn(ds->dev, "No tagger for this switch\n");
548                 return PTR_ERR(tag_ops);
549         }
550
551         dp->type = DSA_PORT_TYPE_CPU;
552         dp->rcv = tag_ops->rcv;
553         dp->tag_ops = tag_ops;
554         dp->master = master;
555         dp->dst = dst;
556
557         return 0;
558 }
559
560 static int dsa_port_parse_of(struct dsa_port *dp, struct device_node *dn)
561 {
562         struct device_node *ethernet = of_parse_phandle(dn, "ethernet", 0);
563         const char *name = of_get_property(dn, "label", NULL);
564         bool link = of_property_read_bool(dn, "link");
565
566         dp->dn = dn;
567
568         if (ethernet) {
569                 struct net_device *master;
570
571                 master = of_find_net_device_by_node(ethernet);
572                 if (!master)
573                         return -EPROBE_DEFER;
574
575                 return dsa_port_parse_cpu(dp, master);
576         }
577
578         if (link)
579                 return dsa_port_parse_dsa(dp);
580
581         return dsa_port_parse_user(dp, name);
582 }
583
584 static int dsa_switch_parse_ports_of(struct dsa_switch *ds,
585                                      struct device_node *dn)
586 {
587         struct device_node *ports, *port;
588         struct dsa_port *dp;
589         u32 reg;
590         int err;
591
592         ports = of_get_child_by_name(dn, "ports");
593         if (!ports) {
594                 dev_err(ds->dev, "no ports child node found\n");
595                 return -EINVAL;
596         }
597
598         for_each_available_child_of_node(ports, port) {
599                 err = of_property_read_u32(port, "reg", &reg);
600                 if (err)
601                         return err;
602
603                 if (reg >= ds->num_ports)
604                         return -EINVAL;
605
606                 dp = &ds->ports[reg];
607
608                 err = dsa_port_parse_of(dp, port);
609                 if (err)
610                         return err;
611         }
612
613         return 0;
614 }
615
616 static int dsa_switch_parse_member_of(struct dsa_switch *ds,
617                                       struct device_node *dn)
618 {
619         u32 m[2] = { 0, 0 };
620         int sz;
621
622         /* Don't error out if this optional property isn't found */
623         sz = of_property_read_variable_u32_array(dn, "dsa,member", m, 2, 2);
624         if (sz < 0 && sz != -EINVAL)
625                 return sz;
626
627         ds->index = m[1];
628         if (ds->index >= DSA_MAX_SWITCHES)
629                 return -EINVAL;
630
631         ds->dst = dsa_tree_touch(m[0]);
632         if (!ds->dst)
633                 return -ENOMEM;
634
635         return 0;
636 }
637
638 static int dsa_switch_parse_of(struct dsa_switch *ds, struct device_node *dn)
639 {
640         int err;
641
642         err = dsa_switch_parse_member_of(ds, dn);
643         if (err)
644                 return err;
645
646         return dsa_switch_parse_ports_of(ds, dn);
647 }
648
649 static int dsa_port_parse(struct dsa_port *dp, const char *name,
650                           struct device *dev)
651 {
652         if (!strcmp(name, "cpu")) {
653                 struct net_device *master;
654
655                 master = dsa_dev_to_net_device(dev);
656                 if (!master)
657                         return -EPROBE_DEFER;
658
659                 dev_put(master);
660
661                 return dsa_port_parse_cpu(dp, master);
662         }
663
664         if (!strcmp(name, "dsa"))
665                 return dsa_port_parse_dsa(dp);
666
667         return dsa_port_parse_user(dp, name);
668 }
669
670 static int dsa_switch_parse_ports(struct dsa_switch *ds,
671                                   struct dsa_chip_data *cd)
672 {
673         bool valid_name_found = false;
674         struct dsa_port *dp;
675         struct device *dev;
676         const char *name;
677         unsigned int i;
678         int err;
679
680         for (i = 0; i < DSA_MAX_PORTS; i++) {
681                 name = cd->port_names[i];
682                 dev = cd->netdev[i];
683                 dp = &ds->ports[i];
684
685                 if (!name)
686                         continue;
687
688                 err = dsa_port_parse(dp, name, dev);
689                 if (err)
690                         return err;
691
692                 valid_name_found = true;
693         }
694
695         if (!valid_name_found && i == DSA_MAX_PORTS)
696                 return -EINVAL;
697
698         return 0;
699 }
700
701 static int dsa_switch_parse(struct dsa_switch *ds, struct dsa_chip_data *cd)
702 {
703         ds->cd = cd;
704
705         /* We don't support interconnected switches nor multiple trees via
706          * platform data, so this is the unique switch of the tree.
707          */
708         ds->index = 0;
709         ds->dst = dsa_tree_touch(0);
710         if (!ds->dst)
711                 return -ENOMEM;
712
713         return dsa_switch_parse_ports(ds, cd);
714 }
715
716 static int dsa_switch_add(struct dsa_switch *ds)
717 {
718         struct dsa_switch_tree *dst = ds->dst;
719
720         return dsa_tree_add_switch(dst, ds);
721 }
722
723 static int dsa_switch_probe(struct dsa_switch *ds)
724 {
725         struct dsa_chip_data *pdata = ds->dev->platform_data;
726         struct device_node *np = ds->dev->of_node;
727         int err;
728
729         if (np)
730                 err = dsa_switch_parse_of(ds, np);
731         else if (pdata)
732                 err = dsa_switch_parse(ds, pdata);
733         else
734                 err = -ENODEV;
735
736         if (err)
737                 return err;
738
739         return dsa_switch_add(ds);
740 }
741
742 struct dsa_switch *dsa_switch_alloc(struct device *dev, size_t n)
743 {
744         size_t size = sizeof(struct dsa_switch) + n * sizeof(struct dsa_port);
745         struct dsa_switch *ds;
746         int i;
747
748         ds = devm_kzalloc(dev, size, GFP_KERNEL);
749         if (!ds)
750                 return NULL;
751
752         ds->dev = dev;
753         ds->num_ports = n;
754
755         for (i = 0; i < ds->num_ports; ++i) {
756                 ds->ports[i].index = i;
757                 ds->ports[i].ds = ds;
758         }
759
760         return ds;
761 }
762 EXPORT_SYMBOL_GPL(dsa_switch_alloc);
763
764 int dsa_register_switch(struct dsa_switch *ds)
765 {
766         int err;
767
768         mutex_lock(&dsa2_mutex);
769         err = dsa_switch_probe(ds);
770         dsa_tree_put(ds->dst);
771         mutex_unlock(&dsa2_mutex);
772
773         return err;
774 }
775 EXPORT_SYMBOL_GPL(dsa_register_switch);
776
777 static void dsa_switch_remove(struct dsa_switch *ds)
778 {
779         struct dsa_switch_tree *dst = ds->dst;
780         unsigned int index = ds->index;
781
782         dsa_tree_remove_switch(dst, index);
783 }
784
785 void dsa_unregister_switch(struct dsa_switch *ds)
786 {
787         mutex_lock(&dsa2_mutex);
788         dsa_switch_remove(ds);
789         mutex_unlock(&dsa2_mutex);
790 }
791 EXPORT_SYMBOL_GPL(dsa_unregister_switch);