net: macb: rework suspend/resume

This commit is based on internal commit [1] and reworks it based on
latest driver format and keeping in mind that the driver is not used only
by Atmel/Microchip SAMA5 SoCs.

[1] commit db48b97
Author: Boris Brezillon <boris.brezillon@free-electrons.com>
Date:   Tue Dec 6 14:07:37 2016 +0100

    net: macb: Add support for sama5d2 suspend-to-mem

    Signed-off-by: Boris Brezillon <boris.brezillon@free-electrons.com>

Signed-off-by: Claudiu Beznea <claudiu.beznea@microchip.com>

Author: claudiubeznea

drivers/net/ethernet/cadence/macb.h

@@ -1077,13 +1077,45 @@ struct macb_ptp_info {
 			 struct ifreq *ifr, int cmd);
 };
 
+struct macb_sama5d2_pm_data {
+	u32 etht;
+	u32 usrio;
+};
+
+struct macb_pm_ops {
+	int (*suspend)(struct macb *bp);
+	int (*resume)(struct macb *bp);
+};
+
+struct macb_pm {
+	bool				(*can_wol)(void);
+	const struct macb_pm_ops	*ops;
+	const u32			data_size;
+};
+
+#ifdef CONFIG_PM
+#define MACB_CONFIG_PM(name, can_wol_fn, suspend_fn, resume_fn, data_sz) \
+static const struct macb_pm_ops name##_ops = { \
+	.suspend = suspend_fn, \
+	.resume = resume_fn, \
+}; \
+static const struct macb_pm name = { \
+	.can_wol = can_wol_fn, \
+	.ops = &name##_ops, \
+	.data_size = data_sz, \
+}
+#else
+#define MACB_CONFIG_PM(name, can_wol_fn, suspend_fn, resume_fn, data_sz)
+#endif
+
 struct macb_config {
 	u32			caps;
 	unsigned int		dma_burst_length;
 	int	(*clk_init)(struct platform_device *pdev, struct clk **pclk,
 			    struct clk **hclk, struct clk **tx_clk,
 			    struct clk **rx_clk);
 	int	(*init)(struct platform_device *pdev);
+	const struct macb_pm	*pm;
 	int	jumbo_max_len;
 };
 
@@ -1214,6 +1246,8 @@ struct macb {
 	int	tx_bd_rd_prefetch;
 
 	const struct macb_config *config;
+
+	void *pm_data;
 };
 
 #ifdef CONFIG_MACB_USE_HWSTAMP

drivers/net/ethernet/cadence/macb_main.c

@@ -25,6 +25,7 @@
 #include <linux/netdevice.h>
 #include <linux/etherdevice.h>
 #include <linux/dma-mapping.h>
+#include <linux/platform_data/atmel.h>
 #include <linux/platform_data/macb.h>
 #include <linux/platform_device.h>
 #include <linux/phy.h>
