blob: 05677e016982ffc58fd85137b6dafa674f581a36 [file] [log] [blame]
Thomas Gleixner2874c5f2019-05-27 08:55:01 +02001// SPDX-License-Identifier: GPL-2.0-or-later
Vivien Didelota40c1752017-05-19 17:00:44 -04002/*
3 * Handling of a single switch port
4 *
5 * Copyright (c) 2017 Savoir-faire Linux Inc.
6 * Vivien Didelot <vivien.didelot@savoirfairelinux.com>
Vivien Didelota40c1752017-05-19 17:00:44 -04007 */
8
9#include <linux/if_bridge.h>
Vivien Didelotcfbed322017-05-19 17:00:45 -040010#include <linux/notifier.h>
Vivien Didelot57ab1ca2017-10-26 10:50:07 -040011#include <linux/of_mdio.h>
12#include <linux/of_net.h>
Vivien Didelota40c1752017-05-19 17:00:44 -040013
14#include "dsa_priv.h"
15
Vladimir Oltean886f8e22021-01-29 03:00:04 +020016/**
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 */
Andrew Lunnbb9f603172017-11-09 23:11:01 +010028static int dsa_port_notify(const struct dsa_port *dp, unsigned long e, void *v)
Vivien Didelotcfbed322017-05-19 17:00:45 -040029{
Vladimir Oltean886f8e22021-01-29 03:00:04 +020030 return dsa_tree_notify(dp->ds->dst, e, v);
Vivien Didelotcfbed322017-05-19 17:00:45 -040031}
32
Vladimir Oltean9264e4a2021-08-08 17:35:25 +030033static void dsa_port_notify_bridge_fdb_flush(const struct dsa_port *dp)
34{
35 struct net_device *brport_dev = dsa_port_to_bridge_port(dp);
36 struct switchdev_notifier_fdb_info info = {
37 /* flush all VLANs */
38 .vid = 0,
39 };
40
41 /* When the port becomes standalone it has already left the bridge.
42 * Don't notify the bridge in that case.
43 */
44 if (!brport_dev)
45 return;
46
47 call_switchdev_notifiers(SWITCHDEV_FDB_FLUSH_TO_BRIDGE,
48 brport_dev, &info.info, NULL);
49}
50
Vladimir Oltean045c45d2021-08-08 17:35:23 +030051static void dsa_port_fast_age(const struct dsa_port *dp)
52{
53 struct dsa_switch *ds = dp->ds;
54
55 if (!ds->ops->port_fast_age)
56 return;
57
58 ds->ops->port_fast_age(ds, dp->index);
Vladimir Oltean9264e4a2021-08-08 17:35:25 +030059
60 dsa_port_notify_bridge_fdb_flush(dp);
Vladimir Oltean045c45d2021-08-08 17:35:23 +030061}
62
Vladimir Olteana4ffe092021-08-09 01:56:48 +030063static bool dsa_port_can_configure_learning(struct dsa_port *dp)
64{
65 struct switchdev_brport_flags flags = {
66 .mask = BR_LEARNING,
67 };
68 struct dsa_switch *ds = dp->ds;
69 int err;
70
71 if (!ds->ops->port_bridge_flags || !ds->ops->port_pre_bridge_flags)
72 return false;
73
74 err = ds->ops->port_pre_bridge_flags(ds, dp->index, flags, NULL);
75 return !err;
76}
77
Vladimir Oltean39f32102021-08-08 14:16:37 +030078int dsa_port_set_state(struct dsa_port *dp, u8 state, bool do_fast_age)
Vivien Didelota40c1752017-05-19 17:00:44 -040079{
80 struct dsa_switch *ds = dp->ds;
81 int port = dp->index;
82
Vladimir Olteanbae33f22021-01-09 02:01:50 +020083 if (!ds->ops->port_stp_state_set)
84 return -EOPNOTSUPP;
Vivien Didelota40c1752017-05-19 17:00:44 -040085
Vladimir Olteanbae33f22021-01-09 02:01:50 +020086 ds->ops->port_stp_state_set(ds, port, state);
Vivien Didelota40c1752017-05-19 17:00:44 -040087
Vladimir Olteana4ffe092021-08-09 01:56:48 +030088 if (!dsa_port_can_configure_learning(dp) ||
89 (do_fast_age && dp->learning)) {
Vivien Didelota40c1752017-05-19 17:00:44 -040090 /* Fast age FDB entries or flush appropriate forwarding database
91 * for the given port, if we are moving it from Learning or
92 * Forwarding state, to Disabled or Blocking or Listening state.
Vladimir Oltean39f32102021-08-08 14:16:37 +030093 * Ports that were standalone before the STP state change don't
94 * need to fast age the FDB, since address learning is off in
95 * standalone mode.
Vivien Didelota40c1752017-05-19 17:00:44 -040096 */
97
98 if ((dp->stp_state == BR_STATE_LEARNING ||
99 dp->stp_state == BR_STATE_FORWARDING) &&
100 (state == BR_STATE_DISABLED ||
101 state == BR_STATE_BLOCKING ||
102 state == BR_STATE_LISTENING))
Vladimir Oltean045c45d2021-08-08 17:35:23 +0300103 dsa_port_fast_age(dp);
Vivien Didelota40c1752017-05-19 17:00:44 -0400104 }
105
106 dp->stp_state = state;
107
108 return 0;
109}
110
Vladimir Oltean39f32102021-08-08 14:16:37 +0300111static void dsa_port_set_state_now(struct dsa_port *dp, u8 state,
112 bool do_fast_age)
Vivien Didelota40c1752017-05-19 17:00:44 -0400113{
114 int err;
115
Vladimir Oltean39f32102021-08-08 14:16:37 +0300116 err = dsa_port_set_state(dp, state, do_fast_age);
Vivien Didelota40c1752017-05-19 17:00:44 -0400117 if (err)
118 pr_err("DSA: failed to set STP state %u (%d)\n", state, err);
119}
Vivien Didelotcfbed322017-05-19 17:00:45 -0400120
Russell King8640f8d2020-03-03 15:01:46 +0000121int dsa_port_enable_rt(struct dsa_port *dp, struct phy_device *phy)
Vivien Didelotfb8a6a22017-09-22 19:01:56 -0400122{
Vivien Didelotfb8a6a22017-09-22 19:01:56 -0400123 struct dsa_switch *ds = dp->ds;
124 int port = dp->index;
125 int err;
126
127 if (ds->ops->port_enable) {
128 err = ds->ops->port_enable(ds, port, phy);
129 if (err)
130 return err;
131 }
132
Vladimir Olteand3eed0e2021-12-06 18:57:56 +0200133 if (!dp->bridge)
Vladimir Oltean39f32102021-08-08 14:16:37 +0300134 dsa_port_set_state_now(dp, BR_STATE_FORWARDING, false);
Vivien Didelotfb8a6a22017-09-22 19:01:56 -0400135
Russell King8640f8d2020-03-03 15:01:46 +0000136 if (dp->pl)
137 phylink_start(dp->pl);
138
Vivien Didelotfb8a6a22017-09-22 19:01:56 -0400139 return 0;
140}
141
Russell King8640f8d2020-03-03 15:01:46 +0000142int dsa_port_enable(struct dsa_port *dp, struct phy_device *phy)
143{
144 int err;
145
146 rtnl_lock();
147 err = dsa_port_enable_rt(dp, phy);
148 rtnl_unlock();
149
150 return err;
151}
152
153void dsa_port_disable_rt(struct dsa_port *dp)
Vivien Didelotfb8a6a22017-09-22 19:01:56 -0400154{
155 struct dsa_switch *ds = dp->ds;
156 int port = dp->index;
157
Russell King8640f8d2020-03-03 15:01:46 +0000158 if (dp->pl)
159 phylink_stop(dp->pl);
160
Vladimir Olteand3eed0e2021-12-06 18:57:56 +0200161 if (!dp->bridge)
Vladimir Oltean39f32102021-08-08 14:16:37 +0300162 dsa_port_set_state_now(dp, BR_STATE_DISABLED, false);
Vivien Didelotfb8a6a22017-09-22 19:01:56 -0400163
164 if (ds->ops->port_disable)
Andrew Lunn75104db2019-02-24 20:44:43 +0100165 ds->ops->port_disable(ds, port);
Vivien Didelotfb8a6a22017-09-22 19:01:56 -0400166}
167
Russell King8640f8d2020-03-03 15:01:46 +0000168void dsa_port_disable(struct dsa_port *dp)
169{
170 rtnl_lock();
171 dsa_port_disable_rt(dp);
172 rtnl_unlock();
173}
174
Vladimir Oltean5961d6a2021-03-23 01:51:49 +0200175static int dsa_port_inherit_brport_flags(struct dsa_port *dp,
176 struct netlink_ext_ack *extack)
Vladimir Oltean5e38c152021-02-12 17:15:54 +0200177{
Vladimir Oltean5961d6a2021-03-23 01:51:49 +0200178 const unsigned long mask = BR_LEARNING | BR_FLOOD | BR_MCAST_FLOOD |
179 BR_BCAST_FLOOD;
180 struct net_device *brport_dev = dsa_port_to_bridge_port(dp);
181 int flag, err;
Vladimir Oltean5e38c152021-02-12 17:15:54 +0200182
Vladimir Oltean5961d6a2021-03-23 01:51:49 +0200183 for_each_set_bit(flag, &mask, 32) {
184 struct switchdev_brport_flags flags = {0};
Vladimir Oltean5e38c152021-02-12 17:15:54 +0200185
Vladimir Oltean5961d6a2021-03-23 01:51:49 +0200186 flags.mask = BIT(flag);
Vladimir Oltean5e38c152021-02-12 17:15:54 +0200187
Vladimir Oltean5961d6a2021-03-23 01:51:49 +0200188 if (br_port_flag_is_set(brport_dev, BIT(flag)))
189 flags.val = BIT(flag);
Vladimir Olteane18f4c12021-02-12 17:15:55 +0200190
Vladimir Oltean5961d6a2021-03-23 01:51:49 +0200191 err = dsa_port_bridge_flags(dp, flags, extack);
192 if (err && err != -EOPNOTSUPP)
193 return err;
Vladimir Oltean5e38c152021-02-12 17:15:54 +0200194 }
Vladimir Oltean5961d6a2021-03-23 01:51:49 +0200195
196 return 0;
197}
198
199static void dsa_port_clear_brport_flags(struct dsa_port *dp)
200{
201 const unsigned long val = BR_FLOOD | BR_MCAST_FLOOD | BR_BCAST_FLOOD;
202 const unsigned long mask = BR_LEARNING | BR_FLOOD | BR_MCAST_FLOOD |
203 BR_BCAST_FLOOD;
204 int flag, err;
205
206 for_each_set_bit(flag, &mask, 32) {
207 struct switchdev_brport_flags flags = {0};
208
209 flags.mask = BIT(flag);
210 flags.val = val & BIT(flag);
211
212 err = dsa_port_bridge_flags(dp, flags, NULL);
213 if (err && err != -EOPNOTSUPP)
214 dev_err(dp->ds->dev,
215 "failed to clear bridge port flag %lu: %pe\n",
216 flags.val, ERR_PTR(err));
217 }
218}
219
Vladimir Oltean4e51bf42021-07-21 19:24:03 +0300220static int dsa_port_switchdev_sync_attrs(struct dsa_port *dp,
221 struct netlink_ext_ack *extack)
Vladimir Oltean5961d6a2021-03-23 01:51:49 +0200222{
Vladimir Oltean010e2692021-03-23 01:51:50 +0200223 struct net_device *brport_dev = dsa_port_to_bridge_port(dp);
Vladimir Oltean36cbf392021-12-06 18:57:52 +0200224 struct net_device *br = dsa_port_bridge_dev_get(dp);
Vladimir Oltean5961d6a2021-03-23 01:51:49 +0200225 int err;
226
227 err = dsa_port_inherit_brport_flags(dp, extack);
228 if (err)
229 return err;
230
Vladimir Oltean39f32102021-08-08 14:16:37 +0300231 err = dsa_port_set_state(dp, br_port_get_stp_state(brport_dev), false);
Vladimir Oltean010e2692021-03-23 01:51:50 +0200232 if (err && err != -EOPNOTSUPP)
233 return err;
234
235 err = dsa_port_vlan_filtering(dp, br_vlan_enabled(br), extack);
236 if (err && err != -EOPNOTSUPP)
237 return err;
238
Vladimir Oltean010e2692021-03-23 01:51:50 +0200239 err = dsa_port_ageing_time(dp, br_get_ageing_time(br));
240 if (err && err != -EOPNOTSUPP)
241 return err;
242
Vladimir Oltean74918942021-06-27 14:54:29 +0300243 return 0;
244}
245
246static void dsa_port_switchdev_unsync_attrs(struct dsa_port *dp)
Vladimir Oltean5961d6a2021-03-23 01:51:49 +0200247{
248 /* Configure the port for standalone mode (no address learning,
249 * flood everything).
250 * The bridge only emits SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS events
251 * when the user requests it through netlink or sysfs, but not
252 * automatically at port join or leave, so we need to handle resetting
253 * the brport flags ourselves. But we even prefer it that way, because
254 * otherwise, some setups might never get the notification they need,
255 * for example, when a port leaves a LAG that offloads the bridge,
256 * it becomes standalone, but as far as the bridge is concerned, no
257 * port ever left.
258 */
259 dsa_port_clear_brport_flags(dp);
260
261 /* Port left the bridge, put in BR_STATE_DISABLED by the bridge layer,
262 * so allow it to be in BR_STATE_FORWARDING to be kept functional
263 */
Vladimir Oltean39f32102021-08-08 14:16:37 +0300264 dsa_port_set_state_now(dp, BR_STATE_FORWARDING, true);
Vladimir Oltean010e2692021-03-23 01:51:50 +0200265
266 /* VLAN filtering is handled by dsa_switch_bridge_leave */
267
Vladimir Oltean010e2692021-03-23 01:51:50 +0200268 /* Ageing time may be global to the switch chip, so don't change it
269 * here because we have no good reason (or value) to change it to.
270 */
Vladimir Oltean5e38c152021-02-12 17:15:54 +0200271}
272
Vladimir Oltean947c8742021-12-06 18:57:48 +0200273static int dsa_port_bridge_create(struct dsa_port *dp,
274 struct net_device *br,
275 struct netlink_ext_ack *extack)
276{
277 struct dsa_switch *ds = dp->ds;
Vladimir Olteand3eed0e2021-12-06 18:57:56 +0200278 struct dsa_bridge *bridge;
Vladimir Oltean947c8742021-12-06 18:57:48 +0200279
Vladimir Olteand3eed0e2021-12-06 18:57:56 +0200280 bridge = dsa_tree_bridge_find(ds->dst, br);
281 if (bridge) {
282 refcount_inc(&bridge->refcount);
283 dp->bridge = bridge;
Vladimir Oltean947c8742021-12-06 18:57:48 +0200284 return 0;
Vladimir Olteand3eed0e2021-12-06 18:57:56 +0200285 }
Vladimir Oltean947c8742021-12-06 18:57:48 +0200286
Vladimir Olteand3eed0e2021-12-06 18:57:56 +0200287 bridge = kzalloc(sizeof(*bridge), GFP_KERNEL);
288 if (!bridge)
289 return -ENOMEM;
290
291 refcount_set(&bridge->refcount, 1);
292
293 bridge->dev = br;
294
295 bridge->num = dsa_bridge_num_get(br, ds->max_num_bridges);
296 if (ds->max_num_bridges && !bridge->num) {
Vladimir Oltean947c8742021-12-06 18:57:48 +0200297 NL_SET_ERR_MSG_MOD(extack,
298 "Range of offloadable bridges exceeded");
Vladimir Olteand3eed0e2021-12-06 18:57:56 +0200299 kfree(bridge);
Vladimir Oltean947c8742021-12-06 18:57:48 +0200300 return -EOPNOTSUPP;
Vladimir Oltean123abc062021-07-22 18:55:40 +0300301 }
302
Vladimir Olteand3eed0e2021-12-06 18:57:56 +0200303 dp->bridge = bridge;
Vladimir Oltean947c8742021-12-06 18:57:48 +0200304
305 return 0;
306}
307
308static void dsa_port_bridge_destroy(struct dsa_port *dp,
309 const struct net_device *br)
310{
Vladimir Olteand3eed0e2021-12-06 18:57:56 +0200311 struct dsa_bridge *bridge = dp->bridge;
Vladimir Oltean947c8742021-12-06 18:57:48 +0200312
Vladimir Olteand3eed0e2021-12-06 18:57:56 +0200313 dp->bridge = NULL;
Vladimir Oltean947c8742021-12-06 18:57:48 +0200314
Vladimir Olteand3eed0e2021-12-06 18:57:56 +0200315 if (!refcount_dec_and_test(&bridge->refcount))
316 return;
Vladimir Oltean947c8742021-12-06 18:57:48 +0200317
Vladimir Olteand3eed0e2021-12-06 18:57:56 +0200318 if (bridge->num)
319 dsa_bridge_num_put(br, bridge->num);
320
321 kfree(bridge);
Vladimir Oltean123abc062021-07-22 18:55:40 +0300322}
323
Vladimir Oltean2afc5262021-03-23 01:51:48 +0200324int dsa_port_bridge_join(struct dsa_port *dp, struct net_device *br,
325 struct netlink_ext_ack *extack)
Vivien Didelotcfbed322017-05-19 17:00:45 -0400326{
327 struct dsa_notifier_bridge_info info = {
Vladimir Olteanf66a6a62020-05-10 19:37:41 +0300328 .tree_index = dp->ds->dst->index,
Vivien Didelotcfbed322017-05-19 17:00:45 -0400329 .sw_index = dp->ds->index,
330 .port = dp->index,
Vivien Didelotcfbed322017-05-19 17:00:45 -0400331 };
Vladimir Oltean2f5dc002021-07-21 19:24:01 +0300332 struct net_device *dev = dp->slave;
333 struct net_device *brport_dev;
Vivien Didelotcfbed322017-05-19 17:00:45 -0400334 int err;
335
Russell Kingc1388062019-02-20 15:35:06 -0800336 /* Here the interface is already bridged. Reflect the current
337 * configuration so that drivers can program their chips accordingly.
Vivien Didelotcfbed322017-05-19 17:00:45 -0400338 */
Vladimir Oltean947c8742021-12-06 18:57:48 +0200339 err = dsa_port_bridge_create(dp, br, extack);
340 if (err)
341 return err;
Vivien Didelotcfbed322017-05-19 17:00:45 -0400342
Vladimir Oltean2f5dc002021-07-21 19:24:01 +0300343 brport_dev = dsa_port_to_bridge_port(dp);
344
Vladimir Olteand3eed0e2021-12-06 18:57:56 +0200345 info.bridge = *dp->bridge;
Vladimir Olteanf66a6a62020-05-10 19:37:41 +0300346 err = dsa_broadcast(DSA_NOTIFIER_BRIDGE_JOIN, &info);
Vladimir Oltean5961d6a2021-03-23 01:51:49 +0200347 if (err)
348 goto out_rollback;
Vivien Didelotcfbed322017-05-19 17:00:45 -0400349
Vladimir Oltean857fdd72021-12-06 18:57:58 +0200350 /* Drivers which support bridge TX forwarding should set this */
351 dp->bridge->tx_fwd_offload = info.tx_fwd_offload;
Vladimir Oltean123abc062021-07-22 18:55:40 +0300352
Vladimir Oltean4e51bf42021-07-21 19:24:03 +0300353 err = switchdev_bridge_port_offload(brport_dev, dev, dp,
354 &dsa_slave_switchdev_notifier,
355 &dsa_slave_switchdev_blocking_notifier,
Vladimir Oltean857fdd72021-12-06 18:57:58 +0200356 dp->bridge->tx_fwd_offload, extack);
Vladimir Oltean5961d6a2021-03-23 01:51:49 +0200357 if (err)
358 goto out_rollback_unbridge;
Vivien Didelotcfbed322017-05-19 17:00:45 -0400359
Vladimir Oltean4e51bf42021-07-21 19:24:03 +0300360 err = dsa_port_switchdev_sync_attrs(dp, extack);
Vladimir Oltean2f5dc002021-07-21 19:24:01 +0300361 if (err)
362 goto out_rollback_unoffload;
363
Vladimir Oltean5961d6a2021-03-23 01:51:49 +0200364 return 0;
365
Vladimir Oltean2f5dc002021-07-21 19:24:01 +0300366out_rollback_unoffload:
Vladimir Oltean4e51bf42021-07-21 19:24:03 +0300367 switchdev_bridge_port_unoffload(brport_dev, dp,
368 &dsa_slave_switchdev_notifier,
369 &dsa_slave_switchdev_blocking_notifier);
Vladimir Oltean5961d6a2021-03-23 01:51:49 +0200370out_rollback_unbridge:
371 dsa_broadcast(DSA_NOTIFIER_BRIDGE_LEAVE, &info);
372out_rollback:
Vladimir Oltean947c8742021-12-06 18:57:48 +0200373 dsa_port_bridge_destroy(dp, br);
Vivien Didelotcfbed322017-05-19 17:00:45 -0400374 return err;
375}
376
Vladimir Oltean4e51bf42021-07-21 19:24:03 +0300377void dsa_port_pre_bridge_leave(struct dsa_port *dp, struct net_device *br)
Vladimir Oltean74918942021-06-27 14:54:29 +0300378{
Vladimir Oltean2f5dc002021-07-21 19:24:01 +0300379 struct net_device *brport_dev = dsa_port_to_bridge_port(dp);
380
Vladimir Oltean09dba212021-08-24 00:22:55 +0300381 /* Don't try to unoffload something that is not offloaded */
382 if (!brport_dev)
383 return;
384
Vladimir Oltean4e51bf42021-07-21 19:24:03 +0300385 switchdev_bridge_port_unoffload(brport_dev, dp,
386 &dsa_slave_switchdev_notifier,
387 &dsa_slave_switchdev_blocking_notifier);
Vladimir Olteand7d0d422021-10-26 12:25:55 +0300388
389 dsa_flush_workqueue();
Vladimir Oltean74918942021-06-27 14:54:29 +0300390}
391
Vivien Didelotcfbed322017-05-19 17:00:45 -0400392void dsa_port_bridge_leave(struct dsa_port *dp, struct net_device *br)
393{
394 struct dsa_notifier_bridge_info info = {
Vladimir Olteanf66a6a62020-05-10 19:37:41 +0300395 .tree_index = dp->ds->dst->index,
Vivien Didelotcfbed322017-05-19 17:00:45 -0400396 .sw_index = dp->ds->index,
397 .port = dp->index,
Vladimir Olteand3eed0e2021-12-06 18:57:56 +0200398 .bridge = *dp->bridge,
Vivien Didelotcfbed322017-05-19 17:00:45 -0400399 };
400 int err;
401
402 /* Here the port is already unbridged. Reflect the current configuration
403 * so that drivers can program their chips accordingly.
404 */
Vladimir Oltean947c8742021-12-06 18:57:48 +0200405 dsa_port_bridge_destroy(dp, br);
Vivien Didelotcfbed322017-05-19 17:00:45 -0400406
Vladimir Olteanf66a6a62020-05-10 19:37:41 +0300407 err = dsa_broadcast(DSA_NOTIFIER_BRIDGE_LEAVE, &info);
Vivien Didelotcfbed322017-05-19 17:00:45 -0400408 if (err)
Vladimir Olteanab974622021-08-11 16:46:05 +0300409 dev_err(dp->ds->dev,
410 "port %d failed to notify DSA_NOTIFIER_BRIDGE_LEAVE: %pe\n",
411 dp->index, ERR_PTR(err));
Vivien Didelotcfbed322017-05-19 17:00:45 -0400412
Vladimir Oltean74918942021-06-27 14:54:29 +0300413 dsa_port_switchdev_unsync_attrs(dp);
Vivien Didelotcfbed322017-05-19 17:00:45 -0400414}
Vivien Didelot4d61d302017-05-19 17:00:46 -0400415
Tobias Waldekranz058102a2021-01-13 09:42:53 +0100416int dsa_port_lag_change(struct dsa_port *dp,
417 struct netdev_lag_lower_state_info *linfo)
418{
419 struct dsa_notifier_lag_info info = {
420 .sw_index = dp->ds->index,
421 .port = dp->index,
422 };
423 bool tx_enabled;
424
425 if (!dp->lag_dev)
426 return 0;
427
428 /* On statically configured aggregates (e.g. loadbalance
429 * without LACP) ports will always be tx_enabled, even if the
430 * link is down. Thus we require both link_up and tx_enabled
431 * in order to include it in the tx set.
432 */
433 tx_enabled = linfo->link_up && linfo->tx_enabled;
434
435 if (tx_enabled == dp->lag_tx_enabled)
436 return 0;
437
438 dp->lag_tx_enabled = tx_enabled;
439
440 return dsa_port_notify(dp, DSA_NOTIFIER_LAG_CHANGE, &info);
441}
442
443int dsa_port_lag_join(struct dsa_port *dp, struct net_device *lag,
Vladimir Oltean2afc5262021-03-23 01:51:48 +0200444 struct netdev_lag_upper_info *uinfo,
445 struct netlink_ext_ack *extack)
Tobias Waldekranz058102a2021-01-13 09:42:53 +0100446{
447 struct dsa_notifier_lag_info info = {
448 .sw_index = dp->ds->index,
449 .port = dp->index,
450 .lag = lag,
451 .info = uinfo,
452 };
Vladimir Oltean185c9a72021-03-23 01:51:47 +0200453 struct net_device *bridge_dev;
Tobias Waldekranz058102a2021-01-13 09:42:53 +0100454 int err;
455
456 dsa_lag_map(dp->ds->dst, lag);
457 dp->lag_dev = lag;
458
459 err = dsa_port_notify(dp, DSA_NOTIFIER_LAG_JOIN, &info);
Vladimir Oltean185c9a72021-03-23 01:51:47 +0200460 if (err)
461 goto err_lag_join;
Tobias Waldekranz058102a2021-01-13 09:42:53 +0100462
Vladimir Oltean185c9a72021-03-23 01:51:47 +0200463 bridge_dev = netdev_master_upper_dev_get(lag);
464 if (!bridge_dev || !netif_is_bridge_master(bridge_dev))
465 return 0;
466
Vladimir Oltean2afc5262021-03-23 01:51:48 +0200467 err = dsa_port_bridge_join(dp, bridge_dev, extack);
Vladimir Oltean185c9a72021-03-23 01:51:47 +0200468 if (err)
469 goto err_bridge_join;
470
471 return 0;
472
473err_bridge_join:
474 dsa_port_notify(dp, DSA_NOTIFIER_LAG_LEAVE, &info);
475err_lag_join:
476 dp->lag_dev = NULL;
477 dsa_lag_unmap(dp->ds->dst, lag);
Tobias Waldekranz058102a2021-01-13 09:42:53 +0100478 return err;
479}
480
Vladimir Oltean4e51bf42021-07-21 19:24:03 +0300481void dsa_port_pre_lag_leave(struct dsa_port *dp, struct net_device *lag)
Vladimir Oltean74918942021-06-27 14:54:29 +0300482{
Vladimir Oltean36cbf392021-12-06 18:57:52 +0200483 struct net_device *br = dsa_port_bridge_dev_get(dp);
484
485 if (br)
486 dsa_port_pre_bridge_leave(dp, br);
Vladimir Oltean74918942021-06-27 14:54:29 +0300487}
488
Tobias Waldekranz058102a2021-01-13 09:42:53 +0100489void dsa_port_lag_leave(struct dsa_port *dp, struct net_device *lag)
490{
Vladimir Oltean36cbf392021-12-06 18:57:52 +0200491 struct net_device *br = dsa_port_bridge_dev_get(dp);
Tobias Waldekranz058102a2021-01-13 09:42:53 +0100492 struct dsa_notifier_lag_info info = {
493 .sw_index = dp->ds->index,
494 .port = dp->index,
495 .lag = lag,
496 };
497 int err;
498
499 if (!dp->lag_dev)
500 return;
501
502 /* Port might have been part of a LAG that in turn was
503 * attached to a bridge.
504 */
Vladimir Oltean36cbf392021-12-06 18:57:52 +0200505 if (br)
506 dsa_port_bridge_leave(dp, br);
Tobias Waldekranz058102a2021-01-13 09:42:53 +0100507
508 dp->lag_tx_enabled = false;
509 dp->lag_dev = NULL;
510
511 err = dsa_port_notify(dp, DSA_NOTIFIER_LAG_LEAVE, &info);
512 if (err)
Vladimir Olteanab974622021-08-11 16:46:05 +0300513 dev_err(dp->ds->dev,
514 "port %d failed to notify DSA_NOTIFIER_LAG_LEAVE: %pe\n",
515 dp->index, ERR_PTR(err));
Tobias Waldekranz058102a2021-01-13 09:42:53 +0100516
517 dsa_lag_unmap(dp->ds->dst, lag);
518}
519
Vladimir Olteanadb256e2020-09-21 03:10:28 +0300520/* Must be called under rcu_read_lock() */
Vladimir Oltean8f5d16f2019-04-28 21:45:44 +0300521static bool dsa_port_can_apply_vlan_filtering(struct dsa_port *dp,
Vladimir Oltean89153ed2021-02-13 22:43:19 +0200522 bool vlan_filtering,
523 struct netlink_ext_ack *extack)
Vladimir Oltean8f5d16f2019-04-28 21:45:44 +0300524{
525 struct dsa_switch *ds = dp->ds;
Vladimir Olteand0004a02021-10-20 20:49:50 +0300526 struct dsa_port *other_dp;
527 int err;
Vladimir Olteanadb256e2020-09-21 03:10:28 +0300528
529 /* VLAN awareness was off, so the question is "can we turn it on".
530 * We may have had 8021q uppers, those need to go. Make sure we don't
531 * enter an inconsistent state: deny changing the VLAN awareness state
532 * as long as we have 8021q uppers.
533 */
Vladimir Oltean57d77982021-10-20 20:49:52 +0300534 if (vlan_filtering && dsa_port_is_user(dp)) {
Vladimir Oltean36cbf392021-12-06 18:57:52 +0200535 struct net_device *br = dsa_port_bridge_dev_get(dp);
Vladimir Olteanadb256e2020-09-21 03:10:28 +0300536 struct net_device *upper_dev, *slave = dp->slave;
Vladimir Olteanadb256e2020-09-21 03:10:28 +0300537 struct list_head *iter;
538
539 netdev_for_each_upper_dev_rcu(slave, upper_dev, iter) {
540 struct bridge_vlan_info br_info;
541 u16 vid;
542
543 if (!is_vlan_dev(upper_dev))
544 continue;
545
546 vid = vlan_dev_vlan_id(upper_dev);
547
548 /* br_vlan_get_info() returns -EINVAL or -ENOENT if the
549 * device, respectively the VID is not found, returning
550 * 0 means success, which is a failure for us here.
551 */
552 err = br_vlan_get_info(br, vid, &br_info);
553 if (err == 0) {
Vladimir Oltean89153ed2021-02-13 22:43:19 +0200554 NL_SET_ERR_MSG_MOD(extack,
555 "Must first remove VLAN uppers having VIDs also present in bridge");
Vladimir Olteanadb256e2020-09-21 03:10:28 +0300556 return false;
557 }
558 }
559 }
Vladimir Oltean8f5d16f2019-04-28 21:45:44 +0300560
561 if (!ds->vlan_filtering_is_global)
562 return true;
563
564 /* For cases where enabling/disabling VLAN awareness is global to the
565 * switch, we need to handle the case where multiple bridges span
566 * different ports of the same switch device and one of them has a
567 * different setting than what is being requested.
568 */
Vladimir Olteand0004a02021-10-20 20:49:50 +0300569 dsa_switch_for_each_port(other_dp, ds) {
Vladimir Oltean36cbf392021-12-06 18:57:52 +0200570 struct net_device *other_br = dsa_port_bridge_dev_get(other_dp);
Vladimir Oltean8f5d16f2019-04-28 21:45:44 +0300571
Vladimir Oltean8f5d16f2019-04-28 21:45:44 +0300572 /* If it's the same bridge, it also has same
573 * vlan_filtering setting => no need to check
574 */
Vladimir Oltean36cbf392021-12-06 18:57:52 +0200575 if (!other_br || other_br == dsa_port_bridge_dev_get(dp))
Vladimir Oltean8f5d16f2019-04-28 21:45:44 +0300576 continue;
Vladimir Oltean36cbf392021-12-06 18:57:52 +0200577
578 if (br_vlan_enabled(other_br) != vlan_filtering) {
Vladimir Oltean89153ed2021-02-13 22:43:19 +0200579 NL_SET_ERR_MSG_MOD(extack,
580 "VLAN filtering is a global setting");
Vladimir Oltean8f5d16f2019-04-28 21:45:44 +0300581 return false;
582 }
583 }
584 return true;
585}
586
Vladimir Oltean89153ed2021-02-13 22:43:19 +0200587int dsa_port_vlan_filtering(struct dsa_port *dp, bool vlan_filtering,
588 struct netlink_ext_ack *extack)
Vivien Didelot4d61d302017-05-19 17:00:46 -0400589{
Vladimir Oltean06cfb2d2021-08-24 00:22:57 +0300590 bool old_vlan_filtering = dsa_port_is_vlan_filtering(dp);
Vivien Didelot4d61d302017-05-19 17:00:46 -0400591 struct dsa_switch *ds = dp->ds;
Vladimir Olteanbae33f22021-01-09 02:01:50 +0200592 bool apply;
Vladimir Oltean33162e92019-04-28 21:45:43 +0300593 int err;
Vivien Didelot4d61d302017-05-19 17:00:46 -0400594
Vladimir Olteanbae33f22021-01-09 02:01:50 +0200595 if (!ds->ops->port_vlan_filtering)
596 return -EOPNOTSUPP;
Vladimir Olteanadb256e2020-09-21 03:10:28 +0300597
Vladimir Olteanbae33f22021-01-09 02:01:50 +0200598 /* We are called from dsa_slave_switchdev_blocking_event(),
599 * which is not under rcu_read_lock(), unlike
600 * dsa_slave_switchdev_event().
601 */
602 rcu_read_lock();
Vladimir Oltean89153ed2021-02-13 22:43:19 +0200603 apply = dsa_port_can_apply_vlan_filtering(dp, vlan_filtering, extack);
Vladimir Olteanbae33f22021-01-09 02:01:50 +0200604 rcu_read_unlock();
605 if (!apply)
606 return -EINVAL;
Vladimir Oltean8f5d16f2019-04-28 21:45:44 +0300607
Vladimir Olteanec9121e2019-04-28 21:45:51 +0300608 if (dsa_port_is_vlan_filtering(dp) == vlan_filtering)
609 return 0;
610
Vladimir Oltean89153ed2021-02-13 22:43:19 +0200611 err = ds->ops->port_vlan_filtering(ds, dp->index, vlan_filtering,
612 extack);
Vladimir Oltean8f5d16f2019-04-28 21:45:44 +0300613 if (err)
614 return err;
615
Vladimir Oltean06cfb2d2021-08-24 00:22:57 +0300616 if (ds->vlan_filtering_is_global) {
Vladimir Olteand0004a02021-10-20 20:49:50 +0300617 struct dsa_port *other_dp;
Vladimir Oltean06cfb2d2021-08-24 00:22:57 +0300618
Vladimir Olteanbae33f22021-01-09 02:01:50 +0200619 ds->vlan_filtering = vlan_filtering;
Vladimir Oltean06cfb2d2021-08-24 00:22:57 +0300620
Vladimir Olteand0004a02021-10-20 20:49:50 +0300621 dsa_switch_for_each_user_port(other_dp, ds) {
622 struct net_device *slave = dp->slave;
Vladimir Oltean06cfb2d2021-08-24 00:22:57 +0300623
624 /* We might be called in the unbind path, so not
625 * all slave devices might still be registered.
626 */
Vladimir Oltean06cfb2d2021-08-24 00:22:57 +0300627 if (!slave)
628 continue;
629
630 err = dsa_slave_manage_vlan_filtering(slave,
631 vlan_filtering);
632 if (err)
633 goto restore;
634 }
635 } else {
Vladimir Olteanbae33f22021-01-09 02:01:50 +0200636 dp->vlan_filtering = vlan_filtering;
Vladimir Oltean2e554a72020-10-03 01:06:46 +0300637
Vladimir Oltean06cfb2d2021-08-24 00:22:57 +0300638 err = dsa_slave_manage_vlan_filtering(dp->slave,
639 vlan_filtering);
640 if (err)
641 goto restore;
642 }
643
Vivien Didelot4d61d302017-05-19 17:00:46 -0400644 return 0;
Vladimir Oltean06cfb2d2021-08-24 00:22:57 +0300645
646restore:
647 ds->ops->port_vlan_filtering(ds, dp->index, old_vlan_filtering, NULL);
648
649 if (ds->vlan_filtering_is_global)
650 ds->vlan_filtering = old_vlan_filtering;
651 else
652 dp->vlan_filtering = old_vlan_filtering;
653
654 return err;
Vivien Didelot4d61d302017-05-19 17:00:46 -0400655}
Vivien Didelotd87bd942017-05-19 17:00:47 -0400656
Russell King54a0ed02020-05-12 20:20:25 +0300657/* This enforces legacy behavior for switch drivers which assume they can't
658 * receive VLAN configuration when enslaved to a bridge with vlan_filtering=0
659 */
660bool dsa_port_skip_vlan_configuration(struct dsa_port *dp)
661{
Vladimir Oltean36cbf392021-12-06 18:57:52 +0200662 struct net_device *br = dsa_port_bridge_dev_get(dp);
Russell King54a0ed02020-05-12 20:20:25 +0300663 struct dsa_switch *ds = dp->ds;
664
Vladimir Oltean36cbf392021-12-06 18:57:52 +0200665 if (!br)
Russell King54a0ed02020-05-12 20:20:25 +0300666 return false;
667
Vladimir Oltean36cbf392021-12-06 18:57:52 +0200668 return !ds->configure_vlan_while_not_filtering && !br_vlan_enabled(br);
Russell King54a0ed02020-05-12 20:20:25 +0300669}
670
Vladimir Olteanbae33f22021-01-09 02:01:50 +0200671int dsa_port_ageing_time(struct dsa_port *dp, clock_t ageing_clock)
Vivien Didelotd87bd942017-05-19 17:00:47 -0400672{
673 unsigned long ageing_jiffies = clock_t_to_jiffies(ageing_clock);
674 unsigned int ageing_time = jiffies_to_msecs(ageing_jiffies);
Vladimir Olteanbae33f22021-01-09 02:01:50 +0200675 struct dsa_notifier_ageing_time_info info;
Vladimir Olteanbae33f22021-01-09 02:01:50 +0200676 int err;
Vivien Didelotd87bd942017-05-19 17:00:47 -0400677
Vladimir Olteanbae33f22021-01-09 02:01:50 +0200678 info.ageing_time = ageing_time;
Vladimir Olteanbae33f22021-01-09 02:01:50 +0200679
Vladimir Olteanbae33f22021-01-09 02:01:50 +0200680 err = dsa_port_notify(dp, DSA_NOTIFIER_AGEING_TIME, &info);
681 if (err)
682 return err;
Vivien Didelotd87bd942017-05-19 17:00:47 -0400683
Vivien Didelotd87bd942017-05-19 17:00:47 -0400684 dp->ageing_time = ageing_time;
Vivien Didelotd87bd942017-05-19 17:00:47 -0400685
Vladimir Oltean77b61362021-01-09 02:01:51 +0200686 return 0;
Vivien Didelotd87bd942017-05-19 17:00:47 -0400687}
Vivien Didelotd1cffff2017-05-19 17:00:48 -0400688
Vladimir Olteane18f4c12021-02-12 17:15:55 +0200689int dsa_port_pre_bridge_flags(const struct dsa_port *dp,
Vladimir Olteana8b659e2021-02-12 17:15:56 +0200690 struct switchdev_brport_flags flags,
691 struct netlink_ext_ack *extack)
Florian Fainelliea870052019-02-20 16:58:22 -0800692{
693 struct dsa_switch *ds = dp->ds;
694
Vladimir Olteana8b659e2021-02-12 17:15:56 +0200695 if (!ds->ops->port_pre_bridge_flags)
Florian Fainelliea870052019-02-20 16:58:22 -0800696 return -EINVAL;
697
Vladimir Olteana8b659e2021-02-12 17:15:56 +0200698 return ds->ops->port_pre_bridge_flags(ds, dp->index, flags, extack);
Florian Fainelliea870052019-02-20 16:58:22 -0800699}
700
Vladimir Oltean045c45d2021-08-08 17:35:23 +0300701int dsa_port_bridge_flags(struct dsa_port *dp,
Vladimir Olteana8b659e2021-02-12 17:15:56 +0200702 struct switchdev_brport_flags flags,
703 struct netlink_ext_ack *extack)
Russell King57652792019-02-20 15:35:04 -0800704{
705 struct dsa_switch *ds = dp->ds;
Vladimir Oltean045c45d2021-08-08 17:35:23 +0300706 int err;
Russell King57652792019-02-20 15:35:04 -0800707
Vladimir Olteana8b659e2021-02-12 17:15:56 +0200708 if (!ds->ops->port_bridge_flags)
Oleksij Rempel70a7c482021-04-21 15:05:40 +0200709 return -EOPNOTSUPP;
Russell King57652792019-02-20 15:35:04 -0800710
Vladimir Oltean045c45d2021-08-08 17:35:23 +0300711 err = ds->ops->port_bridge_flags(ds, dp->index, flags, extack);
712 if (err)
713 return err;
714
715 if (flags.mask & BR_LEARNING) {
716 bool learning = flags.val & BR_LEARNING;
717
718 if (learning == dp->learning)
719 return 0;
720
Vladimir Olteanbee7c572021-08-09 01:56:49 +0300721 if ((dp->learning && !learning) &&
722 (dp->stp_state == BR_STATE_LEARNING ||
723 dp->stp_state == BR_STATE_FORWARDING))
Vladimir Oltean045c45d2021-08-08 17:35:23 +0300724 dsa_port_fast_age(dp);
725
726 dp->learning = learning;
727 }
728
729 return 0;
Russell King57652792019-02-20 15:35:04 -0800730}
731
Vladimir Olteanbfcb8132020-03-27 21:55:42 +0200732int dsa_port_mtu_change(struct dsa_port *dp, int new_mtu,
Vladimir Oltean88faba22021-06-21 19:42:18 +0300733 bool targeted_match)
Vladimir Olteanbfcb8132020-03-27 21:55:42 +0200734{
735 struct dsa_notifier_mtu_info info = {
736 .sw_index = dp->ds->index,
Vladimir Oltean88faba22021-06-21 19:42:18 +0300737 .targeted_match = targeted_match,
Vladimir Olteanbfcb8132020-03-27 21:55:42 +0200738 .port = dp->index,
739 .mtu = new_mtu,
740 };
741
742 return dsa_port_notify(dp, DSA_NOTIFIER_MTU, &info);
743}
744
Arkadi Sharshevsky2acf4e62017-08-06 16:15:41 +0300745int dsa_port_fdb_add(struct dsa_port *dp, const unsigned char *addr,
746 u16 vid)
Vivien Didelotd1cffff2017-05-19 17:00:48 -0400747{
Vivien Didelot685fb6a2017-05-19 17:00:53 -0400748 struct dsa_notifier_fdb_info info = {
749 .sw_index = dp->ds->index,
750 .port = dp->index,
Arkadi Sharshevsky2acf4e62017-08-06 16:15:41 +0300751 .addr = addr,
752 .vid = vid,
Vivien Didelot685fb6a2017-05-19 17:00:53 -0400753 };
Vivien Didelotd1cffff2017-05-19 17:00:48 -0400754
Vivien Didelot685fb6a2017-05-19 17:00:53 -0400755 return dsa_port_notify(dp, DSA_NOTIFIER_FDB_ADD, &info);
Vivien Didelotd1cffff2017-05-19 17:00:48 -0400756}
757
Arkadi Sharshevsky2acf4e62017-08-06 16:15:41 +0300758int dsa_port_fdb_del(struct dsa_port *dp, const unsigned char *addr,
759 u16 vid)
Vivien Didelotd1cffff2017-05-19 17:00:48 -0400760{
Vivien Didelot685fb6a2017-05-19 17:00:53 -0400761 struct dsa_notifier_fdb_info info = {
762 .sw_index = dp->ds->index,
763 .port = dp->index,
Arkadi Sharshevsky2acf4e62017-08-06 16:15:41 +0300764 .addr = addr,
765 .vid = vid,
766
Vivien Didelot685fb6a2017-05-19 17:00:53 -0400767 };
Vivien Didelotd1cffff2017-05-19 17:00:48 -0400768
Vivien Didelot685fb6a2017-05-19 17:00:53 -0400769 return dsa_port_notify(dp, DSA_NOTIFIER_FDB_DEL, &info);
Vivien Didelotd1cffff2017-05-19 17:00:48 -0400770}
771
Vladimir Oltean3dc80af2021-06-29 17:06:51 +0300772int dsa_port_host_fdb_add(struct dsa_port *dp, const unsigned char *addr,
773 u16 vid)
774{
775 struct dsa_notifier_fdb_info info = {
776 .sw_index = dp->ds->index,
777 .port = dp->index,
778 .addr = addr,
779 .vid = vid,
780 };
Vladimir Oltean26ee7b02021-06-29 17:06:53 +0300781 struct dsa_port *cpu_dp = dp->cpu_dp;
782 int err;
783
784 err = dev_uc_add(cpu_dp->master, addr);
785 if (err)
786 return err;
Vladimir Oltean3dc80af2021-06-29 17:06:51 +0300787
788 return dsa_port_notify(dp, DSA_NOTIFIER_HOST_FDB_ADD, &info);
789}
790
791int dsa_port_host_fdb_del(struct dsa_port *dp, const unsigned char *addr,
792 u16 vid)
793{
794 struct dsa_notifier_fdb_info info = {
795 .sw_index = dp->ds->index,
796 .port = dp->index,
797 .addr = addr,
798 .vid = vid,
799 };
Vladimir Oltean26ee7b02021-06-29 17:06:53 +0300800 struct dsa_port *cpu_dp = dp->cpu_dp;
801 int err;
802
803 err = dev_uc_del(cpu_dp->master, addr);
804 if (err)
805 return err;
Vladimir Oltean3dc80af2021-06-29 17:06:51 +0300806
807 return dsa_port_notify(dp, DSA_NOTIFIER_HOST_FDB_DEL, &info);
808}
809
Vivien Didelotde40fc52017-09-20 19:32:14 -0400810int dsa_port_fdb_dump(struct dsa_port *dp, dsa_fdb_dump_cb_t *cb, void *data)
811{
812 struct dsa_switch *ds = dp->ds;
813 int port = dp->index;
814
815 if (!ds->ops->port_fdb_dump)
816 return -EOPNOTSUPP;
817
818 return ds->ops->port_fdb_dump(ds, port, cb, data);
819}
820
Andrew Lunnbb9f603172017-11-09 23:11:01 +0100821int dsa_port_mdb_add(const struct dsa_port *dp,
Vladimir Olteanffb68fc2021-01-09 02:01:48 +0200822 const struct switchdev_obj_port_mdb *mdb)
Vivien Didelot3a9afea2017-05-19 17:00:49 -0400823{
Vivien Didelot8ae5bcd2017-05-19 17:00:54 -0400824 struct dsa_notifier_mdb_info info = {
825 .sw_index = dp->ds->index,
826 .port = dp->index,
Vivien Didelot8ae5bcd2017-05-19 17:00:54 -0400827 .mdb = mdb,
828 };
Vivien Didelot3a9afea2017-05-19 17:00:49 -0400829
Vivien Didelot8ae5bcd2017-05-19 17:00:54 -0400830 return dsa_port_notify(dp, DSA_NOTIFIER_MDB_ADD, &info);
Vivien Didelot3a9afea2017-05-19 17:00:49 -0400831}
832
Andrew Lunnbb9f603172017-11-09 23:11:01 +0100833int dsa_port_mdb_del(const struct dsa_port *dp,
Vivien Didelot3a9afea2017-05-19 17:00:49 -0400834 const struct switchdev_obj_port_mdb *mdb)
835{
Vivien Didelot8ae5bcd2017-05-19 17:00:54 -0400836 struct dsa_notifier_mdb_info info = {
837 .sw_index = dp->ds->index,
838 .port = dp->index,
839 .mdb = mdb,
840 };
Vivien Didelot3a9afea2017-05-19 17:00:49 -0400841
Vivien Didelot8ae5bcd2017-05-19 17:00:54 -0400842 return dsa_port_notify(dp, DSA_NOTIFIER_MDB_DEL, &info);
Vivien Didelot3a9afea2017-05-19 17:00:49 -0400843}
844
Vladimir Olteanb8e997c2021-06-29 17:06:49 +0300845int dsa_port_host_mdb_add(const struct dsa_port *dp,
846 const struct switchdev_obj_port_mdb *mdb)
847{
848 struct dsa_notifier_mdb_info info = {
849 .sw_index = dp->ds->index,
850 .port = dp->index,
851 .mdb = mdb,
852 };
Vladimir Oltean26ee7b02021-06-29 17:06:53 +0300853 struct dsa_port *cpu_dp = dp->cpu_dp;
854 int err;
855
856 err = dev_mc_add(cpu_dp->master, mdb->addr);
857 if (err)
858 return err;
Vladimir Olteanb8e997c2021-06-29 17:06:49 +0300859
860 return dsa_port_notify(dp, DSA_NOTIFIER_HOST_MDB_ADD, &info);
861}
862
863int dsa_port_host_mdb_del(const struct dsa_port *dp,
864 const struct switchdev_obj_port_mdb *mdb)
865{
866 struct dsa_notifier_mdb_info info = {
867 .sw_index = dp->ds->index,
868 .port = dp->index,
869 .mdb = mdb,
870 };
Vladimir Oltean26ee7b02021-06-29 17:06:53 +0300871 struct dsa_port *cpu_dp = dp->cpu_dp;
872 int err;
873
874 err = dev_mc_del(cpu_dp->master, mdb->addr);
875 if (err)
876 return err;
Vladimir Olteanb8e997c2021-06-29 17:06:49 +0300877
878 return dsa_port_notify(dp, DSA_NOTIFIER_HOST_MDB_DEL, &info);
879}
880
Vivien Didelot076e7132017-05-19 17:00:50 -0400881int dsa_port_vlan_add(struct dsa_port *dp,
Vladimir Oltean31046a52021-02-13 22:43:18 +0200882 const struct switchdev_obj_port_vlan *vlan,
883 struct netlink_ext_ack *extack)
Vivien Didelot076e7132017-05-19 17:00:50 -0400884{
Vivien Didelotd0c627b2017-05-19 17:00:55 -0400885 struct dsa_notifier_vlan_info info = {
886 .sw_index = dp->ds->index,
887 .port = dp->index,
Vivien Didelotd0c627b2017-05-19 17:00:55 -0400888 .vlan = vlan,
Vladimir Oltean31046a52021-02-13 22:43:18 +0200889 .extack = extack,
Vivien Didelotd0c627b2017-05-19 17:00:55 -0400890 };
Vivien Didelot076e7132017-05-19 17:00:50 -0400891
Vivien Didelotc5335d72019-08-25 13:25:18 -0400892 return dsa_port_notify(dp, DSA_NOTIFIER_VLAN_ADD, &info);
Vivien Didelot076e7132017-05-19 17:00:50 -0400893}
894
895int dsa_port_vlan_del(struct dsa_port *dp,
896 const struct switchdev_obj_port_vlan *vlan)
897{
Vivien Didelotd0c627b2017-05-19 17:00:55 -0400898 struct dsa_notifier_vlan_info info = {
899 .sw_index = dp->ds->index,
900 .port = dp->index,
901 .vlan = vlan,
902 };
Vivien Didelot076e7132017-05-19 17:00:50 -0400903
Vivien Didelotc5335d72019-08-25 13:25:18 -0400904 return dsa_port_notify(dp, DSA_NOTIFIER_VLAN_DEL, &info);
Vivien Didelot076e7132017-05-19 17:00:50 -0400905}
Vivien Didelot57ab1ca2017-10-26 10:50:07 -0400906
Horatiu Vulturc595c432021-02-16 22:42:04 +0100907int dsa_port_mrp_add(const struct dsa_port *dp,
908 const struct switchdev_obj_mrp *mrp)
909{
910 struct dsa_notifier_mrp_info info = {
911 .sw_index = dp->ds->index,
912 .port = dp->index,
913 .mrp = mrp,
914 };
915
916 return dsa_port_notify(dp, DSA_NOTIFIER_MRP_ADD, &info);
917}
918
919int dsa_port_mrp_del(const struct dsa_port *dp,
920 const struct switchdev_obj_mrp *mrp)
921{
922 struct dsa_notifier_mrp_info info = {
923 .sw_index = dp->ds->index,
924 .port = dp->index,
925 .mrp = mrp,
926 };
927
928 return dsa_port_notify(dp, DSA_NOTIFIER_MRP_DEL, &info);
929}
930
931int dsa_port_mrp_add_ring_role(const struct dsa_port *dp,
932 const struct switchdev_obj_ring_role_mrp *mrp)
933{
934 struct dsa_notifier_mrp_ring_role_info info = {
935 .sw_index = dp->ds->index,
936 .port = dp->index,
937 .mrp = mrp,
938 };
939
940 return dsa_port_notify(dp, DSA_NOTIFIER_MRP_ADD_RING_ROLE, &info);
941}
942
943int dsa_port_mrp_del_ring_role(const struct dsa_port *dp,
944 const struct switchdev_obj_ring_role_mrp *mrp)
945{
946 struct dsa_notifier_mrp_ring_role_info info = {
947 .sw_index = dp->ds->index,
948 .port = dp->index,
949 .mrp = mrp,
950 };
951
952 return dsa_port_notify(dp, DSA_NOTIFIER_MRP_DEL_RING_ROLE, &info);
953}
954
Vladimir Oltean53da0eb2021-01-29 03:00:06 +0200955void dsa_port_set_tag_protocol(struct dsa_port *cpu_dp,
956 const struct dsa_device_ops *tag_ops)
957{
Vladimir Oltean53da0eb2021-01-29 03:00:06 +0200958 cpu_dp->rcv = tag_ops->rcv;
959 cpu_dp->tag_ops = tag_ops;
960}
961
Florian Fainelli6207a782018-04-25 12:12:51 -0700962static struct phy_device *dsa_port_get_phy_device(struct dsa_port *dp)
963{
964 struct device_node *phy_dn;
965 struct phy_device *phydev;
966
967 phy_dn = of_parse_phandle(dp->dn, "phy-handle", 0);
968 if (!phy_dn)
969 return NULL;
970
971 phydev = of_phy_find_device(phy_dn);
972 if (!phydev) {
973 of_node_put(phy_dn);
974 return ERR_PTR(-EPROBE_DEFER);
975 }
976
Wen Yang9919a362019-02-25 15:22:19 +0800977 of_node_put(phy_dn);
Florian Fainelli6207a782018-04-25 12:12:51 -0700978 return phydev;
979}
980
Florian Fainelli8ae67492019-12-16 10:32:47 -0800981static void dsa_port_phylink_validate(struct phylink_config *config,
982 unsigned long *supported,
983 struct phylink_link_state *state)
Ioana Ciornei77373d42019-05-28 20:38:15 +0300984{
985 struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
986 struct dsa_switch *ds = dp->ds;
987
Russell King (Oracle)5938bce2021-11-30 13:10:06 +0000988 if (!ds->ops->phylink_validate) {
989 if (config->mac_capabilities)
990 phylink_generic_validate(config, supported, state);
Ioana Ciornei77373d42019-05-28 20:38:15 +0300991 return;
Russell King (Oracle)5938bce2021-11-30 13:10:06 +0000992 }
Ioana Ciornei77373d42019-05-28 20:38:15 +0300993
994 ds->ops->phylink_validate(ds, dp->index, supported, state);
995}
Ioana Ciornei77373d42019-05-28 20:38:15 +0300996
Florian Fainelli8ae67492019-12-16 10:32:47 -0800997static void dsa_port_phylink_mac_pcs_get_state(struct phylink_config *config,
998 struct phylink_link_state *state)
Ioana Ciornei77373d42019-05-28 20:38:15 +0300999{
1000 struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
1001 struct dsa_switch *ds = dp->ds;
Russell King87615c962020-03-14 10:15:28 +00001002 int err;
Ioana Ciornei77373d42019-05-28 20:38:15 +03001003
Russell Kingd46b7e42019-11-21 00:36:22 +00001004 /* Only called for inband modes */
1005 if (!ds->ops->phylink_mac_link_state) {
1006 state->link = 0;
1007 return;
1008 }
Ioana Ciornei77373d42019-05-28 20:38:15 +03001009
Russell King87615c962020-03-14 10:15:28 +00001010 err = ds->ops->phylink_mac_link_state(ds, dp->index, state);
1011 if (err < 0) {
1012 dev_err(ds->dev, "p%d: phylink_mac_link_state() failed: %d\n",
1013 dp->index, err);
Russell Kingd46b7e42019-11-21 00:36:22 +00001014 state->link = 0;
Russell King87615c962020-03-14 10:15:28 +00001015 }
Ioana Ciornei77373d42019-05-28 20:38:15 +03001016}
Ioana Ciornei77373d42019-05-28 20:38:15 +03001017
Florian Fainelli8ae67492019-12-16 10:32:47 -08001018static void dsa_port_phylink_mac_config(struct phylink_config *config,
1019 unsigned int mode,
1020 const struct phylink_link_state *state)
Ioana Ciornei77373d42019-05-28 20:38:15 +03001021{
1022 struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
1023 struct dsa_switch *ds = dp->ds;
1024
1025 if (!ds->ops->phylink_mac_config)
1026 return;
1027
1028 ds->ops->phylink_mac_config(ds, dp->index, mode, state);
1029}
Ioana Ciornei77373d42019-05-28 20:38:15 +03001030
Florian Fainelli8ae67492019-12-16 10:32:47 -08001031static void dsa_port_phylink_mac_an_restart(struct phylink_config *config)
Ioana Ciornei77373d42019-05-28 20:38:15 +03001032{
1033 struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
1034 struct dsa_switch *ds = dp->ds;
1035
1036 if (!ds->ops->phylink_mac_an_restart)
1037 return;
1038
1039 ds->ops->phylink_mac_an_restart(ds, dp->index);
1040}
Ioana Ciornei77373d42019-05-28 20:38:15 +03001041
Florian Fainelli8ae67492019-12-16 10:32:47 -08001042static void dsa_port_phylink_mac_link_down(struct phylink_config *config,
1043 unsigned int mode,
1044 phy_interface_t interface)
Ioana Ciornei77373d42019-05-28 20:38:15 +03001045{
1046 struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
Ioana Ciornei0e279212019-05-28 20:38:16 +03001047 struct phy_device *phydev = NULL;
Ioana Ciornei77373d42019-05-28 20:38:15 +03001048 struct dsa_switch *ds = dp->ds;
1049
Vladimir Oltean57d77982021-10-20 20:49:52 +03001050 if (dsa_port_is_user(dp))
Ioana Ciornei0e279212019-05-28 20:38:16 +03001051 phydev = dp->slave->phydev;
1052
Ioana Ciornei77373d42019-05-28 20:38:15 +03001053 if (!ds->ops->phylink_mac_link_down) {
Ioana Ciornei0e279212019-05-28 20:38:16 +03001054 if (ds->ops->adjust_link && phydev)
1055 ds->ops->adjust_link(ds, dp->index, phydev);
Ioana Ciornei77373d42019-05-28 20:38:15 +03001056 return;
1057 }
1058
1059 ds->ops->phylink_mac_link_down(ds, dp->index, mode, interface);
1060}
Ioana Ciornei77373d42019-05-28 20:38:15 +03001061
Florian Fainelli8ae67492019-12-16 10:32:47 -08001062static void dsa_port_phylink_mac_link_up(struct phylink_config *config,
Russell King91a208f2020-02-26 10:23:41 +00001063 struct phy_device *phydev,
Florian Fainelli8ae67492019-12-16 10:32:47 -08001064 unsigned int mode,
1065 phy_interface_t interface,
Russell King91a208f2020-02-26 10:23:41 +00001066 int speed, int duplex,
1067 bool tx_pause, bool rx_pause)
Ioana Ciornei77373d42019-05-28 20:38:15 +03001068{
1069 struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
Ioana Ciornei77373d42019-05-28 20:38:15 +03001070 struct dsa_switch *ds = dp->ds;
1071
1072 if (!ds->ops->phylink_mac_link_up) {
Ioana Ciornei0e279212019-05-28 20:38:16 +03001073 if (ds->ops->adjust_link && phydev)
1074 ds->ops->adjust_link(ds, dp->index, phydev);
Ioana Ciornei77373d42019-05-28 20:38:15 +03001075 return;
1076 }
1077
Russell King5b502a72020-02-26 10:23:46 +00001078 ds->ops->phylink_mac_link_up(ds, dp->index, mode, interface, phydev,
1079 speed, duplex, tx_pause, rx_pause);
Ioana Ciornei77373d42019-05-28 20:38:15 +03001080}
Ioana Ciornei77373d42019-05-28 20:38:15 +03001081
Russell King (Oracle)21bd64b2021-11-30 13:09:55 +00001082static const struct phylink_mac_ops dsa_port_phylink_mac_ops = {
Ioana Ciornei77373d42019-05-28 20:38:15 +03001083 .validate = dsa_port_phylink_validate,
Russell Kingd46b7e42019-11-21 00:36:22 +00001084 .mac_pcs_get_state = dsa_port_phylink_mac_pcs_get_state,
Ioana Ciornei77373d42019-05-28 20:38:15 +03001085 .mac_config = dsa_port_phylink_mac_config,
1086 .mac_an_restart = dsa_port_phylink_mac_an_restart,
1087 .mac_link_down = dsa_port_phylink_mac_link_down,
1088 .mac_link_up = dsa_port_phylink_mac_link_up,
1089};
1090
Russell King (Oracle)21bd64b2021-11-30 13:09:55 +00001091int dsa_port_phylink_create(struct dsa_port *dp)
1092{
1093 struct dsa_switch *ds = dp->ds;
1094 phy_interface_t mode;
1095 int err;
1096
1097 err = of_get_phy_mode(dp->dn, &mode);
1098 if (err)
1099 mode = PHY_INTERFACE_MODE_NA;
1100
Russell King (Oracle)0a9f0792021-12-09 13:11:38 +00001101 /* Presence of phylink_mac_link_state or phylink_mac_an_restart is
1102 * an indicator of a legacy phylink driver.
1103 */
1104 if (ds->ops->phylink_mac_link_state ||
1105 ds->ops->phylink_mac_an_restart)
1106 dp->pl_config.legacy_pre_march2020 = true;
1107
Russell King (Oracle)072eea62021-11-30 13:10:01 +00001108 if (ds->ops->phylink_get_caps)
1109 ds->ops->phylink_get_caps(ds, dp->index, &dp->pl_config);
Russell King (Oracle)21bd64b2021-11-30 13:09:55 +00001110
1111 dp->pl = phylink_create(&dp->pl_config, of_fwnode_handle(dp->dn),
1112 mode, &dsa_port_phylink_mac_ops);
1113 if (IS_ERR(dp->pl)) {
1114 pr_err("error creating PHYLINK: %ld\n", PTR_ERR(dp->pl));
1115 return PTR_ERR(dp->pl);
1116 }
1117
1118 return 0;
1119}
1120
Sebastian Reichel33615362018-01-23 16:03:46 +01001121static int dsa_port_setup_phy_of(struct dsa_port *dp, bool enable)
1122{
Sebastian Reichel33615362018-01-23 16:03:46 +01001123 struct dsa_switch *ds = dp->ds;
1124 struct phy_device *phydev;
1125 int port = dp->index;
1126 int err = 0;
1127
Florian Fainelli6207a782018-04-25 12:12:51 -07001128 phydev = dsa_port_get_phy_device(dp);
1129 if (!phydev)
Sebastian Reichel33615362018-01-23 16:03:46 +01001130 return 0;
1131
Florian Fainelli6207a782018-04-25 12:12:51 -07001132 if (IS_ERR(phydev))
1133 return PTR_ERR(phydev);
Sebastian Reichel33615362018-01-23 16:03:46 +01001134
1135 if (enable) {
Sebastian Reichel33615362018-01-23 16:03:46 +01001136 err = genphy_resume(phydev);
1137 if (err < 0)
1138 goto err_put_dev;
1139
1140 err = genphy_read_status(phydev);
1141 if (err < 0)
1142 goto err_put_dev;
1143 } else {
1144 err = genphy_suspend(phydev);
1145 if (err < 0)
1146 goto err_put_dev;
1147 }
1148
1149 if (ds->ops->adjust_link)
1150 ds->ops->adjust_link(ds, port, phydev);
1151
1152 dev_dbg(ds->dev, "enabled port's phy: %s", phydev_name(phydev));
1153
1154err_put_dev:
1155 put_device(&phydev->mdio.dev);
Sebastian Reichel33615362018-01-23 16:03:46 +01001156 return err;
1157}
1158
1159static int dsa_port_fixed_link_register_of(struct dsa_port *dp)
Vivien Didelot57ab1ca2017-10-26 10:50:07 -04001160{
1161 struct device_node *dn = dp->dn;
1162 struct dsa_switch *ds = dp->ds;
1163 struct phy_device *phydev;
1164 int port = dp->index;
Andrew Lunn0c65b2b2019-11-04 02:40:33 +01001165 phy_interface_t mode;
Vivien Didelot57ab1ca2017-10-26 10:50:07 -04001166 int err;
1167
Sebastian Reichel33615362018-01-23 16:03:46 +01001168 err = of_phy_register_fixed_link(dn);
1169 if (err) {
1170 dev_err(ds->dev,
1171 "failed to register the fixed PHY of port %d\n",
1172 port);
1173 return err;
Vivien Didelot57ab1ca2017-10-26 10:50:07 -04001174 }
1175
Sebastian Reichel33615362018-01-23 16:03:46 +01001176 phydev = of_phy_find_device(dn);
1177
Andrew Lunn0c65b2b2019-11-04 02:40:33 +01001178 err = of_get_phy_mode(dn, &mode);
1179 if (err)
Sebastian Reichel33615362018-01-23 16:03:46 +01001180 mode = PHY_INTERFACE_MODE_NA;
1181 phydev->interface = mode;
1182
Sebastian Reichel33615362018-01-23 16:03:46 +01001183 genphy_read_status(phydev);
1184
1185 if (ds->ops->adjust_link)
1186 ds->ops->adjust_link(ds, port, phydev);
1187
1188 put_device(&phydev->mdio.dev);
1189
Vivien Didelot57ab1ca2017-10-26 10:50:07 -04001190 return 0;
1191}
1192
Ioana Ciornei0e279212019-05-28 20:38:16 +03001193static int dsa_port_phylink_register(struct dsa_port *dp)
1194{
1195 struct dsa_switch *ds = dp->ds;
1196 struct device_node *port_dn = dp->dn;
Andrew Lunn0c65b2b2019-11-04 02:40:33 +01001197 int err;
Ioana Ciornei0e279212019-05-28 20:38:16 +03001198
Ioana Ciornei0e279212019-05-28 20:38:16 +03001199 dp->pl_config.dev = ds->dev;
1200 dp->pl_config.type = PHYLINK_DEV;
Vladimir Oltean787cac32020-01-06 03:34:12 +02001201 dp->pl_config.pcs_poll = ds->pcs_poll;
Ioana Ciornei0e279212019-05-28 20:38:16 +03001202
Russell King (Oracle)21bd64b2021-11-30 13:09:55 +00001203 err = dsa_port_phylink_create(dp);
1204 if (err)
1205 return err;
Ioana Ciornei0e279212019-05-28 20:38:16 +03001206
1207 err = phylink_of_phy_connect(dp->pl, port_dn, 0);
Florian Fainelli2131fba2019-06-10 12:31:49 -07001208 if (err && err != -ENODEV) {
Ioana Ciornei0e279212019-05-28 20:38:16 +03001209 pr_err("could not attach to PHY: %d\n", err);
1210 goto err_phy_connect;
1211 }
1212
Ioana Ciornei0e279212019-05-28 20:38:16 +03001213 return 0;
1214
1215err_phy_connect:
1216 phylink_destroy(dp->pl);
1217 return err;
1218}
1219
Sebastian Reichel33615362018-01-23 16:03:46 +01001220int dsa_port_link_register_of(struct dsa_port *dp)
Vivien Didelot57ab1ca2017-10-26 10:50:07 -04001221{
Ioana Ciornei0e279212019-05-28 20:38:16 +03001222 struct dsa_switch *ds = dp->ds;
Andrew Lunna20f9972020-03-11 16:24:24 +01001223 struct device_node *phy_np;
Andrew Lunn3be98b22020-04-14 02:34:39 +02001224 int port = dp->index;
Ioana Ciornei0e279212019-05-28 20:38:16 +03001225
Andrew Lunna20f9972020-03-11 16:24:24 +01001226 if (!ds->ops->adjust_link) {
1227 phy_np = of_parse_phandle(dp->dn, "phy-handle", 0);
Andrew Lunn3be98b22020-04-14 02:34:39 +02001228 if (of_phy_is_fixed_link(dp->dn) || phy_np) {
1229 if (ds->ops->phylink_mac_link_down)
1230 ds->ops->phylink_mac_link_down(ds, port,
1231 MLO_AN_FIXED, PHY_INTERFACE_MODE_NA);
Andrew Lunna20f9972020-03-11 16:24:24 +01001232 return dsa_port_phylink_register(dp);
Andrew Lunn3be98b22020-04-14 02:34:39 +02001233 }
Andrew Lunna20f9972020-03-11 16:24:24 +01001234 return 0;
1235 }
Ioana Ciornei0e279212019-05-28 20:38:16 +03001236
1237 dev_warn(ds->dev,
1238 "Using legacy PHYLIB callbacks. Please migrate to PHYLINK!\n");
1239
Sebastian Reichel33615362018-01-23 16:03:46 +01001240 if (of_phy_is_fixed_link(dp->dn))
1241 return dsa_port_fixed_link_register_of(dp);
1242 else
1243 return dsa_port_setup_phy_of(dp, true);
1244}
Vivien Didelot57ab1ca2017-10-26 10:50:07 -04001245
Sebastian Reichel33615362018-01-23 16:03:46 +01001246void dsa_port_link_unregister_of(struct dsa_port *dp)
1247{
Ioana Ciornei0e279212019-05-28 20:38:16 +03001248 struct dsa_switch *ds = dp->ds;
1249
Andrew Lunna20f9972020-03-11 16:24:24 +01001250 if (!ds->ops->adjust_link && dp->pl) {
Ioana Ciornei0e279212019-05-28 20:38:16 +03001251 rtnl_lock();
1252 phylink_disconnect_phy(dp->pl);
1253 rtnl_unlock();
1254 phylink_destroy(dp->pl);
Andrew Lunna20f9972020-03-11 16:24:24 +01001255 dp->pl = NULL;
Ioana Ciornei0e279212019-05-28 20:38:16 +03001256 return;
1257 }
1258
Sebastian Reichel33615362018-01-23 16:03:46 +01001259 if (of_phy_is_fixed_link(dp->dn))
1260 of_phy_deregister_fixed_link(dp->dn);
1261 else
1262 dsa_port_setup_phy_of(dp, false);
Vivien Didelot57ab1ca2017-10-26 10:50:07 -04001263}
Florian Fainellicf963572018-04-25 12:12:52 -07001264
1265int dsa_port_get_phy_strings(struct dsa_port *dp, uint8_t *data)
1266{
1267 struct phy_device *phydev;
1268 int ret = -EOPNOTSUPP;
1269
1270 if (of_phy_is_fixed_link(dp->dn))
1271 return ret;
1272
1273 phydev = dsa_port_get_phy_device(dp);
1274 if (IS_ERR_OR_NULL(phydev))
1275 return ret;
1276
1277 ret = phy_ethtool_get_strings(phydev, data);
1278 put_device(&phydev->mdio.dev);
1279
1280 return ret;
1281}
1282EXPORT_SYMBOL_GPL(dsa_port_get_phy_strings);
1283
1284int dsa_port_get_ethtool_phy_stats(struct dsa_port *dp, uint64_t *data)
1285{
1286 struct phy_device *phydev;
1287 int ret = -EOPNOTSUPP;
1288
1289 if (of_phy_is_fixed_link(dp->dn))
1290 return ret;
1291
1292 phydev = dsa_port_get_phy_device(dp);
1293 if (IS_ERR_OR_NULL(phydev))
1294 return ret;
1295
1296 ret = phy_ethtool_get_stats(phydev, NULL, data);
1297 put_device(&phydev->mdio.dev);
1298
1299 return ret;
1300}
1301EXPORT_SYMBOL_GPL(dsa_port_get_ethtool_phy_stats);
1302
1303int dsa_port_get_phy_sset_count(struct dsa_port *dp)
1304{
1305 struct phy_device *phydev;
1306 int ret = -EOPNOTSUPP;
1307
1308 if (of_phy_is_fixed_link(dp->dn))
1309 return ret;
1310
1311 phydev = dsa_port_get_phy_device(dp);
1312 if (IS_ERR_OR_NULL(phydev))
1313 return ret;
1314
1315 ret = phy_ethtool_get_sset_count(phydev);
1316 put_device(&phydev->mdio.dev);
1317
1318 return ret;
1319}
1320EXPORT_SYMBOL_GPL(dsa_port_get_phy_sset_count);
George McCollister18596f52021-02-09 19:02:12 -06001321
1322int dsa_port_hsr_join(struct dsa_port *dp, struct net_device *hsr)
1323{
1324 struct dsa_notifier_hsr_info info = {
1325 .sw_index = dp->ds->index,
1326 .port = dp->index,
1327 .hsr = hsr,
1328 };
1329 int err;
1330
1331 dp->hsr_dev = hsr;
1332
1333 err = dsa_port_notify(dp, DSA_NOTIFIER_HSR_JOIN, &info);
1334 if (err)
1335 dp->hsr_dev = NULL;
1336
1337 return err;
1338}
1339
1340void dsa_port_hsr_leave(struct dsa_port *dp, struct net_device *hsr)
1341{
1342 struct dsa_notifier_hsr_info info = {
1343 .sw_index = dp->ds->index,
1344 .port = dp->index,
1345 .hsr = hsr,
1346 };
1347 int err;
1348
1349 dp->hsr_dev = NULL;
1350
1351 err = dsa_port_notify(dp, DSA_NOTIFIER_HSR_LEAVE, &info);
1352 if (err)
Vladimir Olteanab974622021-08-11 16:46:05 +03001353 dev_err(dp->ds->dev,
1354 "port %d failed to notify DSA_NOTIFIER_HSR_LEAVE: %pe\n",
1355 dp->index, ERR_PTR(err));
George McCollister18596f52021-02-09 19:02:12 -06001356}
Vladimir Olteanc64b9c02021-07-19 20:14:52 +03001357
Vladimir Oltean724395f2021-08-11 16:46:06 +03001358int dsa_port_tag_8021q_vlan_add(struct dsa_port *dp, u16 vid, bool broadcast)
Vladimir Olteanc64b9c02021-07-19 20:14:52 +03001359{
1360 struct dsa_notifier_tag_8021q_vlan_info info = {
1361 .tree_index = dp->ds->dst->index,
1362 .sw_index = dp->ds->index,
1363 .port = dp->index,
1364 .vid = vid,
1365 };
1366
Vladimir Oltean724395f2021-08-11 16:46:06 +03001367 if (broadcast)
1368 return dsa_broadcast(DSA_NOTIFIER_TAG_8021Q_VLAN_ADD, &info);
1369
1370 return dsa_port_notify(dp, DSA_NOTIFIER_TAG_8021Q_VLAN_ADD, &info);
Vladimir Olteanc64b9c02021-07-19 20:14:52 +03001371}
1372
Vladimir Oltean724395f2021-08-11 16:46:06 +03001373void dsa_port_tag_8021q_vlan_del(struct dsa_port *dp, u16 vid, bool broadcast)
Vladimir Olteanc64b9c02021-07-19 20:14:52 +03001374{
1375 struct dsa_notifier_tag_8021q_vlan_info info = {
1376 .tree_index = dp->ds->dst->index,
1377 .sw_index = dp->ds->index,
1378 .port = dp->index,
1379 .vid = vid,
1380 };
1381 int err;
1382
Vladimir Oltean724395f2021-08-11 16:46:06 +03001383 if (broadcast)
1384 err = dsa_broadcast(DSA_NOTIFIER_TAG_8021Q_VLAN_DEL, &info);
1385 else
1386 err = dsa_port_notify(dp, DSA_NOTIFIER_TAG_8021Q_VLAN_DEL, &info);
Vladimir Olteanc64b9c02021-07-19 20:14:52 +03001387 if (err)
Vladimir Olteanab974622021-08-11 16:46:05 +03001388 dev_err(dp->ds->dev,
1389 "port %d failed to notify tag_8021q VLAN %d deletion: %pe\n",
1390 dp->index, vid, ERR_PTR(err));
Vladimir Olteanc64b9c02021-07-19 20:14:52 +03001391}