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 */
33static int dsa_port_notify(const struct dsa_port *dp, unsigned long e, void *v)
34{
35 return dsa_tree_notify(dst: dp->ds->dst, e, v);
36}
37
38static 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(val: SWITCHDEV_FDB_FLUSH_TO_BRIDGE,
52 dev: brport_dev, info: &info.info, NULL);
53}
54
55static 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, vid: 0);
66}
67
68static 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
84static 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(dev: 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
102static 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
117bool 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
135int 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
168static 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
181int 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(dev: dsa_port_to_bridge_port(dp), msti: state->msti,
193 state: &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, msti: state->msti);
210 if (err)
211 NL_SET_ERR_MSG_MOD(extack,
212 "Unable to flush associated VLANs");
213
214 return 0;
215}
216
217int 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, do_fast_age: false);
231
232 if (dp->pl)
233 phylink_start(dp->pl);
234
235 return 0;
236}
237
238int 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
249void 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, do_fast_age: false);
259
260 if (ds->ops->port_disable)
261 ds->ops->port_disable(ds, port);
262}
263
264void dsa_port_disable(struct dsa_port *dp)
265{
266 rtnl_lock();
267 dsa_port_disable_rt(dp);
268 rtnl_unlock();
269}
270
271static 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(dev: bridge.dev)) {
283 change_vlan_filtering = true;
284 vlan_filtering = true;
285 } else if (!ds->needs_standalone_vlan_filtering &&
286 br_vlan_enabled(dev: 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(dp: other_dp);
302
303 if (br && br_vlan_enabled(dev: 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: &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
325static 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(dev: 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
349static 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
370static 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, state: br_port_get_stp_state(dev: brport_dev), do_fast_age: false);
382 if (err && err != -EOPNOTSUPP)
383 return err;
384
385 err = dsa_port_vlan_filtering(dp, vlan_filtering: br_vlan_enabled(dev: br), extack);
386 if (err && err != -EOPNOTSUPP)
387 return err;
388
389 err = dsa_port_ageing_time(dp, ageing_clock: br_get_ageing_time(br_dev: br));
390 if (err && err != -EOPNOTSUPP)
391 return err;
392
393 return 0;
394}
395
396static 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, do_fast_age: 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
424static 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(dst: ds->dst, br);
432 if (bridge) {
433 refcount_inc(r: &bridge->refcount);
434 dp->bridge = bridge;
435 return 0;
436 }
437
438 bridge = kzalloc(size: sizeof(*bridge), GFP_KERNEL);
439 if (!bridge)
440 return -ENOMEM;
441
442 refcount_set(r: &bridge->refcount, n: 1);
443
444 bridge->dev = br;
445
446 bridge->num = dsa_bridge_num_get(bridge_dev: br, max: 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(objp: bridge);
451 return -EOPNOTSUPP;
452 }
453
454 dp->bridge = bridge;
455
456 return 0;
457}
458
459static 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(r: &bridge->refcount))
467 return;
468
469 if (bridge->num)
470 dsa_bridge_num_put(bridge_dev: br, bridge_num: bridge->num);
471
472 kfree(objp: bridge);
473}
474
475static 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
485int 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(dev: 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(e: DSA_NOTIFIER_BRIDGE_JOIN, v: &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, ctx: dp,
517 atomic_nb: &dsa_user_switchdev_notifier,
518 blocking_nb: &dsa_user_switchdev_blocking_notifier,
519 tx_fwd_offload: 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
529out_rollback_unoffload:
530 switchdev_bridge_port_unoffload(brport_dev, ctx: dp,
531 atomic_nb: &dsa_user_switchdev_notifier,
532 blocking_nb: &dsa_user_switchdev_blocking_notifier);
533 dsa_flush_workqueue();
534out_rollback_unbridge:
535 dsa_broadcast(e: DSA_NOTIFIER_BRIDGE_LEAVE, v: &info);
536out_rollback:
537 dsa_port_bridge_destroy(dp, br);
538 return err;
539}
540
541void 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, ctx: dp,
550 atomic_nb: &dsa_user_switchdev_notifier,
551 blocking_nb: &dsa_user_switchdev_blocking_notifier);
552
553 dsa_flush_workqueue();
554}
555
556void 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(e: DSA_NOTIFIER_BRIDGE_LEAVE, v: &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, bridge: info.bridge);
583}
584
585int 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, e: DSA_NOTIFIER_LAG_CHANGE, v: &info);
609}
610
611static 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(dst: ds->dst, lag_dev);
618 if (lag) {
619 refcount_inc(r: &lag->refcount);
620 dp->lag = lag;
621 return 0;
622 }
623
624 lag = kzalloc(size: sizeof(*lag), GFP_KERNEL);
625 if (!lag)
626 return -ENOMEM;
627
628 refcount_set(r: &lag->refcount, n: 1);
629 mutex_init(&lag->fdb_lock);
630 INIT_LIST_HEAD(list: &lag->fdbs);
631 lag->dev = lag_dev;
632 dsa_lag_map(dst: ds->dst, lag);
633 dp->lag = lag;
634
635 return 0;
636}
637
638static 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(r: &lag->refcount))
646 return;
647
648 WARN_ON(!list_empty(&lag->fdbs));
649 dsa_lag_unmap(dst: dp->ds->dst, lag);
650 kfree(objp: lag);
651}
652
653int 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, e: DSA_NOTIFIER_LAG_JOIN, v: &info);
671 if (err)
672 goto err_lag_join;
673
674 bridge_dev = netdev_master_upper_dev_get(dev: lag_dev);
675 if (!bridge_dev || !netif_is_bridge_master(dev: bridge_dev))
676 return 0;
677
678 err = dsa_port_bridge_join(dp, br: bridge_dev, extack);
679 if (err)
680 goto err_bridge_join;
681
682 return 0;
683
684err_bridge_join:
685 dsa_port_notify(dp, e: DSA_NOTIFIER_LAG_LEAVE, v: &info);
686err_lag_join:
687 dsa_port_lag_destroy(dp);
688err_lag_create:
689 return err;
690}
691
692void 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
700void 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, e: DSA_NOTIFIER_LAG_LEAVE, v: &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() */
729static 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(dev: upper_dev))
752 continue;
753
754 vid = vlan_dev_vlan_id(dev: 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(dev: br, vid, p_vinfo: &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(dp: 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(dev: 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
795int 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(dev: 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(dev: dp->user,
847 vlan_filtering);
848 if (err)
849 goto restore;
850 }
851
852 return 0;
853
854restore:
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 */
868bool 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(dev: br);
877}
878
879int dsa_port_ageing_time(struct dsa_port *dp, clock_t ageing_clock)
880{
881 unsigned long ageing_jiffies = clock_t_to_jiffies(x: ageing_clock);
882 unsigned int ageing_time = jiffies_to_msecs(j: 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, e: DSA_NOTIFIER_AGEING_TIME, v: &info);
889 if (err)
890 return err;
891
892 dp->ageing_time = ageing_time;
893
894 return 0;
895}
896
897int 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
908int 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
920int 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
951void 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
959int 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
970int 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, e: DSA_NOTIFIER_MTU, v: &info);
978}
979
980int 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, e: DSA_NOTIFIER_FDB_ADD, v: &info);
1001}
1002
1003int 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, e: DSA_NOTIFIER_FDB_DEL, v: &info);
1020}
1021
1022static 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, e: DSA_NOTIFIER_HOST_FDB_ADD, v: &info);
1034}
1035
1036int 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
1047int 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(dev: conduit, addr);
1066 if (err)
1067 return err;
1068 }
1069
1070 return dsa_port_host_fdb_add(dp, addr, vid, db);
1071}
1072
1073static 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, e: DSA_NOTIFIER_HOST_FDB_DEL, v: &info);
1085}
1086
1087int 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
1098int 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(dev: conduit, addr);
1113 if (err)
1114 return err;
1115 }
1116
1117 return dsa_port_host_fdb_del(dp, addr, vid, db);
1118}
1119
1120int 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, e: DSA_NOTIFIER_LAG_FDB_ADD, v: &info);
1137}
1138
1139int 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, e: DSA_NOTIFIER_LAG_FDB_DEL, v: &info);
1156}
1157
1158int 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
1169int 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, e: DSA_NOTIFIER_MDB_ADD, v: &info);
1185}
1186
1187int 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, e: DSA_NOTIFIER_MDB_DEL, v: &info);
1203}
1204
1205static 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, e: DSA_NOTIFIER_HOST_MDB_ADD, v: &info);
1216}
1217
1218int 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
1229int 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(dev: conduit, addr: mdb->addr);
1243 if (err)
1244 return err;
1245
1246 return dsa_port_host_mdb_add(dp, mdb, db);
1247}
1248
1249static 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, e: DSA_NOTIFIER_HOST_MDB_DEL, v: &info);
1260}
1261
1262int 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
1273int 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(dev: conduit, addr: mdb->addr);
1287 if (err)
1288 return err;
1289
1290 return dsa_port_host_mdb_del(dp, mdb, db);
1291}
1292
1293int 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, e: DSA_NOTIFIER_VLAN_ADD, v: &info);
1304}
1305
1306int 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, e: DSA_NOTIFIER_VLAN_DEL, v: &info);
1315}
1316
1317int 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, e: DSA_NOTIFIER_HOST_VLAN_ADD, v: &info);
1330 if (err && err != -EOPNOTSUPP)
1331 return err;
1332
1333 vlan_vid_add(dev: conduit, htons(ETH_P_8021Q), vid: vlan->vid);
1334
1335 return err;
1336}
1337
1338int 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, e: DSA_NOTIFIER_HOST_VLAN_DEL, v: &info);
1349 if (err && err != -EOPNOTSUPP)
1350 return err;
1351
1352 vlan_vid_del(dev: conduit, htons(ETH_P_8021Q), vid: vlan->vid);
1353
1354 return err;
1355}
1356
1357int 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
1368int 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
1379int 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
1390int 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
1401static 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(dev: 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 */
1431int 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, br: bridge_dev);
1447 dsa_port_bridge_leave(dp, br: 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, vlan_filtering: 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 err = dsa_port_assign_conduit(dp, conduit, extack, fail_on_err: true);
1471 if (err)
1472 goto rewind_old_addrs;
1473
1474 dsa_user_sync_ha(dev);
1475
1476 if (vlan_filtering) {
1477 err = dsa_user_manage_vlan_filtering(dev, vlan_filtering: true);
1478 if (err) {
1479 NL_SET_ERR_MSG_MOD(extack,
1480 "Failed to restore standalone VLANs");
1481 goto rewind_new_addrs;
1482 }
1483 }
1484
1485 if (bridge_dev) {
1486 err = dsa_port_bridge_join(dp, br: bridge_dev, extack);
1487 if (err && err == -EOPNOTSUPP) {
1488 NL_SET_ERR_MSG_MOD(extack,
1489 "Failed to reoffload bridge");
1490 goto rewind_new_vlan;
1491 }
1492 }
1493
1494 return 0;
1495
1496rewind_new_vlan:
1497 if (vlan_filtering)
1498 dsa_user_manage_vlan_filtering(dev, vlan_filtering: false);
1499
1500rewind_new_addrs:
1501 dsa_user_unsync_ha(dev);
1502
1503 dsa_port_assign_conduit(dp, conduit: old_conduit, NULL, fail_on_err: false);
1504
1505/* Restore the objects on the old CPU port */
1506rewind_old_addrs:
1507 dsa_user_sync_ha(dev);
1508
1509 if (vlan_filtering) {
1510 tmp = dsa_user_manage_vlan_filtering(dev, vlan_filtering: true);
1511 if (tmp) {
1512 dev_err(ds->dev,
1513 "port %d failed to restore standalone VLANs: %pe\n",
1514 dp->index, ERR_PTR(tmp));
1515 }
1516 }
1517
1518rewind_old_bridge:
1519 if (bridge_dev) {
1520 tmp = dsa_port_bridge_join(dp, br: bridge_dev, extack);
1521 if (tmp) {
1522 dev_err(ds->dev,
1523 "port %d failed to rejoin bridge %s: %pe\n",
1524 dp->index, bridge_dev->name, ERR_PTR(tmp));
1525 }
1526 }
1527
1528 return err;
1529}
1530
1531void dsa_port_set_tag_protocol(struct dsa_port *cpu_dp,
1532 const struct dsa_device_ops *tag_ops)
1533{
1534 cpu_dp->rcv = tag_ops->rcv;
1535 cpu_dp->tag_ops = tag_ops;
1536}
1537
1538static struct phy_device *dsa_port_get_phy_device(struct dsa_port *dp)
1539{
1540 struct device_node *phy_dn;
1541 struct phy_device *phydev;
1542
1543 phy_dn = of_parse_phandle(np: dp->dn, phandle_name: "phy-handle", index: 0);
1544 if (!phy_dn)
1545 return NULL;
1546
1547 phydev = of_phy_find_device(phy_np: phy_dn);
1548 if (!phydev) {
1549 of_node_put(node: phy_dn);
1550 return ERR_PTR(error: -EPROBE_DEFER);
1551 }
1552
1553 of_node_put(node: phy_dn);
1554 return phydev;
1555}
1556
1557static struct phylink_pcs *
1558dsa_port_phylink_mac_select_pcs(struct phylink_config *config,
1559 phy_interface_t interface)
1560{
1561 struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
1562 struct phylink_pcs *pcs = ERR_PTR(error: -EOPNOTSUPP);
1563 struct dsa_switch *ds = dp->ds;
1564
1565 if (ds->ops->phylink_mac_select_pcs)
1566 pcs = ds->ops->phylink_mac_select_pcs(ds, dp->index, interface);
1567
1568 return pcs;
1569}
1570
1571static int dsa_port_phylink_mac_prepare(struct phylink_config *config,
1572 unsigned int mode,
1573 phy_interface_t interface)
1574{
1575 struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
1576 struct dsa_switch *ds = dp->ds;
1577 int err = 0;
1578
1579 if (ds->ops->phylink_mac_prepare)
1580 err = ds->ops->phylink_mac_prepare(ds, dp->index, mode,
1581 interface);
1582
1583 return err;
1584}
1585
1586static void dsa_port_phylink_mac_config(struct phylink_config *config,
1587 unsigned int mode,
1588 const struct phylink_link_state *state)
1589{
1590 struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
1591 struct dsa_switch *ds = dp->ds;
1592
1593 if (!ds->ops->phylink_mac_config)
1594 return;
1595
1596 ds->ops->phylink_mac_config(ds, dp->index, mode, state);
1597}
1598
1599static int dsa_port_phylink_mac_finish(struct phylink_config *config,
1600 unsigned int mode,
1601 phy_interface_t interface)
1602{
1603 struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
1604 struct dsa_switch *ds = dp->ds;
1605 int err = 0;
1606
1607 if (ds->ops->phylink_mac_finish)
1608 err = ds->ops->phylink_mac_finish(ds, dp->index, mode,
1609 interface);
1610
1611 return err;
1612}
1613
1614static void dsa_port_phylink_mac_link_down(struct phylink_config *config,
1615 unsigned int mode,
1616 phy_interface_t interface)
1617{
1618 struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
1619 struct phy_device *phydev = NULL;
1620 struct dsa_switch *ds = dp->ds;
1621
1622 if (dsa_port_is_user(dp))
1623 phydev = dp->user->phydev;
1624
1625 if (!ds->ops->phylink_mac_link_down) {
1626 if (ds->ops->adjust_link && phydev)
1627 ds->ops->adjust_link(ds, dp->index, phydev);
1628 return;
1629 }
1630
1631 ds->ops->phylink_mac_link_down(ds, dp->index, mode, interface);
1632}
1633
1634static void dsa_port_phylink_mac_link_up(struct phylink_config *config,
1635 struct phy_device *phydev,
1636 unsigned int mode,
1637 phy_interface_t interface,
1638 int speed, int duplex,
1639 bool tx_pause, bool rx_pause)
1640{
1641 struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
1642 struct dsa_switch *ds = dp->ds;
1643
1644 if (!ds->ops->phylink_mac_link_up) {
1645 if (ds->ops->adjust_link && phydev)
1646 ds->ops->adjust_link(ds, dp->index, phydev);
1647 return;
1648 }
1649
1650 ds->ops->phylink_mac_link_up(ds, dp->index, mode, interface, phydev,
1651 speed, duplex, tx_pause, rx_pause);
1652}
1653
1654static const struct phylink_mac_ops dsa_port_phylink_mac_ops = {
1655 .mac_select_pcs = dsa_port_phylink_mac_select_pcs,
1656 .mac_prepare = dsa_port_phylink_mac_prepare,
1657 .mac_config = dsa_port_phylink_mac_config,
1658 .mac_finish = dsa_port_phylink_mac_finish,
1659 .mac_link_down = dsa_port_phylink_mac_link_down,
1660 .mac_link_up = dsa_port_phylink_mac_link_up,
1661};
1662
1663int dsa_port_phylink_create(struct dsa_port *dp)
1664{
1665 struct dsa_switch *ds = dp->ds;
1666 phy_interface_t mode;
1667 struct phylink *pl;
1668 int err;
1669
1670 err = of_get_phy_mode(np: dp->dn, interface: &mode);
1671 if (err)
1672 mode = PHY_INTERFACE_MODE_NA;
1673
1674 if (ds->ops->phylink_get_caps) {
1675 ds->ops->phylink_get_caps(ds, dp->index, &dp->pl_config);
1676 } else {
1677 /* For legacy drivers */
1678 if (mode != PHY_INTERFACE_MODE_NA) {
1679 __set_bit(mode, dp->pl_config.supported_interfaces);
1680 } else {
1681 __set_bit(PHY_INTERFACE_MODE_INTERNAL,
1682 dp->pl_config.supported_interfaces);
1683 __set_bit(PHY_INTERFACE_MODE_GMII,
1684 dp->pl_config.supported_interfaces);
1685 }
1686 }
1687
1688 pl = phylink_create(&dp->pl_config, of_fwnode_handle(dp->dn),
1689 mode, &dsa_port_phylink_mac_ops);
1690 if (IS_ERR(ptr: pl)) {
1691 pr_err("error creating PHYLINK: %ld\n", PTR_ERR(pl));
1692 return PTR_ERR(ptr: pl);
1693 }
1694
1695 dp->pl = pl;
1696
1697 return 0;
1698}
1699
1700void dsa_port_phylink_destroy(struct dsa_port *dp)
1701{
1702 phylink_destroy(dp->pl);
1703 dp->pl = NULL;
1704}
1705
1706static int dsa_shared_port_setup_phy_of(struct dsa_port *dp, bool enable)
1707{
1708 struct dsa_switch *ds = dp->ds;
1709 struct phy_device *phydev;
1710 int port = dp->index;
1711 int err = 0;
1712
1713 phydev = dsa_port_get_phy_device(dp);
1714 if (!phydev)
1715 return 0;
1716
1717 if (IS_ERR(ptr: phydev))
1718 return PTR_ERR(ptr: phydev);
1719
1720 if (enable) {
1721 err = genphy_resume(phydev);
1722 if (err < 0)
1723 goto err_put_dev;
1724
1725 err = genphy_read_status(phydev);
1726 if (err < 0)
1727 goto err_put_dev;
1728 } else {
1729 err = genphy_suspend(phydev);
1730 if (err < 0)
1731 goto err_put_dev;
1732 }
1733
1734 if (ds->ops->adjust_link)
1735 ds->ops->adjust_link(ds, port, phydev);
1736
1737 dev_dbg(ds->dev, "enabled port's phy: %s", phydev_name(phydev));
1738
1739err_put_dev:
1740 put_device(dev: &phydev->mdio.dev);
1741 return err;
1742}
1743
1744static int dsa_shared_port_fixed_link_register_of(struct dsa_port *dp)
1745{
1746 struct device_node *dn = dp->dn;
1747 struct dsa_switch *ds = dp->ds;
1748 struct phy_device *phydev;
1749 int port = dp->index;
1750 phy_interface_t mode;
1751 int err;
1752
1753 err = of_phy_register_fixed_link(np: dn);
1754 if (err) {
1755 dev_err(ds->dev,
1756 "failed to register the fixed PHY of port %d\n",
1757 port);
1758 return err;
1759 }
1760
1761 phydev = of_phy_find_device(phy_np: dn);
1762
1763 err = of_get_phy_mode(np: dn, interface: &mode);
1764 if (err)
1765 mode = PHY_INTERFACE_MODE_NA;
1766 phydev->interface = mode;
1767
1768 genphy_read_status(phydev);
1769
1770 if (ds->ops->adjust_link)
1771 ds->ops->adjust_link(ds, port, phydev);
1772
1773 put_device(dev: &phydev->mdio.dev);
1774
1775 return 0;
1776}
1777
1778static int dsa_shared_port_phylink_register(struct dsa_port *dp)
1779{
1780 struct dsa_switch *ds = dp->ds;
1781 struct device_node *port_dn = dp->dn;
1782 int err;
1783
1784 dp->pl_config.dev = ds->dev;
1785 dp->pl_config.type = PHYLINK_DEV;
1786
1787 err = dsa_port_phylink_create(dp);
1788 if (err)
1789 return err;
1790
1791 err = phylink_of_phy_connect(dp->pl, port_dn, flags: 0);
1792 if (err && err != -ENODEV) {
1793 pr_err("could not attach to PHY: %d\n", err);
1794 goto err_phy_connect;
1795 }
1796
1797 return 0;
1798
1799err_phy_connect:
1800 dsa_port_phylink_destroy(dp);
1801 return err;
1802}
1803
1804/* During the initial DSA driver migration to OF, port nodes were sometimes
1805 * added to device trees with no indication of how they should operate from a
1806 * link management perspective (phy-handle, fixed-link, etc). Additionally, the
1807 * phy-mode may be absent. The interpretation of these port OF nodes depends on
1808 * their type.
1809 *
1810 * User ports with no phy-handle or fixed-link are expected to connect to an
1811 * internal PHY located on the ds->user_mii_bus at an MDIO address equal to
1812 * the port number. This description is still actively supported.
1813 *
1814 * Shared (CPU and DSA) ports with no phy-handle or fixed-link are expected to
1815 * operate at the maximum speed that their phy-mode is capable of. If the
1816 * phy-mode is absent, they are expected to operate using the phy-mode
1817 * supported by the port that gives the highest link speed. It is unspecified
1818 * if the port should use flow control or not, half duplex or full duplex, or
1819 * if the phy-mode is a SERDES link, whether in-band autoneg is expected to be
1820 * enabled or not.
1821 *
1822 * In the latter case of shared ports, omitting the link management description
1823 * from the firmware node is deprecated and strongly discouraged. DSA uses
1824 * phylink, which rejects the firmware nodes of these ports for lacking
1825 * required properties.
1826 *
1827 * For switches in this table, DSA will skip enforcing validation and will
1828 * later omit registering a phylink instance for the shared ports, if they lack
1829 * a fixed-link, a phy-handle, or a managed = "in-band-status" property.
1830 * It becomes the responsibility of the driver to ensure that these ports
1831 * operate at the maximum speed (whatever this means) and will interoperate
1832 * with the DSA conduit or other cascade port, since phylink methods will not be
1833 * invoked for them.
1834 *
1835 * If you are considering expanding this table for newly introduced switches,
1836 * think again. It is OK to remove switches from this table if there aren't DT
1837 * blobs in circulation which rely on defaulting the shared ports.
1838 */
1839static const char * const dsa_switches_apply_workarounds[] = {
1840#if IS_ENABLED(CONFIG_NET_DSA_XRS700X)
1841 "arrow,xrs7003e",
1842 "arrow,xrs7003f",
1843 "arrow,xrs7004e",
1844 "arrow,xrs7004f",
1845#endif
1846#if IS_ENABLED(CONFIG_B53)
1847 "brcm,bcm5325",
1848 "brcm,bcm53115",
1849 "brcm,bcm53125",
1850 "brcm,bcm53128",
1851 "brcm,bcm5365",
1852 "brcm,bcm5389",
1853 "brcm,bcm5395",
1854 "brcm,bcm5397",
1855 "brcm,bcm5398",
1856 "brcm,bcm53010-srab",
1857 "brcm,bcm53011-srab",
1858 "brcm,bcm53012-srab",
1859 "brcm,bcm53018-srab",
1860 "brcm,bcm53019-srab",
1861 "brcm,bcm5301x-srab",
1862 "brcm,bcm11360-srab",
1863 "brcm,bcm58522-srab",
1864 "brcm,bcm58525-srab",
1865 "brcm,bcm58535-srab",
1866 "brcm,bcm58622-srab",
1867 "brcm,bcm58623-srab",
1868 "brcm,bcm58625-srab",
1869 "brcm,bcm88312-srab",
1870 "brcm,cygnus-srab",
1871 "brcm,nsp-srab",
1872 "brcm,omega-srab",
1873 "brcm,bcm3384-switch",
1874 "brcm,bcm6328-switch",
1875 "brcm,bcm6368-switch",
1876 "brcm,bcm63xx-switch",
1877#endif
1878#if IS_ENABLED(CONFIG_NET_DSA_BCM_SF2)
1879 "brcm,bcm7445-switch-v4.0",
1880 "brcm,bcm7278-switch-v4.0",
1881 "brcm,bcm7278-switch-v4.8",
1882#endif
1883#if IS_ENABLED(CONFIG_NET_DSA_LANTIQ_GSWIP)
1884 "lantiq,xrx200-gswip",
1885 "lantiq,xrx300-gswip",
1886 "lantiq,xrx330-gswip",
1887#endif
1888#if IS_ENABLED(CONFIG_NET_DSA_MV88E6060)
1889 "marvell,mv88e6060",
1890#endif
1891#if IS_ENABLED(CONFIG_NET_DSA_MV88E6XXX)
1892 "marvell,mv88e6085",
1893 "marvell,mv88e6190",
1894 "marvell,mv88e6250",
1895#endif
1896#if IS_ENABLED(CONFIG_NET_DSA_MICROCHIP_KSZ_COMMON)
1897 "microchip,ksz8765",
1898 "microchip,ksz8794",
1899 "microchip,ksz8795",
1900 "microchip,ksz8863",
1901 "microchip,ksz8873",
1902 "microchip,ksz9477",
1903 "microchip,ksz9897",
1904 "microchip,ksz9893",
1905 "microchip,ksz9563",
1906 "microchip,ksz8563",
1907 "microchip,ksz9567",
1908#endif
1909#if IS_ENABLED(CONFIG_NET_DSA_SMSC_LAN9303_MDIO)
1910 "smsc,lan9303-mdio",
1911#endif
1912#if IS_ENABLED(CONFIG_NET_DSA_SMSC_LAN9303_I2C)
1913 "smsc,lan9303-i2c",
1914#endif
1915 NULL,
1916};
1917
1918static void dsa_shared_port_validate_of(struct dsa_port *dp,
1919 bool *missing_phy_mode,
1920 bool *missing_link_description)
1921{
1922 struct device_node *dn = dp->dn, *phy_np;
1923 struct dsa_switch *ds = dp->ds;
1924 phy_interface_t mode;
1925
1926 *missing_phy_mode = false;
1927 *missing_link_description = false;
1928
1929 if (of_get_phy_mode(np: dn, interface: &mode)) {
1930 *missing_phy_mode = true;
1931 dev_err(ds->dev,
1932 "OF node %pOF of %s port %d lacks the required \"phy-mode\" property\n",
1933 dn, dsa_port_is_cpu(dp) ? "CPU" : "DSA", dp->index);
1934 }
1935
1936 /* Note: of_phy_is_fixed_link() also returns true for
1937 * managed = "in-band-status"
1938 */
1939 if (of_phy_is_fixed_link(np: dn))
1940 return;
1941
1942 phy_np = of_parse_phandle(np: dn, phandle_name: "phy-handle", index: 0);
1943 if (phy_np) {
1944 of_node_put(node: phy_np);
1945 return;
1946 }
1947
1948 *missing_link_description = true;
1949
1950 dev_err(ds->dev,
1951 "OF node %pOF of %s port %d lacks the required \"phy-handle\", \"fixed-link\" or \"managed\" properties\n",
1952 dn, dsa_port_is_cpu(dp) ? "CPU" : "DSA", dp->index);
1953}
1954
1955int dsa_shared_port_link_register_of(struct dsa_port *dp)
1956{
1957 struct dsa_switch *ds = dp->ds;
1958 bool missing_link_description;
1959 bool missing_phy_mode;
1960 int port = dp->index;
1961
1962 dsa_shared_port_validate_of(dp, missing_phy_mode: &missing_phy_mode,
1963 missing_link_description: &missing_link_description);
1964
1965 if ((missing_phy_mode || missing_link_description) &&
1966 !of_device_compatible_match(device: ds->dev->of_node,
1967 compat: dsa_switches_apply_workarounds))
1968 return -EINVAL;
1969
1970 if (!ds->ops->adjust_link) {
1971 if (missing_link_description) {
1972 dev_warn(ds->dev,
1973 "Skipping phylink registration for %s port %d\n",
1974 dsa_port_is_cpu(dp) ? "CPU" : "DSA", dp->index);
1975 } else {
1976 if (ds->ops->phylink_mac_link_down)
1977 ds->ops->phylink_mac_link_down(ds, port,
1978 MLO_AN_FIXED, PHY_INTERFACE_MODE_NA);
1979
1980 return dsa_shared_port_phylink_register(dp);
1981 }
1982 return 0;
1983 }
1984
1985 dev_warn(ds->dev,
1986 "Using legacy PHYLIB callbacks. Please migrate to PHYLINK!\n");
1987
1988 if (of_phy_is_fixed_link(np: dp->dn))
1989 return dsa_shared_port_fixed_link_register_of(dp);
1990 else
1991 return dsa_shared_port_setup_phy_of(dp, enable: true);
1992}
1993
1994void dsa_shared_port_link_unregister_of(struct dsa_port *dp)
1995{
1996 struct dsa_switch *ds = dp->ds;
1997
1998 if (!ds->ops->adjust_link && dp->pl) {
1999 rtnl_lock();
2000 phylink_disconnect_phy(dp->pl);
2001 rtnl_unlock();
2002 dsa_port_phylink_destroy(dp);
2003 return;
2004 }
2005
2006 if (of_phy_is_fixed_link(np: dp->dn))
2007 of_phy_deregister_fixed_link(np: dp->dn);
2008 else
2009 dsa_shared_port_setup_phy_of(dp, enable: false);
2010}
2011
2012int dsa_port_hsr_join(struct dsa_port *dp, struct net_device *hsr,
2013 struct netlink_ext_ack *extack)
2014{
2015 struct dsa_switch *ds = dp->ds;
2016 int err;
2017
2018 if (!ds->ops->port_hsr_join)
2019 return -EOPNOTSUPP;
2020
2021 dp->hsr_dev = hsr;
2022
2023 err = ds->ops->port_hsr_join(ds, dp->index, hsr, extack);
2024 if (err)
2025 dp->hsr_dev = NULL;
2026
2027 return err;
2028}
2029
2030void dsa_port_hsr_leave(struct dsa_port *dp, struct net_device *hsr)
2031{
2032 struct dsa_switch *ds = dp->ds;
2033 int err;
2034
2035 dp->hsr_dev = NULL;
2036
2037 if (ds->ops->port_hsr_leave) {
2038 err = ds->ops->port_hsr_leave(ds, dp->index, hsr);
2039 if (err)
2040 dev_err(dp->ds->dev,
2041 "port %d failed to leave HSR %s: %pe\n",
2042 dp->index, hsr->name, ERR_PTR(err));
2043 }
2044}
2045
2046int dsa_port_tag_8021q_vlan_add(struct dsa_port *dp, u16 vid, bool broadcast)
2047{
2048 struct dsa_notifier_tag_8021q_vlan_info info = {
2049 .dp = dp,
2050 .vid = vid,
2051 };
2052
2053 if (broadcast)
2054 return dsa_broadcast(e: DSA_NOTIFIER_TAG_8021Q_VLAN_ADD, v: &info);
2055
2056 return dsa_port_notify(dp, e: DSA_NOTIFIER_TAG_8021Q_VLAN_ADD, v: &info);
2057}
2058
2059void dsa_port_tag_8021q_vlan_del(struct dsa_port *dp, u16 vid, bool broadcast)
2060{
2061 struct dsa_notifier_tag_8021q_vlan_info info = {
2062 .dp = dp,
2063 .vid = vid,
2064 };
2065 int err;
2066
2067 if (broadcast)
2068 err = dsa_broadcast(e: DSA_NOTIFIER_TAG_8021Q_VLAN_DEL, v: &info);
2069 else
2070 err = dsa_port_notify(dp, e: DSA_NOTIFIER_TAG_8021Q_VLAN_DEL, v: &info);
2071 if (err)
2072 dev_err(dp->ds->dev,
2073 "port %d failed to notify tag_8021q VLAN %d deletion: %pe\n",
2074 dp->index, vid, ERR_PTR(err));
2075}
2076

source code of linux/net/dsa/port.c