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	unsigned int 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(bridge: 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	fn: mlxsw_sp_bridge_device_upper_rif_destroy,
191	priv: &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(mlxsw_sp: bridge->mlxsw_sp,
205	br_dev, vxlan_dev: dev, vid: 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(mlxsw_sp: bridge->mlxsw_sp, vxlan_dev: 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(mlxsw_sp: bridge->mlxsw_sp, vxlan_dev: 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(dwork: &bridge->fdb_notify.dw,
246	delay: msecs_to_jiffies(m: 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(dev: 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(error: -EINVAL);
263	}
264
265	bridge_device = kzalloc(size: sizeof(*bridge_device), GFP_KERNEL);
266	if (!bridge_device)
267	return ERR_PTR(error: -ENOMEM);
268
269	err = rhashtable_init(ht: &bridge_device->mdb_ht, params: &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(dev: br_dev);
276	bridge_device->mrouter = br_multicast_router(dev: br_dev);
277	INIT_LIST_HEAD(list: &bridge_device->ports_list);
278	if (vlan_enabled) {
279	u16 proto;
280
281	bridge->vlan_enabled_exists = true;
282	br_vlan_get_proto(dev: br_dev, p_proto: &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(list: &bridge_device->mdb_list);
291
292	if (list_empty(head: &bridge->bridges_list))
293	mlxsw_sp_fdb_notify_work_schedule(mlxsw_sp: bridge->mlxsw_sp, no_delay: false);
294	list_add(new: &bridge_device->list, head: &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(entry: &bridge_device->list);
308	if (bridge_device->vlan_enabled)
309	bridge->vlan_enabled_exists = false;
310	rhashtable_destroy(ht: &bridge_device->mdb_ht);
311	err_mdb_rhashtable_init:
312	kfree(objp: bridge_device);
313	return ERR_PTR(error: 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, br_dev: bridge_device->dev);
321	mlxsw_sp_bridge_device_rifs_destroy(mlxsw_sp: bridge->mlxsw_sp,
322	dev: bridge_device->dev);
323	list_del(entry: &bridge_device->list);
324	if (list_empty(head: &bridge->bridges_list))
325	cancel_delayed_work(dwork: &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(ht: &bridge_device->mdb_ht);
331	kfree(objp: 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(head: &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(dev: 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(info: 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(dev: rso->mlxsw_sp_port->dev, proto: 0, vid);
431	if (err)
432	goto out;
433	}
434
435	++rso->done;
436	err = mlxsw_sp_port_obj_add(dev: rso->mlxsw_sp_port->dev, NULL,
437	obj: 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(info: 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(dev: rso->mlxsw_sp_port->dev, NULL,
464	obj: 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(size: sizeof(*bridge_port), GFP_KERNEL);
482	if (!bridge_port)
483	return ERR_PTR(error: -ENOMEM);
484
485	mlxsw_sp_port = mlxsw_sp_port_dev_lower_find(dev: 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(dev: brport_dev);
494	bridge_port->flags = BR_LEARNING | BR_FLOOD | BR_LEARNING_SYNC |
495	BR_MCAST_FLOOD;
496	INIT_LIST_HEAD(list: &bridge_port->vlans_list);
497	list_add(new: &bridge_port->list, head: &bridge_device->ports_list);
498	bridge_port->ref_count = 1;
499
500	err = switchdev_bridge_port_offload(brport_dev, dev: mlxsw_sp_port->dev,
501	NULL, NULL, NULL, tx_fwd_offload: false, extack);
502	if (err)
503	goto err_switchdev_offload;
504
505	return bridge_port;
506
507	err_switchdev_offload:
508	list_del(entry: &bridge_port->list);
509	kfree(objp: bridge_port);
510	return ERR_PTR(error: 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(brport_dev: bridge_port->dev, NULL, NULL, NULL);
517	list_del(entry: &bridge_port->list);
518	WARN_ON(!list_empty(&bridge_port->vlans_list));
519	kfree(objp: 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(dev: 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	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(ptr: bridge_device))
540	return ERR_CAST(ptr: bridge_device);
541
542	bridge_port = mlxsw_sp_bridge_port_create(bridge_device, brport_dev,
543	extack);
544	if (IS_ERR(ptr: bridge_port)) {
545	err = PTR_ERR(ptr: 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(error: 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 (--bridge_port->ref_count != 0)
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(size: sizeof(*bridge_vlan), GFP_KERNEL);
629	if (!bridge_vlan)
630	return NULL;
631
632	INIT_LIST_HEAD(list: &bridge_vlan->port_vlan_list);
633	bridge_vlan->vid = vid;
634	list_add(new: &bridge_vlan->list, head: &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(entry: &bridge_vlan->list);
643	WARN_ON(!list_empty(&bridge_vlan->port_vlan_list));
644	kfree(objp: 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(head: &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	vid: 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(bridge: mlxsw_sp_port->mlxsw_sp->bridge,
695	brport_dev: 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	state: 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(fid: mlxsw_sp_port_vlan->fid,
731	packet_type,
732	local_port: 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: !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(fid: 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(fid: mlxsw_sp_port_vlan->fid, packet_type,
794	local_port, member: !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: !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, learn_enable: 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: !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(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(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(bridge: mlxsw_sp_port->mlxsw_sp->bridge,
901	brport_dev: 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	packet_type: MLXSW_SP_FLOOD_TYPE_UC,
909	member: 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	set: 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	enable: 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	packet_type: MLXSW_SP_FLOOD_TYPE_MC,
936	member: 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(payload: sfdat_pl, age_time: ageing_time);
952	err = mlxsw_reg_write(mlxsw_core: mlxsw_sp->core, MLXSW_REG(sfdat), payload: 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(x: ageing_clock_t);
964	u32 ageing_time = jiffies_to_msecs(j: 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(bridge: mlxsw_sp->bridge, br_dev: 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(dev: bridge_device->dev, format: "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(bridge: mlxsw_sp->bridge, br_dev: orig_dev);
999	if (WARN_ON(!bridge_device))
1000	return -EINVAL;
1001
1002	netdev_err(dev: bridge_device->dev, format: "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(bridge: mlxsw_sp_port->mlxsw_sp->bridge,
1014	brport_dev: orig_dev);
1015	if (!bridge_port)
1016	return 0;
1017
1018	mlxsw_sp_port_mrouter_update_mdb(mlxsw_sp_port, bridge_port,
1019	add: 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	packet_type: MLXSW_SP_FLOOD_TYPE_MC,
1026	member: 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(bridge: mlxsw_sp->bridge, br_dev: 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_enabled: !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: !member);
1089	}
1090	mlxsw_sp_bridge_mdb_mc_enable_sync(mlxsw_sp, bridge_device,
1091	mc_enabled: 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(r: &mdb_entry_port->refcount) == 1)
1123	mdb_entry->ports_count++;
1124
1125	refcount_inc(r: &mdb_entry_port->refcount);
1126	return mdb_entry_port;
1127	}
1128
1129	err = mlxsw_sp_pgt_entry_port_set(mlxsw_sp, mid: mdb_entry->mid,
1130	smpe: mdb_entry->key.fid, local_port, member: true);
1131	if (err)
1132	return ERR_PTR(error: err);
1133
1134	mdb_entry_port = kzalloc(size: 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(r: &mdb_entry_port->refcount, n: 1);
1142	list_add(new: &mdb_entry_port->list, head: &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, mid: mdb_entry->mid,
1149	smpe: mdb_entry->key.fid, local_port, member: false);
1150	return ERR_PTR(error: 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(r: &mdb_entry_port->refcount)) {
1165	if (mdb_entry_port->mrouter &&
1166	refcount_read(r: &mdb_entry_port->refcount) == 1)
1167	mdb_entry->ports_count--;
1168	return;
1169	}
1170
1171	mdb_entry->ports_count--;
1172	list_del(entry: &mdb_entry_port->list);
1173	kfree(objp: mdb_entry_port);
1174	mlxsw_sp_pgt_entry_port_set(mlxsw_sp, mid: mdb_entry->mid,
1175	smpe: mdb_entry->key.fid, local_port, member: 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(r: &mdb_entry_port->refcount);
1190	return mdb_entry_port;
1191	}
1192
1193	err = mlxsw_sp_pgt_entry_port_set(mlxsw_sp, mid: mdb_entry->mid,
1194	smpe: mdb_entry->key.fid, local_port, member: true);
1195	if (err)
1196	return ERR_PTR(error: err);
1197
1198	mdb_entry_port = kzalloc(size: 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(r: &mdb_entry_port->refcount, n: 1);
1206	mdb_entry_port->mrouter = true;
1207	list_add(new: &mdb_entry_port->list, head: &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, mid: mdb_entry->mid,
1213	smpe: mdb_entry->key.fid, local_port, member: false);
1214	return ERR_PTR(error: 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(r: &mdb_entry_port->refcount))
1233	return;
1234
1235	list_del(entry: &mdb_entry_port->list);
1236	kfree(objp: mdb_entry_port);
1237	mlxsw_sp_pgt_entry_port_set(mlxsw_sp, mid: mdb_entry->mid,
1238	smpe: mdb_entry->key.fid, local_port, member: 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(bridge: mlxsw_sp->bridge, br_dev: 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	add: 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	orig_dev: attr->orig_dev,
1292	state: 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	orig_dev: attr->orig_dev,
1297	flags: 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	orig_dev: attr->orig_dev,
1303	flags: 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	ageing_clock_t: 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	orig_dev: attr->orig_dev,
1312	vlan_enabled: 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	orig_dev: attr->orig_dev,
1317	vlan_proto: 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	orig_dev: attr->orig_dev,
1322	is_port_mrouter: 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	orig_dev: attr->orig_dev,
1327	mc_disabled: 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	orig_dev: attr->orig_dev,
1332	is_mrouter: attr->u.mrouter);
1333	break;
1334	default:
1335	err = -EOPNOTSUPP;
1336	break;
1337	}
1338
1339	mlxsw_sp_span_respin(mlxsw_sp: 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(ptr: fid))
1359	return PTR_ERR(ptr: fid);
1360
1361	err = mlxsw_sp_fid_flood_set(fid, packet_type: MLXSW_SP_FLOOD_TYPE_UC, local_port,
1362	member: bridge_port->flags & BR_FLOOD);
1363	if (err)
1364	goto err_fid_uc_flood_set;
1365
1366	err = mlxsw_sp_fid_flood_set(fid, packet_type: MLXSW_SP_FLOOD_TYPE_MC, local_port,
1367	member: 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, packet_type: MLXSW_SP_FLOOD_TYPE_BC, local_port,
1372	member: 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, packet_type: MLXSW_SP_FLOOD_TYPE_BC, local_port, member: false);
1386	err_fid_bc_flood_set:
1387	mlxsw_sp_fid_flood_set(fid, packet_type: MLXSW_SP_FLOOD_TYPE_MC, local_port, member: false);
1388	err_fid_mc_flood_set:
1389	mlxsw_sp_fid_flood_set(fid, packet_type: MLXSW_SP_FLOOD_TYPE_UC, local_port, member: 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, packet_type: MLXSW_SP_FLOOD_TYPE_BC, local_port, member: false);
1406	mlxsw_sp_fid_flood_set(fid, packet_type: MLXSW_SP_FLOOD_TYPE_MC, local_port, member: false);
1407	mlxsw_sp_fid_flood_set(fid, packet_type: MLXSW_SP_FLOOD_TYPE_UC, local_port, member: 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	learn_enable: 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	state: 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(new: &mlxsw_sp_port_vlan->bridge_vlan_node,
1459	head: &bridge_vlan->port_vlan_list);
1460
1461	mlxsw_sp_bridge_port_get(bridge: mlxsw_sp_port->mlxsw_sp->bridge,
1462	brport_dev: 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, learn_enable: 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(head: &bridge_vlan->port_vlan_list);
1493
1494	list_del(entry: &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, learn_enable: false);
1498	if (last_port)
1499	mlxsw_sp_bridge_port_fdb_flush(mlxsw_sp: mlxsw_sp_port->mlxsw_sp,
1500	bridge_port,
1501	fid_index: mlxsw_sp_fid_index(fid));
1502
1503	mlxsw_sp_bridge_port_mdb_flush(mlxsw_sp_port, bridge_port,
1504	fid_index: mlxsw_sp_fid_index(fid));
1505
1506	mlxsw_sp_port_vlan_fid_leave(mlxsw_sp_port_vlan);
1507
1508	mlxsw_sp_bridge_port_put(bridge: 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(ptr: mlxsw_sp_port_vlan))
1537	return PTR_ERR(ptr: mlxsw_sp_port_vlan);
1538	}
1539
1540	err = mlxsw_sp_port_vlan_set(mlxsw_sp_port, vid_begin: vid, vid_end: vid, is_member: true,
1541	untagged: is_untagged);
1542	if (err)
1543	goto err_port_vlan_set;
1544
1545	br_vlan_get_proto(dev: bridge_port->bridge_device->dev, p_proto: &proto);
1546	err = mlxsw_sp_port_pvid_set(mlxsw_sp_port, vid: pvid, ethtype: 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, vid: old_pvid, ethtype: proto);
1559	err_port_pvid_set:
1560	mlxsw_sp_port_vlan_set(mlxsw_sp_port, vid_begin: vid, vid_end: vid, is_member: false, untagged: 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, dev: br_dev, new_vid: vlan->vid,
1575	is_pvid: 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(dev: orig_dev)) {
1589	int err = 0;
1590
1591	if (br_vlan_enabled(dev: orig_dev))
1592	err = mlxsw_sp_br_rif_pvid_change(mlxsw_sp, br_dev: orig_dev,
1593	vlan, extack);
1594	if (!err)
1595	err = -EOPNOTSUPP;
1596	return err;
1597	}
1598
1599	bridge_port = mlxsw_sp_bridge_port_find(bridge: mlxsw_sp->bridge, brport_dev: 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	vid: vlan->vid, is_untagged: flag_untagged,
1608	is_pvid: 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(payload: sfdf_pl, type: mlxsw_sp_fdb_flush_type(lagged));
1628	mlxsw_reg_sfdf_fid_set(buf: sfdf_pl, val: fid_index);
1629	mlxsw_reg_sfdf_port_fid_system_port_set(buf: sfdf_pl, val: system_port);
1630
1631	return mlxsw_reg_write(mlxsw_core: mlxsw_sp->core, MLXSW_REG(sfdf), payload: 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(payload: sfd_pl, op: mlxsw_sp_sfd_op(adding), record_locator: 0);
1661	mlxsw_reg_sfd_uc_tunnel_pack4(payload: sfd_pl, rec_index: 0,
1662	policy: mlxsw_sp_sfd_rec_policy(dynamic), mac,
1663	fid, action: MLXSW_REG_SFD_REC_ACTION_NOP, uip);
1664	num_rec = mlxsw_reg_sfd_num_rec_get(buf: sfd_pl);
1665	err = mlxsw_reg_write(mlxsw_core: mlxsw_sp->core, MLXSW_REG(sfd), payload: sfd_pl);
1666	if (err)
1667	goto out;
1668
1669	if (num_rec != mlxsw_reg_sfd_num_rec_get(buf: sfd_pl))
1670	err = -EBUSY;
1671
1672	out:
1673	kfree(objp: 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(payload: sfd_pl, op: mlxsw_sp_sfd_op(adding), record_locator: 0);
1690	mlxsw_reg_sfd_uc_tunnel_pack6(payload: sfd_pl, rec_index: 0, mac, fid,
1691	action: MLXSW_REG_SFD_REC_ACTION_NOP, uip_ptr: kvdl_index);
1692	num_rec = mlxsw_reg_sfd_num_rec_get(buf: sfd_pl);
1693	err = mlxsw_reg_write(mlxsw_core: mlxsw_sp->core, MLXSW_REG(sfd), payload: sfd_pl);
1694	if (err)
1695	goto out;
1696
1697	if (num_rec != mlxsw_reg_sfd_num_rec_get(buf: sfd_pl))
1698	err = -EBUSY;
1699
1700	out:
1701	kfree(objp: 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, addr6: addr, p_kvdl_index: &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, adding: true);
1718	if (err)
1719	goto err_sfd_write;
1720
1721	err = mlxsw_sp_nve_ipv6_addr_map_replace(mlxsw_sp, mac, fid_index: fid, new_addr6: 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	adding: false);
1733	err_sfd_write:
1734	mlxsw_sp_nve_ipv6_addr_kvdl_unset(mlxsw_sp, addr6: 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_index: fid);
1743	mlxsw_sp_port_fdb_tun_uc_op6_sfd_write(mlxsw_sp, mac, fid, kvdl_index: 0, adding: false);
1744	mlxsw_sp_nve_ipv6_addr_kvdl_unset(mlxsw_sp, addr6: 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: 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: &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(payload: sfd_pl, op: mlxsw_sp_sfd_op(adding), record_locator: 0);
1793	mlxsw_reg_sfd_uc_pack(payload: sfd_pl, rec_index: 0, policy, mac, fid_vid: fid, vid, action,
1794	local_port);
1795	num_rec = mlxsw_reg_sfd_num_rec_get(buf: sfd_pl);
1796	err = mlxsw_reg_write(mlxsw_core: mlxsw_sp->core, MLXSW_REG(sfd), payload: sfd_pl);
1797	if (err)
1798	goto out;
1799
1800	if (num_rec != mlxsw_reg_sfd_num_rec_get(buf: sfd_pl))
1801	err = -EBUSY;
1802
1803	out:
1804	kfree(objp: 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, action: MLXSW_REG_SFD_REC_ACTION_NOP,
1814	policy: 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, local_port: 0, mac, fid, vid: 0, adding,
1821	action: MLXSW_REG_SFD_REC_ACTION_FORWARD_IP_ROUTER,
1822	policy: 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(payload: sfd_pl, op: mlxsw_sp_sfd_op(adding), record_locator: 0);
1838	mlxsw_reg_sfd_uc_lag_pack(payload: sfd_pl, rec_index: 0, policy: mlxsw_sp_sfd_rec_policy(dynamic),
1839	mac, fid_vid: fid, action: MLXSW_REG_SFD_REC_ACTION_NOP,
1840	lag_vid, lag_id);
1841	num_rec = mlxsw_reg_sfd_num_rec_get(buf: sfd_pl);
1842	err = mlxsw_reg_write(mlxsw_core: mlxsw_sp->core, MLXSW_REG(sfd), payload: sfd_pl);
1843	if (err)
1844	goto out;
1845
1846	if (num_rec != mlxsw_reg_sfd_num_rec_get(buf: sfd_pl))
1847	err = -EBUSY;
1848
1849	out:
1850	kfree(objp: 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(bridge: mlxsw_sp->bridge, brport_dev: 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	vid: fdb_info->vid);
1873	if (!mlxsw_sp_port_vlan)
1874	return 0;
1875
1876	fid_index = mlxsw_sp_fid_index(fid: 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	local_port: bridge_port->system_port,
1882	mac: fdb_info->addr, fid: fid_index, vid,
1883	adding, dynamic: false);
1884	else
1885	return mlxsw_sp_port_fdb_uc_lag_op(mlxsw_sp,
1886	lag_id: bridge_port->lag_id,
1887	mac: fdb_info->addr, fid: fid_index,
1888	lag_vid: vid, adding, dynamic: 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(payload: sfd_pl, op: mlxsw_sp_sfd_op(adding), record_locator: 0);
1904	mlxsw_reg_sfd_mc_pack(payload: sfd_pl, rec_index: 0, mac: mdb_entry->key.addr,
1905	fid_vid: mdb_entry->key.fid, action: MLXSW_REG_SFD_REC_ACTION_NOP,
1906	mid: mdb_entry->mid);
1907	num_rec = mlxsw_reg_sfd_num_rec_get(buf: sfd_pl);
1908	err = mlxsw_reg_write(mlxsw_core: mlxsw_sp->core, MLXSW_REG(sfd), payload: sfd_pl);
1909	if (err)
1910	goto out;
1911
1912	if (num_rec != mlxsw_reg_sfd_num_rec_get(buf: sfd_pl))
1913	err = -EBUSY;
1914
1915	out:
1916	kfree(objp: 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(nr: bridge_port->system_port, addr: 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, port_index: i);
1938	if (mlxsw_sp_port)
1939	set_bit(nr: mlxsw_sp_port->local_port,
1940	addr: 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	ports_bm: 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	local_port: i);
1973	if (IS_ERR(ptr: 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, local_port: i);
1984	return PTR_ERR(ptr: 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, local_port: 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: &ports_bm);
2006	if (err)
2007	return err;
2008
2009	mlxsw_sp_mc_get_mrouters_bitmap(flood_bm: &ports_bm, bridge_device, mlxsw_sp);
2010
2011	if (add)
2012	err = mlxsw_sp_mc_mdb_mrouters_add(mlxsw_sp, ports_bm: &ports_bm,
2013	mdb_entry);
2014	else
2015	mlxsw_sp_mc_mdb_mrouters_del(mlxsw_sp, ports_bm: &ports_bm, mdb_entry);
2016
2017	mlxsw_sp_port_bitmap_fini(ports_bm: &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(size: sizeof(*mdb_entry), GFP_KERNEL);
2031	if (!mdb_entry)
2032	return ERR_PTR(error: -ENOMEM);
2033
2034	ether_addr_copy(dst: mdb_entry->key.addr, src: addr);
2035	mdb_entry->key.fid = fid;
2036	err = mlxsw_sp_pgt_mid_alloc(mlxsw_sp, p_mid: &mdb_entry->mid);
2037	if (err)
2038	goto err_pgt_mid_alloc;
2039
2040	INIT_LIST_HEAD(list: &mdb_entry->ports_list);
2041
2042	err = mlxsw_sp_mc_mdb_mrouters_set(mlxsw_sp, bridge_device, mdb_entry,
2043	add: 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(ptr: mdb_entry_port)) {
2050	err = PTR_ERR(ptr: 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, adding: true);
2056	if (err)
2057	goto err_mdb_entry_write;
2058	}
2059
2060	err = rhashtable_insert_fast(ht: &bridge_device->mdb_ht,
2061	obj: &mdb_entry->ht_node,
2062	params: mlxsw_sp_mdb_ht_params);
2063	if (err)
2064	goto err_rhashtable_insert;
2065
2066	list_add_tail(new: &mdb_entry->list, head: &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, adding: false);
2073	err_mdb_entry_write:
2074	mlxsw_sp_mdb_entry_port_put(mlxsw_sp, mdb_entry, local_port, force: false);
2075	err_mdb_entry_port_get:
2076	mlxsw_sp_mc_mdb_mrouters_set(mlxsw_sp, bridge_device, mdb_entry, add: false);
2077	err_mdb_mrouters_set:
2078	mlxsw_sp_pgt_mid_free(mlxsw_sp, mid_base: mdb_entry->mid);
2079	err_pgt_mid_alloc:
2080	kfree(objp: mdb_entry);
2081	return ERR_PTR(error: 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(entry: &mdb_entry->list);
2091	rhashtable_remove_fast(ht: &bridge_device->mdb_ht, obj: &mdb_entry->ht_node,
2092	params: mlxsw_sp_mdb_ht_params);
2093	if (bridge_device->multicast_enabled)
2094	mlxsw_sp_mdb_entry_write(mlxsw_sp, mdb_entry, adding: 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, add: false);
2097	WARN_ON(!list_empty(&mdb_entry->ports_list));
2098	mlxsw_sp_pgt_mid_free(mlxsw_sp, mid_base: mdb_entry->mid);
2099	kfree(objp: 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(dst: key.addr, src: addr);
2111	key.fid = fid;
2112	mdb_entry = rhashtable_lookup_fast(ht: &bridge_device->mdb_ht, key: &key,
2113	params: 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(ptr: mdb_entry_port))
2121	return ERR_CAST(ptr: 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(r: &removed_entry_port->refcount) > 1)
2143	return false;
2144
2145	if (removed_entry_port->mrouter &&
2146	refcount_read(r: &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, removed_entry_port: 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(bridge: mlxsw_sp->bridge, brport_dev: 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	vid: mdb->vid);
2197	if (!mlxsw_sp_port_vlan)
2198	return 0;
2199
2200	fid_index = mlxsw_sp_fid_index(fid: mlxsw_sp_port_vlan->fid);
2201
2202	mdb_entry = mlxsw_sp_mc_mdb_entry_get(mlxsw_sp, bridge_device,
2203	addr: mdb->addr, fid: fid_index,
2204	local_port: mlxsw_sp_port->local_port);
2205	if (IS_ERR(ptr: mdb_entry))
2206	return PTR_ERR(ptr: 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, adding: 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, adding: !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: 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(dev: bridge_port->bridge_device->dev, p_proto: &proto);
2302	mlxsw_sp_port_pvid_set(mlxsw_sp_port, vid: pvid, ethtype: proto);
2303	mlxsw_sp_port_vlan_set(mlxsw_sp_port, vid_begin: vid, vid_end: vid, is_member: false, untagged: 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(dev: orig_dev))
2315	return -EOPNOTSUPP;
2316
2317	bridge_port = mlxsw_sp_bridge_port_find(bridge: mlxsw_sp->bridge, brport_dev: 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, vid: 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(bridge: mlxsw_sp->bridge, brport_dev: 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	vid: mdb->vid);
2350	if (!mlxsw_sp_port_vlan)
2351	return 0;
2352
2353	fid_index = mlxsw_sp_fid_index(fid: mlxsw_sp_port_vlan->fid);
2354
2355	ether_addr_copy(dst: key.addr, src: mdb->addr);
2356	key.fid = fid_index;
2357	mdb_entry = rhashtable_lookup_fast(ht: &bridge_device->mdb_ht, key: &key,
2358	params: mlxsw_sp_mdb_ht_params);
2359	if (!mdb_entry) {
2360	netdev_err(dev, format: "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	local_port: mlxsw_sp_port->local_port, force: 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, force: 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: 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, port_index: 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(brport_dev: bridge_port->dev, dev: mlxsw_sp_port->dev,
2452	ctx: &rso, NULL, blocking_nb: 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(brport_dev: bridge_port->dev, dev: mlxsw_sp_port->dev,
2461	ctx: &rso, NULL, blocking_nb: 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(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_vlan: 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(dev: bridge_device->dev);
2515	struct vxlan_dev *vxlan = netdev_priv(dev: 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, p_vid: &vid);
2531	if (err || !vid)
2532	return err;
2533	}
2534
2535	fid = mlxsw_sp_fid_8021q_get(mlxsw_sp, vid);
2536	if (IS_ERR(ptr: fid)) {
2537	NL_SET_ERR_MSG_MOD(extack, "Failed to create 802.1Q FID");
2538	return PTR_ERR(ptr: 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: &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(vxlan_dev: dev, p_vid: &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(dev: 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(dev: 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, br_dev: 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(dev: bridge_device->dev);
2706	struct vxlan_dev *vxlan = netdev_priv(dev: 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, br_ifindex: bridge_device->dev->ifindex);
2717	if (IS_ERR(ptr: 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: &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(dev: bridge_device->dev);
2745
2746	return mlxsw_sp_fid_8021d_get(mlxsw_sp, br_ifindex: 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(dev: 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, br_ifindex: 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, is_8021ad_tagged: true, is_8021q_tagged: 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, is_8021ad_tagged: false, is_8021q_tagged: 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, is_8021ad_tagged: false, is_8021q_tagged: 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(bridge: mlxsw_sp->bridge, brport_dev,
2887	extack);
2888	if (IS_ERR(ptr: bridge_port))
2889	return PTR_ERR(ptr: 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, upper_dev: 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(bridge: 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(bridge: 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, enable: false);
2929	mlxsw_sp_bridge_port_put(bridge: 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(bridge: 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(dev: 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, vni: 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, vxlan_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(dst: info.eth_addr, src: mac);
3014	info.vni = vni;
3015	info.offloaded = adding;
3016	call_switchdev_notifiers(val: type, dev, info: &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(val: type, dev, info: &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(payload: sfn_pl, rec_index, mac, p_vid: &fid, p_local_port: &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_index: fid);
3070	if (!mlxsw_sp_port_vlan) {
3071	netdev_err(dev: mlxsw_sp_port->dev, format: "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(dev: mlxsw_sp_port->dev, format: "{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(type: SWITCHDEV_FDB_ADD_TO_BRIDGE, mac,
3087	vid, dev: bridge_port->dev, offloaded: false, locked: true);
3088	return;
3089	}
3090
3091	do_fdb_op:
3092	err = mlxsw_sp_port_fdb_uc_op(mlxsw_sp, local_port, mac, fid, vid: evid,
3093	adding, dynamic: 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, dev: bridge_port->dev, offloaded: adding,
3103	locked: 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(payload: sfn_pl, rec_index, mac, p_vid: &fid, p_lag_id: &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_index: fid);
3137	if (!mlxsw_sp_port_vlan) {
3138	netdev_err(dev: mlxsw_sp_port->dev, format: "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(dev: mlxsw_sp_port->dev, format: "{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(type: SWITCHDEV_FDB_ADD_TO_BRIDGE, mac,
3154	vid, dev: bridge_port->dev, offloaded: false, locked: 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, dynamic: 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, dev: bridge_port->dev, offloaded: adding,
3170	locked: 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: &nve_ifindex);
3193	if (err)
3194	return err;
3195
3196	err = mlxsw_sp_fid_vni(fid, vni: p_vni);
3197	if (err)
3198	return err;
3199
3200	dev = __dev_get_by_index(net: mlxsw_sp_net(mlxsw_sp), ifindex: 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(bridge: 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(payload: sfn_pl, rec_index, mac, p_fid: &fid_index,
3248	p_uip: &uip, p_proto: &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	proto: (enum mlxsw_sp_l3proto) sfn_proto,
3256	addr: &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: &nve_dev, p_vid: &vid, p_vni: &vni);
3262	if (err)
3263	goto err_fdb_process;
3264
3265	err = mlxsw_sp_port_fdb_tunnel_uc_op(mlxsw_sp, mac, fid: fid_index,
3266	proto: (enum mlxsw_sp_l3proto) sfn_proto,
3267	addr: &addr, adding, dynamic: true);
3268	if (err)
3269	goto err_fdb_op;
3270
3271	mlxsw_sp_fdb_nve_call_notifiers(dev: nve_dev, mac,
3272	proto: (enum mlxsw_sp_l3proto) sfn_proto,
3273	addr: &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, dev: nve_dev, offloaded: adding, locked: 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: fid_index,
3292	proto: (enum mlxsw_sp_l3proto) sfn_proto, addr: &addr,
3293	adding: false, dynamic: 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(buf: sfn_pl, index: 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, adding: 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, adding: 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, adding: 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, adding: 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, adding: 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, adding: 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(head: &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(payload: sfn_pl);
3354	err = mlxsw_reg_query(mlxsw_core: mlxsw_sp->core, MLXSW_REG(sfn), payload: 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(buf: sfn_pl);
3360	for (i = 0; i < num_rec; i++)
3361	mlxsw_sp_fdb_notify_rec_process(mlxsw_sp, sfn_pl, rec_index: 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(objp: sfn_pl);
3370	if (!reschedule)
3371	return;
3372	mlxsw_sp_fdb_notify_work_schedule(mlxsw_sp, no_delay: !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, mac: fdb_info->addr, vni, fdb_info: &vxlan_fdb_info);
3401	if (err)
3402	return;
3403
3404	mlxsw_sp_switchdev_vxlan_addr_convert(vxlan_addr: &vxlan_fdb_info.remote_ip,
3405	proto: &proto, addr: &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	mac: vxlan_fdb_info.eth_addr,
3411	fid: mlxsw_sp_fid_index(fid),
3412	proto, addr: &addr, adding: true, dynamic: false);
3413	if (err)
3414	return;
3415	vxlan_fdb_info.offloaded = true;
3416	call_switchdev_notifiers(val: SWITCHDEV_VXLAN_FDB_OFFLOADED, dev,
3417	info: &vxlan_fdb_info.info, NULL);
3418	mlxsw_sp_fdb_call_notifiers(type: SWITCHDEV_FDB_OFFLOADED,
3419	mac: vxlan_fdb_info.eth_addr,
3420	vid: fdb_info->vid, dev, offloaded: true, locked: false);
3421	break;
3422	case SWITCHDEV_FDB_DEL_TO_DEVICE:
3423	err = mlxsw_sp_port_fdb_tunnel_uc_op(mlxsw_sp,
3424	mac: vxlan_fdb_info.eth_addr,
3425	fid: mlxsw_sp_fid_index(fid),
3426	proto, addr: &addr, adding: false,
3427	dynamic: false);
3428	vxlan_fdb_info.offloaded = false;
3429	call_switchdev_notifiers(val: SWITCHDEV_VXLAN_FDB_OFFLOADED, dev,
3430	info: &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(dev: br_dev))
3462	return;
3463	mlxsw_sp = mlxsw_sp_lower_get(dev: br_dev);
3464	if (!mlxsw_sp)
3465	return;
3466	bridge_device = mlxsw_sp_bridge_device_find(bridge: 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: &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, adding: true);
3511	if (err)
3512	break;
3513	mlxsw_sp_fdb_call_notifiers(type: SWITCHDEV_FDB_OFFLOADED,
3514	mac: fdb_info->addr,
3515	vid: fdb_info->vid, dev, offloaded: true, locked: 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, adding: 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: mlxsw_sp_port->mlxsw_sp);
3530
3531	out:
3532	rtnl_unlock();
3533	kfree(objp: switchdev_work->fdb_info.addr);
3534	netdev_put(dev, tracker: &switchdev_work->dev_tracker);
3535	kfree(objp: 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(bridge: mlxsw_sp->bridge, br_dev);
3557	if (!bridge_device)
3558	return;
3559
3560	fid = mlxsw_sp_fid_lookup_by_vni(mlxsw_sp, vni: vxlan_fdb_info->vni);
3561	if (!fid)
3562	return;
3563
3564	mlxsw_sp_switchdev_vxlan_addr_convert(vxlan_addr: &vxlan_fdb_info->remote_ip,
3565	proto: &proto, addr: &addr);
3566
3567	if (is_zero_ether_addr(addr: vxlan_fdb_info->eth_addr)) {
3568	err = mlxsw_sp_nve_flood_ip_add(mlxsw_sp, fid, proto, addr: &addr);
3569	if (err) {
3570	mlxsw_sp_fid_put(fid);
3571	return;
3572	}
3573	vxlan_fdb_info->offloaded = true;
3574	call_switchdev_notifiers(val: SWITCHDEV_VXLAN_FDB_OFFLOADED, dev,
3575	info: &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, addr: 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, mac: vxlan_fdb_info->eth_addr,
3590	fid: mlxsw_sp_fid_index(fid), proto,
3591	addr: &addr, adding: true, dynamic: false);
3592	if (err)
3593	goto err_fdb_tunnel_uc_op;
3594	vxlan_fdb_info->offloaded = true;
3595	call_switchdev_notifiers(val: SWITCHDEV_VXLAN_FDB_OFFLOADED, dev,
3596	info: &vxlan_fdb_info->info, NULL);
3597	mlxsw_sp_fdb_call_notifiers(type: SWITCHDEV_FDB_OFFLOADED,
3598	mac: vxlan_fdb_info->eth_addr, vid, dev, offloaded: true,
3599	locked: 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(bridge: mlxsw_sp->bridge, br_dev);
3629	if (!bridge_device)
3630	return;
3631
3632	fid = mlxsw_sp_fid_lookup_by_vni(mlxsw_sp, vni: vxlan_fdb_info->vni);
3633	if (!fid)
3634	return;
3635
3636	mlxsw_sp_switchdev_vxlan_addr_convert(vxlan_addr: &vxlan_fdb_info->remote_ip,
3637	proto: &proto, addr: &addr);
3638
3639	if (is_zero_ether_addr(addr: vxlan_fdb_info->eth_addr)) {
3640	mlxsw_sp_nve_flood_ip_del(mlxsw_sp, fid, proto, addr: &addr);
3641	mlxsw_sp_fid_put(fid);
3642	return;
3643	}
3644
3645	mlxsw_sp_port_fdb_tunnel_uc_op(mlxsw_sp, mac: vxlan_fdb_info->eth_addr,
3646	fid: mlxsw_sp_fid_index(fid), proto, addr: &addr,
3647	adding: false, dynamic: false);
3648	vid = bridge_device->ops->fid_vid(bridge_device, fid);
3649	mlxsw_sp_fdb_call_notifiers(type: SWITCHDEV_FDB_OFFLOADED,
3650	mac: vxlan_fdb_info->eth_addr, vid, dev, offloaded: false,
3651	locked: 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(dev: br_dev))
3672	goto out;
3673	mlxsw_sp = mlxsw_sp_lower_get(dev: 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, tracker: &switchdev_work->dev_tracker);
3689	kfree(objp: 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(dev: 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(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(ipa: &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(info: 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, port_attr_info: ptr,
3747	check_cb: mlxsw_sp_port_dev_check,
3748	set_cb: 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(dev: br_dev))
3757	return NOTIFY_DONE;
3758	if (!mlxsw_sp_port_dev_lower_find_rcu(dev: br_dev))
3759	return NOTIFY_DONE;
3760
3761	switchdev_work = kzalloc(size: 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(dst: (u8 *)switchdev_work->fdb_info.addr,
3784	src: 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, tracker: &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, tracker: &switchdev_work->dev_tracker, GFP_ATOMIC);
3800	break;
3801	default:
3802	kfree(objp: switchdev_work);
3803	return NOTIFY_DONE;
3804	}
3805
3806	mlxsw_core_schedule_work(work: &switchdev_work->work);
3807
3808	return NOTIFY_DONE;
3809
3810	err_vxlan_work_prepare:
3811	err_addr_alloc:
3812	kfree(objp: 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(dev: 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(br_dev: 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(dev: 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(dev: vxlan_dev);
3912	__be32 vni = vxlan->cfg.vni;
3913	struct mlxsw_sp_fid *fid;
3914
3915	if (!netif_running(dev: 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(info: &port_obj_info->info);
3947	br_dev = netdev_master_upper_dev_get(dev: vxlan_dev);
3948	if (!br_dev)
3949	return 0;
3950
3951	mlxsw_sp = mlxsw_sp_lower_get(dev: 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(bridge: 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, vid: 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(dev: vxlan_dev);
3982	if (!br_dev)
3983	return;
3984
3985	mlxsw_sp = mlxsw_sp_lower_get(dev: br_dev);
3986	if (!mlxsw_sp)
3987	return;
3988
3989	port_obj_info->handled = true;
3990
3991	bridge_device = mlxsw_sp_bridge_device_find(bridge: 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	vid: 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(info: 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(vxlan_dev: dev, port_obj_info: ptr);
4045	else
4046	err = switchdev_handle_port_obj_add(dev, port_obj_info: ptr,
4047	check_cb: mlxsw_sp_port_dev_check,
4048	add_cb: 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(vxlan_dev: dev, port_obj_info: ptr);
4053	else
4054	err = switchdev_handle_port_obj_del(dev, port_obj_info: ptr,
4055	check_cb: mlxsw_sp_port_dev_check,
4056	del_cb: 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, port_attr_info: ptr,
4060	check_cb: mlxsw_sp_port_dev_check,
4061	set_cb: 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(nb: &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(nb: &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(dwork: &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(nb: &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(size: 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(list: &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(objp: mlxsw_sp->bridge);
4167	}
4168
4169