Commit 601c10c8 authored by Leon Romanovsky's avatar Leon Romanovsky
Browse files

net/mlx5: Delete custom device management logic 



After conversion to use auxiliary bus, all custom device management is
not needed anymore, delete it.

Signed-off-by: default avatarLeon Romanovsky <leonro@nvidia.com>
parent 93f82444

drivers/net/ethernet/mellanox/mlx5/core/dev.c

+18 −270
Original line number Diff line number Diff line
@@ -35,24 +35,10 @@ 
#include <linux/mlx5/mlx5_ifc_vdpa.h>

#include "mlx5_core.h"



static LIST_HEAD(intf_list);

static LIST_HEAD(mlx5_dev_list);

/* intf dev list mutex */

static DEFINE_MUTEX(mlx5_intf_mutex);

static DEFINE_IDA(mlx5_adev_ida);



struct mlx5_device_context {

	struct list_head	list;

	struct mlx5_interface  *intf;

	void		       *context;

	unsigned long		state;

};



enum {

	MLX5_INTERFACE_ADDED,

	MLX5_INTERFACE_ATTACHED,

};



static bool is_eth_rep_supported(struct mlx5_core_dev *dev)

{

	if (!IS_ENABLED(CONFIG_MLX5_ESWITCH))
@@ -204,11 +190,22 @@ static bool is_ib_supported(struct mlx5_core_dev *dev) 
	return true;

}



enum {

	MLX5_INTERFACE_PROTOCOL_ETH_REP,

	MLX5_INTERFACE_PROTOCOL_ETH,



	MLX5_INTERFACE_PROTOCOL_IB_REP,

	MLX5_INTERFACE_PROTOCOL_MPIB,

	MLX5_INTERFACE_PROTOCOL_IB,



	MLX5_INTERFACE_PROTOCOL_VNET,

};



static const struct mlx5_adev_device {

	const char *suffix;

	bool (*is_supported)(struct mlx5_core_dev *dev);

} mlx5_adev_devices[] = {

	[MLX5_INTERFACE_PROTOCOL_VDPA] = { .suffix = "vnet",

	[MLX5_INTERFACE_PROTOCOL_VNET] = { .suffix = "vnet",

					   .is_supported = &is_vnet_supported },

	[MLX5_INTERFACE_PROTOCOL_IB] = { .suffix = "rdma",

					 .is_supported = &is_ib_supported },
@@ -251,90 +248,6 @@ void mlx5_adev_cleanup(struct mlx5_core_dev *dev) 
	kfree(priv->adev);

}



void mlx5_add_device(struct mlx5_interface *intf, struct mlx5_priv *priv)

{

	struct mlx5_device_context *dev_ctx;

	struct mlx5_core_dev *dev = container_of(priv, struct mlx5_core_dev, priv);



	if (!mlx5_lag_intf_add(intf, priv))

		return;



	dev_ctx = kzalloc(sizeof(*dev_ctx), GFP_KERNEL);

	if (!dev_ctx)

		return;



	dev_ctx->intf = intf;



	dev_ctx->context = intf->add(dev);

	if (dev_ctx->context) {

		set_bit(MLX5_INTERFACE_ADDED, &dev_ctx->state);

		if (intf->attach)

			set_bit(MLX5_INTERFACE_ATTACHED, &dev_ctx->state);



		spin_lock_irq(&priv->ctx_lock);

		list_add_tail(&dev_ctx->list, &priv->ctx_list);

		spin_unlock_irq(&priv->ctx_lock);

	}



	if (!dev_ctx->context)

		kfree(dev_ctx);

}



static struct mlx5_device_context *mlx5_get_device(struct mlx5_interface *intf,

						   struct mlx5_priv *priv)

{

	struct mlx5_device_context *dev_ctx;



	list_for_each_entry(dev_ctx, &priv->ctx_list, list)

		if (dev_ctx->intf == intf)

			return dev_ctx;

	return NULL;

}



void mlx5_remove_device(struct mlx5_interface *intf, struct mlx5_priv *priv)

{

	struct mlx5_device_context *dev_ctx;

	struct mlx5_core_dev *dev = container_of(priv, struct mlx5_core_dev, priv);



	dev_ctx = mlx5_get_device(intf, priv);

	if (!dev_ctx)

		return;



	spin_lock_irq(&priv->ctx_lock);

	list_del(&dev_ctx->list);

	spin_unlock_irq(&priv->ctx_lock);



	if (test_bit(MLX5_INTERFACE_ADDED, &dev_ctx->state))

		intf->remove(dev, dev_ctx->context);



	kfree(dev_ctx);

}



static void mlx5_attach_interface(struct mlx5_interface *intf, struct mlx5_priv *priv)

{

	struct mlx5_device_context *dev_ctx;

	struct mlx5_core_dev *dev = container_of(priv, struct mlx5_core_dev, priv);



	dev_ctx = mlx5_get_device(intf, priv);

	if (!dev_ctx)

		return;



	if (intf->attach) {

		if (test_bit(MLX5_INTERFACE_ATTACHED, &dev_ctx->state))

			return;

		if (intf->attach(dev, dev_ctx->context))

			return;

		set_bit(MLX5_INTERFACE_ATTACHED, &dev_ctx->state);

	} else {

		if (test_bit(MLX5_INTERFACE_ADDED, &dev_ctx->state))

			return;

		dev_ctx->context = intf->add(dev);

		if (!dev_ctx->context)

			return;

		set_bit(MLX5_INTERFACE_ADDED, &dev_ctx->state);

	}

}



static void adev_release(struct device *dev)

{

	struct mlx5_adev *mlx5_adev =
@@ -390,7 +303,6 @@ int mlx5_attach_device(struct mlx5_core_dev *dev) 
	struct mlx5_priv *priv = &dev->priv;

	struct auxiliary_device *adev;

	struct auxiliary_driver *adrv;

	struct mlx5_interface *intf;

	int ret = 0, i;



	mutex_lock(&mlx5_intf_mutex);
@@ -423,41 +335,15 @@ int mlx5_attach_device(struct mlx5_core_dev *dev) 
			break;

		}

	}



	list_for_each_entry(intf, &intf_list, list)

		mlx5_attach_interface(intf, priv);

	mutex_unlock(&mlx5_intf_mutex);

	return ret;

}



