Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 3aa10dad authored by David S. Miller's avatar David S. Miller
Browse files

Merge branch 'mlx4-next' 



Or Gerlitz says:

====================
mlx4: Extend statistics gathering and display

This series from Eran and Matan extends the statistics collected and later
reported to the user via ethtool for native mode and SRIOV PF.

More Packet statistics, PFC statistics and global pause statistics
are now displayed via ethtool.
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents c9975337 a3333b35

drivers/net/ethernet/mellanox/mlx4/en_dcb_nl.c

+4 −0
Original line number Diff line number Diff line
@@ -226,6 +226,10 @@ static int mlx4_en_dcbnl_ieee_setpfc(struct net_device *dev, 
				    prof->rx_ppp);

	if (err)

		en_err(priv, "Failed setting pause params\n");

	else

		mlx4_en_update_pfc_stats_bitmap(mdev->dev, &priv->stats_bitmap,

						prof->rx_ppp, prof->rx_pause,

						prof->tx_ppp, prof->tx_pause);



	return err;

}

drivers/net/ethernet/mellanox/mlx4/en_ethtool.c

+173 −52
Original line number Diff line number Diff line
@@ -38,6 +38,7 @@ 
#include <linux/mlx4/device.h>

#include <linux/in.h>

#include <net/ip.h>

#include <linux/bitmap.h>



#include "mlx4_en.h"

#include "en_port.h"
@@ -104,6 +105,7 @@ static const char mlx4_en_priv_flags[][ETH_GSTRING_LEN] = { 
};



