1
2
3
4
5
6
7
8
9
10
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
24static LIST_HEAD(dsa_tree_list);
25static DEFINE_MUTEX(dsa2_mutex);
26
27static const struct devlink_ops dsa_devlink_ops = {
28};
29
30static 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
41static 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
59static void dsa_tree_free(struct dsa_switch_tree *dst)
60{
61 list_del(&dst->list);
62 kfree(dst);
63}
64
65static 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
73static 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
84static 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
93static void dsa_tree_put(struct dsa_switch_tree *dst)
94{
95 if (dst)
96 kref_put(&dst->refcount, dsa_tree_release);
97}
98
99static bool dsa_port_is_dsa(struct dsa_port *port)
100{
101 return port->type == DSA_PORT_TYPE_DSA;
102}
103
104static bool dsa_port_is_cpu(struct dsa_port *port)
105{
106 return port->type == DSA_PORT_TYPE_CPU;
107}
108
109static bool dsa_port_is_user(struct dsa_port *dp)
110{
111 return dp->type == DSA_PORT_TYPE_USER;
112}
113
114static 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
137static 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
159static 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
181static 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
200static 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
222static 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
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
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) || dsa_port_is_dsa(dp))
245 dp->cpu_dp = dst->cpu_dp;
246 }
247 }
248
249 return 0;
250}
251
252static void dsa_tree_teardown_default_cpu(struct dsa_switch_tree *dst)
253{
254
255 dst->cpu_dp = NULL;
256}
257
258static 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_link_register_of(dp);
275 if (err) {
276 dev_err(ds->dev, "failed to setup link for port %d.%d\n",
277 ds->index, dp->index);
278 return err;
279 }
280 break;
281 case DSA_PORT_TYPE_USER:
282 err = dsa_slave_create(dp);
283 if (err)
284 dev_err(ds->dev, "failed to create slave for port %d.%d\n",
285 ds->index, dp->index);
286 else
287 devlink_port_type_eth_set(&dp->devlink_port, dp->slave);
288 break;
289 }
290
291 return 0;
292}
293
294static void dsa_port_teardown(struct dsa_port *dp)
295{
296 devlink_port_unregister(&dp->devlink_port);
297
298 switch (dp->type) {
299 case DSA_PORT_TYPE_UNUSED:
300 break;
301 case DSA_PORT_TYPE_CPU:
302 case DSA_PORT_TYPE_DSA:
303 dsa_port_link_unregister_of(dp);
304 break;
305 case DSA_PORT_TYPE_USER:
306 if (dp->slave) {
307 dsa_slave_destroy(dp->slave);
308 dp->slave = NULL;
309 }
310 break;
311 }
312}
313
314static int dsa_switch_setup(struct dsa_switch *ds)
315{
316 int err;
317
318
319
320
321
322
323 ds->phys_mii_mask |= dsa_user_ports(ds);
324
325
326
327
328 ds->devlink = devlink_alloc(&dsa_devlink_ops, 0);
329 if (!ds->devlink)
330 return -ENOMEM;
331
332 err = devlink_register(ds->devlink, ds->dev);
333 if (err)
334 return err;
335
336 err = ds->ops->setup(ds);
337 if (err < 0)
338 return err;
339
340 err = dsa_switch_register_notifier(ds);
341 if (err)
342 return err;
343
344 if (!ds->slave_mii_bus && ds->ops->phy_read) {
345 ds->slave_mii_bus = devm_mdiobus_alloc(ds->dev);
346 if (!ds->slave_mii_bus)
347 return -ENOMEM;
348
349 dsa_slave_mii_bus_init(ds);
350
351 err = mdiobus_register(ds->slave_mii_bus);
352 if (err < 0)
353 return err;
354 }
355
356 return 0;
357}
358
359static void dsa_switch_teardown(struct dsa_switch *ds)
360{
361 if (ds->slave_mii_bus && ds->ops->phy_read)
362 mdiobus_unregister(ds->slave_mii_bus);
363
364 dsa_switch_unregister_notifier(ds);
365
366 if (ds->devlink) {
367 devlink_unregister(ds->devlink);
368 devlink_free(ds->devlink);
369 ds->devlink = NULL;
370 }
371
372}
373
374static int dsa_tree_setup_switches(struct dsa_switch_tree *dst)
375{
376 struct dsa_switch *ds;
377 struct dsa_port *dp;
378 int device, port;
379 int err;
380
381 for (device = 0; device < DSA_MAX_SWITCHES; device++) {
382 ds = dst->ds[device];
383 if (!ds)
384 continue;
385
386 err = dsa_switch_setup(ds);
387 if (err)
388 return err;
389
390 for (port = 0; port < ds->num_ports; port++) {
391 dp = &ds->ports[port];
392
393 err = dsa_port_setup(dp);
394 if (err)
395 return err;
396 }
397 }
398
399 return 0;
400}
401
402static void dsa_tree_teardown_switches(struct dsa_switch_tree *dst)
403{
404 struct dsa_switch *ds;
405 struct dsa_port *dp;
406 int device, port;
407
408 for (device = 0; device < DSA_MAX_SWITCHES; device++) {
409 ds = dst->ds[device];
410 if (!ds)
411 continue;
412
413 for (port = 0; port < ds->num_ports; port++) {
414 dp = &ds->ports[port];
415
416 dsa_port_teardown(dp);
417 }
418
419 dsa_switch_teardown(ds);
420 }
421}
422
423static int dsa_tree_setup_master(struct dsa_switch_tree *dst)
424{
425 struct dsa_port *cpu_dp = dst->cpu_dp;
426 struct net_device *master = cpu_dp->master;
427
428
429 return dsa_master_setup(master, cpu_dp);
430}
431
432static void dsa_tree_teardown_master(struct dsa_switch_tree *dst)
433{
434 struct dsa_port *cpu_dp = dst->cpu_dp;
435 struct net_device *master = cpu_dp->master;
436
437 return dsa_master_teardown(master);
438}
439
440static int dsa_tree_setup(struct dsa_switch_tree *dst)
441{
442 bool complete;
443 int err;
444
445 if (dst->setup) {
446 pr_err("DSA: tree %d already setup! Disjoint trees?\n",
447 dst->index);
448 return -EEXIST;
449 }
450
451 complete = dsa_tree_setup_routing_table(dst);
452 if (!complete)
453 return 0;
454
455 err = dsa_tree_setup_default_cpu(dst);
456 if (err)
457 return err;
458
459 err = dsa_tree_setup_switches(dst);
460 if (err)
461 return err;
462
463 err = dsa_tree_setup_master(dst);
464 if (err)
465 return err;
466
467 dst->setup = true;
468
469 pr_info("DSA: tree %d setup\n", dst->index);
470
471 return 0;
472}
473
474static void dsa_tree_teardown(struct dsa_switch_tree *dst)
475{
476 if (!dst->setup)
477 return;
478
479 dsa_tree_teardown_master(dst);
480
481 dsa_tree_teardown_switches(dst);
482
483 dsa_tree_teardown_default_cpu(dst);
484
485 pr_info("DSA: tree %d torn down\n", dst->index);
486
487 dst->setup = false;
488}
489
490static void dsa_tree_remove_switch(struct dsa_switch_tree *dst,
491 unsigned int index)
492{
493 dsa_tree_teardown(dst);
494
495 dst->ds[index] = NULL;
496 dsa_tree_put(dst);
497}
498
499static int dsa_tree_add_switch(struct dsa_switch_tree *dst,
500 struct dsa_switch *ds)
501{
502 unsigned int index = ds->index;
503 int err;
504
505 if (dst->ds[index])
506 return -EBUSY;
507
508 dsa_tree_get(dst);
509 dst->ds[index] = ds;
510
511 err = dsa_tree_setup(dst);
512 if (err)
513 dsa_tree_remove_switch(dst, index);
514
515 return err;
516}
517
518static int dsa_port_parse_user(struct dsa_port *dp, const char *name)
519{
520 if (!name)
521 name = "eth%d";
522
523 dp->type = DSA_PORT_TYPE_USER;
524 dp->name = name;
525
526 return 0;
527}
528
529static int dsa_port_parse_dsa(struct dsa_port *dp)
530{
531 dp->type = DSA_PORT_TYPE_DSA;
532
533 return 0;
534}
535
536static int dsa_port_parse_cpu(struct dsa_port *dp, struct net_device *master)
537{
538 struct dsa_switch *ds = dp->ds;
539 struct dsa_switch_tree *dst = ds->dst;
540 const struct dsa_device_ops *tag_ops;
541 enum dsa_tag_protocol tag_protocol;
542
543 tag_protocol = ds->ops->get_tag_protocol(ds, dp->index);
544 tag_ops = dsa_resolve_tag_protocol(tag_protocol);
545 if (IS_ERR(tag_ops)) {
546 dev_warn(ds->dev, "No tagger for this switch\n");
547 return PTR_ERR(tag_ops);
548 }
549
550 dp->type = DSA_PORT_TYPE_CPU;
551 dp->rcv = tag_ops->rcv;
552 dp->tag_ops = tag_ops;
553 dp->master = master;
554 dp->dst = dst;
555
556 return 0;
557}
558
559static int dsa_port_parse_of(struct dsa_port *dp, struct device_node *dn)
560{
561 struct device_node *ethernet = of_parse_phandle(dn, "ethernet", 0);
562 const char *name = of_get_property(dn, "label", NULL);
563 bool link = of_property_read_bool(dn, "link");
564
565 dp->dn = dn;
566
567 if (ethernet) {
568 struct net_device *master;
569
570 master = of_find_net_device_by_node(ethernet);
571 if (!master)
572 return -EPROBE_DEFER;
573
574 return dsa_port_parse_cpu(dp, master);
575 }
576
577 if (link)
578 return dsa_port_parse_dsa(dp);
579
580 return dsa_port_parse_user(dp, name);
581}
582
583static int dsa_switch_parse_ports_of(struct dsa_switch *ds,
584 struct device_node *dn)
585{
586 struct device_node *ports, *port;
587 struct dsa_port *dp;
588 u32 reg;
589 int err;
590
591 ports = of_get_child_by_name(dn, "ports");
592 if (!ports) {
593 dev_err(ds->dev, "no ports child node found\n");
594 return -EINVAL;
595 }
596
597 for_each_available_child_of_node(ports, port) {
598 err = of_property_read_u32(port, "reg", ®);
599 if (err)
600 return err;
601
602 if (reg >= ds->num_ports)
603 return -EINVAL;
604
605 dp = &ds->ports[reg];
606
607 err = dsa_port_parse_of(dp, port);
608 if (err)
609 return err;
610 }
611
612 return 0;
613}
614
615static int dsa_switch_parse_member_of(struct dsa_switch *ds,
616 struct device_node *dn)
617{
618 u32 m[2] = { 0, 0 };
619 int sz;
620
621
622 sz = of_property_read_variable_u32_array(dn, "dsa,member", m, 2, 2);
623 if (sz < 0 && sz != -EINVAL)
624 return sz;
625
626 ds->index = m[1];
627 if (ds->index >= DSA_MAX_SWITCHES)
628 return -EINVAL;
629
630 ds->dst = dsa_tree_touch(m[0]);
631 if (!ds->dst)
632 return -ENOMEM;
633
634 return 0;
635}
636
637static int dsa_switch_parse_of(struct dsa_switch *ds, struct device_node *dn)
638{
639 int err;
640
641 err = dsa_switch_parse_member_of(ds, dn);
642 if (err)
643 return err;
644
645 return dsa_switch_parse_ports_of(ds, dn);
646}
647
648static int dsa_port_parse(struct dsa_port *dp, const char *name,
649 struct device *dev)
650{
651 if (!strcmp(name, "cpu")) {
652 struct net_device *master;
653
654 master = dsa_dev_to_net_device(dev);
655 if (!master)
656 return -EPROBE_DEFER;
657
658 dev_put(master);
659
660 return dsa_port_parse_cpu(dp, master);
661 }
662
663 if (!strcmp(name, "dsa"))
664 return dsa_port_parse_dsa(dp);
665
666 return dsa_port_parse_user(dp, name);
667}
668
669static int dsa_switch_parse_ports(struct dsa_switch *ds,
670 struct dsa_chip_data *cd)
671{
672 bool valid_name_found = false;
673 struct dsa_port *dp;
674 struct device *dev;
675 const char *name;
676 unsigned int i;
677 int err;
678
679 for (i = 0; i < DSA_MAX_PORTS; i++) {
680 name = cd->port_names[i];
681 dev = cd->netdev[i];
682 dp = &ds->ports[i];
683
684 if (!name)
685 continue;
686
687 err = dsa_port_parse(dp, name, dev);
688 if (err)
689 return err;
690
691 valid_name_found = true;
692 }
693
694 if (!valid_name_found && i == DSA_MAX_PORTS)
695 return -EINVAL;
696
697 return 0;
698}
699
700static int dsa_switch_parse(struct dsa_switch *ds, struct dsa_chip_data *cd)
701{
702 ds->cd = cd;
703
704
705
706
707 ds->index = 0;
708 ds->dst = dsa_tree_touch(0);
709 if (!ds->dst)
710 return -ENOMEM;
711
712 return dsa_switch_parse_ports(ds, cd);
713}
714
715static int dsa_switch_add(struct dsa_switch *ds)
716{
717 struct dsa_switch_tree *dst = ds->dst;
718
719 return dsa_tree_add_switch(dst, ds);
720}
721
722static int dsa_switch_probe(struct dsa_switch *ds)
723{
724 struct dsa_chip_data *pdata = ds->dev->platform_data;
725 struct device_node *np = ds->dev->of_node;
726 int err;
727
728 if (np)
729 err = dsa_switch_parse_of(ds, np);
730 else if (pdata)
731 err = dsa_switch_parse(ds, pdata);
732 else
733 err = -ENODEV;
734
735 if (err)
736 return err;
737
738 return dsa_switch_add(ds);
739}
740
741struct dsa_switch *dsa_switch_alloc(struct device *dev, size_t n)
742{
743 size_t size = sizeof(struct dsa_switch) + n * sizeof(struct dsa_port);
744 struct dsa_switch *ds;
745 int i;
746
747 ds = devm_kzalloc(dev, size, GFP_KERNEL);
748 if (!ds)
749 return NULL;
750
751 ds->dev = dev;
752 ds->num_ports = n;
753
754 for (i = 0; i < ds->num_ports; ++i) {
755 ds->ports[i].index = i;
756 ds->ports[i].ds = ds;
757 }
758
759 return ds;
760}
761EXPORT_SYMBOL_GPL(dsa_switch_alloc);
762
763int dsa_register_switch(struct dsa_switch *ds)
764{
765 int err;
766
767 mutex_lock(&dsa2_mutex);
768 err = dsa_switch_probe(ds);
769 dsa_tree_put(ds->dst);
770 mutex_unlock(&dsa2_mutex);
771
772 return err;
773}
774EXPORT_SYMBOL_GPL(dsa_register_switch);
775
776static void dsa_switch_remove(struct dsa_switch *ds)
777{
778 struct dsa_switch_tree *dst = ds->dst;
779 unsigned int index = ds->index;
780
781 dsa_tree_remove_switch(dst, index);
782}
783
784void dsa_unregister_switch(struct dsa_switch *ds)
785{
786 mutex_lock(&dsa2_mutex);
787 dsa_switch_remove(ds);
788 mutex_unlock(&dsa2_mutex);
789}
790EXPORT_SYMBOL_GPL(dsa_unregister_switch);
791