[linux-2.6-block.git] / drivers / net / ethernet / mellanox / mlx5 / core / ipoib / ipoib_vlan.c

/*
 * Copyright (c) 2017, Mellanox Technologies. All rights reserved.
 *
 * This software is available to you under a choice of one of two
 * licenses.  You may choose to be licensed under the terms of the GNU
 * General Public License (GPL) Version 2, available from the file
 * COPYING in the main directory of this source tree, or the
 * OpenIB.org BSD license below:
 *
 *     Redistribution and use in source and binary forms, with or
 *     without modification, are permitted provided that the following
 *     conditions are met:
 *
 *      - Redistributions of source code must retain the above
 *        copyright notice, this list of conditions and the following
 *        disclaimer.
 *
 *      - Redistributions in binary form must reproduce the above
 *        copyright notice, this list of conditions and the following
 *        disclaimer in the documentation and/or other materials
 *        provided with the distribution.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

#include <linux/hash.h>
#include "ipoib.h"

#define MLX5I_MAX_LOG_PKEY_SUP 7

struct qpn_to_netdev {
	struct net_device *netdev;
	struct hlist_node hlist;
	u32 underlay_qpn;
};

struct mlx5i_pkey_qpn_ht {
	struct hlist_head buckets[1 << MLX5I_MAX_LOG_PKEY_SUP];
	spinlock_t ht_lock; /* Synchronise with NAPI */
};

int mlx5i_pkey_qpn_ht_init(struct net_device *netdev)
{
	struct mlx5i_priv *ipriv = netdev_priv(netdev);
	struct mlx5i_pkey_qpn_ht *qpn_htbl;

	qpn_htbl = kzalloc(sizeof(*qpn_htbl), GFP_KERNEL);
	if (!qpn_htbl)
		return -ENOMEM;

	ipriv->qpn_htbl = qpn_htbl;
	spin_lock_init(&qpn_htbl->ht_lock);

	return 0;
}

void mlx5i_pkey_qpn_ht_cleanup(struct net_device *netdev)
{
	struct mlx5i_priv *ipriv = netdev_priv(netdev);

	kfree(ipriv->qpn_htbl);
}

static struct qpn_to_netdev *mlx5i_find_qpn_to_netdev_node(struct hlist_head *buckets,
							   u32 qpn)
{
	struct hlist_head *h = &buckets[hash_32(qpn, MLX5I_MAX_LOG_PKEY_SUP)];
	struct qpn_to_netdev *node;

	hlist_for_each_entry(node, h, hlist) {
		if (node->underlay_qpn == qpn)
			return node;
	}

	return NULL;
}

int mlx5i_pkey_add_qpn(struct net_device *netdev, u32 qpn)
{
	struct mlx5i_priv *ipriv = netdev_priv(netdev);
	struct mlx5i_pkey_qpn_ht *ht = ipriv->qpn_htbl;
	u8 key = hash_32(qpn, MLX5I_MAX_LOG_PKEY_SUP);
	struct qpn_to_netdev *new_node;

	new_node = kzalloc(sizeof(*new_node), GFP_KERNEL);
	if (!new_node)
		return -ENOMEM;

	new_node->netdev = netdev;
	new_node->underlay_qpn = qpn;
	spin_lock_bh(&ht->ht_lock);
	hlist_add_head(&new_node->hlist, &ht->buckets[key]);
	spin_unlock_bh(&ht->ht_lock);

	return 0;
}

int mlx5i_pkey_del_qpn(struct net_device *netdev, u32 qpn)
{
	struct mlx5e_priv *epriv = mlx5i_epriv(netdev);
	struct mlx5i_priv *ipriv = epriv->ppriv;
	struct mlx5i_pkey_qpn_ht *ht = ipriv->qpn_htbl;
	struct qpn_to_netdev *node;

	node = mlx5i_find_qpn_to_netdev_node(ht->buckets, qpn);
	if (!node) {
		mlx5_core_warn(epriv->mdev, "QPN to netdev delete from HT failed\n");
		return -EINVAL;
	}

	spin_lock_bh(&ht->ht_lock);
	hlist_del_init(&node->hlist);
	spin_unlock_bh(&ht->ht_lock);
	kfree(node);

	return 0;
}

