Merge tag 'mvebu-fixes-4.14-3' of git://git.infradead.org/linux-mvebu into fixes
[sfrench/cifs-2.6.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_switch_trees);
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_get_dst(u32 tree)
31 {
32         struct dsa_switch_tree *dst;
33
34         list_for_each_entry(dst, &dsa_switch_trees, list)
35                 if (dst->tree == tree) {
36                         kref_get(&dst->refcount);
37                         return dst;
38                 }
39         return NULL;
40 }
41
42 static void dsa_free_dst(struct kref *ref)
43 {
44         struct dsa_switch_tree *dst = container_of(ref, struct dsa_switch_tree,
45                                                    refcount);
46
47         list_del(&dst->list);
48         kfree(dst);
49 }
50
51 static void dsa_put_dst(struct dsa_switch_tree *dst)
52 {
53         kref_put(&dst->refcount, dsa_free_dst);
54 }
55
56 static struct dsa_switch_tree *dsa_add_dst(u32 tree)
57 {
58         struct dsa_switch_tree *dst;
59
60         dst = kzalloc(sizeof(*dst), GFP_KERNEL);
61         if (!dst)
62                 return NULL;
63         dst->tree = tree;
64         INIT_LIST_HEAD(&dst->list);
65         list_add_tail(&dsa_switch_trees, &dst->list);
66         kref_init(&dst->refcount);
67
68         return dst;
69 }
70
71 static void dsa_dst_add_ds(struct dsa_switch_tree *dst,
72                            struct dsa_switch *ds, u32 index)
73 {
74         kref_get(&dst->refcount);
75         dst->ds[index] = ds;
76 }
77
78 static void dsa_dst_del_ds(struct dsa_switch_tree *dst,
79                            struct dsa_switch *ds, u32 index)
80 {
81         dst->ds[index] = NULL;
82         kref_put(&dst->refcount, dsa_free_dst);
83 }
84
85 /* For platform data configurations, we need to have a valid name argument to
86  * differentiate a disabled port from an enabled one
87  */
88 static bool dsa_port_is_valid(struct dsa_port *port)
89 {
90         return !!(port->dn || port->name);
91 }
92
93 static bool dsa_port_is_dsa(struct dsa_port *port)
94 {
95         if (port->name && !strcmp(port->name, "dsa"))
96                 return true;
97         else
98                 return !!of_parse_phandle(port->dn, "link", 0);
99 }
100
101 static bool dsa_port_is_cpu(struct dsa_port *port)
102 {
103         if (port->name && !strcmp(port->name, "cpu"))
104                 return true;
105         else
106                 return !!of_parse_phandle(port->dn, "ethernet", 0);
107 }
108
109 static bool dsa_ds_find_port_dn(struct dsa_switch *ds,
110                                 struct device_node *port)
111 {
112         u32 index;
113
114         for (index = 0; index < ds->num_ports; index++)
115                 if (ds->ports[index].dn == port)
116                         return true;
117         return false;
118 }
119
120 static struct dsa_switch *dsa_dst_find_port_dn(struct dsa_switch_tree *dst,
121                                                struct device_node *port)
122 {
123         struct dsa_switch *ds;
124         u32 index;
125
126         for (index = 0; index < DSA_MAX_SWITCHES; index++) {
127                 ds = dst->ds[index];
128                 if (!ds)
129                         continue;
130
131                 if (dsa_ds_find_port_dn(ds, port))
132                         return ds;
133         }
134
135         return NULL;
136 }
137
138 static int dsa_port_complete(struct dsa_switch_tree *dst,
139                              struct dsa_switch *src_ds,
140                              struct dsa_port *port,
141                              u32 src_port)
142 {
143         struct device_node *link;
144         int index;
145         struct dsa_switch *dst_ds;
146
147         for (index = 0;; index++) {
148                 link = of_parse_phandle(port->dn, "link", index);
149                 if (!link)
150                         break;
151
152                 dst_ds = dsa_dst_find_port_dn(dst, link);
153                 of_node_put(link);
154
155                 if (!dst_ds)
156                         return 1;
157
158                 src_ds->rtable[dst_ds->index] = src_port;
159         }
160
161         return 0;
162 }
163
164 /* A switch is complete if all the DSA ports phandles point to ports
165  * known in the tree. A return value of 1 means the tree is not
166  * complete. This is not an error condition. A value of 0 is
167  * success.
168  */
169 static int dsa_ds_complete(struct dsa_switch_tree *dst, struct dsa_switch *ds)
170 {
171         struct dsa_port *port;
172         u32 index;
173         int err;
174
175         for (index = 0; index < ds->num_ports; index++) {
176                 port = &ds->ports[index];
177                 if (!dsa_port_is_valid(port))
178                         continue;
179
180                 if (!dsa_port_is_dsa(port))
181                         continue;
182
183                 err = dsa_port_complete(dst, ds, port, index);
184                 if (err != 0)
185                         return err;
186
187                 ds->dsa_port_mask |= BIT(index);
188         }
189
190         return 0;
191 }
192
193 /* A tree is complete if all the DSA ports phandles point to ports
194  * known in the tree. A return value of 1 means the tree is not
195  * complete. This is not an error condition. A value of 0 is
196  * success.
197  */
198 static int dsa_dst_complete(struct dsa_switch_tree *dst)
199 {
200         struct dsa_switch *ds;
201         u32 index;
202         int err;
203
204         for (index = 0; index < DSA_MAX_SWITCHES; index++) {
205                 ds = dst->ds[index];
206                 if (!ds)
207                         continue;
208
209                 err = dsa_ds_complete(dst, ds);
210                 if (err != 0)
211                         return err;
212         }
213
214         return 0;
215 }
216
217 static int dsa_dsa_port_apply(struct dsa_port *port)
218 {
219         struct dsa_switch *ds = port->ds;
220         int err;
221
222         err = dsa_cpu_dsa_setup(port);
223         if (err) {
224                 dev_warn(ds->dev, "Failed to setup dsa port %d: %d\n",
225                          port->index, err);
226                 return err;
227         }
228
229         memset(&port->devlink_port, 0, sizeof(port->devlink_port));
230
231         return devlink_port_register(ds->devlink, &port->devlink_port,
232                                      port->index);
233 }
234
235 static void dsa_dsa_port_unapply(struct dsa_port *port)
236 {
237         devlink_port_unregister(&port->devlink_port);
238         dsa_cpu_dsa_destroy(port);
239 }
240
241 static int dsa_cpu_port_apply(struct dsa_port *port)
242 {
243         struct dsa_switch *ds = port->ds;
244         int err;
245
246         err = dsa_cpu_dsa_setup(port);
247         if (err) {
248                 dev_warn(ds->dev, "Failed to setup cpu port %d: %d\n",
249                          port->index, err);
250                 return err;
251         }
252
253         memset(&port->devlink_port, 0, sizeof(port->devlink_port));
254         err = devlink_port_register(ds->devlink, &port->devlink_port,
255                                     port->index);
256         return err;
257 }
258
259 static void dsa_cpu_port_unapply(struct dsa_port *port)
260 {
261         devlink_port_unregister(&port->devlink_port);
262         dsa_cpu_dsa_destroy(port);
263         port->ds->cpu_port_mask &= ~BIT(port->index);
264
265 }
266
267 static int dsa_user_port_apply(struct dsa_port *port)
268 {
269         struct dsa_switch *ds = port->ds;
270         const char *name = port->name;
271         int err;
272
273         if (port->dn)
274                 name = of_get_property(port->dn, "label", NULL);
275         if (!name)
276                 name = "eth%d";
277
278         err = dsa_slave_create(port, name);
279         if (err) {
280                 dev_warn(ds->dev, "Failed to create slave %d: %d\n",
281                          port->index, err);
282                 port->netdev = NULL;
283                 return err;
284         }
285
286         memset(&port->devlink_port, 0, sizeof(port->devlink_port));
287         err = devlink_port_register(ds->devlink, &port->devlink_port,
288                                     port->index);
289         if (err)
290                 return err;
291
292         devlink_port_type_eth_set(&port->devlink_port, port->netdev);
293
294         return 0;
295 }
296
297 static void dsa_user_port_unapply(struct dsa_port *port)
298 {
299         devlink_port_unregister(&port->devlink_port);
300         if (port->netdev) {
301                 dsa_slave_destroy(port->netdev);
302                 port->netdev = NULL;
303                 port->ds->enabled_port_mask &= ~(1 << port->index);
304         }
305 }
306
307 static int dsa_ds_apply(struct dsa_switch_tree *dst, struct dsa_switch *ds)
308 {
309         struct dsa_port *port;
310         u32 index;
311         int err;
312
313         /* Initialize ds->phys_mii_mask before registering the slave MDIO bus
314          * driver and before ops->setup() has run, since the switch drivers and
315          * the slave MDIO bus driver rely on these values for probing PHY
316          * devices or not
317          */
318         ds->phys_mii_mask = ds->enabled_port_mask;
319
320         /* Add the switch to devlink before calling setup, so that setup can
321          * add dpipe tables
322          */
323         ds->devlink = devlink_alloc(&dsa_devlink_ops, 0);
324         if (!ds->devlink)
325                 return -ENOMEM;
326
327         err = devlink_register(ds->devlink, ds->dev);
328         if (err)
329                 return err;
330
331         err = ds->ops->setup(ds);
332         if (err < 0)
333                 return err;
334
335         err = dsa_switch_register_notifier(ds);
336         if (err)
337                 return err;
338
339         if (ds->ops->set_addr) {
340                 err = ds->ops->set_addr(ds, dst->cpu_dp->netdev->dev_addr);
341                 if (err < 0)
342                         return err;
343         }
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         for (index = 0; index < ds->num_ports; index++) {
358                 port = &ds->ports[index];
359                 if (!dsa_port_is_valid(port))
360                         continue;
361
362                 if (dsa_port_is_dsa(port)) {
363                         err = dsa_dsa_port_apply(port);
364                         if (err)
365                                 return err;
366                         continue;
367                 }
368
369                 if (dsa_port_is_cpu(port)) {
370                         err = dsa_cpu_port_apply(port);
371                         if (err)
372                                 return err;
373                         continue;
374                 }
375
376                 err = dsa_user_port_apply(port);
377                 if (err)
378                         continue;
379         }
380
381         return 0;
382 }
383
384 static void dsa_ds_unapply(struct dsa_switch_tree *dst, struct dsa_switch *ds)
385 {
386         struct dsa_port *port;
387         u32 index;
388
389         for (index = 0; index < ds->num_ports; index++) {
390                 port = &ds->ports[index];
391                 if (!dsa_port_is_valid(port))
392                         continue;
393
394                 if (dsa_port_is_dsa(port)) {
395                         dsa_dsa_port_unapply(port);
396                         continue;
397                 }
398
399                 if (dsa_port_is_cpu(port)) {
400                         dsa_cpu_port_unapply(port);
401                         continue;
402                 }
403
404                 dsa_user_port_unapply(port);
405         }
406
407         if (ds->slave_mii_bus && ds->ops->phy_read)
408                 mdiobus_unregister(ds->slave_mii_bus);
409
410         dsa_switch_unregister_notifier(ds);
411
412         if (ds->devlink) {
413                 devlink_unregister(ds->devlink);
414                 devlink_free(ds->devlink);
415                 ds->devlink = NULL;
416         }
417
418 }
419
420 static int dsa_dst_apply(struct dsa_switch_tree *dst)
421 {
422         struct dsa_switch *ds;
423         u32 index;
424         int err;
425
426         for (index = 0; index < DSA_MAX_SWITCHES; index++) {
427                 ds = dst->ds[index];
428                 if (!ds)
429                         continue;
430
431                 err = dsa_ds_apply(dst, ds);
432                 if (err)
433                         return err;
434         }
435
436         if (dst->cpu_dp) {
437                 err = dsa_cpu_port_ethtool_setup(dst->cpu_dp);
438                 if (err)
439                         return err;
440         }
441
442         /* If we use a tagging format that doesn't have an ethertype
443          * field, make sure that all packets from this point on get
444          * sent to the tag format's receive function.
445          */
446         wmb();
447         dst->cpu_dp->netdev->dsa_ptr = dst;
448         dst->applied = true;
449
450         return 0;
451 }
452
453 static void dsa_dst_unapply(struct dsa_switch_tree *dst)
454 {
455         struct dsa_switch *ds;
456         u32 index;
457
458         if (!dst->applied)
459                 return;
460
461         dst->cpu_dp->netdev->dsa_ptr = NULL;
462
463         /* If we used a tagging format that doesn't have an ethertype
464          * field, make sure that all packets from this point get sent
465          * without the tag and go through the regular receive path.
466          */
467         wmb();
468
469         for (index = 0; index < DSA_MAX_SWITCHES; index++) {
470                 ds = dst->ds[index];
471                 if (!ds)
472                         continue;
473
474                 dsa_ds_unapply(dst, ds);
475         }
476
477         if (dst->cpu_dp) {
478                 dsa_cpu_port_ethtool_restore(dst->cpu_dp);
479                 dst->cpu_dp = NULL;
480         }
481
482         pr_info("DSA: tree %d unapplied\n", dst->tree);
483         dst->applied = false;
484 }
485
486 static int dsa_cpu_parse(struct dsa_port *port, u32 index,
487                          struct dsa_switch_tree *dst,
488                          struct dsa_switch *ds)
489 {
490         enum dsa_tag_protocol tag_protocol;
491         struct net_device *ethernet_dev;
492         struct device_node *ethernet;
493
494         if (port->dn) {
495                 ethernet = of_parse_phandle(port->dn, "ethernet", 0);
496                 if (!ethernet)
497                         return -EINVAL;
498                 ethernet_dev = of_find_net_device_by_node(ethernet);
499                 if (!ethernet_dev)
500                         return -EPROBE_DEFER;
501         } else {
502                 ethernet_dev = dsa_dev_to_net_device(ds->cd->netdev[index]);
503                 if (!ethernet_dev)
504                         return -EPROBE_DEFER;
505                 dev_put(ethernet_dev);
506         }
507
508         if (!dst->cpu_dp) {
509                 dst->cpu_dp = port;
510                 dst->cpu_dp->netdev = ethernet_dev;
511         }
512
513         /* Initialize cpu_port_mask now for drv->setup()
514          * to have access to a correct value, just like what
515          * net/dsa/dsa.c::dsa_switch_setup_one does.
516          */
517         ds->cpu_port_mask |= BIT(index);
518
519         tag_protocol = ds->ops->get_tag_protocol(ds);
520         dst->tag_ops = dsa_resolve_tag_protocol(tag_protocol);
521         if (IS_ERR(dst->tag_ops)) {
522                 dev_warn(ds->dev, "No tagger for this switch\n");
523                 ds->cpu_port_mask &= ~BIT(index);
524                 return PTR_ERR(dst->tag_ops);
525         }
526
527         dst->rcv = dst->tag_ops->rcv;
528
529         return 0;
530 }
531
532 static int dsa_ds_parse(struct dsa_switch_tree *dst, struct dsa_switch *ds)
533 {
534         struct dsa_port *port;
535         u32 index;
536         int err;
537
538         for (index = 0; index < ds->num_ports; index++) {
539                 port = &ds->ports[index];
540                 if (!dsa_port_is_valid(port) ||
541                     dsa_port_is_dsa(port))
542                         continue;
543
544                 if (dsa_port_is_cpu(port)) {
545                         err = dsa_cpu_parse(port, index, dst, ds);
546                         if (err)
547                                 return err;
548                 } else {
549                         /* Initialize enabled_port_mask now for drv->setup()
550                          * to have access to a correct value, just like what
551                          * net/dsa/dsa.c::dsa_switch_setup_one does.
552                          */
553                         ds->enabled_port_mask |= BIT(index);
554                 }
555
556         }
557
558         pr_info("DSA: switch %d %d parsed\n", dst->tree, ds->index);
559
560         return 0;
561 }
562
563 static int dsa_dst_parse(struct dsa_switch_tree *dst)
564 {
565         struct dsa_switch *ds;
566         struct dsa_port *dp;
567         u32 index;
568         int port;
569         int err;
570
571         for (index = 0; index < DSA_MAX_SWITCHES; index++) {
572                 ds = dst->ds[index];
573                 if (!ds)
574                         continue;
575
576                 err = dsa_ds_parse(dst, ds);
577                 if (err)
578                         return err;
579         }
580
581         if (!dst->cpu_dp) {
582                 pr_warn("Tree has no master device\n");
583                 return -EINVAL;
584         }
585
586         /* Assign the default CPU port to all ports of the fabric */
587         for (index = 0; index < DSA_MAX_SWITCHES; index++) {
588                 ds = dst->ds[index];
589                 if (!ds)
590                         continue;
591
592                 for (port = 0; port < ds->num_ports; port++) {
593                         dp = &ds->ports[port];
594                         if (!dsa_port_is_valid(dp) ||
595                             dsa_port_is_dsa(dp) ||
596                             dsa_port_is_cpu(dp))
597                                 continue;
598
599                         dp->cpu_dp = dst->cpu_dp;
600                 }
601         }
602
603         pr_info("DSA: tree %d parsed\n", dst->tree);
604
605         return 0;
606 }
607
608 static int dsa_parse_ports_dn(struct device_node *ports, struct dsa_switch *ds)
609 {
610         struct device_node *port;
611         int err;
612         u32 reg;
613
614         for_each_available_child_of_node(ports, port) {
615                 err = of_property_read_u32(port, "reg", &reg);
616                 if (err)
617                         return err;
618
619                 if (reg >= ds->num_ports)
620                         return -EINVAL;
621
622                 ds->ports[reg].dn = port;
623         }
624
625         return 0;
626 }
627
628 static int dsa_parse_ports(struct dsa_chip_data *cd, struct dsa_switch *ds)
629 {
630         bool valid_name_found = false;
631         unsigned int i;
632
633         for (i = 0; i < DSA_MAX_PORTS; i++) {
634                 if (!cd->port_names[i])
635                         continue;
636
637                 ds->ports[i].name = cd->port_names[i];
638                 valid_name_found = true;
639         }
640
641         if (!valid_name_found && i == DSA_MAX_PORTS)
642                 return -EINVAL;
643
644         return 0;
645 }
646
647 static int dsa_parse_member_dn(struct device_node *np, u32 *tree, u32 *index)
648 {
649         int err;
650
651         *tree = *index = 0;
652
653         err = of_property_read_u32_index(np, "dsa,member", 0, tree);
654         if (err) {
655                 /* Does not exist, but it is optional */
656                 if (err == -EINVAL)
657                         return 0;
658                 return err;
659         }
660
661         err = of_property_read_u32_index(np, "dsa,member", 1, index);
662         if (err)
663                 return err;
664
665         if (*index >= DSA_MAX_SWITCHES)
666                 return -EINVAL;
667
668         return 0;
669 }
670
671 static int dsa_parse_member(struct dsa_chip_data *pd, u32 *tree, u32 *index)
672 {
673         if (!pd)
674                 return -ENODEV;
675
676         /* We do not support complex trees with dsa_chip_data */
677         *tree = 0;
678         *index = 0;
679
680         return 0;
681 }
682
683 static struct device_node *dsa_get_ports(struct dsa_switch *ds,
684                                          struct device_node *np)
685 {
686         struct device_node *ports;
687
688         ports = of_get_child_by_name(np, "ports");
689         if (!ports) {
690                 dev_err(ds->dev, "no ports child node found\n");
691                 return ERR_PTR(-EINVAL);
692         }
693
694         return ports;
695 }
696
697 static int _dsa_register_switch(struct dsa_switch *ds)
698 {
699         struct dsa_chip_data *pdata = ds->dev->platform_data;
700         struct device_node *np = ds->dev->of_node;
701         struct dsa_switch_tree *dst;
702         struct device_node *ports;
703         u32 tree, index;
704         int i, err;
705
706         if (np) {
707                 err = dsa_parse_member_dn(np, &tree, &index);
708                 if (err)
709                         return err;
710
711                 ports = dsa_get_ports(ds, np);
712                 if (IS_ERR(ports))
713                         return PTR_ERR(ports);
714
715                 err = dsa_parse_ports_dn(ports, ds);
716                 if (err)
717                         return err;
718         } else {
719                 err = dsa_parse_member(pdata, &tree, &index);
720                 if (err)
721                         return err;
722
723                 err = dsa_parse_ports(pdata, ds);
724                 if (err)
725                         return err;
726         }
727
728         dst = dsa_get_dst(tree);
729         if (!dst) {
730                 dst = dsa_add_dst(tree);
731                 if (!dst)
732                         return -ENOMEM;
733         }
734
735         if (dst->ds[index]) {
736                 err = -EBUSY;
737                 goto out;
738         }
739
740         ds->dst = dst;
741         ds->index = index;
742         ds->cd = pdata;
743
744         /* Initialize the routing table */
745         for (i = 0; i < DSA_MAX_SWITCHES; ++i)
746                 ds->rtable[i] = DSA_RTABLE_NONE;
747
748         dsa_dst_add_ds(dst, ds, index);
749
750         err = dsa_dst_complete(dst);
751         if (err < 0)
752                 goto out_del_dst;
753
754         if (err == 1) {
755                 /* Not all switches registered yet */
756                 err = 0;
757                 goto out;
758         }
759
760         if (dst->applied) {
761                 pr_info("DSA: Disjoint trees?\n");
762                 return -EINVAL;
763         }
764
765         err = dsa_dst_parse(dst);
766         if (err) {
767                 if (err == -EPROBE_DEFER) {
768                         dsa_dst_del_ds(dst, ds, ds->index);
769                         return err;
770                 }
771
772                 goto out_del_dst;
773         }
774
775         err = dsa_dst_apply(dst);
776         if (err) {
777                 dsa_dst_unapply(dst);
778                 goto out_del_dst;
779         }
780
781         dsa_put_dst(dst);
782         return 0;
783
784 out_del_dst:
785         dsa_dst_del_ds(dst, ds, ds->index);
786 out:
787         dsa_put_dst(dst);
788
789         return err;
790 }
791
792 struct dsa_switch *dsa_switch_alloc(struct device *dev, size_t n)
793 {
794         size_t size = sizeof(struct dsa_switch) + n * sizeof(struct dsa_port);
795         struct dsa_switch *ds;
796         int i;
797
798         ds = devm_kzalloc(dev, size, GFP_KERNEL);
799         if (!ds)
800                 return NULL;
801
802         ds->dev = dev;
803         ds->num_ports = n;
804
805         for (i = 0; i < ds->num_ports; ++i) {
806                 ds->ports[i].index = i;
807                 ds->ports[i].ds = ds;
808         }
809
810         return ds;
811 }
812 EXPORT_SYMBOL_GPL(dsa_switch_alloc);
813
814 int dsa_register_switch(struct dsa_switch *ds)
815 {
816         int err;
817
818         mutex_lock(&dsa2_mutex);
819         err = _dsa_register_switch(ds);
820         mutex_unlock(&dsa2_mutex);
821
822         return err;
823 }
824 EXPORT_SYMBOL_GPL(dsa_register_switch);
825
826 static void _dsa_unregister_switch(struct dsa_switch *ds)
827 {
828         struct dsa_switch_tree *dst = ds->dst;
829
830         dsa_dst_unapply(dst);
831
832         dsa_dst_del_ds(dst, ds, ds->index);
833 }
834
835 void dsa_unregister_switch(struct dsa_switch *ds)
836 {
837         mutex_lock(&dsa2_mutex);
838         _dsa_unregister_switch(ds);
839         mutex_unlock(&dsa2_mutex);
840 }
841 EXPORT_SYMBOL_GPL(dsa_unregister_switch);