[deliverable/linux.git] / drivers / net / ixgbe / ixgbe_dcb_nl.c

/*******************************************************************************

  Intel 10 Gigabit PCI Express Linux driver
  Copyright(c) 1999 - 2009 Intel Corporation.

  This program is free software; you can redistribute it and/or modify it
  under the terms and conditions of the GNU General Public License,
  version 2, as published by the Free Software Foundation.

  This program is distributed in the hope it will be useful, but WITHOUT
  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  more details.

  You should have received a copy of the GNU General Public License along with
  this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.

  The full GNU General Public License is included in this distribution in
  the file called "COPYING".

  Contact Information:
  Linux NICS <linux.nics@intel.com>
  e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
  Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497

*******************************************************************************/

#include "ixgbe.h"
#include <linux/dcbnl.h>

/* Callbacks for DCB netlink in the kernel */
#define BIT_DCB_MODE	0x01
#define BIT_PFC		0x02
#define BIT_PG_RX	0x04
#define BIT_PG_TX	0x08
#define BIT_BCN         0x10
#define BIT_LINKSPEED   0x80

int ixgbe_copy_dcb_cfg(struct ixgbe_dcb_config *src_dcb_cfg,
                       struct ixgbe_dcb_config *dst_dcb_cfg, int tc_max)
{
	struct tc_configuration *src_tc_cfg = NULL;
	struct tc_configuration *dst_tc_cfg = NULL;
	int i;

	if (!src_dcb_cfg || !dst_dcb_cfg)
		return -EINVAL;

	for (i = DCB_PG_ATTR_TC_0; i < tc_max + DCB_PG_ATTR_TC_0; i++) {
		src_tc_cfg = &src_dcb_cfg->tc_config[i - DCB_PG_ATTR_TC_0];
		dst_tc_cfg = &dst_dcb_cfg->tc_config[i - DCB_PG_ATTR_TC_0];

		dst_tc_cfg->path[DCB_TX_CONFIG].prio_type =
				src_tc_cfg->path[DCB_TX_CONFIG].prio_type;

		dst_tc_cfg->path[DCB_TX_CONFIG].bwg_id =
				src_tc_cfg->path[DCB_TX_CONFIG].bwg_id;

		dst_tc_cfg->path[DCB_TX_CONFIG].bwg_percent =
				src_tc_cfg->path[DCB_TX_CONFIG].bwg_percent;

		dst_tc_cfg->path[DCB_TX_CONFIG].up_to_tc_bitmap =
				src_tc_cfg->path[DCB_TX_CONFIG].up_to_tc_bitmap;

		dst_tc_cfg->path[DCB_RX_CONFIG].prio_type =
				src_tc_cfg->path[DCB_RX_CONFIG].prio_type;

		dst_tc_cfg->path[DCB_RX_CONFIG].bwg_id =
				src_tc_cfg->path[DCB_RX_CONFIG].bwg_id;

		dst_tc_cfg->path[DCB_RX_CONFIG].bwg_percent =
				src_tc_cfg->path[DCB_RX_CONFIG].bwg_percent;

		dst_tc_cfg->path[DCB_RX_CONFIG].up_to_tc_bitmap =
				src_tc_cfg->path[DCB_RX_CONFIG].up_to_tc_bitmap;
	}

	for (i = DCB_PG_ATTR_BW_ID_0; i < DCB_PG_ATTR_BW_ID_MAX; i++) {
		dst_dcb_cfg->bw_percentage[DCB_TX_CONFIG]
			[i-DCB_PG_ATTR_BW_ID_0] = src_dcb_cfg->bw_percentage
				[DCB_TX_CONFIG][i-DCB_PG_ATTR_BW_ID_0];
		dst_dcb_cfg->bw_percentage[DCB_RX_CONFIG]
			[i-DCB_PG_ATTR_BW_ID_0] = src_dcb_cfg->bw_percentage
				[DCB_RX_CONFIG][i-DCB_PG_ATTR_BW_ID_0];
	}

	for (i = DCB_PFC_UP_ATTR_0; i < DCB_PFC_UP_ATTR_MAX; i++) {
		dst_dcb_cfg->tc_config[i - DCB_PFC_UP_ATTR_0].dcb_pfc =
			src_dcb_cfg->tc_config[i - DCB_PFC_UP_ATTR_0].dcb_pfc;
	}

	dst_dcb_cfg->pfc_mode_enable = src_dcb_cfg->pfc_mode_enable;

	return 0;
}

static u8 ixgbe_dcbnl_get_state(struct net_device *netdev)
{
	struct ixgbe_adapter *adapter = netdev_priv(netdev);

	DPRINTK(DRV, INFO, "Get DCB Admin Mode.\n");

	return !!(adapter->flags & IXGBE_FLAG_DCB_ENABLED);
}