struct net_device *mlx5i_pkey_get_netdev(struct net_device *netdev, u32 qpn)
{
	struct mlx5i_priv *ipriv = netdev_priv(netdev);
	struct qpn_to_netdev *node;

	node = mlx5i_find_qpn_to_netdev_node(ipriv->qpn_htbl->buckets, qpn);
	if (!node)
		return NULL;

	return node->netdev;
}

static int mlx5i_pkey_open(struct net_device *netdev);
static int mlx5i_pkey_close(struct net_device *netdev);
static int mlx5i_pkey_dev_init(struct net_device *dev);
static void mlx5i_pkey_dev_cleanup(struct net_device *netdev);
static int mlx5i_pkey_change_mtu(struct net_device *netdev, int new_mtu);
static int mlx5i_pkey_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd);

static const struct net_device_ops mlx5i_pkey_netdev_ops = {
	.ndo_open                = mlx5i_pkey_open,
	.ndo_stop                = mlx5i_pkey_close,
	.ndo_init                = mlx5i_pkey_dev_init,
	.ndo_get_stats64         = mlx5i_get_stats,
	.ndo_uninit              = mlx5i_pkey_dev_cleanup,
	.ndo_change_mtu          = mlx5i_pkey_change_mtu,
	.ndo_eth_ioctl            = mlx5i_pkey_ioctl,
};

/* Child NDOs */
static int mlx5i_pkey_dev_init(struct net_device *dev)
{
	struct mlx5e_priv *priv = mlx5i_epriv(dev);
	struct mlx5i_priv *ipriv, *parent_ipriv;
	struct net_device *parent_dev;
	int parent_ifindex;

	ipriv = priv->ppriv;

	/* Get QPN to netdevice hash table from parent */
	parent_ifindex = dev->netdev_ops->ndo_get_iflink(dev);
	parent_dev = dev_get_by_index(dev_net(dev), parent_ifindex);
	if (!parent_dev) {
		mlx5_core_warn(priv->mdev, "failed to get parent device\n");
		return -EINVAL;
	}

	parent_ipriv = netdev_priv(parent_dev);
	ipriv->qpn_htbl = parent_ipriv->qpn_htbl;
	dev_put(parent_dev);

	return mlx5i_dev_init(dev);
}

static int mlx5i_pkey_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
{
	return mlx5i_ioctl(dev, ifr, cmd);
}

static void mlx5i_pkey_dev_cleanup(struct net_device *netdev)
{
	return mlx5i_dev_cleanup(netdev);
}

static int mlx5i_pkey_open(struct net_device *netdev)
{
	struct mlx5e_priv *epriv = mlx5i_epriv(netdev);
	struct mlx5i_priv *ipriv = epriv->ppriv;
	struct mlx5_core_dev *mdev = epriv->mdev;
	int err;

	mutex_lock(&epriv->state_lock);

	set_bit(MLX5E_STATE_OPENED, &epriv->state);

	err = mlx5i_init_underlay_qp(epriv);
	if (err) {
		mlx5_core_warn(mdev, "prepare child underlay qp state failed, %d\n", err);
		goto err_release_lock;
	}

	err = mlx5_fs_add_rx_underlay_qpn(mdev, ipriv->qpn);
	if (err) {
		mlx5_core_warn(mdev, "attach child underlay qp to ft failed, %d\n", err);
		goto err_unint_underlay_qp;
	}

	err = mlx5i_create_tis(mdev, ipriv->qpn, &epriv->tisn[0][0]);
	if (err) {
		mlx5_core_warn(mdev, "create child tis failed, %d\n", err);
		goto err_remove_rx_uderlay_qp;
	}

	err = mlx5e_open_channels(epriv, &epriv->channels);
	if (err) {
		mlx5_core_warn(mdev, "opening child channels failed, %d\n", err);
		goto err_clear_state_opened_flag;
	}
	epriv->profile->update_rx(epriv);
	mlx5e_activate_priv_channels(epriv);
	mutex_unlock(&epriv->state_lock);

	return 0;

err_clear_state_opened_flag:
	mlx5e_destroy_tis(mdev, epriv->tisn[0][0]);
err_remove_rx_uderlay_qp:
	mlx5_fs_remove_rx_underlay_qpn(mdev, ipriv->qpn);
err_unint_underlay_qp:
	mlx5i_uninit_underlay_qp(epriv);
err_release_lock:
	clear_bit(MLX5E_STATE_OPENED, &epriv->state);
	mutex_unlock(&epriv->state_lock);
	return err;
}

