spectrum_switchdev.c

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