1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * Handling of a single switch chip, part of a switch fabric
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/if_vlan.h>
13 #include <net/switchdev.h>
14
15 #include "dsa_priv.h"
16
dsa_switch_fastest_ageing_time(struct dsa_switch * ds,unsigned int ageing_time)17 static unsigned int dsa_switch_fastest_ageing_time(struct dsa_switch *ds,
18 unsigned int ageing_time)
19 {
20 int i;
21
22 for (i = 0; i < ds->num_ports; ++i) {
23 struct dsa_port *dp = dsa_to_port(ds, i);
24
25 if (dp->ageing_time && dp->ageing_time < ageing_time)
26 ageing_time = dp->ageing_time;
27 }
28
29 return ageing_time;
30 }
31
dsa_switch_ageing_time(struct dsa_switch * ds,struct dsa_notifier_ageing_time_info * info)32 static int dsa_switch_ageing_time(struct dsa_switch *ds,
33 struct dsa_notifier_ageing_time_info *info)
34 {
35 unsigned int ageing_time = info->ageing_time;
36 struct switchdev_trans *trans = info->trans;
37
38 if (switchdev_trans_ph_prepare(trans)) {
39 if (ds->ageing_time_min && ageing_time < ds->ageing_time_min)
40 return -ERANGE;
41 if (ds->ageing_time_max && ageing_time > ds->ageing_time_max)
42 return -ERANGE;
43 return 0;
44 }
45
46 /* Program the fastest ageing time in case of multiple bridges */
47 ageing_time = dsa_switch_fastest_ageing_time(ds, ageing_time);
48
49 if (ds->ops->set_ageing_time)
50 return ds->ops->set_ageing_time(ds, ageing_time);
51
52 return 0;
53 }
54
dsa_switch_mtu_match(struct dsa_switch * ds,int port,struct dsa_notifier_mtu_info * info)55 static bool dsa_switch_mtu_match(struct dsa_switch *ds, int port,
56 struct dsa_notifier_mtu_info *info)
57 {
58 if (ds->index == info->sw_index)
59 return (port == info->port) || dsa_is_dsa_port(ds, port);
60
61 if (!info->propagate_upstream)
62 return false;
63
64 if (dsa_is_dsa_port(ds, port) || dsa_is_cpu_port(ds, port))
65 return true;
66
67 return false;
68 }
69
dsa_switch_mtu(struct dsa_switch * ds,struct dsa_notifier_mtu_info * info)70 static int dsa_switch_mtu(struct dsa_switch *ds,
71 struct dsa_notifier_mtu_info *info)
72 {
73 int port, ret;
74
75 if (!ds->ops->port_change_mtu)
76 return -EOPNOTSUPP;
77
78 for (port = 0; port < ds->num_ports; port++) {
79 if (dsa_switch_mtu_match(ds, port, info)) {
80 ret = ds->ops->port_change_mtu(ds, port, info->mtu);
81 if (ret)
82 return ret;
83 }
84 }
85
86 return 0;
87 }
88
dsa_switch_bridge_join(struct dsa_switch * ds,struct dsa_notifier_bridge_info * info)89 static int dsa_switch_bridge_join(struct dsa_switch *ds,
90 struct dsa_notifier_bridge_info *info)
91 {
92 struct dsa_switch_tree *dst = ds->dst;
93
94 if (dst->index == info->tree_index && ds->index == info->sw_index &&
95 ds->ops->port_bridge_join)
96 return ds->ops->port_bridge_join(ds, info->port, info->br);
97
98 if ((dst->index != info->tree_index || ds->index != info->sw_index) &&
99 ds->ops->crosschip_bridge_join)
100 return ds->ops->crosschip_bridge_join(ds, info->tree_index,
101 info->sw_index,
102 info->port, info->br);
103
104 return 0;
105 }
106
dsa_switch_bridge_leave(struct dsa_switch * ds,struct dsa_notifier_bridge_info * info)107 static int dsa_switch_bridge_leave(struct dsa_switch *ds,
108 struct dsa_notifier_bridge_info *info)
109 {
110 bool unset_vlan_filtering = br_vlan_enabled(info->br);
111 struct dsa_switch_tree *dst = ds->dst;
112 int err, i;
113
114 if (dst->index == info->tree_index && ds->index == info->sw_index &&
115 ds->ops->port_bridge_leave)
116 ds->ops->port_bridge_leave(ds, info->port, info->br);
117
118 if ((dst->index != info->tree_index || ds->index != info->sw_index) &&
119 ds->ops->crosschip_bridge_leave)
120 ds->ops->crosschip_bridge_leave(ds, info->tree_index,
121 info->sw_index, info->port,
122 info->br);
123
124 /* If the bridge was vlan_filtering, the bridge core doesn't trigger an
125 * event for changing vlan_filtering setting upon slave ports leaving
126 * it. That is a good thing, because that lets us handle it and also
127 * handle the case where the switch's vlan_filtering setting is global
128 * (not per port). When that happens, the correct moment to trigger the
129 * vlan_filtering callback is only when the last port left this bridge.
130 */
131 if (unset_vlan_filtering && ds->vlan_filtering_is_global) {
132 for (i = 0; i < ds->num_ports; i++) {
133 if (i == info->port)
134 continue;
135 if (dsa_to_port(ds, i)->bridge_dev == info->br) {
136 unset_vlan_filtering = false;
137 break;
138 }
139 }
140 }
141 if (unset_vlan_filtering) {
142 struct switchdev_trans trans;
143
144 trans.ph_prepare = true;
145 err = dsa_port_vlan_filtering(dsa_to_port(ds, info->port),
146 false, &trans);
147 if (err && err != EOPNOTSUPP)
148 return err;
149
150 trans.ph_prepare = false;
151 err = dsa_port_vlan_filtering(dsa_to_port(ds, info->port),
152 false, &trans);
153 if (err && err != EOPNOTSUPP)
154 return err;
155 }
156 return 0;
157 }
158
dsa_switch_fdb_add(struct dsa_switch * ds,struct dsa_notifier_fdb_info * info)159 static int dsa_switch_fdb_add(struct dsa_switch *ds,
160 struct dsa_notifier_fdb_info *info)
161 {
162 int port = dsa_towards_port(ds, info->sw_index, info->port);
163
164 if (!ds->ops->port_fdb_add)
165 return -EOPNOTSUPP;
166
167 return ds->ops->port_fdb_add(ds, port, info->addr, info->vid);
168 }
169
dsa_switch_fdb_del(struct dsa_switch * ds,struct dsa_notifier_fdb_info * info)170 static int dsa_switch_fdb_del(struct dsa_switch *ds,
171 struct dsa_notifier_fdb_info *info)
172 {
173 int port = dsa_towards_port(ds, info->sw_index, info->port);
174
175 if (!ds->ops->port_fdb_del)
176 return -EOPNOTSUPP;
177
178 return ds->ops->port_fdb_del(ds, port, info->addr, info->vid);
179 }
180
dsa_switch_mdb_match(struct dsa_switch * ds,int port,struct dsa_notifier_mdb_info * info)181 static bool dsa_switch_mdb_match(struct dsa_switch *ds, int port,
182 struct dsa_notifier_mdb_info *info)
183 {
184 if (ds->index == info->sw_index && port == info->port)
185 return true;
186
187 if (dsa_is_dsa_port(ds, port))
188 return true;
189
190 return false;
191 }
192
dsa_switch_mdb_prepare(struct dsa_switch * ds,struct dsa_notifier_mdb_info * info)193 static int dsa_switch_mdb_prepare(struct dsa_switch *ds,
194 struct dsa_notifier_mdb_info *info)
195 {
196 int port, err;
197
198 if (!ds->ops->port_mdb_prepare || !ds->ops->port_mdb_add)
199 return -EOPNOTSUPP;
200
201 for (port = 0; port < ds->num_ports; port++) {
202 if (dsa_switch_mdb_match(ds, port, info)) {
203 err = ds->ops->port_mdb_prepare(ds, port, info->mdb);
204 if (err)
205 return err;
206 }
207 }
208
209 return 0;
210 }
211
dsa_switch_mdb_add(struct dsa_switch * ds,struct dsa_notifier_mdb_info * info)212 static int dsa_switch_mdb_add(struct dsa_switch *ds,
213 struct dsa_notifier_mdb_info *info)
214 {
215 int port;
216
217 if (switchdev_trans_ph_prepare(info->trans))
218 return dsa_switch_mdb_prepare(ds, info);
219
220 if (!ds->ops->port_mdb_add)
221 return 0;
222
223 for (port = 0; port < ds->num_ports; port++)
224 if (dsa_switch_mdb_match(ds, port, info))
225 ds->ops->port_mdb_add(ds, port, info->mdb);
226
227 return 0;
228 }
229
dsa_switch_mdb_del(struct dsa_switch * ds,struct dsa_notifier_mdb_info * info)230 static int dsa_switch_mdb_del(struct dsa_switch *ds,
231 struct dsa_notifier_mdb_info *info)
232 {
233 if (!ds->ops->port_mdb_del)
234 return -EOPNOTSUPP;
235
236 if (ds->index == info->sw_index)
237 return ds->ops->port_mdb_del(ds, info->port, info->mdb);
238
239 return 0;
240 }
241
dsa_switch_vlan_match(struct dsa_switch * ds,int port,struct dsa_notifier_vlan_info * info)242 static bool dsa_switch_vlan_match(struct dsa_switch *ds, int port,
243 struct dsa_notifier_vlan_info *info)
244 {
245 if (ds->index == info->sw_index && port == info->port)
246 return true;
247
248 if (dsa_is_dsa_port(ds, port))
249 return true;
250
251 return false;
252 }
253
dsa_switch_vlan_prepare(struct dsa_switch * ds,struct dsa_notifier_vlan_info * info)254 static int dsa_switch_vlan_prepare(struct dsa_switch *ds,
255 struct dsa_notifier_vlan_info *info)
256 {
257 int port, err;
258
259 if (!ds->ops->port_vlan_prepare || !ds->ops->port_vlan_add)
260 return -EOPNOTSUPP;
261
262 for (port = 0; port < ds->num_ports; port++) {
263 if (dsa_switch_vlan_match(ds, port, info)) {
264 err = ds->ops->port_vlan_prepare(ds, port, info->vlan);
265 if (err)
266 return err;
267 }
268 }
269
270 return 0;
271 }
272
dsa_switch_vlan_add(struct dsa_switch * ds,struct dsa_notifier_vlan_info * info)273 static int dsa_switch_vlan_add(struct dsa_switch *ds,
274 struct dsa_notifier_vlan_info *info)
275 {
276 int port;
277
278 if (switchdev_trans_ph_prepare(info->trans))
279 return dsa_switch_vlan_prepare(ds, info);
280
281 if (!ds->ops->port_vlan_add)
282 return 0;
283
284 for (port = 0; port < ds->num_ports; port++)
285 if (dsa_switch_vlan_match(ds, port, info))
286 ds->ops->port_vlan_add(ds, port, info->vlan);
287
288 return 0;
289 }
290
dsa_switch_vlan_del(struct dsa_switch * ds,struct dsa_notifier_vlan_info * info)291 static int dsa_switch_vlan_del(struct dsa_switch *ds,
292 struct dsa_notifier_vlan_info *info)
293 {
294 if (!ds->ops->port_vlan_del)
295 return -EOPNOTSUPP;
296
297 if (ds->index == info->sw_index)
298 return ds->ops->port_vlan_del(ds, info->port, info->vlan);
299
300 /* Do not deprogram the DSA links as they may be used as conduit
301 * for other VLAN members in the fabric.
302 */
303 return 0;
304 }
305
dsa_switch_event(struct notifier_block * nb,unsigned long event,void * info)306 static int dsa_switch_event(struct notifier_block *nb,
307 unsigned long event, void *info)
308 {
309 struct dsa_switch *ds = container_of(nb, struct dsa_switch, nb);
310 int err;
311
312 switch (event) {
313 case DSA_NOTIFIER_AGEING_TIME:
314 err = dsa_switch_ageing_time(ds, info);
315 break;
316 case DSA_NOTIFIER_BRIDGE_JOIN:
317 err = dsa_switch_bridge_join(ds, info);
318 break;
319 case DSA_NOTIFIER_BRIDGE_LEAVE:
320 err = dsa_switch_bridge_leave(ds, info);
321 break;
322 case DSA_NOTIFIER_FDB_ADD:
323 err = dsa_switch_fdb_add(ds, info);
324 break;
325 case DSA_NOTIFIER_FDB_DEL:
326 err = dsa_switch_fdb_del(ds, info);
327 break;
328 case DSA_NOTIFIER_MDB_ADD:
329 err = dsa_switch_mdb_add(ds, info);
330 break;
331 case DSA_NOTIFIER_MDB_DEL:
332 err = dsa_switch_mdb_del(ds, info);
333 break;
334 case DSA_NOTIFIER_VLAN_ADD:
335 err = dsa_switch_vlan_add(ds, info);
336 break;
337 case DSA_NOTIFIER_VLAN_DEL:
338 err = dsa_switch_vlan_del(ds, info);
339 break;
340 case DSA_NOTIFIER_MTU:
341 err = dsa_switch_mtu(ds, info);
342 break;
343 default:
344 err = -EOPNOTSUPP;
345 break;
346 }
347
348 /* Non-switchdev operations cannot be rolled back. If a DSA driver
349 * returns an error during the chained call, switch chips may be in an
350 * inconsistent state.
351 */
352 if (err)
353 dev_dbg(ds->dev, "breaking chain for DSA event %lu (%d)\n",
354 event, err);
355
356 return notifier_from_errno(err);
357 }
358
dsa_switch_register_notifier(struct dsa_switch * ds)359 int dsa_switch_register_notifier(struct dsa_switch *ds)
360 {
361 ds->nb.notifier_call = dsa_switch_event;
362
363 return raw_notifier_chain_register(&ds->dst->nh, &ds->nb);
364 }
365
dsa_switch_unregister_notifier(struct dsa_switch * ds)366 void dsa_switch_unregister_notifier(struct dsa_switch *ds)
367 {
368 int err;
369
370 err = raw_notifier_chain_unregister(&ds->dst->nh, &ds->nb);
371 if (err)
372 dev_err(ds->dev, "failed to unregister notifier (%d)\n", err);
373 }
374