korg/linux
0
0
Fork 0
mirror of https://mirrors.bfsu.edu.cn/git/linux.git synced 2024-12-15 23:14:31 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'amd-xgbe-net'

Browse Source 
Tom Lendacky says:

====================
amd-xgbe: AMD XGBE driver fixes 2014-09-05

The following series of patches includes fixes to the driver.

- Proper access to 64 bit management counter registers
- Enable all management counter registers to generate an interrupt when
  the counter threshold is reached

This patch series is based on net.
====================

Signed-off-by: David S. Miller <davem@davemloft.net>
This commit is contained in:
David S. Miller 2014-09-05 22:37:36 -07:00
commit bc55dc63b2
1 changed files with 110 additions and 84 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

194
drivers/net/ethernet/amd/xgbe/xgbe-dev.c
View File

@ -509,8 +509,8 @@ static void xgbe_enable_mac_interrupts(struct xgbe_prv_data *pdata)
XGMAC_IOWRITE(pdata, MAC_IER, mac_ier);
/* Enable all counter interrupts */
XGMAC_IOWRITE_BITS(pdata, MMC_RIER, ALL_INTERRUPTS, 0xff);
XGMAC_IOWRITE_BITS(pdata, MMC_TIER, ALL_INTERRUPTS, 0xff);
XGMAC_IOWRITE_BITS(pdata, MMC_RIER, ALL_INTERRUPTS, 0xffffffff);
XGMAC_IOWRITE_BITS(pdata, MMC_TIER, ALL_INTERRUPTS, 0xffffffff);
}
static int xgbe_set_gmii_speed(struct xgbe_prv_data *pdata)
@ -1954,6 +1954,32 @@ static void xgbe_config_vlan_support(struct xgbe_prv_data *pdata)
xgbe_disable_rx_vlan_stripping(pdata);
}
static u64 xgbe_mmc_read(struct xgbe_prv_data *pdata, unsigned int reg_lo)
{
bool read_hi;
u64 val;
switch (reg_lo) {
/* These registers are always 64 bit */
case MMC_TXOCTETCOUNT_GB_LO:
case MMC_TXOCTETCOUNT_G_LO:
case MMC_RXOCTETCOUNT_GB_LO:
case MMC_RXOCTETCOUNT_G_LO:
read_hi = true;
break;
default:
read_hi = false;
};
val = XGMAC_IOREAD(pdata, reg_lo);
if (read_hi)
val |= ((u64)XGMAC_IOREAD(pdata, reg_lo + 4) << 32);
return val;
}
static void xgbe_tx_mmc_int(struct xgbe_prv_data *pdata)
{
struct xgbe_mmc_stats *stats = &pdata->mmc_stats;
@ -1961,75 +1987,75 @@ static void xgbe_tx_mmc_int(struct xgbe_prv_data *pdata)
if (XGMAC_GET_BITS(mmc_isr, MMC_TISR, TXOCTETCOUNT_GB))
stats->txoctetcount_gb +=
XGMAC_IOREAD(pdata, MMC_TXOCTETCOUNT_GB_LO);
xgbe_mmc_read(pdata, MMC_TXOCTETCOUNT_GB_LO);
if (XGMAC_GET_BITS(mmc_isr, MMC_TISR, TXFRAMECOUNT_GB))
stats->txframecount_gb +=
XGMAC_IOREAD(pdata, MMC_TXFRAMECOUNT_GB_LO);
xgbe_mmc_read(pdata, MMC_TXFRAMECOUNT_GB_LO);
if (XGMAC_GET_BITS(mmc_isr, MMC_TISR, TXBROADCASTFRAMES_G))
stats->txbroadcastframes_g +=
XGMAC_IOREAD(pdata, MMC_TXBROADCASTFRAMES_G_LO);
xgbe_mmc_read(pdata, MMC_TXBROADCASTFRAMES_G_LO);
if (XGMAC_GET_BITS(mmc_isr, MMC_TISR, TXMULTICASTFRAMES_G))
stats->txmulticastframes_g +=
XGMAC_IOREAD(pdata, MMC_TXMULTICASTFRAMES_G_LO);
xgbe_mmc_read(pdata, MMC_TXMULTICASTFRAMES_G_LO);
if (XGMAC_GET_BITS(mmc_isr, MMC_TISR, TX64OCTETS_GB))
stats->tx64octets_gb +=
XGMAC_IOREAD(pdata, MMC_TX64OCTETS_GB_LO);
xgbe_mmc_read(pdata, MMC_TX64OCTETS_GB_LO);
if (XGMAC_GET_BITS(mmc_isr, MMC_TISR, TX65TO127OCTETS_GB))
stats->tx65to127octets_gb +=
XGMAC_IOREAD(pdata, MMC_TX65TO127OCTETS_GB_LO);
xgbe_mmc_read(pdata, MMC_TX65TO127OCTETS_GB_LO);
if (XGMAC_GET_BITS(mmc_isr, MMC_TISR, TX128TO255OCTETS_GB))
stats->tx128to255octets_gb +=
XGMAC_IOREAD(pdata, MMC_TX128TO255OCTETS_GB_LO);
xgbe_mmc_read(pdata, MMC_TX128TO255OCTETS_GB_LO);
if (XGMAC_GET_BITS(mmc_isr, MMC_TISR, TX256TO511OCTETS_GB))
stats->tx256to511octets_gb +=
XGMAC_IOREAD(pdata, MMC_TX256TO511OCTETS_GB_LO);
xgbe_mmc_read(pdata, MMC_TX256TO511OCTETS_GB_LO);
if (XGMAC_GET_BITS(mmc_isr, MMC_TISR, TX512TO1023OCTETS_GB))
stats->tx512to1023octets_gb +=
XGMAC_IOREAD(pdata, MMC_TX512TO1023OCTETS_GB_LO);
xgbe_mmc_read(pdata, MMC_TX512TO1023OCTETS_GB_LO);
if (XGMAC_GET_BITS(mmc_isr, MMC_TISR, TX1024TOMAXOCTETS_GB))
stats->tx1024tomaxoctets_gb +=
XGMAC_IOREAD(pdata, MMC_TX1024TOMAXOCTETS_GB_LO);
xgbe_mmc_read(pdata, MMC_TX1024TOMAXOCTETS_GB_LO);
if (XGMAC_GET_BITS(mmc_isr, MMC_TISR, TXUNICASTFRAMES_GB))
stats->txunicastframes_gb +=
XGMAC_IOREAD(pdata, MMC_TXUNICASTFRAMES_GB_LO);
xgbe_mmc_read(pdata, MMC_TXUNICASTFRAMES_GB_LO);
if (XGMAC_GET_BITS(mmc_isr, MMC_TISR, TXMULTICASTFRAMES_GB))
stats->txmulticastframes_gb +=
XGMAC_IOREAD(pdata, MMC_TXMULTICASTFRAMES_GB_LO);
xgbe_mmc_read(pdata, MMC_TXMULTICASTFRAMES_GB_LO);
if (XGMAC_GET_BITS(mmc_isr, MMC_TISR, TXBROADCASTFRAMES_GB))
stats->txbroadcastframes_g +=
XGMAC_IOREAD(pdata, MMC_TXBROADCASTFRAMES_GB_LO);
xgbe_mmc_read(pdata, MMC_TXBROADCASTFRAMES_GB_LO);
if (XGMAC_GET_BITS(mmc_isr, MMC_TISR, TXUNDERFLOWERROR))
stats->txunderflowerror +=
XGMAC_IOREAD(pdata, MMC_TXUNDERFLOWERROR_LO);
xgbe_mmc_read(pdata, MMC_TXUNDERFLOWERROR_LO);
if (XGMAC_GET_BITS(mmc_isr, MMC_TISR, TXOCTETCOUNT_G))
stats->txoctetcount_g +=
XGMAC_IOREAD(pdata, MMC_TXOCTETCOUNT_G_LO);
xgbe_mmc_read(pdata, MMC_TXOCTETCOUNT_G_LO);
if (XGMAC_GET_BITS(mmc_isr, MMC_TISR, TXFRAMECOUNT_G))
stats->txframecount_g +=
XGMAC_IOREAD(pdata, MMC_TXFRAMECOUNT_G_LO);
xgbe_mmc_read(pdata, MMC_TXFRAMECOUNT_G_LO);
if (XGMAC_GET_BITS(mmc_isr, MMC_TISR, TXPAUSEFRAMES))
stats->txpauseframes +=
XGMAC_IOREAD(pdata, MMC_TXPAUSEFRAMES_LO);
xgbe_mmc_read(pdata, MMC_TXPAUSEFRAMES_LO);
if (XGMAC_GET_BITS(mmc_isr, MMC_TISR, TXVLANFRAMES_G))
stats->txvlanframes_g +=
XGMAC_IOREAD(pdata, MMC_TXVLANFRAMES_G_LO);
xgbe_mmc_read(pdata, MMC_TXVLANFRAMES_G_LO);
}
static void xgbe_rx_mmc_int(struct xgbe_prv_data *pdata)
@ -2039,95 +2065,95 @@ static void xgbe_rx_mmc_int(struct xgbe_prv_data *pdata)
if (XGMAC_GET_BITS(mmc_isr, MMC_RISR, RXFRAMECOUNT_GB))
stats->rxframecount_gb +=
XGMAC_IOREAD(pdata, MMC_RXFRAMECOUNT_GB_LO);
xgbe_mmc_read(pdata, MMC_RXFRAMECOUNT_GB_LO);
if (XGMAC_GET_BITS(mmc_isr, MMC_RISR, RXOCTETCOUNT_GB))
stats->rxoctetcount_gb +=
XGMAC_IOREAD(pdata, MMC_RXOCTETCOUNT_GB_LO);
xgbe_mmc_read(pdata, MMC_RXOCTETCOUNT_GB_LO);
if (XGMAC_GET_BITS(mmc_isr, MMC_RISR, RXOCTETCOUNT_G))
stats->rxoctetcount_g +=
XGMAC_IOREAD(pdata, MMC_RXOCTETCOUNT_G_LO);
xgbe_mmc_read(pdata, MMC_RXOCTETCOUNT_G_LO);
if (XGMAC_GET_BITS(mmc_isr, MMC_RISR, RXBROADCASTFRAMES_G))
stats->rxbroadcastframes_g +=
XGMAC_IOREAD(pdata, MMC_RXBROADCASTFRAMES_G_LO);
xgbe_mmc_read(pdata, MMC_RXBROADCASTFRAMES_G_LO);
if (XGMAC_GET_BITS(mmc_isr, MMC_RISR, RXMULTICASTFRAMES_G))
stats->rxmulticastframes_g +=
XGMAC_IOREAD(pdata, MMC_RXMULTICASTFRAMES_G_LO);
xgbe_mmc_read(pdata, MMC_RXMULTICASTFRAMES_G_LO);
if (XGMAC_GET_BITS(mmc_isr, MMC_RISR, RXCRCERROR))
stats->rxcrcerror +=
XGMAC_IOREAD(pdata, MMC_RXCRCERROR_LO);
xgbe_mmc_read(pdata, MMC_RXCRCERROR_LO);
if (XGMAC_GET_BITS(mmc_isr, MMC_RISR, RXRUNTERROR))
stats->rxrunterror +=
XGMAC_IOREAD(pdata, MMC_RXRUNTERROR);
xgbe_mmc_read(pdata, MMC_RXRUNTERROR);
if (XGMAC_GET_BITS(mmc_isr, MMC_RISR, RXJABBERERROR))
stats->rxjabbererror +=
XGMAC_IOREAD(pdata, MMC_RXJABBERERROR);
xgbe_mmc_read(pdata, MMC_RXJABBERERROR);
if (XGMAC_GET_BITS(mmc_isr, MMC_RISR, RXUNDERSIZE_G))
stats->rxundersize_g +=
XGMAC_IOREAD(pdata, MMC_RXUNDERSIZE_G);
xgbe_mmc_read(pdata, MMC_RXUNDERSIZE_G);
if (XGMAC_GET_BITS(mmc_isr, MMC_RISR, RXOVERSIZE_G))
stats->rxoversize_g +=
XGMAC_IOREAD(pdata, MMC_RXOVERSIZE_G);
xgbe_mmc_read(pdata, MMC_RXOVERSIZE_G);
if (XGMAC_GET_BITS(mmc_isr, MMC_RISR, RX64OCTETS_GB))
stats->rx64octets_gb +=
XGMAC_IOREAD(pdata, MMC_RX64OCTETS_GB_LO);
xgbe_mmc_read(pdata, MMC_RX64OCTETS_GB_LO);
if (XGMAC_GET_BITS(mmc_isr, MMC_RISR, RX65TO127OCTETS_GB))
stats->rx65to127octets_gb +=
XGMAC_IOREAD(pdata, MMC_RX65TO127OCTETS_GB_LO);
xgbe_mmc_read(pdata, MMC_RX65TO127OCTETS_GB_LO);
if (XGMAC_GET_BITS(mmc_isr, MMC_RISR, RX128TO255OCTETS_GB))
stats->rx128to255octets_gb +=
XGMAC_IOREAD(pdata, MMC_RX128TO255OCTETS_GB_LO);
xgbe_mmc_read(pdata, MMC_RX128TO255OCTETS_GB_LO);
if (XGMAC_GET_BITS(mmc_isr, MMC_RISR, RX256TO511OCTETS_GB))
stats->rx256to511octets_gb +=
XGMAC_IOREAD(pdata, MMC_RX256TO511OCTETS_GB_LO);
xgbe_mmc_read(pdata, MMC_RX256TO511OCTETS_GB_LO);
if (XGMAC_GET_BITS(mmc_isr, MMC_RISR, RX512TO1023OCTETS_GB))
stats->rx512to1023octets_gb +=
XGMAC_IOREAD(pdata, MMC_RX512TO1023OCTETS_GB_LO);
xgbe_mmc_read(pdata, MMC_RX512TO1023OCTETS_GB_LO);
if (XGMAC_GET_BITS(mmc_isr, MMC_RISR, RX1024TOMAXOCTETS_GB))
stats->rx1024tomaxoctets_gb +=
XGMAC_IOREAD(pdata, MMC_RX1024TOMAXOCTETS_GB_LO);
xgbe_mmc_read(pdata, MMC_RX1024TOMAXOCTETS_GB_LO);
if (XGMAC_GET_BITS(mmc_isr, MMC_RISR, RXUNICASTFRAMES_G))
stats->rxunicastframes_g +=
XGMAC_IOREAD(pdata, MMC_RXUNICASTFRAMES_G_LO);
xgbe_mmc_read(pdata, MMC_RXUNICASTFRAMES_G_LO);
if (XGMAC_GET_BITS(mmc_isr, MMC_RISR, RXLENGTHERROR))
stats->rxlengtherror +=
XGMAC_IOREAD(pdata, MMC_RXLENGTHERROR_LO);
xgbe_mmc_read(pdata, MMC_RXLENGTHERROR_LO);
if (XGMAC_GET_BITS(mmc_isr, MMC_RISR, RXOUTOFRANGETYPE))
stats->rxoutofrangetype +=
XGMAC_IOREAD(pdata, MMC_RXOUTOFRANGETYPE_LO);
xgbe_mmc_read(pdata, MMC_RXOUTOFRANGETYPE_LO);
if (XGMAC_GET_BITS(mmc_isr, MMC_RISR, RXPAUSEFRAMES))
stats->rxpauseframes +=
XGMAC_IOREAD(pdata, MMC_RXPAUSEFRAMES_LO);
xgbe_mmc_read(pdata, MMC_RXPAUSEFRAMES_LO);
if (XGMAC_GET_BITS(mmc_isr, MMC_RISR, RXFIFOOVERFLOW))
stats->rxfifooverflow +=
XGMAC_IOREAD(pdata, MMC_RXFIFOOVERFLOW_LO);
xgbe_mmc_read(pdata, MMC_RXFIFOOVERFLOW_LO);
if (XGMAC_GET_BITS(mmc_isr, MMC_RISR, RXVLANFRAMES_GB))
stats->rxvlanframes_gb +=
XGMAC_IOREAD(pdata, MMC_RXVLANFRAMES_GB_LO);
xgbe_mmc_read(pdata, MMC_RXVLANFRAMES_GB_LO);
if (XGMAC_GET_BITS(mmc_isr, MMC_RISR, RXWATCHDOGERROR))
stats->rxwatchdogerror +=
XGMAC_IOREAD(pdata, MMC_RXWATCHDOGERROR);
xgbe_mmc_read(pdata, MMC_RXWATCHDOGERROR);
}
static void xgbe_read_mmc_stats(struct xgbe_prv_data *pdata)
@ -2138,127 +2164,127 @@ static void xgbe_read_mmc_stats(struct xgbe_prv_data *pdata)
XGMAC_IOWRITE_BITS(pdata, MMC_CR, MCF, 1);
stats->txoctetcount_gb +=
XGMAC_IOREAD(pdata, MMC_TXOCTETCOUNT_GB_LO);
xgbe_mmc_read(pdata, MMC_TXOCTETCOUNT_GB_LO);
stats->txframecount_gb +=
XGMAC_IOREAD(pdata, MMC_TXFRAMECOUNT_GB_LO);
xgbe_mmc_read(pdata, MMC_TXFRAMECOUNT_GB_LO);
stats->txbroadcastframes_g +=
XGMAC_IOREAD(pdata, MMC_TXBROADCASTFRAMES_G_LO);
xgbe_mmc_read(pdata, MMC_TXBROADCASTFRAMES_G_LO);
stats->txmulticastframes_g +=
XGMAC_IOREAD(pdata, MMC_TXMULTICASTFRAMES_G_LO);
xgbe_mmc_read(pdata, MMC_TXMULTICASTFRAMES_G_LO);
stats->tx64octets_gb +=
XGMAC_IOREAD(pdata, MMC_TX64OCTETS_GB_LO);
xgbe_mmc_read(pdata, MMC_TX64OCTETS_GB_LO);
stats->tx65to127octets_gb +=
XGMAC_IOREAD(pdata, MMC_TX65TO127OCTETS_GB_LO);
xgbe_mmc_read(pdata, MMC_TX65TO127OCTETS_GB_LO);
stats->tx128to255octets_gb +=
XGMAC_IOREAD(pdata, MMC_TX128TO255OCTETS_GB_LO);
xgbe_mmc_read(pdata, MMC_TX128TO255OCTETS_GB_LO);
stats->tx256to511octets_gb +=
XGMAC_IOREAD(pdata, MMC_TX256TO511OCTETS_GB_LO);
xgbe_mmc_read(pdata, MMC_TX256TO511OCTETS_GB_LO);
stats->tx512to1023octets_gb +=
XGMAC_IOREAD(pdata, MMC_TX512TO1023OCTETS_GB_LO);
xgbe_mmc_read(pdata, MMC_TX512TO1023OCTETS_GB_LO);
stats->tx1024tomaxoctets_gb +=
XGMAC_IOREAD(pdata, MMC_TX1024TOMAXOCTETS_GB_LO);
xgbe_mmc_read(pdata, MMC_TX1024TOMAXOCTETS_GB_LO);
stats->txunicastframes_gb +=
XGMAC_IOREAD(pdata, MMC_TXUNICASTFRAMES_GB_LO);
xgbe_mmc_read(pdata, MMC_TXUNICASTFRAMES_GB_LO);
stats->txmulticastframes_gb +=
XGMAC_IOREAD(pdata, MMC_TXMULTICASTFRAMES_GB_LO);
xgbe_mmc_read(pdata, MMC_TXMULTICASTFRAMES_GB_LO);
stats->txbroadcastframes_g +=
XGMAC_IOREAD(pdata, MMC_TXBROADCASTFRAMES_GB_LO);
xgbe_mmc_read(pdata, MMC_TXBROADCASTFRAMES_GB_LO);
stats->txunderflowerror +=
XGMAC_IOREAD(pdata, MMC_TXUNDERFLOWERROR_LO);
xgbe_mmc_read(pdata, MMC_TXUNDERFLOWERROR_LO);
stats->txoctetcount_g +=
XGMAC_IOREAD(pdata, MMC_TXOCTETCOUNT_G_LO);
xgbe_mmc_read(pdata, MMC_TXOCTETCOUNT_G_LO);
stats->txframecount_g +=
XGMAC_IOREAD(pdata, MMC_TXFRAMECOUNT_G_LO);
xgbe_mmc_read(pdata, MMC_TXFRAMECOUNT_G_LO);
stats->txpauseframes +=
XGMAC_IOREAD(pdata, MMC_TXPAUSEFRAMES_LO);
xgbe_mmc_read(pdata, MMC_TXPAUSEFRAMES_LO);
stats->txvlanframes_g +=
XGMAC_IOREAD(pdata, MMC_TXVLANFRAMES_G_LO);
xgbe_mmc_read(pdata, MMC_TXVLANFRAMES_G_LO);
stats->rxframecount_gb +=
XGMAC_IOREAD(pdata, MMC_RXFRAMECOUNT_GB_LO);
xgbe_mmc_read(pdata, MMC_RXFRAMECOUNT_GB_LO);
stats->rxoctetcount_gb +=
XGMAC_IOREAD(pdata, MMC_RXOCTETCOUNT_GB_LO);
xgbe_mmc_read(pdata, MMC_RXOCTETCOUNT_GB_LO);
stats->rxoctetcount_g +=
XGMAC_IOREAD(pdata, MMC_RXOCTETCOUNT_G_LO);
xgbe_mmc_read(pdata, MMC_RXOCTETCOUNT_G_LO);
stats->rxbroadcastframes_g +=
XGMAC_IOREAD(pdata, MMC_RXBROADCASTFRAMES_G_LO);
xgbe_mmc_read(pdata, MMC_RXBROADCASTFRAMES_G_LO);
stats->rxmulticastframes_g +=
XGMAC_IOREAD(pdata, MMC_RXMULTICASTFRAMES_G_LO);
xgbe_mmc_read(pdata, MMC_RXMULTICASTFRAMES_G_LO);
stats->rxcrcerror +=
XGMAC_IOREAD(pdata, MMC_RXCRCERROR_LO);
xgbe_mmc_read(pdata, MMC_RXCRCERROR_LO);
stats->rxrunterror +=
XGMAC_IOREAD(pdata, MMC_RXRUNTERROR);
xgbe_mmc_read(pdata, MMC_RXRUNTERROR);
stats->rxjabbererror +=
XGMAC_IOREAD(pdata, MMC_RXJABBERERROR);
xgbe_mmc_read(pdata, MMC_RXJABBERERROR);
stats->rxundersize_g +=
XGMAC_IOREAD(pdata, MMC_RXUNDERSIZE_G);
xgbe_mmc_read(pdata, MMC_RXUNDERSIZE_G);
stats->rxoversize_g +=
XGMAC_IOREAD(pdata, MMC_RXOVERSIZE_G);
xgbe_mmc_read(pdata, MMC_RXOVERSIZE_G);
stats->rx64octets_gb +=
XGMAC_IOREAD(pdata, MMC_RX64OCTETS_GB_LO);
xgbe_mmc_read(pdata, MMC_RX64OCTETS_GB_LO);
stats->rx65to127octets_gb +=
XGMAC_IOREAD(pdata, MMC_RX65TO127OCTETS_GB_LO);
xgbe_mmc_read(pdata, MMC_RX65TO127OCTETS_GB_LO);
stats->rx128to255octets_gb +=
XGMAC_IOREAD(pdata, MMC_RX128TO255OCTETS_GB_LO);
xgbe_mmc_read(pdata, MMC_RX128TO255OCTETS_GB_LO);
stats->rx256to511octets_gb +=
XGMAC_IOREAD(pdata, MMC_RX256TO511OCTETS_GB_LO);
xgbe_mmc_read(pdata, MMC_RX256TO511OCTETS_GB_LO);
stats->rx512to1023octets_gb +=
XGMAC_IOREAD(pdata, MMC_RX512TO1023OCTETS_GB_LO);
xgbe_mmc_read(pdata, MMC_RX512TO1023OCTETS_GB_LO);
stats->rx1024tomaxoctets_gb +=
XGMAC_IOREAD(pdata, MMC_RX1024TOMAXOCTETS_GB_LO);
xgbe_mmc_read(pdata, MMC_RX1024TOMAXOCTETS_GB_LO);
stats->rxunicastframes_g +=
XGMAC_IOREAD(pdata, MMC_RXUNICASTFRAMES_G_LO);
xgbe_mmc_read(pdata, MMC_RXUNICASTFRAMES_G_LO);
stats->rxlengtherror +=
XGMAC_IOREAD(pdata, MMC_RXLENGTHERROR_LO);
xgbe_mmc_read(pdata, MMC_RXLENGTHERROR_LO);
stats->rxoutofrangetype +=
XGMAC_IOREAD(pdata, MMC_RXOUTOFRANGETYPE_LO);
xgbe_mmc_read(pdata, MMC_RXOUTOFRANGETYPE_LO);
stats->rxpauseframes +=
XGMAC_IOREAD(pdata, MMC_RXPAUSEFRAMES_LO);
xgbe_mmc_read(pdata, MMC_RXPAUSEFRAMES_LO);
stats->rxfifooverflow +=
XGMAC_IOREAD(pdata, MMC_RXFIFOOVERFLOW_LO);
xgbe_mmc_read(pdata, MMC_RXFIFOOVERFLOW_LO);
stats->rxvlanframes_gb +=
XGMAC_IOREAD(pdata, MMC_RXVLANFRAMES_GB_LO);
xgbe_mmc_read(pdata, MMC_RXVLANFRAMES_GB_LO);
stats->rxwatchdogerror +=
XGMAC_IOREAD(pdata, MMC_RXWATCHDOGERROR);
xgbe_mmc_read(pdata, MMC_RXWATCHDOGERROR);
/* Un-freeze counters */
XGMAC_IOWRITE_BITS(pdata, MMC_CR, MCF, 0);