static u8 ixgbe_dcbnl_set_state(struct net_device *netdev, u8 state)
{
	u8 err = 0;
	struct ixgbe_adapter *adapter = netdev_priv(netdev);

	DPRINTK(DRV, INFO, "Set DCB Admin Mode.\n");

	if (state > 0) {
		/* Turn on DCB */
		if (adapter->flags & IXGBE_FLAG_DCB_ENABLED)
			goto out;

		if (!(adapter->flags & IXGBE_FLAG_MSIX_ENABLED)) {
			DPRINTK(DRV, ERR, "Enable failed, needs MSI-X\n");
			err = 1;
			goto out;
		}

		if (netif_running(netdev))
			netdev->netdev_ops->ndo_stop(netdev);
		ixgbe_clear_interrupt_scheme(adapter);

		if (adapter->hw.mac.type == ixgbe_mac_82598EB) {
			adapter->last_lfc_mode = adapter->hw.fc.current_mode;
			adapter->hw.fc.requested_mode = ixgbe_fc_none;
		}
		adapter->flags &= ~IXGBE_FLAG_RSS_ENABLED;
		adapter->flags |= IXGBE_FLAG_DCB_ENABLED;
		ixgbe_init_interrupt_scheme(adapter);
		if (netif_running(netdev))
			netdev->netdev_ops->ndo_open(netdev);
	} else {
		/* Turn off DCB */
		if (adapter->flags & IXGBE_FLAG_DCB_ENABLED) {
			if (netif_running(netdev))
				netdev->netdev_ops->ndo_stop(netdev);
			ixgbe_clear_interrupt_scheme(adapter);

			adapter->hw.fc.requested_mode = adapter->last_lfc_mode;
			adapter->temp_dcb_cfg.pfc_mode_enable = false;
			adapter->dcb_cfg.pfc_mode_enable = false;
			adapter->flags &= ~IXGBE_FLAG_DCB_ENABLED;
			adapter->flags |= IXGBE_FLAG_RSS_ENABLED;
			ixgbe_init_interrupt_scheme(adapter);
			if (netif_running(netdev))
				netdev->netdev_ops->ndo_open(netdev);
		}
	}
out:
	return err;
}

static void ixgbe_dcbnl_get_perm_hw_addr(struct net_device *netdev,
					 u8 *perm_addr)
{
	struct ixgbe_adapter *adapter = netdev_priv(netdev);
	int i, j;

	for (i = 0; i < netdev->addr_len; i++)
		perm_addr[i] = adapter->hw.mac.perm_addr[i];

	if (adapter->hw.mac.type == ixgbe_mac_82599EB) {
		for (j = 0; j < netdev->addr_len; j++, i++)
			perm_addr[i] = adapter->hw.mac.san_addr[j];
	}
}

static void ixgbe_dcbnl_set_pg_tc_cfg_tx(struct net_device *netdev, int tc,
                                         u8 prio, u8 bwg_id, u8 bw_pct,
                                         u8 up_map)
{
	struct ixgbe_adapter *adapter = netdev_priv(netdev);

	if (prio != DCB_ATTR_VALUE_UNDEFINED)
		adapter->temp_dcb_cfg.tc_config[tc].path[0].prio_type = prio;
	if (bwg_id != DCB_ATTR_VALUE_UNDEFINED)
		adapter->temp_dcb_cfg.tc_config[tc].path[0].bwg_id = bwg_id;
	if (bw_pct != DCB_ATTR_VALUE_UNDEFINED)
		adapter->temp_dcb_cfg.tc_config[tc].path[0].bwg_percent =
			bw_pct;
	if (up_map != DCB_ATTR_VALUE_UNDEFINED)
		adapter->temp_dcb_cfg.tc_config[tc].path[0].up_to_tc_bitmap =
			up_map;

	if ((adapter->temp_dcb_cfg.tc_config[tc].path[0].prio_type !=
	     adapter->dcb_cfg.tc_config[tc].path[0].prio_type) ||
	    (adapter->temp_dcb_cfg.tc_config[tc].path[0].bwg_id !=
	     adapter->dcb_cfg.tc_config[tc].path[0].bwg_id) ||
	    (adapter->temp_dcb_cfg.tc_config[tc].path[0].bwg_percent !=
	     adapter->dcb_cfg.tc_config[tc].path[0].bwg_percent) ||
	    (adapter->temp_dcb_cfg.tc_config[tc].path[0].up_to_tc_bitmap !=
	     adapter->dcb_cfg.tc_config[tc].path[0].up_to_tc_bitmap))
		adapter->dcb_set_bitmap |= BIT_PG_TX;
}

static void ixgbe_dcbnl_set_pg_bwg_cfg_tx(struct net_device *netdev, int bwg_id,
                                          u8 bw_pct)
{
	struct ixgbe_adapter *adapter = netdev_priv(netdev);

	adapter->temp_dcb_cfg.bw_percentage[0][bwg_id] = bw_pct;

	if (adapter->temp_dcb_cfg.bw_percentage[0][bwg_id] !=
	    adapter->dcb_cfg.bw_percentage[0][bwg_id])
		adapter->dcb_set_bitmap |= BIT_PG_RX;
}

static void ixgbe_dcbnl_set_pg_tc_cfg_rx(struct net_device *netdev, int tc,
                                         u8 prio, u8 bwg_id, u8 bw_pct,
                                         u8 up_map)
{
	struct ixgbe_adapter *adapter = netdev_priv(netdev);

	if (prio != DCB_ATTR_VALUE_UNDEFINED)
		adapter->temp_dcb_cfg.tc_config[tc].path[1].prio_type = prio;
	if (bwg_id != DCB_ATTR_VALUE_UNDEFINED)
		adapter->temp_dcb_cfg.tc_config[tc].path[1].bwg_id = bwg_id;
	if (bw_pct != DCB_ATTR_VALUE_UNDEFINED)
		adapter->temp_dcb_cfg.tc_config[tc].path[1].bwg_percent =
			bw_pct;
	if (up_map != DCB_ATTR_VALUE_UNDEFINED)
		adapter->temp_dcb_cfg.tc_config[tc].path[1].up_to_tc_bitmap =
			up_map;

	if ((adapter->temp_dcb_cfg.tc_config[tc].path[1].prio_type !=
	     adapter->dcb_cfg.tc_config[tc].path[1].prio_type) ||
	    (adapter->temp_dcb_cfg.tc_config[tc].path[1].bwg_id !=
	     adapter->dcb_cfg.tc_config[tc].path[1].bwg_id) ||
	    (adapter->temp_dcb_cfg.tc_config[tc].path[1].bwg_percent !=
	     adapter->dcb_cfg.tc_config[tc].path[1].bwg_percent) ||
	    (adapter->temp_dcb_cfg.tc_config[tc].path[1].up_to_tc_bitmap !=
	     adapter->dcb_cfg.tc_config[tc].path[1].up_to_tc_bitmap))
		adapter->dcb_set_bitmap |= BIT_PG_RX;
}

