1
2
3
4
5
6
7
8
9#include <linux/if_bridge.h>
10#include <linux/notifier.h>
11#include <linux/of_mdio.h>
12#include <linux/of_net.h>
13
14#include "dsa_priv.h"
15
16
17
18
19
20
21
22
23
24
25
26
27
28static int dsa_port_notify(const struct dsa_port *dp, unsigned long e, void *v)
29{
30 return dsa_tree_notify(dp->ds->dst, e, v);
31}
32
33static void dsa_port_notify_bridge_fdb_flush(const struct dsa_port *dp, u16 vid)
34{
35 struct net_device *brport_dev = dsa_port_to_bridge_port(dp);
36 struct switchdev_notifier_fdb_info info = {
37 .vid = vid,
38 };
39
40
41
42
43 if (!brport_dev)
44 return;
45
46 call_switchdev_notifiers(SWITCHDEV_FDB_FLUSH_TO_BRIDGE,
47 brport_dev, &info.info, NULL);
48}
49
50static void dsa_port_fast_age(const struct dsa_port *dp)
51{
52 struct dsa_switch *ds = dp->ds;
53
54 if (!ds->ops->port_fast_age)
55 return;
56
57 ds->ops->port_fast_age(ds, dp->index);
58
59
60 dsa_port_notify_bridge_fdb_flush(dp, 0);
61}
62
63static int dsa_port_vlan_fast_age(const struct dsa_port *dp, u16 vid)
64{
65 struct dsa_switch *ds = dp->ds;
66 int err;
67
68 if (!ds->ops->port_vlan_fast_age)
69 return -EOPNOTSUPP;
70
71 err = ds->ops->port_vlan_fast_age(ds, dp->index, vid);
72
73 if (!err)
74 dsa_port_notify_bridge_fdb_flush(dp, vid);
75
76 return err;
77}
78
79static int dsa_port_msti_fast_age(const struct dsa_port *dp, u16 msti)
80{
81 DECLARE_BITMAP(vids, VLAN_N_VID) = { 0 };
82 int err, vid;
83
84 err = br_mst_get_info(dsa_port_bridge_dev_get(dp), msti, vids);
85 if (err)
86 return err;
87
88 for_each_set_bit(vid, vids, VLAN_N_VID) {
89 err = dsa_port_vlan_fast_age(dp, vid);
90 if (err)
91 return err;
92 }
93
94 return 0;
95}
96
97static bool dsa_port_can_configure_learning(struct dsa_port *dp)
98{
99 struct switchdev_brport_flags flags = {
100 .mask = BR_LEARNING,
101 };
102 struct dsa_switch *ds = dp->ds;
103 int err;
104
105 if (!ds->ops->port_bridge_flags || !ds->ops->port_pre_bridge_flags)
106 return false;
107
108 err = ds->ops->port_pre_bridge_flags(ds, dp->index, flags, NULL);
109 return !err;
110}
111
112int dsa_port_set_state(struct dsa_port *dp, u8 state, bool do_fast_age)
113{
114 struct dsa_switch *ds = dp->ds;
115 int port = dp->index;
116
117 if (!ds->ops->port_stp_state_set)
118 return -EOPNOTSUPP;
119
120 ds->ops->port_stp_state_set(ds, port, state);
121
122 if (!dsa_port_can_configure_learning(dp) ||
123 (do_fast_age && dp->learning)) {
124
125
126
127
128
129
130
131
132 if ((dp->stp_state == BR_STATE_LEARNING ||
133 dp->stp_state == BR_STATE_FORWARDING) &&
134 (state == BR_STATE_DISABLED ||
135 state == BR_STATE_BLOCKING ||
136 state == BR_STATE_LISTENING))
137 dsa_port_fast_age(dp);
138 }
139
140 dp->stp_state = state;
141
142 return 0;
143}
144
145static void dsa_port_set_state_now(struct dsa_port *dp, u8 state,
146 bool do_fast_age)
147{
148 int err;
149
150 err = dsa_port_set_state(dp, state, do_fast_age);
151 if (err)
152 pr_err("DSA: failed to set STP state %u (%d)\n", state, err);
153}
154
155int dsa_port_set_mst_state(struct dsa_port *dp,
156 const struct switchdev_mst_state *state,
157 struct netlink_ext_ack *extack)
158{
159 struct dsa_switch *ds = dp->ds;
160 u8 prev_state;
161 int err;
162
163 if (!ds->ops->port_mst_state_set)
164 return -EOPNOTSUPP;
165
166 err = br_mst_get_state(dsa_port_to_bridge_port(dp), state->msti,
167 &prev_state);
168 if (err)
169 return err;
170
171 err = ds->ops->port_mst_state_set(ds, dp->index, state);
172 if (err)
173 return err;
174
175 if (!(dp->learning &&
176 (prev_state == BR_STATE_LEARNING ||
177 prev_state == BR_STATE_FORWARDING) &&
178 (state->state == BR_STATE_DISABLED ||
179 state->state == BR_STATE_BLOCKING ||
180 state->state == BR_STATE_LISTENING)))
181 return 0;
182
183 err = dsa_port_msti_fast_age(dp, state->msti);
184 if (err)
185 NL_SET_ERR_MSG_MOD(extack,
186 "Unable to flush associated VLANs");
187
188 return 0;
189}
190
191int dsa_port_enable_rt(struct dsa_port *dp, struct phy_device *phy)
192{
193 struct dsa_switch *ds = dp->ds;
194 int port = dp->index;
195 int err;
196
197 if (ds->ops->port_enable) {
198 err = ds->ops->port_enable(ds, port, phy);
199 if (err)
200 return err;
201 }
202
203 if (!dp->bridge)
204 dsa_port_set_state_now(dp, BR_STATE_FORWARDING, false);
205
206 if (dp->pl)
207 phylink_start(dp->pl);
208
209 return 0;
210}
211
212int dsa_port_enable(struct dsa_port *dp, struct phy_device *phy)
213{
214 int err;
215
216 rtnl_lock();
217 err = dsa_port_enable_rt(dp, phy);
218 rtnl_unlock();
219
220 return err;
221}
222
223void dsa_port_disable_rt(struct dsa_port *dp)
224{
225 struct dsa_switch *ds = dp->ds;
226 int port = dp->index;
227
228 if (dp->pl)
229 phylink_stop(dp->pl);
230
231 if (!dp->bridge)
232 dsa_port_set_state_now(dp, BR_STATE_DISABLED, false);
233
234 if (ds->ops->port_disable)
235 ds->ops->port_disable(ds, port);
236}
237
238void dsa_port_disable(struct dsa_port *dp)
239{
240 rtnl_lock();
241 dsa_port_disable_rt(dp);
242 rtnl_unlock();
243}
244
245static void dsa_port_reset_vlan_filtering(struct dsa_port *dp,
246 struct dsa_bridge bridge)
247{
248 struct netlink_ext_ack extack = {0};
249 bool change_vlan_filtering = false;
250 struct dsa_switch *ds = dp->ds;
251 struct dsa_port *other_dp;
252 bool vlan_filtering;
253 int err;
254
255 if (ds->needs_standalone_vlan_filtering &&
256 !br_vlan_enabled(bridge.dev)) {
257 change_vlan_filtering = true;
258 vlan_filtering = true;
259 } else if (!ds->needs_standalone_vlan_filtering &&
260 br_vlan_enabled(bridge.dev)) {
261 change_vlan_filtering = true;
262 vlan_filtering = false;
263 }
264
265
266
267
268
269
270
271
272
273 if (change_vlan_filtering && ds->vlan_filtering_is_global) {
274 dsa_switch_for_each_port(other_dp, ds) {
275 struct net_device *br = dsa_port_bridge_dev_get(other_dp);
276
277 if (br && br_vlan_enabled(br)) {
278 change_vlan_filtering = false;
279 break;
280 }
281 }
282 }
283
284 if (!change_vlan_filtering)
285 return;
286
287 err = dsa_port_vlan_filtering(dp, vlan_filtering, &extack);
288 if (extack._msg) {
289 dev_err(ds->dev, "port %d: %s\n", dp->index,
290 extack._msg);
291 }
292 if (err && err != -EOPNOTSUPP) {
293 dev_err(ds->dev,
294 "port %d failed to reset VLAN filtering to %d: %pe\n",
295 dp->index, vlan_filtering, ERR_PTR(err));
296 }
297}
298
299static int dsa_port_inherit_brport_flags(struct dsa_port *dp,
300 struct netlink_ext_ack *extack)
301{
302 const unsigned long mask = BR_LEARNING | BR_FLOOD | BR_MCAST_FLOOD |
303 BR_BCAST_FLOOD | BR_PORT_LOCKED;
304 struct net_device *brport_dev = dsa_port_to_bridge_port(dp);
305 int flag, err;
306
307 for_each_set_bit(flag, &mask, 32) {
308 struct switchdev_brport_flags flags = {0};
309
310 flags.mask = BIT(flag);
311
312 if (br_port_flag_is_set(brport_dev, BIT(flag)))
313 flags.val = BIT(flag);
314
315 err = dsa_port_bridge_flags(dp, flags, extack);
316 if (err && err != -EOPNOTSUPP)
317 return err;
318 }
319
320 return 0;
321}
322
323static void dsa_port_clear_brport_flags(struct dsa_port *dp)
324{
325 const unsigned long val = BR_FLOOD | BR_MCAST_FLOOD | BR_BCAST_FLOOD;
326 const unsigned long mask = BR_LEARNING | BR_FLOOD | BR_MCAST_FLOOD |
327 BR_BCAST_FLOOD | BR_PORT_LOCKED;
328 int flag, err;
329
330 for_each_set_bit(flag, &mask, 32) {
331 struct switchdev_brport_flags flags = {0};
332
333 flags.mask = BIT(flag);
334 flags.val = val & BIT(flag);
335
336 err = dsa_port_bridge_flags(dp, flags, NULL);
337 if (err && err != -EOPNOTSUPP)
338 dev_err(dp->ds->dev,
339 "failed to clear bridge port flag %lu: %pe\n",
340 flags.val, ERR_PTR(err));
341 }
342}
343
344static int dsa_port_switchdev_sync_attrs(struct dsa_port *dp,
345 struct netlink_ext_ack *extack)
346{
347 struct net_device *brport_dev = dsa_port_to_bridge_port(dp);
348 struct net_device *br = dsa_port_bridge_dev_get(dp);
349 int err;
350
351 err = dsa_port_inherit_brport_flags(dp, extack);
352 if (err)
353 return err;
354
355 err = dsa_port_set_state(dp, br_port_get_stp_state(brport_dev), false);
356 if (err && err != -EOPNOTSUPP)
357 return err;
358
359 err = dsa_port_vlan_filtering(dp, br_vlan_enabled(br), extack);
360 if (err && err != -EOPNOTSUPP)
361 return err;
362
363 err = dsa_port_ageing_time(dp, br_get_ageing_time(br));
364 if (err && err != -EOPNOTSUPP)
365 return err;
366
367 return 0;
368}
369
370static void dsa_port_switchdev_unsync_attrs(struct dsa_port *dp,
371 struct dsa_bridge bridge)
372{
373
374
375
376
377
378
379
380
381
382
383
384 dsa_port_clear_brport_flags(dp);
385
386
387
388
389 dsa_port_set_state_now(dp, BR_STATE_FORWARDING, true);
390
391 dsa_port_reset_vlan_filtering(dp, bridge);
392
393
394
395
396}
397
398static int dsa_port_bridge_create(struct dsa_port *dp,
399 struct net_device *br,
400 struct netlink_ext_ack *extack)
401{
402 struct dsa_switch *ds = dp->ds;
403 struct dsa_bridge *bridge;
404
405 bridge = dsa_tree_bridge_find(ds->dst, br);
406 if (bridge) {
407 refcount_inc(&bridge->refcount);
408 dp->bridge = bridge;
409 return 0;
410 }
411
412 bridge = kzalloc(sizeof(*bridge), GFP_KERNEL);
413 if (!bridge)
414 return -ENOMEM;
415
416 refcount_set(&bridge->refcount, 1);
417
418 bridge->dev = br;
419
420 bridge->num = dsa_bridge_num_get(br, ds->max_num_bridges);
421 if (ds->max_num_bridges && !bridge->num) {
422 NL_SET_ERR_MSG_MOD(extack,
423 "Range of offloadable bridges exceeded");
424 kfree(bridge);
425 return -EOPNOTSUPP;
426 }
427
428 dp->bridge = bridge;
429
430 return 0;
431}
432
433static void dsa_port_bridge_destroy(struct dsa_port *dp,
434 const struct net_device *br)
435{
436 struct dsa_bridge *bridge = dp->bridge;
437
438 dp->bridge = NULL;
439
440 if (!refcount_dec_and_test(&bridge->refcount))
441 return;
442
443 if (bridge->num)
444 dsa_bridge_num_put(br, bridge->num);
445
446 kfree(bridge);
447}
448
449static bool dsa_port_supports_mst(struct dsa_port *dp)
450{
451 struct dsa_switch *ds = dp->ds;
452
453 return ds->ops->vlan_msti_set &&
454 ds->ops->port_mst_state_set &&
455 ds->ops->port_vlan_fast_age &&
456 dsa_port_can_configure_learning(dp);
457}
458
459int dsa_port_bridge_join(struct dsa_port *dp, struct net_device *br,
460 struct netlink_ext_ack *extack)
461{
462 struct dsa_notifier_bridge_info info = {
463 .dp = dp,
464 .extack = extack,
465 };
466 struct net_device *dev = dp->slave;
467 struct net_device *brport_dev;
468 int err;
469
470 if (br_mst_enabled(br) && !dsa_port_supports_mst(dp))
471 return -EOPNOTSUPP;
472
473
474
475
476 err = dsa_port_bridge_create(dp, br, extack);
477 if (err)
478 return err;
479
480 brport_dev = dsa_port_to_bridge_port(dp);
481
482 info.bridge = *dp->bridge;
483 err = dsa_broadcast(DSA_NOTIFIER_BRIDGE_JOIN, &info);
484 if (err)
485 goto out_rollback;
486
487
488 dp->bridge->tx_fwd_offload = info.tx_fwd_offload;
489
490 err = switchdev_bridge_port_offload(brport_dev, dev, dp,
491 &dsa_slave_switchdev_notifier,
492 &dsa_slave_switchdev_blocking_notifier,
493 dp->bridge->tx_fwd_offload, extack);
494 if (err)
495 goto out_rollback_unbridge;
496
497 err = dsa_port_switchdev_sync_attrs(dp, extack);
498 if (err)
499 goto out_rollback_unoffload;
500
501 return 0;
502
503out_rollback_unoffload:
504 switchdev_bridge_port_unoffload(brport_dev, dp,
505 &dsa_slave_switchdev_notifier,
506 &dsa_slave_switchdev_blocking_notifier);
507 dsa_flush_workqueue();
508out_rollback_unbridge:
509 dsa_broadcast(DSA_NOTIFIER_BRIDGE_LEAVE, &info);
510out_rollback:
511 dsa_port_bridge_destroy(dp, br);
512 return err;
513}
514
515void dsa_port_pre_bridge_leave(struct dsa_port *dp, struct net_device *br)
516{
517 struct net_device *brport_dev = dsa_port_to_bridge_port(dp);
518
519
520 if (!brport_dev)
521 return;
522
523 switchdev_bridge_port_unoffload(brport_dev, dp,
524 &dsa_slave_switchdev_notifier,
525 &dsa_slave_switchdev_blocking_notifier);
526
527 dsa_flush_workqueue();
528}
529
530void dsa_port_bridge_leave(struct dsa_port *dp, struct net_device *br)
531{
532 struct dsa_notifier_bridge_info info = {
533 .dp = dp,
534 };
535 int err;
536
537
538
539
540 if (!dp->bridge)
541 return;
542
543 info.bridge = *dp->bridge;
544
545
546
547
548 dsa_port_bridge_destroy(dp, br);
549
550 err = dsa_broadcast(DSA_NOTIFIER_BRIDGE_LEAVE, &info);
551 if (err)
552 dev_err(dp->ds->dev,
553 "port %d failed to notify DSA_NOTIFIER_BRIDGE_LEAVE: %pe\n",
554 dp->index, ERR_PTR(err));
555
556 dsa_port_switchdev_unsync_attrs(dp, info.bridge);
557}
558
559int dsa_port_lag_change(struct dsa_port *dp,
560 struct netdev_lag_lower_state_info *linfo)
561{
562 struct dsa_notifier_lag_info info = {
563 .dp = dp,
564 };
565 bool tx_enabled;
566
567 if (!dp->lag)
568 return 0;
569
570
571
572
573
574
575 tx_enabled = linfo->link_up && linfo->tx_enabled;
576
577 if (tx_enabled == dp->lag_tx_enabled)
578 return 0;
579
580 dp->lag_tx_enabled = tx_enabled;
581
582 return dsa_port_notify(dp, DSA_NOTIFIER_LAG_CHANGE, &info);
583}
584
585static int dsa_port_lag_create(struct dsa_port *dp,
586 struct net_device *lag_dev)
587{
588 struct dsa_switch *ds = dp->ds;
589 struct dsa_lag *lag;
590
591 lag = dsa_tree_lag_find(ds->dst, lag_dev);
592 if (lag) {
593 refcount_inc(&lag->refcount);
594 dp->lag = lag;
595 return 0;
596 }
597
598 lag = kzalloc(sizeof(*lag), GFP_KERNEL);
599 if (!lag)
600 return -ENOMEM;
601
602 refcount_set(&lag->refcount, 1);
603 mutex_init(&lag->fdb_lock);
604 INIT_LIST_HEAD(&lag->fdbs);
605 lag->dev = lag_dev;
606 dsa_lag_map(ds->dst, lag);
607 dp->lag = lag;
608
609 return 0;
610}
611
612static void dsa_port_lag_destroy(struct dsa_port *dp)
613{
614 struct dsa_lag *lag = dp->lag;
615
616 dp->lag = NULL;
617 dp->lag_tx_enabled = false;
618
619 if (!refcount_dec_and_test(&lag->refcount))
620 return;
621
622 WARN_ON(!list_empty(&lag->fdbs));
623 dsa_lag_unmap(dp->ds->dst, lag);
624 kfree(lag);
625}
626
627int dsa_port_lag_join(struct dsa_port *dp, struct net_device *lag_dev,
628 struct netdev_lag_upper_info *uinfo,
629 struct netlink_ext_ack *extack)
630{
631 struct dsa_notifier_lag_info info = {
632 .dp = dp,
633 .info = uinfo,
634 };
635 struct net_device *bridge_dev;
636 int err;
637
638 err = dsa_port_lag_create(dp, lag_dev);
639 if (err)
640 goto err_lag_create;
641
642 info.lag = *dp->lag;
643 err = dsa_port_notify(dp, DSA_NOTIFIER_LAG_JOIN, &info);
644 if (err)
645 goto err_lag_join;
646
647 bridge_dev = netdev_master_upper_dev_get(lag_dev);
648 if (!bridge_dev || !netif_is_bridge_master(bridge_dev))
649 return 0;
650
651 err = dsa_port_bridge_join(dp, bridge_dev, extack);
652 if (err)
653 goto err_bridge_join;
654
655 return 0;
656
657err_bridge_join:
658 dsa_port_notify(dp, DSA_NOTIFIER_LAG_LEAVE, &info);
659err_lag_join:
660 dsa_port_lag_destroy(dp);
661err_lag_create:
662 return err;
663}
664
665void dsa_port_pre_lag_leave(struct dsa_port *dp, struct net_device *lag_dev)
666{
667 struct net_device *br = dsa_port_bridge_dev_get(dp);
668
669 if (br)
670 dsa_port_pre_bridge_leave(dp, br);
671}
672
673void dsa_port_lag_leave(struct dsa_port *dp, struct net_device *lag_dev)
674{
675 struct net_device *br = dsa_port_bridge_dev_get(dp);
676 struct dsa_notifier_lag_info info = {
677 .dp = dp,
678 };
679 int err;
680
681 if (!dp->lag)
682 return;
683
684
685
686
687 if (br)
688 dsa_port_bridge_leave(dp, br);
689
690 info.lag = *dp->lag;
691
692 dsa_port_lag_destroy(dp);
693
694 err = dsa_port_notify(dp, DSA_NOTIFIER_LAG_LEAVE, &info);
695 if (err)
696 dev_err(dp->ds->dev,
697 "port %d failed to notify DSA_NOTIFIER_LAG_LEAVE: %pe\n",
698 dp->index, ERR_PTR(err));
699}
700
701
702static bool dsa_port_can_apply_vlan_filtering(struct dsa_port *dp,
703 bool vlan_filtering,
704 struct netlink_ext_ack *extack)
705{
706 struct dsa_switch *ds = dp->ds;
707 struct dsa_port *other_dp;
708 int err;
709
710
711
712
713
714
715 if (vlan_filtering && dsa_port_is_user(dp)) {
716 struct net_device *br = dsa_port_bridge_dev_get(dp);
717 struct net_device *upper_dev, *slave = dp->slave;
718 struct list_head *iter;
719
720 netdev_for_each_upper_dev_rcu(slave, upper_dev, iter) {
721 struct bridge_vlan_info br_info;
722 u16 vid;
723
724 if (!is_vlan_dev(upper_dev))
725 continue;
726
727 vid = vlan_dev_vlan_id(upper_dev);
728
729
730
731
732
733 err = br_vlan_get_info(br, vid, &br_info);
734 if (err == 0) {
735 NL_SET_ERR_MSG_MOD(extack,
736 "Must first remove VLAN uppers having VIDs also present in bridge");
737 return false;
738 }
739 }
740 }
741
742 if (!ds->vlan_filtering_is_global)
743 return true;
744
745
746
747
748
749
750 dsa_switch_for_each_port(other_dp, ds) {
751 struct net_device *other_br = dsa_port_bridge_dev_get(other_dp);
752
753
754
755
756 if (!other_br || other_br == dsa_port_bridge_dev_get(dp))
757 continue;
758
759 if (br_vlan_enabled(other_br) != vlan_filtering) {
760 NL_SET_ERR_MSG_MOD(extack,
761 "VLAN filtering is a global setting");
762 return false;
763 }
764 }
765 return true;
766}
767
768int dsa_port_vlan_filtering(struct dsa_port *dp, bool vlan_filtering,
769 struct netlink_ext_ack *extack)
770{
771 bool old_vlan_filtering = dsa_port_is_vlan_filtering(dp);
772 struct dsa_switch *ds = dp->ds;
773 bool apply;
774 int err;
775
776 if (!ds->ops->port_vlan_filtering)
777 return -EOPNOTSUPP;
778
779
780
781
782
783 rcu_read_lock();
784 apply = dsa_port_can_apply_vlan_filtering(dp, vlan_filtering, extack);
785 rcu_read_unlock();
786 if (!apply)
787 return -EINVAL;
788
789 if (dsa_port_is_vlan_filtering(dp) == vlan_filtering)
790 return 0;
791
792 err = ds->ops->port_vlan_filtering(ds, dp->index, vlan_filtering,
793 extack);
794 if (err)
795 return err;
796
797 if (ds->vlan_filtering_is_global) {
798 struct dsa_port *other_dp;
799
800 ds->vlan_filtering = vlan_filtering;
801
802 dsa_switch_for_each_user_port(other_dp, ds) {
803 struct net_device *slave = other_dp->slave;
804
805
806
807
808 if (!slave)
809 continue;
810
811 err = dsa_slave_manage_vlan_filtering(slave,
812 vlan_filtering);
813 if (err)
814 goto restore;
815 }
816 } else {
817 dp->vlan_filtering = vlan_filtering;
818
819 err = dsa_slave_manage_vlan_filtering(dp->slave,
820 vlan_filtering);
821 if (err)
822 goto restore;
823 }
824
825 return 0;
826
827restore:
828 ds->ops->port_vlan_filtering(ds, dp->index, old_vlan_filtering, NULL);
829
830 if (ds->vlan_filtering_is_global)
831 ds->vlan_filtering = old_vlan_filtering;
832 else
833 dp->vlan_filtering = old_vlan_filtering;
834
835 return err;
836}
837
838
839
840
841bool dsa_port_skip_vlan_configuration(struct dsa_port *dp)
842{
843 struct net_device *br = dsa_port_bridge_dev_get(dp);
844 struct dsa_switch *ds = dp->ds;
845
846 if (!br)
847 return false;
848
849 return !ds->configure_vlan_while_not_filtering && !br_vlan_enabled(br);
850}
851
852int dsa_port_ageing_time(struct dsa_port *dp, clock_t ageing_clock)
853{
854 unsigned long ageing_jiffies = clock_t_to_jiffies(ageing_clock);
855 unsigned int ageing_time = jiffies_to_msecs(ageing_jiffies);
856 struct dsa_notifier_ageing_time_info info;
857 int err;
858
859 info.ageing_time = ageing_time;
860
861 err = dsa_port_notify(dp, DSA_NOTIFIER_AGEING_TIME, &info);
862 if (err)
863 return err;
864
865 dp->ageing_time = ageing_time;
866
867 return 0;
868}
869
870int dsa_port_mst_enable(struct dsa_port *dp, bool on,
871 struct netlink_ext_ack *extack)
872{
873 if (on && !dsa_port_supports_mst(dp)) {
874 NL_SET_ERR_MSG_MOD(extack, "Hardware does not support MST");
875 return -EINVAL;
876 }
877
878 return 0;
879}
880
881int dsa_port_pre_bridge_flags(const struct dsa_port *dp,
882 struct switchdev_brport_flags flags,
883 struct netlink_ext_ack *extack)
884{
885 struct dsa_switch *ds = dp->ds;
886
887 if (!ds->ops->port_pre_bridge_flags)
888 return -EINVAL;
889
890 return ds->ops->port_pre_bridge_flags(ds, dp->index, flags, extack);
891}
892
893int dsa_port_bridge_flags(struct dsa_port *dp,
894 struct switchdev_brport_flags flags,
895 struct netlink_ext_ack *extack)
896{
897 struct dsa_switch *ds = dp->ds;
898 int err;
899
900 if (!ds->ops->port_bridge_flags)
901 return -EOPNOTSUPP;
902
903 err = ds->ops->port_bridge_flags(ds, dp->index, flags, extack);
904 if (err)
905 return err;
906
907 if (flags.mask & BR_LEARNING) {
908 bool learning = flags.val & BR_LEARNING;
909
910 if (learning == dp->learning)
911 return 0;
912
913 if ((dp->learning && !learning) &&
914 (dp->stp_state == BR_STATE_LEARNING ||
915 dp->stp_state == BR_STATE_FORWARDING))
916 dsa_port_fast_age(dp);
917
918 dp->learning = learning;
919 }
920
921 return 0;
922}
923
924void dsa_port_set_host_flood(struct dsa_port *dp, bool uc, bool mc)
925{
926 struct dsa_switch *ds = dp->ds;
927
928 if (ds->ops->port_set_host_flood)
929 ds->ops->port_set_host_flood(ds, dp->index, uc, mc);
930}
931
932int dsa_port_vlan_msti(struct dsa_port *dp,
933 const struct switchdev_vlan_msti *msti)
934{
935 struct dsa_switch *ds = dp->ds;
936
937 if (!ds->ops->vlan_msti_set)
938 return -EOPNOTSUPP;
939
940 return ds->ops->vlan_msti_set(ds, *dp->bridge, msti);
941}
942
943int dsa_port_mtu_change(struct dsa_port *dp, int new_mtu)
944{
945 struct dsa_notifier_mtu_info info = {
946 .dp = dp,
947 .mtu = new_mtu,
948 };
949
950 return dsa_port_notify(dp, DSA_NOTIFIER_MTU, &info);
951}
952
953int dsa_port_fdb_add(struct dsa_port *dp, const unsigned char *addr,
954 u16 vid)
955{
956 struct dsa_notifier_fdb_info info = {
957 .dp = dp,
958 .addr = addr,
959 .vid = vid,
960 .db = {
961 .type = DSA_DB_BRIDGE,
962 .bridge = *dp->bridge,
963 },
964 };
965
966
967
968
969
970 if (!dp->ds->fdb_isolation)
971 info.db.bridge.num = 0;
972
973 return dsa_port_notify(dp, DSA_NOTIFIER_FDB_ADD, &info);
974}
975
976int dsa_port_fdb_del(struct dsa_port *dp, const unsigned char *addr,
977 u16 vid)
978{
979 struct dsa_notifier_fdb_info info = {
980 .dp = dp,
981 .addr = addr,
982 .vid = vid,
983 .db = {
984 .type = DSA_DB_BRIDGE,
985 .bridge = *dp->bridge,
986 },
987 };
988
989 if (!dp->ds->fdb_isolation)
990 info.db.bridge.num = 0;
991
992 return dsa_port_notify(dp, DSA_NOTIFIER_FDB_DEL, &info);
993}
994
995static int dsa_port_host_fdb_add(struct dsa_port *dp,
996 const unsigned char *addr, u16 vid,
997 struct dsa_db db)
998{
999 struct dsa_notifier_fdb_info info = {
1000 .dp = dp,
1001 .addr = addr,
1002 .vid = vid,
1003 .db = db,
1004 };
1005
1006 if (!dp->ds->fdb_isolation)
1007 info.db.bridge.num = 0;
1008
1009 return dsa_port_notify(dp, DSA_NOTIFIER_HOST_FDB_ADD, &info);
1010}
1011
1012int dsa_port_standalone_host_fdb_add(struct dsa_port *dp,
1013 const unsigned char *addr, u16 vid)
1014{
1015 struct dsa_db db = {
1016 .type = DSA_DB_PORT,
1017 .dp = dp,
1018 };
1019
1020 return dsa_port_host_fdb_add(dp, addr, vid, db);
1021}
1022
1023int dsa_port_bridge_host_fdb_add(struct dsa_port *dp,
1024 const unsigned char *addr, u16 vid)
1025{
1026 struct dsa_port *cpu_dp = dp->cpu_dp;
1027 struct dsa_db db = {
1028 .type = DSA_DB_BRIDGE,
1029 .bridge = *dp->bridge,
1030 };
1031 int err;
1032
1033
1034
1035
1036
1037 if (cpu_dp->master->priv_flags & IFF_UNICAST_FLT) {
1038 err = dev_uc_add(cpu_dp->master, addr);
1039 if (err)
1040 return err;
1041 }
1042
1043 return dsa_port_host_fdb_add(dp, addr, vid, db);
1044}
1045
1046static int dsa_port_host_fdb_del(struct dsa_port *dp,
1047 const unsigned char *addr, u16 vid,
1048 struct dsa_db db)
1049{
1050 struct dsa_notifier_fdb_info info = {
1051 .dp = dp,
1052 .addr = addr,
1053 .vid = vid,
1054 .db = db,
1055 };
1056
1057 if (!dp->ds->fdb_isolation)
1058 info.db.bridge.num = 0;
1059
1060 return dsa_port_notify(dp, DSA_NOTIFIER_HOST_FDB_DEL, &info);
1061}
1062
1063int dsa_port_standalone_host_fdb_del(struct dsa_port *dp,
1064 const unsigned char *addr, u16 vid)
1065{
1066 struct dsa_db db = {
1067 .type = DSA_DB_PORT,
1068 .dp = dp,
1069 };
1070
1071 return dsa_port_host_fdb_del(dp, addr, vid, db);
1072}
1073
1074int dsa_port_bridge_host_fdb_del(struct dsa_port *dp,
1075 const unsigned char *addr, u16 vid)
1076{
1077 struct dsa_port *cpu_dp = dp->cpu_dp;
1078 struct dsa_db db = {
1079 .type = DSA_DB_BRIDGE,
1080 .bridge = *dp->bridge,
1081 };
1082 int err;
1083
1084 if (cpu_dp->master->priv_flags & IFF_UNICAST_FLT) {
1085 err = dev_uc_del(cpu_dp->master, addr);
1086 if (err)
1087 return err;
1088 }
1089
1090 return dsa_port_host_fdb_del(dp, addr, vid, db);
1091}
1092
1093int dsa_port_lag_fdb_add(struct dsa_port *dp, const unsigned char *addr,
1094 u16 vid)
1095{
1096 struct dsa_notifier_lag_fdb_info info = {
1097 .lag = dp->lag,
1098 .addr = addr,
1099 .vid = vid,
1100 .db = {
1101 .type = DSA_DB_BRIDGE,
1102 .bridge = *dp->bridge,
1103 },
1104 };
1105
1106 if (!dp->ds->fdb_isolation)
1107 info.db.bridge.num = 0;
1108
1109 return dsa_port_notify(dp, DSA_NOTIFIER_LAG_FDB_ADD, &info);
1110}
1111
1112int dsa_port_lag_fdb_del(struct dsa_port *dp, const unsigned char *addr,
1113 u16 vid)
1114{
1115 struct dsa_notifier_lag_fdb_info info = {
1116 .lag = dp->lag,
1117 .addr = addr,
1118 .vid = vid,
1119 .db = {
1120 .type = DSA_DB_BRIDGE,
1121 .bridge = *dp->bridge,
1122 },
1123 };
1124
1125 if (!dp->ds->fdb_isolation)
1126 info.db.bridge.num = 0;
1127
1128 return dsa_port_notify(dp, DSA_NOTIFIER_LAG_FDB_DEL, &info);
1129}
1130
1131int dsa_port_fdb_dump(struct dsa_port *dp, dsa_fdb_dump_cb_t *cb, void *data)
1132{
1133 struct dsa_switch *ds = dp->ds;
1134 int port = dp->index;
1135
1136 if (!ds->ops->port_fdb_dump)
1137 return -EOPNOTSUPP;
1138
1139 return ds->ops->port_fdb_dump(ds, port, cb, data);
1140}
1141
1142int dsa_port_mdb_add(const struct dsa_port *dp,
1143 const struct switchdev_obj_port_mdb *mdb)
1144{
1145 struct dsa_notifier_mdb_info info = {
1146 .dp = dp,
1147 .mdb = mdb,
1148 .db = {
1149 .type = DSA_DB_BRIDGE,
1150 .bridge = *dp->bridge,
1151 },
1152 };
1153
1154 if (!dp->ds->fdb_isolation)
1155 info.db.bridge.num = 0;
1156
1157 return dsa_port_notify(dp, DSA_NOTIFIER_MDB_ADD, &info);
1158}
1159
1160int dsa_port_mdb_del(const struct dsa_port *dp,
1161 const struct switchdev_obj_port_mdb *mdb)
1162{
1163 struct dsa_notifier_mdb_info info = {
1164 .dp = dp,
1165 .mdb = mdb,
1166 .db = {
1167 .type = DSA_DB_BRIDGE,
1168 .bridge = *dp->bridge,
1169 },
1170 };
1171
1172 if (!dp->ds->fdb_isolation)
1173 info.db.bridge.num = 0;
1174
1175 return dsa_port_notify(dp, DSA_NOTIFIER_MDB_DEL, &info);
1176}
1177
1178static int dsa_port_host_mdb_add(const struct dsa_port *dp,
1179 const struct switchdev_obj_port_mdb *mdb,
1180 struct dsa_db db)
1181{
1182 struct dsa_notifier_mdb_info info = {
1183 .dp = dp,
1184 .mdb = mdb,
1185 .db = db,
1186 };
1187
1188 if (!dp->ds->fdb_isolation)
1189 info.db.bridge.num = 0;
1190
1191 return dsa_port_notify(dp, DSA_NOTIFIER_HOST_MDB_ADD, &info);
1192}
1193
1194int dsa_port_standalone_host_mdb_add(const struct dsa_port *dp,
1195 const struct switchdev_obj_port_mdb *mdb)
1196{
1197 struct dsa_db db = {
1198 .type = DSA_DB_PORT,
1199 .dp = dp,
1200 };
1201
1202 return dsa_port_host_mdb_add(dp, mdb, db);
1203}
1204
1205int dsa_port_bridge_host_mdb_add(const struct dsa_port *dp,
1206 const struct switchdev_obj_port_mdb *mdb)
1207{
1208 struct dsa_port *cpu_dp = dp->cpu_dp;
1209 struct dsa_db db = {
1210 .type = DSA_DB_BRIDGE,
1211 .bridge = *dp->bridge,
1212 };
1213 int err;
1214
1215 err = dev_mc_add(cpu_dp->master, mdb->addr);
1216 if (err)
1217 return err;
1218
1219 return dsa_port_host_mdb_add(dp, mdb, db);
1220}
1221
1222static int dsa_port_host_mdb_del(const struct dsa_port *dp,
1223 const struct switchdev_obj_port_mdb *mdb,
1224 struct dsa_db db)
1225{
1226 struct dsa_notifier_mdb_info info = {
1227 .dp = dp,
1228 .mdb = mdb,
1229 .db = db,
1230 };
1231
1232 if (!dp->ds->fdb_isolation)
1233 info.db.bridge.num = 0;
1234
1235 return dsa_port_notify(dp, DSA_NOTIFIER_HOST_MDB_DEL, &info);
1236}
1237
1238int dsa_port_standalone_host_mdb_del(const struct dsa_port *dp,
1239 const struct switchdev_obj_port_mdb *mdb)
1240{
1241 struct dsa_db db = {
1242 .type = DSA_DB_PORT,
1243 .dp = dp,
1244 };
1245
1246 return dsa_port_host_mdb_del(dp, mdb, db);
1247}
1248
1249int dsa_port_bridge_host_mdb_del(const struct dsa_port *dp,
1250 const struct switchdev_obj_port_mdb *mdb)
1251{
1252 struct dsa_port *cpu_dp = dp->cpu_dp;
1253 struct dsa_db db = {
1254 .type = DSA_DB_BRIDGE,
1255 .bridge = *dp->bridge,
1256 };
1257 int err;
1258
1259 err = dev_mc_del(cpu_dp->master, mdb->addr);
1260 if (err)
1261 return err;
1262
1263 return dsa_port_host_mdb_del(dp, mdb, db);
1264}
1265
1266int dsa_port_vlan_add(struct dsa_port *dp,
1267 const struct switchdev_obj_port_vlan *vlan,
1268 struct netlink_ext_ack *extack)
1269{
1270 struct dsa_notifier_vlan_info info = {
1271 .dp = dp,
1272 .vlan = vlan,
1273 .extack = extack,
1274 };
1275
1276 return dsa_port_notify(dp, DSA_NOTIFIER_VLAN_ADD, &info);
1277}
1278
1279int dsa_port_vlan_del(struct dsa_port *dp,
1280 const struct switchdev_obj_port_vlan *vlan)
1281{
1282 struct dsa_notifier_vlan_info info = {
1283 .dp = dp,
1284 .vlan = vlan,
1285 };
1286
1287 return dsa_port_notify(dp, DSA_NOTIFIER_VLAN_DEL, &info);
1288}
1289
1290int dsa_port_host_vlan_add(struct dsa_port *dp,
1291 const struct switchdev_obj_port_vlan *vlan,
1292 struct netlink_ext_ack *extack)
1293{
1294 struct dsa_notifier_vlan_info info = {
1295 .dp = dp,
1296 .vlan = vlan,
1297 .extack = extack,
1298 };
1299 struct dsa_port *cpu_dp = dp->cpu_dp;
1300 int err;
1301
1302 err = dsa_port_notify(dp, DSA_NOTIFIER_HOST_VLAN_ADD, &info);
1303 if (err && err != -EOPNOTSUPP)
1304 return err;
1305
1306 vlan_vid_add(cpu_dp->master, htons(ETH_P_8021Q), vlan->vid);
1307
1308 return err;
1309}
1310
1311int dsa_port_host_vlan_del(struct dsa_port *dp,
1312 const struct switchdev_obj_port_vlan *vlan)
1313{
1314 struct dsa_notifier_vlan_info info = {
1315 .dp = dp,
1316 .vlan = vlan,
1317 };
1318 struct dsa_port *cpu_dp = dp->cpu_dp;
1319 int err;
1320
1321 err = dsa_port_notify(dp, DSA_NOTIFIER_HOST_VLAN_DEL, &info);
1322 if (err && err != -EOPNOTSUPP)
1323 return err;
1324
1325 vlan_vid_del(cpu_dp->master, htons(ETH_P_8021Q), vlan->vid);
1326
1327 return err;
1328}
1329
1330int dsa_port_mrp_add(const struct dsa_port *dp,
1331 const struct switchdev_obj_mrp *mrp)
1332{
1333 struct dsa_switch *ds = dp->ds;
1334
1335 if (!ds->ops->port_mrp_add)
1336 return -EOPNOTSUPP;
1337
1338 return ds->ops->port_mrp_add(ds, dp->index, mrp);
1339}
1340
1341int dsa_port_mrp_del(const struct dsa_port *dp,
1342 const struct switchdev_obj_mrp *mrp)
1343{
1344 struct dsa_switch *ds = dp->ds;
1345
1346 if (!ds->ops->port_mrp_del)
1347 return -EOPNOTSUPP;
1348
1349 return ds->ops->port_mrp_del(ds, dp->index, mrp);
1350}
1351
1352int dsa_port_mrp_add_ring_role(const struct dsa_port *dp,
1353 const struct switchdev_obj_ring_role_mrp *mrp)
1354{
1355 struct dsa_switch *ds = dp->ds;
1356
1357 if (!ds->ops->port_mrp_add_ring_role)
1358 return -EOPNOTSUPP;
1359
1360 return ds->ops->port_mrp_add_ring_role(ds, dp->index, mrp);
1361}
1362
1363int dsa_port_mrp_del_ring_role(const struct dsa_port *dp,
1364 const struct switchdev_obj_ring_role_mrp *mrp)
1365{
1366 struct dsa_switch *ds = dp->ds;
1367
1368 if (!ds->ops->port_mrp_del_ring_role)
1369 return -EOPNOTSUPP;
1370
1371 return ds->ops->port_mrp_del_ring_role(ds, dp->index, mrp);
1372}
1373
1374void dsa_port_set_tag_protocol(struct dsa_port *cpu_dp,
1375 const struct dsa_device_ops *tag_ops)
1376{
1377 cpu_dp->rcv = tag_ops->rcv;
1378 cpu_dp->tag_ops = tag_ops;
1379}
1380
1381static struct phy_device *dsa_port_get_phy_device(struct dsa_port *dp)
1382{
1383 struct device_node *phy_dn;
1384 struct phy_device *phydev;
1385
1386 phy_dn = of_parse_phandle(dp->dn, "phy-handle", 0);
1387 if (!phy_dn)
1388 return NULL;
1389
1390 phydev = of_phy_find_device(phy_dn);
1391 if (!phydev) {
1392 of_node_put(phy_dn);
1393 return ERR_PTR(-EPROBE_DEFER);
1394 }
1395
1396 of_node_put(phy_dn);
1397 return phydev;
1398}
1399
1400static void dsa_port_phylink_validate(struct phylink_config *config,
1401 unsigned long *supported,
1402 struct phylink_link_state *state)
1403{
1404 struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
1405 struct dsa_switch *ds = dp->ds;
1406
1407 if (!ds->ops->phylink_validate) {
1408 if (config->mac_capabilities)
1409 phylink_generic_validate(config, supported, state);
1410 return;
1411 }
1412
1413 ds->ops->phylink_validate(ds, dp->index, supported, state);
1414}
1415
1416static void dsa_port_phylink_mac_pcs_get_state(struct phylink_config *config,
1417 struct phylink_link_state *state)
1418{
1419 struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
1420 struct dsa_switch *ds = dp->ds;
1421 int err;
1422
1423
1424 if (!ds->ops->phylink_mac_link_state) {
1425 state->link = 0;
1426 return;
1427 }
1428
1429 err = ds->ops->phylink_mac_link_state(ds, dp->index, state);
1430 if (err < 0) {
1431 dev_err(ds->dev, "p%d: phylink_mac_link_state() failed: %d\n",
1432 dp->index, err);
1433 state->link = 0;
1434 }
1435}
1436
1437static struct phylink_pcs *
1438dsa_port_phylink_mac_select_pcs(struct phylink_config *config,
1439 phy_interface_t interface)
1440{
1441 struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
1442 struct phylink_pcs *pcs = ERR_PTR(-EOPNOTSUPP);
1443 struct dsa_switch *ds = dp->ds;
1444
1445 if (ds->ops->phylink_mac_select_pcs)
1446 pcs = ds->ops->phylink_mac_select_pcs(ds, dp->index, interface);
1447
1448 return pcs;
1449}
1450
1451static void dsa_port_phylink_mac_config(struct phylink_config *config,
1452 unsigned int mode,
1453 const struct phylink_link_state *state)
1454{
1455 struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
1456 struct dsa_switch *ds = dp->ds;
1457
1458 if (!ds->ops->phylink_mac_config)
1459 return;
1460
1461 ds->ops->phylink_mac_config(ds, dp->index, mode, state);
1462}
1463
1464static void dsa_port_phylink_mac_an_restart(struct phylink_config *config)
1465{
1466 struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
1467 struct dsa_switch *ds = dp->ds;
1468
1469 if (!ds->ops->phylink_mac_an_restart)
1470 return;
1471
1472 ds->ops->phylink_mac_an_restart(ds, dp->index);
1473}
1474
1475static void dsa_port_phylink_mac_link_down(struct phylink_config *config,
1476 unsigned int mode,
1477 phy_interface_t interface)
1478{
1479 struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
1480 struct phy_device *phydev = NULL;
1481 struct dsa_switch *ds = dp->ds;
1482
1483 if (dsa_port_is_user(dp))
1484 phydev = dp->slave->phydev;
1485
1486 if (!ds->ops->phylink_mac_link_down) {
1487 if (ds->ops->adjust_link && phydev)
1488 ds->ops->adjust_link(ds, dp->index, phydev);
1489 return;
1490 }
1491
1492 ds->ops->phylink_mac_link_down(ds, dp->index, mode, interface);
1493}
1494
1495static void dsa_port_phylink_mac_link_up(struct phylink_config *config,
1496 struct phy_device *phydev,
1497 unsigned int mode,
1498 phy_interface_t interface,
1499 int speed, int duplex,
1500 bool tx_pause, bool rx_pause)
1501{
1502 struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
1503 struct dsa_switch *ds = dp->ds;
1504
1505 if (!ds->ops->phylink_mac_link_up) {
1506 if (ds->ops->adjust_link && phydev)
1507 ds->ops->adjust_link(ds, dp->index, phydev);
1508 return;
1509 }
1510
1511 ds->ops->phylink_mac_link_up(ds, dp->index, mode, interface, phydev,
1512 speed, duplex, tx_pause, rx_pause);
1513}
1514
1515static const struct phylink_mac_ops dsa_port_phylink_mac_ops = {
1516 .validate = dsa_port_phylink_validate,
1517 .mac_select_pcs = dsa_port_phylink_mac_select_pcs,
1518 .mac_pcs_get_state = dsa_port_phylink_mac_pcs_get_state,
1519 .mac_config = dsa_port_phylink_mac_config,
1520 .mac_an_restart = dsa_port_phylink_mac_an_restart,
1521 .mac_link_down = dsa_port_phylink_mac_link_down,
1522 .mac_link_up = dsa_port_phylink_mac_link_up,
1523};
1524
1525int dsa_port_phylink_create(struct dsa_port *dp)
1526{
1527 struct dsa_switch *ds = dp->ds;
1528 phy_interface_t mode;
1529 int err;
1530
1531 err = of_get_phy_mode(dp->dn, &mode);
1532 if (err)
1533 mode = PHY_INTERFACE_MODE_NA;
1534
1535
1536
1537
1538 if (ds->ops->phylink_mac_link_state ||
1539 ds->ops->phylink_mac_an_restart)
1540 dp->pl_config.legacy_pre_march2020 = true;
1541
1542 if (ds->ops->phylink_get_caps)
1543 ds->ops->phylink_get_caps(ds, dp->index, &dp->pl_config);
1544
1545 dp->pl = phylink_create(&dp->pl_config, of_fwnode_handle(dp->dn),
1546 mode, &dsa_port_phylink_mac_ops);
1547 if (IS_ERR(dp->pl)) {
1548 pr_err("error creating PHYLINK: %ld\n", PTR_ERR(dp->pl));
1549 return PTR_ERR(dp->pl);
1550 }
1551
1552 return 0;
1553}
1554
1555static int dsa_port_setup_phy_of(struct dsa_port *dp, bool enable)
1556{
1557 struct dsa_switch *ds = dp->ds;
1558 struct phy_device *phydev;
1559 int port = dp->index;
1560 int err = 0;
1561
1562 phydev = dsa_port_get_phy_device(dp);
1563 if (!phydev)
1564 return 0;
1565
1566 if (IS_ERR(phydev))
1567 return PTR_ERR(phydev);
1568
1569 if (enable) {
1570 err = genphy_resume(phydev);
1571 if (err < 0)
1572 goto err_put_dev;
1573
1574 err = genphy_read_status(phydev);
1575 if (err < 0)
1576 goto err_put_dev;
1577 } else {
1578 err = genphy_suspend(phydev);
1579 if (err < 0)
1580 goto err_put_dev;
1581 }
1582
1583 if (ds->ops->adjust_link)
1584 ds->ops->adjust_link(ds, port, phydev);
1585
1586 dev_dbg(ds->dev, "enabled port's phy: %s", phydev_name(phydev));
1587
1588err_put_dev:
1589 put_device(&phydev->mdio.dev);
1590 return err;
1591}
1592
1593static int dsa_port_fixed_link_register_of(struct dsa_port *dp)
1594{
1595 struct device_node *dn = dp->dn;
1596 struct dsa_switch *ds = dp->ds;
1597 struct phy_device *phydev;
1598 int port = dp->index;
1599 phy_interface_t mode;
1600 int err;
1601
1602 err = of_phy_register_fixed_link(dn);
1603 if (err) {
1604 dev_err(ds->dev,
1605 "failed to register the fixed PHY of port %d\n",
1606 port);
1607 return err;
1608 }
1609
1610 phydev = of_phy_find_device(dn);
1611
1612 err = of_get_phy_mode(dn, &mode);
1613 if (err)
1614 mode = PHY_INTERFACE_MODE_NA;
1615 phydev->interface = mode;
1616
1617 genphy_read_status(phydev);
1618
1619 if (ds->ops->adjust_link)
1620 ds->ops->adjust_link(ds, port, phydev);
1621
1622 put_device(&phydev->mdio.dev);
1623
1624 return 0;
1625}
1626
1627static int dsa_port_phylink_register(struct dsa_port *dp)
1628{
1629 struct dsa_switch *ds = dp->ds;
1630 struct device_node *port_dn = dp->dn;
1631 int err;
1632
1633 dp->pl_config.dev = ds->dev;
1634 dp->pl_config.type = PHYLINK_DEV;
1635
1636 err = dsa_port_phylink_create(dp);
1637 if (err)
1638 return err;
1639
1640 err = phylink_of_phy_connect(dp->pl, port_dn, 0);
1641 if (err && err != -ENODEV) {
1642 pr_err("could not attach to PHY: %d\n", err);
1643 goto err_phy_connect;
1644 }
1645
1646 return 0;
1647
1648err_phy_connect:
1649 phylink_destroy(dp->pl);
1650 return err;
1651}
1652
1653int dsa_port_link_register_of(struct dsa_port *dp)
1654{
1655 struct dsa_switch *ds = dp->ds;
1656 struct device_node *phy_np;
1657 int port = dp->index;
1658
1659 if (!ds->ops->adjust_link) {
1660 phy_np = of_parse_phandle(dp->dn, "phy-handle", 0);
1661 if (of_phy_is_fixed_link(dp->dn) || phy_np) {
1662 if (ds->ops->phylink_mac_link_down)
1663 ds->ops->phylink_mac_link_down(ds, port,
1664 MLO_AN_FIXED, PHY_INTERFACE_MODE_NA);
1665 of_node_put(phy_np);
1666 return dsa_port_phylink_register(dp);
1667 }
1668 of_node_put(phy_np);
1669 return 0;
1670 }
1671
1672 dev_warn(ds->dev,
1673 "Using legacy PHYLIB callbacks. Please migrate to PHYLINK!\n");
1674
1675 if (of_phy_is_fixed_link(dp->dn))
1676 return dsa_port_fixed_link_register_of(dp);
1677 else
1678 return dsa_port_setup_phy_of(dp, true);
1679}
1680
1681void dsa_port_link_unregister_of(struct dsa_port *dp)
1682{
1683 struct dsa_switch *ds = dp->ds;
1684
1685 if (!ds->ops->adjust_link && dp->pl) {
1686 rtnl_lock();
1687 phylink_disconnect_phy(dp->pl);
1688 rtnl_unlock();
1689 phylink_destroy(dp->pl);
1690 dp->pl = NULL;
1691 return;
1692 }
1693
1694 if (of_phy_is_fixed_link(dp->dn))
1695 of_phy_deregister_fixed_link(dp->dn);
1696 else
1697 dsa_port_setup_phy_of(dp, false);
1698}
1699
1700int dsa_port_hsr_join(struct dsa_port *dp, struct net_device *hsr)
1701{
1702 struct dsa_switch *ds = dp->ds;
1703 int err;
1704
1705 if (!ds->ops->port_hsr_join)
1706 return -EOPNOTSUPP;
1707
1708 dp->hsr_dev = hsr;
1709
1710 err = ds->ops->port_hsr_join(ds, dp->index, hsr);
1711 if (err)
1712 dp->hsr_dev = NULL;
1713
1714 return err;
1715}
1716
1717void dsa_port_hsr_leave(struct dsa_port *dp, struct net_device *hsr)
1718{
1719 struct dsa_switch *ds = dp->ds;
1720 int err;
1721
1722 dp->hsr_dev = NULL;
1723
1724 if (ds->ops->port_hsr_leave) {
1725 err = ds->ops->port_hsr_leave(ds, dp->index, hsr);
1726 if (err)
1727 dev_err(dp->ds->dev,
1728 "port %d failed to leave HSR %s: %pe\n",
1729 dp->index, hsr->name, ERR_PTR(err));
1730 }
1731}
1732
1733int dsa_port_tag_8021q_vlan_add(struct dsa_port *dp, u16 vid, bool broadcast)
1734{
1735 struct dsa_notifier_tag_8021q_vlan_info info = {
1736 .dp = dp,
1737 .vid = vid,
1738 };
1739
1740 if (broadcast)
1741 return dsa_broadcast(DSA_NOTIFIER_TAG_8021Q_VLAN_ADD, &info);
1742
1743 return dsa_port_notify(dp, DSA_NOTIFIER_TAG_8021Q_VLAN_ADD, &info);
1744}
1745
1746void dsa_port_tag_8021q_vlan_del(struct dsa_port *dp, u16 vid, bool broadcast)
1747{
1748 struct dsa_notifier_tag_8021q_vlan_info info = {
1749 .dp = dp,
1750 .vid = vid,
1751 };
1752 int err;
1753
1754 if (broadcast)
1755 err = dsa_broadcast(DSA_NOTIFIER_TAG_8021Q_VLAN_DEL, &info);
1756 else
1757 err = dsa_port_notify(dp, DSA_NOTIFIER_TAG_8021Q_VLAN_DEL, &info);
1758 if (err)
1759 dev_err(dp->ds->dev,
1760 "port %d failed to notify tag_8021q VLAN %d deletion: %pe\n",
1761 dp->index, vid, ERR_PTR(err));
1762}
1763
