1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * Handling of a single switch port
4 *
5 * Copyright (c) 2017 Savoir-faire Linux Inc.
6 * Vivien Didelot <vivien.didelot@savoirfairelinux.com>
7 */
8
9 #include <linux/if_bridge.h>
10 #include <linux/netdevice.h>
11 #include <linux/notifier.h>
12 #include <linux/of_mdio.h>
13 #include <linux/of_net.h>
14
15 #include "dsa.h"
16 #include "port.h"
17 #include "switch.h"
18 #include "tag_8021q.h"
19 #include "user.h"
20
21 /**
22 * dsa_port_notify - Notify the switching fabric of changes to a port
23 * @dp: port on which change occurred
24 * @e: event, must be of type DSA_NOTIFIER_*
25 * @v: event-specific value.
26 *
27 * Notify all switches in the DSA tree that this port's switch belongs to,
28 * including this switch itself, of an event. Allows the other switches to
29 * reconfigure themselves for cross-chip operations. Can also be used to
30 * reconfigure ports without net_devices (CPU ports, DSA links) whenever
31 * a user port's state changes.
32 */
33 static int dsa_port_notify(const struct dsa_port *dp, unsigned long e, void *v)
34 {
35 return dsa_tree_notify(dp->ds->dst, e, v);
36 }
37
38 static void dsa_port_notify_bridge_fdb_flush(const struct dsa_port *dp, u16 vid)
39 {
40 struct net_device *brport_dev = dsa_port_to_bridge_port(dp);
41 struct switchdev_notifier_fdb_info info = {
42 .vid = vid,
43 };
44
45 /* When the port becomes standalone it has already left the bridge.
46 * Don't notify the bridge in that case.
47 */
48 if (!brport_dev)
49 return;
50
51 call_switchdev_notifiers(SWITCHDEV_FDB_FLUSH_TO_BRIDGE,
52 brport_dev, &info.info, NULL);
53 }
54
55 static void dsa_port_fast_age(const struct dsa_port *dp)
56 {
57 struct dsa_switch *ds = dp->ds;
58
59 if (!ds->ops->port_fast_age)
60 return;
61
62 ds->ops->port_fast_age(ds, dp->index);
63
64 /* flush all VLANs */
65 dsa_port_notify_bridge_fdb_flush(dp, 0);
66 }
67
68 static int dsa_port_vlan_fast_age(const struct dsa_port *dp, u16 vid)
69 {
70 struct dsa_switch *ds = dp->ds;
71 int err;
72
73 if (!ds->ops->port_vlan_fast_age)
74 return -EOPNOTSUPP;
75
76 err = ds->ops->port_vlan_fast_age(ds, dp->index, vid);
77
78 if (!err)
79 dsa_port_notify_bridge_fdb_flush(dp, vid);
80
81 return err;
82 }
83
84 static int dsa_port_msti_fast_age(const struct dsa_port *dp, u16 msti)
85 {
86 DECLARE_BITMAP(vids, VLAN_N_VID) = { 0 };
87 int err, vid;
88
89 err = br_mst_get_info(dsa_port_bridge_dev_get(dp), msti, vids);
90 if (err)
91 return err;
92
93 for_each_set_bit(vid, vids, VLAN_N_VID) {
94 err = dsa_port_vlan_fast_age(dp, vid);
95 if (err)
96 return err;
97 }
98
99 return 0;
100 }
101
102 static bool dsa_port_can_configure_learning(struct dsa_port *dp)
103 {
104 struct switchdev_brport_flags flags = {
105 .mask = BR_LEARNING,
106 };
107 struct dsa_switch *ds = dp->ds;
108 int err;
109
110 if (!ds->ops->port_bridge_flags || !ds->ops->port_pre_bridge_flags)
111 return false;
112
113 err = ds->ops->port_pre_bridge_flags(ds, dp->index, flags, NULL);
114 return !err;
115 }
116
117 bool dsa_port_supports_hwtstamp(struct dsa_port *dp)
118 {
119 struct dsa_switch *ds = dp->ds;
120 struct ifreq ifr = {};
121 int err;
122
123 if (!ds->ops->port_hwtstamp_get || !ds->ops->port_hwtstamp_set)
124 return false;
125
126 /* "See through" shim implementations of the "get" method.
127 * Since we can't cook up a complete ioctl request structure, this will
128 * fail in copy_to_user() with -EFAULT, which hopefully is enough to
129 * detect a valid implementation.
130 */
131 err = ds->ops->port_hwtstamp_get(ds, dp->index, &ifr);
132 return err != -EOPNOTSUPP;
133 }
134
135 int dsa_port_set_state(struct dsa_port *dp, u8 state, bool do_fast_age)
136 {
137 struct dsa_switch *ds = dp->ds;
138 int port = dp->index;
139
140 if (!ds->ops->port_stp_state_set)
141 return -EOPNOTSUPP;
142
143 ds->ops->port_stp_state_set(ds, port, state);
144
145 if (!dsa_port_can_configure_learning(dp) ||
146 (do_fast_age && dp->learning)) {
147 /* Fast age FDB entries or flush appropriate forwarding database
148 * for the given port, if we are moving it from Learning or
149 * Forwarding state, to Disabled or Blocking or Listening state.
150 * Ports that were standalone before the STP state change don't
151 * need to fast age the FDB, since address learning is off in
152 * standalone mode.
153 */
154
155 if ((dp->stp_state == BR_STATE_LEARNING ||
156 dp->stp_state == BR_STATE_FORWARDING) &&
157 (state == BR_STATE_DISABLED ||
158 state == BR_STATE_BLOCKING ||
159 state == BR_STATE_LISTENING))
160 dsa_port_fast_age(dp);
161 }
162
163 dp->stp_state = state;
164
165 return 0;
166 }
167
168 static void dsa_port_set_state_now(struct dsa_port *dp, u8 state,
169 bool do_fast_age)
170 {
171 struct dsa_switch *ds = dp->ds;
172 int err;
173
174 err = dsa_port_set_state(dp, state, do_fast_age);
175 if (err && err != -EOPNOTSUPP) {
176 dev_err(ds->dev, "port %d failed to set STP state %u: %pe\n",
177 dp->index, state, ERR_PTR(err));
178 }
179 }
180
181 int dsa_port_set_mst_state(struct dsa_port *dp,
182 const struct switchdev_mst_state *state,
183 struct netlink_ext_ack *extack)
184 {
185 struct dsa_switch *ds = dp->ds;
186 u8 prev_state;
187 int err;
188
189 if (!ds->ops->port_mst_state_set)
190 return -EOPNOTSUPP;
191
192 err = br_mst_get_state(dsa_port_to_bridge_port(dp), state->msti,
193 &prev_state);
194 if (err)
195 return err;
196
197 err = ds->ops->port_mst_state_set(ds, dp->index, state);
198 if (err)
199 return err;
200
201 if (!(dp->learning &&
202 (prev_state == BR_STATE_LEARNING ||
203 prev_state == BR_STATE_FORWARDING) &&
204 (state->state == BR_STATE_DISABLED ||
205 state->state == BR_STATE_BLOCKING ||
206 state->state == BR_STATE_LISTENING)))
207 return 0;
208
209 err = dsa_port_msti_fast_age(dp, state->msti);
210 if (err)
211 NL_SET_ERR_MSG_MOD(extack,
212 "Unable to flush associated VLANs");
213
214 return 0;
215 }
216
217 int dsa_port_enable_rt(struct dsa_port *dp, struct phy_device *phy)
218 {
219 struct dsa_switch *ds = dp->ds;
220 int port = dp->index;
221 int err;
222
223 if (ds->ops->port_enable) {
224 err = ds->ops->port_enable(ds, port, phy);
225 if (err)
226 return err;
227 }
228
229 if (!dp->bridge)
230 dsa_port_set_state_now(dp, BR_STATE_FORWARDING, false);
231
232 if (dp->pl)
233 phylink_start(dp->pl);
234
235 return 0;
236 }
237
238 int dsa_port_enable(struct dsa_port *dp, struct phy_device *phy)
239 {
240 int err;
241
242 rtnl_lock();
243 err = dsa_port_enable_rt(dp, phy);
244 rtnl_unlock();
245
246 return err;
247 }
248
249 void dsa_port_disable_rt(struct dsa_port *dp)
250 {
251 struct dsa_switch *ds = dp->ds;
252 int port = dp->index;
253
254 if (dp->pl)
255 phylink_stop(dp->pl);
256
257 if (!dp->bridge)
258 dsa_port_set_state_now(dp, BR_STATE_DISABLED, false);
259
260 if (ds->ops->port_disable)
261 ds->ops->port_disable(ds, port);
262 }
263
264 void dsa_port_disable(struct dsa_port *dp)
265 {
266 rtnl_lock();
267 dsa_port_disable_rt(dp);
268 rtnl_unlock();
269 }
270
271 static void dsa_port_reset_vlan_filtering(struct dsa_port *dp,
272 struct dsa_bridge bridge)
273 {
274 struct netlink_ext_ack extack = {0};
275 bool change_vlan_filtering = false;
276 struct dsa_switch *ds = dp->ds;
277 struct dsa_port *other_dp;
278 bool vlan_filtering;
279 int err;
280
281 if (ds->needs_standalone_vlan_filtering &&
282 !br_vlan_enabled(bridge.dev)) {
283 change_vlan_filtering = true;
284 vlan_filtering = true;
285 } else if (!ds->needs_standalone_vlan_filtering &&
286 br_vlan_enabled(bridge.dev)) {
287 change_vlan_filtering = true;
288 vlan_filtering = false;
289 }
290
291 /* If the bridge was vlan_filtering, the bridge core doesn't trigger an
292 * event for changing vlan_filtering setting upon user ports leaving
293 * it. That is a good thing, because that lets us handle it and also
294 * handle the case where the switch's vlan_filtering setting is global
295 * (not per port). When that happens, the correct moment to trigger the
296 * vlan_filtering callback is only when the last port leaves the last
297 * VLAN-aware bridge.
298 */
299 if (change_vlan_filtering && ds->vlan_filtering_is_global) {
300 dsa_switch_for_each_port(other_dp, ds) {
301 struct net_device *br = dsa_port_bridge_dev_get(other_dp);
302
303 if (br && br_vlan_enabled(br)) {
304 change_vlan_filtering = false;
305 break;
306 }
307 }
308 }
309
310 if (!change_vlan_filtering)
311 return;
312
313 err = dsa_port_vlan_filtering(dp, vlan_filtering, &extack);
314 if (extack._msg) {
315 dev_err(ds->dev, "port %d: %s\n", dp->index,
316 extack._msg);
317 }
318 if (err && err != -EOPNOTSUPP) {
319 dev_err(ds->dev,
320 "port %d failed to reset VLAN filtering to %d: %pe\n",
321 dp->index, vlan_filtering, ERR_PTR(err));
322 }
323 }
324
325 static int dsa_port_inherit_brport_flags(struct dsa_port *dp,
326 struct netlink_ext_ack *extack)
327 {
328 const unsigned long mask = BR_LEARNING | BR_FLOOD | BR_MCAST_FLOOD |
329 BR_BCAST_FLOOD | BR_PORT_LOCKED;
330 struct net_device *brport_dev = dsa_port_to_bridge_port(dp);
331 int flag, err;
332
333 for_each_set_bit(flag, &mask, 32) {
334 struct switchdev_brport_flags flags = {0};
335
336 flags.mask = BIT(flag);
337
338 if (br_port_flag_is_set(brport_dev, BIT(flag)))
339 flags.val = BIT(flag);
340
341 err = dsa_port_bridge_flags(dp, flags, extack);
342 if (err && err != -EOPNOTSUPP)
343 return err;
344 }
345
346 return 0;
347 }
348
349 static void dsa_port_clear_brport_flags(struct dsa_port *dp)
350 {
351 const unsigned long val = BR_FLOOD | BR_MCAST_FLOOD | BR_BCAST_FLOOD;
352 const unsigned long mask = BR_LEARNING | BR_FLOOD | BR_MCAST_FLOOD |
353 BR_BCAST_FLOOD | BR_PORT_LOCKED;
354 int flag, err;
355
356 for_each_set_bit(flag, &mask, 32) {
357 struct switchdev_brport_flags flags = {0};
358
359 flags.mask = BIT(flag);
360 flags.val = val & BIT(flag);
361
362 err = dsa_port_bridge_flags(dp, flags, NULL);
363 if (err && err != -EOPNOTSUPP)
364 dev_err(dp->ds->dev,
365 "failed to clear bridge port flag %lu: %pe\n",
366 flags.val, ERR_PTR(err));
367 }
368 }
369
370 static int dsa_port_switchdev_sync_attrs(struct dsa_port *dp,
371 struct netlink_ext_ack *extack)
372 {
373 struct net_device *brport_dev = dsa_port_to_bridge_port(dp);
374 struct net_device *br = dsa_port_bridge_dev_get(dp);
375 int err;
376
377 err = dsa_port_inherit_brport_flags(dp, extack);
378 if (err)
379 return err;
380
381 err = dsa_port_set_state(dp, br_port_get_stp_state(brport_dev), false);
382 if (err && err != -EOPNOTSUPP)
383 return err;
384
385 err = dsa_port_vlan_filtering(dp, br_vlan_enabled(br), extack);
386 if (err && err != -EOPNOTSUPP)
387 return err;
388
389 err = dsa_port_ageing_time(dp, br_get_ageing_time(br));
390 if (err && err != -EOPNOTSUPP)
391 return err;
392
393 return 0;
394 }
395
396 static void dsa_port_switchdev_unsync_attrs(struct dsa_port *dp,
397 struct dsa_bridge bridge)
398 {
399 /* Configure the port for standalone mode (no address learning,
400 * flood everything).
401 * The bridge only emits SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS events
402 * when the user requests it through netlink or sysfs, but not
403 * automatically at port join or leave, so we need to handle resetting
404 * the brport flags ourselves. But we even prefer it that way, because
405 * otherwise, some setups might never get the notification they need,
406 * for example, when a port leaves a LAG that offloads the bridge,
407 * it becomes standalone, but as far as the bridge is concerned, no
408 * port ever left.
409 */
410 dsa_port_clear_brport_flags(dp);
411
412 /* Port left the bridge, put in BR_STATE_DISABLED by the bridge layer,
413 * so allow it to be in BR_STATE_FORWARDING to be kept functional
414 */
415 dsa_port_set_state_now(dp, BR_STATE_FORWARDING, true);
416
417 dsa_port_reset_vlan_filtering(dp, bridge);
418
419 /* Ageing time may be global to the switch chip, so don't change it
420 * here because we have no good reason (or value) to change it to.
421 */
422 }
423
424 static int dsa_port_bridge_create(struct dsa_port *dp,
425 struct net_device *br,
426 struct netlink_ext_ack *extack)
427 {
428 struct dsa_switch *ds = dp->ds;
429 struct dsa_bridge *bridge;
430
431 bridge = dsa_tree_bridge_find(ds->dst, br);
432 if (bridge) {
433 refcount_inc(&bridge->refcount);
434 dp->bridge = bridge;
435 return 0;
436 }
437
438 bridge = kzalloc(sizeof(*bridge), GFP_KERNEL);
439 if (!bridge)
440 return -ENOMEM;
441
442 refcount_set(&bridge->refcount, 1);
443
444 bridge->dev = br;
445
446 bridge->num = dsa_bridge_num_get(br, ds->max_num_bridges);
447 if (ds->max_num_bridges && !bridge->num) {
448 NL_SET_ERR_MSG_MOD(extack,
449 "Range of offloadable bridges exceeded");
450 kfree(bridge);
451 return -EOPNOTSUPP;
452 }
453
454 dp->bridge = bridge;
455
456 return 0;
457 }
458
459 static void dsa_port_bridge_destroy(struct dsa_port *dp,
460 const struct net_device *br)
461 {
462 struct dsa_bridge *bridge = dp->bridge;
463
464 dp->bridge = NULL;
465
466 if (!refcount_dec_and_test(&bridge->refcount))
467 return;
468
469 if (bridge->num)
470 dsa_bridge_num_put(br, bridge->num);
471
472 kfree(bridge);
473 }
474
475 static bool dsa_port_supports_mst(struct dsa_port *dp)
476 {
477 struct dsa_switch *ds = dp->ds;
478
479 return ds->ops->vlan_msti_set &&
480 ds->ops->port_mst_state_set &&
481 ds->ops->port_vlan_fast_age &&
482 dsa_port_can_configure_learning(dp);
483 }
484
485 int dsa_port_bridge_join(struct dsa_port *dp, struct net_device *br,
486 struct netlink_ext_ack *extack)
487 {
488 struct dsa_notifier_bridge_info info = {
489 .dp = dp,
490 .extack = extack,
491 };
492 struct net_device *dev = dp->user;
493 struct net_device *brport_dev;
494 int err;
495
496 if (br_mst_enabled(br) && !dsa_port_supports_mst(dp))
497 return -EOPNOTSUPP;
498
499 /* Here the interface is already bridged. Reflect the current
500 * configuration so that drivers can program their chips accordingly.
501 */
502 err = dsa_port_bridge_create(dp, br, extack);
503 if (err)
504 return err;
505
506 brport_dev = dsa_port_to_bridge_port(dp);
507
508 info.bridge = *dp->bridge;
509 err = dsa_broadcast(DSA_NOTIFIER_BRIDGE_JOIN, &info);
510 if (err)
511 goto out_rollback;
512
513 /* Drivers which support bridge TX forwarding should set this */
514 dp->bridge->tx_fwd_offload = info.tx_fwd_offload;
515
516 err = switchdev_bridge_port_offload(brport_dev, dev, dp,
517 &dsa_user_switchdev_notifier,
518 &dsa_user_switchdev_blocking_notifier,
519 dp->bridge->tx_fwd_offload, extack);
520 if (err)
521 goto out_rollback_unbridge;
522
523 err = dsa_port_switchdev_sync_attrs(dp, extack);
524 if (err)
525 goto out_rollback_unoffload;
526
527 return 0;
528
529 out_rollback_unoffload:
530 switchdev_bridge_port_unoffload(brport_dev, dp,
531 &dsa_user_switchdev_notifier,
532 &dsa_user_switchdev_blocking_notifier);
533 dsa_flush_workqueue();
534 out_rollback_unbridge:
535 dsa_broadcast(DSA_NOTIFIER_BRIDGE_LEAVE, &info);
536 out_rollback:
537 dsa_port_bridge_destroy(dp, br);
538 return err;
539 }
540
541 void dsa_port_pre_bridge_leave(struct dsa_port *dp, struct net_device *br)
542 {
543 struct net_device *brport_dev = dsa_port_to_bridge_port(dp);
544
545 /* Don't try to unoffload something that is not offloaded */
546 if (!brport_dev)
547 return;
548
549 switchdev_bridge_port_unoffload(brport_dev, dp,
550 &dsa_user_switchdev_notifier,
551 &dsa_user_switchdev_blocking_notifier);
552
553 dsa_flush_workqueue();
554 }
555
556 void dsa_port_bridge_leave(struct dsa_port *dp, struct net_device *br)
557 {
558 struct dsa_notifier_bridge_info info = {
559 .dp = dp,
560 };
561 int err;
562
563 /* If the port could not be offloaded to begin with, then
564 * there is nothing to do.
565 */
566 if (!dp->bridge)
567 return;
568
569 info.bridge = *dp->bridge;
570
571 /* Here the port is already unbridged. Reflect the current configuration
572 * so that drivers can program their chips accordingly.
573 */
574 dsa_port_bridge_destroy(dp, br);
575
576 err = dsa_broadcast(DSA_NOTIFIER_BRIDGE_LEAVE, &info);
577 if (err)
578 dev_err(dp->ds->dev,
579 "port %d failed to notify DSA_NOTIFIER_BRIDGE_LEAVE: %pe\n",
580 dp->index, ERR_PTR(err));
581
582 dsa_port_switchdev_unsync_attrs(dp, info.bridge);
583 }
584
585 int dsa_port_lag_change(struct dsa_port *dp,
586 struct netdev_lag_lower_state_info *linfo)
587 {
588 struct dsa_notifier_lag_info info = {
589 .dp = dp,
590 };
591 bool tx_enabled;
592
593 if (!dp->lag)
594 return 0;
595
596 /* On statically configured aggregates (e.g. loadbalance
597 * without LACP) ports will always be tx_enabled, even if the
598 * link is down. Thus we require both link_up and tx_enabled
599 * in order to include it in the tx set.
600 */
601 tx_enabled = linfo->link_up && linfo->tx_enabled;
602
603 if (tx_enabled == dp->lag_tx_enabled)
604 return 0;
605
606 dp->lag_tx_enabled = tx_enabled;
607
608 return dsa_port_notify(dp, DSA_NOTIFIER_LAG_CHANGE, &info);
609 }
610
611 static int dsa_port_lag_create(struct dsa_port *dp,
612 struct net_device *lag_dev)
613 {
614 struct dsa_switch *ds = dp->ds;
615 struct dsa_lag *lag;
616
617 lag = dsa_tree_lag_find(ds->dst, lag_dev);
618 if (lag) {
619 refcount_inc(&lag->refcount);
620 dp->lag = lag;
621 return 0;
622 }
623
624 lag = kzalloc(sizeof(*lag), GFP_KERNEL);
625 if (!lag)
626 return -ENOMEM;
627
628 refcount_set(&lag->refcount, 1);
629 mutex_init(&lag->fdb_lock);
630 INIT_LIST_HEAD(&lag->fdbs);
631 lag->dev = lag_dev;
632 dsa_lag_map(ds->dst, lag);
633 dp->lag = lag;
634
635 return 0;
636 }
637
638 static void dsa_port_lag_destroy(struct dsa_port *dp)
639 {
640 struct dsa_lag *lag = dp->lag;
641
642 dp->lag = NULL;
643 dp->lag_tx_enabled = false;
644
645 if (!refcount_dec_and_test(&lag->refcount))
646 return;
647
648 WARN_ON(!list_empty(&lag->fdbs));
649 dsa_lag_unmap(dp->ds->dst, lag);
650 kfree(lag);
651 }
652
653 int dsa_port_lag_join(struct dsa_port *dp, struct net_device *lag_dev,
654 struct netdev_lag_upper_info *uinfo,
655 struct netlink_ext_ack *extack)
656 {
657 struct dsa_notifier_lag_info info = {
658 .dp = dp,
659 .info = uinfo,
660 .extack = extack,
661 };
662 struct net_device *bridge_dev;
663 int err;
664
665 err = dsa_port_lag_create(dp, lag_dev);
666 if (err)
667 goto err_lag_create;
668
669 info.lag = *dp->lag;
670 err = dsa_port_notify(dp, DSA_NOTIFIER_LAG_JOIN, &info);
671 if (err)
672 goto err_lag_join;
673
674 bridge_dev = netdev_master_upper_dev_get(lag_dev);
675 if (!bridge_dev || !netif_is_bridge_master(bridge_dev))
676 return 0;
677
678 err = dsa_port_bridge_join(dp, bridge_dev, extack);
679 if (err)
680 goto err_bridge_join;
681
682 return 0;
683
684 err_bridge_join:
685 dsa_port_notify(dp, DSA_NOTIFIER_LAG_LEAVE, &info);
686 err_lag_join:
687 dsa_port_lag_destroy(dp);
688 err_lag_create:
689 return err;
690 }
691
692 void dsa_port_pre_lag_leave(struct dsa_port *dp, struct net_device *lag_dev)
693 {
694 struct net_device *br = dsa_port_bridge_dev_get(dp);
695
696 if (br)
697 dsa_port_pre_bridge_leave(dp, br);
698 }
699
700 void dsa_port_lag_leave(struct dsa_port *dp, struct net_device *lag_dev)
701 {
702 struct net_device *br = dsa_port_bridge_dev_get(dp);
703 struct dsa_notifier_lag_info info = {
704 .dp = dp,
705 };
706 int err;
707
708 if (!dp->lag)
709 return;
710
711 /* Port might have been part of a LAG that in turn was
712 * attached to a bridge.
713 */
714 if (br)
715 dsa_port_bridge_leave(dp, br);
716
717 info.lag = *dp->lag;
718
719 dsa_port_lag_destroy(dp);
720
721 err = dsa_port_notify(dp, DSA_NOTIFIER_LAG_LEAVE, &info);
722 if (err)
723 dev_err(dp->ds->dev,
724 "port %d failed to notify DSA_NOTIFIER_LAG_LEAVE: %pe\n",
725 dp->index, ERR_PTR(err));
726 }
727
728 /* Must be called under rcu_read_lock() */
729 static bool dsa_port_can_apply_vlan_filtering(struct dsa_port *dp,
730 bool vlan_filtering,
731 struct netlink_ext_ack *extack)
732 {
733 struct dsa_switch *ds = dp->ds;
734 struct dsa_port *other_dp;
735 int err;
736
737 /* VLAN awareness was off, so the question is "can we turn it on".
738 * We may have had 8021q uppers, those need to go. Make sure we don't
739 * enter an inconsistent state: deny changing the VLAN awareness state
740 * as long as we have 8021q uppers.
741 */
742 if (vlan_filtering && dsa_port_is_user(dp)) {
743 struct net_device *br = dsa_port_bridge_dev_get(dp);
744 struct net_device *upper_dev, *user = dp->user;
745 struct list_head *iter;
746
747 netdev_for_each_upper_dev_rcu(user, upper_dev, iter) {
748 struct bridge_vlan_info br_info;
749 u16 vid;
750
751 if (!is_vlan_dev(upper_dev))
752 continue;
753
754 vid = vlan_dev_vlan_id(upper_dev);
755
756 /* br_vlan_get_info() returns -EINVAL or -ENOENT if the
757 * device, respectively the VID is not found, returning
758 * 0 means success, which is a failure for us here.
759 */
760 err = br_vlan_get_info(br, vid, &br_info);
761 if (err == 0) {
762 NL_SET_ERR_MSG_MOD(extack,
763 "Must first remove VLAN uppers having VIDs also present in bridge");
764 return false;
765 }
766 }
767 }
768
769 if (!ds->vlan_filtering_is_global)
770 return true;
771
772 /* For cases where enabling/disabling VLAN awareness is global to the
773 * switch, we need to handle the case where multiple bridges span
774 * different ports of the same switch device and one of them has a
775 * different setting than what is being requested.
776 */
777 dsa_switch_for_each_port(other_dp, ds) {
778 struct net_device *other_br = dsa_port_bridge_dev_get(other_dp);
779
780 /* If it's the same bridge, it also has same
781 * vlan_filtering setting => no need to check
782 */
783 if (!other_br || other_br == dsa_port_bridge_dev_get(dp))
784 continue;
785
786 if (br_vlan_enabled(other_br) != vlan_filtering) {
787 NL_SET_ERR_MSG_MOD(extack,
788 "VLAN filtering is a global setting");
789 return false;
790 }
791 }
792 return true;
793 }
794
795 int dsa_port_vlan_filtering(struct dsa_port *dp, bool vlan_filtering,
796 struct netlink_ext_ack *extack)
797 {
798 bool old_vlan_filtering = dsa_port_is_vlan_filtering(dp);
799 struct dsa_switch *ds = dp->ds;
800 bool apply;
801 int err;
802
803 if (!ds->ops->port_vlan_filtering)
804 return -EOPNOTSUPP;
805
806 /* We are called from dsa_user_switchdev_blocking_event(),
807 * which is not under rcu_read_lock(), unlike
808 * dsa_user_switchdev_event().
809 */
810 rcu_read_lock();
811 apply = dsa_port_can_apply_vlan_filtering(dp, vlan_filtering, extack);
812 rcu_read_unlock();
813 if (!apply)
814 return -EINVAL;
815
816 if (dsa_port_is_vlan_filtering(dp) == vlan_filtering)
817 return 0;
818
819 err = ds->ops->port_vlan_filtering(ds, dp->index, vlan_filtering,
820 extack);
821 if (err)
822 return err;
823
824 if (ds->vlan_filtering_is_global) {
825 struct dsa_port *other_dp;
826
827 ds->vlan_filtering = vlan_filtering;
828
829 dsa_switch_for_each_user_port(other_dp, ds) {
830 struct net_device *user = other_dp->user;
831
832 /* We might be called in the unbind path, so not
833 * all user devices might still be registered.
834 */
835 if (!user)
836 continue;
837
838 err = dsa_user_manage_vlan_filtering(user,
839 vlan_filtering);
840 if (err)
841 goto restore;
842 }
843 } else {
844 dp->vlan_filtering = vlan_filtering;
845
846 err = dsa_user_manage_vlan_filtering(dp->user,
847 vlan_filtering);
848 if (err)
849 goto restore;
850 }
851
852 return 0;
853
854 restore:
855 ds->ops->port_vlan_filtering(ds, dp->index, old_vlan_filtering, NULL);
856
857 if (ds->vlan_filtering_is_global)
858 ds->vlan_filtering = old_vlan_filtering;
859 else
860 dp->vlan_filtering = old_vlan_filtering;
861
862 return err;
863 }
864
865 /* This enforces legacy behavior for switch drivers which assume they can't
866 * receive VLAN configuration when joining a bridge with vlan_filtering=0
867 */
868 bool dsa_port_skip_vlan_configuration(struct dsa_port *dp)
869 {
870 struct net_device *br = dsa_port_bridge_dev_get(dp);
871 struct dsa_switch *ds = dp->ds;
872
873 if (!br)
874 return false;
875
876 return !ds->configure_vlan_while_not_filtering && !br_vlan_enabled(br);
877 }
878
879 int dsa_port_ageing_time(struct dsa_port *dp, clock_t ageing_clock)
880 {
881 unsigned long ageing_jiffies = clock_t_to_jiffies(ageing_clock);
882 unsigned int ageing_time = jiffies_to_msecs(ageing_jiffies);
883 struct dsa_notifier_ageing_time_info info;
884 int err;
885
886 info.ageing_time = ageing_time;
887
888 err = dsa_port_notify(dp, DSA_NOTIFIER_AGEING_TIME, &info);
889 if (err)
890 return err;
891
892 dp->ageing_time = ageing_time;
893
894 return 0;
895 }
896
897 int dsa_port_mst_enable(struct dsa_port *dp, bool on,
898 struct netlink_ext_ack *extack)
899 {
900 if (on && !dsa_port_supports_mst(dp)) {
901 NL_SET_ERR_MSG_MOD(extack, "Hardware does not support MST");
902 return -EINVAL;
903 }
904
905 return 0;
906 }
907
908 int dsa_port_pre_bridge_flags(const struct dsa_port *dp,
909 struct switchdev_brport_flags flags,
910 struct netlink_ext_ack *extack)
911 {
912 struct dsa_switch *ds = dp->ds;
913
914 if (!ds->ops->port_pre_bridge_flags)
915 return -EINVAL;
916
917 return ds->ops->port_pre_bridge_flags(ds, dp->index, flags, extack);
918 }
919
920 int dsa_port_bridge_flags(struct dsa_port *dp,
921 struct switchdev_brport_flags flags,
922 struct netlink_ext_ack *extack)
923 {
924 struct dsa_switch *ds = dp->ds;
925 int err;
926
927 if (!ds->ops->port_bridge_flags)
928 return -EOPNOTSUPP;
929
930 err = ds->ops->port_bridge_flags(ds, dp->index, flags, extack);
931 if (err)
932 return err;
933
934 if (flags.mask & BR_LEARNING) {
935 bool learning = flags.val & BR_LEARNING;
936
937 if (learning == dp->learning)
938 return 0;
939
940 if ((dp->learning && !learning) &&
941 (dp->stp_state == BR_STATE_LEARNING ||
942 dp->stp_state == BR_STATE_FORWARDING))
943 dsa_port_fast_age(dp);
944
945 dp->learning = learning;
946 }
947
948 return 0;
949 }
950
951 void dsa_port_set_host_flood(struct dsa_port *dp, bool uc, bool mc)
952 {
953 struct dsa_switch *ds = dp->ds;
954
955 if (ds->ops->port_set_host_flood)
956 ds->ops->port_set_host_flood(ds, dp->index, uc, mc);
957 }
958
959 int dsa_port_vlan_msti(struct dsa_port *dp,
960 const struct switchdev_vlan_msti *msti)
961 {
962 struct dsa_switch *ds = dp->ds;
963
964 if (!ds->ops->vlan_msti_set)
965 return -EOPNOTSUPP;
966
967 return ds->ops->vlan_msti_set(ds, *dp->bridge, msti);
968 }
969
970 int dsa_port_mtu_change(struct dsa_port *dp, int new_mtu)
971 {
972 struct dsa_notifier_mtu_info info = {
973 .dp = dp,
974 .mtu = new_mtu,
975 };
976
977 return dsa_port_notify(dp, DSA_NOTIFIER_MTU, &info);
978 }
979
980 int dsa_port_fdb_add(struct dsa_port *dp, const unsigned char *addr,
981 u16 vid)
982 {
983 struct dsa_notifier_fdb_info info = {
984 .dp = dp,
985 .addr = addr,
986 .vid = vid,
987 .db = {
988 .type = DSA_DB_BRIDGE,
989 .bridge = *dp->bridge,
990 },
991 };
992
993 /* Refcounting takes bridge.num as a key, and should be global for all
994 * bridges in the absence of FDB isolation, and per bridge otherwise.
995 * Force the bridge.num to zero here in the absence of FDB isolation.
996 */
997 if (!dp->ds->fdb_isolation)
998 info.db.bridge.num = 0;
999
1000 return dsa_port_notify(dp, DSA_NOTIFIER_FDB_ADD, &info);
1001 }
1002
1003 int dsa_port_fdb_del(struct dsa_port *dp, const unsigned char *addr,
1004 u16 vid)
1005 {
1006 struct dsa_notifier_fdb_info info = {
1007 .dp = dp,
1008 .addr = addr,
1009 .vid = vid,
1010 .db = {
1011 .type = DSA_DB_BRIDGE,
1012 .bridge = *dp->bridge,
1013 },
1014 };
1015
1016 if (!dp->ds->fdb_isolation)
1017 info.db.bridge.num = 0;
1018
1019 return dsa_port_notify(dp, DSA_NOTIFIER_FDB_DEL, &info);
1020 }
1021
1022 static int dsa_port_host_fdb_add(struct dsa_port *dp,
1023 const unsigned char *addr, u16 vid,
1024 struct dsa_db db)
1025 {
1026 struct dsa_notifier_fdb_info info = {
1027 .dp = dp,
1028 .addr = addr,
1029 .vid = vid,
1030 .db = db,
1031 };
1032
1033 return dsa_port_notify(dp, DSA_NOTIFIER_HOST_FDB_ADD, &info);
1034 }
1035
1036 int dsa_port_standalone_host_fdb_add(struct dsa_port *dp,
1037 const unsigned char *addr, u16 vid)
1038 {
1039 struct dsa_db db = {
1040 .type = DSA_DB_PORT,
1041 .dp = dp,
1042 };
1043
1044 return dsa_port_host_fdb_add(dp, addr, vid, db);
1045 }
1046
1047 int dsa_port_bridge_host_fdb_add(struct dsa_port *dp,
1048 const unsigned char *addr, u16 vid)
1049 {
1050 struct net_device *conduit = dsa_port_to_conduit(dp);
1051 struct dsa_db db = {
1052 .type = DSA_DB_BRIDGE,
1053 .bridge = *dp->bridge,
1054 };
1055 int err;
1056
1057 if (!dp->ds->fdb_isolation)
1058 db.bridge.num = 0;
1059
1060 /* Avoid a call to __dev_set_promiscuity() on the conduit, which
1061 * requires rtnl_lock(), since we can't guarantee that is held here,
1062 * and we can't take it either.
1063 */
1064 if (conduit->priv_flags & IFF_UNICAST_FLT) {
1065 err = dev_uc_add(conduit, addr);
1066 if (err)
1067 return err;
1068 }
1069
1070 return dsa_port_host_fdb_add(dp, addr, vid, db);
1071 }
1072
1073 static int dsa_port_host_fdb_del(struct dsa_port *dp,
1074 const unsigned char *addr, u16 vid,
1075 struct dsa_db db)
1076 {
1077 struct dsa_notifier_fdb_info info = {
1078 .dp = dp,
1079 .addr = addr,
1080 .vid = vid,
1081 .db = db,
1082 };
1083
1084 return dsa_port_notify(dp, DSA_NOTIFIER_HOST_FDB_DEL, &info);
1085 }
1086
1087 int dsa_port_standalone_host_fdb_del(struct dsa_port *dp,
1088 const unsigned char *addr, u16 vid)
1089 {
1090 struct dsa_db db = {
1091 .type = DSA_DB_PORT,
1092 .dp = dp,
1093 };
1094
1095 return dsa_port_host_fdb_del(dp, addr, vid, db);
1096 }
1097
1098 int dsa_port_bridge_host_fdb_del(struct dsa_port *dp,
1099 const unsigned char *addr, u16 vid)
1100 {
1101 struct net_device *conduit = dsa_port_to_conduit(dp);
1102 struct dsa_db db = {
1103 .type = DSA_DB_BRIDGE,
1104 .bridge = *dp->bridge,
1105 };
1106 int err;
1107
1108 if (!dp->ds->fdb_isolation)
1109 db.bridge.num = 0;
1110
1111 if (conduit->priv_flags & IFF_UNICAST_FLT) {
1112 err = dev_uc_del(conduit, addr);
1113 if (err)
1114 return err;
1115 }
1116
1117 return dsa_port_host_fdb_del(dp, addr, vid, db);
1118 }
1119
1120 int dsa_port_lag_fdb_add(struct dsa_port *dp, const unsigned char *addr,
1121 u16 vid)
1122 {
1123 struct dsa_notifier_lag_fdb_info info = {
1124 .lag = dp->lag,
1125 .addr = addr,
1126 .vid = vid,
1127 .db = {
1128 .type = DSA_DB_BRIDGE,
1129 .bridge = *dp->bridge,
1130 },
1131 };
1132
1133 if (!dp->ds->fdb_isolation)
1134 info.db.bridge.num = 0;
1135
1136 return dsa_port_notify(dp, DSA_NOTIFIER_LAG_FDB_ADD, &info);
1137 }
1138
1139 int dsa_port_lag_fdb_del(struct dsa_port *dp, const unsigned char *addr,
1140 u16 vid)
1141 {
1142 struct dsa_notifier_lag_fdb_info info = {
1143 .lag = dp->lag,
1144 .addr = addr,
1145 .vid = vid,
1146 .db = {
1147 .type = DSA_DB_BRIDGE,
1148 .bridge = *dp->bridge,
1149 },
1150 };
1151
1152 if (!dp->ds->fdb_isolation)
1153 info.db.bridge.num = 0;
1154
1155 return dsa_port_notify(dp, DSA_NOTIFIER_LAG_FDB_DEL, &info);
1156 }
1157
1158 int dsa_port_fdb_dump(struct dsa_port *dp, dsa_fdb_dump_cb_t *cb, void *data)
1159 {
1160 struct dsa_switch *ds = dp->ds;
1161 int port = dp->index;
1162
1163 if (!ds->ops->port_fdb_dump)
1164 return -EOPNOTSUPP;
1165
1166 return ds->ops->port_fdb_dump(ds, port, cb, data);
1167 }
1168
1169 int dsa_port_mdb_add(const struct dsa_port *dp,
1170 const struct switchdev_obj_port_mdb *mdb)
1171 {
1172 struct dsa_notifier_mdb_info info = {
1173 .dp = dp,
1174 .mdb = mdb,
1175 .db = {
1176 .type = DSA_DB_BRIDGE,
1177 .bridge = *dp->bridge,
1178 },
1179 };
1180
1181 if (!dp->ds->fdb_isolation)
1182 info.db.bridge.num = 0;
1183
1184 return dsa_port_notify(dp, DSA_NOTIFIER_MDB_ADD, &info);
1185 }
1186
1187 int dsa_port_mdb_del(const struct dsa_port *dp,
1188 const struct switchdev_obj_port_mdb *mdb)
1189 {
1190 struct dsa_notifier_mdb_info info = {
1191 .dp = dp,
1192 .mdb = mdb,
1193 .db = {
1194 .type = DSA_DB_BRIDGE,
1195 .bridge = *dp->bridge,
1196 },
1197 };
1198
1199 if (!dp->ds->fdb_isolation)
1200 info.db.bridge.num = 0;
1201
1202 return dsa_port_notify(dp, DSA_NOTIFIER_MDB_DEL, &info);
1203 }
1204
1205 static int dsa_port_host_mdb_add(const struct dsa_port *dp,
1206 const struct switchdev_obj_port_mdb *mdb,
1207 struct dsa_db db)
1208 {
1209 struct dsa_notifier_mdb_info info = {
1210 .dp = dp,
1211 .mdb = mdb,
1212 .db = db,
1213 };
1214
1215 return dsa_port_notify(dp, DSA_NOTIFIER_HOST_MDB_ADD, &info);
1216 }
1217
1218 int dsa_port_standalone_host_mdb_add(const struct dsa_port *dp,
1219 const struct switchdev_obj_port_mdb *mdb)
1220 {
1221 struct dsa_db db = {
1222 .type = DSA_DB_PORT,
1223 .dp = dp,
1224 };
1225
1226 return dsa_port_host_mdb_add(dp, mdb, db);
1227 }
1228
1229 int dsa_port_bridge_host_mdb_add(const struct dsa_port *dp,
1230 const struct switchdev_obj_port_mdb *mdb)
1231 {
1232 struct net_device *conduit = dsa_port_to_conduit(dp);
1233 struct dsa_db db = {
1234 .type = DSA_DB_BRIDGE,
1235 .bridge = *dp->bridge,
1236 };
1237 int err;
1238
1239 if (!dp->ds->fdb_isolation)
1240 db.bridge.num = 0;
1241
1242 err = dev_mc_add(conduit, mdb->addr);
1243 if (err)
1244 return err;
1245
1246 return dsa_port_host_mdb_add(dp, mdb, db);
1247 }
1248
1249 static int dsa_port_host_mdb_del(const struct dsa_port *dp,
1250 const struct switchdev_obj_port_mdb *mdb,
1251 struct dsa_db db)
1252 {
1253 struct dsa_notifier_mdb_info info = {
1254 .dp = dp,
1255 .mdb = mdb,
1256 .db = db,
1257 };
1258
1259 return dsa_port_notify(dp, DSA_NOTIFIER_HOST_MDB_DEL, &info);
1260 }
1261
1262 int dsa_port_standalone_host_mdb_del(const struct dsa_port *dp,
1263 const struct switchdev_obj_port_mdb *mdb)
1264 {
1265 struct dsa_db db = {
1266 .type = DSA_DB_PORT,
1267 .dp = dp,
1268 };
1269
1270 return dsa_port_host_mdb_del(dp, mdb, db);
1271 }
1272
1273 int dsa_port_bridge_host_mdb_del(const struct dsa_port *dp,
1274 const struct switchdev_obj_port_mdb *mdb)
1275 {
1276 struct net_device *conduit = dsa_port_to_conduit(dp);
1277 struct dsa_db db = {
1278 .type = DSA_DB_BRIDGE,
1279 .bridge = *dp->bridge,
1280 };
1281 int err;
1282
1283 if (!dp->ds->fdb_isolation)
1284 db.bridge.num = 0;
1285
1286 err = dev_mc_del(conduit, mdb->addr);
1287 if (err)
1288 return err;
1289
1290 return dsa_port_host_mdb_del(dp, mdb, db);
1291 }
1292
1293 int dsa_port_vlan_add(struct dsa_port *dp,
1294 const struct switchdev_obj_port_vlan *vlan,
1295 struct netlink_ext_ack *extack)
1296 {
1297 struct dsa_notifier_vlan_info info = {
1298 .dp = dp,
1299 .vlan = vlan,
1300 .extack = extack,
1301 };
1302
1303 return dsa_port_notify(dp, DSA_NOTIFIER_VLAN_ADD, &info);
1304 }
1305
1306 int dsa_port_vlan_del(struct dsa_port *dp,
1307 const struct switchdev_obj_port_vlan *vlan)
1308 {
1309 struct dsa_notifier_vlan_info info = {
1310 .dp = dp,
1311 .vlan = vlan,
1312 };
1313
1314 return dsa_port_notify(dp, DSA_NOTIFIER_VLAN_DEL, &info);
1315 }
1316
1317 int dsa_port_host_vlan_add(struct dsa_port *dp,
1318 const struct switchdev_obj_port_vlan *vlan,
1319 struct netlink_ext_ack *extack)
1320 {
1321 struct net_device *conduit = dsa_port_to_conduit(dp);
1322 struct dsa_notifier_vlan_info info = {
1323 .dp = dp,
1324 .vlan = vlan,
1325 .extack = extack,
1326 };
1327 int err;
1328
1329 err = dsa_port_notify(dp, DSA_NOTIFIER_HOST_VLAN_ADD, &info);
1330 if (err && err != -EOPNOTSUPP)
1331 return err;
1332
1333 vlan_vid_add(conduit, htons(ETH_P_8021Q), vlan->vid);
1334
1335 return err;
1336 }
1337
1338 int dsa_port_host_vlan_del(struct dsa_port *dp,
1339 const struct switchdev_obj_port_vlan *vlan)
1340 {
1341 struct net_device *conduit = dsa_port_to_conduit(dp);
1342 struct dsa_notifier_vlan_info info = {
1343 .dp = dp,
1344 .vlan = vlan,
1345 };
1346 int err;
1347
1348 err = dsa_port_notify(dp, DSA_NOTIFIER_HOST_VLAN_DEL, &info);
1349 if (err && err != -EOPNOTSUPP)
1350 return err;
1351
1352 vlan_vid_del(conduit, htons(ETH_P_8021Q), vlan->vid);
1353
1354 return err;
1355 }
1356
1357 int dsa_port_mrp_add(const struct dsa_port *dp,
1358 const struct switchdev_obj_mrp *mrp)
1359 {
1360 struct dsa_switch *ds = dp->ds;
1361
1362 if (!ds->ops->port_mrp_add)
1363 return -EOPNOTSUPP;
1364
1365 return ds->ops->port_mrp_add(ds, dp->index, mrp);
1366 }
1367
1368 int dsa_port_mrp_del(const struct dsa_port *dp,
1369 const struct switchdev_obj_mrp *mrp)
1370 {
1371 struct dsa_switch *ds = dp->ds;
1372
1373 if (!ds->ops->port_mrp_del)
1374 return -EOPNOTSUPP;
1375
1376 return ds->ops->port_mrp_del(ds, dp->index, mrp);
1377 }
1378
1379 int dsa_port_mrp_add_ring_role(const struct dsa_port *dp,
1380 const struct switchdev_obj_ring_role_mrp *mrp)
1381 {
1382 struct dsa_switch *ds = dp->ds;
1383
1384 if (!ds->ops->port_mrp_add_ring_role)
1385 return -EOPNOTSUPP;
1386
1387 return ds->ops->port_mrp_add_ring_role(ds, dp->index, mrp);
1388 }
1389
1390 int dsa_port_mrp_del_ring_role(const struct dsa_port *dp,
1391 const struct switchdev_obj_ring_role_mrp *mrp)
1392 {
1393 struct dsa_switch *ds = dp->ds;
1394
1395 if (!ds->ops->port_mrp_del_ring_role)
1396 return -EOPNOTSUPP;
1397
1398 return ds->ops->port_mrp_del_ring_role(ds, dp->index, mrp);
1399 }
1400
1401 static int dsa_port_assign_conduit(struct dsa_port *dp,
1402 struct net_device *conduit,
1403 struct netlink_ext_ack *extack,
1404 bool fail_on_err)
1405 {
1406 struct dsa_switch *ds = dp->ds;
1407 int port = dp->index, err;
1408
1409 err = ds->ops->port_change_conduit(ds, port, conduit, extack);
1410 if (err && !fail_on_err)
1411 dev_err(ds->dev, "port %d failed to assign conduit %s: %pe\n",
1412 port, conduit->name, ERR_PTR(err));
1413
1414 if (err && fail_on_err)
1415 return err;
1416
1417 dp->cpu_dp = conduit->dsa_ptr;
1418 dp->cpu_port_in_lag = netif_is_lag_master(conduit);
1419
1420 return 0;
1421 }
1422
1423 /* Change the dp->cpu_dp affinity for a user port. Note that both cross-chip
1424 * notifiers and drivers have implicit assumptions about user-to-CPU-port
1425 * mappings, so we unfortunately cannot delay the deletion of the objects
1426 * (switchdev, standalone addresses, standalone VLANs) on the old CPU port
1427 * until the new CPU port has been set up. So we need to completely tear down
1428 * the old CPU port before changing it, and restore it on errors during the
1429 * bringup of the new one.
1430 */
1431 int dsa_port_change_conduit(struct dsa_port *dp, struct net_device *conduit,
1432 struct netlink_ext_ack *extack)
1433 {
1434 struct net_device *bridge_dev = dsa_port_bridge_dev_get(dp);
1435 struct net_device *old_conduit = dsa_port_to_conduit(dp);
1436 struct net_device *dev = dp->user;
1437 struct dsa_switch *ds = dp->ds;
1438 bool vlan_filtering;
1439 int err, tmp;
1440
1441 /* Bridges may hold host FDB, MDB and VLAN objects. These need to be
1442 * migrated, so dynamically unoffload and later reoffload the bridge
1443 * port.
1444 */
1445 if (bridge_dev) {
1446 dsa_port_pre_bridge_leave(dp, bridge_dev);
1447 dsa_port_bridge_leave(dp, bridge_dev);
1448 }
1449
1450 /* The port might still be VLAN filtering even if it's no longer
1451 * under a bridge, either due to ds->vlan_filtering_is_global or
1452 * ds->needs_standalone_vlan_filtering. In turn this means VLANs
1453 * on the CPU port.
1454 */
1455 vlan_filtering = dsa_port_is_vlan_filtering(dp);
1456 if (vlan_filtering) {
1457 err = dsa_user_manage_vlan_filtering(dev, false);
1458 if (err) {
1459 NL_SET_ERR_MSG_MOD(extack,
1460 "Failed to remove standalone VLANs");
1461 goto rewind_old_bridge;
1462 }
1463 }
1464
1465 /* Standalone addresses, and addresses of upper interfaces like
1466 * VLAN, LAG, HSR need to be migrated.
1467 */
1468 dsa_user_unsync_ha(dev);
1469
1470 /* If live-changing, we also need to uninstall the user device address
1471 * from the port FDB and the conduit interface.
1472 */
1473 if (dev->flags & IFF_UP)
1474 dsa_user_host_uc_uninstall(dev);
1475
1476 err = dsa_port_assign_conduit(dp, conduit, extack, true);
1477 if (err)
1478 goto rewind_old_addrs;
1479
1480 /* If the port doesn't have its own MAC address and relies on the DSA
1481 * conduit's one, inherit it again from the new DSA conduit.
1482 */
1483 if (is_zero_ether_addr(dp->mac))
1484 eth_hw_addr_inherit(dev, conduit);
1485
1486 /* If live-changing, we need to install the user device address to the
1487 * port FDB and the conduit interface.
1488 */
1489 if (dev->flags & IFF_UP) {
1490 err = dsa_user_host_uc_install(dev, dev->dev_addr);
1491 if (err) {
1492 NL_SET_ERR_MSG_MOD(extack,
1493 "Failed to install host UC address");
1494 goto rewind_addr_inherit;
1495 }
1496 }
1497
1498 dsa_user_sync_ha(dev);
1499
1500 if (vlan_filtering) {
1501 err = dsa_user_manage_vlan_filtering(dev, true);
1502 if (err) {
1503 NL_SET_ERR_MSG_MOD(extack,
1504 "Failed to restore standalone VLANs");
1505 goto rewind_new_addrs;
1506 }
1507 }
1508
1509 if (bridge_dev) {
1510 err = dsa_port_bridge_join(dp, bridge_dev, extack);
1511 if (err && err == -EOPNOTSUPP) {
1512 NL_SET_ERR_MSG_MOD(extack,
1513 "Failed to reoffload bridge");
1514 goto rewind_new_vlan;
1515 }
1516 }
1517
1518 return 0;
1519
1520 rewind_new_vlan:
1521 if (vlan_filtering)
1522 dsa_user_manage_vlan_filtering(dev, false);
1523
1524 rewind_new_addrs:
1525 dsa_user_unsync_ha(dev);
1526
1527 if (dev->flags & IFF_UP)
1528 dsa_user_host_uc_uninstall(dev);
1529
1530 rewind_addr_inherit:
1531 if (is_zero_ether_addr(dp->mac))
1532 eth_hw_addr_inherit(dev, old_conduit);
1533
1534 dsa_port_assign_conduit(dp, old_conduit, NULL, false);
1535
1536 /* Restore the objects on the old CPU port */
1537 rewind_old_addrs:
1538 if (dev->flags & IFF_UP) {
1539 tmp = dsa_user_host_uc_install(dev, dev->dev_addr);
1540 if (tmp) {
1541 dev_err(ds->dev,
1542 "port %d failed to restore host UC address: %pe\n",
1543 dp->index, ERR_PTR(tmp));
1544 }
1545 }
1546
1547 dsa_user_sync_ha(dev);
1548
1549 if (vlan_filtering) {
1550 tmp = dsa_user_manage_vlan_filtering(dev, true);
1551 if (tmp) {
1552 dev_err(ds->dev,
1553 "port %d failed to restore standalone VLANs: %pe\n",
1554 dp->index, ERR_PTR(tmp));
1555 }
1556 }
1557
1558 rewind_old_bridge:
1559 if (bridge_dev) {
1560 tmp = dsa_port_bridge_join(dp, bridge_dev, extack);
1561 if (tmp) {
1562 dev_err(ds->dev,
1563 "port %d failed to rejoin bridge %s: %pe\n",
1564 dp->index, bridge_dev->name, ERR_PTR(tmp));
1565 }
1566 }
1567
1568 return err;
1569 }
1570
1571 void dsa_port_set_tag_protocol(struct dsa_port *cpu_dp,
1572 const struct dsa_device_ops *tag_ops)
1573 {
1574 cpu_dp->rcv = tag_ops->rcv;
1575 cpu_dp->tag_ops = tag_ops;
1576 }
1577
1578 static struct phylink_pcs *
1579 dsa_port_phylink_mac_select_pcs(struct phylink_config *config,
1580 phy_interface_t interface)
1581 {
1582 struct dsa_port *dp = dsa_phylink_to_port(config);
1583 struct phylink_pcs *pcs = ERR_PTR(-EOPNOTSUPP);
1584 struct dsa_switch *ds = dp->ds;
1585
1586 if (ds->ops->phylink_mac_select_pcs)
1587 pcs = ds->ops->phylink_mac_select_pcs(ds, dp->index, interface);
1588
1589 return pcs;
1590 }
1591
1592 static void dsa_port_phylink_mac_config(struct phylink_config *config,
1593 unsigned int mode,
1594 const struct phylink_link_state *state)
1595 {
1596 struct dsa_port *dp = dsa_phylink_to_port(config);
1597 struct dsa_switch *ds = dp->ds;
1598
1599 if (!ds->ops->phylink_mac_config)
1600 return;
1601
1602 ds->ops->phylink_mac_config(ds, dp->index, mode, state);
1603 }
1604
1605 static void dsa_port_phylink_mac_link_down(struct phylink_config *config,
1606 unsigned int mode,
1607 phy_interface_t interface)
1608 {
1609 struct dsa_port *dp = dsa_phylink_to_port(config);
1610 struct dsa_switch *ds = dp->ds;
1611
1612 if (!ds->ops->phylink_mac_link_down)
1613 return;
1614
1615 ds->ops->phylink_mac_link_down(ds, dp->index, mode, interface);
1616 }
1617
1618 static void dsa_port_phylink_mac_link_up(struct phylink_config *config,
1619 struct phy_device *phydev,
1620 unsigned int mode,
1621 phy_interface_t interface,
1622 int speed, int duplex,
1623 bool tx_pause, bool rx_pause)
1624 {
1625 struct dsa_port *dp = dsa_phylink_to_port(config);
1626 struct dsa_switch *ds = dp->ds;
1627
1628 if (!ds->ops->phylink_mac_link_up)
1629 return;
1630
1631 ds->ops->phylink_mac_link_up(ds, dp->index, mode, interface, phydev,
1632 speed, duplex, tx_pause, rx_pause);
1633 }
1634
1635 static const struct phylink_mac_ops dsa_port_phylink_mac_ops = {
1636 .mac_select_pcs = dsa_port_phylink_mac_select_pcs,
1637 .mac_config = dsa_port_phylink_mac_config,
1638 .mac_link_down = dsa_port_phylink_mac_link_down,
1639 .mac_link_up = dsa_port_phylink_mac_link_up,
1640 };
1641
1642 int dsa_port_phylink_create(struct dsa_port *dp)
1643 {
1644 const struct phylink_mac_ops *mac_ops;
1645 struct dsa_switch *ds = dp->ds;
1646 phy_interface_t mode;
1647 struct phylink *pl;
1648 int err;
1649
1650 err = of_get_phy_mode(dp->dn, &mode);
1651 if (err)
1652 mode = PHY_INTERFACE_MODE_NA;
1653
1654 if (ds->ops->phylink_get_caps) {
1655 ds->ops->phylink_get_caps(ds, dp->index, &dp->pl_config);
1656 } else {
1657 /* For legacy drivers */
1658 if (mode != PHY_INTERFACE_MODE_NA) {
1659 __set_bit(mode, dp->pl_config.supported_interfaces);
1660 } else {
1661 __set_bit(PHY_INTERFACE_MODE_INTERNAL,
1662 dp->pl_config.supported_interfaces);
1663 __set_bit(PHY_INTERFACE_MODE_GMII,
1664 dp->pl_config.supported_interfaces);
1665 }
1666 }
1667
1668 mac_ops = &dsa_port_phylink_mac_ops;
1669 if (ds->phylink_mac_ops)
1670 mac_ops = ds->phylink_mac_ops;
1671
1672 pl = phylink_create(&dp->pl_config, of_fwnode_handle(dp->dn), mode,
1673 mac_ops);
1674 if (IS_ERR(pl)) {
1675 pr_err("error creating PHYLINK: %ld\n", PTR_ERR(pl));
1676 return PTR_ERR(pl);
1677 }
1678
1679 dp->pl = pl;
1680
1681 return 0;
1682 }
1683
1684 void dsa_port_phylink_destroy(struct dsa_port *dp)
1685 {
1686 phylink_destroy(dp->pl);
1687 dp->pl = NULL;
1688 }
1689
1690 static int dsa_shared_port_phylink_register(struct dsa_port *dp)
1691 {
1692 struct dsa_switch *ds = dp->ds;
1693 struct device_node *port_dn = dp->dn;
1694 int err;
1695
1696 dp->pl_config.dev = ds->dev;
1697 dp->pl_config.type = PHYLINK_DEV;
1698
1699 err = dsa_port_phylink_create(dp);
1700 if (err)
1701 return err;
1702
1703 err = phylink_of_phy_connect(dp->pl, port_dn, 0);
1704 if (err && err != -ENODEV) {
1705 pr_err("could not attach to PHY: %d\n", err);
1706 goto err_phy_connect;
1707 }
1708
1709 return 0;
1710
1711 err_phy_connect:
1712 dsa_port_phylink_destroy(dp);
1713 return err;
1714 }
1715
1716 /* During the initial DSA driver migration to OF, port nodes were sometimes
1717 * added to device trees with no indication of how they should operate from a
1718 * link management perspective (phy-handle, fixed-link, etc). Additionally, the
1719 * phy-mode may be absent. The interpretation of these port OF nodes depends on
1720 * their type.
1721 *
1722 * User ports with no phy-handle or fixed-link are expected to connect to an
1723 * internal PHY located on the ds->user_mii_bus at an MDIO address equal to
1724 * the port number. This description is still actively supported.
1725 *
1726 * Shared (CPU and DSA) ports with no phy-handle or fixed-link are expected to
1727 * operate at the maximum speed that their phy-mode is capable of. If the
1728 * phy-mode is absent, they are expected to operate using the phy-mode
1729 * supported by the port that gives the highest link speed. It is unspecified
1730 * if the port should use flow control or not, half duplex or full duplex, or
1731 * if the phy-mode is a SERDES link, whether in-band autoneg is expected to be
1732 * enabled or not.
1733 *
1734 * In the latter case of shared ports, omitting the link management description
1735 * from the firmware node is deprecated and strongly discouraged. DSA uses
1736 * phylink, which rejects the firmware nodes of these ports for lacking
1737 * required properties.
1738 *
1739 * For switches in this table, DSA will skip enforcing validation and will
1740 * later omit registering a phylink instance for the shared ports, if they lack
1741 * a fixed-link, a phy-handle, or a managed = "in-band-status" property.
1742 * It becomes the responsibility of the driver to ensure that these ports
1743 * operate at the maximum speed (whatever this means) and will interoperate
1744 * with the DSA conduit or other cascade port, since phylink methods will not be
1745 * invoked for them.
1746 *
1747 * If you are considering expanding this table for newly introduced switches,
1748 * think again. It is OK to remove switches from this table if there aren't DT
1749 * blobs in circulation which rely on defaulting the shared ports.
1750 */
1751 static const char * const dsa_switches_apply_workarounds[] = {
1752 #if IS_ENABLED(CONFIG_NET_DSA_XRS700X)
1753 "arrow,xrs7003e",
1754 "arrow,xrs7003f",
1755 "arrow,xrs7004e",
1756 "arrow,xrs7004f",
1757 #endif
1758 #if IS_ENABLED(CONFIG_B53)
1759 "brcm,bcm5325",
1760 "brcm,bcm53115",
1761 "brcm,bcm53125",
1762 "brcm,bcm53128",
1763 "brcm,bcm5365",
1764 "brcm,bcm5389",
1765 "brcm,bcm5395",
1766 "brcm,bcm5397",
1767 "brcm,bcm5398",
1768 "brcm,bcm53010-srab",
1769 "brcm,bcm53011-srab",
1770 "brcm,bcm53012-srab",
1771 "brcm,bcm53018-srab",
1772 "brcm,bcm53019-srab",
1773 "brcm,bcm5301x-srab",
1774 "brcm,bcm11360-srab",
1775 "brcm,bcm58522-srab",
1776 "brcm,bcm58525-srab",
1777 "brcm,bcm58535-srab",
1778 "brcm,bcm58622-srab",
1779 "brcm,bcm58623-srab",
1780 "brcm,bcm58625-srab",
1781 "brcm,bcm88312-srab",
1782 "brcm,cygnus-srab",
1783 "brcm,nsp-srab",
1784 "brcm,omega-srab",
1785 "brcm,bcm3384-switch",
1786 "brcm,bcm6328-switch",
1787 "brcm,bcm6368-switch",
1788 "brcm,bcm63xx-switch",
1789 #endif
1790 #if IS_ENABLED(CONFIG_NET_DSA_BCM_SF2)
1791 "brcm,bcm7445-switch-v4.0",
1792 "brcm,bcm7278-switch-v4.0",
1793 "brcm,bcm7278-switch-v4.8",
1794 #endif
1795 #if IS_ENABLED(CONFIG_NET_DSA_LANTIQ_GSWIP)
1796 "lantiq,xrx200-gswip",
1797 "lantiq,xrx300-gswip",
1798 "lantiq,xrx330-gswip",
1799 #endif
1800 #if IS_ENABLED(CONFIG_NET_DSA_MV88E6060)
1801 "marvell,mv88e6060",
1802 #endif
1803 #if IS_ENABLED(CONFIG_NET_DSA_MV88E6XXX)
1804 "marvell,mv88e6085",
1805 "marvell,mv88e6190",
1806 "marvell,mv88e6250",
1807 #endif
1808 #if IS_ENABLED(CONFIG_NET_DSA_MICROCHIP_KSZ_COMMON)
1809 "microchip,ksz8765",
1810 "microchip,ksz8794",
1811 "microchip,ksz8795",
1812 "microchip,ksz8863",
1813 "microchip,ksz8873",
1814 "microchip,ksz9477",
1815 "microchip,ksz9897",
1816 "microchip,ksz9893",
1817 "microchip,ksz9563",
1818 "microchip,ksz8563",
1819 "microchip,ksz9567",
1820 #endif
1821 #if IS_ENABLED(CONFIG_NET_DSA_SMSC_LAN9303_MDIO)
1822 "smsc,lan9303-mdio",
1823 #endif
1824 #if IS_ENABLED(CONFIG_NET_DSA_SMSC_LAN9303_I2C)
1825 "smsc,lan9303-i2c",
1826 #endif
1827 NULL,
1828 };
1829
1830 static void dsa_shared_port_validate_of(struct dsa_port *dp,
1831 bool *missing_phy_mode,
1832 bool *missing_link_description)
1833 {
1834 struct device_node *dn = dp->dn, *phy_np;
1835 struct dsa_switch *ds = dp->ds;
1836 phy_interface_t mode;
1837
1838 *missing_phy_mode = false;
1839 *missing_link_description = false;
1840
1841 if (of_get_phy_mode(dn, &mode)) {
1842 *missing_phy_mode = true;
1843 dev_err(ds->dev,
1844 "OF node %pOF of %s port %d lacks the required \"phy-mode\" property\n",
1845 dn, dsa_port_is_cpu(dp) ? "CPU" : "DSA", dp->index);
1846 }
1847
1848 /* Note: of_phy_is_fixed_link() also returns true for
1849 * managed = "in-band-status"
1850 */
1851 if (of_phy_is_fixed_link(dn))
1852 return;
1853
1854 phy_np = of_parse_phandle(dn, "phy-handle", 0);
1855 if (phy_np) {
1856 of_node_put(phy_np);
1857 return;
1858 }
1859
1860 *missing_link_description = true;
1861
1862 dev_err(ds->dev,
1863 "OF node %pOF of %s port %d lacks the required \"phy-handle\", \"fixed-link\" or \"managed\" properties\n",
1864 dn, dsa_port_is_cpu(dp) ? "CPU" : "DSA", dp->index);
1865 }
1866
1867 static void dsa_shared_port_link_down(struct dsa_port *dp)
1868 {
1869 struct dsa_switch *ds = dp->ds;
1870
1871 if (ds->phylink_mac_ops && ds->phylink_mac_ops->mac_link_down)
1872 ds->phylink_mac_ops->mac_link_down(&dp->pl_config, MLO_AN_FIXED,
1873 PHY_INTERFACE_MODE_NA);
1874 else if (ds->ops->phylink_mac_link_down)
1875 ds->ops->phylink_mac_link_down(ds, dp->index, MLO_AN_FIXED,
1876 PHY_INTERFACE_MODE_NA);
1877 }
1878
1879 int dsa_shared_port_link_register_of(struct dsa_port *dp)
1880 {
1881 struct dsa_switch *ds = dp->ds;
1882 bool missing_link_description;
1883 bool missing_phy_mode;
1884
1885 dsa_shared_port_validate_of(dp, &missing_phy_mode,
1886 &missing_link_description);
1887
1888 if ((missing_phy_mode || missing_link_description) &&
1889 !of_device_compatible_match(ds->dev->of_node,
1890 dsa_switches_apply_workarounds))
1891 return -EINVAL;
1892
1893 if (missing_link_description) {
1894 dev_warn(ds->dev,
1895 "Skipping phylink registration for %s port %d\n",
1896 dsa_port_is_cpu(dp) ? "CPU" : "DSA", dp->index);
1897 } else {
1898 dsa_shared_port_link_down(dp);
1899
1900 return dsa_shared_port_phylink_register(dp);
1901 }
1902
1903 return 0;
1904 }
1905
1906 void dsa_shared_port_link_unregister_of(struct dsa_port *dp)
1907 {
1908 if (dp->pl) {
1909 rtnl_lock();
1910 phylink_disconnect_phy(dp->pl);
1911 rtnl_unlock();
1912 dsa_port_phylink_destroy(dp);
1913 return;
1914 }
1915 }
1916
1917 int dsa_port_hsr_join(struct dsa_port *dp, struct net_device *hsr,
1918 struct netlink_ext_ack *extack)
1919 {
1920 struct dsa_switch *ds = dp->ds;
1921 int err;
1922
1923 if (!ds->ops->port_hsr_join)
1924 return -EOPNOTSUPP;
1925
1926 dp->hsr_dev = hsr;
1927
1928 err = ds->ops->port_hsr_join(ds, dp->index, hsr, extack);
1929 if (err)
1930 dp->hsr_dev = NULL;
1931
1932 return err;
1933 }
1934
1935 void dsa_port_hsr_leave(struct dsa_port *dp, struct net_device *hsr)
1936 {
1937 struct dsa_switch *ds = dp->ds;
1938 int err;
1939
1940 dp->hsr_dev = NULL;
1941
1942 if (ds->ops->port_hsr_leave) {
1943 err = ds->ops->port_hsr_leave(ds, dp->index, hsr);
1944 if (err)
1945 dev_err(dp->ds->dev,
1946 "port %d failed to leave HSR %s: %pe\n",
1947 dp->index, hsr->name, ERR_PTR(err));
1948 }
1949 }
1950
1951 int dsa_port_tag_8021q_vlan_add(struct dsa_port *dp, u16 vid, bool broadcast)
1952 {
1953 struct dsa_notifier_tag_8021q_vlan_info info = {
1954 .dp = dp,
1955 .vid = vid,
1956 };
1957
1958 if (broadcast)
1959 return dsa_broadcast(DSA_NOTIFIER_TAG_8021Q_VLAN_ADD, &info);
1960
1961 return dsa_port_notify(dp, DSA_NOTIFIER_TAG_8021Q_VLAN_ADD, &info);
1962 }
1963
1964 void dsa_port_tag_8021q_vlan_del(struct dsa_port *dp, u16 vid, bool broadcast)
1965 {
1966 struct dsa_notifier_tag_8021q_vlan_info info = {
1967 .dp = dp,
1968 .vid = vid,
1969 };
1970 int err;
1971
1972 if (broadcast)
1973 err = dsa_broadcast(DSA_NOTIFIER_TAG_8021Q_VLAN_DEL, &info);
1974 else
1975 err = dsa_port_notify(dp, DSA_NOTIFIER_TAG_8021Q_VLAN_DEL, &info);
1976 if (err)
1977 dev_err(dp->ds->dev,
1978 "port %d failed to notify tag_8021q VLAN %d deletion: %pe\n",
1979 dp->index, vid, ERR_PTR(err));
1980 }
1981
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.