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

Commit e0348b9a authored by Divy Le Ray's avatar Divy Le Ray Committed by Jeff Garzik
Browse files

cxgb - fix stats 



Fix MAC stats accounting.
Fix get_stats.

Signed-off-by: default avatarDivy Le Ray <divy@chelsio.com>
Signed-off-by: default avatarJeff Garzik <jeff@garzik.org>
parent 445cf803

drivers/net/chelsio/cxgb2.c

+51 −16
Original line number Original line Diff line number Diff line
@@ -374,6 +374,8 @@ static char stats_strings[][ETH_GSTRING_LEN] = { 
	"TxInternalMACXmitError",

	"TxInternalMACXmitError",

	"TxFramesWithExcessiveDeferral",

	"TxFramesWithExcessiveDeferral",

	"TxFCSErrors",

	"TxFCSErrors",

	"TxJumboFramesOk",

	"TxJumboOctetsOk",

	

	

	"RxOctetsOK",

	"RxOctetsOK",

	"RxOctetsBad",

	"RxOctetsBad",
@@ -392,11 +394,11 @@ static char stats_strings[][ETH_GSTRING_LEN] = { 
	"RxInRangeLengthErrors",

	"RxInRangeLengthErrors",

	"RxOutOfRangeLengthField",

	"RxOutOfRangeLengthField",

	"RxFrameTooLongErrors",

	"RxFrameTooLongErrors",

	"RxJumboFramesOk",

	"RxJumboOctetsOk",





	/* Port stats */

	/* Port stats */

	"RxPackets",

	"RxCsumGood",

	"RxCsumGood",

	"TxPackets",

	"TxCsumOffload",

	"TxCsumOffload",

	"TxTso",

	"TxTso",

	"RxVlan",

	"RxVlan",
@@ -464,23 +466,56 @@ static void get_stats(struct net_device *dev, struct ethtool_stats *stats, 
	const struct cmac_statistics *s;

	const struct cmac_statistics *s;

	const struct sge_intr_counts *t;

	const struct sge_intr_counts *t;

	struct sge_port_stats ss;

	struct sge_port_stats ss;

	unsigned int len;





	s = mac->ops->statistics_update(mac, MAC_STATS_UPDATE_FULL);

	s = mac->ops->statistics_update(mac, MAC_STATS_UPDATE_FULL);



	t = t1_sge_get_intr_counts(adapter->sge);

	len = sizeof(u64)*(&s->TxFCSErrors + 1 - &s->TxOctetsOK);

	memcpy(data, &s->TxOctetsOK, len);

	data += len;



	len = sizeof(u64)*(&s->RxFrameTooLongErrors + 1 - &s->RxOctetsOK);

	memcpy(data, &s->RxOctetsOK, len);

	data += len;



	t1_sge_get_port_stats(adapter->sge, dev->if_port, &ss);

	t1_sge_get_port_stats(adapter->sge, dev->if_port, &ss);

	memcpy(data, &ss, sizeof(ss));

	data += sizeof(ss);





	t = t1_sge_get_intr_counts(adapter->sge);

	*data++ = s->TxOctetsOK;

	*data++ = s->TxOctetsBad;

	*data++ = s->TxUnicastFramesOK;

	*data++ = s->TxMulticastFramesOK;

	*data++ = s->TxBroadcastFramesOK;

	*data++ = s->TxPauseFrames;

	*data++ = s->TxFramesWithDeferredXmissions;

	*data++ = s->TxLateCollisions;

	*data++ = s->TxTotalCollisions;

	*data++ = s->TxFramesAbortedDueToXSCollisions;

	*data++ = s->TxUnderrun;

	*data++ = s->TxLengthErrors;

	*data++ = s->TxInternalMACXmitError;

	*data++ = s->TxFramesWithExcessiveDeferral;

	*data++ = s->TxFCSErrors;

	*data++ = s->TxJumboFramesOK;

	*data++ = s->TxJumboOctetsOK;



	*data++ = s->RxOctetsOK;

	*data++ = s->RxOctetsBad;

	*data++ = s->RxUnicastFramesOK;

	*data++ = s->RxMulticastFramesOK;

	*data++ = s->RxBroadcastFramesOK;

	*data++ = s->RxPauseFrames;

	*data++ = s->RxFCSErrors;

	*data++ = s->RxAlignErrors;

	*data++ = s->RxSymbolErrors;

	*data++ = s->RxDataErrors;

	*data++ = s->RxSequenceErrors;

	*data++ = s->RxRuntErrors;

	*data++ = s->RxJabberErrors;

	*data++ = s->RxInternalMACRcvError;

	*data++ = s->RxInRangeLengthErrors;

	*data++ = s->RxOutOfRangeLengthField;

	*data++ = s->RxFrameTooLongErrors;

	*data++ = s->RxJumboFramesOK;

	*data++ = s->RxJumboOctetsOK;



	*data++ = ss.rx_cso_good;

	*data++ = ss.tx_cso;

	*data++ = ss.tx_tso;

	*data++ = ss.vlan_xtract;

	*data++ = ss.vlan_insert;

	*data++ = ss.tx_need_hdrroom;

	

	*data++ = t->rx_drops;

	*data++ = t->rx_drops;

	*data++ = t->pure_rsps;

	*data++ = t->pure_rsps;

	*data++ = t->unhandled_irqs;

	*data++ = t->unhandled_irqs;

drivers/net/chelsio/pm3393.c

100644 → 100755
+45 −67
Original line number Original line Diff line number Diff line
@@ -45,7 +45,7 @@ 




#include <linux/crc32.h>

#include <linux/crc32.h>





#define OFFSET(REG_ADDR)    (REG_ADDR << 2)

#define OFFSET(REG_ADDR)    ((REG_ADDR) << 2)





/* Max frame size PM3393 can handle. Includes Ethernet header and CRC. */

/* Max frame size PM3393 can handle. Includes Ethernet header and CRC. */

#define MAX_FRAME_SIZE  9600

#define MAX_FRAME_SIZE  9600
@@ -428,69 +428,26 @@ static int pm3393_set_speed_duplex_fc(struct cmac *cmac, int speed, int duplex, 
	return 0;

	return 0;

}

}





static void pm3393_rmon_update(struct adapter *adapter, u32 offs, u64 *val,

#define RMON_UPDATE(mac, name, stat_name) \

			       int over)

{ \

{

	t1_tpi_read((mac)->adapter, OFFSET(name), &val0);     \

	u32 val0, val1, val2;

	t1_tpi_read((mac)->adapter, OFFSET((name)+1), &val1); \



	t1_tpi_read((mac)->adapter, OFFSET((name)+2), &val2); \

	t1_tpi_read(adapter, offs, &val0);

	(mac)->stats.stat_name = (u64)(val0 & 0xffff) | \

	t1_tpi_read(adapter, offs + 4, &val1);

				 ((u64)(val1 & 0xffff) << 16) | \

	t1_tpi_read(adapter, offs + 8, &val2);

				 ((u64)(val2 & 0xff) << 32) | \



				 ((mac)->stats.stat_name & \

	*val &= ~0ull << 40;

					0xffffff0000000000ULL); \

	*val |= val0 & 0xffff;

	if (ro & \

	*val |= (val1 & 0xffff) << 16;

	    (1ULL << ((name - SUNI1x10GEXP_REG_MSTAT_COUNTER_0_LOW) >> 2))) \

	*val |= (u64)(val2 & 0xff) << 32;

		(mac)->stats.stat_name += 1ULL << 40; \



	if (over)

		*val += 1ull << 40;

}

}





static const struct cmac_statistics *pm3393_update_statistics(struct cmac *mac,

static const struct cmac_statistics *pm3393_update_statistics(struct cmac *mac,

							      int flag)

							      int flag)

{

{

	static struct {

		unsigned int reg;

		unsigned int offset;

	} hw_stats [] = {



#define HW_STAT(name, stat_name) \

	{ name, (&((struct cmac_statistics *)NULL)->stat_name) - (u64 *)NULL }



		/* Rx stats */

		HW_STAT(RxOctetsReceivedOK, RxOctetsOK),

		HW_STAT(RxUnicastFramesReceivedOK, RxUnicastFramesOK),

		HW_STAT(RxMulticastFramesReceivedOK, RxMulticastFramesOK),

		HW_STAT(RxBroadcastFramesReceivedOK, RxBroadcastFramesOK),

		HW_STAT(RxPAUSEMACCtrlFramesReceived, RxPauseFrames),

		HW_STAT(RxFrameCheckSequenceErrors, RxFCSErrors),

		HW_STAT(RxFramesLostDueToInternalMACErrors,

				RxInternalMACRcvError),

		HW_STAT(RxSymbolErrors, RxSymbolErrors),

		HW_STAT(RxInRangeLengthErrors, RxInRangeLengthErrors),

		HW_STAT(RxFramesTooLongErrors , RxFrameTooLongErrors),

		HW_STAT(RxJabbers, RxJabberErrors),

		HW_STAT(RxFragments, RxRuntErrors),

		HW_STAT(RxUndersizedFrames, RxRuntErrors),

		HW_STAT(RxJumboFramesReceivedOK, RxJumboFramesOK),

		HW_STAT(RxJumboOctetsReceivedOK, RxJumboOctetsOK),



		/* Tx stats */

		HW_STAT(TxOctetsTransmittedOK, TxOctetsOK),

		HW_STAT(TxFramesLostDueToInternalMACTransmissionError,

				TxInternalMACXmitError),

		HW_STAT(TxTransmitSystemError, TxFCSErrors),

		HW_STAT(TxUnicastFramesTransmittedOK, TxUnicastFramesOK),

		HW_STAT(TxMulticastFramesTransmittedOK, TxMulticastFramesOK),

		HW_STAT(TxBroadcastFramesTransmittedOK, TxBroadcastFramesOK),

		HW_STAT(TxPAUSEMACCtrlFramesTransmitted, TxPauseFrames),

		HW_STAT(TxJumboFramesReceivedOK, TxJumboFramesOK),

		HW_STAT(TxJumboOctetsReceivedOK, TxJumboOctetsOK)

	}, *p = hw_stats;

	u64	ro;

	u64	ro;

	u32	val0, val1, val2, val3;

	u32	val0, val1, val2, val3;

	u64 *stats = (u64 *) &mac->stats;

	unsigned int i;





	/* Snap the counters */

	/* Snap the counters */

	pmwrite(mac, SUNI1x10GEXP_REG_MSTAT_CONTROL,

	pmwrite(mac, SUNI1x10GEXP_REG_MSTAT_CONTROL,
@@ -504,14 +461,35 @@ static const struct cmac_statistics *pm3393_update_statistics(struct cmac *mac, 
	ro = ((u64)val0 & 0xffff) | (((u64)val1 & 0xffff) << 16) |

	ro = ((u64)val0 & 0xffff) | (((u64)val1 & 0xffff) << 16) |

		(((u64)val2 & 0xffff) << 32) | (((u64)val3 & 0xffff) << 48);

		(((u64)val2 & 0xffff) << 32) | (((u64)val3 & 0xffff) << 48);





	for (i = 0; i < ARRAY_SIZE(hw_stats); i++) {

	/* Rx stats */

		unsigned reg = p->reg - SUNI1x10GEXP_REG_MSTAT_COUNTER_0_LOW;

	RMON_UPDATE(mac, RxOctetsReceivedOK, RxOctetsOK);



	RMON_UPDATE(mac, RxUnicastFramesReceivedOK, RxUnicastFramesOK);

		pm3393_rmon_update((mac)->adapter, OFFSET(p->reg),

	RMON_UPDATE(mac, RxMulticastFramesReceivedOK, RxMulticastFramesOK);

				   stats + p->offset, ro & (reg >> 2));

	RMON_UPDATE(mac, RxBroadcastFramesReceivedOK, RxBroadcastFramesOK);

	}

	RMON_UPDATE(mac, RxPAUSEMACCtrlFramesReceived, RxPauseFrames);



	RMON_UPDATE(mac, RxFrameCheckSequenceErrors, RxFCSErrors);

	RMON_UPDATE(mac, RxFramesLostDueToInternalMACErrors,

				RxInternalMACRcvError);

	RMON_UPDATE(mac, RxSymbolErrors, RxSymbolErrors);

	RMON_UPDATE(mac, RxInRangeLengthErrors, RxInRangeLengthErrors);

	RMON_UPDATE(mac, RxFramesTooLongErrors , RxFrameTooLongErrors);

	RMON_UPDATE(mac, RxJabbers, RxJabberErrors);

	RMON_UPDATE(mac, RxFragments, RxRuntErrors);

	RMON_UPDATE(mac, RxUndersizedFrames, RxRuntErrors);

	RMON_UPDATE(mac, RxJumboFramesReceivedOK, RxJumboFramesOK);

	RMON_UPDATE(mac, RxJumboOctetsReceivedOK, RxJumboOctetsOK);





	/* Tx stats */

	RMON_UPDATE(mac, TxOctetsTransmittedOK, TxOctetsOK);

	RMON_UPDATE(mac, TxFramesLostDueToInternalMACTransmissionError,

				TxInternalMACXmitError);

	RMON_UPDATE(mac, TxTransmitSystemError, TxFCSErrors);

	RMON_UPDATE(mac, TxUnicastFramesTransmittedOK, TxUnicastFramesOK);

	RMON_UPDATE(mac, TxMulticastFramesTransmittedOK, TxMulticastFramesOK);

	RMON_UPDATE(mac, TxBroadcastFramesTransmittedOK, TxBroadcastFramesOK);

	RMON_UPDATE(mac, TxPAUSEMACCtrlFramesTransmitted, TxPauseFrames);

	RMON_UPDATE(mac, TxJumboFramesReceivedOK, TxJumboFramesOK);

	RMON_UPDATE(mac, TxJumboOctetsReceivedOK, TxJumboOctetsOK);





	return &mac->stats;

	return &mac->stats;

}

}

drivers/net/chelsio/sge.c

100644 → 100755
+0 −4
Original line number Original line Diff line number Diff line
@@ -986,9 +986,7 @@ void t1_sge_get_port_stats(const struct sge *sge, int port, 
	for_each_possible_cpu(cpu) {

	for_each_possible_cpu(cpu) {

		struct sge_port_stats *st = per_cpu_ptr(sge->port_stats[port], cpu);

		struct sge_port_stats *st = per_cpu_ptr(sge->port_stats[port], cpu);





		ss->rx_packets += st->rx_packets;

		ss->rx_cso_good += st->rx_cso_good;

		ss->rx_cso_good += st->rx_cso_good;

		ss->tx_packets += st->tx_packets;

		ss->tx_cso += st->tx_cso;

		ss->tx_cso += st->tx_cso;

		ss->tx_tso += st->tx_tso;

		ss->tx_tso += st->tx_tso;

		ss->tx_need_hdrroom += st->tx_need_hdrroom;

		ss->tx_need_hdrroom += st->tx_need_hdrroom;
@@ -1381,7 +1379,6 @@ static void sge_rx(struct sge *sge, struct freelQ *fl, unsigned int len) 
	__skb_pull(skb, sizeof(*p));

	__skb_pull(skb, sizeof(*p));





	st = per_cpu_ptr(sge->port_stats[p->iff], smp_processor_id());

	st = per_cpu_ptr(sge->port_stats[p->iff], smp_processor_id());

	st->rx_packets++;





	skb->protocol = eth_type_trans(skb, adapter->port[p->iff].dev);

	skb->protocol = eth_type_trans(skb, adapter->port[p->iff].dev);

	skb->dev->last_rx = jiffies;

	skb->dev->last_rx = jiffies;
@@ -1946,7 +1943,6 @@ int t1_start_xmit(struct sk_buff *skb, struct net_device *dev) 
		cpl->vlan_valid = 0;

		cpl->vlan_valid = 0;





send:

send:

	st->tx_packets++;

	dev->trans_start = jiffies;

	dev->trans_start = jiffies;

	ret = t1_sge_tx(skb, adapter, 0, dev);

	ret = t1_sge_tx(skb, adapter, 0, dev);

drivers/net/chelsio/sge.h

+0 −2
Original line number Original line Diff line number Diff line
@@ -57,9 +57,7 @@ struct sge_intr_counts { 
};

};





struct sge_port_stats {

struct sge_port_stats {

	u64 rx_packets;      /* # of Ethernet packets received */

	u64 rx_cso_good;     /* # of successful RX csum offloads */

	u64 rx_cso_good;     /* # of successful RX csum offloads */

	u64 tx_packets;      /* # of TX packets */

	u64 tx_cso;          /* # of TX checksum offloads */

	u64 tx_cso;          /* # of TX checksum offloads */

	u64 tx_tso;          /* # of TSO requests */

	u64 tx_tso;          /* # of TSO requests */

	u64 vlan_xtract;     /* # of VLAN tag extractions */

	u64 vlan_xtract;     /* # of VLAN tag extractions */