static void ixgbe_dcbnl_set_pg_bwg_cfg_rx(struct net_device *netdev, int bwg_id,
                                          u8 bw_pct)
{
	struct ixgbe_adapter *adapter = netdev_priv(netdev);

	adapter->temp_dcb_cfg.bw_percentage[1][bwg_id] = bw_pct;

	if (adapter->temp_dcb_cfg.bw_percentage[1][bwg_id] !=
	    adapter->dcb_cfg.bw_percentage[1][bwg_id])
		adapter->dcb_set_bitmap |= BIT_PG_RX;
}

static void ixgbe_dcbnl_get_pg_tc_cfg_tx(struct net_device *netdev, int tc,
                                         u8 *prio, u8 *bwg_id, u8 *bw_pct,
                                         u8 *up_map)
{
	struct ixgbe_adapter *adapter = netdev_priv(netdev);

	*prio = adapter->dcb_cfg.tc_config[tc].path[0].prio_type;
	*bwg_id = adapter->dcb_cfg.tc_config[tc].path[0].bwg_id;
	*bw_pct = adapter->dcb_cfg.tc_config[tc].path[0].bwg_percent;
	*up_map = adapter->dcb_cfg.tc_config[tc].path[0].up_to_tc_bitmap;
}

static void ixgbe_dcbnl_get_pg_bwg_cfg_tx(struct net_device *netdev, int bwg_id,
                                          u8 *bw_pct)
{
	struct ixgbe_adapter *adapter = netdev_priv(netdev);

	*bw_pct = adapter->dcb_cfg.bw_percentage[0][bwg_id];
}

static void ixgbe_dcbnl_get_pg_tc_cfg_rx(struct net_device *netdev, int tc,
                                         u8 *prio, u8 *bwg_id, u8 *bw_pct,
                                         u8 *up_map)
{
	struct ixgbe_adapter *adapter = netdev_priv(netdev);

	*prio = adapter->dcb_cfg.tc_config[tc].path[1].prio_type;
	*bwg_id = adapter->dcb_cfg.tc_config[tc].path[1].bwg_id;
	*bw_pct = adapter->dcb_cfg.tc_config[tc].path[1].bwg_percent;
	*up_map = adapter->dcb_cfg.tc_config[tc].path[1].up_to_tc_bitmap;
}

static void ixgbe_dcbnl_get_pg_bwg_cfg_rx(struct net_device *netdev, int bwg_id,
                                          u8 *bw_pct)
{
	struct ixgbe_adapter *adapter = netdev_priv(netdev);

	*bw_pct = adapter->dcb_cfg.bw_percentage[1][bwg_id];
}

static void ixgbe_dcbnl_set_pfc_cfg(struct net_device *netdev, int priority,
                                    u8 setting)
{
	struct ixgbe_adapter *adapter = netdev_priv(netdev);

	adapter->temp_dcb_cfg.tc_config[priority].dcb_pfc = setting;
	if (adapter->temp_dcb_cfg.tc_config[priority].dcb_pfc !=
	    adapter->dcb_cfg.tc_config[priority].dcb_pfc) {
		adapter->dcb_set_bitmap |= BIT_PFC;
		adapter->temp_dcb_cfg.pfc_mode_enable = true;
	}
}

static void ixgbe_dcbnl_get_pfc_cfg(struct net_device *netdev, int priority,
                                    u8 *setting)
{
	struct ixgbe_adapter *adapter = netdev_priv(netdev);

	*setting = adapter->dcb_cfg.tc_config[priority].dcb_pfc;
}

static u8 ixgbe_dcbnl_set_all(struct net_device *netdev)
{
	struct ixgbe_adapter *adapter = netdev_priv(netdev);
	int ret;

	adapter->dcb_set_bitmap &= ~BIT_BCN;	/* no set for BCN */
	if (!adapter->dcb_set_bitmap)
		return 1;

	while (test_and_set_bit(__IXGBE_RESETTING, &adapter->state))
		msleep(1);

	if (netif_running(netdev))
		ixgbe_down(adapter);

	ret = ixgbe_copy_dcb_cfg(&adapter->temp_dcb_cfg, &adapter->dcb_cfg,
				 adapter->ring_feature[RING_F_DCB].indices);
	if (ret) {
		clear_bit(__IXGBE_RESETTING, &adapter->state);
		return ret;
	}

	if (adapter->dcb_cfg.pfc_mode_enable) {
		if ((adapter->hw.mac.type != ixgbe_mac_82598EB) &&
			(adapter->hw.fc.current_mode != ixgbe_fc_pfc))
			adapter->last_lfc_mode = adapter->hw.fc.current_mode;
		adapter->hw.fc.requested_mode = ixgbe_fc_pfc;
	} else {
		if (adapter->hw.mac.type != ixgbe_mac_82598EB)
			adapter->hw.fc.requested_mode = adapter->last_lfc_mode;
		else
			adapter->hw.fc.requested_mode = ixgbe_fc_none;
	}

	if (netif_running(netdev))
		ixgbe_up(adapter);

	if (adapter->dcb_cfg.pfc_mode_enable)
		adapter->hw.fc.current_mode = ixgbe_fc_pfc;

	adapter->dcb_set_bitmap = 0x00;
	clear_bit(__IXGBE_RESETTING, &adapter->state);
	return ret;
}

