net: remove interrupt.h inclusion from netdevice.h
[linux-3.10.git] / drivers / net / wireless / libertas / cmdresp.c
index 0371c83..2ffe5a1 100644 (file)
@@ -1,47 +1,42 @@
-/**
-  * This file contains the handling of command
-  * responses as well as events generated by firmware.
-  */
-#include <linux/delay.h>
-#include <linux/if_arp.h>
-#include <linux/netdevice.h>
+/*
+ * This file contains the handling of command
+ * responses as well as events generated by firmware.
+ */
 
-#include <net/iw_handler.h>
+#include <linux/hardirq.h>
+#include <linux/slab.h>
+#include <linux/delay.h>
+#include <linux/sched.h>
+#include <asm/unaligned.h>
+#include <net/cfg80211.h>
 
-#include "host.h"
-#include "decl.h"
-#include "defs.h"
-#include "dev.h"
-#include "assoc.h"
-#include "wext.h"
+#include "cfg.h"
+#include "cmd.h"
 
 /**
- *  @brief This function handles disconnect event. it
- *  reports disconnect to upper layer, clean tx/rx packets,
- *  reset link state etc.
+ * lbs_mac_event_disconnected - handles disconnect event. It
+ * reports disconnect to upper layer, clean tx/rx packets,
+ * reset link state etc.
+ *
+ * @priv:      A pointer to struct lbs_private structure
  *
- *  @param priv    A pointer to struct lbs_private structure
- *  @return       n/a
+ * returns:    n/a
  */
 void lbs_mac_event_disconnected(struct lbs_private *priv)
 {
-       union iwreq_data wrqu;
-
        if (priv->connect_status != LBS_CONNECTED)
                return;
 
        lbs_deb_enter(LBS_DEB_ASSOC);
 
-       memset(wrqu.ap_addr.sa_data, 0x00, ETH_ALEN);
-       wrqu.ap_addr.sa_family = ARPHRD_ETHER;
-
        /*
         * Cisco AP sends EAP failure and de-auth in less than 0.5 ms.
         * It causes problem in the Supplicant
         */
-
        msleep_interruptible(1000);
-       wireless_send_event(priv->dev, SIOCGIWAP, &wrqu, NULL);
+
+       if (priv->wdev->iftype == NL80211_IFTYPE_STATION)
+               lbs_send_disconnect_notification(priv);
 
        /* report disconnect to upper layer */
        netif_stop_queue(priv->dev);
@@ -52,284 +47,16 @@ void lbs_mac_event_disconnected(struct lbs_private *priv)
        priv->currenttxskb = NULL;
        priv->tx_pending_len = 0;
 
-       /* reset SNR/NF/RSSI values */
-       memset(priv->SNR, 0x00, sizeof(priv->SNR));
-       memset(priv->NF, 0x00, sizeof(priv->NF));
-       memset(priv->RSSI, 0x00, sizeof(priv->RSSI));
-       memset(priv->rawSNR, 0x00, sizeof(priv->rawSNR));
-       memset(priv->rawNF, 0x00, sizeof(priv->rawNF));
-       priv->nextSNRNF = 0;
-       priv->numSNRNF = 0;
        priv->connect_status = LBS_DISCONNECTED;
 
-       /* Clear out associated SSID and BSSID since connection is
-        * no longer valid.
-        */
-       memset(&priv->curbssparams.bssid, 0, ETH_ALEN);
-       memset(&priv->curbssparams.ssid, 0, IW_ESSID_MAX_SIZE);
-       priv->curbssparams.ssid_len = 0;
-
        if (priv->psstate != PS_STATE_FULL_POWER) {
                /* make firmware to exit PS mode */
                lbs_deb_cmd("disconnected, so exit PS mode\n");
-               lbs_ps_wakeup(priv, 0);
+               lbs_set_ps_mode(priv, PS_MODE_ACTION_EXIT_PS, false);
        }
        lbs_deb_leave(LBS_DEB_ASSOC);
 }
 
