1 files changed, 94 insertions, 33 deletions

diff --git a/drivers/net/wimax/i2400m/netdev.c b/drivers/net/wimax/i2400m/netdev.c
index 796396cb4c82..599aa4eb9baa 100644
--- a/drivers/net/wimax/i2400m/netdev.c
+++ b/drivers/net/wimax/i2400m/netdev.c
@@ -74,6 +74,7 @@
  */
 #include <linux/if_arp.h>
 #include <linux/netdevice.h>
+#include <linux/ethtool.h>
 #include "i2400m.h"
 
 
@@ -88,7 +89,10 @@ enum {
          * The MTU is 1400 or less
          */
         I2400M_MAX_MTU = 1400,
-        I2400M_TX_TIMEOUT = HZ,
+        /* 20 secs? yep, this is the maximum timeout that the device
+         * might take to get out of IDLE / negotiate it with the base
+         * station. We add 1sec for good measure. */
+        I2400M_TX_TIMEOUT = 21 * HZ,
         I2400M_TX_QLEN = 5,
 };
 
@@ -101,22 +105,19 @@ int i2400m_open(struct net_device *net_dev)
         struct device *dev = i2400m_dev(i2400m);
 
         d_fnstart(3, dev, "(net_dev %p [i2400m %p])\n", net_dev, i2400m);
-        if (i2400m->ready == 0) {
-                dev_err(dev, "Device is still initializing\n");
-                result = -EBUSY;
-        } else
+        /* Make sure we wait until init is complete... */
+        mutex_lock(&i2400m->init_mutex);
+        if (i2400m->updown)
                 result = 0;
+        else
+                result = -EBUSY;
+        mutex_unlock(&i2400m->init_mutex);
         d_fnend(3, dev, "(net_dev %p [i2400m %p]) = %d\n",
                 net_dev, i2400m, result);
         return result;
 }
 
 
-/*
- *
- * On kernel versions where cancel_work_sync() didn't return anything,
- * we rely on wake_tx_skb() being non-NULL.
- */
 static
 int i2400m_stop(struct net_device *net_dev)
 {
@@ -124,21 +125,7 @@ int i2400m_stop(struct net_device *net_dev)
         struct device *dev = i2400m_dev(i2400m);
 
         d_fnstart(3, dev, "(net_dev %p [i2400m %p])\n", net_dev, i2400m);
-        /* See i2400m_hard_start_xmit(), references are taken there
-         * and here we release them if the work was still
-         * pending. Note we can't differentiate work not pending vs
-         * never scheduled, so the NULL check does that. */
-        if (cancel_work_sync(&i2400m->wake_tx_ws) == 0
-            && i2400m->wake_tx_skb != NULL) {
-                unsigned long flags;
-                struct sk_buff *wake_tx_skb;
-                spin_lock_irqsave(&i2400m->tx_lock, flags);
-                wake_tx_skb = i2400m->wake_tx_skb;      /* compat help */
-                i2400m->wake_tx_skb = NULL;     /* compat help */
-                spin_unlock_irqrestore(&i2400m->tx_lock, flags);
-                i2400m_put(i2400m);
-                kfree_skb(wake_tx_skb);
-        }
+        i2400m_net_wake_stop(i2400m);
         d_fnend(3, dev, "(net_dev %p [i2400m %p]) = 0\n", net_dev, i2400m);
         return 0;
 }
@@ -167,6 +154,7 @@ void i2400m_wake_tx_work(struct work_struct *ws)
 {
         int result;
         struct i2400m *i2400m = container_of(ws, struct i2400m, wake_tx_ws);
+        struct net_device *net_dev = i2400m->wimax_dev.net_dev;
         struct device *dev = i2400m_dev(i2400m);
         struct sk_buff *skb = i2400m->wake_tx_skb;
         unsigned long flags;
@@ -182,27 +170,36 @@ void i2400m_wake_tx_work(struct work_struct *ws)
                 dev_err(dev, "WAKE&TX: skb dissapeared!\n");
                 goto out_put;
         }
+        /* If we have, somehow, lost the connection after this was
+         * queued, don't do anything; this might be the device got
+         * reset or just disconnected. */
+        if (unlikely(!netif_carrier_ok(net_dev)))
+                goto out_kfree;
         result = i2400m_cmd_exit_idle(i2400m);
         if (result == -EILSEQ)
                 result = 0;
         if (result < 0) {
                 dev_err(dev, "WAKE&TX: device didn't get out of idle: "
-                        "%d\n", result);
-                        goto error;
+                        "%d - resetting\n", result);
+                i2400m_reset(i2400m, I2400M_RT_BUS);
+                goto error;
         }
         result = wait_event_timeout(i2400m->state_wq,
-                                    i2400m->state != I2400M_SS_IDLE, 5 * HZ);
+                                    i2400m->state != I2400M_SS_IDLE,
+                                    net_dev->watchdog_timeo - HZ/2);
         if (result == 0)
                 result = -ETIMEDOUT;
         if (result < 0) {
                 dev_err(dev, "WAKE&TX: error waiting for device to exit IDLE: "
-                        "%d\n", result);
+                        "%d - resetting\n", result);
+                i2400m_reset(i2400m, I2400M_RT_BUS);
                 goto error;
         }
         msleep(20);     /* device still needs some time or it drops it */
         result = i2400m_tx(i2400m, skb->data, skb->len, I2400M_PT_DATA);
