net: remove interrupt.h inclusion from netdevice.h
[linux-3.10.git] / drivers / net / wireless / libertas / cmdresp.c
index ef63c37..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 "join.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,574 +47,17 @@ 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_deb_leave(LBS_DEB_CMD);
-}
-
-/**
- *  @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_sleep_params(struct lbs_private *priv,
-                                       struct cmd_ds_command *resp)
-{
-       struct cmd_ds_802_11_sleep_params *sp = &resp->params.sleep_params;
-
-       lbs_deb_enter(LBS_DEB_CMD);
-
-       lbs_deb_cmd("error 0x%x, offset 0x%x, stabletime 0x%x, calcontrol 0x%x "
-                   "extsleepclk 0x%x\n", le16_to_cpu(sp->error),
-                   le16_to_cpu(sp->offset), le16_to_cpu(sp->stabletime),
-                   sp->calcontrol, sp->externalsleepclk);
-
-       priv->sp.sp_error = le16_to_cpu(sp->error);
-       priv->sp.sp_offset = le16_to_cpu(sp->offset);
-       priv->sp.sp_stabletime = le16_to_cpu(sp->stabletime);
-       priv->sp.sp_calcontrol = sp->calcontrol;
-       priv->sp.sp_extsleepclk = sp->externalsleepclk;
-       priv->sp.sp_reserved = le16_to_cpu(sp->reserved);
-
-       lbs_deb_enter(LBS_DEB_CMD);
-       return 0;
-}
-
-static int lbs_ret_802_11_stat(struct lbs_private *priv,
-                               struct cmd_ds_command *resp)
-{
-       lbs_deb_enter(LBS_DEB_CMD);
-/*     currently priv->wlan802_11Stat is unused
-
-       struct cmd_ds_802_11_get_stat *p11Stat = &resp->params.gstat;
-
-       // TODO Convert it to Big endian befor copy
-       memcpy(&priv->wlan802_11Stat,
-              p11Stat, sizeof(struct cmd_ds_802_11_get_stat));
-*/
-       lbs_deb_leave(LBS_DEB_CMD);
-       return 0;
-}
-
-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_set_ps_mode(priv, PS_MODE_ACTION_EXIT_PS, false);
        }
-
-       lbs_deb_enter(LBS_DEB_CMD);
-       return 0;
+       lbs_deb_leave(LBS_DEB_ASSOC);
 }
 
