14 files changed, 457 insertions, 232 deletions

diff --git a/drivers/net/wireless/libertas/cfg.c b/drivers/net/wireless/libertas/cfg.c
index b456a53b64b1..85b3169c40d7 100644
--- a/drivers/net/wireless/libertas/cfg.c
+++ b/drivers/net/wireless/libertas/cfg.c
@@ -19,6 +19,7 @@
 #include "decl.h"
 #include "cfg.h"
 #include "cmd.h"
+#include "mesh.h"
 
 
 #define CHAN2G(_channel, _freq, _flags) {        \
@@ -442,13 +443,16 @@ static int lbs_cfg_set_channel(struct wiphy *wiphy,
         struct lbs_private *priv = wiphy_priv(wiphy);
         int ret = -ENOTSUPP;
 
-        lbs_deb_enter_args(LBS_DEB_CFG80211, "freq %d, type %d",
-                           channel->center_freq, channel_type);
+        lbs_deb_enter_args(LBS_DEB_CFG80211, "iface %s freq %d, type %d",
+                           netdev_name(netdev), channel->center_freq, channel_type);
 
         if (channel_type != NL80211_CHAN_NO_HT)
                 goto out;
 
-        ret = lbs_set_channel(priv, channel->hw_value);
+        if (netdev == priv->mesh_dev)
+                ret = lbs_mesh_set_channel(priv, channel->hw_value);
+        else
+                ret = lbs_set_channel(priv, channel->hw_value);
 
  out:
         lbs_deb_leave_args(LBS_DEB_CFG80211, "ret %d", ret);
@@ -708,7 +712,7 @@ static void lbs_scan_worker(struct work_struct *work)
 
         if (priv->scan_channel < priv->scan_req->n_channels) {
                 cancel_delayed_work(&priv->scan_work);
-                if (!priv->stopping)
+                if (netif_running(priv->dev))
                         queue_delayed_work(priv->work_thread, &priv->scan_work,
                                 msecs_to_jiffies(300));
         }
@@ -1292,6 +1296,9 @@ static int lbs_cfg_connect(struct wiphy *wiphy, struct net_device *dev,
         int ret = 0;
         u8 preamble = RADIO_PREAMBLE_SHORT;
 
+        if (dev == priv->mesh_dev)
+                return -EOPNOTSUPP;
+
         lbs_deb_enter(LBS_DEB_CFG80211);
 
         if (!sme->bssid) {
@@ -1402,28 +1409,23 @@ static int lbs_cfg_connect(struct wiphy *wiphy, struct net_device *dev,
         return ret;
 }
 
-static int lbs_cfg_disconnect(struct wiphy *wiphy, struct net_device *dev,
-        u16 reason_code)
+int lbs_disconnect(struct lbs_private *priv, u16 reason)
 {
-        struct lbs_private *priv = wiphy_priv(wiphy);
         struct cmd_ds_802_11_deauthenticate cmd;
-
-        lbs_deb_enter_args(LBS_DEB_CFG80211, "reason_code %d", reason_code);
-
-        /* store for lbs_cfg_ret_disconnect() */
-        priv->disassoc_reason = reason_code;
+        int ret;
 
         memset(&cmd, 0, sizeof(cmd));
         cmd.hdr.size = cpu_to_le16(sizeof(cmd));
         /* Mildly ugly to use a locally store my own BSSID ... */
         memcpy(cmd.macaddr, &priv->assoc_bss, ETH_ALEN);
-        cmd.reasoncode = cpu_to_le16(reason_code);
+        cmd.reasoncode = cpu_to_le16(reason);
 
-        if (lbs_cmd_with_response(priv, CMD_802_11_DEAUTHENTICATE, &cmd))
-                return -EFAULT;
+        ret = lbs_cmd_with_response(priv, CMD_802_11_DEAUTHENTICATE, &cmd);
+        if (ret)
+                return ret;
 
         cfg80211_disconnected(priv->dev,
-                        priv->disassoc_reason,
+                        reason,
                         NULL, 0,
                         GFP_KERNEL);
         priv->connect_status = LBS_DISCONNECTED;
@@ -1431,6 +1433,21 @@ static int lbs_cfg_disconnect(struct wiphy *wiphy, struct net_device *dev,
         return 0;
 }
 
+static int lbs_cfg_disconnect(struct wiphy *wiphy, struct net_device *dev,
+        u16 reason_code)
+{
+        struct lbs_private *priv = wiphy_priv(wiphy);
+
+        if (dev == priv->mesh_dev)
+                return -EOPNOTSUPP;
+
+        lbs_deb_enter_args(LBS_DEB_CFG80211, "reason_code %d", reason_code);
+
+        /* store for lbs_cfg_ret_disconnect() */
+        priv->disassoc_reason = reason_code;
+
+        return lbs_disconnect(priv, reason_code);
+}
 
 static int lbs_cfg_set_default_key(struct wiphy *wiphy,
                                    struct net_device *netdev,
@@ -1439,6 +1456,9 @@ static int lbs_cfg_set_default_key(struct wiphy *wiphy,
 {
         struct lbs_private *priv = wiphy_priv(wiphy);
 
+        if (netdev == priv->mesh_dev)
+                return -EOPNOTSUPP;
+
         lbs_deb_enter(LBS_DEB_CFG80211);
 
         if (key_index != priv->wep_tx_key) {
@@ -1460,6 +1480,9 @@ static int lbs_cfg_add_key(struct wiphy *wiphy, struct net_device *netdev,
         u16 key_type;
         int ret = 0;
 
+        if (netdev == priv->mesh_dev)
+                return -EOPNOTSUPP;
+
         lbs_deb_enter(LBS_DEB_CFG80211);
 
         lbs_deb_assoc("add_key: cipher 0x%x, mac_addr %pM\n",
@@ -1603,6 +1626,9 @@ static int lbs_get_survey(struct wiphy *wiphy, struct net_device *dev,
         s8 signal, noise;
         int ret;
 
+        if (dev == priv->mesh_dev)
+                return -EOPNOTSUPP;
+
         if (idx != 0)
                 ret = -ENOENT;
 
@@ -1636,6 +1662,9 @@ static int lbs_change_intf(struct wiphy *wiphy, struct net_device *dev,
         struct lbs_private *priv = wiphy_priv(wiphy);
         int ret = 0;
 
+        if (dev == priv->mesh_dev)
+                return -EOPNOTSUPP;
+
         lbs_deb_enter(LBS_DEB_CFG80211);
 
         switch (type) {
@@ -1959,6 +1988,9 @@ static int lbs_join_ibss(struct wiphy *wiphy, struct net_device *dev,
         struct cfg80211_bss *bss;
         DECLARE_SSID_BUF(ssid_buf);
 
+        if (dev == priv->mesh_dev)
+                return -EOPNOTSUPP;
+
         lbs_deb_enter(LBS_DEB_CFG80211);
 
         if (!params->channel) {
@@ -1995,6 +2027,9 @@ static int lbs_leave_ibss(struct wiphy *wiphy, struct net_device *dev)
         struct cmd_ds_802_11_ad_hoc_stop cmd;
         int ret = 0;
 
+        if (dev == priv->mesh_dev)
+                return -EOPNOTSUPP;
+
         lbs_deb_enter(LBS_DEB_CFG80211);
 
         memset(&cmd, 0, sizeof(cmd));
@@ -2117,6 +2152,8 @@ int lbs_cfg_register(struct lbs_private *priv)
                         BIT(NL80211_IFTYPE_ADHOC);
         if (lbs_rtap_supported(priv))
                 wdev->wiphy->interface_modes |= BIT(NL80211_IFTYPE_MONITOR);
+        if (lbs_mesh_activated(priv))
+                wdev->wiphy->interface_modes |= BIT(NL80211_IFTYPE_MESH_POINT);
 
         wdev->wiphy->bands[IEEE80211_BAND_2GHZ] = &lbs_band_2ghz;
 
diff --git a/drivers/net/wireless/libertas/cfg.h b/drivers/net/wireless/libertas/cfg.h
index 4f46bb744bee..a02ee151710e 100644
--- a/drivers/net/wireless/libertas/cfg.h
+++ b/drivers/net/wireless/libertas/cfg.h
@@ -17,5 +17,6 @@ void lbs_send_disconnect_notification(struct lbs_private *priv);
 void lbs_send_mic_failureevent(struct lbs_private *priv, u32 event);
 
 void lbs_scan_deinit(struct lbs_private *priv);
+int lbs_disconnect(struct lbs_private *priv, u16 reason);
 
 #endif
diff --git a/drivers/net/wireless/libertas/cmd.c b/drivers/net/wireless/libertas/cmd.c
index dbd24a4607ec..e08ab1de3d9d 100644
--- a/drivers/net/wireless/libertas/cmd.c
+++ b/drivers/net/wireless/libertas/cmd.c
@@ -1088,7 +1088,7 @@ void __lbs_complete_command(struct lbs_private *priv, struct cmd_ctrl_node *cmd,
         if (!cmd->callback || cmd->callback == lbs_cmd_async_callback)
                 __lbs_cleanup_and_insert_cmd(priv, cmd);
         priv->cur_cmd = NULL;
-        wake_up_interruptible(&priv->waitq);
+        wake_up(&priv->waitq);
 }
 
 void lbs_complete_command(struct lbs_private *priv, struct cmd_ctrl_node *cmd,
@@ -1627,7 +1627,7 @@ struct cmd_ctrl_node *__lbs_cmd_async(struct lbs_private *priv,
                 lbs_deb_host("PREP_CMD: cmdnode is NULL\n");
 
                 /* Wake up main thread to execute next command */
-                wake_up_interruptible(&priv->waitq);
+                wake_up(&priv->waitq);
                 cmdnode = ERR_PTR(-ENOBUFS);
                 goto done;
         }
@@ -1647,7 +1647,7 @@ struct cmd_ctrl_node *__lbs_cmd_async(struct lbs_private *priv,
 
         cmdnode->cmdwaitqwoken = 0;
         lbs_queue_cmd(priv, cmdnode);
-        wake_up_interruptible(&priv->waitq);
+        wake_up(&priv->waitq);
 
  done:
         lbs_deb_leave_args(LBS_DEB_HOST, "ret %p", cmdnode);
diff --git a/drivers/net/wireless/libertas/decl.h b/drivers/net/wireless/libertas/decl.h
index da0b05bb89fe..9304e6fc421f 100644
--- a/drivers/net/wireless/libertas/decl.h
+++ b/drivers/net/wireless/libertas/decl.h
@@ -43,10 +43,14 @@ int lbs_start_card(struct lbs_private *priv);
 void lbs_stop_card(struct lbs_private *priv);
 void lbs_host_to_card_done(struct lbs_private *priv);
 
+int lbs_start_iface(struct lbs_private *priv);
+int lbs_stop_iface(struct lbs_private *priv);
+
 int lbs_rtap_supported(struct lbs_private *priv);
 
 int lbs_set_mac_address(struct net_device *dev, void *addr);
 void lbs_set_multicast_list(struct net_device *dev);
+void lbs_update_mcast(struct lbs_private *priv);
 
 int lbs_suspend(struct lbs_private *priv);
 int lbs_resume(struct lbs_private *priv);
diff --git a/drivers/net/wireless/libertas/dev.h b/drivers/net/wireless/libertas/dev.h
index adb3490e3cf5..814838916b82 100644
--- a/drivers/net/wireless/libertas/dev.h
+++ b/drivers/net/wireless/libertas/dev.h
@@ -6,7 +6,6 @@
 #ifndef _LBS_DEV_H_
 #define _LBS_DEV_H_
 
-#include "mesh.h"
 #include "defs.h"
 #include "host.h"
 
@@ -22,6 +21,17 @@ struct sleep_params {
         uint16_t sp_reserved;
 };
 
+/* Mesh statistics */
+struct lbs_mesh_stats {
+        u32     fwd_bcast_cnt;          /* Fwd: Broadcast counter */
+        u32     fwd_unicast_cnt;        /* Fwd: Unicast counter */
+        u32     fwd_drop_ttl;           /* Fwd: TTL zero */
+        u32     fwd_drop_rbt;           /* Fwd: Recently Broadcasted */
+        u32     fwd_drop_noroute;       /* Fwd: No route to Destination */
+        u32     fwd_drop_nobuf;         /* Fwd: Run out of internal buffers */
+        u32     drop_blind;             /* Rx:  Dropped by blinding table */
+        u32     tx_failed_cnt;          /* Tx:  Failed transmissions */
+};
 
 /* Private structure for the MV device */
 struct lbs_private {
@@ -36,7 +46,6 @@ struct lbs_private {
         /* CFG80211 */
         struct wireless_dev *wdev;
         bool wiphy_registered;
-        bool stopping;
         struct cfg80211_scan_request *scan_req;
         u8 assoc_bss[ETH_ALEN];
         u8 disassoc_reason;
@@ -86,11 +95,14 @@ struct lbs_private {
 
         /* Hardware access */
         void *card;
+        bool iface_running;
         u8 fw_ready;
         u8 surpriseremoved;
         u8 setup_fw_on_resume;
         int (*hw_host_to_card) (struct lbs_private *priv, u8 type, u8 *payload, u16 nb);
         void (*reset_card) (struct lbs_private *priv);
+        int (*power_save) (struct lbs_private *priv);
+        int (*power_restore) (struct lbs_private *priv);
         int (*enter_deep_sleep) (struct lbs_private *priv);
         int (*exit_deep_sleep) (struct lbs_private *priv);
         int (*reset_deep_sleep_wakeup) (struct lbs_private *priv);
@@ -172,4 +184,16 @@ struct lbs_private {
 
 extern struct cmd_confirm_sleep confirm_sleep;
 
+/* Check if there is an interface active. */
+static inline int lbs_iface_active(struct lbs_private *priv)
+{
+        int r;
+
+        r = netif_running(priv->dev);
+        if (priv->mesh_dev);
+                r |= netif_running(priv->dev);
+
+        return r;
+}
+
 #endif
diff --git a/drivers/net/wireless/libertas/ethtool.c b/drivers/net/wireless/libertas/ethtool.c
index 4dfb3bfd2cf3..885ddc1c4fed 100644
--- a/drivers/net/wireless/libertas/ethtool.c
+++ b/drivers/net/wireless/libertas/ethtool.c
@@ -5,6 +5,7 @@
 
 #include "decl.h"
 #include "cmd.h"
+#include "mesh.h"
 
 
 static void lbs_ethtool_get_drvinfo(struct net_device *dev,
diff --git a/drivers/net/wireless/libertas/if_sdio.c b/drivers/net/wireless/libertas/if_sdio.c
index 387786e1b394..c962e21762dc 100644
--- a/drivers/net/wireless/libertas/if_sdio.c
+++ b/drivers/net/wireless/libertas/if_sdio.c
@@ -39,6 +39,7 @@
 #include <linux/mmc/sdio_ids.h>
 #include <linux/mmc/sdio.h>
 #include <linux/mmc/host.h>
+#include <linux/pm_runtime.h>
 
 #include "host.h"
 #include "decl.h"
@@ -47,6 +48,8 @@
 #include "cmd.h"
 #include "if_sdio.h"
 
+static void if_sdio_interrupt(struct sdio_func *func);
+
 /* The if_sdio_remove() callback function is called when
  * user removes this module from kernel space or ejects
  * the card from the slot. The driver handles these 2 cases
@@ -757,6 +760,136 @@ out:
         return ret;
 }
 
+/********************************************************************/
+/* Power management                                                 */
+/********************************************************************/
+
+static int if_sdio_power_on(struct if_sdio_card *card)
+{
+        struct sdio_func *func = card->func;
+        struct lbs_private *priv = card->priv;
+        struct mmc_host *host = func->card->host;
+        int ret;
+
+        sdio_claim_host(func);
+
+        ret = sdio_enable_func(func);
+        if (ret)
+                goto release;
+
+        /* For 1-bit transfers to the 8686 model, we need to enable the
+         * interrupt flag in the CCCR register. Set the MMC_QUIRK_LENIENT_FN0
+         * bit to allow access to non-vendor registers. */
+        if ((card->model == MODEL_8686) &&
+            (host->caps & MMC_CAP_SDIO_IRQ) &&
+            (host->ios.bus_width == MMC_BUS_WIDTH_1)) {
+                u8 reg;
+
+                func->card->quirks |= MMC_QUIRK_LENIENT_FN0;
+                reg = sdio_f0_readb(func, SDIO_CCCR_IF, &ret);
+                if (ret)
+                        goto disable;
+
+                reg |= SDIO_BUS_ECSI;
+                sdio_f0_writeb(func, reg, SDIO_CCCR_IF, &ret);
+                if (ret)
+                        goto disable;
+        }
+
+        card->ioport = sdio_readb(func, IF_SDIO_IOPORT, &ret);
+        if (ret)
+                goto disable;
+
+        card->ioport |= sdio_readb(func, IF_SDIO_IOPORT + 1, &ret) << 8;
+        if (ret)
+                goto disable;
+
+        card->ioport |= sdio_readb(func, IF_SDIO_IOPORT + 2, &ret) << 16;
+        if (ret)
+                goto disable;
+
+        sdio_release_host(func);
+        ret = if_sdio_prog_firmware(card);
+        sdio_claim_host(func);
+        if (ret)
+                goto disable;
+
+        /*
+         * Get rx_unit if the chip is SD8688 or newer.
+         * SD8385 & SD8686 do not have rx_unit.
+         */
+        if ((card->model != MODEL_8385)
+                        && (card->model != MODEL_8686))
+                card->rx_unit = if_sdio_read_rx_unit(card);
+        else
+                card->rx_unit = 0;
+
+        /*
+         * Set up the interrupt handler late.
+         *
+         * If we set it up earlier, the (buggy) hardware generates a spurious
+         * interrupt, even before the interrupt has been enabled, with
+         * CCCR_INTx = 0.
+         *
+         * We register the interrupt handler late so that we can handle any
+         * spurious interrupts, and also to avoid generation of that known
+         * spurious interrupt in the first place.
+         */
+        ret = sdio_claim_irq(func, if_sdio_interrupt);
+        if (ret)
+                goto disable;
+
+        /*
+         * Enable interrupts now that everything is set up
+         */
+        sdio_writeb(func, 0x0f, IF_SDIO_H_INT_MASK, &ret);
+        if (ret)
+                goto release_irq;
+
+        sdio_release_host(func);
+
+        /*
+         * FUNC_INIT is required for SD8688 WLAN/BT multiple functions
+         */
+        if (card->model == MODEL_8688) {
+                struct cmd_header cmd;
+
+                memset(&cmd, 0, sizeof(cmd));
+
+                lbs_deb_sdio("send function INIT command\n");
+                if (__lbs_cmd(priv, CMD_FUNC_INIT, &cmd, sizeof(cmd),
+                                lbs_cmd_copyback, (unsigned long) &cmd))
+                        netdev_alert(priv->dev, "CMD_FUNC_INIT cmd failed\n");
+        }
+
+        priv->fw_ready = 1;
+
+        return 0;
+
+release_irq:
+        sdio_release_irq(func);
+disable:
+        sdio_disable_func(func);
+release:
+        sdio_release_host(func);
+        return ret;
+}
+
+static int if_sdio_power_off(struct if_sdio_card *card)
+{
+        struct sdio_func *func = card->func;
+        struct lbs_private *priv = card->priv;
+
+        priv->fw_ready = 0;
+
+        sdio_claim_host(func);
+        sdio_release_irq(func);
+        sdio_disable_func(func);
+        sdio_release_host(func);
+        return 0;
+}
+
+
 /*******************************************************************/
 /* Libertas callbacks                                              */
 /*******************************************************************/
@@ -923,6 +1056,32 @@ static void if_sdio_reset_card(struct lbs_private *priv)
         schedule_work(&card_reset_work);
 }
 
+static int if_sdio_power_save(struct lbs_private *priv)
+{
+        struct if_sdio_card *card = priv->card;
+        int ret;
+
+        flush_workqueue(card->workqueue);
+
+        ret = if_sdio_power_off(card);
+
+        /* Let runtime PM know the card is powered off */
+        pm_runtime_put_sync(&card->func->dev);
+
+        return ret;
+}
+
+static int if_sdio_power_restore(struct lbs_private *priv)
+{
+        struct if_sdio_card *card = priv->card;
+
+        /* Make sure the card will not be powered off by runtime PM */
+        pm_runtime_get_sync(&card->func->dev);
+
+        return if_sdio_power_on(card);
+}
+
+
 /*******************************************************************/
 /* SDIO callbacks                                                  */
 /*******************************************************************/
@@ -976,7 +1135,6 @@ static int if_sdio_probe(struct sdio_func *func,
         int ret, i;
         unsigned int model;
         struct if_sdio_packet *packet;
-        struct mmc_host *host = func->card->host;
 
         lbs_deb_enter(LBS_DEB_SDIO);
 
@@ -1033,45 +1191,6 @@ static int if_sdio_probe(struct sdio_func *func,
                 goto free;
         }
 
-        sdio_claim_host(func);
-
-        ret = sdio_enable_func(func);
-        if (ret)
-                goto release;
-
-        /* For 1-bit transfers to the 8686 model, we need to enable the
-         * interrupt flag in the CCCR register. Set the MMC_QUIRK_LENIENT_FN0
-         * bit to allow access to non-vendor registers. */
-        if ((card->model == MODEL_8686) &&
-            (host->caps & MMC_CAP_SDIO_IRQ) &&
-            (host->ios.bus_width == MMC_BUS_WIDTH_1)) {
-                u8 reg;
-
-                func->card->quirks |= MMC_QUIRK_LENIENT_FN0;
-                reg = sdio_f0_readb(func, SDIO_CCCR_IF, &ret);
-                if (ret)
-                        goto release_int;
-
-                reg |= SDIO_BUS_ECSI;
-                sdio_f0_writeb(func, reg, SDIO_CCCR_IF, &ret);
-                if (ret)
-                        goto release_int;
-        }
-
-        card->ioport = sdio_readb(func, IF_SDIO_IOPORT, &ret);
-        if (ret)
-                goto release_int;
-
-        card->ioport |= sdio_readb(func, IF_SDIO_IOPORT + 1, &ret) << 8;
-        if (ret)
-                goto release_int;
-
-        card->ioport |= sdio_readb(func, IF_SDIO_IOPORT + 2, &ret) << 16;
-        if (ret)
-                goto release_int;
-
-        sdio_release_host(func);
-
         sdio_set_drvdata(func, card);
 
         lbs_deb_sdio("class = 0x%X, vendor = 0x%X, "
@@ -1079,14 +1198,11 @@ static int if_sdio_probe(struct sdio_func *func,
                         func->class, func->vendor, func->device,
                         model, (unsigned)card->ioport);
 
-        ret = if_sdio_prog_firmware(card);
-        if (ret)
-                goto reclaim;
 
         priv = lbs_add_card(card, &func->dev);
         if (!priv) {
                 ret = -ENOMEM;
-                goto reclaim;
+                goto free;
         }
 
         card->priv = priv;
@@ -1097,62 +1213,21 @@ static int if_sdio_probe(struct sdio_func *func,
         priv->exit_deep_sleep = if_sdio_exit_deep_sleep;
         priv->reset_deep_sleep_wakeup = if_sdio_reset_deep_sleep_wakeup;
         priv->reset_card = if_sdio_reset_card;
+        priv->power_save = if_sdio_power_save;
+        priv->power_restore = if_sdio_power_restore;
 
-        sdio_claim_host(func);
-
-        /*
-         * Get rx_unit if the chip is SD8688 or newer.
-         * SD8385 & SD8686 do not have rx_unit.
-         */
-        if ((card->model != MODEL_8385)
-                        && (card->model != MODEL_8686))
-                card->rx_unit = if_sdio_read_rx_unit(card);
-        else
-                card->rx_unit = 0;
-
-        /*
-         * Set up the interrupt handler late.
-         *
-         * If we set it up earlier, the (buggy) hardware generates a spurious
-         * interrupt, even before the interrupt has been enabled, with
-         * CCCR_INTx = 0.
-         *
-         * We register the interrupt handler late so that we can handle any
-         * spurious interrupts, and also to avoid generation of that known
-         * spurious interrupt in the first place.
-         */
-        ret = sdio_claim_irq(func, if_sdio_interrupt);
-        if (ret)
-                goto disable;
-
-        /*
-         * Enable interrupts now that everything is set up
-         */
-        sdio_writeb(func, 0x0f, IF_SDIO_H_INT_MASK, &ret);
-        sdio_release_host(func);
+        ret = if_sdio_power_on(card);
         if (ret)
-                goto reclaim;
-
-        priv->fw_ready = 1;
-
-        /*
-         * FUNC_INIT is required for SD8688 WLAN/BT multiple functions
-         */
-        if (card->model == MODEL_8688) {
-                struct cmd_header cmd;
-
-                memset(&cmd, 0, sizeof(cmd));
-
-                lbs_deb_sdio("send function INIT command\n");
-                if (__lbs_cmd(priv, CMD_FUNC_INIT, &cmd, sizeof(cmd),
-                                lbs_cmd_copyback, (unsigned long) &cmd))
-                        netdev_alert(priv->dev, "CMD_FUNC_INIT cmd failed\n");
-        }
+                goto err_activate_card;
 
         ret = lbs_start_card(priv);
+        if_sdio_power_off(card);
         if (ret)
                 goto err_activate_card;
 
+        /* Tell PM core that we don't need the card to be powered now */
+        pm_runtime_put_noidle(&func->dev);
+
 out:
         lbs_deb_leave_args(LBS_DEB_SDIO, "ret %d", ret);
 
@@ -1161,14 +1236,6 @@ out:
 err_activate_card:
         flush_workqueue(card->workqueue);
         lbs_remove_card(priv);
-reclaim:
-        sdio_claim_host(func);
-release_int:
-        sdio_release_irq(func);
-disable:
-        sdio_disable_func(func);
-release:
-        sdio_release_host(func);
 free:
         destroy_workqueue(card->workqueue);
         while (card->packets) {
@@ -1195,6 +1262,9 @@ static void if_sdio_remove(struct sdio_func *func)
 
         card = sdio_get_drvdata(func);
 
+        /* Undo decrement done above in if_sdio_probe */
+        pm_runtime_get_noresume(&func->dev);
+
         if (user_rmmod && (card->model == MODEL_8688)) {
                 /*
                  * FUNC_SHUTDOWN is required for SD8688 WLAN/BT
@@ -1219,11 +1289,6 @@ static void if_sdio_remove(struct sdio_func *func)
         flush_workqueue(card->workqueue);
         destroy_workqueue(card->workqueue);
 
-        sdio_claim_host(func);
-        sdio_release_irq(func);
-        sdio_disable_func(func);
-        sdio_release_host(func);
-
         while (card->packets) {
                 packet = card->packets;
                 card->packets = card->packets->next;
diff --git a/drivers/net/wireless/libertas/if_spi.c b/drivers/net/wireless/libertas/if_spi.c
index e0286cfbc91d..622ae6de0d8b 100644
--- a/drivers/net/wireless/libertas/if_spi.c
+++ b/drivers/net/wireless/libertas/if_spi.c
@@ -531,10 +531,6 @@ static int if_spi_prog_helper_firmware(struct if_spi_card *card,
                 goto out;
         err = spu_write_u16(card, IF_SPI_CARD_INT_CAUSE_REG,
                                 IF_SPI_CIC_CMD_DOWNLOAD_OVER);
-                goto out;
-
-        lbs_deb_spi("waiting for helper to boot...\n");
-
 out:
         if (err)
                 pr_err("failed to load helper firmware (err=%d)\n", err);
diff --git a/drivers/net/wireless/libertas/if_usb.c b/drivers/net/wireless/libertas/if_usb.c
index b5acc393a65a..0c846f5a646a 100644
--- a/drivers/net/wireless/libertas/if_usb.c
+++ b/drivers/net/wireless/libertas/if_usb.c
@@ -324,7 +324,7 @@ static int if_usb_probe(struct usb_interface *intf,
         }
         kparam_unblock_sysfs_write(fw_name);
 
-        if (!(priv = lbs_add_card(cardp, &udev->dev)))
+        if (!(priv = lbs_add_card(cardp, &intf->dev)))
                 goto err_prog_firmware;
 
         cardp->priv = priv;
@@ -956,7 +956,7 @@ static int if_usb_prog_firmware(struct if_usb_card *cardp,
         priv->dnld_sent = DNLD_RES_RECEIVED;
         spin_unlock_irqrestore(&priv->driver_lock, flags);
 
-        wake_up_interruptible(&priv->waitq);
+        wake_up(&priv->waitq);
 
         return ret;
 }
@@ -1112,6 +1112,15 @@ static int if_usb_suspend(struct usb_interface *intf, pm_message_t message)
         if (priv->psstate != PS_STATE_FULL_POWER)
                 return -1;
 
+#ifdef CONFIG_OLPC
+        if (machine_is_olpc()) {
+                if (priv->wol_criteria == EHS_REMOVE_WAKEUP)
+                        olpc_ec_wakeup_clear(EC_SCI_SRC_WLAN);
+                else
+                        olpc_ec_wakeup_set(EC_SCI_SRC_WLAN);
+        }
+#endif
+
         ret = lbs_suspend(priv);
         if (ret)
                 goto out;
diff --git a/drivers/net/wireless/libertas/main.c b/drivers/net/wireless/libertas/main.c
index 2fdeb81ce5b2..d1c1d52931f1 100644
--- a/drivers/net/wireless/libertas/main.c
+++ b/drivers/net/wireless/libertas/main.c
@@ -23,6 +23,7 @@
 #include "cfg.h"
 #include "debugfs.h"
 #include "cmd.h"
+#include "mesh.h"
 
 #define DRIVER_RELEASE_VERSION "323.p0"
 const char lbs_driver_version[] = "COMM-USB8388-" DRIVER_RELEASE_VERSION
@@ -98,6 +99,37 @@ u8 lbs_data_rate_to_fw_index(u32 rate)
         return 0;
 }
 
+int lbs_start_iface(struct lbs_private *priv)
+{
+        struct cmd_ds_802_11_mac_address cmd;
+        int ret;
+
+        if (priv->power_restore) {
+                ret = priv->power_restore(priv);
+                if (ret)
+                        return ret;
+        }
+
+        cmd.hdr.size = cpu_to_le16(sizeof(cmd));
+        cmd.action = cpu_to_le16(CMD_ACT_SET);
+        memcpy(cmd.macadd, priv->current_addr, ETH_ALEN);
+
+        ret = lbs_cmd_with_response(priv, CMD_802_11_MAC_ADDRESS, &cmd);
+        if (ret) {
+                lbs_deb_net("set MAC address failed\n");
+                goto err;
+        }
+
+        lbs_update_channel(priv);
+
+        priv->iface_running = true;
+        return 0;
+
+err:
+        if (priv->power_save)
+                priv->power_save(priv);
+        return ret;
+}
 
 /**
  *  lbs_dev_open - open the ethX interface
@@ -111,23 +143,64 @@ static int lbs_dev_open(struct net_device *dev)
         int ret = 0;
 
         lbs_deb_enter(LBS_DEB_NET);
+        if (!priv->iface_running) {
+                ret = lbs_start_iface(priv);
+                if (ret)
+                        goto out;
+        }
 
         spin_lock_irq(&priv->driver_lock);
-        priv->stopping = false;
 
-        if (priv->connect_status == LBS_CONNECTED)
-                netif_carrier_on(dev);
-        else
-                netif_carrier_off(dev);
+        netif_carrier_off(dev);
 
         if (!priv->tx_pending_len)
                 netif_wake_queue(dev);
 
         spin_unlock_irq(&priv->driver_lock);
+
+out:
         lbs_deb_leave_args(LBS_DEB_NET, "ret %d", ret);
         return ret;
 }
 
+static bool lbs_command_queue_empty(struct lbs_private *priv)
+{
+        unsigned long flags;
+        bool ret;
+        spin_lock_irqsave(&priv->driver_lock, flags);
+        ret = priv->cur_cmd == NULL && list_empty(&priv->cmdpendingq);
+        spin_unlock_irqrestore(&priv->driver_lock, flags);
+        return ret;
+}
+
+int lbs_stop_iface(struct lbs_private *priv)
+{
+        unsigned long flags;
+        int ret = 0;
+
+        lbs_deb_enter(LBS_DEB_MAIN);
+
+        spin_lock_irqsave(&priv->driver_lock, flags);
+        priv->iface_running = false;
+        kfree_skb(priv->currenttxskb);
+        priv->currenttxskb = NULL;
+        priv->tx_pending_len = 0;
+        spin_unlock_irqrestore(&priv->driver_lock, flags);
+
+        cancel_work_sync(&priv->mcast_work);
+
+        /* Disable command processing, and wait for all commands to complete */
+        lbs_deb_main("waiting for commands to complete\n");
+        wait_event(priv->waitq, lbs_command_queue_empty(priv));
+        lbs_deb_main("all commands completed\n");
+
+        if (priv->power_save)
+                ret = priv->power_save(priv);
+
+        lbs_deb_leave(LBS_DEB_MAIN);
+        return ret;
+}
+
 /**
  *  lbs_eth_stop - close the ethX interface
  *
@@ -140,18 +213,25 @@ static int lbs_eth_stop(struct net_device *dev)
 
         lbs_deb_enter(LBS_DEB_NET);
 
+        if (priv->connect_status == LBS_CONNECTED)
+                lbs_disconnect(priv, WLAN_REASON_DEAUTH_LEAVING);
+
         spin_lock_irq(&priv->driver_lock);
-        priv->stopping = true;
         netif_stop_queue(dev);
         spin_unlock_irq(&priv->driver_lock);
 
-        schedule_work(&priv->mcast_work);
+        lbs_update_mcast(priv);
         cancel_delayed_work_sync(&priv->scan_work);
         if (priv->scan_req) {
                 cfg80211_scan_done(priv->scan_req, false);
                 priv->scan_req = NULL;
         }
 
+        netif_carrier_off(priv->dev);
+
+        if (!lbs_iface_active(priv))
+                lbs_stop_iface(priv);
+
         lbs_deb_leave(LBS_DEB_NET);
         return 0;
 }
@@ -169,7 +249,7 @@ void lbs_host_to_card_done(struct lbs_private *priv)
         /* Wake main thread if commands are pending */
         if (!priv->cur_cmd || priv->tx_pending_len > 0) {
                 if (!priv->wakeup_dev_required)
-                        wake_up_interruptible(&priv->waitq);
+                        wake_up(&priv->waitq);
         }
 
         spin_unlock_irqrestore(&priv->driver_lock, flags);
@@ -182,29 +262,24 @@ int lbs_set_mac_address(struct net_device *dev, void *addr)
         int ret = 0;
         struct lbs_private *priv = dev->ml_priv;
         struct sockaddr *phwaddr = addr;
-        struct cmd_ds_802_11_mac_address cmd;
 
         lbs_deb_enter(LBS_DEB_NET);
 
+        /*
+         * Can only set MAC address when all interfaces are down, to be written
+         * to the hardware when one of them is brought up.
+         */
+        if (lbs_iface_active(priv))
+                return -EBUSY;
+
         /* In case it was called from the mesh device */
         dev = priv->dev;
 
-        cmd.hdr.size = cpu_to_le16(sizeof(cmd));
-        cmd.action = cpu_to_le16(CMD_ACT_SET);
-        memcpy(cmd.macadd, phwaddr->sa_data, ETH_ALEN);
-
-        ret = lbs_cmd_with_response(priv, CMD_802_11_MAC_ADDRESS, &cmd);
-        if (ret) {
-                lbs_deb_net("set MAC address failed\n");
-                goto done;
-        }
-
         memcpy(priv->current_addr, phwaddr->sa_data, ETH_ALEN);
         memcpy(dev->dev_addr, phwaddr->sa_data, ETH_ALEN);
         if (priv->mesh_dev)
                 memcpy(priv->mesh_dev->dev_addr, phwaddr->sa_data, ETH_ALEN);
 
-done:
         lbs_deb_leave_args(LBS_DEB_NET, "ret %d", ret);
         return ret;
 }
@@ -258,18 +333,18 @@ static int lbs_add_mcast_addrs(struct cmd_ds_mac_multicast_adr *cmd,
         return i;
 }
 
-static void lbs_set_mcast_worker(struct work_struct *work)
+void lbs_update_mcast(struct lbs_private *priv)
 {
-        struct lbs_private *priv = container_of(work, struct lbs_private, mcast_work);
         struct cmd_ds_mac_multicast_adr mcast_cmd;
-        int dev_flags;
+        int dev_flags = 0;
         int nr_addrs;
         int old_mac_control = priv->mac_control;
 
         lbs_deb_enter(LBS_DEB_NET);
 
-        dev_flags = priv->dev->flags;
-        if (priv->mesh_dev)
+        if (netif_running(priv->dev))
+                dev_flags |= priv->dev->flags;
+        if (priv->mesh_dev && netif_running(priv->mesh_dev))
                 dev_flags |= priv->mesh_dev->flags;
 
         if (dev_flags & IFF_PROMISC) {
@@ -315,6 +390,12 @@ static void lbs_set_mcast_worker(struct work_struct *work)
         lbs_deb_leave(LBS_DEB_NET);
 }
 
+static void lbs_set_mcast_worker(struct work_struct *work)
+{
+        struct lbs_private *priv = container_of(work, struct lbs_private, mcast_work);
+        lbs_update_mcast(priv);
+}
+
 void lbs_set_multicast_list(struct net_device *dev)
 {
         struct lbs_private *priv = dev->ml_priv;
@@ -647,7 +728,7 @@ static void lbs_cmd_timeout_handler(unsigned long data)
         if (priv->dnld_sent == DNLD_CMD_SENT)
                 priv->dnld_sent = DNLD_RES_RECEIVED;
 
-        wake_up_interruptible(&priv->waitq);
+        wake_up(&priv->waitq);
 out:
         spin_unlock_irqrestore(&priv->driver_lock, flags);
         lbs_deb_leave(LBS_DEB_CMD);
@@ -889,10 +970,6 @@ void lbs_remove_card(struct lbs_private *priv)
         lbs_remove_mesh(priv);
         lbs_scan_deinit(priv);
 
-        dev = priv->dev;
-
-        cancel_work_sync(&priv->mcast_work);
-
         /* worker thread destruction blocks on the in-flight command which
          * should have been cleared already in lbs_stop_card().
          */
@@ -950,17 +1027,18 @@ int lbs_start_card(struct lbs_private *priv)
         if (ret)
                 goto done;
 
+        if (!lbs_disablemesh)
+                lbs_init_mesh(priv);
+        else
+                pr_info("%s: mesh disabled\n", dev->name);
+
         if (lbs_cfg_register(priv)) {
                 pr_err("cannot register device\n");
                 goto done;
         }
 
-        lbs_update_channel(priv);
-
-        if (!lbs_disablemesh)
-                lbs_init_mesh(priv);
-        else
-                pr_info("%s: mesh disabled\n", dev->name);
+        if (lbs_mesh_activated(priv))
+                lbs_start_mesh(priv);
 
         lbs_debugfs_init_one(priv, dev);
 
@@ -978,8 +1056,6 @@ EXPORT_SYMBOL_GPL(lbs_start_card);
 void lbs_stop_card(struct lbs_private *priv)
 {
         struct net_device *dev;
-        struct cmd_ctrl_node *cmdnode;
-        unsigned long flags;
 
         lbs_deb_enter(LBS_DEB_MAIN);
 
@@ -992,30 +1068,6 @@ void lbs_stop_card(struct lbs_private *priv)
 
         lbs_debugfs_remove_one(priv);
         lbs_deinit_mesh(priv);
-
-        /* Delete the timeout of the currently processing command */
-        del_timer_sync(&priv->command_timer);
-        del_timer_sync(&priv->auto_deepsleep_timer);
-
-        /* Flush pending command nodes */
-        spin_lock_irqsave(&priv->driver_lock, flags);
-        lbs_deb_main("clearing pending commands\n");
-        list_for_each_entry(cmdnode, &priv->cmdpendingq, list) {
-                cmdnode->result = -ENOENT;
-                cmdnode->cmdwaitqwoken = 1;
-                wake_up(&cmdnode->cmdwait_q);
-        }
-
-        /* Flush the command the card is currently processing */
-        if (priv->cur_cmd) {
-                lbs_deb_main("clearing current command\n");
-                priv->cur_cmd->result = -ENOENT;
-                priv->cur_cmd->cmdwaitqwoken = 1;
-                wake_up(&priv->cur_cmd->cmdwait_q);
-        }
-        lbs_deb_main("done clearing commands\n");
-        spin_unlock_irqrestore(&priv->driver_lock, flags);
-
         unregister_netdev(dev);
 
 out:
@@ -1036,7 +1088,7 @@ void lbs_queue_event(struct lbs_private *priv, u32 event)
 
         kfifo_in(&priv->event_fifo, (unsigned char *) &event, sizeof(u32));
 
-        wake_up_interruptible(&priv->waitq);
+        wake_up(&priv->waitq);
 
         spin_unlock_irqrestore(&priv->driver_lock, flags);
         lbs_deb_leave(LBS_DEB_THREAD);
@@ -1054,7 +1106,7 @@ void lbs_notify_command_response(struct lbs_private *priv, u8 resp_idx)
         BUG_ON(resp_idx > 1);
         priv->resp_idx = resp_idx;
 
-        wake_up_interruptible(&priv->waitq);
+        wake_up(&priv->waitq);
 
         lbs_deb_leave(LBS_DEB_THREAD);
 }
diff --git a/drivers/net/wireless/libertas/mesh.c b/drivers/net/wireless/libertas/mesh.c
index 8e3104d990fb..e87c031b298f 100644
--- a/drivers/net/wireless/libertas/mesh.c
+++ b/drivers/net/wireless/libertas/mesh.c
@@ -129,6 +129,19 @@ static int lbs_mesh_config(struct lbs_private *priv, uint16_t action,
         return __lbs_mesh_config_send(priv, &cmd, action, priv->mesh_tlv);
 }
 
+int lbs_mesh_set_channel(struct lbs_private *priv, u8 channel)
+{
+        return lbs_mesh_config(priv, CMD_ACT_MESH_CONFIG_START, channel);
+}
+
+static uint16_t lbs_mesh_get_channel(struct lbs_private *priv)
+{
+        struct wireless_dev *mesh_wdev = priv->mesh_dev->ieee80211_ptr;
+        if (mesh_wdev->channel)
+                return mesh_wdev->channel->hw_value;
+        else
+                return 1;
+}
 
 /***************************************************************************
  * Mesh sysfs support
@@ -812,7 +825,6 @@ static void lbs_persist_config_remove(struct net_device *dev)
  */
 int lbs_init_mesh(struct lbs_private *priv)
 {
-        struct net_device *dev = priv->dev;
         int ret = 0;
 
         lbs_deb_enter(LBS_DEB_MESH);
@@ -837,11 +849,9 @@ int lbs_init_mesh(struct lbs_private *priv)
                    useful */
 
                 priv->mesh_tlv = TLV_TYPE_OLD_MESH_ID;
-                if (lbs_mesh_config(priv, CMD_ACT_MESH_CONFIG_START,
-                                    priv->channel)) {
+                if (lbs_mesh_config(priv, CMD_ACT_MESH_CONFIG_START, 1)) {
                         priv->mesh_tlv = TLV_TYPE_MESH_ID;
-                        if (lbs_mesh_config(priv, CMD_ACT_MESH_CONFIG_START,
-                                            priv->channel))
+                        if (lbs_mesh_config(priv, CMD_ACT_MESH_CONFIG_START, 1))
                                 priv->mesh_tlv = 0;
                 }
         } else
@@ -851,23 +861,16 @@ int lbs_init_mesh(struct lbs_private *priv)
                  * 0x100+37; Do not invoke command with old TLV.
                  */
                 priv->mesh_tlv = TLV_TYPE_MESH_ID;
-                if (lbs_mesh_config(priv, CMD_ACT_MESH_CONFIG_START,
-                                    priv->channel))
+                if (lbs_mesh_config(priv, CMD_ACT_MESH_CONFIG_START, 1))
                         priv->mesh_tlv = 0;
         }
 
         /* Stop meshing until interface is brought up */
-        lbs_mesh_config(priv, CMD_ACT_MESH_CONFIG_STOP, priv->channel);
+        lbs_mesh_config(priv, CMD_ACT_MESH_CONFIG_STOP, 1);
 
         if (priv->mesh_tlv) {
                 sprintf(priv->mesh_ssid, "mesh");
                 priv->mesh_ssid_len = 4;
-
-                lbs_add_mesh(priv);
-
-                if (device_create_file(&dev->dev, &dev_attr_lbs_mesh))
-                        netdev_err(dev, "cannot register lbs_mesh attribute\n");
-
                 ret = 1;
         }
 
@@ -875,6 +878,13 @@ int lbs_init_mesh(struct lbs_private *priv)
         return ret;
 }
 
+void lbs_start_mesh(struct lbs_private *priv)
+{
+        lbs_add_mesh(priv);
+
+        if (device_create_file(&priv->dev->dev, &dev_attr_lbs_mesh))
+                netdev_err(priv->dev, "cannot register lbs_mesh attribute\n");
+}
 
 int lbs_deinit_mesh(struct lbs_private *priv)
 {
@@ -904,7 +914,8 @@ static int lbs_mesh_stop(struct net_device *dev)
         struct lbs_private *priv = dev->ml_priv;
 
         lbs_deb_enter(LBS_DEB_MESH);
-        lbs_mesh_config(priv, CMD_ACT_MESH_CONFIG_STOP, priv->channel);
+        lbs_mesh_config(priv, CMD_ACT_MESH_CONFIG_STOP,
+                lbs_mesh_get_channel(priv));
 
         spin_lock_irq(&priv->driver_lock);
 
@@ -913,7 +924,9 @@ static int lbs_mesh_stop(struct net_device *dev)
 
         spin_unlock_irq(&priv->driver_lock);
 
-        schedule_work(&priv->mcast_work);
+        lbs_update_mcast(priv);
+        if (!lbs_iface_active(priv))
+                lbs_stop_iface(priv);
 
         lbs_deb_leave(LBS_DEB_MESH);
         return 0;
@@ -931,6 +944,11 @@ static int lbs_mesh_dev_open(struct net_device *dev)
         int ret = 0;
 
         lbs_deb_enter(LBS_DEB_NET);
+        if (!priv->iface_running) {
+                ret = lbs_start_iface(priv);
+                if (ret)
+                        goto out;
+        }
 
         spin_lock_irq(&priv->driver_lock);
 
@@ -947,7 +965,8 @@ static int lbs_mesh_dev_open(struct net_device *dev)
 
         spin_unlock_irq(&priv->driver_lock);
 
-        ret = lbs_mesh_config(priv, CMD_ACT_MESH_CONFIG_START, priv->channel);
+        ret = lbs_mesh_config(priv, CMD_ACT_MESH_CONFIG_START,
+                lbs_mesh_get_channel(priv));
 
 out:
         lbs_deb_leave_args(LBS_DEB_NET, "ret %d", ret);
@@ -971,18 +990,32 @@ static const struct net_device_ops mesh_netdev_ops = {
 static int lbs_add_mesh(struct lbs_private *priv)
 {
         struct net_device *mesh_dev = NULL;
+        struct wireless_dev *mesh_wdev;
         int ret = 0;
 
         lbs_deb_enter(LBS_DEB_MESH);
 
         /* Allocate a virtual mesh device */
+        mesh_wdev = kzalloc(sizeof(struct wireless_dev), GFP_KERNEL);
+        if (!mesh_wdev) {
+                lbs_deb_mesh("init mshX wireless device failed\n");
+                ret = -ENOMEM;
+                goto done;
+        }
+
         mesh_dev = alloc_netdev(0, "msh%d", ether_setup);
         if (!mesh_dev) {
                 lbs_deb_mesh("init mshX device failed\n");
                 ret = -ENOMEM;
-                goto done;
+                goto err_free_wdev;
         }
+
+        mesh_wdev->iftype = NL80211_IFTYPE_MESH_POINT;
+        mesh_wdev->wiphy = priv->wdev->wiphy;
+        mesh_wdev->netdev = mesh_dev;
+
         mesh_dev->ml_priv = priv;
+        mesh_dev->ieee80211_ptr = mesh_wdev;
         priv->mesh_dev = mesh_dev;
 
         mesh_dev->netdev_ops = &mesh_netdev_ops;
@@ -996,7 +1029,7 @@ static int lbs_add_mesh(struct lbs_private *priv)
         ret = register_netdev(mesh_dev);
         if (ret) {
                 pr_err("cannot register mshX virtual interface\n");
-                goto err_free;
+                goto err_free_netdev;
         }
 
         ret = sysfs_create_group(&(mesh_dev->dev.kobj), &lbs_mesh_attr_group);
@@ -1012,9 +1045,12 @@ static int lbs_add_mesh(struct lbs_private *priv)
 err_unregister:
         unregister_netdev(mesh_dev);
 
-err_free:
+err_free_netdev:
         free_netdev(mesh_dev);
 
+err_free_wdev:
+        kfree(mesh_wdev);
+
 done:
         lbs_deb_leave_args(LBS_DEB_MESH, "ret %d", ret);
         return ret;
@@ -1035,6 +1071,7 @@ void lbs_remove_mesh(struct lbs_private *priv)
         lbs_persist_config_remove(mesh_dev);
         unregister_netdev(mesh_dev);
         priv->mesh_dev = NULL;
+        kfree(mesh_dev->ieee80211_ptr);
         free_netdev(mesh_dev);
         lbs_deb_leave(LBS_DEB_MESH);
 }
diff --git a/drivers/net/wireless/libertas/mesh.h b/drivers/net/wireless/libertas/mesh.h
index 50144913f2ab..6603f341c874 100644
--- a/drivers/net/wireless/libertas/mesh.h
+++ b/drivers/net/wireless/libertas/mesh.h
@@ -9,30 +9,25 @@
 #include <net/lib80211.h>
 
 #include "host.h"
+#include "dev.h"
 
 #ifdef CONFIG_LIBERTAS_MESH
 
-/* Mesh statistics */
-struct lbs_mesh_stats {
-        u32     fwd_bcast_cnt;          /* Fwd: Broadcast counter */
-        u32     fwd_unicast_cnt;        /* Fwd: Unicast counter */
-        u32     fwd_drop_ttl;           /* Fwd: TTL zero */
-        u32     fwd_drop_rbt;           /* Fwd: Recently Broadcasted */
-        u32     fwd_drop_noroute;       /* Fwd: No route to Destination */
-        u32     fwd_drop_nobuf;         /* Fwd: Run out of internal buffers */
-        u32     drop_blind;             /* Rx:  Dropped by blinding table */
-        u32     tx_failed_cnt;          /* Tx:  Failed transmissions */
-};
-
-
 struct net_device;
-struct lbs_private;
 
 int lbs_init_mesh(struct lbs_private *priv);
+void lbs_start_mesh(struct lbs_private *priv);
 int lbs_deinit_mesh(struct lbs_private *priv);
 
 void lbs_remove_mesh(struct lbs_private *priv);
 
+static inline bool lbs_mesh_activated(struct lbs_private *priv)
+{
+        /* Mesh SSID is only programmed after successful init */
+        return priv->mesh_ssid_len != 0;
+}
+
+int lbs_mesh_set_channel(struct lbs_private *priv, u8 channel);
 
 /* Sending / Receiving */
 
@@ -67,11 +62,13 @@ void lbs_mesh_ethtool_get_strings(struct net_device *dev,
 
 #define lbs_init_mesh(priv)
 #define lbs_deinit_mesh(priv)
+#define lbs_start_mesh(priv)
 #define lbs_add_mesh(priv)
 #define lbs_remove_mesh(priv)
 #define lbs_mesh_set_dev(priv, dev, rxpd) (dev)
 #define lbs_mesh_set_txpd(priv, dev, txpd)
-#define lbs_mesh_config(priv, enable, chan)
+#define lbs_mesh_set_channel(priv, channel) (0)
+#define lbs_mesh_activated(priv) (false)
 
 #endif
 
diff --git a/drivers/net/wireless/libertas/rx.c b/drivers/net/wireless/libertas/rx.c
index bfb8898ae518..62e10eeadd7e 100644
--- a/drivers/net/wireless/libertas/rx.c
+++ b/drivers/net/wireless/libertas/rx.c
@@ -15,6 +15,7 @@
 #include "radiotap.h"
 #include "decl.h"
 #include "dev.h"
+#include "mesh.h"
 
 struct eth803hdr {
         u8 dest_addr[6];
diff --git a/drivers/net/wireless/libertas/tx.c b/drivers/net/wireless/libertas/tx.c
index a6e85134cfe1..8f127520d786 100644
--- a/drivers/net/wireless/libertas/tx.c
+++ b/drivers/net/wireless/libertas/tx.c
@@ -12,6 +12,7 @@
 #include "decl.h"
 #include "defs.h"
 #include "dev.h"
+#include "mesh.h"
 
 /**
  * convert_radiotap_rate_to_mv - converts Tx/Rx rates from IEEE80211_RADIOTAP_RATE