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