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