if (!ndev)
                goto out;
 
-       if (mlx5_lag_is_active(dev->mdev)) {
+       if (dev->lag_active) {
                rcu_read_lock();
                upper = netdev_master_upper_dev_get_rcu(ndev);
                if (upper) {
        context->lib_caps = req.lib_caps;
        print_lib_caps(dev, context->lib_caps);
 
-       if (mlx5_lag_is_active(dev->mdev)) {
+       if (dev->lag_active) {
                u8 port = mlx5_core_native_port_num(dev->mdev);
 
                atomic_set(&context->tx_port_affinity,
        struct mlx5_flow_table *ft;
        int err;
 
-       if (!ns || !mlx5_lag_is_active(mdev))
+       if (!ns || !mlx5_lag_is_roce(mdev))
                return 0;
 
        err = mlx5_cmd_create_vport_lag(mdev);
        }
 
        dev->flow_db->lag_demux_ft = ft;
+       dev->lag_active = true;
        return 0;
 
 err_destroy_vport_lag:
 {
        struct mlx5_core_dev *mdev = dev->mdev;
 
-       if (dev->flow_db->lag_demux_ft) {
+       if (dev->lag_active) {
+               dev->lag_active = false;
+
                mlx5_destroy_flow_table(dev->flow_db->lag_demux_ft);
                dev->flow_db->lag_demux_ft = NULL;
 
        const char *name;
 
        rdma_set_device_sysfs_group(&dev->ib_dev, &mlx5_attr_group);
-       if (!mlx5_lag_is_active(dev->mdev))
+       if (!mlx5_lag_is_roce(dev->mdev))
                name = "mlx5_%d";
        else
                name = "mlx5_bond_%d";
 
 #include "eswitch.h"
 
 enum {
-       MLX5_LAG_FLAG_BONDED = 1 << 0,
+       MLX5_LAG_FLAG_ROCE   = 1 << 0,
+       MLX5_LAG_FLAG_SRIOV  = 1 << 1,
 };
 
+#define MLX5_LAG_MODE_FLAGS (MLX5_LAG_FLAG_ROCE | MLX5_LAG_FLAG_SRIOV)
+
 struct lag_func {
        struct mlx5_core_dev *dev;
        struct net_device    *netdev;
        return -1;
 }
 
+static bool __mlx5_lag_is_roce(struct mlx5_lag *ldev)
+{
+       return !!(ldev->flags & MLX5_LAG_FLAG_ROCE);
+}
+
+static bool __mlx5_lag_is_sriov(struct mlx5_lag *ldev)
+{
+       return !!(ldev->flags & MLX5_LAG_FLAG_SRIOV);
+}
+
 static bool __mlx5_lag_is_active(struct mlx5_lag *ldev)
 {
-       return !!(ldev->flags & MLX5_LAG_FLAG_BONDED);
+       return !!(ldev->flags & MLX5_LAG_MODE_FLAGS);
 }
 
 static void mlx5_infer_tx_affinity_mapping(struct lag_tracker *tracker,
 }
 
 static void mlx5_activate_lag(struct mlx5_lag *ldev,
-                             struct lag_tracker *tracker)
+                             struct lag_tracker *tracker,
+                             u8 flags)
 {
-       ldev->flags |= MLX5_LAG_FLAG_BONDED;
+       ldev->flags |= flags;
        mlx5_create_lag(ldev, tracker);
 }
 
        struct mlx5_core_dev *dev0 = ldev->pf[0].dev;
        int err;
 
-       ldev->flags &= ~MLX5_LAG_FLAG_BONDED;
+       ldev->flags &= ~MLX5_LAG_MODE_FLAGS;
 
        err = mlx5_cmd_destroy_lag(dev0);
        if (err)
 {
        struct mlx5_core_dev *dev0 = ldev->pf[0].dev;
        struct mlx5_core_dev *dev1 = ldev->pf[1].dev;
-       bool do_bond, sriov_enabled;
        struct lag_tracker tracker;
+       bool do_bond, roce_lag;
        int i;
 
        if (!dev0 || !dev1)
                return;
 
-       sriov_enabled = mlx5_sriov_is_enabled(dev0) || mlx5_sriov_is_enabled(dev1);
-
        mutex_lock(&lag_mutex);
        tracker = ldev->tracker;
        mutex_unlock(&lag_mutex);
        do_bond = tracker.is_bonded && mlx5_lag_check_prereq(ldev);
 
        if (do_bond && !__mlx5_lag_is_active(ldev)) {
-               if (!sriov_enabled)
+               roce_lag = !mlx5_sriov_is_enabled(dev0) &&
+                          !mlx5_sriov_is_enabled(dev1);
+
+               if (roce_lag)
                        for (i = 0; i < MLX5_MAX_PORTS; i++)
                                mlx5_remove_dev_by_protocol(ldev->pf[i].dev,
                                                            MLX5_INTERFACE_PROTOCOL_IB);
 
-               mlx5_activate_lag(ldev, &tracker);
+               mlx5_activate_lag(ldev, &tracker,
+                                 roce_lag ? MLX5_LAG_FLAG_ROCE :
+                                 MLX5_LAG_FLAG_SRIOV);
 
-               if (!sriov_enabled) {
+               if (roce_lag) {
                        mlx5_add_dev_by_protocol(dev0, MLX5_INTERFACE_PROTOCOL_IB);
                        mlx5_nic_vport_enable_roce(dev1);
                }
        } else if (do_bond && __mlx5_lag_is_active(ldev)) {
                mlx5_modify_lag(ldev, &tracker);
        } else if (!do_bond && __mlx5_lag_is_active(ldev)) {
-               if (!sriov_enabled) {
+               roce_lag = __mlx5_lag_is_roce(ldev);
+
+               if (roce_lag) {
                        mlx5_remove_dev_by_protocol(dev0, MLX5_INTERFACE_PROTOCOL_IB);
                        mlx5_nic_vport_disable_roce(dev1);
                }
 
                mlx5_deactivate_lag(ldev);
 
-               if (!sriov_enabled)
+               if (roce_lag)
                        for (i = 0; i < MLX5_MAX_PORTS; i++)
                                if (ldev->pf[i].dev)
                                        mlx5_add_dev_by_protocol(ldev->pf[i].dev,
        }
 }
 
+bool mlx5_lag_is_roce(struct mlx5_core_dev *dev)
+{
+       struct mlx5_lag *ldev;
+       bool res;
+
+       mutex_lock(&lag_mutex);
+       ldev = mlx5_lag_dev_get(dev);
+       res  = ldev && __mlx5_lag_is_roce(ldev);
+       mutex_unlock(&lag_mutex);
+
+       return res;
+}
+EXPORT_SYMBOL(mlx5_lag_is_roce);
+
 bool mlx5_lag_is_active(struct mlx5_core_dev *dev)
 {
        struct mlx5_lag *ldev;
 }
 EXPORT_SYMBOL(mlx5_lag_is_active);
 
+bool mlx5_lag_is_sriov(struct mlx5_core_dev *dev)
+{
+       struct mlx5_lag *ldev;
+       bool res;
+
+       mutex_lock(&lag_mutex);
+       ldev = mlx5_lag_dev_get(dev);
+       res  = ldev && __mlx5_lag_is_sriov(ldev);
+       mutex_unlock(&lag_mutex);
+
+       return res;
+}
+EXPORT_SYMBOL(mlx5_lag_is_sriov);
+
 void mlx5_lag_update(struct mlx5_core_dev *dev)
 {
        struct mlx5_lag *ldev;
        mutex_lock(&lag_mutex);
        ldev = mlx5_lag_dev_get(dev);
 
-       if (!(ldev && __mlx5_lag_is_active(ldev)))
+       if (!(ldev && __mlx5_lag_is_roce(ldev)))
                goto unlock;
 
        if (ldev->tracker.tx_type == NETDEV_LAG_TX_TYPE_ACTIVEBACKUP) {
                return true;
 
        ldev = mlx5_lag_dev_get(dev);
-       if (!ldev || !__mlx5_lag_is_active(ldev) || ldev->pf[0].dev == dev)
+       if (!ldev || !__mlx5_lag_is_roce(ldev) || ldev->pf[0].dev == dev)
                return true;
 
        /* If bonded, we do not add an IB device for PF1. */
 
        mutex_lock(&lag_mutex);
        ldev = mlx5_lag_dev_get(dev);
-       if (ldev && __mlx5_lag_is_active(ldev)) {
+       if (ldev && __mlx5_lag_is_roce(ldev)) {
                num_ports = MLX5_MAX_PORTS;
                mdev[0] = ldev->pf[0].dev;
                mdev[1] = ldev->pf[1].dev;