1 files changed, 65 insertions, 100 deletions

diff --git a/drivers/net/ethernet/freescale/gianfar_ethtool.c b/drivers/net/ethernet/freescale/gianfar_ethtool.c
index 63d234419cc1..891dbee6e6c1 100644
--- a/drivers/net/ethernet/freescale/gianfar_ethtool.c
+++ b/drivers/net/ethernet/freescale/gianfar_ethtool.c
@@ -44,10 +44,6 @@
 
 #include "gianfar.h"
 
-extern void gfar_start(struct net_device *dev);
-extern int gfar_clean_rx_ring(struct gfar_priv_rx_q *rx_queue,
-                              int rx_work_limit);
-
 #define GFAR_MAX_COAL_USECS 0xffff
 #define GFAR_MAX_COAL_FRAMES 0xff
 static void gfar_fill_stats(struct net_device *dev, struct ethtool_stats *dummy,
@@ -364,25 +360,11 @@ static int gfar_scoalesce(struct net_device *dev,
                           struct ethtool_coalesce *cvals)
 {
         struct gfar_private *priv = netdev_priv(dev);
-        int i = 0;
+        int i, err = 0;
 
         if (!(priv->device_flags & FSL_GIANFAR_DEV_HAS_COALESCE))
                 return -EOPNOTSUPP;
 
-        /* Set up rx coalescing */
-        /* As of now, we will enable/disable coalescing for all
-         * queues together in case of eTSEC2, this will be modified
-         * along with the ethtool interface
-         */
-        if ((cvals->rx_coalesce_usecs == 0) ||
-            (cvals->rx_max_coalesced_frames == 0)) {
-                for (i = 0; i < priv->num_rx_queues; i++)
-                        priv->rx_queue[i]->rxcoalescing = 0;
-        } else {
-                for (i = 0; i < priv->num_rx_queues; i++)
-                        priv->rx_queue[i]->rxcoalescing = 1;
-        }
-
         if (NULL == priv->phydev)
                 return -ENODEV;
 
@@ -399,6 +381,32 @@ static int gfar_scoalesce(struct net_device *dev,
                 return -EINVAL;
         }
 
+        /* Check the bounds of the values */
+        if (cvals->tx_coalesce_usecs > GFAR_MAX_COAL_USECS) {
+                netdev_info(dev, "Coalescing is limited to %d microseconds\n",
+                            GFAR_MAX_COAL_USECS);
+                return -EINVAL;
+        }
+
+        if (cvals->tx_max_coalesced_frames > GFAR_MAX_COAL_FRAMES) {
+                netdev_info(dev, "Coalescing is limited to %d frames\n",
+                            GFAR_MAX_COAL_FRAMES);
+                return -EINVAL;
+        }
+
+        while (test_and_set_bit_lock(GFAR_RESETTING, &priv->state))
+                cpu_relax();
+
+        /* Set up rx coalescing */
+        if ((cvals->rx_coalesce_usecs == 0) ||
+            (cvals->rx_max_coalesced_frames == 0)) {
+                for (i = 0; i < priv->num_rx_queues; i++)
+                        priv->rx_queue[i]->rxcoalescing = 0;
+        } else {
+                for (i = 0; i < priv->num_rx_queues; i++)
+                        priv->rx_queue[i]->rxcoalescing = 1;
+        }
+
         for (i = 0; i < priv->num_rx_queues; i++) {
                 priv->rx_queue[i]->rxic = mk_ic_value(
                         cvals->rx_max_coalesced_frames,
@@ -415,28 +423,22 @@ static int gfar_scoalesce(struct net_device *dev,
                         priv->tx_queue[i]->txcoalescing = 1;
         }
 
-        /* Check the bounds of the values */
-        if (cvals->tx_coalesce_usecs > GFAR_MAX_COAL_USECS) {
-                netdev_info(dev, "Coalescing is limited to %d microseconds\n",
-                            GFAR_MAX_COAL_USECS);
-                return -EINVAL;
-        }
-
-        if (cvals->tx_max_coalesced_frames > GFAR_MAX_COAL_FRAMES) {
-                netdev_info(dev, "Coalescing is limited to %d frames\n",
-                            GFAR_MAX_COAL_FRAMES);
-                return -EINVAL;
-        }
-
         for (i = 0; i < priv->num_tx_queues; i++) {
                 priv->tx_queue[i]->txic = mk_ic_value(
                         cvals->tx_max_coalesced_frames,
                         gfar_usecs2ticks(priv, cvals->tx_coalesce_usecs));
         }
 
-        gfar_configure_coalescing_all(priv);
+        if (dev->flags & IFF_UP) {
+                stop_gfar(dev);
+                err = startup_gfar(dev);
+        } else {
+                gfar_mac_reset(priv);
+        }
+
+        clear_bit_unlock(GFAR_RESETTING, &priv->state);
 
-        return 0;
+        return err;
 }
 
 /* Fills in rvals with the current ring parameters.  Currently,
@@ -467,15 +469,13 @@ static void gfar_gringparam(struct net_device *dev,
 }
 
 /* Change the current ring parameters, stopping the controller if
- * necessary so that we don't mess things up while we're in
- * motion.  We wait for the ring to be clean before reallocating
- * the rings.
+ * necessary so that we don't mess things up while we're in motion.
  */
 static int gfar_sringparam(struct net_device *dev,
                            struct ethtool_ringparam *rvals)
 {
         struct gfar_private *priv = netdev_priv(dev);
-        int err = 0, i = 0;
+        int err = 0, i;
 
         if (rvals->rx_pending > GFAR_RX_MAX_RING_SIZE)
                 return -EINVAL;
@@ -493,44 +493,25 @@ static int gfar_sringparam(struct net_device *dev,
                 return -EINVAL;
         }
 
+        while (test_and_set_bit_lock(GFAR_RESETTING, &priv->state))
+                cpu_relax();
 
-        if (dev->flags & IFF_UP) {
-                unsigned long flags;
-
-                /* Halt TX and RX, and process the frames which
-                 * have already been received
-                 */
-                local_irq_save(flags);
-                lock_tx_qs(priv);
-                lock_rx_qs(priv);
-
-                gfar_halt(dev);
-
-                unlock_rx_qs(priv);
-                unlock_tx_qs(priv);
-                local_irq_restore(flags);
-
-                for (i = 0; i < priv->num_rx_queues; i++)
-                        gfar_clean_rx_ring(priv->rx_queue[i],
-                                           priv->rx_queue[i]->rx_ring_size);
-
-                /* Now we take down the rings to rebuild them */
+        if (dev->flags & IFF_UP)
                 stop_gfar(dev);
-        }
 
-        /* Change the size */
-        for (i = 0; i < priv->num_rx_queues; i++) {
+        /* Change the sizes */
+        for (i = 0; i < priv->num_rx_queues; i++)
                 priv->rx_queue[i]->rx_ring_size = rvals->rx_pending;
+
+        for (i = 0; i < priv->num_tx_queues; i++)
                 priv->tx_queue[i]->tx_ring_size = rvals->tx_pending;
-                priv->tx_queue[i]->num_txbdfree =
-                        priv->tx_queue[i]->tx_ring_size;
-        }
 
         /* Rebuild the rings with the new size */
-        if (dev->flags & IFF_UP) {
+        if (dev->flags & IFF_UP)
                 err = startup_gfar(dev);
-                netif_tx_wake_all_queues(dev);
-        }
+
+        clear_bit_unlock(GFAR_RESETTING, &priv->state);
+
         return err;
 }
 
@@ -608,43 +589,29 @@ static int gfar_spauseparam(struct net_device *dev,
 
 int gfar_set_features(struct net_device *dev, netdev_features_t features)
 {
-        struct gfar_private *priv = netdev_priv(dev);
-        unsigned long flags;
-        int err = 0, i = 0;
         netdev_features_t changed = dev->features ^ features;
+        struct gfar_private *priv = netdev_priv(dev);
+        int err = 0;
 
-        if (changed & (NETIF_F_HW_VLAN_CTAG_TX|NETIF_F_HW_VLAN_CTAG_RX))
-                gfar_vlan_mode(dev, features);
-
-        if (!(changed & NETIF_F_RXCSUM))
+        if (!(changed & (NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_HW_VLAN_CTAG_RX |
+                         NETIF_F_RXCSUM)))
                 return 0;
 
-        if (dev->flags & IFF_UP) {
-                /* Halt TX and RX, and process the frames which
-                 * have already been received
-                 */
-                local_irq_save(flags);
-                lock_tx_qs(priv);
-                lock_rx_qs(priv);
-
-                gfar_halt(dev);
+        while (test_and_set_bit_lock(GFAR_RESETTING, &priv->state))
+                cpu_relax();
 
-                unlock_tx_qs(priv);
-                unlock_rx_qs(priv);
-                local_irq_restore(flags);
-
-                for (i = 0; i < priv->num_rx_queues; i++)
-                        gfar_clean_rx_ring(priv->rx_queue[i],
-                                           priv->rx_queue[i]->rx_ring_size);
+        dev->features = features;
 
+        if (dev->flags & IFF_UP) {
                 /* Now we take down the rings to rebuild them */
                 stop_gfar(dev);
-
-                dev->features = features;
-
                 err = startup_gfar(dev);
-                netif_tx_wake_all_queues(dev);
+        } else {
+                gfar_mac_reset(priv);
         }
+
+        clear_bit_unlock(GFAR_RESETTING, &priv->state);
+
         return err;
 }
 
@@ -1610,9 +1577,6 @@ static int gfar_write_filer_table(struct gfar_private *priv,
         if (tab->index > MAX_FILER_IDX - 1)
                 return -EBUSY;
 
-        /* Avoid inconsistent filer table to be processed */
-        lock_rx_qs(priv);
-
         /* Fill regular entries */
         for (; i < MAX_FILER_IDX - 1 && (tab->fe[i].ctrl | tab->fe[i].ctrl);
              i++)
@@ -1625,8 +1589,6 @@ static int gfar_write_filer_table(struct gfar_private *priv,
          */
         gfar_write_filer(priv, i, 0x20, 0x0);
 
-        unlock_rx_qs(priv);
-
         return 0;
 }
 
@@ -1831,6 +1793,9 @@ static int gfar_set_nfc(struct net_device *dev, struct ethtool_rxnfc *cmd)
         struct gfar_private *priv = netdev_priv(dev);
         int ret = 0;
 
+        if (test_bit(GFAR_RESETTING, &priv->state))
+                return -EBUSY;
+
         mutex_lock(&priv->rx_queue_access);
 
         switch (cmd->cmd) {