-        netif_wake_queue(i2400m->wimax_dev.net_dev);
 error:
+        netif_wake_queue(net_dev);
+out_kfree:
         kfree_skb(skb); /* refcount transferred by _hard_start_xmit() */
 out_put:
         i2400m_put(i2400m);
@@ -229,6 +226,38 @@ void i2400m_tx_prep_header(struct sk_buff *skb)
 }
 
 
+
+/*
+ * Cleanup resources acquired during i2400m_net_wake_tx()
+ *
+ * This is called by __i2400m_dev_stop and means we have to make sure
+ * the workqueue is flushed from any pending work.
+ */
+void i2400m_net_wake_stop(struct i2400m *i2400m)
+{
+        struct device *dev = i2400m_dev(i2400m);
+
+        d_fnstart(3, dev, "(i2400m %p)\n", i2400m);
+        /* See i2400m_hard_start_xmit(), references are taken there
+         * and here we release them if the work was still
+         * pending. Note we can't differentiate work not pending vs
+         * never scheduled, so the NULL check does that. */
+        if (cancel_work_sync(&i2400m->wake_tx_ws) == 0
+            && i2400m->wake_tx_skb != NULL) {
+                unsigned long flags;
+                struct sk_buff *wake_tx_skb;
+                spin_lock_irqsave(&i2400m->tx_lock, flags);
+                wake_tx_skb = i2400m->wake_tx_skb;      /* compat help */
+                i2400m->wake_tx_skb = NULL;     /* compat help */
+                spin_unlock_irqrestore(&i2400m->tx_lock, flags);
+                i2400m_put(i2400m);
+                kfree_skb(wake_tx_skb);
+        }
+        d_fnend(3, dev, "(i2400m %p) = void\n", i2400m);
+        return;
+}
+
+
 /*
  * TX an skb to an idle device
  *
@@ -342,6 +371,20 @@ netdev_tx_t i2400m_hard_start_xmit(struct sk_buff *skb,
         int result;
 
         d_fnstart(3, dev, "(skb %p net_dev %p)\n", skb, net_dev);
+        if (skb_header_cloned(skb)) {
+                /*
+                 * Make tcpdump/wireshark happy -- if they are
+                 * running, the skb is cloned and we will overwrite
+                 * the mac fields in i2400m_tx_prep_header. Expand
+                 * seems to fix this...
+                 */
+                result = pskb_expand_head(skb, 0, 0, GFP_ATOMIC);
+                if (result) {
+                        result = NETDEV_TX_BUSY;
+                        goto error_expand;
+                }
+        }
+
         if (i2400m->state == I2400M_SS_IDLE)
                 result = i2400m_net_wake_tx(i2400m, net_dev, skb);
         else
@@ -352,10 +395,11 @@ netdev_tx_t i2400m_hard_start_xmit(struct sk_buff *skb,
                 net_dev->stats.tx_packets++;
                 net_dev->stats.tx_bytes += skb->len;
         }
+        result = NETDEV_TX_OK;
+error_expand:
         kfree_skb(skb);
-
-        d_fnend(3, dev, "(skb %p net_dev %p)\n", skb, net_dev);
-        return NETDEV_TX_OK;
+        d_fnend(3, dev, "(skb %p net_dev %p) = %d\n", skb, net_dev, result);
+        return result;
 }
 
 
@@ -559,6 +603,22 @@ static const struct net_device_ops i2400m_netdev_ops = {
         .ndo_change_mtu = i2400m_change_mtu,
 };
 
+static void i2400m_get_drvinfo(struct net_device *net_dev,
+                               struct ethtool_drvinfo *info)
+{
+        struct i2400m *i2400m = net_dev_to_i2400m(net_dev);
+
+        strncpy(info->driver, KBUILD_MODNAME, sizeof(info->driver) - 1);
+        strncpy(info->fw_version, i2400m->fw_name, sizeof(info->fw_version) - 1);
+        if (net_dev->dev.parent)
+                strncpy(info->bus_info, dev_name(net_dev->dev.parent),
+                        sizeof(info->bus_info) - 1);
+}
+
+static const struct ethtool_ops i2400m_ethtool_ops = {
+        .get_drvinfo = i2400m_get_drvinfo,
+        .get_link = ethtool_op_get_link,
+};
 
 /**
  * i2400m_netdev_setup - Setup setup @net_dev's i2400m private data
@@ -580,6 +640,7 @@ void i2400m_netdev_setup(struct net_device *net_dev)
                    & ~IFF_MULTICAST);
         net_dev->watchdog_timeo = I2400M_TX_TIMEOUT;
         net_dev->netdev_ops = &i2400m_netdev_ops;
+        net_dev->ethtool_ops = &i2400m_ethtool_ops;
         d_fnend(3, NULL, "(net_dev %p) = void\n", net_dev);
 }
 EXPORT_SYMBOL_GPL(i2400m_netdev_setup);