static void mlx5_detach_interface(struct mlx5_interface *intf, struct mlx5_priv *priv)

{

	struct mlx5_device_context *dev_ctx;

	struct mlx5_core_dev *dev = container_of(priv, struct mlx5_core_dev, priv);



	dev_ctx = mlx5_get_device(intf, priv);

	if (!dev_ctx)

		return;



	if (intf->detach) {

		if (!test_bit(MLX5_INTERFACE_ATTACHED, &dev_ctx->state))

			return;

		intf->detach(dev, dev_ctx->context);

		clear_bit(MLX5_INTERFACE_ATTACHED, &dev_ctx->state);

	} else {

		if (!test_bit(MLX5_INTERFACE_ADDED, &dev_ctx->state))

			return;

		intf->remove(dev, dev_ctx->context);

		clear_bit(MLX5_INTERFACE_ADDED, &dev_ctx->state);

	}

}



void mlx5_detach_device(struct mlx5_core_dev *dev)

{

	struct mlx5_priv *priv = &dev->priv;

	struct auxiliary_device *adev;

	struct auxiliary_driver *adrv;

	struct mlx5_interface *intf;

	pm_message_t pm = {};

	int i;
@@ -477,30 +363,11 @@ void mlx5_detach_device(struct mlx5_core_dev *dev) 
		del_adev(&priv->adev[i]->adev);

		priv->adev[i] = NULL;

	}



	list_for_each_entry(intf, &intf_list, list)

		mlx5_detach_interface(intf, priv);

	mutex_unlock(&mlx5_intf_mutex);

}



bool mlx5_device_registered(struct mlx5_core_dev *dev)

{

	struct mlx5_priv *priv;

	bool found = false;



	mutex_lock(&mlx5_intf_mutex);

	list_for_each_entry(priv, &mlx5_dev_list, dev_list)

		if (priv == &dev->priv)

			found = true;

	mutex_unlock(&mlx5_intf_mutex);



	return found;

}



int mlx5_register_device(struct mlx5_core_dev *dev)

{

	struct mlx5_priv *priv = &dev->priv;

	struct mlx5_interface *intf;

	int ret;



	mutex_lock(&mlx5_intf_mutex);
@@ -508,65 +375,19 @@ int mlx5_register_device(struct mlx5_core_dev *dev) 
	ret = mlx5_rescan_drivers_locked(dev);

	mutex_unlock(&mlx5_intf_mutex);

	if (ret)

		goto add_err;



	mutex_lock(&mlx5_intf_mutex);

	list_add_tail(&priv->dev_list, &mlx5_dev_list);

	list_for_each_entry(intf, &intf_list, list)

		mlx5_add_device(intf, priv);

	mutex_unlock(&mlx5_intf_mutex);



	return 0;



add_err:

		mlx5_unregister_device(dev);



	return ret;

}



void mlx5_unregister_device(struct mlx5_core_dev *dev)

{

	struct mlx5_priv *priv = &dev->priv;

	struct mlx5_interface *intf;



	mutex_lock(&mlx5_intf_mutex);

	list_for_each_entry_reverse(intf, &intf_list, list)

		mlx5_remove_device(intf, priv);

	list_del(&priv->dev_list);



	dev->priv.flags |= MLX5_PRIV_FLAGS_DISABLE_ALL_ADEV;

	mlx5_rescan_drivers_locked(dev);

	mutex_unlock(&mlx5_intf_mutex);

}



