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