ixgbe: this patch adds support for DCB to the kernel and ixgbe driver (2f90b865) · Commits · 戴 / test

drivers/net/Kconfig

+10 −0

Original line number	Diff line number	Diff line
		@@ -2451,6 +2451,16 @@ config IXGBE_DCA
		driver. DCA is a method for warming the CPU cache before data
		is used, with the intent of lessening the impact of cache misses.

		config IXGBE_DCBNL
		bool "Data Center Bridging (DCB) Support"
		default n
		depends on IXGBE && DCBNL
		---help---
		Say Y here if you want to use Data Center Bridging (DCB) in the
		driver.

		If unsure, say N.

		config IXGB
		tristate "Intel(R) PRO/10GbE support"
		depends on PCI

drivers/net/ixgbe/Makefile

+2 −0

Original line number	Diff line number	Diff line
		@@ -34,3 +34,5 @@ obj-$(CONFIG_IXGBE) += ixgbe.o

		ixgbe-objs := ixgbe_main.o ixgbe_common.o ixgbe_ethtool.o \
		ixgbe_82598.o ixgbe_phy.o

		ixgbe-$(CONFIG_IXGBE_DCBNL) += ixgbe_dcb.o ixgbe_dcb_82598.o ixgbe_dcb_nl.o

drivers/net/ixgbe/ixgbe.h

+23 −2