int mlx5_register_interface(struct mlx5_interface *intf)

{

	struct mlx5_priv *priv;



	if (!intf->add || !intf->remove)

		return -EINVAL;



	mutex_lock(&mlx5_intf_mutex);

	list_add_tail(&intf->list, &intf_list);

	list_for_each_entry(priv, &mlx5_dev_list, dev_list)

		mlx5_add_device(intf, priv);

	mutex_unlock(&mlx5_intf_mutex);



	return 0;

}

EXPORT_SYMBOL(mlx5_register_interface);



void mlx5_unregister_interface(struct mlx5_interface *intf)

{

	struct mlx5_priv *priv;



	mutex_lock(&mlx5_intf_mutex);

	list_for_each_entry(priv, &mlx5_dev_list, dev_list)

		mlx5_remove_device(intf, priv);

	list_del(&intf->list);

	mutex_unlock(&mlx5_intf_mutex);

}

EXPORT_SYMBOL(mlx5_unregister_interface);



static int add_drivers(struct mlx5_core_dev *dev)

{

	struct mlx5_priv *priv = &dev->priv;
@@ -638,59 +459,6 @@ int mlx5_rescan_drivers_locked(struct mlx5_core_dev *dev) 
	return add_drivers(dev);

}



/* Must be called with intf_mutex held */

static bool mlx5_has_added_dev_by_protocol(struct mlx5_core_dev *mdev, int protocol)

{

	struct mlx5_device_context *dev_ctx;

	struct mlx5_interface *intf;

	bool found = false;



	list_for_each_entry(intf, &intf_list, list) {

		if (intf->protocol == protocol) {

			dev_ctx = mlx5_get_device(intf, &mdev->priv);

			if (dev_ctx && test_bit(MLX5_INTERFACE_ADDED, &dev_ctx->state))

				found = true;

			break;

		}

	}



	return found;

}



void mlx5_reload_interface(struct mlx5_core_dev *mdev, int protocol)

{

	mutex_lock(&mlx5_intf_mutex);

	if (mlx5_has_added_dev_by_protocol(mdev, protocol)) {

		mlx5_remove_dev_by_protocol(mdev, protocol);

		mlx5_add_dev_by_protocol(mdev, protocol);

	}

	mutex_unlock(&mlx5_intf_mutex);

}



/* Must be called with intf_mutex held */

void mlx5_add_dev_by_protocol(struct mlx5_core_dev *dev, int protocol)

{

	struct mlx5_interface *intf;



	list_for_each_entry(intf, &intf_list, list)

		if (intf->protocol == protocol) {

			mlx5_add_device(intf, &dev->priv);

			break;

		}

}



/* Must be called with intf_mutex held */

void mlx5_remove_dev_by_protocol(struct mlx5_core_dev *dev, int protocol)

{

	struct mlx5_interface *intf;



	list_for_each_entry(intf, &intf_list, list)

		if (intf->protocol == protocol) {

			mlx5_remove_device(intf, &dev->priv);

			break;

		}

}



static u32 mlx5_gen_pci_id(const struct mlx5_core_dev *dev)

