Loading...
Note: File does not exist in v3.1.
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
17static 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 = &ds->ports[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
32static 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
55static int dsa_switch_bridge_join(struct dsa_switch *ds,
56 struct dsa_notifier_bridge_info *info)
57{
58 if (ds->index == info->sw_index && ds->ops->port_bridge_join)
59 return ds->ops->port_bridge_join(ds, info->port, info->br);
60
61 if (ds->index != info->sw_index && ds->ops->crosschip_bridge_join)
62 return ds->ops->crosschip_bridge_join(ds, info->sw_index,
63 info->port, info->br);
64
65 return 0;
66}
67
68static int dsa_switch_bridge_leave(struct dsa_switch *ds,
69 struct dsa_notifier_bridge_info *info)
70{
71 bool unset_vlan_filtering = br_vlan_enabled(info->br);
72 int err, i;
73
74 if (ds->index == info->sw_index && ds->ops->port_bridge_leave)
75 ds->ops->port_bridge_leave(ds, info->port, info->br);
76
77 if (ds->index != info->sw_index && ds->ops->crosschip_bridge_leave)
78 ds->ops->crosschip_bridge_leave(ds, info->sw_index, info->port,
79 info->br);
80
81 /* If the bridge was vlan_filtering, the bridge core doesn't trigger an
82 * event for changing vlan_filtering setting upon slave ports leaving
83 * it. That is a good thing, because that lets us handle it and also
84 * handle the case where the switch's vlan_filtering setting is global
85 * (not per port). When that happens, the correct moment to trigger the
86 * vlan_filtering callback is only when the last port left this bridge.
87 */
88 if (unset_vlan_filtering && ds->vlan_filtering_is_global) {
89 for (i = 0; i < ds->num_ports; i++) {
90 if (i == info->port)
91 continue;
92 if (dsa_to_port(ds, i)->bridge_dev == info->br) {
93 unset_vlan_filtering = false;
94 break;
95 }
96 }
97 }
98 if (unset_vlan_filtering) {
99 struct switchdev_trans trans = {0};
100
101 err = dsa_port_vlan_filtering(&ds->ports[info->port],
102 false, &trans);
103 if (err && err != EOPNOTSUPP)
104 return err;
105 }
106 return 0;
107}
108
109static int dsa_switch_fdb_add(struct dsa_switch *ds,
110 struct dsa_notifier_fdb_info *info)
111{
112 int port = dsa_towards_port(ds, info->sw_index, info->port);
113
114 if (!ds->ops->port_fdb_add)
115 return -EOPNOTSUPP;
116
117 return ds->ops->port_fdb_add(ds, port, info->addr, info->vid);
118}
119
120static int dsa_switch_fdb_del(struct dsa_switch *ds,
121 struct dsa_notifier_fdb_info *info)
122{
123 int port = dsa_towards_port(ds, info->sw_index, info->port);
124
125 if (!ds->ops->port_fdb_del)
126 return -EOPNOTSUPP;
127
128 return ds->ops->port_fdb_del(ds, port, info->addr, info->vid);
129}
130
131static bool dsa_switch_mdb_match(struct dsa_switch *ds, int port,
132 struct dsa_notifier_mdb_info *info)
133{
134 if (ds->index == info->sw_index && port == info->port)
135 return true;
136
137 if (dsa_is_dsa_port(ds, port))
138 return true;
139
140 return false;
141}
142
143static int dsa_switch_mdb_prepare(struct dsa_switch *ds,
144 struct dsa_notifier_mdb_info *info)
145{
146 int port, err;
147
148 if (!ds->ops->port_mdb_prepare || !ds->ops->port_mdb_add)
149 return -EOPNOTSUPP;
150
151 for (port = 0; port < ds->num_ports; port++) {
152 if (dsa_switch_mdb_match(ds, port, info)) {
153 err = ds->ops->port_mdb_prepare(ds, port, info->mdb);
154 if (err)
155 return err;
156 }
157 }
158
159 return 0;
160}
161
162static int dsa_switch_mdb_add(struct dsa_switch *ds,
163 struct dsa_notifier_mdb_info *info)
164{
165 int port;
166
167 if (switchdev_trans_ph_prepare(info->trans))
168 return dsa_switch_mdb_prepare(ds, info);
169
170 if (!ds->ops->port_mdb_add)
171 return 0;
172
173 for (port = 0; port < ds->num_ports; port++)
174 if (dsa_switch_mdb_match(ds, port, info))
175 ds->ops->port_mdb_add(ds, port, info->mdb);
176
177 return 0;
178}
179
180static int dsa_switch_mdb_del(struct dsa_switch *ds,
181 struct dsa_notifier_mdb_info *info)
182{
183 if (!ds->ops->port_mdb_del)
184 return -EOPNOTSUPP;
185
186 if (ds->index == info->sw_index)
187 return ds->ops->port_mdb_del(ds, info->port, info->mdb);
188
189 return 0;
190}
191
192static int dsa_port_vlan_device_check(struct net_device *vlan_dev,
193 int vlan_dev_vid,
194 void *arg)
195{
196 struct switchdev_obj_port_vlan *vlan = arg;
197 u16 vid;
198
199 for (vid = vlan->vid_begin; vid <= vlan->vid_end; ++vid) {
200 if (vid == vlan_dev_vid)
201 return -EBUSY;
202 }
203
204 return 0;
205}
206
207static int dsa_port_vlan_check(struct dsa_switch *ds, int port,
208 const struct switchdev_obj_port_vlan *vlan)
209{
210 const struct dsa_port *dp = dsa_to_port(ds, port);
211 int err = 0;
212
213 /* Device is not bridged, let it proceed with the VLAN device
214 * creation.
215 */
216 if (!dp->bridge_dev)
217 return err;
218
219 /* dsa_slave_vlan_rx_{add,kill}_vid() cannot use the prepare phase and
220 * already checks whether there is an overlapping bridge VLAN entry
221 * with the same VID, so here we only need to check that if we are
222 * adding a bridge VLAN entry there is not an overlapping VLAN device
223 * claiming that VID.
224 */
225 return vlan_for_each(dp->slave, dsa_port_vlan_device_check,
226 (void *)vlan);
227}
228
229static bool dsa_switch_vlan_match(struct dsa_switch *ds, int port,
230 struct dsa_notifier_vlan_info *info)
231{
232 if (ds->index == info->sw_index && port == info->port)
233 return true;
234
235 if (dsa_is_dsa_port(ds, port))
236 return true;
237
238 return false;
239}
240
241static int dsa_switch_vlan_prepare(struct dsa_switch *ds,
242 struct dsa_notifier_vlan_info *info)
243{
244 int port, err;
245
246 if (!ds->ops->port_vlan_prepare || !ds->ops->port_vlan_add)
247 return -EOPNOTSUPP;
248
249 for (port = 0; port < ds->num_ports; port++) {
250 if (dsa_switch_vlan_match(ds, port, info)) {
251 err = dsa_port_vlan_check(ds, port, info->vlan);
252 if (err)
253 return err;
254
255 err = ds->ops->port_vlan_prepare(ds, port, info->vlan);
256 if (err)
257 return err;
258 }
259 }
260
261 return 0;
262}
263
264static int dsa_switch_vlan_add(struct dsa_switch *ds,
265 struct dsa_notifier_vlan_info *info)
266{
267 int port;
268
269 if (switchdev_trans_ph_prepare(info->trans))
270 return dsa_switch_vlan_prepare(ds, info);
271
272 if (!ds->ops->port_vlan_add)
273 return 0;
274
275 for (port = 0; port < ds->num_ports; port++)
276 if (dsa_switch_vlan_match(ds, port, info))
277 ds->ops->port_vlan_add(ds, port, info->vlan);
278
279 return 0;
280}
281
282static int dsa_switch_vlan_del(struct dsa_switch *ds,
283 struct dsa_notifier_vlan_info *info)
284{
285 if (!ds->ops->port_vlan_del)
286 return -EOPNOTSUPP;
287
288 if (ds->index == info->sw_index)
289 return ds->ops->port_vlan_del(ds, info->port, info->vlan);
290
291 /* Do not deprogram the DSA links as they may be used as conduit
292 * for other VLAN members in the fabric.
293 */
294 return 0;
295}
296
297static int dsa_switch_event(struct notifier_block *nb,
298 unsigned long event, void *info)
299{
300 struct dsa_switch *ds = container_of(nb, struct dsa_switch, nb);
301 int err;
302
303 switch (event) {
304 case DSA_NOTIFIER_AGEING_TIME:
305 err = dsa_switch_ageing_time(ds, info);
306 break;
307 case DSA_NOTIFIER_BRIDGE_JOIN:
308 err = dsa_switch_bridge_join(ds, info);
309 break;
310 case DSA_NOTIFIER_BRIDGE_LEAVE:
311 err = dsa_switch_bridge_leave(ds, info);
312 break;
313 case DSA_NOTIFIER_FDB_ADD:
314 err = dsa_switch_fdb_add(ds, info);
315 break;
316 case DSA_NOTIFIER_FDB_DEL:
317 err = dsa_switch_fdb_del(ds, info);
318 break;
319 case DSA_NOTIFIER_MDB_ADD:
320 err = dsa_switch_mdb_add(ds, info);
321 break;
322 case DSA_NOTIFIER_MDB_DEL:
323 err = dsa_switch_mdb_del(ds, info);
324 break;
325 case DSA_NOTIFIER_VLAN_ADD:
326 err = dsa_switch_vlan_add(ds, info);
327 break;
328 case DSA_NOTIFIER_VLAN_DEL:
329 err = dsa_switch_vlan_del(ds, info);
330 break;
331 default:
332 err = -EOPNOTSUPP;
333 break;
334 }
335
336 /* Non-switchdev operations cannot be rolled back. If a DSA driver
337 * returns an error during the chained call, switch chips may be in an
338 * inconsistent state.
339 */
340 if (err)
341 dev_dbg(ds->dev, "breaking chain for DSA event %lu (%d)\n",
342 event, err);
343
344 return notifier_from_errno(err);
345}
346
347int dsa_switch_register_notifier(struct dsa_switch *ds)
348{
349 ds->nb.notifier_call = dsa_switch_event;
350
351 return raw_notifier_chain_register(&ds->dst->nh, &ds->nb);
352}
353
354void dsa_switch_unregister_notifier(struct dsa_switch *ds)
355{
356 int err;
357
358 err = raw_notifier_chain_unregister(&ds->dst->nh, &ds->nb);
359 if (err)
360 dev_err(ds->dev, "failed to unregister notifier (%d)\n", err);
361}