static int mlx5i_pkey_close(struct net_device *netdev)
{
	struct mlx5e_priv *priv = mlx5i_epriv(netdev);
	struct mlx5i_priv *ipriv = priv->ppriv;
	struct mlx5_core_dev *mdev = priv->mdev;

	mutex_lock(&priv->state_lock);

	if (!test_bit(MLX5E_STATE_OPENED, &priv->state))
		goto unlock;

	clear_bit(MLX5E_STATE_OPENED, &priv->state);

	netif_carrier_off(priv->netdev);
	mlx5_fs_remove_rx_underlay_qpn(mdev, ipriv->qpn);
	mlx5i_uninit_underlay_qp(priv);
	mlx5e_deactivate_priv_channels(priv);
	mlx5e_close_channels(&priv->channels);
	mlx5e_destroy_tis(mdev, priv->tisn[0][0]);
unlock:
	mutex_unlock(&priv->state_lock);
	return 0;
}

static int mlx5i_pkey_change_mtu(struct net_device *netdev, int new_mtu)
{
	struct mlx5e_priv *priv = mlx5i_epriv(netdev);

	mutex_lock(&priv->state_lock);
	netdev->mtu = new_mtu;
	mutex_unlock(&priv->state_lock);

	return 0;
}

/* Called directly after IPoIB netdevice was created to initialize SW structs */
static int mlx5i_pkey_init(struct mlx5_core_dev *mdev,
			   struct net_device *netdev)
{
	struct mlx5e_priv *priv  = mlx5i_epriv(netdev);
	int err;

	err = mlx5i_init(mdev, netdev);
	if (err)
		return err;

	/* Override parent ndo */
	netdev->netdev_ops = &mlx5i_pkey_netdev_ops;

	/* Set child limited ethtool support */
	netdev->ethtool_ops = &mlx5i_pkey_ethtool_ops;

	/* Use dummy rqs */
	priv->channels.params.log_rq_mtu_frames = MLX5E_PARAMS_MINIMUM_LOG_RQ_SIZE;

	return 0;
}

/* Called directly before IPoIB netdevice is destroyed to cleanup SW structs */
static void mlx5i_pkey_cleanup(struct mlx5e_priv *priv)
{
	mlx5i_cleanup(priv);
}

static int mlx5i_pkey_init_tx(struct mlx5e_priv *priv)
{
	int err;

	err = mlx5i_create_underlay_qp(priv);
	if (err)
		mlx5_core_warn(priv->mdev, "create child underlay QP failed, %d\n", err);

	return err;
}

static void mlx5i_pkey_cleanup_tx(struct mlx5e_priv *priv)
{
	struct mlx5i_priv *ipriv = priv->ppriv;

	mlx5i_destroy_underlay_qp(priv->mdev, ipriv->qpn);
}

static int mlx5i_pkey_init_rx(struct mlx5e_priv *priv)
{
	/* Since the rx resources are shared between child and parent, the
	 * parent interface is taking care of rx resource allocation and init
	 */
	return 0;
}

static void mlx5i_pkey_cleanup_rx(struct mlx5e_priv *priv)
{
	/* Since the rx resources are shared between child and parent, the
	 * parent interface is taking care of rx resource free and de-init
	 */
}

static const struct mlx5e_profile mlx5i_pkey_nic_profile = {
	.init		   = mlx5i_pkey_init,
	.cleanup	   = mlx5i_pkey_cleanup,
	.init_tx	   = mlx5i_pkey_init_tx,
	.cleanup_tx	   = mlx5i_pkey_cleanup_tx,
	.init_rx	   = mlx5i_pkey_init_rx,
	.cleanup_rx	   = mlx5i_pkey_cleanup_rx,
	.enable		   = NULL,
	.disable	   = NULL,
	.update_rx	   = mlx5i_update_nic_rx,
	.update_stats	   = NULL,
	.rx_handlers       = &mlx5i_rx_handlers,
	.max_tc		   = MLX5I_MAX_NUM_TC,
	.rq_groups	   = MLX5E_NUM_RQ_GROUPS(REGULAR),
	.rx_ptp_support	   = false,
};

