xref: /openbmc/linux/net/dsa/switch.c (revision d06f925f)
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.h"
16 #include "netlink.h"
17 #include "port.h"
18 #include "slave.h"
19 #include "switch.h"
20 #include "tag_8021q.h"
21 #include "trace.h"
22 
dsa_switch_fastest_ageing_time(struct dsa_switch * ds,unsigned int ageing_time)23 static unsigned int dsa_switch_fastest_ageing_time(struct dsa_switch *ds,
24 						   unsigned int ageing_time)
25 {
26 	struct dsa_port *dp;
27 
28 	dsa_switch_for_each_port(dp, ds)
29 		if (dp->ageing_time && dp->ageing_time < ageing_time)
30 			ageing_time = dp->ageing_time;
31 
32 	return ageing_time;
33 }
34 
dsa_switch_ageing_time(struct dsa_switch * ds,struct dsa_notifier_ageing_time_info * info)35 static int dsa_switch_ageing_time(struct dsa_switch *ds,
36 				  struct dsa_notifier_ageing_time_info *info)
37 {
38 	unsigned int ageing_time = info->ageing_time;
39 
40 	if (ds->ageing_time_min && ageing_time < ds->ageing_time_min)
41 		return -ERANGE;
42 
43 	if (ds->ageing_time_max && ageing_time > ds->ageing_time_max)
44 		return -ERANGE;
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_port_mtu_match(struct dsa_port * dp,struct dsa_notifier_mtu_info * info)55 static bool dsa_port_mtu_match(struct dsa_port *dp,
56 			       struct dsa_notifier_mtu_info *info)
57 {
58 	return dp == info->dp || dsa_port_is_dsa(dp) || dsa_port_is_cpu(dp);
59 }
60 
dsa_switch_mtu(struct dsa_switch * ds,struct dsa_notifier_mtu_info * info)61 static int dsa_switch_mtu(struct dsa_switch *ds,
62 			  struct dsa_notifier_mtu_info *info)
63 {
64 	struct dsa_port *dp;
65 	int ret;
66 
67 	if (!ds->ops->port_change_mtu)
68 		return -EOPNOTSUPP;
69 
70 	dsa_switch_for_each_port(dp, ds) {
71 		if (dsa_port_mtu_match(dp, info)) {
72 			ret = ds->ops->port_change_mtu(ds, dp->index,
73 						       info->mtu);
74 			if (ret)
75 				return ret;
76 		}
77 	}
78 
79 	return 0;
80 }
81 
dsa_switch_bridge_join(struct dsa_switch * ds,struct dsa_notifier_bridge_info * info)82 static int dsa_switch_bridge_join(struct dsa_switch *ds,
83 				  struct dsa_notifier_bridge_info *info)
84 {
85 	int err;
86 
87 	if (info->dp->ds == ds) {
88 		if (!ds->ops->port_bridge_join)
89 			return -EOPNOTSUPP;
90 
91 		err = ds->ops->port_bridge_join(ds, info->dp->index,
92 						info->bridge,
93 						&info->tx_fwd_offload,
94 						info->extack);
95 		if (err)
96 			return err;
97 	}
98 
99 	if (info->dp->ds != ds && ds->ops->crosschip_bridge_join) {
100 		err = ds->ops->crosschip_bridge_join(ds,
101 						     info->dp->ds->dst->index,
102 						     info->dp->ds->index,
103 						     info->dp->index,
104 						     info->bridge,
105 						     info->extack);
106 		if (err)
107 			return err;
108 	}
109 
110 	return 0;
111 }
112 
dsa_switch_bridge_leave(struct dsa_switch * ds,struct dsa_notifier_bridge_info * info)113 static int dsa_switch_bridge_leave(struct dsa_switch *ds,
114 				   struct dsa_notifier_bridge_info *info)
115 {
116 	if (info->dp->ds == ds && ds->ops->port_bridge_leave)
117 		ds->ops->port_bridge_leave(ds, info->dp->index, info->bridge);
118 
119 	if (info->dp->ds != ds && ds->ops->crosschip_bridge_leave)
120 		ds->ops->crosschip_bridge_leave(ds, info->dp->ds->dst->index,
121 						info->dp->ds->index,
122 						info->dp->index,
123 						info->bridge);
124 
125 	return 0;
126 }
127 
128 /* Matches for all upstream-facing ports (the CPU port and all upstream-facing
129  * DSA links) that sit between the targeted port on which the notifier was
130  * emitted and its dedicated CPU port.
131  */
dsa_port_host_address_match(struct dsa_port * dp,const struct dsa_port * targeted_dp)132 static bool dsa_port_host_address_match(struct dsa_port *dp,
133 					const struct dsa_port *targeted_dp)
134 {
135 	struct dsa_port *cpu_dp = targeted_dp->cpu_dp;
136 
137 	if (dsa_switch_is_upstream_of(dp->ds, targeted_dp->ds))
138 		return dp->index == dsa_towards_port(dp->ds, cpu_dp->ds->index,
139 						     cpu_dp->index);
140 
141 	return false;
142 }
143 
dsa_mac_addr_find(struct list_head * addr_list,const unsigned char * addr,u16 vid,struct dsa_db db)144 static struct dsa_mac_addr *dsa_mac_addr_find(struct list_head *addr_list,
145 					      const unsigned char *addr, u16 vid,
146 					      struct dsa_db db)
147 {
148 	struct dsa_mac_addr *a;
149 
150 	list_for_each_entry(a, addr_list, list)
151 		if (ether_addr_equal(a->addr, addr) && a->vid == vid &&
152 		    dsa_db_equal(&a->db, &db))
153 			return a;
154 
155 	return NULL;
156 }
157 
dsa_port_do_mdb_add(struct dsa_port * dp,const struct switchdev_obj_port_mdb * mdb,struct dsa_db db)158 static int dsa_port_do_mdb_add(struct dsa_port *dp,
159 			       const struct switchdev_obj_port_mdb *mdb,
160 			       struct dsa_db db)
161 {
162 	struct dsa_switch *ds = dp->ds;
163 	struct dsa_mac_addr *a;
164 	int port = dp->index;
165 	int err = 0;
166 
167 	/* No need to bother with refcounting for user ports */
168 	if (!(dsa_port_is_cpu(dp) || dsa_port_is_dsa(dp))) {
169 		err = ds->ops->port_mdb_add(ds, port, mdb, db);
170 		trace_dsa_mdb_add_hw(dp, mdb->addr, mdb->vid, &db, err);
171 
172 		return err;
173 	}
174 
175 	mutex_lock(&dp->addr_lists_lock);
176 
177 	a = dsa_mac_addr_find(&dp->mdbs, mdb->addr, mdb->vid, db);
178 	if (a) {
179 		refcount_inc(&a->refcount);
180 		trace_dsa_mdb_add_bump(dp, mdb->addr, mdb->vid, &db,
181 				       &a->refcount);
182 		goto out;
183 	}
184 
185 	a = kzalloc(sizeof(*a), GFP_KERNEL);
186 	if (!a) {
187 		err = -ENOMEM;
188 		goto out;
189 	}
190 
191 	err = ds->ops->port_mdb_add(ds, port, mdb, db);
192 	trace_dsa_mdb_add_hw(dp, mdb->addr, mdb->vid, &db, err);
193 	if (err) {
194 		kfree(a);
195 		goto out;
196 	}
197 
198 	ether_addr_copy(a->addr, mdb->addr);
199 	a->vid = mdb->vid;
200 	a->db = db;
201 	refcount_set(&a->refcount, 1);
202 	list_add_tail(&a->list, &dp->mdbs);
203 
204 out:
205 	mutex_unlock(&dp->addr_lists_lock);
206 
207 	return err;
208 }
209 
dsa_port_do_mdb_del(struct dsa_port * dp,const struct switchdev_obj_port_mdb * mdb,struct dsa_db db)210 static int dsa_port_do_mdb_del(struct dsa_port *dp,
211 			       const struct switchdev_obj_port_mdb *mdb,
212 			       struct dsa_db db)
213 {
214 	struct dsa_switch *ds = dp->ds;
215 	struct dsa_mac_addr *a;
216 	int port = dp->index;
217 	int err = 0;
218 
219 	/* No need to bother with refcounting for user ports */
220 	if (!(dsa_port_is_cpu(dp) || dsa_port_is_dsa(dp))) {
221 		err = ds->ops->port_mdb_del(ds, port, mdb, db);
222 		trace_dsa_mdb_del_hw(dp, mdb->addr, mdb->vid, &db, err);
223 
224 		return err;
225 	}
226 
227 	mutex_lock(&dp->addr_lists_lock);
228 
229 	a = dsa_mac_addr_find(&dp->mdbs, mdb->addr, mdb->vid, db);
230 	if (!a) {
231 		trace_dsa_mdb_del_not_found(dp, mdb->addr, mdb->vid, &db);
232 		err = -ENOENT;
233 		goto out;
234 	}
235 
236 	if (!refcount_dec_and_test(&a->refcount)) {
237 		trace_dsa_mdb_del_drop(dp, mdb->addr, mdb->vid, &db,
238 				       &a->refcount);
239 		goto out;
240 	}
241 
242 	err = ds->ops->port_mdb_del(ds, port, mdb, db);
243 	trace_dsa_mdb_del_hw(dp, mdb->addr, mdb->vid, &db, err);
244 	if (err) {
245 		refcount_set(&a->refcount, 1);
246 		goto out;
247 	}
248 
249 	list_del(&a->list);
250 	kfree(a);
251 
252 out:
253 	mutex_unlock(&dp->addr_lists_lock);
254 
255 	return err;
256 }
257 
dsa_port_do_fdb_add(struct dsa_port * dp,const unsigned char * addr,u16 vid,struct dsa_db db)258 static int dsa_port_do_fdb_add(struct dsa_port *dp, const unsigned char *addr,
259 			       u16 vid, struct dsa_db db)
260 {
261 	struct dsa_switch *ds = dp->ds;
262 	struct dsa_mac_addr *a;
263 	int port = dp->index;
264 	int err = 0;
265 
266 	/* No need to bother with refcounting for user ports */
267 	if (!(dsa_port_is_cpu(dp) || dsa_port_is_dsa(dp))) {
268 		err = ds->ops->port_fdb_add(ds, port, addr, vid, db);
269 		trace_dsa_fdb_add_hw(dp, addr, vid, &db, err);
270 
271 		return err;
272 	}
273 
274 	mutex_lock(&dp->addr_lists_lock);
275 
276 	a = dsa_mac_addr_find(&dp->fdbs, addr, vid, db);
277 	if (a) {
278 		refcount_inc(&a->refcount);
279 		trace_dsa_fdb_add_bump(dp, addr, vid, &db, &a->refcount);
280 		goto out;
281 	}
282 
283 	a = kzalloc(sizeof(*a), GFP_KERNEL);
284 	if (!a) {
285 		err = -ENOMEM;
286 		goto out;
287 	}
288 
289 	err = ds->ops->port_fdb_add(ds, port, addr, vid, db);
290 	trace_dsa_fdb_add_hw(dp, addr, vid, &db, err);
291 	if (err) {
292 		kfree(a);
293 		goto out;
294 	}
295 
296 	ether_addr_copy(a->addr, addr);
297 	a->vid = vid;
298 	a->db = db;
299 	refcount_set(&a->refcount, 1);
300 	list_add_tail(&a->list, &dp->fdbs);
301 
302 out:
303 	mutex_unlock(&dp->addr_lists_lock);
304 
305 	return err;
306 }
307 
dsa_port_do_fdb_del(struct dsa_port * dp,const unsigned char * addr,u16 vid,struct dsa_db db)308 static int dsa_port_do_fdb_del(struct dsa_port *dp, const unsigned char *addr,
309 			       u16 vid, struct dsa_db db)
310 {
311 	struct dsa_switch *ds = dp->ds;
312 	struct dsa_mac_addr *a;
313 	int port = dp->index;
314 	int err = 0;
315 
316 	/* No need to bother with refcounting for user ports */
317 	if (!(dsa_port_is_cpu(dp) || dsa_port_is_dsa(dp))) {
318 		err = ds->ops->port_fdb_del(ds, port, addr, vid, db);
319 		trace_dsa_fdb_del_hw(dp, addr, vid, &db, err);
320 
321 		return err;
322 	}
323 
324 	mutex_lock(&dp->addr_lists_lock);
325 
326 	a = dsa_mac_addr_find(&dp->fdbs, addr, vid, db);
327 	if (!a) {
328 		trace_dsa_fdb_del_not_found(dp, addr, vid, &db);
329 		err = -ENOENT;
330 		goto out;
331 	}
332 
333 	if (!refcount_dec_and_test(&a->refcount)) {
334 		trace_dsa_fdb_del_drop(dp, addr, vid, &db, &a->refcount);
335 		goto out;
336 	}
337 
338 	err = ds->ops->port_fdb_del(ds, port, addr, vid, db);
339 	trace_dsa_fdb_del_hw(dp, addr, vid, &db, err);
340 	if (err) {
341 		refcount_set(&a->refcount, 1);
342 		goto out;
343 	}
344 
345 	list_del(&a->list);
346 	kfree(a);
347 
348 out:
349 	mutex_unlock(&dp->addr_lists_lock);
350 
351 	return err;
352 }
353 
dsa_switch_do_lag_fdb_add(struct dsa_switch * ds,struct dsa_lag * lag,const unsigned char * addr,u16 vid,struct dsa_db db)354 static int dsa_switch_do_lag_fdb_add(struct dsa_switch *ds, struct dsa_lag *lag,
355 				     const unsigned char *addr, u16 vid,
356 				     struct dsa_db db)
357 {
358 	struct dsa_mac_addr *a;
359 	int err = 0;
360 
361 	mutex_lock(&lag->fdb_lock);
362 
363 	a = dsa_mac_addr_find(&lag->fdbs, addr, vid, db);
364 	if (a) {
365 		refcount_inc(&a->refcount);
366 		trace_dsa_lag_fdb_add_bump(lag->dev, addr, vid, &db,
367 					   &a->refcount);
368 		goto out;
369 	}
370 
371 	a = kzalloc(sizeof(*a), GFP_KERNEL);
372 	if (!a) {
373 		err = -ENOMEM;
374 		goto out;
375 	}
376 
377 	err = ds->ops->lag_fdb_add(ds, *lag, addr, vid, db);
378 	trace_dsa_lag_fdb_add_hw(lag->dev, addr, vid, &db, err);
379 	if (err) {
380 		kfree(a);
381 		goto out;
382 	}
383 
384 	ether_addr_copy(a->addr, addr);
385 	a->vid = vid;
386 	a->db = db;
387 	refcount_set(&a->refcount, 1);
388 	list_add_tail(&a->list, &lag->fdbs);
389 
390 out:
391 	mutex_unlock(&lag->fdb_lock);
392 
393 	return err;
394 }
395 
dsa_switch_do_lag_fdb_del(struct dsa_switch * ds,struct dsa_lag * lag,const unsigned char * addr,u16 vid,struct dsa_db db)396 static int dsa_switch_do_lag_fdb_del(struct dsa_switch *ds, struct dsa_lag *lag,
397 				     const unsigned char *addr, u16 vid,
398 				     struct dsa_db db)
399 {
400 	struct dsa_mac_addr *a;
401 	int err = 0;
402 
403 	mutex_lock(&lag->fdb_lock);
404 
405 	a = dsa_mac_addr_find(&lag->fdbs, addr, vid, db);
406 	if (!a) {
407 		trace_dsa_lag_fdb_del_not_found(lag->dev, addr, vid, &db);
408 		err = -ENOENT;
409 		goto out;
410 	}
411 
412 	if (!refcount_dec_and_test(&a->refcount)) {
413 		trace_dsa_lag_fdb_del_drop(lag->dev, addr, vid, &db,
414 					   &a->refcount);
415 		goto out;
416 	}
417 
418 	err = ds->ops->lag_fdb_del(ds, *lag, addr, vid, db);
419 	trace_dsa_lag_fdb_del_hw(lag->dev, addr, vid, &db, err);
420 	if (err) {
421 		refcount_set(&a->refcount, 1);
422 		goto out;
423 	}
424 
425 	list_del(&a->list);
426 	kfree(a);
427 
428 out:
429 	mutex_unlock(&lag->fdb_lock);
430 
431 	return err;
432 }
433 
dsa_switch_host_fdb_add(struct dsa_switch * ds,struct dsa_notifier_fdb_info * info)434 static int dsa_switch_host_fdb_add(struct dsa_switch *ds,
435 				   struct dsa_notifier_fdb_info *info)
436 {
437 	struct dsa_port *dp;
438 	int err = 0;
439 
440 	if (!ds->ops->port_fdb_add)
441 		return -EOPNOTSUPP;
442 
443 	dsa_switch_for_each_port(dp, ds) {
444 		if (dsa_port_host_address_match(dp, info->dp)) {
445 			if (dsa_port_is_cpu(dp) && info->dp->cpu_port_in_lag) {
446 				err = dsa_switch_do_lag_fdb_add(ds, dp->lag,
447 								info->addr,
448 								info->vid,
449 								info->db);
450 			} else {
451 				err = dsa_port_do_fdb_add(dp, info->addr,
452 							  info->vid, info->db);
453 			}
454 			if (err)
455 				break;
456 		}
457 	}
458 
459 	return err;
460 }
461 
dsa_switch_host_fdb_del(struct dsa_switch * ds,struct dsa_notifier_fdb_info * info)462 static int dsa_switch_host_fdb_del(struct dsa_switch *ds,
463 				   struct dsa_notifier_fdb_info *info)
464 {
465 	struct dsa_port *dp;
466 	int err = 0;
467 
468 	if (!ds->ops->port_fdb_del)
469 		return -EOPNOTSUPP;
470 
471 	dsa_switch_for_each_port(dp, ds) {
472 		if (dsa_port_host_address_match(dp, info->dp)) {
473 			if (dsa_port_is_cpu(dp) && info->dp->cpu_port_in_lag) {
474 				err = dsa_switch_do_lag_fdb_del(ds, dp->lag,
475 								info->addr,
476 								info->vid,
477 								info->db);
478 			} else {
479 				err = dsa_port_do_fdb_del(dp, info->addr,
480 							  info->vid, info->db);
481 			}
482 			if (err)
483 				break;
484 		}
485 	}
486 
487 	return err;
488 }
489 
dsa_switch_fdb_add(struct dsa_switch * ds,struct dsa_notifier_fdb_info * info)490 static int dsa_switch_fdb_add(struct dsa_switch *ds,
491 			      struct dsa_notifier_fdb_info *info)
492 {
493 	int port = dsa_towards_port(ds, info->dp->ds->index, info->dp->index);
494 	struct dsa_port *dp = dsa_to_port(ds, port);
495 
496 	if (!ds->ops->port_fdb_add)
497 		return -EOPNOTSUPP;
498 
499 	return dsa_port_do_fdb_add(dp, info->addr, info->vid, info->db);
500 }
501 
dsa_switch_fdb_del(struct dsa_switch * ds,struct dsa_notifier_fdb_info * info)502 static int dsa_switch_fdb_del(struct dsa_switch *ds,
503 			      struct dsa_notifier_fdb_info *info)
504 {
505 	int port = dsa_towards_port(ds, info->dp->ds->index, info->dp->index);
506 	struct dsa_port *dp = dsa_to_port(ds, port);
507 
508 	if (!ds->ops->port_fdb_del)
509 		return -EOPNOTSUPP;
510 
511 	return dsa_port_do_fdb_del(dp, info->addr, info->vid, info->db);
512 }
513 
dsa_switch_lag_fdb_add(struct dsa_switch * ds,struct dsa_notifier_lag_fdb_info * info)514 static int dsa_switch_lag_fdb_add(struct dsa_switch *ds,
515 				  struct dsa_notifier_lag_fdb_info *info)
516 {
517 	struct dsa_port *dp;
518 
519 	if (!ds->ops->lag_fdb_add)
520 		return -EOPNOTSUPP;
521 
522 	/* Notify switch only if it has a port in this LAG */
523 	dsa_switch_for_each_port(dp, ds)
524 		if (dsa_port_offloads_lag(dp, info->lag))
525 			return dsa_switch_do_lag_fdb_add(ds, info->lag,
526 							 info->addr, info->vid,
527 							 info->db);
528 
529 	return 0;
530 }
531 
dsa_switch_lag_fdb_del(struct dsa_switch * ds,struct dsa_notifier_lag_fdb_info * info)532 static int dsa_switch_lag_fdb_del(struct dsa_switch *ds,
533 				  struct dsa_notifier_lag_fdb_info *info)
534 {
535 	struct dsa_port *dp;
536 
537 	if (!ds->ops->lag_fdb_del)
538 		return -EOPNOTSUPP;
539 
540 	/* Notify switch only if it has a port in this LAG */
541 	dsa_switch_for_each_port(dp, ds)
542 		if (dsa_port_offloads_lag(dp, info->lag))
543 			return dsa_switch_do_lag_fdb_del(ds, info->lag,
544 							 info->addr, info->vid,
545 							 info->db);
546 
547 	return 0;
548 }
549 
dsa_switch_lag_change(struct dsa_switch * ds,struct dsa_notifier_lag_info * info)550 static int dsa_switch_lag_change(struct dsa_switch *ds,
551 				 struct dsa_notifier_lag_info *info)
552 {
553 	if (info->dp->ds == ds && ds->ops->port_lag_change)
554 		return ds->ops->port_lag_change(ds, info->dp->index);
555 
556 	if (info->dp->ds != ds && ds->ops->crosschip_lag_change)
557 		return ds->ops->crosschip_lag_change(ds, info->dp->ds->index,
558 						     info->dp->index);
559 
560 	return 0;
561 }
562 
dsa_switch_lag_join(struct dsa_switch * ds,struct dsa_notifier_lag_info * info)563 static int dsa_switch_lag_join(struct dsa_switch *ds,
564 			       struct dsa_notifier_lag_info *info)
565 {
566 	if (info->dp->ds == ds && ds->ops->port_lag_join)
567 		return ds->ops->port_lag_join(ds, info->dp->index, info->lag,
568 					      info->info, info->extack);
569 
570 	if (info->dp->ds != ds && ds->ops->crosschip_lag_join)
571 		return ds->ops->crosschip_lag_join(ds, info->dp->ds->index,
572 						   info->dp->index, info->lag,
573 						   info->info, info->extack);
574 
575 	return -EOPNOTSUPP;
576 }
577 
dsa_switch_lag_leave(struct dsa_switch * ds,struct dsa_notifier_lag_info * info)578 static int dsa_switch_lag_leave(struct dsa_switch *ds,
579 				struct dsa_notifier_lag_info *info)
580 {
581 	if (info->dp->ds == ds && ds->ops->port_lag_leave)
582 		return ds->ops->port_lag_leave(ds, info->dp->index, info->lag);
583 
584 	if (info->dp->ds != ds && ds->ops->crosschip_lag_leave)
585 		return ds->ops->crosschip_lag_leave(ds, info->dp->ds->index,
586 						    info->dp->index, info->lag);
587 
588 	return -EOPNOTSUPP;
589 }
590 
dsa_switch_mdb_add(struct dsa_switch * ds,struct dsa_notifier_mdb_info * info)591 static int dsa_switch_mdb_add(struct dsa_switch *ds,
592 			      struct dsa_notifier_mdb_info *info)
593 {
594 	int port = dsa_towards_port(ds, info->dp->ds->index, info->dp->index);
595 	struct dsa_port *dp = dsa_to_port(ds, port);
596 
597 	if (!ds->ops->port_mdb_add)
598 		return -EOPNOTSUPP;
599 
600 	return dsa_port_do_mdb_add(dp, info->mdb, info->db);
601 }
602 
dsa_switch_mdb_del(struct dsa_switch * ds,struct dsa_notifier_mdb_info * info)603 static int dsa_switch_mdb_del(struct dsa_switch *ds,
604 			      struct dsa_notifier_mdb_info *info)
605 {
606 	int port = dsa_towards_port(ds, info->dp->ds->index, info->dp->index);
607 	struct dsa_port *dp = dsa_to_port(ds, port);
608 
609 	if (!ds->ops->port_mdb_del)
610 		return -EOPNOTSUPP;
611 
612 	return dsa_port_do_mdb_del(dp, info->mdb, info->db);
613 }
614 
dsa_switch_host_mdb_add(struct dsa_switch * ds,struct dsa_notifier_mdb_info * info)615 static int dsa_switch_host_mdb_add(struct dsa_switch *ds,
616 				   struct dsa_notifier_mdb_info *info)
617 {
618 	struct dsa_port *dp;
619 	int err = 0;
620 
621 	if (!ds->ops->port_mdb_add)
622 		return -EOPNOTSUPP;
623 
624 	dsa_switch_for_each_port(dp, ds) {
625 		if (dsa_port_host_address_match(dp, info->dp)) {
626 			err = dsa_port_do_mdb_add(dp, info->mdb, info->db);
627 			if (err)
628 				break;
629 		}
630 	}
631 
632 	return err;
633 }
634 
dsa_switch_host_mdb_del(struct dsa_switch * ds,struct dsa_notifier_mdb_info * info)635 static int dsa_switch_host_mdb_del(struct dsa_switch *ds,
636 				   struct dsa_notifier_mdb_info *info)
637 {
638 	struct dsa_port *dp;
639 	int err = 0;
640 
641 	if (!ds->ops->port_mdb_del)
642 		return -EOPNOTSUPP;
643 
644 	dsa_switch_for_each_port(dp, ds) {
645 		if (dsa_port_host_address_match(dp, info->dp)) {
646 			err = dsa_port_do_mdb_del(dp, info->mdb, info->db);
647 			if (err)
648 				break;
649 		}
650 	}
651 
652 	return err;
653 }
654 
655 /* Port VLANs match on the targeted port and on all DSA ports */
dsa_port_vlan_match(struct dsa_port * dp,struct dsa_notifier_vlan_info * info)656 static bool dsa_port_vlan_match(struct dsa_port *dp,
657 				struct dsa_notifier_vlan_info *info)
658 {
659 	return dsa_port_is_dsa(dp) || dp == info->dp;
660 }
661 
662 /* Host VLANs match on the targeted port's CPU port, and on all DSA ports
663  * (upstream and downstream) of that switch and its upstream switches.
664  */
dsa_port_host_vlan_match(struct dsa_port * dp,const struct dsa_port * targeted_dp)665 static bool dsa_port_host_vlan_match(struct dsa_port *dp,
666 				     const struct dsa_port *targeted_dp)
667 {
668 	struct dsa_port *cpu_dp = targeted_dp->cpu_dp;
669 
670 	if (dsa_switch_is_upstream_of(dp->ds, targeted_dp->ds))
671 		return dsa_port_is_dsa(dp) || dp == cpu_dp;
672 
673 	return false;
674 }
675 
dsa_vlan_find(struct list_head * vlan_list,const struct switchdev_obj_port_vlan * vlan)676 struct dsa_vlan *dsa_vlan_find(struct list_head *vlan_list,
677 			       const struct switchdev_obj_port_vlan *vlan)
678 {
679 	struct dsa_vlan *v;
680 
681 	list_for_each_entry(v, vlan_list, list)
682 		if (v->vid == vlan->vid)
683 			return v;
684 
685 	return NULL;
686 }
687 
dsa_port_do_vlan_add(struct dsa_port * dp,const struct switchdev_obj_port_vlan * vlan,struct netlink_ext_ack * extack)688 static int dsa_port_do_vlan_add(struct dsa_port *dp,
689 				const struct switchdev_obj_port_vlan *vlan,
690 				struct netlink_ext_ack *extack)
691 {
692 	struct dsa_switch *ds = dp->ds;
693 	int port = dp->index;
694 	struct dsa_vlan *v;
695 	int err = 0;
696 
697 	/* No need to bother with refcounting for user ports. */
698 	if (!(dsa_port_is_cpu(dp) || dsa_port_is_dsa(dp))) {
699 		err = ds->ops->port_vlan_add(ds, port, vlan, extack);
700 		trace_dsa_vlan_add_hw(dp, vlan, err);
701 
702 		return err;
703 	}
704 
705 	/* No need to propagate on shared ports the existing VLANs that were
706 	 * re-notified after just the flags have changed. This would cause a
707 	 * refcount bump which we need to avoid, since it unbalances the
708 	 * additions with the deletions.
709 	 */
710 	if (vlan->changed)
711 		return 0;
712 
713 	mutex_lock(&dp->vlans_lock);
714 
715 	v = dsa_vlan_find(&dp->vlans, vlan);
716 	if (v) {
717 		refcount_inc(&v->refcount);
718 		trace_dsa_vlan_add_bump(dp, vlan, &v->refcount);
719 		goto out;
720 	}
721 
722 	v = kzalloc(sizeof(*v), GFP_KERNEL);
723 	if (!v) {
724 		err = -ENOMEM;
725 		goto out;
726 	}
727 
728 	err = ds->ops->port_vlan_add(ds, port, vlan, extack);
729 	trace_dsa_vlan_add_hw(dp, vlan, err);
730 	if (err) {
731 		kfree(v);
732 		goto out;
733 	}
734 
735 	v->vid = vlan->vid;
736 	refcount_set(&v->refcount, 1);
737 	list_add_tail(&v->list, &dp->vlans);
738 
739 out:
740 	mutex_unlock(&dp->vlans_lock);
741 
742 	return err;
743 }
744 
dsa_port_do_vlan_del(struct dsa_port * dp,const struct switchdev_obj_port_vlan * vlan)745 static int dsa_port_do_vlan_del(struct dsa_port *dp,
746 				const struct switchdev_obj_port_vlan *vlan)
747 {
748 	struct dsa_switch *ds = dp->ds;
749 	int port = dp->index;
750 	struct dsa_vlan *v;
751 	int err = 0;
752 
753 	/* No need to bother with refcounting for user ports */
754 	if (!(dsa_port_is_cpu(dp) || dsa_port_is_dsa(dp))) {
755 		err = ds->ops->port_vlan_del(ds, port, vlan);
756 		trace_dsa_vlan_del_hw(dp, vlan, err);
757 
758 		return err;
759 	}
760 
761 	mutex_lock(&dp->vlans_lock);
762 
763 	v = dsa_vlan_find(&dp->vlans, vlan);
764 	if (!v) {
765 		trace_dsa_vlan_del_not_found(dp, vlan);
766 		err = -ENOENT;
767 		goto out;
768 	}
769 
770 	if (!refcount_dec_and_test(&v->refcount)) {
771 		trace_dsa_vlan_del_drop(dp, vlan, &v->refcount);
772 		goto out;
773 	}
774 
775 	err = ds->ops->port_vlan_del(ds, port, vlan);
776 	trace_dsa_vlan_del_hw(dp, vlan, err);
777 	if (err) {
778 		refcount_set(&v->refcount, 1);
779 		goto out;
780 	}
781 
782 	list_del(&v->list);
783 	kfree(v);
784 
785 out:
786 	mutex_unlock(&dp->vlans_lock);
787 
788 	return err;
789 }
790 
dsa_switch_vlan_add(struct dsa_switch * ds,struct dsa_notifier_vlan_info * info)791 static int dsa_switch_vlan_add(struct dsa_switch *ds,
792 			       struct dsa_notifier_vlan_info *info)
793 {
794 	struct dsa_port *dp;
795 	int err;
796 
797 	if (!ds->ops->port_vlan_add)
798 		return -EOPNOTSUPP;
799 
800 	dsa_switch_for_each_port(dp, ds) {
801 		if (dsa_port_vlan_match(dp, info)) {
802 			err = dsa_port_do_vlan_add(dp, info->vlan,
803 						   info->extack);
804 			if (err)
805 				return err;
806 		}
807 	}
808 
809 	return 0;
810 }
811 
dsa_switch_vlan_del(struct dsa_switch * ds,struct dsa_notifier_vlan_info * info)812 static int dsa_switch_vlan_del(struct dsa_switch *ds,
813 			       struct dsa_notifier_vlan_info *info)
814 {
815 	struct dsa_port *dp;
816 	int err;
817 
818 	if (!ds->ops->port_vlan_del)
819 		return -EOPNOTSUPP;
820 
821 	dsa_switch_for_each_port(dp, ds) {
822 		if (dsa_port_vlan_match(dp, info)) {
823 			err = dsa_port_do_vlan_del(dp, info->vlan);
824 			if (err)
825 				return err;
826 		}
827 	}
828 
829 	return 0;
830 }
831 
dsa_switch_host_vlan_add(struct dsa_switch * ds,struct dsa_notifier_vlan_info * info)832 static int dsa_switch_host_vlan_add(struct dsa_switch *ds,
833 				    struct dsa_notifier_vlan_info *info)
834 {
835 	struct dsa_port *dp;
836 	int err;
837 
838 	if (!ds->ops->port_vlan_add)
839 		return -EOPNOTSUPP;
840 
841 	dsa_switch_for_each_port(dp, ds) {
842 		if (dsa_port_host_vlan_match(dp, info->dp)) {
843 			err = dsa_port_do_vlan_add(dp, info->vlan,
844 						   info->extack);
845 			if (err)
846 				return err;
847 		}
848 	}
849 
850 	return 0;
851 }
852 
dsa_switch_host_vlan_del(struct dsa_switch * ds,struct dsa_notifier_vlan_info * info)853 static int dsa_switch_host_vlan_del(struct dsa_switch *ds,
854 				    struct dsa_notifier_vlan_info *info)
855 {
856 	struct dsa_port *dp;
857 	int err;
858 
859 	if (!ds->ops->port_vlan_del)
860 		return -EOPNOTSUPP;
861 
862 	dsa_switch_for_each_port(dp, ds) {
863 		if (dsa_port_host_vlan_match(dp, info->dp)) {
864 			err = dsa_port_do_vlan_del(dp, info->vlan);
865 			if (err)
866 				return err;
867 		}
868 	}
869 
870 	return 0;
871 }
872 
dsa_switch_change_tag_proto(struct dsa_switch * ds,struct dsa_notifier_tag_proto_info * info)873 static int dsa_switch_change_tag_proto(struct dsa_switch *ds,
874 				       struct dsa_notifier_tag_proto_info *info)
875 {
876 	const struct dsa_device_ops *tag_ops = info->tag_ops;
877 	struct dsa_port *dp, *cpu_dp;
878 	int err;
879 
880 	if (!ds->ops->change_tag_protocol)
881 		return -EOPNOTSUPP;
882 
883 	ASSERT_RTNL();
884 
885 	err = ds->ops->change_tag_protocol(ds, tag_ops->proto);
886 	if (err)
887 		return err;
888 
889 	dsa_switch_for_each_cpu_port(cpu_dp, ds)
890 		dsa_port_set_tag_protocol(cpu_dp, tag_ops);
891 
892 	/* Now that changing the tag protocol can no longer fail, let's update
893 	 * the remaining bits which are "duplicated for faster access", and the
894 	 * bits that depend on the tagger, such as the MTU.
895 	 */
896 	dsa_switch_for_each_user_port(dp, ds) {
897 		struct net_device *slave = dp->slave;
898 
899 		dsa_slave_setup_tagger(slave);
900 
901 		/* rtnl_mutex is held in dsa_tree_change_tag_proto */
902 		dsa_slave_change_mtu(slave, slave->mtu);
903 	}
904 
905 	return 0;
906 }
907 
908 /* We use the same cross-chip notifiers to inform both the tagger side, as well
909  * as the switch side, of connection and disconnection events.
910  * Since ds->tagger_data is owned by the tagger, it isn't a hard error if the
911  * switch side doesn't support connecting to this tagger, and therefore, the
912  * fact that we don't disconnect the tagger side doesn't constitute a memory
913  * leak: the tagger will still operate with persistent per-switch memory, just
914  * with the switch side unconnected to it. What does constitute a hard error is
915  * when the switch side supports connecting but fails.
916  */
917 static int
dsa_switch_connect_tag_proto(struct dsa_switch * ds,struct dsa_notifier_tag_proto_info * info)918 dsa_switch_connect_tag_proto(struct dsa_switch *ds,
919 			     struct dsa_notifier_tag_proto_info *info)
920 {
921 	const struct dsa_device_ops *tag_ops = info->tag_ops;
922 	int err;
923 
924 	/* Notify the new tagger about the connection to this switch */
925 	if (tag_ops->connect) {
926 		err = tag_ops->connect(ds);
927 		if (err)
928 			return err;
929 	}
930 
931 	if (!ds->ops->connect_tag_protocol)
932 		return -EOPNOTSUPP;
933 
934 	/* Notify the switch about the connection to the new tagger */
935 	err = ds->ops->connect_tag_protocol(ds, tag_ops->proto);
936 	if (err) {
937 		/* Revert the new tagger's connection to this tree */
938 		if (tag_ops->disconnect)
939 			tag_ops->disconnect(ds);
940 		return err;
941 	}
942 
943 	return 0;
944 }
945 
946 static int
dsa_switch_disconnect_tag_proto(struct dsa_switch * ds,struct dsa_notifier_tag_proto_info * info)947 dsa_switch_disconnect_tag_proto(struct dsa_switch *ds,
948 				struct dsa_notifier_tag_proto_info *info)
949 {
950 	const struct dsa_device_ops *tag_ops = info->tag_ops;
951 
952 	/* Notify the tagger about the disconnection from this switch */
953 	if (tag_ops->disconnect && ds->tagger_data)
954 		tag_ops->disconnect(ds);
955 
956 	/* No need to notify the switch, since it shouldn't have any
957 	 * resources to tear down
958 	 */
959 	return 0;
960 }
961 
962 static int
dsa_switch_master_state_change(struct dsa_switch * ds,struct dsa_notifier_master_state_info * info)963 dsa_switch_master_state_change(struct dsa_switch *ds,
964 			       struct dsa_notifier_master_state_info *info)
965 {
966 	if (!ds->ops->master_state_change)
967 		return 0;
968 
969 	ds->ops->master_state_change(ds, info->master, info->operational);
970 
971 	return 0;
972 }
973 
dsa_switch_event(struct notifier_block * nb,unsigned long event,void * info)974 static int dsa_switch_event(struct notifier_block *nb,
975 			    unsigned long event, void *info)
976 {
977 	struct dsa_switch *ds = container_of(nb, struct dsa_switch, nb);
978 	int err;
979 
980 	switch (event) {
981 	case DSA_NOTIFIER_AGEING_TIME:
982 		err = dsa_switch_ageing_time(ds, info);
983 		break;
984 	case DSA_NOTIFIER_BRIDGE_JOIN:
985 		err = dsa_switch_bridge_join(ds, info);
986 		break;
987 	case DSA_NOTIFIER_BRIDGE_LEAVE:
988 		err = dsa_switch_bridge_leave(ds, info);
989 		break;
990 	case DSA_NOTIFIER_FDB_ADD:
991 		err = dsa_switch_fdb_add(ds, info);
992 		break;
993 	case DSA_NOTIFIER_FDB_DEL:
994 		err = dsa_switch_fdb_del(ds, info);
995 		break;
996 	case DSA_NOTIFIER_HOST_FDB_ADD:
997 		err = dsa_switch_host_fdb_add(ds, info);
998 		break;
999 	case DSA_NOTIFIER_HOST_FDB_DEL:
1000 		err = dsa_switch_host_fdb_del(ds, info);
1001 		break;
1002 	case DSA_NOTIFIER_LAG_FDB_ADD:
1003 		err = dsa_switch_lag_fdb_add(ds, info);
1004 		break;
1005 	case DSA_NOTIFIER_LAG_FDB_DEL:
1006 		err = dsa_switch_lag_fdb_del(ds, info);
1007 		break;
1008 	case DSA_NOTIFIER_LAG_CHANGE:
1009 		err = dsa_switch_lag_change(ds, info);
1010 		break;
1011 	case DSA_NOTIFIER_LAG_JOIN:
1012 		err = dsa_switch_lag_join(ds, info);
1013 		break;
1014 	case DSA_NOTIFIER_LAG_LEAVE:
1015 		err = dsa_switch_lag_leave(ds, info);
1016 		break;
1017 	case DSA_NOTIFIER_MDB_ADD:
1018 		err = dsa_switch_mdb_add(ds, info);
1019 		break;
1020 	case DSA_NOTIFIER_MDB_DEL:
1021 		err = dsa_switch_mdb_del(ds, info);
1022 		break;
1023 	case DSA_NOTIFIER_HOST_MDB_ADD:
1024 		err = dsa_switch_host_mdb_add(ds, info);
1025 		break;
1026 	case DSA_NOTIFIER_HOST_MDB_DEL:
1027 		err = dsa_switch_host_mdb_del(ds, info);
1028 		break;
1029 	case DSA_NOTIFIER_VLAN_ADD:
1030 		err = dsa_switch_vlan_add(ds, info);
1031 		break;
1032 	case DSA_NOTIFIER_VLAN_DEL:
1033 		err = dsa_switch_vlan_del(ds, info);
1034 		break;
1035 	case DSA_NOTIFIER_HOST_VLAN_ADD:
1036 		err = dsa_switch_host_vlan_add(ds, info);
1037 		break;
1038 	case DSA_NOTIFIER_HOST_VLAN_DEL:
1039 		err = dsa_switch_host_vlan_del(ds, info);
1040 		break;
1041 	case DSA_NOTIFIER_MTU:
1042 		err = dsa_switch_mtu(ds, info);
1043 		break;
1044 	case DSA_NOTIFIER_TAG_PROTO:
1045 		err = dsa_switch_change_tag_proto(ds, info);
1046 		break;
1047 	case DSA_NOTIFIER_TAG_PROTO_CONNECT:
1048 		err = dsa_switch_connect_tag_proto(ds, info);
1049 		break;
1050 	case DSA_NOTIFIER_TAG_PROTO_DISCONNECT:
1051 		err = dsa_switch_disconnect_tag_proto(ds, info);
1052 		break;
1053 	case DSA_NOTIFIER_TAG_8021Q_VLAN_ADD:
1054 		err = dsa_switch_tag_8021q_vlan_add(ds, info);
1055 		break;
1056 	case DSA_NOTIFIER_TAG_8021Q_VLAN_DEL:
1057 		err = dsa_switch_tag_8021q_vlan_del(ds, info);
1058 		break;
1059 	case DSA_NOTIFIER_MASTER_STATE_CHANGE:
1060 		err = dsa_switch_master_state_change(ds, info);
1061 		break;
1062 	default:
1063 		err = -EOPNOTSUPP;
1064 		break;
1065 	}
1066 
1067 	if (err)
1068 		dev_dbg(ds->dev, "breaking chain for DSA event %lu (%d)\n",
1069 			event, err);
1070 
1071 	return notifier_from_errno(err);
1072 }
1073 
1074 /**
1075  * dsa_tree_notify - Execute code for all switches in a DSA switch tree.
1076  * @dst: collection of struct dsa_switch devices to notify.
1077  * @e: event, must be of type DSA_NOTIFIER_*
1078  * @v: event-specific value.
1079  *
1080  * Given a struct dsa_switch_tree, this can be used to run a function once for
1081  * each member DSA switch. The other alternative of traversing the tree is only
1082  * through its ports list, which does not uniquely list the switches.
1083  */
dsa_tree_notify(struct dsa_switch_tree * dst,unsigned long e,void * v)1084 int dsa_tree_notify(struct dsa_switch_tree *dst, unsigned long e, void *v)
1085 {
1086 	struct raw_notifier_head *nh = &dst->nh;
1087 	int err;
1088 
1089 	err = raw_notifier_call_chain(nh, e, v);
1090 
1091 	return notifier_to_errno(err);
1092 }
1093 
1094 /**
1095  * dsa_broadcast - Notify all DSA trees in the system.
1096  * @e: event, must be of type DSA_NOTIFIER_*
1097  * @v: event-specific value.
1098  *
1099  * Can be used to notify the switching fabric of events such as cross-chip
1100  * bridging between disjoint trees (such as islands of tagger-compatible
1101  * switches bridged by an incompatible middle switch).
1102  *
1103  * WARNING: this function is not reliable during probe time, because probing
1104  * between trees is asynchronous and not all DSA trees might have probed.
1105  */
dsa_broadcast(unsigned long e,void * v)1106 int dsa_broadcast(unsigned long e, void *v)
1107 {
1108 	struct dsa_switch_tree *dst;
1109 	int err = 0;
1110 
1111 	list_for_each_entry(dst, &dsa_tree_list, list) {
1112 		err = dsa_tree_notify(dst, e, v);
1113 		if (err)
1114 			break;
1115 	}
1116 
1117 	return err;
1118 }
1119 
dsa_switch_register_notifier(struct dsa_switch * ds)1120 int dsa_switch_register_notifier(struct dsa_switch *ds)
1121 {
1122 	ds->nb.notifier_call = dsa_switch_event;
1123 
1124 	return raw_notifier_chain_register(&ds->dst->nh, &ds->nb);
1125 }
1126 
dsa_switch_unregister_notifier(struct dsa_switch * ds)1127 void dsa_switch_unregister_notifier(struct dsa_switch *ds)
1128 {
1129 	int err;
1130 
1131 	err = raw_notifier_chain_unregister(&ds->dst->nh, &ds->nb);
1132 	if (err)
1133 		dev_err(ds->dev, "failed to unregister notifier (%d)\n", err);
1134 }
1135