[deliverable/linux.git] / drivers / net / ethernet / mellanox / mlx4 / en_dcb_nl.c

/*
 * Copyright (c) 2011 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/dcbnl.h>
#include <linux/math64.h>

#include "mlx4_en.h"

static int mlx4_en_dcbnl_ieee_getets(struct net_device *dev,
				   struct ieee_ets *ets)
{
	struct mlx4_en_priv *priv = netdev_priv(dev);
	struct ieee_ets *my_ets = &priv->ets;

	/* No IEEE PFC settings available */
	if (!my_ets)
		return -EINVAL;

	ets->ets_cap = IEEE_8021QAZ_MAX_TCS;
	ets->cbs = my_ets->cbs;
	memcpy(ets->tc_tx_bw, my_ets->tc_tx_bw, sizeof(ets->tc_tx_bw));
	memcpy(ets->tc_tsa, my_ets->tc_tsa, sizeof(ets->tc_tsa));
	memcpy(ets->prio_tc, my_ets->prio_tc, sizeof(ets->prio_tc));

	return 0;
}

static int mlx4_en_ets_validate(struct mlx4_en_priv *priv, struct ieee_ets *ets)
{
	int i;
	int total_ets_bw = 0;
	int has_ets_tc = 0;

	for (i = 0; i < IEEE_8021QAZ_MAX_TCS; i++) {
		if (ets->prio_tc[i] > MLX4_EN_NUM_UP) {
			en_err(priv, "Bad priority in UP <=> TC mapping. TC: %d, UP: %d\n",
					i, ets->prio_tc[i]);
			return -EINVAL;
		}

		switch (ets->tc_tsa[i]) {
		case IEEE_8021QAZ_TSA_STRICT:
			break;
		case IEEE_8021QAZ_TSA_ETS:
			has_ets_tc = 1;
			total_ets_bw += ets->tc_tx_bw[i];
			break;
		default:
			en_err(priv, "TC[%d]: Not supported TSA: %d\n",
					i, ets->tc_tsa[i]);
			return -ENOTSUPP;
		}
	}

	if (has_ets_tc && total_ets_bw != MLX4_EN_BW_MAX) {
		en_err(priv, "Bad ETS BW sum: %d. Should be exactly 100%%\n",
				total_ets_bw);
		return -EINVAL;
	}

	return 0;
}

static int mlx4_en_config_port_scheduler(struct mlx4_en_priv *priv,
		struct ieee_ets *ets, u16 *ratelimit)
{
	struct mlx4_en_dev *mdev = priv->mdev;
	int num_strict = 0;
	int i;
	__u8 tc_tx_bw[IEEE_8021QAZ_MAX_TCS] = { 0 };
	__u8 pg[IEEE_8021QAZ_MAX_TCS] = { 0 };

	ets = ets ?: &priv->ets;
	ratelimit = ratelimit ?: priv->maxrate;

	/* higher TC means higher priority => lower pg */
	for (i = IEEE_8021QAZ_MAX_TCS - 1; i >= 0; i--) {
		switch (ets->tc_tsa[i]) {
		case IEEE_8021QAZ_TSA_STRICT:
			pg[i] = num_strict++;
			tc_tx_bw[i] = MLX4_EN_BW_MAX;
			break;
		case IEEE_8021QAZ_TSA_ETS:
			pg[i] = MLX4_EN_TC_ETS;
			tc_tx_bw[i] = ets->tc_tx_bw[i] ?: MLX4_EN_BW_MIN;
			break;
		}
	}

	return mlx4_SET_PORT_SCHEDULER(mdev->dev, priv->port, tc_tx_bw, pg,
			ratelimit);
}

static int
mlx4_en_dcbnl_ieee_setets(struct net_device *dev, struct ieee_ets *ets)
{
	struct mlx4_en_priv *priv = netdev_priv(dev);
	struct mlx4_en_dev *mdev = priv->mdev;
	int err;

	err = mlx4_en_ets_validate(priv, ets);
	if (err)
		return err;

	err = mlx4_SET_PORT_PRIO2TC(mdev->dev, priv->port, ets->prio_tc);
	if (err)
		return err;

	err = mlx4_en_config_port_scheduler(priv, ets, NULL);
	if (err)
		return err;

	memcpy(&priv->ets, ets, sizeof(priv->ets));

	return 0;
}

static int mlx4_en_dcbnl_ieee_getpfc(struct net_device *dev,
		struct ieee_pfc *pfc)
{
	struct mlx4_en_priv *priv = netdev_priv(dev);

	pfc->pfc_cap = IEEE_8021QAZ_MAX_TCS;
	pfc->pfc_en = priv->prof->tx_ppp;