@@ -2797,10 +2798,14 @@ static int macb_get_ts_info(struct net_device *netdev,
 
 static void gem_enable_flow_filters(struct macb *bp, bool enable)
 {
+	struct net_device *netdev = bp->dev;
 	struct ethtool_rx_fs_item *item;
 	u32 t2_scr;
 	int num_t2_scr;
 
+	if (!(netdev->features & NETIF_F_NTUPLE))
+		return;
+
 	num_t2_scr = GEM_BFEXT(T2SCR, gem_readl(bp, DCFG8));
 
 	list_for_each_entry(item, &bp->rx_fs_list.list, list) {
@@ -2960,8 +2965,7 @@ static int gem_add_flow_filter(struct net_device *netdev,
 	gem_prog_cmp_regs(bp, fs);
 	bp->rx_fs_list.count++;
 	/* enable filtering if NTUPLE on */
-	if (netdev->features & NETIF_F_NTUPLE)
-		gem_enable_flow_filters(bp, 1);
+	gem_enable_flow_filters(bp, 1);
 
 	spin_unlock_irqrestore(&bp->rx_fs_lock, flags);
 	return 0;
@@ -3149,46 +3153,86 @@ static int macb_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
 	}
 }
 
+static inline void macb_set_txcsum_feature(struct macb *bp,
+					   netdev_features_t features)
+{
+	u32 val;
+
+	if (!macb_is_gem(bp))
+		return;
+
+	val = gem_readl(bp, DMACFG);
+	if (features & NETIF_F_HW_CSUM)
+		val |= GEM_BIT(TXCOEN);
+	else
+		val &= ~GEM_BIT(TXCOEN);
+
+	gem_writel(bp, DMACFG, val);
+}
+
+static inline void macb_set_rxcsum_feature(struct macb *bp,
+					   netdev_features_t features)
+{
+	struct net_device *netdev = bp->dev;
+	u32 val;
+
+	if (!macb_is_gem(bp))
+		return;
+
+	val = gem_readl(bp, NCFGR);
+	if ((features & NETIF_F_RXCSUM) && !(netdev->flags & IFF_PROMISC))
+		val |= GEM_BIT(RXCOEN);
+	else
+		val &= ~GEM_BIT(RXCOEN);
+
+	gem_writel(bp, NCFGR, val);
+}
+
+static inline void macb_set_rxflow_feature(struct macb *bp,
+					   netdev_features_t features)
+{
+	if (!macb_is_gem(bp))
+		return;
+
+	gem_enable_flow_filters(bp, !!(features & NETIF_F_NTUPLE));
+}
+
 static int macb_set_features(struct net_device *netdev,
 			     netdev_features_t features)
 {
 	struct macb *bp = netdev_priv(netdev);
 	netdev_features_t changed = features ^ netdev->features;
 
 	/* TX checksum offload */
-	if ((changed & NETIF_F_HW_CSUM) && macb_is_gem(bp)) {
-		u32 dmacfg;
-
-		dmacfg = gem_readl(bp, DMACFG);
-		if (features & NETIF_F_HW_CSUM)
-			dmacfg |= GEM_BIT(TXCOEN);
-		else
-			dmacfg &= ~GEM_BIT(TXCOEN);
-		gem_writel(bp, DMACFG, dmacfg);
-	}
+	if (changed & NETIF_F_HW_CSUM)
+		macb_set_txcsum_feature(bp, features);
 
 	/* RX checksum offload */
-	if ((changed & NETIF_F_RXCSUM) && macb_is_gem(bp)) {
-		u32 netcfg;
-
-		netcfg = gem_readl(bp, NCFGR);
-		if (features & NETIF_F_RXCSUM &&
-		    !(netdev->flags & IFF_PROMISC))
-			netcfg |= GEM_BIT(RXCOEN);
-		else
-			netcfg &= ~GEM_BIT(RXCOEN);
-		gem_writel(bp, NCFGR, netcfg);
-	}
+	if (changed & NETIF_F_RXCSUM)
+		macb_set_rxcsum_feature(bp, features);
 
 	/* RX Flow Filters */
-	if ((changed & NETIF_F_NTUPLE) && macb_is_gem(bp)) {
-		bool turn_on = features & NETIF_F_NTUPLE;
+	if (changed & NETIF_F_NTUPLE)
+		macb_set_rxflow_feature(bp, features);
 
-		gem_enable_flow_filters(bp, turn_on);
-	}
 	return 0;
 }
 
+static void macb_restore_features(struct macb *bp)
+{
+	struct net_device *netdev = bp->dev;
+	netdev_features_t features = netdev->features;
+
+	/* TX checksum offload */
+	macb_set_txcsum_feature(bp, features);
+
+	/* RX checksum offload */
+	macb_set_rxcsum_feature(bp, features);
+
+	/* RX Flow Filters */
+	macb_set_rxflow_feature(bp, features);
+}
+
 static const struct net_device_ops macb_netdev_ops = {
 	.ndo_open		= macb_open,
 	.ndo_stop		= macb_close,
@@ -3830,6 +3874,71 @@ static int at91ether_init(struct platform_device *pdev)
 	return 0;
 }
 
+static bool __maybe_unused macb_sama5d2_can_wol(void)
+{
+#ifdef CONFIG_ARCH_AT91
+	return at91_suspend_entering_slow_clock();
+#else
+	return true;
+#endif
+}
+
+static bool __maybe_unused macb_sama5d2_backup(void)
+{
+#ifdef CONFIG_ARCH_AT91
+	return at91_suspend_entering_backup();
+#else
+	return false;
+#endif
+}
+
+static int __maybe_unused macb_sama5d2_suspend(struct macb *bp)
+{
+	struct macb_sama5d2_pm_data *pm_data = bp->pm_data;
+	struct net_device *netdev = bp->dev;
+
+	if (!macb_sama5d2_backup())
+		return -EPERM;
+
+	if (netdev->hw_features & NETIF_F_NTUPLE)
+		pm_data->etht = gem_readl_n(bp, ETHT, SCRT2_ETHT);
+
+	if (!(bp->caps & MACB_CAPS_USRIO_DISABLED))
+		pm_data->usrio = macb_or_gem_readl(bp, USRIO);
+
+	if (netif_running(netdev))
+		macb_close(netdev);
+
+	return 0;
+}
+
+static int __maybe_unused macb_sama5d2_resume(struct macb *bp)
+{
+	struct macb_sama5d2_pm_data *pm_data = bp->pm_data;
+	struct net_device *netdev = bp->dev;
+
+	if (!macb_sama5d2_backup())
+		return -EPERM;
+
+	if (netdev->hw_features & NETIF_F_NTUPLE)
+		gem_writel_n(bp, ETHT, SCRT2_ETHT, pm_data->etht);
+
+	if (!(bp->caps & MACB_CAPS_USRIO_DISABLED))
+		macb_or_gem_writel(bp, USRIO, pm_data->usrio);
+
+	if (netif_running(netdev))
+		macb_open(netdev);
+
+	macb_set_rx_mode(bp->dev);
+	macb_restore_features(bp);
+
+	return 0;
+}
+
+MACB_CONFIG_PM(macb_sama5d2_pm, macb_sama5d2_can_wol,
+	       macb_sama5d2_suspend, macb_sama5d2_resume,
+	       sizeof(struct macb_sama5d2_pm_data));
+
 static const struct macb_config at91sam9260_config = {
 	.caps = MACB_CAPS_USRIO_HAS_CLKEN | MACB_CAPS_USRIO_DEFAULT_IS_MII_GMII,
 	.clk_init = macb_clk_init,
@@ -3848,6 +3957,7 @@ static const struct macb_config sama5d2_config = {
 	.dma_burst_length = 16,
 	.clk_init = macb_clk_init,
 	.init = macb_init,
+	.pm = &macb_sama5d2_pm,
 };
 
 static const struct macb_config sama5d3_config = {
@@ -3989,6 +4099,18 @@ static int macb_probe(struct platform_device *pdev)
 	bp->tx_clk = tx_clk;
 	bp->rx_clk = rx_clk;
 
+	if (bp->config->pm && bp->config->pm->data_size > 0) {
+		bp->pm_data = devm_kzalloc(&pdev->dev,
+					   bp->config->pm->data_size,
+					   GFP_KERNEL);
+		if (!bp->pm_data) {
+			err = -ENOMEM;
+			goto err_out_free_netdev;
+		}
+	} else {
+		bp->pm_data = NULL;
+	}
+
 	bp->wol = 0;
 	if (of_get_property(np, "magic-packet", NULL))
 		bp->wol |= MACB_WOL_HAS_MAGIC_PACKET;
@@ -4140,15 +4262,23 @@ static int __maybe_unused macb_suspend(struct device *dev)
 	struct platform_device *pdev = to_platform_device(dev);
 	struct net_device *netdev = platform_get_drvdata(pdev);
 	struct macb *bp = netdev_priv(netdev);
+	bool can_wol = true;
 
 	netif_carrier_off(netdev);
 	netif_device_detach(netdev);
 
-	if (bp->wol & MACB_WOL_ENABLED) {
+	if (bp->config->pm && bp->config->pm->can_wol())
+		can_wol = bp->config->pm->can_wol();
+
+	if (can_wol && (bp->wol & MACB_WOL_ENABLED)) {
 		macb_writel(bp, IER, MACB_BIT(WOL));
 		macb_writel(bp, WOL, MACB_BIT(MAG));
 		enable_irq_wake(bp->queues[0].irq);
 	} else {
+		if (bp->config->pm && bp->config->pm->ops &&
+		    bp->config->pm->ops->suspend)
+			bp->config->pm->ops->suspend(bp);
+
 		clk_disable_unprepare(bp->tx_clk);
 		clk_disable_unprepare(bp->hclk);
 		clk_disable_unprepare(bp->pclk);
@@ -4163,8 +4293,12 @@ static int __maybe_unused macb_resume(struct device *dev)
 	struct platform_device *pdev = to_platform_device(dev);
 	struct net_device *netdev = platform_get_drvdata(pdev);
 	struct macb *bp = netdev_priv(netdev);
+	bool can_wol = true;
 
-	if (bp->wol & MACB_WOL_ENABLED) {
+	if (bp->config->pm && bp->config->pm->can_wol)
+		can_wol = bp->config->pm->can_wol();
+
+	if (can_wol && (bp->wol & MACB_WOL_ENABLED)) {
 		macb_writel(bp, IDR, MACB_BIT(WOL));
 		macb_writel(bp, WOL, 0);
 		disable_irq_wake(bp->queues[0].irq);
@@ -4173,6 +4307,10 @@ static int __maybe_unused macb_resume(struct device *dev)
 		clk_prepare_enable(bp->hclk);
 		clk_prepare_enable(bp->tx_clk);
 		clk_prepare_enable(bp->rx_clk);
+
+		if (bp->config->pm && bp->config->pm->ops &&
+		    bp->config->pm->ops->resume)
+			bp->config->pm->ops->resume(bp);
 	}
 
 	netif_device_attach(netdev);