Loading...
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/notifier.h>
11#include <linux/of_mdio.h>
12#include <linux/of_net.h>
13
14#include "dsa_priv.h"
15
16/**
17 * dsa_port_notify - Notify the switching fabric of changes to a port
18 * @dp: port on which change occurred
19 * @e: event, must be of type DSA_NOTIFIER_*
20 * @v: event-specific value.
21 *
22 * Notify all switches in the DSA tree that this port's switch belongs to,
23 * including this switch itself, of an event. Allows the other switches to
24 * reconfigure themselves for cross-chip operations. Can also be used to
25 * reconfigure ports without net_devices (CPU ports, DSA links) whenever
26 * a user port's state changes.
27 */
28static int dsa_port_notify(const struct dsa_port *dp, unsigned long e, void *v)
29{
30 return dsa_tree_notify(dp->ds->dst, e, v);
31}
32
33int dsa_port_set_state(struct dsa_port *dp, u8 state)
34{
35 struct dsa_switch *ds = dp->ds;
36 int port = dp->index;
37
38 if (!ds->ops->port_stp_state_set)
39 return -EOPNOTSUPP;
40
41 ds->ops->port_stp_state_set(ds, port, state);
42
43 if (ds->ops->port_fast_age) {
44 /* Fast age FDB entries or flush appropriate forwarding database
45 * for the given port, if we are moving it from Learning or
46 * Forwarding state, to Disabled or Blocking or Listening state.
47 */
48
49 if ((dp->stp_state == BR_STATE_LEARNING ||
50 dp->stp_state == BR_STATE_FORWARDING) &&
51 (state == BR_STATE_DISABLED ||
52 state == BR_STATE_BLOCKING ||
53 state == BR_STATE_LISTENING))
54 ds->ops->port_fast_age(ds, port);
55 }
56
57 dp->stp_state = state;
58
59 return 0;
60}
61
62static void dsa_port_set_state_now(struct dsa_port *dp, u8 state)
63{
64 int err;
65
66 err = dsa_port_set_state(dp, state);
67 if (err)
68 pr_err("DSA: failed to set STP state %u (%d)\n", state, err);
69}
70
71int dsa_port_enable_rt(struct dsa_port *dp, struct phy_device *phy)
72{
73 struct dsa_switch *ds = dp->ds;
74 int port = dp->index;
75 int err;
76
77 if (ds->ops->port_enable) {
78 err = ds->ops->port_enable(ds, port, phy);
79 if (err)
80 return err;
81 }
82
83 if (!dp->bridge_dev)
84 dsa_port_set_state_now(dp, BR_STATE_FORWARDING);
85
86 if (dp->pl)
87 phylink_start(dp->pl);
88
89 return 0;
90}
91
92int dsa_port_enable(struct dsa_port *dp, struct phy_device *phy)
93{
94 int err;
95
96 rtnl_lock();
97 err = dsa_port_enable_rt(dp, phy);
98 rtnl_unlock();
99
100 return err;
101}
102
103void dsa_port_disable_rt(struct dsa_port *dp)
104{
105 struct dsa_switch *ds = dp->ds;
106 int port = dp->index;
107
108 if (dp->pl)
109 phylink_stop(dp->pl);
110
111 if (!dp->bridge_dev)
112 dsa_port_set_state_now(dp, BR_STATE_DISABLED);
113
114 if (ds->ops->port_disable)
115 ds->ops->port_disable(ds, port);
116}
117
118void dsa_port_disable(struct dsa_port *dp)
119{
120 rtnl_lock();
121 dsa_port_disable_rt(dp);
122 rtnl_unlock();
123}
124
125static int dsa_port_inherit_brport_flags(struct dsa_port *dp,
126 struct netlink_ext_ack *extack)
127{
128 const unsigned long mask = BR_LEARNING | BR_FLOOD | BR_MCAST_FLOOD |
129 BR_BCAST_FLOOD;
130 struct net_device *brport_dev = dsa_port_to_bridge_port(dp);
131 int flag, err;
132
133 for_each_set_bit(flag, &mask, 32) {
134 struct switchdev_brport_flags flags = {0};
135
136 flags.mask = BIT(flag);
137
138 if (br_port_flag_is_set(brport_dev, BIT(flag)))
139 flags.val = BIT(flag);
140
141 err = dsa_port_bridge_flags(dp, flags, extack);
142 if (err && err != -EOPNOTSUPP)
143 return err;
144 }
145
146 return 0;
147}
148
149static void dsa_port_clear_brport_flags(struct dsa_port *dp)
150{
151 const unsigned long val = BR_FLOOD | BR_MCAST_FLOOD | BR_BCAST_FLOOD;
152 const unsigned long mask = BR_LEARNING | BR_FLOOD | BR_MCAST_FLOOD |
153 BR_BCAST_FLOOD;
154 int flag, err;
155
156 for_each_set_bit(flag, &mask, 32) {
157 struct switchdev_brport_flags flags = {0};
158
159 flags.mask = BIT(flag);
160 flags.val = val & BIT(flag);
161
162 err = dsa_port_bridge_flags(dp, flags, NULL);
163 if (err && err != -EOPNOTSUPP)
164 dev_err(dp->ds->dev,
165 "failed to clear bridge port flag %lu: %pe\n",
166 flags.val, ERR_PTR(err));
167 }
168}
169
170static int dsa_port_switchdev_sync(struct dsa_port *dp,
171 struct netlink_ext_ack *extack)
172{
173 struct net_device *brport_dev = dsa_port_to_bridge_port(dp);
174 struct net_device *br = dp->bridge_dev;
175 int err;
176
177 err = dsa_port_inherit_brport_flags(dp, extack);
178 if (err)
179 return err;
180
181 err = dsa_port_set_state(dp, br_port_get_stp_state(brport_dev));
182 if (err && err != -EOPNOTSUPP)
183 return err;
184
185 err = dsa_port_vlan_filtering(dp, br_vlan_enabled(br), extack);
186 if (err && err != -EOPNOTSUPP)
187 return err;
188
189 err = dsa_port_ageing_time(dp, br_get_ageing_time(br));
190 if (err && err != -EOPNOTSUPP)
191 return err;
192
193 err = br_mdb_replay(br, brport_dev, dp, true,
194 &dsa_slave_switchdev_blocking_notifier, extack);
195 if (err && err != -EOPNOTSUPP)
196 return err;
197
198 /* Forwarding and termination FDB entries on the port */
199 err = br_fdb_replay(br, brport_dev, dp, true,
200 &dsa_slave_switchdev_notifier);
201 if (err && err != -EOPNOTSUPP)
202 return err;
203
204 /* Termination FDB entries on the bridge itself */
205 err = br_fdb_replay(br, br, dp, true, &dsa_slave_switchdev_notifier);
206 if (err && err != -EOPNOTSUPP)
207 return err;
208
209 err = br_vlan_replay(br, brport_dev, dp, true,
210 &dsa_slave_switchdev_blocking_notifier, extack);
211 if (err && err != -EOPNOTSUPP)
212 return err;
213
214 return 0;
215}
216
217static int dsa_port_switchdev_unsync_objs(struct dsa_port *dp,
218 struct net_device *br,
219 struct netlink_ext_ack *extack)
220{
221 struct net_device *brport_dev = dsa_port_to_bridge_port(dp);
222 int err;
223
224 /* Delete the switchdev objects left on this port */
225 err = br_mdb_replay(br, brport_dev, dp, false,
226 &dsa_slave_switchdev_blocking_notifier, extack);
227 if (err && err != -EOPNOTSUPP)
228 return err;
229
230 /* Forwarding and termination FDB entries on the port */
231 err = br_fdb_replay(br, brport_dev, dp, false,
232 &dsa_slave_switchdev_notifier);
233 if (err && err != -EOPNOTSUPP)
234 return err;
235
236 /* Termination FDB entries on the bridge itself */
237 err = br_fdb_replay(br, br, dp, false, &dsa_slave_switchdev_notifier);
238 if (err && err != -EOPNOTSUPP)
239 return err;
240
241 err = br_vlan_replay(br, brport_dev, dp, false,
242 &dsa_slave_switchdev_blocking_notifier, extack);
243 if (err && err != -EOPNOTSUPP)
244 return err;
245
246 return 0;
247}
248
249static void dsa_port_switchdev_unsync_attrs(struct dsa_port *dp)
250{
251 /* Configure the port for standalone mode (no address learning,
252 * flood everything).
253 * The bridge only emits SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS events
254 * when the user requests it through netlink or sysfs, but not
255 * automatically at port join or leave, so we need to handle resetting
256 * the brport flags ourselves. But we even prefer it that way, because
257 * otherwise, some setups might never get the notification they need,
258 * for example, when a port leaves a LAG that offloads the bridge,
259 * it becomes standalone, but as far as the bridge is concerned, no
260 * port ever left.
261 */
262 dsa_port_clear_brport_flags(dp);
263
264 /* Port left the bridge, put in BR_STATE_DISABLED by the bridge layer,
265 * so allow it to be in BR_STATE_FORWARDING to be kept functional
266 */
267 dsa_port_set_state_now(dp, BR_STATE_FORWARDING);
268
269 /* VLAN filtering is handled by dsa_switch_bridge_leave */
270
271 /* Ageing time may be global to the switch chip, so don't change it
272 * here because we have no good reason (or value) to change it to.
273 */
274}
275
276int dsa_port_bridge_join(struct dsa_port *dp, struct net_device *br,
277 struct netlink_ext_ack *extack)
278{
279 struct dsa_notifier_bridge_info info = {
280 .tree_index = dp->ds->dst->index,
281 .sw_index = dp->ds->index,
282 .port = dp->index,
283 .br = br,
284 };
285 int err;
286
287 /* Here the interface is already bridged. Reflect the current
288 * configuration so that drivers can program their chips accordingly.
289 */
290 dp->bridge_dev = br;
291
292 err = dsa_broadcast(DSA_NOTIFIER_BRIDGE_JOIN, &info);
293 if (err)
294 goto out_rollback;
295
296 err = dsa_port_switchdev_sync(dp, extack);
297 if (err)
298 goto out_rollback_unbridge;
299
300 return 0;
301
302out_rollback_unbridge:
303 dsa_broadcast(DSA_NOTIFIER_BRIDGE_LEAVE, &info);
304out_rollback:
305 dp->bridge_dev = NULL;
306 return err;
307}
308
309int dsa_port_pre_bridge_leave(struct dsa_port *dp, struct net_device *br,
310 struct netlink_ext_ack *extack)
311{
312 return dsa_port_switchdev_unsync_objs(dp, br, extack);
313}
314
315void dsa_port_bridge_leave(struct dsa_port *dp, struct net_device *br)
316{
317 struct dsa_notifier_bridge_info info = {
318 .tree_index = dp->ds->dst->index,
319 .sw_index = dp->ds->index,
320 .port = dp->index,
321 .br = br,
322 };
323 int err;
324
325 /* Here the port is already unbridged. Reflect the current configuration
326 * so that drivers can program their chips accordingly.
327 */
328 dp->bridge_dev = NULL;
329
330 err = dsa_broadcast(DSA_NOTIFIER_BRIDGE_LEAVE, &info);
331 if (err)
332 pr_err("DSA: failed to notify DSA_NOTIFIER_BRIDGE_LEAVE\n");
333
334 dsa_port_switchdev_unsync_attrs(dp);
335}
336
337int dsa_port_lag_change(struct dsa_port *dp,
338 struct netdev_lag_lower_state_info *linfo)
339{
340 struct dsa_notifier_lag_info info = {
341 .sw_index = dp->ds->index,
342 .port = dp->index,
343 };
344 bool tx_enabled;
345
346 if (!dp->lag_dev)
347 return 0;
348
349 /* On statically configured aggregates (e.g. loadbalance
350 * without LACP) ports will always be tx_enabled, even if the
351 * link is down. Thus we require both link_up and tx_enabled
352 * in order to include it in the tx set.
353 */
354 tx_enabled = linfo->link_up && linfo->tx_enabled;
355
356 if (tx_enabled == dp->lag_tx_enabled)
357 return 0;
358
359 dp->lag_tx_enabled = tx_enabled;
360
361 return dsa_port_notify(dp, DSA_NOTIFIER_LAG_CHANGE, &info);
362}
363
364int dsa_port_lag_join(struct dsa_port *dp, struct net_device *lag,
365 struct netdev_lag_upper_info *uinfo,
366 struct netlink_ext_ack *extack)
367{
368 struct dsa_notifier_lag_info info = {
369 .sw_index = dp->ds->index,
370 .port = dp->index,
371 .lag = lag,
372 .info = uinfo,
373 };
374 struct net_device *bridge_dev;
375 int err;
376
377 dsa_lag_map(dp->ds->dst, lag);
378 dp->lag_dev = lag;
379
380 err = dsa_port_notify(dp, DSA_NOTIFIER_LAG_JOIN, &info);
381 if (err)
382 goto err_lag_join;
383
384 bridge_dev = netdev_master_upper_dev_get(lag);
385 if (!bridge_dev || !netif_is_bridge_master(bridge_dev))
386 return 0;
387
388 err = dsa_port_bridge_join(dp, bridge_dev, extack);
389 if (err)
390 goto err_bridge_join;
391
392 return 0;
393
394err_bridge_join:
395 dsa_port_notify(dp, DSA_NOTIFIER_LAG_LEAVE, &info);
396err_lag_join:
397 dp->lag_dev = NULL;
398 dsa_lag_unmap(dp->ds->dst, lag);
399 return err;
400}
401
402int dsa_port_pre_lag_leave(struct dsa_port *dp, struct net_device *lag,
403 struct netlink_ext_ack *extack)
404{
405 if (dp->bridge_dev)
406 return dsa_port_pre_bridge_leave(dp, dp->bridge_dev, extack);
407
408 return 0;
409}
410
411void dsa_port_lag_leave(struct dsa_port *dp, struct net_device *lag)
412{
413 struct dsa_notifier_lag_info info = {
414 .sw_index = dp->ds->index,
415 .port = dp->index,
416 .lag = lag,
417 };
418 int err;
419
420 if (!dp->lag_dev)
421 return;
422
423 /* Port might have been part of a LAG that in turn was
424 * attached to a bridge.
425 */
426 if (dp->bridge_dev)
427 dsa_port_bridge_leave(dp, dp->bridge_dev);
428
429 dp->lag_tx_enabled = false;
430 dp->lag_dev = NULL;
431
432 err = dsa_port_notify(dp, DSA_NOTIFIER_LAG_LEAVE, &info);
433 if (err)
434 pr_err("DSA: failed to notify DSA_NOTIFIER_LAG_LEAVE: %d\n",
435 err);
436
437 dsa_lag_unmap(dp->ds->dst, lag);
438}
439
440/* Must be called under rcu_read_lock() */
441static bool dsa_port_can_apply_vlan_filtering(struct dsa_port *dp,
442 bool vlan_filtering,
443 struct netlink_ext_ack *extack)
444{
445 struct dsa_switch *ds = dp->ds;
446 int err, i;
447
448 /* VLAN awareness was off, so the question is "can we turn it on".
449 * We may have had 8021q uppers, those need to go. Make sure we don't
450 * enter an inconsistent state: deny changing the VLAN awareness state
451 * as long as we have 8021q uppers.
452 */
453 if (vlan_filtering && dsa_is_user_port(ds, dp->index)) {
454 struct net_device *upper_dev, *slave = dp->slave;
455 struct net_device *br = dp->bridge_dev;
456 struct list_head *iter;
457
458 netdev_for_each_upper_dev_rcu(slave, upper_dev, iter) {
459 struct bridge_vlan_info br_info;
460 u16 vid;
461
462 if (!is_vlan_dev(upper_dev))
463 continue;
464
465 vid = vlan_dev_vlan_id(upper_dev);
466
467 /* br_vlan_get_info() returns -EINVAL or -ENOENT if the
468 * device, respectively the VID is not found, returning
469 * 0 means success, which is a failure for us here.
470 */
471 err = br_vlan_get_info(br, vid, &br_info);
472 if (err == 0) {
473 NL_SET_ERR_MSG_MOD(extack,
474 "Must first remove VLAN uppers having VIDs also present in bridge");
475 return false;
476 }
477 }
478 }
479
480 if (!ds->vlan_filtering_is_global)
481 return true;
482
483 /* For cases where enabling/disabling VLAN awareness is global to the
484 * switch, we need to handle the case where multiple bridges span
485 * different ports of the same switch device and one of them has a
486 * different setting than what is being requested.
487 */
488 for (i = 0; i < ds->num_ports; i++) {
489 struct net_device *other_bridge;
490
491 other_bridge = dsa_to_port(ds, i)->bridge_dev;
492 if (!other_bridge)
493 continue;
494 /* If it's the same bridge, it also has same
495 * vlan_filtering setting => no need to check
496 */
497 if (other_bridge == dp->bridge_dev)
498 continue;
499 if (br_vlan_enabled(other_bridge) != vlan_filtering) {
500 NL_SET_ERR_MSG_MOD(extack,
501 "VLAN filtering is a global setting");
502 return false;
503 }
504 }
505 return true;
506}
507
508int dsa_port_vlan_filtering(struct dsa_port *dp, bool vlan_filtering,
509 struct netlink_ext_ack *extack)
510{
511 struct dsa_switch *ds = dp->ds;
512 bool apply;
513 int err;
514
515 if (!ds->ops->port_vlan_filtering)
516 return -EOPNOTSUPP;
517
518 /* We are called from dsa_slave_switchdev_blocking_event(),
519 * which is not under rcu_read_lock(), unlike
520 * dsa_slave_switchdev_event().
521 */
522 rcu_read_lock();
523 apply = dsa_port_can_apply_vlan_filtering(dp, vlan_filtering, extack);
524 rcu_read_unlock();
525 if (!apply)
526 return -EINVAL;
527
528 if (dsa_port_is_vlan_filtering(dp) == vlan_filtering)
529 return 0;
530
531 err = ds->ops->port_vlan_filtering(ds, dp->index, vlan_filtering,
532 extack);
533 if (err)
534 return err;
535
536 if (ds->vlan_filtering_is_global)
537 ds->vlan_filtering = vlan_filtering;
538 else
539 dp->vlan_filtering = vlan_filtering;
540
541 return 0;
542}
543
544/* This enforces legacy behavior for switch drivers which assume they can't
545 * receive VLAN configuration when enslaved to a bridge with vlan_filtering=0
546 */
547bool dsa_port_skip_vlan_configuration(struct dsa_port *dp)
548{
549 struct dsa_switch *ds = dp->ds;
550
551 if (!dp->bridge_dev)
552 return false;
553
554 return (!ds->configure_vlan_while_not_filtering &&
555 !br_vlan_enabled(dp->bridge_dev));
556}
557
558int dsa_port_ageing_time(struct dsa_port *dp, clock_t ageing_clock)
559{
560 unsigned long ageing_jiffies = clock_t_to_jiffies(ageing_clock);
561 unsigned int ageing_time = jiffies_to_msecs(ageing_jiffies);
562 struct dsa_notifier_ageing_time_info info;
563 int err;
564
565 info.ageing_time = ageing_time;
566
567 err = dsa_port_notify(dp, DSA_NOTIFIER_AGEING_TIME, &info);
568 if (err)
569 return err;
570
571 dp->ageing_time = ageing_time;
572
573 return 0;
574}
575
576int dsa_port_pre_bridge_flags(const struct dsa_port *dp,
577 struct switchdev_brport_flags flags,
578 struct netlink_ext_ack *extack)
579{
580 struct dsa_switch *ds = dp->ds;
581
582 if (!ds->ops->port_pre_bridge_flags)
583 return -EINVAL;
584
585 return ds->ops->port_pre_bridge_flags(ds, dp->index, flags, extack);
586}
587
588int dsa_port_bridge_flags(const struct dsa_port *dp,
589 struct switchdev_brport_flags flags,
590 struct netlink_ext_ack *extack)
591{
592 struct dsa_switch *ds = dp->ds;
593
594 if (!ds->ops->port_bridge_flags)
595 return -EOPNOTSUPP;
596
597 return ds->ops->port_bridge_flags(ds, dp->index, flags, extack);
598}
599
600int dsa_port_mtu_change(struct dsa_port *dp, int new_mtu,
601 bool targeted_match)
602{
603 struct dsa_notifier_mtu_info info = {
604 .sw_index = dp->ds->index,
605 .targeted_match = targeted_match,
606 .port = dp->index,
607 .mtu = new_mtu,
608 };
609
610 return dsa_port_notify(dp, DSA_NOTIFIER_MTU, &info);
611}
612
613int dsa_port_fdb_add(struct dsa_port *dp, const unsigned char *addr,
614 u16 vid)
615{
616 struct dsa_notifier_fdb_info info = {
617 .sw_index = dp->ds->index,
618 .port = dp->index,
619 .addr = addr,
620 .vid = vid,
621 };
622
623 return dsa_port_notify(dp, DSA_NOTIFIER_FDB_ADD, &info);
624}
625
626int dsa_port_fdb_del(struct dsa_port *dp, const unsigned char *addr,
627 u16 vid)
628{
629 struct dsa_notifier_fdb_info info = {
630 .sw_index = dp->ds->index,
631 .port = dp->index,
632 .addr = addr,
633 .vid = vid,
634
635 };
636
637 return dsa_port_notify(dp, DSA_NOTIFIER_FDB_DEL, &info);
638}
639
640int dsa_port_host_fdb_add(struct dsa_port *dp, const unsigned char *addr,
641 u16 vid)
642{
643 struct dsa_notifier_fdb_info info = {
644 .sw_index = dp->ds->index,
645 .port = dp->index,
646 .addr = addr,
647 .vid = vid,
648 };
649 struct dsa_port *cpu_dp = dp->cpu_dp;
650 int err;
651
652 err = dev_uc_add(cpu_dp->master, addr);
653 if (err)
654 return err;
655
656 return dsa_port_notify(dp, DSA_NOTIFIER_HOST_FDB_ADD, &info);
657}
658
659int dsa_port_host_fdb_del(struct dsa_port *dp, const unsigned char *addr,
660 u16 vid)
661{
662 struct dsa_notifier_fdb_info info = {
663 .sw_index = dp->ds->index,
664 .port = dp->index,
665 .addr = addr,
666 .vid = vid,
667 };
668 struct dsa_port *cpu_dp = dp->cpu_dp;
669 int err;
670
671 err = dev_uc_del(cpu_dp->master, addr);
672 if (err)
673 return err;
674
675 return dsa_port_notify(dp, DSA_NOTIFIER_HOST_FDB_DEL, &info);
676}
677
678int dsa_port_fdb_dump(struct dsa_port *dp, dsa_fdb_dump_cb_t *cb, void *data)
679{
680 struct dsa_switch *ds = dp->ds;
681 int port = dp->index;
682
683 if (!ds->ops->port_fdb_dump)
684 return -EOPNOTSUPP;
685
686 return ds->ops->port_fdb_dump(ds, port, cb, data);
687}
688
689int dsa_port_mdb_add(const struct dsa_port *dp,
690 const struct switchdev_obj_port_mdb *mdb)
691{
692 struct dsa_notifier_mdb_info info = {
693 .sw_index = dp->ds->index,
694 .port = dp->index,
695 .mdb = mdb,
696 };
697
698 return dsa_port_notify(dp, DSA_NOTIFIER_MDB_ADD, &info);
699}
700
701int dsa_port_mdb_del(const struct dsa_port *dp,
702 const struct switchdev_obj_port_mdb *mdb)
703{
704 struct dsa_notifier_mdb_info info = {
705 .sw_index = dp->ds->index,
706 .port = dp->index,
707 .mdb = mdb,
708 };
709
710 return dsa_port_notify(dp, DSA_NOTIFIER_MDB_DEL, &info);
711}
712
713int dsa_port_host_mdb_add(const struct dsa_port *dp,
714 const struct switchdev_obj_port_mdb *mdb)
715{
716 struct dsa_notifier_mdb_info info = {
717 .sw_index = dp->ds->index,
718 .port = dp->index,
719 .mdb = mdb,
720 };
721 struct dsa_port *cpu_dp = dp->cpu_dp;
722 int err;
723
724 err = dev_mc_add(cpu_dp->master, mdb->addr);
725 if (err)
726 return err;
727
728 return dsa_port_notify(dp, DSA_NOTIFIER_HOST_MDB_ADD, &info);
729}
730
731int dsa_port_host_mdb_del(const struct dsa_port *dp,
732 const struct switchdev_obj_port_mdb *mdb)
733{
734 struct dsa_notifier_mdb_info info = {
735 .sw_index = dp->ds->index,
736 .port = dp->index,
737 .mdb = mdb,
738 };
739 struct dsa_port *cpu_dp = dp->cpu_dp;
740 int err;
741
742 err = dev_mc_del(cpu_dp->master, mdb->addr);
743 if (err)
744 return err;
745
746 return dsa_port_notify(dp, DSA_NOTIFIER_HOST_MDB_DEL, &info);
747}
748
749int dsa_port_vlan_add(struct dsa_port *dp,
750 const struct switchdev_obj_port_vlan *vlan,
751 struct netlink_ext_ack *extack)
752{
753 struct dsa_notifier_vlan_info info = {
754 .sw_index = dp->ds->index,
755 .port = dp->index,
756 .vlan = vlan,
757 .extack = extack,
758 };
759
760 return dsa_port_notify(dp, DSA_NOTIFIER_VLAN_ADD, &info);
761}
762
763int dsa_port_vlan_del(struct dsa_port *dp,
764 const struct switchdev_obj_port_vlan *vlan)
765{
766 struct dsa_notifier_vlan_info info = {
767 .sw_index = dp->ds->index,
768 .port = dp->index,
769 .vlan = vlan,
770 };
771
772 return dsa_port_notify(dp, DSA_NOTIFIER_VLAN_DEL, &info);
773}
774
775int dsa_port_mrp_add(const struct dsa_port *dp,
776 const struct switchdev_obj_mrp *mrp)
777{
778 struct dsa_notifier_mrp_info info = {
779 .sw_index = dp->ds->index,
780 .port = dp->index,
781 .mrp = mrp,
782 };
783
784 return dsa_port_notify(dp, DSA_NOTIFIER_MRP_ADD, &info);
785}
786
787int dsa_port_mrp_del(const struct dsa_port *dp,
788 const struct switchdev_obj_mrp *mrp)
789{
790 struct dsa_notifier_mrp_info info = {
791 .sw_index = dp->ds->index,
792 .port = dp->index,
793 .mrp = mrp,
794 };
795
796 return dsa_port_notify(dp, DSA_NOTIFIER_MRP_DEL, &info);
797}
798
799int dsa_port_mrp_add_ring_role(const struct dsa_port *dp,
800 const struct switchdev_obj_ring_role_mrp *mrp)
801{
802 struct dsa_notifier_mrp_ring_role_info info = {
803 .sw_index = dp->ds->index,
804 .port = dp->index,
805 .mrp = mrp,
806 };
807
808 return dsa_port_notify(dp, DSA_NOTIFIER_MRP_ADD_RING_ROLE, &info);
809}
810
811int dsa_port_mrp_del_ring_role(const struct dsa_port *dp,
812 const struct switchdev_obj_ring_role_mrp *mrp)
813{
814 struct dsa_notifier_mrp_ring_role_info info = {
815 .sw_index = dp->ds->index,
816 .port = dp->index,
817 .mrp = mrp,
818 };
819
820 return dsa_port_notify(dp, DSA_NOTIFIER_MRP_DEL_RING_ROLE, &info);
821}
822
823void dsa_port_set_tag_protocol(struct dsa_port *cpu_dp,
824 const struct dsa_device_ops *tag_ops)
825{
826 cpu_dp->filter = tag_ops->filter;
827 cpu_dp->rcv = tag_ops->rcv;
828 cpu_dp->tag_ops = tag_ops;
829}
830
831static struct phy_device *dsa_port_get_phy_device(struct dsa_port *dp)
832{
833 struct device_node *phy_dn;
834 struct phy_device *phydev;
835
836 phy_dn = of_parse_phandle(dp->dn, "phy-handle", 0);
837 if (!phy_dn)
838 return NULL;
839
840 phydev = of_phy_find_device(phy_dn);
841 if (!phydev) {
842 of_node_put(phy_dn);
843 return ERR_PTR(-EPROBE_DEFER);
844 }
845
846 of_node_put(phy_dn);
847 return phydev;
848}
849
850static void dsa_port_phylink_validate(struct phylink_config *config,
851 unsigned long *supported,
852 struct phylink_link_state *state)
853{
854 struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
855 struct dsa_switch *ds = dp->ds;
856
857 if (!ds->ops->phylink_validate)
858 return;
859
860 ds->ops->phylink_validate(ds, dp->index, supported, state);
861}
862
863static void dsa_port_phylink_mac_pcs_get_state(struct phylink_config *config,
864 struct phylink_link_state *state)
865{
866 struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
867 struct dsa_switch *ds = dp->ds;
868 int err;
869
870 /* Only called for inband modes */
871 if (!ds->ops->phylink_mac_link_state) {
872 state->link = 0;
873 return;
874 }
875
876 err = ds->ops->phylink_mac_link_state(ds, dp->index, state);
877 if (err < 0) {
878 dev_err(ds->dev, "p%d: phylink_mac_link_state() failed: %d\n",
879 dp->index, err);
880 state->link = 0;
881 }
882}
883
884static void dsa_port_phylink_mac_config(struct phylink_config *config,
885 unsigned int mode,
886 const struct phylink_link_state *state)
887{
888 struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
889 struct dsa_switch *ds = dp->ds;
890
891 if (!ds->ops->phylink_mac_config)
892 return;
893
894 ds->ops->phylink_mac_config(ds, dp->index, mode, state);
895}
896
897static void dsa_port_phylink_mac_an_restart(struct phylink_config *config)
898{
899 struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
900 struct dsa_switch *ds = dp->ds;
901
902 if (!ds->ops->phylink_mac_an_restart)
903 return;
904
905 ds->ops->phylink_mac_an_restart(ds, dp->index);
906}
907
908static void dsa_port_phylink_mac_link_down(struct phylink_config *config,
909 unsigned int mode,
910 phy_interface_t interface)
911{
912 struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
913 struct phy_device *phydev = NULL;
914 struct dsa_switch *ds = dp->ds;
915
916 if (dsa_is_user_port(ds, dp->index))
917 phydev = dp->slave->phydev;
918
919 if (!ds->ops->phylink_mac_link_down) {
920 if (ds->ops->adjust_link && phydev)
921 ds->ops->adjust_link(ds, dp->index, phydev);
922 return;
923 }
924
925 ds->ops->phylink_mac_link_down(ds, dp->index, mode, interface);
926}
927
928static void dsa_port_phylink_mac_link_up(struct phylink_config *config,
929 struct phy_device *phydev,
930 unsigned int mode,
931 phy_interface_t interface,
932 int speed, int duplex,
933 bool tx_pause, bool rx_pause)
934{
935 struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
936 struct dsa_switch *ds = dp->ds;
937
938 if (!ds->ops->phylink_mac_link_up) {
939 if (ds->ops->adjust_link && phydev)
940 ds->ops->adjust_link(ds, dp->index, phydev);
941 return;
942 }
943
944 ds->ops->phylink_mac_link_up(ds, dp->index, mode, interface, phydev,
945 speed, duplex, tx_pause, rx_pause);
946}
947
948const struct phylink_mac_ops dsa_port_phylink_mac_ops = {
949 .validate = dsa_port_phylink_validate,
950 .mac_pcs_get_state = dsa_port_phylink_mac_pcs_get_state,
951 .mac_config = dsa_port_phylink_mac_config,
952 .mac_an_restart = dsa_port_phylink_mac_an_restart,
953 .mac_link_down = dsa_port_phylink_mac_link_down,
954 .mac_link_up = dsa_port_phylink_mac_link_up,
955};
956
957static int dsa_port_setup_phy_of(struct dsa_port *dp, bool enable)
958{
959 struct dsa_switch *ds = dp->ds;
960 struct phy_device *phydev;
961 int port = dp->index;
962 int err = 0;
963
964 phydev = dsa_port_get_phy_device(dp);
965 if (!phydev)
966 return 0;
967
968 if (IS_ERR(phydev))
969 return PTR_ERR(phydev);
970
971 if (enable) {
972 err = genphy_resume(phydev);
973 if (err < 0)
974 goto err_put_dev;
975
976 err = genphy_read_status(phydev);
977 if (err < 0)
978 goto err_put_dev;
979 } else {
980 err = genphy_suspend(phydev);
981 if (err < 0)
982 goto err_put_dev;
983 }
984
985 if (ds->ops->adjust_link)
986 ds->ops->adjust_link(ds, port, phydev);
987
988 dev_dbg(ds->dev, "enabled port's phy: %s", phydev_name(phydev));
989
990err_put_dev:
991 put_device(&phydev->mdio.dev);
992 return err;
993}
994
995static int dsa_port_fixed_link_register_of(struct dsa_port *dp)
996{
997 struct device_node *dn = dp->dn;
998 struct dsa_switch *ds = dp->ds;
999 struct phy_device *phydev;
1000 int port = dp->index;
1001 phy_interface_t mode;
1002 int err;
1003
1004 err = of_phy_register_fixed_link(dn);
1005 if (err) {
1006 dev_err(ds->dev,
1007 "failed to register the fixed PHY of port %d\n",
1008 port);
1009 return err;
1010 }
1011
1012 phydev = of_phy_find_device(dn);
1013
1014 err = of_get_phy_mode(dn, &mode);
1015 if (err)
1016 mode = PHY_INTERFACE_MODE_NA;
1017 phydev->interface = mode;
1018
1019 genphy_read_status(phydev);
1020
1021 if (ds->ops->adjust_link)
1022 ds->ops->adjust_link(ds, port, phydev);
1023
1024 put_device(&phydev->mdio.dev);
1025
1026 return 0;
1027}
1028
1029static int dsa_port_phylink_register(struct dsa_port *dp)
1030{
1031 struct dsa_switch *ds = dp->ds;
1032 struct device_node *port_dn = dp->dn;
1033 phy_interface_t mode;
1034 int err;
1035
1036 err = of_get_phy_mode(port_dn, &mode);
1037 if (err)
1038 mode = PHY_INTERFACE_MODE_NA;
1039
1040 dp->pl_config.dev = ds->dev;
1041 dp->pl_config.type = PHYLINK_DEV;
1042 dp->pl_config.pcs_poll = ds->pcs_poll;
1043
1044 dp->pl = phylink_create(&dp->pl_config, of_fwnode_handle(port_dn),
1045 mode, &dsa_port_phylink_mac_ops);
1046 if (IS_ERR(dp->pl)) {
1047 pr_err("error creating PHYLINK: %ld\n", PTR_ERR(dp->pl));
1048 return PTR_ERR(dp->pl);
1049 }
1050
1051 err = phylink_of_phy_connect(dp->pl, port_dn, 0);
1052 if (err && err != -ENODEV) {
1053 pr_err("could not attach to PHY: %d\n", err);
1054 goto err_phy_connect;
1055 }
1056
1057 return 0;
1058
1059err_phy_connect:
1060 phylink_destroy(dp->pl);
1061 return err;
1062}
1063
1064int dsa_port_link_register_of(struct dsa_port *dp)
1065{
1066 struct dsa_switch *ds = dp->ds;
1067 struct device_node *phy_np;
1068 int port = dp->index;
1069
1070 if (!ds->ops->adjust_link) {
1071 phy_np = of_parse_phandle(dp->dn, "phy-handle", 0);
1072 if (of_phy_is_fixed_link(dp->dn) || phy_np) {
1073 if (ds->ops->phylink_mac_link_down)
1074 ds->ops->phylink_mac_link_down(ds, port,
1075 MLO_AN_FIXED, PHY_INTERFACE_MODE_NA);
1076 return dsa_port_phylink_register(dp);
1077 }
1078 return 0;
1079 }
1080
1081 dev_warn(ds->dev,
1082 "Using legacy PHYLIB callbacks. Please migrate to PHYLINK!\n");
1083
1084 if (of_phy_is_fixed_link(dp->dn))
1085 return dsa_port_fixed_link_register_of(dp);
1086 else
1087 return dsa_port_setup_phy_of(dp, true);
1088}
1089
1090void dsa_port_link_unregister_of(struct dsa_port *dp)
1091{
1092 struct dsa_switch *ds = dp->ds;
1093
1094 if (!ds->ops->adjust_link && dp->pl) {
1095 rtnl_lock();
1096 phylink_disconnect_phy(dp->pl);
1097 rtnl_unlock();
1098 phylink_destroy(dp->pl);
1099 dp->pl = NULL;
1100 return;
1101 }
1102
1103 if (of_phy_is_fixed_link(dp->dn))
1104 of_phy_deregister_fixed_link(dp->dn);
1105 else
1106 dsa_port_setup_phy_of(dp, false);
1107}
1108
1109int dsa_port_get_phy_strings(struct dsa_port *dp, uint8_t *data)
1110{
1111 struct phy_device *phydev;
1112 int ret = -EOPNOTSUPP;
1113
1114 if (of_phy_is_fixed_link(dp->dn))
1115 return ret;
1116
1117 phydev = dsa_port_get_phy_device(dp);
1118 if (IS_ERR_OR_NULL(phydev))
1119 return ret;
1120
1121 ret = phy_ethtool_get_strings(phydev, data);
1122 put_device(&phydev->mdio.dev);
1123
1124 return ret;
1125}
1126EXPORT_SYMBOL_GPL(dsa_port_get_phy_strings);
1127
1128int dsa_port_get_ethtool_phy_stats(struct dsa_port *dp, uint64_t *data)
1129{
1130 struct phy_device *phydev;
1131 int ret = -EOPNOTSUPP;
1132
1133 if (of_phy_is_fixed_link(dp->dn))
1134 return ret;
1135
1136 phydev = dsa_port_get_phy_device(dp);
1137 if (IS_ERR_OR_NULL(phydev))
1138 return ret;
1139
1140 ret = phy_ethtool_get_stats(phydev, NULL, data);
1141 put_device(&phydev->mdio.dev);
1142
1143 return ret;
1144}
1145EXPORT_SYMBOL_GPL(dsa_port_get_ethtool_phy_stats);
1146
1147int dsa_port_get_phy_sset_count(struct dsa_port *dp)
1148{
1149 struct phy_device *phydev;
1150 int ret = -EOPNOTSUPP;
1151
1152 if (of_phy_is_fixed_link(dp->dn))
1153 return ret;
1154
1155 phydev = dsa_port_get_phy_device(dp);
1156 if (IS_ERR_OR_NULL(phydev))
1157 return ret;
1158
1159 ret = phy_ethtool_get_sset_count(phydev);
1160 put_device(&phydev->mdio.dev);
1161
1162 return ret;
1163}
1164EXPORT_SYMBOL_GPL(dsa_port_get_phy_sset_count);
1165
1166int dsa_port_hsr_join(struct dsa_port *dp, struct net_device *hsr)
1167{
1168 struct dsa_notifier_hsr_info info = {
1169 .sw_index = dp->ds->index,
1170 .port = dp->index,
1171 .hsr = hsr,
1172 };
1173 int err;
1174
1175 dp->hsr_dev = hsr;
1176
1177 err = dsa_port_notify(dp, DSA_NOTIFIER_HSR_JOIN, &info);
1178 if (err)
1179 dp->hsr_dev = NULL;
1180
1181 return err;
1182}
1183
1184void dsa_port_hsr_leave(struct dsa_port *dp, struct net_device *hsr)
1185{
1186 struct dsa_notifier_hsr_info info = {
1187 .sw_index = dp->ds->index,
1188 .port = dp->index,
1189 .hsr = hsr,
1190 };
1191 int err;
1192
1193 dp->hsr_dev = NULL;
1194
1195 err = dsa_port_notify(dp, DSA_NOTIFIER_HSR_LEAVE, &info);
1196 if (err)
1197 pr_err("DSA: failed to notify DSA_NOTIFIER_HSR_LEAVE\n");
1198}
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(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(SWITCHDEV_FDB_FLUSH_TO_BRIDGE,
52 brport_dev, &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, 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(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(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
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, 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, 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(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
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(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, 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
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, 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(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
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(&bridge->refcount))
467 return;
468
469 if (bridge->num)
470 dsa_bridge_num_put(br, bridge->num);
471
472 kfree(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(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
529out_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();
534out_rollback_unbridge:
535 dsa_broadcast(DSA_NOTIFIER_BRIDGE_LEAVE, &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, dp,
550 &dsa_user_switchdev_notifier,
551 &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(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
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, DSA_NOTIFIER_LAG_CHANGE, &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(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
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(&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
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, 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
684err_bridge_join:
685 dsa_port_notify(dp, DSA_NOTIFIER_LAG_LEAVE, &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, 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() */
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(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
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(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
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(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(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
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, DSA_NOTIFIER_MTU, &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, DSA_NOTIFIER_FDB_ADD, &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, DSA_NOTIFIER_FDB_DEL, &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, DSA_NOTIFIER_HOST_FDB_ADD, &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(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, DSA_NOTIFIER_HOST_FDB_DEL, &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(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, DSA_NOTIFIER_LAG_FDB_ADD, &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, DSA_NOTIFIER_LAG_FDB_DEL, &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, DSA_NOTIFIER_MDB_ADD, &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, DSA_NOTIFIER_MDB_DEL, &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, DSA_NOTIFIER_HOST_MDB_ADD, &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(conduit, 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, DSA_NOTIFIER_HOST_MDB_DEL, &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(conduit, 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, DSA_NOTIFIER_VLAN_ADD, &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, DSA_NOTIFIER_VLAN_DEL, &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, 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
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, 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
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(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, 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 err = dsa_port_assign_conduit(dp, conduit, extack, 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, 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, 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, false);
1499
1500rewind_new_addrs:
1501 dsa_user_unsync_ha(dev);
1502
1503 dsa_port_assign_conduit(dp, old_conduit, NULL, 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, 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, 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(dp->dn, "phy-handle", 0);
1544 if (!phy_dn)
1545 return NULL;
1546
1547 phydev = of_phy_find_device(phy_dn);
1548 if (!phydev) {
1549 of_node_put(phy_dn);
1550 return ERR_PTR(-EPROBE_DEFER);
1551 }
1552
1553 of_node_put(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(-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(dp->dn, &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(pl)) {
1691 pr_err("error creating PHYLINK: %ld\n", PTR_ERR(pl));
1692 return PTR_ERR(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(phydev))
1718 return PTR_ERR(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(&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(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(dn);
1762
1763 err = of_get_phy_mode(dn, &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(&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, 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(dn, &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(dn))
1940 return;
1941
1942 phy_np = of_parse_phandle(dn, "phy-handle", 0);
1943 if (phy_np) {
1944 of_node_put(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,
1963 &missing_link_description);
1964
1965 if ((missing_phy_mode || missing_link_description) &&
1966 !of_device_compatible_match(ds->dev->of_node,
1967 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(dp->dn))
1989 return dsa_shared_port_fixed_link_register_of(dp);
1990 else
1991 return dsa_shared_port_setup_phy_of(dp, 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(dp->dn))
2007 of_phy_deregister_fixed_link(dp->dn);
2008 else
2009 dsa_shared_port_setup_phy_of(dp, 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(DSA_NOTIFIER_TAG_8021Q_VLAN_ADD, &info);
2055
2056 return dsa_port_notify(dp, DSA_NOTIFIER_TAG_8021Q_VLAN_ADD, &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(DSA_NOTIFIER_TAG_8021Q_VLAN_DEL, &info);
2069 else
2070 err = dsa_port_notify(dp, DSA_NOTIFIER_TAG_8021Q_VLAN_DEL, &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}