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