{

	return (u32)((pci_domain_nr(dev->pdev->bus) << 16) |
@@ -722,45 +490,25 @@ static int next_phys_dev(struct device *dev, const void *data) 
 */

struct mlx5_core_dev *mlx5_get_next_phys_dev(struct mlx5_core_dev *dev)

{

	struct mlx5_core_dev *res = NULL;

	struct mlx5_core_dev *tmp_dev;

	struct auxiliary_device *adev;

	struct mlx5_adev *madev;

	struct mlx5_priv *priv;

	u32 pci_id;



	if (!mlx5_core_is_pf(dev))

		return NULL;



	adev = auxiliary_find_device(NULL, dev, &next_phys_dev);

	if (adev) {

		madev = container_of(adev, struct mlx5_adev, adev);

	if (!adev)

		return NULL;



	madev = container_of(adev, struct mlx5_adev, adev);

	put_device(&adev->dev);

	return madev->mdev;

}



	pci_id = mlx5_gen_pci_id(dev);

	list_for_each_entry(priv, &mlx5_dev_list, dev_list) {

		tmp_dev = container_of(priv, struct mlx5_core_dev, priv);

		if (!mlx5_core_is_pf(tmp_dev))

			continue;



		if ((dev != tmp_dev) && (mlx5_gen_pci_id(tmp_dev) == pci_id)) {

			res = tmp_dev;

			break;

		}

	}



	return res;

}





void mlx5_dev_list_lock(void)

{

	mutex_lock(&mlx5_intf_mutex);

}



void mlx5_dev_list_unlock(void)

{

	mutex_unlock(&mlx5_intf_mutex);

drivers/net/ethernet/mellanox/mlx5/core/lag.c

+0 −18
Original line number Diff line number Diff line
@@ -749,24 +749,6 @@ u8 mlx5_lag_get_slave_port(struct mlx5_core_dev *dev, 
}

EXPORT_SYMBOL(mlx5_lag_get_slave_port);



bool mlx5_lag_intf_add(struct mlx5_interface *intf, struct mlx5_priv *priv)

{

	struct mlx5_core_dev *dev = container_of(priv, struct mlx5_core_dev,

						 priv);

	struct mlx5_lag *ldev;



	if (intf->protocol != MLX5_INTERFACE_PROTOCOL_IB)

		return true;



	ldev = mlx5_lag_dev_get(dev);

	if (!ldev || !__mlx5_lag_is_roce(ldev) ||

	    ldev->pf[MLX5_LAG_P1].dev == dev)

		return true;



	/* If bonded, we do not add an IB device for PF1. */

	return false;

}



int mlx5_lag_query_cong_counters(struct mlx5_core_dev *dev,

				 u64 *values,

				 int num_counters,

drivers/net/ethernet/mellanox/mlx5/core/mlx5_core.h

+0 −8
Original line number Diff line number Diff line
@@ -183,22 +183,15 @@ void mlx5_adev_idx_free(int idx); 
void mlx5_adev_cleanup(struct mlx5_core_dev *dev);

int mlx5_adev_init(struct mlx5_core_dev *dev);



void mlx5_add_device(struct mlx5_interface *intf, struct mlx5_priv *priv);

void mlx5_remove_device(struct mlx5_interface *intf, struct mlx5_priv *priv);

int mlx5_attach_device(struct mlx5_core_dev *dev);

void mlx5_detach_device(struct mlx5_core_dev *dev);

bool mlx5_device_registered(struct mlx5_core_dev *dev);

int mlx5_register_device(struct mlx5_core_dev *dev);

void mlx5_unregister_device(struct mlx5_core_dev *dev);

void mlx5_add_dev_by_protocol(struct mlx5_core_dev *dev, int protocol);

void mlx5_remove_dev_by_protocol(struct mlx5_core_dev *dev, int protocol);

struct mlx5_core_dev *mlx5_get_next_phys_dev(struct mlx5_core_dev *dev);

void mlx5_dev_list_lock(void);

void mlx5_dev_list_unlock(void);

int mlx5_dev_list_trylock(void);



bool mlx5_lag_intf_add(struct mlx5_interface *intf, struct mlx5_priv *priv);



int mlx5_query_mtpps(struct mlx5_core_dev *dev, u32 *mtpps, u32 mtpps_size);

int mlx5_set_mtpps(struct mlx5_core_dev *mdev, u32 *mtpps, u32 mtpps_size);

int mlx5_query_mtppse(struct mlx5_core_dev *mdev, u8 pin, u8 *arm, u8 *mode);
@@ -248,7 +241,6 @@ static inline int mlx5_rescan_drivers(struct mlx5_core_dev *dev) 
	return ret;

}



void mlx5_reload_interface(struct mlx5_core_dev *mdev, int protocol);

void mlx5_lag_update(struct mlx5_core_dev *dev);



enum {

include/linux/mlx5/driver.h

+0 −22
Original line number Diff line number Diff line
@@ -1076,28 +1076,6 @@ enum { 
	MAX_MR_CACHE_ENTRIES

};



enum {

	MLX5_INTERFACE_PROTOCOL_ETH_REP,

	MLX5_INTERFACE_PROTOCOL_ETH,



	MLX5_INTERFACE_PROTOCOL_IB_REP,

	MLX5_INTERFACE_PROTOCOL_MPIB,

	MLX5_INTERFACE_PROTOCOL_IB,



	MLX5_INTERFACE_PROTOCOL_VDPA,

};



struct mlx5_interface {

	void *			(*add)(struct mlx5_core_dev *dev);

	void			(*remove)(struct mlx5_core_dev *dev, void *context);

	int			(*attach)(struct mlx5_core_dev *dev, void *context);

	void			(*detach)(struct mlx5_core_dev *dev, void *context);

	int			protocol;

	struct list_head	list;

};



int mlx5_register_interface(struct mlx5_interface *intf);

void mlx5_unregister_interface(struct mlx5_interface *intf);

int mlx5_notifier_register(struct mlx5_core_dev *dev, struct notifier_block *nb);

int mlx5_notifier_unregister(struct mlx5_core_dev *dev, struct notifier_block *nb);

int mlx5_eq_notifier_register(struct mlx5_core_dev *dev, struct mlx5_nb *nb);