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