-/**
- *  @brief This function handles MIC failure event.
- *
- *  @param priv    A pointer to struct lbs_private structure
- *  @para  event   the event id
- *  @return       n/a
- */
-static void handle_mic_failureevent(struct lbs_private *priv, u32 event)
-{
-       char buf[50];
-
-       lbs_deb_enter(LBS_DEB_CMD);
-       memset(buf, 0, sizeof(buf));
-
-       sprintf(buf, "%s", "MLME-MICHAELMICFAILURE.indication ");
-
-       if (event == MACREG_INT_CODE_MIC_ERR_UNICAST) {
-               strcat(buf, "unicast ");
-       } else {
-               strcat(buf, "multicast ");
-       }
-
-       lbs_send_iwevcustom_event(priv, buf);
-       lbs_deb_leave(LBS_DEB_CMD);
-}
-
-static int lbs_ret_reg_access(struct lbs_private *priv,
-                              u16 type, struct cmd_ds_command *resp)
-{
-       int ret = 0;
-
-       lbs_deb_enter(LBS_DEB_CMD);
-
-       switch (type) {
-       case CMD_RET(CMD_MAC_REG_ACCESS):
-               {
-                       struct cmd_ds_mac_reg_access *reg = &resp->params.macreg;
-
-                       priv->offsetvalue.offset = (u32)le16_to_cpu(reg->offset);
-                       priv->offsetvalue.value = le32_to_cpu(reg->value);
-                       break;
-               }
-
-       case CMD_RET(CMD_BBP_REG_ACCESS):
-               {
-                       struct cmd_ds_bbp_reg_access *reg = &resp->params.bbpreg;
-
-                       priv->offsetvalue.offset = (u32)le16_to_cpu(reg->offset);
-                       priv->offsetvalue.value = reg->value;
-                       break;
-               }
-
-       case CMD_RET(CMD_RF_REG_ACCESS):
-               {
-                       struct cmd_ds_rf_reg_access *reg = &resp->params.rfreg;
-
-                       priv->offsetvalue.offset = (u32)le16_to_cpu(reg->offset);
-                       priv->offsetvalue.value = reg->value;
-                       break;
-               }
-
-       default:
-               ret = -1;
-       }
-
-       lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
-       return ret;
-}
-
-static int lbs_ret_802_11_snmp_mib(struct lbs_private *priv,
-                                   struct cmd_ds_command *resp)
-{
-       struct cmd_ds_802_11_snmp_mib *smib = &resp->params.smib;
-       u16 oid = le16_to_cpu(smib->oid);
-       u16 querytype = le16_to_cpu(smib->querytype);
-
-       lbs_deb_enter(LBS_DEB_CMD);
-
-       lbs_deb_cmd("SNMP_RESP: oid 0x%x, querytype 0x%x\n", oid,
-              querytype);
-       lbs_deb_cmd("SNMP_RESP: Buf size %d\n", le16_to_cpu(smib->bufsize));
-
-       if (querytype == CMD_ACT_GET) {
-               switch (oid) {
-               case FRAGTHRESH_I:
-                       priv->fragthsd =
-                               le16_to_cpu(*((__le16 *)(smib->value)));
-                       lbs_deb_cmd("SNMP_RESP: frag threshold %u\n",
-                                   priv->fragthsd);
-                       break;
-               case RTSTHRESH_I:
-                       priv->rtsthsd =
-                               le16_to_cpu(*((__le16 *)(smib->value)));
-                       lbs_deb_cmd("SNMP_RESP: rts threshold %u\n",
-                                   priv->rtsthsd);
-                       break;
-               case SHORT_RETRYLIM_I:
-                       priv->txretrycount =
-                               le16_to_cpu(*((__le16 *)(smib->value)));
-                       lbs_deb_cmd("SNMP_RESP: tx retry count %u\n",
-                                   priv->rtsthsd);
-                       break;
-               default:
-                       break;
-               }
-       }
-
-       lbs_deb_enter(LBS_DEB_CMD);
-       return 0;
-}
-
-static int lbs_ret_802_11_rssi(struct lbs_private *priv,
-                               struct cmd_ds_command *resp)
-{
-       struct cmd_ds_802_11_rssi_rsp *rssirsp = &resp->params.rssirsp;
-
-       lbs_deb_enter(LBS_DEB_CMD);
-
-       /* store the non average value */
-       priv->SNR[TYPE_BEACON][TYPE_NOAVG] = le16_to_cpu(rssirsp->SNR);
-       priv->NF[TYPE_BEACON][TYPE_NOAVG] = le16_to_cpu(rssirsp->noisefloor);
-
-       priv->SNR[TYPE_BEACON][TYPE_AVG] = le16_to_cpu(rssirsp->avgSNR);
-       priv->NF[TYPE_BEACON][TYPE_AVG] = le16_to_cpu(rssirsp->avgnoisefloor);
-
-       priv->RSSI[TYPE_BEACON][TYPE_NOAVG] =
-           CAL_RSSI(priv->SNR[TYPE_BEACON][TYPE_NOAVG],
-                    priv->NF[TYPE_BEACON][TYPE_NOAVG]);
-
-       priv->RSSI[TYPE_BEACON][TYPE_AVG] =
-           CAL_RSSI(priv->SNR[TYPE_BEACON][TYPE_AVG] / AVG_SCALE,
-                    priv->NF[TYPE_BEACON][TYPE_AVG] / AVG_SCALE);
-
-       lbs_deb_cmd("RSSI: beacon %d, avg %d\n",
-              priv->RSSI[TYPE_BEACON][TYPE_NOAVG],
-              priv->RSSI[TYPE_BEACON][TYPE_AVG]);
-
-       lbs_deb_leave(LBS_DEB_CMD);
-       return 0;
-}
-
-static int lbs_ret_802_11_bcn_ctrl(struct lbs_private * priv,
-                                       struct cmd_ds_command *resp)
-{
-       struct cmd_ds_802_11_beacon_control *bcn_ctrl =
-           &resp->params.bcn_ctrl;
-
-       lbs_deb_enter(LBS_DEB_CMD);
-
-       if (bcn_ctrl->action == CMD_ACT_GET) {
-               priv->beacon_enable = (u8) le16_to_cpu(bcn_ctrl->beacon_enable);
-               priv->beacon_period = le16_to_cpu(bcn_ctrl->beacon_period);
-       }
-
-       lbs_deb_enter(LBS_DEB_CMD);
-       return 0;
-}
-
-static inline int handle_cmd_response(struct lbs_private *priv,
-                                     struct cmd_header *cmd_response)
-{
-       struct cmd_ds_command *resp = (struct cmd_ds_command *) cmd_response;
-       int ret = 0;
-       unsigned long flags;
-       uint16_t respcmd = le16_to_cpu(resp->command);
-
-       lbs_deb_enter(LBS_DEB_HOST);
-
-       switch (respcmd) {
-       case CMD_RET(CMD_MAC_REG_ACCESS):
-       case CMD_RET(CMD_BBP_REG_ACCESS):
-       case CMD_RET(CMD_RF_REG_ACCESS):
-               ret = lbs_ret_reg_access(priv, respcmd, resp);
-               break;
-
-       case CMD_RET_802_11_ASSOCIATE:
-       case CMD_RET(CMD_802_11_ASSOCIATE):
-       case CMD_RET(CMD_802_11_REASSOCIATE):
-               ret = lbs_ret_80211_associate(priv, resp);
-               break;
-
-       case CMD_RET(CMD_802_11_SNMP_MIB):
-               ret = lbs_ret_802_11_snmp_mib(priv, resp);
-               break;
-
-       case CMD_RET(CMD_802_11_SET_AFC):
-       case CMD_RET(CMD_802_11_GET_AFC):
-               spin_lock_irqsave(&priv->driver_lock, flags);
-               memmove((void *)priv->cur_cmd->callback_arg, &resp->params.afc,
-                       sizeof(struct cmd_ds_802_11_afc));
-               spin_unlock_irqrestore(&priv->driver_lock, flags);
-
-               break;
-
-       case CMD_RET(CMD_802_11_RESET):
-       case CMD_RET(CMD_802_11_AUTHENTICATE):
-       case CMD_RET(CMD_802_11_BEACON_STOP):
-               break;
-
-       case CMD_RET(CMD_802_11_RSSI):
-               ret = lbs_ret_802_11_rssi(priv, resp);
-               break;
-
-       case CMD_RET(CMD_802_11D_DOMAIN_INFO):
-               ret = lbs_ret_802_11d_domain_info(resp);
-               break;
-
-       case CMD_RET(CMD_802_11_TPC_CFG):
-               spin_lock_irqsave(&priv->driver_lock, flags);
-               memmove((void *)priv->cur_cmd->callback_arg, &resp->params.tpccfg,
-                       sizeof(struct cmd_ds_802_11_tpc_cfg));
-               spin_unlock_irqrestore(&priv->driver_lock, flags);
-               break;
-       case CMD_RET(CMD_802_11_LED_GPIO_CTRL):
-               spin_lock_irqsave(&priv->driver_lock, flags);
-               memmove((void *)priv->cur_cmd->callback_arg, &resp->params.ledgpio,
-                       sizeof(struct cmd_ds_802_11_led_ctrl));
-               spin_unlock_irqrestore(&priv->driver_lock, flags);
-               break;
-
-       case CMD_RET(CMD_GET_TSF):
-               spin_lock_irqsave(&priv->driver_lock, flags);
-               memcpy((void *)priv->cur_cmd->callback_arg,
-                      &resp->params.gettsf.tsfvalue, sizeof(u64));
-               spin_unlock_irqrestore(&priv->driver_lock, flags);
-               break;
-       case CMD_RET(CMD_BT_ACCESS):
-               spin_lock_irqsave(&priv->driver_lock, flags);
-               if (priv->cur_cmd->callback_arg)
-                       memcpy((void *)priv->cur_cmd->callback_arg,
-                              &resp->params.bt.addr1, 2 * ETH_ALEN);
-               spin_unlock_irqrestore(&priv->driver_lock, flags);
-               break;
-       case CMD_RET(CMD_FWT_ACCESS):
-               spin_lock_irqsave(&priv->driver_lock, flags);
-               if (priv->cur_cmd->callback_arg)
-                       memcpy((void *)priv->cur_cmd->callback_arg, &resp->params.fwt,
-                              sizeof(resp->params.fwt));
-               spin_unlock_irqrestore(&priv->driver_lock, flags);
-               break;
-       case CMD_RET(CMD_802_11_BEACON_CTRL):
-               ret = lbs_ret_802_11_bcn_ctrl(priv, resp);
-               break;
-
-       default:
-               lbs_pr_err("CMD_RESP: unknown cmd response 0x%04x\n",
-                          le16_to_cpu(resp->command));
-               break;
-       }
-       lbs_deb_leave(LBS_DEB_HOST);
-       return ret;
-}
-
 int lbs_process_command_response(struct lbs_private *priv, u8 *data, u32 len)
 {
        uint16_t respcmd, curcmd;
@@ -360,15 +87,18 @@ int lbs_process_command_response(struct lbs_private *priv, u8 *data, u32 len)
        lbs_deb_hex(LBS_DEB_CMD, "CMD_RESP", (void *) resp, len);
 
        if (resp->seqnum != priv->cur_cmd->cmdbuf->seqnum) {
-               lbs_pr_info("Received CMD_RESP with invalid sequence %d (expected %d)\n",
-                           le16_to_cpu(resp->seqnum), le16_to_cpu(priv->cur_cmd->cmdbuf->seqnum));
+               netdev_info(priv->dev,
+                           "Received CMD_RESP with invalid sequence %d (expected %d)\n",
+                           le16_to_cpu(resp->seqnum),
+                           le16_to_cpu(priv->cur_cmd->cmdbuf->seqnum));
                spin_unlock_irqrestore(&priv->driver_lock, flags);
                ret = -1;
                goto done;
        }
        if (respcmd != CMD_RET(curcmd) &&
            respcmd != CMD_RET_802_11_ASSOCIATE && curcmd != CMD_802_11_ASSOCIATE) {
-               lbs_pr_info("Invalid CMD_RESP %x to command %x!\n", respcmd, curcmd);
+               netdev_info(priv->dev, "Invalid CMD_RESP %x to command %x!\n",
+                           respcmd, curcmd);
                spin_unlock_irqrestore(&priv->driver_lock, flags);
                ret = -1;
                goto done;
@@ -377,7 +107,8 @@ int lbs_process_command_response(struct lbs_private *priv, u8 *data, u32 len)
        if (resp->result == cpu_to_le16(0x0004)) {
                /* 0x0004 means -EAGAIN. Drop the response, let it time out
                   and be resubmitted */
-               lbs_pr_info("Firmware returns DEFER to command %x. Will let it time out...\n",
+               netdev_info(priv->dev,
+                           "Firmware returns DEFER to command %x. Will let it time out...\n",
                            le16_to_cpu(resp->command));
                spin_unlock_irqrestore(&priv->driver_lock, flags);
                ret = -1;
@@ -387,14 +118,6 @@ int lbs_process_command_response(struct lbs_private *priv, u8 *data, u32 len)
        /* Now we got response from FW, cancel the command timer */
        del_timer(&priv->command_timer);
        priv->cmd_timed_out = 0;
-       if (priv->nr_retries) {
-               lbs_pr_info("Received result %x to command %x after %d retries\n",
-                           result, curcmd, priv->nr_retries);
-               priv->nr_retries = 0;
-       }
-
-       /* Store the response code to cur_cmd_retcode. */
-       priv->cur_cmd_retcode = result;
 
        if (respcmd == CMD_RET(CMD_802_11_PS_MODE)) {
                struct cmd_ds_802_11_ps_mode *psmode = (void *) &resp[1];
@@ -412,10 +135,10 @@ int lbs_process_command_response(struct lbs_private *priv, u8 *data, u32 len)
                         * ad-hoc mode. It takes place in
                         * lbs_execute_next_command().
                         */
-                       if (priv->mode == IW_MODE_ADHOC &&
-                           action == CMD_SUBCMD_ENTER_PS)
+                       if (priv->wdev->iftype == NL80211_IFTYPE_MONITOR &&
+                           action == PS_MODE_ACTION_ENTER_PS)
                                priv->psmode = LBS802_11POWERMODECAM;
-               } else if (action == CMD_SUBCMD_ENTER_PS) {
+               } else if (action == PS_MODE_ACTION_ENTER_PS) {
                        priv->needtowakeup = 0;
                        priv->psstate = PS_STATE_AWAKE;
 
@@ -430,11 +153,12 @@ int lbs_process_command_response(struct lbs_private *priv, u8 *data, u32 len)
 
                                spin_unlock_irqrestore(&priv->driver_lock, flags);
                                mutex_unlock(&priv->lock);
-                               lbs_ps_wakeup(priv, 0);
+                               lbs_set_ps_mode(priv, PS_MODE_ACTION_EXIT_PS,
+                                               false);
                                mutex_lock(&priv->lock);
                                spin_lock_irqsave(&priv->driver_lock, flags);
                        }
-               } else if (action == CMD_SUBCMD_EXIT_PS) {
+               } else if (action == PS_MODE_ACTION_EXIT_PS) {
                        priv->needtowakeup = 0;
                        priv->psstate = PS_STATE_FULL_POWER;
                        lbs_deb_host("CMD_RESP: EXIT_PS command response\n");
@@ -475,8 +199,7 @@ int lbs_process_command_response(struct lbs_private *priv, u8 *data, u32 len)
        if (priv->cur_cmd && priv->cur_cmd->callback) {
                ret = priv->cur_cmd->callback(priv, priv->cur_cmd->callback_arg,
                                resp);
-       } else
-               ret = handle_cmd_response(priv, resp);
+       }
 
        spin_lock_irqsave(&priv->driver_lock, flags);
 
@@ -492,32 +215,10 @@ done:
        return ret;
 }
 
-static int lbs_send_confirmwake(struct lbs_private *priv)
-{
-       struct cmd_header cmd;
-       int ret = 0;
-
-       lbs_deb_enter(LBS_DEB_HOST);
-
-       cmd.command = cpu_to_le16(CMD_802_11_WAKEUP_CONFIRM);
-       cmd.size = cpu_to_le16(sizeof(cmd));
-       cmd.seqnum = cpu_to_le16(++priv->seqnum);
-       cmd.result = 0;
-
-       lbs_deb_hex(LBS_DEB_HOST, "wake confirm", (u8 *) &cmd,
-               sizeof(cmd));
-
-       ret = priv->hw_host_to_card(priv, MVMS_CMD, (u8 *) &cmd, sizeof(cmd));
-       if (ret)
-               lbs_pr_alert("SEND_WAKEC_CMD: Host to Card failed for Confirm Wake\n");
-
-       lbs_deb_leave_args(LBS_DEB_HOST, "ret %d", ret);
-       return ret;
-}
-
 int lbs_process_event(struct lbs_private *priv, u32 event)
 {
        int ret = 0;
+       struct cmd_header cmd;
 
        lbs_deb_enter(LBS_DEB_CMD);
 
@@ -558,7 +259,22 @@ int lbs_process_event(struct lbs_private *priv, u32 event)
 
        case MACREG_INT_CODE_HOST_AWAKE:
                lbs_deb_cmd("EVENT: host awake\n");
-               lbs_send_confirmwake(priv);
+               if (priv->reset_deep_sleep_wakeup)
+                       priv->reset_deep_sleep_wakeup(priv);
+               priv->is_deep_sleep = 0;
+               lbs_cmd_async(priv, CMD_802_11_WAKEUP_CONFIRM, &cmd,
+                               sizeof(cmd));
+               priv->is_host_sleep_activated = 0;
+               wake_up_interruptible(&priv->host_sleep_q);
+               break;
+
+       case MACREG_INT_CODE_DEEP_SLEEP_AWAKE:
+               if (priv->reset_deep_sleep_wakeup)
+                       priv->reset_deep_sleep_wakeup(priv);
+               lbs_deb_cmd("EVENT: ds awake\n");
+               priv->is_deep_sleep = 0;
+               priv->wakeup_dev_required = 0;
+               wake_up_interruptible(&priv->ds_awake_q);
                break;
 
        case MACREG_INT_CODE_PS_AWAKE:
@@ -580,18 +296,18 @@ int lbs_process_event(struct lbs_private *priv, u32 event)
                         * in lbs_ps_wakeup()
                         */
                        lbs_deb_cmd("waking up ...\n");
-                       lbs_ps_wakeup(priv, 0);
+                       lbs_set_ps_mode(priv, PS_MODE_ACTION_EXIT_PS, false);
                }
                break;
 
        case MACREG_INT_CODE_MIC_ERR_UNICAST:
                lbs_deb_cmd("EVENT: UNICAST MIC ERROR\n");
-               handle_mic_failureevent(priv, MACREG_INT_CODE_MIC_ERR_UNICAST);
+               lbs_send_mic_failureevent(priv, event);
                break;
 
        case MACREG_INT_CODE_MIC_ERR_MULTICAST:
                lbs_deb_cmd("EVENT: MULTICAST MIC ERROR\n");
-               handle_mic_failureevent(priv, MACREG_INT_CODE_MIC_ERR_MULTICAST);
+               lbs_send_mic_failureevent(priv, event);
                break;
 
        case MACREG_INT_CODE_MIB_CHANGED:
@@ -604,40 +320,28 @@ int lbs_process_event(struct lbs_private *priv, u32 event)
                lbs_deb_cmd("EVENT: ADHOC beacon lost\n");
                break;
        case MACREG_INT_CODE_RSSI_LOW:
-               lbs_pr_alert("EVENT: rssi low\n");
+               netdev_alert(priv->dev, "EVENT: rssi low\n");
                break;
        case MACREG_INT_CODE_SNR_LOW:
-               lbs_pr_alert("EVENT: snr low\n");
+               netdev_alert(priv->dev, "EVENT: snr low\n");
                break;
        case MACREG_INT_CODE_MAX_FAIL:
-               lbs_pr_alert("EVENT: max fail\n");
+               netdev_alert(priv->dev, "EVENT: max fail\n");
                break;
        case MACREG_INT_CODE_RSSI_HIGH:
-               lbs_pr_alert("EVENT: rssi high\n");
+               netdev_alert(priv->dev, "EVENT: rssi high\n");
                break;
        case MACREG_INT_CODE_SNR_HIGH:
-               lbs_pr_alert("EVENT: snr high\n");
+               netdev_alert(priv->dev, "EVENT: snr high\n");
                break;
 
        case MACREG_INT_CODE_MESH_AUTO_STARTED:
-               /* Ignore spurious autostart events if autostart is disabled */
-               if (!priv->mesh_autostart_enabled) {
-                       lbs_pr_info("EVENT: MESH_AUTO_STARTED (ignoring)\n");
-                       break;
-               }
-               lbs_pr_info("EVENT: MESH_AUTO_STARTED\n");
-               priv->mesh_connect_status = LBS_CONNECTED;
-               if (priv->mesh_open) {
-                       netif_carrier_on(priv->mesh_dev);
-                       if (!priv->tx_pending_len)
-                               netif_wake_queue(priv->mesh_dev);
-               }
-               priv->mode = IW_MODE_ADHOC;
-               schedule_work(&priv->sync_channel);
+               /* Ignore spurious autostart events */
+               netdev_info(priv->dev, "EVENT: MESH_AUTO_STARTED (ignoring)\n");
                break;
 
        default:
-               lbs_pr_alert("EVENT: unknown event id %d\n", event);
+               netdev_alert(priv->dev, "EVENT: unknown event id %d\n", event);
                break;
        }