	return 0;
}

static int mlx4_en_dcbnl_ieee_setpfc(struct net_device *dev,
		struct ieee_pfc *pfc)
{
	struct mlx4_en_priv *priv = netdev_priv(dev);
	struct mlx4_en_dev *mdev = priv->mdev;
	int err;

	en_dbg(DRV, priv, "cap: 0x%x en: 0x%x mbc: 0x%x delay: %d\n",
			pfc->pfc_cap,
			pfc->pfc_en,
			pfc->mbc,
			pfc->delay);

	priv->prof->rx_pause = priv->prof->tx_pause = !!pfc->pfc_en;
	priv->prof->rx_ppp = priv->prof->tx_ppp = pfc->pfc_en;

	err = mlx4_SET_PORT_general(mdev->dev, priv->port,
				    priv->rx_skb_size + ETH_FCS_LEN,
				    priv->prof->tx_pause,
				    priv->prof->tx_ppp,
				    priv->prof->rx_pause,
				    priv->prof->rx_ppp);
	if (err)
		en_err(priv, "Failed setting pause params\n");

	return err;
}

static u8 mlx4_en_dcbnl_getdcbx(struct net_device *dev)
{
	return DCB_CAP_DCBX_VER_IEEE;
}

static u8 mlx4_en_dcbnl_setdcbx(struct net_device *dev, u8 mode)
{
	if ((mode & DCB_CAP_DCBX_LLD_MANAGED) ||
	    (mode & DCB_CAP_DCBX_VER_CEE) ||
	    !(mode & DCB_CAP_DCBX_VER_IEEE) ||
	    !(mode & DCB_CAP_DCBX_HOST))
		return 1;

	return 0;
}

#define MLX4_RATELIMIT_UNITS_IN_KB 100000 /* rate-limit HW unit in Kbps */
static int mlx4_en_dcbnl_ieee_getmaxrate(struct net_device *dev,
				   struct ieee_maxrate *maxrate)
{
	struct mlx4_en_priv *priv = netdev_priv(dev);
	int i;

	if (!priv->maxrate)
		return -EINVAL;

	for (i = 0; i < IEEE_8021QAZ_MAX_TCS; i++)
		maxrate->tc_maxrate[i] =
			priv->maxrate[i] * MLX4_RATELIMIT_UNITS_IN_KB;

	return 0;
}

static int mlx4_en_dcbnl_ieee_setmaxrate(struct net_device *dev,
		struct ieee_maxrate *maxrate)
{
	struct mlx4_en_priv *priv = netdev_priv(dev);
	u16 tmp[IEEE_8021QAZ_MAX_TCS];
	int i, err;

	for (i = 0; i < IEEE_8021QAZ_MAX_TCS; i++) {
		/* Convert from Kbps into HW units, rounding result up.
		 * Setting to 0, means unlimited BW.
		 */
		tmp[i] = div_u64(maxrate->tc_maxrate[i] +
				 MLX4_RATELIMIT_UNITS_IN_KB - 1,
				 MLX4_RATELIMIT_UNITS_IN_KB);
	}

	err = mlx4_en_config_port_scheduler(priv, NULL, tmp);
	if (err)
		return err;

	memcpy(priv->maxrate, tmp, sizeof(priv->maxrate));

	return 0;
}

