7 files changed, 109 insertions, 64 deletions

diff --git a/drivers/net/wimax/i2400m/control.c b/drivers/net/wimax/i2400m/control.c
index b3cadb626fe0..bd193ae2178b 100644
--- a/drivers/net/wimax/i2400m/control.c
+++ b/drivers/net/wimax/i2400m/control.c
@@ -292,8 +292,6 @@ void i2400m_report_tlv_system_state(struct i2400m *i2400m,
 
         d_fnstart(3, dev, "(i2400m %p ss %p [%u])\n", i2400m, ss, i2400m_state);
 
-        if (unlikely(i2400m->ready == 0))       /* act if up */
-                goto out;
         if (i2400m->state != i2400m_state) {
                 i2400m->state = i2400m_state;
                 wake_up_all(&i2400m->state_wq);
@@ -341,7 +339,6 @@ void i2400m_report_tlv_system_state(struct i2400m *i2400m,
                 i2400m->bus_reset(i2400m, I2400M_RT_WARM);
                 break;
         };
-out:
         d_fnend(3, dev, "(i2400m %p ss %p [%u]) = void\n",
                 i2400m, ss, i2400m_state);
 }
@@ -372,8 +369,6 @@ void i2400m_report_tlv_media_status(struct i2400m *i2400m,
 
         d_fnstart(3, dev, "(i2400m %p ms %p [%u])\n", i2400m, ms, status);
 
-        if (unlikely(i2400m->ready == 0))       /* act if up */
-                goto out;
         switch (status) {
         case I2400M_MEDIA_STATUS_LINK_UP:
                 netif_carrier_on(net_dev);
@@ -393,14 +388,59 @@ void i2400m_report_tlv_media_status(struct i2400m *i2400m,
                 dev_err(dev, "HW BUG? unknown media status %u\n",
                         status);
         };
-out:
         d_fnend(3, dev, "(i2400m %p ms %p [%u]) = void\n",
                 i2400m, ms, status);
 }
 
 
 /*
- * Parse a 'state report' and extract carrier on/off information
+ * Process a TLV from a 'state report'
+ *
+ * @i2400m: device descriptor
+ * @tlv: pointer to the TLV header; it has been already validated for
+ *     consistent size.
+ * @tag: for error messages
+ *
+ * Act on the TLVs from a 'state report'.
+ */
+static
+void i2400m_report_state_parse_tlv(struct i2400m *i2400m,
+                                   const struct i2400m_tlv_hdr *tlv,
+                                   const char *tag)
+{
+        struct device *dev = i2400m_dev(i2400m);
+        const struct i2400m_tlv_media_status *ms;
+        const struct i2400m_tlv_system_state *ss;
+        const struct i2400m_tlv_rf_switches_status *rfss;
+
+        if (0 == i2400m_tlv_match(tlv, I2400M_TLV_SYSTEM_STATE, sizeof(*ss))) {
+                ss = container_of(tlv, typeof(*ss), hdr);
+                d_printf(2, dev, "%s: system state TLV "
+                         "found (0x%04x), state 0x%08x\n",
+                         tag, I2400M_TLV_SYSTEM_STATE,
+                         le32_to_cpu(ss->state));
+                i2400m_report_tlv_system_state(i2400m, ss);
+        }
+        if (0 == i2400m_tlv_match(tlv, I2400M_TLV_RF_STATUS, sizeof(*rfss))) {
+                rfss = container_of(tlv, typeof(*rfss), hdr);
+                d_printf(2, dev, "%s: RF status TLV "
+                         "found (0x%04x), sw 0x%02x hw 0x%02x\n",
+                         tag, I2400M_TLV_RF_STATUS,
+                         le32_to_cpu(rfss->sw_rf_switch),
+                         le32_to_cpu(rfss->hw_rf_switch));
+                i2400m_report_tlv_rf_switches_status(i2400m, rfss);
+        }
+        if (0 == i2400m_tlv_match(tlv, I2400M_TLV_MEDIA_STATUS, sizeof(*ms))) {
+                ms = container_of(tlv, typeof(*ms), hdr);
+                d_printf(2, dev, "%s: Media Status TLV: %u\n",
+                         tag, le32_to_cpu(ms->media_status));
+                i2400m_report_tlv_media_status(i2400m, ms);
+        }
+}
+
+
+/*
+ * Parse a 'state report' and extract information
  *
  * @i2400m: device descriptor
  * @l3l4_hdr: pointer to message; it has been already validated for
@@ -409,13 +449,7 @@ out:
  *        declaration is assumed to be congruent with @size (as in
  *        sizeof(*l3l4_hdr) + l3l4_hdr->length == size)
  *
- * Extract from the report state the system state TLV and infer from
- * there if we have a carrier or not. Update our local state and tell
- * netdev.
- *
- * When setting the carrier, it's fine to set OFF twice (for example),
- * as netif_carrier_off() will not generate two OFF events (just on
- * the transitions).
+ * Walk over the TLVs in a report state and act on them.
  */
 static
 void i2400m_report_state_hook(struct i2400m *i2400m,
@@ -424,9 +458,6 @@ void i2400m_report_state_hook(struct i2400m *i2400m,
 {
         struct device *dev = i2400m_dev(i2400m);
         const struct i2400m_tlv_hdr *tlv;
-        const struct i2400m_tlv_system_state *ss;
-        const struct i2400m_tlv_rf_switches_status *rfss;
-        const struct i2400m_tlv_media_status *ms;
         size_t tlv_size = le16_to_cpu(l3l4_hdr->length);
 
         d_fnstart(4, dev, "(i2400m %p, l3l4_hdr %p, size %zu, %s)\n",
@@ -434,34 +465,8 @@ void i2400m_report_state_hook(struct i2400m *i2400m,
         tlv = NULL;
 
         while ((tlv = i2400m_tlv_buffer_walk(i2400m, &l3l4_hdr->pl,
-                                             tlv_size, tlv))) {
-                if (0 == i2400m_tlv_match(tlv, I2400M_TLV_SYSTEM_STATE,
-                                          sizeof(*ss))) {
-                        ss = container_of(tlv, typeof(*ss), hdr);
-                        d_printf(2, dev, "%s: system state TLV "
-                                 "found (0x%04x), state 0x%08x\n",
-                                 tag, I2400M_TLV_SYSTEM_STATE,
-                                 le32_to_cpu(ss->state));
-                        i2400m_report_tlv_system_state(i2400m, ss);
-                }
-                if (0 == i2400m_tlv_match(tlv, I2400M_TLV_RF_STATUS,
-                                          sizeof(*rfss))) {
-                        rfss = container_of(tlv, typeof(*rfss), hdr);
-                        d_printf(2, dev, "%s: RF status TLV "
-                                 "found (0x%04x), sw 0x%02x hw 0x%02x\n",
-                                 tag, I2400M_TLV_RF_STATUS,
-                                 le32_to_cpu(rfss->sw_rf_switch),
-                                 le32_to_cpu(rfss->hw_rf_switch));
-                        i2400m_report_tlv_rf_switches_status(i2400m, rfss);
-                }
-                if (0 == i2400m_tlv_match(tlv, I2400M_TLV_MEDIA_STATUS,
-                                          sizeof(*ms))) {
-                        ms = container_of(tlv, typeof(*ms), hdr);
-                        d_printf(2, dev, "%s: Media Status TLV: %u\n",
-                                 tag, le32_to_cpu(ms->media_status));
-                        i2400m_report_tlv_media_status(i2400m, ms);
-                }
-        }
+                                             tlv_size, tlv)))
+                i2400m_report_state_parse_tlv(i2400m, tlv, tag);
         d_fnend(4, dev, "(i2400m %p, l3l4_hdr %p, size %zu, %s) = void\n",
                 i2400m, l3l4_hdr, size, tag);
 }
@@ -721,6 +726,8 @@ struct sk_buff *i2400m_msg_to_dev(struct i2400m *i2400m,
                 ack_timeout = HZ;
         };
 
+        if (unlikely(i2400m->trace_msg_from_user))
+                wimax_msg(&i2400m->wimax_dev, "echo", buf, buf_len, GFP_KERNEL);
         /* The RX path in rx.c will put any response for this message
          * in i2400m->ack_skb and wake us up. If we cancel the wait,
          * we need to change the value of i2400m->ack_skb to something
@@ -755,6 +762,9 @@ struct sk_buff *i2400m_msg_to_dev(struct i2400m *i2400m,
         ack_l3l4_hdr = wimax_msg_data_len(ack_skb, &ack_len);
 
         /* Check the ack and deliver it if it is ok */
+        if (unlikely(i2400m->trace_msg_from_user))
+                wimax_msg(&i2400m->wimax_dev, "echo",
+                          ack_l3l4_hdr, ack_len, GFP_KERNEL);
         result = i2400m_msg_size_check(i2400m, ack_l3l4_hdr, ack_len);
         if (result < 0) {
                 dev_err(dev, "HW BUG? reply to message 0x%04x: %d\n",
diff --git a/drivers/net/wimax/i2400m/driver.c b/drivers/net/wimax/i2400m/driver.c
index 07a54bad237b..ef16c573bb22 100644
--- a/drivers/net/wimax/i2400m/driver.c
+++ b/drivers/net/wimax/i2400m/driver.c
@@ -62,6 +62,7 @@
  *   unregister_netdev()
  */
 #include "i2400m.h"
+#include <linux/etherdevice.h>
 #include <linux/wimax/i2400m.h>
 #include <linux/module.h>
 #include <linux/moduleparam.h>
@@ -234,9 +235,6 @@ int i2400m_op_msg_from_user(struct wimax_dev *wimax_dev,
         result = PTR_ERR(ack_skb);
         if (IS_ERR(ack_skb))
                 goto error_msg_to_dev;
-        if (unlikely(i2400m->trace_msg_from_user))
-                wimax_msg(&i2400m->wimax_dev, "trace",
-                          msg_buf, msg_len, GFP_KERNEL);
         result = wimax_msg_send(&i2400m->wimax_dev, ack_skb);
 error_msg_to_dev:
         d_fnend(4, dev, "(wimax_dev %p [i2400m %p] msg_buf %p msg_len %zu "
@@ -650,6 +648,7 @@ int i2400m_setup(struct i2400m *i2400m, enum i2400m_bri bm_flags)
         result = i2400m_read_mac_addr(i2400m);
         if (result < 0)
                 goto error_read_mac_addr;
+        random_ether_addr(i2400m->src_mac_addr);
 
         result = register_netdev(net_dev);      /* Okey dokey, bring it up */
         if (result < 0) {
diff --git a/drivers/net/wimax/i2400m/i2400m.h b/drivers/net/wimax/i2400m/i2400m.h
index 3ae2df38b59a..434ba310c2fe 100644
--- a/drivers/net/wimax/i2400m/i2400m.h
+++ b/drivers/net/wimax/i2400m/i2400m.h
@@ -323,6 +323,10 @@ struct i2400m_roq;
  *     delivered. Then the driver can release them to the host. See
  *     drivers/net/i2400m/rx.c for details.
  *
+ * @src_mac_addr: MAC address used to make ethernet packets be coming
+ *     from. This is generated at i2400m_setup() time and used during
+ *     the life cycle of the instance. See i2400m_fake_eth_header().
+ *
  * @init_mutex: Mutex used for serializing the device bringup
  *     sequence; this way if the device reboots in the middle, we
  *     don't try to do a bringup again while we are tearing down the
@@ -421,6 +425,7 @@ struct i2400m {
         unsigned rx_pl_num, rx_pl_max, rx_pl_min,
                 rx_num, rx_size_acc, rx_size_min, rx_size_max;
         struct i2400m_roq *rx_roq;      /* not under rx_lock! */
+        u8 src_mac_addr[ETH_HLEN];
 
         struct mutex msg_mutex;         /* serialize command execution */
         struct completion msg_completion;
diff --git a/drivers/net/wimax/i2400m/netdev.c b/drivers/net/wimax/i2400m/netdev.c
index 6b1fe7a81f25..9653f478b382 100644
--- a/drivers/net/wimax/i2400m/netdev.c
+++ b/drivers/net/wimax/i2400m/netdev.c
@@ -404,10 +404,12 @@ static
 void i2400m_rx_fake_eth_header(struct net_device *net_dev,
                                void *_eth_hdr, __be16 protocol)
 {
+        struct i2400m *i2400m = net_dev_to_i2400m(net_dev);
         struct ethhdr *eth_hdr = _eth_hdr;
 
         memcpy(eth_hdr->h_dest, net_dev->dev_addr, sizeof(eth_hdr->h_dest));
-        memset(eth_hdr->h_source, 0, sizeof(eth_hdr->h_dest));
+        memcpy(eth_hdr->h_source, i2400m->src_mac_addr,
+               sizeof(eth_hdr->h_source));
         eth_hdr->h_proto = protocol;
 }
 
diff --git a/drivers/net/wimax/i2400m/rx.c b/drivers/net/wimax/i2400m/rx.c
index f9fc38902322..7643850a6fb8 100644
--- a/drivers/net/wimax/i2400m/rx.c
+++ b/drivers/net/wimax/i2400m/rx.c
@@ -177,7 +177,8 @@ void i2400m_report_hook_work(struct work_struct *ws)
         struct i2400m_work *iw =
                 container_of(ws, struct i2400m_work, ws);
         struct i2400m_report_hook_args *args = (void *) iw->pl;
-        i2400m_report_hook(iw->i2400m, args->l3l4_hdr, args->size);
+        if (iw->i2400m->ready)
+                i2400m_report_hook(iw->i2400m, args->l3l4_hdr, args->size);
         kfree_skb(args->skb_rx);
         i2400m_put(iw->i2400m);
         kfree(iw);
@@ -309,6 +310,9 @@ void i2400m_rx_ctl(struct i2400m *i2400m, struct sk_buff *skb_rx,
                 skb_get(skb_rx);
                 i2400m_queue_work(i2400m, i2400m_report_hook_work,
                                   GFP_KERNEL, &args, sizeof(args));
+                if (unlikely(i2400m->trace_msg_from_user))
+                        wimax_msg(&i2400m->wimax_dev, "echo",
+                                  l3l4_hdr, size, GFP_KERNEL);
                 result = wimax_msg(&i2400m->wimax_dev, NULL, l3l4_hdr, size,
                                    GFP_KERNEL);
                 if (result < 0)
diff --git a/drivers/net/wimax/i2400m/sdio.c b/drivers/net/wimax/i2400m/sdio.c
index 5ac5e76701cd..777c981676fc 100644
--- a/drivers/net/wimax/i2400m/sdio.c
+++ b/drivers/net/wimax/i2400m/sdio.c
@@ -409,19 +409,19 @@ int i2400ms_probe(struct sdio_func *func,
         i2400m->bus_fw_names = i2400ms_bus_fw_names;
         i2400m->bus_bm_mac_addr_impaired = 1;
 
-        result = i2400ms_enable_function(i2400ms->func);
-        if (result < 0) {
-                dev_err(dev, "Cannot enable SDIO function: %d\n", result);
-                goto error_func_enable;
-        }
-
         sdio_claim_host(func);
         result = sdio_set_block_size(func, I2400MS_BLK_SIZE);
+        sdio_release_host(func);
         if (result < 0) {
                 dev_err(dev, "Failed to set block size: %d\n", result);
                 goto error_set_blk_size;
         }
-        sdio_release_host(func);
+
+        result = i2400ms_enable_function(i2400ms->func);
+        if (result < 0) {
+                dev_err(dev, "Cannot enable SDIO function: %d\n", result);
+                goto error_func_enable;
+        }
 
         result = i2400m_setup(i2400m, I2400M_BRI_NO_REBOOT);
         if (result < 0) {
@@ -440,12 +440,12 @@ int i2400ms_probe(struct sdio_func *func,
 error_debugfs_add:
         i2400m_release(i2400m);
 error_setup:
-        sdio_set_drvdata(func, NULL);
         sdio_claim_host(func);
-error_set_blk_size:
         sdio_disable_func(func);
         sdio_release_host(func);
 error_func_enable:
+error_set_blk_size:
+        sdio_set_drvdata(func, NULL);
         free_netdev(net_dev);
 error_alloc_netdev:
         return result;
diff --git a/drivers/net/wimax/i2400m/usb.c b/drivers/net/wimax/i2400m/usb.c
index ca4151a9e222..17851321b7fd 100644
--- a/drivers/net/wimax/i2400m/usb.c
+++ b/drivers/net/wimax/i2400m/usb.c
@@ -505,27 +505,52 @@ int i2400mu_suspend(struct usb_interface *iface, pm_message_t pm_msg)
 #ifdef CONFIG_PM
         struct usb_device *usb_dev = i2400mu->usb_dev;
 #endif
+        unsigned is_autosuspend = 0;
         struct i2400m *i2400m = &i2400mu->i2400m;
 
+#ifdef CONFIG_PM
+        if (usb_dev->auto_pm > 0)
+                is_autosuspend = 1;
+#endif
+
         d_fnstart(3, dev, "(iface %p pm_msg %u)\n", iface, pm_msg.event);
         if (i2400m->updown == 0)
                 goto no_firmware;
-        d_printf(1, dev, "fw up, requesting standby\n");
+        if (i2400m->state == I2400M_SS_DATA_PATH_CONNECTED && is_autosuspend) {
+                /* ugh -- the device is connected and this suspend
+                 * request is an autosuspend one (not a system standby
+                 * / hibernate).
+                 *
+                 * The only way the device can go to standby is if the
+                 * link with the base station is in IDLE mode; that
+                 * were the case, we'd be in status
+                 * I2400M_SS_CONNECTED_IDLE. But we are not.
+                 *
+                 * If we *tell* him to go power save now, it'll reset
+                 * as a precautionary measure, so if this is an
+                 * autosuspend thing, say no and it'll come back
+                 * later, when the link is IDLE
+                 */
+                result = -EBADF;
+                d_printf(1, dev, "fw up, link up, not-idle, autosuspend: "
+                         "not entering powersave\n");
+                goto error_not_now;
+        }
+        d_printf(1, dev, "fw up: entering powersave\n");
         atomic_dec(&i2400mu->do_autopm);
         result = i2400m_cmd_enter_powersave(i2400m);
         atomic_inc(&i2400mu->do_autopm);
-#ifdef CONFIG_PM
-        if (result < 0 && usb_dev->auto_pm == 0) {
+        if (result < 0 && !is_autosuspend) {
                 /* System suspend, can't fail */
                 dev_err(dev, "failed to suspend, will reset on resume\n");
                 result = 0;
         }
-#endif
         if (result < 0)
                 goto error_enter_powersave;
         i2400mu_notification_release(i2400mu);
-        d_printf(1, dev, "fw up, got standby\n");
+        d_printf(1, dev, "powersave requested\n");
 error_enter_powersave:
+error_not_now:
 no_firmware:
         d_fnend(3, dev, "(iface %p pm_msg %u) = %d\n",
                 iface, pm_msg.event, result);