net: eth: altera: tse: Add PTP and mSGDMA prefetcher

From: Dalon Westergreen <[email protected]>

The return from tx_buffer call in tse_start_xmit is inapropriately ignored. tse_buffer calls should return 0 for success or NETDEV_TX_BUSY. tse_start_xmit should return not report a successful transmit when the tse_buffer call returns an error condition.

In addition to the above, the msgdma and sgdma do not return the same value on success or failure. The sgdma_tx_buffer returned 0 on failure and a positive number of transmitted packets on success. Given that it only ever sends 1 packet, this made no sense. The msgdma implementation msgdma_tx_buffer returns 0 on success.

-> Don't ignore the return from tse_buffer calls -> Fix sgdma tse_buffer call to return 0 on success
and NETDEV_TX_BUSY on failure.

Signed-off-by Dalon Westergreen <[email protected]>

---
  drivers/net/ethernet/altera/altera_sgdma.c    | 14 ++++++++------
  drivers/net/ethernet/altera/altera_tse_main.c |  4 +++-
  2 files changed, 11 insertions(+), 7 deletions(-)

drivers/net/ethernet/altera/altera_sgdma.c +8 -6

index 88ef67a998b4..eb47b9b820bb 100644
@@ -15,6 +15,7 @@
   */
 
  #include <linux/list.h>
+#include <linux/netdevice.h>
  #include "altera_utils.h"
  #include "altera_tse.h"
  #include "altera_sgdmahw.h"

@@ -170,10 +171,11 @@ void sgdma_clear_txirq(struct altera_tse_private *priv)
  		    SGDMA_CTRLREG_CLRINT);
  }
 