static u8 ixgbe_dcbnl_getcap(struct net_device *netdev, int capid, u8 *cap)
{
	struct ixgbe_adapter *adapter = netdev_priv(netdev);
	u8 rval = 0;

	if (adapter->flags & IXGBE_FLAG_DCB_ENABLED) {
		switch (capid) {
		case DCB_CAP_ATTR_PG:
			*cap = true;
			break;
		case DCB_CAP_ATTR_PFC:
			*cap = true;
			break;
		case DCB_CAP_ATTR_UP2TC:
			*cap = false;
			break;
		case DCB_CAP_ATTR_PG_TCS:
			*cap = 0x80;
			break;
		case DCB_CAP_ATTR_PFC_TCS:
			*cap = 0x80;
			break;
		case DCB_CAP_ATTR_GSP:
			*cap = true;
			break;
		case DCB_CAP_ATTR_BCN:
			*cap = false;
			break;
		default:
			rval = -EINVAL;
			break;
		}
	} else {
		rval = -EINVAL;
	}

	return rval;
}

static u8 ixgbe_dcbnl_getnumtcs(struct net_device *netdev, int tcid, u8 *num)
{
	struct ixgbe_adapter *adapter = netdev_priv(netdev);
	u8 rval = 0;

	if (adapter->flags & IXGBE_FLAG_DCB_ENABLED) {
		switch (tcid) {
		case DCB_NUMTCS_ATTR_PG:
			*num = MAX_TRAFFIC_CLASS;
			break;
		case DCB_NUMTCS_ATTR_PFC:
			*num = MAX_TRAFFIC_CLASS;
			break;
		default:
			rval = -EINVAL;
			break;
		}
	} else {
		rval = -EINVAL;
	}

	return rval;
}

static u8 ixgbe_dcbnl_setnumtcs(struct net_device *netdev, int tcid, u8 num)
{
	return -EINVAL;
}

static u8 ixgbe_dcbnl_getpfcstate(struct net_device *netdev)
{
	struct ixgbe_adapter *adapter = netdev_priv(netdev);

	return adapter->dcb_cfg.pfc_mode_enable;
}

static void ixgbe_dcbnl_setpfcstate(struct net_device *netdev, u8 state)
{
	struct ixgbe_adapter *adapter = netdev_priv(netdev);

	adapter->temp_dcb_cfg.pfc_mode_enable = state;
	if (adapter->temp_dcb_cfg.pfc_mode_enable !=
		adapter->dcb_cfg.pfc_mode_enable)
		adapter->dcb_set_bitmap |= BIT_PFC;
	return;
}

struct dcbnl_rtnl_ops dcbnl_ops = {
	.getstate	= ixgbe_dcbnl_get_state,
	.setstate	= ixgbe_dcbnl_set_state,
	.getpermhwaddr	= ixgbe_dcbnl_get_perm_hw_addr,
	.setpgtccfgtx	= ixgbe_dcbnl_set_pg_tc_cfg_tx,
	.setpgbwgcfgtx	= ixgbe_dcbnl_set_pg_bwg_cfg_tx,
	.setpgtccfgrx	= ixgbe_dcbnl_set_pg_tc_cfg_rx,
	.setpgbwgcfgrx	= ixgbe_dcbnl_set_pg_bwg_cfg_rx,
	.getpgtccfgtx	= ixgbe_dcbnl_get_pg_tc_cfg_tx,
	.getpgbwgcfgtx	= ixgbe_dcbnl_get_pg_bwg_cfg_tx,
	.getpgtccfgrx	= ixgbe_dcbnl_get_pg_tc_cfg_rx,
	.getpgbwgcfgrx	= ixgbe_dcbnl_get_pg_bwg_cfg_rx,
	.setpfccfg	= ixgbe_dcbnl_set_pfc_cfg,
	.getpfccfg	= ixgbe_dcbnl_get_pfc_cfg,
	.setall		= ixgbe_dcbnl_set_all,
	.getcap		= ixgbe_dcbnl_getcap,
	.getnumtcs	= ixgbe_dcbnl_getnumtcs,
	.setnumtcs	= ixgbe_dcbnl_setnumtcs,
	.getpfcstate	= ixgbe_dcbnl_getpfcstate,
	.setpfcstate	= ixgbe_dcbnl_setpfcstate,
};
Commit	Line	Data
2f90b865 AD	1	/*******************************************************************************
	2
	3	Intel 10 Gigabit PCI Express Linux driver
3efac5a0	4	Copyright(c) 1999 - 2009 Intel Corporation.
2f90b865 AD	5
	6	This program is free software; you can redistribute it and/or modify it
	7	under the terms and conditions of the GNU General Public License,
	8	version 2, as published by the Free Software Foundation.
	9
	10	This program is distributed in the hope it will be useful, but WITHOUT
	11	ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	12	FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
	13	more details.
	14
	15	You should have received a copy of the GNU General Public License along with
	16	this program; if not, write to the Free Software Foundation, Inc.,
	17	51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
	18
	19	The full GNU General Public License is included in this distribution in
	20	the file called "COPYING".
	21
	22	Contact Information:
	23	Linux NICS <linux.nics@intel.com>
	24	e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
	25	Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
	26
	27	*******************************************************************************/
	28
	29	#include "ixgbe.h"
	30	#include <linux/dcbnl.h>
	31
	32	/* Callbacks for DCB netlink in the kernel */
	33	#define BIT_DCB_MODE 0x01
	34	#define BIT_PFC 0x02
	35	#define BIT_PG_RX 0x04
	36	#define BIT_PG_TX 0x08