-static int lbs_ret_802_11_key_material(struct lbs_private *priv,
-                                       struct cmd_ds_command *resp)
-{
-       struct cmd_ds_802_11_key_material *pkeymaterial =
-           &resp->params.keymaterial;
-       u16 action = le16_to_cpu(pkeymaterial->action);
-
-       lbs_deb_enter(LBS_DEB_CMD);
-
-       /* Copy the returned key to driver private data */
-       if (action == CMD_ACT_GET) {
-               u8 * buf_ptr = (u8 *) &pkeymaterial->keyParamSet;
-               u8 * resp_end = (u8 *) (resp + le16_to_cpu(resp->size));
-
-               while (buf_ptr < resp_end) {
-                       struct MrvlIEtype_keyParamSet * pkeyparamset =
-                           (struct MrvlIEtype_keyParamSet *) buf_ptr;
-                       struct enc_key * pkey;
-                       u16 param_set_len = le16_to_cpu(pkeyparamset->length);
-                       u16 key_len = le16_to_cpu(pkeyparamset->keylen);
-                       u16 key_flags = le16_to_cpu(pkeyparamset->keyinfo);
-                       u16 key_type = le16_to_cpu(pkeyparamset->keytypeid);
-                       u8 * end;
-
-                       end = (u8 *) pkeyparamset + sizeof (pkeyparamset->type)
-                                                 + sizeof (pkeyparamset->length)
-                                                 + param_set_len;
-                       /* Make sure we don't access past the end of the IEs */
-                       if (end > resp_end)
-                               break;
-
-                       if (key_flags & KEY_INFO_WPA_UNICAST)
-                               pkey = &priv->wpa_unicast_key;
-                       else if (key_flags & KEY_INFO_WPA_MCAST)
-                               pkey = &priv->wpa_mcast_key;
-                       else
-                               break;
-
-                       /* Copy returned key into driver */
-                       memset(pkey, 0, sizeof(struct enc_key));
-                       if (key_len > sizeof(pkey->key))
-                               break;
-                       pkey->type = key_type;
-                       pkey->flags = key_flags;
-                       pkey->len = key_len;
-                       memcpy(pkey->key, pkeyparamset->key, pkey->len);
-
-                       buf_ptr = end + 1;
-               }
-       }
-
-       lbs_deb_enter(LBS_DEB_CMD);
-       return 0;
-}
-
-static int lbs_ret_802_11_mac_address(struct lbs_private *priv,
-                                      struct cmd_ds_command *resp)
-{
-       struct cmd_ds_802_11_mac_address *macadd = &resp->params.macadd;
-
-       lbs_deb_enter(LBS_DEB_CMD);
-
-       memcpy(priv->current_addr, macadd->macadd, ETH_ALEN);
-
-       lbs_deb_enter(LBS_DEB_CMD);
-       return 0;
-}
-
-static int lbs_ret_802_11_rf_tx_power(struct lbs_private *priv,
-                                      struct cmd_ds_command *resp)
-{
-       struct cmd_ds_802_11_rf_tx_power *rtp = &resp->params.txp;
-
-       lbs_deb_enter(LBS_DEB_CMD);
-
-       priv->txpowerlevel = le16_to_cpu(rtp->currentlevel);
-
-       lbs_deb_cmd("TX power currently %d\n", priv->txpowerlevel);
-
-       lbs_deb_leave(LBS_DEB_CMD);
-       return 0;
-}
-
-static int lbs_ret_802_11_rate_adapt_rateset(struct lbs_private *priv,
-                                             struct cmd_ds_command *resp)
-{
-       struct cmd_ds_802_11_rate_adapt_rateset *rates = &resp->params.rateset;
-
-       lbs_deb_enter(LBS_DEB_CMD);
-
-       if (rates->action == CMD_ACT_GET) {
-               priv->enablehwauto = le16_to_cpu(rates->enablehwauto);
-               priv->ratebitmap = le16_to_cpu(rates->bitmap);
-       }
-
-       lbs_deb_leave(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_eeprom_access(struct lbs_private *priv,
-                                 struct cmd_ds_command *resp)
-{
-       struct lbs_ioctl_regrdwr *pbuf;
-       pbuf = (struct lbs_ioctl_regrdwr *) priv->prdeeprom;
-
-       lbs_deb_enter_args(LBS_DEB_CMD, "len %d",
-              le16_to_cpu(resp->params.rdeeprom.bytecount));
-       if (pbuf->NOB < le16_to_cpu(resp->params.rdeeprom.bytecount)) {
-               pbuf->NOB = 0;
-               lbs_deb_cmd("EEPROM read length too big\n");
-               return -1;
-       }
-       pbuf->NOB = le16_to_cpu(resp->params.rdeeprom.bytecount);
-       if (pbuf->NOB > 0) {
-
-               memcpy(&pbuf->value, (u8 *) & resp->params.rdeeprom.value,
-                      le16_to_cpu(resp->params.rdeeprom.bytecount));
-               lbs_deb_hex(LBS_DEB_CMD, "EEPROM", (char *)&pbuf->value,
-                       le16_to_cpu(resp->params.rdeeprom.bytecount));
-       }
-       lbs_deb_leave(LBS_DEB_CMD);
-       return 0;
-}
-
-static int lbs_ret_get_log(struct lbs_private *priv,
-                           struct cmd_ds_command *resp)
-{
-       struct cmd_ds_802_11_get_log *logmessage = &resp->params.glog;
-
-       lbs_deb_enter(LBS_DEB_CMD);
-
-       /* Stored little-endian */
-       memcpy(&priv->logmsg, logmessage, sizeof(struct cmd_ds_802_11_get_log));
-
-       lbs_deb_leave(LBS_DEB_CMD);
-       return 0;
-}
-
-static int lbs_ret_802_11_enable_rsn(struct lbs_private *priv,
-                                          struct cmd_ds_command *resp)
-{
-       struct cmd_ds_802_11_enable_rsn *enable_rsn = &resp->params.enbrsn;
-       uint32_t * pdata_buf = (uint32_t *)priv->cur_cmd->callback_arg;
-
-       lbs_deb_enter(LBS_DEB_CMD);
-
-       if (enable_rsn->action == cpu_to_le16(CMD_ACT_GET)) {
-               if (pdata_buf)
-                       *pdata_buf = (uint32_t) le16_to_cpu(enable_rsn->enable);
-       }
-
-       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 int lbs_ret_802_11_subscribe_event(struct lbs_private *priv,
-       struct cmd_ds_command *resp)
-{
-       struct cmd_ds_802_11_subscribe_event *cmd_event =
-               &resp->params.subscribe_event;
-       struct cmd_ds_802_11_subscribe_event *dst_event =
-               (void *)priv->cur_cmd->callback_arg;
-
-       lbs_deb_enter(LBS_DEB_CMD);
-
-       if (dst_event->action == cpu_to_le16(CMD_ACT_GET)) {
-               dst_event->events = cmd_event->events;
-               memcpy(dst_event->tlv, cmd_event->tlv, sizeof(dst_event->tlv));
-       }
-
-       lbs_deb_leave(LBS_DEB_CMD);
-       return 0;
-}
-
-static inline int handle_cmd_response(struct lbs_private *priv,
-                                     unsigned long dummy,
-                                     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(CMD_802_11_SCAN):
-               ret = lbs_ret_80211_scan(priv, resp);
-               break;
-
-       case CMD_RET(CMD_802_11_GET_LOG):
-               ret = lbs_ret_get_log(priv, 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_DISASSOCIATE):
-       case CMD_RET(CMD_802_11_DEAUTHENTICATE):
-               ret = lbs_ret_80211_disassociate(priv, resp);
-               break;
-
-       case CMD_RET(CMD_802_11_AD_HOC_START):
-       case CMD_RET(CMD_802_11_AD_HOC_JOIN):
-               ret = lbs_ret_80211_ad_hoc_start(priv, resp);
-               break;
-
-       case CMD_RET(CMD_802_11_GET_STAT):
-               ret = lbs_ret_802_11_stat(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_RF_TX_POWER):
-               ret = lbs_ret_802_11_rf_tx_power(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_MAC_MULTICAST_ADR):
-       case CMD_RET(CMD_MAC_CONTROL):
-       case CMD_RET(CMD_802_11_SET_WEP):
-       case CMD_RET(CMD_802_11_RESET):
-       case CMD_RET(CMD_802_11_AUTHENTICATE):
-       case CMD_RET(CMD_802_11_RADIO_CONTROL):
-       case CMD_RET(CMD_802_11_BEACON_STOP):
-               break;
-
-       case CMD_RET(CMD_802_11_ENABLE_RSN):
-               ret = lbs_ret_802_11_enable_rsn(priv, resp);
-               break;
-
-       case CMD_RET(CMD_802_11_RATE_ADAPT_RATESET):
-               ret = lbs_ret_802_11_rate_adapt_rateset(priv, resp);
-               break;
-
-       case CMD_RET(CMD_802_11_RSSI):
-               ret = lbs_ret_802_11_rssi(priv, resp);
-               break;
-
-       case CMD_RET(CMD_802_11_MAC_ADDRESS):
-               ret = lbs_ret_802_11_mac_address(priv, resp);
-               break;
-
-       case CMD_RET(CMD_802_11_AD_HOC_STOP):
-               ret = lbs_ret_80211_ad_hoc_stop(priv, resp);
-               break;
-
-       case CMD_RET(CMD_802_11_KEY_MATERIAL):
-               ret = lbs_ret_802_11_key_material(priv, resp);
-               break;
-
-       case CMD_RET(CMD_802_11_EEPROM_ACCESS):
-               ret = lbs_ret_802_11_eeprom_access(priv, resp);
-               break;
-
-       case CMD_RET(CMD_802_11D_DOMAIN_INFO):
-               ret = lbs_ret_802_11d_domain_info(priv, resp);
-               break;
-
-       case CMD_RET(CMD_802_11_SLEEP_PARAMS):
-               ret = lbs_ret_802_11_sleep_params(priv, resp);
-               break;
-       case CMD_RET(CMD_802_11_INACTIVITY_TIMEOUT):
-               spin_lock_irqsave(&priv->driver_lock, flags);
-               *((uint16_t *) priv->cur_cmd->callback_arg) =
-                   le16_to_cpu(resp->params.inactivity_timeout.timeout);
-               spin_unlock_irqrestore(&priv->driver_lock, flags);
-               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_802_11_SUBSCRIBE_EVENT):
-               ret = lbs_ret_802_11_subscribe_event(priv, resp);
-               break;
-
-       case CMD_RET(CMD_802_11_PWR_CFG):
-               spin_lock_irqsave(&priv->driver_lock, flags);
-               memmove((void *)priv->cur_cmd->callback_arg, &resp->params.pwrcfg,
-                       sizeof(struct cmd_ds_802_11_pwr_cfg));
-               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_deb_host("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_rx_command(struct lbs_private *priv)
+int lbs_process_command_response(struct lbs_private *priv, u8 *data, u32 len)
 {
        uint16_t respcmd, curcmd;
        struct cmd_header *resp;
@@ -639,27 +77,39 @@ int lbs_process_rx_command(struct lbs_private *priv)
                goto done;
        }
 
+       resp = (void *)data;
        curcmd = le16_to_cpu(priv->cur_cmd->cmdbuf->command);
-
-       resp = priv->cur_cmd->cmdbuf;
-
        respcmd = le16_to_cpu(resp->command);
        result = le16_to_cpu(resp->result);
 
-       lbs_deb_host("CMD_RESP: response 0x%04x, seq %d, size %d, jiffies %lu\n",
-                    respcmd, le16_to_cpu(resp->seqnum), priv->upld_len, jiffies);
-       lbs_deb_hex(LBS_DEB_HOST, "CMD_RESP", (void *) resp, priv->upld_len);
+       lbs_deb_cmd("CMD_RESP: response 0x%04x, seq %d, size %d\n",
+                    respcmd, le16_to_cpu(resp->seqnum), 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_802_11_ASSOCIATE && curcmd != CMD_RET_802_11_ASSOCIATE) {
-               lbs_pr_info("Invalid CMD_RESP %x to command %x!\n", respcmd, curcmd);
+           respcmd != CMD_RET_802_11_ASSOCIATE && curcmd != CMD_802_11_ASSOCIATE) {
+               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;
+       }
+
+       if (resp->result == cpu_to_le16(0x0004)) {
+               /* 0x0004 means -EAGAIN. Drop the response, let it time out
+                  and be resubmitted */
+               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;
                goto done;
@@ -668,17 +118,9 @@ int lbs_process_rx_command(struct lbs_private *priv)
        /* 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;
+               struct cmd_ds_802_11_ps_mode *psmode = (void *) &resp[1];
                u16 action = le16_to_cpu(psmode->action);
 
                lbs_deb_host(
@@ -693,10 +135,10 @@ int lbs_process_rx_command(struct lbs_private *priv)
                         * 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;
 
@@ -711,11 +153,12 @@ int lbs_process_rx_command(struct lbs_private *priv)
 
                                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");
@@ -756,8 +199,7 @@ int lbs_process_rx_command(struct lbs_private *priv)
        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, 0, resp);
+       }
 
        spin_lock_irqsave(&priv->driver_lock, flags);
 
@@ -773,22 +215,16 @@ done:
        return ret;
 }
 
-int lbs_process_event(struct lbs_private *priv)
+int lbs_process_event(struct lbs_private *priv, u32 event)
 {
        int ret = 0;
-       u32 eventcause;
+       struct cmd_header cmd;
 
        lbs_deb_enter(LBS_DEB_CMD);
 
-       spin_lock_irq(&priv->driver_lock);
-       eventcause = priv->eventcause >> SBI_EVENT_CAUSE_SHIFT;
-       spin_unlock_irq(&priv->driver_lock);
-
-       lbs_deb_cmd("event cause %d\n", eventcause);
-
-       switch (eventcause) {
+       switch (event) {
        case MACREG_INT_CODE_LINK_SENSED:
-               lbs_deb_cmd("EVENT: MACREG_INT_CODE_LINK_SENSED\n");
+               lbs_deb_cmd("EVENT: link sensed\n");
                break;
 
        case MACREG_INT_CODE_DEAUTHENTICATED:
@@ -807,7 +243,7 @@ int lbs_process_event(struct lbs_private *priv)
                break;
 
        case MACREG_INT_CODE_PS_SLEEP:
-               lbs_deb_cmd("EVENT: sleep\n");
+               lbs_deb_cmd("EVENT: ps sleep\n");
 
                /* handle unexpected PS SLEEP event */
                if (priv->psstate == PS_STATE_FULL_POWER) {
@@ -817,13 +253,32 @@ int lbs_process_event(struct lbs_private *priv)
                }
                priv->psstate = PS_STATE_PRE_SLEEP;
 
-               lbs_ps_confirm_sleep(priv, (u16) priv->psmode);
+               lbs_ps_confirm_sleep(priv);
 
                break;
 
-       case MACREG_INT_CODE_PS_AWAKE:
-               lbs_deb_cmd("EVENT: awake\n");
+       case MACREG_INT_CODE_HOST_AWAKE:
+               lbs_deb_cmd("EVENT: host awake\n");
+               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:
+               lbs_deb_cmd("EVENT: ps awake\n");
                /* handle unexpected PS AWAKE event */
                if (priv->psstate == PS_STATE_FULL_POWER) {
                        lbs_deb_cmd(
@@ -841,69 +296,55 @@ int lbs_process_event(struct lbs_private *priv)
                         * 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:
+               lbs_deb_cmd("EVENT: MIB CHANGED\n");
+               break;
        case MACREG_INT_CODE_INIT_DONE:
+               lbs_deb_cmd("EVENT: INIT DONE\n");
                break;
-
        case MACREG_INT_CODE_ADHOC_BCN_LOST:
                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", eventcause);
+               netdev_alert(priv->dev, "EVENT: unknown event id %d\n", event);
                break;
        }
 
-       spin_lock_irq(&priv->driver_lock);
-       priv->eventcause = 0;
-       spin_unlock_irq(&priv->driver_lock);
-
        lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
        return ret;
 }