drivers/net/ethernet/mellanox/mlxsw/spectrum_switchdev.c

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