859ee3c4	37	#define BIT_BCN 0x10
235ea828	38	#define BIT_LINKSPEED 0x80
2f90b865 AD	39
	40	int ixgbe_copy_dcb_cfg(struct ixgbe_dcb_config *src_dcb_cfg,
	41	struct ixgbe_dcb_config *dst_dcb_cfg, int tc_max)
	42	{
	43	struct tc_configuration *src_tc_cfg = NULL;
	44	struct tc_configuration *dst_tc_cfg = NULL;
	45	int i;
	46
	47	if (!src_dcb_cfg \|\| !dst_dcb_cfg)
	48	return -EINVAL;
	49
	50	for (i = DCB_PG_ATTR_TC_0; i < tc_max + DCB_PG_ATTR_TC_0; i++) {
	51	src_tc_cfg = &src_dcb_cfg->tc_config[i - DCB_PG_ATTR_TC_0];
	52	dst_tc_cfg = &dst_dcb_cfg->tc_config[i - DCB_PG_ATTR_TC_0];
	53
	54	dst_tc_cfg->path[DCB_TX_CONFIG].prio_type =
	55	src_tc_cfg->path[DCB_TX_CONFIG].prio_type;
	56
	57	dst_tc_cfg->path[DCB_TX_CONFIG].bwg_id =
	58	src_tc_cfg->path[DCB_TX_CONFIG].bwg_id;
	59
	60	dst_tc_cfg->path[DCB_TX_CONFIG].bwg_percent =
	61	src_tc_cfg->path[DCB_TX_CONFIG].bwg_percent;
	62
	63	dst_tc_cfg->path[DCB_TX_CONFIG].up_to_tc_bitmap =
	64	src_tc_cfg->path[DCB_TX_CONFIG].up_to_tc_bitmap;
	65
	66	dst_tc_cfg->path[DCB_RX_CONFIG].prio_type =
	67	src_tc_cfg->path[DCB_RX_CONFIG].prio_type;
	68
	69	dst_tc_cfg->path[DCB_RX_CONFIG].bwg_id =
	70	src_tc_cfg->path[DCB_RX_CONFIG].bwg_id;
	71
	72	dst_tc_cfg->path[DCB_RX_CONFIG].bwg_percent =
	73	src_tc_cfg->path[DCB_RX_CONFIG].bwg_percent;
	74
	75	dst_tc_cfg->path[DCB_RX_CONFIG].up_to_tc_bitmap =
	76	src_tc_cfg->path[DCB_RX_CONFIG].up_to_tc_bitmap;
	77	}
	78
	79	for (i = DCB_PG_ATTR_BW_ID_0; i < DCB_PG_ATTR_BW_ID_MAX; i++) {
	80	dst_dcb_cfg->bw_percentage[DCB_TX_CONFIG]
	81	[i-DCB_PG_ATTR_BW_ID_0] = src_dcb_cfg->bw_percentage
	82	[DCB_TX_CONFIG][i-DCB_PG_ATTR_BW_ID_0];
	83	dst_dcb_cfg->bw_percentage[DCB_RX_CONFIG]
	84	[i-DCB_PG_ATTR_BW_ID_0] = src_dcb_cfg->bw_percentage
	85	[DCB_RX_CONFIG][i-DCB_PG_ATTR_BW_ID_0];
	86	}
	87
	88	for (i = DCB_PFC_UP_ATTR_0; i < DCB_PFC_UP_ATTR_MAX; i++) {
	89	dst_dcb_cfg->tc_config[i - DCB_PFC_UP_ATTR_0].dcb_pfc =
	90	src_dcb_cfg->tc_config[i - DCB_PFC_UP_ATTR_0].dcb_pfc;
	91	}
	92
ea4af4f4 PW	93	dst_dcb_cfg->pfc_mode_enable = src_dcb_cfg->pfc_mode_enable;
ea4af4f4 PW	94
2f90b865 AD	95	return 0;
	96	}
	97
	98	static u8 ixgbe_dcbnl_get_state(struct net_device *netdev)
	99	{
	100	struct ixgbe_adapter *adapter = netdev_priv(netdev);
	101
	102	DPRINTK(DRV, INFO, "Get DCB Admin Mode.\n");
	103
	104	return !!(adapter->flags & IXGBE_FLAG_DCB_ENABLED);
	105	}
	106
