chelsio: tabulate the update of the statistic counters
Let's try to avoid some code duplication. - cxgb2 The data are contiguous. Use plain memcpy. - ixf1010/pm3393/vsc7326 The cast of &mac->stats to (u64 *) is not wonderful but it is not clear if it is worth to add an ad-hoc union under the struct cmac_statistics. vsc7326_reg.h suggests that more statistics could be available. Signed-off-by: Francois Romieu <romieu@fr.zoreil.com>
This commit is contained in:
Francois Romieu
Jeff Garzik
parent
3e0f75be52
commit
834324687d
@ -454,51 +454,21 @@ static void get_stats(struct net_device *dev, struct ethtool_stats *stats,
|
||||
const struct cmac_statistics *s;
|
||||
const struct sge_intr_counts *t;
|
||||
struct sge_port_stats ss;
|
||||
unsigned int len;
|
||||
|
||||
s = mac->ops->statistics_update(mac, MAC_STATS_UPDATE_FULL);
|
||||
|
||||
*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;
|
||||
len = sizeof(u64)*(&s->TxFCSErrors + 1 - &s->TxOctetsOK);
|
||||
memcpy(data, &s->TxOctetsOK, len);
|
||||
data += len;
|
||||
|
||||
*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;
|
||||
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);
|
||||
*data++ = ss.rx_packets;
|
||||
*data++ = ss.rx_cso_good;
|
||||
*data++ = ss.tx_packets;
|
||||
*data++ = ss.tx_cso;
|
||||
*data++ = ss.tx_tso;
|
||||
*data++ = ss.vlan_xtract;
|
||||
*data++ = ss.vlan_insert;
|
||||
memcpy(data, &ss, sizeof(ss));
|
||||
data += sizeof(ss);
|
||||
|
||||
t = t1_sge_get_intr_counts(adapter->sge);
|
||||
*data++ = t->rx_drops;
|
||||
|
||||
@ -145,48 +145,61 @@ static void disable_port(struct cmac *mac)
|
||||
t1_tpi_write(mac->adapter, REG_PORT_ENABLE, val);
|
||||
}
|
||||
|
||||
#define RMON_UPDATE(mac, name, stat_name) \
|
||||
t1_tpi_read((mac)->adapter, MACREG(mac, REG_##name), &val); \
|
||||
(mac)->stats.stat_name += val;
|
||||
|
||||
/*
|
||||
* Read the current values of the RMON counters and add them to the cumulative
|
||||
* port statistics. The HW RMON counters are cleared by this operation.
|
||||
*/
|
||||
static void port_stats_update(struct cmac *mac)
|
||||
{
|
||||
u32 val;
|
||||
static struct {
|
||||
unsigned int reg;
|
||||
unsigned int offset;
|
||||
} hw_stats[] = {
|
||||
|
||||
/* Rx stats */
|
||||
RMON_UPDATE(mac, RxOctetsTotalOK, RxOctetsOK);
|
||||
RMON_UPDATE(mac, RxOctetsBad, RxOctetsBad);
|
||||
RMON_UPDATE(mac, RxUCPkts, RxUnicastFramesOK);
|
||||
RMON_UPDATE(mac, RxMCPkts, RxMulticastFramesOK);
|
||||
RMON_UPDATE(mac, RxBCPkts, RxBroadcastFramesOK);
|
||||
RMON_UPDATE(mac, RxJumboPkts, RxJumboFramesOK);
|
||||
RMON_UPDATE(mac, RxFCSErrors, RxFCSErrors);
|
||||
RMON_UPDATE(mac, RxAlignErrors, RxAlignErrors);
|
||||
RMON_UPDATE(mac, RxLongErrors, RxFrameTooLongErrors);
|
||||
RMON_UPDATE(mac, RxVeryLongErrors, RxFrameTooLongErrors);
|
||||
RMON_UPDATE(mac, RxPauseMacControlCounter, RxPauseFrames);
|
||||
RMON_UPDATE(mac, RxDataErrors, RxDataErrors);
|
||||
RMON_UPDATE(mac, RxJabberErrors, RxJabberErrors);
|
||||
RMON_UPDATE(mac, RxRuntErrors, RxRuntErrors);
|
||||
RMON_UPDATE(mac, RxShortErrors, RxRuntErrors);
|
||||
RMON_UPDATE(mac, RxSequenceErrors, RxSequenceErrors);
|
||||
RMON_UPDATE(mac, RxSymbolErrors, RxSymbolErrors);
|
||||
#define HW_STAT(name, stat_name) \
|
||||
{ REG_##name, \
|
||||
(&((struct cmac_statistics *)NULL)->stat_name) - (u64 *)NULL }
|
||||
|
||||
/* Tx stats (skip collision stats as we are full-duplex only) */
|
||||
RMON_UPDATE(mac, TxOctetsTotalOK, TxOctetsOK);
|
||||
RMON_UPDATE(mac, TxOctetsBad, TxOctetsBad);
|
||||
RMON_UPDATE(mac, TxUCPkts, TxUnicastFramesOK);
|
||||
RMON_UPDATE(mac, TxMCPkts, TxMulticastFramesOK);
|
||||
RMON_UPDATE(mac, TxBCPkts, TxBroadcastFramesOK);
|
||||
RMON_UPDATE(mac, TxJumboPkts, TxJumboFramesOK);
|
||||
RMON_UPDATE(mac, TxPauseFrames, TxPauseFrames);
|
||||
RMON_UPDATE(mac, TxExcessiveLengthDrop, TxLengthErrors);
|
||||
RMON_UPDATE(mac, TxUnderrun, TxUnderrun);
|
||||
RMON_UPDATE(mac, TxCRCErrors, TxFCSErrors);
|
||||
/* Rx stats */
|
||||
HW_STAT(RxOctetsTotalOK, RxOctetsOK),
|
||||
HW_STAT(RxOctetsBad, RxOctetsBad),
|
||||
HW_STAT(RxUCPkts, RxUnicastFramesOK),
|
||||
HW_STAT(RxMCPkts, RxMulticastFramesOK),
|
||||
HW_STAT(RxBCPkts, RxBroadcastFramesOK),
|
||||
HW_STAT(RxJumboPkts, RxJumboFramesOK),
|
||||
HW_STAT(RxFCSErrors, RxFCSErrors),
|
||||
HW_STAT(RxAlignErrors, RxAlignErrors),
|
||||
HW_STAT(RxLongErrors, RxFrameTooLongErrors),
|
||||
HW_STAT(RxVeryLongErrors, RxFrameTooLongErrors),
|
||||
HW_STAT(RxPauseMacControlCounter, RxPauseFrames),
|
||||
HW_STAT(RxDataErrors, RxDataErrors),
|
||||
HW_STAT(RxJabberErrors, RxJabberErrors),
|
||||
HW_STAT(RxRuntErrors, RxRuntErrors),
|
||||
HW_STAT(RxShortErrors, RxRuntErrors),
|
||||
HW_STAT(RxSequenceErrors, RxSequenceErrors),
|
||||
HW_STAT(RxSymbolErrors, RxSymbolErrors),
|
||||
|
||||
/* Tx stats (skip collision stats as we are full-duplex only) */
|
||||
HW_STAT(TxOctetsTotalOK, TxOctetsOK),
|
||||
HW_STAT(TxOctetsBad, TxOctetsBad),
|
||||
HW_STAT(TxUCPkts, TxUnicastFramesOK),
|
||||
HW_STAT(TxMCPkts, TxMulticastFramesOK),
|
||||
HW_STAT(TxBCPkts, TxBroadcastFramesOK),
|
||||
HW_STAT(TxJumboPkts, TxJumboFramesOK),
|
||||
HW_STAT(TxPauseFrames, TxPauseFrames),
|
||||
HW_STAT(TxExcessiveLengthDrop, TxLengthErrors),
|
||||
HW_STAT(TxUnderrun, TxUnderrun),
|
||||
HW_STAT(TxCRCErrors, TxFCSErrors)
|
||||
}, *p = hw_stats;
|
||||
u64 *stats = (u64 *) &mac->stats;
|
||||
unsigned int i;
|
||||
|
||||
for (i = 0; i < ARRAY_SIZE(hw_stats); i++) {
|
||||
u32 val;
|
||||
|
||||
t1_tpi_read(mac->adapter, MACREG(mac, p->reg), &val);
|
||||
stats[p->offset] += val;
|
||||
}
|
||||
}
|
||||
|
||||
/* No-op interrupt operation as this MAC does not support interrupts */
|
||||
@ -390,6 +403,10 @@ static int mac_disable(struct cmac *mac, int which)
|
||||
return 0;
|
||||
}
|
||||
|
||||
#define RMON_UPDATE(mac, name, stat_name) \
|
||||
t1_tpi_read((mac)->adapter, MACREG(mac, REG_##name), &val); \
|
||||
(mac)->stats.stat_name += val;
|
||||
|
||||
/*
|
||||
* This function is called periodically to accumulate the current values of the
|
||||
* RMON counters into the port statistics. Since the counters are only 32 bits
|
||||
|
||||
@ -446,17 +446,51 @@ static void pm3393_rmon_update(struct adapter *adapter, u32 offs, u64 *val,
|
||||
*val += 1ull << 40;
|
||||
}
|
||||
|
||||
#define RMON_UPDATE(mac, name, stat_name) \
|
||||
pm3393_rmon_update((mac)->adapter, OFFSET(name), \
|
||||
&(mac)->stats.stat_name, \
|
||||
(ro &((name - SUNI1x10GEXP_REG_MSTAT_COUNTER_0_LOW) >> 2)))
|
||||
|
||||
|
||||
static const struct cmac_statistics *pm3393_update_statistics(struct cmac *mac,
|
||||
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;
|
||||
u32 val0, val1, val2, val3;
|
||||
u64 *stats = (u64 *) &mac->stats;
|
||||
unsigned int i;
|
||||
|
||||
/* Snap the counters */
|
||||
pmwrite(mac, SUNI1x10GEXP_REG_MSTAT_CONTROL,
|
||||
@ -470,35 +504,14 @@ static const struct cmac_statistics *pm3393_update_statistics(struct cmac *mac,
|
||||
ro = ((u64)val0 & 0xffff) | (((u64)val1 & 0xffff) << 16) |
|
||||
(((u64)val2 & 0xffff) << 32) | (((u64)val3 & 0xffff) << 48);
|
||||
|
||||
/* Rx stats */
|
||||
RMON_UPDATE(mac, RxOctetsReceivedOK, RxOctetsOK);
|
||||
RMON_UPDATE(mac, RxUnicastFramesReceivedOK, RxUnicastFramesOK);
|
||||
RMON_UPDATE(mac, RxMulticastFramesReceivedOK, RxMulticastFramesOK);
|
||||
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);
|
||||
for (i = 0; i < ARRAY_SIZE(hw_stats); i++) {
|
||||
unsigned reg = p->reg - SUNI1x10GEXP_REG_MSTAT_COUNTER_0_LOW;
|
||||
|
||||
pm3393_rmon_update((mac)->adapter, OFFSET(p->reg),
|
||||
stats + p->offset, ro & (reg >> 2));
|
||||
}
|
||||
|
||||
|
||||
/* 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;
|
||||
}
|
||||
|
||||
@ -589,40 +589,46 @@ static void rmon_update(struct cmac *mac, unsigned int addr, u64 *stat)
|
||||
|
||||
static void port_stats_update(struct cmac *mac)
|
||||
{
|
||||
int port = mac->instance->index;
|
||||
struct {
|
||||
unsigned int reg;
|
||||
unsigned int offset;
|
||||
} hw_stats[] = {
|
||||
|
||||
/* Rx stats */
|
||||
#define HW_STAT(reg, stat_name) \
|
||||
{ reg, (&((struct cmac_statistics *)NULL)->stat_name) - (u64 *)NULL }
|
||||
|
||||
/* Rx stats */
|
||||
HW_STAT(RxUnicast, RxUnicastFramesOK),
|
||||
HW_STAT(RxMulticast, RxMulticastFramesOK),
|
||||
HW_STAT(RxBroadcast, RxBroadcastFramesOK),
|
||||
HW_STAT(Crc, RxFCSErrors),
|
||||
HW_STAT(RxAlignment, RxAlignErrors),
|
||||
HW_STAT(RxOversize, RxFrameTooLongErrors),
|
||||
HW_STAT(RxPause, RxPauseFrames),
|
||||
HW_STAT(RxJabbers, RxJabberErrors),
|
||||
HW_STAT(RxFragments, RxRuntErrors),
|
||||
HW_STAT(RxUndersize, RxRuntErrors),
|
||||
HW_STAT(RxSymbolCarrier, RxSymbolErrors),
|
||||
HW_STAT(RxSize1519ToMax, RxJumboFramesOK),
|
||||
|
||||
/* Tx stats (skip collision stats as we are full-duplex only) */
|
||||
HW_STAT(TxUnicast, TxUnicastFramesOK),
|
||||
HW_STAT(TxMulticast, TxMulticastFramesOK),
|
||||
HW_STAT(TxBroadcast, TxBroadcastFramesOK),
|
||||
HW_STAT(TxPause, TxPauseFrames),
|
||||
HW_STAT(TxUnderrun, TxUnderrun),
|
||||
HW_STAT(TxSize1519ToMax, TxJumboFramesOK),
|
||||
}, *p = hw_stats;
|
||||
unsigned int port = mac->instance->index;
|
||||
u64 *stats = (u64 *)&mac->stats;
|
||||
unsigned int i;
|
||||
|
||||
for (i = 0; i < ARRAY_SIZE(hw_stats); i++)
|
||||
rmon_update(mac, CRA(0x4, port, p->reg), stats + p->offset);
|
||||
|
||||
rmon_update(mac, REG_TX_OK_BYTES(port), &mac->stats.TxOctetsOK);
|
||||
rmon_update(mac, REG_RX_OK_BYTES(port), &mac->stats.RxOctetsOK);
|
||||
rmon_update(mac, REG_RX_BAD_BYTES(port), &mac->stats.RxOctetsBad);
|
||||
rmon_update(mac, REG_RX_UNICAST(port), &mac->stats.RxUnicastFramesOK);
|
||||
rmon_update(mac, REG_RX_MULTICAST(port),
|
||||
&mac->stats.RxMulticastFramesOK);
|
||||
rmon_update(mac, REG_RX_BROADCAST(port),
|
||||
&mac->stats.RxBroadcastFramesOK);
|
||||
rmon_update(mac, REG_CRC(port), &mac->stats.RxFCSErrors);
|
||||
rmon_update(mac, REG_RX_ALIGNMENT(port), &mac->stats.RxAlignErrors);
|
||||
rmon_update(mac, REG_RX_OVERSIZE(port),
|
||||
&mac->stats.RxFrameTooLongErrors);
|
||||
rmon_update(mac, REG_RX_PAUSE(port), &mac->stats.RxPauseFrames);
|
||||
rmon_update(mac, REG_RX_JABBERS(port), &mac->stats.RxJabberErrors);
|
||||
rmon_update(mac, REG_RX_FRAGMENTS(port), &mac->stats.RxRuntErrors);
|
||||
rmon_update(mac, REG_RX_UNDERSIZE(port), &mac->stats.RxRuntErrors);
|
||||
rmon_update(mac, REG_RX_SYMBOL_CARRIER(port),
|
||||
&mac->stats.RxSymbolErrors);
|
||||
rmon_update(mac, REG_RX_SIZE_1519_TO_MAX(port),
|
||||
&mac->stats.RxJumboFramesOK);
|
||||
|
||||
/* Tx stats (skip collision stats as we are full-duplex only) */
|
||||
rmon_update(mac, REG_TX_OK_BYTES(port), &mac->stats.TxOctetsOK);
|
||||
rmon_update(mac, REG_TX_UNICAST(port), &mac->stats.TxUnicastFramesOK);
|
||||
rmon_update(mac, REG_TX_MULTICAST(port),
|
||||
&mac->stats.TxMulticastFramesOK);
|
||||
rmon_update(mac, REG_TX_BROADCAST(port),
|
||||
&mac->stats.TxBroadcastFramesOK);
|
||||
rmon_update(mac, REG_TX_PAUSE(port), &mac->stats.TxPauseFrames);
|
||||
rmon_update(mac, REG_TX_UNDERRUN(port), &mac->stats.TxUnderrun);
|
||||
rmon_update(mac, REG_TX_SIZE_1519_TO_MAX(port),
|
||||
&mac->stats.TxJumboFramesOK);
|
||||
}
|
||||
|
||||
/*
|
||||
|
||||
@ -192,73 +192,84 @@
|
||||
#define REG_HDX(pn) CRA(0x1,pn,0x19) /* Half-duplex config */
|
||||
|
||||
/* Statistics */
|
||||
/* CRA(0x4,pn,reg) */
|
||||
/* reg below */
|
||||
/* pn = port number, 0-a, a = 10GbE */
|
||||
#define REG_RX_IN_BYTES(pn) CRA(0x4,pn,0x00) /* # Rx in octets */
|
||||
#define REG_RX_SYMBOL_CARRIER(pn) CRA(0x4,pn,0x01) /* Frames w/ symbol errors */
|
||||
#define REG_RX_PAUSE(pn) CRA(0x4,pn,0x02) /* # pause frames received */
|
||||
#define REG_RX_UNSUP_OPCODE(pn) CRA(0x4,pn,0x03) /* # control frames with unsupported opcode */
|
||||
#define REG_RX_OK_BYTES(pn) CRA(0x4,pn,0x04) /* # octets in good frames */
|
||||
#define REG_RX_BAD_BYTES(pn) CRA(0x4,pn,0x05) /* # octets in bad frames */
|
||||
#define REG_RX_UNICAST(pn) CRA(0x4,pn,0x06) /* # good unicast frames */
|
||||
#define REG_RX_MULTICAST(pn) CRA(0x4,pn,0x07) /* # good multicast frames */
|
||||
#define REG_RX_BROADCAST(pn) CRA(0x4,pn,0x08) /* # good broadcast frames */
|
||||
#define REG_CRC(pn) CRA(0x4,pn,0x09) /* # frames w/ bad CRC only */
|
||||
#define REG_RX_ALIGNMENT(pn) CRA(0x4,pn,0x0a) /* # frames w/ alignment err */
|
||||
#define REG_RX_UNDERSIZE(pn) CRA(0x4,pn,0x0b) /* # frames undersize */
|
||||
#define REG_RX_FRAGMENTS(pn) CRA(0x4,pn,0x0c) /* # frames undersize w/ crc err */
|
||||
#define REG_RX_IN_RANGE_LENGTH_ERROR(pn) CRA(0x4,pn,0x0d) /* # frames with length error */
|
||||
#define REG_RX_OUT_OF_RANGE_ERROR(pn) CRA(0x4,pn,0x0e) /* # frames with illegal length field */
|
||||
#define REG_RX_OVERSIZE(pn) CRA(0x4,pn,0x0f) /* # frames oversize */
|
||||
#define REG_RX_JABBERS(pn) CRA(0x4,pn,0x10) /* # frames oversize w/ crc err */
|
||||
#define REG_RX_SIZE_64(pn) CRA(0x4,pn,0x11) /* # frames 64 octets long */
|
||||
#define REG_RX_SIZE_65_TO_127(pn) CRA(0x4,pn,0x12) /* # frames 65-127 octets */
|
||||
#define REG_RX_SIZE_128_TO_255(pn) CRA(0x4,pn,0x13) /* # frames 128-255 */
|
||||
#define REG_RX_SIZE_256_TO_511(pn) CRA(0x4,pn,0x14) /* # frames 256-511 */
|
||||
#define REG_RX_SIZE_512_TO_1023(pn) CRA(0x4,pn,0x15) /* # frames 512-1023 */
|
||||
#define REG_RX_SIZE_1024_TO_1518(pn) CRA(0x4,pn,0x16) /* # frames 1024-1518 */
|
||||
#define REG_RX_SIZE_1519_TO_MAX(pn) CRA(0x4,pn,0x17) /* # frames 1519-max */
|
||||
|
||||
#define REG_TX_OUT_BYTES(pn) CRA(0x4,pn,0x18) /* # octets tx */
|
||||
#define REG_TX_PAUSE(pn) CRA(0x4,pn,0x19) /* # pause frames sent */
|
||||
#define REG_TX_OK_BYTES(pn) CRA(0x4,pn,0x1a) /* # octets tx OK */
|
||||
#define REG_TX_UNICAST(pn) CRA(0x4,pn,0x1b) /* # frames unicast */
|
||||
#define REG_TX_MULTICAST(pn) CRA(0x4,pn,0x1c) /* # frames multicast */
|
||||
#define REG_TX_BROADCAST(pn) CRA(0x4,pn,0x1d) /* # frames broadcast */
|
||||
#define REG_TX_MULTIPLE_COLL(pn) CRA(0x4,pn,0x1e) /* # frames tx after multiple collisions */
|
||||
#define REG_TX_LATE_COLL(pn) CRA(0x4,pn,0x1f) /* # late collisions detected */
|
||||
#define REG_TX_XCOLL(pn) CRA(0x4,pn,0x20) /* # frames lost, excessive collisions */
|
||||
#define REG_TX_DEFER(pn) CRA(0x4,pn,0x21) /* # frames deferred on first tx attempt */
|
||||
#define REG_TX_XDEFER(pn) CRA(0x4,pn,0x22) /* # frames excessively deferred */
|
||||
#define REG_TX_CSENSE(pn) CRA(0x4,pn,0x23) /* carrier sense errors at frame end */
|
||||
#define REG_TX_SIZE_64(pn) CRA(0x4,pn,0x24) /* # frames 64 octets long */
|
||||
#define REG_TX_SIZE_65_TO_127(pn) CRA(0x4,pn,0x25) /* # frames 65-127 octets */
|
||||
#define REG_TX_SIZE_128_TO_255(pn) CRA(0x4,pn,0x26) /* # frames 128-255 */
|
||||
#define REG_TX_SIZE_256_TO_511(pn) CRA(0x4,pn,0x27) /* # frames 256-511 */
|
||||
#define REG_TX_SIZE_512_TO_1023(pn) CRA(0x4,pn,0x28) /* # frames 512-1023 */
|
||||
#define REG_TX_SIZE_1024_TO_1518(pn) CRA(0x4,pn,0x29) /* # frames 1024-1518 */
|
||||
#define REG_TX_SIZE_1519_TO_MAX(pn) CRA(0x4,pn,0x2a) /* # frames 1519-max */
|
||||
#define REG_TX_SINGLE_COLL(pn) CRA(0x4,pn,0x2b) /* # frames tx after single collision */
|
||||
#define REG_TX_BACKOFF2(pn) CRA(0x4,pn,0x2c) /* # frames tx ok after 2 backoffs/collisions */
|
||||
#define REG_TX_BACKOFF3(pn) CRA(0x4,pn,0x2d) /* after 3 backoffs/collisions */
|
||||
#define REG_TX_BACKOFF4(pn) CRA(0x4,pn,0x2e) /* after 4 */
|
||||
#define REG_TX_BACKOFF5(pn) CRA(0x4,pn,0x2f) /* after 5 */
|
||||
#define REG_TX_BACKOFF6(pn) CRA(0x4,pn,0x30) /* after 6 */
|
||||
#define REG_TX_BACKOFF7(pn) CRA(0x4,pn,0x31) /* after 7 */
|
||||
#define REG_TX_BACKOFF8(pn) CRA(0x4,pn,0x32) /* after 8 */
|
||||
#define REG_TX_BACKOFF9(pn) CRA(0x4,pn,0x33) /* after 9 */
|
||||
#define REG_TX_BACKOFF10(pn) CRA(0x4,pn,0x34) /* after 10 */
|
||||
#define REG_TX_BACKOFF11(pn) CRA(0x4,pn,0x35) /* after 11 */
|
||||
#define REG_TX_BACKOFF12(pn) CRA(0x4,pn,0x36) /* after 12 */
|
||||
#define REG_TX_BACKOFF13(pn) CRA(0x4,pn,0x37) /* after 13 */
|
||||
#define REG_TX_BACKOFF14(pn) CRA(0x4,pn,0x38) /* after 14 */
|
||||
#define REG_TX_BACKOFF15(pn) CRA(0x4,pn,0x39) /* after 15 */
|
||||
#define REG_TX_UNDERRUN(pn) CRA(0x4,pn,0x3a) /* # frames dropped from underrun */
|
||||
#define REG_RX_XGMII_PROT_ERR CRA(0x4,0xa,0x3b) /* # protocol errors detected on XGMII interface */
|
||||
#define REG_RX_IPG_SHRINK(pn) CRA(0x4,pn,0x3c) /* # of IPG shrinks detected */
|
||||
enum {
|
||||
RxInBytes = 0x00, // # Rx in octets
|
||||
RxSymbolCarrier = 0x01, // Frames w/ symbol errors
|
||||
RxPause = 0x02, // # pause frames received
|
||||
RxUnsupOpcode = 0x03, // # control frames with unsupported opcode
|
||||
RxOkBytes = 0x04, // # octets in good frames
|
||||
RxBadBytes = 0x05, // # octets in bad frames
|
||||
RxUnicast = 0x06, // # good unicast frames
|
||||
RxMulticast = 0x07, // # good multicast frames
|
||||
RxBroadcast = 0x08, // # good broadcast frames
|
||||
Crc = 0x09, // # frames w/ bad CRC only
|
||||
RxAlignment = 0x0a, // # frames w/ alignment err
|
||||
RxUndersize = 0x0b, // # frames undersize
|
||||
RxFragments = 0x0c, // # frames undersize w/ crc err
|
||||
RxInRangeLengthError = 0x0d, // # frames with length error
|
||||
RxOutOfRangeError = 0x0e, // # frames with illegal length field
|
||||
RxOversize = 0x0f, // # frames oversize
|
||||
RxJabbers = 0x10, // # frames oversize w/ crc err
|
||||
RxSize64 = 0x11, // # frames 64 octets long
|
||||
RxSize65To127 = 0x12, // # frames 65-127 octets
|
||||
RxSize128To255 = 0x13, // # frames 128-255
|
||||
RxSize256To511 = 0x14, // # frames 256-511
|
||||
RxSize512To1023 = 0x15, // # frames 512-1023
|
||||
RxSize1024To1518 = 0x16, // # frames 1024-1518
|
||||
RxSize1519ToMax = 0x17, // # frames 1519-max
|
||||
|
||||
#define REG_STAT_STICKY1G(pn) CRA(0x4,pn,0x3e) /* tri-speed sticky bits */
|
||||
#define REG_STAT_STICKY10G CRA(0x4,0xa,0x3e) /* 10GbE sticky bits */
|
||||
#define REG_STAT_INIT(pn) CRA(0x4,pn,0x3f) /* Clear all statistics */
|
||||
TxOutBytes = 0x18, // # octets tx
|
||||
TxPause = 0x19, // # pause frames sent
|
||||
TxOkBytes = 0x1a, // # octets tx OK
|
||||
TxUnicast = 0x1b, // # frames unicast
|
||||
TxMulticast = 0x1c, // # frames multicast
|
||||
TxBroadcast = 0x1d, // # frames broadcast
|
||||
TxMultipleColl = 0x1e, // # frames tx after multiple collisions
|
||||
TxLateColl = 0x1f, // # late collisions detected
|
||||
TxXcoll = 0x20, // # frames lost, excessive collisions
|
||||
TxDefer = 0x21, // # frames deferred on first tx attempt
|
||||
TxXdefer = 0x22, // # frames excessively deferred
|
||||
TxCsense = 0x23, // carrier sense errors at frame end
|
||||
TxSize64 = 0x24, // # frames 64 octets long
|
||||
TxSize65To127 = 0x25, // # frames 65-127 octets
|
||||
TxSize128To255 = 0x26, // # frames 128-255
|
||||
TxSize256To511 = 0x27, // # frames 256-511
|
||||
TxSize512To1023 = 0x28, // # frames 512-1023
|
||||
TxSize1024To1518 = 0x29, // # frames 1024-1518
|
||||
TxSize1519ToMax = 0x2a, // # frames 1519-max
|
||||
TxSingleColl = 0x2b, // # frames tx after single collision
|
||||
TxBackoff2 = 0x2c, // # frames tx ok after 2 backoffs/collisions
|
||||
TxBackoff3 = 0x2d, // after 3 backoffs/collisions
|
||||
TxBackoff4 = 0x2e, // after 4
|
||||
TxBackoff5 = 0x2f, // after 5
|
||||
TxBackoff6 = 0x30, // after 6
|
||||
TxBackoff7 = 0x31, // after 7
|
||||
TxBackoff8 = 0x32, // after 8
|
||||
TxBackoff9 = 0x33, // after 9
|
||||
TxBackoff10 = 0x34, // after 10
|
||||
TxBackoff11 = 0x35, // after 11
|
||||
TxBackoff12 = 0x36, // after 12
|
||||
TxBackoff13 = 0x37, // after 13
|
||||
TxBackoff14 = 0x38, // after 14
|
||||
TxBackoff15 = 0x39, // after 15
|
||||
TxUnderrun = 0x3a, // # frames dropped from underrun
|
||||
// Hole. See REG_RX_XGMII_PROT_ERR below.
|
||||
RxIpgShrink = 0x3c, // # of IPG shrinks detected
|
||||
// Duplicate. See REG_STAT_STICKY10G below.
|
||||
StatSticky1G = 0x3e, // tri-speed sticky bits
|
||||
StatInit = 0x3f // Clear all statistics
|
||||
};
|
||||
|
||||
#define REG_RX_XGMII_PROT_ERR CRA(0x4,0xa,0x3b) /* # protocol errors detected on XGMII interface */
|
||||
#define REG_STAT_STICKY10G CRA(0x4,0xa,StatSticky1G) /* 10GbE sticky bits */
|
||||
|
||||
#define REG_RX_OK_BYTES(pn) CRA(0x4,pn,RxOkBytes)
|
||||
#define REG_RX_BAD_BYTES(pn) CRA(0x4,pn,RxBadBytes)
|
||||
#define REG_TX_OK_BYTES(pn) CRA(0x4,pn,TxOkBytes)
|
||||
|
||||
/* MII-Management Block registers */
|
||||
/* These are for MII-M interface 0, which is the bidirectional LVTTL one. If
|
||||
|
||||
Loading…
Reference in New Issue
Block a user