The sun8i MAC drops packets with a bad IP or transport checksum before packet sockets or the protocol stack can see them, even with RX checksum offload disabled. Its error-forwarding bit controls Ethernet and IP errors together. Enable error forwarding and decode the sun8i RX status in both receive paths. Give checksum failures and unchecked packets to the stack with CHECKSUM_NONE. Continue to discard Ethernet errors, incomplete frames and lengths that cannot fit in the receive buffer. Address filter and VLAN indications are not checksum errors. Keep the hardware checker running whenever the receiver is enabled. Turning RX checksum reporting back on can then use the result already recorded in queued descriptors without flushing the ring. Fixes: 9f93ac8d4085 ("net-next: stmmac: Add dwmac-sun8i") Signed-off-by: James Hilliard --- drivers/net/ethernet/stmicro/stmmac/common.h | 2 + drivers/net/ethernet/stmicro/stmmac/dwmac-sun8i.c | 98 ++++++++++++++++++++--- drivers/net/ethernet/stmicro/stmmac/hwif.h | 2 - drivers/net/ethernet/stmicro/stmmac/stmmac_main.c | 7 +- 4 files changed, 94 insertions(+), 15 deletions(-) diff --git a/drivers/net/ethernet/stmicro/stmmac/common.h b/drivers/net/ethernet/stmicro/stmmac/common.h index a972bee66504..706feb7bcbed 100644 --- a/drivers/net/ethernet/stmicro/stmmac/common.h +++ b/drivers/net/ethernet/stmicro/stmmac/common.h @@ -615,6 +615,8 @@ struct mii_regs { struct mac_device_info { const struct stmmac_ops *mac; const struct stmmac_desc_ops *desc; + /* Defaults to the descriptor format's decoder unless the MAC overrides it. */ + int (*rx_status)(struct stmmac_extra_stats *x, struct dma_desc *p); const struct stmmac_dma_ops *dma; const struct stmmac_mode_ops *mode; const struct stmmac_hwtimestamp *ptp; diff --git a/drivers/net/ethernet/stmicro/stmmac/dwmac-sun8i.c b/drivers/net/ethernet/stmicro/stmmac/dwmac-sun8i.c index 2ece7ba9dd73..0ad2203f76c3 100644 --- a/drivers/net/ethernet/stmicro/stmmac/dwmac-sun8i.c +++ b/drivers/net/ethernet/stmicro/stmmac/dwmac-sun8i.c @@ -5,6 +5,7 @@ * Copyright (C) 2017 Corentin Labbe */ +#include #include #include #include @@ -197,6 +198,7 @@ static const struct emac_variant emac_variant_h616_emac1 = { /* Used in RX_CTL1*/ #define EMAC_RX_MD BIT(1) +#define EMAC_RX_ERR_FRM BIT(3) #define EMAC_RX_TH_MASK GENMASK(5, 4) #define EMAC_RX_TH_32 0 #define EMAC_RX_TH_64 (0x1 << 4) @@ -644,6 +646,9 @@ static void sun8i_dwmac_core_init(struct mac_device_info *hw, v = (8 << EMAC_BURSTLEN_SHIFT); /* burst len */ writel(v, ioaddr + EMAC_BASIC_CTL1); + + /* Forward checksum failures to software before starting RX. */ + writel(EMAC_RX_ERR_FRM, ioaddr + EMAC_RX_CTL1); } static void sun8i_dwmac_set_mac(void __iomem *ioaddr, bool enable) @@ -654,7 +659,7 @@ static void sun8i_dwmac_set_mac(void __iomem *ioaddr, bool enable) r = readl(ioaddr + EMAC_RX_CTL0); if (enable) { t |= EMAC_TX_TRANSMITTER_EN; - r |= EMAC_RX_RECEIVER_EN; + r |= EMAC_RX_RECEIVER_EN | EMAC_RX_DO_CRC; } else { t &= ~EMAC_TX_TRANSMITTER_EN; r &= ~EMAC_RX_RECEIVER_EN; @@ -698,16 +703,9 @@ static void sun8i_dwmac_get_umac_addr(struct mac_device_info *hw, EMAC_MACADDR_LO(reg_n)); } -/* caution this function must return non 0 to work */ -static int sun8i_dwmac_rx_ipc_enable(struct mac_device_info *hw) +static int sun8i_dwmac_rx_ipc(struct mac_device_info *hw) { - void __iomem *ioaddr = hw->pcsr; - u32 v; - - v = readl(ioaddr + EMAC_RX_CTL0); - v |= EMAC_RX_DO_CRC; - writel(v, ioaddr + EMAC_RX_CTL0); - + /* The receiver always records the checksum result, even with RXCSUM off. */ return 1; } @@ -1053,7 +1051,7 @@ static const struct stmmac_ops sun8i_dwmac_ops = { .core_init = sun8i_dwmac_core_init, .set_mac = sun8i_dwmac_set_mac, .dump_regs = sun8i_dwmac_dump_mac_regs, - .rx_ipc = sun8i_dwmac_rx_ipc_enable, + .rx_ipc = sun8i_dwmac_rx_ipc, .set_filter = sun8i_dwmac_set_filter, .flow_ctrl = sun8i_dwmac_flow_ctrl, .set_umac_addr = sun8i_dwmac_set_umac_addr, @@ -1061,6 +1059,83 @@ static const struct stmmac_ops sun8i_dwmac_ops = { .set_mac_loopback = sun8i_dwmac_set_mac_loopback, }; +static void sun8i_dwmac_rx_error_stats(struct stmmac_extra_stats *x, u32 status) +{ + if (status & RDES0_DESCRIPTOR_ERROR) + x->rx_desc++; + if (status & RDES0_OVERFLOW_ERROR) + x->overflow_error++; + if (status & RDES0_RECEIVE_WATCHDOG) + x->rx_watchdog++; + if (status & RDES0_SA_FILTER_FAIL) + x->sa_filter_fail++; + if ((status & RDES0_FRAME_TYPE) && (status & RDES0_IPC_CSUM_ERROR)) + x->ipc_csum_error++; + if (status & RDES0_COLLISION) + x->rx_collision++; + if (status & RDES0_CRC_ERROR) + x->rx_crc_errors++; + if (status & RDES0_MII_ERROR) + x->rx_mii++; + if (status & RDES0_LENGTH_ERROR) + x->rx_length++; +} + +static int sun8i_dwmac_rx_status(struct stmmac_extra_stats *x, struct dma_desc *p) +{ + const u32 csum_mask = RDES0_IPC_CSUM_ERROR | RDES0_PAYLOAD_CSUM_ERR; + const u32 dma_errors = RDES0_DESCRIPTOR_ERROR | RDES0_OVERFLOW_ERROR; + const u32 wire_errors = RDES0_CRC_ERROR | RDES0_MII_ERROR | + RDES0_RECEIVE_WATCHDOG | RDES0_COLLISION | + RDES0_LENGTH_ERROR; + u32 status = le32_to_cpu(READ_ONCE(p->des0)); + u32 len = FIELD_GET(RDES0_FRAME_LEN_MASK, status); + bool runt = len < ETH_ZLEN + ETH_FCS_LEN; + + if (unlikely(status & RDES0_OWN)) + return dma_own; + if (unlikely(!(status & RDES0_LAST_DESCRIPTOR))) + return discard_frame | rx_not_ls; + if (unlikely(!(status & RDES0_FIRST_DESCRIPTOR))) { + x->rx_length++; + return discard_frame; + } + +#ifdef STMMAC_VLAN_TAG_USED + if (status & RDES0_VLAN_TAG) + x->vlan_tag++; +#endif + if (unlikely(status & RDES0_DRIBBLING)) + x->dribbling_bit++; + if (unlikely(status & (RDES0_ERROR_SUMMARY | wire_errors | dma_errors))) { + sun8i_dwmac_rx_error_stats(x, status); + if (status & dma_errors) + return discard_frame; + /* An unexplained error summary is not a checksum verdict. */ + if (!(status & wire_errors) && + (!(status & RDES0_FRAME_TYPE) || !(status & csum_mask))) + return discard_frame; + } + + /* One buffer per chain descriptor; the reported length includes FCS. */ + if (unlikely(len < ETH_HLEN + ETH_FCS_LEN || + len > FIELD_GET(RDES1_BUFFER1_SIZE_MASK, le32_to_cpu(p->des1)))) { + x->rx_desc++; + return discard_frame; + } + if (unlikely(runt || (status & wire_errors))) { + if (runt && !(status & RDES0_LENGTH_ERROR)) + x->rx_length++; + return discard_frame; + } + + /* Only a checked IP frame is eligible for CHECKSUM_UNNECESSARY. */ + if (!(status & RDES0_FRAME_TYPE) || (status & (csum_mask | RDES0_DRIBBLING))) + return csum_none; + + return good_frame; +} + static int sun8i_dwmac_setup(void *ppriv, struct mac_device_info *mac) { struct stmmac_priv *priv = ppriv; @@ -1068,6 +1143,7 @@ static int sun8i_dwmac_setup(void *ppriv, struct mac_device_info *mac) mac->pcsr = priv->ioaddr; mac->mac = &sun8i_dwmac_ops; mac->dma = &sun8i_dwmac_dma_ops; + mac->rx_status = sun8i_dwmac_rx_status; priv->dev->priv_flags |= IFF_UNICAST_FLT; diff --git a/drivers/net/ethernet/stmicro/stmmac/hwif.h b/drivers/net/ethernet/stmicro/stmmac/hwif.h index 8ae95e91a36a..047d809b8b88 100644 --- a/drivers/net/ethernet/stmicro/stmmac/hwif.h +++ b/drivers/net/ethernet/stmicro/stmmac/hwif.h @@ -125,8 +125,6 @@ struct stmmac_desc_ops { stmmac_do_void_callback(__priv, desc, set_rx_owner, __args) #define stmmac_get_rx_frame_len(__priv, __args...) \ stmmac_do_callback(__priv, desc, get_rx_frame_len, __args) -#define stmmac_rx_status(__priv, __args...) \ - stmmac_do_callback(__priv, desc, rx_status, __args) #define stmmac_rx_extended_status(__priv, __args...) \ stmmac_do_callback(__priv, desc, rx_extended_status, __args) #define stmmac_enable_tx_timestamp(__priv, __args...) \ diff --git a/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c b/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c index f256244ce0d1..2f33fc0126b1 100644 --- a/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c +++ b/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c @@ -5775,7 +5775,7 @@ static int stmmac_rx_zc(struct stmmac_priv *priv, int limit, u32 queue) p = stmmac_get_rx_desc(priv, rx_q, entry); /* read the status of the incoming frame */ - status = stmmac_rx_status(priv, &priv->xstats, p); + status = priv->hw->rx_status(&priv->xstats, p); /* check if managed by the DMA otherwise go ahead */ if (unlikely(status & dma_own)) break; @@ -5978,7 +5978,7 @@ static int stmmac_rx(struct stmmac_priv *priv, int limit, u32 queue) p = stmmac_get_rx_desc(priv, rx_q, entry); /* read the status of the incoming frame */ - status = stmmac_rx_status(priv, &priv->xstats, p); + status = priv->hw->rx_status(&priv->xstats, p); /* check if managed by the DMA otherwise go ahead */ if (unlikely(status & dma_own)) break; @@ -7809,6 +7809,9 @@ static int stmmac_hw_init(struct stmmac_priv *priv) return ret; } + if (!priv->hw->rx_status) + priv->hw->rx_status = priv->hw->desc->rx_status; + /* Set alternate descriptor size (which tells the hardware that * descriptors are 8 32-bit words) when using extended descriptors * with ring mode. Only applicable for pre-v4.0 cores. Platform glue -- 2.53.0