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