static const char main_strings[][ETH_GSTRING_LEN] = {

	/* main statistics */

	"rx_packets", "tx_packets", "rx_bytes", "tx_bytes", "rx_errors",

	"tx_errors", "rx_dropped", "tx_dropped", "multicast", "collisions",

	"rx_length_errors", "rx_over_errors", "rx_crc_errors",
@@ -117,14 +119,76 @@ static const char main_strings[][ETH_GSTRING_LEN] = { 
	"queue_stopped", "wake_queue", "tx_timeout", "rx_alloc_failed",

	"rx_csum_good", "rx_csum_none", "rx_csum_complete", "tx_chksum_offload",



	/* priority flow control statistics rx */

	"rx_pause_prio_0", "rx_pause_duration_prio_0",

	"rx_pause_transition_prio_0",

	"rx_pause_prio_1", "rx_pause_duration_prio_1",

	"rx_pause_transition_prio_1",

	"rx_pause_prio_2", "rx_pause_duration_prio_2",

	"rx_pause_transition_prio_2",

	"rx_pause_prio_3", "rx_pause_duration_prio_3",

	"rx_pause_transition_prio_3",

	"rx_pause_prio_4", "rx_pause_duration_prio_4",

	"rx_pause_transition_prio_4",

	"rx_pause_prio_5", "rx_pause_duration_prio_5",

	"rx_pause_transition_prio_5",

	"rx_pause_prio_6", "rx_pause_duration_prio_6",

	"rx_pause_transition_prio_6",

	"rx_pause_prio_7", "rx_pause_duration_prio_7",

	"rx_pause_transition_prio_7",



	/* flow control statistics rx */

	"rx_pause", "rx_pause_duration", "rx_pause_transition",



	/* priority flow control statistics tx */

	"tx_pause_prio_0", "tx_pause_duration_prio_0",

	"tx_pause_transition_prio_0",

	"tx_pause_prio_1", "tx_pause_duration_prio_1",

	"tx_pause_transition_prio_1",

	"tx_pause_prio_2", "tx_pause_duration_prio_2",

	"tx_pause_transition_prio_2",

	"tx_pause_prio_3", "tx_pause_duration_prio_3",

	"tx_pause_transition_prio_3",

	"tx_pause_prio_4", "tx_pause_duration_prio_4",

	"tx_pause_transition_prio_4",

	"tx_pause_prio_5", "tx_pause_duration_prio_5",

	"tx_pause_transition_prio_5",

	"tx_pause_prio_6", "tx_pause_duration_prio_6",

	"tx_pause_transition_prio_6",

	"tx_pause_prio_7", "tx_pause_duration_prio_7",

	"tx_pause_transition_prio_7",



	/* flow control statistics tx */

	"tx_pause", "tx_pause_duration", "tx_pause_transition",



	/* packet statistics */

	"broadcast", "rx_prio_0", "rx_prio_1", "rx_prio_2", "rx_prio_3",

	"rx_prio_4", "rx_prio_5", "rx_prio_6", "rx_prio_7", "tx_prio_0",

	"tx_prio_1", "tx_prio_2", "tx_prio_3", "tx_prio_4", "tx_prio_5",

	"tx_prio_6", "tx_prio_7",

	"rx_multicast_packets",

	"rx_broadcast_packets",

	"rx_jabbers",

	"rx_in_range_length_error",

	"rx_out_range_length_error",

	"tx_multicast_packets",

	"tx_broadcast_packets",

	"rx_prio_0_packets", "rx_prio_0_bytes",

	"rx_prio_1_packets", "rx_prio_1_bytes",

	"rx_prio_2_packets", "rx_prio_2_bytes",

	"rx_prio_3_packets", "rx_prio_3_bytes",

	"rx_prio_4_packets", "rx_prio_4_bytes",

	"rx_prio_5_packets", "rx_prio_5_bytes",

	"rx_prio_6_packets", "rx_prio_6_bytes",

	"rx_prio_7_packets", "rx_prio_7_bytes",

	"rx_novlan_packets", "rx_novlan_bytes",

	"tx_prio_0_packets", "tx_prio_0_bytes",

	"tx_prio_1_packets", "tx_prio_1_bytes",

	"tx_prio_2_packets", "tx_prio_2_bytes",

	"tx_prio_3_packets", "tx_prio_3_bytes",

	"tx_prio_4_packets", "tx_prio_4_bytes",

	"tx_prio_5_packets", "tx_prio_5_bytes",

	"tx_prio_6_packets", "tx_prio_6_bytes",

	"tx_prio_7_packets", "tx_prio_7_bytes",

	"tx_novlan_packets", "tx_novlan_bytes",



};

#define NUM_MAIN_STATS	21

#define NUM_ALL_STATS	(NUM_MAIN_STATS + NUM_PORT_STATS + NUM_PKT_STATS + NUM_PERF_STATS)



static const char mlx4_en_test_names[][ETH_GSTRING_LEN]= {

	"Interrupt Test",
@@ -224,14 +288,50 @@ static int mlx4_en_set_wol(struct net_device *netdev, 
	return err;

}



struct bitmap_iterator {

	unsigned long *stats_bitmap;

	unsigned int count;

	unsigned int iterator;

	bool advance_array; /* if set, force no increments */

};



static inline void bitmap_iterator_init(struct bitmap_iterator *h,

					unsigned long *stats_bitmap,

					int count)

{

	h->iterator = 0;

	h->advance_array = !bitmap_empty(stats_bitmap, count);

	h->count = h->advance_array ? bitmap_weight(stats_bitmap, count)

		: count;

	h->stats_bitmap = stats_bitmap;

}



static inline int bitmap_iterator_test(struct bitmap_iterator *h)

{

	return !h->advance_array ? 1 : test_bit(h->iterator, h->stats_bitmap);

}



static inline int bitmap_iterator_inc(struct bitmap_iterator *h)

{

	return h->iterator++;

}



static inline unsigned int

bitmap_iterator_count(struct bitmap_iterator *h)

{

	return h->count;

}



static int mlx4_en_get_sset_count(struct net_device *dev, int sset)

{

	struct mlx4_en_priv *priv = netdev_priv(dev);

	int bit_count = hweight64(priv->stats_bitmap);

	struct bitmap_iterator it;



	bitmap_iterator_init(&it, priv->stats_bitmap.bitmap, NUM_ALL_STATS);



	switch (sset) {

	case ETH_SS_STATS:

		return (priv->stats_bitmap ? bit_count : NUM_ALL_STATS) +

		return bitmap_iterator_count(&it) +

			(priv->tx_ring_num * 2) +

#ifdef CONFIG_NET_RX_BUSY_POLL

			(priv->rx_ring_num * 5);
@@ -253,34 +353,45 @@ static void mlx4_en_get_ethtool_stats(struct net_device *dev, 
{

	struct mlx4_en_priv *priv = netdev_priv(dev);

	int index = 0;

	int i, j = 0;

	int i;

	struct bitmap_iterator it;



	bitmap_iterator_init(&it, priv->stats_bitmap.bitmap, NUM_ALL_STATS);



	spin_lock_bh(&priv->stats_lock);



	if (!(priv->stats_bitmap)) {

		for (i = 0; i < NUM_MAIN_STATS; i++)

			data[index++] =

				((unsigned long *) &priv->stats)[i];

		for (i = 0; i < NUM_PORT_STATS; i++)

			data[index++] =

				((unsigned long *) &priv->port_stats)[i];

		for (i = 0; i < NUM_PKT_STATS; i++)

			data[index++] =

				((unsigned long *) &priv->pkstats)[i];

	} else {

		for (i = 0; i < NUM_MAIN_STATS; i++) {

			if ((priv->stats_bitmap >> j) & 1)

	for (i = 0; i < NUM_MAIN_STATS; i++, bitmap_iterator_inc(&it))

		if (bitmap_iterator_test(&it))

			data[index++] = ((unsigned long *)&priv->stats)[i];



	for (i = 0; i < NUM_PORT_STATS; i++, bitmap_iterator_inc(&it))

		if (bitmap_iterator_test(&it))

			data[index++] = ((unsigned long *)&priv->port_stats)[i];



	for (i = 0; i < NUM_FLOW_PRIORITY_STATS_RX;

	     i++, bitmap_iterator_inc(&it))

		if (bitmap_iterator_test(&it))

			data[index++] =

				((unsigned long *) &priv->stats)[i];

			j++;

		}

		for (i = 0; i < NUM_PORT_STATS; i++) {

			if ((priv->stats_bitmap >> j) & 1)

				((u64 *)&priv->rx_priority_flowstats)[i];



	for (i = 0; i < NUM_FLOW_STATS_RX; i++, bitmap_iterator_inc(&it))

		if (bitmap_iterator_test(&it))

			data[index++] = ((u64 *)&priv->rx_flowstats)[i];



	for (i = 0; i < NUM_FLOW_PRIORITY_STATS_TX;

	     i++, bitmap_iterator_inc(&it))

		if (bitmap_iterator_test(&it))

			data[index++] =

				((unsigned long *) &priv->port_stats)[i];

			j++;

		}

	}

				((u64 *)&priv->tx_priority_flowstats)[i];



	for (i = 0; i < NUM_FLOW_STATS_TX; i++, bitmap_iterator_inc(&it))

		if (bitmap_iterator_test(&it))

			data[index++] = ((u64 *)&priv->tx_flowstats)[i];



	for (i = 0; i < NUM_PKT_STATS; i++, bitmap_iterator_inc(&it))

		if (bitmap_iterator_test(&it))

			data[index++] = ((unsigned long *)&priv->pkstats)[i];



	for (i = 0; i < priv->tx_ring_num; i++) {

		data[index++] = priv->tx_ring[i]->packets;

		data[index++] = priv->tx_ring[i]->bytes;
@@ -309,7 +420,10 @@ static void mlx4_en_get_strings(struct net_device *dev, 
{

	struct mlx4_en_priv *priv = netdev_priv(dev);

	int index = 0;

	int i;

	int i, strings = 0;

	struct bitmap_iterator it;



	bitmap_iterator_init(&it, priv->stats_bitmap.bitmap, NUM_ALL_STATS);



	switch (stringset) {

	case ETH_SS_TEST:
@@ -322,29 +436,30 @@ static void mlx4_en_get_strings(struct net_device *dev, 


	case ETH_SS_STATS:

		/* Add main counters */

		if (!priv->stats_bitmap) {

			for (i = 0; i < NUM_MAIN_STATS; i++)

		for (i = 0; i < NUM_MAIN_STATS; i++, strings++,

		     bitmap_iterator_inc(&it))

			if (bitmap_iterator_test(&it))

				strcpy(data + (index++) * ETH_GSTRING_LEN,

					main_strings[i]);

			for (i = 0; i < NUM_PORT_STATS; i++)

				       main_strings[strings]);



		for (i = 0; i < NUM_PORT_STATS; i++, strings++,

		     bitmap_iterator_inc(&it))

			if (bitmap_iterator_test(&it))

				strcpy(data + (index++) * ETH_GSTRING_LEN,

					main_strings[i +

					NUM_MAIN_STATS]);

			for (i = 0; i < NUM_PKT_STATS; i++)

				       main_strings[strings]);



		for (i = 0; i < NUM_FLOW_STATS; i++, strings++,

		     bitmap_iterator_inc(&it))

			if (bitmap_iterator_test(&it))

				strcpy(data + (index++) * ETH_GSTRING_LEN,

					main_strings[i +

					NUM_MAIN_STATS +

					NUM_PORT_STATS]);

		} else

			for (i = 0; i < NUM_MAIN_STATS + NUM_PORT_STATS; i++) {

				if ((priv->stats_bitmap >> i) & 1) {

					strcpy(data +

					       (index++) * ETH_GSTRING_LEN,

					       main_strings[i]);

				}

				if (!(priv->stats_bitmap >> i))

					break;

			}

				       main_strings[strings]);



		for (i = 0; i < NUM_PKT_STATS; i++, strings++,

		     bitmap_iterator_inc(&it))

			if (bitmap_iterator_test(&it))

				strcpy(data + (index++) * ETH_GSTRING_LEN,

				       main_strings[strings]);



		for (i = 0; i < priv->tx_ring_num; i++) {

			sprintf(data + (index++) * ETH_GSTRING_LEN,

				"tx%d_packets", i);
@@ -885,6 +1000,12 @@ static int mlx4_en_set_pauseparam(struct net_device *dev, 
				    priv->prof->rx_ppp);

	if (err)

		en_err(priv, "Failed setting pause params\n");

	else

		mlx4_en_update_pfc_stats_bitmap(mdev->dev, &priv->stats_bitmap,

						priv->prof->rx_ppp,

						priv->prof->rx_pause,

						priv->prof->tx_ppp,

						priv->prof->tx_pause);



	return err;

}

drivers/net/ethernet/mellanox/mlx4/en_netdev.c

+87 −1
Original line number Diff line number Diff line
@@ -1888,6 +1888,12 @@ static void mlx4_en_clear_stats(struct net_device *dev) 
	memset(&priv->pstats, 0, sizeof(priv->pstats));

	memset(&priv->pkstats, 0, sizeof(priv->pkstats));

	memset(&priv->port_stats, 0, sizeof(priv->port_stats));

	memset(&priv->rx_flowstats, 0, sizeof(priv->rx_flowstats));

	memset(&priv->tx_flowstats, 0, sizeof(priv->tx_flowstats));

	memset(&priv->rx_priority_flowstats, 0,

	       sizeof(priv->rx_priority_flowstats));

	memset(&priv->tx_priority_flowstats, 0,

	       sizeof(priv->tx_priority_flowstats));



	for (i = 0; i < priv->tx_ring_num; i++) {

		priv->tx_ring[i]->bytes = 0;
@@ -2648,6 +2654,82 @@ int mlx4_en_netdev_event(struct notifier_block *this, 
	return NOTIFY_DONE;

}



void mlx4_en_update_pfc_stats_bitmap(struct mlx4_dev *dev,

				     struct mlx4_en_stats_bitmap *stats_bitmap,

				     u8 rx_ppp, u8 rx_pause,

				     u8 tx_ppp, u8 tx_pause)

{

	int last_i = NUM_MAIN_STATS + NUM_PORT_STATS;



	if (!mlx4_is_slave(dev) &&

	    (dev->caps.flags2 & MLX4_DEV_CAP_FLAG2_FLOWSTATS_EN)) {

		mutex_lock(&stats_bitmap->mutex);

		bitmap_clear(stats_bitmap->bitmap, last_i, NUM_FLOW_STATS);



		if (rx_ppp)

			bitmap_set(stats_bitmap->bitmap, last_i,

				   NUM_FLOW_PRIORITY_STATS_RX);

		last_i += NUM_FLOW_PRIORITY_STATS_RX;



		if (rx_pause && !(rx_ppp))

			bitmap_set(stats_bitmap->bitmap, last_i,

				   NUM_FLOW_STATS_RX);

		last_i += NUM_FLOW_STATS_RX;



		if (tx_ppp)

			bitmap_set(stats_bitmap->bitmap, last_i,

				   NUM_FLOW_PRIORITY_STATS_TX);

		last_i += NUM_FLOW_PRIORITY_STATS_TX;



		if (tx_pause && !(tx_ppp))

			bitmap_set(stats_bitmap->bitmap, last_i,

				   NUM_FLOW_STATS_TX);

		last_i += NUM_FLOW_STATS_TX;



		mutex_unlock(&stats_bitmap->mutex);

	}

}



void mlx4_en_set_stats_bitmap(struct mlx4_dev *dev,

			      struct mlx4_en_stats_bitmap *stats_bitmap,

			      u8 rx_ppp, u8 rx_pause,

			      u8 tx_ppp, u8 tx_pause)

{

	int last_i = 0;



	mutex_init(&stats_bitmap->mutex);

	bitmap_zero(stats_bitmap->bitmap, NUM_ALL_STATS);



	if (mlx4_is_slave(dev)) {

		bitmap_set(stats_bitmap->bitmap, last_i +

					 MLX4_FIND_NETDEV_STAT(rx_packets), 1);

		bitmap_set(stats_bitmap->bitmap, last_i +

					 MLX4_FIND_NETDEV_STAT(tx_packets), 1);

		bitmap_set(stats_bitmap->bitmap, last_i +

					 MLX4_FIND_NETDEV_STAT(rx_bytes), 1);

		bitmap_set(stats_bitmap->bitmap, last_i +

					 MLX4_FIND_NETDEV_STAT(tx_bytes), 1);

		bitmap_set(stats_bitmap->bitmap, last_i +

					 MLX4_FIND_NETDEV_STAT(rx_dropped), 1);

		bitmap_set(stats_bitmap->bitmap, last_i +

					 MLX4_FIND_NETDEV_STAT(tx_dropped), 1);

	} else {

		bitmap_set(stats_bitmap->bitmap, last_i, NUM_MAIN_STATS);

	}

	last_i += NUM_MAIN_STATS;



	bitmap_set(stats_bitmap->bitmap, last_i, NUM_PORT_STATS);

	last_i += NUM_PORT_STATS;



	mlx4_en_update_pfc_stats_bitmap(dev, stats_bitmap,

					rx_ppp, rx_pause,

					tx_ppp, tx_pause);

	last_i += NUM_FLOW_STATS;



	if (!mlx4_is_slave(dev))

		bitmap_set(stats_bitmap->bitmap, last_i, NUM_PKT_STATS);

}



int mlx4_en_init_netdev(struct mlx4_en_dev *mdev, int port,

			struct mlx4_en_port_profile *prof)

{
@@ -2881,7 +2963,11 @@ int mlx4_en_init_netdev(struct mlx4_en_dev *mdev, int port, 
		queue_delayed_work(mdev->workqueue, &priv->service_task,

				   SERVICE_TASK_DELAY);



	mlx4_set_stats_bitmap(mdev->dev, &priv->stats_bitmap);

	mlx4_en_set_stats_bitmap(mdev->dev, &priv->stats_bitmap,

				 mdev->profile.prof[priv->port].rx_ppp,

				 mdev->profile.prof[priv->port].rx_pause,

				 mdev->profile.prof[priv->port].tx_ppp,

				 mdev->profile.prof[priv->port].tx_pause);



	return 0;

drivers/net/ethernet/mellanox/mlx4/en_port.c

+144 −38
Original line number Diff line number Diff line
@@ -128,9 +128,29 @@ int mlx4_en_QUERY_PORT(struct mlx4_en_dev *mdev, u8 port) 
	return err;

}



/* Each counter set is located in struct mlx4_en_stat_out_mbox

 * with a const offset between its prio components.

 * This function runs over a counter set and sum all of it's prio components.

 */

static unsigned long en_stats_adder(__be64 *start, __be64 *next, int num)

{

	__be64 *curr = start;

	unsigned long ret = 0;

	int i;

	int offset = next - start;



	for (i = 0; i <= num; i++) {

		ret += be64_to_cpu(*curr);

		curr += offset;

	}



	return ret;

}



int mlx4_en_DUMP_ETH_STATS(struct mlx4_en_dev *mdev, u8 port, u8 reset)

{

	struct mlx4_en_stat_out_mbox *mlx4_en_stats;

	struct mlx4_en_stat_out_flow_control_mbox *flowstats;

	struct mlx4_en_priv *priv = netdev_priv(mdev->pndev[port]);

	struct net_device_stats *stats = &priv->stats;

	struct mlx4_cmd_mailbox *mailbox;
@@ -183,22 +203,25 @@ int mlx4_en_DUMP_ETH_STATS(struct mlx4_en_dev *mdev, u8 port, u8 reset) 
		priv->port_stats.xmit_more         += ring->xmit_more;

	}



	/* net device stats */

	stats->rx_errors = be64_to_cpu(mlx4_en_stats->PCS) +

			   be32_to_cpu(mlx4_en_stats->RdropLength) +

			   be32_to_cpu(mlx4_en_stats->RJBBR) +

			   be32_to_cpu(mlx4_en_stats->RCRC) +

			   be32_to_cpu(mlx4_en_stats->RRUNT);

	stats->tx_errors = be32_to_cpu(mlx4_en_stats->TDROP);

	stats->multicast = be64_to_cpu(mlx4_en_stats->MCAST_prio_0) +

			   be64_to_cpu(mlx4_en_stats->MCAST_prio_1) +

			   be64_to_cpu(mlx4_en_stats->MCAST_prio_2) +

			   be64_to_cpu(mlx4_en_stats->MCAST_prio_3) +

			   be64_to_cpu(mlx4_en_stats->MCAST_prio_4) +

			   be64_to_cpu(mlx4_en_stats->MCAST_prio_5) +

			   be64_to_cpu(mlx4_en_stats->MCAST_prio_6) +

			   be64_to_cpu(mlx4_en_stats->MCAST_prio_7) +

			   be64_to_cpu(mlx4_en_stats->MCAST_novlan);

			   be32_to_cpu(mlx4_en_stats->RRUNT) +

			   be64_to_cpu(mlx4_en_stats->RInRangeLengthErr) +

			   be64_to_cpu(mlx4_en_stats->ROutRangeLengthErr) +

			   be32_to_cpu(mlx4_en_stats->RSHORT) +

			   en_stats_adder(&mlx4_en_stats->RGIANT_prio_0,

					  &mlx4_en_stats->RGIANT_prio_1,

					  NUM_PRIORITIES);

	stats->tx_errors = en_stats_adder(&mlx4_en_stats->TGIANT_prio_0,

					  &mlx4_en_stats->TGIANT_prio_1,

					  NUM_PRIORITIES);

	stats->multicast = en_stats_adder(&mlx4_en_stats->MCAST_prio_0,

					  &mlx4_en_stats->MCAST_prio_1,

					  NUM_PRIORITIES);

	stats->collisions = 0;

	stats->rx_dropped = be32_to_cpu(mlx4_en_stats->RDROP);

	stats->rx_length_errors = be32_to_cpu(mlx4_en_stats->RdropLength);

	stats->rx_over_errors = be32_to_cpu(mlx4_en_stats->RdropOvflw);

	stats->rx_crc_errors = be32_to_cpu(mlx4_en_stats->RCRC);
@@ -210,33 +233,116 @@ int mlx4_en_DUMP_ETH_STATS(struct mlx4_en_dev *mdev, u8 port, u8 reset) 
	stats->tx_fifo_errors = 0;

	stats->tx_heartbeat_errors = 0;

	stats->tx_window_errors = 0;

	stats->tx_dropped = be32_to_cpu(mlx4_en_stats->TDROP);



	/* RX stats */

	priv->pkstats.rx_multicast_packets = stats->multicast;

	priv->pkstats.rx_broadcast_packets =

			en_stats_adder(&mlx4_en_stats->RBCAST_prio_0,

				       &mlx4_en_stats->RBCAST_prio_1,

				       NUM_PRIORITIES);

	priv->pkstats.rx_jabbers = be32_to_cpu(mlx4_en_stats->RJBBR);

	priv->pkstats.rx_in_range_length_error =

		be64_to_cpu(mlx4_en_stats->RInRangeLengthErr);

	priv->pkstats.rx_out_range_length_error =

		be64_to_cpu(mlx4_en_stats->ROutRangeLengthErr);



	/* Tx stats */

	priv->pkstats.tx_multicast_packets =

		en_stats_adder(&mlx4_en_stats->TMCAST_prio_0,

			       &mlx4_en_stats->TMCAST_prio_1,

			       NUM_PRIORITIES);

	priv->pkstats.tx_broadcast_packets =

		en_stats_adder(&mlx4_en_stats->TBCAST_prio_0,

			       &mlx4_en_stats->TBCAST_prio_1,

			       NUM_PRIORITIES);



	priv->pkstats.rx_prio[0][0] = be64_to_cpu(mlx4_en_stats->RTOT_prio_0);

	priv->pkstats.rx_prio[0][1] = be64_to_cpu(mlx4_en_stats->ROCT_prio_0);

	priv->pkstats.rx_prio[1][0] = be64_to_cpu(mlx4_en_stats->RTOT_prio_1);

	priv->pkstats.rx_prio[1][1] = be64_to_cpu(mlx4_en_stats->ROCT_prio_1);

	priv->pkstats.rx_prio[2][0] = be64_to_cpu(mlx4_en_stats->RTOT_prio_2);

	priv->pkstats.rx_prio[2][1] = be64_to_cpu(mlx4_en_stats->ROCT_prio_2);

	priv->pkstats.rx_prio[3][0] = be64_to_cpu(mlx4_en_stats->RTOT_prio_3);

	priv->pkstats.rx_prio[3][1] = be64_to_cpu(mlx4_en_stats->ROCT_prio_3);

	priv->pkstats.rx_prio[4][0] = be64_to_cpu(mlx4_en_stats->RTOT_prio_4);

	priv->pkstats.rx_prio[4][1] = be64_to_cpu(mlx4_en_stats->ROCT_prio_4);

	priv->pkstats.rx_prio[5][0] = be64_to_cpu(mlx4_en_stats->RTOT_prio_5);

	priv->pkstats.rx_prio[5][1] = be64_to_cpu(mlx4_en_stats->ROCT_prio_5);

	priv->pkstats.rx_prio[6][0] = be64_to_cpu(mlx4_en_stats->RTOT_prio_6);

	priv->pkstats.rx_prio[6][1] = be64_to_cpu(mlx4_en_stats->ROCT_prio_6);

	priv->pkstats.rx_prio[7][0] = be64_to_cpu(mlx4_en_stats->RTOT_prio_7);

	priv->pkstats.rx_prio[7][1] = be64_to_cpu(mlx4_en_stats->ROCT_prio_7);

	priv->pkstats.rx_prio[8][0] = be64_to_cpu(mlx4_en_stats->RTOT_novlan);

	priv->pkstats.rx_prio[8][1] = be64_to_cpu(mlx4_en_stats->ROCT_novlan);

	priv->pkstats.tx_prio[0][0] = be64_to_cpu(mlx4_en_stats->TTOT_prio_0);

	priv->pkstats.tx_prio[0][1] = be64_to_cpu(mlx4_en_stats->TOCT_prio_0);

	priv->pkstats.tx_prio[1][0] = be64_to_cpu(mlx4_en_stats->TTOT_prio_1);

	priv->pkstats.tx_prio[1][1] = be64_to_cpu(mlx4_en_stats->TOCT_prio_1);

	priv->pkstats.tx_prio[2][0] = be64_to_cpu(mlx4_en_stats->TTOT_prio_2);

	priv->pkstats.tx_prio[2][1] = be64_to_cpu(mlx4_en_stats->TOCT_prio_2);

	priv->pkstats.tx_prio[3][0] = be64_to_cpu(mlx4_en_stats->TTOT_prio_3);

	priv->pkstats.tx_prio[3][1] = be64_to_cpu(mlx4_en_stats->TOCT_prio_3);

	priv->pkstats.tx_prio[4][0] = be64_to_cpu(mlx4_en_stats->TTOT_prio_4);

	priv->pkstats.tx_prio[4][1] = be64_to_cpu(mlx4_en_stats->TOCT_prio_4);

	priv->pkstats.tx_prio[5][0] = be64_to_cpu(mlx4_en_stats->TTOT_prio_5);

	priv->pkstats.tx_prio[5][1] = be64_to_cpu(mlx4_en_stats->TOCT_prio_5);

	priv->pkstats.tx_prio[6][0] = be64_to_cpu(mlx4_en_stats->TTOT_prio_6);

	priv->pkstats.tx_prio[6][1] = be64_to_cpu(mlx4_en_stats->TOCT_prio_6);

	priv->pkstats.tx_prio[7][0] = be64_to_cpu(mlx4_en_stats->TTOT_prio_7);

	priv->pkstats.tx_prio[7][1] = be64_to_cpu(mlx4_en_stats->TOCT_prio_7);

	priv->pkstats.tx_prio[8][0] = be64_to_cpu(mlx4_en_stats->TTOT_novlan);

	priv->pkstats.tx_prio[8][1] = be64_to_cpu(mlx4_en_stats->TOCT_novlan);



	spin_unlock_bh(&priv->stats_lock);



	/* 0xffs indicates invalid value */

	memset(mailbox->buf, 0xff, sizeof(*flowstats) * MLX4_NUM_PRIORITIES);



	if (mdev->dev->caps.flags2 & MLX4_DEV_CAP_FLAG2_FLOWSTATS_EN) {

		memset(mailbox->buf, 0,

		       sizeof(*flowstats) * MLX4_NUM_PRIORITIES);

		err = mlx4_cmd_box(mdev->dev, 0, mailbox->dma,

				   in_mod | MLX4_DUMP_ETH_STATS_FLOW_CONTROL,

				   0, MLX4_CMD_DUMP_ETH_STATS,

				   MLX4_CMD_TIME_CLASS_B, MLX4_CMD_WRAPPED);

		if (err)

			goto out;

	}



	flowstats = mailbox->buf;



	spin_lock_bh(&priv->stats_lock);



	for (i = 0; i < MLX4_NUM_PRIORITIES; i++)	{

		priv->rx_priority_flowstats[i].rx_pause =

			be64_to_cpu(flowstats[i].rx_pause);

		priv->rx_priority_flowstats[i].rx_pause_duration =

			be64_to_cpu(flowstats[i].rx_pause_duration);

		priv->rx_priority_flowstats[i].rx_pause_transition =

			be64_to_cpu(flowstats[i].rx_pause_transition);

		priv->tx_priority_flowstats[i].tx_pause =

			be64_to_cpu(flowstats[i].tx_pause);

		priv->tx_priority_flowstats[i].tx_pause_duration =

			be64_to_cpu(flowstats[i].tx_pause_duration);

		priv->tx_priority_flowstats[i].tx_pause_transition =

			be64_to_cpu(flowstats[i].tx_pause_transition);

	}



	/* if pfc is not in use, all priorities counters have the same value */

	priv->rx_flowstats.rx_pause =

		be64_to_cpu(flowstats[0].rx_pause);

	priv->rx_flowstats.rx_pause_duration =

		be64_to_cpu(flowstats[0].rx_pause_duration);

	priv->rx_flowstats.rx_pause_transition =

		be64_to_cpu(flowstats[0].rx_pause_transition);

	priv->tx_flowstats.tx_pause =

		be64_to_cpu(flowstats[0].tx_pause);

	priv->tx_flowstats.tx_pause_duration =

		be64_to_cpu(flowstats[0].tx_pause_duration);

	priv->tx_flowstats.tx_pause_transition =

		be64_to_cpu(flowstats[0].tx_pause_transition);



	priv->pkstats.broadcast =

				be64_to_cpu(mlx4_en_stats->RBCAST_prio_0) +

				be64_to_cpu(mlx4_en_stats->RBCAST_prio_1) +

				be64_to_cpu(mlx4_en_stats->RBCAST_prio_2) +

				be64_to_cpu(mlx4_en_stats->RBCAST_prio_3) +

				be64_to_cpu(mlx4_en_stats->RBCAST_prio_4) +

				be64_to_cpu(mlx4_en_stats->RBCAST_prio_5) +

				be64_to_cpu(mlx4_en_stats->RBCAST_prio_6) +

				be64_to_cpu(mlx4_en_stats->RBCAST_prio_7) +

				be64_to_cpu(mlx4_en_stats->RBCAST_novlan);

	priv->pkstats.rx_prio[0] = be64_to_cpu(mlx4_en_stats->RTOT_prio_0);

	priv->pkstats.rx_prio[1] = be64_to_cpu(mlx4_en_stats->RTOT_prio_1);

	priv->pkstats.rx_prio[2] = be64_to_cpu(mlx4_en_stats->RTOT_prio_2);

	priv->pkstats.rx_prio[3] = be64_to_cpu(mlx4_en_stats->RTOT_prio_3);

	priv->pkstats.rx_prio[4] = be64_to_cpu(mlx4_en_stats->RTOT_prio_4);

	priv->pkstats.rx_prio[5] = be64_to_cpu(mlx4_en_stats->RTOT_prio_5);

	priv->pkstats.rx_prio[6] = be64_to_cpu(mlx4_en_stats->RTOT_prio_6);

	priv->pkstats.rx_prio[7] = be64_to_cpu(mlx4_en_stats->RTOT_prio_7);

	priv->pkstats.tx_prio[0] = be64_to_cpu(mlx4_en_stats->TTOT_prio_0);

	priv->pkstats.tx_prio[1] = be64_to_cpu(mlx4_en_stats->TTOT_prio_1);

	priv->pkstats.tx_prio[2] = be64_to_cpu(mlx4_en_stats->TTOT_prio_2);

	priv->pkstats.tx_prio[3] = be64_to_cpu(mlx4_en_stats->TTOT_prio_3);

	priv->pkstats.tx_prio[4] = be64_to_cpu(mlx4_en_stats->TTOT_prio_4);

	priv->pkstats.tx_prio[5] = be64_to_cpu(mlx4_en_stats->TTOT_prio_5);

	priv->pkstats.tx_prio[6] = be64_to_cpu(mlx4_en_stats->TTOT_prio_6);

	priv->pkstats.tx_prio[7] = be64_to_cpu(mlx4_en_stats->TTOT_prio_7);

	spin_unlock_bh(&priv->stats_lock);



out:

drivers/net/ethernet/mellanox/mlx4/fw.c

+8 −2
Original line number Diff line number Diff line
@@ -145,7 +145,8 @@ static void dump_dev_cap_flags2(struct mlx4_dev *dev, u64 flags) 
		[20] = "Recoverable error events support",

		[21] = "Port Remap support",

		[22] = "QCN support",

		[23] = "QP rate limiting support"

		[23] = "QP rate limiting support",

		[24] = "Ethernet Flow control statistics support"

	};

	int i;
@@ -672,6 +673,7 @@ int mlx4_QUERY_DEV_CAP(struct mlx4_dev *dev, struct mlx4_dev_cap *dev_cap) 
#define QUERY_DEV_CAP_RSVD_XRC_OFFSET		0x66

#define QUERY_DEV_CAP_MAX_XRC_OFFSET		0x67

#define QUERY_DEV_CAP_MAX_COUNTERS_OFFSET	0x68

#define QUERY_DEV_CAP_PORT_FLOWSTATS_COUNTERS_OFFSET	0x70

#define QUERY_DEV_CAP_EXT_2_FLAGS_OFFSET	0x70

#define QUERY_DEV_CAP_FLOW_STEERING_IPOIB_OFFSET	0x74

#define QUERY_DEV_CAP_FLOW_STEERING_RANGE_EN_OFFSET	0x76
@@ -773,6 +775,9 @@ int mlx4_QUERY_DEV_CAP(struct mlx4_dev *dev, struct mlx4_dev_cap *dev_cap) 
	MLX4_GET(field, outbox, QUERY_DEV_CAP_VL_PORT_OFFSET);

	dev_cap->num_ports = field & 0xf;

	MLX4_GET(field, outbox, QUERY_DEV_CAP_MAX_MSG_SZ_OFFSET);

	MLX4_GET(field, outbox, QUERY_DEV_CAP_PORT_FLOWSTATS_COUNTERS_OFFSET);

	if (field & 0x10)

		dev_cap->flags2 |= MLX4_DEV_CAP_FLAG2_FLOWSTATS_EN;

	dev_cap->max_msg_sz = 1 << (field & 0x1f);

	MLX4_GET(field, outbox, QUERY_DEV_CAP_FLOW_STEERING_RANGE_EN_OFFSET);

	if (field & 0x80)
@@ -1088,6 +1093,7 @@ int mlx4_QUERY_PORT(struct mlx4_dev *dev, int port, struct mlx4_port_cap *port_c 
	return err;

}



#define DEV_CAP_EXT_2_FLAG_PFC_COUNTERS	(1 << 28)

#define DEV_CAP_EXT_2_FLAG_VLAN_CONTROL (1 << 26)

#define DEV_CAP_EXT_2_FLAG_80_VFS	(1 << 21)

#define DEV_CAP_EXT_2_FLAG_FSM		(1 << 20)
@@ -1177,7 +1183,7 @@ int mlx4_QUERY_DEV_CAP_wrapper(struct mlx4_dev *dev, int slave, 
	/* turn off host side virt features (VST, FSM, etc) for guests */

	MLX4_GET(field32, outbox->buf, QUERY_DEV_CAP_EXT_2_FLAGS_OFFSET);

	field32 &= ~(DEV_CAP_EXT_2_FLAG_VLAN_CONTROL | DEV_CAP_EXT_2_FLAG_80_VFS |

		     DEV_CAP_EXT_2_FLAG_FSM);

		     DEV_CAP_EXT_2_FLAG_FSM | DEV_CAP_EXT_2_FLAG_PFC_COUNTERS);

	MLX4_PUT(outbox->buf, field32, QUERY_DEV_CAP_EXT_2_FLAGS_OFFSET);



	/* turn off QCN for guests */