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