const struct mlx5e_profile *mlx5i_pkey_get_profile(void)
{
	return &mlx5i_pkey_nic_profile;
}
Commit	Line	Data
7e7f4780 AV	1	/*
	2	* Copyright (c) 2017, Mellanox Technologies. All rights reserved.
	3	*
	4	* This software is available to you under a choice of one of two
	5	* licenses. You may choose to be licensed under the terms of the GNU
	6	* General Public License (GPL) Version 2, available from the file
	7	* COPYING in the main directory of this source tree, or the
	8	* OpenIB.org BSD license below:
	9	*
	10	* Redistribution and use in source and binary forms, with or
	11	* without modification, are permitted provided that the following
	12	* conditions are met:
	13	*
	14	* - Redistributions of source code must retain the above
	15	* copyright notice, this list of conditions and the following
	16	* disclaimer.
	17	*
	18	* - Redistributions in binary form must reproduce the above
	19	* copyright notice, this list of conditions and the following
	20	* disclaimer in the documentation and/or other materials
	21	* provided with the distribution.
	22	*
	23	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
	24	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
	25	* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
	26	* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
	27	* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
	28	* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
	29	* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
	30	* SOFTWARE.
	31	*/
	32
	33	#include <linux/hash.h>
	34	#include "ipoib.h"
	35
	36	#define MLX5I_MAX_LOG_PKEY_SUP 7
	37
	38	struct qpn_to_netdev {
	39	struct net_device *netdev;
	40	struct hlist_node hlist;
	41	u32 underlay_qpn;
	42	};
	43
	44	struct mlx5i_pkey_qpn_ht {
	45	struct hlist_head buckets[1 << MLX5I_MAX_LOG_PKEY_SUP];
	46	spinlock_t ht_lock; /* Synchronise with NAPI */
	47	};
	48
	49	int mlx5i_pkey_qpn_ht_init(struct net_device *netdev)
	50	{
	51	struct mlx5i_priv *ipriv = netdev_priv(netdev);
	52	struct mlx5i_pkey_qpn_ht *qpn_htbl;
	53
	54	qpn_htbl = kzalloc(sizeof(*qpn_htbl), GFP_KERNEL);
	55	if (!qpn_htbl)
	56	return -ENOMEM;
	57
	58	ipriv->qpn_htbl = qpn_htbl;
	59	spin_lock_init(&qpn_htbl->ht_lock);
	60
	61	return 0;
	62	}
	63
	64	void mlx5i_pkey_qpn_ht_cleanup(struct net_device *netdev)
