1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
2 /* Copyright (c) 2015-2018 Mellanox Technologies. All rights reserved */
3 
4 #include <linux/kernel.h>
5 #include <linux/types.h>
6 #include <linux/netdevice.h>
7 #include <linux/etherdevice.h>
8 #include <linux/slab.h>
9 #include <linux/device.h>
10 #include <linux/skbuff.h>
11 #include <linux/if_vlan.h>
12 #include <linux/if_bridge.h>
13 #include <linux/workqueue.h>
14 #include <linux/jiffies.h>
15 #include <linux/rtnetlink.h>
16 #include <linux/netlink.h>
17 #include <net/switchdev.h>
18 #include <net/vxlan.h>
19 
20 #include "spectrum_span.h"
21 #include "spectrum_switchdev.h"
22 #include "spectrum.h"
23 #include "core.h"
24 #include "reg.h"
25 
26 struct mlxsw_sp_bridge_ops;
27 
28 struct mlxsw_sp_bridge {
29 	struct mlxsw_sp *mlxsw_sp;
30 	struct {
31 		struct delayed_work dw;
32 #define MLXSW_SP_DEFAULT_LEARNING_INTERVAL 100
33 		unsigned int interval; /* ms */
34 	} fdb_notify;
35 #define MLXSW_SP_MIN_AGEING_TIME 10
36 #define MLXSW_SP_MAX_AGEING_TIME 1000000
37 #define MLXSW_SP_DEFAULT_AGEING_TIME 300
38 	u32 ageing_time;
39 	bool vlan_enabled_exists;
40 	struct list_head bridges_list;
41 	DECLARE_BITMAP(mids_bitmap, MLXSW_SP_MID_MAX);
42 	const struct mlxsw_sp_bridge_ops *bridge_8021q_ops;
43 	const struct mlxsw_sp_bridge_ops *bridge_8021d_ops;
44 	const struct mlxsw_sp_bridge_ops *bridge_8021ad_ops;
45 };
46 
47 struct mlxsw_sp_bridge_device {
48 	struct net_device *dev;
49 	struct list_head list;
50 	struct list_head ports_list;
51 	struct list_head mids_list;
52 	u8 vlan_enabled:1,
53 	   multicast_enabled:1,
54 	   mrouter:1;
55 	const struct mlxsw_sp_bridge_ops *ops;
56 };
57 
58 struct mlxsw_sp_bridge_port {
59 	struct net_device *dev;
60 	struct mlxsw_sp_bridge_device *bridge_device;
61 	struct list_head list;
62 	struct list_head vlans_list;
63 	unsigned int ref_count;
64 	u8 stp_state;
65 	unsigned long flags;
66 	bool mrouter;
67 	bool lagged;
68 	union {
69 		u16 lag_id;
70 		u16 system_port;
71 	};
72 };
73 
74 struct mlxsw_sp_bridge_vlan {
75 	struct list_head list;
76 	struct list_head port_vlan_list;
77 	u16 vid;
78 };
79 
80 struct mlxsw_sp_bridge_ops {
81 	int (*port_join)(struct mlxsw_sp_bridge_device *bridge_device,
82 			 struct mlxsw_sp_bridge_port *bridge_port,
83 			 struct mlxsw_sp_port *mlxsw_sp_port,
84 			 struct netlink_ext_ack *extack);
85 	void (*port_leave)(struct mlxsw_sp_bridge_device *bridge_device,
86 			   struct mlxsw_sp_bridge_port *bridge_port,
87 			   struct mlxsw_sp_port *mlxsw_sp_port);
88 	int (*vxlan_join)(struct mlxsw_sp_bridge_device *bridge_device,
89 			  const struct net_device *vxlan_dev, u16 vid,
90 			  struct netlink_ext_ack *extack);
91 	struct mlxsw_sp_fid *
92 		(*fid_get)(struct mlxsw_sp_bridge_device *bridge_device,
93 			   u16 vid, struct netlink_ext_ack *extack);
94 	struct mlxsw_sp_fid *
95 		(*fid_lookup)(struct mlxsw_sp_bridge_device *bridge_device,
96 			      u16 vid);
97 	u16 (*fid_vid)(struct mlxsw_sp_bridge_device *bridge_device,
98 		       const struct mlxsw_sp_fid *fid);
99 };
100 
101 struct mlxsw_sp_switchdev_ops {
102 	void (*init)(struct mlxsw_sp *mlxsw_sp);
103 };
104 
105 static int
106 mlxsw_sp_bridge_port_fdb_flush(struct mlxsw_sp *mlxsw_sp,
107 			       struct mlxsw_sp_bridge_port *bridge_port,
108 			       u16 fid_index);
109 
110 static void
111 mlxsw_sp_bridge_port_mdb_flush(struct mlxsw_sp_port *mlxsw_sp_port,
112 			       struct mlxsw_sp_bridge_port *bridge_port);
113 
114 static void
115 mlxsw_sp_bridge_mdb_mc_enable_sync(struct mlxsw_sp_port *mlxsw_sp_port,
116 				   struct mlxsw_sp_bridge_device
117 				   *bridge_device);
118 
119 static void
120 mlxsw_sp_port_mrouter_update_mdb(struct mlxsw_sp_port *mlxsw_sp_port,
121 				 struct mlxsw_sp_bridge_port *bridge_port,
122 				 bool add);
123 
124 static struct mlxsw_sp_bridge_device *
125 mlxsw_sp_bridge_device_find(const struct mlxsw_sp_bridge *bridge,
126 			    const struct net_device *br_dev)
127 {
128 	struct mlxsw_sp_bridge_device *bridge_device;
129 
130 	list_for_each_entry(bridge_device, &bridge->bridges_list, list)
131 		if (bridge_device->dev == br_dev)
132 			return bridge_device;
133 
134 	return NULL;
135 }
136 
137 bool mlxsw_sp_bridge_device_is_offloaded(const struct mlxsw_sp *mlxsw_sp,
138 					 const struct net_device *br_dev)
139 {
140 	return !!mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, br_dev);
141 }
142 
143 static int mlxsw_sp_bridge_device_upper_rif_destroy(struct net_device *dev,
144 						    struct netdev_nested_priv *priv)
145 {
146 	struct mlxsw_sp *mlxsw_sp = priv->data;
147 
148 	mlxsw_sp_rif_destroy_by_dev(mlxsw_sp, dev);
149 	return 0;
150 }
151 
152 static void mlxsw_sp_bridge_device_rifs_destroy(struct mlxsw_sp *mlxsw_sp,
153 						struct net_device *dev)
154 {
155 	struct netdev_nested_priv priv = {
156 		.data = (void *)mlxsw_sp,
157 	};
158 
159 	mlxsw_sp_rif_destroy_by_dev(mlxsw_sp, dev);
160 	netdev_walk_all_upper_dev_rcu(dev,
161 				      mlxsw_sp_bridge_device_upper_rif_destroy,
162 				      &priv);
163 }
164 
165 static int mlxsw_sp_bridge_device_vxlan_init(struct mlxsw_sp_bridge *bridge,
166 					     struct net_device *br_dev,
167 					     struct netlink_ext_ack *extack)
168 {
169 	struct net_device *dev, *stop_dev;
170 	struct list_head *iter;
171 	int err;
172 
173 	netdev_for_each_lower_dev(br_dev, dev, iter) {
174 		if (netif_is_vxlan(dev) && netif_running(dev)) {
175 			err = mlxsw_sp_bridge_vxlan_join(bridge->mlxsw_sp,
176 							 br_dev, dev, 0,
177 							 extack);
178 			if (err) {
179 				stop_dev = dev;
180 				goto err_vxlan_join;
181 			}
182 		}
183 	}
184 
185 	return 0;
186 
187 err_vxlan_join:
188 	netdev_for_each_lower_dev(br_dev, dev, iter) {
189 		if (netif_is_vxlan(dev) && netif_running(dev)) {
190 			if (stop_dev == dev)
191 				break;
192 			mlxsw_sp_bridge_vxlan_leave(bridge->mlxsw_sp, dev);
193 		}
194 	}
195 	return err;
196 }
197 
198 static void mlxsw_sp_bridge_device_vxlan_fini(struct mlxsw_sp_bridge *bridge,
199 					      struct net_device *br_dev)
200 {
201 	struct net_device *dev;
202 	struct list_head *iter;
203 
204 	netdev_for_each_lower_dev(br_dev, dev, iter) {
205 		if (netif_is_vxlan(dev) && netif_running(dev))
206 			mlxsw_sp_bridge_vxlan_leave(bridge->mlxsw_sp, dev);
207 	}
208 }
209 
210 static struct mlxsw_sp_bridge_device *
211 mlxsw_sp_bridge_device_create(struct mlxsw_sp_bridge *bridge,
212 			      struct net_device *br_dev,
213 			      struct netlink_ext_ack *extack)
214 {
215 	struct device *dev = bridge->mlxsw_sp->bus_info->dev;
216 	struct mlxsw_sp_bridge_device *bridge_device;
217 	bool vlan_enabled = br_vlan_enabled(br_dev);
218 	int err;
219 
220 	if (vlan_enabled && bridge->vlan_enabled_exists) {
221 		dev_err(dev, "Only one VLAN-aware bridge is supported\n");
222 		NL_SET_ERR_MSG_MOD(extack, "Only one VLAN-aware bridge is supported");
223 		return ERR_PTR(-EINVAL);
224 	}
225 
226 	bridge_device = kzalloc(sizeof(*bridge_device), GFP_KERNEL);
227 	if (!bridge_device)
228 		return ERR_PTR(-ENOMEM);
229 
230 	bridge_device->dev = br_dev;
231 	bridge_device->vlan_enabled = vlan_enabled;
232 	bridge_device->multicast_enabled = br_multicast_enabled(br_dev);
233 	bridge_device->mrouter = br_multicast_router(br_dev);
234 	INIT_LIST_HEAD(&bridge_device->ports_list);
235 	if (vlan_enabled) {
236 		u16 proto;
237 
238 		bridge->vlan_enabled_exists = true;
239 		br_vlan_get_proto(br_dev, &proto);
240 		if (proto == ETH_P_8021AD)
241 			bridge_device->ops = bridge->bridge_8021ad_ops;
242 		else
243 			bridge_device->ops = bridge->bridge_8021q_ops;
244 	} else {
245 		bridge_device->ops = bridge->bridge_8021d_ops;
246 	}
247 	INIT_LIST_HEAD(&bridge_device->mids_list);
248 	list_add(&bridge_device->list, &bridge->bridges_list);
249 
250 	/* It is possible we already have VXLAN devices enslaved to the bridge.
251 	 * In which case, we need to replay their configuration as if they were
252 	 * just now enslaved to the bridge.
253 	 */
254 	err = mlxsw_sp_bridge_device_vxlan_init(bridge, br_dev, extack);
255 	if (err)
256 		goto err_vxlan_init;
257 
258 	return bridge_device;
259 
260 err_vxlan_init:
261 	list_del(&bridge_device->list);
262 	if (bridge_device->vlan_enabled)
263 		bridge->vlan_enabled_exists = false;
264 	kfree(bridge_device);
265 	return ERR_PTR(err);
266 }
267 
268 static void
269 mlxsw_sp_bridge_device_destroy(struct mlxsw_sp_bridge *bridge,
270 			       struct mlxsw_sp_bridge_device *bridge_device)
271 {
272 	mlxsw_sp_bridge_device_vxlan_fini(bridge, bridge_device->dev);
273 	mlxsw_sp_bridge_device_rifs_destroy(bridge->mlxsw_sp,
274 					    bridge_device->dev);
275 	list_del(&bridge_device->list);
276 	if (bridge_device->vlan_enabled)
277 		bridge->vlan_enabled_exists = false;
278 	WARN_ON(!list_empty(&bridge_device->ports_list));
279 	WARN_ON(!list_empty(&bridge_device->mids_list));
280 	kfree(bridge_device);
281 }
282 
283 static struct mlxsw_sp_bridge_device *
284 mlxsw_sp_bridge_device_get(struct mlxsw_sp_bridge *bridge,
285 			   struct net_device *br_dev,
286 			   struct netlink_ext_ack *extack)
287 {
288 	struct mlxsw_sp_bridge_device *bridge_device;
289 
290 	bridge_device = mlxsw_sp_bridge_device_find(bridge, br_dev);
291 	if (bridge_device)
292 		return bridge_device;
293 
294 	return mlxsw_sp_bridge_device_create(bridge, br_dev, extack);
295 }
296 
297 static void
298 mlxsw_sp_bridge_device_put(struct mlxsw_sp_bridge *bridge,
299 			   struct mlxsw_sp_bridge_device *bridge_device)
300 {
301 	if (list_empty(&bridge_device->ports_list))
302 		mlxsw_sp_bridge_device_destroy(bridge, bridge_device);
303 }
304 
305 static struct mlxsw_sp_bridge_port *
306 __mlxsw_sp_bridge_port_find(const struct mlxsw_sp_bridge_device *bridge_device,
307 			    const struct net_device *brport_dev)
308 {
309 	struct mlxsw_sp_bridge_port *bridge_port;
310 
311 	list_for_each_entry(bridge_port, &bridge_device->ports_list, list) {
312 		if (bridge_port->dev == brport_dev)
313 			return bridge_port;
314 	}
315 
316 	return NULL;
317 }
318 
319 struct mlxsw_sp_bridge_port *
320 mlxsw_sp_bridge_port_find(struct mlxsw_sp_bridge *bridge,
321 			  struct net_device *brport_dev)
322 {
323 	struct net_device *br_dev = netdev_master_upper_dev_get(brport_dev);
324 	struct mlxsw_sp_bridge_device *bridge_device;
325 
326 	if (!br_dev)
327 		return NULL;
328 
329 	bridge_device = mlxsw_sp_bridge_device_find(bridge, br_dev);
330 	if (!bridge_device)
331 		return NULL;
332 
333 	return __mlxsw_sp_bridge_port_find(bridge_device, brport_dev);
334 }
335 
336 static struct mlxsw_sp_bridge_port *
337 mlxsw_sp_bridge_port_create(struct mlxsw_sp_bridge_device *bridge_device,
338 			    struct net_device *brport_dev)
339 {
340 	struct mlxsw_sp_bridge_port *bridge_port;
341 	struct mlxsw_sp_port *mlxsw_sp_port;
342 
343 	bridge_port = kzalloc(sizeof(*bridge_port), GFP_KERNEL);
344 	if (!bridge_port)
345 		return NULL;
346 
347 	mlxsw_sp_port = mlxsw_sp_port_dev_lower_find(brport_dev);
348 	bridge_port->lagged = mlxsw_sp_port->lagged;
349 	if (bridge_port->lagged)
350 		bridge_port->lag_id = mlxsw_sp_port->lag_id;
351 	else
352 		bridge_port->system_port = mlxsw_sp_port->local_port;
353 	bridge_port->dev = brport_dev;
354 	bridge_port->bridge_device = bridge_device;
355 	bridge_port->stp_state = BR_STATE_DISABLED;
356 	bridge_port->flags = BR_LEARNING | BR_FLOOD | BR_LEARNING_SYNC |
357 			     BR_MCAST_FLOOD;
358 	INIT_LIST_HEAD(&bridge_port->vlans_list);
359 	list_add(&bridge_port->list, &bridge_device->ports_list);
360 	bridge_port->ref_count = 1;
361 
362 	return bridge_port;
363 }
364 
365 static void
366 mlxsw_sp_bridge_port_destroy(struct mlxsw_sp_bridge_port *bridge_port)
367 {
368 	list_del(&bridge_port->list);
369 	WARN_ON(!list_empty(&bridge_port->vlans_list));
370 	kfree(bridge_port);
371 }
372 
373 static struct mlxsw_sp_bridge_port *
374 mlxsw_sp_bridge_port_get(struct mlxsw_sp_bridge *bridge,
375 			 struct net_device *brport_dev,
376 			 struct netlink_ext_ack *extack)
377 {
378 	struct net_device *br_dev = netdev_master_upper_dev_get(brport_dev);
379 	struct mlxsw_sp_bridge_device *bridge_device;
380 	struct mlxsw_sp_bridge_port *bridge_port;
381 	int err;
382 
383 	bridge_port = mlxsw_sp_bridge_port_find(bridge, brport_dev);
384 	if (bridge_port) {
385 		bridge_port->ref_count++;
386 		return bridge_port;
387 	}
388 
389 	bridge_device = mlxsw_sp_bridge_device_get(bridge, br_dev, extack);
390 	if (IS_ERR(bridge_device))
391 		return ERR_CAST(bridge_device);
392 
393 	bridge_port = mlxsw_sp_bridge_port_create(bridge_device, brport_dev);
394 	if (!bridge_port) {
395 		err = -ENOMEM;
396 		goto err_bridge_port_create;
397 	}
398 
399 	return bridge_port;
400 
401 err_bridge_port_create:
402 	mlxsw_sp_bridge_device_put(bridge, bridge_device);
403 	return ERR_PTR(err);
404 }
405 
406 static void mlxsw_sp_bridge_port_put(struct mlxsw_sp_bridge *bridge,
407 				     struct mlxsw_sp_bridge_port *bridge_port)
408 {
409 	struct mlxsw_sp_bridge_device *bridge_device;
410 
411 	if (--bridge_port->ref_count != 0)
412 		return;
413 	bridge_device = bridge_port->bridge_device;
414 	mlxsw_sp_bridge_port_destroy(bridge_port);
415 	mlxsw_sp_bridge_device_put(bridge, bridge_device);
416 }
417 
418 static struct mlxsw_sp_port_vlan *
419 mlxsw_sp_port_vlan_find_by_bridge(struct mlxsw_sp_port *mlxsw_sp_port,
420 				  const struct mlxsw_sp_bridge_device *
421 				  bridge_device,
422 				  u16 vid)
423 {
424 	struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
425 
426 	list_for_each_entry(mlxsw_sp_port_vlan, &mlxsw_sp_port->vlans_list,
427 			    list) {
428 		if (!mlxsw_sp_port_vlan->bridge_port)
429 			continue;
430 		if (mlxsw_sp_port_vlan->bridge_port->bridge_device !=
431 		    bridge_device)
432 			continue;
433 		if (bridge_device->vlan_enabled &&
434 		    mlxsw_sp_port_vlan->vid != vid)
435 			continue;
436 		return mlxsw_sp_port_vlan;
437 	}
438 
439 	return NULL;
440 }
441 
442 static struct mlxsw_sp_port_vlan*
443 mlxsw_sp_port_vlan_find_by_fid(struct mlxsw_sp_port *mlxsw_sp_port,
444 			       u16 fid_index)
445 {
446 	struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
447 
448 	list_for_each_entry(mlxsw_sp_port_vlan, &mlxsw_sp_port->vlans_list,
449 			    list) {
450 		struct mlxsw_sp_fid *fid = mlxsw_sp_port_vlan->fid;
451 
452 		if (fid && mlxsw_sp_fid_index(fid) == fid_index)
453 			return mlxsw_sp_port_vlan;
454 	}
455 
456 	return NULL;
457 }
458 
459 static struct mlxsw_sp_bridge_vlan *
460 mlxsw_sp_bridge_vlan_find(const struct mlxsw_sp_bridge_port *bridge_port,
461 			  u16 vid)
462 {
463 	struct mlxsw_sp_bridge_vlan *bridge_vlan;
464 
465 	list_for_each_entry(bridge_vlan, &bridge_port->vlans_list, list) {
466 		if (bridge_vlan->vid == vid)
467 			return bridge_vlan;
468 	}
469 
470 	return NULL;
471 }
472 
473 static struct mlxsw_sp_bridge_vlan *
474 mlxsw_sp_bridge_vlan_create(struct mlxsw_sp_bridge_port *bridge_port, u16 vid)
475 {
476 	struct mlxsw_sp_bridge_vlan *bridge_vlan;
477 
478 	bridge_vlan = kzalloc(sizeof(*bridge_vlan), GFP_KERNEL);
479 	if (!bridge_vlan)
480 		return NULL;
481 
482 	INIT_LIST_HEAD(&bridge_vlan->port_vlan_list);
483 	bridge_vlan->vid = vid;
484 	list_add(&bridge_vlan->list, &bridge_port->vlans_list);
485 
486 	return bridge_vlan;
487 }
488 
489 static void
490 mlxsw_sp_bridge_vlan_destroy(struct mlxsw_sp_bridge_vlan *bridge_vlan)
491 {
492 	list_del(&bridge_vlan->list);
493 	WARN_ON(!list_empty(&bridge_vlan->port_vlan_list));
494 	kfree(bridge_vlan);
495 }
496 
497 static struct mlxsw_sp_bridge_vlan *
498 mlxsw_sp_bridge_vlan_get(struct mlxsw_sp_bridge_port *bridge_port, u16 vid)
499 {
500 	struct mlxsw_sp_bridge_vlan *bridge_vlan;
501 
502 	bridge_vlan = mlxsw_sp_bridge_vlan_find(bridge_port, vid);
503 	if (bridge_vlan)
504 		return bridge_vlan;
505 
506 	return mlxsw_sp_bridge_vlan_create(bridge_port, vid);
507 }
508 
509 static void mlxsw_sp_bridge_vlan_put(struct mlxsw_sp_bridge_vlan *bridge_vlan)
510 {
511 	if (list_empty(&bridge_vlan->port_vlan_list))
512 		mlxsw_sp_bridge_vlan_destroy(bridge_vlan);
513 }
514 
515 static int
516 mlxsw_sp_port_bridge_vlan_stp_set(struct mlxsw_sp_port *mlxsw_sp_port,
517 				  struct mlxsw_sp_bridge_vlan *bridge_vlan,
518 				  u8 state)
519 {
520 	struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
521 
522 	list_for_each_entry(mlxsw_sp_port_vlan, &bridge_vlan->port_vlan_list,
523 			    bridge_vlan_node) {
524 		if (mlxsw_sp_port_vlan->mlxsw_sp_port != mlxsw_sp_port)
525 			continue;
526 		return mlxsw_sp_port_vid_stp_set(mlxsw_sp_port,
527 						 bridge_vlan->vid, state);
528 	}
529 
530 	return 0;
531 }
532 
533 static int mlxsw_sp_port_attr_stp_state_set(struct mlxsw_sp_port *mlxsw_sp_port,
534 					    struct net_device *orig_dev,
535 					    u8 state)
536 {
537 	struct mlxsw_sp_bridge_port *bridge_port;
538 	struct mlxsw_sp_bridge_vlan *bridge_vlan;
539 	int err;
540 
541 	/* It's possible we failed to enslave the port, yet this
542 	 * operation is executed due to it being deferred.
543 	 */
544 	bridge_port = mlxsw_sp_bridge_port_find(mlxsw_sp_port->mlxsw_sp->bridge,
545 						orig_dev);
546 	if (!bridge_port)
547 		return 0;
548 
549 	list_for_each_entry(bridge_vlan, &bridge_port->vlans_list, list) {
550 		err = mlxsw_sp_port_bridge_vlan_stp_set(mlxsw_sp_port,
551 							bridge_vlan, state);
552 		if (err)
553 			goto err_port_bridge_vlan_stp_set;
554 	}
555 
556 	bridge_port->stp_state = state;
557 
558 	return 0;
559 
560 err_port_bridge_vlan_stp_set:
561 	list_for_each_entry_continue_reverse(bridge_vlan,
562 					     &bridge_port->vlans_list, list)
563 		mlxsw_sp_port_bridge_vlan_stp_set(mlxsw_sp_port, bridge_vlan,
564 						  bridge_port->stp_state);
565 	return err;
566 }
567 
568 static int
569 mlxsw_sp_port_bridge_vlan_flood_set(struct mlxsw_sp_port *mlxsw_sp_port,
570 				    struct mlxsw_sp_bridge_vlan *bridge_vlan,
571 				    enum mlxsw_sp_flood_type packet_type,
572 				    bool member)
573 {
574 	struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
575 
576 	list_for_each_entry(mlxsw_sp_port_vlan, &bridge_vlan->port_vlan_list,
577 			    bridge_vlan_node) {
578 		if (mlxsw_sp_port_vlan->mlxsw_sp_port != mlxsw_sp_port)
579 			continue;
580 		return mlxsw_sp_fid_flood_set(mlxsw_sp_port_vlan->fid,
581 					      packet_type,
582 					      mlxsw_sp_port->local_port,
583 					      member);
584 	}
585 
586 	return 0;
587 }
588 
589 static int
590 mlxsw_sp_bridge_port_flood_table_set(struct mlxsw_sp_port *mlxsw_sp_port,
591 				     struct mlxsw_sp_bridge_port *bridge_port,
592 				     enum mlxsw_sp_flood_type packet_type,
593 				     bool member)
594 {
595 	struct mlxsw_sp_bridge_vlan *bridge_vlan;
596 	int err;
597 
598 	list_for_each_entry(bridge_vlan, &bridge_port->vlans_list, list) {
599 		err = mlxsw_sp_port_bridge_vlan_flood_set(mlxsw_sp_port,
600 							  bridge_vlan,
601 							  packet_type,
602 							  member);
603 		if (err)
604 			goto err_port_bridge_vlan_flood_set;
605 	}
606 
607 	return 0;
608 
609 err_port_bridge_vlan_flood_set:
610 	list_for_each_entry_continue_reverse(bridge_vlan,
611 					     &bridge_port->vlans_list, list)
612 		mlxsw_sp_port_bridge_vlan_flood_set(mlxsw_sp_port, bridge_vlan,
613 						    packet_type, !member);
614 	return err;
615 }
616 
617 static int
618 mlxsw_sp_port_bridge_vlan_learning_set(struct mlxsw_sp_port *mlxsw_sp_port,
619 				       struct mlxsw_sp_bridge_vlan *bridge_vlan,
620 				       bool set)
621 {
622 	struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
623 	u16 vid = bridge_vlan->vid;
624 
625 	list_for_each_entry(mlxsw_sp_port_vlan, &bridge_vlan->port_vlan_list,
626 			    bridge_vlan_node) {
627 		if (mlxsw_sp_port_vlan->mlxsw_sp_port != mlxsw_sp_port)
628 			continue;
629 		return mlxsw_sp_port_vid_learning_set(mlxsw_sp_port, vid, set);
630 	}
631 
632 	return 0;
633 }
634 
635 static int
636 mlxsw_sp_bridge_port_learning_set(struct mlxsw_sp_port *mlxsw_sp_port,
637 				  struct mlxsw_sp_bridge_port *bridge_port,
638 				  bool set)
639 {
640 	struct mlxsw_sp_bridge_vlan *bridge_vlan;
641 	int err;
642 
643 	list_for_each_entry(bridge_vlan, &bridge_port->vlans_list, list) {
644 		err = mlxsw_sp_port_bridge_vlan_learning_set(mlxsw_sp_port,
645 							     bridge_vlan, set);
646 		if (err)
647 			goto err_port_bridge_vlan_learning_set;
648 	}
649 
650 	return 0;
651 
652 err_port_bridge_vlan_learning_set:
653 	list_for_each_entry_continue_reverse(bridge_vlan,
654 					     &bridge_port->vlans_list, list)
655 		mlxsw_sp_port_bridge_vlan_learning_set(mlxsw_sp_port,
656 						       bridge_vlan, !set);
657 	return err;
658 }
659 
660 static int
661 mlxsw_sp_port_attr_br_pre_flags_set(struct mlxsw_sp_port *mlxsw_sp_port,
662 				    struct switchdev_brport_flags flags)
663 {
664 	if (flags.mask & ~(BR_LEARNING | BR_FLOOD | BR_MCAST_FLOOD))
665 		return -EINVAL;
666 
667 	return 0;
668 }
669 
670 static int mlxsw_sp_port_attr_br_flags_set(struct mlxsw_sp_port *mlxsw_sp_port,
671 					   struct net_device *orig_dev,
672 					   struct switchdev_brport_flags flags)
673 {
674 	struct mlxsw_sp_bridge_port *bridge_port;
675 	int err;
676 
677 	bridge_port = mlxsw_sp_bridge_port_find(mlxsw_sp_port->mlxsw_sp->bridge,
678 						orig_dev);
679 	if (!bridge_port)
680 		return 0;
681 
682 	if (flags.mask & BR_FLOOD) {
683 		err = mlxsw_sp_bridge_port_flood_table_set(mlxsw_sp_port,
684 							   bridge_port,
685 							   MLXSW_SP_FLOOD_TYPE_UC,
686 							   flags.val & BR_FLOOD);
687 		if (err)
688 			return err;
689 	}
690 
691 	if (flags.mask & BR_LEARNING) {
692 		err = mlxsw_sp_bridge_port_learning_set(mlxsw_sp_port,
693 							bridge_port,
694 							flags.val & BR_LEARNING);
695 		if (err)
696 			return err;
697 	}
698 
699 	if (bridge_port->bridge_device->multicast_enabled)
700 		goto out;
701 
702 	if (flags.mask & BR_MCAST_FLOOD) {
703 		err = mlxsw_sp_bridge_port_flood_table_set(mlxsw_sp_port,
704 							   bridge_port,
705 							   MLXSW_SP_FLOOD_TYPE_MC,
706 							   flags.val & BR_MCAST_FLOOD);
707 		if (err)
708 			return err;
709 	}
710 
711 out:
712 	memcpy(&bridge_port->flags, &flags.val, sizeof(flags.val));
713 	return 0;
714 }
715 
716 static int mlxsw_sp_ageing_set(struct mlxsw_sp *mlxsw_sp, u32 ageing_time)
717 {
718 	char sfdat_pl[MLXSW_REG_SFDAT_LEN];
719 	int err;
720 
721 	mlxsw_reg_sfdat_pack(sfdat_pl, ageing_time);
722 	err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(sfdat), sfdat_pl);
723 	if (err)
724 		return err;
725 	mlxsw_sp->bridge->ageing_time = ageing_time;
726 	return 0;
727 }
728 
729 static int mlxsw_sp_port_attr_br_ageing_set(struct mlxsw_sp_port *mlxsw_sp_port,
730 					    unsigned long ageing_clock_t)
731 {
732 	struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
733 	unsigned long ageing_jiffies = clock_t_to_jiffies(ageing_clock_t);
734 	u32 ageing_time = jiffies_to_msecs(ageing_jiffies) / 1000;
735 
736 	if (ageing_time < MLXSW_SP_MIN_AGEING_TIME ||
737 	    ageing_time > MLXSW_SP_MAX_AGEING_TIME)
738 		return -ERANGE;
739 
740 	return mlxsw_sp_ageing_set(mlxsw_sp, ageing_time);
741 }
742 
743 static int mlxsw_sp_port_attr_br_vlan_set(struct mlxsw_sp_port *mlxsw_sp_port,
744 					  struct net_device *orig_dev,
745 					  bool vlan_enabled)
746 {
747 	struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
748 	struct mlxsw_sp_bridge_device *bridge_device;
749 
750 	bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, orig_dev);
751 	if (WARN_ON(!bridge_device))
752 		return -EINVAL;
753 
754 	if (bridge_device->vlan_enabled == vlan_enabled)
755 		return 0;
756 
757 	netdev_err(bridge_device->dev, "VLAN filtering can't be changed for existing bridge\n");
758 	return -EINVAL;
759 }
760 
761 static int mlxsw_sp_port_attr_br_vlan_proto_set(struct mlxsw_sp_port *mlxsw_sp_port,
762 						struct net_device *orig_dev,
763 						u16 vlan_proto)
764 {
765 	struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
766 	struct mlxsw_sp_bridge_device *bridge_device;
767 
768 	bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, orig_dev);
769 	if (WARN_ON(!bridge_device))
770 		return -EINVAL;
771 
772 	netdev_err(bridge_device->dev, "VLAN protocol can't be changed on existing bridge\n");
773 	return -EINVAL;
774 }
775 
776 static int mlxsw_sp_port_attr_mrouter_set(struct mlxsw_sp_port *mlxsw_sp_port,
777 					  struct net_device *orig_dev,
778 					  bool is_port_mrouter)
779 {
780 	struct mlxsw_sp_bridge_port *bridge_port;
781 	int err;
782 
783 	bridge_port = mlxsw_sp_bridge_port_find(mlxsw_sp_port->mlxsw_sp->bridge,
784 						orig_dev);
785 	if (!bridge_port)
786 		return 0;
787 
788 	if (!bridge_port->bridge_device->multicast_enabled)
789 		goto out;
790 
791 	err = mlxsw_sp_bridge_port_flood_table_set(mlxsw_sp_port, bridge_port,
792 						   MLXSW_SP_FLOOD_TYPE_MC,
793 						   is_port_mrouter);
794 	if (err)
795 		return err;
796 
797 	mlxsw_sp_port_mrouter_update_mdb(mlxsw_sp_port, bridge_port,
798 					 is_port_mrouter);
799 out:
800 	bridge_port->mrouter = is_port_mrouter;
801 	return 0;
802 }
803 
804 static bool mlxsw_sp_mc_flood(const struct mlxsw_sp_bridge_port *bridge_port)
805 {
806 	const struct mlxsw_sp_bridge_device *bridge_device;
807 
808 	bridge_device = bridge_port->bridge_device;
809 	return bridge_device->multicast_enabled ? bridge_port->mrouter :
810 					bridge_port->flags & BR_MCAST_FLOOD;
811 }
812 
813 static int mlxsw_sp_port_mc_disabled_set(struct mlxsw_sp_port *mlxsw_sp_port,
814 					 struct net_device *orig_dev,
815 					 bool mc_disabled)
816 {
817 	struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
818 	struct mlxsw_sp_bridge_device *bridge_device;
819 	struct mlxsw_sp_bridge_port *bridge_port;
820 	int err;
821 
822 	/* It's possible we failed to enslave the port, yet this
823 	 * operation is executed due to it being deferred.
824 	 */
825 	bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, orig_dev);
826 	if (!bridge_device)
827 		return 0;
828 
829 	if (bridge_device->multicast_enabled != !mc_disabled) {
830 		bridge_device->multicast_enabled = !mc_disabled;
831 		mlxsw_sp_bridge_mdb_mc_enable_sync(mlxsw_sp_port,
832 						   bridge_device);
833 	}
834 
835 	list_for_each_entry(bridge_port, &bridge_device->ports_list, list) {
836 		enum mlxsw_sp_flood_type packet_type = MLXSW_SP_FLOOD_TYPE_MC;
837 		bool member = mlxsw_sp_mc_flood(bridge_port);
838 
839 		err = mlxsw_sp_bridge_port_flood_table_set(mlxsw_sp_port,
840 							   bridge_port,
841 							   packet_type, member);
842 		if (err)
843 			return err;
844 	}
845 
846 	bridge_device->multicast_enabled = !mc_disabled;
847 
848 	return 0;
849 }
850 
851 static int mlxsw_sp_smid_router_port_set(struct mlxsw_sp *mlxsw_sp,
852 					 u16 mid_idx, bool add)
853 {
854 	char *smid_pl;
855 	int err;
856 
857 	smid_pl = kmalloc(MLXSW_REG_SMID_LEN, GFP_KERNEL);
858 	if (!smid_pl)
859 		return -ENOMEM;
860 
861 	mlxsw_reg_smid_pack(smid_pl, mid_idx,
862 			    mlxsw_sp_router_port(mlxsw_sp), add);
863 	err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(smid), smid_pl);
864 	kfree(smid_pl);
865 	return err;
866 }
867 
868 static void
869 mlxsw_sp_bridge_mrouter_update_mdb(struct mlxsw_sp *mlxsw_sp,
870 				   struct mlxsw_sp_bridge_device *bridge_device,
871 				   bool add)
872 {
873 	struct mlxsw_sp_mid *mid;
874 
875 	list_for_each_entry(mid, &bridge_device->mids_list, list)
876 		mlxsw_sp_smid_router_port_set(mlxsw_sp, mid->mid, add);
877 }
878 
879 static int
880 mlxsw_sp_port_attr_br_mrouter_set(struct mlxsw_sp_port *mlxsw_sp_port,
881 				  struct net_device *orig_dev,
882 				  bool is_mrouter)
883 {
884 	struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
885 	struct mlxsw_sp_bridge_device *bridge_device;
886 
887 	/* It's possible we failed to enslave the port, yet this
888 	 * operation is executed due to it being deferred.
889 	 */
890 	bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, orig_dev);
891 	if (!bridge_device)
892 		return 0;
893 
894 	if (bridge_device->mrouter != is_mrouter)
895 		mlxsw_sp_bridge_mrouter_update_mdb(mlxsw_sp, bridge_device,
896 						   is_mrouter);
897 	bridge_device->mrouter = is_mrouter;
898 	return 0;
899 }
900 
901 static int mlxsw_sp_port_attr_set(struct net_device *dev,
902 				  const struct switchdev_attr *attr,
903 				  struct netlink_ext_ack *extack)
904 {
905 	struct mlxsw_sp_port *mlxsw_sp_port = netdev_priv(dev);
906 	int err;
907 
908 	switch (attr->id) {
909 	case SWITCHDEV_ATTR_ID_PORT_STP_STATE:
910 		err = mlxsw_sp_port_attr_stp_state_set(mlxsw_sp_port,
911 						       attr->orig_dev,
912 						       attr->u.stp_state);
913 		break;
914 	case SWITCHDEV_ATTR_ID_PORT_PRE_BRIDGE_FLAGS:
915 		err = mlxsw_sp_port_attr_br_pre_flags_set(mlxsw_sp_port,
916 							  attr->u.brport_flags);
917 		break;
918 	case SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS:
919 		err = mlxsw_sp_port_attr_br_flags_set(mlxsw_sp_port,
920 						      attr->orig_dev,
921 						      attr->u.brport_flags);
922 		break;
923 	case SWITCHDEV_ATTR_ID_BRIDGE_AGEING_TIME:
924 		err = mlxsw_sp_port_attr_br_ageing_set(mlxsw_sp_port,
925 						       attr->u.ageing_time);
926 		break;
927 	case SWITCHDEV_ATTR_ID_BRIDGE_VLAN_FILTERING:
928 		err = mlxsw_sp_port_attr_br_vlan_set(mlxsw_sp_port,
929 						     attr->orig_dev,
930 						     attr->u.vlan_filtering);
931 		break;
932 	case SWITCHDEV_ATTR_ID_BRIDGE_VLAN_PROTOCOL:
933 		err = mlxsw_sp_port_attr_br_vlan_proto_set(mlxsw_sp_port,
934 							   attr->orig_dev,
935 							   attr->u.vlan_protocol);
936 		break;
937 	case SWITCHDEV_ATTR_ID_PORT_MROUTER:
938 		err = mlxsw_sp_port_attr_mrouter_set(mlxsw_sp_port,
939 						     attr->orig_dev,
940 						     attr->u.mrouter);
941 		break;
942 	case SWITCHDEV_ATTR_ID_BRIDGE_MC_DISABLED:
943 		err = mlxsw_sp_port_mc_disabled_set(mlxsw_sp_port,
944 						    attr->orig_dev,
945 						    attr->u.mc_disabled);
946 		break;
947 	case SWITCHDEV_ATTR_ID_BRIDGE_MROUTER:
948 		err = mlxsw_sp_port_attr_br_mrouter_set(mlxsw_sp_port,
949 							attr->orig_dev,
950 							attr->u.mrouter);
951 		break;
952 	default:
953 		err = -EOPNOTSUPP;
954 		break;
955 	}
956 
957 	mlxsw_sp_span_respin(mlxsw_sp_port->mlxsw_sp);
958 
959 	return err;
960 }
961 
962 static int
963 mlxsw_sp_port_vlan_fid_join(struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan,
964 			    struct mlxsw_sp_bridge_port *bridge_port,
965 			    struct netlink_ext_ack *extack)
966 {
967 	struct mlxsw_sp_port *mlxsw_sp_port = mlxsw_sp_port_vlan->mlxsw_sp_port;
968 	struct mlxsw_sp_bridge_device *bridge_device;
969 	u8 local_port = mlxsw_sp_port->local_port;
970 	u16 vid = mlxsw_sp_port_vlan->vid;
971 	struct mlxsw_sp_fid *fid;
972 	int err;
973 
974 	bridge_device = bridge_port->bridge_device;
975 	fid = bridge_device->ops->fid_get(bridge_device, vid, extack);
976 	if (IS_ERR(fid))
977 		return PTR_ERR(fid);
978 
979 	err = mlxsw_sp_fid_flood_set(fid, MLXSW_SP_FLOOD_TYPE_UC, local_port,
980 				     bridge_port->flags & BR_FLOOD);
981 	if (err)
982 		goto err_fid_uc_flood_set;
983 
984 	err = mlxsw_sp_fid_flood_set(fid, MLXSW_SP_FLOOD_TYPE_MC, local_port,
985 				     mlxsw_sp_mc_flood(bridge_port));
986 	if (err)
987 		goto err_fid_mc_flood_set;
988 
989 	err = mlxsw_sp_fid_flood_set(fid, MLXSW_SP_FLOOD_TYPE_BC, local_port,
990 				     true);
991 	if (err)
992 		goto err_fid_bc_flood_set;
993 
994 	err = mlxsw_sp_fid_port_vid_map(fid, mlxsw_sp_port, vid);
995 	if (err)
996 		goto err_fid_port_vid_map;
997 
998 	mlxsw_sp_port_vlan->fid = fid;
999 
1000 	return 0;
1001 
1002 err_fid_port_vid_map:
1003 	mlxsw_sp_fid_flood_set(fid, MLXSW_SP_FLOOD_TYPE_BC, local_port, false);
1004 err_fid_bc_flood_set:
1005 	mlxsw_sp_fid_flood_set(fid, MLXSW_SP_FLOOD_TYPE_MC, local_port, false);
1006 err_fid_mc_flood_set:
1007 	mlxsw_sp_fid_flood_set(fid, MLXSW_SP_FLOOD_TYPE_UC, local_port, false);
1008 err_fid_uc_flood_set:
1009 	mlxsw_sp_fid_put(fid);
1010 	return err;
1011 }
1012 
1013 static void
1014 mlxsw_sp_port_vlan_fid_leave(struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan)
1015 {
1016 	struct mlxsw_sp_port *mlxsw_sp_port = mlxsw_sp_port_vlan->mlxsw_sp_port;
1017 	struct mlxsw_sp_fid *fid = mlxsw_sp_port_vlan->fid;
1018 	u8 local_port = mlxsw_sp_port->local_port;
1019 	u16 vid = mlxsw_sp_port_vlan->vid;
1020 
1021 	mlxsw_sp_port_vlan->fid = NULL;
1022 	mlxsw_sp_fid_port_vid_unmap(fid, mlxsw_sp_port, vid);
1023 	mlxsw_sp_fid_flood_set(fid, MLXSW_SP_FLOOD_TYPE_BC, local_port, false);
1024 	mlxsw_sp_fid_flood_set(fid, MLXSW_SP_FLOOD_TYPE_MC, local_port, false);
1025 	mlxsw_sp_fid_flood_set(fid, MLXSW_SP_FLOOD_TYPE_UC, local_port, false);
1026 	mlxsw_sp_fid_put(fid);
1027 }
1028 
1029 static u16
1030 mlxsw_sp_port_pvid_determine(const struct mlxsw_sp_port *mlxsw_sp_port,
1031 			     u16 vid, bool is_pvid)
1032 {
1033 	if (is_pvid)
1034 		return vid;
1035 	else if (mlxsw_sp_port->pvid == vid)
1036 		return 0;	/* Dis-allow untagged packets */
1037 	else
1038 		return mlxsw_sp_port->pvid;
1039 }
1040 
1041 static int
1042 mlxsw_sp_port_vlan_bridge_join(struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan,
1043 			       struct mlxsw_sp_bridge_port *bridge_port,
1044 			       struct netlink_ext_ack *extack)
1045 {
1046 	struct mlxsw_sp_port *mlxsw_sp_port = mlxsw_sp_port_vlan->mlxsw_sp_port;
1047 	struct mlxsw_sp_bridge_vlan *bridge_vlan;
1048 	u16 vid = mlxsw_sp_port_vlan->vid;
1049 	int err;
1050 
1051 	/* No need to continue if only VLAN flags were changed */
1052 	if (mlxsw_sp_port_vlan->bridge_port)
1053 		return 0;
1054 
1055 	err = mlxsw_sp_port_vlan_fid_join(mlxsw_sp_port_vlan, bridge_port,
1056 					  extack);
1057 	if (err)
1058 		return err;
1059 
1060 	err = mlxsw_sp_port_vid_learning_set(mlxsw_sp_port, vid,
1061 					     bridge_port->flags & BR_LEARNING);
1062 	if (err)
1063 		goto err_port_vid_learning_set;
1064 
1065 	err = mlxsw_sp_port_vid_stp_set(mlxsw_sp_port, vid,
1066 					bridge_port->stp_state);
1067 	if (err)
1068 		goto err_port_vid_stp_set;
1069 
1070 	bridge_vlan = mlxsw_sp_bridge_vlan_get(bridge_port, vid);
1071 	if (!bridge_vlan) {
1072 		err = -ENOMEM;
1073 		goto err_bridge_vlan_get;
1074 	}
1075 
1076 	list_add(&mlxsw_sp_port_vlan->bridge_vlan_node,
1077 		 &bridge_vlan->port_vlan_list);
1078 
1079 	mlxsw_sp_bridge_port_get(mlxsw_sp_port->mlxsw_sp->bridge,
1080 				 bridge_port->dev, extack);
1081 	mlxsw_sp_port_vlan->bridge_port = bridge_port;
1082 
1083 	return 0;
1084 
1085 err_bridge_vlan_get:
1086 	mlxsw_sp_port_vid_stp_set(mlxsw_sp_port, vid, BR_STATE_DISABLED);
1087 err_port_vid_stp_set:
1088 	mlxsw_sp_port_vid_learning_set(mlxsw_sp_port, vid, false);
1089 err_port_vid_learning_set:
1090 	mlxsw_sp_port_vlan_fid_leave(mlxsw_sp_port_vlan);
1091 	return err;
1092 }
1093 
1094 void
1095 mlxsw_sp_port_vlan_bridge_leave(struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan)
1096 {
1097 	struct mlxsw_sp_port *mlxsw_sp_port = mlxsw_sp_port_vlan->mlxsw_sp_port;
1098 	struct mlxsw_sp_fid *fid = mlxsw_sp_port_vlan->fid;
1099 	struct mlxsw_sp_bridge_vlan *bridge_vlan;
1100 	struct mlxsw_sp_bridge_port *bridge_port;
1101 	u16 vid = mlxsw_sp_port_vlan->vid;
1102 	bool last_port, last_vlan;
1103 
1104 	if (WARN_ON(mlxsw_sp_fid_type(fid) != MLXSW_SP_FID_TYPE_8021Q &&
1105 		    mlxsw_sp_fid_type(fid) != MLXSW_SP_FID_TYPE_8021D))
1106 		return;
1107 
1108 	bridge_port = mlxsw_sp_port_vlan->bridge_port;
1109 	last_vlan = list_is_singular(&bridge_port->vlans_list);
1110 	bridge_vlan = mlxsw_sp_bridge_vlan_find(bridge_port, vid);
1111 	last_port = list_is_singular(&bridge_vlan->port_vlan_list);
1112 
1113 	list_del(&mlxsw_sp_port_vlan->bridge_vlan_node);
1114 	mlxsw_sp_bridge_vlan_put(bridge_vlan);
1115 	mlxsw_sp_port_vid_stp_set(mlxsw_sp_port, vid, BR_STATE_DISABLED);
1116 	mlxsw_sp_port_vid_learning_set(mlxsw_sp_port, vid, false);
1117 	if (last_port)
1118 		mlxsw_sp_bridge_port_fdb_flush(mlxsw_sp_port->mlxsw_sp,
1119 					       bridge_port,
1120 					       mlxsw_sp_fid_index(fid));
1121 	if (last_vlan)
1122 		mlxsw_sp_bridge_port_mdb_flush(mlxsw_sp_port, bridge_port);
1123 
1124 	mlxsw_sp_port_vlan_fid_leave(mlxsw_sp_port_vlan);
1125 
1126 	mlxsw_sp_bridge_port_put(mlxsw_sp_port->mlxsw_sp->bridge, bridge_port);
1127 	mlxsw_sp_port_vlan->bridge_port = NULL;
1128 }
1129 
1130 static int
1131 mlxsw_sp_bridge_port_vlan_add(struct mlxsw_sp_port *mlxsw_sp_port,
1132 			      struct mlxsw_sp_bridge_port *bridge_port,
1133 			      u16 vid, bool is_untagged, bool is_pvid,
1134 			      struct netlink_ext_ack *extack)
1135 {
1136 	u16 pvid = mlxsw_sp_port_pvid_determine(mlxsw_sp_port, vid, is_pvid);
1137 	struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
1138 	u16 old_pvid = mlxsw_sp_port->pvid;
1139 	u16 proto;
1140 	int err;
1141 
1142 	/* The only valid scenario in which a port-vlan already exists, is if
1143 	 * the VLAN flags were changed and the port-vlan is associated with the
1144 	 * correct bridge port
1145 	 */
1146 	mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_vid(mlxsw_sp_port, vid);
1147 	if (mlxsw_sp_port_vlan &&
1148 	    mlxsw_sp_port_vlan->bridge_port != bridge_port)
1149 		return -EEXIST;
1150 
1151 	if (!mlxsw_sp_port_vlan) {
1152 		mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_create(mlxsw_sp_port,
1153 							       vid);
1154 		if (IS_ERR(mlxsw_sp_port_vlan))
1155 			return PTR_ERR(mlxsw_sp_port_vlan);
1156 	}
1157 
1158 	err = mlxsw_sp_port_vlan_set(mlxsw_sp_port, vid, vid, true,
1159 				     is_untagged);
1160 	if (err)
1161 		goto err_port_vlan_set;
1162 
1163 	br_vlan_get_proto(bridge_port->bridge_device->dev, &proto);
1164 	err = mlxsw_sp_port_pvid_set(mlxsw_sp_port, pvid, proto);
1165 	if (err)
1166 		goto err_port_pvid_set;
1167 
1168 	err = mlxsw_sp_port_vlan_bridge_join(mlxsw_sp_port_vlan, bridge_port,
1169 					     extack);
1170 	if (err)
1171 		goto err_port_vlan_bridge_join;
1172 
1173 	return 0;
1174 
1175 err_port_vlan_bridge_join:
1176 	mlxsw_sp_port_pvid_set(mlxsw_sp_port, old_pvid, proto);
1177 err_port_pvid_set:
1178 	mlxsw_sp_port_vlan_set(mlxsw_sp_port, vid, vid, false, false);
1179 err_port_vlan_set:
1180 	mlxsw_sp_port_vlan_destroy(mlxsw_sp_port_vlan);
1181 	return err;
1182 }
1183 
1184 static int
1185 mlxsw_sp_br_ban_rif_pvid_change(struct mlxsw_sp *mlxsw_sp,
1186 				const struct net_device *br_dev,
1187 				const struct switchdev_obj_port_vlan *vlan)
1188 {
1189 	u16 pvid;
1190 
1191 	pvid = mlxsw_sp_rif_vid(mlxsw_sp, br_dev);
1192 	if (!pvid)
1193 		return 0;
1194 
1195 	if (vlan->flags & BRIDGE_VLAN_INFO_PVID) {
1196 		if (vlan->vid != pvid) {
1197 			netdev_err(br_dev, "Can't change PVID, it's used by router interface\n");
1198 			return -EBUSY;
1199 		}
1200 	} else {
1201 		if (vlan->vid == pvid) {
1202 			netdev_err(br_dev, "Can't remove PVID, it's used by router interface\n");
1203 			return -EBUSY;
1204 		}
1205 	}
1206 
1207 	return 0;
1208 }
1209 
1210 static int mlxsw_sp_port_vlans_add(struct mlxsw_sp_port *mlxsw_sp_port,
1211 				   const struct switchdev_obj_port_vlan *vlan,
1212 				   struct netlink_ext_ack *extack)
1213 {
1214 	bool flag_untagged = vlan->flags & BRIDGE_VLAN_INFO_UNTAGGED;
1215 	bool flag_pvid = vlan->flags & BRIDGE_VLAN_INFO_PVID;
1216 	struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
1217 	struct net_device *orig_dev = vlan->obj.orig_dev;
1218 	struct mlxsw_sp_bridge_port *bridge_port;
1219 
1220 	if (netif_is_bridge_master(orig_dev)) {
1221 		int err = 0;
1222 
1223 		if ((vlan->flags & BRIDGE_VLAN_INFO_BRENTRY) &&
1224 		    br_vlan_enabled(orig_dev))
1225 			err = mlxsw_sp_br_ban_rif_pvid_change(mlxsw_sp,
1226 							      orig_dev, vlan);
1227 		if (!err)
1228 			err = -EOPNOTSUPP;
1229 		return err;
1230 	}
1231 
1232 	bridge_port = mlxsw_sp_bridge_port_find(mlxsw_sp->bridge, orig_dev);
1233 	if (WARN_ON(!bridge_port))
1234 		return -EINVAL;
1235 
1236 	if (!bridge_port->bridge_device->vlan_enabled)
1237 		return 0;
1238 
1239 	return mlxsw_sp_bridge_port_vlan_add(mlxsw_sp_port, bridge_port,
1240 					     vlan->vid, flag_untagged,
1241 					     flag_pvid, extack);
1242 }
1243 
1244 static enum mlxsw_reg_sfdf_flush_type mlxsw_sp_fdb_flush_type(bool lagged)
1245 {
1246 	return lagged ? MLXSW_REG_SFDF_FLUSH_PER_LAG_AND_FID :
1247 			MLXSW_REG_SFDF_FLUSH_PER_PORT_AND_FID;
1248 }
1249 
1250 static int
1251 mlxsw_sp_bridge_port_fdb_flush(struct mlxsw_sp *mlxsw_sp,
1252 			       struct mlxsw_sp_bridge_port *bridge_port,
1253 			       u16 fid_index)
1254 {
1255 	bool lagged = bridge_port->lagged;
1256 	char sfdf_pl[MLXSW_REG_SFDF_LEN];
1257 	u16 system_port;
1258 
1259 	system_port = lagged ? bridge_port->lag_id : bridge_port->system_port;
1260 	mlxsw_reg_sfdf_pack(sfdf_pl, mlxsw_sp_fdb_flush_type(lagged));
1261 	mlxsw_reg_sfdf_fid_set(sfdf_pl, fid_index);
1262 	mlxsw_reg_sfdf_port_fid_system_port_set(sfdf_pl, system_port);
1263 
1264 	return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(sfdf), sfdf_pl);
1265 }
1266 
1267 static enum mlxsw_reg_sfd_rec_policy mlxsw_sp_sfd_rec_policy(bool dynamic)
1268 {
1269 	return dynamic ? MLXSW_REG_SFD_REC_POLICY_DYNAMIC_ENTRY_INGRESS :
1270 			 MLXSW_REG_SFD_REC_POLICY_DYNAMIC_ENTRY_MLAG;
1271 }
1272 
1273 static enum mlxsw_reg_sfd_op mlxsw_sp_sfd_op(bool adding)
1274 {
1275 	return adding ? MLXSW_REG_SFD_OP_WRITE_EDIT :
1276 			MLXSW_REG_SFD_OP_WRITE_REMOVE;
1277 }
1278 
1279 static int mlxsw_sp_port_fdb_tunnel_uc_op(struct mlxsw_sp *mlxsw_sp,
1280 					  const char *mac, u16 fid,
1281 					  enum mlxsw_sp_l3proto proto,
1282 					  const union mlxsw_sp_l3addr *addr,
1283 					  bool adding, bool dynamic)
1284 {
1285 	enum mlxsw_reg_sfd_uc_tunnel_protocol sfd_proto;
1286 	char *sfd_pl;
1287 	u8 num_rec;
1288 	u32 uip;
1289 	int err;
1290 
1291 	switch (proto) {
1292 	case MLXSW_SP_L3_PROTO_IPV4:
1293 		uip = be32_to_cpu(addr->addr4);
1294 		sfd_proto = MLXSW_REG_SFD_UC_TUNNEL_PROTOCOL_IPV4;
1295 		break;
1296 	case MLXSW_SP_L3_PROTO_IPV6:
1297 	default:
1298 		WARN_ON(1);
1299 		return -EOPNOTSUPP;
1300 	}
1301 
1302 	sfd_pl = kmalloc(MLXSW_REG_SFD_LEN, GFP_KERNEL);
1303 	if (!sfd_pl)
1304 		return -ENOMEM;
1305 
1306 	mlxsw_reg_sfd_pack(sfd_pl, mlxsw_sp_sfd_op(adding), 0);
1307 	mlxsw_reg_sfd_uc_tunnel_pack(sfd_pl, 0,
1308 				     mlxsw_sp_sfd_rec_policy(dynamic), mac, fid,
1309 				     MLXSW_REG_SFD_REC_ACTION_NOP, uip,
1310 				     sfd_proto);
1311 	num_rec = mlxsw_reg_sfd_num_rec_get(sfd_pl);
1312 	err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(sfd), sfd_pl);
1313 	if (err)
1314 		goto out;
1315 
1316 	if (num_rec != mlxsw_reg_sfd_num_rec_get(sfd_pl))
1317 		err = -EBUSY;
1318 
1319 out:
1320 	kfree(sfd_pl);
1321 	return err;
1322 }
1323 
1324 static int __mlxsw_sp_port_fdb_uc_op(struct mlxsw_sp *mlxsw_sp, u8 local_port,
1325 				     const char *mac, u16 fid, bool adding,
1326 				     enum mlxsw_reg_sfd_rec_action action,
1327 				     enum mlxsw_reg_sfd_rec_policy policy)
1328 {
1329 	char *sfd_pl;
1330 	u8 num_rec;
1331 	int err;
1332 
1333 	sfd_pl = kmalloc(MLXSW_REG_SFD_LEN, GFP_KERNEL);
1334 	if (!sfd_pl)
1335 		return -ENOMEM;
1336 
1337 	mlxsw_reg_sfd_pack(sfd_pl, mlxsw_sp_sfd_op(adding), 0);
1338 	mlxsw_reg_sfd_uc_pack(sfd_pl, 0, policy, mac, fid, action, local_port);
1339 	num_rec = mlxsw_reg_sfd_num_rec_get(sfd_pl);
1340 	err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(sfd), sfd_pl);
1341 	if (err)
1342 		goto out;
1343 
1344 	if (num_rec != mlxsw_reg_sfd_num_rec_get(sfd_pl))
1345 		err = -EBUSY;
1346 
1347 out:
1348 	kfree(sfd_pl);
1349 	return err;
1350 }
1351 
1352 static int mlxsw_sp_port_fdb_uc_op(struct mlxsw_sp *mlxsw_sp, u8 local_port,
1353 				   const char *mac, u16 fid, bool adding,
1354 				   bool dynamic)
1355 {
1356 	return __mlxsw_sp_port_fdb_uc_op(mlxsw_sp, local_port, mac, fid, adding,
1357 					 MLXSW_REG_SFD_REC_ACTION_NOP,
1358 					 mlxsw_sp_sfd_rec_policy(dynamic));
1359 }
1360 
1361 int mlxsw_sp_rif_fdb_op(struct mlxsw_sp *mlxsw_sp, const char *mac, u16 fid,
1362 			bool adding)
1363 {
1364 	return __mlxsw_sp_port_fdb_uc_op(mlxsw_sp, 0, mac, fid, adding,
1365 					 MLXSW_REG_SFD_REC_ACTION_FORWARD_IP_ROUTER,
1366 					 MLXSW_REG_SFD_REC_POLICY_STATIC_ENTRY);
1367 }
1368 
1369 static int mlxsw_sp_port_fdb_uc_lag_op(struct mlxsw_sp *mlxsw_sp, u16 lag_id,
1370 				       const char *mac, u16 fid, u16 lag_vid,
1371 				       bool adding, bool dynamic)
1372 {
1373 	char *sfd_pl;
1374 	u8 num_rec;
1375 	int err;
1376 
1377 	sfd_pl = kmalloc(MLXSW_REG_SFD_LEN, GFP_KERNEL);
1378 	if (!sfd_pl)
1379 		return -ENOMEM;
1380 
1381 	mlxsw_reg_sfd_pack(sfd_pl, mlxsw_sp_sfd_op(adding), 0);
1382 	mlxsw_reg_sfd_uc_lag_pack(sfd_pl, 0, mlxsw_sp_sfd_rec_policy(dynamic),
1383 				  mac, fid, MLXSW_REG_SFD_REC_ACTION_NOP,
1384 				  lag_vid, lag_id);
1385 	num_rec = mlxsw_reg_sfd_num_rec_get(sfd_pl);
1386 	err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(sfd), sfd_pl);
1387 	if (err)
1388 		goto out;
1389 
1390 	if (num_rec != mlxsw_reg_sfd_num_rec_get(sfd_pl))
1391 		err = -EBUSY;
1392 
1393 out:
1394 	kfree(sfd_pl);
1395 	return err;
1396 }
1397 
1398 static int
1399 mlxsw_sp_port_fdb_set(struct mlxsw_sp_port *mlxsw_sp_port,
1400 		      struct switchdev_notifier_fdb_info *fdb_info, bool adding)
1401 {
1402 	struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
1403 	struct net_device *orig_dev = fdb_info->info.dev;
1404 	struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
1405 	struct mlxsw_sp_bridge_device *bridge_device;
1406 	struct mlxsw_sp_bridge_port *bridge_port;
1407 	u16 fid_index, vid;
1408 
1409 	bridge_port = mlxsw_sp_bridge_port_find(mlxsw_sp->bridge, orig_dev);
1410 	if (!bridge_port)
1411 		return -EINVAL;
1412 
1413 	bridge_device = bridge_port->bridge_device;
1414 	mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_bridge(mlxsw_sp_port,
1415 							       bridge_device,
1416 							       fdb_info->vid);
1417 	if (!mlxsw_sp_port_vlan)
1418 		return 0;
1419 
1420 	fid_index = mlxsw_sp_fid_index(mlxsw_sp_port_vlan->fid);
1421 	vid = mlxsw_sp_port_vlan->vid;
1422 
1423 	if (!bridge_port->lagged)
1424 		return mlxsw_sp_port_fdb_uc_op(mlxsw_sp,
1425 					       bridge_port->system_port,
1426 					       fdb_info->addr, fid_index,
1427 					       adding, false);
1428 	else
1429 		return mlxsw_sp_port_fdb_uc_lag_op(mlxsw_sp,
1430 						   bridge_port->lag_id,
1431 						   fdb_info->addr, fid_index,
1432 						   vid, adding, false);
1433 }
1434 
1435 static int mlxsw_sp_port_mdb_op(struct mlxsw_sp *mlxsw_sp, const char *addr,
1436 				u16 fid, u16 mid_idx, bool adding)
1437 {
1438 	char *sfd_pl;
1439 	u8 num_rec;
1440 	int err;
1441 
1442 	sfd_pl = kmalloc(MLXSW_REG_SFD_LEN, GFP_KERNEL);
1443 	if (!sfd_pl)
1444 		return -ENOMEM;
1445 
1446 	mlxsw_reg_sfd_pack(sfd_pl, mlxsw_sp_sfd_op(adding), 0);
1447 	mlxsw_reg_sfd_mc_pack(sfd_pl, 0, addr, fid,
1448 			      MLXSW_REG_SFD_REC_ACTION_NOP, mid_idx);
1449 	num_rec = mlxsw_reg_sfd_num_rec_get(sfd_pl);
1450 	err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(sfd), sfd_pl);
1451 	if (err)
1452 		goto out;
1453 
1454 	if (num_rec != mlxsw_reg_sfd_num_rec_get(sfd_pl))
1455 		err = -EBUSY;
1456 
1457 out:
1458 	kfree(sfd_pl);
1459 	return err;
1460 }
1461 
1462 static int mlxsw_sp_port_smid_full_entry(struct mlxsw_sp *mlxsw_sp, u16 mid_idx,
1463 					 long *ports_bitmap,
1464 					 bool set_router_port)
1465 {
1466 	char *smid_pl;
1467 	int err, i;
1468 
1469 	smid_pl = kmalloc(MLXSW_REG_SMID_LEN, GFP_KERNEL);
1470 	if (!smid_pl)
1471 		return -ENOMEM;
1472 
1473 	mlxsw_reg_smid_pack(smid_pl, mid_idx, 0, false);
1474 	for (i = 1; i < mlxsw_core_max_ports(mlxsw_sp->core); i++) {
1475 		if (mlxsw_sp->ports[i])
1476 			mlxsw_reg_smid_port_mask_set(smid_pl, i, 1);
1477 	}
1478 
1479 	mlxsw_reg_smid_port_mask_set(smid_pl,
1480 				     mlxsw_sp_router_port(mlxsw_sp), 1);
1481 
1482 	for_each_set_bit(i, ports_bitmap, mlxsw_core_max_ports(mlxsw_sp->core))
1483 		mlxsw_reg_smid_port_set(smid_pl, i, 1);
1484 
1485 	mlxsw_reg_smid_port_set(smid_pl, mlxsw_sp_router_port(mlxsw_sp),
1486 				set_router_port);
1487 
1488 	err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(smid), smid_pl);
1489 	kfree(smid_pl);
1490 	return err;
1491 }
1492 
1493 static int mlxsw_sp_port_smid_set(struct mlxsw_sp_port *mlxsw_sp_port,
1494 				  u16 mid_idx, bool add)
1495 {
1496 	struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
1497 	char *smid_pl;
1498 	int err;
1499 
1500 	smid_pl = kmalloc(MLXSW_REG_SMID_LEN, GFP_KERNEL);
1501 	if (!smid_pl)
1502 		return -ENOMEM;
1503 
1504 	mlxsw_reg_smid_pack(smid_pl, mid_idx, mlxsw_sp_port->local_port, add);
1505 	err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(smid), smid_pl);
1506 	kfree(smid_pl);
1507 	return err;
1508 }
1509 
1510 static struct
1511 mlxsw_sp_mid *__mlxsw_sp_mc_get(struct mlxsw_sp_bridge_device *bridge_device,
1512 				const unsigned char *addr,
1513 				u16 fid)
1514 {
1515 	struct mlxsw_sp_mid *mid;
1516 
1517 	list_for_each_entry(mid, &bridge_device->mids_list, list) {
1518 		if (ether_addr_equal(mid->addr, addr) && mid->fid == fid)
1519 			return mid;
1520 	}
1521 	return NULL;
1522 }
1523 
1524 static void
1525 mlxsw_sp_bridge_port_get_ports_bitmap(struct mlxsw_sp *mlxsw_sp,
1526 				      struct mlxsw_sp_bridge_port *bridge_port,
1527 				      unsigned long *ports_bitmap)
1528 {
1529 	struct mlxsw_sp_port *mlxsw_sp_port;
1530 	u64 max_lag_members, i;
1531 	int lag_id;
1532 
1533 	if (!bridge_port->lagged) {
1534 		set_bit(bridge_port->system_port, ports_bitmap);
1535 	} else {
1536 		max_lag_members = MLXSW_CORE_RES_GET(mlxsw_sp->core,
1537 						     MAX_LAG_MEMBERS);
1538 		lag_id = bridge_port->lag_id;
1539 		for (i = 0; i < max_lag_members; i++) {
1540 			mlxsw_sp_port = mlxsw_sp_port_lagged_get(mlxsw_sp,
1541 								 lag_id, i);
1542 			if (mlxsw_sp_port)
1543 				set_bit(mlxsw_sp_port->local_port,
1544 					ports_bitmap);
1545 		}
1546 	}
1547 }
1548 
1549 static void
1550 mlxsw_sp_mc_get_mrouters_bitmap(unsigned long *flood_bitmap,
1551 				struct mlxsw_sp_bridge_device *bridge_device,
1552 				struct mlxsw_sp *mlxsw_sp)
1553 {
1554 	struct mlxsw_sp_bridge_port *bridge_port;
1555 
1556 	list_for_each_entry(bridge_port, &bridge_device->ports_list, list) {
1557 		if (bridge_port->mrouter) {
1558 			mlxsw_sp_bridge_port_get_ports_bitmap(mlxsw_sp,
1559 							      bridge_port,
1560 							      flood_bitmap);
1561 		}
1562 	}
1563 }
1564 
1565 static bool
1566 mlxsw_sp_mc_write_mdb_entry(struct mlxsw_sp *mlxsw_sp,
1567 			    struct mlxsw_sp_mid *mid,
1568 			    struct mlxsw_sp_bridge_device *bridge_device)
1569 {
1570 	long *flood_bitmap;
1571 	int num_of_ports;
1572 	int alloc_size;
1573 	u16 mid_idx;
1574 	int err;
1575 
1576 	mid_idx = find_first_zero_bit(mlxsw_sp->bridge->mids_bitmap,
1577 				      MLXSW_SP_MID_MAX);
1578 	if (mid_idx == MLXSW_SP_MID_MAX)
1579 		return false;
1580 
1581 	num_of_ports = mlxsw_core_max_ports(mlxsw_sp->core);
1582 	alloc_size = sizeof(long) * BITS_TO_LONGS(num_of_ports);
1583 	flood_bitmap = kzalloc(alloc_size, GFP_KERNEL);
1584 	if (!flood_bitmap)
1585 		return false;
1586 
1587 	bitmap_copy(flood_bitmap,  mid->ports_in_mid, num_of_ports);
1588 	mlxsw_sp_mc_get_mrouters_bitmap(flood_bitmap, bridge_device, mlxsw_sp);
1589 
1590 	mid->mid = mid_idx;
1591 	err = mlxsw_sp_port_smid_full_entry(mlxsw_sp, mid_idx, flood_bitmap,
1592 					    bridge_device->mrouter);
1593 	kfree(flood_bitmap);
1594 	if (err)
1595 		return false;
1596 
1597 	err = mlxsw_sp_port_mdb_op(mlxsw_sp, mid->addr, mid->fid, mid_idx,
1598 				   true);
1599 	if (err)
1600 		return false;
1601 
1602 	set_bit(mid_idx, mlxsw_sp->bridge->mids_bitmap);
1603 	mid->in_hw = true;
1604 	return true;
1605 }
1606 
1607 static int mlxsw_sp_mc_remove_mdb_entry(struct mlxsw_sp *mlxsw_sp,
1608 					struct mlxsw_sp_mid *mid)
1609 {
1610 	if (!mid->in_hw)
1611 		return 0;
1612 
1613 	clear_bit(mid->mid, mlxsw_sp->bridge->mids_bitmap);
1614 	mid->in_hw = false;
1615 	return mlxsw_sp_port_mdb_op(mlxsw_sp, mid->addr, mid->fid, mid->mid,
1616 				    false);
1617 }
1618 
1619 static struct
1620 mlxsw_sp_mid *__mlxsw_sp_mc_alloc(struct mlxsw_sp *mlxsw_sp,
1621 				  struct mlxsw_sp_bridge_device *bridge_device,
1622 				  const unsigned char *addr,
1623 				  u16 fid)
1624 {
1625 	struct mlxsw_sp_mid *mid;
1626 	size_t alloc_size;
1627 
1628 	mid = kzalloc(sizeof(*mid), GFP_KERNEL);
1629 	if (!mid)
1630 		return NULL;
1631 
1632 	alloc_size = sizeof(unsigned long) *
1633 		     BITS_TO_LONGS(mlxsw_core_max_ports(mlxsw_sp->core));
1634 
1635 	mid->ports_in_mid = kzalloc(alloc_size, GFP_KERNEL);
1636 	if (!mid->ports_in_mid)
1637 		goto err_ports_in_mid_alloc;
1638 
1639 	ether_addr_copy(mid->addr, addr);
1640 	mid->fid = fid;
1641 	mid->in_hw = false;
1642 
1643 	if (!bridge_device->multicast_enabled)
1644 		goto out;
1645 
1646 	if (!mlxsw_sp_mc_write_mdb_entry(mlxsw_sp, mid, bridge_device))
1647 		goto err_write_mdb_entry;
1648 
1649 out:
1650 	list_add_tail(&mid->list, &bridge_device->mids_list);
1651 	return mid;
1652 
1653 err_write_mdb_entry:
1654 	kfree(mid->ports_in_mid);
1655 err_ports_in_mid_alloc:
1656 	kfree(mid);
1657 	return NULL;
1658 }
1659 
1660 static int mlxsw_sp_port_remove_from_mid(struct mlxsw_sp_port *mlxsw_sp_port,
1661 					 struct mlxsw_sp_mid *mid)
1662 {
1663 	struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
1664 	int err = 0;
1665 
1666 	clear_bit(mlxsw_sp_port->local_port, mid->ports_in_mid);
1667 	if (bitmap_empty(mid->ports_in_mid,
1668 			 mlxsw_core_max_ports(mlxsw_sp->core))) {
1669 		err = mlxsw_sp_mc_remove_mdb_entry(mlxsw_sp, mid);
1670 		list_del(&mid->list);
1671 		kfree(mid->ports_in_mid);
1672 		kfree(mid);
1673 	}
1674 	return err;
1675 }
1676 
1677 static int mlxsw_sp_port_mdb_add(struct mlxsw_sp_port *mlxsw_sp_port,
1678 				 const struct switchdev_obj_port_mdb *mdb)
1679 {
1680 	struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
1681 	struct net_device *orig_dev = mdb->obj.orig_dev;
1682 	struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
1683 	struct net_device *dev = mlxsw_sp_port->dev;
1684 	struct mlxsw_sp_bridge_device *bridge_device;
1685 	struct mlxsw_sp_bridge_port *bridge_port;
1686 	struct mlxsw_sp_mid *mid;
1687 	u16 fid_index;
1688 	int err = 0;
1689 
1690 	bridge_port = mlxsw_sp_bridge_port_find(mlxsw_sp->bridge, orig_dev);
1691 	if (!bridge_port)
1692 		return 0;
1693 
1694 	bridge_device = bridge_port->bridge_device;
1695 	mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_bridge(mlxsw_sp_port,
1696 							       bridge_device,
1697 							       mdb->vid);
1698 	if (!mlxsw_sp_port_vlan)
1699 		return 0;
1700 
1701 	fid_index = mlxsw_sp_fid_index(mlxsw_sp_port_vlan->fid);
1702 
1703 	mid = __mlxsw_sp_mc_get(bridge_device, mdb->addr, fid_index);
1704 	if (!mid) {
1705 		mid = __mlxsw_sp_mc_alloc(mlxsw_sp, bridge_device, mdb->addr,
1706 					  fid_index);
1707 		if (!mid) {
1708 			netdev_err(dev, "Unable to allocate MC group\n");
1709 			return -ENOMEM;
1710 		}
1711 	}
1712 	set_bit(mlxsw_sp_port->local_port, mid->ports_in_mid);
1713 
1714 	if (!bridge_device->multicast_enabled)
1715 		return 0;
1716 
1717 	if (bridge_port->mrouter)
1718 		return 0;
1719 
1720 	err = mlxsw_sp_port_smid_set(mlxsw_sp_port, mid->mid, true);
1721 	if (err) {
1722 		netdev_err(dev, "Unable to set SMID\n");
1723 		goto err_out;
1724 	}
1725 
1726 	return 0;
1727 
1728 err_out:
1729 	mlxsw_sp_port_remove_from_mid(mlxsw_sp_port, mid);
1730 	return err;
1731 }
1732 
1733 static void
1734 mlxsw_sp_bridge_mdb_mc_enable_sync(struct mlxsw_sp_port *mlxsw_sp_port,
1735 				   struct mlxsw_sp_bridge_device
1736 				   *bridge_device)
1737 {
1738 	struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
1739 	struct mlxsw_sp_mid *mid;
1740 	bool mc_enabled;
1741 
1742 	mc_enabled = bridge_device->multicast_enabled;
1743 
1744 	list_for_each_entry(mid, &bridge_device->mids_list, list) {
1745 		if (mc_enabled)
1746 			mlxsw_sp_mc_write_mdb_entry(mlxsw_sp, mid,
1747 						    bridge_device);
1748 		else
1749 			mlxsw_sp_mc_remove_mdb_entry(mlxsw_sp, mid);
1750 	}
1751 }
1752 
1753 static void
1754 mlxsw_sp_port_mrouter_update_mdb(struct mlxsw_sp_port *mlxsw_sp_port,
1755 				 struct mlxsw_sp_bridge_port *bridge_port,
1756 				 bool add)
1757 {
1758 	struct mlxsw_sp_bridge_device *bridge_device;
1759 	struct mlxsw_sp_mid *mid;
1760 
1761 	bridge_device = bridge_port->bridge_device;
1762 
1763 	list_for_each_entry(mid, &bridge_device->mids_list, list) {
1764 		if (!test_bit(mlxsw_sp_port->local_port, mid->ports_in_mid))
1765 			mlxsw_sp_port_smid_set(mlxsw_sp_port, mid->mid, add);
1766 	}
1767 }
1768 
1769 static int mlxsw_sp_port_obj_add(struct net_device *dev,
1770 				 const struct switchdev_obj *obj,
1771 				 struct netlink_ext_ack *extack)
1772 {
1773 	struct mlxsw_sp_port *mlxsw_sp_port = netdev_priv(dev);
1774 	const struct switchdev_obj_port_vlan *vlan;
1775 	int err = 0;
1776 
1777 	switch (obj->id) {
1778 	case SWITCHDEV_OBJ_ID_PORT_VLAN:
1779 		vlan = SWITCHDEV_OBJ_PORT_VLAN(obj);
1780 
1781 		err = mlxsw_sp_port_vlans_add(mlxsw_sp_port, vlan, extack);
1782 
1783 		/* The event is emitted before the changes are actually
1784 		 * applied to the bridge. Therefore schedule the respin
1785 		 * call for later, so that the respin logic sees the
1786 		 * updated bridge state.
1787 		 */
1788 		mlxsw_sp_span_respin(mlxsw_sp_port->mlxsw_sp);
1789 		break;
1790 	case SWITCHDEV_OBJ_ID_PORT_MDB:
1791 		err = mlxsw_sp_port_mdb_add(mlxsw_sp_port,
1792 					    SWITCHDEV_OBJ_PORT_MDB(obj));
1793 		break;
1794 	default:
1795 		err = -EOPNOTSUPP;
1796 		break;
1797 	}
1798 
1799 	return err;
1800 }
1801 
1802 static void
1803 mlxsw_sp_bridge_port_vlan_del(struct mlxsw_sp_port *mlxsw_sp_port,
1804 			      struct mlxsw_sp_bridge_port *bridge_port, u16 vid)
1805 {
1806 	u16 pvid = mlxsw_sp_port->pvid == vid ? 0 : mlxsw_sp_port->pvid;
1807 	struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
1808 	u16 proto;
1809 
1810 	mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_vid(mlxsw_sp_port, vid);
1811 	if (WARN_ON(!mlxsw_sp_port_vlan))
1812 		return;
1813 
1814 	mlxsw_sp_port_vlan_bridge_leave(mlxsw_sp_port_vlan);
1815 	br_vlan_get_proto(bridge_port->bridge_device->dev, &proto);
1816 	mlxsw_sp_port_pvid_set(mlxsw_sp_port, pvid, proto);
1817 	mlxsw_sp_port_vlan_set(mlxsw_sp_port, vid, vid, false, false);
1818 	mlxsw_sp_port_vlan_destroy(mlxsw_sp_port_vlan);
1819 }
1820 
1821 static int mlxsw_sp_port_vlans_del(struct mlxsw_sp_port *mlxsw_sp_port,
1822 				   const struct switchdev_obj_port_vlan *vlan)
1823 {
1824 	struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
1825 	struct net_device *orig_dev = vlan->obj.orig_dev;
1826 	struct mlxsw_sp_bridge_port *bridge_port;
1827 
1828 	if (netif_is_bridge_master(orig_dev))
1829 		return -EOPNOTSUPP;
1830 
1831 	bridge_port = mlxsw_sp_bridge_port_find(mlxsw_sp->bridge, orig_dev);
1832 	if (WARN_ON(!bridge_port))
1833 		return -EINVAL;
1834 
1835 	if (!bridge_port->bridge_device->vlan_enabled)
1836 		return 0;
1837 
1838 	mlxsw_sp_bridge_port_vlan_del(mlxsw_sp_port, bridge_port, vlan->vid);
1839 
1840 	return 0;
1841 }
1842 
1843 static int
1844 __mlxsw_sp_port_mdb_del(struct mlxsw_sp_port *mlxsw_sp_port,
1845 			struct mlxsw_sp_bridge_port *bridge_port,
1846 			struct mlxsw_sp_mid *mid)
1847 {
1848 	struct net_device *dev = mlxsw_sp_port->dev;
1849 	int err;
1850 
1851 	if (bridge_port->bridge_device->multicast_enabled &&
1852 	    !bridge_port->mrouter) {
1853 		err = mlxsw_sp_port_smid_set(mlxsw_sp_port, mid->mid, false);
1854 		if (err)
1855 			netdev_err(dev, "Unable to remove port from SMID\n");
1856 	}
1857 
1858 	err = mlxsw_sp_port_remove_from_mid(mlxsw_sp_port, mid);
1859 	if (err)
1860 		netdev_err(dev, "Unable to remove MC SFD\n");
1861 
1862 	return err;
1863 }
1864 
1865 static int mlxsw_sp_port_mdb_del(struct mlxsw_sp_port *mlxsw_sp_port,
1866 				 const struct switchdev_obj_port_mdb *mdb)
1867 {
1868 	struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
1869 	struct net_device *orig_dev = mdb->obj.orig_dev;
1870 	struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
1871 	struct mlxsw_sp_bridge_device *bridge_device;
1872 	struct net_device *dev = mlxsw_sp_port->dev;
1873 	struct mlxsw_sp_bridge_port *bridge_port;
1874 	struct mlxsw_sp_mid *mid;
1875 	u16 fid_index;
1876 
1877 	bridge_port = mlxsw_sp_bridge_port_find(mlxsw_sp->bridge, orig_dev);
1878 	if (!bridge_port)
1879 		return 0;
1880 
1881 	bridge_device = bridge_port->bridge_device;
1882 	mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_bridge(mlxsw_sp_port,
1883 							       bridge_device,
1884 							       mdb->vid);
1885 	if (!mlxsw_sp_port_vlan)
1886 		return 0;
1887 
1888 	fid_index = mlxsw_sp_fid_index(mlxsw_sp_port_vlan->fid);
1889 
1890 	mid = __mlxsw_sp_mc_get(bridge_device, mdb->addr, fid_index);
1891 	if (!mid) {
1892 		netdev_err(dev, "Unable to remove port from MC DB\n");
1893 		return -EINVAL;
1894 	}
1895 
1896 	return __mlxsw_sp_port_mdb_del(mlxsw_sp_port, bridge_port, mid);
1897 }
1898 
1899 static void
1900 mlxsw_sp_bridge_port_mdb_flush(struct mlxsw_sp_port *mlxsw_sp_port,
1901 			       struct mlxsw_sp_bridge_port *bridge_port)
1902 {
1903 	struct mlxsw_sp_bridge_device *bridge_device;
1904 	struct mlxsw_sp_mid *mid, *tmp;
1905 
1906 	bridge_device = bridge_port->bridge_device;
1907 
1908 	list_for_each_entry_safe(mid, tmp, &bridge_device->mids_list, list) {
1909 		if (test_bit(mlxsw_sp_port->local_port, mid->ports_in_mid)) {
1910 			__mlxsw_sp_port_mdb_del(mlxsw_sp_port, bridge_port,
1911 						mid);
1912 		} else if (bridge_device->multicast_enabled &&
1913 			   bridge_port->mrouter) {
1914 			mlxsw_sp_port_smid_set(mlxsw_sp_port, mid->mid, false);
1915 		}
1916 	}
1917 }
1918 
1919 static int mlxsw_sp_port_obj_del(struct net_device *dev,
1920 				 const struct switchdev_obj *obj)
1921 {
1922 	struct mlxsw_sp_port *mlxsw_sp_port = netdev_priv(dev);
1923 	int err = 0;
1924 
1925 	switch (obj->id) {
1926 	case SWITCHDEV_OBJ_ID_PORT_VLAN:
1927 		err = mlxsw_sp_port_vlans_del(mlxsw_sp_port,
1928 					      SWITCHDEV_OBJ_PORT_VLAN(obj));
1929 		break;
1930 	case SWITCHDEV_OBJ_ID_PORT_MDB:
1931 		err = mlxsw_sp_port_mdb_del(mlxsw_sp_port,
1932 					    SWITCHDEV_OBJ_PORT_MDB(obj));
1933 		break;
1934 	default:
1935 		err = -EOPNOTSUPP;
1936 		break;
1937 	}
1938 
1939 	mlxsw_sp_span_respin(mlxsw_sp_port->mlxsw_sp);
1940 
1941 	return err;
1942 }
1943 
1944 static struct mlxsw_sp_port *mlxsw_sp_lag_rep_port(struct mlxsw_sp *mlxsw_sp,
1945 						   u16 lag_id)
1946 {
1947 	struct mlxsw_sp_port *mlxsw_sp_port;
1948 	u64 max_lag_members;
1949 	int i;
1950 
1951 	max_lag_members = MLXSW_CORE_RES_GET(mlxsw_sp->core,
1952 					     MAX_LAG_MEMBERS);
1953 	for (i = 0; i < max_lag_members; i++) {
1954 		mlxsw_sp_port = mlxsw_sp_port_lagged_get(mlxsw_sp, lag_id, i);
1955 		if (mlxsw_sp_port)
1956 			return mlxsw_sp_port;
1957 	}
1958 	return NULL;
1959 }
1960 
1961 static int
1962 mlxsw_sp_bridge_vlan_aware_port_join(struct mlxsw_sp_bridge_port *bridge_port,
1963 				     struct mlxsw_sp_port *mlxsw_sp_port,
1964 				     struct netlink_ext_ack *extack)
1965 {
1966 	if (is_vlan_dev(bridge_port->dev)) {
1967 		NL_SET_ERR_MSG_MOD(extack, "Can not enslave a VLAN device to a VLAN-aware bridge");
1968 		return -EINVAL;
1969 	}
1970 
1971 	/* Port is no longer usable as a router interface */
1972 	if (mlxsw_sp_port->default_vlan->fid)
1973 		mlxsw_sp_port_vlan_router_leave(mlxsw_sp_port->default_vlan);
1974 
1975 	return 0;
1976 }
1977 
1978 static int
1979 mlxsw_sp_bridge_8021q_port_join(struct mlxsw_sp_bridge_device *bridge_device,
1980 				struct mlxsw_sp_bridge_port *bridge_port,
1981 				struct mlxsw_sp_port *mlxsw_sp_port,
1982 				struct netlink_ext_ack *extack)
1983 {
1984 	return mlxsw_sp_bridge_vlan_aware_port_join(bridge_port, mlxsw_sp_port,
1985 						    extack);
1986 }
1987 
1988 static void
1989 mlxsw_sp_bridge_vlan_aware_port_leave(struct mlxsw_sp_port *mlxsw_sp_port)
1990 {
1991 	/* Make sure untagged frames are allowed to ingress */
1992 	mlxsw_sp_port_pvid_set(mlxsw_sp_port, MLXSW_SP_DEFAULT_VID,
1993 			       ETH_P_8021Q);
1994 }
1995 
1996 static void
1997 mlxsw_sp_bridge_8021q_port_leave(struct mlxsw_sp_bridge_device *bridge_device,
1998 				 struct mlxsw_sp_bridge_port *bridge_port,
1999 				 struct mlxsw_sp_port *mlxsw_sp_port)
2000 {
2001 	mlxsw_sp_bridge_vlan_aware_port_leave(mlxsw_sp_port);
2002 }
2003 
2004 static int
2005 mlxsw_sp_bridge_vlan_aware_vxlan_join(struct mlxsw_sp_bridge_device *bridge_device,
2006 				      const struct net_device *vxlan_dev,
2007 				      u16 vid, u16 ethertype,
2008 				      struct netlink_ext_ack *extack)
2009 {
2010 	struct mlxsw_sp *mlxsw_sp = mlxsw_sp_lower_get(bridge_device->dev);
2011 	struct vxlan_dev *vxlan = netdev_priv(vxlan_dev);
2012 	struct mlxsw_sp_nve_params params = {
2013 		.type = MLXSW_SP_NVE_TYPE_VXLAN,
2014 		.vni = vxlan->cfg.vni,
2015 		.dev = vxlan_dev,
2016 		.ethertype = ethertype,
2017 	};
2018 	struct mlxsw_sp_fid *fid;
2019 	int err;
2020 
2021 	/* If the VLAN is 0, we need to find the VLAN that is configured as
2022 	 * PVID and egress untagged on the bridge port of the VxLAN device.
2023 	 * It is possible no such VLAN exists
2024 	 */
2025 	if (!vid) {
2026 		err = mlxsw_sp_vxlan_mapped_vid(vxlan_dev, &vid);
2027 		if (err || !vid)
2028 			return err;
2029 	}
2030 
2031 	fid = mlxsw_sp_fid_8021q_get(mlxsw_sp, vid);
2032 	if (IS_ERR(fid)) {
2033 		NL_SET_ERR_MSG_MOD(extack, "Failed to create 802.1Q FID");
2034 		return PTR_ERR(fid);
2035 	}
2036 
2037 	if (mlxsw_sp_fid_vni_is_set(fid)) {
2038 		NL_SET_ERR_MSG_MOD(extack, "VNI is already set on FID");
2039 		err = -EINVAL;
2040 		goto err_vni_exists;
2041 	}
2042 
2043 	err = mlxsw_sp_nve_fid_enable(mlxsw_sp, fid, &params, extack);
2044 	if (err)
2045 		goto err_nve_fid_enable;
2046 
2047 	return 0;
2048 
2049 err_nve_fid_enable:
2050 err_vni_exists:
2051 	mlxsw_sp_fid_put(fid);
2052 	return err;
2053 }
2054 
2055 static int
2056 mlxsw_sp_bridge_8021q_vxlan_join(struct mlxsw_sp_bridge_device *bridge_device,
2057 				 const struct net_device *vxlan_dev, u16 vid,
2058 				 struct netlink_ext_ack *extack)
2059 {
2060 	return mlxsw_sp_bridge_vlan_aware_vxlan_join(bridge_device, vxlan_dev,
2061 						     vid, ETH_P_8021Q, extack);
2062 }
2063 
2064 static struct net_device *
2065 mlxsw_sp_bridge_8021q_vxlan_dev_find(struct net_device *br_dev, u16 vid)
2066 {
2067 	struct net_device *dev;
2068 	struct list_head *iter;
2069 
2070 	netdev_for_each_lower_dev(br_dev, dev, iter) {
2071 		u16 pvid;
2072 		int err;
2073 
2074 		if (!netif_is_vxlan(dev))
2075 			continue;
2076 
2077 		err = mlxsw_sp_vxlan_mapped_vid(dev, &pvid);
2078 		if (err || pvid != vid)
2079 			continue;
2080 
2081 		return dev;
2082 	}
2083 
2084 	return NULL;
2085 }
2086 
2087 static struct mlxsw_sp_fid *
2088 mlxsw_sp_bridge_8021q_fid_get(struct mlxsw_sp_bridge_device *bridge_device,
2089 			      u16 vid, struct netlink_ext_ack *extack)
2090 {
2091 	struct mlxsw_sp *mlxsw_sp = mlxsw_sp_lower_get(bridge_device->dev);
2092 
2093 	return mlxsw_sp_fid_8021q_get(mlxsw_sp, vid);
2094 }
2095 
2096 static struct mlxsw_sp_fid *
2097 mlxsw_sp_bridge_8021q_fid_lookup(struct mlxsw_sp_bridge_device *bridge_device,
2098 				 u16 vid)
2099 {
2100 	struct mlxsw_sp *mlxsw_sp = mlxsw_sp_lower_get(bridge_device->dev);
2101 
2102 	return mlxsw_sp_fid_8021q_lookup(mlxsw_sp, vid);
2103 }
2104 
2105 static u16
2106 mlxsw_sp_bridge_8021q_fid_vid(struct mlxsw_sp_bridge_device *bridge_device,
2107 			      const struct mlxsw_sp_fid *fid)
2108 {
2109 	return mlxsw_sp_fid_8021q_vid(fid);
2110 }
2111 
2112 static const struct mlxsw_sp_bridge_ops mlxsw_sp_bridge_8021q_ops = {
2113 	.port_join	= mlxsw_sp_bridge_8021q_port_join,
2114 	.port_leave	= mlxsw_sp_bridge_8021q_port_leave,
2115 	.vxlan_join	= mlxsw_sp_bridge_8021q_vxlan_join,
2116 	.fid_get	= mlxsw_sp_bridge_8021q_fid_get,
2117 	.fid_lookup	= mlxsw_sp_bridge_8021q_fid_lookup,
2118 	.fid_vid	= mlxsw_sp_bridge_8021q_fid_vid,
2119 };
2120 
2121 static bool
2122 mlxsw_sp_port_is_br_member(const struct mlxsw_sp_port *mlxsw_sp_port,
2123 			   const struct net_device *br_dev)
2124 {
2125 	struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
2126 
2127 	list_for_each_entry(mlxsw_sp_port_vlan, &mlxsw_sp_port->vlans_list,
2128 			    list) {
2129 		if (mlxsw_sp_port_vlan->bridge_port &&
2130 		    mlxsw_sp_port_vlan->bridge_port->bridge_device->dev ==
2131 		    br_dev)
2132 			return true;
2133 	}
2134 
2135 	return false;
2136 }
2137 
2138 static int
2139 mlxsw_sp_bridge_8021d_port_join(struct mlxsw_sp_bridge_device *bridge_device,
2140 				struct mlxsw_sp_bridge_port *bridge_port,
2141 				struct mlxsw_sp_port *mlxsw_sp_port,
2142 				struct netlink_ext_ack *extack)
2143 {
2144 	struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
2145 	struct net_device *dev = bridge_port->dev;
2146 	u16 vid;
2147 
2148 	vid = is_vlan_dev(dev) ? vlan_dev_vlan_id(dev) : MLXSW_SP_DEFAULT_VID;
2149 	mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_vid(mlxsw_sp_port, vid);
2150 	if (WARN_ON(!mlxsw_sp_port_vlan))
2151 		return -EINVAL;
2152 
2153 	if (mlxsw_sp_port_is_br_member(mlxsw_sp_port, bridge_device->dev)) {
2154 		NL_SET_ERR_MSG_MOD(extack, "Can not bridge VLAN uppers of the same port");
2155 		return -EINVAL;
2156 	}
2157 
2158 	/* Port is no longer usable as a router interface */
2159 	if (mlxsw_sp_port_vlan->fid)
2160 		mlxsw_sp_port_vlan_router_leave(mlxsw_sp_port_vlan);
2161 
2162 	return mlxsw_sp_port_vlan_bridge_join(mlxsw_sp_port_vlan, bridge_port,
2163 					      extack);
2164 }
2165 
2166 static void
2167 mlxsw_sp_bridge_8021d_port_leave(struct mlxsw_sp_bridge_device *bridge_device,
2168 				 struct mlxsw_sp_bridge_port *bridge_port,
2169 				 struct mlxsw_sp_port *mlxsw_sp_port)
2170 {
2171 	struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
2172 	struct net_device *dev = bridge_port->dev;
2173 	u16 vid;
2174 
2175 	vid = is_vlan_dev(dev) ? vlan_dev_vlan_id(dev) : MLXSW_SP_DEFAULT_VID;
2176 	mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_vid(mlxsw_sp_port, vid);
2177 	if (!mlxsw_sp_port_vlan || !mlxsw_sp_port_vlan->bridge_port)
2178 		return;
2179 
2180 	mlxsw_sp_port_vlan_bridge_leave(mlxsw_sp_port_vlan);
2181 }
2182 
2183 static int
2184 mlxsw_sp_bridge_8021d_vxlan_join(struct mlxsw_sp_bridge_device *bridge_device,
2185 				 const struct net_device *vxlan_dev, u16 vid,
2186 				 struct netlink_ext_ack *extack)
2187 {
2188 	struct mlxsw_sp *mlxsw_sp = mlxsw_sp_lower_get(bridge_device->dev);
2189 	struct vxlan_dev *vxlan = netdev_priv(vxlan_dev);
2190 	struct mlxsw_sp_nve_params params = {
2191 		.type = MLXSW_SP_NVE_TYPE_VXLAN,
2192 		.vni = vxlan->cfg.vni,
2193 		.dev = vxlan_dev,
2194 		.ethertype = ETH_P_8021Q,
2195 	};
2196 	struct mlxsw_sp_fid *fid;
2197 	int err;
2198 
2199 	fid = mlxsw_sp_fid_8021d_get(mlxsw_sp, bridge_device->dev->ifindex);
2200 	if (IS_ERR(fid)) {
2201 		NL_SET_ERR_MSG_MOD(extack, "Failed to create 802.1D FID");
2202 		return -EINVAL;
2203 	}
2204 
2205 	if (mlxsw_sp_fid_vni_is_set(fid)) {
2206 		NL_SET_ERR_MSG_MOD(extack, "VNI is already set on FID");
2207 		err = -EINVAL;
2208 		goto err_vni_exists;
2209 	}
2210 
2211 	err = mlxsw_sp_nve_fid_enable(mlxsw_sp, fid, &params, extack);
2212 	if (err)
2213 		goto err_nve_fid_enable;
2214 
2215 	return 0;
2216 
2217 err_nve_fid_enable:
2218 err_vni_exists:
2219 	mlxsw_sp_fid_put(fid);
2220 	return err;
2221 }
2222 
2223 static struct mlxsw_sp_fid *
2224 mlxsw_sp_bridge_8021d_fid_get(struct mlxsw_sp_bridge_device *bridge_device,
2225 			      u16 vid, struct netlink_ext_ack *extack)
2226 {
2227 	struct mlxsw_sp *mlxsw_sp = mlxsw_sp_lower_get(bridge_device->dev);
2228 
2229 	return mlxsw_sp_fid_8021d_get(mlxsw_sp, bridge_device->dev->ifindex);
2230 }
2231 
2232 static struct mlxsw_sp_fid *
2233 mlxsw_sp_bridge_8021d_fid_lookup(struct mlxsw_sp_bridge_device *bridge_device,
2234 				 u16 vid)
2235 {
2236 	struct mlxsw_sp *mlxsw_sp = mlxsw_sp_lower_get(bridge_device->dev);
2237 
2238 	/* The only valid VLAN for a VLAN-unaware bridge is 0 */
2239 	if (vid)
2240 		return NULL;
2241 
2242 	return mlxsw_sp_fid_8021d_lookup(mlxsw_sp, bridge_device->dev->ifindex);
2243 }
2244 
2245 static u16
2246 mlxsw_sp_bridge_8021d_fid_vid(struct mlxsw_sp_bridge_device *bridge_device,
2247 			      const struct mlxsw_sp_fid *fid)
2248 {
2249 	return 0;
2250 }
2251 
2252 static const struct mlxsw_sp_bridge_ops mlxsw_sp_bridge_8021d_ops = {
2253 	.port_join	= mlxsw_sp_bridge_8021d_port_join,
2254 	.port_leave	= mlxsw_sp_bridge_8021d_port_leave,
2255 	.vxlan_join	= mlxsw_sp_bridge_8021d_vxlan_join,
2256 	.fid_get	= mlxsw_sp_bridge_8021d_fid_get,
2257 	.fid_lookup	= mlxsw_sp_bridge_8021d_fid_lookup,
2258 	.fid_vid	= mlxsw_sp_bridge_8021d_fid_vid,
2259 };
2260 
2261 static int
2262 mlxsw_sp_bridge_8021ad_port_join(struct mlxsw_sp_bridge_device *bridge_device,
2263 				 struct mlxsw_sp_bridge_port *bridge_port,
2264 				 struct mlxsw_sp_port *mlxsw_sp_port,
2265 				 struct netlink_ext_ack *extack)
2266 {
2267 	int err;
2268 
2269 	err = mlxsw_sp_port_vlan_classification_set(mlxsw_sp_port, true, false);
2270 	if (err)
2271 		return err;
2272 
2273 	err = mlxsw_sp_bridge_vlan_aware_port_join(bridge_port, mlxsw_sp_port,
2274 						   extack);
2275 	if (err)
2276 		goto err_bridge_vlan_aware_port_join;
2277 
2278 	return 0;
2279 
2280 err_bridge_vlan_aware_port_join:
2281 	mlxsw_sp_port_vlan_classification_set(mlxsw_sp_port, false, true);
2282 	return err;
2283 }
2284 
2285 static void
2286 mlxsw_sp_bridge_8021ad_port_leave(struct mlxsw_sp_bridge_device *bridge_device,
2287 				  struct mlxsw_sp_bridge_port *bridge_port,
2288 				  struct mlxsw_sp_port *mlxsw_sp_port)
2289 {
2290 	mlxsw_sp_bridge_vlan_aware_port_leave(mlxsw_sp_port);
2291 	mlxsw_sp_port_vlan_classification_set(mlxsw_sp_port, false, true);
2292 }
2293 
2294 static int
2295 mlxsw_sp_bridge_8021ad_vxlan_join(struct mlxsw_sp_bridge_device *bridge_device,
2296 				  const struct net_device *vxlan_dev, u16 vid,
2297 				  struct netlink_ext_ack *extack)
2298 {
2299 	return mlxsw_sp_bridge_vlan_aware_vxlan_join(bridge_device, vxlan_dev,
2300 						     vid, ETH_P_8021AD, extack);
2301 }
2302 
2303 static const struct mlxsw_sp_bridge_ops mlxsw_sp1_bridge_8021ad_ops = {
2304 	.port_join	= mlxsw_sp_bridge_8021ad_port_join,
2305 	.port_leave	= mlxsw_sp_bridge_8021ad_port_leave,
2306 	.vxlan_join	= mlxsw_sp_bridge_8021ad_vxlan_join,
2307 	.fid_get	= mlxsw_sp_bridge_8021q_fid_get,
2308 	.fid_lookup	= mlxsw_sp_bridge_8021q_fid_lookup,
2309 	.fid_vid	= mlxsw_sp_bridge_8021q_fid_vid,
2310 };
2311 
2312 static int
2313 mlxsw_sp2_bridge_8021ad_port_join(struct mlxsw_sp_bridge_device *bridge_device,
2314 				  struct mlxsw_sp_bridge_port *bridge_port,
2315 				  struct mlxsw_sp_port *mlxsw_sp_port,
2316 				  struct netlink_ext_ack *extack)
2317 {
2318 	int err;
2319 
2320 	/* The EtherType of decapsulated packets is determined at the egress
2321 	 * port to allow 802.1d and 802.1ad bridges with VXLAN devices to
2322 	 * co-exist.
2323 	 */
2324 	err = mlxsw_sp_port_egress_ethtype_set(mlxsw_sp_port, ETH_P_8021AD);
2325 	if (err)
2326 		return err;
2327 
2328 	err = mlxsw_sp_bridge_8021ad_port_join(bridge_device, bridge_port,
2329 					       mlxsw_sp_port, extack);
2330 	if (err)
2331 		goto err_bridge_8021ad_port_join;
2332 
2333 	return 0;
2334 
2335 err_bridge_8021ad_port_join:
2336 	mlxsw_sp_port_egress_ethtype_set(mlxsw_sp_port, ETH_P_8021Q);
2337 	return err;
2338 }
2339 
2340 static void
2341 mlxsw_sp2_bridge_8021ad_port_leave(struct mlxsw_sp_bridge_device *bridge_device,
2342 				   struct mlxsw_sp_bridge_port *bridge_port,
2343 				   struct mlxsw_sp_port *mlxsw_sp_port)
2344 {
2345 	mlxsw_sp_bridge_8021ad_port_leave(bridge_device, bridge_port,
2346 					  mlxsw_sp_port);
2347 	mlxsw_sp_port_egress_ethtype_set(mlxsw_sp_port, ETH_P_8021Q);
2348 }
2349 
2350 static const struct mlxsw_sp_bridge_ops mlxsw_sp2_bridge_8021ad_ops = {
2351 	.port_join	= mlxsw_sp2_bridge_8021ad_port_join,
2352 	.port_leave	= mlxsw_sp2_bridge_8021ad_port_leave,
2353 	.vxlan_join	= mlxsw_sp_bridge_8021ad_vxlan_join,
2354 	.fid_get	= mlxsw_sp_bridge_8021q_fid_get,
2355 	.fid_lookup	= mlxsw_sp_bridge_8021q_fid_lookup,
2356 	.fid_vid	= mlxsw_sp_bridge_8021q_fid_vid,
2357 };
2358 
2359 int mlxsw_sp_port_bridge_join(struct mlxsw_sp_port *mlxsw_sp_port,
2360 			      struct net_device *brport_dev,
2361 			      struct net_device *br_dev,
2362 			      struct netlink_ext_ack *extack)
2363 {
2364 	struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
2365 	struct mlxsw_sp_bridge_device *bridge_device;
2366 	struct mlxsw_sp_bridge_port *bridge_port;
2367 	int err;
2368 
2369 	bridge_port = mlxsw_sp_bridge_port_get(mlxsw_sp->bridge, brport_dev,
2370 					       extack);
2371 	if (IS_ERR(bridge_port))
2372 		return PTR_ERR(bridge_port);
2373 	bridge_device = bridge_port->bridge_device;
2374 
2375 	err = bridge_device->ops->port_join(bridge_device, bridge_port,
2376 					    mlxsw_sp_port, extack);
2377 	if (err)
2378 		goto err_port_join;
2379 
2380 	return 0;
2381 
2382 err_port_join:
2383 	mlxsw_sp_bridge_port_put(mlxsw_sp->bridge, bridge_port);
2384 	return err;
2385 }
2386 
2387 void mlxsw_sp_port_bridge_leave(struct mlxsw_sp_port *mlxsw_sp_port,
2388 				struct net_device *brport_dev,
2389 				struct net_device *br_dev)
2390 {
2391 	struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
2392 	struct mlxsw_sp_bridge_device *bridge_device;
2393 	struct mlxsw_sp_bridge_port *bridge_port;
2394 
2395 	bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, br_dev);
2396 	if (!bridge_device)
2397 		return;
2398 	bridge_port = __mlxsw_sp_bridge_port_find(bridge_device, brport_dev);
2399 	if (!bridge_port)
2400 		return;
2401 
2402 	bridge_device->ops->port_leave(bridge_device, bridge_port,
2403 				       mlxsw_sp_port);
2404 	mlxsw_sp_bridge_port_put(mlxsw_sp->bridge, bridge_port);
2405 }
2406 
2407 int mlxsw_sp_bridge_vxlan_join(struct mlxsw_sp *mlxsw_sp,
2408 			       const struct net_device *br_dev,
2409 			       const struct net_device *vxlan_dev, u16 vid,
2410 			       struct netlink_ext_ack *extack)
2411 {
2412 	struct mlxsw_sp_bridge_device *bridge_device;
2413 
2414 	bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, br_dev);
2415 	if (WARN_ON(!bridge_device))
2416 		return -EINVAL;
2417 
2418 	return bridge_device->ops->vxlan_join(bridge_device, vxlan_dev, vid,
2419 					      extack);
2420 }
2421 
2422 void mlxsw_sp_bridge_vxlan_leave(struct mlxsw_sp *mlxsw_sp,
2423 				 const struct net_device *vxlan_dev)
2424 {
2425 	struct vxlan_dev *vxlan = netdev_priv(vxlan_dev);
2426 	struct mlxsw_sp_fid *fid;
2427 
2428 	/* If the VxLAN device is down, then the FID does not have a VNI */
2429 	fid = mlxsw_sp_fid_lookup_by_vni(mlxsw_sp, vxlan->cfg.vni);
2430 	if (!fid)
2431 		return;
2432 
2433 	mlxsw_sp_nve_fid_disable(mlxsw_sp, fid);
2434 	/* Drop both the reference we just took during lookup and the reference
2435 	 * the VXLAN device took.
2436 	 */
2437 	mlxsw_sp_fid_put(fid);
2438 	mlxsw_sp_fid_put(fid);
2439 }
2440 
2441 static void
2442 mlxsw_sp_switchdev_vxlan_addr_convert(const union vxlan_addr *vxlan_addr,
2443 				      enum mlxsw_sp_l3proto *proto,
2444 				      union mlxsw_sp_l3addr *addr)
2445 {
2446 	if (vxlan_addr->sa.sa_family == AF_INET) {
2447 		addr->addr4 = vxlan_addr->sin.sin_addr.s_addr;
2448 		*proto = MLXSW_SP_L3_PROTO_IPV4;
2449 	} else {
2450 		addr->addr6 = vxlan_addr->sin6.sin6_addr;
2451 		*proto = MLXSW_SP_L3_PROTO_IPV6;
2452 	}
2453 }
2454 
2455 static void
2456 mlxsw_sp_switchdev_addr_vxlan_convert(enum mlxsw_sp_l3proto proto,
2457 				      const union mlxsw_sp_l3addr *addr,
2458 				      union vxlan_addr *vxlan_addr)
2459 {
2460 	switch (proto) {
2461 	case MLXSW_SP_L3_PROTO_IPV4:
2462 		vxlan_addr->sa.sa_family = AF_INET;
2463 		vxlan_addr->sin.sin_addr.s_addr = addr->addr4;
2464 		break;
2465 	case MLXSW_SP_L3_PROTO_IPV6:
2466 		vxlan_addr->sa.sa_family = AF_INET6;
2467 		vxlan_addr->sin6.sin6_addr = addr->addr6;
2468 		break;
2469 	}
2470 }
2471 
2472 static void mlxsw_sp_fdb_vxlan_call_notifiers(struct net_device *dev,
2473 					      const char *mac,
2474 					      enum mlxsw_sp_l3proto proto,
2475 					      union mlxsw_sp_l3addr *addr,
2476 					      __be32 vni, bool adding)
2477 {
2478 	struct switchdev_notifier_vxlan_fdb_info info;
2479 	struct vxlan_dev *vxlan = netdev_priv(dev);
2480 	enum switchdev_notifier_type type;
2481 
2482 	type = adding ? SWITCHDEV_VXLAN_FDB_ADD_TO_BRIDGE :
2483 			SWITCHDEV_VXLAN_FDB_DEL_TO_BRIDGE;
2484 	mlxsw_sp_switchdev_addr_vxlan_convert(proto, addr, &info.remote_ip);
2485 	info.remote_port = vxlan->cfg.dst_port;
2486 	info.remote_vni = vni;
2487 	info.remote_ifindex = 0;
2488 	ether_addr_copy(info.eth_addr, mac);
2489 	info.vni = vni;
2490 	info.offloaded = adding;
2491 	call_switchdev_notifiers(type, dev, &info.info, NULL);
2492 }
2493 
2494 static void mlxsw_sp_fdb_nve_call_notifiers(struct net_device *dev,
2495 					    const char *mac,
2496 					    enum mlxsw_sp_l3proto proto,
2497 					    union mlxsw_sp_l3addr *addr,
2498 					    __be32 vni,
2499 					    bool adding)
2500 {
2501 	if (netif_is_vxlan(dev))
2502 		mlxsw_sp_fdb_vxlan_call_notifiers(dev, mac, proto, addr, vni,
2503 						  adding);
2504 }
2505 
2506 static void
2507 mlxsw_sp_fdb_call_notifiers(enum switchdev_notifier_type type,
2508 			    const char *mac, u16 vid,
2509 			    struct net_device *dev, bool offloaded)
2510 {
2511 	struct switchdev_notifier_fdb_info info;
2512 
2513 	info.addr = mac;
2514 	info.vid = vid;
2515 	info.offloaded = offloaded;
2516 	call_switchdev_notifiers(type, dev, &info.info, NULL);
2517 }
2518 
2519 static void mlxsw_sp_fdb_notify_mac_process(struct mlxsw_sp *mlxsw_sp,
2520 					    char *sfn_pl, int rec_index,
2521 					    bool adding)
2522 {
2523 	struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
2524 	struct mlxsw_sp_bridge_device *bridge_device;
2525 	struct mlxsw_sp_bridge_port *bridge_port;
2526 	struct mlxsw_sp_port *mlxsw_sp_port;
2527 	enum switchdev_notifier_type type;
2528 	char mac[ETH_ALEN];
2529 	u8 local_port;
2530 	u16 vid, fid;
2531 	bool do_notification = true;
2532 	int err;
2533 
2534 	mlxsw_reg_sfn_mac_unpack(sfn_pl, rec_index, mac, &fid, &local_port);
2535 	mlxsw_sp_port = mlxsw_sp->ports[local_port];
2536 	if (!mlxsw_sp_port) {
2537 		dev_err_ratelimited(mlxsw_sp->bus_info->dev, "Incorrect local port in FDB notification\n");
2538 		goto just_remove;
2539 	}
2540 
2541 	if (mlxsw_sp_fid_is_dummy(mlxsw_sp, fid))
2542 		goto just_remove;
2543 
2544 	mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_fid(mlxsw_sp_port, fid);
2545 	if (!mlxsw_sp_port_vlan) {
2546 		netdev_err(mlxsw_sp_port->dev, "Failed to find a matching {Port, VID} following FDB notification\n");
2547 		goto just_remove;
2548 	}
2549 
2550 	bridge_port = mlxsw_sp_port_vlan->bridge_port;
2551 	if (!bridge_port) {
2552 		netdev_err(mlxsw_sp_port->dev, "{Port, VID} not associated with a bridge\n");
2553 		goto just_remove;
2554 	}
2555 
2556 	bridge_device = bridge_port->bridge_device;
2557 	vid = bridge_device->vlan_enabled ? mlxsw_sp_port_vlan->vid : 0;
2558 
2559 do_fdb_op:
2560 	err = mlxsw_sp_port_fdb_uc_op(mlxsw_sp, local_port, mac, fid,
2561 				      adding, true);
2562 	if (err) {
2563 		dev_err_ratelimited(mlxsw_sp->bus_info->dev, "Failed to set FDB entry\n");
2564 		return;
2565 	}
2566 
2567 	if (!do_notification)
2568 		return;
2569 	type = adding ? SWITCHDEV_FDB_ADD_TO_BRIDGE : SWITCHDEV_FDB_DEL_TO_BRIDGE;
2570 	mlxsw_sp_fdb_call_notifiers(type, mac, vid, bridge_port->dev, adding);
2571 
2572 	return;
2573 
2574 just_remove:
2575 	adding = false;
2576 	do_notification = false;
2577 	goto do_fdb_op;
2578 }
2579 
2580 static void mlxsw_sp_fdb_notify_mac_lag_process(struct mlxsw_sp *mlxsw_sp,
2581 						char *sfn_pl, int rec_index,
2582 						bool adding)
2583 {
2584 	struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
2585 	struct mlxsw_sp_bridge_device *bridge_device;
2586 	struct mlxsw_sp_bridge_port *bridge_port;
2587 	struct mlxsw_sp_port *mlxsw_sp_port;
2588 	enum switchdev_notifier_type type;
2589 	char mac[ETH_ALEN];
2590 	u16 lag_vid = 0;
2591 	u16 lag_id;
2592 	u16 vid, fid;
2593 	bool do_notification = true;
2594 	int err;
2595 
2596 	mlxsw_reg_sfn_mac_lag_unpack(sfn_pl, rec_index, mac, &fid, &lag_id);
2597 	mlxsw_sp_port = mlxsw_sp_lag_rep_port(mlxsw_sp, lag_id);
2598 	if (!mlxsw_sp_port) {
2599 		dev_err_ratelimited(mlxsw_sp->bus_info->dev, "Cannot find port representor for LAG\n");
2600 		goto just_remove;
2601 	}
2602 
2603 	if (mlxsw_sp_fid_is_dummy(mlxsw_sp, fid))
2604 		goto just_remove;
2605 
2606 	mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_fid(mlxsw_sp_port, fid);
2607 	if (!mlxsw_sp_port_vlan) {
2608 		netdev_err(mlxsw_sp_port->dev, "Failed to find a matching {Port, VID} following FDB notification\n");
2609 		goto just_remove;
2610 	}
2611 
2612 	bridge_port = mlxsw_sp_port_vlan->bridge_port;
2613 	if (!bridge_port) {
2614 		netdev_err(mlxsw_sp_port->dev, "{Port, VID} not associated with a bridge\n");
2615 		goto just_remove;
2616 	}
2617 
2618 	bridge_device = bridge_port->bridge_device;
2619 	vid = bridge_device->vlan_enabled ? mlxsw_sp_port_vlan->vid : 0;
2620 	lag_vid = mlxsw_sp_fid_lag_vid_valid(mlxsw_sp_port_vlan->fid) ?
2621 		  mlxsw_sp_port_vlan->vid : 0;
2622 
2623 do_fdb_op:
2624 	err = mlxsw_sp_port_fdb_uc_lag_op(mlxsw_sp, lag_id, mac, fid, lag_vid,
2625 					  adding, true);
2626 	if (err) {
2627 		dev_err_ratelimited(mlxsw_sp->bus_info->dev, "Failed to set FDB entry\n");
2628 		return;
2629 	}
2630 
2631 	if (!do_notification)
2632 		return;
2633 	type = adding ? SWITCHDEV_FDB_ADD_TO_BRIDGE : SWITCHDEV_FDB_DEL_TO_BRIDGE;
2634 	mlxsw_sp_fdb_call_notifiers(type, mac, vid, bridge_port->dev, adding);
2635 
2636 	return;
2637 
2638 just_remove:
2639 	adding = false;
2640 	do_notification = false;
2641 	goto do_fdb_op;
2642 }
2643 
2644 static int
2645 __mlxsw_sp_fdb_notify_mac_uc_tunnel_process(struct mlxsw_sp *mlxsw_sp,
2646 					    const struct mlxsw_sp_fid *fid,
2647 					    bool adding,
2648 					    struct net_device **nve_dev,
2649 					    u16 *p_vid, __be32 *p_vni)
2650 {
2651 	struct mlxsw_sp_bridge_device *bridge_device;
2652 	struct net_device *br_dev, *dev;
2653 	int nve_ifindex;
2654 	int err;
2655 
2656 	err = mlxsw_sp_fid_nve_ifindex(fid, &nve_ifindex);
2657 	if (err)
2658 		return err;
2659 
2660 	err = mlxsw_sp_fid_vni(fid, p_vni);
2661 	if (err)
2662 		return err;
2663 
2664 	dev = __dev_get_by_index(mlxsw_sp_net(mlxsw_sp), nve_ifindex);
2665 	if (!dev)
2666 		return -EINVAL;
2667 	*nve_dev = dev;
2668 
2669 	if (!netif_running(dev))
2670 		return -EINVAL;
2671 
2672 	if (adding && !br_port_flag_is_set(dev, BR_LEARNING))
2673 		return -EINVAL;
2674 
2675 	if (adding && netif_is_vxlan(dev)) {
2676 		struct vxlan_dev *vxlan = netdev_priv(dev);
2677 
2678 		if (!(vxlan->cfg.flags & VXLAN_F_LEARN))
2679 			return -EINVAL;
2680 	}
2681 
2682 	br_dev = netdev_master_upper_dev_get(dev);
2683 	if (!br_dev)
2684 		return -EINVAL;
2685 
2686 	bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, br_dev);
2687 	if (!bridge_device)
2688 		return -EINVAL;
2689 
2690 	*p_vid = bridge_device->ops->fid_vid(bridge_device, fid);
2691 
2692 	return 0;
2693 }
2694 
2695 static void mlxsw_sp_fdb_notify_mac_uc_tunnel_process(struct mlxsw_sp *mlxsw_sp,
2696 						      char *sfn_pl,
2697 						      int rec_index,
2698 						      bool adding)
2699 {
2700 	enum mlxsw_reg_sfn_uc_tunnel_protocol sfn_proto;
2701 	enum switchdev_notifier_type type;
2702 	struct net_device *nve_dev;
2703 	union mlxsw_sp_l3addr addr;
2704 	struct mlxsw_sp_fid *fid;
2705 	char mac[ETH_ALEN];
2706 	u16 fid_index, vid;
2707 	__be32 vni;
2708 	u32 uip;
2709 	int err;
2710 
2711 	mlxsw_reg_sfn_uc_tunnel_unpack(sfn_pl, rec_index, mac, &fid_index,
2712 				       &uip, &sfn_proto);
2713 
2714 	fid = mlxsw_sp_fid_lookup_by_index(mlxsw_sp, fid_index);
2715 	if (!fid)
2716 		goto err_fid_lookup;
2717 
2718 	err = mlxsw_sp_nve_learned_ip_resolve(mlxsw_sp, uip,
2719 					      (enum mlxsw_sp_l3proto) sfn_proto,
2720 					      &addr);
2721 	if (err)
2722 		goto err_ip_resolve;
2723 
2724 	err = __mlxsw_sp_fdb_notify_mac_uc_tunnel_process(mlxsw_sp, fid, adding,
2725 							  &nve_dev, &vid, &vni);
2726 	if (err)
2727 		goto err_fdb_process;
2728 
2729 	err = mlxsw_sp_port_fdb_tunnel_uc_op(mlxsw_sp, mac, fid_index,
2730 					     (enum mlxsw_sp_l3proto) sfn_proto,
2731 					     &addr, adding, true);
2732 	if (err)
2733 		goto err_fdb_op;
2734 
2735 	mlxsw_sp_fdb_nve_call_notifiers(nve_dev, mac,
2736 					(enum mlxsw_sp_l3proto) sfn_proto,
2737 					&addr, vni, adding);
2738 
2739 	type = adding ? SWITCHDEV_FDB_ADD_TO_BRIDGE :
2740 			SWITCHDEV_FDB_DEL_TO_BRIDGE;
2741 	mlxsw_sp_fdb_call_notifiers(type, mac, vid, nve_dev, adding);
2742 
2743 	mlxsw_sp_fid_put(fid);
2744 
2745 	return;
2746 
2747 err_fdb_op:
2748 err_fdb_process:
2749 err_ip_resolve:
2750 	mlxsw_sp_fid_put(fid);
2751 err_fid_lookup:
2752 	/* Remove an FDB entry in case we cannot process it. Otherwise the
2753 	 * device will keep sending the same notification over and over again.
2754 	 */
2755 	mlxsw_sp_port_fdb_tunnel_uc_op(mlxsw_sp, mac, fid_index,
2756 				       (enum mlxsw_sp_l3proto) sfn_proto, &addr,
2757 				       false, true);
2758 }
2759 
2760 static void mlxsw_sp_fdb_notify_rec_process(struct mlxsw_sp *mlxsw_sp,
2761 					    char *sfn_pl, int rec_index)
2762 {
2763 	switch (mlxsw_reg_sfn_rec_type_get(sfn_pl, rec_index)) {
2764 	case MLXSW_REG_SFN_REC_TYPE_LEARNED_MAC:
2765 		mlxsw_sp_fdb_notify_mac_process(mlxsw_sp, sfn_pl,
2766 						rec_index, true);
2767 		break;
2768 	case MLXSW_REG_SFN_REC_TYPE_AGED_OUT_MAC:
2769 		mlxsw_sp_fdb_notify_mac_process(mlxsw_sp, sfn_pl,
2770 						rec_index, false);
2771 		break;
2772 	case MLXSW_REG_SFN_REC_TYPE_LEARNED_MAC_LAG:
2773 		mlxsw_sp_fdb_notify_mac_lag_process(mlxsw_sp, sfn_pl,
2774 						    rec_index, true);
2775 		break;
2776 	case MLXSW_REG_SFN_REC_TYPE_AGED_OUT_MAC_LAG:
2777 		mlxsw_sp_fdb_notify_mac_lag_process(mlxsw_sp, sfn_pl,
2778 						    rec_index, false);
2779 		break;
2780 	case MLXSW_REG_SFN_REC_TYPE_LEARNED_UNICAST_TUNNEL:
2781 		mlxsw_sp_fdb_notify_mac_uc_tunnel_process(mlxsw_sp, sfn_pl,
2782 							  rec_index, true);
2783 		break;
2784 	case MLXSW_REG_SFN_REC_TYPE_AGED_OUT_UNICAST_TUNNEL:
2785 		mlxsw_sp_fdb_notify_mac_uc_tunnel_process(mlxsw_sp, sfn_pl,
2786 							  rec_index, false);
2787 		break;
2788 	}
2789 }
2790 
2791 static void mlxsw_sp_fdb_notify_work_schedule(struct mlxsw_sp *mlxsw_sp,
2792 					      bool no_delay)
2793 {
2794 	struct mlxsw_sp_bridge *bridge = mlxsw_sp->bridge;
2795 	unsigned int interval = no_delay ? 0 : bridge->fdb_notify.interval;
2796 
2797 	mlxsw_core_schedule_dw(&bridge->fdb_notify.dw,
2798 			       msecs_to_jiffies(interval));
2799 }
2800 
2801 #define MLXSW_SP_FDB_SFN_QUERIES_PER_SESSION 10
2802 
2803 static void mlxsw_sp_fdb_notify_work(struct work_struct *work)
2804 {
2805 	struct mlxsw_sp_bridge *bridge;
2806 	struct mlxsw_sp *mlxsw_sp;
2807 	char *sfn_pl;
2808 	int queries;
2809 	u8 num_rec;
2810 	int i;
2811 	int err;
2812 
2813 	sfn_pl = kmalloc(MLXSW_REG_SFN_LEN, GFP_KERNEL);
2814 	if (!sfn_pl)
2815 		return;
2816 
2817 	bridge = container_of(work, struct mlxsw_sp_bridge, fdb_notify.dw.work);
2818 	mlxsw_sp = bridge->mlxsw_sp;
2819 
2820 	rtnl_lock();
2821 	queries = MLXSW_SP_FDB_SFN_QUERIES_PER_SESSION;
2822 	while (queries > 0) {
2823 		mlxsw_reg_sfn_pack(sfn_pl);
2824 		err = mlxsw_reg_query(mlxsw_sp->core, MLXSW_REG(sfn), sfn_pl);
2825 		if (err) {
2826 			dev_err_ratelimited(mlxsw_sp->bus_info->dev, "Failed to get FDB notifications\n");
2827 			goto out;
2828 		}
2829 		num_rec = mlxsw_reg_sfn_num_rec_get(sfn_pl);
2830 		for (i = 0; i < num_rec; i++)
2831 			mlxsw_sp_fdb_notify_rec_process(mlxsw_sp, sfn_pl, i);
2832 		if (num_rec != MLXSW_REG_SFN_REC_MAX_COUNT)
2833 			goto out;
2834 		queries--;
2835 	}
2836 
2837 out:
2838 	rtnl_unlock();
2839 	kfree(sfn_pl);
2840 	mlxsw_sp_fdb_notify_work_schedule(mlxsw_sp, !queries);
2841 }
2842 
2843 struct mlxsw_sp_switchdev_event_work {
2844 	struct work_struct work;
2845 	union {
2846 		struct switchdev_notifier_fdb_info fdb_info;
2847 		struct switchdev_notifier_vxlan_fdb_info vxlan_fdb_info;
2848 	};
2849 	struct net_device *dev;
2850 	unsigned long event;
2851 };
2852 
2853 static void
2854 mlxsw_sp_switchdev_bridge_vxlan_fdb_event(struct mlxsw_sp *mlxsw_sp,
2855 					  struct mlxsw_sp_switchdev_event_work *
2856 					  switchdev_work,
2857 					  struct mlxsw_sp_fid *fid, __be32 vni)
2858 {
2859 	struct switchdev_notifier_vxlan_fdb_info vxlan_fdb_info;
2860 	struct switchdev_notifier_fdb_info *fdb_info;
2861 	struct net_device *dev = switchdev_work->dev;
2862 	enum mlxsw_sp_l3proto proto;
2863 	union mlxsw_sp_l3addr addr;
2864 	int err;
2865 
2866 	fdb_info = &switchdev_work->fdb_info;
2867 	err = vxlan_fdb_find_uc(dev, fdb_info->addr, vni, &vxlan_fdb_info);
2868 	if (err)
2869 		return;
2870 
2871 	mlxsw_sp_switchdev_vxlan_addr_convert(&vxlan_fdb_info.remote_ip,
2872 					      &proto, &addr);
2873 
2874 	switch (switchdev_work->event) {
2875 	case SWITCHDEV_FDB_ADD_TO_DEVICE:
2876 		err = mlxsw_sp_port_fdb_tunnel_uc_op(mlxsw_sp,
2877 						     vxlan_fdb_info.eth_addr,
2878 						     mlxsw_sp_fid_index(fid),
2879 						     proto, &addr, true, false);
2880 		if (err)
2881 			return;
2882 		vxlan_fdb_info.offloaded = true;
2883 		call_switchdev_notifiers(SWITCHDEV_VXLAN_FDB_OFFLOADED, dev,
2884 					 &vxlan_fdb_info.info, NULL);
2885 		mlxsw_sp_fdb_call_notifiers(SWITCHDEV_FDB_OFFLOADED,
2886 					    vxlan_fdb_info.eth_addr,
2887 					    fdb_info->vid, dev, true);
2888 		break;
2889 	case SWITCHDEV_FDB_DEL_TO_DEVICE:
2890 		err = mlxsw_sp_port_fdb_tunnel_uc_op(mlxsw_sp,
2891 						     vxlan_fdb_info.eth_addr,
2892 						     mlxsw_sp_fid_index(fid),
2893 						     proto, &addr, false,
2894 						     false);
2895 		vxlan_fdb_info.offloaded = false;
2896 		call_switchdev_notifiers(SWITCHDEV_VXLAN_FDB_OFFLOADED, dev,
2897 					 &vxlan_fdb_info.info, NULL);
2898 		break;
2899 	}
2900 }
2901 
2902 static void
2903 mlxsw_sp_switchdev_bridge_nve_fdb_event(struct mlxsw_sp_switchdev_event_work *
2904 					switchdev_work)
2905 {
2906 	struct mlxsw_sp_bridge_device *bridge_device;
2907 	struct net_device *dev = switchdev_work->dev;
2908 	struct net_device *br_dev;
2909 	struct mlxsw_sp *mlxsw_sp;
2910 	struct mlxsw_sp_fid *fid;
2911 	__be32 vni;
2912 	int err;
2913 
2914 	if (switchdev_work->event != SWITCHDEV_FDB_ADD_TO_DEVICE &&
2915 	    switchdev_work->event != SWITCHDEV_FDB_DEL_TO_DEVICE)
2916 		return;
2917 
2918 	if (switchdev_work->event == SWITCHDEV_FDB_ADD_TO_DEVICE &&
2919 	    (!switchdev_work->fdb_info.added_by_user ||
2920 	     switchdev_work->fdb_info.is_local))
2921 		return;
2922 
2923 	if (!netif_running(dev))
2924 		return;
2925 	br_dev = netdev_master_upper_dev_get(dev);
2926 	if (!br_dev)
2927 		return;
2928 	if (!netif_is_bridge_master(br_dev))
2929 		return;
2930 	mlxsw_sp = mlxsw_sp_lower_get(br_dev);
2931 	if (!mlxsw_sp)
2932 		return;
2933 	bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, br_dev);
2934 	if (!bridge_device)
2935 		return;
2936 
2937 	fid = bridge_device->ops->fid_lookup(bridge_device,
2938 					     switchdev_work->fdb_info.vid);
2939 	if (!fid)
2940 		return;
2941 
2942 	err = mlxsw_sp_fid_vni(fid, &vni);
2943 	if (err)
2944 		goto out;
2945 
2946 	mlxsw_sp_switchdev_bridge_vxlan_fdb_event(mlxsw_sp, switchdev_work, fid,
2947 						  vni);
2948 
2949 out:
2950 	mlxsw_sp_fid_put(fid);
2951 }
2952 
2953 static void mlxsw_sp_switchdev_bridge_fdb_event_work(struct work_struct *work)
2954 {
2955 	struct mlxsw_sp_switchdev_event_work *switchdev_work =
2956 		container_of(work, struct mlxsw_sp_switchdev_event_work, work);
2957 	struct net_device *dev = switchdev_work->dev;
2958 	struct switchdev_notifier_fdb_info *fdb_info;
2959 	struct mlxsw_sp_port *mlxsw_sp_port;
2960 	int err;
2961 
2962 	rtnl_lock();
2963 	if (netif_is_vxlan(dev)) {
2964 		mlxsw_sp_switchdev_bridge_nve_fdb_event(switchdev_work);
2965 		goto out;
2966 	}
2967 
2968 	mlxsw_sp_port = mlxsw_sp_port_dev_lower_find(dev);
2969 	if (!mlxsw_sp_port)
2970 		goto out;
2971 
2972 	switch (switchdev_work->event) {
2973 	case SWITCHDEV_FDB_ADD_TO_DEVICE:
2974 		fdb_info = &switchdev_work->fdb_info;
2975 		if (!fdb_info->added_by_user || fdb_info->is_local)
2976 			break;
2977 		err = mlxsw_sp_port_fdb_set(mlxsw_sp_port, fdb_info, true);
2978 		if (err)
2979 			break;
2980 		mlxsw_sp_fdb_call_notifiers(SWITCHDEV_FDB_OFFLOADED,
2981 					    fdb_info->addr,
2982 					    fdb_info->vid, dev, true);
2983 		break;
2984 	case SWITCHDEV_FDB_DEL_TO_DEVICE:
2985 		fdb_info = &switchdev_work->fdb_info;
2986 		mlxsw_sp_port_fdb_set(mlxsw_sp_port, fdb_info, false);
2987 		break;
2988 	case SWITCHDEV_FDB_ADD_TO_BRIDGE:
2989 	case SWITCHDEV_FDB_DEL_TO_BRIDGE:
2990 		/* These events are only used to potentially update an existing
2991 		 * SPAN mirror.
2992 		 */
2993 		break;
2994 	}
2995 
2996 	mlxsw_sp_span_respin(mlxsw_sp_port->mlxsw_sp);
2997 
2998 out:
2999 	rtnl_unlock();
3000 	kfree(switchdev_work->fdb_info.addr);
3001 	kfree(switchdev_work);
3002 	dev_put(dev);
3003 }
3004 
3005 static void
3006 mlxsw_sp_switchdev_vxlan_fdb_add(struct mlxsw_sp *mlxsw_sp,
3007 				 struct mlxsw_sp_switchdev_event_work *
3008 				 switchdev_work)
3009 {
3010 	struct switchdev_notifier_vxlan_fdb_info *vxlan_fdb_info;
3011 	struct mlxsw_sp_bridge_device *bridge_device;
3012 	struct net_device *dev = switchdev_work->dev;
3013 	u8 all_zeros_mac[ETH_ALEN] = { 0 };
3014 	enum mlxsw_sp_l3proto proto;
3015 	union mlxsw_sp_l3addr addr;
3016 	struct net_device *br_dev;
3017 	struct mlxsw_sp_fid *fid;
3018 	u16 vid;
3019 	int err;
3020 
3021 	vxlan_fdb_info = &switchdev_work->vxlan_fdb_info;
3022 	br_dev = netdev_master_upper_dev_get(dev);
3023 
3024 	bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, br_dev);
3025 	if (!bridge_device)
3026 		return;
3027 
3028 	fid = mlxsw_sp_fid_lookup_by_vni(mlxsw_sp, vxlan_fdb_info->vni);
3029 	if (!fid)
3030 		return;
3031 
3032 	mlxsw_sp_switchdev_vxlan_addr_convert(&vxlan_fdb_info->remote_ip,
3033 					      &proto, &addr);
3034 
3035 	if (ether_addr_equal(vxlan_fdb_info->eth_addr, all_zeros_mac)) {
3036 		err = mlxsw_sp_nve_flood_ip_add(mlxsw_sp, fid, proto, &addr);
3037 		if (err) {
3038 			mlxsw_sp_fid_put(fid);
3039 			return;
3040 		}
3041 		vxlan_fdb_info->offloaded = true;
3042 		call_switchdev_notifiers(SWITCHDEV_VXLAN_FDB_OFFLOADED, dev,
3043 					 &vxlan_fdb_info->info, NULL);
3044 		mlxsw_sp_fid_put(fid);
3045 		return;
3046 	}
3047 
3048 	/* The device has a single FDB table, whereas Linux has two - one
3049 	 * in the bridge driver and another in the VxLAN driver. We only
3050 	 * program an entry to the device if the MAC points to the VxLAN
3051 	 * device in the bridge's FDB table
3052 	 */
3053 	vid = bridge_device->ops->fid_vid(bridge_device, fid);
3054 	if (br_fdb_find_port(br_dev, vxlan_fdb_info->eth_addr, vid) != dev)
3055 		goto err_br_fdb_find;
3056 
3057 	err = mlxsw_sp_port_fdb_tunnel_uc_op(mlxsw_sp, vxlan_fdb_info->eth_addr,
3058 					     mlxsw_sp_fid_index(fid), proto,
3059 					     &addr, true, false);
3060 	if (err)
3061 		goto err_fdb_tunnel_uc_op;
3062 	vxlan_fdb_info->offloaded = true;
3063 	call_switchdev_notifiers(SWITCHDEV_VXLAN_FDB_OFFLOADED, dev,
3064 				 &vxlan_fdb_info->info, NULL);
3065 	mlxsw_sp_fdb_call_notifiers(SWITCHDEV_FDB_OFFLOADED,
3066 				    vxlan_fdb_info->eth_addr, vid, dev, true);
3067 
3068 	mlxsw_sp_fid_put(fid);
3069 
3070 	return;
3071 
3072 err_fdb_tunnel_uc_op:
3073 err_br_fdb_find:
3074 	mlxsw_sp_fid_put(fid);
3075 }
3076 
3077 static void
3078 mlxsw_sp_switchdev_vxlan_fdb_del(struct mlxsw_sp *mlxsw_sp,
3079 				 struct mlxsw_sp_switchdev_event_work *
3080 				 switchdev_work)
3081 {
3082 	struct switchdev_notifier_vxlan_fdb_info *vxlan_fdb_info;
3083 	struct mlxsw_sp_bridge_device *bridge_device;
3084 	struct net_device *dev = switchdev_work->dev;
3085 	struct net_device *br_dev = netdev_master_upper_dev_get(dev);
3086 	u8 all_zeros_mac[ETH_ALEN] = { 0 };
3087 	enum mlxsw_sp_l3proto proto;
3088 	union mlxsw_sp_l3addr addr;
3089 	struct mlxsw_sp_fid *fid;
3090 	u16 vid;
3091 
3092 	vxlan_fdb_info = &switchdev_work->vxlan_fdb_info;
3093 
3094 	bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, br_dev);
3095 	if (!bridge_device)
3096 		return;
3097 
3098 	fid = mlxsw_sp_fid_lookup_by_vni(mlxsw_sp, vxlan_fdb_info->vni);
3099 	if (!fid)
3100 		return;
3101 
3102 	mlxsw_sp_switchdev_vxlan_addr_convert(&vxlan_fdb_info->remote_ip,
3103 					      &proto, &addr);
3104 
3105 	if (ether_addr_equal(vxlan_fdb_info->eth_addr, all_zeros_mac)) {
3106 		mlxsw_sp_nve_flood_ip_del(mlxsw_sp, fid, proto, &addr);
3107 		mlxsw_sp_fid_put(fid);
3108 		return;
3109 	}
3110 
3111 	mlxsw_sp_port_fdb_tunnel_uc_op(mlxsw_sp, vxlan_fdb_info->eth_addr,
3112 				       mlxsw_sp_fid_index(fid), proto, &addr,
3113 				       false, false);
3114 	vid = bridge_device->ops->fid_vid(bridge_device, fid);
3115 	mlxsw_sp_fdb_call_notifiers(SWITCHDEV_FDB_OFFLOADED,
3116 				    vxlan_fdb_info->eth_addr, vid, dev, false);
3117 
3118 	mlxsw_sp_fid_put(fid);
3119 }
3120 
3121 static void mlxsw_sp_switchdev_vxlan_fdb_event_work(struct work_struct *work)
3122 {
3123 	struct mlxsw_sp_switchdev_event_work *switchdev_work =
3124 		container_of(work, struct mlxsw_sp_switchdev_event_work, work);
3125 	struct net_device *dev = switchdev_work->dev;
3126 	struct mlxsw_sp *mlxsw_sp;
3127 	struct net_device *br_dev;
3128 
3129 	rtnl_lock();
3130 
3131 	if (!netif_running(dev))
3132 		goto out;
3133 	br_dev = netdev_master_upper_dev_get(dev);
3134 	if (!br_dev)
3135 		goto out;
3136 	if (!netif_is_bridge_master(br_dev))
3137 		goto out;
3138 	mlxsw_sp = mlxsw_sp_lower_get(br_dev);
3139 	if (!mlxsw_sp)
3140 		goto out;
3141 
3142 	switch (switchdev_work->event) {
3143 	case SWITCHDEV_VXLAN_FDB_ADD_TO_DEVICE:
3144 		mlxsw_sp_switchdev_vxlan_fdb_add(mlxsw_sp, switchdev_work);
3145 		break;
3146 	case SWITCHDEV_VXLAN_FDB_DEL_TO_DEVICE:
3147 		mlxsw_sp_switchdev_vxlan_fdb_del(mlxsw_sp, switchdev_work);
3148 		break;
3149 	}
3150 
3151 out:
3152 	rtnl_unlock();
3153 	kfree(switchdev_work);
3154 	dev_put(dev);
3155 }
3156 
3157 static int
3158 mlxsw_sp_switchdev_vxlan_work_prepare(struct mlxsw_sp_switchdev_event_work *
3159 				      switchdev_work,
3160 				      struct switchdev_notifier_info *info)
3161 {
3162 	struct vxlan_dev *vxlan = netdev_priv(switchdev_work->dev);
3163 	struct switchdev_notifier_vxlan_fdb_info *vxlan_fdb_info;
3164 	struct vxlan_config *cfg = &vxlan->cfg;
3165 	struct netlink_ext_ack *extack;
3166 
3167 	extack = switchdev_notifier_info_to_extack(info);
3168 	vxlan_fdb_info = container_of(info,
3169 				      struct switchdev_notifier_vxlan_fdb_info,
3170 				      info);
3171 
3172 	if (vxlan_fdb_info->remote_port != cfg->dst_port) {
3173 		NL_SET_ERR_MSG_MOD(extack, "VxLAN: FDB: Non-default remote port is not supported");
3174 		return -EOPNOTSUPP;
3175 	}
3176 	if (vxlan_fdb_info->remote_vni != cfg->vni ||
3177 	    vxlan_fdb_info->vni != cfg->vni) {
3178 		NL_SET_ERR_MSG_MOD(extack, "VxLAN: FDB: Non-default VNI is not supported");
3179 		return -EOPNOTSUPP;
3180 	}
3181 	if (vxlan_fdb_info->remote_ifindex) {
3182 		NL_SET_ERR_MSG_MOD(extack, "VxLAN: FDB: Local interface is not supported");
3183 		return -EOPNOTSUPP;
3184 	}
3185 	if (is_multicast_ether_addr(vxlan_fdb_info->eth_addr)) {
3186 		NL_SET_ERR_MSG_MOD(extack, "VxLAN: FDB: Multicast MAC addresses not supported");
3187 		return -EOPNOTSUPP;
3188 	}
3189 	if (vxlan_addr_multicast(&vxlan_fdb_info->remote_ip)) {
3190 		NL_SET_ERR_MSG_MOD(extack, "VxLAN: FDB: Multicast destination IP is not supported");
3191 		return -EOPNOTSUPP;
3192 	}
3193 
3194 	switchdev_work->vxlan_fdb_info = *vxlan_fdb_info;
3195 
3196 	return 0;
3197 }
3198 
3199 /* Called under rcu_read_lock() */
3200 static int mlxsw_sp_switchdev_event(struct notifier_block *unused,
3201 				    unsigned long event, void *ptr)
3202 {
3203 	struct net_device *dev = switchdev_notifier_info_to_dev(ptr);
3204 	struct mlxsw_sp_switchdev_event_work *switchdev_work;
3205 	struct switchdev_notifier_fdb_info *fdb_info;
3206 	struct switchdev_notifier_info *info = ptr;
3207 	struct net_device *br_dev;
3208 	int err;
3209 
3210 	if (event == SWITCHDEV_PORT_ATTR_SET) {
3211 		err = switchdev_handle_port_attr_set(dev, ptr,
3212 						     mlxsw_sp_port_dev_check,
3213 						     mlxsw_sp_port_attr_set);
3214 		return notifier_from_errno(err);
3215 	}
3216 
3217 	/* Tunnel devices are not our uppers, so check their master instead */
3218 	br_dev = netdev_master_upper_dev_get_rcu(dev);
3219 	if (!br_dev)
3220 		return NOTIFY_DONE;
3221 	if (!netif_is_bridge_master(br_dev))
3222 		return NOTIFY_DONE;
3223 	if (!mlxsw_sp_port_dev_lower_find_rcu(br_dev))
3224 		return NOTIFY_DONE;
3225 
3226 	switchdev_work = kzalloc(sizeof(*switchdev_work), GFP_ATOMIC);
3227 	if (!switchdev_work)
3228 		return NOTIFY_BAD;
3229 
3230 	switchdev_work->dev = dev;
3231 	switchdev_work->event = event;
3232 
3233 	switch (event) {
3234 	case SWITCHDEV_FDB_ADD_TO_DEVICE:
3235 	case SWITCHDEV_FDB_DEL_TO_DEVICE:
3236 	case SWITCHDEV_FDB_ADD_TO_BRIDGE:
3237 	case SWITCHDEV_FDB_DEL_TO_BRIDGE:
3238 		fdb_info = container_of(info,
3239 					struct switchdev_notifier_fdb_info,
3240 					info);
3241 		INIT_WORK(&switchdev_work->work,
3242 			  mlxsw_sp_switchdev_bridge_fdb_event_work);
3243 		memcpy(&switchdev_work->fdb_info, ptr,
3244 		       sizeof(switchdev_work->fdb_info));
3245 		switchdev_work->fdb_info.addr = kzalloc(ETH_ALEN, GFP_ATOMIC);
3246 		if (!switchdev_work->fdb_info.addr)
3247 			goto err_addr_alloc;
3248 		ether_addr_copy((u8 *)switchdev_work->fdb_info.addr,
3249 				fdb_info->addr);
3250 		/* Take a reference on the device. This can be either
3251 		 * upper device containig mlxsw_sp_port or just a
3252 		 * mlxsw_sp_port
3253 		 */
3254 		dev_hold(dev);
3255 		break;
3256 	case SWITCHDEV_VXLAN_FDB_ADD_TO_DEVICE:
3257 	case SWITCHDEV_VXLAN_FDB_DEL_TO_DEVICE:
3258 		INIT_WORK(&switchdev_work->work,
3259 			  mlxsw_sp_switchdev_vxlan_fdb_event_work);
3260 		err = mlxsw_sp_switchdev_vxlan_work_prepare(switchdev_work,
3261 							    info);
3262 		if (err)
3263 			goto err_vxlan_work_prepare;
3264 		dev_hold(dev);
3265 		break;
3266 	default:
3267 		kfree(switchdev_work);
3268 		return NOTIFY_DONE;
3269 	}
3270 
3271 	mlxsw_core_schedule_work(&switchdev_work->work);
3272 
3273 	return NOTIFY_DONE;
3274 
3275 err_vxlan_work_prepare:
3276 err_addr_alloc:
3277 	kfree(switchdev_work);
3278 	return NOTIFY_BAD;
3279 }
3280 
3281 struct notifier_block mlxsw_sp_switchdev_notifier = {
3282 	.notifier_call = mlxsw_sp_switchdev_event,
3283 };
3284 
3285 static int
3286 mlxsw_sp_switchdev_vxlan_vlan_add(struct mlxsw_sp *mlxsw_sp,
3287 				  struct mlxsw_sp_bridge_device *bridge_device,
3288 				  const struct net_device *vxlan_dev, u16 vid,
3289 				  bool flag_untagged, bool flag_pvid,
3290 				  struct netlink_ext_ack *extack)
3291 {
3292 	struct vxlan_dev *vxlan = netdev_priv(vxlan_dev);
3293 	__be32 vni = vxlan->cfg.vni;
3294 	struct mlxsw_sp_fid *fid;
3295 	u16 old_vid;
3296 	int err;
3297 
3298 	/* We cannot have the same VLAN as PVID and egress untagged on multiple
3299 	 * VxLAN devices. Note that we get this notification before the VLAN is
3300 	 * actually added to the bridge's database, so it is not possible for
3301 	 * the lookup function to return 'vxlan_dev'
3302 	 */
3303 	if (flag_untagged && flag_pvid &&
3304 	    mlxsw_sp_bridge_8021q_vxlan_dev_find(bridge_device->dev, vid)) {
3305 		NL_SET_ERR_MSG_MOD(extack, "VLAN already mapped to a different VNI");
3306 		return -EINVAL;
3307 	}
3308 
3309 	if (!netif_running(vxlan_dev))
3310 		return 0;
3311 
3312 	/* First case: FID is not associated with this VNI, but the new VLAN
3313 	 * is both PVID and egress untagged. Need to enable NVE on the FID, if
3314 	 * it exists
3315 	 */
3316 	fid = mlxsw_sp_fid_lookup_by_vni(mlxsw_sp, vni);
3317 	if (!fid) {
3318 		if (!flag_untagged || !flag_pvid)
3319 			return 0;
3320 		return bridge_device->ops->vxlan_join(bridge_device, vxlan_dev,
3321 						      vid, extack);
3322 	}
3323 
3324 	/* Second case: FID is associated with the VNI and the VLAN associated
3325 	 * with the FID is the same as the notified VLAN. This means the flags
3326 	 * (PVID / egress untagged) were toggled and that NVE should be
3327 	 * disabled on the FID
3328 	 */
3329 	old_vid = mlxsw_sp_fid_8021q_vid(fid);
3330 	if (vid == old_vid) {
3331 		if (WARN_ON(flag_untagged && flag_pvid)) {
3332 			mlxsw_sp_fid_put(fid);
3333 			return -EINVAL;
3334 		}
3335 		mlxsw_sp_bridge_vxlan_leave(mlxsw_sp, vxlan_dev);
3336 		mlxsw_sp_fid_put(fid);
3337 		return 0;
3338 	}
3339 
3340 	/* Third case: A new VLAN was configured on the VxLAN device, but this
3341 	 * VLAN is not PVID, so there is nothing to do.
3342 	 */
3343 	if (!flag_pvid) {
3344 		mlxsw_sp_fid_put(fid);
3345 		return 0;
3346 	}
3347 
3348 	/* Fourth case: Thew new VLAN is PVID, which means the VLAN currently
3349 	 * mapped to the VNI should be unmapped
3350 	 */
3351 	mlxsw_sp_bridge_vxlan_leave(mlxsw_sp, vxlan_dev);
3352 	mlxsw_sp_fid_put(fid);
3353 
3354 	/* Fifth case: The new VLAN is also egress untagged, which means the
3355 	 * VLAN needs to be mapped to the VNI
3356 	 */
3357 	if (!flag_untagged)
3358 		return 0;
3359 
3360 	err = bridge_device->ops->vxlan_join(bridge_device, vxlan_dev, vid, extack);
3361 	if (err)
3362 		goto err_vxlan_join;
3363 
3364 	return 0;
3365 
3366 err_vxlan_join:
3367 	bridge_device->ops->vxlan_join(bridge_device, vxlan_dev, old_vid, NULL);
3368 	return err;
3369 }
3370 
3371 static void
3372 mlxsw_sp_switchdev_vxlan_vlan_del(struct mlxsw_sp *mlxsw_sp,
3373 				  struct mlxsw_sp_bridge_device *bridge_device,
3374 				  const struct net_device *vxlan_dev, u16 vid)
3375 {
3376 	struct vxlan_dev *vxlan = netdev_priv(vxlan_dev);
3377 	__be32 vni = vxlan->cfg.vni;
3378 	struct mlxsw_sp_fid *fid;
3379 
3380 	if (!netif_running(vxlan_dev))
3381 		return;
3382 
3383 	fid = mlxsw_sp_fid_lookup_by_vni(mlxsw_sp, vni);
3384 	if (!fid)
3385 		return;
3386 
3387 	/* A different VLAN than the one mapped to the VNI is deleted */
3388 	if (mlxsw_sp_fid_8021q_vid(fid) != vid)
3389 		goto out;
3390 
3391 	mlxsw_sp_bridge_vxlan_leave(mlxsw_sp, vxlan_dev);
3392 
3393 out:
3394 	mlxsw_sp_fid_put(fid);
3395 }
3396 
3397 static int
3398 mlxsw_sp_switchdev_vxlan_vlans_add(struct net_device *vxlan_dev,
3399 				   struct switchdev_notifier_port_obj_info *
3400 				   port_obj_info)
3401 {
3402 	struct switchdev_obj_port_vlan *vlan =
3403 		SWITCHDEV_OBJ_PORT_VLAN(port_obj_info->obj);
3404 	bool flag_untagged = vlan->flags & BRIDGE_VLAN_INFO_UNTAGGED;
3405 	bool flag_pvid = vlan->flags & BRIDGE_VLAN_INFO_PVID;
3406 	struct mlxsw_sp_bridge_device *bridge_device;
3407 	struct netlink_ext_ack *extack;
3408 	struct mlxsw_sp *mlxsw_sp;
3409 	struct net_device *br_dev;
3410 
3411 	extack = switchdev_notifier_info_to_extack(&port_obj_info->info);
3412 	br_dev = netdev_master_upper_dev_get(vxlan_dev);
3413 	if (!br_dev)
3414 		return 0;
3415 
3416 	mlxsw_sp = mlxsw_sp_lower_get(br_dev);
3417 	if (!mlxsw_sp)
3418 		return 0;
3419 
3420 	port_obj_info->handled = true;
3421 
3422 	bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, br_dev);
3423 	if (!bridge_device)
3424 		return -EINVAL;
3425 
3426 	if (!bridge_device->vlan_enabled)
3427 		return 0;
3428 
3429 	return mlxsw_sp_switchdev_vxlan_vlan_add(mlxsw_sp, bridge_device,
3430 						 vxlan_dev, vlan->vid,
3431 						 flag_untagged,
3432 						 flag_pvid, extack);
3433 }
3434 
3435 static void
3436 mlxsw_sp_switchdev_vxlan_vlans_del(struct net_device *vxlan_dev,
3437 				   struct switchdev_notifier_port_obj_info *
3438 				   port_obj_info)
3439 {
3440 	struct switchdev_obj_port_vlan *vlan =
3441 		SWITCHDEV_OBJ_PORT_VLAN(port_obj_info->obj);
3442 	struct mlxsw_sp_bridge_device *bridge_device;
3443 	struct mlxsw_sp *mlxsw_sp;
3444 	struct net_device *br_dev;
3445 
3446 	br_dev = netdev_master_upper_dev_get(vxlan_dev);
3447 	if (!br_dev)
3448 		return;
3449 
3450 	mlxsw_sp = mlxsw_sp_lower_get(br_dev);
3451 	if (!mlxsw_sp)
3452 		return;
3453 
3454 	port_obj_info->handled = true;
3455 
3456 	bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, br_dev);
3457 	if (!bridge_device)
3458 		return;
3459 
3460 	if (!bridge_device->vlan_enabled)
3461 		return;
3462 
3463 	mlxsw_sp_switchdev_vxlan_vlan_del(mlxsw_sp, bridge_device, vxlan_dev,
3464 					  vlan->vid);
3465 }
3466 
3467 static int
3468 mlxsw_sp_switchdev_handle_vxlan_obj_add(struct net_device *vxlan_dev,
3469 					struct switchdev_notifier_port_obj_info *
3470 					port_obj_info)
3471 {
3472 	int err = 0;
3473 
3474 	switch (port_obj_info->obj->id) {
3475 	case SWITCHDEV_OBJ_ID_PORT_VLAN:
3476 		err = mlxsw_sp_switchdev_vxlan_vlans_add(vxlan_dev,
3477 							 port_obj_info);
3478 		break;
3479 	default:
3480 		break;
3481 	}
3482 
3483 	return err;
3484 }
3485 
3486 static void
3487 mlxsw_sp_switchdev_handle_vxlan_obj_del(struct net_device *vxlan_dev,
3488 					struct switchdev_notifier_port_obj_info *
3489 					port_obj_info)
3490 {
3491 	switch (port_obj_info->obj->id) {
3492 	case SWITCHDEV_OBJ_ID_PORT_VLAN:
3493 		mlxsw_sp_switchdev_vxlan_vlans_del(vxlan_dev, port_obj_info);
3494 		break;
3495 	default:
3496 		break;
3497 	}
3498 }
3499 
3500 static int mlxsw_sp_switchdev_blocking_event(struct notifier_block *unused,
3501 					     unsigned long event, void *ptr)
3502 {
3503 	struct net_device *dev = switchdev_notifier_info_to_dev(ptr);
3504 	int err = 0;
3505 
3506 	switch (event) {
3507 	case SWITCHDEV_PORT_OBJ_ADD:
3508 		if (netif_is_vxlan(dev))
3509 			err = mlxsw_sp_switchdev_handle_vxlan_obj_add(dev, ptr);
3510 		else
3511 			err = switchdev_handle_port_obj_add(dev, ptr,
3512 							mlxsw_sp_port_dev_check,
3513 							mlxsw_sp_port_obj_add);
3514 		return notifier_from_errno(err);
3515 	case SWITCHDEV_PORT_OBJ_DEL:
3516 		if (netif_is_vxlan(dev))
3517 			mlxsw_sp_switchdev_handle_vxlan_obj_del(dev, ptr);
3518 		else
3519 			err = switchdev_handle_port_obj_del(dev, ptr,
3520 							mlxsw_sp_port_dev_check,
3521 							mlxsw_sp_port_obj_del);
3522 		return notifier_from_errno(err);
3523 	case SWITCHDEV_PORT_ATTR_SET:
3524 		err = switchdev_handle_port_attr_set(dev, ptr,
3525 						     mlxsw_sp_port_dev_check,
3526 						     mlxsw_sp_port_attr_set);
3527 		return notifier_from_errno(err);
3528 	}
3529 
3530 	return NOTIFY_DONE;
3531 }
3532 
3533 static struct notifier_block mlxsw_sp_switchdev_blocking_notifier = {
3534 	.notifier_call = mlxsw_sp_switchdev_blocking_event,
3535 };
3536 
3537 u8
3538 mlxsw_sp_bridge_port_stp_state(struct mlxsw_sp_bridge_port *bridge_port)
3539 {
3540 	return bridge_port->stp_state;
3541 }
3542 
3543 static int mlxsw_sp_fdb_init(struct mlxsw_sp *mlxsw_sp)
3544 {
3545 	struct mlxsw_sp_bridge *bridge = mlxsw_sp->bridge;
3546 	struct notifier_block *nb;
3547 	int err;
3548 
3549 	err = mlxsw_sp_ageing_set(mlxsw_sp, MLXSW_SP_DEFAULT_AGEING_TIME);
3550 	if (err) {
3551 		dev_err(mlxsw_sp->bus_info->dev, "Failed to set default ageing time\n");
3552 		return err;
3553 	}
3554 
3555 	err = register_switchdev_notifier(&mlxsw_sp_switchdev_notifier);
3556 	if (err) {
3557 		dev_err(mlxsw_sp->bus_info->dev, "Failed to register switchdev notifier\n");
3558 		return err;
3559 	}
3560 
3561 	nb = &mlxsw_sp_switchdev_blocking_notifier;
3562 	err = register_switchdev_blocking_notifier(nb);
3563 	if (err) {
3564 		dev_err(mlxsw_sp->bus_info->dev, "Failed to register switchdev blocking notifier\n");
3565 		goto err_register_switchdev_blocking_notifier;
3566 	}
3567 
3568 	INIT_DELAYED_WORK(&bridge->fdb_notify.dw, mlxsw_sp_fdb_notify_work);
3569 	bridge->fdb_notify.interval = MLXSW_SP_DEFAULT_LEARNING_INTERVAL;
3570 	mlxsw_sp_fdb_notify_work_schedule(mlxsw_sp, false);
3571 	return 0;
3572 
3573 err_register_switchdev_blocking_notifier:
3574 	unregister_switchdev_notifier(&mlxsw_sp_switchdev_notifier);
3575 	return err;
3576 }
3577 
3578 static void mlxsw_sp_fdb_fini(struct mlxsw_sp *mlxsw_sp)
3579 {
3580 	struct notifier_block *nb;
3581 
3582 	cancel_delayed_work_sync(&mlxsw_sp->bridge->fdb_notify.dw);
3583 
3584 	nb = &mlxsw_sp_switchdev_blocking_notifier;
3585 	unregister_switchdev_blocking_notifier(nb);
3586 
3587 	unregister_switchdev_notifier(&mlxsw_sp_switchdev_notifier);
3588 }
3589 
3590 static void mlxsw_sp1_switchdev_init(struct mlxsw_sp *mlxsw_sp)
3591 {
3592 	mlxsw_sp->bridge->bridge_8021ad_ops = &mlxsw_sp1_bridge_8021ad_ops;
3593 }
3594 
3595 const struct mlxsw_sp_switchdev_ops mlxsw_sp1_switchdev_ops = {
3596 	.init	= mlxsw_sp1_switchdev_init,
3597 };
3598 
3599 static void mlxsw_sp2_switchdev_init(struct mlxsw_sp *mlxsw_sp)
3600 {
3601 	mlxsw_sp->bridge->bridge_8021ad_ops = &mlxsw_sp2_bridge_8021ad_ops;
3602 }
3603 
3604 const struct mlxsw_sp_switchdev_ops mlxsw_sp2_switchdev_ops = {
3605 	.init	= mlxsw_sp2_switchdev_init,
3606 };
3607 
3608 int mlxsw_sp_switchdev_init(struct mlxsw_sp *mlxsw_sp)
3609 {
3610 	struct mlxsw_sp_bridge *bridge;
3611 
3612 	bridge = kzalloc(sizeof(*mlxsw_sp->bridge), GFP_KERNEL);
3613 	if (!bridge)
3614 		return -ENOMEM;
3615 	mlxsw_sp->bridge = bridge;
3616 	bridge->mlxsw_sp = mlxsw_sp;
3617 
3618 	INIT_LIST_HEAD(&mlxsw_sp->bridge->bridges_list);
3619 
3620 	bridge->bridge_8021q_ops = &mlxsw_sp_bridge_8021q_ops;
3621 	bridge->bridge_8021d_ops = &mlxsw_sp_bridge_8021d_ops;
3622 
3623 	mlxsw_sp->switchdev_ops->init(mlxsw_sp);
3624 
3625 	return mlxsw_sp_fdb_init(mlxsw_sp);
3626 }
3627 
3628 void mlxsw_sp_switchdev_fini(struct mlxsw_sp *mlxsw_sp)
3629 {
3630 	mlxsw_sp_fdb_fini(mlxsw_sp);
3631 	WARN_ON(!list_empty(&mlxsw_sp->bridge->bridges_list));
3632 	kfree(mlxsw_sp->bridge);
3633 }
3634 
3635