-/* transmits buffer through SGDMA. Returns number of buffers
- * transmitted, 0 if not possible.
- *
- * tx_lock is held by the caller
+/* transmits buffer through SGDMA.
+ *   original behavior returned the number of transmitted packets (always 1) &
+ *   returned 0 on error.  This differs from the msgdma.  the calling function
+ *   will now actually look at the code, so from now, 0 is good and return
+ *   NETDEV_TX_BUSY when busy.
   */
  int sgdma_tx_buffer(struct altera_tse_private *priv, struct tse_buffer *buffer)
  {

@@ -185,7 +187,7 @@ int sgdma_tx_buffer(struct altera_tse_private *priv, struct tse_buffer *buffer)
 
  	/* wait 'til the tx sgdma is ready for the next transmit request */
  	if (sgdma_txbusy(priv))
-		return 0;
+		return NETDEV_TX_BUSY;
 
  	sgdma_setup_descrip(cdesc,			/* current descriptor */
  			    ndesc,			/* next descriptor */

@@ -202,7 +204,7 @@ int sgdma_tx_buffer(struct altera_tse_private *priv, struct tse_buffer *buffer)
  	/* enqueue the request to the pending transmit queue */
  	queue_tx(priv, buffer);
 
-	return 1;
+	return 0;
  }
 
 

drivers/net/ethernet/altera/altera_tse_main.c +0 -0

index baca8f704a45..dcb330129e23 100644

From: Dalon Westergreen <[email protected]>

It is more appropriate to set the rx and tx ring size before calling the init function for the dma.

Signed-off-by Dalon Westergreen <[email protected]>

---
  drivers/net/ethernet/altera/altera_tse_main.c | 6 ++++--
  1 file changed, 4 insertions(+), 2 deletions(-)

drivers/net/ethernet/altera/altera_tse_main.c +4 -0

index dcb330129e23..0c0e8f9bba9b 100644
@@ -1166,6 +1166,10 @@ static int tse_open(struct net_device *dev)
  	int i;
  	unsigned long int flags;
 
+	/* set tx and rx ring size */
+	priv->rx_ring_size = dma_rx_num;
+	priv->tx_ring_size = dma_tx_num;
+
  	/* Reset and configure TSE MAC and probe associated PHY */
  	ret = priv->dmaops->init_dma(priv);
  	if (ret != 0) {

From: Dalon Westergreen <[email protected]>

The declaration of struct altera_dmaops does not have identifier names. Add identifier names to confrom with required coding styles.

Signed-off-by Dalon Westergreen <[email protected]>

---
  drivers/net/ethernet/altera/altera_tse.h | 30 +++++++++++++-----------
  1 file changed, 16 insertions(+), 14 deletions(-)

drivers/net/ethernet/altera/altera_tse.h +9 -14

index e2feee87180a..d5b97e02e6d6 100644
@@ -396,20 +396,22 @@ struct altera_tse_private;
  struct altera_dmaops {
  	int altera_dtype;
  	int dmamask;
-	void (*reset_dma)(struct altera_tse_private *);
-	void (*enable_txirq)(struct altera_tse_private *);
-	void (*enable_rxirq)(struct altera_tse_private *);
-	void (*disable_txirq)(struct altera_tse_private *);
-	void (*disable_rxirq)(struct altera_tse_private *);
-	void (*clear_txirq)(struct altera_tse_private *);
-	void (*clear_rxirq)(struct altera_tse_private *);
-	int (*tx_buffer)(struct altera_tse_private *, struct tse_buffer *);
-	u32 (*tx_completions)(struct altera_tse_private *);
-	void (*add_rx_desc)(struct altera_tse_private *, struct tse_buffer *);
-	u32 (*get_rx_status)(struct altera_tse_private *);
-	int (*init_dma)(struct altera_tse_private *);
-	void (*uninit_dma)(struct altera_tse_private *);
-	void (*start_rxdma)(struct altera_tse_private *);
+	void (*reset_dma)(struct altera_tse_private *priv);
+	void (*enable_txirq)(struct altera_tse_private *priv);
+	void (*enable_rxirq)(struct altera_tse_private *priv);
+	void (*disable_txirq)(struct altera_tse_private *priv);
+	void (*disable_rxirq)(struct altera_tse_private *priv);
+	void (*clear_txirq)(struct altera_tse_private *priv);
+	void (*clear_rxirq)(struct altera_tse_private *priv);
+	int (*tx_buffer)(struct altera_tse_private *priv,
+			 struct tse_buffer *buffer);

From: Dalon Westergreen <[email protected]>

Allow for optional start up of tx dma if the start_txdma function is defined in altera_dmaops.

Signed-off-by Dalon Westergreen <[email protected]>

---
  drivers/net/ethernet/altera/altera_tse.h      | 1 +
  drivers/net/ethernet/altera/altera_tse_main.c | 5 +++++
  2 files changed, 6 insertions(+)

drivers/net/ethernet/altera/altera_tse.h +1 -0

index d5b97e02e6d6..7f246040135d 100644
@@ -412,6 +412,7 @@ struct altera_dmaops {
  	int (*init_dma)(struct altera_tse_private *priv);
  	void (*uninit_dma)(struct altera_tse_private *priv);
  	void (*start_rxdma)(struct altera_tse_private *priv);
+	void (*start_txdma)(struct altera_tse_private *priv);
  };
 
  /* This structure is private to each device.

drivers/net/ethernet/altera/altera_tse_main.c +4 -0

index 0c0e8f9bba9b..f6b6a14b1ce9 100644
@@ -1256,6 +1256,9 @@ static int tse_open(struct net_device *dev)
 
  	priv->dmaops->start_rxdma(priv);
 
+	if (priv->dmaops->start_txdma)
+		priv->dmaops->start_txdma(priv);
+
  	/* Start MAC Rx/Tx */
  	spin_lock(&priv->mac_cfg_lock);
  	tse_set_mac(priv, true);

@@ -1658,6 +1661,7 @@ static const struct altera_dmaops altera_dtype_sgdma = {
  	.init_dma = sgdma_initialize,
  	.uninit_dma = sgdma_uninitialize,
  	.start_rxdma = sgdma_start_rxdma,
+	.start_txdma = NULL,
  };
 
  static const struct altera_dmaops altera_dtype_msgdma = {

From: Dalon Westergreen <[email protected]>

Move request_and_map and other shared functions to altera_utils. This is the first step to moving common code out of tse specific code so that it can be shared with future altera ethernet ip.

Signed-off-by Dalon Westergreen <[email protected]>

---
  drivers/net/ethernet/altera/altera_tse.h      | 45 ------------------
  .../net/ethernet/altera/altera_tse_ethtool.c  |  1 +
  drivers/net/ethernet/altera/altera_tse_main.c | 32 +------------
  drivers/net/ethernet/altera/altera_utils.c    | 30 ++++++++++++
  drivers/net/ethernet/altera/altera_utils.h    | 46 +++++++++++++++++++
  5 files changed, 78 insertions(+), 76 deletions(-)

drivers/net/ethernet/altera/altera_tse.h +0 -45

index 7f246040135d..f435fb0eca90 100644
@@ -500,49 +500,4 @@ struct altera_tse_private {
   */
  void altera_tse_set_ethtool_ops(struct net_device *);
 
-static inline
-u32 csrrd32(void __iomem *mac, size_t offs)
-{
-	void __iomem *paddr = (void __iomem *)((uintptr_t)mac + offs);
-	return readl(paddr);
-}
-
-static inline
-u16 csrrd16(void __iomem *mac, size_t offs)
-{
-	void __iomem *paddr = (void __iomem *)((uintptr_t)mac + offs);
-	return readw(paddr);
-}
-
-static inline
-u8 csrrd8(void __iomem *mac, size_t offs)
-{
-	void __iomem *paddr = (void __iomem *)((uintptr_t)mac + offs);
-	return readb(paddr);
-}
-
-static inline
-void csrwr32(u32 val, void __iomem *mac, size_t offs)
-{
-	void __iomem *paddr = (void __iomem *)((uintptr_t)mac + offs);
-
-	writel(val, paddr);
-}
-
-static inline
-void csrwr16(u16 val, void __iomem *mac, size_t offs)
-{
-	void __iomem *paddr = (void __iomem *)((uintptr_t)mac + offs);
-
-	writew(val, paddr);
-}
-
-static inline
-void csrwr8(u8 val, void __iomem *mac, size_t offs)
-{
-	void __iomem *paddr = (void __iomem *)((uintptr_t)mac + offs);
-
-	writeb(val, paddr);
-}
-
  #endif /* __ALTERA_TSE_H__ */

drivers/net/ethernet/altera/altera_tse_ethtool.c +1 -0

index 7c367713c3e6..2998655ab316 100644
@@ -33,6 +33,7 @@
  #include <linux/phy.h>
 
  #include "altera_tse.h"
+#include "altera_utils.h"
 
  #define TSE_STATS_LEN	31
  #define TSE_NUM_REGS	128

drivers/net/ethernet/altera/altera_tse_main.c +1 -31

index f6b6a14b1ce9..b25d03506470 100644
@@ -34,7 +34,6 @@
  #include <linux/if_vlan.h>
  #include <linux/init.h>
  #include <linux/interrupt.h>
-#include <linux/io.h>
  #include <linux/kernel.h>
  #include <linux/module.h>
  #include <linux/mii.h>

@@ -44,7 +43,7 @@
  #include <linux/of_net.h>
  #include <linux/of_platform.h>
  #include <linux/phy.h>
-#include <linux/platform_device.h>
+#include <linux/ptp_classify.h>
  #include <linux/skbuff.h>
  #include <asm/cacheflush.h>
 

@@ -1332,35 +1331,6 @@ static struct net_device_ops altera_tse_netdev_ops = {
  	.ndo_validate_addr	= eth_validate_addr,
  };
 
-static int request_and_map(struct platform_device *pdev, const char *name,
-			   struct resource **res, void __iomem **ptr)
-{
-	struct resource *region;
-	struct device *device = &pdev->dev;
-
-	*res = platform_get_resource_byname(pdev, IORESOURCE_MEM, name);
-	if (*res == NULL) {
-		dev_err(device, "resource %s not defined\n", name);
-		return -ENODEV;
-	}
-
-	region = devm_request_mem_region(device, (*res)->start,
-					 resource_size(*res), dev_name(device));
-	if (region == NULL) {
-		dev_err(device, "unable to request %s\n", name);
-		return -EBUSY;
-	}
-
-	*ptr = devm_ioremap_nocache(device, region->start,
-				    resource_size(region));
-	if (*ptr == NULL) {
-		dev_err(device, "ioremap_nocache of %s failed!", name);
-		return -ENOMEM;
-	}
-
-	return 0;
-}
-
  /* Probe Altera TSE MAC device
   */
  static int altera_tse_probe(struct platform_device *pdev)

drivers/net/ethernet/altera/altera_utils.c +30 -0

index d7eeb1713ad2..bc33b7f0b0c5 100644
@@ -42,3 +42,33 @@ int tse_bit_is_clear(void __iomem *ioaddr, size_t offs, u32 bit_mask)
  	u32 value = csrrd32(ioaddr, offs);
  	return (value & bit_mask) ? 0 : 1;
  }
+
+int request_and_map(struct platform_device *pdev, const char *name,
+		    struct resource **res, void __iomem **ptr)
+{
+	struct resource *region;
+	struct device *device = &pdev->dev;
+
+	*res = platform_get_resource_byname(pdev, IORESOURCE_MEM, name);
+	if (!*res) {
+		dev_err(device, "resource %s not defined\n", name);
+		return -ENODEV;
+	}
+
+	region = devm_request_mem_region(device, (*res)->start,
+					 resource_size(*res), dev_name(device));
+	if (!region) {
+		dev_err(device, "unable to request %s\n", name);
+		return -EBUSY;
+	}
+
+	*ptr = devm_ioremap_nocache(device, region->start,
+				    resource_size(region));
+	if (!*ptr) {
+		dev_err(device, "ioremap_nocache of %s failed!", name);
+		return -ENOMEM;
+	}
+
+	return 0;
+}
+

drivers/net/ethernet/altera/altera_utils.h +38 -0

index baf100ccf587..bb7eff792bb7 100644
@@ -14,7 +14,9 @@
   * this program.  If not, see <http://www.gnu.org/licenses/>.
   */
 
+#include <linux/io.h>
  #include <linux/kernel.h>
+#include <linux/platform_device.h>
 
  #ifndef __ALTERA_UTILS_H__
  #define __ALTERA_UTILS_H__

@@ -23,5 +25,49 @@ void tse_set_bit(void __iomem *ioaddr, size_t offs, u32 bit_mask);
  void tse_clear_bit(void __iomem *ioaddr, size_t offs, u32 bit_mask);
  int tse_bit_is_set(void __iomem *ioaddr, size_t offs, u32 bit_mask);
  int tse_bit_is_clear(void __iomem *ioaddr, size_t offs, u32 bit_mask);
+int request_and_map(struct platform_device *pdev, const char *name,
+		    struct resource **res, void __iomem **ptr);
+
+static inline u32 csrrd32(void __iomem *mac, size_t offs)
+{
+	void __iomem *paddr = (void __iomem *)((uintptr_t)mac + offs);
+
+	return readl(paddr);
+}
+
+static inline u16 csrrd16(void __iomem *mac, size_t offs)
+{
+	void __iomem *paddr = (void __iomem *)((uintptr_t)mac + offs);
+
+	return readw(paddr);
+}
+
+static inline u8 csrrd8(void __iomem *mac, size_t offs)
+{
+	void __iomem *paddr = (void __iomem *)((uintptr_t)mac + offs);
+
+	return readb(paddr);
+}
+
+static inline void csrwr32(u32 val, void __iomem *mac, size_t offs)
+{
+	void __iomem *paddr = (void __iomem *)((uintptr_t)mac + offs);
+
+	writel(val, paddr);
+}
+
+static inline void csrwr16(u16 val, void __iomem *mac, size_t offs)
+{
+	void __iomem *paddr = (void __iomem *)((uintptr_t)mac + offs);
+
+	writew(val, paddr);

From: Dalon Westergreen <[email protected]>

The sgdma and msgdma header files included function declarations without identifier names for pointers. Add appropriate identifier names.

Signed-off-by Dalon Westergreen <[email protected]>

---
  drivers/net/ethernet/altera/altera_msgdma.h | 30 ++++++++++---------
  drivers/net/ethernet/altera/altera_sgdma.h  | 32 +++++++++++----------
  2 files changed, 33 insertions(+), 29 deletions(-)

drivers/net/ethernet/altera/altera_msgdma.h +16 -14

index 42cf61c81057..e18be91a48a7 100644
@@ -17,19 +17,21 @@
  #ifndef __ALTERA_MSGDMA_H__
  #define __ALTERA_MSGDMA_H__
 
-void msgdma_reset(struct altera_tse_private *);
-void msgdma_enable_txirq(struct altera_tse_private *);
-void msgdma_enable_rxirq(struct altera_tse_private *);
-void msgdma_disable_rxirq(struct altera_tse_private *);
-void msgdma_disable_txirq(struct altera_tse_private *);
-void msgdma_clear_rxirq(struct altera_tse_private *);
-void msgdma_clear_txirq(struct altera_tse_private *);
-u32 msgdma_tx_completions(struct altera_tse_private *);
-void msgdma_add_rx_desc(struct altera_tse_private *, struct tse_buffer *);
-int msgdma_tx_buffer(struct altera_tse_private *, struct tse_buffer *);
-u32 msgdma_rx_status(struct altera_tse_private *);
-int msgdma_initialize(struct altera_tse_private *);
-void msgdma_uninitialize(struct altera_tse_private *);
-void msgdma_start_rxdma(struct altera_tse_private *);
+void msgdma_reset(struct altera_tse_private *priv);
+void msgdma_enable_txirq(struct altera_tse_private *priv);
+void msgdma_enable_rxirq(struct altera_tse_private *priv);
+void msgdma_disable_rxirq(struct altera_tse_private *priv);
+void msgdma_disable_txirq(struct altera_tse_private *priv);
+void msgdma_clear_rxirq(struct altera_tse_private *priv);
+void msgdma_clear_txirq(struct altera_tse_private *priv);
+u32 msgdma_tx_completions(struct altera_tse_private *priv);
+void msgdma_add_rx_desc(struct altera_tse_private *priv,
+			struct tse_buffer *buffer);
+int msgdma_tx_buffer(struct altera_tse_private *priv,
+		     struct tse_buffer *buffer);
+u32 msgdma_rx_status(struct altera_tse_private *priv);
+int msgdma_initialize(struct altera_tse_private *priv);
+void msgdma_uninitialize(struct altera_tse_private *priv);
+void msgdma_start_rxdma(struct altera_tse_private *priv);
 
  #endif /*  __ALTERA_MSGDMA_H__ */

drivers/net/ethernet/altera/altera_sgdma.h +9 -15

index 584977e29ef9..769e720a2043 100644
@@ -17,20 +17,22 @@
  #ifndef __ALTERA_SGDMA_H__
  #define __ALTERA_SGDMA_H__
 
-void sgdma_reset(struct altera_tse_private *);
-void sgdma_enable_txirq(struct altera_tse_private *);
-void sgdma_enable_rxirq(struct altera_tse_private *);
-void sgdma_disable_rxirq(struct altera_tse_private *);
-void sgdma_disable_txirq(struct altera_tse_private *);
-void sgdma_clear_rxirq(struct altera_tse_private *);
-void sgdma_clear_txirq(struct altera_tse_private *);
-int sgdma_tx_buffer(struct altera_tse_private *priv, struct tse_buffer *);
-u32 sgdma_tx_completions(struct altera_tse_private *);
-void sgdma_add_rx_desc(struct altera_tse_private *priv, struct tse_buffer *);
-void sgdma_status(struct altera_tse_private *);
-u32 sgdma_rx_status(struct altera_tse_private *);
-int sgdma_initialize(struct altera_tse_private *);
-void sgdma_uninitialize(struct altera_tse_private *);
-void sgdma_start_rxdma(struct altera_tse_private *);
+void sgdma_reset(struct altera_tse_private *priv);
+void sgdma_enable_txirq(struct altera_tse_private *priv);
+void sgdma_enable_rxirq(struct altera_tse_private *priv);
+void sgdma_disable_rxirq(struct altera_tse_private *priv);
+void sgdma_disable_txirq(struct altera_tse_private *priv);
+void sgdma_clear_rxirq(struct altera_tse_private *priv);
+void sgdma_clear_txirq(struct altera_tse_private *priv);
+int sgdma_tx_buffer(struct altera_tse_private *priv,
+		    struct tse_buffer *buffer);

Signed-off-by Dalon Westergreen <[email protected]>

---
v2 New patch cleanup that adds the pointer identifier names.

---
  drivers/net/ethernet/altera/altera_msgdma.h | 30 ++++++++++---------
  drivers/net/ethernet/altera/altera_sgdma.h  | 32 +++++++++++----------

Hi Dalon,

Quoted 96 lines · On 12/13/18 11:52 AM, [email protected] wrote:

From: Dalon Westergreen <[email protected]>

The sgdma and msgdma header files included function declarations without identifier names for pointers. Add appropriate identifier names.

Signed-off-by Dalon Westergreen <[email protected]>

---
  drivers/net/ethernet/altera/altera_msgdma.h | 30 ++++++++++---------
  drivers/net/ethernet/altera/altera_sgdma.h  | 32 +++++++++++----------
  2 files changed, 33 insertions(+), 29 deletions(-)

drivers/net/ethernet/altera/altera_msgdma.h +16 -14

index 42cf61c81057..e18be91a48a7 100644
@@ -17,19 +17,21 @@
  #ifndef __ALTERA_MSGDMA_H__
  #define __ALTERA_MSGDMA_H__
 
-void msgdma_reset(struct altera_tse_private *);
-void msgdma_enable_txirq(struct altera_tse_private *);
-void msgdma_enable_rxirq(struct altera_tse_private *);
-void msgdma_disable_rxirq(struct altera_tse_private *);
-void msgdma_disable_txirq(struct altera_tse_private *);
-void msgdma_clear_rxirq(struct altera_tse_private *);
-void msgdma_clear_txirq(struct altera_tse_private *);
-u32 msgdma_tx_completions(struct altera_tse_private *);
-void msgdma_add_rx_desc(struct altera_tse_private *, struct tse_buffer *);
-int msgdma_tx_buffer(struct altera_tse_private *, struct tse_buffer *);
-u32 msgdma_rx_status(struct altera_tse_private *);
-int msgdma_initialize(struct altera_tse_private *);
-void msgdma_uninitialize(struct altera_tse_private *);
-void msgdma_start_rxdma(struct altera_tse_private *);
+void msgdma_reset(struct altera_tse_private *priv);
+void msgdma_enable_txirq(struct altera_tse_private *priv);
+void msgdma_enable_rxirq(struct altera_tse_private *priv);
+void msgdma_disable_rxirq(struct altera_tse_private *priv);
+void msgdma_disable_txirq(struct altera_tse_private *priv);
+void msgdma_clear_rxirq(struct altera_tse_private *priv);
+void msgdma_clear_txirq(struct altera_tse_private *priv);
+u32 msgdma_tx_completions(struct altera_tse_private *priv);
+void msgdma_add_rx_desc(struct altera_tse_private *priv,
+			struct tse_buffer *buffer);
+int msgdma_tx_buffer(struct altera_tse_private *priv,
+		     struct tse_buffer *buffer);
+u32 msgdma_rx_status(struct altera_tse_private *priv);
+int msgdma_initialize(struct altera_tse_private *priv);
+void msgdma_uninitialize(struct altera_tse_private *priv);
+void msgdma_start_rxdma(struct altera_tse_private *priv);
 
  #endif /*  __ALTERA_MSGDMA_H__ */

drivers/net/ethernet/altera/altera_sgdma.h +17 -15

index 584977e29ef9..769e720a2043 100644
@@ -17,20 +17,22 @@
  #ifndef __ALTERA_SGDMA_H__
  #define __ALTERA_SGDMA_H__
 
-void sgdma_reset(struct altera_tse_private *);
-void sgdma_enable_txirq(struct altera_tse_private *);
-void sgdma_enable_rxirq(struct altera_tse_private *);
-void sgdma_disable_rxirq(struct altera_tse_private *);
-void sgdma_disable_txirq(struct altera_tse_private *);
-void sgdma_clear_rxirq(struct altera_tse_private *);
-void sgdma_clear_txirq(struct altera_tse_private *);
-int sgdma_tx_buffer(struct altera_tse_private *priv, struct tse_buffer *);
-u32 sgdma_tx_completions(struct altera_tse_private *);
-void sgdma_add_rx_desc(struct altera_tse_private *priv, struct tse_buffer
 *);
-void sgdma_status(struct altera_tse_private *);
-u32 sgdma_rx_status(struct altera_tse_private *);
-int sgdma_initialize(struct altera_tse_private *);
-void sgdma_uninitialize(struct altera_tse_private *);
-void sgdma_start_rxdma(struct altera_tse_private *);
+void sgdma_reset(struct altera_tse_private *priv);
+void sgdma_enable_txirq(struct altera_tse_private *priv);
+void sgdma_enable_rxirq(struct altera_tse_private *priv);
+void sgdma_disable_rxirq(struct altera_tse_private *priv);
+void sgdma_disable_txirq(struct altera_tse_private *priv);
+void sgdma_clear_rxirq(struct altera_tse_private *priv);
+void sgdma_clear_txirq(struct altera_tse_private *priv);
+int sgdma_tx_buffer(struct altera_tse_private *priv,
+		    struct tse_buffer *buffer);
+u32 sgdma_tx_completions(struct altera_tse_private *priv);
+void sgdma_add_rx_desc(struct altera_tse_private *priv,
+		       struct tse_buffer *buffer);
+void sgdma_status(struct altera_tse_private *priv);
+u32 sgdma_rx_status(struct altera_tse_private *priv);
+int sgdma_initialize(struct altera_tse_private *priv);
+void sgdma_uninitialize(struct altera_tse_private *priv);
+void sgdma_start_rxdma(struct altera_tse_private *priv);
 

Quoted 2 lines

  #endif /*  __ALTERA_SGDMA_H__ */

FYI. Since this is a change in v2, there is normally a break below your Signed-off-by and then a description of what changed (in this case new patch). This isolates the changes to the patch even though you put it in the summary patch. So it would look like this

<snip>

Quoted 1 line

Quoted 6 lines

Signed-off-by Dalon Westergreen <[email protected]>

---
v2 New patch cleanup that adds the pointer identifier names.

---
  drivers/net/ethernet/altera/altera_msgdma.h | 30 ++++++++++---------
  drivers/net/ethernet/altera/altera_sgdma.h  | 32 +++++++++++----------

</snip>

Acked-by Thor Thayer <[email protected]>

From: Dalon Westergreen <[email protected]>

Modify all msgdma and sgdma tx_buffer functions to be of type netdev_tx_t, and also modify main tx function to be of netdev_tx_t type.

Signed-off-by Dalon Westergreen <[email protected]>

---
  drivers/net/ethernet/altera/altera_msgdma.c   | 5 +++--
  drivers/net/ethernet/altera/altera_msgdma.h   | 4 ++--
  drivers/net/ethernet/altera/altera_sgdma.c    | 5 +++--
  drivers/net/ethernet/altera/altera_sgdma.h    | 4 ++--
  drivers/net/ethernet/altera/altera_tse.h      | 4 ++--
  drivers/net/ethernet/altera/altera_tse_main.c | 2 +-
  6 files changed, 13 insertions(+), 11 deletions(-)

drivers/net/ethernet/altera/altera_msgdma.c +3 -2

index 0fb986ba3290..95f016731cc2 100644
@@ -117,7 +117,8 @@ void msgdma_clear_txirq(struct altera_tse_private *priv)
  }
 
  /* return 0 to indicate transmit is pending */
-int msgdma_tx_buffer(struct altera_tse_private *priv, struct tse_buffer *buffer)
+netdev_tx_t
+msgdma_tx_buffer(struct altera_tse_private *priv, struct tse_buffer *buffer)
  {
  	csrwr32(lower_32_bits(buffer->dma_addr), priv->tx_dma_desc,
  		msgdma_descroffs(read_addr_lo));

@@ -131,7 +132,7 @@ int msgdma_tx_buffer(struct altera_tse_private *priv, struct tse_buffer *buffer)
  		msgdma_descroffs(stride));
  	csrwr32(MSGDMA_DESC_CTL_TX_SINGLE, priv->tx_dma_desc,
  		msgdma_descroffs(control));
-	return 0;
+	return NETDEV_TX_OK;
  }
 
  u32 msgdma_tx_completions(struct altera_tse_private *priv)

drivers/net/ethernet/altera/altera_msgdma.h +2 -2

index e18be91a48a7..e9008e3761b9 100644
@@ -27,8 +27,8 @@ void msgdma_clear_txirq(struct altera_tse_private *priv);
  u32 msgdma_tx_completions(struct altera_tse_private *priv);
  void msgdma_add_rx_desc(struct altera_tse_private *priv,
  			struct tse_buffer *buffer);
-int msgdma_tx_buffer(struct altera_tse_private *priv,
-		     struct tse_buffer *buffer);
+netdev_tx_t msgdma_tx_buffer(struct altera_tse_private *priv,
+			     struct tse_buffer *buffer);
  u32 msgdma_rx_status(struct altera_tse_private *priv);
  int msgdma_initialize(struct altera_tse_private *priv);
  void msgdma_uninitialize(struct altera_tse_private *priv);

drivers/net/ethernet/altera/altera_sgdma.c +3 -2

index eb47b9b820bb..93f66af338de 100644
@@ -177,7 +177,8 @@ void sgdma_clear_txirq(struct altera_tse_private *priv)
   *   will now actually look at the code, so from now, 0 is good and return
   *   NETDEV_TX_BUSY when busy.
   */
-int sgdma_tx_buffer(struct altera_tse_private *priv, struct tse_buffer *buffer)
+netdev_tx_t
+sgdma_tx_buffer(struct altera_tse_private *priv, struct tse_buffer *buffer)
  {
  	struct sgdma_descrip __iomem *descbase =
  		(struct sgdma_descrip __iomem *)priv->tx_dma_desc;

@@ -204,7 +205,7 @@ int sgdma_tx_buffer(struct altera_tse_private *priv, struct tse_buffer *buffer)
  	/* enqueue the request to the pending transmit queue */
  	queue_tx(priv, buffer);
 
-	return 0;
+	return NETDEV_TX_OK;
  }
 
 

drivers/net/ethernet/altera/altera_sgdma.h +2 -2

index 769e720a2043..984c00d81596 100644
@@ -24,8 +24,8 @@ void sgdma_disable_rxirq(struct altera_tse_private *priv);
  void sgdma_disable_txirq(struct altera_tse_private *priv);
  void sgdma_clear_rxirq(struct altera_tse_private *priv);
  void sgdma_clear_txirq(struct altera_tse_private *priv);
-int sgdma_tx_buffer(struct altera_tse_private *priv,
-		    struct tse_buffer *buffer);
+netdev_tx_t sgdma_tx_buffer(struct altera_tse_private *priv,
+			    struct tse_buffer *buffer);
  u32 sgdma_tx_completions(struct altera_tse_private *priv);
  void sgdma_add_rx_desc(struct altera_tse_private *priv,
  		       struct tse_buffer *buffer);

drivers/net/ethernet/altera/altera_tse.h +2 -2

index f435fb0eca90..6e7f92ebf3cf 100644
@@ -403,8 +403,8 @@ struct altera_dmaops {
  	void (*disable_rxirq)(struct altera_tse_private *priv);
  	void (*clear_txirq)(struct altera_tse_private *priv);
  	void (*clear_rxirq)(struct altera_tse_private *priv);
-	int (*tx_buffer)(struct altera_tse_private *priv,
-			 struct tse_buffer *buffer);
+	netdev_tx_t (*tx_buffer)(struct altera_tse_private *priv,
+				 struct tse_buffer *buffer);
  	u32 (*tx_completions)(struct altera_tse_private *priv);
  	void (*add_rx_desc)(struct altera_tse_private *priv,
  			    struct tse_buffer *buffer);

drivers/net/ethernet/altera/altera_tse_main.c +0 -0

index b25d03506470..24915f72e965 100644

Changes from V1:
-> Remove debugfs for tod manipulation
-> Reorder variable declarations in functions to order
by length of declaration, largest to smallest
-> Rename altera_ptp to intel_fpga_tod
-> Rename functions in intel_fpga_tod so that they are not
generic
-> Use imply instead of select in Kconfig
-> Re-write adjust time function to remove while loop with
64 bit divide.

drivers/net/ethernet/altera/altera_tse_ethtool.c +6 -0

+		return 0;
+	} else {
+		return ethtool_op_get_ts_info(dev, info);
+	}
+}
+

Quoted 10 lines · On Thu, Dec 13, 2018 at 09:52:50AM -0800, [email protected] wrote:

Changes from V1:
-> Remove debugfs for tod manipulation
-> Reorder variable declarations in functions to order
by length of declaration, largest to smallest
-> Rename altera_ptp to intel_fpga_tod
-> Rename functions in intel_fpga_tod so that they are not
generic
-> Use imply instead of select in Kconfig
-> Re-write adjust time function to remove while loop with
64 bit divide.

Overall this is looking better. A few more comments follow...

drivers/net/ethernet/altera/altera_tse_ethtool.c static void tse_get_regs(struct net_device *dev, struct ethtool_regs *regs, · line 246

Quoted 10 lines

drivers/net/ethernet/altera/altera_tse_ethtool.c +9 -0

+static int tse_get_ts_info(struct net_device *dev,
+			   struct ethtool_ts_info *info)
+{
+	struct altera_tse_private *priv = netdev_priv(dev);
+
+	if (priv->ptp_enable) {
+		if (priv->ptp_priv.ptp_clock)
+			info->phc_index =
+				ptp_clock_index(priv->ptp_priv.ptp_clock);

else
info->phc_index = -1;

drivers/net/ethernet/altera/altera_tse_ethtool.c static void tse_get_regs(struct net_device *dev, struct ethtool_regs *regs, · line 253

Quoted 6 lines

drivers/net/ethernet/altera/altera_tse_ethtool.c +6 -0

+		info->so_timestamping = SOF_TIMESTAMPING_TX_HARDWARE |
+					SOF_TIMESTAMPING_RX_HARDWARE |
+					SOF_TIMESTAMPING_RAW_HARDWARE;
+
+		info->tx_types = (1 << HWTSTAMP_TX_OFF) |
+						 (1 << HWTSTAMP_TX_ON);

This fits on one line ^^^

drivers/net/ethernet/altera/altera_tse_ethtool.c static void tse_get_regs(struct net_device *dev, struct ethtool_regs *regs, · line 256

Quoted 2 lines

drivers/net/ethernet/altera/altera_tse_ethtool.c +2 -0

+		info->rx_filters = (1 << HWTSTAMP_FILTER_NONE) |
+						   (1 << HWTSTAMP_FILTER_ALL);

Funky indentation here. One extra level is enough:

		info->rx_filters = (1 << HWTSTAMP_FILTER_NONE) |
			(1 << HWTSTAMP_FILTER_ALL);

Quoted 6 lines

drivers/net/ethernet/altera/altera_tse_ethtool.c +6 -0

+		return 0;
+	} else {
+		return ethtool_op_get_ts_info(dev, info);
+	}
+}
+

...

drivers/net/ethernet/altera/altera_tse_main.c static netdev_tx_t tse_start_xmit(struct sk_buff *skb, · line 621

Quoted 11 lines

drivers/net/ethernet/altera/altera_tse_main.c +5 -1

@@ -609,7 +613,14 @@ static netdev_tx_t tse_start_xmit(struct sk_buff *skb,
 struct net_device *dev)
 	if (ret)
 		goto out;
 
-	skb_tx_timestamp(skb);
+	/* Provide a hardware time stamp if requested.
+	 */
+	if (unlikely((skb_shinfo(skb)->tx_flags & SKBTX_HW_TSTAMP) &&
+		     priv->hwts_tx_en))
+		/* declare that device is doing timestamping */

Please drop those two comments. They are redundant because they only restate what the code does.

Quoted 6 lines

drivers/net/ethernet/altera/altera_tse_main.c +3 -0

+		skb_shinfo(skb)->tx_flags |= SKBTX_IN_PROGRESS;
+	else
+		skb_tx_timestamp(skb);
 
 	priv->tx_prod++;

dev->stats.tx_bytes += skb->len;

Thanks,
Richard

From: Dalon Westergreen <[email protected]>

Add support for the mSGDMA prefetcher. The prefetcher adds support for a linked list of descriptors in system memory. The prefetcher feeds these to the mSGDMA dispatcher.

The prefetcher is configured to poll for the next descriptor in the list to be owned by hardware, then pass the descriptor to the dispatcher. It will then poll the next descriptor until it is owned by hardware.

The dispatcher responses are written back to the appropriate descriptor, and the owned by hardware bit is cleared.

The driver sets up a linked list twice the tx and rx ring sizes, with the last descriptor pointing back to the first. This ensures that the ring of descriptors will always have inactive descriptors preventing the prefetcher from looping over and reusing descriptors inappropriately. The prefetcher will continuously loop over these descriptors. The driver modifies descriptors as required to update the skb address and length as well as the owned by hardware bit.

In addition to the above, the mSGDMA prefetcher can be used to handle rx and tx timestamps coming from the ethernet ip. These can be included in the prefetcher response in the descriptor.

Signed-off-by Dalon Westergreen <[email protected]>

---
Changes from v1:
-> Alphabatize includes
-> update xmit function to return type net_tx_t
-> Cleanup msgdms descriptor ring by making is more apparent
that the msgdma descriptor ring is 2 * ring_size

---
  drivers/net/ethernet/altera/Makefile          |   2 +-
  .../altera/altera_msgdma_prefetcher.c         | 432 ++++++++++++++++++
  .../altera/altera_msgdma_prefetcher.h         |  30 ++
  .../altera/altera_msgdmahw_prefetcher.h       |  87 ++++
  drivers/net/ethernet/altera/altera_tse.h      |  14 +
  drivers/net/ethernet/altera/altera_tse_main.c |  51 +++
  6 files changed, 615 insertions(+), 1 deletion(-)

create mode 100644 drivers/net/ethernet/altera/altera_msgdma_prefetcher.c create mode 100644 drivers/net/ethernet/altera/altera_msgdma_prefetcher.h create mode 100644 drivers/net/ethernet/altera/altera_msgdmahw_prefetcher.h

drivers/net/ethernet/altera/Makefile +1 -1

index 3e622b4c105a..f6627615c6c1 100644
@@ -5,4 +5,4 @@
  obj-$(CONFIG_ALTERA_TSE) += altera_tse.o
  altera_tse-objs := altera_tse_main.o altera_tse_ethtool.o \
  		   altera_msgdma.o altera_sgdma.o altera_utils.o \
-		   intel_fpga_tod.o
+		   intel_fpga_tod.o altera_msgdma_prefetcher.o

drivers/net/ethernet/altera/altera_msgdma_prefetcher.c new file +8 -0

new file mode 100644
index 000000000000..f50ea62f687d
@@ -0,0 +1,432 @@
+// SPDX-License-Identifier: GPL-2.0
+/* MSGDMA Prefetcher driver for Altera ethernet devices
+ *
+ * Copyright (C) 2018 Intel Corporation. All rights reserved.
+ * Author(s):
+ *   Dalon Westergreen <[email protected]>
+ */
+

drivers/net/ethernet/altera/altera_msgdma_prefetcher.c new file +159 -0

+int msgdma_pref_initialize(struct altera_tse_private *priv)
+{
+	int i;
+	struct msgdma_pref_extended_desc *rx_descs;
+	struct msgdma_pref_extended_desc *tx_descs;
+	dma_addr_t rx_descsphys;
+	dma_addr_t tx_descsphys;
+
+	priv->pref_rxdescphys = (dma_addr_t)0;
+	priv->pref_txdescphys = (dma_addr_t)0;
+
+	/* we need to allocate more pref descriptors than ringsize to
+	 * prevent all of the descriptors being owned by hw.  To do this
+	 * we just allocate twice ring_size descriptors.
+	 * rx_ring_size = priv->rx_ring_size * 2
+	 * tx_ring_size = priv->tx_ring_size * 2
+	 */
+
+	/* The prefetcher requires the descriptors to be aligned to the
+	 * descriptor read/write master's data width which worst case is
+	 * 512 bits.  Currently we DO NOT CHECK THIS and only support 32-bit
+	 * prefetcher masters.
+	 */
+
+	/* allocate memory for rx descriptors */
+	priv->pref_rxdesc =
+		dma_zalloc_coherent(priv->device,
+				    sizeof(struct msgdma_pref_extended_desc)
+				    * priv->rx_ring_size * 2,
+				    &priv->pref_rxdescphys, GFP_KERNEL);
+
+	if (!priv->pref_rxdesc)
+		goto err_rx;
+
+	/* allocate memory for tx descriptors */
+	priv->pref_txdesc =
+		dma_zalloc_coherent(priv->device,
+				    sizeof(struct msgdma_pref_extended_desc)
+				    * priv->tx_ring_size * 2,
+				    &priv->pref_txdescphys, GFP_KERNEL);
+
+	if (!priv->pref_txdesc)
+		goto err_tx;
+
+	/* setup base descriptor ring for tx & rx */
+	rx_descs = (struct msgdma_pref_extended_desc *)priv->pref_rxdesc;
+	tx_descs = (struct msgdma_pref_extended_desc *)priv->pref_txdesc;
+	tx_descsphys = priv->pref_txdescphys;
+	rx_descsphys = priv->pref_rxdescphys;
+
+	/* setup RX descriptors */
+	priv->pref_rx_prod = 0;
+	for (i = 0; i < priv->rx_ring_size * 2; i++) {
+		rx_descsphys = priv->pref_rxdescphys +
+			(((i + 1) % (priv->rx_ring_size * 2)) *
+			sizeof(struct msgdma_pref_extended_desc));
+		rx_descs[i].next_desc_lo = lower_32_bits(rx_descsphys);
+		rx_descs[i].next_desc_hi = upper_32_bits(rx_descsphys);
+		rx_descs[i].stride = MSGDMA_DESC_RX_STRIDE;
+		/* burst set to 0 so it defaults to max configured */
+		/* set seq number to desc number */
+		rx_descs[i].burst_seq_num = i;
+	}
+
+	/* setup TX descriptors */
+	for (i = 0; i < priv->tx_ring_size * 2; i++) {
+		tx_descsphys = priv->pref_txdescphys +
+			(((i + 1) % (priv->tx_ring_size * 2)) *
+			sizeof(struct msgdma_pref_extended_desc));
+		tx_descs[i].next_desc_lo = lower_32_bits(tx_descsphys);
+		tx_descs[i].next_desc_hi = upper_32_bits(tx_descsphys);
+		tx_descs[i].stride = MSGDMA_DESC_TX_STRIDE;
+		/* burst set to 0 so it defaults to max configured */
+		/* set seq number to desc number */
+		tx_descs[i].burst_seq_num = i;
+	}
+
+	if (netif_msg_ifup(priv))
+		netdev_info(priv->dev, "%s: RX Desc mem at 0x%x\n", __func__,
+			    priv->pref_rxdescphys);
+
+	if (netif_msg_ifup(priv))
+		netdev_info(priv->dev, "%s: TX Desc mem at 0x%x\n", __func__,
+			    priv->pref_txdescphys);
+
+	return 0;
+
+err_tx:
+	dma_free_coherent(priv->device,
+			  sizeof(struct msgdma_pref_extended_desc)
+			  * priv->rx_ring_size * 2,
+			  priv->pref_rxdesc, priv->pref_rxdescphys);
+err_rx:
+	return -ENOMEM;
+}
+
+void msgdma_pref_uninitialize(struct altera_tse_private *priv)
+{
+	if (priv->pref_rxdesc)
+		dma_free_coherent(priv->device,
+				  sizeof(struct msgdma_pref_extended_desc)
+				  * priv->rx_ring_size * 2,
+				  priv->pref_rxdesc, priv->pref_rxdescphys);
+
+	if (priv->pref_txdesc)
+		dma_free_coherent(priv->device,
+				  sizeof(struct msgdma_pref_extended_desc)
+				  * priv->rx_ring_size * 2,
+				  priv->pref_txdesc, priv->pref_txdescphys);
+}
+
+void msgdma_pref_enable_txirq(struct altera_tse_private *priv)
+{
+	tse_set_bit(priv->tx_pref_csr, msgdma_pref_csroffs(control),
+		    MSGDMA_PREF_CTL_GLOBAL_INTR);
+}
+
+void msgdma_pref_disable_txirq(struct altera_tse_private *priv)
+{
+	tse_clear_bit(priv->tx_pref_csr, msgdma_pref_csroffs(control),
+		      MSGDMA_PREF_CTL_GLOBAL_INTR);
+}
+
+void msgdma_pref_clear_txirq(struct altera_tse_private *priv)
+{
+	csrwr32(MSGDMA_PREF_STAT_IRQ, priv->tx_pref_csr,
+		msgdma_pref_csroffs(status));
+}
+
+void msgdma_pref_enable_rxirq(struct altera_tse_private *priv)
+{
+	tse_set_bit(priv->rx_pref_csr, msgdma_pref_csroffs(control),
+		    MSGDMA_PREF_CTL_GLOBAL_INTR);
+}
+
+void msgdma_pref_disable_rxirq(struct altera_tse_private *priv)
+{
+	tse_clear_bit(priv->rx_pref_csr, msgdma_pref_csroffs(control),
+		      MSGDMA_PREF_CTL_GLOBAL_INTR);
+}
+
+void msgdma_pref_clear_rxirq(struct altera_tse_private *priv)
+{
+	csrwr32(MSGDMA_PREF_STAT_IRQ, priv->rx_pref_csr,
+		msgdma_pref_csroffs(status));
+}
+
+static u64 timestamp_to_ns(struct msgdma_pref_extended_desc *desc)
+{
+	u64 ns = 0;
+	u64 second;
+	u32 tmp;
+
+	tmp = desc->timestamp_96b[0] >> 16;
+	tmp |= (desc->timestamp_96b[1] << 16);
+
+	second = desc->timestamp_96b[2];
+	second <<= 16;
+	second |= ((desc->timestamp_96b[1] & 0xffff0000) >> 16);

drivers/net/ethernet/altera/altera_msgdma_prefetcher.c new file +104 -0

+netdev_tx_t msgdma_pref_tx_buffer(struct altera_tse_private *priv,
+				  struct tse_buffer *buffer)
+{
+	u32 desc_entry = priv->tx_prod % (priv->tx_ring_size * 2);
+	struct msgdma_pref_extended_desc *tx_descs = priv->pref_txdesc;
+
+	/* if for some reason the descriptor is still owned by hardware */
+	if (unlikely(tx_descs[desc_entry].desc_control
+		     & MSGDMA_PREF_DESC_CTL_OWNED_BY_HW))
+		return NETDEV_TX_BUSY;
+
+	/* write descriptor entries */
+	tx_descs[desc_entry].len = buffer->len;
+	tx_descs[desc_entry].read_addr_lo = lower_32_bits(buffer->dma_addr);
+	tx_descs[desc_entry].read_addr_hi = upper_32_bits(buffer->dma_addr);
+
+	/* set the control bits and set owned by hw */
+	tx_descs[desc_entry].desc_control = (MSGDMA_DESC_CTL_TX_SINGLE
+			| MSGDMA_PREF_DESC_CTL_OWNED_BY_HW);
+
+	if (netif_msg_tx_queued(priv))
+		netdev_info(priv->dev, "%s: cons: %d prod: %d",
+			    __func__, priv->tx_cons, priv->tx_prod);
+
+	return NETDEV_TX_OK;
+}
+
+u32 msgdma_pref_tx_completions(struct altera_tse_private *priv)
+{
+	u32 control;
+	u32 ready = 0;
+	u32 cons = priv->tx_cons;
+	u32 desc_ringsize = priv->tx_ring_size * 2;
+	u32 ringsize = priv->tx_ring_size;
+	u64 ns = 0;
+	struct msgdma_pref_extended_desc *cur;
+	struct tse_buffer *tx_buff;
+	struct skb_shared_hwtstamps shhwtstamp;
+	int i;
+
+	if (netif_msg_tx_done(priv))
+		for (i = 0; i < desc_ringsize; i++)
+			netdev_info(priv->dev, "%s: desc: %d control 0x%x\n",
+				    __func__, i,
+				    priv->pref_txdesc[i].desc_control);
+
+	cur = &priv->pref_txdesc[cons % desc_ringsize];
+	control = cur->desc_control;
+	tx_buff = &priv->tx_ring[cons % ringsize];
+
+	while (!(control & MSGDMA_PREF_DESC_CTL_OWNED_BY_HW) &&
+	       (priv->tx_prod != (cons + ready)) && control) {
+		if (skb_shinfo(tx_buff->skb)->tx_flags & SKBTX_IN_PROGRESS) {
+			/* Timestamping is enabled, pass timestamp back */
+			ns = timestamp_to_ns(cur);
+			memset(&shhwtstamp, 0,
+			       sizeof(struct skb_shared_hwtstamps));
+			shhwtstamp.hwtstamp = ns_to_ktime(ns);
+			skb_tstamp_tx(tx_buff->skb, &shhwtstamp);
+		}
+
+		if (netif_msg_tx_done(priv))
+			netdev_info(priv->dev, "%s: cur: %d ts: %lld ns\n",
+				    __func__,
+				    ((cons + ready) % desc_ringsize), ns);
+
+		/* clear data */
+		cur->desc_control = 0;
+		cur->timestamp_96b[0] = 0;
+		cur->timestamp_96b[1] = 0;
+		cur->timestamp_96b[2] = 0;
+
+		ready++;
+		cur = &priv->pref_txdesc[(cons + ready) % desc_ringsize];
+		tx_buff = &priv->tx_ring[(cons + ready) % ringsize];
+		control = cur->desc_control;
+	}
+
+	return ready;
+}
+
+void msgdma_pref_reset(struct altera_tse_private *priv)
+{
+	int counter;
+
+	/* turn off polling */
+	tse_clear_bit(priv->rx_pref_csr, msgdma_pref_csroffs(control),
+		      MSGDMA_PREF_CTL_DESC_POLL_EN);
+	tse_clear_bit(priv->tx_pref_csr, msgdma_pref_csroffs(control),
+		      MSGDMA_PREF_CTL_DESC_POLL_EN);
+
+	/* Reset the RX Prefetcher */
+	csrwr32(MSGDMA_PREF_STAT_IRQ, priv->rx_pref_csr,
+		msgdma_pref_csroffs(status));
+	csrwr32(MSGDMA_PREF_CTL_RESET, priv->rx_pref_csr,
+		msgdma_pref_csroffs(control));
+
+	counter = 0;
+	while (counter++ < ALTERA_TSE_SW_RESET_WATCHDOG_CNTR) {
+		if (tse_bit_is_clear(priv->rx_pref_csr,
+				     msgdma_pref_csroffs(control),
+				     MSGDMA_PREF_CTL_RESET))
+			break;
+		udelay(1);

drivers/net/ethernet/altera/altera_msgdma_prefetcher.c new file +12 -0

+	/* Reset the TX Prefetcher */
+	csrwr32(MSGDMA_PREF_STAT_IRQ, priv->tx_pref_csr,
+		msgdma_pref_csroffs(status));
+	csrwr32(MSGDMA_PREF_CTL_RESET, priv->tx_pref_csr,
+		msgdma_pref_csroffs(control));
+
+	counter = 0;
+	while (counter++ < ALTERA_TSE_SW_RESET_WATCHDOG_CNTR) {
+		if (tse_bit_is_clear(priv->tx_pref_csr,
+				     msgdma_pref_csroffs(control),
+				     MSGDMA_PREF_CTL_RESET))
+			break;

drivers/net/ethernet/altera/altera_msgdma_prefetcher.c new file +44 -0

+	msgdma_reset(priv);
+}
+
+/* Setup the RX and TX prefetchers to poll the descriptor chain */
+void msgdma_pref_start_rxdma(struct altera_tse_private *priv)
+{
+	csrwr32(priv->rx_poll_freq, priv->rx_pref_csr,
+		msgdma_pref_csroffs(desc_poll_freq));
+	csrwr32(lower_32_bits(priv->pref_rxdescphys), priv->rx_pref_csr,
+		msgdma_pref_csroffs(next_desc_lo));
+	csrwr32(upper_32_bits(priv->pref_rxdescphys), priv->rx_pref_csr,
+		msgdma_pref_csroffs(next_desc_hi));
+	tse_set_bit(priv->rx_pref_csr, msgdma_pref_csroffs(control),
+		    MSGDMA_PREF_CTL_DESC_POLL_EN | MSGDMA_PREF_CTL_RUN);
+}
+
+void msgdma_pref_start_txdma(struct altera_tse_private *priv)
+{
+	csrwr32(priv->tx_poll_freq, priv->tx_pref_csr,
+		msgdma_pref_csroffs(desc_poll_freq));
+	csrwr32(lower_32_bits(priv->pref_txdescphys), priv->tx_pref_csr,
+		msgdma_pref_csroffs(next_desc_lo));
+	csrwr32(upper_32_bits(priv->pref_txdescphys), priv->tx_pref_csr,
+		msgdma_pref_csroffs(next_desc_hi));
+	tse_set_bit(priv->tx_pref_csr, msgdma_pref_csroffs(control),
+		    MSGDMA_PREF_CTL_DESC_POLL_EN | MSGDMA_PREF_CTL_RUN);
+}
+
+/* Add MSGDMA Prefetcher Descriptor to descriptor list
+ *   -> This should never be called when a descriptor isn't available
+ */
+void msgdma_pref_add_rx_desc(struct altera_tse_private *priv,
+			     struct tse_buffer *rxbuffer)
+{
+	struct msgdma_pref_extended_desc *rx_descs = priv->pref_rxdesc;
+	u32 desc_entry = priv->pref_rx_prod % (priv->rx_ring_size * 2);
+
+	/* write descriptor entries */
+	rx_descs[desc_entry].len = priv->rx_dma_buf_sz;
+	rx_descs[desc_entry].write_addr_lo = lower_32_bits(rxbuffer->dma_addr);
+	rx_descs[desc_entry].write_addr_hi = upper_32_bits(rxbuffer->dma_addr);
+
+	/* set the control bits and set owned by hw */
+	rx_descs[desc_entry].desc_control = (MSGDMA_DESC_CTL_END_ON_EOP

drivers/net/ethernet/altera/altera_msgdma_prefetcher.c new file +53 -0

+	priv->pref_rx_prod++;
+
+	if (netif_msg_rx_status(priv)) {
+		netdev_info(priv->dev, "%s: desc: %d buf: %d control 0x%x\n",
+			    __func__, desc_entry,
+			    priv->rx_prod % priv->rx_ring_size,
+			    priv->pref_rxdesc[desc_entry].desc_control);
+	}
+}
+
+u32 msgdma_pref_rx_status(struct altera_tse_private *priv)
+{
+	u32 rxstatus = 0;
+	u32 pktlength;
+	u32 pktstatus;
+	u64 ns = 0;
+	u32 entry = priv->rx_cons % priv->rx_ring_size;
+	u32 desc_entry = priv->rx_prod % (priv->rx_ring_size * 2);
+	struct msgdma_pref_extended_desc *rx_descs = priv->pref_rxdesc;
+	struct skb_shared_hwtstamps *shhwtstamp = NULL;
+	struct tse_buffer *rx_buff = priv->rx_ring;
+
+	/* if the current entry is not owned by hardware, process it */
+	if (!(rx_descs[desc_entry].desc_control
+	      & MSGDMA_PREF_DESC_CTL_OWNED_BY_HW) &&
+	      rx_descs[desc_entry].desc_control) {
+		pktlength = rx_descs[desc_entry].bytes_transferred;
+		pktstatus = rx_descs[desc_entry].desc_status;
+		rxstatus = pktstatus;
+		rxstatus = rxstatus << 16;
+		rxstatus |= (pktlength & 0xffff);
+
+		/* get the timestamp */
+		if (priv->hwts_rx_en) {
+			ns = timestamp_to_ns(&rx_descs[desc_entry]);
+			shhwtstamp = skb_hwtstamps(rx_buff[entry].skb);
+			memset(shhwtstamp, 0,
+			       sizeof(struct skb_shared_hwtstamps));
+			shhwtstamp->hwtstamp = ns_to_ktime(ns);
+		}
+
+		/* clear data */
+		rx_descs[desc_entry].desc_control = 0;
+		rx_descs[desc_entry].timestamp_96b[0] = 0;
+		rx_descs[desc_entry].timestamp_96b[1] = 0;
+		rx_descs[desc_entry].timestamp_96b[2] = 0;
+
+		if (netif_msg_rx_status(priv))
+			netdev_info(priv->dev, "%s: desc: %d buf: %d ts: %lld ns",
+				    __func__, desc_entry, entry, ns);
+	}
+	return rxstatus;
+}

drivers/net/ethernet/altera/altera_msgdma_prefetcher.h new file +30 -0

new file mode 100644
index 000000000000..b520b1eb85c0
@@ -0,0 +1,30 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/* MSGDMA Prefetcher driver for Altera ethernet devices
+ *
+ * Copyright (C) 2018 Intel Corporation. All rights reserved.
+ * Author(s):
+ *   Dalon Westergreen <[email protected]>
+ */
+
+#ifndef __ALTERA_PREF_MSGDMA_H__
+#define __ALTERA_PREF_MSGDMA_H__
+
+void msgdma_pref_reset(struct altera_tse_private *priv);
+void msgdma_pref_enable_txirq(struct altera_tse_private *priv);
+void msgdma_pref_enable_rxirq(struct altera_tse_private *priv);
+void msgdma_pref_disable_rxirq(struct altera_tse_private *priv);
+void msgdma_pref_disable_txirq(struct altera_tse_private *priv);
+void msgdma_pref_clear_rxirq(struct altera_tse_private *priv);
+void msgdma_pref_clear_txirq(struct altera_tse_private *priv);
+u32 msgdma_pref_tx_completions(struct altera_tse_private *priv);
+void msgdma_pref_add_rx_desc(struct altera_tse_private *priv,
+			     struct tse_buffer *buffer);
+netdev_tx_t msgdma_pref_tx_buffer(struct altera_tse_private *priv,
+				  struct tse_buffer *buffer);
+u32 msgdma_pref_rx_status(struct altera_tse_private *priv);
+int msgdma_pref_initialize(struct altera_tse_private *priv);
+void msgdma_pref_uninitialize(struct altera_tse_private *priv);
+void msgdma_pref_start_rxdma(struct altera_tse_private *priv);
+void msgdma_pref_start_txdma(struct altera_tse_private *priv);
+
+#endif /*  __ALTERA_PREF_MSGDMA_H__ */

drivers/net/ethernet/altera/altera_msgdmahw_prefetcher.h new file +87 -0

new file mode 100644
index 000000000000..e0484a3dc66e
@@ -0,0 +1,87 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/* MSGDMA Prefetcher driver for Altera ethernet devices
+ *
+ * Copyright (C) 2018 Intel Corporation.
+ * Contributors:
+ *   Dalon Westergreen
+ *   Thomas Chou
+ *   Ian Abbott
+ *   Yuriy Kozlov
+ *   Tobias Klauser
+ *   Andriy Smolskyy
+ *   Roman Bulgakov
+ *   Dmytro Mytarchuk
+ *   Matthew Gerlach
+ */
+
+#ifndef __ALTERA_MSGDMAHW_PREFETCHER_H__
+#define __ALTERA_MSGDMAHW_PREFETCHER_H__
+
+/* mSGDMA prefetcher extended prefectcher descriptor format
+ */
+struct msgdma_pref_extended_desc {
+	/* data buffer source address low bits */
+	u32 read_addr_lo;
+	/* data buffer destination address low bits */
+	u32 write_addr_lo;
+	/* the number of bytes to transfer */
+	u32 len;
+	/* next descriptor low address */
+	u32 next_desc_lo;
+	/* number of bytes transferred */
+	u32 bytes_transferred;
+	u32 desc_status;
+	u32 reserved_18;
+	/* bit 31:24 write burst */
+	/* bit 23:16 read burst */
+	/* bit 15:0  sequence number */
+	u32 burst_seq_num;
+	/* bit 31:16 write stride */
+	/* bit 15:0  read stride */
+	u32 stride;
+	/* data buffer source address high bits */
+	u32 read_addr_hi;
+	/* data buffer destination address high bits */
+	u32 write_addr_hi;
+	/* next descriptor high address */
+	u32 next_desc_hi;
+	/* prefetcher mod now writes these reserved bits*/
+	/* Response bits [191:160] */
+	u32 timestamp_96b[3];
+	/* desc_control */
+	u32 desc_control;
+};
+
+/* mSGDMA Prefetcher Descriptor Status bits */
+#define MSGDMA_PREF_DESC_STAT_STOPPED_ON_EARLY		BIT(8)
+#define MSGDMA_PREF_DESC_STAT_MASK			0xFF
+
+/* mSGDMA Prefetcher Descriptor Control bits */
+/* bit 31 and bits 29-0 are the same as the normal dispatcher ctl flags */
+#define MSGDMA_PREF_DESC_CTL_OWNED_BY_HW		BIT(30)
+
+/* mSGDMA Prefetcher CSR */
+struct msgdma_prefetcher_csr {
+	u32 control;
+	u32 next_desc_lo;
+	u32 next_desc_hi;
+	u32 desc_poll_freq;
+	u32 status;
+};
+
+/* mSGDMA Prefetcher Control */
+#define MSGDMA_PREF_CTL_PARK				BIT(4)
+#define MSGDMA_PREF_CTL_GLOBAL_INTR			BIT(3)
+#define MSGDMA_PREF_CTL_RESET				BIT(2)
+#define MSGDMA_PREF_CTL_DESC_POLL_EN			BIT(1)
+#define MSGDMA_PREF_CTL_RUN				BIT(0)
+
+#define MSGDMA_PREF_POLL_FREQ_MASK			0xFFFF
+
+/* mSGDMA Prefetcher Status */
+#define MSGDMA_PREF_STAT_IRQ				BIT(0)
+
+#define msgdma_pref_csroffs(a) (offsetof(struct msgdma_prefetcher_csr, a))
+#define msgdma_pref_descroffs(a) (offsetof(struct msgdma_pref_extended_desc, a))
+
+#endif /* __ALTERA_MSGDMAHW_PREFETCHER_H__*/

drivers/net/ethernet/altera/altera_tse.h +14 -0

index 14515a76d634..31f11fdc94b4 100644
@@ -393,6 +393,7 @@ struct altera_tse_private;
 
  #define ALTERA_DTYPE_SGDMA 1
  #define ALTERA_DTYPE_MSGDMA 2
+#define ALTERA_DTYPE_MSGDMA_PREF 3
 
  /* standard DMA interface for SGDMA and MSGDMA */
  struct altera_dmaops {

@@ -445,6 +446,19 @@ struct altera_tse_private {
  	void __iomem *tx_dma_csr;
  	void __iomem *tx_dma_desc;
 
+	/* mSGDMA Rx Prefecher address space */
+	void __iomem *rx_pref_csr;
+	struct msgdma_pref_extended_desc *pref_rxdesc;
+	dma_addr_t pref_rxdescphys;
+	u32 pref_rx_prod;
+
+	/* mSGDMA Tx Prefecher address space */
+	void __iomem *tx_pref_csr;
+	struct msgdma_pref_extended_desc *pref_txdesc;
+	dma_addr_t pref_txdescphys;
+	u32 rx_poll_freq;
+	u32 tx_poll_freq;
+
  	/* Rx buffers queue */
  	struct tse_buffer *rx_ring;
  	u32 rx_cons;

drivers/net/ethernet/altera/altera_tse_main.c +0 -0

index 60f0c43a9334..5cb3ea4314f2 100644

drivers/net/ethernet/altera/altera_tse_main.c +44 -0

  static atomic_t instance_count = ATOMIC_INIT(~0);
  /* Module parameters */

@@ -1515,6 +1516,34 @@ static int altera_tse_probe(struct platform_device *pdev)
  		priv->rxdescmem = resource_size(dma_res);
  		priv->rxdescmem_busaddr = dma_res->start;
 
+	} else if (priv->dmaops &&
+			   priv->dmaops->altera_dtype ==
+			   ALTERA_DTYPE_MSGDMA_PREF) {
+		/* mSGDMA Rx Prefetcher address space */
+		ret = request_and_map(pdev, "rx_pref", &dma_res,
+				      &priv->rx_pref_csr);
+		if (ret)
+			goto err_free_netdev;
+
+		/* mSGDMA Tx Prefetcher address space */
+		ret = request_and_map(pdev, "tx_pref", &dma_res,
+				      &priv->tx_pref_csr);
+		if (ret)
+			goto err_free_netdev;
+
+		/* get prefetcher rx poll frequency from device tree */
+		if (of_property_read_u32(pdev->dev.of_node, "rx-poll-freq",
+					 &priv->rx_poll_freq)) {
+			dev_info(&pdev->dev, "Defaulting RX Poll Frequency to 128\n");
+			priv->rx_poll_freq = 128;
+		}
+
+		/* get prefetcher rx poll frequency from device tree */
+		if (of_property_read_u32(pdev->dev.of_node, "tx-poll-freq",
+					 &priv->tx_poll_freq)) {
+			dev_info(&pdev->dev, "Defaulting TX Poll Frequency to 128\n");
+			priv->tx_poll_freq = 128;
+		}
  	} else {
  		goto err_free_netdev;
  	}

@@ -1773,7 +1802,29 @@ static const struct altera_dmaops altera_dtype_msgdma = {
  	.start_txdma = NULL,
  };
 
+static const struct altera_dmaops altera_dtype_prefetcher = {
+	.altera_dtype = ALTERA_DTYPE_MSGDMA_PREF,
+	.dmamask = 64,
+	.reset_dma = msgdma_pref_reset,
+	.enable_txirq = msgdma_pref_enable_txirq,
+	.enable_rxirq = msgdma_pref_enable_rxirq,
+	.disable_txirq = msgdma_pref_disable_txirq,
+	.disable_rxirq = msgdma_pref_disable_rxirq,
+	.clear_txirq = msgdma_pref_clear_txirq,
+	.clear_rxirq = msgdma_pref_clear_rxirq,
+	.tx_buffer = msgdma_pref_tx_buffer,
+	.tx_completions = msgdma_pref_tx_completions,
+	.add_rx_desc = msgdma_pref_add_rx_desc,
+	.get_rx_status = msgdma_pref_rx_status,
+	.init_dma = msgdma_pref_initialize,
+	.uninit_dma = msgdma_pref_uninitialize,

Hi Dalon,

Quoted 73 lines · On 12/13/18 11:52 AM, [email protected] wrote:

From: Dalon Westergreen <[email protected]>

Add support for the mSGDMA prefetcher. The prefetcher adds support for a linked list of descriptors in system memory. The prefetcher feeds these to the mSGDMA dispatcher.

The prefetcher is configured to poll for the next descriptor in the list to be owned by hardware, then pass the descriptor to the dispatcher. It will then poll the next descriptor until it is owned by hardware.

The dispatcher responses are written back to the appropriate descriptor, and the owned by hardware bit is cleared.

The driver sets up a linked list twice the tx and rx ring sizes, with the last descriptor pointing back to the first. This ensures that the ring of descriptors will always have inactive descriptors preventing the prefetcher from looping over and reusing descriptors inappropriately. The prefetcher will continuously loop over these descriptors. The driver modifies descriptors as required to update the skb address and length as well as the owned by hardware bit.

In addition to the above, the mSGDMA prefetcher can be used to handle rx and tx timestamps coming from the ethernet ip. These can be included in the prefetcher response in the descriptor.

Signed-off-by Dalon Westergreen <[email protected]>

---
Changes from v1:
-> Alphabatize includes
-> update xmit function to return type net_tx_t
-> Cleanup msgdms descriptor ring by making is more apparent
that the msgdma descriptor ring is 2 * ring_size

---
  drivers/net/ethernet/altera/Makefile          |   2 +-
  .../altera/altera_msgdma_prefetcher.c         | 432 ++++++++++++++++++
  .../altera/altera_msgdma_prefetcher.h         |  30 ++
  .../altera/altera_msgdmahw_prefetcher.h       |  87 ++++
  drivers/net/ethernet/altera/altera_tse.h      |  14 +
  drivers/net/ethernet/altera/altera_tse_main.c |  51 +++
  6 files changed, 615 insertions(+), 1 deletion(-)

create mode 100644 drivers/net/ethernet/altera/altera_msgdma_prefetcher.c create mode 100644 drivers/net/ethernet/altera/altera_msgdma_prefetcher.h create mode 100644
drivers/net/ethernet/altera/altera_msgdmahw_prefetcher.h

drivers/net/ethernet/altera/Makefile +1 -1

index 3e622b4c105a..f6627615c6c1 100644
@@ -5,4 +5,4 @@
  obj-$(CONFIG_ALTERA_TSE) += altera_tse.o
  altera_tse-objs := altera_tse_main.o altera_tse_ethtool.o \
  		   altera_msgdma.o altera_sgdma.o altera_utils.o \
-		   intel_fpga_tod.o
+		   intel_fpga_tod.o altera_msgdma_prefetcher.o

drivers/net/ethernet/altera/altera_msgdma_prefetcher.c new file +8 -0

new file mode 100644
index 000000000000..f50ea62f687d
@@ -0,0 +1,432 @@
+// SPDX-License-Identifier: GPL-2.0
+/* MSGDMA Prefetcher driver for Altera ethernet devices
+ *
+ * Copyright (C) 2018 Intel Corporation. All rights reserved.
+ * Author(s):
+ *   Dalon Westergreen <[email protected]>
+ */
+

drivers/net/ethernet/altera/altera_msgdma_prefetcher.c line 18

Quoted 10 lines

drivers/net/ethernet/altera/altera_msgdma_prefetcher.c new file +10 -0

+#include <linux/list.h>
+#include <linux/netdevice.h>
+#include <linux/net_tstamp.h>
+#include "altera_tse.h"
+#include "altera_msgdma.h"
+#include "altera_msgdmahw.h"
+#include "altera_msgdma_prefetcher.h"
+#include "altera_msgdmahw_prefetcher.h"
+#include "altera_utils.h"
+

Alphabetize includes. altera_tse.h can be just before altera_utils.h

drivers/net/ethernet/altera/altera_msgdma_prefetcher.c

Quoted 7 lines

  static const struct of_device_id altera_tse_ids[] = {

drivers/net/ethernet/altera/altera_msgdma_prefetcher.c new file +2 -0

+	{ .compatible = "altr,tse-msgdma-2.0",
+		.data = &altera_dtype_prefetcher, },
  	{ .compatible = "altr,tse-msgdma-1.0", .data = &altera_dtype_msgdma, },
  	{ .compatible = "altr,tse-1.0", .data = &altera_dtype_sgdma, },
  	{ .compatible = "ALTR,tse-1.0", .data = &altera_dtype_sgdma, },

Hmm. I'm not sure you sent the right version - this looks very similar to v1.