65	{
66	struct mlx5i_priv *ipriv = netdev_priv(netdev);
67
68	kfree(ipriv->qpn_htbl);
69	}
70
71	static struct qpn_to_netdev mlx5i_find_qpn_to_netdev_node(struct hlist_head buckets,
72	u32 qpn)
73	{
74	struct hlist_head *h = &buckets[hash_32(qpn, MLX5I_MAX_LOG_PKEY_SUP)];
75	struct qpn_to_netdev *node;
76
77	hlist_for_each_entry(node, h, hlist) {
78	if (node->underlay_qpn == qpn)
79	return node;
80	}
81
82	return NULL;
83	}
84
85	int mlx5i_pkey_add_qpn(struct net_device *netdev, u32 qpn)
86	{
87	struct mlx5i_priv *ipriv = netdev_priv(netdev);
88	struct mlx5i_pkey_qpn_ht *ht = ipriv->qpn_htbl;
89	u8 key = hash_32(qpn, MLX5I_MAX_LOG_PKEY_SUP);
90	struct qpn_to_netdev *new_node;
91
92	new_node = kzalloc(sizeof(*new_node), GFP_KERNEL);
93	if (!new_node)
94	return -ENOMEM;
95
96	new_node->netdev = netdev;
97	new_node->underlay_qpn = qpn;
98	spin_lock_bh(&ht->ht_lock);
99	hlist_add_head(&new_node->hlist, &ht->buckets[key]);
100	spin_unlock_bh(&ht->ht_lock);
101
102	return 0;
103	}
104
105	int mlx5i_pkey_del_qpn(struct net_device *netdev, u32 qpn)
106	{
107	struct mlx5e_priv *epriv = mlx5i_epriv(netdev);
108	struct mlx5i_priv *ipriv = epriv->ppriv;
109	struct mlx5i_pkey_qpn_ht *ht = ipriv->qpn_htbl;
110	struct qpn_to_netdev *node;
111
112	node = mlx5i_find_qpn_to_netdev_node(ht->buckets, qpn);
113	if (!node) {
114	mlx5_core_warn(epriv->mdev, "QPN to netdev delete from HT failed\n");
115	return -EINVAL;
116	}
117
118	spin_lock_bh(&ht->ht_lock);
119	hlist_del_init(&node->hlist);
120	spin_unlock_bh(&ht->ht_lock);
121	kfree(node);
122
123	return 0;
124	}
125
126	struct net_device mlx5i_pkey_get_netdev(struct net_device netdev, u32 qpn)
127	{
128	struct mlx5i_priv *ipriv = netdev_priv(netdev);
129	struct qpn_to_netdev *node;
130
131	node = mlx5i_find_qpn_to_netdev_node(ipriv->qpn_htbl->buckets, qpn);
132	if (!node)
133	return NULL;
134
135	return node->netdev;
136	}
4c6c615e	137
af98cebc AV	138	static int mlx5i_pkey_open(struct net_device *netdev);
	139	static int mlx5i_pkey_close(struct net_device *netdev);
	140	static int mlx5i_pkey_dev_init(struct net_device *dev);
	141	static void mlx5i_pkey_dev_cleanup(struct net_device *netdev);
	142	static int mlx5i_pkey_change_mtu(struct net_device *netdev, int new_mtu);
08437c57	143	static int mlx5i_pkey_ioctl(struct net_device dev, struct ifreq ifr, int cmd);
af98cebc AV	144
	145	static const struct net_device_ops mlx5i_pkey_netdev_ops = {
	146	.ndo_open = mlx5i_pkey_open,
	147	.ndo_stop = mlx5i_pkey_close,
	148	.ndo_init = mlx5i_pkey_dev_init,
b75ba382	149	.ndo_get_stats64 = mlx5i_get_stats,
af98cebc AV	150	.ndo_uninit = mlx5i_pkey_dev_cleanup,
af98cebc AV	151	.ndo_change_mtu = mlx5i_pkey_change_mtu,
a7605370	152	.ndo_eth_ioctl = mlx5i_pkey_ioctl,
af98cebc AV	153	};
	154
	155	/* Child NDOs */
	156	static int mlx5i_pkey_dev_init(struct net_device *dev)
	157	{
	158	struct mlx5e_priv *priv = mlx5i_epriv(dev);
	159	struct mlx5i_priv ipriv, parent_ipriv;
	160	struct net_device *parent_dev;
	161	int parent_ifindex;
	162
	163	ipriv = priv->ppriv;
	164
	165	/* Get QPN to netdevice hash table from parent */
	166	parent_ifindex = dev->netdev_ops->ndo_get_iflink(dev);
	167	parent_dev = dev_get_by_index(dev_net(dev), parent_ifindex);
	168	if (!parent_dev) {
	169	mlx5_core_warn(priv->mdev, "failed to get parent device\n");
	170	return -EINVAL;
	171	}
	172
	173	parent_ipriv = netdev_priv(parent_dev);
	174	ipriv->qpn_htbl = parent_ipriv->qpn_htbl;
	175	dev_put(parent_dev);
	176
	177	return mlx5i_dev_init(dev);
	178	}
	179
08437c57 FD	180	static int mlx5i_pkey_ioctl(struct net_device dev, struct ifreq ifr, int cmd)
	181	{
	182	return mlx5i_ioctl(dev, ifr, cmd);
	183	}
	184