const struct dcbnl_rtnl_ops mlx4_en_dcbnl_ops = {
	.ieee_getets	= mlx4_en_dcbnl_ieee_getets,
	.ieee_setets	= mlx4_en_dcbnl_ieee_setets,
	.ieee_getmaxrate = mlx4_en_dcbnl_ieee_getmaxrate,
	.ieee_setmaxrate = mlx4_en_dcbnl_ieee_setmaxrate,
	.ieee_getpfc	= mlx4_en_dcbnl_ieee_getpfc,
	.ieee_setpfc	= mlx4_en_dcbnl_ieee_setpfc,

	.getdcbx	= mlx4_en_dcbnl_getdcbx,
	.setdcbx	= mlx4_en_dcbnl_setdcbx,
};
Commit	Line	Data
564c274c AV	1	/*
	2	* Copyright (c) 2011 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
	34	#include <linux/dcbnl.h>
43c880df	35	#include <linux/math64.h>
564c274c AV	36
	37	#include "mlx4_en.h"
	38
	39	static int mlx4_en_dcbnl_ieee_getets(struct net_device *dev,
	40	struct ieee_ets *ets)
	41	{
	42	struct mlx4_en_priv *priv = netdev_priv(dev);
	43	struct ieee_ets *my_ets = &priv->ets;
	44
	45	/* No IEEE PFC settings available */
	46	if (!my_ets)
	47	return -EINVAL;
	48
	49	ets->ets_cap = IEEE_8021QAZ_MAX_TCS;
	50	ets->cbs = my_ets->cbs;
	51	memcpy(ets->tc_tx_bw, my_ets->tc_tx_bw, sizeof(ets->tc_tx_bw));
	52	memcpy(ets->tc_tsa, my_ets->tc_tsa, sizeof(ets->tc_tsa));
	53	memcpy(ets->prio_tc, my_ets->prio_tc, sizeof(ets->prio_tc));
	54
	55	return 0;
	56	}
	57
	58	static int mlx4_en_ets_validate(struct mlx4_en_priv priv, struct ieee_ets ets)
	59	{
	60	int i;
	61	int total_ets_bw = 0;
	62	int has_ets_tc = 0;
	63
	64	for (i = 0; i < IEEE_8021QAZ_MAX_TCS; i++) {
	65	if (ets->prio_tc[i] > MLX4_EN_NUM_UP) {
	66	en_err(priv, "Bad priority in UP <=> TC mapping. TC: %d, UP: %d\n",
	67	i, ets->prio_tc[i]);
	68	return -EINVAL;
	69	}
	70
	71	switch (ets->tc_tsa[i]) {
	72	case IEEE_8021QAZ_TSA_STRICT:
	73	break;
	74	case IEEE_8021QAZ_TSA_ETS:
	75	has_ets_tc = 1;
	76	total_ets_bw += ets->tc_tx_bw[i];
	77	break;
	78	default:
	79	en_err(priv, "TC[%d]: Not supported TSA: %d\n",
	80	i, ets->tc_tsa[i]);
	81	return -ENOTSUPP;
	82	}
	83	}
	84
	85	if (has_ets_tc && total_ets_bw != MLX4_EN_BW_MAX) {
	86	en_err(priv, "Bad ETS BW sum: %d. Should be exactly 100%%\n",
	87	total_ets_bw);
	88	return -EINVAL;
	89	}
	90
	91	return 0;
	92	}
	93
	94	static int mlx4_en_config_port_scheduler(struct mlx4_en_priv *priv,
	95	struct ieee_ets ets, u16 ratelimit)
	96	{
	97	struct mlx4_en_dev *mdev = priv->mdev;
	98	int num_strict = 0;
	99	int i;
100	__u8 tc_tx_bw[IEEE_8021QAZ_MAX_TCS] = { 0 };
101	__u8 pg[IEEE_8021QAZ_MAX_TCS] = { 0 };
102
103	ets = ets ?: &priv->ets;
109d2446	104	ratelimit = ratelimit ?: priv->maxrate;
564c274c AV	105
	106	/* higher TC means higher priority => lower pg */
	107	for (i = IEEE_8021QAZ_MAX_TCS - 1; i >= 0; i--) {
	108	switch (ets->tc_tsa[i]) {
	109	case IEEE_8021QAZ_TSA_STRICT:
	110	pg[i] = num_strict++;
	111	tc_tx_bw[i] = MLX4_EN_BW_MAX;
	112	break;
	113	case IEEE_8021QAZ_TSA_ETS:
	114	pg[i] = MLX4_EN_TC_ETS;
	115	tc_tx_bw[i] = ets->tc_tx_bw[i] ?: MLX4_EN_BW_MIN;
	116	break;
	117	}
	118	}
	119
	120	return mlx4_SET_PORT_SCHEDULER(mdev->dev, priv->port, tc_tx_bw, pg,
	121	ratelimit);
	122	}
	123
	124	static int
	125	mlx4_en_dcbnl_ieee_setets(struct net_device dev, struct ieee_ets ets)
	126	{
	127	struct mlx4_en_priv *priv = netdev_priv(dev);
	128	struct mlx4_en_dev *mdev = priv->mdev;
	129	int err;
	130
	131	err = mlx4_en_ets_validate(priv, ets);
	132	if (err)
	133	return err;
	134
	135	err = mlx4_SET_PORT_PRIO2TC(mdev->dev, priv->port, ets->prio_tc);
	136	if (err)
	137	return err;
	138
	139	err = mlx4_en_config_port_scheduler(priv, ets, NULL);
	140	if (err)
	141	return err;
	142
	143	memcpy(&priv->ets, ets, sizeof(priv->ets));
	144
	145	return 0;
	146	}
	147
	148	static int mlx4_en_dcbnl_ieee_getpfc(struct net_device *dev,
	149	struct ieee_pfc *pfc)
	150	{
	151	struct mlx4_en_priv *priv = netdev_priv(dev);
	152
	153	pfc->pfc_cap = IEEE_8021QAZ_MAX_TCS;
	154	pfc->pfc_en = priv->prof->tx_ppp;
	155
	156	return 0;
	157	}
	158
	159	static int mlx4_en_dcbnl_ieee_setpfc(struct net_device *dev,
	160	struct ieee_pfc *pfc)
	161	{
	162	struct mlx4_en_priv *priv = netdev_priv(dev);
	163	struct mlx4_en_dev *mdev = priv->mdev;
	164	int err;
	165
	166	en_dbg(DRV, priv, "cap: 0x%x en: 0x%x mbc: 0x%x delay: %d\n",
	167	pfc->pfc_cap,
	168	pfc->pfc_en,
169	pfc->mbc,
170	pfc->delay);
171
172	priv->prof->rx_pause = priv->prof->tx_pause = !!pfc->pfc_en;
173	priv->prof->rx_ppp = priv->prof->tx_ppp = pfc->pfc_en;
174
175	err = mlx4_SET_PORT_general(mdev->dev, priv->port,
176	priv->rx_skb_size + ETH_FCS_LEN,
177	priv->prof->tx_pause,
178	priv->prof->tx_ppp,
179	priv->prof->rx_pause,
180	priv->prof->rx_ppp);
181	if (err)
182	en_err(priv, "Failed setting pause params\n");
183
184	return err;
185	}
186
187	static u8 mlx4_en_dcbnl_getdcbx(struct net_device *dev)
188	{
189	return DCB_CAP_DCBX_VER_IEEE;
190	}
191
192	static u8 mlx4_en_dcbnl_setdcbx(struct net_device *dev, u8 mode)
193	{
194	if ((mode & DCB_CAP_DCBX_LLD_MANAGED) \|\|
195	(mode & DCB_CAP_DCBX_VER_CEE) \|\|
196	!(mode & DCB_CAP_DCBX_VER_IEEE) \|\|
197	!(mode & DCB_CAP_DCBX_HOST))
198	return 1;
199
200	return 0;
201	}
202
109d2446 AV	203	#define MLX4_RATELIMIT_UNITS_IN_KB 100000 /* rate-limit HW unit in Kbps */
	204	static int mlx4_en_dcbnl_ieee_getmaxrate(struct net_device *dev,
	205	struct ieee_maxrate *maxrate)
	206	{
	207	struct mlx4_en_priv *priv = netdev_priv(dev);
	208	int i;
	209
	210	if (!priv->maxrate)
	211	return -EINVAL;
	212
	213	for (i = 0; i < IEEE_8021QAZ_MAX_TCS; i++)
	214	maxrate->tc_maxrate[i] =
	215	priv->maxrate[i] * MLX4_RATELIMIT_UNITS_IN_KB;
	216
	217	return 0;
	218	}
	219
	220	static int mlx4_en_dcbnl_ieee_setmaxrate(struct net_device *dev,
	221	struct ieee_maxrate *maxrate)
	222	{
	223	struct mlx4_en_priv *priv = netdev_priv(dev);
	224	u16 tmp[IEEE_8021QAZ_MAX_TCS];
	225	int i, err;
	226
	227	for (i = 0; i < IEEE_8021QAZ_MAX_TCS; i++) {
	228	/* Convert from Kbps into HW units, rounding result up.
	229	* Setting to 0, means unlimited BW.
	230	*/
43c880df PG	231	tmp[i] = div_u64(maxrate->tc_maxrate[i] +
	232	MLX4_RATELIMIT_UNITS_IN_KB - 1,
	233	MLX4_RATELIMIT_UNITS_IN_KB);
109d2446 AV	234	}
	235
	236	err = mlx4_en_config_port_scheduler(priv, NULL, tmp);
	237	if (err)
	238	return err;
	239
29bb8f4a	240	memcpy(priv->maxrate, tmp, sizeof(priv->maxrate));
109d2446 AV	241
	242	return 0;
	243	}
	244
564c274c AV	245	const struct dcbnl_rtnl_ops mlx4_en_dcbnl_ops = {
	246	.ieee_getets = mlx4_en_dcbnl_ieee_getets,
	247	.ieee_setets = mlx4_en_dcbnl_ieee_setets,
109d2446 AV	248	.ieee_getmaxrate = mlx4_en_dcbnl_ieee_getmaxrate,
109d2446 AV	249	.ieee_setmaxrate = mlx4_en_dcbnl_ieee_setmaxrate,
564c274c AV	250	.ieee_getpfc = mlx4_en_dcbnl_ieee_getpfc,
	251	.ieee_setpfc = mlx4_en_dcbnl_ieee_setpfc,
	252
	253	.getdcbx = mlx4_en_dcbnl_getdcbx,
	254	.setdcbx = mlx4_en_dcbnl_setdcbx,
	255	};