1486a61e	107	static u8 ixgbe_dcbnl_set_state(struct net_device *netdev, u8 state)
2f90b865	108	{
1486a61e	109	u8 err = 0;
2f90b865 AD	110	struct ixgbe_adapter *adapter = netdev_priv(netdev);
	111
	112	DPRINTK(DRV, INFO, "Set DCB Admin Mode.\n");
	113
	114	if (state > 0) {
	115	/* Turn on DCB */
1486a61e DS	116	if (adapter->flags & IXGBE_FLAG_DCB_ENABLED)
1486a61e DS	117	goto out;
2f90b865	118
1486a61e DS	119	if (!(adapter->flags & IXGBE_FLAG_MSIX_ENABLED)) {
	120	DPRINTK(DRV, ERR, "Enable failed, needs MSI-X\n");
	121	err = 1;
	122	goto out;
2f90b865	123	}
1486a61e DS	124
	125	if (netif_running(netdev))
	126	netdev->netdev_ops->ndo_stop(netdev);
7a921c93	127	ixgbe_clear_interrupt_scheme(adapter);
1486a61e	128
264857b8 PWJ	129	if (adapter->hw.mac.type == ixgbe_mac_82598EB) {
	130	adapter->last_lfc_mode = adapter->hw.fc.current_mode;
	131	adapter->hw.fc.requested_mode = ixgbe_fc_none;
	132	}
1486a61e DS	133	adapter->flags &= ~IXGBE_FLAG_RSS_ENABLED;
	134	adapter->flags \|= IXGBE_FLAG_DCB_ENABLED;
	135	ixgbe_init_interrupt_scheme(adapter);
1486a61e DS	136	if (netif_running(netdev))
1486a61e DS	137	netdev->netdev_ops->ndo_open(netdev);
2f90b865 AD	138	} else {
	139	/* Turn off DCB */
	140	if (adapter->flags & IXGBE_FLAG_DCB_ENABLED) {
	141	if (netif_running(netdev))
1486a61e	142	netdev->netdev_ops->ndo_stop(netdev);
7a921c93	143	ixgbe_clear_interrupt_scheme(adapter);
2f90b865	144
264857b8 PWJ	145	adapter->hw.fc.requested_mode = adapter->last_lfc_mode;
	146	adapter->temp_dcb_cfg.pfc_mode_enable = false;
	147	adapter->dcb_cfg.pfc_mode_enable = false;
2f90b865 AD	148	adapter->flags &= ~IXGBE_FLAG_DCB_ENABLED;
	149	adapter->flags \|= IXGBE_FLAG_RSS_ENABLED;
	150	ixgbe_init_interrupt_scheme(adapter);
2f90b865	151	if (netif_running(netdev))
1486a61e	152	netdev->netdev_ops->ndo_open(netdev);
2f90b865 AD	153	}
2f90b865 AD	154	}
1486a61e DS	155	out:
1486a61e DS	156	return err;
2f90b865 AD	157	}
	158
	159	static void ixgbe_dcbnl_get_perm_hw_addr(struct net_device *netdev,
	160	u8 *perm_addr)
	161	{
	162	struct ixgbe_adapter *adapter = netdev_priv(netdev);
aca6bee7	163	int i, j;
2f90b865 AD	164
	165	for (i = 0; i < netdev->addr_len; i++)
	166	perm_addr[i] = adapter->hw.mac.perm_addr[i];
aca6bee7 WJP	167
	168	if (adapter->hw.mac.type == ixgbe_mac_82599EB) {
	169	for (j = 0; j < netdev->addr_len; j++, i++)
	170	perm_addr[i] = adapter->hw.mac.san_addr[j];
	171	}
2f90b865 AD	172	}
	173
	174	static void ixgbe_dcbnl_set_pg_tc_cfg_tx(struct net_device *netdev, int tc,
	175	u8 prio, u8 bwg_id, u8 bw_pct,
	176	u8 up_map)
	177	{
	178	struct ixgbe_adapter *adapter = netdev_priv(netdev);
	179
	180	if (prio != DCB_ATTR_VALUE_UNDEFINED)
	181	adapter->temp_dcb_cfg.tc_config[tc].path[0].prio_type = prio;
	182	if (bwg_id != DCB_ATTR_VALUE_UNDEFINED)
	183	adapter->temp_dcb_cfg.tc_config[tc].path[0].bwg_id = bwg_id;
	184	if (bw_pct != DCB_ATTR_VALUE_UNDEFINED)
	185	adapter->temp_dcb_cfg.tc_config[tc].path[0].bwg_percent =
	186	bw_pct;
	187	if (up_map != DCB_ATTR_VALUE_UNDEFINED)
	188	adapter->temp_dcb_cfg.tc_config[tc].path[0].up_to_tc_bitmap =
	189	up_map;
	190
	191	if ((adapter->temp_dcb_cfg.tc_config[tc].path[0].prio_type !=
	192	adapter->dcb_cfg.tc_config[tc].path[0].prio_type) \|\|
	193	(adapter->temp_dcb_cfg.tc_config[tc].path[0].bwg_id !=
	194	adapter->dcb_cfg.tc_config[tc].path[0].bwg_id) \|\|
	195	(adapter->temp_dcb_cfg.tc_config[tc].path[0].bwg_percent !=
	196	adapter->dcb_cfg.tc_config[tc].path[0].bwg_percent) \|\|
	197	(adapter->temp_dcb_cfg.tc_config[tc].path[0].up_to_tc_bitmap !=
	198	adapter->dcb_cfg.tc_config[tc].path[0].up_to_tc_bitmap))
	199	adapter->dcb_set_bitmap \|= BIT_PG_TX;
	200	}
	201
	202	static void ixgbe_dcbnl_set_pg_bwg_cfg_tx(struct net_device *netdev, int bwg_id,
	203	u8 bw_pct)
	204	{
	205	struct ixgbe_adapter *adapter = netdev_priv(netdev);
	206
	207	adapter->temp_dcb_cfg.bw_percentage[0][bwg_id] = bw_pct;
	208
	209	if (adapter->temp_dcb_cfg.bw_percentage[0][bwg_id] !=
	210	adapter->dcb_cfg.bw_percentage[0][bwg_id])
	211	adapter->dcb_set_bitmap \|= BIT_PG_RX;
	212	}
	213
	214	static void ixgbe_dcbnl_set_pg_tc_cfg_rx(struct net_device *netdev, int tc,
	215	u8 prio, u8 bwg_id, u8 bw_pct,
	216	u8 up_map)
	217	{
	218	struct ixgbe_adapter *adapter = netdev_priv(netdev);
	219
	220	if (prio != DCB_ATTR_VALUE_UNDEFINED)
	221	adapter->temp_dcb_cfg.tc_config[tc].path[1].prio_type = prio;
	222	if (bwg_id != DCB_ATTR_VALUE_UNDEFINED)
	223	adapter->temp_dcb_cfg.tc_config[tc].path[1].bwg_id = bwg_id;
	224	if (bw_pct != DCB_ATTR_VALUE_UNDEFINED)
	225	adapter->temp_dcb_cfg.tc_config[tc].path[1].bwg_percent =
	226	bw_pct;
	227	if (up_map != DCB_ATTR_VALUE_UNDEFINED)
	228	adapter->temp_dcb_cfg.tc_config[tc].path[1].up_to_tc_bitmap =
	229	up_map;
	230
	231	if ((adapter->temp_dcb_cfg.tc_config[tc].path[1].prio_type !=
	232	adapter->dcb_cfg.tc_config[tc].path[1].prio_type) \|\|
	233	(adapter->temp_dcb_cfg.tc_config[tc].path[1].bwg_id !=
	234	adapter->dcb_cfg.tc_config[tc].path[1].bwg_id) \|\|
	235	(adapter->temp_dcb_cfg.tc_config[tc].path[1].bwg_percent !=
236	adapter->dcb_cfg.tc_config[tc].path[1].bwg_percent) \|\|
237	(adapter->temp_dcb_cfg.tc_config[tc].path[1].up_to_tc_bitmap !=
238	adapter->dcb_cfg.tc_config[tc].path[1].up_to_tc_bitmap))
239	adapter->dcb_set_bitmap \|= BIT_PG_RX;
240	}
241
242	static void ixgbe_dcbnl_set_pg_bwg_cfg_rx(struct net_device *netdev, int bwg_id,
243	u8 bw_pct)
244	{
245	struct ixgbe_adapter *adapter = netdev_priv(netdev);
246
247	adapter->temp_dcb_cfg.bw_percentage[1][bwg_id] = bw_pct;
248
249	if (adapter->temp_dcb_cfg.bw_percentage[1][bwg_id] !=
250	adapter->dcb_cfg.bw_percentage[1][bwg_id])
251	adapter->dcb_set_bitmap \|= BIT_PG_RX;
252	}
253
254	static void ixgbe_dcbnl_get_pg_tc_cfg_tx(struct net_device *netdev, int tc,
255	u8 prio, u8 bwg_id, u8 *bw_pct,
256	u8 *up_map)
257	{
258	struct ixgbe_adapter *adapter = netdev_priv(netdev);
259
260	*prio = adapter->dcb_cfg.tc_config[tc].path[0].prio_type;
261	*bwg_id = adapter->dcb_cfg.tc_config[tc].path[0].bwg_id;
262	*bw_pct = adapter->dcb_cfg.tc_config[tc].path[0].bwg_percent;
263	*up_map = adapter->dcb_cfg.tc_config[tc].path[0].up_to_tc_bitmap;
264	}
265
266	static void ixgbe_dcbnl_get_pg_bwg_cfg_tx(struct net_device *netdev, int bwg_id,
267	u8 *bw_pct)
268	{
269	struct ixgbe_adapter *adapter = netdev_priv(netdev);
270
271	*bw_pct = adapter->dcb_cfg.bw_percentage[0][bwg_id];
272	}
273
274	static void ixgbe_dcbnl_get_pg_tc_cfg_rx(struct net_device *netdev, int tc,
275	u8 prio, u8 bwg_id, u8 *bw_pct,
276	u8 *up_map)
277	{
278	struct ixgbe_adapter *adapter = netdev_priv(netdev);
279
280	*prio = adapter->dcb_cfg.tc_config[tc].path[1].prio_type;
281	*bwg_id = adapter->dcb_cfg.tc_config[tc].path[1].bwg_id;
282	*bw_pct = adapter->dcb_cfg.tc_config[tc].path[1].bwg_percent;
283	*up_map = adapter->dcb_cfg.tc_config[tc].path[1].up_to_tc_bitmap;
284	}
285
286	static void ixgbe_dcbnl_get_pg_bwg_cfg_rx(struct net_device *netdev, int bwg_id,
287	u8 *bw_pct)
288	{
289	struct ixgbe_adapter *adapter = netdev_priv(netdev);
290
291	*bw_pct = adapter->dcb_cfg.bw_percentage[1][bwg_id];
292	}
293
294	static void ixgbe_dcbnl_set_pfc_cfg(struct net_device *netdev, int priority,
295	u8 setting)
296	{
297	struct ixgbe_adapter *adapter = netdev_priv(netdev);
298
299	adapter->temp_dcb_cfg.tc_config[priority].dcb_pfc = setting;
300	if (adapter->temp_dcb_cfg.tc_config[priority].dcb_pfc !=
ea4af4f4	301	adapter->dcb_cfg.tc_config[priority].dcb_pfc) {
2f90b865	302	adapter->dcb_set_bitmap \|= BIT_PFC;
ea4af4f4 PW	303	adapter->temp_dcb_cfg.pfc_mode_enable = true;
ea4af4f4 PW	304	}
2f90b865 AD	305	}
	306
	307	static void ixgbe_dcbnl_get_pfc_cfg(struct net_device *netdev, int priority,
	308	u8 *setting)
	309	{
	310	struct ixgbe_adapter *adapter = netdev_priv(netdev);
	311
	312	*setting = adapter->dcb_cfg.tc_config[priority].dcb_pfc;
	313	}
	314
	315	static u8 ixgbe_dcbnl_set_all(struct net_device *netdev)
	316	{
	317	struct ixgbe_adapter *adapter = netdev_priv(netdev);
	318	int ret;
	319
859ee3c4	320	adapter->dcb_set_bitmap &= ~BIT_BCN; /* no set for BCN */
2f90b865 AD	321	if (!adapter->dcb_set_bitmap)
	322	return 1;
	323
	324	while (test_and_set_bit(__IXGBE_RESETTING, &adapter->state))
	325	msleep(1);
	326
	327	if (netif_running(netdev))
	328	ixgbe_down(adapter);
	329
	330	ret = ixgbe_copy_dcb_cfg(&adapter->temp_dcb_cfg, &adapter->dcb_cfg,
	331	adapter->ring_feature[RING_F_DCB].indices);
	332	if (ret) {
	333	clear_bit(__IXGBE_RESETTING, &adapter->state);
	334	return ret;
	335	}
	336
264857b8 PWJ	337	if (adapter->dcb_cfg.pfc_mode_enable) {
	338	if ((adapter->hw.mac.type != ixgbe_mac_82598EB) &&
	339	(adapter->hw.fc.current_mode != ixgbe_fc_pfc))
	340	adapter->last_lfc_mode = adapter->hw.fc.current_mode;
	341	adapter->hw.fc.requested_mode = ixgbe_fc_pfc;
	342	} else {
	343	if (adapter->hw.mac.type != ixgbe_mac_82598EB)
	344	adapter->hw.fc.requested_mode = adapter->last_lfc_mode;
	345	else
	346	adapter->hw.fc.requested_mode = ixgbe_fc_none;
	347	}
	348
2f90b865 AD	349	if (netif_running(netdev))
	350	ixgbe_up(adapter);
	351
264857b8 PWJ	352	if (adapter->dcb_cfg.pfc_mode_enable)
	353	adapter->hw.fc.current_mode = ixgbe_fc_pfc;
	354
2f90b865 AD	355	adapter->dcb_set_bitmap = 0x00;
	356	clear_bit(__IXGBE_RESETTING, &adapter->state);
	357	return ret;
	358	}
	359