af98cebc AV	185	static void mlx5i_pkey_dev_cleanup(struct net_device *netdev)
	186	{
	187	return mlx5i_dev_cleanup(netdev);
	188	}
	189
	190	static int mlx5i_pkey_open(struct net_device *netdev)
	191	{
	192	struct mlx5e_priv *epriv = mlx5i_epriv(netdev);
	193	struct mlx5i_priv *ipriv = epriv->ppriv;
	194	struct mlx5_core_dev *mdev = epriv->mdev;
	195	int err;
	196
	197	mutex_lock(&epriv->state_lock);
	198
	199	set_bit(MLX5E_STATE_OPENED, &epriv->state);
	200
	201	err = mlx5i_init_underlay_qp(epriv);
	202	if (err) {
	203	mlx5_core_warn(mdev, "prepare child underlay qp state failed, %d\n", err);
	204	goto err_release_lock;
	205	}
	206
f93f4f4f	207	err = mlx5_fs_add_rx_underlay_qpn(mdev, ipriv->qpn);
af98cebc AV	208	if (err) {
	209	mlx5_core_warn(mdev, "attach child underlay qp to ft failed, %d\n", err);
	210	goto err_unint_underlay_qp;
	211	}
	212
f93f4f4f	213	err = mlx5i_create_tis(mdev, ipriv->qpn, &epriv->tisn[0][0]);
af98cebc AV	214	if (err) {
	215	mlx5_core_warn(mdev, "create child tis failed, %d\n", err);
	216	goto err_remove_rx_uderlay_qp;
	217	}
	218
	219	err = mlx5e_open_channels(epriv, &epriv->channels);
	220	if (err) {
	221	mlx5_core_warn(mdev, "opening child channels failed, %d\n", err);
	222	goto err_clear_state_opened_flag;
	223	}
a90f88fe	224	epriv->profile->update_rx(epriv);
af98cebc AV	225	mlx5e_activate_priv_channels(epriv);
	226	mutex_unlock(&epriv->state_lock);
	227
	228	return 0;
	229
	230	err_clear_state_opened_flag:
45f171b1	231	mlx5e_destroy_tis(mdev, epriv->tisn[0][0]);
af98cebc	232	err_remove_rx_uderlay_qp:
f93f4f4f	233	mlx5_fs_remove_rx_underlay_qpn(mdev, ipriv->qpn);
af98cebc AV	234	err_unint_underlay_qp:
	235	mlx5i_uninit_underlay_qp(epriv);
	236	err_release_lock:
	237	clear_bit(MLX5E_STATE_OPENED, &epriv->state);
	238	mutex_unlock(&epriv->state_lock);
	239	return err;
	240	}
	241
	242	static int mlx5i_pkey_close(struct net_device *netdev)
	243	{
	244	struct mlx5e_priv *priv = mlx5i_epriv(netdev);
	245	struct mlx5i_priv *ipriv = priv->ppriv;
	246	struct mlx5_core_dev *mdev = priv->mdev;
	247
	248	mutex_lock(&priv->state_lock);
	249
	250	if (!test_bit(MLX5E_STATE_OPENED, &priv->state))
	251	goto unlock;
	252
	253	clear_bit(MLX5E_STATE_OPENED, &priv->state);
	254
	255	netif_carrier_off(priv->netdev);
f93f4f4f	256	mlx5_fs_remove_rx_underlay_qpn(mdev, ipriv->qpn);
af98cebc AV	257	mlx5i_uninit_underlay_qp(priv);
	258	mlx5e_deactivate_priv_channels(priv);
	259	mlx5e_close_channels(&priv->channels);
45f171b1	260	mlx5e_destroy_tis(mdev, priv->tisn[0][0]);
af98cebc AV	261	unlock:
	262	mutex_unlock(&priv->state_lock);
	263	return 0;
	264	}
	265
	266	static int mlx5i_pkey_change_mtu(struct net_device *netdev, int new_mtu)
	267	{
	268	struct mlx5e_priv *priv = mlx5i_epriv(netdev);
	269
	270	mutex_lock(&priv->state_lock);
	271	netdev->mtu = new_mtu;
	272	mutex_unlock(&priv->state_lock);
	273
	274	return 0;
	275	}
	276
