net: macb: Limit maximum GEM TX length in TSO

[linux.git] / drivers / net / ethernet / cadence / macb_main.c

diff --git a/drivers/net/ethernet/cadence/macb_main.c b/drivers/net/ethernet/cadence/macb_main.c
index c5ee363ca5dc36f2512d3acabc401ceab3b968e2..4508f0d150da95d8e838d0ead806e8ef74794cc5 100644 (file)
--- a/drivers/net/ethernet/cadence/macb_main.c
+++ b/drivers/net/ethernet/cadence/macb_main.c
@@ -73,7 +73,11 @@ struct sifive_fu540_macb_mgmt {
 /* Max length of transmit frame must be a multiple of 8 bytes */
 #define MACB_TX_LEN_ALIGN      8
 #define MACB_MAX_TX_LEN                ((unsigned int)((1 << MACB_TX_FRMLEN_SIZE) - 1) & ~((unsigned int)(MACB_TX_LEN_ALIGN - 1)))
-#define GEM_MAX_TX_LEN         ((unsigned int)((1 << GEM_TX_FRMLEN_SIZE) - 1) & ~((unsigned int)(MACB_TX_LEN_ALIGN - 1)))
+/* Limit maximum TX length as per Cadence TSO errata. This is to avoid a
+ * false amba_error in TX path from the DMA assuming there is not enough
+ * space in the SRAM (16KB) even when there is.
+ */
+#define GEM_MAX_TX_LEN         (unsigned int)(0x3FC0)
 
 #define GEM_MTU_MIN_SIZE       ETH_MIN_MTU
 #define MACB_NETIF_LSO         NETIF_F_TSO
@@ -337,11 +341,30 @@ static int macb_mdio_read(struct mii_bus *bus, int mii_id, int regnum)
        if (status < 0)
                goto mdio_read_exit;
 
-       macb_writel(bp, MAN, (MACB_BF(SOF, MACB_MAN_SOF)
-                             | MACB_BF(RW, MACB_MAN_READ)
-                             | MACB_BF(PHYA, mii_id)
-                             | MACB_BF(REGA, regnum)
-                             | MACB_BF(CODE, MACB_MAN_CODE)));
+       if (regnum & MII_ADDR_C45) {
+               macb_writel(bp, MAN, (MACB_BF(SOF, MACB_MAN_C45_SOF)
+                           | MACB_BF(RW, MACB_MAN_C45_ADDR)
+                           | MACB_BF(PHYA, mii_id)
+                           | MACB_BF(REGA, (regnum >> 16) & 0x1F)
+                           | MACB_BF(DATA, regnum & 0xFFFF)
+                           | MACB_BF(CODE, MACB_MAN_C45_CODE)));
+
+               status = macb_mdio_wait_for_idle(bp);
+               if (status < 0)
+                       goto mdio_read_exit;
+
+               macb_writel(bp, MAN, (MACB_BF(SOF, MACB_MAN_C45_SOF)
+                           | MACB_BF(RW, MACB_MAN_C45_READ)
+                           | MACB_BF(PHYA, mii_id)
+                           | MACB_BF(REGA, (regnum >> 16) & 0x1F)
+                           | MACB_BF(CODE, MACB_MAN_C45_CODE)));
+       } else {
+               macb_writel(bp, MAN, (MACB_BF(SOF, MACB_MAN_C22_SOF)
+                               | MACB_BF(RW, MACB_MAN_C22_READ)
+                               | MACB_BF(PHYA, mii_id)
+                               | MACB_BF(REGA, regnum)
+                               | MACB_BF(CODE, MACB_MAN_C22_CODE)));
+       }
 
        status = macb_mdio_wait_for_idle(bp);
        if (status < 0)
@@ -370,12 +393,32 @@ static int macb_mdio_write(struct mii_bus *bus, int mii_id, int regnum,
        if (status < 0)
                goto mdio_write_exit;
 
-       macb_writel(bp, MAN, (MACB_BF(SOF, MACB_MAN_SOF)
-                             | MACB_BF(RW, MACB_MAN_WRITE)
-                             | MACB_BF(PHYA, mii_id)
-                             | MACB_BF(REGA, regnum)
-                             | MACB_BF(CODE, MACB_MAN_CODE)
-                             | MACB_BF(DATA, value)));
+       if (regnum & MII_ADDR_C45) {
+               macb_writel(bp, MAN, (MACB_BF(SOF, MACB_MAN_C45_SOF)
+                           | MACB_BF(RW, MACB_MAN_C45_ADDR)
+                           | MACB_BF(PHYA, mii_id)
+                           | MACB_BF(REGA, (regnum >> 16) & 0x1F)
+                           | MACB_BF(DATA, regnum & 0xFFFF)
+                           | MACB_BF(CODE, MACB_MAN_C45_CODE)));
+
+               status = macb_mdio_wait_for_idle(bp);
+               if (status < 0)
+                       goto mdio_write_exit;
+
+               macb_writel(bp, MAN, (MACB_BF(SOF, MACB_MAN_C45_SOF)
+                           | MACB_BF(RW, MACB_MAN_C45_WRITE)
+                           | MACB_BF(PHYA, mii_id)
+                           | MACB_BF(REGA, (regnum >> 16) & 0x1F)
+                           | MACB_BF(CODE, MACB_MAN_C45_CODE)
+                           | MACB_BF(DATA, value)));
+       } else {
+               macb_writel(bp, MAN, (MACB_BF(SOF, MACB_MAN_C22_SOF)
+                               | MACB_BF(RW, MACB_MAN_C22_WRITE)
+                               | MACB_BF(PHYA, mii_id)
+                               | MACB_BF(REGA, regnum)
+                               | MACB_BF(CODE, MACB_MAN_C22_CODE)
+                               | MACB_BF(DATA, value)));
+       }
 
        status = macb_mdio_wait_for_idle(bp);
        if (status < 0)
@@ -611,21 +654,24 @@ static const struct phylink_mac_ops macb_phylink_ops = {
        .mac_link_up = macb_mac_link_up,
 };
 
+static bool macb_phy_handle_exists(struct device_node *dn)
+{
+       dn = of_parse_phandle(dn, "phy-handle", 0);
+       of_node_put(dn);
+       return dn != NULL;
+}
+
 static int macb_phylink_connect(struct macb *bp)
 {
+       struct device_node *dn = bp->pdev->dev.of_node;
        struct net_device *dev = bp->dev;
        struct phy_device *phydev;
        int ret;
 
-       if (bp->pdev->dev.of_node &&
-           of_parse_phandle(bp->pdev->dev.of_node, "phy-handle", 0)) {
-               ret = phylink_of_phy_connect(bp->phylink, bp->pdev->dev.of_node,
-                                            0);
-               if (ret) {
-                       netdev_err(dev, "Could not attach PHY (%d)\n", ret);
-                       return ret;
-               }
-       } else {
+       if (dn)
+               ret = phylink_of_phy_connect(bp->phylink, dn, 0);
+
+       if (!dn || (ret && !macb_phy_handle_exists(dn))) {
                phydev = phy_find_first(bp->mii_bus);
                if (!phydev) {
                        netdev_err(dev, "no PHY found\n");
@@ -634,10 +680,11 @@ static int macb_phylink_connect(struct macb *bp)
 
                /* attach the mac to the phy */
                ret = phylink_connect_phy(bp->phylink, phydev);
-               if (ret) {
-                       netdev_err(dev, "Could not attach to PHY (%d)\n", ret);
-                       return ret;
-               }
+       }
+
+       if (ret) {
+               netdev_err(dev, "Could not attach PHY (%d)\n", ret);
+               return ret;
        }
 
        phylink_start(bp->phylink);
@@ -1748,16 +1795,14 @@ static netdev_features_t macb_features_check(struct sk_buff *skb,
 
        /* Validate LSO compatibility */
 
-       /* there is only one buffer */
-       if (!skb_is_nonlinear(skb))
+       /* there is only one buffer or protocol is not UDP */
+       if (!skb_is_nonlinear(skb) || (ip_hdr(skb)->protocol != IPPROTO_UDP))
                return features;
 
        /* length of header */
        hdrlen = skb_transport_offset(skb);
-       if (ip_hdr(skb)->protocol == IPPROTO_TCP)
-               hdrlen += tcp_hdrlen(skb);
 
-       /* For LSO:
+       /* For UFO only:
         * When software supplies two or more payload buffers all payload buffers
         * apart from the last must be a multiple of 8 bytes in size.
         */
@@ -4088,7 +4133,7 @@ static int fu540_c000_clk_init(struct platform_device *pdev, struct clk **pclk,
        mgmt->rate = 0;
        mgmt->hw.init = &init;
 
-       *tx_clk = clk_register(NULL, &mgmt->hw);
+       *tx_clk = devm_clk_register(&pdev->dev, &mgmt->hw);
        if (IS_ERR(*tx_clk))
                return PTR_ERR(*tx_clk);
 
@@ -4416,7 +4461,6 @@ static int macb_probe(struct platform_device *pdev)
 
 err_disable_clocks:
        clk_disable_unprepare(tx_clk);
-       clk_unregister(tx_clk);
        clk_disable_unprepare(hclk);
        clk_disable_unprepare(pclk);
        clk_disable_unprepare(rx_clk);
@@ -4446,7 +4490,6 @@ static int macb_remove(struct platform_device *pdev)
                pm_runtime_dont_use_autosuspend(&pdev->dev);
                if (!pm_runtime_suspended(&pdev->dev)) {
                        clk_disable_unprepare(bp->tx_clk);
-                       clk_unregister(bp->tx_clk);
                        clk_disable_unprepare(bp->hclk);
                        clk_disable_unprepare(bp->pclk);
                        clk_disable_unprepare(bp->rx_clk);