46132188 AD	360	static u8 ixgbe_dcbnl_getcap(struct net_device netdev, int capid, u8 cap)
	361	{
	362	struct ixgbe_adapter *adapter = netdev_priv(netdev);
	363	u8 rval = 0;
	364
	365	if (adapter->flags & IXGBE_FLAG_DCB_ENABLED) {
	366	switch (capid) {
	367	case DCB_CAP_ATTR_PG:
	368	*cap = true;
	369	break;
	370	case DCB_CAP_ATTR_PFC:
	371	*cap = true;
	372	break;
	373	case DCB_CAP_ATTR_UP2TC:
	374	*cap = false;
	375	break;
	376	case DCB_CAP_ATTR_PG_TCS:
	377	*cap = 0x80;
	378	break;
	379	case DCB_CAP_ATTR_PFC_TCS:
	380	*cap = 0x80;
	381	break;
	382	case DCB_CAP_ATTR_GSP:
	383	*cap = true;
	384	break;
	385	case DCB_CAP_ATTR_BCN:
	386	*cap = false;
	387	break;
	388	default:
	389	rval = -EINVAL;
	390	break;
	391	}
	392	} else {
	393	rval = -EINVAL;
	394	}
	395
	396	return rval;
	397	}
	398
33dbabc4 AD	399	static u8 ixgbe_dcbnl_getnumtcs(struct net_device netdev, int tcid, u8 num)
	400	{
	401	struct ixgbe_adapter *adapter = netdev_priv(netdev);
	402	u8 rval = 0;
	403
	404	if (adapter->flags & IXGBE_FLAG_DCB_ENABLED) {
	405	switch (tcid) {
	406	case DCB_NUMTCS_ATTR_PG:
	407	*num = MAX_TRAFFIC_CLASS;
	408	break;
	409	case DCB_NUMTCS_ATTR_PFC:
	410	*num = MAX_TRAFFIC_CLASS;
	411	break;
	412	default:
	413	rval = -EINVAL;
	414	break;
	415	}
	416	} else {
	417	rval = -EINVAL;
	418	}
	419
	420	return rval;
	421	}
	422
	423	static u8 ixgbe_dcbnl_setnumtcs(struct net_device *netdev, int tcid, u8 num)
	424	{
	425	return -EINVAL;
	426	}
	427
