mellanox/mlxsw/spectrum_switchdev.c

0001 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
0002 /* Copyright (c) 2015-2018 Mellanox Technologies. All rights reserved */
0003
0004 #include <linux/kernel.h>
0005 #include <linux/types.h>
0006 #include <linux/netdevice.h>
0007 #include <linux/etherdevice.h>
0008 #include <linux/slab.h>
0009 #include <linux/device.h>
0010 #include <linux/skbuff.h>
0011 #include <linux/if_vlan.h>
0012 #include <linux/if_bridge.h>
0013 #include <linux/workqueue.h>
0014 #include <linux/jiffies.h>
0015 #include <linux/rtnetlink.h>
0016 #include <linux/netlink.h>
0017 #include <net/switchdev.h>
0018 #include <net/vxlan.h>
0019
0020 #include "spectrum_span.h"
0021 #include "spectrum_switchdev.h"
0022 #include "spectrum.h"
0023 #include "core.h"
0024 #include "reg.h"
0025
0026 struct mlxsw_sp_bridge_ops;
0027
0028 struct mlxsw_sp_bridge {
0029     struct mlxsw_sp *mlxsw_sp;
0030     struct {
0031         struct delayed_work dw;
0032 #define MLXSW_SP_DEFAULT_LEARNING_INTERVAL 100
0033         unsigned int interval; /* ms */
0034     } fdb_notify;
0035 #define MLXSW_SP_MIN_AGEING_TIME 10
0036 #define MLXSW_SP_MAX_AGEING_TIME 1000000
0037 #define MLXSW_SP_DEFAULT_AGEING_TIME 300
0038     u32 ageing_time;
0039     bool vlan_enabled_exists;
0040     struct list_head bridges_list;
0041     DECLARE_BITMAP(mids_bitmap, MLXSW_SP_MID_MAX);
0042     const struct mlxsw_sp_bridge_ops *bridge_8021q_ops;
0043     const struct mlxsw_sp_bridge_ops *bridge_8021d_ops;
0044     const struct mlxsw_sp_bridge_ops *bridge_8021ad_ops;
0045 };
0046
0047 struct mlxsw_sp_bridge_device {
0048     struct net_device *dev;
0049     struct list_head list;
0050     struct list_head ports_list;
0051     struct list_head mdb_list;
0052     struct rhashtable mdb_ht;
0053     u8 vlan_enabled:1,
0054        multicast_enabled:1,
0055        mrouter:1;
0056     const struct mlxsw_sp_bridge_ops *ops;
0057 };
0058
0059 struct mlxsw_sp_bridge_port {
0060     struct net_device *dev;
0061     struct mlxsw_sp_bridge_device *bridge_device;
0062     struct list_head list;
0063     struct list_head vlans_list;
0064     unsigned int ref_count;
0065     u8 stp_state;
0066     unsigned long flags;
0067     bool mrouter;
0068     bool lagged;
0069     union {
0070         u16 lag_id;
0071         u16 system_port;
0072     };
0073 };
0074
0075 struct mlxsw_sp_bridge_vlan {
0076     struct list_head list;
0077     struct list_head port_vlan_list;
0078     u16 vid;
0079 };
0080
0081 struct mlxsw_sp_bridge_ops {
0082     int (*port_join)(struct mlxsw_sp_bridge_device *bridge_device,
0083              struct mlxsw_sp_bridge_port *bridge_port,
0084              struct mlxsw_sp_port *mlxsw_sp_port,
0085              struct netlink_ext_ack *extack);
0086     void (*port_leave)(struct mlxsw_sp_bridge_device *bridge_device,
0087                struct mlxsw_sp_bridge_port *bridge_port,
0088                struct mlxsw_sp_port *mlxsw_sp_port);
0089     int (*vxlan_join)(struct mlxsw_sp_bridge_device *bridge_device,
0090               const struct net_device *vxlan_dev, u16 vid,
0091               struct netlink_ext_ack *extack);
0092     struct mlxsw_sp_fid *
0093         (*fid_get)(struct mlxsw_sp_bridge_device *bridge_device,
0094                u16 vid, struct netlink_ext_ack *extack);
0095     struct mlxsw_sp_fid *
0096         (*fid_lookup)(struct mlxsw_sp_bridge_device *bridge_device,
0097                   u16 vid);
0098     u16 (*fid_vid)(struct mlxsw_sp_bridge_device *bridge_device,
0099                const struct mlxsw_sp_fid *fid);
0100 };
0101
0102 struct mlxsw_sp_switchdev_ops {
0103     void (*init)(struct mlxsw_sp *mlxsw_sp);
0104 };
0105
0106 struct mlxsw_sp_mdb_entry_key {
0107     unsigned char addr[ETH_ALEN];
0108     u16 fid;
0109 };
0110
0111 struct mlxsw_sp_mdb_entry {
0112     struct list_head list;
0113     struct rhash_head ht_node;
0114     struct mlxsw_sp_mdb_entry_key key;
0115     u16 mid;
0116     struct list_head ports_list;
0117     u16 ports_count;
0118 };
0119
0120 struct mlxsw_sp_mdb_entry_port {
0121     struct list_head list; /* Member of 'ports_list'. */
0122     u16 local_port;
0123     refcount_t refcount;
0124     bool mrouter;
0125 };
0126
0127 static const struct rhashtable_params mlxsw_sp_mdb_ht_params = {
0128     .key_offset = offsetof(struct mlxsw_sp_mdb_entry, key),
0129     .head_offset = offsetof(struct mlxsw_sp_mdb_entry, ht_node),
0130     .key_len = sizeof(struct mlxsw_sp_mdb_entry_key),
0131 };
0132
0133 static int
0134 mlxsw_sp_bridge_port_fdb_flush(struct mlxsw_sp *mlxsw_sp,
0135                    struct mlxsw_sp_bridge_port *bridge_port,
0136                    u16 fid_index);
0137
0138 static void
0139 mlxsw_sp_bridge_port_mdb_flush(struct mlxsw_sp_port *mlxsw_sp_port,
0140                    struct mlxsw_sp_bridge_port *bridge_port,
0141                    u16 fid_index);
0142
0143 static int
0144 mlxsw_sp_bridge_mdb_mc_enable_sync(struct mlxsw_sp *mlxsw_sp,
0145                    struct mlxsw_sp_bridge_device
0146                    *bridge_device, bool mc_enabled);
0147
0148 static void
0149 mlxsw_sp_port_mrouter_update_mdb(struct mlxsw_sp_port *mlxsw_sp_port,
0150                  struct mlxsw_sp_bridge_port *bridge_port,
0151                  bool add);
0152
0153 static struct mlxsw_sp_bridge_device *
0154 mlxsw_sp_bridge_device_find(const struct mlxsw_sp_bridge *bridge,
0155                 const struct net_device *br_dev)
0156 {
0157     struct mlxsw_sp_bridge_device *bridge_device;
0158
0159     list_for_each_entry(bridge_device, &bridge->bridges_list, list)
0160         if (bridge_device->dev == br_dev)
0161             return bridge_device;
0162
0163     return NULL;
0164 }
0165
0166 bool mlxsw_sp_bridge_device_is_offloaded(const struct mlxsw_sp *mlxsw_sp,
0167                      const struct net_device *br_dev)
0168 {
0169     return !!mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, br_dev);
0170 }
0171
0172 static int mlxsw_sp_bridge_device_upper_rif_destroy(struct net_device *dev,
0173                             struct netdev_nested_priv *priv)
0174 {
0175     struct mlxsw_sp *mlxsw_sp = priv->data;
0176
0177     mlxsw_sp_rif_destroy_by_dev(mlxsw_sp, dev);
0178     return 0;
0179 }
0180
0181 static void mlxsw_sp_bridge_device_rifs_destroy(struct mlxsw_sp *mlxsw_sp,
0182                         struct net_device *dev)
0183 {
0184     struct netdev_nested_priv priv = {
0185         .data = (void *)mlxsw_sp,
0186     };
0187
0188     mlxsw_sp_rif_destroy_by_dev(mlxsw_sp, dev);
0189     netdev_walk_all_upper_dev_rcu(dev,
0190                       mlxsw_sp_bridge_device_upper_rif_destroy,
0191                       &priv);
0192 }
0193
0194 static int mlxsw_sp_bridge_device_vxlan_init(struct mlxsw_sp_bridge *bridge,
0195                          struct net_device *br_dev,
0196                          struct netlink_ext_ack *extack)
0197 {
0198     struct net_device *dev, *stop_dev;
0199     struct list_head *iter;
0200     int err;
0201
0202     netdev_for_each_lower_dev(br_dev, dev, iter) {
0203         if (netif_is_vxlan(dev) && netif_running(dev)) {
0204             err = mlxsw_sp_bridge_vxlan_join(bridge->mlxsw_sp,
0205                              br_dev, dev, 0,
0206                              extack);
0207             if (err) {
0208                 stop_dev = dev;
0209                 goto err_vxlan_join;
0210             }
0211         }
0212     }
0213
0214     return 0;
0215
0216 err_vxlan_join:
0217     netdev_for_each_lower_dev(br_dev, dev, iter) {
0218         if (netif_is_vxlan(dev) && netif_running(dev)) {
0219             if (stop_dev == dev)
0220                 break;
0221             mlxsw_sp_bridge_vxlan_leave(bridge->mlxsw_sp, dev);
0222         }
0223     }
0224     return err;
0225 }
0226
0227 static void mlxsw_sp_bridge_device_vxlan_fini(struct mlxsw_sp_bridge *bridge,
0228                           struct net_device *br_dev)
0229 {
0230     struct net_device *dev;
0231     struct list_head *iter;
0232
0233     netdev_for_each_lower_dev(br_dev, dev, iter) {
0234         if (netif_is_vxlan(dev) && netif_running(dev))
0235             mlxsw_sp_bridge_vxlan_leave(bridge->mlxsw_sp, dev);
0236     }
0237 }
0238
0239 static void mlxsw_sp_fdb_notify_work_schedule(struct mlxsw_sp *mlxsw_sp,
0240                           bool no_delay)
0241 {
0242     struct mlxsw_sp_bridge *bridge = mlxsw_sp->bridge;
0243     unsigned int interval = no_delay ? 0 : bridge->fdb_notify.interval;
0244
0245     mlxsw_core_schedule_dw(&bridge->fdb_notify.dw,
0246                    msecs_to_jiffies(interval));
0247 }
0248
0249 static struct mlxsw_sp_bridge_device *
0250 mlxsw_sp_bridge_device_create(struct mlxsw_sp_bridge *bridge,
0251                   struct net_device *br_dev,
0252                   struct netlink_ext_ack *extack)
0253 {
0254     struct device *dev = bridge->mlxsw_sp->bus_info->dev;
0255     struct mlxsw_sp_bridge_device *bridge_device;
0256     bool vlan_enabled = br_vlan_enabled(br_dev);
0257     int err;
0258
0259     if (vlan_enabled && bridge->vlan_enabled_exists) {
0260         dev_err(dev, "Only one VLAN-aware bridge is supported\n");
0261         NL_SET_ERR_MSG_MOD(extack, "Only one VLAN-aware bridge is supported");
0262         return ERR_PTR(-EINVAL);
0263     }
0264
0265     bridge_device = kzalloc(sizeof(*bridge_device), GFP_KERNEL);
0266     if (!bridge_device)
0267         return ERR_PTR(-ENOMEM);
0268
0269     err = rhashtable_init(&bridge_device->mdb_ht, &mlxsw_sp_mdb_ht_params);
0270     if (err)
0271         goto err_mdb_rhashtable_init;
0272
0273     bridge_device->dev = br_dev;
0274     bridge_device->vlan_enabled = vlan_enabled;
0275     bridge_device->multicast_enabled = br_multicast_enabled(br_dev);
0276     bridge_device->mrouter = br_multicast_router(br_dev);
0277     INIT_LIST_HEAD(&bridge_device->ports_list);
0278     if (vlan_enabled) {
0279         u16 proto;
0280
0281         bridge->vlan_enabled_exists = true;
0282         br_vlan_get_proto(br_dev, &proto);
0283         if (proto == ETH_P_8021AD)
0284             bridge_device->ops = bridge->bridge_8021ad_ops;
0285         else
0286             bridge_device->ops = bridge->bridge_8021q_ops;
0287     } else {
0288         bridge_device->ops = bridge->bridge_8021d_ops;
0289     }
0290     INIT_LIST_HEAD(&bridge_device->mdb_list);
0291
0292     if (list_empty(&bridge->bridges_list))
0293         mlxsw_sp_fdb_notify_work_schedule(bridge->mlxsw_sp, false);
0294     list_add(&bridge_device->list, &bridge->bridges_list);
0295
0296     /* It is possible we already have VXLAN devices enslaved to the bridge.
0297      * In which case, we need to replay their configuration as if they were
0298      * just now enslaved to the bridge.
0299      */
0300     err = mlxsw_sp_bridge_device_vxlan_init(bridge, br_dev, extack);
0301     if (err)
0302         goto err_vxlan_init;
0303
0304     return bridge_device;
0305
0306 err_vxlan_init:
0307     list_del(&bridge_device->list);
0308     if (bridge_device->vlan_enabled)
0309         bridge->vlan_enabled_exists = false;
0310     rhashtable_destroy(&bridge_device->mdb_ht);
0311 err_mdb_rhashtable_init:
0312     kfree(bridge_device);
0313     return ERR_PTR(err);
0314 }
0315
0316 static void
0317 mlxsw_sp_bridge_device_destroy(struct mlxsw_sp_bridge *bridge,
0318                    struct mlxsw_sp_bridge_device *bridge_device)
0319 {
0320     mlxsw_sp_bridge_device_vxlan_fini(bridge, bridge_device->dev);
0321     mlxsw_sp_bridge_device_rifs_destroy(bridge->mlxsw_sp,
0322                         bridge_device->dev);
0323     list_del(&bridge_device->list);
0324     if (list_empty(&bridge->bridges_list))
0325         cancel_delayed_work(&bridge->fdb_notify.dw);
0326     if (bridge_device->vlan_enabled)
0327         bridge->vlan_enabled_exists = false;
0328     WARN_ON(!list_empty(&bridge_device->ports_list));
0329     WARN_ON(!list_empty(&bridge_device->mdb_list));
0330     rhashtable_destroy(&bridge_device->mdb_ht);
0331     kfree(bridge_device);
0332 }
0333
0334 static struct mlxsw_sp_bridge_device *
0335 mlxsw_sp_bridge_device_get(struct mlxsw_sp_bridge *bridge,
0336                struct net_device *br_dev,
0337                struct netlink_ext_ack *extack)
0338 {
0339     struct mlxsw_sp_bridge_device *bridge_device;
0340
0341     bridge_device = mlxsw_sp_bridge_device_find(bridge, br_dev);
0342     if (bridge_device)
0343         return bridge_device;
0344
0345     return mlxsw_sp_bridge_device_create(bridge, br_dev, extack);
0346 }
0347
0348 static void
0349 mlxsw_sp_bridge_device_put(struct mlxsw_sp_bridge *bridge,
0350                struct mlxsw_sp_bridge_device *bridge_device)
0351 {
0352     if (list_empty(&bridge_device->ports_list))
0353         mlxsw_sp_bridge_device_destroy(bridge, bridge_device);
0354 }
0355
0356 static struct mlxsw_sp_bridge_port *
0357 __mlxsw_sp_bridge_port_find(const struct mlxsw_sp_bridge_device *bridge_device,
0358                 const struct net_device *brport_dev)
0359 {
0360     struct mlxsw_sp_bridge_port *bridge_port;
0361
0362     list_for_each_entry(bridge_port, &bridge_device->ports_list, list) {
0363         if (bridge_port->dev == brport_dev)
0364             return bridge_port;
0365     }
0366
0367     return NULL;
0368 }
0369
0370 struct mlxsw_sp_bridge_port *
0371 mlxsw_sp_bridge_port_find(struct mlxsw_sp_bridge *bridge,
0372               struct net_device *brport_dev)
0373 {
0374     struct net_device *br_dev = netdev_master_upper_dev_get(brport_dev);
0375     struct mlxsw_sp_bridge_device *bridge_device;
0376
0377     if (!br_dev)
0378         return NULL;
0379
0380     bridge_device = mlxsw_sp_bridge_device_find(bridge, br_dev);
0381     if (!bridge_device)
0382         return NULL;
0383
0384     return __mlxsw_sp_bridge_port_find(bridge_device, brport_dev);
0385 }
0386
0387 static struct mlxsw_sp_bridge_port *
0388 mlxsw_sp_bridge_port_create(struct mlxsw_sp_bridge_device *bridge_device,
0389                 struct net_device *brport_dev,
0390                 struct netlink_ext_ack *extack)
0391 {
0392     struct mlxsw_sp_bridge_port *bridge_port;
0393     struct mlxsw_sp_port *mlxsw_sp_port;
0394     int err;
0395
0396     bridge_port = kzalloc(sizeof(*bridge_port), GFP_KERNEL);
0397     if (!bridge_port)
0398         return ERR_PTR(-ENOMEM);
0399
0400     mlxsw_sp_port = mlxsw_sp_port_dev_lower_find(brport_dev);
0401     bridge_port->lagged = mlxsw_sp_port->lagged;
0402     if (bridge_port->lagged)
0403         bridge_port->lag_id = mlxsw_sp_port->lag_id;
0404     else
0405         bridge_port->system_port = mlxsw_sp_port->local_port;
0406     bridge_port->dev = brport_dev;
0407     bridge_port->bridge_device = bridge_device;
0408     bridge_port->stp_state = BR_STATE_DISABLED;
0409     bridge_port->flags = BR_LEARNING | BR_FLOOD | BR_LEARNING_SYNC |
0410                  BR_MCAST_FLOOD;
0411     INIT_LIST_HEAD(&bridge_port->vlans_list);
0412     list_add(&bridge_port->list, &bridge_device->ports_list);
0413     bridge_port->ref_count = 1;
0414
0415     err = switchdev_bridge_port_offload(brport_dev, mlxsw_sp_port->dev,
0416                         NULL, NULL, NULL, false, extack);
0417     if (err)
0418         goto err_switchdev_offload;
0419
0420     return bridge_port;
0421
0422 err_switchdev_offload:
0423     list_del(&bridge_port->list);
0424     kfree(bridge_port);
0425     return ERR_PTR(err);
0426 }
0427
0428 static void
0429 mlxsw_sp_bridge_port_destroy(struct mlxsw_sp_bridge_port *bridge_port)
0430 {
0431     switchdev_bridge_port_unoffload(bridge_port->dev, NULL, NULL, NULL);
0432     list_del(&bridge_port->list);
0433     WARN_ON(!list_empty(&bridge_port->vlans_list));
0434     kfree(bridge_port);
0435 }
0436
0437 static struct mlxsw_sp_bridge_port *
0438 mlxsw_sp_bridge_port_get(struct mlxsw_sp_bridge *bridge,
0439              struct net_device *brport_dev,
0440              struct netlink_ext_ack *extack)
0441 {
0442     struct net_device *br_dev = netdev_master_upper_dev_get(brport_dev);
0443     struct mlxsw_sp_bridge_device *bridge_device;
0444     struct mlxsw_sp_bridge_port *bridge_port;
0445     int err;
0446
0447     bridge_port = mlxsw_sp_bridge_port_find(bridge, brport_dev);
0448     if (bridge_port) {
0449         bridge_port->ref_count++;
0450         return bridge_port;
0451     }
0452
0453     bridge_device = mlxsw_sp_bridge_device_get(bridge, br_dev, extack);
0454     if (IS_ERR(bridge_device))
0455         return ERR_CAST(bridge_device);
0456
0457     bridge_port = mlxsw_sp_bridge_port_create(bridge_device, brport_dev,
0458                           extack);
0459     if (IS_ERR(bridge_port)) {
0460         err = PTR_ERR(bridge_port);
0461         goto err_bridge_port_create;
0462     }
0463
0464     return bridge_port;
0465
0466 err_bridge_port_create:
0467     mlxsw_sp_bridge_device_put(bridge, bridge_device);
0468     return ERR_PTR(err);
0469 }
0470
0471 static void mlxsw_sp_bridge_port_put(struct mlxsw_sp_bridge *bridge,
0472                      struct mlxsw_sp_bridge_port *bridge_port)
0473 {
0474     struct mlxsw_sp_bridge_device *bridge_device;
0475
0476     if (--bridge_port->ref_count != 0)
0477         return;
0478     bridge_device = bridge_port->bridge_device;
0479     mlxsw_sp_bridge_port_destroy(bridge_port);
0480     mlxsw_sp_bridge_device_put(bridge, bridge_device);
0481 }
0482
0483 static struct mlxsw_sp_port_vlan *
0484 mlxsw_sp_port_vlan_find_by_bridge(struct mlxsw_sp_port *mlxsw_sp_port,
0485                   const struct mlxsw_sp_bridge_device *
0486                   bridge_device,
0487                   u16 vid)
0488 {
0489     struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
0490
0491     list_for_each_entry(mlxsw_sp_port_vlan, &mlxsw_sp_port->vlans_list,
0492                 list) {
0493         if (!mlxsw_sp_port_vlan->bridge_port)
0494             continue;
0495         if (mlxsw_sp_port_vlan->bridge_port->bridge_device !=
0496             bridge_device)
0497             continue;
0498         if (bridge_device->vlan_enabled &&
0499             mlxsw_sp_port_vlan->vid != vid)
0500             continue;
0501         return mlxsw_sp_port_vlan;
0502     }
0503
0504     return NULL;
0505 }
0506
0507 static struct mlxsw_sp_port_vlan*
0508 mlxsw_sp_port_vlan_find_by_fid(struct mlxsw_sp_port *mlxsw_sp_port,
0509                    u16 fid_index)
0510 {
0511     struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
0512
0513     list_for_each_entry(mlxsw_sp_port_vlan, &mlxsw_sp_port->vlans_list,
0514                 list) {
0515         struct mlxsw_sp_fid *fid = mlxsw_sp_port_vlan->fid;
0516
0517         if (fid && mlxsw_sp_fid_index(fid) == fid_index)
0518             return mlxsw_sp_port_vlan;
0519     }
0520
0521     return NULL;
0522 }
0523
0524 static struct mlxsw_sp_bridge_vlan *
0525 mlxsw_sp_bridge_vlan_find(const struct mlxsw_sp_bridge_port *bridge_port,
0526               u16 vid)
0527 {
0528     struct mlxsw_sp_bridge_vlan *bridge_vlan;
0529
0530     list_for_each_entry(bridge_vlan, &bridge_port->vlans_list, list) {
0531         if (bridge_vlan->vid == vid)
0532             return bridge_vlan;
0533     }
0534
0535     return NULL;
0536 }
0537
0538 static struct mlxsw_sp_bridge_vlan *
0539 mlxsw_sp_bridge_vlan_create(struct mlxsw_sp_bridge_port *bridge_port, u16 vid)
0540 {
0541     struct mlxsw_sp_bridge_vlan *bridge_vlan;
0542
0543     bridge_vlan = kzalloc(sizeof(*bridge_vlan), GFP_KERNEL);
0544     if (!bridge_vlan)
0545         return NULL;
0546
0547     INIT_LIST_HEAD(&bridge_vlan->port_vlan_list);
0548     bridge_vlan->vid = vid;
0549     list_add(&bridge_vlan->list, &bridge_port->vlans_list);
0550
0551     return bridge_vlan;
0552 }
0553
0554 static void
0555 mlxsw_sp_bridge_vlan_destroy(struct mlxsw_sp_bridge_vlan *bridge_vlan)
0556 {
0557     list_del(&bridge_vlan->list);
0558     WARN_ON(!list_empty(&bridge_vlan->port_vlan_list));
0559     kfree(bridge_vlan);
0560 }
0561
0562 static struct mlxsw_sp_bridge_vlan *
0563 mlxsw_sp_bridge_vlan_get(struct mlxsw_sp_bridge_port *bridge_port, u16 vid)
0564 {
0565     struct mlxsw_sp_bridge_vlan *bridge_vlan;
0566
0567     bridge_vlan = mlxsw_sp_bridge_vlan_find(bridge_port, vid);
0568     if (bridge_vlan)
0569         return bridge_vlan;
0570
0571     return mlxsw_sp_bridge_vlan_create(bridge_port, vid);
0572 }
0573
0574 static void mlxsw_sp_bridge_vlan_put(struct mlxsw_sp_bridge_vlan *bridge_vlan)
0575 {
0576     if (list_empty(&bridge_vlan->port_vlan_list))
0577         mlxsw_sp_bridge_vlan_destroy(bridge_vlan);
0578 }
0579
0580 static int
0581 mlxsw_sp_port_bridge_vlan_stp_set(struct mlxsw_sp_port *mlxsw_sp_port,
0582                   struct mlxsw_sp_bridge_vlan *bridge_vlan,
0583                   u8 state)
0584 {
0585     struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
0586
0587     list_for_each_entry(mlxsw_sp_port_vlan, &bridge_vlan->port_vlan_list,
0588                 bridge_vlan_node) {
0589         if (mlxsw_sp_port_vlan->mlxsw_sp_port != mlxsw_sp_port)
0590             continue;
0591         return mlxsw_sp_port_vid_stp_set(mlxsw_sp_port,
0592                          bridge_vlan->vid, state);
0593     }
0594
0595     return 0;
0596 }
0597
0598 static int mlxsw_sp_port_attr_stp_state_set(struct mlxsw_sp_port *mlxsw_sp_port,
0599                         struct net_device *orig_dev,
0600                         u8 state)
0601 {
0602     struct mlxsw_sp_bridge_port *bridge_port;
0603     struct mlxsw_sp_bridge_vlan *bridge_vlan;
0604     int err;
0605
0606     /* It's possible we failed to enslave the port, yet this
0607      * operation is executed due to it being deferred.
0608      */
0609     bridge_port = mlxsw_sp_bridge_port_find(mlxsw_sp_port->mlxsw_sp->bridge,
0610                         orig_dev);
0611     if (!bridge_port)
0612         return 0;
0613
0614     list_for_each_entry(bridge_vlan, &bridge_port->vlans_list, list) {
0615         err = mlxsw_sp_port_bridge_vlan_stp_set(mlxsw_sp_port,
0616                             bridge_vlan, state);
0617         if (err)
0618             goto err_port_bridge_vlan_stp_set;
0619     }
0620
0621     bridge_port->stp_state = state;
0622
0623     return 0;
0624
0625 err_port_bridge_vlan_stp_set:
0626     list_for_each_entry_continue_reverse(bridge_vlan,
0627                          &bridge_port->vlans_list, list)
0628         mlxsw_sp_port_bridge_vlan_stp_set(mlxsw_sp_port, bridge_vlan,
0629                           bridge_port->stp_state);
0630     return err;
0631 }
0632
0633 static int
0634 mlxsw_sp_port_bridge_vlan_flood_set(struct mlxsw_sp_port *mlxsw_sp_port,
0635                     struct mlxsw_sp_bridge_vlan *bridge_vlan,
0636                     enum mlxsw_sp_flood_type packet_type,
0637                     bool member)
0638 {
0639     struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
0640
0641     list_for_each_entry(mlxsw_sp_port_vlan, &bridge_vlan->port_vlan_list,
0642                 bridge_vlan_node) {
0643         if (mlxsw_sp_port_vlan->mlxsw_sp_port != mlxsw_sp_port)
0644             continue;
0645         return mlxsw_sp_fid_flood_set(mlxsw_sp_port_vlan->fid,
0646                           packet_type,
0647                           mlxsw_sp_port->local_port,
0648                           member);
0649     }
0650
0651     return 0;
0652 }
0653
0654 static int
0655 mlxsw_sp_bridge_port_flood_table_set(struct mlxsw_sp_port *mlxsw_sp_port,
0656                      struct mlxsw_sp_bridge_port *bridge_port,
0657                      enum mlxsw_sp_flood_type packet_type,
0658                      bool member)
0659 {
0660     struct mlxsw_sp_bridge_vlan *bridge_vlan;
0661     int err;
0662
0663     list_for_each_entry(bridge_vlan, &bridge_port->vlans_list, list) {
0664         err = mlxsw_sp_port_bridge_vlan_flood_set(mlxsw_sp_port,
0665                               bridge_vlan,
0666                               packet_type,
0667                               member);
0668         if (err)
0669             goto err_port_bridge_vlan_flood_set;
0670     }
0671
0672     return 0;
0673
0674 err_port_bridge_vlan_flood_set:
0675     list_for_each_entry_continue_reverse(bridge_vlan,
0676                          &bridge_port->vlans_list, list)
0677         mlxsw_sp_port_bridge_vlan_flood_set(mlxsw_sp_port, bridge_vlan,
0678                             packet_type, !member);
0679     return err;
0680 }
0681
0682 static int
0683 mlxsw_sp_bridge_vlans_flood_set(struct mlxsw_sp_bridge_vlan *bridge_vlan,
0684                 enum mlxsw_sp_flood_type packet_type,
0685                 bool member)
0686 {
0687     struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
0688     int err;
0689
0690     list_for_each_entry(mlxsw_sp_port_vlan, &bridge_vlan->port_vlan_list,
0691                 bridge_vlan_node) {
0692         u16 local_port = mlxsw_sp_port_vlan->mlxsw_sp_port->local_port;
0693
0694         err = mlxsw_sp_fid_flood_set(mlxsw_sp_port_vlan->fid,
0695                          packet_type, local_port, member);
0696         if (err)
0697             goto err_fid_flood_set;
0698     }
0699
0700     return 0;
0701
0702 err_fid_flood_set:
0703     list_for_each_entry_continue_reverse(mlxsw_sp_port_vlan,
0704                          &bridge_vlan->port_vlan_list,
0705                          list) {
0706         u16 local_port = mlxsw_sp_port_vlan->mlxsw_sp_port->local_port;
0707
0708         mlxsw_sp_fid_flood_set(mlxsw_sp_port_vlan->fid, packet_type,
0709                        local_port, !member);
0710     }
0711
0712     return err;
0713 }
0714
0715 static int
0716 mlxsw_sp_bridge_ports_flood_table_set(struct mlxsw_sp_bridge_port *bridge_port,
0717                       enum mlxsw_sp_flood_type packet_type,
0718                       bool member)
0719 {
0720     struct mlxsw_sp_bridge_vlan *bridge_vlan;
0721     int err;
0722
0723     list_for_each_entry(bridge_vlan, &bridge_port->vlans_list, list) {
0724         err = mlxsw_sp_bridge_vlans_flood_set(bridge_vlan, packet_type,
0725                               member);
0726         if (err)
0727             goto err_bridge_vlans_flood_set;
0728     }
0729
0730     return 0;
0731
0732 err_bridge_vlans_flood_set:
0733     list_for_each_entry_continue_reverse(bridge_vlan,
0734                          &bridge_port->vlans_list, list)
0735         mlxsw_sp_bridge_vlans_flood_set(bridge_vlan, packet_type,
0736                         !member);
0737     return err;
0738 }
0739
0740 static int
0741 mlxsw_sp_port_bridge_vlan_learning_set(struct mlxsw_sp_port *mlxsw_sp_port,
0742                        struct mlxsw_sp_bridge_vlan *bridge_vlan,
0743                        bool set)
0744 {
0745     struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
0746     u16 vid = bridge_vlan->vid;
0747
0748     list_for_each_entry(mlxsw_sp_port_vlan, &bridge_vlan->port_vlan_list,
0749                 bridge_vlan_node) {
0750         if (mlxsw_sp_port_vlan->mlxsw_sp_port != mlxsw_sp_port)
0751             continue;
0752         return mlxsw_sp_port_vid_learning_set(mlxsw_sp_port, vid, set);
0753     }
0754
0755     return 0;
0756 }
0757
0758 static int
0759 mlxsw_sp_bridge_port_learning_set(struct mlxsw_sp_port *mlxsw_sp_port,
0760                   struct mlxsw_sp_bridge_port *bridge_port,
0761                   bool set)
0762 {
0763     struct mlxsw_sp_bridge_vlan *bridge_vlan;
0764     int err;
0765
0766     list_for_each_entry(bridge_vlan, &bridge_port->vlans_list, list) {
0767         err = mlxsw_sp_port_bridge_vlan_learning_set(mlxsw_sp_port,
0768                                  bridge_vlan, set);
0769         if (err)
0770             goto err_port_bridge_vlan_learning_set;
0771     }
0772
0773     return 0;
0774
0775 err_port_bridge_vlan_learning_set:
0776     list_for_each_entry_continue_reverse(bridge_vlan,
0777                          &bridge_port->vlans_list, list)
0778         mlxsw_sp_port_bridge_vlan_learning_set(mlxsw_sp_port,
0779                                bridge_vlan, !set);
0780     return err;
0781 }
0782
0783 static int
0784 mlxsw_sp_port_attr_br_pre_flags_set(struct mlxsw_sp_port *mlxsw_sp_port,
0785                     struct switchdev_brport_flags flags)
0786 {
0787     if (flags.mask & ~(BR_LEARNING | BR_FLOOD | BR_MCAST_FLOOD))
0788         return -EINVAL;
0789
0790     return 0;
0791 }
0792
0793 static int mlxsw_sp_port_attr_br_flags_set(struct mlxsw_sp_port *mlxsw_sp_port,
0794                        struct net_device *orig_dev,
0795                        struct switchdev_brport_flags flags)
0796 {
0797     struct mlxsw_sp_bridge_port *bridge_port;
0798     int err;
0799
0800     bridge_port = mlxsw_sp_bridge_port_find(mlxsw_sp_port->mlxsw_sp->bridge,
0801                         orig_dev);
0802     if (!bridge_port)
0803         return 0;
0804
0805     if (flags.mask & BR_FLOOD) {
0806         err = mlxsw_sp_bridge_port_flood_table_set(mlxsw_sp_port,
0807                                bridge_port,
0808                                MLXSW_SP_FLOOD_TYPE_UC,
0809                                flags.val & BR_FLOOD);
0810         if (err)
0811             return err;
0812     }
0813
0814     if (flags.mask & BR_LEARNING) {
0815         err = mlxsw_sp_bridge_port_learning_set(mlxsw_sp_port,
0816                             bridge_port,
0817                             flags.val & BR_LEARNING);
0818         if (err)
0819             return err;
0820     }
0821
0822     if (bridge_port->bridge_device->multicast_enabled)
0823         goto out;
0824
0825     if (flags.mask & BR_MCAST_FLOOD) {
0826         err = mlxsw_sp_bridge_port_flood_table_set(mlxsw_sp_port,
0827                                bridge_port,
0828                                MLXSW_SP_FLOOD_TYPE_MC,
0829                                flags.val & BR_MCAST_FLOOD);
0830         if (err)
0831             return err;
0832     }
0833
0834 out:
0835     memcpy(&bridge_port->flags, &flags.val, sizeof(flags.val));
0836     return 0;
0837 }
0838
0839 static int mlxsw_sp_ageing_set(struct mlxsw_sp *mlxsw_sp, u32 ageing_time)
0840 {
0841     char sfdat_pl[MLXSW_REG_SFDAT_LEN];
0842     int err;
0843
0844     mlxsw_reg_sfdat_pack(sfdat_pl, ageing_time);
0845     err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(sfdat), sfdat_pl);
0846     if (err)
0847         return err;
0848     mlxsw_sp->bridge->ageing_time = ageing_time;
0849     return 0;
0850 }
0851
0852 static int mlxsw_sp_port_attr_br_ageing_set(struct mlxsw_sp_port *mlxsw_sp_port,
0853                         unsigned long ageing_clock_t)
0854 {
0855     struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
0856     unsigned long ageing_jiffies = clock_t_to_jiffies(ageing_clock_t);
0857     u32 ageing_time = jiffies_to_msecs(ageing_jiffies) / 1000;
0858
0859     if (ageing_time < MLXSW_SP_MIN_AGEING_TIME ||
0860         ageing_time > MLXSW_SP_MAX_AGEING_TIME)
0861         return -ERANGE;
0862
0863     return mlxsw_sp_ageing_set(mlxsw_sp, ageing_time);
0864 }
0865
0866 static int mlxsw_sp_port_attr_br_vlan_set(struct mlxsw_sp_port *mlxsw_sp_port,
0867                       struct net_device *orig_dev,
0868                       bool vlan_enabled)
0869 {
0870     struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
0871     struct mlxsw_sp_bridge_device *bridge_device;
0872
0873     bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, orig_dev);
0874     if (WARN_ON(!bridge_device))
0875         return -EINVAL;
0876
0877     if (bridge_device->vlan_enabled == vlan_enabled)
0878         return 0;
0879
0880     netdev_err(bridge_device->dev, "VLAN filtering can't be changed for existing bridge\n");
0881     return -EINVAL;
0882 }
0883
0884 static int mlxsw_sp_port_attr_br_vlan_proto_set(struct mlxsw_sp_port *mlxsw_sp_port,
0885                         struct net_device *orig_dev,
0886                         u16 vlan_proto)
0887 {
0888     struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
0889     struct mlxsw_sp_bridge_device *bridge_device;
0890
0891     bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, orig_dev);
0892     if (WARN_ON(!bridge_device))
0893         return -EINVAL;
0894
0895     netdev_err(bridge_device->dev, "VLAN protocol can't be changed on existing bridge\n");
0896     return -EINVAL;
0897 }
0898
0899 static int mlxsw_sp_port_attr_mrouter_set(struct mlxsw_sp_port *mlxsw_sp_port,
0900                       struct net_device *orig_dev,
0901                       bool is_port_mrouter)
0902 {
0903     struct mlxsw_sp_bridge_port *bridge_port;
0904     int err;
0905
0906     bridge_port = mlxsw_sp_bridge_port_find(mlxsw_sp_port->mlxsw_sp->bridge,
0907                         orig_dev);
0908     if (!bridge_port)
0909         return 0;
0910
0911     mlxsw_sp_port_mrouter_update_mdb(mlxsw_sp_port, bridge_port,
0912                      is_port_mrouter);
0913
0914     if (!bridge_port->bridge_device->multicast_enabled)
0915         goto out;
0916
0917     err = mlxsw_sp_bridge_port_flood_table_set(mlxsw_sp_port, bridge_port,
0918                            MLXSW_SP_FLOOD_TYPE_MC,
0919                            is_port_mrouter);
0920     if (err)
0921         return err;
0922
0923 out:
0924     bridge_port->mrouter = is_port_mrouter;
0925     return 0;
0926 }
0927
0928 static bool mlxsw_sp_mc_flood(const struct mlxsw_sp_bridge_port *bridge_port)
0929 {
0930     const struct mlxsw_sp_bridge_device *bridge_device;
0931
0932     bridge_device = bridge_port->bridge_device;
0933     return bridge_device->multicast_enabled ? bridge_port->mrouter :
0934                     bridge_port->flags & BR_MCAST_FLOOD;
0935 }
0936
0937 static int mlxsw_sp_port_mc_disabled_set(struct mlxsw_sp_port *mlxsw_sp_port,
0938                      struct net_device *orig_dev,
0939                      bool mc_disabled)
0940 {
0941     enum mlxsw_sp_flood_type packet_type = MLXSW_SP_FLOOD_TYPE_MC;
0942     struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
0943     struct mlxsw_sp_bridge_device *bridge_device;
0944     struct mlxsw_sp_bridge_port *bridge_port;
0945     int err;
0946
0947     /* It's possible we failed to enslave the port, yet this
0948      * operation is executed due to it being deferred.
0949      */
0950     bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, orig_dev);
0951     if (!bridge_device)
0952         return 0;
0953
0954     if (bridge_device->multicast_enabled == !mc_disabled)
0955         return 0;
0956
0957     bridge_device->multicast_enabled = !mc_disabled;
0958     err = mlxsw_sp_bridge_mdb_mc_enable_sync(mlxsw_sp, bridge_device,
0959                          !mc_disabled);
0960     if (err)
0961         goto err_mc_enable_sync;
0962
0963     list_for_each_entry(bridge_port, &bridge_device->ports_list, list) {
0964         bool member = mlxsw_sp_mc_flood(bridge_port);
0965
0966         err = mlxsw_sp_bridge_ports_flood_table_set(bridge_port,
0967                                 packet_type,
0968                                 member);
0969         if (err)
0970             goto err_flood_table_set;
0971     }
0972
0973     return 0;
0974
0975 err_flood_table_set:
0976     list_for_each_entry_continue_reverse(bridge_port,
0977                          &bridge_device->ports_list, list) {
0978         bool member = mlxsw_sp_mc_flood(bridge_port);
0979
0980         mlxsw_sp_bridge_ports_flood_table_set(bridge_port, packet_type,
0981                               !member);
0982     }
0983     mlxsw_sp_bridge_mdb_mc_enable_sync(mlxsw_sp, bridge_device,
0984                        mc_disabled);
0985 err_mc_enable_sync:
0986     bridge_device->multicast_enabled = mc_disabled;
0987     return err;
0988 }
0989
0990 static struct mlxsw_sp_mdb_entry_port *
0991 mlxsw_sp_mdb_entry_port_lookup(struct mlxsw_sp_mdb_entry *mdb_entry,
0992                    u16 local_port)
0993 {
0994     struct mlxsw_sp_mdb_entry_port *mdb_entry_port;
0995
0996     list_for_each_entry(mdb_entry_port, &mdb_entry->ports_list, list) {
0997         if (mdb_entry_port->local_port == local_port)
0998             return mdb_entry_port;
0999     }
1000
1001     return NULL;
1002 }
1003
1004 static struct mlxsw_sp_mdb_entry_port *
1005 mlxsw_sp_mdb_entry_port_get(struct mlxsw_sp *mlxsw_sp,
1006                 struct mlxsw_sp_mdb_entry *mdb_entry,
1007                 u16 local_port)
1008 {
1009     struct mlxsw_sp_mdb_entry_port *mdb_entry_port;
1010     int err;
1011
1012     mdb_entry_port = mlxsw_sp_mdb_entry_port_lookup(mdb_entry, local_port);
1013     if (mdb_entry_port) {
1014         if (mdb_entry_port->mrouter &&
1015             refcount_read(&mdb_entry_port->refcount) == 1)
1016             mdb_entry->ports_count++;
1017
1018         refcount_inc(&mdb_entry_port->refcount);
1019         return mdb_entry_port;
1020     }
1021
1022     err = mlxsw_sp_pgt_entry_port_set(mlxsw_sp, mdb_entry->mid,
1023                       mdb_entry->key.fid, local_port, true);
1024     if (err)
1025         return ERR_PTR(err);
1026
1027     mdb_entry_port = kzalloc(sizeof(*mdb_entry_port), GFP_KERNEL);
1028     if (!mdb_entry_port) {
1029         err = -ENOMEM;
1030         goto err_mdb_entry_port_alloc;
1031     }
1032
1033     mdb_entry_port->local_port = local_port;
1034     refcount_set(&mdb_entry_port->refcount, 1);
1035     list_add(&mdb_entry_port->list, &mdb_entry->ports_list);
1036     mdb_entry->ports_count++;
1037
1038     return mdb_entry_port;
1039
1040 err_mdb_entry_port_alloc:
1041     mlxsw_sp_pgt_entry_port_set(mlxsw_sp, mdb_entry->mid,
1042                     mdb_entry->key.fid, local_port, false);
1043     return ERR_PTR(err);
1044 }
1045
1046 static void
1047 mlxsw_sp_mdb_entry_port_put(struct mlxsw_sp *mlxsw_sp,
1048                 struct mlxsw_sp_mdb_entry *mdb_entry,
1049                 u16 local_port, bool force)
1050 {
1051     struct mlxsw_sp_mdb_entry_port *mdb_entry_port;
1052
1053     mdb_entry_port = mlxsw_sp_mdb_entry_port_lookup(mdb_entry, local_port);
1054     if (!mdb_entry_port)
1055         return;
1056
1057     if (!force && !refcount_dec_and_test(&mdb_entry_port->refcount)) {
1058         if (mdb_entry_port->mrouter &&
1059             refcount_read(&mdb_entry_port->refcount) == 1)
1060             mdb_entry->ports_count--;
1061         return;
1062     }
1063
1064     mdb_entry->ports_count--;
1065     list_del(&mdb_entry_port->list);
1066     kfree(mdb_entry_port);
1067     mlxsw_sp_pgt_entry_port_set(mlxsw_sp, mdb_entry->mid,
1068                     mdb_entry->key.fid, local_port, false);
1069 }
1070
1071 static __always_unused struct mlxsw_sp_mdb_entry_port *
1072 mlxsw_sp_mdb_entry_mrouter_port_get(struct mlxsw_sp *mlxsw_sp,
1073                     struct mlxsw_sp_mdb_entry *mdb_entry,
1074                     u16 local_port)
1075 {
1076     struct mlxsw_sp_mdb_entry_port *mdb_entry_port;
1077     int err;
1078
1079     mdb_entry_port = mlxsw_sp_mdb_entry_port_lookup(mdb_entry, local_port);
1080     if (mdb_entry_port) {
1081         if (!mdb_entry_port->mrouter)
1082             refcount_inc(&mdb_entry_port->refcount);
1083         return mdb_entry_port;
1084     }
1085
1086     err = mlxsw_sp_pgt_entry_port_set(mlxsw_sp, mdb_entry->mid,
1087                       mdb_entry->key.fid, local_port, true);
1088     if (err)
1089         return ERR_PTR(err);
1090
1091     mdb_entry_port = kzalloc(sizeof(*mdb_entry_port), GFP_KERNEL);
1092     if (!mdb_entry_port) {
1093         err = -ENOMEM;
1094         goto err_mdb_entry_port_alloc;
1095     }
1096
1097     mdb_entry_port->local_port = local_port;
1098     refcount_set(&mdb_entry_port->refcount, 1);
1099     mdb_entry_port->mrouter = true;
1100     list_add(&mdb_entry_port->list, &mdb_entry->ports_list);
1101
1102     return mdb_entry_port;
1103
1104 err_mdb_entry_port_alloc:
1105     mlxsw_sp_pgt_entry_port_set(mlxsw_sp, mdb_entry->mid,
1106                     mdb_entry->key.fid, local_port, false);
1107     return ERR_PTR(err);
1108 }
1109
1110 static __always_unused void
1111 mlxsw_sp_mdb_entry_mrouter_port_put(struct mlxsw_sp *mlxsw_sp,
1112                     struct mlxsw_sp_mdb_entry *mdb_entry,
1113                     u16 local_port)
1114 {
1115     struct mlxsw_sp_mdb_entry_port *mdb_entry_port;
1116
1117     mdb_entry_port = mlxsw_sp_mdb_entry_port_lookup(mdb_entry, local_port);
1118     if (!mdb_entry_port)
1119         return;
1120
1121     if (!mdb_entry_port->mrouter)
1122         return;
1123
1124     mdb_entry_port->mrouter = false;
1125     if (!refcount_dec_and_test(&mdb_entry_port->refcount))
1126         return;
1127
1128     list_del(&mdb_entry_port->list);
1129     kfree(mdb_entry_port);
1130     mlxsw_sp_pgt_entry_port_set(mlxsw_sp, mdb_entry->mid,
1131                     mdb_entry->key.fid, local_port, false);
1132 }
1133
1134 static void
1135 mlxsw_sp_bridge_mrouter_update_mdb(struct mlxsw_sp *mlxsw_sp,
1136                    struct mlxsw_sp_bridge_device *bridge_device,
1137                    bool add)
1138 {
1139     u16 local_port = mlxsw_sp_router_port(mlxsw_sp);
1140     struct mlxsw_sp_mdb_entry *mdb_entry;
1141
1142     list_for_each_entry(mdb_entry, &bridge_device->mdb_list, list) {
1143         if (add)
1144             mlxsw_sp_mdb_entry_mrouter_port_get(mlxsw_sp, mdb_entry,
1145                                 local_port);
1146         else
1147             mlxsw_sp_mdb_entry_mrouter_port_put(mlxsw_sp, mdb_entry,
1148                                 local_port);
1149     }
1150 }
1151
1152 static int
1153 mlxsw_sp_port_attr_br_mrouter_set(struct mlxsw_sp_port *mlxsw_sp_port,
1154                   struct net_device *orig_dev,
1155                   bool is_mrouter)
1156 {
1157     struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
1158     struct mlxsw_sp_bridge_device *bridge_device;
1159
1160     /* It's possible we failed to enslave the port, yet this
1161      * operation is executed due to it being deferred.
1162      */
1163     bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, orig_dev);
1164     if (!bridge_device)
1165         return 0;
1166
1167     if (bridge_device->mrouter != is_mrouter)
1168         mlxsw_sp_bridge_mrouter_update_mdb(mlxsw_sp, bridge_device,
1169                            is_mrouter);
1170     bridge_device->mrouter = is_mrouter;
1171     return 0;
1172 }
1173
1174 static int mlxsw_sp_port_attr_set(struct net_device *dev, const void *ctx,
1175                   const struct switchdev_attr *attr,
1176                   struct netlink_ext_ack *extack)
1177 {
1178     struct mlxsw_sp_port *mlxsw_sp_port = netdev_priv(dev);
1179     int err;
1180
1181     switch (attr->id) {
1182     case SWITCHDEV_ATTR_ID_PORT_STP_STATE:
1183         err = mlxsw_sp_port_attr_stp_state_set(mlxsw_sp_port,
1184                                attr->orig_dev,
1185                                attr->u.stp_state);
1186         break;
1187     case SWITCHDEV_ATTR_ID_PORT_PRE_BRIDGE_FLAGS:
1188         err = mlxsw_sp_port_attr_br_pre_flags_set(mlxsw_sp_port,
1189                               attr->u.brport_flags);
1190         break;
1191     case SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS:
1192         err = mlxsw_sp_port_attr_br_flags_set(mlxsw_sp_port,
1193                               attr->orig_dev,
1194                               attr->u.brport_flags);
1195         break;
1196     case SWITCHDEV_ATTR_ID_BRIDGE_AGEING_TIME:
1197         err = mlxsw_sp_port_attr_br_ageing_set(mlxsw_sp_port,
1198                                attr->u.ageing_time);
1199         break;
1200     case SWITCHDEV_ATTR_ID_BRIDGE_VLAN_FILTERING:
1201         err = mlxsw_sp_port_attr_br_vlan_set(mlxsw_sp_port,
1202                              attr->orig_dev,
1203                              attr->u.vlan_filtering);
1204         break;
1205     case SWITCHDEV_ATTR_ID_BRIDGE_VLAN_PROTOCOL:
1206         err = mlxsw_sp_port_attr_br_vlan_proto_set(mlxsw_sp_port,
1207                                attr->orig_dev,
1208                                attr->u.vlan_protocol);
1209         break;
1210     case SWITCHDEV_ATTR_ID_PORT_MROUTER:
1211         err = mlxsw_sp_port_attr_mrouter_set(mlxsw_sp_port,
1212                              attr->orig_dev,
1213                              attr->u.mrouter);
1214         break;
1215     case SWITCHDEV_ATTR_ID_BRIDGE_MC_DISABLED:
1216         err = mlxsw_sp_port_mc_disabled_set(mlxsw_sp_port,
1217                             attr->orig_dev,
1218                             attr->u.mc_disabled);
1219         break;
1220     case SWITCHDEV_ATTR_ID_BRIDGE_MROUTER:
1221         err = mlxsw_sp_port_attr_br_mrouter_set(mlxsw_sp_port,
1222                             attr->orig_dev,
1223                             attr->u.mrouter);
1224         break;
1225     default:
1226         err = -EOPNOTSUPP;
1227         break;
1228     }
1229
1230     mlxsw_sp_span_respin(mlxsw_sp_port->mlxsw_sp);
1231
1232     return err;
1233 }
1234
1235 static int
1236 mlxsw_sp_port_vlan_fid_join(struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan,
1237                 struct mlxsw_sp_bridge_port *bridge_port,
1238                 struct netlink_ext_ack *extack)
1239 {
1240     struct mlxsw_sp_port *mlxsw_sp_port = mlxsw_sp_port_vlan->mlxsw_sp_port;
1241     struct mlxsw_sp_bridge_device *bridge_device;
1242     u16 local_port = mlxsw_sp_port->local_port;
1243     u16 vid = mlxsw_sp_port_vlan->vid;
1244     struct mlxsw_sp_fid *fid;
1245     int err;
1246
1247     bridge_device = bridge_port->bridge_device;
1248     fid = bridge_device->ops->fid_get(bridge_device, vid, extack);
1249     if (IS_ERR(fid))
1250         return PTR_ERR(fid);
1251
1252     err = mlxsw_sp_fid_flood_set(fid, MLXSW_SP_FLOOD_TYPE_UC, local_port,
1253                      bridge_port->flags & BR_FLOOD);
1254     if (err)
1255         goto err_fid_uc_flood_set;
1256
1257     err = mlxsw_sp_fid_flood_set(fid, MLXSW_SP_FLOOD_TYPE_MC, local_port,
1258                      mlxsw_sp_mc_flood(bridge_port));
1259     if (err)
1260         goto err_fid_mc_flood_set;
1261
1262     err = mlxsw_sp_fid_flood_set(fid, MLXSW_SP_FLOOD_TYPE_BC, local_port,
1263                      true);
1264     if (err)
1265         goto err_fid_bc_flood_set;
1266
1267     err = mlxsw_sp_fid_port_vid_map(fid, mlxsw_sp_port, vid);
1268     if (err)
1269         goto err_fid_port_vid_map;
1270
1271     mlxsw_sp_port_vlan->fid = fid;
1272
1273     return 0;
1274
1275 err_fid_port_vid_map:
1276     mlxsw_sp_fid_flood_set(fid, MLXSW_SP_FLOOD_TYPE_BC, local_port, false);
1277 err_fid_bc_flood_set:
1278     mlxsw_sp_fid_flood_set(fid, MLXSW_SP_FLOOD_TYPE_MC, local_port, false);
1279 err_fid_mc_flood_set:
1280     mlxsw_sp_fid_flood_set(fid, MLXSW_SP_FLOOD_TYPE_UC, local_port, false);
1281 err_fid_uc_flood_set:
1282     mlxsw_sp_fid_put(fid);
1283     return err;
1284 }
1285
1286 static void
1287 mlxsw_sp_port_vlan_fid_leave(struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan)
1288 {
1289     struct mlxsw_sp_port *mlxsw_sp_port = mlxsw_sp_port_vlan->mlxsw_sp_port;
1290     struct mlxsw_sp_fid *fid = mlxsw_sp_port_vlan->fid;
1291     u16 local_port = mlxsw_sp_port->local_port;
1292     u16 vid = mlxsw_sp_port_vlan->vid;
1293
1294     mlxsw_sp_port_vlan->fid = NULL;
1295     mlxsw_sp_fid_port_vid_unmap(fid, mlxsw_sp_port, vid);
1296     mlxsw_sp_fid_flood_set(fid, MLXSW_SP_FLOOD_TYPE_BC, local_port, false);
1297     mlxsw_sp_fid_flood_set(fid, MLXSW_SP_FLOOD_TYPE_MC, local_port, false);
1298     mlxsw_sp_fid_flood_set(fid, MLXSW_SP_FLOOD_TYPE_UC, local_port, false);
1299     mlxsw_sp_fid_put(fid);
1300 }
1301
1302 static u16
1303 mlxsw_sp_port_pvid_determine(const struct mlxsw_sp_port *mlxsw_sp_port,
1304                  u16 vid, bool is_pvid)
1305 {
1306     if (is_pvid)
1307         return vid;
1308     else if (mlxsw_sp_port->pvid == vid)
1309         return 0;   /* Dis-allow untagged packets */
1310     else
1311         return mlxsw_sp_port->pvid;
1312 }
1313
1314 static int
1315 mlxsw_sp_port_vlan_bridge_join(struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan,
1316                    struct mlxsw_sp_bridge_port *bridge_port,
1317                    struct netlink_ext_ack *extack)
1318 {
1319     struct mlxsw_sp_port *mlxsw_sp_port = mlxsw_sp_port_vlan->mlxsw_sp_port;
1320     struct mlxsw_sp_bridge_vlan *bridge_vlan;
1321     u16 vid = mlxsw_sp_port_vlan->vid;
1322     int err;
1323
1324     /* No need to continue if only VLAN flags were changed */
1325     if (mlxsw_sp_port_vlan->bridge_port)
1326         return 0;
1327
1328     err = mlxsw_sp_port_vlan_fid_join(mlxsw_sp_port_vlan, bridge_port,
1329                       extack);
1330     if (err)
1331         return err;
1332
1333     err = mlxsw_sp_port_vid_learning_set(mlxsw_sp_port, vid,
1334                          bridge_port->flags & BR_LEARNING);
1335     if (err)
1336         goto err_port_vid_learning_set;
1337
1338     err = mlxsw_sp_port_vid_stp_set(mlxsw_sp_port, vid,
1339                     bridge_port->stp_state);
1340     if (err)
1341         goto err_port_vid_stp_set;
1342
1343     bridge_vlan = mlxsw_sp_bridge_vlan_get(bridge_port, vid);
1344     if (!bridge_vlan) {
1345         err = -ENOMEM;
1346         goto err_bridge_vlan_get;
1347     }
1348
1349     list_add(&mlxsw_sp_port_vlan->bridge_vlan_node,
1350          &bridge_vlan->port_vlan_list);
1351
1352     mlxsw_sp_bridge_port_get(mlxsw_sp_port->mlxsw_sp->bridge,
1353                  bridge_port->dev, extack);
1354     mlxsw_sp_port_vlan->bridge_port = bridge_port;
1355
1356     return 0;
1357
1358 err_bridge_vlan_get:
1359     mlxsw_sp_port_vid_stp_set(mlxsw_sp_port, vid, BR_STATE_DISABLED);
1360 err_port_vid_stp_set:
1361     mlxsw_sp_port_vid_learning_set(mlxsw_sp_port, vid, false);
1362 err_port_vid_learning_set:
1363     mlxsw_sp_port_vlan_fid_leave(mlxsw_sp_port_vlan);
1364     return err;
1365 }
1366
1367 void
1368 mlxsw_sp_port_vlan_bridge_leave(struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan)
1369 {
1370     struct mlxsw_sp_port *mlxsw_sp_port = mlxsw_sp_port_vlan->mlxsw_sp_port;
1371     struct mlxsw_sp_fid *fid = mlxsw_sp_port_vlan->fid;
1372     struct mlxsw_sp_bridge_vlan *bridge_vlan;
1373     struct mlxsw_sp_bridge_port *bridge_port;
1374     u16 vid = mlxsw_sp_port_vlan->vid;
1375     bool last_port;
1376
1377     if (WARN_ON(mlxsw_sp_fid_type(fid) != MLXSW_SP_FID_TYPE_8021Q &&
1378             mlxsw_sp_fid_type(fid) != MLXSW_SP_FID_TYPE_8021D))
1379         return;
1380
1381     bridge_port = mlxsw_sp_port_vlan->bridge_port;
1382     bridge_vlan = mlxsw_sp_bridge_vlan_find(bridge_port, vid);
1383     last_port = list_is_singular(&bridge_vlan->port_vlan_list);
1384
1385     list_del(&mlxsw_sp_port_vlan->bridge_vlan_node);
1386     mlxsw_sp_bridge_vlan_put(bridge_vlan);
1387     mlxsw_sp_port_vid_stp_set(mlxsw_sp_port, vid, BR_STATE_DISABLED);
1388     mlxsw_sp_port_vid_learning_set(mlxsw_sp_port, vid, false);
1389     if (last_port)
1390         mlxsw_sp_bridge_port_fdb_flush(mlxsw_sp_port->mlxsw_sp,
1391                            bridge_port,
1392                            mlxsw_sp_fid_index(fid));
1393
1394     mlxsw_sp_bridge_port_mdb_flush(mlxsw_sp_port, bridge_port,
1395                        mlxsw_sp_fid_index(fid));
1396
1397     mlxsw_sp_port_vlan_fid_leave(mlxsw_sp_port_vlan);
1398
1399     mlxsw_sp_bridge_port_put(mlxsw_sp_port->mlxsw_sp->bridge, bridge_port);
1400     mlxsw_sp_port_vlan->bridge_port = NULL;
1401 }
1402
1403 static int
1404 mlxsw_sp_bridge_port_vlan_add(struct mlxsw_sp_port *mlxsw_sp_port,
1405                   struct mlxsw_sp_bridge_port *bridge_port,
1406                   u16 vid, bool is_untagged, bool is_pvid,
1407                   struct netlink_ext_ack *extack)
1408 {
1409     u16 pvid = mlxsw_sp_port_pvid_determine(mlxsw_sp_port, vid, is_pvid);
1410     struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
1411     u16 old_pvid = mlxsw_sp_port->pvid;
1412     u16 proto;
1413     int err;
1414
1415     /* The only valid scenario in which a port-vlan already exists, is if
1416      * the VLAN flags were changed and the port-vlan is associated with the
1417      * correct bridge port
1418      */
1419     mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_vid(mlxsw_sp_port, vid);
1420     if (mlxsw_sp_port_vlan &&
1421         mlxsw_sp_port_vlan->bridge_port != bridge_port)
1422         return -EEXIST;
1423
1424     if (!mlxsw_sp_port_vlan) {
1425         mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_create(mlxsw_sp_port,
1426                                    vid);
1427         if (IS_ERR(mlxsw_sp_port_vlan))
1428             return PTR_ERR(mlxsw_sp_port_vlan);
1429     }
1430
1431     err = mlxsw_sp_port_vlan_set(mlxsw_sp_port, vid, vid, true,
1432                      is_untagged);
1433     if (err)
1434         goto err_port_vlan_set;
1435
1436     br_vlan_get_proto(bridge_port->bridge_device->dev, &proto);
1437     err = mlxsw_sp_port_pvid_set(mlxsw_sp_port, pvid, proto);
1438     if (err)
1439         goto err_port_pvid_set;
1440
1441     err = mlxsw_sp_port_vlan_bridge_join(mlxsw_sp_port_vlan, bridge_port,
1442                          extack);
1443     if (err)
1444         goto err_port_vlan_bridge_join;
1445
1446     return 0;
1447
1448 err_port_vlan_bridge_join:
1449     mlxsw_sp_port_pvid_set(mlxsw_sp_port, old_pvid, proto);
1450 err_port_pvid_set:
1451     mlxsw_sp_port_vlan_set(mlxsw_sp_port, vid, vid, false, false);
1452 err_port_vlan_set:
1453     mlxsw_sp_port_vlan_destroy(mlxsw_sp_port_vlan);
1454     return err;
1455 }
1456
1457 static int
1458 mlxsw_sp_br_ban_rif_pvid_change(struct mlxsw_sp *mlxsw_sp,
1459                 const struct net_device *br_dev,
1460                 const struct switchdev_obj_port_vlan *vlan)
1461 {
1462     u16 pvid;
1463
1464     pvid = mlxsw_sp_rif_vid(mlxsw_sp, br_dev);
1465     if (!pvid)
1466         return 0;
1467
1468     if (vlan->flags & BRIDGE_VLAN_INFO_PVID) {
1469         if (vlan->vid != pvid) {
1470             netdev_err(br_dev, "Can't change PVID, it's used by router interface\n");
1471             return -EBUSY;
1472         }
1473     } else {
1474         if (vlan->vid == pvid) {
1475             netdev_err(br_dev, "Can't remove PVID, it's used by router interface\n");
1476             return -EBUSY;
1477         }
1478     }
1479
1480     return 0;
1481 }
1482
1483 static int mlxsw_sp_port_vlans_add(struct mlxsw_sp_port *mlxsw_sp_port,
1484                    const struct switchdev_obj_port_vlan *vlan,
1485                    struct netlink_ext_ack *extack)
1486 {
1487     bool flag_untagged = vlan->flags & BRIDGE_VLAN_INFO_UNTAGGED;
1488     bool flag_pvid = vlan->flags & BRIDGE_VLAN_INFO_PVID;
1489     struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
1490     struct net_device *orig_dev = vlan->obj.orig_dev;
1491     struct mlxsw_sp_bridge_port *bridge_port;
1492
1493     if (netif_is_bridge_master(orig_dev)) {
1494         int err = 0;
1495
1496         if (br_vlan_enabled(orig_dev))
1497             err = mlxsw_sp_br_ban_rif_pvid_change(mlxsw_sp,
1498                                   orig_dev, vlan);
1499         if (!err)
1500             err = -EOPNOTSUPP;
1501         return err;
1502     }
1503
1504     bridge_port = mlxsw_sp_bridge_port_find(mlxsw_sp->bridge, orig_dev);
1505     if (WARN_ON(!bridge_port))
1506         return -EINVAL;
1507
1508     if (!bridge_port->bridge_device->vlan_enabled)
1509         return 0;
1510
1511     return mlxsw_sp_bridge_port_vlan_add(mlxsw_sp_port, bridge_port,
1512                          vlan->vid, flag_untagged,
1513                          flag_pvid, extack);
1514 }
1515
1516 static enum mlxsw_reg_sfdf_flush_type mlxsw_sp_fdb_flush_type(bool lagged)
1517 {
1518     return lagged ? MLXSW_REG_SFDF_FLUSH_PER_LAG_AND_FID :
1519             MLXSW_REG_SFDF_FLUSH_PER_PORT_AND_FID;
1520 }
1521
1522 static int
1523 mlxsw_sp_bridge_port_fdb_flush(struct mlxsw_sp *mlxsw_sp,
1524                    struct mlxsw_sp_bridge_port *bridge_port,
1525                    u16 fid_index)
1526 {
1527     bool lagged = bridge_port->lagged;
1528     char sfdf_pl[MLXSW_REG_SFDF_LEN];
1529     u16 system_port;
1530
1531     system_port = lagged ? bridge_port->lag_id : bridge_port->system_port;
1532     mlxsw_reg_sfdf_pack(sfdf_pl, mlxsw_sp_fdb_flush_type(lagged));
1533     mlxsw_reg_sfdf_fid_set(sfdf_pl, fid_index);
1534     mlxsw_reg_sfdf_port_fid_system_port_set(sfdf_pl, system_port);
1535
1536     return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(sfdf), sfdf_pl);
1537 }
1538
1539 static enum mlxsw_reg_sfd_rec_policy mlxsw_sp_sfd_rec_policy(bool dynamic)
1540 {
1541     return dynamic ? MLXSW_REG_SFD_REC_POLICY_DYNAMIC_ENTRY_INGRESS :
1542              MLXSW_REG_SFD_REC_POLICY_DYNAMIC_ENTRY_MLAG;
1543 }
1544
1545 static enum mlxsw_reg_sfd_op mlxsw_sp_sfd_op(bool adding)
1546 {
1547     return adding ? MLXSW_REG_SFD_OP_WRITE_EDIT :
1548             MLXSW_REG_SFD_OP_WRITE_REMOVE;
1549 }
1550
1551 static int
1552 mlxsw_sp_port_fdb_tun_uc_op4(struct mlxsw_sp *mlxsw_sp, bool dynamic,
1553                  const char *mac, u16 fid, __be32 addr, bool adding)
1554 {
1555     char *sfd_pl;
1556     u8 num_rec;
1557     u32 uip;
1558     int err;
1559
1560     sfd_pl = kmalloc(MLXSW_REG_SFD_LEN, GFP_KERNEL);
1561     if (!sfd_pl)
1562         return -ENOMEM;
1563
1564     uip = be32_to_cpu(addr);
1565     mlxsw_reg_sfd_pack(sfd_pl, mlxsw_sp_sfd_op(adding), 0);
1566     mlxsw_reg_sfd_uc_tunnel_pack4(sfd_pl, 0,
1567                       mlxsw_sp_sfd_rec_policy(dynamic), mac,
1568                       fid, MLXSW_REG_SFD_REC_ACTION_NOP, uip);
1569     num_rec = mlxsw_reg_sfd_num_rec_get(sfd_pl);
1570     err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(sfd), sfd_pl);
1571     if (err)
1572         goto out;
1573
1574     if (num_rec != mlxsw_reg_sfd_num_rec_get(sfd_pl))
1575         err = -EBUSY;
1576
1577 out:
1578     kfree(sfd_pl);
1579     return err;
1580 }
1581
1582 static int mlxsw_sp_port_fdb_tun_uc_op6_sfd_write(struct mlxsw_sp *mlxsw_sp,
1583                           const char *mac, u16 fid,
1584                           u32 kvdl_index, bool adding)
1585 {
1586     char *sfd_pl;
1587     u8 num_rec;
1588     int err;
1589
1590     sfd_pl = kmalloc(MLXSW_REG_SFD_LEN, GFP_KERNEL);
1591     if (!sfd_pl)
1592         return -ENOMEM;
1593
1594     mlxsw_reg_sfd_pack(sfd_pl, mlxsw_sp_sfd_op(adding), 0);
1595     mlxsw_reg_sfd_uc_tunnel_pack6(sfd_pl, 0, mac, fid,
1596                       MLXSW_REG_SFD_REC_ACTION_NOP, kvdl_index);
1597     num_rec = mlxsw_reg_sfd_num_rec_get(sfd_pl);
1598     err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(sfd), sfd_pl);
1599     if (err)
1600         goto out;
1601
1602     if (num_rec != mlxsw_reg_sfd_num_rec_get(sfd_pl))
1603         err = -EBUSY;
1604
1605 out:
1606     kfree(sfd_pl);
1607     return err;
1608 }
1609
1610 static int mlxsw_sp_port_fdb_tun_uc_op6_add(struct mlxsw_sp *mlxsw_sp,
1611                         const char *mac, u16 fid,
1612                         const struct in6_addr *addr)
1613 {
1614     u32 kvdl_index;
1615     int err;
1616
1617     err = mlxsw_sp_nve_ipv6_addr_kvdl_set(mlxsw_sp, addr, &kvdl_index);
1618     if (err)
1619         return err;
1620
1621     err = mlxsw_sp_port_fdb_tun_uc_op6_sfd_write(mlxsw_sp, mac, fid,
1622                              kvdl_index, true);
1623     if (err)
1624         goto err_sfd_write;
1625
1626     err = mlxsw_sp_nve_ipv6_addr_map_replace(mlxsw_sp, mac, fid, addr);
1627     if (err)
1628         /* Replace can fail only for creating new mapping, so removing
1629          * the FDB entry in the error path is OK.
1630          */
1631         goto err_addr_replace;
1632
1633     return 0;
1634
1635 err_addr_replace:
1636     mlxsw_sp_port_fdb_tun_uc_op6_sfd_write(mlxsw_sp, mac, fid, kvdl_index,
1637                            false);
1638 err_sfd_write:
1639     mlxsw_sp_nve_ipv6_addr_kvdl_unset(mlxsw_sp, addr);
1640     return err;
1641 }
1642
1643 static void mlxsw_sp_port_fdb_tun_uc_op6_del(struct mlxsw_sp *mlxsw_sp,
1644                          const char *mac, u16 fid,
1645                          const struct in6_addr *addr)
1646 {
1647     mlxsw_sp_nve_ipv6_addr_map_del(mlxsw_sp, mac, fid);
1648     mlxsw_sp_port_fdb_tun_uc_op6_sfd_write(mlxsw_sp, mac, fid, 0, false);
1649     mlxsw_sp_nve_ipv6_addr_kvdl_unset(mlxsw_sp, addr);
1650 }
1651
1652 static int
1653 mlxsw_sp_port_fdb_tun_uc_op6(struct mlxsw_sp *mlxsw_sp, const char *mac,
1654                  u16 fid, const struct in6_addr *addr, bool adding)
1655 {
1656     if (adding)
1657         return mlxsw_sp_port_fdb_tun_uc_op6_add(mlxsw_sp, mac, fid,
1658                             addr);
1659
1660     mlxsw_sp_port_fdb_tun_uc_op6_del(mlxsw_sp, mac, fid, addr);
1661     return 0;
1662 }
1663
1664 static int mlxsw_sp_port_fdb_tunnel_uc_op(struct mlxsw_sp *mlxsw_sp,
1665                       const char *mac, u16 fid,
1666                       enum mlxsw_sp_l3proto proto,
1667                       const union mlxsw_sp_l3addr *addr,
1668                       bool adding, bool dynamic)
1669 {
1670     switch (proto) {
1671     case MLXSW_SP_L3_PROTO_IPV4:
1672         return mlxsw_sp_port_fdb_tun_uc_op4(mlxsw_sp, dynamic, mac, fid,
1673                             addr->addr4, adding);
1674     case MLXSW_SP_L3_PROTO_IPV6:
1675         return mlxsw_sp_port_fdb_tun_uc_op6(mlxsw_sp, mac, fid,
1676                             &addr->addr6, adding);
1677     default:
1678         WARN_ON(1);
1679         return -EOPNOTSUPP;
1680     }
1681 }
1682
1683 static int __mlxsw_sp_port_fdb_uc_op(struct mlxsw_sp *mlxsw_sp, u16 local_port,
1684                      const char *mac, u16 fid, u16 vid,
1685                      bool adding,
1686                      enum mlxsw_reg_sfd_rec_action action,
1687                      enum mlxsw_reg_sfd_rec_policy policy)
1688 {
1689     char *sfd_pl;
1690     u8 num_rec;
1691     int err;
1692
1693     sfd_pl = kmalloc(MLXSW_REG_SFD_LEN, GFP_KERNEL);
1694     if (!sfd_pl)
1695         return -ENOMEM;
1696
1697     mlxsw_reg_sfd_pack(sfd_pl, mlxsw_sp_sfd_op(adding), 0);
1698     mlxsw_reg_sfd_uc_pack(sfd_pl, 0, policy, mac, fid, vid, action,
1699                   local_port);
1700     num_rec = mlxsw_reg_sfd_num_rec_get(sfd_pl);
1701     err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(sfd), sfd_pl);
1702     if (err)
1703         goto out;
1704
1705     if (num_rec != mlxsw_reg_sfd_num_rec_get(sfd_pl))
1706         err = -EBUSY;
1707
1708 out:
1709     kfree(sfd_pl);
1710     return err;
1711 }
1712
1713 static int mlxsw_sp_port_fdb_uc_op(struct mlxsw_sp *mlxsw_sp, u16 local_port,
1714                    const char *mac, u16 fid, u16 vid,
1715                    bool adding, bool dynamic)
1716 {
1717     return __mlxsw_sp_port_fdb_uc_op(mlxsw_sp, local_port, mac, fid, vid,
1718                      adding, MLXSW_REG_SFD_REC_ACTION_NOP,
1719                      mlxsw_sp_sfd_rec_policy(dynamic));
1720 }
1721
1722 int mlxsw_sp_rif_fdb_op(struct mlxsw_sp *mlxsw_sp, const char *mac, u16 fid,
1723             bool adding)
1724 {
1725     return __mlxsw_sp_port_fdb_uc_op(mlxsw_sp, 0, mac, fid, 0, adding,
1726                      MLXSW_REG_SFD_REC_ACTION_FORWARD_IP_ROUTER,
1727                      MLXSW_REG_SFD_REC_POLICY_STATIC_ENTRY);
1728 }
1729
1730 static int mlxsw_sp_port_fdb_uc_lag_op(struct mlxsw_sp *mlxsw_sp, u16 lag_id,
1731                        const char *mac, u16 fid, u16 lag_vid,
1732                        bool adding, bool dynamic)
1733 {
1734     char *sfd_pl;
1735     u8 num_rec;
1736     int err;
1737
1738     sfd_pl = kmalloc(MLXSW_REG_SFD_LEN, GFP_KERNEL);
1739     if (!sfd_pl)
1740         return -ENOMEM;
1741
1742     mlxsw_reg_sfd_pack(sfd_pl, mlxsw_sp_sfd_op(adding), 0);
1743     mlxsw_reg_sfd_uc_lag_pack(sfd_pl, 0, mlxsw_sp_sfd_rec_policy(dynamic),
1744                   mac, fid, MLXSW_REG_SFD_REC_ACTION_NOP,
1745                   lag_vid, lag_id);
1746     num_rec = mlxsw_reg_sfd_num_rec_get(sfd_pl);
1747     err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(sfd), sfd_pl);
1748     if (err)
1749         goto out;
1750
1751     if (num_rec != mlxsw_reg_sfd_num_rec_get(sfd_pl))
1752         err = -EBUSY;
1753
1754 out:
1755     kfree(sfd_pl);
1756     return err;
1757 }
1758
1759 static int
1760 mlxsw_sp_port_fdb_set(struct mlxsw_sp_port *mlxsw_sp_port,
1761               struct switchdev_notifier_fdb_info *fdb_info, bool adding)
1762 {
1763     struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
1764     struct net_device *orig_dev = fdb_info->info.dev;
1765     struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
1766     struct mlxsw_sp_bridge_device *bridge_device;
1767     struct mlxsw_sp_bridge_port *bridge_port;
1768     u16 fid_index, vid;
1769
1770     bridge_port = mlxsw_sp_bridge_port_find(mlxsw_sp->bridge, orig_dev);
1771     if (!bridge_port)
1772         return -EINVAL;
1773
1774     bridge_device = bridge_port->bridge_device;
1775     mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_bridge(mlxsw_sp_port,
1776                                    bridge_device,
1777                                    fdb_info->vid);
1778     if (!mlxsw_sp_port_vlan)
1779         return 0;
1780
1781     fid_index = mlxsw_sp_fid_index(mlxsw_sp_port_vlan->fid);
1782     vid = mlxsw_sp_port_vlan->vid;
1783
1784     if (!bridge_port->lagged)
1785         return mlxsw_sp_port_fdb_uc_op(mlxsw_sp,
1786                            bridge_port->system_port,
1787                            fdb_info->addr, fid_index, vid,
1788                            adding, false);
1789     else
1790         return mlxsw_sp_port_fdb_uc_lag_op(mlxsw_sp,
1791                            bridge_port->lag_id,
1792                            fdb_info->addr, fid_index,
1793                            vid, adding, false);
1794 }
1795
1796 static int mlxsw_sp_mdb_entry_write(struct mlxsw_sp *mlxsw_sp,
1797                     const struct mlxsw_sp_mdb_entry *mdb_entry,
1798                     bool adding)
1799 {
1800     char *sfd_pl;
1801     u8 num_rec;
1802     int err;
1803
1804     sfd_pl = kmalloc(MLXSW_REG_SFD_LEN, GFP_KERNEL);
1805     if (!sfd_pl)
1806         return -ENOMEM;
1807
1808     mlxsw_reg_sfd_pack(sfd_pl, mlxsw_sp_sfd_op(adding), 0);
1809     mlxsw_reg_sfd_mc_pack(sfd_pl, 0, mdb_entry->key.addr,
1810                   mdb_entry->key.fid, MLXSW_REG_SFD_REC_ACTION_NOP,
1811                   mdb_entry->mid);
1812     num_rec = mlxsw_reg_sfd_num_rec_get(sfd_pl);
1813     err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(sfd), sfd_pl);
1814     if (err)
1815         goto out;
1816
1817     if (num_rec != mlxsw_reg_sfd_num_rec_get(sfd_pl))
1818         err = -EBUSY;
1819
1820 out:
1821     kfree(sfd_pl);
1822     return err;
1823 }
1824
1825 static void
1826 mlxsw_sp_bridge_port_get_ports_bitmap(struct mlxsw_sp *mlxsw_sp,
1827                       struct mlxsw_sp_bridge_port *bridge_port,
1828                       struct mlxsw_sp_ports_bitmap *ports_bm)
1829 {
1830     struct mlxsw_sp_port *mlxsw_sp_port;
1831     u64 max_lag_members, i;
1832     int lag_id;
1833
1834     if (!bridge_port->lagged) {
1835         set_bit(bridge_port->system_port, ports_bm->bitmap);
1836     } else {
1837         max_lag_members = MLXSW_CORE_RES_GET(mlxsw_sp->core,
1838                              MAX_LAG_MEMBERS);
1839         lag_id = bridge_port->lag_id;
1840         for (i = 0; i < max_lag_members; i++) {
1841             mlxsw_sp_port = mlxsw_sp_port_lagged_get(mlxsw_sp,
1842                                  lag_id, i);
1843             if (mlxsw_sp_port)
1844                 set_bit(mlxsw_sp_port->local_port,
1845                     ports_bm->bitmap);
1846         }
1847     }
1848 }
1849
1850 static void
1851 mlxsw_sp_mc_get_mrouters_bitmap(struct mlxsw_sp_ports_bitmap *flood_bm,
1852                 struct mlxsw_sp_bridge_device *bridge_device,
1853                 struct mlxsw_sp *mlxsw_sp)
1854 {
1855     struct mlxsw_sp_bridge_port *bridge_port;
1856
1857     list_for_each_entry(bridge_port, &bridge_device->ports_list, list) {
1858         if (bridge_port->mrouter) {
1859             mlxsw_sp_bridge_port_get_ports_bitmap(mlxsw_sp,
1860                                   bridge_port,
1861                                   flood_bm);
1862         }
1863     }
1864 }
1865
1866 static int mlxsw_sp_mc_mdb_mrouters_add(struct mlxsw_sp *mlxsw_sp,
1867                     struct mlxsw_sp_ports_bitmap *ports_bm,
1868                     struct mlxsw_sp_mdb_entry *mdb_entry)
1869 {
1870     struct mlxsw_sp_mdb_entry_port *mdb_entry_port;
1871     unsigned int nbits = ports_bm->nbits;
1872     int i;
1873
1874     for_each_set_bit(i, ports_bm->bitmap, nbits) {
1875         mdb_entry_port = mlxsw_sp_mdb_entry_mrouter_port_get(mlxsw_sp,
1876                                      mdb_entry,
1877                                      i);
1878         if (IS_ERR(mdb_entry_port)) {
1879             nbits = i;
1880             goto err_mrouter_port_get;
1881         }
1882     }
1883
1884     return 0;
1885
1886 err_mrouter_port_get:
1887     for_each_set_bit(i, ports_bm->bitmap, nbits)
1888         mlxsw_sp_mdb_entry_mrouter_port_put(mlxsw_sp, mdb_entry, i);
1889     return PTR_ERR(mdb_entry_port);
1890 }
1891
1892 static void mlxsw_sp_mc_mdb_mrouters_del(struct mlxsw_sp *mlxsw_sp,
1893                      struct mlxsw_sp_ports_bitmap *ports_bm,
1894                      struct mlxsw_sp_mdb_entry *mdb_entry)
1895 {
1896     int i;
1897
1898     for_each_set_bit(i, ports_bm->bitmap, ports_bm->nbits)
1899         mlxsw_sp_mdb_entry_mrouter_port_put(mlxsw_sp, mdb_entry, i);
1900 }
1901
1902 static int
1903 mlxsw_sp_mc_mdb_mrouters_set(struct mlxsw_sp *mlxsw_sp,
1904                  struct mlxsw_sp_bridge_device *bridge_device,
1905                  struct mlxsw_sp_mdb_entry *mdb_entry, bool add)
1906 {
1907     struct mlxsw_sp_ports_bitmap ports_bm;
1908     int err;
1909
1910     err = mlxsw_sp_port_bitmap_init(mlxsw_sp, &ports_bm);
1911     if (err)
1912         return err;
1913
1914     mlxsw_sp_mc_get_mrouters_bitmap(&ports_bm, bridge_device, mlxsw_sp);
1915
1916     if (add)
1917         err = mlxsw_sp_mc_mdb_mrouters_add(mlxsw_sp, &ports_bm,
1918                            mdb_entry);
1919     else
1920         mlxsw_sp_mc_mdb_mrouters_del(mlxsw_sp, &ports_bm, mdb_entry);
1921
1922     mlxsw_sp_port_bitmap_fini(&ports_bm);
1923     return err;
1924 }
1925
1926 static struct mlxsw_sp_mdb_entry *
1927 mlxsw_sp_mc_mdb_entry_init(struct mlxsw_sp *mlxsw_sp,
1928                struct mlxsw_sp_bridge_device *bridge_device,
1929                const unsigned char *addr, u16 fid, u16 local_port)
1930 {
1931     struct mlxsw_sp_mdb_entry_port *mdb_entry_port;
1932     struct mlxsw_sp_mdb_entry *mdb_entry;
1933     int err;
1934
1935     mdb_entry = kzalloc(sizeof(*mdb_entry), GFP_KERNEL);
1936     if (!mdb_entry)
1937         return ERR_PTR(-ENOMEM);
1938
1939     ether_addr_copy(mdb_entry->key.addr, addr);
1940     mdb_entry->key.fid = fid;
1941     err = mlxsw_sp_pgt_mid_alloc(mlxsw_sp, &mdb_entry->mid);
1942     if (err)
1943         goto err_pgt_mid_alloc;
1944
1945     INIT_LIST_HEAD(&mdb_entry->ports_list);
1946
1947     err = mlxsw_sp_mc_mdb_mrouters_set(mlxsw_sp, bridge_device, mdb_entry,
1948                        true);
1949     if (err)
1950         goto err_mdb_mrouters_set;
1951
1952     mdb_entry_port = mlxsw_sp_mdb_entry_port_get(mlxsw_sp, mdb_entry,
1953                              local_port);
1954     if (IS_ERR(mdb_entry_port)) {
1955         err = PTR_ERR(mdb_entry_port);
1956         goto err_mdb_entry_port_get;
1957     }
1958
1959     if (bridge_device->multicast_enabled) {
1960         err = mlxsw_sp_mdb_entry_write(mlxsw_sp, mdb_entry, true);
1961         if (err)
1962             goto err_mdb_entry_write;
1963     }
1964
1965     err = rhashtable_insert_fast(&bridge_device->mdb_ht,
1966                      &mdb_entry->ht_node,
1967                      mlxsw_sp_mdb_ht_params);
1968     if (err)
1969         goto err_rhashtable_insert;
1970
1971     list_add_tail(&mdb_entry->list, &bridge_device->mdb_list);
1972
1973     return mdb_entry;
1974
1975 err_rhashtable_insert:
1976     if (bridge_device->multicast_enabled)
1977         mlxsw_sp_mdb_entry_write(mlxsw_sp, mdb_entry, false);
1978 err_mdb_entry_write:
1979     mlxsw_sp_mdb_entry_port_put(mlxsw_sp, mdb_entry, local_port, false);
1980 err_mdb_entry_port_get:
1981     mlxsw_sp_mc_mdb_mrouters_set(mlxsw_sp, bridge_device, mdb_entry, false);
1982 err_mdb_mrouters_set:
1983     mlxsw_sp_pgt_mid_free(mlxsw_sp, mdb_entry->mid);
1984 err_pgt_mid_alloc:
1985     kfree(mdb_entry);
1986     return ERR_PTR(err);
1987 }
1988
1989 static void
1990 mlxsw_sp_mc_mdb_entry_fini(struct mlxsw_sp *mlxsw_sp,
1991                struct mlxsw_sp_mdb_entry *mdb_entry,
1992                struct mlxsw_sp_bridge_device *bridge_device,
1993                u16 local_port, bool force)
1994 {
1995     list_del(&mdb_entry->list);
1996     rhashtable_remove_fast(&bridge_device->mdb_ht, &mdb_entry->ht_node,
1997                    mlxsw_sp_mdb_ht_params);
1998     if (bridge_device->multicast_enabled)
1999         mlxsw_sp_mdb_entry_write(mlxsw_sp, mdb_entry, false);
2000     mlxsw_sp_mdb_entry_port_put(mlxsw_sp, mdb_entry, local_port, force);
2001     mlxsw_sp_mc_mdb_mrouters_set(mlxsw_sp, bridge_device, mdb_entry, false);
2002     WARN_ON(!list_empty(&mdb_entry->ports_list));
2003     mlxsw_sp_pgt_mid_free(mlxsw_sp, mdb_entry->mid);
2004     kfree(mdb_entry);
2005 }
2006
2007 static struct mlxsw_sp_mdb_entry *
2008 mlxsw_sp_mc_mdb_entry_get(struct mlxsw_sp *mlxsw_sp,
2009               struct mlxsw_sp_bridge_device *bridge_device,
2010               const unsigned char *addr, u16 fid, u16 local_port)
2011 {
2012     struct mlxsw_sp_mdb_entry_key key = {};
2013     struct mlxsw_sp_mdb_entry *mdb_entry;
2014
2015     ether_addr_copy(key.addr, addr);
2016     key.fid = fid;
2017     mdb_entry = rhashtable_lookup_fast(&bridge_device->mdb_ht, &key,
2018                        mlxsw_sp_mdb_ht_params);
2019     if (mdb_entry) {
2020         struct mlxsw_sp_mdb_entry_port *mdb_entry_port;
2021
2022         mdb_entry_port = mlxsw_sp_mdb_entry_port_get(mlxsw_sp,
2023                                  mdb_entry,
2024                                  local_port);
2025         if (IS_ERR(mdb_entry_port))
2026             return ERR_CAST(mdb_entry_port);
2027
2028         return mdb_entry;
2029     }
2030
2031     return mlxsw_sp_mc_mdb_entry_init(mlxsw_sp, bridge_device, addr, fid,
2032                       local_port);
2033 }
2034
2035 static bool
2036 mlxsw_sp_mc_mdb_entry_remove(struct mlxsw_sp_mdb_entry *mdb_entry,
2037                  struct mlxsw_sp_mdb_entry_port *removed_entry_port,
2038                  bool force)
2039 {
2040     if (mdb_entry->ports_count > 1)
2041         return false;
2042
2043     if (force)
2044         return true;
2045
2046     if (!removed_entry_port->mrouter &&
2047         refcount_read(&removed_entry_port->refcount) > 1)
2048         return false;
2049
2050     if (removed_entry_port->mrouter &&
2051         refcount_read(&removed_entry_port->refcount) > 2)
2052         return false;
2053
2054     return true;
2055 }
2056
2057 static void
2058 mlxsw_sp_mc_mdb_entry_put(struct mlxsw_sp *mlxsw_sp,
2059               struct mlxsw_sp_bridge_device *bridge_device,
2060               struct mlxsw_sp_mdb_entry *mdb_entry, u16 local_port,
2061               bool force)
2062 {
2063     struct mlxsw_sp_mdb_entry_port *mdb_entry_port;
2064
2065     mdb_entry_port = mlxsw_sp_mdb_entry_port_lookup(mdb_entry, local_port);
2066     if (!mdb_entry_port)
2067         return;
2068
2069     /* Avoid a temporary situation in which the MDB entry points to an empty
2070      * PGT entry, as otherwise packets will be temporarily dropped instead
2071      * of being flooded. Instead, in this situation, call
2072      * mlxsw_sp_mc_mdb_entry_fini(), which first deletes the MDB entry and
2073      * then releases the PGT entry.
2074      */
2075     if (mlxsw_sp_mc_mdb_entry_remove(mdb_entry, mdb_entry_port, force))
2076         mlxsw_sp_mc_mdb_entry_fini(mlxsw_sp, mdb_entry, bridge_device,
2077                        local_port, force);
2078     else
2079         mlxsw_sp_mdb_entry_port_put(mlxsw_sp, mdb_entry, local_port,
2080                         force);
2081 }
2082
2083 static int mlxsw_sp_port_mdb_add(struct mlxsw_sp_port *mlxsw_sp_port,
2084                  const struct switchdev_obj_port_mdb *mdb)
2085 {
2086     struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
2087     struct net_device *orig_dev = mdb->obj.orig_dev;
2088     struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
2089     struct mlxsw_sp_bridge_device *bridge_device;
2090     struct mlxsw_sp_bridge_port *bridge_port;
2091     struct mlxsw_sp_mdb_entry *mdb_entry;
2092     u16 fid_index;
2093
2094     bridge_port = mlxsw_sp_bridge_port_find(mlxsw_sp->bridge, orig_dev);
2095     if (!bridge_port)
2096         return 0;
2097
2098     bridge_device = bridge_port->bridge_device;
2099     mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_bridge(mlxsw_sp_port,
2100                                    bridge_device,
2101                                    mdb->vid);
2102     if (!mlxsw_sp_port_vlan)
2103         return 0;
2104
2105     fid_index = mlxsw_sp_fid_index(mlxsw_sp_port_vlan->fid);
2106
2107     mdb_entry = mlxsw_sp_mc_mdb_entry_get(mlxsw_sp, bridge_device,
2108                           mdb->addr, fid_index,
2109                           mlxsw_sp_port->local_port);
2110     if (IS_ERR(mdb_entry))
2111         return PTR_ERR(mdb_entry);
2112
2113     return 0;
2114 }
2115
2116 static int
2117 mlxsw_sp_bridge_mdb_mc_enable_sync(struct mlxsw_sp *mlxsw_sp,
2118                    struct mlxsw_sp_bridge_device *bridge_device,
2119                    bool mc_enabled)
2120 {
2121     struct mlxsw_sp_mdb_entry *mdb_entry;
2122     int err;
2123
2124     list_for_each_entry(mdb_entry, &bridge_device->mdb_list, list) {
2125         err = mlxsw_sp_mdb_entry_write(mlxsw_sp, mdb_entry, mc_enabled);
2126         if (err)
2127             goto err_mdb_entry_write;
2128     }
2129     return 0;
2130
2131 err_mdb_entry_write:
2132     list_for_each_entry_continue_reverse(mdb_entry,
2133                          &bridge_device->mdb_list, list)
2134         mlxsw_sp_mdb_entry_write(mlxsw_sp, mdb_entry, !mc_enabled);
2135     return err;
2136 }
2137
2138 static void
2139 mlxsw_sp_port_mrouter_update_mdb(struct mlxsw_sp_port *mlxsw_sp_port,
2140                  struct mlxsw_sp_bridge_port *bridge_port,
2141                  bool add)
2142 {
2143     struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
2144     struct mlxsw_sp_bridge_device *bridge_device;
2145     u16 local_port = mlxsw_sp_port->local_port;
2146     struct mlxsw_sp_mdb_entry *mdb_entry;
2147
2148     bridge_device = bridge_port->bridge_device;
2149
2150     list_for_each_entry(mdb_entry, &bridge_device->mdb_list, list) {
2151         if (add)
2152             mlxsw_sp_mdb_entry_mrouter_port_get(mlxsw_sp, mdb_entry,
2153                                 local_port);
2154         else
2155             mlxsw_sp_mdb_entry_mrouter_port_put(mlxsw_sp, mdb_entry,
2156                                 local_port);
2157     }
2158 }
2159
2160 static int mlxsw_sp_port_obj_add(struct net_device *dev, const void *ctx,
2161                  const struct switchdev_obj *obj,
2162                  struct netlink_ext_ack *extack)
2163 {
2164     struct mlxsw_sp_port *mlxsw_sp_port = netdev_priv(dev);
2165     const struct switchdev_obj_port_vlan *vlan;
2166     int err = 0;
2167
2168     switch (obj->id) {
2169     case SWITCHDEV_OBJ_ID_PORT_VLAN:
2170         vlan = SWITCHDEV_OBJ_PORT_VLAN(obj);
2171
2172         err = mlxsw_sp_port_vlans_add(mlxsw_sp_port, vlan, extack);
2173
2174         /* The event is emitted before the changes are actually
2175          * applied to the bridge. Therefore schedule the respin
2176          * call for later, so that the respin logic sees the
2177          * updated bridge state.
2178          */
2179         mlxsw_sp_span_respin(mlxsw_sp_port->mlxsw_sp);
2180         break;
2181     case SWITCHDEV_OBJ_ID_PORT_MDB:
2182         err = mlxsw_sp_port_mdb_add(mlxsw_sp_port,
2183                         SWITCHDEV_OBJ_PORT_MDB(obj));
2184         break;
2185     default:
2186         err = -EOPNOTSUPP;
2187         break;
2188     }
2189
2190     return err;
2191 }
2192
2193 static void
2194 mlxsw_sp_bridge_port_vlan_del(struct mlxsw_sp_port *mlxsw_sp_port,
2195                   struct mlxsw_sp_bridge_port *bridge_port, u16 vid)
2196 {
2197     u16 pvid = mlxsw_sp_port->pvid == vid ? 0 : mlxsw_sp_port->pvid;
2198     struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
2199     u16 proto;
2200
2201     mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_vid(mlxsw_sp_port, vid);
2202     if (WARN_ON(!mlxsw_sp_port_vlan))
2203         return;
2204
2205     mlxsw_sp_port_vlan_bridge_leave(mlxsw_sp_port_vlan);
2206     br_vlan_get_proto(bridge_port->bridge_device->dev, &proto);
2207     mlxsw_sp_port_pvid_set(mlxsw_sp_port, pvid, proto);
2208     mlxsw_sp_port_vlan_set(mlxsw_sp_port, vid, vid, false, false);
2209     mlxsw_sp_port_vlan_destroy(mlxsw_sp_port_vlan);
2210 }
2211
2212 static int mlxsw_sp_port_vlans_del(struct mlxsw_sp_port *mlxsw_sp_port,
2213                    const struct switchdev_obj_port_vlan *vlan)
2214 {
2215     struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
2216     struct net_device *orig_dev = vlan->obj.orig_dev;
2217     struct mlxsw_sp_bridge_port *bridge_port;
2218
2219     if (netif_is_bridge_master(orig_dev))
2220         return -EOPNOTSUPP;
2221
2222     bridge_port = mlxsw_sp_bridge_port_find(mlxsw_sp->bridge, orig_dev);
2223     if (WARN_ON(!bridge_port))
2224         return -EINVAL;
2225
2226     if (!bridge_port->bridge_device->vlan_enabled)
2227         return 0;
2228
2229     mlxsw_sp_bridge_port_vlan_del(mlxsw_sp_port, bridge_port, vlan->vid);
2230
2231     return 0;
2232 }
2233
2234 static int mlxsw_sp_port_mdb_del(struct mlxsw_sp_port *mlxsw_sp_port,
2235                  const struct switchdev_obj_port_mdb *mdb)
2236 {
2237     struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
2238     struct net_device *orig_dev = mdb->obj.orig_dev;
2239     struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
2240     struct mlxsw_sp_bridge_device *bridge_device;
2241     struct net_device *dev = mlxsw_sp_port->dev;
2242     struct mlxsw_sp_bridge_port *bridge_port;
2243     struct mlxsw_sp_mdb_entry_key key = {};
2244     struct mlxsw_sp_mdb_entry *mdb_entry;
2245     u16 fid_index;
2246
2247     bridge_port = mlxsw_sp_bridge_port_find(mlxsw_sp->bridge, orig_dev);
2248     if (!bridge_port)
2249         return 0;
2250
2251     bridge_device = bridge_port->bridge_device;
2252     mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_bridge(mlxsw_sp_port,
2253                                    bridge_device,
2254                                    mdb->vid);
2255     if (!mlxsw_sp_port_vlan)
2256         return 0;
2257
2258     fid_index = mlxsw_sp_fid_index(mlxsw_sp_port_vlan->fid);
2259
2260     ether_addr_copy(key.addr, mdb->addr);
2261     key.fid = fid_index;
2262     mdb_entry = rhashtable_lookup_fast(&bridge_device->mdb_ht, &key,
2263                        mlxsw_sp_mdb_ht_params);
2264     if (!mdb_entry) {
2265         netdev_err(dev, "Unable to remove port from MC DB\n");
2266         return -EINVAL;
2267     }
2268
2269     mlxsw_sp_mc_mdb_entry_put(mlxsw_sp, bridge_device, mdb_entry,
2270                   mlxsw_sp_port->local_port, false);
2271     return 0;
2272 }
2273
2274 static void
2275 mlxsw_sp_bridge_port_mdb_flush(struct mlxsw_sp_port *mlxsw_sp_port,
2276                    struct mlxsw_sp_bridge_port *bridge_port,
2277                    u16 fid_index)
2278 {
2279     struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
2280     struct mlxsw_sp_bridge_device *bridge_device;
2281     struct mlxsw_sp_mdb_entry *mdb_entry, *tmp;
2282     u16 local_port = mlxsw_sp_port->local_port;
2283
2284     bridge_device = bridge_port->bridge_device;
2285
2286     list_for_each_entry_safe(mdb_entry, tmp, &bridge_device->mdb_list,
2287                  list) {
2288         if (mdb_entry->key.fid != fid_index)
2289             continue;
2290
2291         if (bridge_port->mrouter)
2292             mlxsw_sp_mdb_entry_mrouter_port_put(mlxsw_sp,
2293                                 mdb_entry,
2294                                 local_port);
2295
2296         mlxsw_sp_mc_mdb_entry_put(mlxsw_sp, bridge_device, mdb_entry,
2297                       local_port, true);
2298     }
2299 }
2300
2301 static int mlxsw_sp_port_obj_del(struct net_device *dev, const void *ctx,
2302                  const struct switchdev_obj *obj)
2303 {
2304     struct mlxsw_sp_port *mlxsw_sp_port = netdev_priv(dev);
2305     int err = 0;
2306
2307     switch (obj->id) {
2308     case SWITCHDEV_OBJ_ID_PORT_VLAN:
2309         err = mlxsw_sp_port_vlans_del(mlxsw_sp_port,
2310                           SWITCHDEV_OBJ_PORT_VLAN(obj));
2311         break;
2312     case SWITCHDEV_OBJ_ID_PORT_MDB:
2313         err = mlxsw_sp_port_mdb_del(mlxsw_sp_port,
2314                         SWITCHDEV_OBJ_PORT_MDB(obj));
2315         break;
2316     default:
2317         err = -EOPNOTSUPP;
2318         break;
2319     }
2320
2321     mlxsw_sp_span_respin(mlxsw_sp_port->mlxsw_sp);
2322
2323     return err;
2324 }
2325
2326 static struct mlxsw_sp_port *mlxsw_sp_lag_rep_port(struct mlxsw_sp *mlxsw_sp,
2327                            u16 lag_id)
2328 {
2329     struct mlxsw_sp_port *mlxsw_sp_port;
2330     u64 max_lag_members;
2331     int i;
2332
2333     max_lag_members = MLXSW_CORE_RES_GET(mlxsw_sp->core,
2334                          MAX_LAG_MEMBERS);
2335     for (i = 0; i < max_lag_members; i++) {
2336         mlxsw_sp_port = mlxsw_sp_port_lagged_get(mlxsw_sp, lag_id, i);
2337         if (mlxsw_sp_port)
2338             return mlxsw_sp_port;
2339     }
2340     return NULL;
2341 }
2342
2343 static int
2344 mlxsw_sp_bridge_vlan_aware_port_join(struct mlxsw_sp_bridge_port *bridge_port,
2345                      struct mlxsw_sp_port *mlxsw_sp_port,
2346                      struct netlink_ext_ack *extack)
2347 {
2348     if (is_vlan_dev(bridge_port->dev)) {
2349         NL_SET_ERR_MSG_MOD(extack, "Can not enslave a VLAN device to a VLAN-aware bridge");
2350         return -EINVAL;
2351     }
2352
2353     /* Port is no longer usable as a router interface */
2354     if (mlxsw_sp_port->default_vlan->fid)
2355         mlxsw_sp_port_vlan_router_leave(mlxsw_sp_port->default_vlan);
2356
2357     return 0;
2358 }
2359
2360 static int
2361 mlxsw_sp_bridge_8021q_port_join(struct mlxsw_sp_bridge_device *bridge_device,
2362                 struct mlxsw_sp_bridge_port *bridge_port,
2363                 struct mlxsw_sp_port *mlxsw_sp_port,
2364                 struct netlink_ext_ack *extack)
2365 {
2366     return mlxsw_sp_bridge_vlan_aware_port_join(bridge_port, mlxsw_sp_port,
2367                             extack);
2368 }
2369
2370 static void
2371 mlxsw_sp_bridge_vlan_aware_port_leave(struct mlxsw_sp_port *mlxsw_sp_port)
2372 {
2373     /* Make sure untagged frames are allowed to ingress */
2374     mlxsw_sp_port_pvid_set(mlxsw_sp_port, MLXSW_SP_DEFAULT_VID,
2375                    ETH_P_8021Q);
2376 }
2377
2378 static void
2379 mlxsw_sp_bridge_8021q_port_leave(struct mlxsw_sp_bridge_device *bridge_device,
2380                  struct mlxsw_sp_bridge_port *bridge_port,
2381                  struct mlxsw_sp_port *mlxsw_sp_port)
2382 {
2383     mlxsw_sp_bridge_vlan_aware_port_leave(mlxsw_sp_port);
2384 }
2385
2386 static int
2387 mlxsw_sp_bridge_vlan_aware_vxlan_join(struct mlxsw_sp_bridge_device *bridge_device,
2388                       const struct net_device *vxlan_dev,
2389                       u16 vid, u16 ethertype,
2390                       struct netlink_ext_ack *extack)
2391 {
2392     struct mlxsw_sp *mlxsw_sp = mlxsw_sp_lower_get(bridge_device->dev);
2393     struct vxlan_dev *vxlan = netdev_priv(vxlan_dev);
2394     struct mlxsw_sp_nve_params params = {
2395         .type = MLXSW_SP_NVE_TYPE_VXLAN,
2396         .vni = vxlan->cfg.vni,
2397         .dev = vxlan_dev,
2398         .ethertype = ethertype,
2399     };
2400     struct mlxsw_sp_fid *fid;
2401     int err;
2402
2403     /* If the VLAN is 0, we need to find the VLAN that is configured as
2404      * PVID and egress untagged on the bridge port of the VxLAN device.
2405      * It is possible no such VLAN exists
2406      */
2407     if (!vid) {
2408         err = mlxsw_sp_vxlan_mapped_vid(vxlan_dev, &vid);
2409         if (err || !vid)
2410             return err;
2411     }
2412
2413     fid = mlxsw_sp_fid_8021q_get(mlxsw_sp, vid);
2414     if (IS_ERR(fid)) {
2415         NL_SET_ERR_MSG_MOD(extack, "Failed to create 802.1Q FID");
2416         return PTR_ERR(fid);
2417     }
2418
2419     if (mlxsw_sp_fid_vni_is_set(fid)) {
2420         NL_SET_ERR_MSG_MOD(extack, "VNI is already set on FID");
2421         err = -EINVAL;
2422         goto err_vni_exists;
2423     }
2424
2425     err = mlxsw_sp_nve_fid_enable(mlxsw_sp, fid, &params, extack);
2426     if (err)
2427         goto err_nve_fid_enable;
2428
2429     return 0;
2430
2431 err_nve_fid_enable:
2432 err_vni_exists:
2433     mlxsw_sp_fid_put(fid);
2434     return err;
2435 }
2436
2437 static int
2438 mlxsw_sp_bridge_8021q_vxlan_join(struct mlxsw_sp_bridge_device *bridge_device,
2439                  const struct net_device *vxlan_dev, u16 vid,
2440                  struct netlink_ext_ack *extack)
2441 {
2442     return mlxsw_sp_bridge_vlan_aware_vxlan_join(bridge_device, vxlan_dev,
2443                              vid, ETH_P_8021Q, extack);
2444 }
2445
2446 static struct net_device *
2447 mlxsw_sp_bridge_8021q_vxlan_dev_find(struct net_device *br_dev, u16 vid)
2448 {
2449     struct net_device *dev;
2450     struct list_head *iter;
2451
2452     netdev_for_each_lower_dev(br_dev, dev, iter) {
2453         u16 pvid;
2454         int err;
2455
2456         if (!netif_is_vxlan(dev))
2457             continue;
2458
2459         err = mlxsw_sp_vxlan_mapped_vid(dev, &pvid);
2460         if (err || pvid != vid)
2461             continue;
2462
2463         return dev;
2464     }
2465
2466     return NULL;
2467 }
2468
2469 static struct mlxsw_sp_fid *
2470 mlxsw_sp_bridge_8021q_fid_get(struct mlxsw_sp_bridge_device *bridge_device,
2471                   u16 vid, struct netlink_ext_ack *extack)
2472 {
2473     struct mlxsw_sp *mlxsw_sp = mlxsw_sp_lower_get(bridge_device->dev);
2474
2475     return mlxsw_sp_fid_8021q_get(mlxsw_sp, vid);
2476 }
2477
2478 static struct mlxsw_sp_fid *
2479 mlxsw_sp_bridge_8021q_fid_lookup(struct mlxsw_sp_bridge_device *bridge_device,
2480                  u16 vid)
2481 {
2482     struct mlxsw_sp *mlxsw_sp = mlxsw_sp_lower_get(bridge_device->dev);
2483
2484     return mlxsw_sp_fid_8021q_lookup(mlxsw_sp, vid);
2485 }
2486
2487 static u16
2488 mlxsw_sp_bridge_8021q_fid_vid(struct mlxsw_sp_bridge_device *bridge_device,
2489                   const struct mlxsw_sp_fid *fid)
2490 {
2491     return mlxsw_sp_fid_8021q_vid(fid);
2492 }
2493
2494 static const struct mlxsw_sp_bridge_ops mlxsw_sp_bridge_8021q_ops = {
2495     .port_join  = mlxsw_sp_bridge_8021q_port_join,
2496     .port_leave = mlxsw_sp_bridge_8021q_port_leave,
2497     .vxlan_join = mlxsw_sp_bridge_8021q_vxlan_join,
2498     .fid_get    = mlxsw_sp_bridge_8021q_fid_get,
2499     .fid_lookup = mlxsw_sp_bridge_8021q_fid_lookup,
2500     .fid_vid    = mlxsw_sp_bridge_8021q_fid_vid,
2501 };
2502
2503 static bool
2504 mlxsw_sp_port_is_br_member(const struct mlxsw_sp_port *mlxsw_sp_port,
2505                const struct net_device *br_dev)
2506 {
2507     struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
2508
2509     list_for_each_entry(mlxsw_sp_port_vlan, &mlxsw_sp_port->vlans_list,
2510                 list) {
2511         if (mlxsw_sp_port_vlan->bridge_port &&
2512             mlxsw_sp_port_vlan->bridge_port->bridge_device->dev ==
2513             br_dev)
2514             return true;
2515     }
2516
2517     return false;
2518 }
2519
2520 static int
2521 mlxsw_sp_bridge_8021d_port_join(struct mlxsw_sp_bridge_device *bridge_device,
2522                 struct mlxsw_sp_bridge_port *bridge_port,
2523                 struct mlxsw_sp_port *mlxsw_sp_port,
2524                 struct netlink_ext_ack *extack)
2525 {
2526     struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
2527     struct net_device *dev = bridge_port->dev;
2528     u16 vid;
2529
2530     vid = is_vlan_dev(dev) ? vlan_dev_vlan_id(dev) : MLXSW_SP_DEFAULT_VID;
2531     mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_vid(mlxsw_sp_port, vid);
2532     if (WARN_ON(!mlxsw_sp_port_vlan))
2533         return -EINVAL;
2534
2535     if (mlxsw_sp_port_is_br_member(mlxsw_sp_port, bridge_device->dev)) {
2536         NL_SET_ERR_MSG_MOD(extack, "Can not bridge VLAN uppers of the same port");
2537         return -EINVAL;
2538     }
2539
2540     /* Port is no longer usable as a router interface */
2541     if (mlxsw_sp_port_vlan->fid)
2542         mlxsw_sp_port_vlan_router_leave(mlxsw_sp_port_vlan);
2543
2544     return mlxsw_sp_port_vlan_bridge_join(mlxsw_sp_port_vlan, bridge_port,
2545                           extack);
2546 }
2547
2548 static void
2549 mlxsw_sp_bridge_8021d_port_leave(struct mlxsw_sp_bridge_device *bridge_device,
2550                  struct mlxsw_sp_bridge_port *bridge_port,
2551                  struct mlxsw_sp_port *mlxsw_sp_port)
2552 {
2553     struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
2554     struct net_device *dev = bridge_port->dev;
2555     u16 vid;
2556
2557     vid = is_vlan_dev(dev) ? vlan_dev_vlan_id(dev) : MLXSW_SP_DEFAULT_VID;
2558     mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_vid(mlxsw_sp_port, vid);
2559     if (!mlxsw_sp_port_vlan || !mlxsw_sp_port_vlan->bridge_port)
2560         return;
2561
2562     mlxsw_sp_port_vlan_bridge_leave(mlxsw_sp_port_vlan);
2563 }
2564
2565 static int
2566 mlxsw_sp_bridge_8021d_vxlan_join(struct mlxsw_sp_bridge_device *bridge_device,
2567                  const struct net_device *vxlan_dev, u16 vid,
2568                  struct netlink_ext_ack *extack)
2569 {
2570     struct mlxsw_sp *mlxsw_sp = mlxsw_sp_lower_get(bridge_device->dev);
2571     struct vxlan_dev *vxlan = netdev_priv(vxlan_dev);
2572     struct mlxsw_sp_nve_params params = {
2573         .type = MLXSW_SP_NVE_TYPE_VXLAN,
2574         .vni = vxlan->cfg.vni,
2575         .dev = vxlan_dev,
2576         .ethertype = ETH_P_8021Q,
2577     };
2578     struct mlxsw_sp_fid *fid;
2579     int err;
2580
2581     fid = mlxsw_sp_fid_8021d_get(mlxsw_sp, bridge_device->dev->ifindex);
2582     if (IS_ERR(fid)) {
2583         NL_SET_ERR_MSG_MOD(extack, "Failed to create 802.1D FID");
2584         return -EINVAL;
2585     }
2586
2587     if (mlxsw_sp_fid_vni_is_set(fid)) {
2588         NL_SET_ERR_MSG_MOD(extack, "VNI is already set on FID");
2589         err = -EINVAL;
2590         goto err_vni_exists;
2591     }
2592
2593     err = mlxsw_sp_nve_fid_enable(mlxsw_sp, fid, &params, extack);
2594     if (err)
2595         goto err_nve_fid_enable;
2596
2597     return 0;
2598
2599 err_nve_fid_enable:
2600 err_vni_exists:
2601     mlxsw_sp_fid_put(fid);
2602     return err;
2603 }
2604
2605 static struct mlxsw_sp_fid *
2606 mlxsw_sp_bridge_8021d_fid_get(struct mlxsw_sp_bridge_device *bridge_device,
2607                   u16 vid, struct netlink_ext_ack *extack)
2608 {
2609     struct mlxsw_sp *mlxsw_sp = mlxsw_sp_lower_get(bridge_device->dev);
2610
2611     return mlxsw_sp_fid_8021d_get(mlxsw_sp, bridge_device->dev->ifindex);
2612 }
2613
2614 static struct mlxsw_sp_fid *
2615 mlxsw_sp_bridge_8021d_fid_lookup(struct mlxsw_sp_bridge_device *bridge_device,
2616                  u16 vid)
2617 {
2618     struct mlxsw_sp *mlxsw_sp = mlxsw_sp_lower_get(bridge_device->dev);
2619
2620     /* The only valid VLAN for a VLAN-unaware bridge is 0 */
2621     if (vid)
2622         return NULL;
2623
2624     return mlxsw_sp_fid_8021d_lookup(mlxsw_sp, bridge_device->dev->ifindex);
2625 }
2626
2627 static u16
2628 mlxsw_sp_bridge_8021d_fid_vid(struct mlxsw_sp_bridge_device *bridge_device,
2629                   const struct mlxsw_sp_fid *fid)
2630 {
2631     return 0;
2632 }
2633
2634 static const struct mlxsw_sp_bridge_ops mlxsw_sp_bridge_8021d_ops = {
2635     .port_join  = mlxsw_sp_bridge_8021d_port_join,
2636     .port_leave = mlxsw_sp_bridge_8021d_port_leave,
2637     .vxlan_join = mlxsw_sp_bridge_8021d_vxlan_join,
2638     .fid_get    = mlxsw_sp_bridge_8021d_fid_get,
2639     .fid_lookup = mlxsw_sp_bridge_8021d_fid_lookup,
2640     .fid_vid    = mlxsw_sp_bridge_8021d_fid_vid,
2641 };
2642
2643 static int
2644 mlxsw_sp_bridge_8021ad_port_join(struct mlxsw_sp_bridge_device *bridge_device,
2645                  struct mlxsw_sp_bridge_port *bridge_port,
2646                  struct mlxsw_sp_port *mlxsw_sp_port,
2647                  struct netlink_ext_ack *extack)
2648 {
2649     int err;
2650
2651     err = mlxsw_sp_port_vlan_classification_set(mlxsw_sp_port, true, false);
2652     if (err)
2653         return err;
2654
2655     err = mlxsw_sp_bridge_vlan_aware_port_join(bridge_port, mlxsw_sp_port,
2656                            extack);
2657     if (err)
2658         goto err_bridge_vlan_aware_port_join;
2659
2660     return 0;
2661
2662 err_bridge_vlan_aware_port_join:
2663     mlxsw_sp_port_vlan_classification_set(mlxsw_sp_port, false, true);
2664     return err;
2665 }
2666
2667 static void
2668 mlxsw_sp_bridge_8021ad_port_leave(struct mlxsw_sp_bridge_device *bridge_device,
2669                   struct mlxsw_sp_bridge_port *bridge_port,
2670                   struct mlxsw_sp_port *mlxsw_sp_port)
2671 {
2672     mlxsw_sp_bridge_vlan_aware_port_leave(mlxsw_sp_port);
2673     mlxsw_sp_port_vlan_classification_set(mlxsw_sp_port, false, true);
2674 }
2675
2676 static int
2677 mlxsw_sp_bridge_8021ad_vxlan_join(struct mlxsw_sp_bridge_device *bridge_device,
2678                   const struct net_device *vxlan_dev, u16 vid,
2679                   struct netlink_ext_ack *extack)
2680 {
2681     return mlxsw_sp_bridge_vlan_aware_vxlan_join(bridge_device, vxlan_dev,
2682                              vid, ETH_P_8021AD, extack);
2683 }
2684
2685 static const struct mlxsw_sp_bridge_ops mlxsw_sp1_bridge_8021ad_ops = {
2686     .port_join  = mlxsw_sp_bridge_8021ad_port_join,
2687     .port_leave = mlxsw_sp_bridge_8021ad_port_leave,
2688     .vxlan_join = mlxsw_sp_bridge_8021ad_vxlan_join,
2689     .fid_get    = mlxsw_sp_bridge_8021q_fid_get,
2690     .fid_lookup = mlxsw_sp_bridge_8021q_fid_lookup,
2691     .fid_vid    = mlxsw_sp_bridge_8021q_fid_vid,
2692 };
2693
2694 static int
2695 mlxsw_sp2_bridge_8021ad_port_join(struct mlxsw_sp_bridge_device *bridge_device,
2696                   struct mlxsw_sp_bridge_port *bridge_port,
2697                   struct mlxsw_sp_port *mlxsw_sp_port,
2698                   struct netlink_ext_ack *extack)
2699 {
2700     int err;
2701
2702     /* The EtherType of decapsulated packets is determined at the egress
2703      * port to allow 802.1d and 802.1ad bridges with VXLAN devices to
2704      * co-exist.
2705      */
2706     err = mlxsw_sp_port_egress_ethtype_set(mlxsw_sp_port, ETH_P_8021AD);
2707     if (err)
2708         return err;
2709
2710     err = mlxsw_sp_bridge_8021ad_port_join(bridge_device, bridge_port,
2711                            mlxsw_sp_port, extack);
2712     if (err)
2713         goto err_bridge_8021ad_port_join;
2714
2715     return 0;
2716
2717 err_bridge_8021ad_port_join:
2718     mlxsw_sp_port_egress_ethtype_set(mlxsw_sp_port, ETH_P_8021Q);
2719     return err;
2720 }
2721
2722 static void
2723 mlxsw_sp2_bridge_8021ad_port_leave(struct mlxsw_sp_bridge_device *bridge_device,
2724                    struct mlxsw_sp_bridge_port *bridge_port,
2725                    struct mlxsw_sp_port *mlxsw_sp_port)
2726 {
2727     mlxsw_sp_bridge_8021ad_port_leave(bridge_device, bridge_port,
2728                       mlxsw_sp_port);
2729     mlxsw_sp_port_egress_ethtype_set(mlxsw_sp_port, ETH_P_8021Q);
2730 }
2731
2732 static const struct mlxsw_sp_bridge_ops mlxsw_sp2_bridge_8021ad_ops = {
2733     .port_join  = mlxsw_sp2_bridge_8021ad_port_join,
2734     .port_leave = mlxsw_sp2_bridge_8021ad_port_leave,
2735     .vxlan_join = mlxsw_sp_bridge_8021ad_vxlan_join,
2736     .fid_get    = mlxsw_sp_bridge_8021q_fid_get,
2737     .fid_lookup = mlxsw_sp_bridge_8021q_fid_lookup,
2738     .fid_vid    = mlxsw_sp_bridge_8021q_fid_vid,
2739 };
2740
2741 int mlxsw_sp_port_bridge_join(struct mlxsw_sp_port *mlxsw_sp_port,
2742                   struct net_device *brport_dev,
2743                   struct net_device *br_dev,
2744                   struct netlink_ext_ack *extack)
2745 {
2746     struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
2747     struct mlxsw_sp_bridge_device *bridge_device;
2748     struct mlxsw_sp_bridge_port *bridge_port;
2749     int err;
2750
2751     bridge_port = mlxsw_sp_bridge_port_get(mlxsw_sp->bridge, brport_dev,
2752                            extack);
2753     if (IS_ERR(bridge_port))
2754         return PTR_ERR(bridge_port);
2755     bridge_device = bridge_port->bridge_device;
2756
2757     err = bridge_device->ops->port_join(bridge_device, bridge_port,
2758                         mlxsw_sp_port, extack);
2759     if (err)
2760         goto err_port_join;
2761
2762     return 0;
2763
2764 err_port_join:
2765     mlxsw_sp_bridge_port_put(mlxsw_sp->bridge, bridge_port);
2766     return err;
2767 }
2768
2769 void mlxsw_sp_port_bridge_leave(struct mlxsw_sp_port *mlxsw_sp_port,
2770                 struct net_device *brport_dev,
2771                 struct net_device *br_dev)
2772 {
2773     struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
2774     struct mlxsw_sp_bridge_device *bridge_device;
2775     struct mlxsw_sp_bridge_port *bridge_port;
2776
2777     bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, br_dev);
2778     if (!bridge_device)
2779         return;
2780     bridge_port = __mlxsw_sp_bridge_port_find(bridge_device, brport_dev);
2781     if (!bridge_port)
2782         return;
2783
2784     bridge_device->ops->port_leave(bridge_device, bridge_port,
2785                        mlxsw_sp_port);
2786     mlxsw_sp_bridge_port_put(mlxsw_sp->bridge, bridge_port);
2787 }
2788
2789 int mlxsw_sp_bridge_vxlan_join(struct mlxsw_sp *mlxsw_sp,
2790                    const struct net_device *br_dev,
2791                    const struct net_device *vxlan_dev, u16 vid,
2792                    struct netlink_ext_ack *extack)
2793 {
2794     struct mlxsw_sp_bridge_device *bridge_device;
2795
2796     bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, br_dev);
2797     if (WARN_ON(!bridge_device))
2798         return -EINVAL;
2799
2800     return bridge_device->ops->vxlan_join(bridge_device, vxlan_dev, vid,
2801                           extack);
2802 }
2803
2804 void mlxsw_sp_bridge_vxlan_leave(struct mlxsw_sp *mlxsw_sp,
2805                  const struct net_device *vxlan_dev)
2806 {
2807     struct vxlan_dev *vxlan = netdev_priv(vxlan_dev);
2808     struct mlxsw_sp_fid *fid;
2809
2810     /* If the VxLAN device is down, then the FID does not have a VNI */
2811     fid = mlxsw_sp_fid_lookup_by_vni(mlxsw_sp, vxlan->cfg.vni);
2812     if (!fid)
2813         return;
2814
2815     mlxsw_sp_nve_fid_disable(mlxsw_sp, fid);
2816     /* Drop both the reference we just took during lookup and the reference
2817      * the VXLAN device took.
2818      */
2819     mlxsw_sp_fid_put(fid);
2820     mlxsw_sp_fid_put(fid);
2821 }
2822
2823 static void
2824 mlxsw_sp_switchdev_vxlan_addr_convert(const union vxlan_addr *vxlan_addr,
2825                       enum mlxsw_sp_l3proto *proto,
2826                       union mlxsw_sp_l3addr *addr)
2827 {
2828     if (vxlan_addr->sa.sa_family == AF_INET) {
2829         addr->addr4 = vxlan_addr->sin.sin_addr.s_addr;
2830         *proto = MLXSW_SP_L3_PROTO_IPV4;
2831     } else {
2832         addr->addr6 = vxlan_addr->sin6.sin6_addr;
2833         *proto = MLXSW_SP_L3_PROTO_IPV6;
2834     }
2835 }
2836
2837 static void
2838 mlxsw_sp_switchdev_addr_vxlan_convert(enum mlxsw_sp_l3proto proto,
2839                       const union mlxsw_sp_l3addr *addr,
2840                       union vxlan_addr *vxlan_addr)
2841 {
2842     switch (proto) {
2843     case MLXSW_SP_L3_PROTO_IPV4:
2844         vxlan_addr->sa.sa_family = AF_INET;
2845         vxlan_addr->sin.sin_addr.s_addr = addr->addr4;
2846         break;
2847     case MLXSW_SP_L3_PROTO_IPV6:
2848         vxlan_addr->sa.sa_family = AF_INET6;
2849         vxlan_addr->sin6.sin6_addr = addr->addr6;
2850         break;
2851     }
2852 }
2853
2854 static void mlxsw_sp_fdb_vxlan_call_notifiers(struct net_device *dev,
2855                           const char *mac,
2856                           enum mlxsw_sp_l3proto proto,
2857                           union mlxsw_sp_l3addr *addr,
2858                           __be32 vni, bool adding)
2859 {
2860     struct switchdev_notifier_vxlan_fdb_info info;
2861     struct vxlan_dev *vxlan = netdev_priv(dev);
2862     enum switchdev_notifier_type type;
2863
2864     type = adding ? SWITCHDEV_VXLAN_FDB_ADD_TO_BRIDGE :
2865             SWITCHDEV_VXLAN_FDB_DEL_TO_BRIDGE;
2866     mlxsw_sp_switchdev_addr_vxlan_convert(proto, addr, &info.remote_ip);
2867     info.remote_port = vxlan->cfg.dst_port;
2868     info.remote_vni = vni;
2869     info.remote_ifindex = 0;
2870     ether_addr_copy(info.eth_addr, mac);
2871     info.vni = vni;
2872     info.offloaded = adding;
2873     call_switchdev_notifiers(type, dev, &info.info, NULL);
2874 }
2875
2876 static void mlxsw_sp_fdb_nve_call_notifiers(struct net_device *dev,
2877                         const char *mac,
2878                         enum mlxsw_sp_l3proto proto,
2879                         union mlxsw_sp_l3addr *addr,
2880                         __be32 vni,
2881                         bool adding)
2882 {
2883     if (netif_is_vxlan(dev))
2884         mlxsw_sp_fdb_vxlan_call_notifiers(dev, mac, proto, addr, vni,
2885                           adding);
2886 }
2887
2888 static void
2889 mlxsw_sp_fdb_call_notifiers(enum switchdev_notifier_type type,
2890                 const char *mac, u16 vid,
2891                 struct net_device *dev, bool offloaded)
2892 {
2893     struct switchdev_notifier_fdb_info info = {};
2894
2895     info.addr = mac;
2896     info.vid = vid;
2897     info.offloaded = offloaded;
2898     call_switchdev_notifiers(type, dev, &info.info, NULL);
2899 }
2900
2901 static void mlxsw_sp_fdb_notify_mac_process(struct mlxsw_sp *mlxsw_sp,
2902                         char *sfn_pl, int rec_index,
2903                         bool adding)
2904 {
2905     struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
2906     struct mlxsw_sp_bridge_device *bridge_device;
2907     struct mlxsw_sp_bridge_port *bridge_port;
2908     struct mlxsw_sp_port *mlxsw_sp_port;
2909     u16 local_port, vid, fid, evid = 0;
2910     enum switchdev_notifier_type type;
2911     char mac[ETH_ALEN];
2912     bool do_notification = true;
2913     int err;
2914
2915     mlxsw_reg_sfn_mac_unpack(sfn_pl, rec_index, mac, &fid, &local_port);
2916
2917     if (WARN_ON_ONCE(!mlxsw_sp_local_port_is_valid(mlxsw_sp, local_port)))
2918         return;
2919     mlxsw_sp_port = mlxsw_sp->ports[local_port];
2920     if (!mlxsw_sp_port) {
2921         dev_err_ratelimited(mlxsw_sp->bus_info->dev, "Incorrect local port in FDB notification\n");
2922         goto just_remove;
2923     }
2924
2925     if (mlxsw_sp_fid_is_dummy(mlxsw_sp, fid))
2926         goto just_remove;
2927
2928     mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_fid(mlxsw_sp_port, fid);
2929     if (!mlxsw_sp_port_vlan) {
2930         netdev_err(mlxsw_sp_port->dev, "Failed to find a matching {Port, VID} following FDB notification\n");
2931         goto just_remove;
2932     }
2933
2934     bridge_port = mlxsw_sp_port_vlan->bridge_port;
2935     if (!bridge_port) {
2936         netdev_err(mlxsw_sp_port->dev, "{Port, VID} not associated with a bridge\n");
2937         goto just_remove;
2938     }
2939
2940     bridge_device = bridge_port->bridge_device;
2941     vid = bridge_device->vlan_enabled ? mlxsw_sp_port_vlan->vid : 0;
2942     evid = mlxsw_sp_port_vlan->vid;
2943
2944 do_fdb_op:
2945     err = mlxsw_sp_port_fdb_uc_op(mlxsw_sp, local_port, mac, fid, evid,
2946                       adding, true);
2947     if (err) {
2948         dev_err_ratelimited(mlxsw_sp->bus_info->dev, "Failed to set FDB entry\n");
2949         return;
2950     }
2951
2952     if (!do_notification)
2953         return;
2954     type = adding ? SWITCHDEV_FDB_ADD_TO_BRIDGE : SWITCHDEV_FDB_DEL_TO_BRIDGE;
2955     mlxsw_sp_fdb_call_notifiers(type, mac, vid, bridge_port->dev, adding);
2956
2957     return;
2958
2959 just_remove:
2960     adding = false;
2961     do_notification = false;
2962     goto do_fdb_op;
2963 }
2964
2965 static void mlxsw_sp_fdb_notify_mac_lag_process(struct mlxsw_sp *mlxsw_sp,
2966                         char *sfn_pl, int rec_index,
2967                         bool adding)
2968 {
2969     struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
2970     struct mlxsw_sp_bridge_device *bridge_device;
2971     struct mlxsw_sp_bridge_port *bridge_port;
2972     struct mlxsw_sp_port *mlxsw_sp_port;
2973     enum switchdev_notifier_type type;
2974     char mac[ETH_ALEN];
2975     u16 lag_vid = 0;
2976     u16 lag_id;
2977     u16 vid, fid;
2978     bool do_notification = true;
2979     int err;
2980
2981     mlxsw_reg_sfn_mac_lag_unpack(sfn_pl, rec_index, mac, &fid, &lag_id);
2982     mlxsw_sp_port = mlxsw_sp_lag_rep_port(mlxsw_sp, lag_id);
2983     if (!mlxsw_sp_port) {
2984         dev_err_ratelimited(mlxsw_sp->bus_info->dev, "Cannot find port representor for LAG\n");
2985         goto just_remove;
2986     }
2987
2988     if (mlxsw_sp_fid_is_dummy(mlxsw_sp, fid))
2989         goto just_remove;
2990
2991     mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_fid(mlxsw_sp_port, fid);
2992     if (!mlxsw_sp_port_vlan) {
2993         netdev_err(mlxsw_sp_port->dev, "Failed to find a matching {Port, VID} following FDB notification\n");
2994         goto just_remove;
2995     }
2996
2997     bridge_port = mlxsw_sp_port_vlan->bridge_port;
2998     if (!bridge_port) {
2999         netdev_err(mlxsw_sp_port->dev, "{Port, VID} not associated with a bridge\n");
3000         goto just_remove;
3001     }
3002
3003     bridge_device = bridge_port->bridge_device;
3004     vid = bridge_device->vlan_enabled ? mlxsw_sp_port_vlan->vid : 0;
3005     lag_vid = mlxsw_sp_port_vlan->vid;
3006
3007 do_fdb_op:
3008     err = mlxsw_sp_port_fdb_uc_lag_op(mlxsw_sp, lag_id, mac, fid, lag_vid,
3009                       adding, true);
3010     if (err) {
3011         dev_err_ratelimited(mlxsw_sp->bus_info->dev, "Failed to set FDB entry\n");
3012         return;
3013     }
3014
3015     if (!do_notification)
3016         return;
3017     type = adding ? SWITCHDEV_FDB_ADD_TO_BRIDGE : SWITCHDEV_FDB_DEL_TO_BRIDGE;
3018     mlxsw_sp_fdb_call_notifiers(type, mac, vid, bridge_port->dev, adding);
3019
3020     return;
3021
3022 just_remove:
3023     adding = false;
3024     do_notification = false;
3025     goto do_fdb_op;
3026 }
3027
3028 static int
3029 __mlxsw_sp_fdb_notify_mac_uc_tunnel_process(struct mlxsw_sp *mlxsw_sp,
3030                         const struct mlxsw_sp_fid *fid,
3031                         bool adding,
3032                         struct net_device **nve_dev,
3033                         u16 *p_vid, __be32 *p_vni)
3034 {
3035     struct mlxsw_sp_bridge_device *bridge_device;
3036     struct net_device *br_dev, *dev;
3037     int nve_ifindex;
3038     int err;
3039
3040     err = mlxsw_sp_fid_nve_ifindex(fid, &nve_ifindex);
3041     if (err)
3042         return err;
3043
3044     err = mlxsw_sp_fid_vni(fid, p_vni);
3045     if (err)
3046         return err;
3047
3048     dev = __dev_get_by_index(mlxsw_sp_net(mlxsw_sp), nve_ifindex);
3049     if (!dev)
3050         return -EINVAL;
3051     *nve_dev = dev;
3052
3053     if (!netif_running(dev))
3054         return -EINVAL;
3055
3056     if (adding && !br_port_flag_is_set(dev, BR_LEARNING))
3057         return -EINVAL;
3058
3059     if (adding && netif_is_vxlan(dev)) {
3060         struct vxlan_dev *vxlan = netdev_priv(dev);
3061
3062         if (!(vxlan->cfg.flags & VXLAN_F_LEARN))
3063             return -EINVAL;
3064     }
3065
3066     br_dev = netdev_master_upper_dev_get(dev);
3067     if (!br_dev)
3068         return -EINVAL;
3069
3070     bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, br_dev);
3071     if (!bridge_device)
3072         return -EINVAL;
3073
3074     *p_vid = bridge_device->ops->fid_vid(bridge_device, fid);
3075
3076     return 0;
3077 }
3078
3079 static void mlxsw_sp_fdb_notify_mac_uc_tunnel_process(struct mlxsw_sp *mlxsw_sp,
3080                               char *sfn_pl,
3081                               int rec_index,
3082                               bool adding)
3083 {
3084     enum mlxsw_reg_sfn_uc_tunnel_protocol sfn_proto;
3085     enum switchdev_notifier_type type;
3086     struct net_device *nve_dev;
3087     union mlxsw_sp_l3addr addr;
3088     struct mlxsw_sp_fid *fid;
3089     char mac[ETH_ALEN];
3090     u16 fid_index, vid;
3091     __be32 vni;
3092     u32 uip;
3093     int err;
3094
3095     mlxsw_reg_sfn_uc_tunnel_unpack(sfn_pl, rec_index, mac, &fid_index,
3096                        &uip, &sfn_proto);
3097
3098     fid = mlxsw_sp_fid_lookup_by_index(mlxsw_sp, fid_index);
3099     if (!fid)
3100         goto err_fid_lookup;
3101
3102     err = mlxsw_sp_nve_learned_ip_resolve(mlxsw_sp, uip,
3103                           (enum mlxsw_sp_l3proto) sfn_proto,
3104                           &addr);
3105     if (err)
3106         goto err_ip_resolve;
3107
3108     err = __mlxsw_sp_fdb_notify_mac_uc_tunnel_process(mlxsw_sp, fid, adding,
3109                               &nve_dev, &vid, &vni);
3110     if (err)
3111         goto err_fdb_process;
3112
3113     err = mlxsw_sp_port_fdb_tunnel_uc_op(mlxsw_sp, mac, fid_index,
3114                          (enum mlxsw_sp_l3proto) sfn_proto,
3115                          &addr, adding, true);
3116     if (err)
3117         goto err_fdb_op;
3118
3119     mlxsw_sp_fdb_nve_call_notifiers(nve_dev, mac,
3120                     (enum mlxsw_sp_l3proto) sfn_proto,
3121                     &addr, vni, adding);
3122
3123     type = adding ? SWITCHDEV_FDB_ADD_TO_BRIDGE :
3124             SWITCHDEV_FDB_DEL_TO_BRIDGE;
3125     mlxsw_sp_fdb_call_notifiers(type, mac, vid, nve_dev, adding);
3126
3127     mlxsw_sp_fid_put(fid);
3128
3129     return;
3130
3131 err_fdb_op:
3132 err_fdb_process:
3133 err_ip_resolve:
3134     mlxsw_sp_fid_put(fid);
3135 err_fid_lookup:
3136     /* Remove an FDB entry in case we cannot process it. Otherwise the
3137      * device will keep sending the same notification over and over again.
3138      */
3139     mlxsw_sp_port_fdb_tunnel_uc_op(mlxsw_sp, mac, fid_index,
3140                        (enum mlxsw_sp_l3proto) sfn_proto, &addr,
3141                        false, true);
3142 }
3143
3144 static void mlxsw_sp_fdb_notify_rec_process(struct mlxsw_sp *mlxsw_sp,
3145                         char *sfn_pl, int rec_index)
3146 {
3147     switch (mlxsw_reg_sfn_rec_type_get(sfn_pl, rec_index)) {
3148     case MLXSW_REG_SFN_REC_TYPE_LEARNED_MAC:
3149         mlxsw_sp_fdb_notify_mac_process(mlxsw_sp, sfn_pl,
3150                         rec_index, true);
3151         break;
3152     case MLXSW_REG_SFN_REC_TYPE_AGED_OUT_MAC:
3153         mlxsw_sp_fdb_notify_mac_process(mlxsw_sp, sfn_pl,
3154                         rec_index, false);
3155         break;
3156     case MLXSW_REG_SFN_REC_TYPE_LEARNED_MAC_LAG:
3157         mlxsw_sp_fdb_notify_mac_lag_process(mlxsw_sp, sfn_pl,
3158                             rec_index, true);
3159         break;
3160     case MLXSW_REG_SFN_REC_TYPE_AGED_OUT_MAC_LAG:
3161         mlxsw_sp_fdb_notify_mac_lag_process(mlxsw_sp, sfn_pl,
3162                             rec_index, false);
3163         break;
3164     case MLXSW_REG_SFN_REC_TYPE_LEARNED_UNICAST_TUNNEL:
3165         mlxsw_sp_fdb_notify_mac_uc_tunnel_process(mlxsw_sp, sfn_pl,
3166                               rec_index, true);
3167         break;
3168     case MLXSW_REG_SFN_REC_TYPE_AGED_OUT_UNICAST_TUNNEL:
3169         mlxsw_sp_fdb_notify_mac_uc_tunnel_process(mlxsw_sp, sfn_pl,
3170                               rec_index, false);
3171         break;
3172     }
3173 }
3174
3175 #define MLXSW_SP_FDB_SFN_QUERIES_PER_SESSION 10
3176
3177 static void mlxsw_sp_fdb_notify_work(struct work_struct *work)
3178 {
3179     struct mlxsw_sp_bridge *bridge;
3180     struct mlxsw_sp *mlxsw_sp;
3181     bool reschedule = false;
3182     char *sfn_pl;
3183     int queries;
3184     u8 num_rec;
3185     int i;
3186     int err;
3187
3188     sfn_pl = kmalloc(MLXSW_REG_SFN_LEN, GFP_KERNEL);
3189     if (!sfn_pl)
3190         return;
3191
3192     bridge = container_of(work, struct mlxsw_sp_bridge, fdb_notify.dw.work);
3193     mlxsw_sp = bridge->mlxsw_sp;
3194
3195     rtnl_lock();
3196     if (list_empty(&bridge->bridges_list))
3197         goto out;
3198     reschedule = true;
3199     queries = MLXSW_SP_FDB_SFN_QUERIES_PER_SESSION;
3200     while (queries > 0) {
3201         mlxsw_reg_sfn_pack(sfn_pl);
3202         err = mlxsw_reg_query(mlxsw_sp->core, MLXSW_REG(sfn), sfn_pl);
3203         if (err) {
3204             dev_err_ratelimited(mlxsw_sp->bus_info->dev, "Failed to get FDB notifications\n");
3205             goto out;
3206         }
3207         num_rec = mlxsw_reg_sfn_num_rec_get(sfn_pl);
3208         for (i = 0; i < num_rec; i++)
3209             mlxsw_sp_fdb_notify_rec_process(mlxsw_sp, sfn_pl, i);
3210         if (num_rec != MLXSW_REG_SFN_REC_MAX_COUNT)
3211             goto out;
3212         queries--;
3213     }
3214
3215 out:
3216     rtnl_unlock();
3217     kfree(sfn_pl);
3218     if (!reschedule)
3219         return;
3220     mlxsw_sp_fdb_notify_work_schedule(mlxsw_sp, !queries);
3221 }
3222
3223 struct mlxsw_sp_switchdev_event_work {
3224     struct work_struct work;
3225     union {
3226         struct switchdev_notifier_fdb_info fdb_info;
3227         struct switchdev_notifier_vxlan_fdb_info vxlan_fdb_info;
3228     };
3229     struct net_device *dev;
3230     unsigned long event;
3231 };
3232
3233 static void
3234 mlxsw_sp_switchdev_bridge_vxlan_fdb_event(struct mlxsw_sp *mlxsw_sp,
3235                       struct mlxsw_sp_switchdev_event_work *
3236                       switchdev_work,
3237                       struct mlxsw_sp_fid *fid, __be32 vni)
3238 {
3239     struct switchdev_notifier_vxlan_fdb_info vxlan_fdb_info;
3240     struct switchdev_notifier_fdb_info *fdb_info;
3241     struct net_device *dev = switchdev_work->dev;
3242     enum mlxsw_sp_l3proto proto;
3243     union mlxsw_sp_l3addr addr;
3244     int err;
3245
3246     fdb_info = &switchdev_work->fdb_info;
3247     err = vxlan_fdb_find_uc(dev, fdb_info->addr, vni, &vxlan_fdb_info);
3248     if (err)
3249         return;
3250
3251     mlxsw_sp_switchdev_vxlan_addr_convert(&vxlan_fdb_info.remote_ip,
3252                           &proto, &addr);
3253
3254     switch (switchdev_work->event) {
3255     case SWITCHDEV_FDB_ADD_TO_DEVICE:
3256         err = mlxsw_sp_port_fdb_tunnel_uc_op(mlxsw_sp,
3257                              vxlan_fdb_info.eth_addr,
3258                              mlxsw_sp_fid_index(fid),
3259                              proto, &addr, true, false);
3260         if (err)
3261             return;
3262         vxlan_fdb_info.offloaded = true;
3263         call_switchdev_notifiers(SWITCHDEV_VXLAN_FDB_OFFLOADED, dev,
3264                      &vxlan_fdb_info.info, NULL);
3265         mlxsw_sp_fdb_call_notifiers(SWITCHDEV_FDB_OFFLOADED,
3266                         vxlan_fdb_info.eth_addr,
3267                         fdb_info->vid, dev, true);
3268         break;
3269     case SWITCHDEV_FDB_DEL_TO_DEVICE:
3270         err = mlxsw_sp_port_fdb_tunnel_uc_op(mlxsw_sp,
3271                              vxlan_fdb_info.eth_addr,
3272                              mlxsw_sp_fid_index(fid),
3273                              proto, &addr, false,
3274                              false);
3275         vxlan_fdb_info.offloaded = false;
3276         call_switchdev_notifiers(SWITCHDEV_VXLAN_FDB_OFFLOADED, dev,
3277                      &vxlan_fdb_info.info, NULL);
3278         break;
3279     }
3280 }
3281
3282 static void
3283 mlxsw_sp_switchdev_bridge_nve_fdb_event(struct mlxsw_sp_switchdev_event_work *
3284                     switchdev_work)
3285 {
3286     struct mlxsw_sp_bridge_device *bridge_device;
3287     struct net_device *dev = switchdev_work->dev;
3288     struct net_device *br_dev;
3289     struct mlxsw_sp *mlxsw_sp;
3290     struct mlxsw_sp_fid *fid;
3291     __be32 vni;
3292     int err;
3293
3294     if (switchdev_work->event != SWITCHDEV_FDB_ADD_TO_DEVICE &&
3295         switchdev_work->event != SWITCHDEV_FDB_DEL_TO_DEVICE)
3296         return;
3297
3298     if (switchdev_work->event == SWITCHDEV_FDB_ADD_TO_DEVICE &&
3299         (!switchdev_work->fdb_info.added_by_user ||
3300          switchdev_work->fdb_info.is_local))
3301         return;
3302
3303     if (!netif_running(dev))
3304         return;
3305     br_dev = netdev_master_upper_dev_get(dev);
3306     if (!br_dev)
3307         return;
3308     if (!netif_is_bridge_master(br_dev))
3309         return;
3310     mlxsw_sp = mlxsw_sp_lower_get(br_dev);
3311     if (!mlxsw_sp)
3312         return;
3313     bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, br_dev);
3314     if (!bridge_device)
3315         return;
3316
3317     fid = bridge_device->ops->fid_lookup(bridge_device,
3318                          switchdev_work->fdb_info.vid);
3319     if (!fid)
3320         return;
3321
3322     err = mlxsw_sp_fid_vni(fid, &vni);
3323     if (err)
3324         goto out;
3325
3326     mlxsw_sp_switchdev_bridge_vxlan_fdb_event(mlxsw_sp, switchdev_work, fid,
3327                           vni);
3328
3329 out:
3330     mlxsw_sp_fid_put(fid);
3331 }
3332
3333 static void mlxsw_sp_switchdev_bridge_fdb_event_work(struct work_struct *work)
3334 {
3335     struct mlxsw_sp_switchdev_event_work *switchdev_work =
3336         container_of(work, struct mlxsw_sp_switchdev_event_work, work);
3337     struct net_device *dev = switchdev_work->dev;
3338     struct switchdev_notifier_fdb_info *fdb_info;
3339     struct mlxsw_sp_port *mlxsw_sp_port;
3340     int err;
3341
3342     rtnl_lock();
3343     if (netif_is_vxlan(dev)) {
3344         mlxsw_sp_switchdev_bridge_nve_fdb_event(switchdev_work);
3345         goto out;
3346     }
3347
3348     mlxsw_sp_port = mlxsw_sp_port_dev_lower_find(dev);
3349     if (!mlxsw_sp_port)
3350         goto out;
3351
3352     switch (switchdev_work->event) {
3353     case SWITCHDEV_FDB_ADD_TO_DEVICE:
3354         fdb_info = &switchdev_work->fdb_info;
3355         if (!fdb_info->added_by_user || fdb_info->is_local)
3356             break;
3357         err = mlxsw_sp_port_fdb_set(mlxsw_sp_port, fdb_info, true);
3358         if (err)
3359             break;
3360         mlxsw_sp_fdb_call_notifiers(SWITCHDEV_FDB_OFFLOADED,
3361                         fdb_info->addr,
3362                         fdb_info->vid, dev, true);
3363         break;
3364     case SWITCHDEV_FDB_DEL_TO_DEVICE:
3365         fdb_info = &switchdev_work->fdb_info;
3366         mlxsw_sp_port_fdb_set(mlxsw_sp_port, fdb_info, false);
3367         break;
3368     case SWITCHDEV_FDB_ADD_TO_BRIDGE:
3369     case SWITCHDEV_FDB_DEL_TO_BRIDGE:
3370         /* These events are only used to potentially update an existing
3371          * SPAN mirror.
3372          */
3373         break;
3374     }
3375
3376     mlxsw_sp_span_respin(mlxsw_sp_port->mlxsw_sp);
3377
3378 out:
3379     rtnl_unlock();
3380     kfree(switchdev_work->fdb_info.addr);
3381     kfree(switchdev_work);
3382     dev_put(dev);
3383 }
3384
3385 static void
3386 mlxsw_sp_switchdev_vxlan_fdb_add(struct mlxsw_sp *mlxsw_sp,
3387                  struct mlxsw_sp_switchdev_event_work *
3388                  switchdev_work)
3389 {
3390     struct switchdev_notifier_vxlan_fdb_info *vxlan_fdb_info;
3391     struct mlxsw_sp_bridge_device *bridge_device;
3392     struct net_device *dev = switchdev_work->dev;
3393     u8 all_zeros_mac[ETH_ALEN] = { 0 };
3394     enum mlxsw_sp_l3proto proto;
3395     union mlxsw_sp_l3addr addr;
3396     struct net_device *br_dev;
3397     struct mlxsw_sp_fid *fid;
3398     u16 vid;
3399     int err;
3400
3401     vxlan_fdb_info = &switchdev_work->vxlan_fdb_info;
3402     br_dev = netdev_master_upper_dev_get(dev);
3403
3404     bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, br_dev);
3405     if (!bridge_device)
3406         return;
3407
3408     fid = mlxsw_sp_fid_lookup_by_vni(mlxsw_sp, vxlan_fdb_info->vni);
3409     if (!fid)
3410         return;
3411
3412     mlxsw_sp_switchdev_vxlan_addr_convert(&vxlan_fdb_info->remote_ip,
3413                           &proto, &addr);
3414
3415     if (ether_addr_equal(vxlan_fdb_info->eth_addr, all_zeros_mac)) {
3416         err = mlxsw_sp_nve_flood_ip_add(mlxsw_sp, fid, proto, &addr);
3417         if (err) {
3418             mlxsw_sp_fid_put(fid);
3419             return;
3420         }
3421         vxlan_fdb_info->offloaded = true;
3422         call_switchdev_notifiers(SWITCHDEV_VXLAN_FDB_OFFLOADED, dev,
3423                      &vxlan_fdb_info->info, NULL);
3424         mlxsw_sp_fid_put(fid);
3425         return;
3426     }
3427
3428     /* The device has a single FDB table, whereas Linux has two - one
3429      * in the bridge driver and another in the VxLAN driver. We only
3430      * program an entry to the device if the MAC points to the VxLAN
3431      * device in the bridge's FDB table
3432      */
3433     vid = bridge_device->ops->fid_vid(bridge_device, fid);
3434     if (br_fdb_find_port(br_dev, vxlan_fdb_info->eth_addr, vid) != dev)
3435         goto err_br_fdb_find;
3436
3437     err = mlxsw_sp_port_fdb_tunnel_uc_op(mlxsw_sp, vxlan_fdb_info->eth_addr,
3438                          mlxsw_sp_fid_index(fid), proto,
3439                          &addr, true, false);
3440     if (err)
3441         goto err_fdb_tunnel_uc_op;
3442     vxlan_fdb_info->offloaded = true;
3443     call_switchdev_notifiers(SWITCHDEV_VXLAN_FDB_OFFLOADED, dev,
3444                  &vxlan_fdb_info->info, NULL);
3445     mlxsw_sp_fdb_call_notifiers(SWITCHDEV_FDB_OFFLOADED,
3446                     vxlan_fdb_info->eth_addr, vid, dev, true);
3447
3448     mlxsw_sp_fid_put(fid);
3449
3450     return;
3451
3452 err_fdb_tunnel_uc_op:
3453 err_br_fdb_find:
3454     mlxsw_sp_fid_put(fid);
3455 }
3456
3457 static void
3458 mlxsw_sp_switchdev_vxlan_fdb_del(struct mlxsw_sp *mlxsw_sp,
3459                  struct mlxsw_sp_switchdev_event_work *
3460                  switchdev_work)
3461 {
3462     struct switchdev_notifier_vxlan_fdb_info *vxlan_fdb_info;
3463     struct mlxsw_sp_bridge_device *bridge_device;
3464     struct net_device *dev = switchdev_work->dev;
3465     struct net_device *br_dev = netdev_master_upper_dev_get(dev);
3466     u8 all_zeros_mac[ETH_ALEN] = { 0 };
3467     enum mlxsw_sp_l3proto proto;
3468     union mlxsw_sp_l3addr addr;
3469     struct mlxsw_sp_fid *fid;
3470     u16 vid;
3471
3472     vxlan_fdb_info = &switchdev_work->vxlan_fdb_info;
3473
3474     bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, br_dev);
3475     if (!bridge_device)
3476         return;
3477
3478     fid = mlxsw_sp_fid_lookup_by_vni(mlxsw_sp, vxlan_fdb_info->vni);
3479     if (!fid)
3480         return;
3481
3482     mlxsw_sp_switchdev_vxlan_addr_convert(&vxlan_fdb_info->remote_ip,
3483                           &proto, &addr);
3484
3485     if (ether_addr_equal(vxlan_fdb_info->eth_addr, all_zeros_mac)) {
3486         mlxsw_sp_nve_flood_ip_del(mlxsw_sp, fid, proto, &addr);
3487         mlxsw_sp_fid_put(fid);
3488         return;
3489     }
3490
3491     mlxsw_sp_port_fdb_tunnel_uc_op(mlxsw_sp, vxlan_fdb_info->eth_addr,
3492                        mlxsw_sp_fid_index(fid), proto, &addr,
3493                        false, false);
3494     vid = bridge_device->ops->fid_vid(bridge_device, fid);
3495     mlxsw_sp_fdb_call_notifiers(SWITCHDEV_FDB_OFFLOADED,
3496                     vxlan_fdb_info->eth_addr, vid, dev, false);
3497
3498     mlxsw_sp_fid_put(fid);
3499 }
3500
3501 static void mlxsw_sp_switchdev_vxlan_fdb_event_work(struct work_struct *work)
3502 {
3503     struct mlxsw_sp_switchdev_event_work *switchdev_work =
3504         container_of(work, struct mlxsw_sp_switchdev_event_work, work);
3505     struct net_device *dev = switchdev_work->dev;
3506     struct mlxsw_sp *mlxsw_sp;
3507     struct net_device *br_dev;
3508
3509     rtnl_lock();
3510
3511     if (!netif_running(dev))
3512         goto out;
3513     br_dev = netdev_master_upper_dev_get(dev);
3514     if (!br_dev)
3515         goto out;
3516     if (!netif_is_bridge_master(br_dev))
3517         goto out;
3518     mlxsw_sp = mlxsw_sp_lower_get(br_dev);
3519     if (!mlxsw_sp)
3520         goto out;
3521
3522     switch (switchdev_work->event) {
3523     case SWITCHDEV_VXLAN_FDB_ADD_TO_DEVICE:
3524         mlxsw_sp_switchdev_vxlan_fdb_add(mlxsw_sp, switchdev_work);
3525         break;
3526     case SWITCHDEV_VXLAN_FDB_DEL_TO_DEVICE:
3527         mlxsw_sp_switchdev_vxlan_fdb_del(mlxsw_sp, switchdev_work);
3528         break;
3529     }
3530
3531 out:
3532     rtnl_unlock();
3533     kfree(switchdev_work);
3534     dev_put(dev);
3535 }
3536
3537 static int
3538 mlxsw_sp_switchdev_vxlan_work_prepare(struct mlxsw_sp_switchdev_event_work *
3539                       switchdev_work,
3540                       struct switchdev_notifier_info *info)
3541 {
3542     struct vxlan_dev *vxlan = netdev_priv(switchdev_work->dev);
3543     struct switchdev_notifier_vxlan_fdb_info *vxlan_fdb_info;
3544     struct vxlan_config *cfg = &vxlan->cfg;
3545     struct netlink_ext_ack *extack;
3546
3547     extack = switchdev_notifier_info_to_extack(info);
3548     vxlan_fdb_info = container_of(info,
3549                       struct switchdev_notifier_vxlan_fdb_info,
3550                       info);
3551
3552     if (vxlan_fdb_info->remote_port != cfg->dst_port) {
3553         NL_SET_ERR_MSG_MOD(extack, "VxLAN: FDB: Non-default remote port is not supported");
3554         return -EOPNOTSUPP;
3555     }
3556     if (vxlan_fdb_info->remote_vni != cfg->vni ||
3557         vxlan_fdb_info->vni != cfg->vni) {
3558         NL_SET_ERR_MSG_MOD(extack, "VxLAN: FDB: Non-default VNI is not supported");
3559         return -EOPNOTSUPP;
3560     }
3561     if (vxlan_fdb_info->remote_ifindex) {
3562         NL_SET_ERR_MSG_MOD(extack, "VxLAN: FDB: Local interface is not supported");
3563         return -EOPNOTSUPP;
3564     }
3565     if (is_multicast_ether_addr(vxlan_fdb_info->eth_addr)) {
3566         NL_SET_ERR_MSG_MOD(extack, "VxLAN: FDB: Multicast MAC addresses not supported");
3567         return -EOPNOTSUPP;
3568     }
3569     if (vxlan_addr_multicast(&vxlan_fdb_info->remote_ip)) {
3570         NL_SET_ERR_MSG_MOD(extack, "VxLAN: FDB: Multicast destination IP is not supported");
3571         return -EOPNOTSUPP;
3572     }
3573
3574     switchdev_work->vxlan_fdb_info = *vxlan_fdb_info;
3575
3576     return 0;
3577 }
3578
3579 /* Called under rcu_read_lock() */
3580 static int mlxsw_sp_switchdev_event(struct notifier_block *unused,
3581                     unsigned long event, void *ptr)
3582 {
3583     struct net_device *dev = switchdev_notifier_info_to_dev(ptr);
3584     struct mlxsw_sp_switchdev_event_work *switchdev_work;
3585     struct switchdev_notifier_fdb_info *fdb_info;
3586     struct switchdev_notifier_info *info = ptr;
3587     struct net_device *br_dev;
3588     int err;
3589
3590     if (event == SWITCHDEV_PORT_ATTR_SET) {
3591         err = switchdev_handle_port_attr_set(dev, ptr,
3592                              mlxsw_sp_port_dev_check,
3593                              mlxsw_sp_port_attr_set);
3594         return notifier_from_errno(err);
3595     }
3596
3597     /* Tunnel devices are not our uppers, so check their master instead */
3598     br_dev = netdev_master_upper_dev_get_rcu(dev);
3599     if (!br_dev)
3600         return NOTIFY_DONE;
3601     if (!netif_is_bridge_master(br_dev))
3602         return NOTIFY_DONE;
3603     if (!mlxsw_sp_port_dev_lower_find_rcu(br_dev))
3604         return NOTIFY_DONE;
3605
3606     switchdev_work = kzalloc(sizeof(*switchdev_work), GFP_ATOMIC);
3607     if (!switchdev_work)
3608         return NOTIFY_BAD;
3609
3610     switchdev_work->dev = dev;
3611     switchdev_work->event = event;
3612
3613     switch (event) {
3614     case SWITCHDEV_FDB_ADD_TO_DEVICE:
3615     case SWITCHDEV_FDB_DEL_TO_DEVICE:
3616     case SWITCHDEV_FDB_ADD_TO_BRIDGE:
3617     case SWITCHDEV_FDB_DEL_TO_BRIDGE:
3618         fdb_info = container_of(info,
3619                     struct switchdev_notifier_fdb_info,
3620                     info);
3621         INIT_WORK(&switchdev_work->work,
3622               mlxsw_sp_switchdev_bridge_fdb_event_work);
3623         memcpy(&switchdev_work->fdb_info, ptr,
3624                sizeof(switchdev_work->fdb_info));
3625         switchdev_work->fdb_info.addr = kzalloc(ETH_ALEN, GFP_ATOMIC);
3626         if (!switchdev_work->fdb_info.addr)
3627             goto err_addr_alloc;
3628         ether_addr_copy((u8 *)switchdev_work->fdb_info.addr,
3629                 fdb_info->addr);
3630         /* Take a reference on the device. This can be either
3631          * upper device containig mlxsw_sp_port or just a
3632          * mlxsw_sp_port
3633          */
3634         dev_hold(dev);
3635         break;
3636     case SWITCHDEV_VXLAN_FDB_ADD_TO_DEVICE:
3637     case SWITCHDEV_VXLAN_FDB_DEL_TO_DEVICE:
3638         INIT_WORK(&switchdev_work->work,
3639               mlxsw_sp_switchdev_vxlan_fdb_event_work);
3640         err = mlxsw_sp_switchdev_vxlan_work_prepare(switchdev_work,
3641                                 info);
3642         if (err)
3643             goto err_vxlan_work_prepare;
3644         dev_hold(dev);
3645         break;
3646     default:
3647         kfree(switchdev_work);
3648         return NOTIFY_DONE;
3649     }
3650
3651     mlxsw_core_schedule_work(&switchdev_work->work);
3652
3653     return NOTIFY_DONE;
3654
3655 err_vxlan_work_prepare:
3656 err_addr_alloc:
3657     kfree(switchdev_work);
3658     return NOTIFY_BAD;
3659 }
3660
3661 struct notifier_block mlxsw_sp_switchdev_notifier = {
3662     .notifier_call = mlxsw_sp_switchdev_event,
3663 };
3664
3665 static int
3666 mlxsw_sp_switchdev_vxlan_vlan_add(struct mlxsw_sp *mlxsw_sp,
3667                   struct mlxsw_sp_bridge_device *bridge_device,
3668                   const struct net_device *vxlan_dev, u16 vid,
3669                   bool flag_untagged, bool flag_pvid,
3670                   struct netlink_ext_ack *extack)
3671 {
3672     struct vxlan_dev *vxlan = netdev_priv(vxlan_dev);
3673     __be32 vni = vxlan->cfg.vni;
3674     struct mlxsw_sp_fid *fid;
3675     u16 old_vid;
3676     int err;
3677
3678     /* We cannot have the same VLAN as PVID and egress untagged on multiple
3679      * VxLAN devices. Note that we get this notification before the VLAN is
3680      * actually added to the bridge's database, so it is not possible for
3681      * the lookup function to return 'vxlan_dev'
3682      */
3683     if (flag_untagged && flag_pvid &&
3684         mlxsw_sp_bridge_8021q_vxlan_dev_find(bridge_device->dev, vid)) {
3685         NL_SET_ERR_MSG_MOD(extack, "VLAN already mapped to a different VNI");
3686         return -EINVAL;
3687     }
3688
3689     if (!netif_running(vxlan_dev))
3690         return 0;
3691
3692     /* First case: FID is not associated with this VNI, but the new VLAN
3693      * is both PVID and egress untagged. Need to enable NVE on the FID, if
3694      * it exists
3695      */
3696     fid = mlxsw_sp_fid_lookup_by_vni(mlxsw_sp, vni);
3697     if (!fid) {
3698         if (!flag_untagged || !flag_pvid)
3699             return 0;
3700         return bridge_device->ops->vxlan_join(bridge_device, vxlan_dev,
3701                               vid, extack);
3702     }
3703
3704     /* Second case: FID is associated with the VNI and the VLAN associated
3705      * with the FID is the same as the notified VLAN. This means the flags
3706      * (PVID / egress untagged) were toggled and that NVE should be
3707      * disabled on the FID
3708      */
3709     old_vid = mlxsw_sp_fid_8021q_vid(fid);
3710     if (vid == old_vid) {
3711         if (WARN_ON(flag_untagged && flag_pvid)) {
3712             mlxsw_sp_fid_put(fid);
3713             return -EINVAL;
3714         }
3715         mlxsw_sp_bridge_vxlan_leave(mlxsw_sp, vxlan_dev);
3716         mlxsw_sp_fid_put(fid);
3717         return 0;
3718     }
3719
3720     /* Third case: A new VLAN was configured on the VxLAN device, but this
3721      * VLAN is not PVID, so there is nothing to do.
3722      */
3723     if (!flag_pvid) {
3724         mlxsw_sp_fid_put(fid);
3725         return 0;
3726     }
3727
3728     /* Fourth case: Thew new VLAN is PVID, which means the VLAN currently
3729      * mapped to the VNI should be unmapped
3730      */
3731     mlxsw_sp_bridge_vxlan_leave(mlxsw_sp, vxlan_dev);
3732     mlxsw_sp_fid_put(fid);
3733
3734     /* Fifth case: The new VLAN is also egress untagged, which means the
3735      * VLAN needs to be mapped to the VNI
3736      */
3737     if (!flag_untagged)
3738         return 0;
3739
3740     err = bridge_device->ops->vxlan_join(bridge_device, vxlan_dev, vid, extack);
3741     if (err)
3742         goto err_vxlan_join;
3743
3744     return 0;
3745
3746 err_vxlan_join:
3747     bridge_device->ops->vxlan_join(bridge_device, vxlan_dev, old_vid, NULL);
3748     return err;
3749 }
3750
3751 static void
3752 mlxsw_sp_switchdev_vxlan_vlan_del(struct mlxsw_sp *mlxsw_sp,
3753                   struct mlxsw_sp_bridge_device *bridge_device,
3754                   const struct net_device *vxlan_dev, u16 vid)
3755 {
3756     struct vxlan_dev *vxlan = netdev_priv(vxlan_dev);
3757     __be32 vni = vxlan->cfg.vni;
3758     struct mlxsw_sp_fid *fid;
3759
3760     if (!netif_running(vxlan_dev))
3761         return;
3762
3763     fid = mlxsw_sp_fid_lookup_by_vni(mlxsw_sp, vni);
3764     if (!fid)
3765         return;
3766
3767     /* A different VLAN than the one mapped to the VNI is deleted */
3768     if (mlxsw_sp_fid_8021q_vid(fid) != vid)
3769         goto out;
3770
3771     mlxsw_sp_bridge_vxlan_leave(mlxsw_sp, vxlan_dev);
3772
3773 out:
3774     mlxsw_sp_fid_put(fid);
3775 }
3776
3777 static int
3778 mlxsw_sp_switchdev_vxlan_vlans_add(struct net_device *vxlan_dev,
3779                    struct switchdev_notifier_port_obj_info *
3780                    port_obj_info)
3781 {
3782     struct switchdev_obj_port_vlan *vlan =
3783         SWITCHDEV_OBJ_PORT_VLAN(port_obj_info->obj);
3784     bool flag_untagged = vlan->flags & BRIDGE_VLAN_INFO_UNTAGGED;
3785     bool flag_pvid = vlan->flags & BRIDGE_VLAN_INFO_PVID;
3786     struct mlxsw_sp_bridge_device *bridge_device;
3787     struct netlink_ext_ack *extack;
3788     struct mlxsw_sp *mlxsw_sp;
3789     struct net_device *br_dev;
3790
3791     extack = switchdev_notifier_info_to_extack(&port_obj_info->info);
3792     br_dev = netdev_master_upper_dev_get(vxlan_dev);
3793     if (!br_dev)
3794         return 0;
3795
3796     mlxsw_sp = mlxsw_sp_lower_get(br_dev);
3797     if (!mlxsw_sp)
3798         return 0;
3799
3800     port_obj_info->handled = true;
3801
3802     bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, br_dev);
3803     if (!bridge_device)
3804         return -EINVAL;
3805
3806     if (!bridge_device->vlan_enabled)
3807         return 0;
3808
3809     return mlxsw_sp_switchdev_vxlan_vlan_add(mlxsw_sp, bridge_device,
3810                          vxlan_dev, vlan->vid,
3811                          flag_untagged,
3812                          flag_pvid, extack);
3813 }
3814
3815 static void
3816 mlxsw_sp_switchdev_vxlan_vlans_del(struct net_device *vxlan_dev,
3817                    struct switchdev_notifier_port_obj_info *
3818                    port_obj_info)
3819 {
3820     struct switchdev_obj_port_vlan *vlan =
3821         SWITCHDEV_OBJ_PORT_VLAN(port_obj_info->obj);
3822     struct mlxsw_sp_bridge_device *bridge_device;
3823     struct mlxsw_sp *mlxsw_sp;
3824     struct net_device *br_dev;
3825
3826     br_dev = netdev_master_upper_dev_get(vxlan_dev);
3827     if (!br_dev)
3828         return;
3829
3830     mlxsw_sp = mlxsw_sp_lower_get(br_dev);
3831     if (!mlxsw_sp)
3832         return;
3833
3834     port_obj_info->handled = true;
3835
3836     bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, br_dev);
3837     if (!bridge_device)
3838         return;
3839
3840     if (!bridge_device->vlan_enabled)
3841         return;
3842
3843     mlxsw_sp_switchdev_vxlan_vlan_del(mlxsw_sp, bridge_device, vxlan_dev,
3844                       vlan->vid);
3845 }
3846
3847 static int
3848 mlxsw_sp_switchdev_handle_vxlan_obj_add(struct net_device *vxlan_dev,
3849                     struct switchdev_notifier_port_obj_info *
3850                     port_obj_info)
3851 {
3852     int err = 0;
3853
3854     switch (port_obj_info->obj->id) {
3855     case SWITCHDEV_OBJ_ID_PORT_VLAN:
3856         err = mlxsw_sp_switchdev_vxlan_vlans_add(vxlan_dev,
3857                              port_obj_info);
3858         break;
3859     default:
3860         break;
3861     }
3862
3863     return err;
3864 }
3865
3866 static void
3867 mlxsw_sp_switchdev_handle_vxlan_obj_del(struct net_device *vxlan_dev,
3868                     struct switchdev_notifier_port_obj_info *
3869                     port_obj_info)
3870 {
3871     switch (port_obj_info->obj->id) {
3872     case SWITCHDEV_OBJ_ID_PORT_VLAN:
3873         mlxsw_sp_switchdev_vxlan_vlans_del(vxlan_dev, port_obj_info);
3874         break;
3875     default:
3876         break;
3877     }
3878 }
3879
3880 static int mlxsw_sp_switchdev_blocking_event(struct notifier_block *unused,
3881                          unsigned long event, void *ptr)
3882 {
3883     struct net_device *dev = switchdev_notifier_info_to_dev(ptr);
3884     int err = 0;
3885
3886     switch (event) {
3887     case SWITCHDEV_PORT_OBJ_ADD:
3888         if (netif_is_vxlan(dev))
3889             err = mlxsw_sp_switchdev_handle_vxlan_obj_add(dev, ptr);
3890         else
3891             err = switchdev_handle_port_obj_add(dev, ptr,
3892                             mlxsw_sp_port_dev_check,
3893                             mlxsw_sp_port_obj_add);
3894         return notifier_from_errno(err);
3895     case SWITCHDEV_PORT_OBJ_DEL:
3896         if (netif_is_vxlan(dev))
3897             mlxsw_sp_switchdev_handle_vxlan_obj_del(dev, ptr);
3898         else
3899             err = switchdev_handle_port_obj_del(dev, ptr,
3900                             mlxsw_sp_port_dev_check,
3901                             mlxsw_sp_port_obj_del);
3902         return notifier_from_errno(err);
3903     case SWITCHDEV_PORT_ATTR_SET:
3904         err = switchdev_handle_port_attr_set(dev, ptr,
3905                              mlxsw_sp_port_dev_check,
3906                              mlxsw_sp_port_attr_set);
3907         return notifier_from_errno(err);
3908     }
3909
3910     return NOTIFY_DONE;
3911 }
3912
3913 static struct notifier_block mlxsw_sp_switchdev_blocking_notifier = {
3914     .notifier_call = mlxsw_sp_switchdev_blocking_event,
3915 };
3916
3917 u8
3918 mlxsw_sp_bridge_port_stp_state(struct mlxsw_sp_bridge_port *bridge_port)
3919 {
3920     return bridge_port->stp_state;
3921 }
3922
3923 static int mlxsw_sp_fdb_init(struct mlxsw_sp *mlxsw_sp)
3924 {
3925     struct mlxsw_sp_bridge *bridge = mlxsw_sp->bridge;
3926     struct notifier_block *nb;
3927     int err;
3928
3929     err = mlxsw_sp_ageing_set(mlxsw_sp, MLXSW_SP_DEFAULT_AGEING_TIME);
3930     if (err) {
3931         dev_err(mlxsw_sp->bus_info->dev, "Failed to set default ageing time\n");
3932         return err;
3933     }
3934
3935     err = register_switchdev_notifier(&mlxsw_sp_switchdev_notifier);
3936     if (err) {
3937         dev_err(mlxsw_sp->bus_info->dev, "Failed to register switchdev notifier\n");
3938         return err;
3939     }
3940
3941     nb = &mlxsw_sp_switchdev_blocking_notifier;
3942     err = register_switchdev_blocking_notifier(nb);
3943     if (err) {
3944         dev_err(mlxsw_sp->bus_info->dev, "Failed to register switchdev blocking notifier\n");
3945         goto err_register_switchdev_blocking_notifier;
3946     }
3947
3948     INIT_DELAYED_WORK(&bridge->fdb_notify.dw, mlxsw_sp_fdb_notify_work);
3949     bridge->fdb_notify.interval = MLXSW_SP_DEFAULT_LEARNING_INTERVAL;
3950     return 0;
3951
3952 err_register_switchdev_blocking_notifier:
3953     unregister_switchdev_notifier(&mlxsw_sp_switchdev_notifier);
3954     return err;
3955 }
3956
3957 static void mlxsw_sp_fdb_fini(struct mlxsw_sp *mlxsw_sp)
3958 {
3959     struct notifier_block *nb;
3960
3961     cancel_delayed_work_sync(&mlxsw_sp->bridge->fdb_notify.dw);
3962
3963     nb = &mlxsw_sp_switchdev_blocking_notifier;
3964     unregister_switchdev_blocking_notifier(nb);
3965
3966     unregister_switchdev_notifier(&mlxsw_sp_switchdev_notifier);
3967 }
3968
3969 static void mlxsw_sp1_switchdev_init(struct mlxsw_sp *mlxsw_sp)
3970 {
3971     mlxsw_sp->bridge->bridge_8021ad_ops = &mlxsw_sp1_bridge_8021ad_ops;
3972 }
3973
3974 const struct mlxsw_sp_switchdev_ops mlxsw_sp1_switchdev_ops = {
3975     .init   = mlxsw_sp1_switchdev_init,
3976 };
3977
3978 static void mlxsw_sp2_switchdev_init(struct mlxsw_sp *mlxsw_sp)
3979 {
3980     mlxsw_sp->bridge->bridge_8021ad_ops = &mlxsw_sp2_bridge_8021ad_ops;
3981 }
3982
3983 const struct mlxsw_sp_switchdev_ops mlxsw_sp2_switchdev_ops = {
3984     .init   = mlxsw_sp2_switchdev_init,
3985 };
3986
3987 int mlxsw_sp_switchdev_init(struct mlxsw_sp *mlxsw_sp)
3988 {
3989     struct mlxsw_sp_bridge *bridge;
3990
3991     bridge = kzalloc(sizeof(*mlxsw_sp->bridge), GFP_KERNEL);
3992     if (!bridge)
3993         return -ENOMEM;
3994     mlxsw_sp->bridge = bridge;
3995     bridge->mlxsw_sp = mlxsw_sp;
3996
3997     INIT_LIST_HEAD(&mlxsw_sp->bridge->bridges_list);
3998
3999     bridge->bridge_8021q_ops = &mlxsw_sp_bridge_8021q_ops;
4000     bridge->bridge_8021d_ops = &mlxsw_sp_bridge_8021d_ops;
4001
4002     mlxsw_sp->switchdev_ops->init(mlxsw_sp);
4003
4004     return mlxsw_sp_fdb_init(mlxsw_sp);
4005 }
4006
4007 void mlxsw_sp_switchdev_fini(struct mlxsw_sp *mlxsw_sp)
4008 {
4009     mlxsw_sp_fdb_fini(mlxsw_sp);
4010     WARN_ON(!list_empty(&mlxsw_sp->bridge->bridges_list));
4011     kfree(mlxsw_sp->bridge);
4012 }
4013