Original line number	Diff line number	Diff line
		@@ -35,7 +35,7 @@

		#include "ixgbe_type.h"
		#include "ixgbe_common.h"

		#include "ixgbe_dcb.h"
		#ifdef CONFIG_IXGBE_DCA
		#include <linux/dca.h>
		#endif
		@@ -84,6 +84,7 @@
		#define IXGBE_TX_FLAGS_TSO (u32)(1 << 2)
		#define IXGBE_TX_FLAGS_IPV4 (u32)(1 << 3)
		#define IXGBE_TX_FLAGS_VLAN_MASK 0xffff0000
		#define IXGBE_TX_FLAGS_VLAN_PRIO_MASK 0x0000e000
		#define IXGBE_TX_FLAGS_VLAN_SHIFT 16

		#define IXGBE_MAX_LRO_DESCRIPTORS 8
		@@ -134,7 +135,7 @@ struct ixgbe_ring {

		u16 reg_idx; /* holds the special value that gets the hardware register
		* offset associated with this ring, which is different
		* for DCE and RSS modes */
		* for DCB and RSS modes */

		#ifdef CONFIG_IXGBE_DCA
		/* cpu for tx queue */
		@@ -152,8 +153,10 @@ struct ixgbe_ring {
		u16 rx_buf_len;
		};

		#define RING_F_DCB 0
		#define RING_F_VMDQ 1
		#define RING_F_RSS 2
		#define IXGBE_MAX_DCB_INDICES 8
		#define IXGBE_MAX_RSS_INDICES 16
		#define IXGBE_MAX_VMDQ_INDICES 16
		struct ixgbe_ring_feature {
		@@ -164,6 +167,10 @@ struct ixgbe_ring_feature {
		#define MAX_RX_QUEUES 64
		#define MAX_TX_QUEUES 32

		#define MAX_RX_PACKET_BUFFERS ((adapter->flags & IXGBE_FLAG_DCB_ENABLED) \
		? 8 : 1)
		#define MAX_TX_PACKET_BUFFERS MAX_RX_PACKET_BUFFERS

		/* MAX_MSIX_Q_VECTORS of these are allocated,
		* but we only use one per queue-specific vector.
		*/
		@@ -215,6 +222,9 @@ struct ixgbe_adapter {
		struct work_struct reset_task;
		struct ixgbe_q_vector q_vector[MAX_MSIX_Q_VECTORS];
		char name[MAX_MSIX_COUNT][IFNAMSIZ + 5];
		struct ixgbe_dcb_config dcb_cfg;
		struct ixgbe_dcb_config temp_dcb_cfg;
		u8 dcb_set_bitmap;

		/* Interrupt Throttle Rate */
		u32 itr_setting;
		@@ -270,6 +280,7 @@ struct ixgbe_adapter {
		#define IXGBE_FLAG_FAN_FAIL_CAPABLE (u32)(1 << 20)
		#define IXGBE_FLAG_NEED_LINK_UPDATE (u32)(1 << 22)
		#define IXGBE_FLAG_IN_WATCHDOG_TASK (u32)(1 << 23)
		#define IXGBE_FLAG_DCB_ENABLED (u32)(1 << 24)

		/* default to trying for four seconds */
		#define IXGBE_TRY_LINK_TIMEOUT (4 * HZ)
		@@ -313,6 +324,12 @@ enum ixgbe_boards {
		};

		extern struct ixgbe_info ixgbe_82598_info;
		#ifdef CONFIG_IXGBE_DCBNL
		extern struct dcbnl_rtnl_ops dcbnl_ops;
		extern int ixgbe_copy_dcb_cfg(struct ixgbe_dcb_config *src_dcb_cfg,
		struct ixgbe_dcb_config *dst_dcb_cfg,
		int tc_max);
		#endif

		extern char ixgbe_driver_name[];
		extern const char ixgbe_driver_version[];
		@@ -327,5 +344,9 @@ extern int ixgbe_setup_tx_resources(struct ixgbe_adapter , struct ixgbe_ring )
		extern void ixgbe_free_rx_resources(struct ixgbe_adapter , struct ixgbe_ring );
		extern void ixgbe_free_tx_resources(struct ixgbe_adapter , struct ixgbe_ring );
		extern void ixgbe_update_stats(struct ixgbe_adapter *adapter);
		extern void ixgbe_reset_interrupt_capability(struct ixgbe_adapter *adapter);
		extern int ixgbe_init_interrupt_scheme(struct ixgbe_adapter *adapter);
		void ixgbe_napi_add_all(struct ixgbe_adapter *adapter);
		void ixgbe_napi_del_all(struct ixgbe_adapter *adapter);

		#endif /* _IXGBE_H_ */

drivers/net/ixgbe/ixgbe_dcb.c

0 → 100644

+332 −0

Original line number	Diff line number	Diff line
		/*******************************************************************************

		Intel 10 Gigabit PCI Express Linux driver
		Copyright(c) 1999 - 2007 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 "ixgbe_type.h"
		#include "ixgbe_dcb.h"
		#include "ixgbe_dcb_82598.h"

		/**
		* ixgbe_dcb_config - Struct containing DCB settings.
		* @dcb_config: Pointer to DCB config structure
		*
		* This function checks DCB rules for DCB settings.
		* The following rules are checked:
		* 1. The sum of bandwidth percentages of all Bandwidth Groups must total 100%.
		* 2. The sum of bandwidth percentages of all Traffic Classes within a Bandwidth
		* Group must total 100.
		* 3. A Traffic Class should not be set to both Link Strict Priority
		* and Group Strict Priority.
		* 4. Link strict Bandwidth Groups can only have link strict traffic classes
		* with zero bandwidth.
		*/
		s32 ixgbe_dcb_check_config(struct ixgbe_dcb_config *dcb_config)
		{
		struct tc_bw_alloc *p;
		s32 ret_val = 0;
		u8 i, j, bw = 0, bw_id;
		u8 bw_sum[2][MAX_BW_GROUP];
		bool link_strict[2][MAX_BW_GROUP];

		memset(bw_sum, 0, sizeof(bw_sum));
		memset(link_strict, 0, sizeof(link_strict));

		/* First Tx, then Rx */
		for (i = 0; i < 2; i++) {
		/* Check each traffic class for rule violation */
		for (j = 0; j < MAX_TRAFFIC_CLASS; j++) {
		p = &dcb_config->tc_config[j].path[i];

		bw = p->bwg_percent;
		bw_id = p->bwg_id;

		if (bw_id >= MAX_BW_GROUP) {
		ret_val = DCB_ERR_CONFIG;
		goto err_config;
		}
		if (p->prio_type == prio_link) {
		link_strict[i][bw_id] = true;
		/* Link strict should have zero bandwidth */
		if (bw) {
		ret_val = DCB_ERR_LS_BW_NONZERO;
		goto err_config;
		}
		} else if (!bw) {
		/*
		* Traffic classes without link strict
		* should have non-zero bandwidth.
		*/
		ret_val = DCB_ERR_TC_BW_ZERO;
		goto err_config;
		}
		bw_sum[i][bw_id] += bw;
		}

		bw = 0;

		/* Check each bandwidth group for rule violation */
		for (j = 0; j < MAX_BW_GROUP; j++) {
		bw += dcb_config->bw_percentage[i][j];
		/*
		* Sum of bandwidth percentages of all traffic classes
		* within a Bandwidth Group must total 100 except for
		* link strict group (zero bandwidth).
		*/
		if (link_strict[i][j]) {
		if (bw_sum[i][j]) {
		/*
		* Link strict group should have zero
		* bandwidth.
		*/
		ret_val = DCB_ERR_LS_BWG_NONZERO;
		goto err_config;
		}
		} else if (bw_sum[i][j] != BW_PERCENT &&
		bw_sum[i][j] != 0) {
		ret_val = DCB_ERR_TC_BW;
		goto err_config;
		}
		}

		if (bw != BW_PERCENT) {
		ret_val = DCB_ERR_BW_GROUP;
		goto err_config;
		}
		}

		err_config:
		return ret_val;
		}

		/**
		* ixgbe_dcb_calculate_tc_credits - Calculates traffic class credits
		* @ixgbe_dcb_config: Struct containing DCB settings.
		* @direction: Configuring either Tx or Rx.
		*
		* This function calculates the credits allocated to each traffic class.
		* It should be called only after the rules are checked by
		* ixgbe_dcb_check_config().
		*/
		s32 ixgbe_dcb_calculate_tc_credits(struct ixgbe_dcb_config *dcb_config,
		u8 direction)
		{
		struct tc_bw_alloc *p;
		s32 ret_val = 0;
		/* Initialization values default for Tx settings */
		u32 credit_refill = 0;
		u32 credit_max = 0;
		u16 link_percentage = 0;
		u8 bw_percent = 0;
		u8 i;

		if (dcb_config == NULL) {
		ret_val = DCB_ERR_CONFIG;
		goto out;
		}

		/* Find out the link percentage for each TC first */
		for (i = 0; i < MAX_TRAFFIC_CLASS; i++) {
		p = &dcb_config->tc_config[i].path[direction];
		bw_percent = dcb_config->bw_percentage[direction][p->bwg_id];

		link_percentage = p->bwg_percent;
		/* Must be careful of integer division for very small nums */
		link_percentage = (link_percentage * bw_percent) / 100;
		if (p->bwg_percent > 0 && link_percentage == 0)
		link_percentage = 1;

		/* Save link_percentage for reference */
		p->link_percent = (u8)link_percentage;

		/* Calculate credit refill and save it */
		credit_refill = link_percentage * MINIMUM_CREDIT_REFILL;
		p->data_credits_refill = (u16)credit_refill;

		/* Calculate maximum credit for the TC */
		credit_max = (link_percentage * MAX_CREDIT) / 100;

		/*
		* Adjustment based on rule checking, if the percentage
		* of a TC is too small, the maximum credit may not be
		* enough to send out a jumbo frame in data plane arbitration.
		*/
		if (credit_max && (credit_max < MINIMUM_CREDIT_FOR_JUMBO))
		credit_max = MINIMUM_CREDIT_FOR_JUMBO;

		if (direction == DCB_TX_CONFIG) {
		/*
		* Adjustment based on rule checking, if the
		* percentage of a TC is too small, the maximum
		* credit may not be enough to send out a TSO
		* packet in descriptor plane arbitration.
		*/
		if (credit_max &&
		(credit_max < MINIMUM_CREDIT_FOR_TSO))
		credit_max = MINIMUM_CREDIT_FOR_TSO;

		dcb_config->tc_config[i].desc_credits_max =
		(u16)credit_max;
		}

		p->data_credits_max = (u16)credit_max;
		}

		out:
		return ret_val;
		}

		/**
		* ixgbe_dcb_get_tc_stats - Returns status of each traffic class
		* @hw: pointer to hardware structure
		* @stats: pointer to statistics structure
		* @tc_count: Number of elements in bwg_array.
		*
		* This function returns the status data for each of the Traffic Classes in use.
		*/
		s32 ixgbe_dcb_get_tc_stats(struct ixgbe_hw hw, struct ixgbe_hw_stats stats,
		u8 tc_count)
		{
		s32 ret = 0;
		if (hw->mac.type == ixgbe_mac_82598EB)
		ret = ixgbe_dcb_get_tc_stats_82598(hw, stats, tc_count);
		return ret;
		}

		/**
		* ixgbe_dcb_get_pfc_stats - Returns CBFC status of each traffic class
		* hw - pointer to hardware structure
		* stats - pointer to statistics structure
		* tc_count - Number of elements in bwg_array.
		*
		* This function returns the CBFC status data for each of the Traffic Classes.
		*/
		s32 ixgbe_dcb_get_pfc_stats(struct ixgbe_hw hw, struct ixgbe_hw_stats stats,
		u8 tc_count)
		{
		s32 ret = 0;
		if (hw->mac.type == ixgbe_mac_82598EB)
		ret = ixgbe_dcb_get_pfc_stats_82598(hw, stats, tc_count);
		return ret;
		}

		/**
		* ixgbe_dcb_config_rx_arbiter - Config Rx arbiter
		* @hw: pointer to hardware structure
		* @dcb_config: pointer to ixgbe_dcb_config structure
		*
		* Configure Rx Data Arbiter and credits for each traffic class.
		*/
		s32 ixgbe_dcb_config_rx_arbiter(struct ixgbe_hw *hw,
		struct ixgbe_dcb_config *dcb_config)
		{
		s32 ret = 0;
		if (hw->mac.type == ixgbe_mac_82598EB)
		ret = ixgbe_dcb_config_rx_arbiter_82598(hw, dcb_config);
		return ret;
		}

		/**
		* ixgbe_dcb_config_tx_desc_arbiter - Config Tx Desc arbiter
		* @hw: pointer to hardware structure
		* @dcb_config: pointer to ixgbe_dcb_config structure
		*
		* Configure Tx Descriptor Arbiter and credits for each traffic class.
		*/
		s32 ixgbe_dcb_config_tx_desc_arbiter(struct ixgbe_hw *hw,
		struct ixgbe_dcb_config *dcb_config)
		{
		s32 ret = 0;
		if (hw->mac.type == ixgbe_mac_82598EB)
		ret = ixgbe_dcb_config_tx_desc_arbiter_82598(hw, dcb_config);
		return ret;
		}

		/**
		* ixgbe_dcb_config_tx_data_arbiter - Config Tx data arbiter
		* @hw: pointer to hardware structure
		* @dcb_config: pointer to ixgbe_dcb_config structure
		*
		* Configure Tx Data Arbiter and credits for each traffic class.
		*/
		s32 ixgbe_dcb_config_tx_data_arbiter(struct ixgbe_hw *hw,
		struct ixgbe_dcb_config *dcb_config)
		{
		s32 ret = 0;
		if (hw->mac.type == ixgbe_mac_82598EB)
		ret = ixgbe_dcb_config_tx_data_arbiter_82598(hw, dcb_config);
		return ret;
		}

		/**
		* ixgbe_dcb_config_pfc - Config priority flow control
		* @hw: pointer to hardware structure
		* @dcb_config: pointer to ixgbe_dcb_config structure
		*
		* Configure Priority Flow Control for each traffic class.
		*/
		s32 ixgbe_dcb_config_pfc(struct ixgbe_hw *hw,
		struct ixgbe_dcb_config *dcb_config)
		{
		s32 ret = 0;
		if (hw->mac.type == ixgbe_mac_82598EB)
		ret = ixgbe_dcb_config_pfc_82598(hw, dcb_config);
		return ret;
		}

		/**
		* ixgbe_dcb_config_tc_stats - Config traffic class statistics
		* @hw: pointer to hardware structure
		*
		* Configure queue statistics registers, all queues belonging to same traffic
		* class uses a single set of queue statistics counters.
		*/
		s32 ixgbe_dcb_config_tc_stats(struct ixgbe_hw *hw)
		{
		s32 ret = 0;
		if (hw->mac.type == ixgbe_mac_82598EB)
		ret = ixgbe_dcb_config_tc_stats_82598(hw);
		return ret;
		}

		/**
		* ixgbe_dcb_hw_config - Config and enable DCB
		* @hw: pointer to hardware structure
		* @dcb_config: pointer to ixgbe_dcb_config structure
		*
		* Configure dcb settings and enable dcb mode.
		*/
		s32 ixgbe_dcb_hw_config(struct ixgbe_hw *hw,
		struct ixgbe_dcb_config *dcb_config)
		{
		s32 ret = 0;
		if (hw->mac.type == ixgbe_mac_82598EB)
		ret = ixgbe_dcb_hw_config_82598(hw, dcb_config);
		return ret;
		}

drivers/net/ixgbe/ixgbe_dcb.h

0 → 100644

+157 −0

Original line number	Diff line number	Diff line
		/*******************************************************************************

		Intel 10 Gigabit PCI Express Linux driver
		Copyright(c) 1999 - 2007 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

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

		#ifndef _DCB_CONFIG_H_
		#define _DCB_CONFIG_H_

		#include "ixgbe_type.h"

		/* DCB data structures */

		#define IXGBE_MAX_PACKET_BUFFERS 8
		#define MAX_USER_PRIORITY 8
		#define MAX_TRAFFIC_CLASS 8
		#define MAX_BW_GROUP 8
		#define BW_PERCENT 100

		#define DCB_TX_CONFIG 0
		#define DCB_RX_CONFIG 1

		/* DCB error Codes */
		#define DCB_SUCCESS 0
		#define DCB_ERR_CONFIG -1
		#define DCB_ERR_PARAM -2

		/* Transmit and receive Errors */
		/* Error in bandwidth group allocation */
		#define DCB_ERR_BW_GROUP -3
		/* Error in traffic class bandwidth allocation */
		#define DCB_ERR_TC_BW -4
		/* Traffic class has both link strict and group strict enabled */
		#define DCB_ERR_LS_GS -5
		/* Link strict traffic class has non zero bandwidth */
		#define DCB_ERR_LS_BW_NONZERO -6
		/* Link strict bandwidth group has non zero bandwidth */
		#define DCB_ERR_LS_BWG_NONZERO -7
		/* Traffic class has zero bandwidth */
		#define DCB_ERR_TC_BW_ZERO -8

		#define DCB_NOT_IMPLEMENTED 0x7FFFFFFF

		struct dcb_pfc_tc_debug {
		u8 tc;
		u8 pause_status;
		u64 pause_quanta;
		};

		enum strict_prio_type {
		prio_none = 0,
		prio_group,
		prio_link
		};

		/* Traffic class bandwidth allocation per direction */
		struct tc_bw_alloc {
		u8 bwg_id; /* Bandwidth Group (BWG) ID */
		u8 bwg_percent; /* % of BWG's bandwidth */
		u8 link_percent; /* % of link bandwidth */
		u8 up_to_tc_bitmap; /* User Priority to Traffic Class mapping */
		u16 data_credits_refill; /* Credit refill amount in 64B granularity */
		u16 data_credits_max; /* Max credits for a configured packet buffer
		* in 64B granularity.*/
		enum strict_prio_type prio_type; /* Link or Group Strict Priority */
		};

		enum dcb_pfc_type {
		pfc_disabled = 0,
		pfc_enabled_full,
		pfc_enabled_tx,
		pfc_enabled_rx
		};

		/* Traffic class configuration */
		struct tc_configuration {
		struct tc_bw_alloc path[2]; /* One each for Tx/Rx */
		enum dcb_pfc_type dcb_pfc; /* Class based flow control setting */

		u16 desc_credits_max; /* For Tx Descriptor arbitration */
		u8 tc; /* Traffic class (TC) */
		};

		enum dcb_rx_pba_cfg {
		pba_equal, /* PBA[0-7] each use 64KB FIFO */
		pba_80_48 /* PBA[0-3] each use 80KB, PBA[4-7] each use 48KB */
		};

		struct ixgbe_dcb_config {
		struct tc_configuration tc_config[MAX_TRAFFIC_CLASS];
		u8 bw_percentage[2][MAX_BW_GROUP]; /* One each for Tx/Rx */

		bool round_robin_enable;

		enum dcb_rx_pba_cfg rx_pba_cfg;

		u32 dcb_cfg_version; /* Not used...OS-specific? */
		u32 link_speed; /* For bandwidth allocation validation purpose */
		};

		/* DCB driver APIs */

		/* DCB rule checking function.*/
		s32 ixgbe_dcb_check_config(struct ixgbe_dcb_config *config);

		/* DCB credits calculation */
		s32 ixgbe_dcb_calculate_tc_credits(struct ixgbe_dcb_config *, u8);

		/* DCB PFC functions */
		s32 ixgbe_dcb_config_pfc(struct ixgbe_hw , struct ixgbe_dcb_config g);
		s32 ixgbe_dcb_get_pfc_stats(struct ixgbe_hw , struct ixgbe_hw_stats , u8);

		/* DCB traffic class stats */
		s32 ixgbe_dcb_config_tc_stats(struct ixgbe_hw *);
		s32 ixgbe_dcb_get_tc_stats(struct ixgbe_hw , struct ixgbe_hw_stats , u8);

		/* DCB config arbiters */
		s32 ixgbe_dcb_config_tx_desc_arbiter(struct ixgbe_hw *,
		struct ixgbe_dcb_config *);
		s32 ixgbe_dcb_config_tx_data_arbiter(struct ixgbe_hw *,
		struct ixgbe_dcb_config *);
		s32 ixgbe_dcb_config_rx_arbiter(struct ixgbe_hw , struct ixgbe_dcb_config );

		/* DCB hw initialization */
		s32 ixgbe_dcb_hw_config(struct ixgbe_hw , struct ixgbe_dcb_config );

		/* DCB definitions for credit calculation */
		#define MAX_CREDIT_REFILL 511 /* 0x1FF * 64B = 32704B */
		#define MINIMUM_CREDIT_REFILL 5 /* 564B = 320B /
		#define MINIMUM_CREDIT_FOR_JUMBO 145 /* 145= UpperBound((91024+54)/64B) for 9KB jumbo frame /
		#define DCB_MAX_TSO_SIZE (321024) / MAX TSO packet size supported in DCB mode */
		#define MINIMUM_CREDIT_FOR_TSO (DCB_MAX_TSO_SIZE/64 + 1) /* 513 for 32KB TSO packet */
		#define MAX_CREDIT 4095 /* Maximum credit supported: 256KB * 1204 / 64B */

		#endif /* _DCB_CONFIG_H */

Admin message