4c6c615e	277	/* Called directly after IPoIB netdevice was created to initialize SW structs */
182570b2	278	static int mlx5i_pkey_init(struct mlx5_core_dev *mdev,
3ef14e46	279	struct net_device *netdev)
4c6c615e AV	280	{
4c6c615e AV	281	struct mlx5e_priv *priv = mlx5i_epriv(netdev);
182570b2	282	int err;
4c6c615e	283
3ef14e46	284	err = mlx5i_init(mdev, netdev);
182570b2 FD	285	if (err)
182570b2 FD	286	return err;
4c6c615e AV	287
4c6c615e AV	288	/* Override parent ndo */
af98cebc	289	netdev->netdev_ops = &mlx5i_pkey_netdev_ops;
4c6c615e	290
6a910233 AV	291	/* Set child limited ethtool support */
6a910233 AV	292	netdev->ethtool_ops = &mlx5i_pkey_ethtool_ops;
4c6c615e AV	293
4c6c615e AV	294	/* Use dummy rqs */
73281b78	295	priv->channels.params.log_rq_mtu_frames = MLX5E_PARAMS_MINIMUM_LOG_RQ_SIZE;
182570b2 FD	296
182570b2 FD	297	return 0;
4c6c615e AV	298	}
	299
	300	/* Called directly before IPoIB netdevice is destroyed to cleanup SW structs */
	301	static void mlx5i_pkey_cleanup(struct mlx5e_priv *priv)
	302	{
182570b2	303	mlx5i_cleanup(priv);
4c6c615e AV	304	}
	305
	306	static int mlx5i_pkey_init_tx(struct mlx5e_priv *priv)
	307	{
4c6c615e AV	308	int err;
4c6c615e AV	309
f93f4f4f LR	310	err = mlx5i_create_underlay_qp(priv);
f93f4f4f LR	311	if (err)
4c6c615e	312	mlx5_core_warn(priv->mdev, "create child underlay QP failed, %d\n", err);
4c6c615e	313
f93f4f4f	314	return err;
4c6c615e AV	315	}
	316
	317	static void mlx5i_pkey_cleanup_tx(struct mlx5e_priv *priv)
	318	{
	319	struct mlx5i_priv *ipriv = priv->ppriv;
	320
f93f4f4f	321	mlx5i_destroy_underlay_qp(priv->mdev, ipriv->qpn);
4c6c615e AV	322	}
	323
	324	static int mlx5i_pkey_init_rx(struct mlx5e_priv *priv)
	325	{
	326	/* Since the rx resources are shared between child and parent, the
	327	* parent interface is taking care of rx resource allocation and init
	328	*/
	329	return 0;
	330	}
	331
	332	static void mlx5i_pkey_cleanup_rx(struct mlx5e_priv *priv)
	333	{
	334	/* Since the rx resources are shared between child and parent, the
	335	* parent interface is taking care of rx resource free and de-init
	336	*/
	337	}
	338
	339	static const struct mlx5e_profile mlx5i_pkey_nic_profile = {
	340	.init = mlx5i_pkey_init,
	341	.cleanup = mlx5i_pkey_cleanup,
	342	.init_tx = mlx5i_pkey_init_tx,
	343	.cleanup_tx = mlx5i_pkey_cleanup_tx,
	344	.init_rx = mlx5i_pkey_init_rx,
	345	.cleanup_rx = mlx5i_pkey_cleanup_rx,
	346	.enable = NULL,
	347	.disable = NULL,
80639b19	348	.update_rx = mlx5i_update_nic_rx,
4c6c615e	349	.update_stats = NULL,
5adf4c47	350	.rx_handlers = &mlx5i_rx_handlers,
4c6c615e	351	.max_tc = MLX5I_MAX_NUM_TC,
694826e3	352	.rq_groups = MLX5E_NUM_RQ_GROUPS(REGULAR),
3adb60b6	353	.rx_ptp_support = false,
4c6c615e AV	354	};
	355
	356	const struct mlx5e_profile *mlx5i_pkey_get_profile(void)
	357	{
	358	return &mlx5i_pkey_nic_profile;
	359	}