0eb3aa9b AD	428	static u8 ixgbe_dcbnl_getpfcstate(struct net_device *netdev)
	429	{
	430	struct ixgbe_adapter *adapter = netdev_priv(netdev);
	431
264857b8	432	return adapter->dcb_cfg.pfc_mode_enable;
0eb3aa9b AD	433	}
	434
	435	static void ixgbe_dcbnl_setpfcstate(struct net_device *netdev, u8 state)
	436	{
264857b8 PWJ	437	struct ixgbe_adapter *adapter = netdev_priv(netdev);
	438
	439	adapter->temp_dcb_cfg.pfc_mode_enable = state;
	440	if (adapter->temp_dcb_cfg.pfc_mode_enable !=
	441	adapter->dcb_cfg.pfc_mode_enable)
	442	adapter->dcb_set_bitmap \|= BIT_PFC;
0eb3aa9b AD	443	return;
	444	}
	445
2f90b865 AD	446	struct dcbnl_rtnl_ops dcbnl_ops = {
	447	.getstate = ixgbe_dcbnl_get_state,
	448	.setstate = ixgbe_dcbnl_set_state,
	449	.getpermhwaddr = ixgbe_dcbnl_get_perm_hw_addr,
	450	.setpgtccfgtx = ixgbe_dcbnl_set_pg_tc_cfg_tx,
	451	.setpgbwgcfgtx = ixgbe_dcbnl_set_pg_bwg_cfg_tx,
	452	.setpgtccfgrx = ixgbe_dcbnl_set_pg_tc_cfg_rx,
	453	.setpgbwgcfgrx = ixgbe_dcbnl_set_pg_bwg_cfg_rx,
	454	.getpgtccfgtx = ixgbe_dcbnl_get_pg_tc_cfg_tx,
	455	.getpgbwgcfgtx = ixgbe_dcbnl_get_pg_bwg_cfg_tx,
	456	.getpgtccfgrx = ixgbe_dcbnl_get_pg_tc_cfg_rx,
	457	.getpgbwgcfgrx = ixgbe_dcbnl_get_pg_bwg_cfg_rx,
	458	.setpfccfg = ixgbe_dcbnl_set_pfc_cfg,
	459	.getpfccfg = ixgbe_dcbnl_get_pfc_cfg,
46132188	460	.setall = ixgbe_dcbnl_set_all,
33dbabc4 AD	461	.getcap = ixgbe_dcbnl_getcap,
33dbabc4 AD	462	.getnumtcs = ixgbe_dcbnl_getnumtcs,
0eb3aa9b AD	463	.setnumtcs = ixgbe_dcbnl_setnumtcs,
0eb3aa9b AD	464	.getpfcstate = ixgbe_dcbnl_getpfcstate,
859ee3c4	465	.setpfcstate = ixgbe_dcbnl_setpfcstate,
2f90b865 AD	466	};
2f90b865 AD	467